@oh-my-pi/pi-coding-agent 8.12.9 → 8.13.0

package/CHANGELOG.md

@@ -2,6 +2,20 @@
 
 ## [Unreleased]
 
+## [8.13.0] - 2026-01-29
+
+### Added
+- Added `/debug` command with interactive menu for bug report generation:
+  - `Report: performance issue` - CPU profiling with reproduction flow
+  - `Report: dump session` - Immediate session bundle creation
+  - `Report: memory issue` - Heap snapshot with bundle
+  - `View: recent logs` - Display last 50 log entries
+  - `View: system info` - Show environment details
+  - `Clear: artifact cache` - Remove old session artifacts
+
+### Fixed
+- Fixed LSP server errors not being visible in `/session` output or logs when startup fails
+
 ## [8.12.7] - 2026-01-29
 
 ### Fixed

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "8.12.9",
+	"version": "8.13.0",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"type": "module",
 	"ompConfig": {
@@ -79,22 +79,20 @@
 		"test": "bun test"
 	},
 	"dependencies": {
-		"@oh-my-pi/omp-stats": "8.12.9",
-		"@oh-my-pi/pi-agent-core": "8.12.9",
-		"@oh-my-pi/pi-ai": "8.12.9",
-		"@oh-my-pi/pi-natives": "8.12.9",
-		"@oh-my-pi/pi-tui": "8.12.9",
-		"@oh-my-pi/pi-utils": "8.12.9",
+		"@oh-my-pi/omp-stats": "8.13.0",
+		"@oh-my-pi/pi-agent-core": "8.13.0",
+		"@oh-my-pi/pi-ai": "8.13.0",
+		"@oh-my-pi/pi-natives": "8.13.0",
+		"@oh-my-pi/pi-tui": "8.13.0",
+		"@oh-my-pi/pi-utils": "8.13.0",
 		"@openai/agents": "^0.4.4",
 		"@sinclair/typebox": "^0.34.48",
 		"ajv": "^8.17.1",
 		"chalk": "^5.6.2",
-		"cli-highlight": "^2.1.11",
 		"diff": "^8.0.3",
 		"file-type": "^21.3.0",
 		"glob": "^13.0.0",
 		"handlebars": "^4.7.8",
-		"highlight.js": "^11.11.1",
 		"marked": "^17.0.1",
 		"nanoid": "^5.1.6",
 		"node-html-parser": "^7.0.2",

package/src/config/settings-manager.ts

@@ -1,6 +1,6 @@
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
-import { isEnoent, logger } from "@oh-my-pi/pi-utils";
+import { isEnoent, logger, procmgr } from "@oh-my-pi/pi-utils";
 import { YAML } from "bun";
 import { type Settings as SettingsItem, settingsCapability } from "../capability/settings";
 import { getAgentDbPath, getAgentDir } from "../config";
@@ -461,6 +461,8 @@ export class SettingsManager {
 	private settings!: Settings;
 	private persist: boolean;
 
+	static #lastInstance: SettingsManager | null = null;
+
 	/**
 	 * Private constructor - use static factory methods instead.
 	 * @param storage - SQLite storage instance for auth/cache, or null for in-memory mode
@@ -477,6 +479,7 @@ export class SettingsManager {
 		initialSettings: Settings,
 		persist: boolean,
 		projectSettings: Settings,
+		private agentDir: string | null,
 	) {
 		this.storage = storage;
 		this.configPath = configPath;
@@ -517,6 +520,9 @@ export class SettingsManager {
 	 * @returns Configured SettingsManager with merged global and user settings
 	 */
 	static async create(cwd: string = process.cwd(), agentDir: string = getAgentDir()): Promise<SettingsManager> {
+		cwd = path.normalize(cwd);
+		agentDir = path.normalize(agentDir);
+
 		const configPath = path.join(agentDir, "config.yml");
 		const storage = await AgentStorage.open(getAgentDbPath(agentDir));
 
@@ -541,7 +547,9 @@ export class SettingsManager {
 		// Load project settings before construction (constructor is sync)
 		const projectSettings = await SettingsManager.loadProjectSettingsStatic(cwd);
 
-		return new SettingsManager(storage, configPath, cwd, globalSettings, true, projectSettings);
+		const instance = new SettingsManager(storage, configPath, cwd, globalSettings, true, projectSettings, agentDir);
+		SettingsManager.#lastInstance = instance;
+		return instance;
 	}
 
 	/**
@@ -550,7 +558,7 @@ export class SettingsManager {
 	 * @returns SettingsManager that won't persist changes to disk
 	 */
 	static inMemory(settings: Partial<Settings> = {}): SettingsManager {
-		return new SettingsManager(null, null, null, settings, false, {});
+		return new SettingsManager(null, null, null, settings, false, {}, null);
 	}
 
 	/**
@@ -1784,4 +1792,54 @@ export class SettingsManager {
 			await this.save();
 		}
 	}
+
+	_compareUniqueCtorKeys(cwd: string, agentDir: string): boolean {
+		if (this.cwd !== cwd) {
+			cwd = path.normalize(cwd);
+			if (this.cwd !== cwd) {
+				return false;
+			}
+		}
+		if (this.agentDir !== agentDir) {
+			agentDir = path.normalize(agentDir);
+			if (this.agentDir !== agentDir) {
+				return false;
+			}
+		}
+		return true;
+	}
+
+	/**
+	 * Acquire the last created SettingsManager instance.
+	 * If no instance exists, create a new one.
+	 * @returns The SettingsManager instance
+	 */
+	static acquire(
+		cwd: string = process.cwd(),
+		agentDir: string = getAgentDir(),
+	): SettingsManager | Promise<SettingsManager> {
+		const prev = SettingsManager.#lastInstance;
+		if (prev?._compareUniqueCtorKeys(cwd, agentDir)) {
+			return prev;
+		}
+		return SettingsManager.create(cwd, agentDir);
+	}
+
+	/**
+	 * Gets the shell configuration
+	 * @returns The shell configuration
+	 */
+	async getShellConfig() {
+		const shell = this.getShellPath();
+		return procmgr.getShellConfig(shell);
+	}
+
+	/**
+	 * Gets the shell configuration from the last created SettingsManager instance.
+	 * @returns The shell configuration
+	 */
+	static async getGlobalShellConfig() {
+		const settings = await SettingsManager.acquire();
+		return settings.getShellConfig();
+	}
 }

package/src/debug/index.ts

@@ -0,0 +1,362 @@
+/**
+ * Debug command handler with interactive menu.
+ *
+ * Provides tools for debugging, bug report generation, and system diagnostics.
+ */
+import { Container, Loader, type SelectItem, SelectList, Spacer, Text } from "@oh-my-pi/pi-tui";
+import { getSessionsDir } from "../config";
+import { DynamicBorder } from "../modes/components/dynamic-border";
+import { getSelectListTheme, getSymbolTheme, theme } from "../modes/theme/theme";
+import type { InteractiveModeContext } from "../modes/types";
+import { generateHeapSnapshotData, type ProfilerSession, startCpuProfile } from "./profiler";
+import { clearArtifactCache, createReportBundle, getArtifactCacheStats, getRecentLogs } from "./report-bundle";
+import { collectSystemInfo, formatSystemInfo } from "./system-info";
+
+/** Debug menu options */
+const DEBUG_MENU_ITEMS: SelectItem[] = [
+	{ value: "performance", label: "Report: performance issue", description: "Profile CPU, reproduce, then bundle" },
+	{ value: "dump", label: "Report: dump session", description: "Create report bundle immediately" },
+	{ value: "memory", label: "Report: memory issue", description: "Heap snapshot + bundle" },
+	{ value: "logs", label: "View: recent logs", description: "Show last 50 log entries" },
+	{ value: "system", label: "View: system info", description: "Show environment details" },
+	{ value: "clear-cache", label: "Clear: artifact cache", description: "Remove old session artifacts" },
+];
+
+/**
+ * Debug selector component.
+ */
+export class DebugSelectorComponent extends Container {
+	private selectList: SelectList;
+
+	constructor(
+		private ctx: InteractiveModeContext,
+		onDone: () => void,
+	) {
+		super();
+
+		// Title
+		this.addChild(new DynamicBorder());
+		this.addChild(new Text(theme.bold(theme.fg("accent", "Debug Tools")), 1, 0));
+		this.addChild(new Spacer(1));
+
+		// Select list
+		this.selectList = new SelectList(DEBUG_MENU_ITEMS, 6, getSelectListTheme());
+
+		this.selectList.onSelect = item => {
+			onDone();
+			void this.handleSelection(item.value);
+		};
+
+		this.selectList.onCancel = () => {
+			onDone();
+		};
+
+		this.addChild(this.selectList);
+		this.addChild(new DynamicBorder());
+	}
+
+	handleInput(keyData: string): void {
+		this.selectList.handleInput(keyData);
+	}
+
+	private async handleSelection(value: string): Promise<void> {
+		switch (value) {
+			case "performance":
+				await this.handlePerformanceReport();
+				break;
+			case "dump":
+				await this.handleDumpReport();
+				break;
+			case "memory":
+				await this.handleMemoryReport();
+				break;
+			case "logs":
+				await this.handleViewLogs();
+				break;
+			case "system":
+				await this.handleViewSystemInfo();
+				break;
+			case "clear-cache":
+				await this.handleClearCache();
+				break;
+		}
+	}
+
+	private async handlePerformanceReport(): Promise<void> {
+		// Start profiling
+		let session: ProfilerSession;
+		try {
+			session = await startCpuProfile();
+		} catch (err) {
+			this.ctx.showError(`Failed to start profiler: ${err instanceof Error ? err.message : String(err)}`);
+			return;
+		}
+
+		// Show message and wait for keypress
+		this.ctx.chatContainer.addChild(new Spacer(1));
+		this.ctx.chatContainer.addChild(new Text(theme.fg("accent", `${theme.status.info} CPU profiling started`), 1, 0));
+		this.ctx.chatContainer.addChild(new Spacer(1));
+		this.ctx.chatContainer.addChild(
+			new Text(theme.fg("muted", "Reproduce the performance issue, then press Enter to stop profiling."), 1, 0),
+		);
+		this.ctx.ui.requestRender();
+
+		// Wait for Enter keypress
+		const { promise, resolve } = Promise.withResolvers<void>();
+		const originalOnEscape = this.ctx.editor.onEscape;
+		const originalOnSubmit = this.ctx.editor.onSubmit;
+
+		this.ctx.editor.onSubmit = () => {
+			this.ctx.editor.onEscape = originalOnEscape;
+			this.ctx.editor.onSubmit = originalOnSubmit;
+			resolve();
+		};
+
+		this.ctx.editor.onEscape = () => {
+			this.ctx.editor.onEscape = originalOnEscape;
+			this.ctx.editor.onSubmit = originalOnSubmit;
+			resolve();
+		};
+
+		await promise;
+
+		// Stop profiling and create report
+		const loader = new Loader(
+			this.ctx.ui,
+			spinner => theme.fg("accent", spinner),
+			text => theme.fg("muted", text),
+			"Generating report...",
+			getSymbolTheme().spinnerFrames,
+		);
+		this.ctx.statusContainer.addChild(loader);
+		this.ctx.ui.requestRender();
+
+		try {
+			const cpuProfile = await session.stop();
+			const result = await createReportBundle({
+				sessionFile: this.ctx.sessionManager.getSessionFile(),
+				settings: this.getResolvedSettings(),
+				cpuProfile,
+			});
+
+			loader.stop();
+			this.ctx.statusContainer.clear();
+
+			this.ctx.chatContainer.addChild(new Spacer(1));
+			this.ctx.chatContainer.addChild(
+				new Text(theme.fg("success", `${theme.status.success} Performance report saved`), 1, 0),
+			);
+			this.ctx.chatContainer.addChild(new Text(theme.fg("dim", result.path), 1, 0));
+			this.ctx.chatContainer.addChild(new Text(theme.fg("dim", `Files: ${result.files.length}`), 1, 0));
+		} catch (err) {
+			loader.stop();
+			this.ctx.statusContainer.clear();
+			this.ctx.showError(`Failed to create report: ${err instanceof Error ? err.message : String(err)}`);
+		}
+
+		this.ctx.ui.requestRender();
+	}
+
+	private async handleDumpReport(): Promise<void> {
+		const loader = new Loader(
+			this.ctx.ui,
+			spinner => theme.fg("accent", spinner),
+			text => theme.fg("muted", text),
+			"Creating report bundle...",
+			getSymbolTheme().spinnerFrames,
+		);
+		this.ctx.statusContainer.addChild(loader);
+		this.ctx.ui.requestRender();
+
+		try {
+			const result = await createReportBundle({
+				sessionFile: this.ctx.sessionManager.getSessionFile(),
+				settings: this.getResolvedSettings(),
+			});
+
+			loader.stop();
+			this.ctx.statusContainer.clear();
+
+			this.ctx.chatContainer.addChild(new Spacer(1));
+			this.ctx.chatContainer.addChild(
+				new Text(theme.fg("success", `${theme.status.success} Report bundle saved`), 1, 0),
+			);
+			this.ctx.chatContainer.addChild(new Text(theme.fg("dim", result.path), 1, 0));
+			this.ctx.chatContainer.addChild(new Text(theme.fg("dim", `Files: ${result.files.length}`), 1, 0));
+		} catch (err) {
+			loader.stop();
+			this.ctx.statusContainer.clear();
+			this.ctx.showError(`Failed to create report: ${err instanceof Error ? err.message : String(err)}`);
+		}
+
+		this.ctx.ui.requestRender();
+	}
+
+	private async handleMemoryReport(): Promise<void> {
+		const loader = new Loader(
+			this.ctx.ui,
+			spinner => theme.fg("accent", spinner),
+			text => theme.fg("muted", text),
+			"Generating heap snapshot...",
+			getSymbolTheme().spinnerFrames,
+		);
+		this.ctx.statusContainer.addChild(loader);
+		this.ctx.ui.requestRender();
+
+		try {
+			const heapSnapshot = generateHeapSnapshotData();
+			loader.setText("Creating report bundle...");
+
+			const result = await createReportBundle({
+				sessionFile: this.ctx.sessionManager.getSessionFile(),
+				settings: this.getResolvedSettings(),
+				heapSnapshot,
+			});
+
+			loader.stop();
+			this.ctx.statusContainer.clear();
+
+			this.ctx.chatContainer.addChild(new Spacer(1));
+			this.ctx.chatContainer.addChild(
+				new Text(theme.fg("success", `${theme.status.success} Memory report saved`), 1, 0),
+			);
+			this.ctx.chatContainer.addChild(new Text(theme.fg("dim", result.path), 1, 0));
+			this.ctx.chatContainer.addChild(new Text(theme.fg("dim", `Files: ${result.files.length}`), 1, 0));
+		} catch (err) {
+			loader.stop();
+			this.ctx.statusContainer.clear();
+			this.ctx.showError(`Failed to create report: ${err instanceof Error ? err.message : String(err)}`);
+		}
+
+		this.ctx.ui.requestRender();
+	}
+
+	private async handleViewLogs(): Promise<void> {
+		try {
+			const logs = await getRecentLogs(50);
+			if (!logs) {
+				this.ctx.showWarning("No log entries found for today.");
+				return;
+			}
+
+			this.ctx.chatContainer.addChild(new Spacer(1));
+			this.ctx.chatContainer.addChild(new DynamicBorder());
+			this.ctx.chatContainer.addChild(new Text(theme.bold(theme.fg("accent", "Recent Logs")), 1, 0));
+			this.ctx.chatContainer.addChild(new Spacer(1));
+
+			// Display logs with dim styling
+			const lines = logs.split("\n").slice(-50);
+			for (const line of lines) {
+				if (line.trim()) {
+					this.ctx.chatContainer.addChild(new Text(theme.fg("dim", line), 1, 0));
+				}
+			}
+
+			this.ctx.chatContainer.addChild(new DynamicBorder());
+		} catch (err) {
+			this.ctx.showError(`Failed to read logs: ${err instanceof Error ? err.message : String(err)}`);
+		}
+
+		this.ctx.ui.requestRender();
+	}
+
+	private async handleViewSystemInfo(): Promise<void> {
+		try {
+			const info = await collectSystemInfo();
+			const formatted = formatSystemInfo(info);
+
+			this.ctx.chatContainer.addChild(new Spacer(1));
+			this.ctx.chatContainer.addChild(new DynamicBorder());
+			this.ctx.chatContainer.addChild(new Text(formatted, 1, 0));
+			this.ctx.chatContainer.addChild(new DynamicBorder());
+		} catch (err) {
+			this.ctx.showError(`Failed to collect system info: ${err instanceof Error ? err.message : String(err)}`);
+		}
+
+		this.ctx.ui.requestRender();
+	}
+
+	private async handleClearCache(): Promise<void> {
+		const sessionsDir = getSessionsDir();
+
+		// Get stats first
+		const stats = await getArtifactCacheStats(sessionsDir);
+
+		if (stats.count === 0) {
+			this.ctx.showStatus("Artifact cache is empty.");
+			return;
+		}
+
+		const sizeStr = formatBytes(stats.totalSize);
+		const oldestStr = stats.oldestDate ? stats.oldestDate.toLocaleDateString() : "unknown";
+
+		// Show confirmation
+		const confirmed = await this.ctx.showHookConfirm(
+			"Clear Artifact Cache",
+			`Found ${stats.count} artifact files (${sizeStr})\nOldest: ${oldestStr}\n\nRemove artifacts older than 30 days?`,
+		);
+
+		if (!confirmed) {
+			this.ctx.showStatus("Cache clear cancelled.");
+			return;
+		}
+
+		// Clear cache
+		const loader = new Loader(
+			this.ctx.ui,
+			spinner => theme.fg("accent", spinner),
+			text => theme.fg("muted", text),
+			"Clearing artifact cache...",
+			getSymbolTheme().spinnerFrames,
+		);
+		this.ctx.statusContainer.addChild(loader);
+		this.ctx.ui.requestRender();
+
+		try {
+			const result = await clearArtifactCache(sessionsDir, 30);
+
+			loader.stop();
+			this.ctx.statusContainer.clear();
+
+			this.ctx.chatContainer.addChild(new Spacer(1));
+			this.ctx.chatContainer.addChild(
+				new Text(
+					theme.fg("success", `${theme.status.success} Cleared ${result.removed} artifact directories`),
+					1,
+					0,
+				),
+			);
+		} catch (err) {
+			loader.stop();
+			this.ctx.statusContainer.clear();
+			this.ctx.showError(`Failed to clear cache: ${err instanceof Error ? err.message : String(err)}`);
+		}
+
+		this.ctx.ui.requestRender();
+	}
+
+	private getResolvedSettings(): Record<string, unknown> {
+		// Extract key settings for the report
+		return {
+			model: this.ctx.session.model?.id,
+			thinkingLevel: this.ctx.session.thinkingLevel,
+			planModeEnabled: this.ctx.planModeEnabled,
+			toolOutputExpanded: this.ctx.toolOutputExpanded,
+			hideThinkingBlock: this.ctx.hideThinkingBlock,
+		};
+	}
+}
+
+function formatBytes(bytes: number): string {
+	if (bytes < 1024) return `${bytes} B`;
+	if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+	return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+
+/**
+ * Show the debug selector.
+ */
+export function showDebugSelector(ctx: InteractiveModeContext, done: () => void): DebugSelectorComponent {
+	const selector = new DebugSelectorComponent(ctx, done);
+	return selector;
+}

package/src/debug/profiler.ts

@@ -0,0 +1,158 @@
+/**
+ * CPU and heap profiling wrappers for debug reports.
+ */
+
+export interface CpuProfile {
+	data: string;
+	markdown: string;
+}
+
+export interface ProfilerSession {
+	/** Stop profiling and return the profile data */
+	stop(): Promise<CpuProfile>;
+}
+
+/** V8 CPU Profile node structure */
+interface CpuProfileNode {
+	id: number;
+	callFrame?: {
+		functionName?: string;
+		url?: string;
+		lineNumber?: number;
+	};
+	hitCount?: number;
+	children?: number[];
+}
+
+/** V8 CPU Profile structure */
+interface CpuProfileData {
+	nodes?: CpuProfileNode[];
+	samples?: number[];
+	timeDeltas?: number[];
+	startTime?: number;
+	endTime?: number;
+}
+
+/**
+ * Format CPU profile data as markdown for LLM analysis.
+ * Extracts top functions by self time and call counts.
+ */
+function formatProfileAsMarkdown(profileJson: string): string {
+	try {
+		const profile = JSON.parse(profileJson) as CpuProfileData;
+		const nodes = profile.nodes ?? [];
+
+		interface NodeInfo {
+			id: number;
+			functionName: string;
+			url: string;
+			lineNumber: number;
+			selfTime: number;
+			hitCount: number;
+		}
+
+		const nodeMap = new Map<number, NodeInfo>();
+		for (const node of nodes) {
+			nodeMap.set(node.id, {
+				id: node.id,
+				functionName: node.callFrame?.functionName ?? "(anonymous)",
+				url: node.callFrame?.url ?? "",
+				lineNumber: node.callFrame?.lineNumber ?? 0,
+				selfTime: 0,
+				hitCount: node.hitCount ?? 0,
+			});
+		}
+
+		// Distribute sample times to nodes
+		const samples = profile.samples ?? [];
+		const timeDeltas = profile.timeDeltas ?? [];
+		for (let i = 0; i < samples.length; i++) {
+			const nodeId = samples[i];
+			const info = nodeId !== undefined ? nodeMap.get(nodeId) : undefined;
+			const delta = timeDeltas[i] ?? 0;
+			if (info) {
+				info.selfTime += delta;
+			}
+		}
+
+		// Sort by self time and get top functions
+		const sorted = Array.from(nodeMap.values())
+			.filter(n => n.selfTime > 0 && n.functionName !== "(root)" && n.functionName !== "(idle)")
+			.sort((a, b) => b.selfTime - a.selfTime)
+			.slice(0, 30);
+
+		if (sorted.length === 0) {
+			return "# CPU Profile Summary\n\nNo significant CPU activity recorded.";
+		}
+
+		const totalTime = sorted.reduce((sum, n) => sum + n.selfTime, 0);
+
+		const lines = ["# CPU Profile Summary", ""];
+		lines.push(`Total profiled time: ${(totalTime / 1000).toFixed(1)}ms`);
+		lines.push("");
+		lines.push("## Top Functions by Self Time");
+		lines.push("");
+		lines.push("| Function | Self Time (ms) | % | Location |");
+		lines.push("|----------|----------------|---|----------|");
+
+		for (const node of sorted) {
+			const selfMs = (node.selfTime / 1000).toFixed(1);
+			const pct = ((node.selfTime / totalTime) * 100).toFixed(1);
+			const location = node.url ? `${node.url}:${node.lineNumber}` : "-";
+			lines.push(`| ${node.functionName} | ${selfMs} | ${pct}% | ${location} |`);
+		}
+
+		return lines.join("\n");
+	} catch {
+		return "# CPU Profile Summary\n\nFailed to parse profile data.";
+	}
+}
+
+/**
+ * Start CPU profiling.
+ * Returns a session that can be stopped to get the profile data.
+ */
+export async function startCpuProfile(): Promise<ProfilerSession> {
+	const v8 = await import("node:v8");
+	v8.setFlagsFromString("--allow-natives-syntax");
+
+	const { Session } = await import("node:inspector/promises");
+	const session = new Session();
+	session.connect();
+
+	await session.post("Profiler.enable");
+	await session.post("Profiler.start");
+
+	return {
+		async stop(): Promise<CpuProfile> {
+			const result = await session.post("Profiler.stop");
+			await session.post("Profiler.disable");
+			session.disconnect();
+
+			const data = JSON.stringify(result.profile, null, 2);
+			const markdown = formatProfileAsMarkdown(data);
+
+			return { data, markdown };
+		},
+	};
+}
+
+export interface HeapSnapshot {
+	data: string;
+}
+
+/**
+ * Generate a heap snapshot.
+ * Uses Bun's built-in generateHeapSnapshot.
+ */
+export function generateHeapSnapshotData(): HeapSnapshot {
+	// Force GC before snapshot
+	Bun.gc(true);
+
+	// Use V8 format for Chrome DevTools compatibility
+	const snapshot = Bun.generateHeapSnapshot("v8");
+
+	return {
+		data: snapshot,
+	};
+}