claude-attribution 1.2.7 → 1.2.9

package/package.json

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

package/src/attribution/minimap.ts

@@ -176,3 +176,163 @@ export async function listMinimapNotes(repoRoot: string): Promise<string[]> {
 		return [];
 	}
 }
+
+// ─── Bulk init helpers ────────────────────────────────────────────────────────
+// Exported for use by install.ts without importing init.ts (which auto-executes
+// main() at module level and cannot be statically imported from other modules).
+
+const CONCURRENCY = 8;
+
+function buildResult(sha: string, files: MinimapFileState[]): MinimapResult {
+	let totalAi = 0,
+		totalHuman = 0,
+		totalLines = 0;
+	for (const f of files) {
+		totalAi += f.ai;
+		totalHuman += f.human;
+		totalLines += f.total;
+	}
+	return {
+		commit: sha,
+		timestamp: new Date().toISOString(),
+		files,
+		totals: {
+			ai: totalAi,
+			human: totalHuman,
+			total: totalLines,
+			pctAi: totalLines > 0 ? Math.round((totalAi / totalLines) * 100) : 0,
+		},
+	};
+}
+
+/**
+ * Mark all currently tracked files as AI-written at HEAD.
+ * Used by `claude-attribution init --ai` and the install baseline prompt.
+ */
+export async function buildAllAiMinimap(
+	repoRoot: string,
+): Promise<MinimapResult> {
+	const sha = await run("git", ["rev-parse", "HEAD"], repoRoot);
+	const lsOutput = await run("git", ["ls-files"], repoRoot);
+	const allFiles = lsOutput ? lsOutput.split("\n").filter(Boolean) : [];
+
+	const minimapFiles: MinimapFileState[] = [];
+	for (let i = 0; i < allFiles.length; i += CONCURRENCY) {
+		const batch = allFiles.slice(i, i + CONCURRENCY);
+		const results = await Promise.all(
+			batch.map(async (relPath): Promise<MinimapFileState | null> => {
+				try {
+					const content = await run(
+						"git",
+						["show", `HEAD:${relPath}`],
+						repoRoot,
+					);
+					if (content.includes("\0")) return null;
+					const lines = content.split("\n");
+					const total = lines.length;
+					const aiHashes = new Set<string>();
+					for (const line of lines) {
+						if (line.trim() !== "") aiHashes.add(hashLine(line));
+					}
+					return {
+						path: relPath,
+						ai_hashes: hashSetToString(aiHashes),
+						ai: total,
+						human: 0,
+						total,
+						pctAi: total > 0 ? 100 : 0,
+					} satisfies MinimapFileState;
+				} catch {
+					return null;
+				}
+			}),
+		);
+		minimapFiles.push(
+			...results.filter((r): r is MinimapFileState => r !== null),
+		);
+	}
+	return buildResult(sha, minimapFiles);
+}
+
+/**
+ * Mark files modified since sinceDate (YYYY-MM-DD) as AI-written at HEAD.
+ * Files with no commits since that date are treated as human-written.
+ */
+export async function buildAiSinceMinimap(
+	repoRoot: string,
+	sinceDate: string,
+): Promise<MinimapResult> {
+	const sha = await run("git", ["rev-parse", "HEAD"], repoRoot);
+	const lsOutput = await run("git", ["ls-files"], repoRoot);
+	const allFiles = lsOutput ? lsOutput.split("\n").filter(Boolean) : [];
+
+	// Collect all files changed in commits since the given date
+	const commitLog = await run(
+		"git",
+		["log", `--since=${sinceDate}`, "--format=%H"],
+		repoRoot,
+	);
+	const commits = commitLog ? commitLog.split("\n").filter(Boolean) : [];
+	const aiFileSet = new Set<string>();
+	for (const commitSha of commits) {
+		try {
+			const changed = await run(
+				"git",
+				["diff-tree", "--no-commit-id", "-r", "--name-only", commitSha],
+				repoRoot,
+			);
+			for (const f of changed.split("\n").filter(Boolean)) {
+				aiFileSet.add(f);
+			}
+		} catch {
+			// Non-fatal: skip this commit's file list
+		}
+	}
+
+	const minimapFiles: MinimapFileState[] = [];
+	for (let i = 0; i < allFiles.length; i += CONCURRENCY) {
+		const batch = allFiles.slice(i, i + CONCURRENCY);
+		const results = await Promise.all(
+			batch.map(async (relPath): Promise<MinimapFileState | null> => {
+				try {
+					const content = await run(
+						"git",
+						["show", `HEAD:${relPath}`],
+						repoRoot,
+					);
+					if (content.includes("\0")) return null;
+					const lines = content.split("\n");
+					const total = lines.length;
+					if (!aiFileSet.has(relPath)) {
+						return {
+							path: relPath,
+							ai_hashes: "",
+							ai: 0,
+							human: total,
+							total,
+							pctAi: 0,
+						};
+					}
+					const aiHashes = new Set<string>();
+					for (const line of lines) {
+						if (line.trim() !== "") aiHashes.add(hashLine(line));
+					}
+					return {
+						path: relPath,
+						ai_hashes: hashSetToString(aiHashes),
+						ai: total,
+						human: 0,
+						total,
+						pctAi: total > 0 ? 100 : 0,
+					} satisfies MinimapFileState;
+				} catch {
+					return null;
+				}
+			}),
+		);
+		minimapFiles.push(
+			...results.filter((r): r is MinimapFileState => r !== null),
+		);
+	}
+	return buildResult(sha, minimapFiles);
+}

