claude-attribution 1.2.1 → 1.2.4

package/package.json

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

package/src/commands/init.ts

@@ -16,7 +16,7 @@ import { execFile } from "child_process";
 import { promisify } from "util";
 import { hashLine } from "../attribution/differ.ts";
 import {
-	computeMinimapFile,
+	hashSetToString,
 	writeMinimap,
 	type MinimapFileState,
 	type MinimapResult,
@@ -97,21 +97,27 @@ async function main() {
 					if (content.includes("\0")) return null;
 
 					const lines = content.split("\n");
+					const total = lines.length;
 
-					// Build currentAiHashes from every non-blank line in the file
-					const currentAiHashes = new Set<string>();
+					// 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() !== "") {
-							currentAiHashes.add(hashLine(line));
+							aiHashes.add(hashLine(line));
 						}
 					}
 
-					return computeMinimapFile(
-						relPath,
-						lines,
-						currentAiHashes,
-						new Set<string>(),
-					);
+					return {
+						path: relPath,
+						ai_hashes: hashSetToString(aiHashes),
+						ai: total,
+						human: 0,
+						total,
+						pctAi: total > 0 ? 100 : 0,
+					} satisfies MinimapFileState;
 				} catch {
 					return null;
 				}

package/src/commands/pr.ts

@@ -88,7 +88,7 @@ async function main() {
 			draft = true;
 		} else if (args[i] === "--base" && i + 1 < args.length) {
 			base = args[++i];
-		} else if (!args[i].startsWith("--")) {
+		} else if (!(args[i] ?? "").startsWith("--")) {
 			title = args[i];
 		}
 	}

package/src/hooks/post-bash.ts

