holocron/plugins/git/.apm/skills/git-history/SKILL.md

name, description, metadata, allowed-tools

name	description	metadata	allowed-tools
git-history	Inspect git history: query logs with pickaxe, line-range, or custom formats; find bug origins via bisect; locate problematic commits for cherry-picking or reverting. Use when investigating history, tracing when a change happened, or finding the commit that broke something. Return structured results for downstream agents. Do not use for authoring or formatting commit messages, or executing rebase/squash/fixup operations — use git-commits for that.	category source_keys git git-scm-bisect-docs git-scm-log-docs git-scm-diff-docs	Bash

Gotchas

• Pickaxe searches (-S vs -G): -S"string" finds commits where string count changed; -G"regex" finds any line matching regex in diffs. They're not equivalent: a line replaced (one removal + one addition) matches -G but not -S if count is unchanged.
• --follow only works for single files: it traces renames but fails with multiple paths or directory globs. Use git log -- <single-file> or query without --follow.
• Bisect with skips: if bisect cannot pinpoint a commit because the culprit is adjacent to skipped commits, it reports "cannot find exact culprit" and lists candidates. This is not a failure — it's as precise as the skip range allows.
• Interactive rebase is non-recoverable on mistake: there's no undo once rebase -i starts. Suggest git reflog to recover if the user realizes mid-way they selected the wrong commits.
• -L (line-range history) requires exact line numbers or regex patterns: off-by-one errors omit the target range. Test the range with git log -L before offering it to users.

Query Logs and Locate Commits

Default to git log --oneline for quick inspection. For deeper queries:

• Find when a string appeared or disappeared: Use git log -S"string" (count-sensitive, finds adds/removes). If you need any mention of the string in diffs, use git log -G"regex" instead. Add --pickaxe-regex to treat the -S string as a POSIX ERE, and --pickaxe-all to show every changed file in a matching changeset, not just the matching ones. Binary files are searched by -S; -G ignores them unless --text is also supplied.
• Trace changes to a specific line or function: Use git log -L <start>,<end>:<file> or git log -L :<function>:<file> (requires function name heuristic). This shows the evolution of that range across all commits.
• Filter by change type: Use git log --diff-filter=<type> (A=added, M=modified, D=deleted, R=renamed) to narrow to specific file operations.
• Mainline-only history through merges: Use --first-parent to follow only the integration branch and skip merged-in side-branch commits; combine with --merges/--no-merges or --ancestry-path/--min-parents/--max-parents for other ancestry-graph filtering — see references/git-log-format.md for the full set.
• Custom format for structured output: Construct format string with %h (hash), %s (subject), %an (author), %ar (relative date), %b (body). Example: git log --format="%h | %s | %an (%ar)".
• File-specific history with renames: Use git log --follow -- <file> (single file only). Without --follow, log stops at the rename boundary.

Bisect to Find Blame Commit

Use bisect when hunting for the commit that introduced a bug or behaviour change. Binary search reduces iterations from O(N) to O(log N).

Basic manual flow:

git bisect start
git bisect bad [HEAD]        # mark current (or specified) as broken
git bisect good <commit>     # mark known-good baseline
# Git checks out midpoint; test it manually
git bisect good              # if test passes
git bisect bad               # if test fails
# Repeat until git reports "X is the first bad commit"
git bisect reset             # return to original HEAD

Automated with git bisect run: if a test command exists, use git bisect run <cmd>. Git interprets the exit code: 0=good, 1-124=bad, 125=skip (build broken), 126-127=POSIX shell errors treated as bad, 128+=aborts the bisect session entirely (not treated as bad — a crashed test script can silently end the search).

With skip: if a commit is untestable (broken build), use git bisect skip to exclude it without manually deciding good/bad. If the first-bad is adjacent to skips, bisect reports it cannot pinpoint but lists candidates.

Undoing a wrong good/bad call: git bisect log prints the session's decision history; save it (git bisect log > bisect.log), edit out the mistaken entry, then git bisect reset && git bisect replay bisect.log to resume from the corrected log instead of restarting the whole search.

Narrowing and speeding up the search: git bisect start HEAD v1.2 -- src/ limits bisection to a path, cutting the number of trials. --no-checkout updates the BISECT_HEAD ref instead of checking out a working tree (useful for tests that don't need one; automatic in bare repos). --first-parent follows only first parents at merges, finding the integration commit that introduced a regression while ignoring broken side branches.

Inspecting remaining candidates visually: git bisect visualize (alias view) opens the suspects in gitk; add --stat or -p to show diffstat or full patches instead. Falls back to git log when no graphical display is detected.

For non-regression hunts: use git bisect start --term-new <new> --term-old <old> to search for a property change instead of a bug (e.g., performance regression). Then use the custom terms instead of good/bad.

For rebase execution (interactive rebase, squash/fixup/reword, conflict handling) see git-commits — it owns history-rewriting operations. This skill only locates commits and reports on history; it does not execute rebases.

Find and Manipulate Problematic Commits

Once a commit is identified (via log query or bisect), offer cherry-pick or revert. This section is general git knowledge, not sourced from history-inspection.md — git-branches's SKILL.md explicitly delegates cherry-pick/revert here (see its Merging section), which is why this skill carries them rather than treating them as out of scope:

• Cherry-pick: git cherry-pick <commit> copies a commit's changes onto current HEAD. Use when backporting fixes to other branches.
• Revert: git revert <commit> creates a new commit that undoes the changes. Use when un-applying a merged commit without rewriting history.
• Blame for context: git blame <file> shows which commit last changed each line. Use to trace a specific line back to its introducing commit.

Inspect Diffs

Diff-output tuning is in scope too: --stat for a diffstat summary, --word-diff for word-level (not line-level) changes, and whitespace flags (-w, --ignore-blank-lines) to suppress noise from reformatting. See references/git-log-format.md for the full flag set.

Return Results Structured

For agent consumption, return:

• Commit SHA (full or abbreviated as appropriate)
• Subject line (from %s)
• Author and date (from %an and %ar)
• Action taken or recommended (e.g., "Found via bisect", "Offer cherry-pick to main", "Rebase conflicts detected")

Example for agent:

Found first bad commit: abc1234
Subject: fix null pointer in parser
Author: Alice (2 weeks ago)
Recommendation: Backport to release branch via cherry-pick

Reference

For the full log format placeholder catalogue, named format presets, --diff-filter letters, -L range syntax, ancestry filters, and git diff output-control flags, read references/git-log-format.md.