agent-optic 0.2.0

package/src/parsers/content-blocks.ts

@@ -0,0 +1,58 @@
+import type { ContentBlock } from "../types/transcript.js";
+import type { ToolCallSummary } from "../types/session.js";
+import { categorizeToolName, toolDisplayName } from "./tool-categories.js";
+
+/** Extract text content from message content (string or ContentBlock[]). */
+export function extractText(content: string | ContentBlock[] | undefined): string {
+	if (!content) return "";
+	if (typeof content === "string") return content;
+	return content
+		.filter((b): b is ContentBlock & { text: string } => b.type === "text" && !!b.text)
+		.map((b) => b.text)
+		.join("\n");
+}
+
+/** Extract tool call summaries from content blocks. */
+export function extractToolCalls(content: string | ContentBlock[] | undefined): ToolCallSummary[] {
+	if (!content || typeof content === "string") return [];
+
+	return content
+		.filter((b): b is ContentBlock & { name: string } => b.type === "tool_use" && !!b.name)
+		.map((b) => ({
+			name: b.name,
+			displayName: toolDisplayName(b.name, b.input as Record<string, unknown> | undefined),
+			category: categorizeToolName(b.name),
+			target: extractToolTarget(b),
+		}));
+}
+
+/** Extract file paths referenced in tool use blocks. */
+export function extractFilePaths(content: string | ContentBlock[] | undefined): string[] {
+	if (!content || typeof content === "string") return [];
+
+	const paths: string[] = [];
+	for (const block of content) {
+		if (block.type !== "tool_use" || !block.input) continue;
+		const input = block.input as Record<string, string>;
+		if (input.file_path) paths.push(input.file_path);
+		if (input.notebook_path) paths.push(input.notebook_path);
+	}
+	return paths;
+}
+
+/** Count thinking blocks in content. */
+export function countThinkingBlocks(content: string | ContentBlock[] | undefined): number {
+	if (!content || typeof content === "string") return 0;
+	return content.filter((b) => b.type === "thinking").length;
+}
+
+function extractToolTarget(block: ContentBlock): string | undefined {
+	const input = block.input as Record<string, string> | undefined;
+	if (!input) return undefined;
+	if (input.file_path) return input.file_path;
+	if (input.notebook_path) return input.notebook_path;
+	if (input.command) return input.command.split(" ")[0];
+	if (input.pattern) return input.pattern;
+	if (input.query) return input.query.slice(0, 80);
+	return undefined;
+}

package/src/parsers/session-detail.ts