@@ -44,7 +44,7 @@ function extractPrUrl(response: unknown): string | null {
 
 function prNumberFromUrl(url: string): number | null {
 	const match = url.match(/\/pull\/(\d+)$/);
-	return match ? parseInt(match[1], 10) : null;
+	return match?.[1] ? parseInt(match[1], 10) : null;
 }
 
 async function main() {

package/src/hooks/pre-tool-use.ts

@@ -20,7 +20,6 @@ import { readStdin, WRITE_TOOLS, getFilePath } from "../lib/hooks.ts";
 import { maybeAutoUpgrade } from "../lib/auto-upgrade.ts";
 import {
 	otelEndpoint,
-	otelHeaders,
 	readOtelContext,
 	writeOtelContext,
 	makeTraceId,

package/src/metrics/transcript.ts

@@ -120,7 +120,7 @@ function computeActiveMinutes(allTimestamps: number[]): number {
 	let totalMs = 0;
 	const IDLE_THRESHOLD_MS = 900_000; // 15 minutes
 	for (let i = 1; i < sorted.length; i++) {
-		const gap = sorted[i] - sorted[i - 1];
+		const gap = (sorted[i] ?? 0) - (sorted[i - 1] ?? 0);
 		if (gap < IDLE_THRESHOLD_MS) totalMs += gap;
 	}
 	return Math.round(totalMs / 60_000);

package/src/setup/install.ts

@@ -25,7 +25,14 @@ const execFileAsync = promisify(execFile);
 const CLI_BIN = resolve(ATTRIBUTION_ROOT, "bin", "claude-attribution");
 
 async function main() {
-	const targetRepo = resolve(process.argv[2] ?? process.cwd());
+	const args = process.argv.slice(2);
+	const runnerFlagIdx = args.findIndex((a: string) => a === "--runner");
+	const runnerOverride =
+		runnerFlagIdx !== -1 ? args[runnerFlagIdx + 1] : undefined;
+	const positional = args.filter(
+		(a: string, i: number) => a !== "--runner" && i !== runnerFlagIdx + 1,
+	);
+	const targetRepo = resolve(positional[0] ?? process.cwd());
 
 	if (!existsSync(join(targetRepo, ".git"))) {
 		console.error(`Error: ${targetRepo} is not a git repository`);
@@ -71,23 +78,34 @@ async function main() {
 	const hookResult = await installGitHook(targetRepo);
 	if (hookResult === "noop") {
 		console.log("");
-		console.log("  ⚠️  Lefthook detected. Add this to lefthook.yml manually:");
-		console.log("  post-commit:");
+		console.log(
+			"  ⚠️  Could not auto-edit lefthook config (unusual structure).",
+		);
+		console.log(
+			"  Add this to your lefthook config under post-commit manually:",
+		);
 		console.log("    commands:");
 		console.log("      claude-attribution:");
 		console.log("        run: claude-attribution hook post-commit || true");
 		console.log("");
-		console.log(
-			"  (skipped automatic hook install — Lefthook manages .git/hooks/)",
-		);
 	} else if (hookResult === "created") {
 		const hookPath =
 			manager === "husky" ? ".husky/post-commit" : ".git/hooks/post-commit";
 		console.log(`✓ Created ${hookPath}`);
 	} else if (hookResult === "appended") {
-		const hookPath =
-			manager === "husky" ? ".husky/post-commit" : ".git/hooks/post-commit";
-		console.log(`✓ Appended to existing ${hookPath}`);
+		const lefthookConfigFile =
+			manager === "lefthook"
+				? (["lefthook.yml", "lefthook.yaml", ".lefthook.yml"].find((name) =>
+						existsSync(join(targetRepo, name)),
+					) ?? "lefthook.yml")
+				: undefined;
+		const hookFile =
+			manager === "husky"
+				? ".husky/post-commit"
+				: manager === "lefthook"
+					? lefthookConfigFile!
+					: ".git/hooks/post-commit";
+		console.log(`✓ Added post-commit entry to ${hookFile}`);
 	} else {
 		// unchanged
 		console.log("✓ post-commit hook already up to date");
@@ -147,9 +165,13 @@ async function main() {
 	console.log("✓ Installed .claude/commands/pr.md (/pr command)");
 
 	// 4. Install GitHub Actions workflow for automatic PR metrics injection
-	await installCiWorkflow(targetRepo);
+	const { runsOn, detected } = await installCiWorkflow(
+		targetRepo,
+		runnerOverride,
+	);
+	const detectedNote = detected ? " (detected from existing workflows)" : "";
 	console.log(
-		"✓ Installed .github/workflows/claude-attribution-pr.yml (auto-injects metrics on PR open)",
+		`✓ Installed .github/workflows/claude-attribution-pr.yml — runner: ${runsOn}${detectedNote}`,
 	);
 
 	// 5. Record installed version for auto-upgrade tracking

package/src/setup/shared.ts

@@ -4,7 +4,7 @@
  * No top-level side effects. No console.log — logging is the caller's
  * responsibility.
  */
-import { readFile, writeFile, chmod, mkdir } from "fs/promises";
+import { readFile, writeFile, chmod, mkdir, readdir } from "fs/promises";
 import { existsSync } from "fs";
 import { resolve, join, dirname } from "path";
 import { fileURLToPath } from "url";
@@ -81,13 +81,111 @@ export type GitHookInstallResult =
 	| "created" // wrote a new hook file
 	| "appended" // appended to an existing hook file
 	| "unchanged" // hook already contained our entry; nothing written
-	| "noop"; // Lefthook detected — manual config required, nothing written
+	| "noop"; // could not auto-edit (complex YAML structure) — manual config required
+
+/** Lefthook config filenames, in priority order. Only YAML files are auto-edited. */
+const LEFTHOOK_CONFIG_FILES = [
+	"lefthook.yml",
+	"lefthook.yaml",
+	".lefthook.yml",
+	"lefthook.json", // JSON files: detect-only, never auto-edited
+	".lefthook.json",
+];
+
+/**
+ * Attempt to add our post-commit entry to a lefthook YAML config file.
+ *
+ * Cases handled automatically:
+ *   1. No post-commit section → append our block at end of file
+ *   2. post-commit + commands section exists → detect indentation, insert entry
+ *
+ * Falls back to "noop" only when the post-commit section has an unrecognised
+ * structure (e.g. uses `scripts:` instead of `commands:`, or non-standard YAML).
+ * Returns "unchanged" if already configured.
+ */
+async function tryInstallLefthookYaml(
+	configPath: string,
+): Promise<GitHookInstallResult> {
+	const content = await readFile(configPath, "utf8");
+
+	if (content.includes("claude-attribution")) return "unchanged";
+
+	const RUN_CMD = "claude-attribution hook post-commit || true";
+
+	// Case 1: no post-commit section — append entire block at the end.
+	if (!/^post-commit:/m.test(content)) {
+		await writeFile(
+			configPath,
+			content.trimEnd() +
+				"\n\npost-commit:\n  commands:\n    claude-attribution:\n      run: " +
+				RUN_CMD +
+				"\n",
+		);
+		return "appended";
+	}
+
+	// Case 2: post-commit section exists — find the commands: block and insert.
+	const lines = content.split("\n");
+	const postCommitIdx = lines.findIndex((l) => /^post-commit:/.test(l ?? ""));
+	if (postCommitIdx === -1) return "noop";
+
+	// Find the commands: line within the post-commit block.
+	let commandsIdx = -1;
+	for (let i = postCommitIdx + 1; i < lines.length; i++) {
+		const line = lines[i] ?? "";
+		if (!line.trim()) continue;
+		if (/^\S/.test(line)) break; // hit another top-level key
+		if (/^\s+commands:\s*$/.test(line)) {
+			commandsIdx = i;
+			break;
+		}
+	}
+	if (commandsIdx === -1) return "noop"; // uses scripts: or unusual structure
+
+	// Detect indentation from the commands: line itself.
+	const commandsLine = lines[commandsIdx] ?? "";
+	const baseIndent = commandsLine.match(/^(\s+)/)?.[1] ?? "  ";
+	const cmdIndent = baseIndent + "  ";
+	const propIndent = cmdIndent + "  ";
+
+	// Find the last indented line of the commands block.
+	// Stop when we reach a top-level key OR when indentation returns to
+	// baseIndent.length or less (i.e. a sibling key of commands:, such as
+	// parallel: or runner:, that would otherwise be treated as a command entry).
+	let insertAfterIdx = commandsIdx;
+	for (let i = commandsIdx + 1; i < lines.length; i++) {
+		const line = lines[i] ?? "";
+		if (!line.trim()) continue;
+		if (/^\S/.test(line)) break;
+		const indentLength = (line.match(/^(\s*)/) ?? ["", ""])[1]?.length ?? 0;
+		if (indentLength <= baseIndent.length) break;
+		insertAfterIdx = i;
+	}
+
+	const entry = [
+		`${cmdIndent}claude-attribution:`,
+		`${propIndent}run: ${RUN_CMD}`,
+	];
+	const newLines = [
+		...lines.slice(0, insertAfterIdx + 1),
+		...entry,
+		...lines.slice(insertAfterIdx + 1),
+	];
+	await writeFile(configPath, newLines.join("\n"));
+	return "appended";
+}
 
 /**
  * Install the post-commit git hook, respecting husky/lefthook if present.
  * Idempotent — safe to call on already-installed repos.
- * Note: for Lefthook repos this is a no-op (manual config required).
- * Returns a GitHookInstallResult describing what was done.
+ *
+ * Lefthook: auto-edits the YAML config to add our command entry. Falls back
+ * to "noop" (with manual instructions) only for unusual config structures.
+ *
+ * Husky: appends to .husky/post-commit if present; creates it if not.
+ *
+ * Plain git hooks: surgically appends our entry. Returns "unchanged" if
+ * already present — never clobbers hooks written by other tools.
  */
 export async function installGitHook(
 	repoRoot: string,
@@ -118,11 +216,31 @@ export async function installGitHook(
 	}
 
 	if (manager === "lefthook") {
-		// Cannot safely auto-edit YAML — caller should inform the user
+		// Try to auto-edit the YAML config; fall back to noop for JSON or
+		// complex structures that are not safe to modify programmatically.
+		for (const configFile of LEFTHOOK_CONFIG_FILES) {
+			const configPath = join(repoRoot, configFile);
+			if (!existsSync(configPath)) continue;
+			if (!configFile.endsWith(".yml") && !configFile.endsWith(".yaml")) {
+				// JSON config: detect-only, never auto-edit
+				try {
+					const content = await readFile(configPath, "utf8");
+					if (content.includes("claude-attribution")) return "unchanged";
+				} catch {
+					// skip
+				}
+				continue;
+			}
+			try {
+				return await tryInstallLefthookYaml(configPath);
+			} catch {
+				return "noop";
+			}
+		}
 		return "noop";
 	}
 
-	// Plain git hooks
+	// Plain git hooks — surgical append only, never overwrite the whole file.
 	const hookDest = join(repoRoot, ".git", "hooks", "post-commit");
 	const template = await readFile(
 		join(ATTRIBUTION_ROOT, "src", "setup", "templates", "post-commit.sh"),
@@ -131,15 +249,16 @@ export async function installGitHook(
 
 	if (existsSync(hookDest)) {
 		const existing = await readFile(hookDest, "utf8");
-		if (!existing.includes("claude-attribution")) {
-			await writeFile(
-				hookDest,
-				existing.trimEnd() + "\n\n# claude-attribution\n" + template,
-			);
-			await chmod(hookDest, 0o755);
-			return "appended";
+		if (existing.includes("claude-attribution")) {
+			// Already present — do not overwrite other hooks in the file.
+			return "unchanged";
 		}
-		// Already ours — replace with latest template
+		await writeFile(
+			hookDest,
+			existing.trimEnd() + "\n\n# claude-attribution\n" + template,
+		);
+		await chmod(hookDest, 0o755);
+		return "appended";
 	}
 
 	await writeFile(hookDest, template);
@@ -169,13 +288,86 @@ export async function installSlashCommands(repoRoot: string): Promise<void> {
 	}
 }
 
+/** GitHub-hosted runner labels — anything else is self-hosted or custom. */
+const GITHUB_HOSTED_RUNNERS = new Set([
+	"ubuntu-latest",
+	"ubuntu-24.04",
+	"ubuntu-22.04",
+	"ubuntu-20.04",
+	"windows-latest",
+	"windows-2025",
+	"windows-2022",
+	"windows-2019",
+	"macos-latest",
+	"macos-15",
+	"macos-14",
+	"macos-13",
+	"macos-12",
+]);
+
+/**
+ * Scan existing workflows in .github/workflows/ (excluding our own) and return
+ * the most common non-GitHub-hosted `runs-on` value, or null if none found.
+ */
+async function detectRunsOn(repoRoot: string): Promise<string | null> {
+	const workflowsDir = join(repoRoot, ".github", "workflows");
+	if (!existsSync(workflowsDir)) return null;
+
+	let files: string[];
+	try {
+		files = await readdir(workflowsDir);
+	} catch {
+		return null;
+	}
+
+	const freq = new Map<string, number>();
+
+	for (const file of files) {
+		if (file === "claude-attribution-pr.yml") continue;
+		if (!file.endsWith(".yml") && !file.endsWith(".yaml")) continue;
+		try {
+			const content = await readFile(join(workflowsDir, file), "utf8");
+			for (const match of content.matchAll(/^\s+runs-on:\s+(.+)$/gm)) {
+				const raw: string = match[1] ?? "";
+				const value = (raw.split("#")[0] ?? raw).trim();
+				if (!GITHUB_HOSTED_RUNNERS.has(value)) {
+					freq.set(value, (freq.get(value) ?? 0) + 1);
+				}
+			}
+		} catch {
+			continue;
+		}
+	}
+
+	if (freq.size === 0) return null;
+	const sorted = [...freq.entries()].sort((a, b) => b[1] - a[1]);
+	return sorted[0]?.[0] ?? null;
+}
+
 /**
  * Install (or overwrite) the GitHub Actions PR metrics workflow.
+ * Auto-detects the runner from existing workflows; override with runsOn param.
+ * Returns the runner value used and whether it was auto-detected.
  */
-export async function installCiWorkflow(repoRoot: string): Promise<void> {
+export async function installCiWorkflow(
+	repoRoot: string,
+	runsOn?: string,
+): Promise<{ runsOn: string; detected: boolean }> {
 	const workflowsDir = join(repoRoot, ".github", "workflows");
 	await mkdir(workflowsDir, { recursive: true });
-	const content = await readFile(
+
+	let detected = false;
+	if (!runsOn) {
+		const autoDetected = await detectRunsOn(repoRoot);
+		if (autoDetected) {
+			runsOn = autoDetected;
+			detected = true;
+		} else {
+			runsOn = "ubuntu-latest";
+		}
+	}
+
+	const template = await readFile(
 		join(
 			ATTRIBUTION_ROOT,
 			"src",
@@ -185,5 +377,9 @@ export async function installCiWorkflow(repoRoot: string): Promise<void> {
 		),
 		"utf8",
 	);
-	await writeFile(join(workflowsDir, "claude-attribution-pr.yml"), content);
+	await writeFile(
+		join(workflowsDir, "claude-attribution-pr.yml"),
+		template.replace("{{RUNS_ON}}", runsOn),
+	);
+	return { runsOn, detected };
 }

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

@@ -11,7 +11,7 @@ permissions:
 jobs:
   metrics:
     name: Claude Code Attribution Metrics
-    runs-on: ubuntu-latest
+    runs-on: {{RUNS_ON}}
     steps:
       - uses: actions/checkout@v4
         with: