agent-optic 0.2.0

package/src/readers/codex-rollout-reader.ts

@@ -0,0 +1,145 @@
+import { join } from "node:path";
+
+interface CodexSessionHeader {
+	cwd?: string;
+	gitBranch?: string;
+	model?: string;
+	modelProvider?: string;
+}
+
+const rolloutIndexCache = new Map<string, Promise<Map<string, string>>>();
+const headerCache = new Map<string, Promise<CodexSessionHeader>>();
+
+function parseRolloutFilename(
+	filename: string,
+): { date: string; sessionId: string } | null {
+	const m = filename.match(
+		/^rollout-(\d{4}-\d{2}-\d{2})T\d{2}-\d{2}-\d{2}-(.+)\.jsonl$/,
+	);
+	return m ? { date: m[1], sessionId: m[2] } : null;
+}
+
+async function buildRolloutIndex(sessionsDir: string): Promise<Map<string, string>> {
+	const index = new Map<string, string>();
+	const glob = new Bun.Glob("**/*.jsonl");
+	for await (const path of glob.scan({
+		cwd: sessionsDir,
+		absolute: false,
+	})) {
+		const filename = path.split("/").pop()!;
+		const parsed = parseRolloutFilename(filename);
+		if (parsed) index.set(parsed.sessionId, join(sessionsDir, path));
+	}
+	return index;
+}
+
+async function getRolloutIndex(sessionsDir: string): Promise<Map<string, string>> {
+	let promise = rolloutIndexCache.get(sessionsDir);
+	if (!promise) {
+		promise = buildRolloutIndex(sessionsDir);
+		rolloutIndexCache.set(sessionsDir, promise);
+	}
+	return promise;
+}
+
+export async function findRolloutFile(
+	sessionsDir: string,
+	sessionId: string,
+): Promise<string | null> {
+	const index = await getRolloutIndex(sessionsDir);
+	const cached = index.get(sessionId);
+	if (cached) return cached;
+
+	// Fallback for newly created files before cache refresh.
+	const glob = new Bun.Glob(`**/*-${sessionId}.jsonl`);
+	for await (const path of glob.scan({
+		cwd: sessionsDir,
+		absolute: false,
+	})) {
+		const fullPath = join(sessionsDir, path);
+		index.set(sessionId, fullPath);
+		return fullPath;
+	}
+	return null;
+}
+
+export async function readCodexSessionHeader(
+	sessionsDir: string,
+	sessionId: string,
+): Promise<CodexSessionHeader> {
+	const key = `${sessionsDir}:${sessionId}`;
+	let promise = headerCache.get(key);
+	if (!promise) {
+		promise = (async () => {
+			const rolloutPath = await findRolloutFile(sessionsDir, sessionId);
+			if (!rolloutPath) return {};
+
+			const file = Bun.file(rolloutPath);
+			if (!(await file.exists())) return {};
+
+			let cwd: string | undefined;
+			let gitBranch: string | undefined;
+			let model: string | undefined;
+			let modelProvider: string | undefined;
+
+			try {
+				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") {
+						cwd = entry.payload?.cwd;
+						gitBranch = entry.payload?.git?.branch;
+						modelProvider = entry.payload?.model_provider;
+					} else if (entry.type === "turn_context") {
+						model = entry.payload?.model;
+					}
+
+					if (cwd && model) break;
+				}
+			} catch {
+				return {};
+			}
+
+			return { cwd, gitBranch, model, modelProvider };
+		})();
+		headerCache.set(key, promise);
+	}
+
+	return promise;
+}
+
+export function parseCodexMessageText(content: unknown): string {
+	if (!Array.isArray(content)) return "";
+	return content
+		.filter(
+			(el): el is { type: string; text: string } =>
+				!!el &&
+				typeof el === "object" &&
+				typeof (el as any).type === "string" &&
+				typeof (el as any).text === "string" &&
+				((el as any).type === "input_text" ||
+					(el as any).type === "output_text" ||
+					(el as any).type === "text"),
+		)
+		.map((el) => el.text)
+		.join("\n");
+}
+
+export function parseCodexToolArguments(
+	argumentsText: unknown,
+): Record<string, unknown> | undefined {
+	if (typeof argumentsText !== "string" || !argumentsText.trim()) return undefined;
+	try {
+		const parsed = JSON.parse(argumentsText);
+		return parsed && typeof parsed === "object" ? parsed : undefined;
+	} catch {
+		return undefined;
+	}
+}

package/src/readers/history-reader.ts

@@ -0,0 +1,205 @@
+import { dirname, join } from "node:path";
+import type { PrivacyConfig } from "../types/privacy.js";
+import type { Provider } from "../types/provider.js";
+import type { SessionInfo } from "../types/session.js";
+import { toLocalDate } from "../utils/dates.js";
+import { projectName } from "../utils/paths.js";
+import { canonicalProvider } from "../utils/providers.js";
+import { isProjectExcluded, redactString } from "../privacy/redact.js";
+import { readCodexSessionHeader } from "./codex-rollout-reader.js";
+
+interface ClaudeHistoryEntry {
+	display: string;
+	timestamp: number;
+	project: string;
+	sessionId: string;
+	pastedContents?: Record<string, unknown>;
+}
+
+interface CodexHistoryEntry {
+	session_id: string;
+	ts: number;
+	text: string;
+}
+
+/**
+ * Read history.jsonl and group entries into SessionInfo objects.
+ * This is the fast path — no session file reads, just history.jsonl.
+ */
+export async function readHistory(
+	historyFile: string,
+	from: string,
+	to: string,
+	privacy: PrivacyConfig,
+	options?: {
+		provider?: Provider;
+		sessionsDir?: string;
+	},
+): Promise<SessionInfo[]> {
+	const provider = canonicalProvider(options?.provider ?? "claude");
+	if (provider === "codex") {
+		return readCodexHistory(
+			historyFile,
+			from,
+			to,
+			privacy,
+			options?.sessionsDir ?? join(dirname(historyFile), "sessions"),
+		);
+	}
+	return readClaudeHistory(historyFile, from, to, privacy);
+}
+
+async function readClaudeHistory(
+	historyFile: string,
+	from: string,
+	to: string,
+	privacy: PrivacyConfig,
+): Promise<SessionInfo[]> {
+	const file = Bun.file(historyFile);
+	if (!(await file.exists())) return [];
+
+	const text = await file.text();
+	const entries: ClaudeHistoryEntry[] = [];
+
+	for (const line of text.split("\n")) {
+		if (!line.trim()) continue;
+		try {
+			const entry = JSON.parse(line) as ClaudeHistoryEntry;
+			const entryDate = toLocalDate(entry.timestamp);
+
+			// Early exit: skip entries outside date range
+			if (entryDate < from || entryDate > to) continue;
+
+			// Privacy: skip excluded projects
+			if (isProjectExcluded(entry.project, privacy)) continue;
+
+			entries.push(entry);
+		} catch {
+			// skip malformed
+		}
+	}
+
+	// Group by sessionId
+	const sessionMap = new Map<
+		string,
+		{ project: string; prompts: string[]; timestamps: number[] }
+	>();
+
+	for (const entry of entries) {
+		const existing = sessionMap.get(entry.sessionId);
+		const display = privacy.redactPrompts
+			? "[redacted]"
+			: privacy.redactPatterns.length > 0
+				? redactString(entry.display, privacy)
+				: entry.display;
+
+		if (existing) {
+			existing.prompts.push(display);
+			existing.timestamps.push(entry.timestamp);
+		} else {
+			sessionMap.set(entry.sessionId, {
+				project: entry.project,
+				prompts: [display],
+				timestamps: [entry.timestamp],
+			});
+		}
+	}
+
+	const sessions: SessionInfo[] = [];
+	for (const [sessionId, data] of sessionMap) {
+		sessions.push({
+			sessionId,
+			project: data.project,
+			projectName: projectName(data.project),
+			prompts: data.prompts,
+			promptTimestamps: data.timestamps,
+			timeRange: {
+				start: Math.min(...data.timestamps),
+				end: Math.max(...data.timestamps),
+			},
+		});
+	}
+
+	sessions.sort((a, b) => a.timeRange.start - b.timeRange.start);
+	return sessions;
+}
+
+async function readCodexHistory(
+	historyFile: string,
+	from: string,
+	to: string,
+	privacy: PrivacyConfig,
+	sessionsDir: string,
+): Promise<SessionInfo[]> {
+	const file = Bun.file(historyFile);
+	if (!(await file.exists())) return [];
+
+	const text = await file.text();
+	const entries: CodexHistoryEntry[] = [];
+
+	for (const line of text.split("\n")) {
+		if (!line.trim()) continue;
+		try {
+			const entry = JSON.parse(line) as CodexHistoryEntry;
+			if (
+				typeof entry.session_id !== "string" ||
+				typeof entry.ts !== "number" ||
+				typeof entry.text !== "string"
+			) {
+				continue;
+			}
+			const timestampMs = entry.ts * 1000;
+			const entryDate = toLocalDate(timestampMs);
+			if (entryDate < from || entryDate > to) continue;
+			entries.push(entry);
+		} catch {
+			// skip malformed
+		}
+	}
+
+	const sessionMap = new Map<string, { prompts: string[]; timestamps: number[] }>();
+	for (const entry of entries) {
+		const existing = sessionMap.get(entry.session_id);
+		const prompt = privacy.redactPrompts
+			? "[redacted]"
+			: privacy.redactPatterns.length > 0
+				? redactString(entry.text, privacy)
+				: entry.text;
+
+		const timestampMs = entry.ts * 1000;
+		if (existing) {
+			existing.prompts.push(prompt);
+			existing.timestamps.push(timestampMs);
+		} else {
+			sessionMap.set(entry.session_id, {
+				prompts: [prompt],
+				timestamps: [timestampMs],
+			});
+		}
+	}
+
+	const sessions = await Promise.all(
+		[...sessionMap.entries()].map(async ([sessionId, data]): Promise<SessionInfo | null> => {
+			const header = await readCodexSessionHeader(sessionsDir, sessionId);
+			const project = header.cwd ?? `(unknown)/${sessionId}`;
+
+			if (isProjectExcluded(project, privacy)) return null;
+
+			return {
+				sessionId,
+				project,
+				projectName: projectName(project),
+				prompts: data.prompts,
+				promptTimestamps: data.timestamps,
+				timeRange: {
+					start: Math.min(...data.timestamps),
+					end: Math.max(...data.timestamps),
+				},
+			};
+		}),
+	);
+
+	return sessions
+		.filter((session): session is SessionInfo => !!session)
+		.sort((a, b) => a.timeRange.start - b.timeRange.start);
+}

package/src/readers/plan-reader.ts

@@ -0,0 +1,60 @@
+import { readdir, stat } from "node:fs/promises";
+import { join } from "node:path";
+import type { PlanInfo } from "../types/plan.js";
+
+function isInDateRange(fileDate: Date, from: string, to: string): boolean {
+	const year = fileDate.getFullYear();
+	const month = String(fileDate.getMonth() + 1).padStart(2, "0");
+	const day = String(fileDate.getDate()).padStart(2, "0");
+	const dateStr = `${year}-${month}-${day}`;
+	return dateStr >= from && dateStr <= to;
+}
+
+/** Read plans from provider/plans/*.md */
+export async function readPlans(
+	plansDir: string,
+	from: string,
+	to: string,
+	includeContent: boolean = false,
+): Promise<PlanInfo[]> {
+	const plans: PlanInfo[] = [];
+
+	let files: string[];
+	try {
+		files = await readdir(plansDir);
+	} catch {
+		return plans;
+	}
+
+	for (const file of files) {
+		if (!file.endsWith(".md")) continue;
+		const filePath = join(plansDir, file);
+
+		const fileStat = await stat(filePath).catch(() => null);
+		if (!fileStat || !isInDateRange(fileStat.mtime, from, to)) continue;
+
+		try {
+			const content = await Bun.file(filePath).text();
+			const lines = content.split("\n");
+			const title =
+				lines.find((l) => l.startsWith("# "))?.replace("# ", "") ||
+				file.replace(".md", "");
+			const snippet = lines
+				.filter((l) => l.trim() && !l.startsWith("#"))
+				.slice(0, 3)
+				.join(" ")
+				.slice(0, 300);
+
+			plans.push({
+				filename: file,
+				title,
+				snippet,
+				content: includeContent ? content : undefined,
+			});
+		} catch {
+			// skip
+		}
+	}
+
+	return plans;
+}

