claude-attribution 1.2.5 → 1.2.8

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "claude-attribution",
-	"version": "1.2.5",
+	"version": "1.2.8",
 	"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/hooks/post-tool-use.ts

@@ -45,12 +45,21 @@ async function main() {
 	const { session_id, tool_name, tool_input } = payload;
 	const repoRoot = resolve(process.cwd());
 
-	// Log every tool call
-	const logEntry = {
+	// Log every tool call. For Skill invocations, also capture the skill name
+	// so metrics can show "/pr" instead of the generic "Skill ×1".
+	const logEntry: {
+		timestamp: string;
+		session: string;
+		tool: string;
+		skill?: string;
+	} = {
 		timestamp: new Date().toISOString(),
 		session: session_id,
 		tool: tool_name,
 	};
+	if (tool_name === "Skill" && typeof tool_input["skill"] === "string") {
+		logEntry.skill = tool_input["skill"];
+	}
 
 	try {
 		const logDir = join(repoRoot, ".claude", "logs");