git-workflow-auditor

Audits git repository hygiene: worktree state, stale branches, uncommitted changes, orphaned worktrees, and hook configuration. Finds the rot before it causes a crisis.

Ir para a instalação

Repositório: curiositech/windags-skills
Última atividade na origem: 31 de março de 2026 às 04:41
Idioma detectado do SKILL.md: inglês
Estrelas: 10
Forks: 2

Opções de instalação

Por padrão, está selecionado o prompt que primeiro revisa a origem. Você pode mudar para um comando direto ou baixar uma cópia local.

Revise os arquivos de origem

Leia o SKILL.md e os arquivos complementares exibidos pelo SkillsMP antes de decidir se vai instalar.

Voltar à pesquisa Voltar à instalação

name	git-workflow-auditor
license	Apache-2.0
description	Audits git repository hygiene: worktree state, stale branches, uncommitted changes, orphaned worktrees, and hook configuration. Finds the rot before it causes a crisis.
category	Code Quality & Testing
tags	["git","audit","worktree","branch-hygiene","cleanup"]
allowed-tools	["Read","Bash(*)","Glob","Grep","Write","Edit"]
pairs-with	[{"skill":"git-workflow-expert","reason":"Auditing finds problems; git-workflow-expert fixes them with proper strategy"},{"skill":"monorepo-management","reason":"Monorepos accumulate worktree and branch debt faster than single-repo projects"},{"skill":"multi-agent-coordination","reason":"Multi-agent workflows create worktrees that must be tracked and cleaned up"},{"skill":"dag-isolation-manager","reason":"DAG execution creates worktrees for isolation that need lifecycle management"}]

Git Workflow Auditor

Systematic audit of git repository state. Detects stale branches, orphaned worktrees, uncommitted work at risk of loss, hook misconfigurations, and branch hygiene violations. Designed for repositories where multiple developers or agents create branches and worktrees that nobody remembers to clean up.

When to Use

Use for:

Periodic repository health checks (weekly or before releases)
Detecting stale worktrees left behind by crashed agent processes
Finding branches with unmerged work that someone forgot about
Auditing git hooks for completeness and correct configuration
Identifying uncommitted changes across multiple worktrees
Cleaning up after multi-agent DAG execution sessions
Pre-migration audits before moving to a new branching strategy
Diagnosing disk space issues caused by accumulated worktrees

Do NOT use for:

Choosing a branching strategy (use git-workflow-expert)
Setting up CI/CD pipelines (use github-actions-pipeline-builder)
Resolving merge conflicts (use git-workflow-expert)
Repository migration between hosting providers

Core Capabilities

1. Worktree State Audit

Worktrees are the primary isolation mechanism for parallel agent execution. They accumulate silently. A crashed agent leaves its worktree behind. Ten crashed agents later, you have ten stale worktrees consuming disk and creating confusion.

# List all worktrees with their state
git worktree list --porcelain

# Parse into structured audit
git worktree list --porcelain | awk '
  /^worktree / { path=$2 }
  /^HEAD / { head=$2 }
  /^branch / { branch=$2 }
  /^detached/ { branch="DETACHED" }
  /^$/ { printf "%-60s %-12s %s\n", path, (branch == "DETACHED" ? "DETACHED" : branch), head; path=""; head=""; branch="" }
'

Worktree classification:

State	Detection	Risk	Action
Active + clean	Has branch, no uncommitted changes	None	Leave alone
Active + dirty	Has branch, uncommitted changes	Data loss on cleanup	Commit or stash before removing

# Find orphaned worktrees (directory gone but git still references)
git worktree list --porcelain | grep "^worktree " | awk '{print $2}' | while read -r wt; do
  if [ ! -d "$wt" ]; then
    echo "ORPHANED: $wt (directory does not exist)"
  fi
done

# Find stale worktrees (no commits in 7+ days)
git worktree list --porcelain | grep "^worktree " | awk '{print $2}' | while read -r wt; do
  if [ -d "$wt" ]; then
    last_commit=$(git -C "$wt" log -1 --format="%ci" 2>/dev/null)
    if [ -n "$last_commit" ]; then
      days_old=$(( ($(date +%s) - $(date -jf "%Y-%m-%d %H:%M:%S %z" "$last_commit" +%s 2>/dev/null || date -d "$last_commit" +%s 2>/dev/null)) / 86400 ))
      if [ "$days_old" -gt 7 ]; then
        echo "STALE ($days_old days): $wt"
      fi
    fi
  fi
done

# Check for dirty worktrees (uncommitted changes)
git worktree list --porcelain | grep "^worktree " | awk '{print $2}' | while read -r wt; do
  if [ -d "$wt" ]; then
    status=$(git -C "$wt" status --porcelain 2>/dev/null)
    if [ -n "$status" ]; then
      file_count=$(echo "$status" | wc -l | tr -d ' ')
      echo "DIRTY ($file_count files): $wt"
    fi
  fi
done

# Branches merged into main that haven't been deleted
git branch --merged main | grep -v "^\*\|main\|master" | while read -r branch; do
  echo "MERGED (safe to delete): $branch"
done

# Branches NOT merged, sorted by last commit date
git for-each-ref --sort=-committerdate --format='%(refname:short) %(committerdate:relative) %(authorname)' refs/heads/ | \
  while read -r branch date author; do
    merged=$(git branch --merged main | grep -c "^\s*$branch$")
    if [ "$merged" -eq 0 ] && [ "$branch" != "main" ] && [ "$branch" != "master" ]; then
      echo "UNMERGED: $branch (last commit: $date by $author)"
    fi
  done

