@mesadev/agentblame 0.2.11 → 3.0.1

package/dist/capture.js

@@ -1,18 +1,15 @@
 #!/usr/bin/env bun
 "use strict";
 /**
- * Agent Blame Hook Capture
+ * Agent Blame Hook Capture v3
  *
- * Captures AI-generated code from Cursor and Claude Code hooks.
- * Performs line-level hashing for precise attribution matching.
+ * Captures AI-generated code from Cursor, Claude Code, and OpenCode hooks.
+ * Uses delta-based tracking for accurate line attribution.
  *
  * Usage:
  *   echo '{"payload": ...}' | bun run capture.ts --provider cursor --event afterFileEdit
  *   echo '{"payload": ...}' | bun run capture.ts --provider claude
- *
- * Note: We only track afterFileEdit (Composer/Agent mode).
- * Tab completions (afterTabFileEdit) are NOT tracked because they fire
- * as fragments that cannot be reliably matched to commits.
+ *   echo '{"payload": ...}' | bun run capture.ts --provider opencode
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -49,164 +46,59 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runCapture = runCapture;
-const crypto = __importStar(require("node:crypto"));
-const diff_1 = require("diff");
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
 const database_1 = require("./lib/database");
+const config_1 = require("./lib/config");
+const storage_1 = require("./lib/storage");
+const checkpoint_1 = require("./lib/checkpoint");
 const util_1 = require("./lib/util");
+const delta_1 = require("./lib/delta");
 // =============================================================================
 // Utilities
 // =============================================================================
-function computeHash(content) {
-    return `sha256:${crypto.createHash("sha256").update(content).digest("hex")}`;
-}
-function computeNormalizedHash(content) {
-    const normalized = content.replace(/\s+/g, "");
-    return `sha256:${crypto.createHash("sha256").update(normalized).digest("hex")}`;
-}
-/**
- * Extract only the added lines from a diff between old and new text.
- */
-function extractAddedContent(oldText, newText) {
-    // Normalize trailing newlines to avoid false positives.
-    // diffLines treats "line" and "line\n" as different, so when a line
-    // goes from being last (no \n) to having content after it (has \n),
-    // it gets marked as "added" even though the content is identical.
-    const normalize = (text) => {
-        if (!text)
-            return "";
-        return text.endsWith("\n") ? text : text + "\n";
-    };
-    const parts = (0, diff_1.diffLines)(normalize(oldText), normalize(newText));
-    const addedParts = [];
-    for (const part of parts) {
-        if (part.added) {
-            addedParts.push(part.value ?? "");
-        }
-    }
-    return addedParts.join("");
-}
-/**
- * Determine the edit type based on old and new content
- */
-function determineEditType(oldContent, newContent) {
-    if (!oldContent || oldContent.trim() === "") {
-        return "addition";
-    }
-    if (newContent.includes(oldContent)) {
-        return "modification"; // New content contains old content (added to it)
-    }
-    return "replacement"; // Old content was replaced
-}
-/**
- * Hash each line individually for precise matching
- */
-function hashLines(content) {
-    const lines = content.split("\n");
-    const result = [];
-    for (const line of lines) {
-        // Skip empty lines for hashing purposes but keep them for content
-        if (!line.trim())
-            continue;
-        result.push({
-            content: line,
-            hash: computeHash(line),
-            hashNormalized: computeNormalizedHash(line),
-        });
+async function findRepoRoot(filePath) {
+    const absolutePath = path.isAbsolute(filePath)
+        ? filePath
+        : path.resolve(process.cwd(), filePath);
+    let dir;
+    try {
+        const stat = fs.statSync(absolutePath);
+        dir = stat.isDirectory() ? absolutePath : path.dirname(absolutePath);
     }
-    return result;
-}
-/**
- * Hash lines with line numbers and context (for Claude structuredPatch)
- */
-function hashLinesWithNumbers(lines, allFileLines) {
-    const result = [];
-    for (const { content, lineNumber } of lines) {
-        // Skip empty lines
-        if (!content.trim())
-            continue;
-        // Get context (3 lines before and after)
-        const contextBefore = allFileLines
-            .slice(Math.max(0, lineNumber - 4), lineNumber - 1)
-            .join("\n");
-        const contextAfter = allFileLines
-            .slice(lineNumber, Math.min(allFileLines.length, lineNumber + 3))
-            .join("\n");
-        result.push({
-            content,
-            hash: computeHash(content),
-            hashNormalized: computeNormalizedHash(content),
-            lineNumber,
-            contextBefore: contextBefore || undefined,
-            contextAfter: contextAfter || undefined,
-        });
+    catch {
+        dir = path.dirname(absolutePath);
     }
-    return result;
-}
-/**
- * Parse Claude Code's structuredPatch to extract added lines with line numbers
- */
-function parseStructuredPatch(hunks, originalFileLines) {
-    const addedLines = [];
-    for (const hunk of hunks) {
-        let newLineNumber = hunk.newStart;
-        for (const line of hunk.lines) {
-            if (line.startsWith("+")) {
-                // Added line - strip the + prefix
-                addedLines.push({
-                    content: line.slice(1),
-                    lineNumber: newLineNumber,
-                });
-                newLineNumber++;
-            }
-            else if (line.startsWith("-")) {
-                // Deleted line - don't increment new line number
-                continue;
-            }
-            else {
-                // Context line (starts with space) - increment line number
-                newLineNumber++;
-            }
+    while (dir !== "/" && dir !== ".") {
+        const gitDir = path.join(dir, ".git");
+        if (fs.existsSync(gitDir)) {
+            return dir;
         }
+        dir = path.dirname(dir);
     }
-    return addedLines;
+    return null;
 }
-/**
- * Read a file and return its lines (for Cursor line number derivation)
- */
-async function readFileLines(filePath) {
-    try {
-        const fs = await Promise.resolve().then(() => __importStar(require("node:fs/promises")));
-        const content = await fs.readFile(filePath, "utf8");
-        return content.split("\n");
-    }
-    catch {
-        return null;
+function makeRelative(repoRoot, filePath) {
+    if (filePath.startsWith(repoRoot)) {
+        return filePath.slice(repoRoot.length + 1);
     }
+    return filePath;
 }
-/**
- * Extract model name from Claude Code transcript file.
- * The transcript is a JSONL file where assistant messages contain the model field.
- * We read from the end to find the most recent model used.
- */
 async function extractModelFromTranscript(transcriptPath) {
     try {
-        const fs = await Promise.resolve().then(() => __importStar(require("node:fs/promises")));
-        const content = await fs.readFile(transcriptPath, "utf8");
+        const content = fs.readFileSync(transcriptPath, "utf8");
         const lines = content.split("\n");
-        // Read from the end to find the most recent assistant message with model info
         for (let i = lines.length - 1; i >= 0; i--) {
             const line = lines[i].trim();
             if (!line)
                 continue;
             try {
                 const entry = JSON.parse(line);
-                // Assistant messages have message.model field
                 if (entry.message?.model) {
                     return entry.message.model;
                 }
             }
             catch {
-                // Skip malformed lines
                 continue;
             }
         }
@@ -216,50 +108,210 @@ async function extractModelFromTranscript(transcriptPath) {
         return null;
     }
 }
-/**
- * Find where old_string exists in file and return line numbers for new_string
- * Returns null if old_string not found (new file or complex edit)
- */
-function findEditLocation(fileLines, oldString, newString) {
-    if (!oldString) {
-        // New content with no old string - can't determine line numbers without more context
+async function extractPromptFromTranscript(transcriptPath) {
+    try {
+        const content = fs.readFileSync(transcriptPath, "utf8");
+        const lines = content.split("\n").reverse();
+        for (const line of lines) {
+            if (!line.trim())
+                continue;
+            try {
+                const entry = JSON.parse(line);
+                if (entry.type === "human" || entry.message?.role === "user") {
+                    const msg = entry.message?.content;
+                    if (Array.isArray(msg)) {
+                        const textPart = msg.find((m) => m.type === "text" || typeof m === "string");
+                        if (textPart) {
+                            return typeof textPart === "string" ? textPart : textPart.text;
+                        }
+                    }
+                    else if (typeof msg === "string") {
+                        return msg;
+                    }
+                    else if (entry.content) {
+                        return entry.content;
+                    }
+                }
+            }
+            catch {
+                continue;
+            }
+        }
         return null;
     }
-    const fileContent = fileLines.join("\n");
-    const oldIndex = fileContent.indexOf(oldString);
-    if (oldIndex === -1) {
+    catch {
         return null;
     }
-    // Count lines before the match to get line number
-    const linesBefore = fileContent.slice(0, oldIndex).split("\n").length;
-    const startLine = linesBefore;
-    // Calculate what the new file will look like after the edit
-    const newFileContent = fileContent.replace(oldString, newString);
-    const newFileLines = newFileContent.split("\n");
-    // Find the added lines by comparing old and new
-    const addedContent = extractAddedContent(oldString, newString);
-    if (!addedContent.trim()) {
+}
+async function setupCaptureContext(filePath, agent, conversationId, model) {
+    const repoRoot = await findRepoRoot(filePath);
+    if (!repoRoot) {
+        if (process.env.AGENTBLAME_DEBUG) {
+            console.error(`[agentblame] No git repo found for ${filePath}`);
+        }
         return null;
     }
-    const addedLines = addedContent.split("\n").filter(l => l.trim());
-    const result = [];
-    // Find each added line in the new content
-    let searchStart = startLine - 1;
-    for (const addedLine of addedLines) {
-        if (!addedLine.trim())
-            continue;
-        for (let i = searchStart; i < newFileLines.length; i++) {
-            if (newFileLines[i] === addedLine || newFileLines[i].trim() === addedLine.trim()) {
-                result.push({
-                    content: addedLine,
-                    lineNumber: i + 1, // 1-indexed
-                });
-                searchStart = i + 1;
-                break;
+    (0, storage_1.ensureAgentBlameDirs)(repoRoot);
+    const dbPath = (0, storage_1.getDatabasePath)(repoRoot);
+    (0, database_1.setDatabasePath)(dbPath);
+    const baseSha = await (0, storage_1.getGitHead)(repoRoot);
+    if (!baseSha) {
+        if (process.env.AGENTBLAME_DEBUG) {
+            console.error(`[agentblame] No HEAD commit found in ${repoRoot}`);
+        }
+        return null;
+    }
+    // Smart cleanup: only clean up working directories for commits that:
+    // 1. Are ancestors of current HEAD (we've moved past them)
+    // 2. Have git notes (deltas were processed)
+    // This preserves deltas for reset/recommit and stash scenarios
+    await (0, storage_1.cleanupProcessedWorkingDirs)(repoRoot, baseSha);
+    const sessionId = (0, database_1.generateSessionId)(agent, conversationId);
+    const normalizedModel = (0, util_1.normalizeModelName)(model);
+    // Load config setting for prompt content storage
+    const storePromptContent = await (0, config_1.getConfig)(repoRoot, 'storePromptContent');
+    return {
+        repoRoot,
+        baseSha,
+        agent,
+        sessionId,
+        model: normalizedModel,
+        storePromptContent,
+    };
+}
+// =============================================================================
+// Delta Capture (v3 - The Only Way)
+// =============================================================================
+/**
+ * Detect and record human edits since last checkpoint.
+ *
+ * IMPORTANT: We need to be careful not to mark another AI tool's edits as human.
+ * The most reliable baseline is the most recent delta's afterBlob (from any session).
+ * This handles:
+ * 1. Cross-session detection (another AI edited the file)
+ * 2. Same-session async race (PostToolUse is async, so checkpoint might be stale)
+ *
+ * Priority:
+ * 1. Last delta's afterBlob (most reliable - represents actual file state)
+ * 2. Checkpoint content (fallback if no delta exists)
+ */
+async function detectAndRecordHumanEdits(ctx, conversationId, filePath) {
+    const absolutePath = path.isAbsolute(filePath)
+        ? filePath
+        : path.join(ctx.repoRoot, filePath);
+    const relativePath = makeRelative(ctx.repoRoot, absolutePath);
+    // Read current file content first
+    const currentContent = (0, storage_1.readFileContent)(absolutePath);
+    if (currentContent === null) {
+        return;
+    }
+    if (process.env.AGENTBLAME_DEBUG) {
+        console.error(`[agentblame] detectHumanEdits: ${relativePath}`);
+    }
+    // Priority 1: Use the last delta's afterBlob as baseline (most reliable)
+    // This handles both cross-session AND same-session scenarios
+    // (e.g., when async PostToolUse writes delta but checkpoint is stale)
+    let beforeContent = null;
+    const lastDelta = (0, delta_1.getLastDeltaForFile)(ctx.repoRoot, ctx.baseSha, relativePath);
+    if (process.env.AGENTBLAME_DEBUG) {
+        console.error(`[agentblame]   lastDelta: ${lastDelta ? `session=${lastDelta.sessionId?.slice(0, 8) || 'human'}, afterBlob=${lastDelta.afterBlob?.slice(0, 8)}` : 'null'}`);
+    }
+    if (lastDelta?.afterBlob) {
+        try {
+            beforeContent = await (0, storage_1.loadSnapshot)(ctx.repoRoot, lastDelta.afterBlob);
+            if (process.env.AGENTBLAME_DEBUG) {
+                console.error(`[agentblame]   Loaded afterBlob: ${beforeContent?.length} chars`);
             }
         }
+        catch (err) {
+            if (process.env.AGENTBLAME_DEBUG) {
+                console.error(`[agentblame]   Failed to load afterBlob: ${err}`);
+            }
+            // Fall through to checkpoint
+        }
+    }
+    // Priority 2: Fall back to checkpoint if no delta afterBlob available
+    if (beforeContent === null) {
+        beforeContent = await (0, checkpoint_1.getCheckpointContent)(ctx.repoRoot, conversationId, relativePath);
+        if (process.env.AGENTBLAME_DEBUG) {
+            console.error(`[agentblame]   checkpoint content: ${beforeContent ? beforeContent.length + ' chars' : 'null'}`);
+        }
+    }
+    // No baseline available - can't detect changes
+    if (beforeContent === null) {
+        if (process.env.AGENTBLAME_DEBUG) {
+            console.error(`[agentblame]   No baseline - skipping`);
+        }
+        return;
+    }
+    const hunks = (0, delta_1.computeDiff)(beforeContent, currentContent);
+    if (process.env.AGENTBLAME_DEBUG) {
+        console.error(`[agentblame]   beforeContent: ${beforeContent.length} chars, currentContent: ${currentContent.length} chars`);
+        console.error(`[agentblame]   diff hunks: ${hunks.length} (${hunks.map(h => `L${h.newStart}+${h.newCount}`).join(',')})`);
+    }
+    if (hunks.length === 0) {
+        // Update checkpoint even if no changes (keeps it current)
+        await (0, checkpoint_1.captureFileCheckpoint)(ctx.repoRoot, conversationId, relativePath);
+        return;
+    }
+    // Store afterBlob for cross-session detection
+    const afterBlob = await (0, storage_1.storeSnapshot)(ctx.repoRoot, currentContent);
+    if (process.env.AGENTBLAME_DEBUG) {
+        console.error(`[agentblame]   RECORDING HUMAN DELTA: ${relativePath} with ${hunks.length} hunks`);
+    }
+    const humanDelta = (0, delta_1.createHumanDelta)(relativePath, hunks, afterBlob);
+    (0, delta_1.appendDelta)(ctx.repoRoot, ctx.baseSha, humanDelta);
+    // Update checkpoint to current state
+    await (0, checkpoint_1.captureFileCheckpoint)(ctx.repoRoot, conversationId, relativePath);
+    if (process.env.AGENTBLAME_DEBUG) {
+        console.error(`[agentblame] Detected human edit: ${relativePath} (${hunks.length} hunks)`);
+    }
+}
+/**
+ * Record an AI edit delta.
+ */
+async function recordAIDelta(ctx, filePath, beforeContent, afterContent) {
+    const absolutePath = path.isAbsolute(filePath)
+        ? filePath
+        : path.join(ctx.repoRoot, filePath);
+    const relativePath = makeRelative(ctx.repoRoot, absolutePath);
+    const before = beforeContent ?? "";
+    const hunks = (0, delta_1.computeDiff)(before, afterContent);
+    if (hunks.length === 0) {
+        if (process.env.AGENTBLAME_DEBUG) {
+            console.error(`[agentblame] recordAIDelta: no diff for ${relativePath} (before=${before.length} chars, after=${afterContent.length} chars)`);
+        }
+        return;
+    }
+    // Store afterBlob for cross-session human edit detection
+    const afterBlob = await (0, storage_1.storeSnapshot)(ctx.repoRoot, afterContent);
+    const latestPrompt = (0, database_1.getLatestPromptForSession)(ctx.sessionId);
+    const promptId = latestPrompt?.id ?? null;
+    const aiDelta = (0, delta_1.createAIDelta)(relativePath, ctx.sessionId, promptId, hunks, afterBlob);
+    (0, delta_1.appendDelta)(ctx.repoRoot, ctx.baseSha, aiDelta);
+    if (process.env.AGENTBLAME_DEBUG) {
+        console.error(`[agentblame] Recorded AI delta: ${relativePath} (${hunks.length} hunks, prompt: ${promptId}, lines: ${hunks.map(h => `${h.newStart}+${h.newCount}`).join(',')})`);
+        console.error(`[agentblame]   stored path: "${relativePath}"`);
+    }
+}
+/**
+ * Get before content from checkpoint or git HEAD.
+ */
+async function getBeforeContent(ctx, conversationId, filePath) {
+    const absolutePath = path.isAbsolute(filePath)
+        ? filePath
+        : path.join(ctx.repoRoot, filePath);
+    const relativePath = makeRelative(ctx.repoRoot, absolutePath);
+    const beforeBlob = await (0, checkpoint_1.getBeforeBlob)(ctx.repoRoot, conversationId, relativePath);
+    if (!beforeBlob) {
+        return null;
+    }
+    try {
+        return await (0, storage_1.loadSnapshot)(ctx.repoRoot, beforeBlob);
+    }
+    catch {
+        return null;
     }
-    return result.length > 0 ? result : null;
 }
 // =============================================================================
 // Payload Processing
@@ -280,316 +332,267 @@ function parseArgs() {
     }
     return { provider, event };
 }
-/**
- * Save an edit to the SQLite database
- */
-function saveEdit(edit) {
-    (0, database_1.insertEdit)({
-        timestamp: edit.timestamp,
-        provider: edit.provider,
-        filePath: edit.filePath,
-        model: edit.model,
-        content: edit.content,
-        contentHash: edit.contentHash,
-        contentHashNormalized: edit.contentHashNormalized,
-        editType: edit.editType,
-        oldContent: edit.oldContent,
-        lines: edit.lines,
-        sessionId: edit.sessionId,
-        toolUseId: edit.toolUseId,
+async function processCursorBeforeSubmitPrompt(payload) {
+    const workspaceRoot = payload.workspace_roots?.[0];
+    if (!workspaceRoot)
+        return;
+    const conversationId = payload.conversation_id || `cursor-${Date.now()}`;
+    const ctx = await setupCaptureContext(workspaceRoot, "cursor", conversationId, payload.model || null);
+    if (!ctx)
+        return;
+    (0, database_1.upsertSession)({
+        id: ctx.sessionId,
+        agent: "cursor",
+        model: ctx.model,
+        conversationId,
     });
+    // Detect human edits on existing checkpoints, then capture new checkpoint
+    try {
+        const existingCheckpoint = (0, checkpoint_1.loadCheckpoint)(ctx.repoRoot, conversationId);
+        if (existingCheckpoint) {
+            for (const filePath of Object.keys(existingCheckpoint.files)) {
+                await detectAndRecordHumanEdits(ctx, conversationId, filePath);
+            }
+        }
+        await (0, checkpoint_1.captureBeforePromptCheckpoint)(ctx.repoRoot, conversationId);
+    }
+    catch (err) {
+        if (process.env.AGENTBLAME_DEBUG) {
+            console.error(`[agentblame] Failed to capture checkpoint:`, err);
+        }
+    }
+    // Store prompt if provided
+    const prompt = payload.prompt;
+    if (prompt) {
+        const contentHash = (0, database_1.hashPromptContent)(prompt);
+        if (!(0, database_1.promptExists)(ctx.sessionId, contentHash)) {
+            (0, database_1.insertPrompt)({
+                sessionId: ctx.sessionId,
+                content: ctx.storePromptContent ? prompt : null,
+                contentHash,
+            });
+            if (process.env.AGENTBLAME_DEBUG) {
+                console.error(`[agentblame] Captured prompt: ${prompt.substring(0, 100)}...`);
+            }
+        }
+    }
 }
 async function processCursorPayload(payload, event) {
-    const edits = [];
-    const timestamp = new Date().toISOString();
-    // Only process afterFileEdit (Composer/Agent mode)
-    // Skip afterTabFileEdit - tab completions fire as fragments that can't be matched
+    if (event === "beforeSubmitPrompt") {
+        await processCursorBeforeSubmitPrompt(payload);
+        return;
+    }
     if (event === "afterTabFileEdit") {
-        return edits;
+        return;
     }
     if (!payload.edits || payload.edits.length === 0) {
-        return edits;
-    }
-    // Read the file to derive line numbers (Cursor doesn't provide them)
-    const fileLines = await readFileLines(payload.file_path);
-    for (const edit of payload.edits) {
-        const oldString = edit.old_string || "";
-        const newString = edit.new_string || "";
-        if (!newString)
-            continue;
-        // Extract only the added content
-        const addedContent = extractAddedContent(oldString, newString);
-        if (!addedContent.trim())
-            continue;
-        let lines;
-        // Try to derive line numbers if we have the file
-        if (fileLines && oldString) {
-            const linesWithNumbers = findEditLocation(fileLines, oldString, newString);
-            if (linesWithNumbers && linesWithNumbers.length > 0) {
-                lines = hashLinesWithNumbers(linesWithNumbers, fileLines);
-            }
-            else {
-                // Fallback to basic hashing without line numbers
-                lines = hashLines(addedContent);
-            }
-        }
-        else {
-            // No file or no old_string - hash without line numbers
-            lines = hashLines(addedContent);
-        }
-        if (lines.length === 0)
-            continue;
-        edits.push({
-            timestamp,
-            provider: "cursor",
-            filePath: payload.file_path,
-            model: payload.model || null,
-            lines,
-            content: addedContent,
-            contentHash: computeHash(addedContent),
-            contentHashNormalized: computeNormalizedHash(addedContent),
-            editType: determineEditType(oldString, newString),
-            oldContent: oldString || undefined,
-            sessionId: payload.conversation_id,
-            toolUseId: payload.generation_id,
-        });
+        return;
+    }
+    const filePath = payload.file_path;
+    if (!filePath)
+        return;
+    const conversationId = payload.conversation_id || `cursor-${Date.now()}`;
+    const ctx = await setupCaptureContext(filePath, "cursor", conversationId, payload.model || null);
+    if (!ctx)
+        return;
+    (0, database_1.upsertSession)({
+        id: ctx.sessionId,
+        agent: "cursor",
+        model: ctx.model,
+        conversationId,
+    });
+    const absolutePath = path.isAbsolute(filePath)
+        ? filePath
+        : path.join(ctx.repoRoot, filePath);
+    const relativePath = makeRelative(ctx.repoRoot, absolutePath);
+    // Get before/after content and record delta
+    const beforeContent = await getBeforeContent(ctx, conversationId, filePath);
+    const afterContent = (0, storage_1.readFileContent)(absolutePath);
+    if (afterContent) {
+        await recordAIDelta(ctx, filePath, beforeContent, afterContent);
+        // Update checkpoint to current state so next beforeSubmitPrompt doesn't
+        // incorrectly detect this AI edit as a "human edit"
+        await (0, checkpoint_1.captureFileCheckpoint)(ctx.repoRoot, conversationId, filePath);
+    }
+    (0, database_1.insertToolCall)({
+        sessionId: ctx.sessionId,
+        toolName: "edit",
+        filePath: relativePath,
+    });
+    if (process.env.AGENTBLAME_DEBUG) {
+        console.error(`[agentblame] Captured Cursor edit: ${filePath}`);
     }
-    return edits;
 }
 async function processClaudePayload(payload) {
-    const edits = [];
-    // CRITICAL: Skip payloads that are actually from Cursor.
-    // Both Cursor and Claude Code can trigger hooks from .claude/settings.json,
-    // so we need to detect Cursor payloads and skip them here.
-    // Cursor payloads have cursor_version field, Claude payloads don't.
     if (payload.cursor_version) {
-        return edits;
-    }
-    // CRITICAL: Only process if this is an actual Edit or Write tool usage from Claude.
-    // Claude Code's hooks fire for various reasons, but we only want to capture
-    // when Claude actually performed an edit/write operation.
-    // Without a valid tool_name, this is likely a spurious trigger (e.g., from file
-    // watcher detecting external changes).
-    const toolName = payload.tool_name?.toLowerCase() || "";
-    if (toolName !== "edit" && toolName !== "write" && toolName !== "multiedit") {
-        return edits;
-    }
-    const timestamp = new Date().toISOString();
-    // Claude Code has tool_input with the actual content
+        return;
+    }
+    const toolName = payload.tool_name || "";
+    if (!toolName)
+        return;
+    const hookEvent = payload.hook_event_name || "PostToolUse";
     const toolInput = payload.tool_input;
     const toolResponse = payload.tool_response;
     const filePath = toolResponse?.filePath || toolInput?.file_path || payload.file_path;
-    if (!filePath)
-        return edits;
-    // Extract session info for correlation
-    const sessionId = payload.session_id;
-    const toolUseId = payload.tool_use_id;
-    // Extract model from transcript file (Claude Code provides transcript_path in hook payload)
+    const toolNameLower = toolName.toLowerCase();
+    const isFileModifying = toolNameLower === "edit" ||
+        toolNameLower === "write" ||
+        toolNameLower === "multiedit";
+    const pathForRepo = filePath || payload.transcript_path;
+    if (!pathForRepo)
+        return;
+    if (process.env.AGENTBLAME_DEBUG) {
+        console.error(`[agentblame] Claude ${hookEvent} ${toolName}:`);
+        console.error(`[agentblame]   toolResponse.filePath: ${toolResponse?.filePath}`);
+        console.error(`[agentblame]   toolInput.file_path: ${toolInput?.file_path}`);
+        console.error(`[agentblame]   payload.file_path: ${payload.file_path}`);
+        console.error(`[agentblame]   resolved filePath: ${filePath}`);
+    }
     let model = null;
     if (payload.transcript_path) {
         model = await extractModelFromTranscript(payload.transcript_path);
     }
-    // Fallback to generic "claude" if transcript parsing fails
     if (!model) {
         model = "claude";
     }
-    // For Edit/MultiEdit tools, REQUIRE structuredPatch.
-    // Without structuredPatch, we cannot accurately determine what Claude added.
-    // Spurious triggers (e.g., file watcher detecting external changes) won't have
-    // structuredPatch and would incorrectly capture the entire file.
-    if (toolName === "edit" || toolName === "multiedit") {
-        if (!toolResponse?.structuredPatch || toolResponse.structuredPatch.length === 0) {
-            // No structuredPatch - skip this capture to avoid incorrect attribution
-            // Log for debugging missing captures
-            if (process.env.AGENTBLAME_DEBUG) {
-                console.error(`[agentblame] Skipping ${toolName} for ${filePath}: no structuredPatch in tool_response`);
-                console.error(`[agentblame] tool_response keys: ${toolResponse ? Object.keys(toolResponse).join(", ") : "null"}`);
+    const conversationId = payload.session_id || `claude-${Date.now()}`;
+    const ctx = await setupCaptureContext(pathForRepo, "claude", conversationId, model);
+    if (!ctx)
+        return;
+    (0, database_1.upsertSession)({
+        id: ctx.sessionId,
+        agent: "claude",
+        model: ctx.model,
+        conversationId,
+    });
+    // Extract and store prompt
+    if (payload.transcript_path) {
+        const prompt = await extractPromptFromTranscript(payload.transcript_path);
+        if (prompt) {
+            const contentHash = (0, database_1.hashPromptContent)(prompt);
+            if (!(0, database_1.promptExists)(ctx.sessionId, contentHash)) {
+                (0, database_1.insertPrompt)({
+                    sessionId: ctx.sessionId,
+                    content: ctx.storePromptContent ? prompt : null,
+                    contentHash,
+                });
             }
-            return edits;
         }
-        // Get original file lines for context
-        const originalFileLines = (toolResponse.originalFile || "").split("\n");
-        // Parse the structured patch to get added lines with line numbers
-        const addedLinesWithNumbers = parseStructuredPatch(toolResponse.structuredPatch, originalFileLines);
-        if (addedLinesWithNumbers.length === 0)
-            return edits;
-        // Hash lines with their line numbers and context
-        const lines = hashLinesWithNumbers(addedLinesWithNumbers, originalFileLines);
-        if (lines.length === 0)
-            return edits;
-        // Aggregate content
-        const addedContent = addedLinesWithNumbers.map(l => l.content).join("\n");
-        edits.push({
-            timestamp,
-            provider: "claudeCode",
-            filePath,
-            model,
-            lines,
-            content: addedContent,
-            contentHash: computeHash(addedContent),
-            contentHashNormalized: computeNormalizedHash(addedContent),
-            editType: "modification",
-            sessionId,
-            toolUseId,
+    }
+    // PreToolUse: detect human edits and capture checkpoint
+    if (hookEvent === "PreToolUse" && isFileModifying && filePath) {
+        if (process.env.AGENTBLAME_DEBUG) {
+            console.error(`[agentblame] PreToolUse: ${filePath}`);
+        }
+        await detectAndRecordHumanEdits(ctx, conversationId, filePath);
+        await (0, checkpoint_1.captureFileCheckpoint)(ctx.repoRoot, conversationId, filePath);
+        if (process.env.AGENTBLAME_DEBUG) {
+            console.error(`[agentblame] PreToolUse complete: ${filePath}`);
+        }
+        return;
+    }
+    // PostToolUse: record AI delta
+    if (hookEvent === "PostToolUse" && isFileModifying && filePath) {
+        const absolutePath = path.isAbsolute(filePath)
+            ? filePath
+            : path.join(ctx.repoRoot, filePath);
+        const relativePath = makeRelative(ctx.repoRoot, absolutePath);
+        const beforeContent = await getBeforeContent(ctx, conversationId, filePath);
+        const afterContent = (0, storage_1.readFileContent)(absolutePath);
+        if (process.env.AGENTBLAME_DEBUG) {
+            console.error(`[agentblame] PostToolUse ${toolName}: ${relativePath}`);
+            console.error(`[agentblame]   beforeContent: ${beforeContent ? beforeContent.length + ' chars' : 'null'}`);
+            console.error(`[agentblame]   afterContent: ${afterContent ? afterContent.length + ' chars' : 'null'}`);
+        }
+        if (afterContent) {
+            await recordAIDelta(ctx, filePath, beforeContent, afterContent);
+            // Update checkpoint to current state so next PreToolUse doesn't
+            // incorrectly detect this AI edit as a "human edit"
+            await (0, checkpoint_1.captureFileCheckpoint)(ctx.repoRoot, conversationId, filePath);
+        }
+        else if (process.env.AGENTBLAME_DEBUG) {
+            console.error(`[agentblame]   SKIPPED: no afterContent for ${relativePath}`);
+        }
+        (0, database_1.insertToolCall)({
+            sessionId: ctx.sessionId,
+            toolName: toolName.toLowerCase(),
+            filePath: relativePath,
         });
-        return edits;
-    }
-    // Handle Write tool (new file creation)
-    // For Write, we need content
-    if (toolName === "write") {
-        const content = toolInput?.content || payload.content;
-        if (!content || !content.trim()) {
-            return edits;
+        if (process.env.AGENTBLAME_DEBUG) {
+            console.error(`[agentblame] Captured Claude ${toolName}: ${filePath}`);
         }
-        const lines = hashLines(content);
-        if (lines.length === 0)
-            return edits;
-        edits.push({
-            timestamp,
-            provider: "claudeCode",
-            filePath,
-            model,
-            lines,
-            content,
-            contentHash: computeHash(content),
-            contentHashNormalized: computeNormalizedHash(content),
-            editType: "addition",
-            sessionId,
-            toolUseId,
+    }
+    else if (!isFileModifying) {
+        // Read-only tools
+        (0, database_1.insertToolCall)({
+            sessionId: ctx.sessionId,
+            toolName: toolName.toLowerCase(),
+            filePath: filePath ? makeRelative(ctx.repoRoot, filePath) : null,
         });
-        return edits;
     }
-    // Unknown tool type that passed the initial check - skip
-    return edits;
 }
-/**
- * Process OpenCode payload.
- * OpenCode provides before/after file content which allows precise line number extraction.
- */
-function processOpenCodePayload(payload) {
-    const edits = [];
-    const timestamp = new Date().toISOString();
+async function processOpenCodePayload(payload) {
     const filePath = payload.filePath;
     if (!filePath)
-        return edits;
-    const sessionId = payload.sessionID;
-    const toolUseId = payload.callID;
-    const model = payload.model || null;
-    // Handle write tool (new file creation)
-    if (payload.tool === "write" && payload.content) {
-        const content = payload.content;
-        if (!content.trim())
-            return edits;
-        // For new files, all lines are added
-        const fileLines = content.split("\n");
-        const linesWithNumbers = fileLines
-            .map((line, i) => ({ content: line, lineNumber: i + 1 }))
-            .filter(l => l.content.trim());
-        const lines = hashLinesWithNumbers(linesWithNumbers, fileLines);
-        if (lines.length === 0)
-            return edits;
-        edits.push({
-            timestamp,
-            provider: "opencode",
-            filePath,
-            model,
-            lines,
-            content,
-            contentHash: computeHash(content),
-            contentHashNormalized: computeNormalizedHash(content),
-            editType: "addition",
-            sessionId,
-            toolUseId,
-        });
-        return edits;
-    }
-    // Handle edit tool
-    if (payload.tool === "edit") {
-        // OpenCode provides full before/after content - use it for precise line detection
-        if (payload.before !== undefined && payload.after !== undefined) {
-            const beforeLines = payload.before.split("\n");
-            const afterLines = payload.after.split("\n");
-            // Use diffLines to find added lines with their positions
-            const parts = (0, diff_1.diffLines)(payload.before, payload.after);
-            const addedLinesWithNumbers = [];
-            let afterLineIndex = 0;
-            for (const part of parts) {
-                const partLines = part.value.split("\n");
-                // Remove empty string from split if value ends with \n
-                if (partLines[partLines.length - 1] === "") {
-                    partLines.pop();
-                }
-                if (part.added) {
-                    // These lines were added
-                    for (const line of partLines) {
-                        addedLinesWithNumbers.push({
-                            content: line,
-                            lineNumber: afterLineIndex + 1, // 1-indexed
-                        });
-                        afterLineIndex++;
-                    }
-                }
-                else if (part.removed) {
-                    // Removed lines don't affect after line index
-                }
-                else {
-                    // Context lines - advance the after line index
-                    afterLineIndex += partLines.length;
-                }
-            }
-            if (addedLinesWithNumbers.length === 0)
-                return edits;
-            // Filter empty lines and hash with context
-            const nonEmptyLines = addedLinesWithNumbers.filter(l => l.content.trim());
-            if (nonEmptyLines.length === 0)
-                return edits;
-            const lines = hashLinesWithNumbers(nonEmptyLines, afterLines);
-            if (lines.length === 0)
-                return edits;
-            const addedContent = nonEmptyLines.map(l => l.content).join("\n");
-            edits.push({
-                timestamp,
-                provider: "opencode",
-                filePath,
-                model,
-                lines,
-                content: addedContent,
-                contentHash: computeHash(addedContent),
-                contentHashNormalized: computeNormalizedHash(addedContent),
-                editType: "modification",
-                oldContent: payload.oldString,
-                sessionId,
-                toolUseId,
+        return;
+    const conversationId = payload.sessionID || `opencode-${Date.now()}`;
+    const ctx = await setupCaptureContext(filePath, "opencode", conversationId, payload.model || null);
+    if (!ctx)
+        return;
+    (0, database_1.upsertSession)({
+        id: ctx.sessionId,
+        agent: "opencode",
+        model: ctx.model,
+        conversationId,
+    });
+    if (payload.prompt) {
+        const contentHash = (0, database_1.hashPromptContent)(payload.prompt);
+        if (!(0, database_1.promptExists)(ctx.sessionId, contentHash)) {
+            (0, database_1.insertPrompt)({
+                sessionId: ctx.sessionId,
+                content: ctx.storePromptContent ? payload.prompt : null,
+                contentHash,
             });
-            return edits;
         }
-        // Fallback: use oldString/newString if before/after not available
-        const oldString = payload.oldString || "";
-        const newString = payload.newString || "";
-        if (!newString)
-            return edits;
-        const addedContent = extractAddedContent(oldString, newString);
-        if (!addedContent.trim())
-            return edits;
-        const lines = hashLines(addedContent);
-        if (lines.length === 0)
-            return edits;
-        edits.push({
-            timestamp,
-            provider: "opencode",
-            filePath,
-            model,
-            lines,
-            content: addedContent,
-            contentHash: computeHash(addedContent),
-            contentHashNormalized: computeNormalizedHash(addedContent),
-            editType: determineEditType(oldString, newString),
-            oldContent: oldString || undefined,
-            sessionId,
-            toolUseId,
-        });
     }
-    return edits;
+    // Before hook: detect human edits and capture checkpoint
+    if (payload.hook_event === "before") {
+        await detectAndRecordHumanEdits(ctx, conversationId, filePath);
+        await (0, checkpoint_1.captureFileCheckpoint)(ctx.repoRoot, conversationId, filePath);
+        if (process.env.AGENTBLAME_DEBUG) {
+            console.error(`[agentblame] OpenCode before checkpoint: ${filePath}`);
+        }
+        return;
+    }
+    // After hook: record AI delta
+    const absolutePath = path.isAbsolute(filePath)
+        ? filePath
+        : path.join(ctx.repoRoot, filePath);
+    const relativePath = makeRelative(ctx.repoRoot, absolutePath);
+    // Get before content (OpenCode may provide it directly)
+    let beforeContent = null;
+    if (payload.before) {
+        beforeContent = payload.before;
+    }
+    else {
+        beforeContent = await getBeforeContent(ctx, conversationId, filePath);
+    }
+    // Get after content
+    const afterContent = payload.after ?? (0, storage_1.readFileContent)(absolutePath);
+    if (afterContent) {
+        await recordAIDelta(ctx, filePath, beforeContent, afterContent);
+        // Update checkpoint to current state so next before hook doesn't
+        // incorrectly detect this AI edit as a "human edit"
+        await (0, checkpoint_1.captureFileCheckpoint)(ctx.repoRoot, conversationId, filePath);
+    }
+    (0, database_1.insertToolCall)({
+        sessionId: ctx.sessionId,
+        toolName: payload.tool,
+        filePath: relativePath,
+    });
+    if (process.env.AGENTBLAME_DEBUG) {
+        console.error(`[agentblame] Captured OpenCode ${payload.tool}: ${filePath}`);
+    }
 }
 // =============================================================================
 // Main
@@ -605,55 +608,30 @@ async function runCapture() {
     try {
         const { provider, event } = parseArgs();
         const input = await readStdin();
+        if (process.env.AGENTBLAME_DEBUG) {
+            console.error(`[agentblame] Capture: provider=${provider}, event=${event}`);
+        }
         if (!input.trim()) {
             process.exit(0);
         }
         const data = JSON.parse(input);
-        // The hook receives the payload directly or wrapped
         const payload = data.payload || data;
-        let edits = [];
         if (provider === "cursor") {
             const eventName = event || data.hook_event_name || "afterFileEdit";
-            edits = await processCursorPayload(payload, eventName);
+            await processCursorPayload(payload, eventName);
         }
         else if (provider === "claude") {
-            edits = await processClaudePayload(payload);
+            await processClaudePayload(payload);
         }
         else if (provider === "opencode") {
-            edits = processOpenCodePayload(payload);
-        }
-        // Save all edits to SQLite database
-        if (process.env.AGENTBLAME_DEBUG && edits.length === 0) {
-            console.error(`[agentblame] No edits extracted from ${provider} payload`);
-        }
-        for (const edit of edits) {
-            // Find the agentblame directory for this file
-            const agentblameDir = (0, util_1.findAgentBlameDir)(edit.filePath);
-            if (!agentblameDir) {
-                // File is not in an initialized repo, skip silently
-                if (process.env.AGENTBLAME_DEBUG) {
-                    console.error(`[agentblame] No agentblame dir found for ${edit.filePath}`);
-                }
-                continue;
-            }
-            // Set the database directory and save
-            (0, database_1.setAgentBlameDir)(agentblameDir);
-            try {
-                saveEdit(edit);
-                if (process.env.AGENTBLAME_DEBUG) {
-                    console.error(`[agentblame] Saved edit for ${edit.filePath}: ${edit.lines.length} lines`);
-                }
-            }
-            catch (saveErr) {
-                // Log database errors even without debug mode since they indicate lost data
-                console.error(`[agentblame] Failed to save edit for ${edit.filePath}:`, saveErr);
-            }
+            await processOpenCodePayload(payload);
         }
         process.exit(0);
     }
     catch (err) {
-        // Silent failure - don't interrupt the editor
-        console.error("Agent Blame capture error:", err);
+        if (process.env.AGENTBLAME_DEBUG) {
+            console.error("Agent Blame capture error:", err);
+        }
         process.exit(0);
     }
 }