claude-attribution 1.2.5 → 1.2.8

package/src/metrics/collect.ts

@@ -29,8 +29,11 @@ const execFileAsync = promisify(execFile);
 export interface MetricsData {
 	repoRoot: string;
 	sessionId: string;
+	/** Notable non-file-op tools used (Bash, Read, Write, Edit etc. excluded). */
 	toolCounts: Map<string, number>;
 	agentCounts: Map<string, number>;
+	/** Slash command skills invoked (e.g. ["pr", "metrics"]). */
+	skillNames: string[];
 	transcript: TranscriptResult | null;
 	attributions: AttributionResult[];
 	lastSeenByFile: Map<string, FileAttribution>;
@@ -43,6 +46,44 @@ export interface MetricsData {
 	} | null;
 }
 
+/**
+ * Tools that are routine file/task operations — excluded from the metrics
+ * display because they add noise without conveying meaningful intent.
+ * Skill invocations are tracked separately by skill name.
+ */
+const BORING_TOOLS = new Set([
+	// File operations
+	"Read",
+	"Write",
+	"Edit",
+	"Glob",
+	"Grep",
+	"NotebookEdit",
+	"MultiEdit",
+	// Task/todo management
+	"TaskCreate",
+	"TaskUpdate",
+	"TaskGet",
+	"TaskList",
+	"TaskOutput",
+	"TaskStop",
+	// Planning & worktree lifecycle
+	"EnterPlanMode",
+	"ExitPlanMode",
+	"EnterWorktree",
+	"ExitWorktree",
+	// Cron
+	"CronCreate",
+	"CronDelete",
+	"CronList",
+	// Shell (too generic — any meaningful external calls are implicit in the PR)
+	"Bash",
+	// Skill is tracked by name in skillNames, not toolCounts
+	"Skill",
+	// Agent is tracked in agentCounts via agent-activity.jsonl
+	"Agent",
+]);
+
 async function readSessionStart(repoRoot: string): Promise<Date | null> {
 	const markerPath = join(
 		repoRoot,
@@ -201,7 +242,7 @@ export async function collectMetrics(
 				join(logDir, "tool-usage.jsonl"),
 				sessionId,
 				sessionStart ?? undefined,
-			) as Promise<{ tool?: string }[]>,
+			) as Promise<{ tool?: string; skill?: string }[]>,
 			readJsonlForSession(
 				join(logDir, "agent-activity.jsonl"),
 				sessionId,
@@ -212,10 +253,18 @@ export async function collectMetrics(
 			getMinimapTotals(root),
 		]);
 
-	// Tool counts
+	// Tool counts — skip boring file ops and infrastructure tools.
+	// Skill invocations are tracked separately by name.
 	const toolCounts = new Map<string, number>();
+	const skillNames: string[] = [];
 	for (const e of toolEntries) {
-		if (e.tool) toolCounts.set(e.tool, (toolCounts.get(e.tool) ?? 0) + 1);
+		if (!e.tool) continue;
+		if (e.tool === "Skill") {
+			if (e.skill) skillNames.push(e.skill);
+			continue;
+		}
+		if (BORING_TOOLS.has(e.tool)) continue;
+		toolCounts.set(e.tool, (toolCounts.get(e.tool) ?? 0) + 1);
 	}
 
 	// Agent counts (SubagentStart events only)
@@ -261,6 +310,7 @@ export async function collectMetrics(
 		sessionId,
 		toolCounts,
 		agentCounts,
+		skillNames,
 		transcript,
 		attributions,
 		lastSeenByFile,
@@ -269,11 +319,36 @@ export async function collectMetrics(
 	};
 }
 
+/** Format a session time summary. Returns empty string when no time data. */
+function formatSessionLine(transcript: TranscriptResult): string {
+	const parts: string[] = [];
+
+	parts.push(
+		`${transcript.humanPromptCount} prompt${transcript.humanPromptCount === 1 ? "" : "s"}`,
+	);
+
+	const {
+		activeMinutes: total,
+		aiMinutes: ai,
+		humanMinutes: human,
+	} = transcript;
+	if (total > 0) {
+		if (human > 0) {
+			parts.push(`${total}m total (${ai}m AI · ${human}m human)`);
+		} else {
+			parts.push(`${total}m`);
+		}
+	}
+
+	return parts.join(" · ");
+}
+
 export function renderMetrics(data: MetricsData): string {
 	const {
 		repoRoot,
 		toolCounts,
 		agentCounts,
+		skillNames,
 		transcript,
 		lastSeenByFile,
 		allTranscripts,
@@ -286,7 +361,7 @@ export function renderMetrics(data: MetricsData): string {
 	out("## Claude Code Metrics");
 	out();
 
-	// Headline: AI% + active time (most important stat, shown first)
+	// Headline: AI% (most important stat, shown first)
 	const allFileStats = [...lastSeenByFile.values()];
 	const hasAttribution = allFileStats.length > 0;
 	if (minimapTotals && minimapTotals.total > 0) {
@@ -304,30 +379,26 @@ export function renderMetrics(data: MetricsData): string {
 				minimapTotals.total > 0
 					? Math.round((prTotal / minimapTotals.total) * 100)
 					: 0;
-			const activePart =
-				transcript && transcript.activeMinutes > 0
-					? ` · Active: ${transcript.activeMinutes}m`
-					: "";
 			out(
-				`**This PR:** ${prTotal} lines changed (${codebasePct}% of codebase) · ${prPctAi}% Claude edits · ${prAi} AI lines${activePart}`,
+				`**This PR:** ${prTotal} lines changed (${codebasePct}% of codebase) · ${prPctAi}% Claude edits · ${prAi} AI lines`,
 			);
 		}
 		out();
 	} else if (hasAttribution) {
 		const { ai, total, pctAi } = aggregateTotals(allFileStats);
-		const activePart =
-			transcript && transcript.activeMinutes > 0
-				? ` · Active: ${transcript.activeMinutes}m`
-				: "";
-		out(
-			`**AI contribution: ~${pctAi}%** (${ai} of ${total} committed lines)${activePart}`,
-		);
-		out();
-	} else if (transcript && transcript.activeMinutes > 0) {
-		out(`**Active session time:** ${transcript.activeMinutes}m`);
+		out(`**AI contribution: ~${pctAi}%** (${ai} of ${total} committed lines)`);
 		out();
 	}
 
+	// Session: prompts + time breakdown
+	if (transcript) {
+		const sessionLine = formatSessionLine(transcript);
+		if (sessionLine) {
+			out(`**Session:** ${sessionLine}`);
+			out();
+		}
+	}
+
 	// Model usage table
 	if (transcript) {
 		out("| Model | Calls | Input | Output | Cache |");
@@ -344,8 +415,6 @@ export function renderMetrics(data: MetricsData): string {
 			`| **Total** | ${t.totalCalls} | ${kFormat(t.totalInputTokens)} | ${kFormat(t.totalOutputTokens)} | ${kFormat(totalCache)} |`,
 		);
 		out();
-		out(`**Human prompts (steering effort):** ${transcript.humanPromptCount}`);
-		out();
 	}
 
 	// Multi-session rollup (shown when multiple Claude sessions contributed)
@@ -362,6 +431,8 @@ export function renderMetrics(data: MetricsData): string {
 					t.totals.totalCacheCreationTokens +
 					t.totals.totalCacheReadTokens,
 				humanPromptCount: acc.humanPromptCount + t.humanPromptCount,
+				aiMinutes: acc.aiMinutes + t.aiMinutes,
+				humanMinutes: acc.humanMinutes + t.humanMinutes,
 				activeMinutes: acc.activeMinutes + t.activeMinutes,
 			}),
 			{
@@ -370,6 +441,8 @@ export function renderMetrics(data: MetricsData): string {
 				totalOutputTokens: 0,
 				totalCacheTokens: 0,
 				humanPromptCount: 0,
+				aiMinutes: 0,
+				humanMinutes: 0,
 				activeMinutes: 0,
 			},
 		);
@@ -379,24 +452,35 @@ export function renderMetrics(data: MetricsData): string {
 			`| ${agg.totalCalls} | ${kFormat(agg.totalInputTokens)} | ${kFormat(agg.totalOutputTokens)} | ${kFormat(agg.totalCacheTokens)} |`,
 		);
 		out();
-		out(`**Total human prompts:** ${agg.humanPromptCount}`);
-		if (agg.activeMinutes > 0) {
-			out(`**Total active session time:** ${agg.activeMinutes}m`);
+		const aggSessionLine = [
+			`${agg.humanPromptCount} prompt${agg.humanPromptCount === 1 ? "" : "s"}`,
+			...(agg.activeMinutes > 0
+				? agg.humanMinutes > 0
+					? [
+							`${agg.activeMinutes}m total (${agg.aiMinutes}m AI · ${agg.humanMinutes}m human)`,
+						]
+					: [`${agg.activeMinutes}m`]
+				: []),
+		].join(" · ");
+		if (aggSessionLine) {
+			out(`**Total session:** ${aggSessionLine}`);
 		}
 		out();
 	}
 
-	// <details> block — tools, agents, per-file breakdown
+	// <details> block — skills, agents, notable tools, per-file breakdown
 	const claudeFiles = [...lastSeenByFile.entries()].filter(
 		([, stats]) => stats.ai > 0 || stats.mixed > 0,
 	);
-	const hasTools = toolCounts.size > 0;
+	const hasSkills = skillNames.length > 0;
 	const hasAgents = agentCounts.size > 0;
+	const hasNotableTools = toolCounts.size > 0;
 	const hasFiles = claudeFiles.length > 0;
 
 	const summaryParts: string[] = [];
-	if (hasTools) summaryParts.push("Tools");
+	if (hasSkills) summaryParts.push("Skills");
 	if (hasAgents) summaryParts.push("Agents");
+	if (hasNotableTools) summaryParts.push("Tools");
 	if (hasFiles) summaryParts.push("Files");
 	if (summaryParts.length === 0) summaryParts.push("Details");
 
@@ -404,27 +488,36 @@ export function renderMetrics(data: MetricsData): string {
 	out(`<summary>${summaryParts.join(" · ")}</summary>`);
 	out();
 
-	if (hasTools) {
-		const toolLine = [...toolCounts.entries()]
-			.sort((a, b) => b[1] - a[1])
-			.map(([tool, count]) => `${tool} ×${count}`)
-			.join(", ");
-		out(`**Tools:** ${toolLine}`);
-		out();
-	} else {
-		out("_No tool usage logs found_");
+	if (hasSkills) {
+		// Deduplicate and show slash command names
+		const unique = [...new Set(skillNames)];
+		out(`**Skills:** ${unique.map((s) => `/${s}`).join(", ")}`);
 		out();
 	}
 
 	if (hasAgents) {
 		const agentLine = [...agentCounts.entries()]
 			.sort((a, b) => b[1] - a[1])
-			.map(([agent, count]) => `${agent} ×${count}`)
+			.map(([agent, count]) => (count > 1 ? `${agent} ×${count}` : agent))
 			.join(", ");
 		out(`**Agents:** ${agentLine}`);
 		out();
 	}
 
+	if (hasNotableTools) {
+		const toolLine = [...toolCounts.entries()]
+			.sort((a, b) => b[1] - a[1])
+			.map(([tool, count]) => (count > 1 ? `${tool} ×${count}` : tool))
+			.join(", ");
+		out(`**External tools:** ${toolLine}`);
+		out();
+	}
+
+	if (!hasSkills && !hasAgents && !hasNotableTools) {
+		out("_No tool usage logs found_");
+		out();
+	}
+
 	if (hasFiles) {
 		out("#### Files");
 		out();

package/src/metrics/transcript.ts

@@ -12,7 +12,7 @@
  *   ~/.claude/projects/<project-key>/<session-id>/subagents/<agent-id>.jsonl
  *
  * This module reads both main and subagent transcripts, merges them by model,
- * and returns aggregated token/model usage + human prompt count.
+ * and returns aggregated token/model usage + human prompt count + time breakdown.
  */
 import { readFile, readdir } from "fs/promises";
 import { existsSync } from "fs";
@@ -40,8 +40,12 @@ export interface TranscriptResult {
 		totalCacheReadTokens: number;
 	};
 	humanPromptCount: number;
-	/** Active session time in minutes (idle gaps >15 min are excluded). */
+	/** Total active session time in minutes (idle gaps >15 min excluded). */
 	activeMinutes: number;
+	/** Minutes Claude was actively processing (human→assistant gaps). */
+	aiMinutes: number;
+	/** Minutes the human was active between Claude responses (>30s gaps, <15m). */
+	humanMinutes: number;
 }
 
 interface TranscriptEntry {
@@ -58,6 +62,11 @@ interface TranscriptEntry {
 	};
 }
 
+interface TimedMessage {
+	type: string;
+	ts: number;
+}
+
 function modelShort(full: string): ModelUsage["modelShort"] {
 	if (/opus/i.test(full)) return "Opus";
 	if (/sonnet/i.test(full)) return "Sonnet";
@@ -82,12 +91,12 @@ function projectKey(repoRoot: string): string {
 async function parseTranscriptFile(filePath: string): Promise<{
 	entries: TranscriptEntry[];
 	humanCount: number;
-	timestamps: number[];
+	timedMessages: TimedMessage[];
 }> {
 	const raw = await readFile(filePath, "utf8");
 	const entries: TranscriptEntry[] = [];
 	let humanCount = 0;
-	const timestamps: number[] = [];
+	const timedMessages: TimedMessage[] = [];
 
 	for (const line of raw.split("\n")) {
 		const trimmed = line.trim();
@@ -96,34 +105,62 @@ async function parseTranscriptFile(filePath: string): Promise<{
 			const entry = JSON.parse(trimmed) as TranscriptEntry;
 			entries.push(entry);
 			if (entry.type === "human") humanCount++;
-			if (entry.timestamp) {
+			if (entry.type && entry.timestamp) {
 				const ms = new Date(entry.timestamp).getTime();
-				if (!isNaN(ms)) timestamps.push(ms);
+				if (!isNaN(ms)) timedMessages.push({ type: entry.type, ts: ms });
 			}
 		} catch {
 			// Skip malformed lines
 		}
 	}
 
-	return { entries, humanCount, timestamps };
+	return { entries, humanCount, timedMessages };
 }
 
 /**
- * Compute active session time in minutes from a sorted list of timestamps.
+ * Compute AI vs human time breakdown from a sequence of timed messages.
  *
- * Sums consecutive gaps only when the gap is under 15 minutes (900_000ms).
- * Gaps of 15+ minutes are treated as idle (away from keyboard, blocked on CI,
- * etc.) and excluded so they don't inflate the active time metric.
+ * - human→* gap: Claude is processing (AI time)
+ * - assistant→* gap <30s: automated tool result turnaround (AI time)
+ * - assistant→* gap 30s–15m: human reviewing/thinking (human time)
+ * - Any gap ≥15m: idle, excluded
  */
-function computeActiveMinutes(allTimestamps: number[]): number {
-	const sorted = [...allTimestamps].sort((a, b) => a - b);
-	let totalMs = 0;
-	const IDLE_THRESHOLD_MS = 900_000; // 15 minutes
+function computeTimeBreakdown(messages: TimedMessage[]): {
+	totalMinutes: number;
+	aiMinutes: number;
+	humanMinutes: number;
+} {
+	const sorted = [...messages].sort((a, b) => a.ts - b.ts);
+	const IDLE_MS = 900_000; // 15 min
+	const AUTO_MS = 30_000; // 30 sec — automated tool turnaround
+
+	let aiMs = 0;
+	let humanMs = 0;
+
 	for (let i = 1; i < sorted.length; i++) {
-		const gap = (sorted[i] ?? 0) - (sorted[i - 1] ?? 0);
-		if (gap < IDLE_THRESHOLD_MS) totalMs += gap;
+		const prev = sorted[i - 1]!;
+		const curr = sorted[i]!;
+		const gap = curr.ts - prev.ts;
+		if (gap >= IDLE_MS) continue; // idle gap, skip
+
+		if (prev.type === "human") {
+			// Claude is processing a message
+			aiMs += gap;
+		} else {
+			// Gap after an assistant message
+			if (gap < AUTO_MS) {
+				aiMs += gap; // automated tool result
+			} else {
+				humanMs += gap; // human reviewing / typing next message
+			}
+		}
 	}
-	return Math.round(totalMs / 60_000);
+
+	return {
+		aiMinutes: Math.round(aiMs / 60_000),
+		humanMinutes: Math.round(humanMs / 60_000),
+		totalMinutes: Math.round((aiMs + humanMs) / 60_000),
+	};
 }
 
 function aggregateEntries(entries: TranscriptEntry[]): Map<string, ModelUsage> {
@@ -164,8 +201,9 @@ function aggregateEntries(entries: TranscriptEntry[]): Map<string, ModelUsage> {
  * ~/.claude/projects/<key>/ directory structure. Aggregates token counts by model
  * (Opus / Sonnet / Haiku / Unknown) and counts human prompt turns.
  *
- * Human prompt count is used as a proxy for "steering effort" in the /metrics output
- * — it represents how many times the developer had to direct Claude.
+ * Time breakdown uses only the main transcript's message sequence (human vs
+ * assistant), since subagent messages are automated orchestration — not human
+ * interaction. Human→assistant gaps = AI time; assistant→human gaps >30s = human time.
  *
  * Returns null if the session transcript file doesn't exist (session not found).
  */
@@ -183,21 +221,17 @@ export async function parseTranscript(
 	const {
 		entries: mainEntries,
 		humanCount,
-		timestamps: mainTimestamps,
+		timedMessages,
 	} = await parseTranscriptFile(mainFile);
 	const combined = aggregateEntries(mainEntries);
-	const allTimestamps: number[] = [...mainTimestamps];
 
-	// Merge subagent transcripts
+	// Merge subagent transcripts (token counts only — exclude from time breakdown)
 	const subagentDir = join(transcriptDir, sessionId, "subagents");
 	if (existsSync(subagentDir)) {
 		for (const file of (await readdir(subagentDir)).filter((f) =>
 			f.endsWith(".jsonl"),
 		)) {
-			const { entries, timestamps } = await parseTranscriptFile(
-				join(subagentDir, file),
-			);
-			allTimestamps.push(...timestamps);
+			const { entries } = await parseTranscriptFile(join(subagentDir, file));
 			for (const [model, usage] of aggregateEntries(entries)) {
 				const existing = combined.get(model);
 				if (!existing) {
@@ -235,11 +269,16 @@ export async function parseTranscript(
 		},
 	);
 
+	const { totalMinutes, aiMinutes, humanMinutes } =
+		computeTimeBreakdown(timedMessages);
+
 	return {
 		sessionId,
 		byModel,
 		totals,
 		humanPromptCount: humanCount,
-		activeMinutes: computeActiveMinutes(allTimestamps),
+		activeMinutes: totalMinutes,
+		aiMinutes,
+		humanMinutes,
 	};
 }