claude-attribution 1.2.5 → 1.2.8

package/src/setup/install.ts

@@ -5,21 +5,12 @@
  *
  * If no path is given, installs into the current working directory.
  */
-import {
-	readFile,
-	writeFile,
-	appendFile,
-	mkdir,
-	mkdtemp,
-	unlink,
-	rmdir,
-} from "fs/promises";
+import { readFile, writeFile, appendFile, mkdir } from "fs/promises";
 import { existsSync } from "fs";
 import { execFile } from "child_process";
 import { promisify } from "util";
-import { resolve, join } from "path";
-import { tmpdir } from "os";
 import { createInterface } from "readline";
+import { resolve, join } from "path";
 import {
 	ATTRIBUTION_ROOT,
 	mergeHooks,
@@ -29,209 +20,122 @@ import {
 	detectHookManager,
 	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");
 
-/**
- * The exact GitHub Actions job name written into our workflow template.
- * Must match the `name:` field of the `metrics` job in pr-metrics-workflow.yml.
- */
-const WORKFLOW_CHECK_NAME = "Claude Code Attribution Metrics";
+// ─── Baseline init prompt ────────────────────────────────────────────────────
 
-/** Extract "owner/repo" from an origin remote URL (SSH or HTTPS). */
-function remoteUrlToSlug(url: string): string | null {
-	const m =
-		url.match(/github\.com[:/]([^/]+\/[^/]+?)(?:\.git)?$/) ??
-		url.match(/github\.com\/([^/]+\/[^/]+?)(?:\.git)?$/);
-	return m?.[1] ?? null;
-}
+const DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
 
-/** Call `gh api <path>` and return parsed JSON, or null on any error. */
-async function ghApiGet(path: string): Promise<unknown> {
-	try {
-		const { stdout } = (await execFileAsync("gh", [
-			"api",
-			path,
-		])) as unknown as {
-			stdout: string;
-		};
-		return JSON.parse(stdout) as unknown;
-	} catch {
-		return null;
-	}
-}
-
-/** Prompt the user for a yes/no answer. Returns false in non-TTY contexts. */
-async function promptYesNo(question: string): Promise<boolean> {
-	if (!process.stdin.isTTY) return false;
+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().toLowerCase() === "y");
+			resolve(answer.trim());
 		});
 	});
 }
 
