claude-attribution 1.6.0 → 1.8.0

package/src/__tests__/integration.test.ts

@@ -0,0 +1,501 @@
+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 { NOTES_REF, writeNote } from "../attribution/git-notes.ts";
+import { pushNotesRef } from "../attribution/notes-sync.ts";
+import { writeMinimap, type MinimapResult } from "../attribution/minimap.ts";
+import { readInstalledRepoRegistry } from "../setup/installed-repos.ts";
+import {
+	CLI_BIN,
+	configureGitIdentity,
+	REPO_ROOT,
+	commitAll,
+	createTempContext,
+	currentSha,
+	initGitRepo,
+	readJson,
+	runCommand,
+	writeJsonl,
+	writeTranscript,
+} from "./integration-helpers.ts";
+
+describe("integration", () => {
+	test("post-commit writes durable note metadata", async () => {
+		const ctx = await createTempContext("claude-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");
+
+			const sessionId = "session-commit-1";
+			await mkdir(join(ctx.repo, ".claude", "attribution-state"), {
+				recursive: true,
+			});
+			await writeFile(
+				join(ctx.repo, ".claude", "attribution-state", "current-session"),
+				sessionId,
+			);
+			await saveCheckpoint(sessionId, filePath, "before");
+			await writeFile(filePath, "const value = 2;\nconst nextValue = 3;\n");
+			await saveCheckpoint(sessionId, filePath, "after");
+
+			await writeJsonl(join(ctx.repo, ".claude", "logs", "tool-usage.jsonl"), [
+				{
+					timestamp: "2026-03-01T10:00:00.000Z",
+					session: sessionId,
+					tool: "Bash",
+				},
+			]);
+			await writeJsonl(
+				join(ctx.repo, ".claude", "logs", "agent-activity.jsonl"),
+				[
+					{
+						timestamp: "2026-03-01T10:02:00.000Z",
+						session: sessionId,
+						event: "SubagentStart",
+						subagentType: "code-review",
+					},
+				],
+			);
+			await writeTranscript(ctx.home, ctx.repo, sessionId, [
+				{
+					type: "human",
+					timestamp: "2026-03-01T10:00:00.000Z",
+				},
+				{
+					type: "assistant",
+					timestamp: "2026-03-01T10:02:00.000Z",
+					message: {
+						model: "claude-sonnet-4-6",
+						usage: {
+							input_tokens: 1200,
+							output_tokens: 300,
+							cache_creation_input_tokens: 50,
+							cache_read_input_tokens: 400,
+						},
+						content: [
+							{ type: "tool_use", name: "WebSearch", input: {} },
+							{
+								type: "tool_use",
+								name: "Skill",
+								input: { skill: "pr" },
+							},
+						],
+					},
+				},
+			]);
+
+			await commitAll(ctx.repo, "feature work");
+			await runCommand(CLI_BIN, ["hook", "post-commit"], {
+				cwd: ctx.repo,
+				env: {
+					HOME: ctx.home,
+					COPILOT_CLI: "1",
+					COPILOT_CLI_BINARY_VERSION: "1.0.14",
+				},
+			});
+
+			const note = JSON.parse(
+				(
+					await runCommand(
+						"git",
+						["notes", "--ref", "claude-attribution", "show", "HEAD"],
+						{ cwd: ctx.repo },
+					)
+				).stdout,
+			) as AttributionResult;
+
+			expect(note.modelUsage?.[0]?.modelFull).toBe("claude-sonnet-4-6");
+			expect(note.modelUsage?.[0]?.calls).toBe(1);
+			expect(note.sessionMetrics?.toolCounts).toEqual({ WebSearch: 1 });
+			expect(note.sessionMetrics?.skillNames).toEqual(["pr"]);
+			expect(note.sessionMetrics?.agentCounts).toEqual({ "code-review": 1 });
+			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",
+			});
+		} finally {
+			await ctx.cleanup();
+		}
+	});
+
+	test("metrics renders from note-backed data without local logs", async () => {
+		const ctx = await createTempContext("claude-attribution-metrics");
+		try {
+			await initGitRepo(ctx.repo);
+			await writeFile(join(ctx.repo, "app.ts"), "export const answer = 42;\n");
+			await commitAll(ctx.repo, "initial");
+
+			const sha = await currentSha(ctx.repo);
+			const note: AttributionResult = {
+				commit: sha,
+				session: "session-metrics-1",
+				branch: "main",
+				timestamp: "2026-03-01T10:00:00.000Z",
+				files: [
+					{
+						path: "app.ts",
+						ai: 1,
+						human: 0,
+						mixed: 0,
+						total: 1,
+						pctAi: 100,
+					},
+				],
+				totals: { ai: 1, human: 0, mixed: 0, total: 1, pctAi: 100 },
+				modelUsage: [
+					{
+						modelFull: "claude-sonnet-4-6",
+						modelShort: "Sonnet",
+						calls: 2,
+						inputTokens: 2000,
+						outputTokens: 500,
+						cacheCreationTokens: 100,
+						cacheReadTokens: 800,
+					},
+				],
+				sessionMetrics: {
+					toolCounts: { WebSearch: 2 },
+					agentCounts: { "code-review": 1 },
+					skillNames: ["pr"],
+					humanPromptCount: 3,
+					activeMinutes: 15,
+					aiMinutes: 10,
+					humanMinutes: 5,
+				},
+				assistantRuntime: {
+					vendor: "copilot",
+					client: "GitHub Copilot CLI",
+					clientVersion: "1.0.14",
+				},
+			};
+			await writeNote(note, ctx.repo, sha);
+			const minimap: MinimapResult = {
+				commit: sha,
+				timestamp: "2026-03-01T10:00:00.000Z",
+				files: [
+					{
+						path: "app.ts",
+						ai_hashes: "abc123abc123abc1",
+						ai: 1,
+						human: 0,
+						total: 1,
+						pctAi: 100,
+					},
+				],
+				totals: { ai: 1, human: 0, total: 1, pctAi: 100 },
+			};
+			await writeMinimap(minimap, ctx.repo, sha);
+
+			const metrics = await runCommand(CLI_BIN, ["metrics"], {
+				cwd: ctx.repo,
+				env: { HOME: ctx.home },
+			});
+
+			expect(metrics.stdout).toContain("**Codebase: ~100% AI**");
+			expect(metrics.stdout).toContain("**This PR:** 1 lines changed");
+			expect(metrics.stdout).toContain("**Session:** 3 prompts · 15m total (10m AI · 5m human)");
+			expect(metrics.stdout).toContain(
+				"**Assistant runtime:** GitHub Copilot CLI (v1.0.14)",
+			);
+			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:**");
+		} finally {
+			await ctx.cleanup();
+		}
+	});
+
+	test("metrics stays backward-compatible with older notes", async () => {
+		const ctx = await createTempContext("claude-attribution-backcompat");
+		try {
+			await initGitRepo(ctx.repo);
+			await writeFile(join(ctx.repo, "legacy.ts"), "export const oldValue = 1;\n");
+			await commitAll(ctx.repo, "initial");
+			const sha = await currentSha(ctx.repo);
+
+			await writeNote(
+				{
+					commit: sha,
+					session: "legacy-session",
+					branch: "main",
+					timestamp: "2026-03-01T10:00:00.000Z",
+					files: [
+						{
+							path: "legacy.ts",
+							ai: 1,
+							human: 0,
+							mixed: 0,
+							total: 1,
+							pctAi: 100,
+						},
+					],
+					totals: { ai: 1, human: 0, mixed: 0, total: 1, pctAi: 100 },
+				},
+				ctx.repo,
+				sha,
+			);
+			await writeMinimap(
+				{
+					commit: sha,
+					timestamp: "2026-03-01T10:00:00.000Z",
+					files: [
+						{
+							path: "legacy.ts",
+							ai_hashes: "abc123abc123abc1",
+							ai: 1,
+							human: 0,
+							total: 1,
+							pctAi: 100,
+						},
+					],
+					totals: { ai: 1, human: 0, total: 1, pctAi: 100 },
+				},
+				ctx.repo,
+				sha,
+			);
+
+			const metrics = await runCommand(CLI_BIN, ["metrics"], {
+				cwd: ctx.repo,
+				env: { HOME: ctx.home },
+			});
+
+			expect(metrics.stdout).toContain("**Codebase: ~100% AI**");
+			expect(metrics.stdout).toContain("`legacy.ts` — 100% AI (1 lines)");
+			expect(metrics.stdout).not.toContain("Assistant runtime:");
+		} finally {
+			await ctx.cleanup();
+		}
+	});
+
+	test("minimap preserves AI attribution across renames", async () => {
+		const ctx = await createTempContext("claude-attribution-rename");
+		try {
+			await initGitRepo(ctx.repo);
+			await writeFile(join(ctx.repo, "a.ts"), "export const renamed = true;\n");
+			await commitAll(ctx.repo, "initial");
+			await runCommand(CLI_BIN, ["init", "--ai"], {
+				cwd: ctx.repo,
+				env: { HOME: ctx.home },
+			});
+
+			await runCommand("git", ["mv", "a.ts", "b.ts"], { cwd: ctx.repo });
+			await commitAll(ctx.repo, "rename file");
+			await runCommand(CLI_BIN, ["hook", "post-commit"], {
+				cwd: ctx.repo,
+				env: { HOME: ctx.home },
+			});
+
+			const minimap = JSON.parse(
+				(
+					await runCommand(
+						"git",
+						["notes", "--ref", "refs/notes/claude-attribution-map", "show", "HEAD"],
+						{ cwd: ctx.repo },
+					)
+				).stdout,
+			) as MinimapResult;
+			const renamed = minimap.files.find((file: MinimapResult["files"][number]) =>
+				file.path === "b.ts",
+			);
+			expect(renamed).toBeDefined();
+			expect(renamed?.ai).toBe(1);
+			expect(renamed?.human).toBe(1);
+		} finally {
+			await ctx.cleanup();
+		}
+	});
+
+	test("notes sync recovers from remote ref rejection", async () => {
+		const rootCtx = await createTempContext("claude-attribution-notes-sync");
+		try {
+			const remote = join(rootCtx.root, "remote.git");
+			await runCommand("git", ["init", "--bare", remote]);
+
+			const source = join(rootCtx.root, "source");
+			await mkdir(source, { recursive: true });
+			await initGitRepo(source);
+			await writeFile(join(source, "app.ts"), "export const version = 1;\n");
+			await commitAll(source, "commit a");
+			await writeFile(join(source, "app.ts"), "export const version = 2;\n");
+			await commitAll(source, "commit b");
+			await runCommand("git", ["branch", "-M", "main"], { cwd: source });
+			await runCommand("git", ["remote", "add", "origin", remote], {
+				cwd: source,
+			});
+			await runCommand("git", ["push", "-u", "origin", "main"], {
+				cwd: source,
+			});
+
+			const repo1 = join(rootCtx.root, "repo1");
+			const repo2 = join(rootCtx.root, "repo2");
+			await runCommand("git", ["clone", remote, repo1]);
+			await runCommand("git", ["clone", remote, repo2]);
+			await configureGitIdentity(repo1);
+			await configureGitIdentity(repo2);
+			await runCommand("git", ["checkout", "main"], { cwd: repo1 });
+			await runCommand("git", ["checkout", "main"], { cwd: repo2 });
+
+			const commitA = (
+				await runCommand("git", ["rev-list", "--max-parents=0", "HEAD"], {
+					cwd: repo1,
+				})
+			).stdout.trim();
+			const commitB = (
+				await runCommand("git", ["rev-parse", "HEAD"], { cwd: repo2 })
+			).stdout.trim();
+
+			await writeNote(
+				{
+					commit: commitA,
+					session: null,
+					branch: "main",
+					timestamp: "2026-03-01T10:00:00.000Z",
+					files: [],
+					totals: { ai: 0, human: 0, mixed: 0, total: 0, pctAi: 0 },
+				},
+				repo1,
+				commitA,
+			);
+			await pushNotesRef(repo1, NOTES_REF);
+
+			await writeNote(
+				{
+					commit: commitB,
+					session: null,
+					branch: "main",
+					timestamp: "2026-03-01T10:05:00.000Z",
+					files: [],
+					totals: { ai: 0, human: 0, mixed: 0, total: 0, pctAi: 0 },
+				},
+				repo2,
+				commitB,
+			);
+			await pushNotesRef(repo2, NOTES_REF);
+
+			await runCommand("git", ["fetch", "origin", `${NOTES_REF}:${NOTES_REF}`], {
+				cwd: repo1,
+			});
+			const listed = (
+				await runCommand(
+					"git",
+					["notes", "--ref", "claude-attribution", "list"],
+					{ cwd: repo1 },
+				)
+			).stdout;
+			expect(listed).toContain(commitA);
+			expect(listed).toContain(commitB);
+		} finally {
+			await rootCtx.cleanup();
+		}
+	});
+
+	test("install and uninstall update hooks and remove legacy refspecs", async () => {
+		const ctx = await createTempContext("claude-attribution-install");
+		try {
+			await initGitRepo(ctx.repo);
+			await writeFile(join(ctx.repo, "README.md"), "test repo\n");
+			await commitAll(ctx.repo, "initial");
+
+			const remote = join(ctx.root, "remote.git");
+			await runCommand("git", ["init", "--bare", remote]);
+			await runCommand("git", ["remote", "add", "origin", remote], {
+				cwd: ctx.repo,
+			});
+			await runCommand(
+				"git",
+				[
+					"config",
+					"--add",
+					"remote.origin.push",
+					"refs/notes/claude-attribution:refs/notes/claude-attribution",
+				],
+				{ cwd: ctx.repo },
+			);
+			await runCommand(
+				"git",
+				[
+					"config",
+					"--add",
+					"remote.origin.push",
+					"refs/notes/claude-attribution-map:refs/notes/claude-attribution-map",
+				],
+				{ cwd: ctx.repo },
+			);
+
+			await runCommand(CLI_BIN, ["install", ctx.repo], {
+				cwd: REPO_ROOT,
+				env: { HOME: ctx.home },
+			});
+
+			const settings = (await readJson(
+				join(ctx.repo, ".claude", "settings.json"),
+			)) as { hooks?: { PostToolUse?: Array<{ hooks?: Array<{ command?: string }> }> } };
+			const postToolCommands =
+				settings.hooks?.PostToolUse?.flatMap((entry) =>
+					entry.hooks?.map((hook) => hook.command ?? "") ?? [],
+				) ?? [];
+			const postCommitHook = await readFile(
+				join(ctx.repo, ".git", "hooks", "post-commit"),
+				"utf8",
+			);
+			const refspecsAfterInstall = (
+				await runCommand(
+					"git",
+					["config", "--get-all", "remote.origin.push"],
+					{ cwd: ctx.repo, allowFailure: true },
+				)
+			).stdout;
+			const installedReposAfterInstall = await readInstalledRepoRegistry(ctx.home);
+
+			expect(postToolCommands.join("\n")).toContain(
+				"claude-attribution hook post-tool-use",
+			);
+			expect(postCommitHook).toContain("claude-attribution hook post-commit");
+			expect(refspecsAfterInstall).not.toContain("refs/notes/claude-attribution");
+			expect(installedReposAfterInstall.map((record) => record.path)).toContain(
+				ctx.repo,
+			);
+
+			await runCommand(CLI_BIN, ["uninstall", ctx.repo], {
+				cwd: REPO_ROOT,
+				env: { HOME: ctx.home },
+			});
+
+			const refspecsAfterUninstall = (
+				await runCommand(
+					"git",
+					["config", "--get-all", "remote.origin.push"],
+					{ cwd: ctx.repo, allowFailure: true },
+				)
+			).stdout;
+			const settingsAfter = await readFile(
+				join(ctx.repo, ".claude", "settings.json"),
+				"utf8",
+			);
+			const postCommitAfter = await readFile(
+				join(ctx.repo, ".git", "hooks", "post-commit"),
+				"utf8",
+			).catch(() => "");
+			const installedReposAfterUninstall = await readInstalledRepoRegistry(
+				ctx.home,
+			);
+
+			expect(refspecsAfterUninstall).not.toContain("refs/notes/claude-attribution");
+			expect(settingsAfter).not.toContain("claude-attribution hook post-tool-use");
+			expect(postCommitAfter).not.toContain("claude-attribution");
+			expect(installedReposAfterUninstall.map((record) => record.path)).not.toContain(
+				ctx.repo,
+			);
+		} finally {
+			await ctx.cleanup();
+		}
+	});
+});

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

