claude-attribution 1.6.0 → 1.9.0

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

@@ -0,0 +1,168 @@
+import { describe, expect, test } from "bun:test";
+import { writeFile } from "fs/promises";
+import { join } from "path";
+import {
+buildAllAiResult,
+committedContent,
+committedContentAt,
+currentBranch,
+filesInCommit,
+filesInCommitAt,
+getBranchCommitShas,
+getCommitMeta,
+headSha,
+isKnownAiActorCommit,
+listNotes,
+readNote,
+writeNote,
+} from "../attribution/git-notes.ts";
+import {
+commitAll,
+createTempContext,
+currentSha,
+initGitRepo,
+runCommand,
+} from "./integration-helpers.ts";
+
+describe("git-notes", () => {
+test("reads repo metadata and writes attribution notes", async () => {
+const ctx = await createTempContext("claude-attribution-git-notes");
+try {
+await initGitRepo(ctx.repo);
+await writeFile(join(ctx.repo, "baseline.txt"), "baseline");
+await commitAll(ctx.repo, "baseline");
+const initialSha = await currentSha(ctx.repo);
+
+await writeFile(join(ctx.repo, "ai.txt"), "alpha\n\nbeta");
+await writeFile(
+join(ctx.repo, "binary.bin"),
+Buffer.from([0, 1, 2, 3]),
+);
+await commitAll(ctx.repo, "add AI-attributed files");
+const sha = await currentSha(ctx.repo);
+
+expect(await headSha(ctx.repo)).toBe(sha);
+expect(await currentBranch(ctx.repo)).not.toBeNull();
+
+const changedFiles = await filesInCommit(ctx.repo);
+expect(changedFiles.includes("ai.txt")).toBe(true);
+expect(changedFiles.includes("binary.bin")).toBe(true);
+
+const changedFilesAtSha = await filesInCommitAt(ctx.repo, sha);
+expect(changedFilesAtSha.includes("ai.txt")).toBe(true);
+expect(changedFilesAtSha.includes("binary.bin")).toBe(true);
+
+expect(await committedContent(ctx.repo, "ai.txt")).toBe("alpha\n\nbeta");
+expect(await committedContent(ctx.repo, "missing.txt")).toBeNull();
+expect(await committedContentAt(ctx.repo, sha, "ai.txt")).toBe(
+"alpha\n\nbeta",
+);
+expect(await committedContentAt(ctx.repo, sha, "missing.txt")).toBeNull();
+
+expect(await readNote(ctx.repo, sha)).toBeNull();
+expect(await listNotes(ctx.repo)).toEqual([]);
+
+const result = await buildAllAiResult(ctx.repo, sha);
+expect(result.commit).toBe(sha);
+expect(result.files).toHaveLength(1);
+expect(result.files[0]).toMatchObject({
+path: "ai.txt",
+ai: 2,
+human: 1,
+total: 3,
+pctAi: 67,
+});
+expect(result.totals).toMatchObject({ ai: 2, human: 1, total: 3, pctAi: 67 });
+
+const meta = await getCommitMeta(ctx.repo, sha);
+expect(meta.authorName).toBe("Test User");
+expect(meta.authorEmail).toBe("test@example.com");
+expect(meta.message).toBe("add AI-attributed files");
+expect(meta.timestamp).toMatch(/T/);
+
+await writeNote(result, ctx.repo, sha);
+const stored = await readNote(ctx.repo, sha);
+expect(stored?.totals).toEqual(result.totals);
+expect(await listNotes(ctx.repo)).toEqual([sha]);
+
+const branchShas = await getBranchCommitShas(ctx.repo);
+expect(branchShas.includes(sha)).toBe(true);
+expect(branchShas.includes(initialSha)).toBe(true);
+} finally {
+await ctx.cleanup();
+}
+});
+
+test("returns null for detached HEAD branches", async () => {
+const ctx = await createTempContext("claude-attribution-detached-head");
+try {
+await initGitRepo(ctx.repo);
+await writeFile(join(ctx.repo, "file.txt"), "content");
+await commitAll(ctx.repo, "initial");
+const sha = await currentSha(ctx.repo);
+
+await runCommand("git", ["checkout", sha], { cwd: ctx.repo });
+expect(await currentBranch(ctx.repo)).toBeNull();
+} finally {
+await ctx.cleanup();
+}
+});
+
+test("detects known AI actor commit metadata", () => {
+expect(
+isKnownAiActorCommit({
+authorName: "github-actions[bot]",
+authorEmail: "41898282+github-actions[bot]@users.noreply.github.com",
+message: "Automated commit",
+timestamp: new Date().toISOString(),
+}),
+).toBe(true);
+
+expect(
+isKnownAiActorCommit({
+authorName: "Test User",
+authorEmail: "test@example.com",
+message:
+"feat: add change\n\nCo-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>",
+timestamp: new Date().toISOString(),
+}),
+).toBe(true);
+
+expect(
+isKnownAiActorCommit({
+authorName: "Test User",
+authorEmail: "test@example.com",
+message: "Regular human commit",
+timestamp: new Date().toISOString(),
+}),
+).toBe(false);
+});
+
+test("buildAllAiResult tags hosted Copilot commits with assistant runtime", async () => {
+const ctx = await createTempContext("claude-attribution-copilot-bot");
+try {
+await initGitRepo(ctx.repo);
+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: add hosted change\n\nCo-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>",
+);
+const sha = await currentSha(ctx.repo);
+
+const result = await buildAllAiResult(ctx.repo, sha);
+
+expect(result.assistantRuntime).toEqual({
+vendor: "copilot",
+client: "GitHub Copilot",
+});
+} finally {
+await ctx.cleanup();
+}
+});
+});