@@ -0,0 +1,323 @@
+import { join } from "node:path";
+import type { PrivacyConfig } from "../types/privacy.js";
+import type { Provider } from "../types/provider.js";
+import type { SessionDetail, SessionInfo, ToolCallSummary } from "../types/session.js";
+import type { TranscriptEntry } from "../types/transcript.js";
+import { encodeProjectPath } from "../utils/paths.js";
+import { canonicalProvider } from "../utils/providers.js";
+import { filterTranscriptEntry, redactString } from "../privacy/redact.js";
+import { extractText, extractToolCalls, extractFilePaths, countThinkingBlocks } from "./content-blocks.js";
+import { categorizeToolName, toolDisplayName } from "./tool-categories.js";
+import {
+	findRolloutFile,
+	parseCodexMessageText,
+	parseCodexToolArguments,
+} from "../readers/codex-rollout-reader.js";
+
+/**
+ * Parse a full session JSONL file into a SessionDetail.
+ * This is the "full" tier — reads and parses every line.
+ */
+export async function parseSessionDetail(
+	provider: Provider,
+	session: SessionInfo,
+	paths: { projectsDir: string; sessionsDir: string },
+	privacy: PrivacyConfig,
+): Promise<SessionDetail> {
+	const normalized = canonicalProvider(provider);
+	if (normalized === "codex") {
+		return parseCodexSessionDetail(session, paths.sessionsDir, privacy);
+	}
+	return parseClaudeSessionDetail(session, paths.projectsDir, privacy);
+}
+
+async function parseClaudeSessionDetail(
+	session: SessionInfo,
+	projectsDir: string,
+	privacy: PrivacyConfig,
+): Promise<SessionDetail> {
+	const detail: SessionDetail = {
+		...session,
+		totalInputTokens: 0,
+		totalOutputTokens: 0,
+		cacheCreationInputTokens: 0,
+		cacheReadInputTokens: 0,
+		messageCount: 0,
+		assistantSummaries: [],
+		toolCalls: [],
+		filesReferenced: [],
+		planReferenced: false,
+		thinkingBlockCount: 0,
+		hasSidechains: false,
+	};
+
+	const encoded = encodeProjectPath(session.project);
+	const filePath = join(projectsDir, encoded, `${session.sessionId}.jsonl`);
+	const file = Bun.file(filePath);
+
+	if (!(await file.exists())) return detail;
+
+	const text = await file.text();
+	const lines = text.split("\n");
+
+	const toolCallSet = new Map<string, ToolCallSummary>();
+	const fileSet = new Set<string>();
+	let gitBranch: string | undefined;
+	let model: string | undefined;
+
+	for (const line of lines) {
+		if (!line.trim()) continue;
+
+		let entry: TranscriptEntry;
+		try {
+			entry = JSON.parse(line);
+		} catch {
+			continue;
+		}
+
+		// Apply privacy filtering
+		const filtered = filterTranscriptEntry(entry, privacy);
+		if (!filtered) continue;
+
+		// Track sidechains
+		if (filtered.isSidechain) {
+			detail.hasSidechains = true;
+		}
+
+		// Extract git branch
+		if (!gitBranch && filtered.gitBranch && filtered.gitBranch !== "HEAD") {
+			gitBranch = filtered.gitBranch;
+		}
+
+		// Track plan references
+		if ((filtered as { planContent?: string }).planContent) {
+			detail.planReferenced = true;
+		}
+
+		if (!filtered.message) continue;
+
+		const { role, content, model: msgModel, usage } = filtered.message;
+
+		// Extract model
+		if (msgModel && !model) {
+			model = msgModel;
+		}
+
+		// Accumulate tokens
+		if (usage) {
+			detail.totalInputTokens += usage.input_tokens ?? 0;
+			detail.totalOutputTokens += usage.output_tokens ?? 0;
+			detail.cacheCreationInputTokens += usage.cache_creation_input_tokens ?? 0;
+			detail.cacheReadInputTokens += usage.cache_read_input_tokens ?? 0;
+		}
+
+		// Count messages
+		if (role === "user" || role === "assistant") {
+			detail.messageCount++;
+		}
+
+		// Process assistant messages
+		if (role === "assistant" && content) {
+			const text = extractText(content);
+			if (text && text.length > 20) {
+				detail.assistantSummaries.push(
+					text.slice(0, 200) + (text.length > 200 ? "..." : ""),
+				);
+			}
+
+			for (const tc of extractToolCalls(content)) {
+				toolCallSet.set(tc.displayName, tc);
+			}
+
+			for (const fp of extractFilePaths(content)) {
+				fileSet.add(fp);
+			}
+
+			detail.thinkingBlockCount += countThinkingBlocks(content);
+		}
+	}
+
+	detail.toolCalls = [...toolCallSet.values()];
+	detail.filesReferenced = [...fileSet];
+	detail.gitBranch = gitBranch;
+	detail.model = model;
+
+	// Limit summaries
+	detail.assistantSummaries = detail.assistantSummaries.slice(0, 10);
+
+	return detail;
+}
+
+async function parseCodexSessionDetail(
+	session: SessionInfo,
+	sessionsDir: string,
+	privacy: PrivacyConfig,
+): Promise<SessionDetail> {
+	const detail: SessionDetail = {
+		...session,
+		totalInputTokens: 0,
+		totalOutputTokens: 0,
+		cacheCreationInputTokens: 0,
+		cacheReadInputTokens: 0,
+		messageCount: 0,
+		assistantSummaries: [],
+		toolCalls: [],
+		filesReferenced: [],
+		planReferenced: false,
+		thinkingBlockCount: 0,
+		hasSidechains: false,
+	};
+
+	const rolloutPath = await findRolloutFile(sessionsDir, session.sessionId);
+	if (!rolloutPath) return detail;
+
+	const file = Bun.file(rolloutPath);
+	if (!(await file.exists())) return detail;
+
+	const toolCallSet = new Map<string, ToolCallSummary>();
+	const fileSet = new Set<string>();
+	let gitBranch: string | undefined;
+	let model: string | undefined;
+
+	const text = await file.text();
+	for (const line of text.split("\n")) {
+		if (!line.trim()) continue;
+
+		let entry: any;
+		try {
+			entry = JSON.parse(line);
+		} catch {
+			continue;
+		}
+
+		if (entry.type === "session_meta") {
+			const branch = entry.payload?.git?.branch;
+			if (!gitBranch && typeof branch === "string" && branch !== "HEAD") {
+				gitBranch = branch;
+			}
+		} else if (entry.type === "turn_context") {
+			const m = entry.payload?.model;
+			if (!model && typeof m === "string") {
+				model = m;
+			}
+		} else if (entry.type === "event_msg") {
+			if (entry.payload?.type === "token_count") {
+				const usage = entry.payload?.info?.last_token_usage;
+				if (usage && typeof usage === "object") {
+					detail.totalInputTokens += Number(usage.input_tokens ?? 0);
+					detail.totalOutputTokens += Number(usage.output_tokens ?? 0);
+					detail.cacheReadInputTokens += Number(usage.cached_input_tokens ?? 0);
+				}
+			}
+
+			if (
+				entry.payload?.type === "user_message" ||
+				entry.payload?.type === "agent_message"
+			) {
+				detail.messageCount++;
+			}
+		} else if (entry.type === "response_item") {
+			if (entry.payload?.type === "reasoning") {
+				detail.thinkingBlockCount++;
+			}
+
+			if (
+				entry.payload?.type === "message" &&
+				entry.payload?.role === "assistant"
+			) {
+				const summary = parseCodexMessageText(entry.payload?.content);
+				if (summary && summary.length > 20) {
+					const redacted =
+						privacy.redactPatterns.length > 0 || privacy.redactHomeDir
+							? redactString(summary, privacy)
+							: summary;
+					detail.assistantSummaries.push(
+						redacted.slice(0, 200) + (redacted.length > 200 ? "..." : ""),
+					);
+				}
+			}
+
+			if (
+				entry.payload?.type === "function_call" &&
+				typeof entry.payload?.name === "string"
+			) {
+				const name = entry.payload.name;
+				const input = parseCodexToolArguments(entry.payload.arguments);
+				const displayName = toolDisplayName(name, input);
+				const target = extractCodexToolTarget(name, input);
+				const summary: ToolCallSummary = {
+					name,
+					displayName,
+					category: categorizeToolName(name),
+					target,
+				};
+				toolCallSet.set(displayName, summary);
+
+				const filePath = extractCodexFilePath(input);
+				if (filePath) fileSet.add(filePath);
+			}
+		}
+	}
+
+	detail.toolCalls = [...toolCallSet.values()];
+	detail.filesReferenced = [...fileSet];
+	detail.gitBranch = gitBranch;
+	detail.model = model;
+	detail.assistantSummaries = detail.assistantSummaries.slice(0, 10);
+	return detail;
+}
+
+function extractCodexFilePath(input: Record<string, unknown> | undefined): string | undefined {
+	if (!input) return undefined;
+	const candidates = ["file_path", "path", "target_file", "notebook_path"];
+	for (const key of candidates) {
+		const value = input[key];
+		if (typeof value === "string" && value.length > 0) return value;
+	}
+	return undefined;
+}
+
+function extractCodexToolTarget(
+	name: string,
+	input: Record<string, unknown> | undefined,
+): string | undefined {
+	const filePath = extractCodexFilePath(input);
+	if (filePath) return filePath;
+
+	if (!input) return undefined;
+	for (const key of ["command", "cmd", "pattern", "query"]) {
+		const value = input[key];
+		if (typeof value === "string" && value.length > 0) {
+			return key === "command" || key === "cmd" ? value.split(" ")[0] : value;
+		}
+	}
+
+	if (name === "exec_command" && typeof input.cmd === "string") {
+		return input.cmd.split(" ")[0];
+	}
+
+	return undefined;
+}
+
+/**
+ * Parse multiple sessions, splitting into detailed (3+ prompts) and short.
+ */
+export async function parseSessions(
+	provider: Provider,
+	sessions: SessionInfo[],
+	paths: { projectsDir: string; sessionsDir: string },
+	privacy: PrivacyConfig,
+): Promise<{ detailed: SessionDetail[]; short: SessionInfo[] }> {
+	const detailed: SessionDetail[] = [];
+	const short: SessionInfo[] = [];
+
+	for (const session of sessions) {
+		if (session.prompts.length >= 3) {
+			detailed.push(await parseSessionDetail(provider, session, paths, privacy));
+		} else {
+			short.push(session);
+		}
+	}
+
+	return { detailed, short };
+}