@@ -0,0 +1,88 @@
+import { describe, expect, test } from "bun:test";
+import { writeFile } from "fs/promises";
+import { join } from "path";
+import {
+buildAiSinceMinimap,
+buildAllAiMinimap,
+listMinimapNotes,
+readMinimap,
+writeMinimap,
+} from "../attribution/minimap.ts";
+import {
+createTempContext,
+currentSha,
+initGitRepo,
+runCommand,
+} from "./integration-helpers.ts";
+
+describe("minimap bulk helpers", () => {
+test("builds, writes, and reads all-AI minimaps", async () => {
+const ctx = await createTempContext("claude-attribution-minimap-all-ai");
+try {
+await initGitRepo(ctx.repo);
+await writeFile(join(ctx.repo, "ai.txt"), "alpha");
+await writeFile(join(ctx.repo, "keep.txt"), "beta");
+await writeFile(join(ctx.repo, "binary.bin"), Buffer.from([0, 1, 2, 3]));
+await runCommand("git", ["add", "."], { cwd: ctx.repo });
+await runCommand("git", ["commit", "-m", "initial"], { cwd: ctx.repo });
+const sha = await currentSha(ctx.repo);
+
+expect(await readMinimap(ctx.repo, sha)).toBeNull();
+expect(await listMinimapNotes(ctx.repo)).toEqual([]);
+
+const result = await buildAllAiMinimap(ctx.repo);
+expect(result.commit).toBe(sha);
+expect(result.files.map((file) => file.path).sort()).toEqual([
+"ai.txt",
+"keep.txt",
+]);
+expect(result.totals).toMatchObject({ ai: 2, human: 0, total: 2, pctAi: 100 });
+
+await writeMinimap(result, ctx.repo, sha);
+const stored = await readMinimap(ctx.repo, sha);
+expect(stored?.totals).toEqual(result.totals);
+expect(await listMinimapNotes(ctx.repo)).toEqual([sha]);
+} 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 {
+await initGitRepo(ctx.repo);
+await writeFile(join(ctx.repo, "changed.txt"), "before");
+await writeFile(join(ctx.repo, "unchanged.txt"), "steady");
+await runCommand("git", ["add", "."], { cwd: ctx.repo });
+await runCommand("git", ["commit", "-m", "baseline"], {
+cwd: ctx.repo,
+env: {
+GIT_AUTHOR_DATE: "2020-01-01T00:00:00Z",
+GIT_COMMITTER_DATE: "2020-01-01T00:00:00Z",
+},
+});
+
+await writeFile(join(ctx.repo, "changed.txt"), "after");
+await writeFile(join(ctx.repo, "binary.bin"), Buffer.from([0, 1, 2, 3]));
+await runCommand("git", ["add", "."], { cwd: ctx.repo });
+await runCommand("git", ["commit", "-m", "recent update"], {
+cwd: ctx.repo,
+env: {
+GIT_AUTHOR_DATE: "2030-01-01T00:00:00Z",
+GIT_COMMITTER_DATE: "2030-01-01T00:00:00Z",
+},
+});
+
+const result = await buildAiSinceMinimap(ctx.repo, "2025-01-01");
+const changed = result.files.find((file) => file.path === "changed.txt");
+const unchanged = result.files.find((file) => file.path === "unchanged.txt");
+
+expect(changed).toMatchObject({ ai: 1, human: 0, total: 1, pctAi: 100 });
+expect(unchanged).toMatchObject({ ai: 0, human: 1, total: 1, pctAi: 0 });
+expect(result.files.find((file) => file.path === "binary.bin")).toBeUndefined();
+expect(result.totals).toMatchObject({ ai: 1, human: 1, total: 2, pctAi: 50 });
+} finally {
+await ctx.cleanup();
+}
+});
+});

