@wahack/pi-coding-agent 15.11.0

package/src/debug/raw-sse.ts

@@ -0,0 +1,292 @@
+import {
+	type Component,
+	matchesKey,
+	padding,
+	replaceTabs,
+	ScrollView,
+	truncateToWidth,
+	visibleWidth,
+} from './stubs/tui/index.ts';
+import { sanitizeText } from "@oh-my-pi/pi-utils";
+import { theme } from "../modes/theme/theme";
+import { copyToClipboard } from "../utils/clipboard";
+import {
+	formatRawSseIsoTime,
+	type RawSseDebugBuffer,
+	type RawSseDebugRecord,
+	rawSseRecordLines,
+} from "./raw-sse-buffer";
+
+const MIN_VIEWER_WIDTH = 20;
+const VIEWER_FRAME_LINES = 5;
+// `data:` lines below this width render fine on a single row; anything wider gets pretty-printed
+// across multiple `data:` lines so streamed JSON blobs stop getting clipped by `truncateToWidth`.
+const PRETTY_PRINT_DATA_THRESHOLD = 100;
+
+function sanitizeFrameLine(line: string, width: number): string {
+	return truncateToWidth(replaceTabs(sanitizeText(line)), width);
+}
+
+// Walks the SSE wire lines and replaces single-line `data: <json>` payloads with
+// multi-line `data: <indented-json>` entries when the JSON is wide enough to clip.
+// Multi-line `data:` is still valid SSE (the spec joins lines with `\n`), so the
+// transformed view round-trips back to the same event when copied.
+/** @internal Exported for tests. */
+export function expandPrettyDataLines(raw: readonly string[]): string[] {
+	const out: string[] = [];
+	for (const line of raw) {
+		if (!line.startsWith("data: ") || line.length <= PRETTY_PRINT_DATA_THRESHOLD) {
+			out.push(line);
+			continue;
+		}
+		const body = line.slice("data: ".length);
+		const trimmed = body.trim();
+		if (trimmed.length === 0 || (trimmed[0] !== "{" && trimmed[0] !== "[")) {
+			out.push(line);
+			continue;
+		}
+		let parsed: unknown;
+		try {
+			parsed = JSON.parse(trimmed);
+		} catch {
+			out.push(line);
+			continue;
+		}
+		const pretty = JSON.stringify(parsed, null, 2);
+		for (const prettyLine of pretty.split("\n")) {
+			out.push(`data: ${prettyLine}`);
+		}
+	}
+	return out;
+}
+
+export interface RawSseViewerOptions {
+	buffer: RawSseDebugBuffer;
+	terminalRows: number;
+	onExit: () => void;
+	onStatus?: (message: string) => void;
+	onUpdate?: () => void;
+}
+
+export class RawSseViewerComponent implements Component {
+	readonly #buffer: RawSseDebugBuffer;
+	readonly #terminalRows: number;
+	readonly #onExit: () => void;
+	readonly #onStatus?: (message: string) => void;
+	readonly #onUpdate?: () => void;
+	readonly #unsubscribe: () => void;
+	#scrollOffset = 0;
+	#followTail = true;
+	#lastRenderWidth = MIN_VIEWER_WIDTH;
+	#statusMessage: string | undefined;
+	// Pretty-printed wire lines keyed by `record.sequence`. Pretty-printing is
+	// the JSON.parse + JSON.stringify per `data:` line, so we cache the result —
+	// the render path runs on every keypress and from `#maxScrollOffset()`.
+	// Sequences are monotonic; we prune entries below the oldest live record
+	// after each render so the cache tracks the buffer's eviction window.
+	readonly #prettyLinesCache = new Map<number, string[]>();
+
+	constructor(options: RawSseViewerOptions) {
+		this.#buffer = options.buffer;
+		this.#terminalRows = options.terminalRows;
+		this.#onExit = options.onExit;
+		this.#onStatus = options.onStatus;
+		this.#onUpdate = options.onUpdate;
+		this.#unsubscribe = this.#buffer.subscribe(() => {
+			this.#followIfNeeded();
+			this.#onUpdate?.();
+		});
+	}
+
+	handleInput(keyData: string): void {
+		if (matchesKey(keyData, "escape") || matchesKey(keyData, "esc")) {
+			this.#unsubscribe();
+			this.#onExit();
+			return;
+		}
+
+		if (matchesKey(keyData, "ctrl+c")) {
+			this.#copyAll();
+			return;
+		}
+
+		if (matchesKey(keyData, "up")) {
+			this.#followTail = false;
+			this.#scrollOffset = Math.max(0, this.#scrollOffset - 1);
+			this.#onUpdate?.();
+			return;
+		}
+
+		if (matchesKey(keyData, "down")) {
+			this.#followTail = false;
+			this.#scrollOffset = Math.min(this.#maxScrollOffset(), this.#scrollOffset + 1);
+			this.#onUpdate?.();
+			return;
+		}
+
+		if (matchesKey(keyData, "pageUp")) {
+			this.#followTail = false;
+			this.#scrollOffset = Math.max(0, this.#scrollOffset - this.#bodyHeight());
+			this.#onUpdate?.();
+			return;
+		}
+
+		if (matchesKey(keyData, "pageDown")) {
+			this.#followTail = false;
+			this.#scrollOffset = Math.min(this.#maxScrollOffset(), this.#scrollOffset + this.#bodyHeight());
+			this.#onUpdate?.();
+			return;
+		}
+
+		if (matchesKey(keyData, "end")) {
+			this.#followTail = true;
+			this.#scrollToTail();
+			this.#onUpdate?.();
+		}
+	}
+
+	invalidate(): void {}
+
+	render(width: number): readonly string[] {
+		this.#lastRenderWidth = Math.max(MIN_VIEWER_WIDTH, width);
+		this.#followIfNeeded();
+
+		const innerWidth = Math.max(1, this.#lastRenderWidth - 2);
+		const bodyHeight = this.#bodyHeight();
+		const rawLines = this.#renderRawLines(innerWidth);
+		const sv = new ScrollView(rawLines.slice(this.#scrollOffset, this.#scrollOffset + bodyHeight), {
+			height: bodyHeight,
+			scrollbar: "auto",
+			totalRows: rawLines.length,
+			theme: { track: t => theme.fg("muted", t), thumb: t => theme.fg("accent", t) },
+		});
+		sv.setScrollOffset(this.#scrollOffset);
+		const bodyRows = sv.render(innerWidth);
+
+		return [
+			this.#frameTop(innerWidth),
+			this.#frameLine(this.#summaryText(), innerWidth),
+			this.#frameSeparator(innerWidth),
+			...bodyRows.map(line => this.#frameLine(line, innerWidth)),
+			this.#frameLine(this.#statusText(), innerWidth),
+			this.#frameBottom(innerWidth),
+		];
+	}
+
+	#renderRawLines(innerWidth: number): string[] {
+		const snapshot = this.#buffer.snapshot();
+		if (snapshot.records.length === 0) {
+			return [
+				theme.fg("muted", "No raw SSE frames captured yet."),
+				theme.fg("muted", "HTTP SSE providers populate this view while a model response is streaming."),
+			];
+		}
+
+		const lines: string[] = [];
+		if (snapshot.droppedRecords > 0) {
+			lines.push(
+				theme.fg(
+					"warning",
+					`: omp-debug-dropped records=${snapshot.droppedRecords} chars=${snapshot.droppedChars}`,
+				),
+			);
+			lines.push("");
+		}
+		const firstSequence = snapshot.records[0]?.sequence;
+		for (const record of snapshot.records) {
+			for (const line of this.#prettyLinesFor(record)) {
+				lines.push(sanitizeFrameLine(line, innerWidth));
+			}
+			if (record.kind === "event" && record.truncated) {
+				lines.push(theme.fg("warning", `: omp-debug-event-truncated originalChars=${record.originalChars}`));
+			}
+			lines.push("");
+		}
+		if (firstSequence !== undefined) this.#pruneCache(firstSequence);
+		return lines;
+	}
+
+	#prettyLinesFor(record: RawSseDebugRecord): string[] {
+		const cached = this.#prettyLinesCache.get(record.sequence);
+		if (cached) return cached;
+		const expanded = expandPrettyDataLines(rawSseRecordLines(record));
+		this.#prettyLinesCache.set(record.sequence, expanded);
+		return expanded;
+	}
+
+	#pruneCache(firstSequence: number): void {
+		// Bounded by the buffer eviction rate; with `MAX_RAW_SSE_EVENTS = 1000`
+		// this rarely runs and only walks freshly-evicted entries.
+		for (const key of this.#prettyLinesCache.keys()) {
+			if (key < firstSequence) this.#prettyLinesCache.delete(key);
+		}
+	}
+
+	#summaryText(): string {
+		const snapshot = this.#buffer.snapshot();
+		const last = snapshot.lastUpdatedAt ? ` last=${formatRawSseIsoTime(snapshot.lastUpdatedAt)}` : "";
+		const follow = this.#followTail ? "follow:on" : "follow:off";
+		return ` # raw provider stream (SSE + WS) | events=${snapshot.totalEvents} records=${snapshot.records.length}${last} | ${follow} | Esc back Ctrl+C copy End follow`;
+	}
+
+	#statusText(): string {
+		return this.#statusMessage ?? " Up/Down scroll  PgUp/PgDn page";
+	}
+
+	#bodyHeight(): number {
+		return Math.max(3, this.#terminalRows - VIEWER_FRAME_LINES);
+	}
+
+	#followIfNeeded(): void {
+		if (this.#followTail) this.#scrollToTail();
+	}
+
+	#scrollToTail(): void {
+		this.#scrollOffset = this.#maxScrollOffset();
+	}
+
+	#maxScrollOffset(): number {
+		const innerWidth = Math.max(1, this.#lastRenderWidth - 2);
+		return Math.max(0, this.#renderRawLines(innerWidth).length - this.#bodyHeight());
+	}
+
+	#copyAll(): void {
+		const payload = this.#buffer.toRawText();
+		if (payload.trim().length === 0) {
+			const message = "No raw SSE frames to copy";
+			this.#statusMessage = message;
+			this.#onStatus?.(message);
+			this.#onUpdate?.();
+			return;
+		}
+
+		try {
+			copyToClipboard(payload);
+			const message = "Copied raw SSE stream";
+			this.#statusMessage = message;
+			this.#onStatus?.(message);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			this.#statusMessage = `Copy failed: ${message}`;
+		}
+		this.#onUpdate?.();
+	}
+
+	#frameTop(innerWidth: number): string {
+		return `${theme.boxSharp.topLeft}${theme.boxSharp.horizontal.repeat(innerWidth)}${theme.boxSharp.topRight}`;
+	}
+
+	#frameSeparator(innerWidth: number): string {
+		return `${theme.boxSharp.teeRight}${theme.boxSharp.horizontal.repeat(innerWidth)}${theme.boxSharp.teeLeft}`;
+	}
+
+	#frameBottom(innerWidth: number): string {
+		return `${theme.boxSharp.bottomLeft}${theme.boxSharp.horizontal.repeat(innerWidth)}${theme.boxSharp.bottomRight}`;
+	}
+
+	#frameLine(content: string, innerWidth: number): string {
+		const truncated = truncateToWidth(content, innerWidth);
+		const remaining = Math.max(0, innerWidth - visibleWidth(truncated));
+		return `${theme.boxSharp.vertical}${truncated}${padding(remaining)}${theme.boxSharp.vertical}`;
+	}
+}

