claude-attribution 1.8.0 → 1.9.4

package/src/__tests__/integration.test.ts

@@ -2,10 +2,14 @@ import { describe, expect, test } from "bun:test";
 import { mkdir, readFile, writeFile } from "fs/promises";
 import { join } from "path";
 import { saveCheckpoint } from "../attribution/checkpoint.ts";
-import type { AttributionResult } from "../attribution/differ.ts";
+import { hashLine, type AttributionResult } from "../attribution/differ.ts";
 import { NOTES_REF, writeNote } from "../attribution/git-notes.ts";
 import { pushNotesRef } from "../attribution/notes-sync.ts";
-import { writeMinimap, type MinimapResult } from "../attribution/minimap.ts";
+import {
+	hashSetToString,
+	writeMinimap,
+	type MinimapResult,
+} from "../attribution/minimap.ts";
 import { readInstalledRepoRegistry } from "../setup/installed-repos.ts";
 import {
 	CLI_BIN,
@@ -17,6 +21,7 @@ import {
 	initGitRepo,
 	readJson,
 	runCommand,
+	writeCopilotSession,
 	writeJsonl,
 	writeTranscript,
 } from "./integration-helpers.ts";
@@ -93,8 +98,9 @@ describe("integration", () => {
 				cwd: ctx.repo,
 				env: {
 					HOME: ctx.home,
-					COPILOT_CLI: "1",
-					COPILOT_CLI_BINARY_VERSION: "1.0.14",
+					COPILOT_CLI: "",
+					COPILOT_CLI_BINARY_VERSION: "",
+					ANTHROPIC_MODEL: "claude-sonnet-4-6",
 				},
 			});
 
@@ -116,9 +122,9 @@ describe("integration", () => {
 			expect(note.sessionMetrics?.humanPromptCount).toBe(1);
 			expect(note.sessionMetrics?.activeMinutes).toBe(2);
 			expect(note.assistantRuntime).toEqual({
-				vendor: "copilot",
-				client: "GitHub Copilot CLI",
-				clientVersion: "1.0.14",
+				vendor: "claude",
+				client: "Claude Code",
+				modelFamily: "claude-sonnet-4-6",
 			});
 		} finally {
 			await ctx.cleanup();
@@ -207,7 +213,389 @@ describe("integration", () => {
 			expect(metrics.stdout).toContain("**Skills:** /pr");
 			expect(metrics.stdout).toContain("**Agents:** code-review");
 			expect(metrics.stdout).toContain("**External tools:** WebSearch ×2");
-			expect(metrics.stdout).toContain("**Estimated cost:**");
+			expect(metrics.stdout).toContain("**Estimated cost:** unavailable");
+		} finally {
+			await ctx.cleanup();
+		}
+	});
+
+	test("metrics headline uses diff-scoped PR stats instead of full touched file totals", async () => {
+		const ctx = await createTempContext("claude-attribution-pr-diff");
+		try {
+			await initGitRepo(ctx.repo);
+			await runCommand("git", ["branch", "-M", "main"], { cwd: ctx.repo });
+
+			const remote = join(ctx.root, "origin.git");
+			await runCommand("git", ["init", "--bare", remote], { cwd: ctx.root });
+			await runCommand("git", ["remote", "add", "origin", remote], {
+				cwd: ctx.repo,
+			});
+
+			const baseContent =
+				Array.from({ length: 100 }, (_, i) => `line ${i + 1}`).join("\n") + "\n";
+			await writeFile(join(ctx.repo, "README.md"), baseContent);
+			await commitAll(ctx.repo, "initial");
+			const baseSha = await currentSha(ctx.repo);
+			await runCommand("git", ["push", "-u", "origin", "main"], { cwd: ctx.repo });
+
+			const baseMinimap: MinimapResult = {
+				commit: baseSha,
+				timestamp: "2026-03-01T10:00:00.000Z",
+				files: [
+					{
+						path: "README.md",
+						ai_hashes: "",
+						ai: 0,
+						human: 100,
+						total: 100,
+						pctAi: 0,
+					},
+				],
+				totals: { ai: 0, human: 100, total: 100, pctAi: 0 },
+			};
+			await writeMinimap(baseMinimap, ctx.repo, baseSha);
+
+			await runCommand("git", ["checkout", "-b", "feature/diff-metrics"], {
+				cwd: ctx.repo,
+			});
+			await writeFile(
+				join(ctx.repo, "README.md"),
+				`${baseContent}AI-added line 1\nAI-added line 2\n`,
+			);
+			await commitAll(ctx.repo, "feature work");
+			const headSha = await currentSha(ctx.repo);
+
+			const note: AttributionResult = {
+				commit: headSha,
+				session: "session-pr-diff-1",
+				branch: "feature/diff-metrics",
+				timestamp: "2026-03-01T10:05:00.000Z",
+				files: [
+					{
+						path: "README.md",
+						ai: 2,
+						human: 100,
+						mixed: 0,
+						total: 102,
+						pctAi: 2,
+					},
+				],
+				totals: { ai: 2, human: 100, mixed: 0, total: 102, pctAi: 2 },
+			};
+			await writeNote(note, ctx.repo, headSha);
+
+			const aiHashes = hashSetToString(
+				new Set([hashLine("AI-added line 1"), hashLine("AI-added line 2")]),
+			);
+			const headMinimap: MinimapResult = {
+				commit: headSha,
+				timestamp: "2026-03-01T10:05:00.000Z",
+				files: [
+					{
+						path: "README.md",
+						ai_hashes: aiHashes,
+						ai: 2,
+						human: 100,
+						total: 102,
+						pctAi: 2,
+					},
+				],
+				totals: { ai: 2, human: 100, total: 102, pctAi: 2 },
+			};
+			await writeMinimap(headMinimap, ctx.repo, headSha);
+
+			const metrics = await runCommand(CLI_BIN, ["metrics"], {
+				cwd: ctx.repo,
+				env: { HOME: ctx.home },
+			});
+
+			expect(metrics.stdout).toContain(
+				"**This PR:** 2 lines changed (2% of codebase) · 100% AI edits · 2 AI-attributed changed lines",
+			);
+			expect(metrics.stdout).not.toContain("**This PR:** 102 lines changed");
+		} finally {
+			await ctx.cleanup();
+		}
+	});
+
+	test("post-commit falls back to Copilot session-state metadata", async () => {
+		const ctx = await createTempContext("copilot-attribution-commit");
+		try {
+			await initGitRepo(ctx.repo);
+			const filePath = join(ctx.repo, "src.ts");
+			await writeFile(filePath, "const value = 1;\n");
+			await commitAll(ctx.repo, "initial");
+
+			await writeFile(filePath, "const value = 1;\nconst nextValue = 2;\n");
+			await commitAll(ctx.repo, "feature work");
+
+			const branch = (
+				await runCommand("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
+					cwd: ctx.repo,
+				})
+			).stdout.trim();
+			const sessionId = "copilot-session-commit-1";
+			await writeCopilotSession(ctx.home, sessionId, [
+				{
+					type: "session.start",
+					timestamp: "2026-04-01T10:00:00.000Z",
+					data: {
+						context: {
+							cwd: ctx.repo,
+							gitRoot: ctx.repo,
+							branch,
+						},
+					},
+				},
+				{
+					type: "user.message",
+					timestamp: "2026-04-01T10:00:00.000Z",
+					data: { content: "start work" },
+				},
+				{
+					type: "tool.execution_start",
+					timestamp: "2026-04-01T10:00:05.000Z",
+					data: { toolName: "web_search" },
+				},
+				{
+					type: "tool.execution_complete",
+					timestamp: "2026-04-01T10:01:00.000Z",
+					data: { model: "gpt-5.4" },
+				},
+				{
+					type: "assistant.message",
+					timestamp: "2026-04-01T10:01:00.000Z",
+					data: { outputTokens: 240 },
+				},
+				{
+					type: "assistant.turn_end",
+					timestamp: "2026-04-01T10:01:00.000Z",
+				},
+			]);
+
+			await runCommand(CLI_BIN, ["hook", "post-commit"], {
+				cwd: ctx.repo,
+				env: {
+					HOME: ctx.home,
+					COPILOT_CLI: "1",
+					COPILOT_CLI_BINARY_VERSION: "1.0.15",
+				},
+			});
+
+			const note = JSON.parse(
+				(
+					await runCommand(
+						"git",
+						["notes", "--ref", "claude-attribution", "show", "HEAD"],
+						{ cwd: ctx.repo },
+					)
+				).stdout,
+			) as AttributionResult;
+
+			expect(note.session).toBe(sessionId);
+			expect(note.totals.ai).toBeGreaterThan(0);
+			expect(note.modelUsage).toEqual([
+				{
+					modelFull: "gpt-5.4",
+					modelShort: "Unknown",
+					calls: 1,
+					inputTokens: 0,
+					outputTokens: 240,
+					cacheCreationTokens: 0,
+					cacheReadTokens: 0,
+				},
+			]);
+			expect(note.sessionMetrics?.toolCounts).toEqual({ web_search: 1 });
+			expect(note.sessionMetrics?.humanPromptCount).toBe(1);
+			expect(note.assistantRuntime).toEqual({
+				vendor: "copilot",
+				client: "GitHub Copilot CLI",
+				clientVersion: "1.0.15",
+				modelFamily: "gpt-5.4",
+			});
+		} finally {
+			await ctx.cleanup();
+		}
+	});
+
+	test("Copilot sessions win over stale Claude session markers and transcripts", async () => {
+		const ctx = await createTempContext("copilot-session-precedence");
+		try {
+			await initGitRepo(ctx.repo);
+			const filePath = join(ctx.repo, "src.ts");
+			await writeFile(filePath, "const value = 1;\n");
+			await commitAll(ctx.repo, "initial");
+
+			const staleClaudeSession = "claude-session-stale-1";
+			await mkdir(join(ctx.repo, ".claude", "attribution-state"), {
+				recursive: true,
+			});
+			await writeFile(
+				join(ctx.repo, ".claude", "attribution-state", "current-session"),
+				staleClaudeSession,
+			);
+			await writeJsonl(join(ctx.repo, ".claude", "logs", "tool-usage.jsonl"), [
+				{
+					timestamp: "2026-03-30T01:09:44.678Z",
+					session: staleClaudeSession,
+					tool: "Bash",
+				},
+			]);
+			await writeTranscript(ctx.home, ctx.repo, staleClaudeSession, [
+				{
+					type: "user",
+					timestamp: "2026-03-30T01:00:00.000Z",
+				},
+				{
+					type: "assistant",
+					timestamp: "2026-03-30T01:01:00.000Z",
+					message: {
+						model: "claude-sonnet-4-6",
+						usage: {
+							input_tokens: 2000,
+							output_tokens: 500,
+							cache_creation_input_tokens: 100,
+							cache_read_input_tokens: 800,
+						},
+					},
+				},
+			]);
+
+			await writeFile(filePath, "const value = 1;\nconst nextValue = 2;\n");
+			await commitAll(ctx.repo, "feature work");
+
+			const branch = (
+				await runCommand("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
+					cwd: ctx.repo,
+				})
+			).stdout.trim();
+			const copilotSession = "copilot-session-precedence-1";
+			await writeCopilotSession(ctx.home, copilotSession, [
+				{
+					type: "session.start",
+					timestamp: "2026-04-01T10:00:00.000Z",
+					data: {
+						context: {
+							cwd: ctx.repo,
+							gitRoot: ctx.repo,
+							branch,
+						},
+					},
+				},
+				{
+					type: "user.message",
+					timestamp: "2026-04-01T10:00:00.000Z",
+					data: { content: "start work" },
+				},
+				{
+					type: "tool.execution_complete",
+					timestamp: "2026-04-01T10:01:00.000Z",
+					data: { model: "gpt-5.4" },
+				},
+				{
+					type: "assistant.message",
+					timestamp: "2026-04-01T10:01:00.000Z",
+					data: { outputTokens: 240 },
+				},
+				{
+					type: "assistant.turn_end",
+					timestamp: "2026-04-01T10:01:00.000Z",
+				},
+			]);
+
+			await runCommand(CLI_BIN, ["hook", "post-commit"], {
+				cwd: ctx.repo,
+				env: {
+					HOME: ctx.home,
+					COPILOT_CLI: "1",
+					COPILOT_CLI_BINARY_VERSION: "1.0.15",
+				},
+			});
+
+			const note = JSON.parse(
+				(
+					await runCommand(
+						"git",
+						["notes", "--ref", "claude-attribution", "show", "HEAD"],
+						{ cwd: ctx.repo },
+					)
+				).stdout,
+			) as AttributionResult;
+
+			expect(note.session).toBe(copilotSession);
+			expect(note.assistantRuntime).toEqual({
+				vendor: "copilot",
+				client: "GitHub Copilot CLI",
+				clientVersion: "1.0.15",
+				modelFamily: "gpt-5.4",
+			});
+			expect(note.modelUsage).toEqual([
+				{
+					modelFull: "gpt-5.4",
+					modelShort: "Unknown",
+					calls: 1,
+					inputTokens: 0,
+					outputTokens: 240,
+					cacheCreationTokens: 0,
+					cacheReadTokens: 0,
+				},
+			]);
+
+			const metrics = await runCommand(CLI_BIN, ["metrics"], {
+				cwd: ctx.repo,
+				env: {
+					HOME: ctx.home,
+					COPILOT_CLI: "1",
+					COPILOT_CLI_BINARY_VERSION: "1.0.15",
+				},
+			});
+
+			expect(metrics.stdout).toContain(
+				"**Assistant runtime:** GitHub Copilot CLI (v1.0.15 · gpt-5.4)",
+			);
+			expect(metrics.stdout).toContain("| Model | Calls | Known Tokens |");
+			expect(metrics.stdout).toContain("| gpt-5.4 | 1 | 240 |");
+			expect(metrics.stdout).toContain("**Estimated cost:** unavailable");
+			expect(metrics.stdout).not.toContain("claude-sonnet-4-6");
+			expect(metrics.stdout).not.toContain("**Estimated cost:** ~$");
+		} finally {
+			await ctx.cleanup();
+		}
+	});
+
+	test("metrics synthesizes hosted Copilot bot commits without local notes", async () => {
+		const ctx = await createTempContext("copilot-hosted-metrics");
+		try {
+			await initGitRepo(ctx.repo);
+			await writeFile(join(ctx.repo, "baseline.ts"), "export const baseline = true;\n");
+			await commitAll(ctx.repo, "initial");
+			await runCommand("git", ["config", "user.name", "copilot[bot]"], {
+				cwd: ctx.repo,
+			});
+			await runCommand(
+				"git",
+				["config", "user.email", "000000+copilot[bot]@users.noreply.github.com"],
+				{ cwd: ctx.repo },
+			);
+			await writeFile(
+				join(ctx.repo, "agent.ts"),
+				"export const generated = true;\n",
+			);
+			await commitAll(
+				ctx.repo,
+				"feat: hosted change\n\nCo-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>",
+			);
+
+			const metrics = await runCommand(CLI_BIN, ["metrics"], {
+				cwd: ctx.repo,
+				env: { HOME: ctx.home },
+			});
+
+			expect(metrics.stdout).toContain("## AI Coding Metrics");
+			expect(metrics.stdout).toContain("**AI contribution: ~50%**");
+			expect(metrics.stdout).toContain("**Assistant runtime:** GitHub Copilot");
+			expect(metrics.stdout).toContain("`agent.ts` — 50% AI (1 lines)");
+			expect(metrics.stdout).not.toContain("**Estimated cost:**");
 		} finally {
 			await ctx.cleanup();
 		}

package/src/__tests__/minimap-bulk.test.ts

@@ -47,6 +47,23 @@ await ctx.cleanup();
 }
 });
 