package/src/__tests__/installed-repos.test.ts

@@ -0,0 +1,68 @@
+import { describe, expect, test } from "bun:test";
+import { mkdir } from "fs/promises";
+import {
+	installedRepoRegistryPath,
+	pruneMissingInstalledRepos,
+	readInstalledRepoRegistry,
+	registerInstalledRepo,
+	unregisterInstalledRepo,
+	writeInstalledRepoRegistry,
+} from "../setup/installed-repos.ts";
+import { createTempContext, initGitRepo } from "./integration-helpers.ts";
+
+describe("installed repo registry", () => {
+	test("registers, updates, prunes, and unregisters repos", async () => {
+		const ctx = await createTempContext("claude-attribution-installed-repos");
+		try {
+			const repo1 = ctx.repo;
+			const repo2 = `${ctx.root}/second-repo`;
+			await mkdir(repo2, { recursive: true });
+			await initGitRepo(repo1);
+			await initGitRepo(repo2);
+
+			await registerInstalledRepo(repo1, "1.6.0", ctx.home);
+			await registerInstalledRepo(repo2, "1.6.0", ctx.home);
+			await registerInstalledRepo(repo1, "1.7.0", ctx.home);
+
+			const registryPath = installedRepoRegistryPath(ctx.home);
+			expect(registryPath).toContain(".claude/claude-attribution/installed-repos.json");
+
+			const records = await readInstalledRepoRegistry(ctx.home);
+			expect(records).toHaveLength(2);
+			expect(records.map((record) => record.path)).toEqual([repo1, repo2].sort());
+			expect(records.find((record) => record.path === repo1)?.installedVersion).toBe(
+				"1.7.0",
+			);
+
+			expect(await unregisterInstalledRepo(repo2, ctx.home)).toBe(true);
+			expect(await readInstalledRepoRegistry(ctx.home)).toHaveLength(1);
+			expect(await unregisterInstalledRepo(repo2, ctx.home)).toBe(false);
+
+			await writeInstalledRepoRegistry(
+				[
+					{
+						path: repo1,
+						firstInstalledAt: new Date(0).toISOString(),
+						lastUpdatedAt: new Date().toISOString(),
+						installedVersion: "1.7.0",
+					},
+					{
+						path: `${ctx.root}/missing-repo`,
+						firstInstalledAt: new Date(0).toISOString(),
+						lastUpdatedAt: new Date().toISOString(),
+						installedVersion: "1.0.0",
+					},
+				],
+				ctx.home,
+			);
+			const pruned = await pruneMissingInstalledRepos(ctx.home);
+			expect(pruned.kept).toHaveLength(1);
+			expect(pruned.removed).toHaveLength(1);
+			expect((await readInstalledRepoRegistry(ctx.home)).map((record) => record.path)).toEqual(
+				[repo1],
+			);
+		} finally {
+			await ctx.cleanup();
+		}
+	});
+});

package/src/__tests__/integration-helpers.ts