# Remote branches with no local tracking
git branch -r | grep -v HEAD | while read -r remote_branch; do
  local_branch="${remote_branch#origin/}"
  if ! git branch --list "$local_branch" | grep -q .; then
    # Check if it's stale
    last_date=$(git log -1 --format="%cr" "$remote_branch" 2>/dev/null)
    echo "REMOTE ONLY: $remote_branch (last commit: $last_date)"
  fi
done

# Branches with diverged upstream
git for-each-ref --format='%(refname:short) %(upstream:short) %(upstream:track)' refs/heads/ | \
  grep -v "^\s*$" | while read -r local upstream track; do
    if [[ "$track" == *"ahead"* ]] && [[ "$track" == *"behind"* ]]; then
      echo "DIVERGED: $local ($track)"
    elif [[ "$track" == *"gone"* ]]; then
      echo "UPSTREAM GONE: $local (remote branch deleted)"
    fi
  done

# Check main worktree
main_status=$(git status --porcelain)
if [ -n "$main_status" ]; then
  echo "MAIN WORKTREE has uncommitted changes:"
  echo "$main_status" | head -20
  staged=$(echo "$main_status" | grep "^[MADRCU]" | wc -l | tr -d ' ')
  unstaged=$(echo "$main_status" | grep "^.[MADRCU]" | wc -l | tr -d ' ')
  untracked=$(echo "$main_status" | grep "^??" | wc -l | tr -d ' ')
  echo "  Staged: $staged | Unstaged: $unstaged | Untracked: $untracked"
fi

# Check all worktrees
git worktree list --porcelain | grep "^worktree " | awk '{print $2}' | while read -r wt; do
  status=$(git -C "$wt" status --porcelain 2>/dev/null)
  if [ -n "$status" ]; then
    branch=$(git -C "$wt" branch --show-current 2>/dev/null || echo "DETACHED")
    echo ""
    echo "UNCOMMITTED in $wt (branch: $branch):"
    echo "$status" | head -10
    total=$(echo "$status" | wc -l | tr -d ' ')
    if [ "$total" -gt 10 ]; then
      echo "  ... and $((total - 10)) more files"
    fi
  fi
done

HOOKS_DIR=".git/hooks"
# Check for Husky (modern standard)
if [ -d ".husky" ]; then
  HOOKS_DIR=".husky"
  echo "Hook system: Husky"
elif [ -f ".lefthookrc" ] || [ -f "lefthook.yml" ]; then
  echo "Hook system: Lefthook"
else
  echo "Hook system: Native git hooks"
fi

# Expected hooks
EXPECTED_HOOKS=("pre-commit" "commit-msg" "pre-push")

for hook in "${EXPECTED_HOOKS[@]}"; do
  hook_file="$HOOKS_DIR/$hook"
  if [ -f "$hook_file" ]; then
    if [ -x "$hook_file" ]; then
      echo "OK: $hook (executable)"
    else
      echo "WARNING: $hook exists but is NOT executable"
    fi
  else
    echo "MISSING: $hook"
  fi
done

# Check if hooks are being bypassed
# Look for --no-verify in recent commits (sign of habitual skipping)
git log --oneline -50 | while read -r sha msg; do
  # Can't detect --no-verify from log, but can check for missing
  # conventional commit format if commit-msg hook should enforce it
  if ! echo "$msg" | grep -qE "^[a-f0-9]+ (feat|fix|docs|style|refactor|test|chore|build|ci|perf)"; then
    echo "UNCONVENTIONAL: $sha $msg"
  fi
done 2>/dev/null | head -10

# Repository size
repo_size=$(du -sh .git | awk '{print $1}')
echo "Repository (.git): $repo_size"

# Worktree sizes
git worktree list --porcelain | grep "^worktree " | awk '{print $2}' | while read -r wt; do
  if [ -d "$wt" ]; then
    wt_size=$(du -sh "$wt" 2>/dev/null | awk '{print $1}')
    echo "Worktree: $wt ($wt_size)"
  fi
done

# Largest objects in pack (potential LFS candidates)
git rev-list --objects --all | \
  git cat-file --batch-check='%(objecttype) %(objectname) %(objectsize) %(rest)' | \
  grep "^blob" | sort -t' ' -k3 -rn | head -10 | \
  while read -r type sha size path; do
    size_mb=$(echo "scale=1; $size / 1048576" | bc)
    echo "LARGE OBJECT: ${size_mb}MB - $path"
  done

# Check for large files that should be in LFS
find . -not -path './.git/*' -type f -size +10M 2>/dev/null | while read -r file; do
  echo "LARGE FILE (>10MB): $file ($(du -h "$file" | awk '{print $1}'))"
done

Condition	Auto-Clean OK?	Reasoning
Orphaned worktree (directory gone)	Yes	`git worktree prune` is safe; the directory is already gone
Merged branch, local only	Yes	Work is in main, branch is redundant
Merged branch, has remote	Ask first	Others may reference the remote branch
Stale branch, unmerged	Never auto-clean	May contain valuable unfinished work
Dirty worktree	Never auto-clean	Uncommitted changes would be lost
Locked worktree	Never auto-clean	Lock exists for a reason; investigate

Project Type	Frequency	Trigger
Solo developer	Monthly	Before release
Small team (2-5)	Bi-weekly	Sprint boundaries
Large team (5+)	Weekly	Automated in CI
Multi-agent execution	After every session	Agent cleanup hook
Monorepo	Weekly	Worktree count check