Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Git History Archaeologist — Blame, Reverts & Commit Forensic

    1

    Investigate Git history using forensic blame analysis and evidence-based commit reconstruction to find and recover code.

    $5.99

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    Git History Archaeologist — Blame, Reverts & Commit Forensic

    Git History Archaeologist — Blame, Reverts & Commit Forensic

    Example session with this skill installed

    Find out when the validation logic in src/auth.ts was changed and why it started failing for OIDC tokens. Use blame and check for any recent reverts.

    • Read your context and instructions
    • Compiled the git history archaeologist

    I have analyzed the history of `src/auth.ts` focusing on the validation logic. I traced the changes through recent commits and identified a specific modification to the token handling. ## Forensic Investigation: src/auth.ts Validation | Commit | Date | Change Type | Evidence | Interpretation | | :--- | :--- | :--- | :--- | :--- | | `a1b2c3d` | 2023-10-12 | Modified | Added `checkIssuer()` call | **Confirmed:** Introduced stricter OIDC validation. | | `e5f6g7h` | 2023-10-15 | Revert | Reverted `a1b2c3d` | **Confirmed:** Revert message cites "OIDC breakages". | | `i9j0k1l` | 2023-10-16 | Modified | Re-implemented validation | **Likely:** Partial fix that still misses OIDC edge cases. | ### Blame and Diff Findings The `git blame -w -M` output shows that lines 45-52 were last touched in commit `i9j0k1l`. While the developer intended to fix the breakage caused by the previous revert, the diff shows that the `issuer_url` check now expects a trailing slash, which differs from the original implementation in `a1b2c3d`. ### Recovery Options If you need to restore the more permissive validation from before the breakage: 1. **Preview:** `git show a1b2c3d:src/auth.ts` 2. **Compare:** `git diff i9j0k1l a1b2c3d -- src/auth.ts` 3. **Restore:** `git restore --source=a1b2c3d -- src/auth.ts` (Ensure your working tree is clean first). **Next steps** - Run `git log -S'issuer_url' -- src/auth.ts` to see if this logic moved from another file. - Verify if the OIDC provider recently changed its metadata endpoint format. - Test the restored logic against the current failing OIDC tokens.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    Codebases often hide the "why" behind layers of refactors, reverts, and moved files. This skill acts as a forensic investigator for your Git history, using deep blame analysis and diff reconstruction to find exactly when and why a behavior was introduced. ## What it does - **Line-level authorship** uses advanced blame flags to track code even through refactors, moves, and whitespace changes. - **Regression tracing** identifies the specific commit where a bug appeared using log filtering and guided bisect workflows. - **Lost change recovery** locates deleted or reverted code by scanning full history and diff-filters for removed content. - **Narrative reconstruction** builds chronological timelines that explain the evolution of a file or feature. - **Branch forensics** analyzes tags and branches to determine exactly where a specific commit has been deployed or merged. ## How it works 1. **Scope definition** establishes the affected files, symbols, and approximate date ranges for the investigation. 2. **Read-only discovery** runs non-destructive commands like `git log` and `git blame` to gather raw evidence. 3. **Forensic analysis** inspects parent diffs and commit metadata to separate confirmed facts from developer intent. 4. **Recovery guidance** provides safe, non-destructive commands to preview or restore historical versions of code. ## Frameworks & tools This skill works with any standard Git repository. It utilizes core Git commands including `blame`, `bisect`, `show-ref`, `rev-parse`, and `log` with advanced filtering options. ## Why this beats prompting it yourself Standard LLMs often hallucinate commit history or suggest dangerous `reset --hard` commands. This skill follows a strict evidence-first workflow that cites specific hashes and mandates read-only inspection before suggesting any write operations. ## Use cases - Finding the original logic of a function that was deleted three months ago. - Determining if a regression was introduced by a specific PR or a side-effect merge. - Auditing who authored a specific block of code after multiple refactors moved the lines. - Recovering a complex conflict resolution that was accidentally reverted. ## Known limitations Cannot access remote-only history without a local fetch. Effectiveness is reduced in shallow clones or repositories with heavily squashed history where original context is lost.

    Requires a local Git repository. Cannot see history not present in the current clone. Blame accuracy may be limited in repositories with frequent large-scale automated refactors.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before any payment.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    Fresh listing

    Recently published to Agensi

    Money-back guarantee

    Doesn't do what its page promises? You get your money back.

    Trust & safety

    Security scan

    Security scan passed 18 days ago

    Requires

    Git

    Permissions

    Terminal / Shell
    Read Files
    Listed18 days ago

    What's inside

    Frequently Asked Questions

    This skill uses advanced flags like `-M` and `-C` to follow code blocks across file renames and moves, preventing the 'broken trail' common in standard git blame tools. It focuses on logical authorship rather than just identifying who last touched the file.

    The skill is designed for any AI agent with filesystem access and a standard Git CLI environment. It works out-of-the-box with any local repository, requiring no external APIs or proprietary database integrations.

    Yes, the skill includes a 'Lost Change Recovery' workflow that scans the entire commit history for specific strings or patterns, even if the file they were in has since been deleted. It can provide the exact diff needed to restore that specific logic.

    Absolutely. The Archaeologist follows a 'read-only' forensic protocol, meaning it primarily uses inspection commands to gather evidence and will only provide suggested commands for you to execute if you choose to restore code.

    The skill works best on full repositories; if you are using a shallow clone (like in some CI environments), it may not be able to trace back to the true origin of a line. We recommend running it on a full fetch for the most accurate forensic results.

    New in Testing & Debugging