+test("all-AI baseline records blank lines as AI-preserving hashes", async () => {
+const ctx = await createTempContext("claude-attribution-minimap-blank-carry");
+try {
+await initGitRepo(ctx.repo);
+await writeFile(join(ctx.repo, "doc.md"), "alpha\n\nbeta\n");
+await runCommand("git", ["add", "."], { cwd: ctx.repo });
+await runCommand("git", ["commit", "-m", "baseline"], { cwd: ctx.repo });
+
+const baseline = await buildAllAiMinimap(ctx.repo);
+const prevEntry = baseline.files.find((file) => file.path === "doc.md");
+expect(prevEntry).toMatchObject({ ai: 3, human: 0, total: 3, pctAi: 100 });
+expect(prevEntry?.ai_hashes.length).toBeGreaterThanOrEqual(16);
+} finally {
+await ctx.cleanup();
+}
+});
+
 test("marks only recently changed files as AI in ai-since minimaps", async () => {
 const ctx = await createTempContext("claude-attribution-minimap-ai-since");
 try {

package/src/__tests__/minimap.test.ts

@@ -99,7 +99,7 @@ describe("computeMinimapFile", () => {
 		expect(hashSetFromString(result.ai_hashes).has(hash)).toBe(false);
 	});
 
-	test("blank line always human (never in ai_hashes)", () => {
+	test("blank line stays AI when the blank-line marker is present", () => {
 		const aiHash = hashLine("");
 		const result = computeMinimapFile(
 			"foo.ts",
@@ -107,12 +107,12 @@ describe("computeMinimapFile", () => {
 			new Set([aiHash]),
 			new Set([aiHash]),
 		);
-		expect(result.ai).toBe(0);
-		expect(result.human).toBe(1);
-		expect(result.ai_hashes).toBe("");
+		expect(result.ai).toBe(1);
+		expect(result.human).toBe(0);
+		expect(result.ai_hashes).toBe(aiHash);
 	});
 
-	test("whitespace-only line treated as blank (always human)", () => {
+	test("whitespace-only line treated as blank and can carry AI attribution", () => {
 		const line = "   ";
 		const aiHash = hashLine(line);
 		const result = computeMinimapFile(
@@ -121,8 +121,8 @@ describe("computeMinimapFile", () => {
 			new Set([aiHash]),
 			new Set([aiHash]),
 		);
-		expect(result.ai).toBe(0);
-		expect(result.human).toBe(1);
+		expect(result.ai).toBe(1);
+		expect(result.human).toBe(0);
 	});
 
 	test("MIXED line — not in currentAiHashes → human even if in prevAiHashSet", () => {

package/src/__tests__/runtime.test.ts

@@ -15,11 +15,22 @@ describe("detectAssistantRuntime", () => {
 		});
 	});
 
-	test("falls back to Claude runtime from Anthropic model env", () => {
+	test("detects Claude runtime without treating alias defaults as the active model", () => {
 		expect(
 			detectAssistantRuntime({
 				ANTHROPIC_DEFAULT_SONNET_MODEL: "claude-sonnet-4-6",
 			}),
+		).toEqual({
+			vendor: "claude",
+			client: "Claude Code",
+		});
+	});
+
+	test("uses ANTHROPIC_MODEL when the active model is explicit", () => {
+		expect(
+			detectAssistantRuntime({
+				ANTHROPIC_MODEL: "claude-sonnet-4-6",
+			}),
 		).toEqual({
 			vendor: "claude",
 			client: "Claude Code",

package/src/__tests__/transcript.test.ts

@@ -0,0 +1,61 @@
+import { describe, expect, test } from "bun:test";
+import { createTempContext, writeTranscript } from "./integration-helpers.ts";
+import { parseTranscript } from "../metrics/transcript.ts";
+
+describe("parseTranscript", () => {
+	test("counts real user prompts and ignores tool_result rows", async () => {
+		const ctx = await createTempContext("transcript-parser");
+		const originalHome = process.env.HOME;
+		try {
+			process.env.HOME = ctx.home;
+			const repo = "/Users/alice.smith/Code/my-repo";
+			const sessionId = "session-1";
+			await writeTranscript(ctx.home, repo, sessionId, [
+				{
+					type: "user",
+					timestamp: "2026-04-01T10:00:00.000Z",
+					message: { role: "user", content: "Add a helper" },
+				},
+				{
+					type: "assistant",
+					timestamp: "2026-04-01T10:00:05.000Z",
+					message: {
+						role: "assistant",
+						model: "claude-sonnet-4-6",
+						usage: { input_tokens: 10, output_tokens: 5 },
+						content: [{ type: "tool_use", name: "WebSearch", input: {} }],
+					},
+				},
+				{
+					type: "user",
+					timestamp: "2026-04-01T10:00:07.000Z",
+					toolUseResult: { tool: "WebSearch" },
+					message: {
+						role: "user",
+						content: [{ type: "tool_result" }],
+					},
+				},
+				{
+					type: "assistant",
+					timestamp: "2026-04-01T10:00:12.000Z",
+					message: {
+						role: "assistant",
+						model: "claude-sonnet-4-6",
+						usage: { input_tokens: 12, output_tokens: 8 },
+						content: [{ type: "text" }],
+					},
+				},
+			]);
+
+			const result = await parseTranscript(sessionId, repo);
+			expect(result).not.toBeNull();
+			expect(result?.humanPromptCount).toBe(1);
+			expect(result?.toolCounts).toEqual({ WebSearch: 1 });
+			expect(result?.totals.totalCalls).toBe(2);
+			expect(result?.aiMinutes).toBe(0);
+		} finally {
+			process.env.HOME = originalHome;
+			await ctx.cleanup();
+		}
+	});
+});