package/src/debug/report-bundle.ts

@@ -0,0 +1,374 @@
+/**
+ * Debug report bundle creation.
+ *
+ * Creates a .tar.gz archive with session data, logs, system info, and optional profiling data.
+ */
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import type { WorkProfile } from './stubs/natives/index.ts';
+import { APP_NAME, getLogPath, getLogsDir, getReportsDir, isEnoent } from "@oh-my-pi/pi-utils";
+import type { CpuProfile, HeapSnapshot } from "./profiler";
+import { collectSystemInfo, sanitizeEnv } from "./system-info";
+
+/** Maximum number of log lines to load into memory at once. */
+const MAX_LOG_LINES = 5000;
+
+/** Maximum bytes to read from the tail of a log file (2 MB). */
+const MAX_LOG_BYTES = 2 * 1024 * 1024;
+/** Read last N lines from a file, reading at most `maxBytes` from the tail. */
+async function readLastLines(filePath: string, n: number, maxBytes = MAX_LOG_BYTES): Promise<string> {
+	try {
+		const file = Bun.file(filePath);
+		const size = file.size;
+		const start = Math.max(0, size - maxBytes);
+		const content = start > 0 ? await file.slice(start, size).text() : await file.text();
+		const lines = content.split("\n");
+		// If we sliced mid-file, drop the first (partial) line
+		if (start > 0 && lines.length > 0) {
+			lines.shift();
+		}
+		return lines.slice(-n).join("\n");
+	} catch (err) {
+		if (isEnoent(err)) return "";
+		throw err;
+	}
+}
+
+export interface ReportBundleOptions {
+	/** Session file path */
+	sessionFile: string | undefined;
+	/** Settings to include */
+	settings?: Record<string, unknown>;
+	/** CPU profile (for performance reports) */
+	cpuProfile?: CpuProfile;
+	/** Heap snapshot (for memory reports) */
+	heapSnapshot?: HeapSnapshot;
+	/** Work profile (for work scheduling reports) */
+	workProfile?: WorkProfile;
+	/** Raw provider SSE diagnostics captured by the session buffer */
+	rawSseText?: string;
+}
+
+export interface ReportBundleResult {
+	path: string;
+	files: string[];
+}
+
+export interface DebugLogSource {
+	getInitialText(): Promise<string>;
+	hasOlderLogs(): boolean;
+	loadOlderLogs(limitDays?: number): Promise<string>;
+}
+
+/**
+ * Create a debug report bundle.
+ *
+ * Bundle contents:
+ * - session.jsonl: Current session transcript
+ * - artifacts/: Session artifacts directory
+ * - subagents/: Subagent sessions + artifacts
+ * - logs.txt: Recent log entries
+ * - system.json: OS, arch, CPU, memory, versions
+ * - env.json: Sanitized environment variables
+ * - config.json: Resolved settings
+ * - profile.cpuprofile: CPU profile (performance report only)
+ * - raw-sse.txt: Recent raw provider SSE diagnostics (when captured)
+ * - profile.md: Markdown CPU profile (performance report only)
+ * - heap.heapsnapshot: Heap snapshot (memory report only)
+ * - work.folded: Work profile folded stacks (work report only)
+ * - work.md: Work profile summary (work report only)
+ * - work.svg: Work profile flamegraph (work report only)
+ */
+export async function createReportBundle(options: ReportBundleOptions): Promise<ReportBundleResult> {
+	const reportsDir = getReportsDir();
+	await fs.mkdir(reportsDir, { recursive: true });
+
+	const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+	const outputPath = path.join(reportsDir, `omp-report-${timestamp}.tar.gz`);
+
+	const data: Record<string, string> = {};
+	const files: string[] = [];
+
+	// Collect system info
+	const systemInfo = await collectSystemInfo();
+	data["system.json"] = JSON.stringify(systemInfo, null, 2);
+	files.push("system.json");
+
+	// Sanitized environment
+	data["env.json"] = JSON.stringify(sanitizeEnv(Bun.env as Record<string, string>), null, 2);
+	files.push("env.json");
+
+	// Settings/config
+	if (options.settings) {
+		data["config.json"] = JSON.stringify(options.settings, null, 2);
+		files.push("config.json");
+	}
+
+	// Recent logs (last 1000 lines)
+	const logPath = getLogPath();
+	const logs = await readLastLines(logPath, 1000);
+	if (logs) {
+		data["logs.txt"] = logs;
+		files.push("logs.txt");
+	}
+
+	// Recent raw provider SSE diagnostics
+	if (options.rawSseText && options.rawSseText.trim().length > 0) {
+		data["raw-sse.txt"] = options.rawSseText;
+		files.push("raw-sse.txt");
+	}
+
+	// Session file
+	if (options.sessionFile) {
+		try {
+			const sessionContent = await Bun.file(options.sessionFile).text();
+			data["session.jsonl"] = sessionContent;
+			files.push("session.jsonl");
+		} catch {
+			// Session file might not exist yet
+		}
+
+		// Artifacts directory (same path without .jsonl)
+		const artifactsDir = options.sessionFile.slice(0, -6);
+		await addDirectoryToArchive(data, files, artifactsDir, "artifacts");
+
+		// Look for subagent sessions in the same directory
+		const sessionDir = path.dirname(options.sessionFile);
+		const sessionBasename = path.basename(options.sessionFile, ".jsonl");
+		await addSubagentSessions(data, files, sessionDir, sessionBasename);
+	}
+
+	// CPU profile
+	if (options.cpuProfile) {
+		data["profile.cpuprofile"] = options.cpuProfile.data;
+		files.push("profile.cpuprofile");
+		data["profile.md"] = options.cpuProfile.markdown;
+		files.push("profile.md");
+	}
+
+	// Heap snapshot
+	if (options.heapSnapshot) {
+		data["heap.heapsnapshot"] = options.heapSnapshot.data;
+		files.push("heap.heapsnapshot");
+	}
+
+	// Work profile
+	if (options.workProfile) {
+		data["work.folded"] = options.workProfile.folded;
+		files.push("work.folded");
+		data["work.md"] = options.workProfile.summary;
+		files.push("work.md");
+		if (options.workProfile.svg) {
+			data["work.svg"] = options.workProfile.svg;
+			files.push("work.svg");
+		}
+	}
+
+	// Write archive
+	await Bun.Archive.write(outputPath, data, { compress: "gzip" });
+
+	return { path: outputPath, files };
+}
+
+/** Add all files from a directory to the archive */
+async function addDirectoryToArchive(
+	data: Record<string, string>,
+	files: string[],
+	dirPath: string,
+	archivePrefix: string,
+): Promise<void> {
+	try {
+		const entries = await fs.readdir(dirPath, { withFileTypes: true });
+		for (const entry of entries) {
+			if (!entry.isFile()) continue;
+			const filePath = path.join(dirPath, entry.name);
+			const archivePath = `${archivePrefix}/${entry.name}`;
+			try {
+				const content = await Bun.file(filePath).text();
+				data[archivePath] = content;
+				files.push(archivePath);
+			} catch {
+				// Skip files we can't read
+			}
+		}
+	} catch {
+		// Directory doesn't exist
+	}
+}
+
+/** Find and add subagent session files */
+async function addSubagentSessions(
+	data: Record<string, string>,
+	files: string[],
+	sessionDir: string,
+	parentBasename: string,
+): Promise<void> {
+	// Subagent sessions are named with task IDs in the same directory
+	// They follow the pattern: {timestamp}_{sessionId}.jsonl
+	// We look for any sessions created after the parent session
+	try {
+		const entries = await fs.readdir(sessionDir, { withFileTypes: true });
+		const sessionFiles = entries
+			.filter(e => e.isFile() && e.name.endsWith(".jsonl") && e.name !== `${parentBasename}.jsonl`)
+			.map(e => e.name);
+
+		// Limit to most recent 10 subagent sessions
+		const sortedFiles = sessionFiles.sort().slice(-10);
+
+		for (const filename of sortedFiles) {
+			const filePath = path.join(sessionDir, filename);
+			const archivePath = `subagents/${filename}`;
+			try {
+				const content = await Bun.file(filePath).text();
+				data[archivePath] = content;
+				files.push(archivePath);
+
+				// Also add artifacts for this subagent session
+				const artifactsDir = filePath.slice(0, -6);
+				await addDirectoryToArchive(data, files, artifactsDir, `subagents/${filename.slice(0, -6)}`);
+			} catch {
+				// Skip files we can't read
+			}
+		}
+	} catch {
+		// Directory doesn't exist
+	}
+}
+
+/** Get recent log entries for display (tail-limited to avoid OOM on large files). */
+export async function getLogText(): Promise<string> {
+	return readLastLines(getLogPath(), MAX_LOG_LINES);
+}
+
+const LOG_FILE_PATTERN = new RegExp(`^${APP_NAME}\\.(\\d{4}-\\d{2}-\\d{2})\\.log$`);
+
+export async function createDebugLogSource(): Promise<DebugLogSource> {
+	const logsDir = getLogsDir();
+	const todayPath = getLogPath();
+	const todayName = path.basename(todayPath);
+	let olderFiles: string[] = [];
+	try {
+		const entries = await fs.readdir(logsDir, { withFileTypes: true });
+		const datedFiles = entries
+			.filter(entry => entry.isFile())
+			.map(entry => {
+				const match = LOG_FILE_PATTERN.exec(entry.name);
+				return match ? { name: entry.name, date: match[1] } : undefined;
+			})
+			.filter((entry): entry is { name: string; date: string } => entry !== undefined)
+			.filter(entry => entry.name !== todayName)
+			.sort((a, b) => b.date.localeCompare(a.date));
+		olderFiles = datedFiles.map(entry => entry.name);
+	} catch {
+		olderFiles = [];
+	}
+
+	let cursor = 0;
+
+	const getInitialText = async (): Promise<string> => {
+		return readLastLines(todayPath, MAX_LOG_LINES);
+	};
+
+	const hasOlderLogs = (): boolean => cursor < olderFiles.length;
+
+	const loadOlderLogs = async (limitDays: number = 1): Promise<string> => {
+		if (!hasOlderLogs()) {
+			return "";
+		}
+		const count = Math.max(1, limitDays);
+		const slice = olderFiles.slice(cursor, cursor + count);
+		cursor += slice.length;
+		const chunks: string[] = [];
+		for (const filename of slice.reverse()) {
+			const filePath = path.join(logsDir, filename);
+			try {
+				const content = await readLastLines(filePath, MAX_LOG_LINES);
+				if (content.length > 0) {
+					chunks.push(content);
+				}
+			} catch (err) {
+				if (!isEnoent(err)) {
+					throw err;
+				}
+			}
+		}
+		return chunks.filter(chunk => chunk.length > 0).join("\n");
+	};
+
+	return {
+		getInitialText,
+		hasOlderLogs,
+		loadOlderLogs,
+	};
+}
+
+/** Calculate total size of artifact cache */
+export async function getArtifactCacheStats(
+	sessionsDir: string,
+): Promise<{ count: number; totalSize: number; oldestDate: Date | null }> {
+	let count = 0;
+	let totalSize = 0;
+	let oldestDate: Date | null = null;
+
+	try {
+		const sessions = await fs.readdir(sessionsDir, { withFileTypes: true });
+
+		for (const session of sessions) {
+			// Artifact directories don't have .jsonl extension
+			if (session.isDirectory()) {
+				const dirPath = path.join(sessionsDir, session.name);
+				try {
+					const stat = await fs.stat(dirPath);
+					const files = await fs.readdir(dirPath);
+					for (const file of files) {
+						const filePath = path.join(dirPath, file);
+						const fileStat = await fs.stat(filePath);
+						if (fileStat.isFile()) {
+							count++;
+							totalSize += fileStat.size;
+						}
+					}
+					if (!oldestDate || stat.mtime < oldestDate) {
+						oldestDate = stat.mtime;
+					}
+				} catch {
+					// Skip inaccessible directories
+				}
+			}
+		}
+	} catch {
+		// Directory doesn't exist
+	}
+
+	return { count, totalSize, oldestDate };
+}
+
+/** Clear artifact cache older than N days */
+export async function clearArtifactCache(sessionsDir: string, daysOld: number = 30): Promise<{ removed: number }> {
+	const cutoff = new Date();
+	cutoff.setDate(cutoff.getDate() - daysOld);
+	let removed = 0;
+
+	try {
+		const sessions = await fs.readdir(sessionsDir, { withFileTypes: true });
+
+		for (const session of sessions) {
+			if (session.isDirectory()) {
+				const dirPath = path.join(sessionsDir, session.name);
+				try {
+					const stat = await fs.stat(dirPath);
+					if (stat.mtime < cutoff) {
+						await fs.rm(dirPath, { recursive: true, force: true });
+						removed++;
+					}
+				} catch {
+					// Skip inaccessible directories
+				}
+			}
+		}
+	} catch {
+		// Directory doesn't exist
+	}
+
+	return { removed };
+}