-function printRequiredCheckNote(branch: string): void {
-	console.log(
-		`\n  ℹ️  To block merges when this workflow fails, add '${WORKFLOW_CHECK_NAME}'`,
-	);
-	console.log(
-		`      to required status checks for '${branch}' in Settings → Branches.`,
-	);
-}
-
 /**
- * PATCH the required status checks for a branch via the GitHub API.
- * Writes the JSON body to a temp file to avoid arg-length issues.
+ * 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 patchRequiredChecks(
-	slug: string,
-	branch: string,
-	body: unknown,
+async function promptBaselineInit(
+	repoRoot: string,
+	claudeDir: string,
 ): Promise<void> {
-	const tmpDir = await mkdtemp(join(tmpdir(), "claude-attribution-api-"));
-	const tmpFile = join(tmpDir, "body.json");
-	try {
-		await writeFile(tmpFile, JSON.stringify(body), { flag: "wx" });
-		await execFileAsync("gh", [
-			"api",
-			`repos/${slug}/branches/${branch}/protection/required_status_checks`,
-			"--method",
-			"PATCH",
-			"--input",
-			tmpFile,
-		]);
-	} finally {
-		await unlink(tmpFile).catch(() => {});
-		await rmdir(tmpDir).catch(() => {});
-	}
-}
+	const flagPath = join(claudeDir, "attribution-state", "baseline-initialized");
 
-/**
- * After installing the workflow, check branch protection / rulesets and offer
- * to add our workflow job as a required status check.
- *
- * - Classic branch protection: fully automatic (detect → prompt → PATCH)
- * - Rulesets: detect only → informational note (ruleset API requires full PUT)
- * - Any error or non-TTY: fall back to informational note
- */
-async function maybeAddRequiredCheck(repoRoot: string): Promise<void> {
 	try {
-		// Resolve the GitHub slug from the origin remote
-		const { stdout: remoteOut } = (await execFileAsync(
-			"git",
-			["remote", "get-url", "origin"],
-			{ cwd: repoRoot },
-		)) as unknown as { stdout: string };
-		const slug = remoteUrlToSlug(remoteOut.trim());
-		if (!slug) return;
-
-		// Get the default branch name
-		const repoData = await ghApiGet(`repos/${slug}`);
-		const branch = (repoData as { default_branch?: string } | null)
-			?.default_branch;
-		if (!branch) return;
-
-		// --- Classic branch protection ---
-		const protection = await ghApiGet(
-			`repos/${slug}/branches/${branch}/protection`,
-		);
-
-		if (!protection) {
-			// No classic protection — check rulesets (detect-only)
-			const rulesets = await ghApiGet(`repos/${slug}/rulesets`);
-			if (Array.isArray(rulesets) && rulesets.length > 0) {
-				// Check if any ruleset already requires our check
-				const alreadyRequired = (
-					rulesets as Array<{
-						rules?: Array<{
-							type: string;
-							parameters?: {
-								required_status_checks?: Array<{ context: string }>;
-							};
-						}>;
-					}>
-				).some((rs) =>
-					rs.rules?.some(
-						(r) =>
-							r.type === "required_status_checks" &&
-							r.parameters?.required_status_checks?.some(
-								(c) => c.context === WORKFLOW_CHECK_NAME,
-							),
-					),
-				);
-				if (alreadyRequired) {
-					console.log(
-						`✓ '${WORKFLOW_CHECK_NAME}' already a required status check`,
-					);
-					return;
-				}
-				console.log(
-					`\n  ℹ️  Ruleset branch protection detected on '${branch}'.`,
-				);
-				console.log(
-					`      Add '${WORKFLOW_CHECK_NAME}' to required status checks`,
-				);
-				console.log(
-					`      in Settings → Rules to block merges on workflow failure.`,
-				);
-			}
+		// 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;
 		}
 
-		// Extract current required check names from classic protection
-		type Check = { context: string; app_id: number };
-		const prot = protection as {
-			required_status_checks?: {
-				strict: boolean;
-				contexts?: string[];
-				checks?: Check[];
-			};
-		};
-		const existingChecks: Check[] =
-			prot.required_status_checks?.checks ??
-			(prot.required_status_checks?.contexts ?? []).map((c) => ({
-				context: c,
-				app_id: -1,
-			}));
-		const strict = prot.required_status_checks?.strict ?? false;
-
-		if (existingChecks.some((c) => c.context === WORKFLOW_CHECK_NAME)) {
-			console.log(`✓ '${WORKFLOW_CHECK_NAME}' already a required status check`);
+		if (!process.stdin.isTTY) {
+			console.log(
+				"\n  ℹ️  Run 'claude-attribution init [--ai | --ai-since <YYYY-MM-DD>]' to set the attribution baseline.",
+			);
 			return;
 		}
 
-		// Prompt
-		console.log(`\n  Branch protection is active on '${branch}'.`);
-		const yes = await promptYesNo(
-			`  Add '${WORKFLOW_CHECK_NAME}' as a required status check? [y/N] `,
+		console.log(
+			"\n  Attribution baseline — how should existing code be treated?",
 		);
-		if (!yes) {
-			printRequiredCheckNote(branch);
-			return;
-		}
-
-		await patchRequiredChecks(slug, branch, {
-			strict,
-			checks: [...existingChecks, { context: WORKFLOW_CHECK_NAME, app_id: -1 }],
-		});
 		console.log(
-			`✓ Added '${WORKFLOW_CHECK_NAME}' as a required status check on '${branch}'`,
+			"    [1] AI          — all current code was written with Claude Code",
 		);
-	} catch {
-		// Any failure — don't break install, just print the note
 		console.log(
-			`\n  ℹ️  Could not configure required status checks automatically.`,
+			"    [2] Human       — assume human-written (AI accumulates from here)",
 		);
 		console.log(
-			`      To block merges on workflow failure, add '${WORKFLOW_CHECK_NAME}'`,
+			"    [3] AI since    — mark commits after a date as AI-written",
 		);
 		console.log(
-			`      to required status checks in your branch protection settings.`,
+			"    [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.",
 		);
 	}
 }
@@ -387,9 +291,12 @@ async function main() {
 	);
 
 	// 5. Check branch protection and offer to add required status check
-	await maybeAddRequiredCheck(targetRepo);
+	await configureRequiredCheck(targetRepo);
+
+	// 6. Prompt for attribution baseline (skipped on re-runs)
+	await promptBaselineInit(targetRepo, claudeDir);
 
-	// 6. Record installed version for auto-upgrade tracking
+	// 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,10 @@ 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 config set prefix "${HOME}/.npm-global"
+          npm install -g claude-attribution
+          echo "${HOME}/.npm-global/bin" >> "$GITHUB_PATH"
 
       - name: Generate metrics
         run: claude-attribution metrics > /tmp/claude-attribution-metrics.md || true