package/src/cli.ts

@@ -92,7 +92,7 @@ Commands:
   uninstall [repo] Remove hooks from a repo (default: current directory)
   metrics [id]     Generate PR metrics report
   pr [title]       Create PR with metrics embedded (--draft, --base <branch>)
-  init [--ai]      Declare current codebase as AI-written in the cumulative minimap
+  init [--ai | --ai-since <YYYY-MM-DD>]  Set attribution baseline in the cumulative minimap
   start            Mark session start for per-ticket scoping
   hook <name>      Run an internal hook (used by installed git hooks)
   version          Print version

package/src/commands/init.ts

@@ -1,37 +1,19 @@
 /**
- * claude-attribution init [--ai | --human]
+ * claude-attribution init [--ai | --ai-since <YYYY-MM-DD> | --human]
  *
  * Initializes the cumulative attribution minimap for an existing repo.
  *
- * --ai     Mark all currently tracked files as AI-written. Use for repos that
- *          were built entirely with Claude Code from the start.
- * --human  (default) Confirm the default: no minimap note written; all lines
- *          are assumed human until Claude writes them.
- *
- * After running init --ai, the next `claude-attribution metrics` or PR will show
- * the true codebase AI% instead of only the current session's delta.
+ * --ai              Mark all currently tracked files as AI-written.
+ * --ai-since <date> Mark files modified since the given date as AI-written.
+ * --human           (default) Confirm the human default — no minimap written.
  */
 import { resolve } from "path";
-import { execFile } from "child_process";
-import { promisify } from "util";
-import { hashLine } from "../attribution/differ.ts";
 import {
-	hashSetToString,
+	buildAllAiMinimap,
+	buildAiSinceMinimap,
 	writeMinimap,
-	type MinimapFileState,
-	type MinimapResult,
 } from "../attribution/minimap.ts";
 