package/src/parsers/tool-categories.ts

@@ -0,0 +1,86 @@
+import type { ToolCategory } from "../types/session.js";
+
+const TOOL_CATEGORY_MAP: Record<string, ToolCategory> = {
+	// File reading
+	Read: "file_read",
+	Glob: "file_read",
+	Grep: "file_read",
+	ListMcpResourcesTool: "file_read",
+	ReadMcpResourceTool: "file_read",
+
+	// File writing
+	Write: "file_write",
+	Edit: "file_write",
+	NotebookEdit: "file_write",
+
+	// Shell
+	Bash: "shell",
+
+	// Search
+	WebSearch: "search",
+	WebFetch: "web",
+
+	// Task/agent management
+	Task: "task",
+	TaskCreate: "task",
+	TaskUpdate: "task",
+	TaskGet: "task",
+	TaskList: "task",
+	TaskStop: "task",
+	TaskOutput: "task",
+	EnterPlanMode: "task",
+	ExitPlanMode: "task",
+	AskUserQuestion: "task",
+	Skill: "task",
+
+	// Codex tools
+	exec_command: "shell",
+	shell_command: "shell",
+	write_stdin: "shell",
+	apply_patch: "file_write",
+	update_plan: "task",
+	request_user_input: "task",
+	view_image: "file_read",
+};
+
+export function categorizeToolName(name: string): ToolCategory {
+	// Check direct mapping
+	if (name in TOOL_CATEGORY_MAP) return TOOL_CATEGORY_MAP[name];
+
+	// MCP tools with known patterns
+	if (name.startsWith("mcp__")) {
+		if (name.includes("search")) return "search";
+		if (name.includes("fetch") || name.includes("read")) return "file_read";
+		if (name.includes("write") || name.includes("create") || name.includes("edit")) return "file_write";
+		return "other";
+	}
+
+	return "other";
+}
+
+/** Create a human-readable display name for a tool call. */
+export function toolDisplayName(
+	name: string,
+	input?: Record<string, unknown>,
+): string {
+	const shortName = name.startsWith("mcp__")
+		? name.split("__").pop() || name
+		: name;
+
+	if (input?.file_path && typeof input.file_path === "string") {
+		const parts = input.file_path.split("/");
+		const short = parts.slice(-2).join("/");
+		return `${shortName}(${short})`;
+	}
+
+	if (input?.command && typeof input.command === "string") {
+		const cmd = input.command.split(" ")[0];
+		return `${shortName}(${cmd})`;
+	}
+
+	if (input?.pattern && typeof input.pattern === "string") {
+		return `${shortName}(${input.pattern})`;
+	}
+
+	return shortName;
+}