@@ -0,0 +1,143 @@
+import { execFile } from "child_process";
+import {
+	mkdir,
+	mkdtemp,
+	realpath,
+	readFile,
+	rm,
+	writeFile,
+} from "fs/promises";
+import { tmpdir } from "os";
+import { dirname, join, resolve } from "path";
+import { promisify } from "util";
+import { claudeProjectKey } from "../metrics/claude-projects.ts";
+
+const execFileAsync = promisify(execFile);
+
+export const REPO_ROOT = resolve(import.meta.dir, "..", "..");
+export const CLI_BIN = join(REPO_ROOT, "bin", "claude-attribution");
+
+export interface CommandResult {
+	stdout: string;
+	stderr: string;
+	exitCode: number;
+}
+
+export interface TempTestContext {
+	root: string;
+	home: string;
+	repo: string;
+	cleanup: () => Promise<void>;
+}
+
+export async function runCommand(
+	command: string,
+	args: string[],
+	options: {
+		cwd?: string;
+		env?: NodeJS.ProcessEnv;
+		allowFailure?: boolean;
+	} = {},
+): Promise<CommandResult> {
+	try {
+		const result = await execFileAsync(command, args, {
+			cwd: options.cwd,
+			env: { ...process.env, ...options.env },
+		});
+		return {
+			stdout: result.stdout.trimEnd(),
+			stderr: result.stderr?.trimEnd() ?? "",
+			exitCode: 0,
+		};
+	} catch (error) {
+		const execError = error as Error & {
+			stdout?: string;
+			stderr?: string;
+			code?: number;
+		};
+		if (!options.allowFailure) throw error;
+		return {
+			stdout: execError.stdout?.trimEnd() ?? "",
+			stderr: execError.stderr?.trimEnd() ?? "",
+			exitCode: execError.code ?? 1,
+		};
+	}
+}
+
+export async function createTempContext(
+	prefix: string,
+): Promise<TempTestContext> {
+	const root = await realpath(await mkdtemp(join(tmpdir(), `${prefix}-`)));
+	const home = join(root, "home");
+	const repo = join(root, "repo");
+	await mkdir(home, { recursive: true });
+	await mkdir(join(home, ".claude", "projects"), { recursive: true });
+	await mkdir(repo, { recursive: true });
+	return {
+		root,
+		home,
+		repo,
+		cleanup: async () => {
+			await rm(root, { recursive: true, force: true });
+		},
+	};
+}
+
+export async function initGitRepo(repo: string): Promise<void> {
+	await runCommand("git", ["init"], { cwd: repo });
+	await configureGitIdentity(repo);
+}
+
+export async function configureGitIdentity(repo: string): Promise<void> {
+	await runCommand("git", ["config", "user.name", "Test User"], { cwd: repo });
+	await runCommand("git", ["config", "user.email", "test@example.com"], {
+		cwd: repo,
+	});
+}
+
+export async function commitAll(repo: string, message: string): Promise<void> {
+	await runCommand("git", ["add", "."], { cwd: repo });
+	await runCommand("git", ["commit", "-m", message], { cwd: repo });
+}
+
+export async function currentSha(repo: string): Promise<string> {
+	const result = await runCommand("git", ["rev-parse", "HEAD"], { cwd: repo });
+	return result.stdout.trim();
+}
+
+export async function writeJsonl(
+	path: string,
+	entries: unknown[],
+): Promise<void> {
+	await mkdir(dirname(path), { recursive: true });
+	await writeFile(path, entries.map((entry) => JSON.stringify(entry)).join("\n") + "\n");
+}
+
+export function transcriptDirFor(home: string, repo: string): string {
+	return join(home, ".claude", "projects", claudeProjectKey(repo));
+}
+
+export async function writeTranscript(
+	home: string,
+	repo: string,
+	sessionId: string,
+	entries: unknown[],
+): Promise<void> {
+	const dir = transcriptDirFor(home, repo);
+	await mkdir(dir, { recursive: true });
+	await writeJsonl(join(dir, `${sessionId}.jsonl`), entries);
+}
+
+export async function writeCopilotSession(
+	home: string,
+	sessionId: string,
+	entries: unknown[],
+): Promise<void> {
+	const dir = join(home, ".copilot", "session-state", sessionId);
+	await mkdir(dir, { recursive: true });
+	await writeJsonl(join(dir, "events.jsonl"), entries);
+}
+
+export async function readJson(path: string): Promise<unknown> {
+	return JSON.parse(await readFile(path, "utf8"));
+}