claude-attribution 1.8.0 → 1.9.0

package/src/__tests__/runtime.test.ts

@@ -15,11 +15,22 @@ describe("detectAssistantRuntime", () => {
 		});
 	});
 
-	test("falls back to Claude runtime from Anthropic model env", () => {
+	test("detects Claude runtime without treating alias defaults as the active model", () => {
 		expect(
 			detectAssistantRuntime({
 				ANTHROPIC_DEFAULT_SONNET_MODEL: "claude-sonnet-4-6",
 			}),
+		).toEqual({
+			vendor: "claude",
+			client: "Claude Code",
+		});
+	});
+
+	test("uses ANTHROPIC_MODEL when the active model is explicit", () => {
+		expect(
+			detectAssistantRuntime({
+				ANTHROPIC_MODEL: "claude-sonnet-4-6",
+			}),
 		).toEqual({
 			vendor: "claude",
 			client: "Claude Code",

package/src/__tests__/transcript.test.ts

@@ -0,0 +1,61 @@
+import { describe, expect, test } from "bun:test";
+import { createTempContext, writeTranscript } from "./integration-helpers.ts";
+import { parseTranscript } from "../metrics/transcript.ts";
+
+describe("parseTranscript", () => {
+	test("counts real user prompts and ignores tool_result rows", async () => {
+		const ctx = await createTempContext("transcript-parser");
+		const originalHome = process.env.HOME;
+		try {
+			process.env.HOME = ctx.home;
+			const repo = "/Users/alice.smith/Code/my-repo";
+			const sessionId = "session-1";
+			await writeTranscript(ctx.home, repo, sessionId, [
+				{
+					type: "user",
+					timestamp: "2026-04-01T10:00:00.000Z",
+					message: { role: "user", content: "Add a helper" },
+				},
+				{
+					type: "assistant",
+					timestamp: "2026-04-01T10:00:05.000Z",
+					message: {
+						role: "assistant",
+						model: "claude-sonnet-4-6",
+						usage: { input_tokens: 10, output_tokens: 5 },
+						content: [{ type: "tool_use", name: "WebSearch", input: {} }],
+					},
+				},
+				{
+					type: "user",
+					timestamp: "2026-04-01T10:00:07.000Z",
+					toolUseResult: { tool: "WebSearch" },
+					message: {
+						role: "user",
+						content: [{ type: "tool_result" }],
+					},
+				},
+				{
+					type: "assistant",
+					timestamp: "2026-04-01T10:00:12.000Z",
+					message: {
+						role: "assistant",
+						model: "claude-sonnet-4-6",
+						usage: { input_tokens: 12, output_tokens: 8 },
+						content: [{ type: "text" }],
+					},
+				},
+			]);
+
+			const result = await parseTranscript(sessionId, repo);
+			expect(result).not.toBeNull();
+			expect(result?.humanPromptCount).toBe(1);
+			expect(result?.toolCounts).toEqual({ WebSearch: 1 });
+			expect(result?.totals.totalCalls).toBe(2);
+			expect(result?.aiMinutes).toBe(0);
+		} finally {
+			process.env.HOME = originalHome;
+			await ctx.cleanup();
+		}
+	});
+});

package/src/attribution/commit.ts

@@ -31,11 +31,13 @@ import {
 	attributeLines,
 	aggregateTotals,
 	type AttributionResult,
+	type AssistantRuntimeInfo,
 	type FileAttribution,
 	type LineAttribution,
 	hashLine,
 } from "./differ.ts";
-import { parseTranscript } from "../metrics/transcript.ts";
+import { resolveCopilotSessionId } from "../metrics/copilot-session.ts";
+import { parseLocalSession } from "../metrics/local-session.ts";
 import { detectAssistantRuntime } from "./runtime.ts";
 import {
 	buildSessionMetrics,
@@ -88,47 +90,66 @@ import {
 async function resolveSessionForCommit(
 	repoRoot: string,
 	changedFiles: string[],
+	branch: string | null,
 ): Promise<string | null> {
 	const fromCurrentSession = await readCurrentSession(repoRoot);
 	if (fromCurrentSession) return fromCurrentSession;
 
 	const toolLog = join(repoRoot, ".claude", "logs", "tool-usage.jsonl");
-	if (!existsSync(toolLog)) return null;
+	if (existsSync(toolLog)) {
+		try {
+			const raw = await readFile(toolLog, "utf8");
+			const EIGHT_HOURS = 8 * 60 * 60 * 1000;
+			const recentSessions: string[] = [];
+			const seen = new Set<string>();
+			for (const line of raw.trim().split("\n").filter(Boolean).reverse()) {
+				const entry = JSON.parse(line) as { session?: string; timestamp?: string };
+				if (!entry.session || !entry.timestamp || seen.has(entry.session)) continue;
+				const age = Date.now() - new Date(entry.timestamp).getTime();
+				if (age >= EIGHT_HOURS) continue;
+				seen.add(entry.session);
+				recentSessions.push(entry.session);
+			}
+			if (recentSessions.length > 0) {
+				if (changedFiles.length > 0) {
+					const changedAbsPaths = changedFiles.map((relPath) => join(repoRoot, relPath));
+					for (const candidate of recentSessions) {
+						const hasMatchingCheckpoint = await Promise.all(
+							changedAbsPaths.map((absPath) =>
+								loadCheckpoint(candidate, absPath, "after")
+									.then((checkpoint) => checkpoint !== null)
+									.catch(() => false),
+							),
+						).then((matches) => matches.some(Boolean));
+						if (hasMatchingCheckpoint) return candidate;
+					}
+				}
 
-	try {
-		const raw = await readFile(toolLog, "utf8");
-		const EIGHT_HOURS = 8 * 60 * 60 * 1000;
-		const recentSessions: string[] = [];
-		const seen = new Set<string>();
-		for (const line of raw.trim().split("\n").filter(Boolean).reverse()) {
-			const entry = JSON.parse(line) as { session?: string; timestamp?: string };
-			if (!entry.session || !entry.timestamp || seen.has(entry.session)) continue;
-			const age = Date.now() - new Date(entry.timestamp).getTime();
-			if (age >= EIGHT_HOURS) continue;
-			seen.add(entry.session);
-			recentSessions.push(entry.session);
-		}
-		if (recentSessions.length === 0) return null;
-
-		if (changedFiles.length > 0) {
-			const changedAbsPaths = changedFiles.map((relPath) => join(repoRoot, relPath));
-			for (const candidate of recentSessions) {
-				const hasMatchingCheckpoint = await Promise.all(
-					changedAbsPaths.map((absPath) =>
-						loadCheckpoint(candidate, absPath, "after")
-							.then((checkpoint) => checkpoint !== null)
-							.catch(() => false),
-					),
-				).then((matches) => matches.some(Boolean));
-				if (hasMatchingCheckpoint) return candidate;
+				return recentSessions[0] ?? null;
 			}
+		} catch {
+			// Non-fatal
 		}
+	}
 
-		return recentSessions[0] ?? null;
-	} catch {
-		// Non-fatal
+	return await resolveCopilotSessionId(repoRoot, branch).catch(() => null);
+}
+
+function mergeAssistantRuntime(
+	runtime: AssistantRuntimeInfo | undefined,
+	provider: "claude" | "copilot" | undefined,
+	transcriptModels: { modelFull: string }[],
+): AssistantRuntimeInfo | undefined {
+	if (provider === "copilot") {
+		return {
+			vendor: "copilot",
+			client: runtime?.client ?? "GitHub Copilot CLI",
+			clientVersion: runtime?.clientVersion,
+			modelFamily: transcriptModels[0]?.modelFull ?? runtime?.modelFamily,
+		};
 	}
-	return null;
+
+	return runtime;
 }
 
 async function main() {
@@ -143,7 +164,7 @@ async function main() {
 			.catch(() => null as string | null),
 		renamedFilesInCommit(repoRoot),
 	]);
-	const sessionId = await resolveSessionForCommit(repoRoot, changedFiles);
+	const sessionId = await resolveSessionForCommit(repoRoot, changedFiles, branch);
 
 	// Process files in parallel — each file attribution is independent.
 	// Return type includes attribution[] so the minimap block can build currentAiHashes.
@@ -227,16 +248,14 @@ async function main() {
 		files: fileResults,
 		totals: aggregateTotals(fileResults),
 	};
-	const assistantRuntime = detectAssistantRuntime();
-	if (assistantRuntime) {
-		result.assistantRuntime = assistantRuntime;
-	}
 	const notesRefsToSync = [NOTES_REF];
 
-	// Attach token usage from the Claude session transcript (non-fatal if unavailable)
+	const detectedRuntime = detectAssistantRuntime();
+
+	// Attach session usage metadata (non-fatal if unavailable)
 	if (sessionId) {
 		const [tx, toolEntries, agentEntries] = await Promise.all([
-			parseTranscript(sessionId, repoRoot).catch(() => null),
+			parseLocalSession(sessionId, repoRoot).catch(() => null),
 			readJsonlForSession<ToolLogEntry>(
 				join(repoRoot, ".claude", "logs", "tool-usage.jsonl"),
 				sessionId,
@@ -246,6 +265,14 @@ async function main() {
 				sessionId,
 			).catch(() => []),
 		]);
+		const mergedRuntime = mergeAssistantRuntime(
+			detectedRuntime ?? undefined,
+			tx?.provider,
+			tx?.byModel ?? [],
+		);
+		if (mergedRuntime) {
+			result.assistantRuntime = mergedRuntime;
+		}
 		if (tx && tx.byModel.length > 0) {
 			result.modelUsage = tx.byModel.map((m) => ({
 				modelFull: m.modelFull,
@@ -261,6 +288,8 @@ async function main() {
 		if (hasSessionMetrics(sessionMetrics)) {
 			result.sessionMetrics = sessionMetrics;
 		}
+	} else if (detectedRuntime) {
+		result.assistantRuntime = detectedRuntime;
 	}
 
 	// Write git note

package/src/attribution/differ.ts

@@ -85,8 +85,9 @@ export function hashLine(line: string): string {
  * Rules:
  *  - AI:    hash present in afterHashes but NOT in beforeHashes
  *           → Claude wrote this line and it survived to the commit unchanged
- *  - MIXED: hash was in afterHashes originally (positional check) but the
- *           committed content differs from what Claude wrote at that position
+ *  - MIXED: committed content sits in a one-for-one replacement span anchored
+ *           by exact surrounding matches, and the replaced after-snapshot line
+ *           was AI-authored
  *           → Claude wrote it, human modified it before committing
  *  - HUMAN: everything else (existed before Claude, or written after Claude
  *           finished without a checkpoint)
@@ -100,13 +101,11 @@ export function hashLine(line: string): string {
  * This is conservative toward AI for identical content — an acceptable trade-off
  * given that truly identical lines are indistinguishable without positional history.
  *
- * **MIXED detection limitation**: MIXED uses a positional index —
- * `afterByIndex[i]` is the hash of Claude's i-th line. If a human inserts or
- * deletes lines above position `i`, the committed file's positions shift while
- * the after-snapshot's positions do not, causing false MIXED classifications.
- * MIXED is therefore a "best effort" signal most accurate when human edits are
- * small in-place tweaks (e.g., changing a value on a line Claude wrote) rather
- * than bulk insertions or deletions that shift line numbers.
+ * **MIXED detection limitation**: MIXED is only inferred for replacement spans
+ * where we can align the after-snapshot and committed file with exact matching
+ * anchors around the changed region. Insertions/deletions without stable
+ * anchors are treated as HUMAN to avoid false positives that would reduce the
+ * reported AI percentage for otherwise all-Claude changes.
  */
 export function attributeLines(
 	beforeLines: string[],
@@ -115,10 +114,10 @@ export function attributeLines(
 ): { attribution: LineAttribution[]; stats: FileAttribution } {
 	const beforeHashes = new Set(beforeLines.map(hashLine));
 	const afterHashes = new Set(afterLines.map(hashLine));
-	// Positional index: line index → hash (for MIXED detection)
 	const afterByIndex = afterLines.map(hashLine);
+	const committedByIndex = committedLines.map(hashLine);
 
-	const attribution: LineAttribution[] = committedLines.map((line, i) => {
+	const attribution: LineAttribution[] = committedLines.map((line) => {
 		const hash = hashLine(line);
 
 		// Blank lines carry no signal
@@ -128,18 +127,75 @@ export function attributeLines(
 			return "AI";
 		}
 
-		// MIXED: Claude wrote something at this position but the human changed it
-		const afterHashAtPos = afterByIndex[i];
-		if (
-			afterHashAtPos !== undefined &&
-			!beforeHashes.has(afterHashAtPos) &&
-			hash !== afterHashAtPos
+		return "HUMAN";
+	});
+
+	function markMixedRange(
+		afterStart: number,
+		afterEnd: number,
+		committedStart: number,
+		committedEnd: number,
+	): void {
+		while (
+			afterStart < afterEnd &&
+			committedStart < committedEnd &&
+			afterByIndex[afterStart] === committedByIndex[committedStart]
 		) {
-			return "MIXED";
+			afterStart++;
+			committedStart++;
 		}
 
-		return "HUMAN";
-	});
+		while (
+			afterStart < afterEnd &&
+			committedStart < committedEnd &&
+			afterByIndex[afterEnd - 1] === committedByIndex[committedEnd - 1]
+		) {
+			afterEnd--;
+			committedEnd--;
+		}
+
+		if (afterStart >= afterEnd || committedStart >= committedEnd) return;
+
+		const nextAfterByHash = new Map<string, number>();
+		for (let i = afterStart; i < afterEnd; i++) {
+			const hash = afterByIndex[i];
+			if (hash !== undefined && !nextAfterByHash.has(hash)) {
+				nextAfterByHash.set(hash, i);
+			}
+		}
+
+		for (let i = committedStart; i < committedEnd; i++) {
+			const hash = committedByIndex[i];
+			if (hash === undefined) continue;
+			const afterMatch = nextAfterByHash.get(hash);
+			if (afterMatch === undefined) continue;
+
+			markMixedRange(afterStart, afterMatch, committedStart, i);
+			markMixedRange(afterMatch + 1, afterEnd, i + 1, committedEnd);
+			return;
+		}
+
+		if (afterEnd - afterStart !== committedEnd - committedStart) return;
+
+		for (let offset = 0; offset < committedEnd - committedStart; offset++) {
+			const committedIndex = committedStart + offset;
+			const afterHash = afterByIndex[afterStart + offset];
+			const committedLine = committedLines[committedIndex];
+			if (
+				afterHash === undefined ||
+				committedLine === undefined ||
+				committedLine.trim() === "" ||
+				attribution[committedIndex] === "AI" ||
+				beforeHashes.has(afterHash)
+			) {
+				continue;
+			}
+
+			attribution[committedIndex] = "MIXED";
+		}
+	}
+
+	markMixedRange(0, afterLines.length, 0, committedLines.length);
 
 	const ai = attribution.filter((a) => a === "AI").length;
 	const human = attribution.filter((a) => a === "HUMAN").length;

package/src/attribution/git-notes.ts

@@ -15,6 +15,7 @@ import { execFile } from "child_process";
 import { promisify } from "util";
 import {
 	aggregateTotals,
+	type AssistantRuntimeInfo,
 	type AttributionResult,
 	type FileAttribution,
 } from "./differ.ts";
@@ -292,6 +293,30 @@ export function isKnownAiActorCommit(meta: CommitMeta): boolean {
 	return false;
 }
 
+function inferAiActorRuntime(meta: CommitMeta): AssistantRuntimeInfo | undefined {
+	const { authorName, authorEmail, message } = meta;
+	const combined = `${authorName}\n${authorEmail}\n${message}`.toLowerCase();
+	if (combined.includes("copilot")) {
+		return {
+			vendor: "copilot",
+			client: "GitHub Copilot",
+		};
+	}
+	if (combined.includes("claude")) {
+		return {
+			vendor: "claude",
+			client: "Claude Code",
+		};
+	}
+	if (authorEmail.includes("[bot]") || authorName.includes("[bot]")) {
+		return {
+			vendor: "unknown",
+			client: authorName || "AI agent",
+		};
+	}
+	return undefined;
+}
+
 /**
  * Build a 100% AI AttributionResult for a commit without running the
  * checkpoint-based differ. All non-blank committed lines are marked AI.
@@ -336,5 +361,6 @@ export async function buildAllAiResult(
 		timestamp: meta.timestamp,
 		files: fileResults,
 		totals: aggregateTotals(fileResults),
+		assistantRuntime: inferAiActorRuntime(meta),
 	};
 }

package/src/attribution/runtime.ts

@@ -17,16 +17,17 @@ export function detectAssistantRuntime(
 		};
 	}
 
-	const anthropicModel =
-		firstNonEmpty(env["ANTHROPIC_MODEL"]) ??
-		firstNonEmpty(env["ANTHROPIC_DEFAULT_OPUS_MODEL"]) ??
-		firstNonEmpty(env["ANTHROPIC_DEFAULT_SONNET_MODEL"]) ??
-		firstNonEmpty(env["ANTHROPIC_DEFAULT_HAIKU_MODEL"]);
-	if (anthropicModel) {
+	const anthropicModel = firstNonEmpty(env["ANTHROPIC_MODEL"]);
+	const hasClaudeRuntimeHint =
+		anthropicModel !== undefined ||
+		firstNonEmpty(env["ANTHROPIC_DEFAULT_OPUS_MODEL"]) !== undefined ||
+		firstNonEmpty(env["ANTHROPIC_DEFAULT_SONNET_MODEL"]) !== undefined ||
+		firstNonEmpty(env["ANTHROPIC_DEFAULT_HAIKU_MODEL"]) !== undefined;
+	if (hasClaudeRuntimeHint) {
 		return {
 			vendor: "claude",
 			client: "Claude Code",
-			modelFamily: anthropicModel,
+			...(anthropicModel ? { modelFamily: anthropicModel } : {}),
 		};
 	}
 

package/src/metrics/claude-projects.ts

@@ -0,0 +1,48 @@
+import { existsSync } from "fs";
+import { readdir } from "fs/promises";
+import { homedir } from "os";
+import { join, resolve } from "path";
+
+function legacyProjectKey(repoRoot: string): string {
+	return resolve(repoRoot).replace(/\//g, "-");
+}
+
+function sanitizeProjectKey(repoRoot: string): string {
+	return resolve(repoRoot).replace(/[^A-Za-z0-9-]/g, "-");
+}
+
+function canonicalProjectKey(value: string): string {
+	return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+
+export function claudeProjectKey(repoRoot: string): string {
+	return sanitizeProjectKey(repoRoot);
+}
+
+export function claudeProjectsRoot(
+	homeDir = process.env["HOME"] ?? homedir(),
+): string {
+	return join(homeDir, ".claude", "projects");
+}
+
+export async function resolveClaudeProjectDir(
+	repoRoot: string,
+	projectsRoot = claudeProjectsRoot(),
+): Promise<string | null> {
+	for (const key of new Set([claudeProjectKey(repoRoot), legacyProjectKey(repoRoot)])) {
+		const dir = join(projectsRoot, key);
+		if (existsSync(dir)) return dir;
+	}
+
+	if (!existsSync(projectsRoot)) return null;
+
+	const expected = canonicalProjectKey(resolve(repoRoot));
+	for (const entry of await readdir(projectsRoot, { withFileTypes: true })) {
+		if (!entry.isDirectory()) continue;
+		if (canonicalProjectKey(entry.name) === expected) {
+			return join(projectsRoot, entry.name);
+		}
+	}
+
+	return null;
+}