package/src/pricing.ts

@@ -0,0 +1,62 @@
+import type { SessionMeta } from "./types/session.js";
+
+/** Per-million-token pricing in USD. */
+export interface ModelPricing {
+	input: number;
+	output: number;
+	cacheWrite: number;
+	cacheRead: number;
+}
+
+/** Default model pricing (USD per million tokens). */
+export const MODEL_PRICING: Record<string, ModelPricing> = {
+	// Opus 4.5+ ($5/$25)
+	"claude-opus-4-6": { input: 5, output: 25, cacheWrite: 6.25, cacheRead: 0.5 },
+	"claude-opus-4-5-20250514": { input: 5, output: 25, cacheWrite: 6.25, cacheRead: 0.5 },
+
+	// Opus 4.0–4.1 ($15/$75)
+	"claude-opus-4-1-20250514": { input: 15, output: 75, cacheWrite: 18.75, cacheRead: 1.5 },
+	"claude-opus-4-0-20250514": { input: 15, output: 75, cacheWrite: 18.75, cacheRead: 1.5 },
+
+	// Sonnet ($3/$15)
+	"claude-sonnet-4-5-20250929": { input: 3, output: 15, cacheWrite: 3.75, cacheRead: 0.3 },
+	"claude-sonnet-4-5-20250514": { input: 3, output: 15, cacheWrite: 3.75, cacheRead: 0.3 },
+	"claude-sonnet-4-0-20250514": { input: 3, output: 15, cacheWrite: 3.75, cacheRead: 0.3 },
+
+	// Haiku 4.5 ($1/$5)
+	"claude-haiku-4-5-20251001": { input: 1, output: 5, cacheWrite: 1.25, cacheRead: 0.1 },
+
+	// Legacy
+	"claude-haiku-3-5-20241022": { input: 0.8, output: 4, cacheWrite: 1, cacheRead: 0.08 },
+	"claude-3-5-sonnet-20241022": { input: 3, output: 15, cacheWrite: 3.75, cacheRead: 0.3 },
+	"claude-3-5-sonnet-20240620": { input: 3, output: 15, cacheWrite: 3.75, cacheRead: 0.3 },
+	"claude-3-5-haiku-20241022": { input: 0.8, output: 4, cacheWrite: 1, cacheRead: 0.08 },
+	"claude-3-opus-20240229": { input: 15, output: 75, cacheWrite: 18.75, cacheRead: 1.5 },
+};
+
+const FALLBACK_PRICING: ModelPricing = { input: 3, output: 15, cacheWrite: 3.75, cacheRead: 0.3 };
+
+let activePricing: Record<string, ModelPricing> = MODEL_PRICING;
+
+/** Override or extend the pricing table. Merges with built-in defaults. */
+export function setPricing(overrides: Record<string, ModelPricing>): void {
+	activePricing = { ...MODEL_PRICING, ...overrides };
+}
+
+/** Look up pricing for a model, falling back to Sonnet rates. */
+export function getModelPricing(model?: string): ModelPricing {
+	if (!model) return FALLBACK_PRICING;
+	return activePricing[model] ?? FALLBACK_PRICING;
+}
+
+/** Estimate USD cost of a session based on token counts and model. */
+export function estimateCost(session: SessionMeta): number {
+	const pricing = getModelPricing(session.model);
+	const m = 1_000_000;
+	return (
+		(session.totalInputTokens / m) * pricing.input +
+		(session.totalOutputTokens / m) * pricing.output +
+		(session.cacheCreationInputTokens / m) * pricing.cacheWrite +
+		(session.cacheReadInputTokens / m) * pricing.cacheRead
+	);
+}

