/git-context

name: "git-context"
description: "Search git history for context — commit messages, blame, related changes, impact analysis"
license: "MIT"
compatibility: "cline, claude, opencode, amp, codex, gemini, cursor, pi"
hint: "Use to understand why code was written a certain way or find related changes"
user-invocable: true

Git Context

When to Use

Use this skill when:

• Understanding why code was written a certain way
• Finding related changes across the codebase
• Tracing the evolution of a feature or pattern
• Identifying who has expertise in a module
• Finding past bug fixes or regressions in an area

What It Does

Searches git history to build context about the codebase, using a combination of native git commands and the `sem` MCP tool for deeper analysis. Helps answer "why was this done this way?" and "what changed recently in this area?"

How to Execute

Find Recent Changes to a Module

# Recent commits touching this area
git log --oneline --all -20 -- path/to/module/

# Who works on this area most
git shortlog -sn -- path/to/module/

# When a specific function was introduced
git log -S "functionName" --oneline -- path/to/module/

Trace a Function's History

# When was this function introduced?
git log -S "export function calculateTotal" --oneline

# Who has modified it?
git blame path/to/file.ts -L 10,30

# What was the commit message?
git show <commit-hash> --no-patch

Find Related Changes

# Files changed together in the same commits
git log --all --name-only -- path/to/changed/file.ts | head -20

# Find commits that reference a ticket or pattern
git log --all --grep="fix|bug|hotfix" --oneline -20

Using `sem` for Deeper Analysis

# Entity-level blame (function level)
sem blame path/to/file.ts --function processOrder

# Impact analysis
sem impact path/to/file.ts --function processOrder

# Compare branches at function level
sem diff main..HEAD -- path/to/file.ts

Cross-Session Context

# Search past agent sessions about this module
ctx search "this module" path/to/module/

# Find past discussions about related changes
ctx search "bug fix" path/to/module/

Decision Tree

┌────────────────────────────┬────────────────────────┐
│ Need this                   │ Use this               │
├────────────────────────────┼────────────────────────┤
│ What changed recently      │ git log -20 -- path/   │
│ Who works on this module   │ git shortlog -sn path/ │
│ Why was this line added    │ git blame path/to/file │
│ When was function added    │ git log -S "funcName"  │
│ What else changed together │ git log --name-only    │
│ Impact of changing X       │ sem impact path/func   │
│ Past agent work on this    │ ctx search "topic"     │
└────────────────────────────┴────────────────────────┘

Common Patterns

Pre-Implementation Check

Before implementing a change, check:

# 1. Recent changes to affected modules
git log --oneline --all -10 -- src/feature/

# 2. Who has expertise
git shortlog -sn -- src/feature/ | head -5

# 3. Related commits (ticket/branch references)
git log --all --grep="feature-name" --oneline

# 4. Past bugs in this area
git log --all --grep="bug|fix|error" --oneline -10 -- src/feature/

Post-Change Verification

After implementing, verify:

# 1. What did I change?
git diff --stat

# 2. Are there unrelated changes?
git diff --cached --name-only

# 3. Did I miss anything?
git diff HEAD --name-only  # Unstaged changes

Tips

• **Commit messages matter**: Write clear messages — they become the primary documentation
• **Use `git log -S` over `grep` for history**: `grep` scans the working tree; `git log -S` scans history
• **Combine with `ctx`**: Past agent sessions often contain context that git history doesn't
• **Be specific with paths**: `git log -- path/` filters to relevant commits, reducing noise
• **Use `--all` for complete picture**: Default `git log` only shows current branch history

Integration with Other Skills

• Use before `/blindspots` to gather initial context
• Use during `context-discovery` for deep git history analysis
• Log surprising git history findings in `implementation-logger`