package/src/__tests__/notes-sync.test.ts

@@ -0,0 +1,38 @@
+import { describe, expect, test } from "bun:test";
+import {
+	buildRemoteMergeRef,
+	isRetryableNotesPushError,
+} from "../attribution/notes-sync.ts";
+
+describe("buildRemoteMergeRef", () => {
+	test("derives the temporary remote merge ref from the notes ref", () => {
+		expect(buildRemoteMergeRef("refs/notes/claude-attribution")).toBe(
+			"refs/notes/claude-attribution-remote",
+		);
+	});
+});
+
+describe("isRetryableNotesPushError", () => {
+	test("matches fetch-first push rejections", () => {
+		const error = Object.assign(new Error("push failed"), {
+			stderr:
+				"! [rejected] refs/notes/claude-attribution -> refs/notes/claude-attribution (fetch first)\nerror: failed to push some refs",
+		});
+		expect(isRetryableNotesPushError(error)).toBe(true);
+	});
+
+	test("matches non-fast-forward push rejections", () => {
+		const error = Object.assign(new Error("push failed"), {
+			stderr:
+				"! [rejected] refs/notes/claude-attribution -> refs/notes/claude-attribution (non-fast-forward)\nerror: failed to push some refs",
+		});
+		expect(isRetryableNotesPushError(error)).toBe(true);
+	});
+
+	test("does not match unrelated push failures", () => {
+		const error = Object.assign(new Error("push failed"), {
+			stderr: "fatal: could not read from remote repository",
+		});
+		expect(isRetryableNotesPushError(error)).toBe(false);
+	});
+});

package/src/__tests__/runtime.test.ts

@@ -0,0 +1,33 @@
+import { describe, expect, test } from "bun:test";
+import { detectAssistantRuntime } from "../attribution/runtime.ts";
+
+describe("detectAssistantRuntime", () => {
+	test("detects GitHub Copilot CLI from environment", () => {
+		expect(
+			detectAssistantRuntime({
+				COPILOT_CLI: "1",
+				COPILOT_CLI_BINARY_VERSION: "1.2.3",
+			}),
+		).toEqual({
+			vendor: "copilot",
+			client: "GitHub Copilot CLI",
+			clientVersion: "1.2.3",
+		});
+	});
+
+	test("falls back to Claude runtime from Anthropic model env", () => {
+		expect(
+			detectAssistantRuntime({
+				ANTHROPIC_DEFAULT_SONNET_MODEL: "claude-sonnet-4-6",
+			}),
+		).toEqual({
+			vendor: "claude",
+			client: "Claude Code",
+			modelFamily: "claude-sonnet-4-6",
+		});
+	});
+
+	test("returns null when no runtime hints are available", () => {
+		expect(detectAssistantRuntime({})).toBeNull();
+	});
+});