package/src/privacy/config.ts

@@ -0,0 +1,67 @@
+import type { PrivacyConfig, PrivacyProfile } from "../types/privacy.js";
+
+// Credential patterns: match common API key/token/secret formats
+const CREDENTIAL_PATTERNS = [
+	// Generic: "key"/"token"/"secret"/"password" followed by a long alphanumeric string
+	/(?:key|token|secret|password|api_key|apikey|auth)["\s:=]+[A-Za-z0-9+/=_\-]{20,}/gi,
+	// Bearer tokens
+	/Bearer\s+[A-Za-z0-9+/=_\-\.]{20,}/g,
+	// AWS-style keys
+	/(?:AKIA|ABIA|ACCA|ASIA)[A-Z0-9]{16}/g,
+	// GitHub tokens
+	/gh[pousr]_[A-Za-z0-9_]{36,}/g,
+	// Generic hex secrets (32+ chars)
+	/(?:secret|token|key)["\s:=]+[0-9a-f]{32,}/gi,
+];
+
+const EMAIL_PATTERN = /[a-zA-Z0-9._%+\-]+@[a-zA-Z0-9.\-]+\.[a-zA-Z]{2,}/g;
+const IP_PATTERN = /\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b/g;
+
+const LOCAL_PROFILE: PrivacyConfig = {
+	redactPrompts: false,
+	redactAbsolutePaths: false,
+	redactHomeDir: false,
+	stripThinking: true,
+	stripToolResults: true,
+	redactPatterns: [],
+	excludeProjects: [],
+};
+
+const SHAREABLE_PROFILE: PrivacyConfig = {
+	...LOCAL_PROFILE,
+	redactAbsolutePaths: true,
+	redactHomeDir: true,
+};
+
+const STRICT_PROFILE: PrivacyConfig = {
+	...SHAREABLE_PROFILE,
+	redactPrompts: true,
+	redactPatterns: [...CREDENTIAL_PATTERNS, EMAIL_PATTERN, IP_PATTERN],
+};
+
+export const PRIVACY_PROFILES: Record<PrivacyProfile, PrivacyConfig> = {
+	local: LOCAL_PROFILE,
+	shareable: SHAREABLE_PROFILE,
+	strict: STRICT_PROFILE,
+};
+
+export function resolvePrivacyConfig(
+	profile?: PrivacyProfile,
+	overrides?: Partial<PrivacyConfig>,
+): PrivacyConfig {
+	const base = PRIVACY_PROFILES[profile ?? "local"];
+	if (!overrides) return { ...base };
+	return {
+		...base,
+		...overrides,
+		// Merge arrays rather than replace
+		redactPatterns: [
+			...base.redactPatterns,
+			...(overrides.redactPatterns ?? []),
+		],
+		excludeProjects: [
+			...base.excludeProjects,
+			...(overrides.excludeProjects ?? []),
+		],
+	};
+}

package/src/privacy/redact.ts

@@ -0,0 +1,99 @@
+import { homedir } from "node:os";
+import type { PrivacyConfig } from "../types/privacy.js";
+import type { ContentBlock, TranscriptEntry } from "../types/transcript.js";
+
+const home = homedir();
+
+/** Apply all configured redaction patterns to a string. */
+export function redactString(text: string, config: PrivacyConfig): string {
+	let result = text;
+
+	if (config.redactHomeDir) {
+		result = result.replaceAll(home, "~");
+	}
+
+	if (config.redactAbsolutePaths) {
+		// Replace absolute paths with just the last 2 segments
+		result = result.replace(/\/(?:Users|home)\/[^\s"',;)}\]]+/g, (match) => {
+			const parts = match.split("/");
+			return parts.length > 2 ? parts.slice(-2).join("/") : match;
+		});
+	}
+
+	for (const pattern of config.redactPatterns) {
+		// Clone the regex to reset lastIndex for global patterns
+		const re = new RegExp(pattern.source, pattern.flags);
+		result = result.replace(re, "[REDACTED]");
+	}
+
+	return result;
+}
+
+/** Filter content blocks according to privacy config. */
+function filterContentBlocks(
+	blocks: ContentBlock[],
+	config: PrivacyConfig,
+): ContentBlock[] {
+	const filtered: ContentBlock[] = [];
+
+	for (const block of blocks) {
+		if (config.stripThinking && block.type === "thinking") continue;
+		if (config.stripToolResults && block.type === "tool_result") continue;
+
+		if (block.text && config.redactPatterns.length > 0) {
+			filtered.push({ ...block, text: redactString(block.text, config) });
+		} else {
+			filtered.push(block);
+		}
+	}
+
+	return filtered;
+}
+
+/** Filter a transcript entry according to privacy config. Returns null to skip entirely. */
+export function filterTranscriptEntry(
+	entry: TranscriptEntry,
+	config: PrivacyConfig,
+): TranscriptEntry | null {
+	// Skip toolUseResult entries
+	if (config.stripToolResults && entry.toolUseResult !== undefined) {
+		return null;
+	}
+
+	if (!entry.message) return entry;
+
+	const { role, content } = entry.message;
+
+	// Redact user prompts
+	if (config.redactPrompts && role === "user") {
+		if (typeof content === "string") {
+			return {
+				...entry,
+				message: { ...entry.message, content: "[redacted]" },
+			};
+		}
+	}
+
+	// Filter assistant content blocks
+	if (role === "assistant" && Array.isArray(content)) {
+		const filtered = filterContentBlocks(content as ContentBlock[], config);
+		return {
+			...entry,
+			message: { ...entry.message, content: filtered },
+		};
+	}
+
+	return entry;
+}
+
+/** Check if a project should be excluded. */
+export function isProjectExcluded(
+	projectPath: string,
+	config: PrivacyConfig,
+): boolean {
+	if (config.excludeProjects.length === 0) return false;
+	const lower = projectPath.toLowerCase();
+	return config.excludeProjects.some(
+		(p) => lower.includes(p.toLowerCase()),
+	);
+}