claude-attribution 1.5.0 → 1.6.0

package/README.md

@@ -584,6 +584,11 @@ jobs:
       - name: Fetch attribution notes
         run: git fetch origin refs/notes/claude-attribution:refs/notes/claude-attribution || true
 
+      - name: Configure git identity for notes
+        run: |
+          git config user.email "claude-attribution[bot]@users.noreply.github.com"
+          git config user.name "claude-attribution[bot]"
+
       - uses: oven-sh/setup-bun@v2
 
       - name: Install claude-attribution

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "claude-attribution",
-	"version": "1.5.0",
+	"version": "1.6.0",
 	"description": "AI code attribution tracking for Claude Code sessions — checkpoint-based line diff approach",
 	"type": "module",
 	"bin": {

package/src/attribution/commit.ts

@@ -20,7 +20,8 @@
  * All errors are caught and logged; the process always exits 0.
  */
 import { resolve, join } from "path";
-import { mkdir, appendFile } from "fs/promises";
+import { mkdir, appendFile, readFile } from "fs/promises";
+import { existsSync } from "fs";
 import { execFile } from "child_process";
 import { promisify } from "util";
 
@@ -40,6 +41,7 @@ import {
 	headSha,
 	filesInCommit,
 	committedContent,
+	committedContentAt,
 	currentBranch,
 } from "./git-notes.ts";
 import {
@@ -59,14 +61,53 @@ import {
 	clearOtelContext,
 } from "./otel.ts";
 
+/**
+ * Resolve the active Claude session ID for this commit.
+ *
+ * Primary: read from .claude/attribution-state/current-session (written by pre-tool-use hook
+ * on the first Write/Edit in a session).
+ *
+ * Fallback: if no current-session file exists (e.g. claude --continue where only Bash was
+ * used to run git commit, so no Write/Edit hook fired), read the most recent entry from
+ * tool-usage.jsonl. If that entry is within 8 hours, return its session ID — this covers
+ * the "install, exit, --continue, commit" workflow where the editing and committing happen
+ * in the same logical session but different invocations.
+ */
+async function resolveSessionForCommit(
+	repoRoot: string,
+): Promise<string | null> {
+	const fromCurrentSession = await readCurrentSession(repoRoot);
+	if (fromCurrentSession) return fromCurrentSession;
+
+	const toolLog = join(repoRoot, ".claude", "logs", "tool-usage.jsonl");
+	if (!existsSync(toolLog)) return null;
+
+	try {
+		const raw = await readFile(toolLog, "utf8");
+		const last = raw.trim().split("\n").filter(Boolean).at(-1);
+		if (!last) return null;
+		const entry = JSON.parse(last) as { session?: string; timestamp?: string };
+		if (!entry.session || !entry.timestamp) return null;
+		const age = Date.now() - new Date(entry.timestamp).getTime();
+		const EIGHT_HOURS = 8 * 60 * 60 * 1000;
+		if (age < EIGHT_HOURS) return entry.session;
+	} catch {
+		// Non-fatal
+	}
+	return null;
+}
+
 async function main() {
 	const repoRoot = resolve(process.cwd());
-	const sessionId = await readCurrentSession(repoRoot);
+	const sessionId = await resolveSessionForCommit(repoRoot);
 
-	const [sha, branch, changedFiles] = await Promise.all([
+	const [sha, branch, changedFiles, parentSha] = await Promise.all([
 		headSha(repoRoot),
 		currentBranch(repoRoot),
 		filesInCommit(repoRoot),
+		execFileAsync("git", ["rev-parse", "HEAD^1"], { cwd: repoRoot })
+			.then((r: { stdout: string }) => r.stdout.trim())
+			.catch(() => null as string | null),
 	]);
 
 	// Process files in parallel — each file attribution is independent.
@@ -109,16 +150,21 @@ async function main() {
 					const after = await loadCheckpoint(sessionId, absPath, "after");
 
 					if (!after) {
-						return {
-							path: relPath,
-							ai: 0,
-							human: committedLines.length,
-							mixed: 0,
-							total: committedLines.length,
-							pctAi: 0,
-							attribution: empty,
+						// Git-diff fallback: no after checkpoint means Claude didn't write this
+						// file in the current session via Write/Edit hooks. Fall back to treating
+						// lines new since the parent commit as AI-authored — covers the case where
+						// attribution was installed after the code was written and committed via
+						// claude --continue (no Write/Edit in the commit session).
+						const parentContent = parentSha
+							? await committedContentAt(repoRoot, parentSha, relPath)
+							: null;
+						const parentLines = parentContent?.split("\n") ?? [];
+						const { stats, attribution } = attributeLines(
+							parentLines,
 							committedLines,
-						};
+							committedLines,
+						);
+						return { ...stats, path: relPath, attribution, committedLines };
 					}
 
 					const beforeLines = before?.lines ?? [];
@@ -167,12 +213,7 @@ async function main() {
 
 	// Update cumulative minimap — non-fatal, never blocks commits
 	try {
-		// Load parent commit's minimap for carry-forward
-		const parentSha = await execFileAsync("git", ["rev-parse", "HEAD^1"], {
-			cwd: repoRoot,
-		})
-			.then((r: { stdout: string }) => r.stdout.trim())
-			.catch(() => null);
+		// Load parent commit's minimap for carry-forward (parentSha fetched at top of main)
 
 		const prevMinimap = parentSha
 			? await readMinimap(repoRoot, parentSha)

package/src/hooks/post-bash.ts

@@ -102,7 +102,7 @@ async function main() {
 			newBody = body ? `${body}\n\n${block}` : block;
 		}
 
-		const tmpFile = `/tmp/claude-attribution-pr-body-${Date.now()}.md`;
+		const tmpFile = `/tmp/claude-attribution-pr-body-${Date.now()}-${process.pid}.md`;
 		await writeFile(tmpFile, newBody);
 		try {
 			await execFileAsync("gh", [

package/src/metrics/collect.ts

@@ -5,10 +5,11 @@
  *   collectMetrics(sessionIdArg?, repoRoot?) — gathers all data sources
  *   renderMetrics(data) — compact markdown for PR descriptions
  */
-import { readFile } from "fs/promises";
+import { readFile, readdir, stat } from "fs/promises";
 import { calculateCostUsd } from "../pricing.ts";
 import { existsSync } from "fs";
 import { resolve, join, relative } from "path";
+import { homedir } from "os";
 import { execFile } from "child_process";
 import { promisify } from "util";
 import { parseTranscript, type TranscriptResult } from "./transcript.ts";
@@ -155,15 +156,52 @@ async function readJsonlForSession(
 	return results;
 }
 
+/**
+ * Resolve the most recent Claude session ID for this repo.
+ *
+ * Strategy (in priority order):
+ *   1. Last entry in .claude/logs/tool-usage.jsonl (hooks were active — most precise)
+ *   2. Most recently modified session file in ~/.claude/projects/<repo-key>/
+ *      (Claude Code always writes transcripts, even without attribution hooks)
+ *
+ * Strategy 2 ensures that /metrics and /pr have full transcript data (cost, model
+ * table, tool counts) even when attribution was installed after the editing session.
+ */
 async function resolveSessionId(repoRoot: string): Promise<string | null> {
+	// Strategy 1: tool-usage.jsonl
 	const toolLog = join(repoRoot, ".claude", "logs", "tool-usage.jsonl");
-	if (!existsSync(toolLog)) return null;
-	const raw = await readFile(toolLog, "utf8");
-	const lines = raw.trim().split("\n").filter(Boolean);
-	const last = lines.at(-1);
-	if (!last) return null;
+	if (existsSync(toolLog)) {
+		try {
+			const raw = await readFile(toolLog, "utf8");
+			const last = raw.trim().split("\n").filter(Boolean).at(-1);
+			if (last) {
+				const id = (JSON.parse(last) as { session?: string }).session ?? null;
+				if (id && SESSION_ID_RE.test(id)) return id;
+			}
+		} catch {
+			// Fall through to strategy 2
+		}
+	}
+
+	// Strategy 2: most recently modified top-level session JSONL in ~/.claude/projects/<key>/
+	const projectKey = repoRoot.replace(/\//g, "-");
+	const transcriptDir = join(homedir(), ".claude", "projects", projectKey);
+	if (!existsSync(transcriptDir)) return null;
 	try {
-		return (JSON.parse(last) as { session?: string }).session ?? null;
+		const files = await readdir(transcriptDir);
+		const sessionFiles = files.filter(
+			(f) => f.endsWith(".jsonl") && SESSION_ID_RE.test(f.slice(0, -6)),
+		);
+		if (sessionFiles.length === 0) return null;
+		// Pick the most recently modified
+		const withMtimes = await Promise.all(
+			sessionFiles.map(async (f) => ({
+				id: f.slice(0, -6),
+				mtime: (await stat(join(transcriptDir, f))).mtimeMs,
+			})),
+		);
+		withMtimes.sort((a, b) => b.mtime - a.mtime);
+		return withMtimes[0]?.id ?? null;
 	} catch {
 		return null;
 	}
@@ -296,6 +334,26 @@ export async function collectMetrics(
 		toolCounts.set(e.tool, (toolCounts.get(e.tool) ?? 0) + 1);
 	}
 
+	// Fallback: if tool-usage.jsonl had no entries for this session (e.g. attribution was
+	// installed after the editing session, or --continue with only Bash calls), read tool
+	// counts from the session transcript instead. The transcript is written by Claude Code
+	// itself regardless of hook installation, so it always has the full tool call history.
+	if (
+		toolCounts.size === 0 &&
+		skillNames.length === 0 &&
+		transcript?.toolCounts
+	) {
+		for (const [tool, count] of Object.entries(transcript.toolCounts)) {
+			if (tool === "Skill") continue;
+			if (!BORING_TOOLS.has(tool)) {
+				toolCounts.set(tool, (toolCounts.get(tool) ?? 0) + count);
+			}
+		}
+		if (transcript.skillNames) {
+			skillNames.push(...transcript.skillNames);
+		}
+	}
+
 	// Agent counts (SubagentStart events only)
 	const agentCounts = new Map<string, number>();
 	for (const e of agentEntries.filter((e) => e.event === "SubagentStart")) {

package/src/metrics/transcript.ts

@@ -46,6 +46,10 @@ export interface TranscriptResult {
 	aiMinutes: number;
 	/** Minutes the human was active between Claude responses (>30s gaps, <15m). */
 	humanMinutes: number;
+	/** Per-tool invocation counts extracted from tool_use content blocks. */
+	toolCounts: Record<string, number>;
+	/** Skill names invoked (from Skill tool_use blocks with input.skill). */
+	skillNames: string[];
 }
 
 interface TranscriptEntry {
@@ -59,6 +63,11 @@ interface TranscriptEntry {
 			cache_creation_input_tokens?: number;
 			cache_read_input_tokens?: number;
 		};
+		content?: Array<{
+			type?: string;
+			name?: string;
+			input?: Record<string, unknown>;
+		}>;
 	};
 }
 
@@ -92,11 +101,15 @@ async function parseTranscriptFile(filePath: string): Promise<{
 	entries: TranscriptEntry[];
 	humanCount: number;
 	timedMessages: TimedMessage[];
+	toolCounts: Map<string, number>;
+	skillNames: string[];
 }> {
 	const raw = await readFile(filePath, "utf8");
 	const entries: TranscriptEntry[] = [];
 	let humanCount = 0;
 	const timedMessages: TimedMessage[] = [];
+	const toolCounts = new Map<string, number>();
+	const skillNames: string[] = [];
 
 	for (const line of raw.split("\n")) {
 		const trimmed = line.trim();
@@ -109,12 +122,24 @@ async function parseTranscriptFile(filePath: string): Promise<{
 				const ms = new Date(entry.timestamp).getTime();
 				if (!isNaN(ms)) timedMessages.push({ type: entry.type, ts: ms });
 			}
+			if (entry.type === "assistant") {
+				for (const block of entry.message?.content ?? []) {
+					if (block.type !== "tool_use" || !block.name) continue;
+					toolCounts.set(block.name, (toolCounts.get(block.name) ?? 0) + 1);
+					if (
+						block.name === "Skill" &&
+						typeof block.input?.skill === "string"
+					) {
+						skillNames.push(block.input.skill);
+					}
+				}
+			}
 		} catch {
 			// Skip malformed lines
 		}
 	}
 
-	return { entries, humanCount, timedMessages };
+	return { entries, humanCount, timedMessages, toolCounts, skillNames };
 }
 
 /**
@@ -222,16 +247,22 @@ export async function parseTranscript(
 		entries: mainEntries,
 		humanCount,
 		timedMessages,
+		toolCounts,
+		skillNames,
 	} = await parseTranscriptFile(mainFile);
 	const combined = aggregateEntries(mainEntries);
 
-	// Merge subagent transcripts (token counts only — exclude from time breakdown)
+	// Merge subagent transcripts (token counts + tool counts — exclude from time breakdown)
 	const subagentDir = join(transcriptDir, sessionId, "subagents");
 	if (existsSync(subagentDir)) {
 		for (const file of (await readdir(subagentDir)).filter((f) =>
 			f.endsWith(".jsonl"),
 		)) {
-			const { entries } = await parseTranscriptFile(join(subagentDir, file));
+			const {
+				entries,
+				toolCounts: subToolCounts,
+				skillNames: subSkillNames,
+			} = await parseTranscriptFile(join(subagentDir, file));
 			for (const [model, usage] of aggregateEntries(entries)) {
 				const existing = combined.get(model);
 				if (!existing) {
@@ -244,6 +275,10 @@ export async function parseTranscript(
 					existing.cacheReadTokens += usage.cacheReadTokens;
 				}
 			}
+			for (const [tool, count] of subToolCounts) {
+				toolCounts.set(tool, (toolCounts.get(tool) ?? 0) + count);
+			}
+			skillNames.push(...subSkillNames);
 		}
 	}
 
@@ -280,5 +315,7 @@ export async function parseTranscript(
 		activeMinutes: totalMinutes,
 		aiMinutes,
 		humanMinutes,
+		toolCounts: Object.fromEntries(toolCounts),
+		skillNames,
 	};
 }

package/src/setup/install.ts

@@ -304,13 +304,23 @@ async function main() {
 	const existingGitignore = existsSync(gitignorePath)
 		? await readFile(gitignorePath, "utf8")
 		: "";
+	const gitignoreEntries: string[] = [];
 	if (!existingGitignore.includes(".claude/logs")) {
+		gitignoreEntries.push(".claude/logs/");
+	}
+	if (!existingGitignore.includes("attribution-state/current-session")) {
+		gitignoreEntries.push(".claude/attribution-state/current-session");
+	}
+	if (!existingGitignore.includes("attribution-state/otel-context")) {
+		gitignoreEntries.push(".claude/attribution-state/otel-context.json");
+	}
+	if (gitignoreEntries.length > 0) {
 		const prefix = existingGitignore.endsWith("\n") ? "" : "\n";
 		await appendFile(
 			gitignorePath,
-			`${prefix}# claude-attribution tool usage logs\n.claude/logs/\n`,
+			`${prefix}# claude-attribution ephemeral state (do not commit)\n${gitignoreEntries.join("\n")}\n`,
 		);
-		console.log("✓ Added .claude/logs/ to .gitignore");
+		console.log(`✓ Added ${gitignoreEntries.length} entries to .gitignore`);
 	}
 
 	const settingsPath = join(claudeDir, "settings.json");
@@ -454,7 +464,7 @@ async function main() {
 		? ", .github/workflows/claude-attribution-export.yml"
 		: "";
 	console.log(
-		`Commit .claude/settings.json, .github/workflows/claude-attribution-pr.yml${exportNote} to share with the team.`,
+		`Commit these files to share with the team:\n  .claude/settings.json\n  .claude/commands/\n  .claude/attribution-state/baseline-initialized (if set)\n  .claude/attribution-state/installed-version\n  .github/workflows/claude-attribution-pr.yml${exportNote}`,
 	);
 }
 

package/src/setup/templates/claude-attribution-gha.yml

@@ -27,6 +27,11 @@ jobs:
       - name: Fetch attribution notes
         run: git fetch origin refs/notes/claude-attribution:refs/notes/claude-attribution || true
 
+      - name: Configure git identity for notes
+        run: |
+          git config user.email "claude-attribution[bot]@users.noreply.github.com"
+          git config user.name "claude-attribution[bot]"
+
       - uses: oven-sh/setup-bun@v2
 
       - name: Install claude-attribution