-const execFileAsync = promisify(execFile);
-const CONCURRENCY = 8;
-
-async function runGit(args: string[], cwd: string): Promise<string> {
-	const result = (await execFileAsync("git", args, { cwd })) as unknown as {
-		stdout: string;
-	};
-	return result.stdout.trim();
-}
-
 async function main() {
 	const repoRoot = resolve(process.cwd());
 	const flag = process.argv[2];
@@ -49,120 +31,40 @@ async function main() {
 		return;
 	}
 
-	if (flag !== "--ai") {
-		console.error(`Unknown flag: ${flag}`);
-		console.error("Usage: claude-attribution init [--ai | --human]");
-		process.exit(1);
-	}
-
-	// --ai: mark entire current codebase as AI-written
-	let sha = "";
-	try {
-		sha = await runGit(["rev-parse", "HEAD"], repoRoot);
-	} catch {
-		console.error(
-			"Error: no commits found. Commit your files first, then run init --ai.",
+	if (flag === "--ai") {
+		const result = await buildAllAiMinimap(repoRoot);
+		await writeMinimap(result, repoRoot);
+		const pct = result.totals.pctAi;
+		console.log(
+			`✓ Marked ${result.files.length} files (${result.totals.total} lines, ${pct}% AI) as AI-written.`,
 		);
-		process.exit(1);
-	}
-
-	const lsOutput = await runGit(["ls-files"], repoRoot);
-	const allFiles = lsOutput ? lsOutput.split("\n").filter(Boolean) : [];
-
-	if (allFiles.length === 0) {
-		console.error("Error: no tracked files found.");
-		process.exit(1);
+		return;
 	}
 
-	console.log(
-		`Marking ${allFiles.length} files as AI-written on ${sha.slice(0, 7)}...`,
-	);
-
-	const minimapFiles: MinimapFileState[] = [];
-	let processed = 0;
-
-	for (let i = 0; i < allFiles.length; i += CONCURRENCY) {
-		const batch = allFiles.slice(i, i + CONCURRENCY);
-		const batchResults = await Promise.all(
-			batch.map(async (relPath): Promise<MinimapFileState | null> => {
-				try {
-					const result = (await execFileAsync(
-						"git",
-						["show", `HEAD:${relPath}`],
-						{ cwd: repoRoot },
-					)) as unknown as { stdout: string };
-					const content = result.stdout;
-
-					// Skip binary files
-					if (content.includes("\0")) return null;
-
-					const lines = content.split("\n");
-					const total = lines.length;
-
-					// init --ai is an explicit declaration: every line (including blank)
-					// is AI-written. Build ai_hashes from all non-blank lines so the
-					// carry-forward algorithm in future commits works correctly; count
-					// blank lines as AI in the totals.
-					const aiHashes = new Set<string>();
-					for (const line of lines) {
-						if (line.trim() !== "") {
-							aiHashes.add(hashLine(line));
-						}
-					}
-
-					return {
-						path: relPath,
-						ai_hashes: hashSetToString(aiHashes),
-						ai: total,
-						human: 0,
-						total,
-						pctAi: total > 0 ? 100 : 0,
-					} satisfies MinimapFileState;
-				} catch {
-					return null;
-				}
-			}),
-		);
-		const valid = batchResults.filter((r): r is MinimapFileState => r !== null);
-		minimapFiles.push(...valid);
-		processed += batch.length;
-		if (processed % 100 === 0 || processed === allFiles.length) {
-			process.stdout.write(`\r  ${processed} / ${allFiles.length} files...`);
+	if (flag === "--ai-since") {
+		const date = process.argv[3];
+		if (!date) {
+			console.error("Usage: claude-attribution init --ai-since <YYYY-MM-DD>");
+			process.exit(1);
 		}
+		if (!/^\d{4}-\d{2}-\d{2}$/.test(date)) {
+			console.error(`Invalid date format: ${date}. Expected YYYY-MM-DD.`);
+			process.exit(1);
+		}
+		const result = await buildAiSinceMinimap(repoRoot, date);
+		await writeMinimap(result, repoRoot);
+		const pct = result.totals.pctAi;
+		console.log(
+			`✓ Marked ${result.files.length} files (${result.totals.total} lines, ${pct}% AI) as AI-written since ${date}.`,
+		);
+		return;
 	}
 
-	process.stdout.write("\n");
-
-	let totalAi = 0,
-		totalHuman = 0,
-		totalLines = 0;
-	for (const f of minimapFiles) {
-		totalAi += f.ai;
-		totalHuman += f.human;
-		totalLines += f.total;
-	}
-
-	const minimapResult: MinimapResult = {
-		commit: sha,
-		timestamp: new Date().toISOString(),
-		files: minimapFiles,
-		totals: {
-			ai: totalAi,
-			human: totalHuman,
-			total: totalLines,
-			pctAi: totalLines > 0 ? Math.round((totalAi / totalLines) * 100) : 0,
-		},
-	};
-
-	await writeMinimap(minimapResult, repoRoot);
-
-	const pct = minimapResult.totals.pctAi;
-	console.log(
-		`✓ Marked ${minimapFiles.length} files (${totalLines} lines, ${pct}% AI) as AI-written.`,
-	);
-	console.log(
-		"  Push to share with team: git push origin refs/notes/claude-attribution-map",
+	console.error(`Unknown flag: ${flag}`);
+	console.error(
+		"Usage: claude-attribution init [--ai | --ai-since <YYYY-MM-DD> | --human]",
 	);
+	process.exit(1);
 }
 
 main().catch((err) => {

package/src/commands/pr.ts

@@ -21,6 +21,7 @@ import { collectMetrics, renderMetrics } from "../metrics/collect.ts";
 const execFileAsync = promisify(execFile);
 
 const METRICS_PLACEHOLDER = "<!-- claude-attribution metrics -->";
+const METRICS_END = "<!-- /claude-attribution metrics -->";
 
 const BUILTIN_TEMPLATE = `## Description
 
@@ -125,12 +126,14 @@ async function main() {
 		? await readFile(templatePath, "utf8")
 		: BUILTIN_TEMPLATE;
 
-	// Inject metrics at placeholder or append
+	// Inject metrics wrapped in start/end markers so CI can find and replace on
+	// subsequent synchronize events without appending a second block.
+	const metricsSection = `${METRICS_PLACEHOLDER}\n${metricsBlock}\n${METRICS_END}`;
 	let body: string;
 	if (template.includes(METRICS_PLACEHOLDER)) {
-		body = template.replace(METRICS_PLACEHOLDER, metricsBlock);
+		body = template.replace(METRICS_PLACEHOLDER, metricsSection);
 	} else {
-		body = template.trimEnd() + "\n\n" + metricsBlock;
+		body = template.trimEnd() + "\n\n" + metricsSection;
 	}
 
 	// Push the current branch to remote. Always push only the branch ref (not

package/src/setup/install.ts

@@ -9,6 +9,7 @@ import { readFile, writeFile, appendFile, mkdir } from "fs/promises";
 import { existsSync } from "fs";
 import { execFile } from "child_process";
 import { promisify } from "util";
+import { createInterface } from "readline";
 import { resolve, join } from "path";
 import {
 	ATTRIBUTION_ROOT,
@@ -20,11 +21,125 @@ import {
 	type HooksConfig,
 } from "./shared.ts";
 import { configureRequiredCheck } from "./branch-protection.ts";
+import {
+	listMinimapNotes,
+	writeMinimap,
+	buildAllAiMinimap,
+	buildAiSinceMinimap,
+} from "../attribution/minimap.ts";
 
 const execFileAsync = promisify(execFile);
 
 const CLI_BIN = resolve(ATTRIBUTION_ROOT, "bin", "claude-attribution");
 
+// ─── Baseline init prompt ────────────────────────────────────────────────────
+
+const DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
+
+async function promptLine(question: string): Promise<string> {
+	const rl = createInterface({ input: process.stdin, output: process.stdout });
+	return new Promise((resolve) => {
+		rl.question(question, (answer) => {
+			rl.close();
+			resolve(answer.trim());
+		});
+	});
+}
+
+/**
+ * After install, ask the developer how to treat existing code in the minimap.
+ * Skipped if the minimap was already initialized (flag file or existing notes).
+ * Never throws — any failure falls back to a printed note.
+ */
+async function promptBaselineInit(
+	repoRoot: string,
+	claudeDir: string,
+): Promise<void> {
+	const flagPath = join(claudeDir, "attribution-state", "baseline-initialized");
+
+	try {
+		// Idempotent: skip if already set
+		if (existsSync(flagPath)) return;
+		const existingNotes = await listMinimapNotes(repoRoot);
+		if (existingNotes.length > 0) return;
+
+		// Verify there are commits to work with
+		try {
+			await execFileAsync("git", ["rev-parse", "HEAD"], { cwd: repoRoot });
+		} catch {
+			console.log(
+				"\n  ℹ️  Run 'claude-attribution init --ai' after your first commit to set the attribution baseline.",
+			);
+			return;
+		}
+
+		if (!process.stdin.isTTY) {
+			console.log(
+				"\n  ℹ️  Run 'claude-attribution init [--ai | --ai-since <YYYY-MM-DD>]' to set the attribution baseline.",
+			);
+			return;
+		}
+
+		console.log(
+			"\n  Attribution baseline — how should existing code be treated?",
+		);
+		console.log(
+			"    [1] AI          — all current code was written with Claude Code",
+		);
+		console.log(
+			"    [2] Human       — assume human-written (AI accumulates from here)",
+		);
+		console.log(
+			"    [3] AI since    — mark commits after a date as AI-written",
+		);
+		console.log(
+			"    [4] Skip        — decide later (run: claude-attribution init --ai)",
+		);
+		const raw = await promptLine("  Choice [2]: ");
+		const choice = raw === "" ? 2 : parseInt(raw, 10);
+
+		if (choice === 1) {
+			console.log("  Marking all files as AI-written...");
+			const result = await buildAllAiMinimap(repoRoot);
+			await writeMinimap(result, repoRoot);
+			await writeFile(flagPath, "ai");
+			const { pctAi, total } = result.totals;
+			console.log(
+				`✓ Baseline set: AI (${result.files.length} files, ${total} lines, ${pctAi}% AI)`,
+			);
+		} else if (choice === 2) {
+			await writeFile(flagPath, "human");
+			console.log(
+				"✓ Baseline set: human (AI attribution accumulates from this point)",
+			);
+		} else if (choice === 3) {
+			// Prompt for date with validation loop
+			let date = "";
+			while (true) {
+				date = await promptLine("  Start date (YYYY-MM-DD): ");
+				if (DATE_RE.test(date)) break;
+				console.log(
+					`  Invalid format: ${date || "(empty)"}. Use YYYY-MM-DD (e.g. 2026-01-15).`,
+				);
+			}
+			console.log(`  Marking files changed since ${date} as AI-written...`);
+			const result = await buildAiSinceMinimap(repoRoot, date);
+			await writeMinimap(result, repoRoot);
+			await writeFile(flagPath, `ai-since:${date}`);
+			const { pctAi, total } = result.totals;
+			console.log(
+				`✓ Baseline set: AI since ${date} (${result.files.length} files, ${total} lines, ${pctAi}% AI)`,
+			);
+		}
+		// choice === 4 or unrecognized: Skip — write no flag, ask again next install
+	} catch {
+		console.log("\n  ℹ️  Could not set attribution baseline automatically.");
+		console.log(
+			"      Run 'claude-attribution init [--ai | --ai-since <YYYY-MM-DD>]' manually.",
+		);
+	}
+}
+
 async function main() {
 	const args = process.argv.slice(2);
 	const runnerFlagIdx = args.findIndex((a: string) => a === "--runner");
@@ -178,7 +293,10 @@ async function main() {
 	// 5. Check branch protection and offer to add required status check
 	await configureRequiredCheck(targetRepo);
 
-	// 6. Record installed version for auto-upgrade tracking
+	// 6. Prompt for attribution baseline (skipped on re-runs)
+	await promptBaselineInit(targetRepo, claudeDir);
+
+	// 7. Record installed version for auto-upgrade tracking
 	const pkg = JSON.parse(
 		await readFile(join(ATTRIBUTION_ROOT, "package.json"), "utf8"),
 	) as { version: string };

package/src/setup/templates/pr-metrics-workflow.yml

@@ -23,7 +23,9 @@ jobs:
           git fetch origin refs/notes/claude-attribution-map:refs/notes/claude-attribution-map || true
 
       - name: Install claude-attribution
-        run: npm install -g claude-attribution
+        run: |
+          npm install -g --prefix "${HOME}/.npm-global" claude-attribution
+          echo "${HOME}/.npm-global/bin" >> "$GITHUB_PATH"
 
       - name: Generate metrics
         run: claude-attribution metrics > /tmp/claude-attribution-metrics.md || true