package/src/readers/project-reader.ts

@@ -0,0 +1,101 @@
+import { readdir } from "node:fs/promises";
+import { join } from "node:path";
+import type { ProjectInfo, ProjectMemory } from "../types/project.js";
+import { decodeProjectPath } from "../utils/paths.js";
+import type { PrivacyConfig } from "../types/privacy.js";
+import { isProjectExcluded } from "../privacy/redact.js";
+
+/** List all projects from provider/projects/ */
+export async function readProjects(
+	projectsDir: string,
+	privacy: PrivacyConfig,
+): Promise<ProjectInfo[]> {
+	const projects: ProjectInfo[] = [];
+
+	let entries: string[];
+	try {
+		entries = await readdir(projectsDir);
+	} catch {
+		return projects;
+	}
+
+	for (const encodedPath of entries) {
+		if (encodedPath.startsWith(".")) continue;
+
+		const decodedPath = decodeProjectPath(encodedPath);
+
+		if (isProjectExcluded(decodedPath, privacy)) continue;
+
+		const projectDir = join(projectsDir, encodedPath);
+
+		// Count session files
+		let sessionCount = 0;
+		try {
+			const files = await readdir(projectDir);
+			sessionCount = files.filter((f) => f.endsWith(".jsonl")).length;
+		} catch {
+			// skip unreadable dirs
+			continue;
+		}
+
+		// Check for MEMORY.md
+		const memoryPath = join(projectDir, "memory", "MEMORY.md");
+		const hasMemory = await Bun.file(memoryPath).exists();
+
+		const name = decodedPath.split("/").pop() || decodedPath;
+
+		projects.push({
+			encodedPath,
+			decodedPath,
+			name,
+			sessionCount,
+			hasMemory,
+		});
+	}
+
+	return projects;
+}
+
+/** Read MEMORY.md for a project. */
+export async function readProjectMemory(
+	projectPath: string,
+	projectsDir: string,
+): Promise<ProjectMemory | null> {
+	const encoded = projectPath.replace(/\//g, "-");
+	const memoryPath = join(projectsDir, encoded, "memory", "MEMORY.md");
+
+	try {
+		const file = Bun.file(memoryPath);
+		if (!(await file.exists())) return null;
+		const content = await file.text();
+		if (!content.trim()) return null;
+
+		return {
+			projectPath,
+			projectName: projectPath.split("/").pop() || projectPath,
+			content: content.slice(0, 2000),
+		};
+	} catch {
+		return null;
+	}
+}
+
+/** Read MEMORY.md for multiple projects. Returns Map<projectName, content>. */
+export async function readProjectMemories(
+	projectPaths: string[],
+	projectsDir: string,
+): Promise<Map<string, string>> {
+	const memory = new Map<string, string>();
+	const unique = [...new Set(projectPaths)];
+
+	await Promise.all(
+		unique.map(async (projectPath) => {
+			const result = await readProjectMemory(projectPath, projectsDir);
+			if (result) {
+				memory.set(result.projectName, result.content);
+			}
+		}),
+	);
+
+	return memory;
+}