@oh-my-pi/pi-coding-agent 5.5.0 → 5.6.7

package/src/core/python-prelude.test.ts

@@ -0,0 +1,140 @@
+import { describe, expect, it } from "bun:test";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { resetPreludeDocsCache, warmPythonEnvironment } from "./python-executor";
+import { createPythonTool, getPythonToolDescription } from "./tools/python";
+
+const resolvePythonPath = (): string | null => {
+	const venvPath = process.env.VIRTUAL_ENV;
+	const candidates = [venvPath, join(process.cwd(), ".venv"), join(process.cwd(), "venv")].filter(Boolean) as string[];
+	for (const candidate of candidates) {
+		const binDir = process.platform === "win32" ? "Scripts" : "bin";
+		const exeName = process.platform === "win32" ? "python.exe" : "python";
+		const pythonCandidate = join(candidate, binDir, exeName);
+		if (existsSync(pythonCandidate)) {
+			return pythonCandidate;
+		}
+	}
+	return Bun.which("python") ?? Bun.which("python3");
+};
+
+const pythonPath = resolvePythonPath();
+const hasKernelDeps = (() => {
+	if (!pythonPath) return false;
+	const result = Bun.spawnSync(
+		[
+			pythonPath,
+			"-c",
+			"import importlib.util,sys;sys.exit(0 if importlib.util.find_spec('kernel_gateway') and importlib.util.find_spec('ipykernel') else 1)",
+		],
+		{ stdin: "ignore", stdout: "pipe", stderr: "pipe" },
+	);
+	return result.exitCode === 0;
+})();
+
+const shouldRun = Boolean(pythonPath) && hasKernelDeps;
+
+describe.skipIf(!shouldRun)("PYTHON_PRELUDE integration", () => {
+	it("exposes prelude helpers via python tool", async () => {
+		const helpers = [
+			"pwd",
+			"cd",
+			"env",
+			"read",
+			"write",
+			"append",
+			"mkdir",
+			"rm",
+			"mv",
+			"cp",
+			"ls",
+			"cat",
+			"touch",
+			"find",
+			"grep",
+			"rgrep",
+			"head",
+			"tail",
+			"replace",
+			"sed",
+			"rsed",
+			"wc",
+			"sort_lines",
+			"uniq",
+			"cols",
+			"tree",
+			"stat",
+			"diff",
+			"glob_files",
+			"batch",
+			"lines",
+			"delete_lines",
+			"delete_matching",
+			"insert_at",
+			"git_status",
+			"git_diff",
+			"git_log",
+			"git_show",
+			"git_file_at",
+			"git_branch",
+			"git_has_changes",
+			"run",
+			"sh",
+		];
+
+		const session = {
+			cwd: process.cwd(),
+			hasUI: false,
+			getSessionFile: () => null,
+			getSessionSpawns: () => null,
+			settings: {
+				getImageAutoResize: () => true,
+				getLspFormatOnWrite: () => false,
+				getLspDiagnosticsOnWrite: () => false,
+				getLspDiagnosticsOnEdit: () => false,
+				getEditFuzzyMatch: () => true,
+				getGitToolEnabled: () => true,
+				getBashInterceptorEnabled: () => true,
+				getBashInterceptorSimpleLsEnabled: () => true,
+				getBashInterceptorRules: () => [],
+				getPythonToolMode: () => "ipy-only" as const,
+				getPythonKernelMode: () => "per-call" as const,
+			},
+		};
+
+		const tool = createPythonTool(session);
+		const code = `
+	helpers = ${JSON.stringify(helpers)}
+	missing = [name for name in helpers if name not in globals() or not callable(globals()[name])]
+	docs = __omp_prelude_docs__()
+	doc_names = [d.get("name") for d in docs]
+	doc_categories = [d.get("category") for d in docs]
+	print("HELPERS_OK=" + ("1" if not missing else "0"))
+	print("DOCS_OK=" + ("1" if "pwd" in doc_names and "Navigation" in doc_categories else "0"))
+	if missing:
+	    print("MISSING=" + ",".join(missing))
+	`;
+
+		const result = await tool.execute("tool-call-1", { code });
+		const output = result.content.find((item) => item.type === "text")?.text ?? "";
+		expect(output).toContain("HELPERS_OK=1");
+		expect(output).toContain("DOCS_OK=1");
+	});
+
+	it("exposes prelude docs via warmup", async () => {
+		resetPreludeDocsCache();
+		const result = await warmPythonEnvironment(process.cwd(), undefined, false);
+		expect(result.ok).toBe(true);
+		const names = result.docs.map((doc) => doc.name);
+		expect(names).toContain("pwd");
+	});
+
+	it("renders prelude docs in python tool description", async () => {
+		resetPreludeDocsCache();
+		const result = await warmPythonEnvironment(process.cwd(), undefined, false);
+		expect(result.ok).toBe(true);
+		const description = getPythonToolDescription();
+		expect(description).toContain("pwd");
+		expect(description).not.toContain("Documentation unavailable");
+	});
+});

package/src/core/python-prelude.ts

@@ -0,0 +1,3 @@
+import pythonPrelude from "./python-prelude.py" with { type: "text" };
+
+export const PYTHON_PRELUDE = pythonPrelude;

package/src/core/sdk.ts

@@ -66,6 +66,7 @@ import { convertToLlm } from "./messages";
 import { ModelRegistry } from "./model-registry";
 import { formatModelString, parseModelString } from "./model-resolver";
 import { loadPromptTemplates as loadPromptTemplatesInternal, type PromptTemplate } from "./prompt-templates";
+import { disposeAllKernelSessions } from "./python-executor";
 import { SessionManager } from "./session-manager";
 import { type Settings, SettingsManager, type SkillsSettings } from "./settings-manager";
 import { loadSkills as loadSkillsInternal, type Skill, type SkillWarning } from "./skills";
@@ -88,6 +89,7 @@ import {
 	createGitTool,
 	createGrepTool,
 	createLsTool,
+	createPythonTool,
 	createReadTool,
 	createSshTool,
 	createTools,
@@ -217,6 +219,7 @@ export {
 	// Individual tool factories (for custom usage)
 	createReadTool,
 	createBashTool,
+	createPythonTool,
 	createSshTool,
 	createEditTool,
 	createWriteTool,
@@ -441,6 +444,16 @@ function registerSshCleanup(): void {
 	registerAsyncCleanup(() => cleanupSshResources());
 }
 
+let pythonCleanupRegistered = false;
+
+function registerPythonCleanup(): void {
+	if (pythonCleanupRegistered) return;
+	pythonCleanupRegistered = true;
+	registerAsyncCleanup(async () => {
+		await disposeAllKernelSessions();
+	});
+}
+
 function customToolToDefinition(tool: CustomTool): ToolDefinition {
 	const definition: ToolDefinition & { [TOOL_DEFINITION_MARKER]: true } = {
 		name: tool.name,
@@ -541,6 +554,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 	const eventBus = options.eventBus ?? createEventBus();
 
 	registerSshCleanup();
+	registerPythonCleanup();
 
 	// Use provided or create AuthStorage and ModelRegistry
 	const authStorage = options.authStorage ?? (await discoverAuthStorage(agentDir));
@@ -726,7 +740,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 
 		// Log MCP errors
 		for (const { path, error } of mcpResult.errors) {
-			console.error(`MCP "${path}": ${error}`);
+			logger.error("MCP tool load failed", { path, error });
 		}
 
 		if (mcpResult.tools.length > 0) {
@@ -784,7 +798,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		);
 		time("discoverAndLoadExtensions");
 		for (const { path, error } of extensionsResult.errors) {
-			console.error(`Failed to load extension "${path}": ${error}`);
+			logger.error("Failed to load extension", { path, error });
 		}
 	}
 
@@ -804,10 +818,14 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 	}
 
 	// Discover custom commands (TypeScript slash commands)
-	const customCommandsResult = await loadCustomCommandsInternal({ cwd, agentDir });
-	time("discoverCustomCommands");
-	for (const { path, error } of customCommandsResult.errors) {
-		console.error(`Failed to load custom command "${path}": ${error}`);
+	const customCommandsResult: CustomCommandsLoadResult = options.disableExtensionDiscovery
+		? { commands: [], errors: [] }
+		: await loadCustomCommandsInternal({ cwd, agentDir });
+	if (!options.disableExtensionDiscovery) {
+		time("discoverCustomCommands");
+		for (const { path, error } of customCommandsResult.errors) {
+			logger.error("Failed to load custom command", { path, error });
+		}
 	}
 
 	let extensionRunner: ExtensionRunner | undefined;

package/src/core/session-manager.ts

@@ -456,8 +456,8 @@ export function loadEntriesFromFile(filePath: string, storage: SessionStorage =
 
 	// Validate session header
 	if (entries.length === 0) return entries;
-	const header = entries[0];
-	if (header.type !== "session" || typeof (header as any).id !== "string") {
+	const header = entries[0] as SessionHeader;
+	if (header.type !== "session" || typeof header.id !== "string") {
 		return [];
 	}
 
@@ -468,6 +468,14 @@ export function loadEntriesFromFile(filePath: string, storage: SessionStorage =
  * Lightweight metadata for a session file, used in session picker UI.
  * Uses lazy getters to defer string formatting until actually displayed.
  */
+function sanitizeSessionName(value: string | undefined): string | undefined {
+	if (!value) return undefined;
+	const firstLine = value.split(/\r?\n/)[0] ?? "";
+	const stripped = firstLine.replace(/[\x00-\x1F\x7F]/g, "");
+	const trimmed = stripped.trim();
+	return trimmed.length > 0 ? trimmed : undefined;
+}
+
 class RecentSessionInfo {
 	readonly path: string;
 	readonly mtime: number;
@@ -476,13 +484,16 @@ class RecentSessionInfo {
 	#name: string | undefined;
 	#timeAgo: string | undefined;
 
-	constructor(path: string, mtime: number, header: Record<string, unknown>) {
+	constructor(path: string, mtime: number, header: Record<string, unknown>, firstPrompt?: string) {
 		this.path = path;
 		this.mtime = mtime;
 
-		// Extract title from session header, falling back to id if title is missing
+		// Extract title from session header, falling back to first user prompt, then id
 		const trystr = (v: unknown) => (typeof v === "string" ? v : undefined);
-		this.#fullName = trystr(header.title) ?? trystr(header.id);
+		this.#fullName =
+			sanitizeSessionName(trystr(header.title)) ??
+			sanitizeSessionName(firstPrompt) ??
+			sanitizeSessionName(trystr(header.id));
 	}
 
 	/** Full session name from header, or filename without extension as fallback */
@@ -508,26 +519,58 @@ class RecentSessionInfo {
 	}
 }
 
+/**
+ * Extracts the text content from a user message entry.
+ * Returns undefined if the entry is not a user message or has no text.
+ */
+function extractFirstUserPrompt(lines: string[]): string | undefined {
+	for (let i = 1; i < lines.length; i++) {
+		const line = lines[i];
+		if (!line?.trim()) continue;
+		try {
+			const entry = JSON.parse(line) as Record<string, unknown>;
+			if (entry.type !== "message") continue;
+			const message = entry.message as Record<string, unknown> | undefined;
+			if (message?.role !== "user") continue;
+			const content = message.content;
+			if (typeof content === "string") return content;
+			if (Array.isArray(content)) {
+				for (const block of content) {
+					if (typeof block === "object" && block !== null && "text" in block) {
+						const text = (block as { text: unknown }).text;
+						if (typeof text === "string") return text;
+					}
+				}
+			}
+		} catch {
+			// Invalid JSON, skip to next line
+		}
+	}
+	return undefined;
+}
+
 /**
  * Reads all session files from the directory and returns them sorted by mtime (newest first).
- * Uses low-level file I/O to efficiently read only the first 512 bytes of each file
- * to extract the JSON header without loading entire session logs into memory.
+ * Uses low-level file I/O to efficiently read only the first 4KB of each file
+ * to extract the JSON header and first user message without loading entire session logs into memory.
  */
 function getSortedSessions(sessionDir: string, storage: SessionStorage): RecentSessionInfo[] {
 	try {
-		const buf = Buffer.alloc(512);
+		const buf = Buffer.alloc(4096);
 		const files: string[] = storage.listFilesSync(sessionDir, "*.jsonl");
 		return files
 			.map((path: string) => {
 				try {
 					const length = storage.readTextPrefixSync(path, buf);
 					const content = buf.toString("utf-8", 0, length);
-					const firstLine = content.split("\n")[0];
+					const lines = content.split("\n");
+					const firstLine = lines[0];
 					if (!firstLine || !firstLine.trim()) return null;
 					const header = JSON.parse(firstLine) as Record<string, unknown>;
 					if (header.type !== "session" || typeof header.id !== "string") return null;
 					const mtime = storage.statSync(path).mtimeMs;
-					return new RecentSessionInfo(path, mtime, header);
+					const firstPrompt = header.title ? undefined : extractFirstUserPrompt(lines);
+					return new RecentSessionInfo(path, mtime, header, firstPrompt);
 				} catch {
 					return null;
 				}
@@ -834,6 +877,85 @@ function getTaskToolUsage(details: unknown): Usage | undefined {
 	return usage as Usage;
 }
 
+function extractTextFromContent(content: Message["content"]): string {
+	if (typeof content === "string") return content;
+	return content
+		.filter((block): block is TextContent => block.type === "text")
+		.map((block) => block.text)
+		.join(" ");
+}
+
+function collectSessionsFromFiles(files: string[], storage: SessionStorage): SessionInfo[] {
+	const sessions: SessionInfo[] = [];
+
+	for (const file of files) {
+		try {
+			const content = storage.readTextSync(file);
+			const lines = content.trim().split("\n");
+			if (lines.length === 0) continue;
+
+			// Check first line for valid session header
+			type SessionHeaderShape = { type: string; id: string; cwd?: string; title?: string; timestamp: string };
+			let header: SessionHeaderShape | null = null;
+			try {
+				const first = JSON.parse(lines[0]) as SessionHeaderShape;
+				if (first.type === "session" && first.id) {
+					header = first;
+				}
+			} catch {
+				// Not valid JSON
+			}
+			if (!header) continue;
+
+			const stats = storage.statSync(file);
+			let messageCount = 0;
+			let firstMessage = "";
+			const allMessages: string[] = [];
+
+			for (let i = 1; i < lines.length; i++) {
+				try {
+					const entry = JSON.parse(lines[i]) as { type?: string; message?: Message };
+
+					if (entry.type === "message" && entry.message) {
+						messageCount++;
+
+						if (entry.message.role === "user" || entry.message.role === "assistant") {
+							const textContent = extractTextFromContent(entry.message.content);
+
+							if (textContent) {
+								allMessages.push(textContent);
+
+								if (!firstMessage && entry.message.role === "user") {
+									firstMessage = textContent;
+								}
+							}
+						}
+					}
+				} catch {
+					// Skip malformed lines
+				}
+			}
+
+			sessions.push({
+				path: file,
+				id: header.id,
+				cwd: typeof header.cwd === "string" ? header.cwd : "",
+				title: header.title,
+				created: new Date(header.timestamp),
+				modified: stats.mtime,
+				messageCount,
+				firstMessage: firstMessage || "(no messages)",
+				allMessagesText: allMessages.join(" "),
+			});
+		} catch {
+			// Skip files that can't be read
+		}
+	}
+
+	sessions.sort((a, b) => b.modified.getTime() - a.modified.getTime());
+	return sessions;
+}
+
 export class SessionManager {
 	private sessionId: string = "";
 	private sessionTitle: string | undefined;
@@ -1643,6 +1765,32 @@ export class SessionManager {
 		return manager;
 	}
 
+	/**
+	 * Fork a session into the current project directory.
+	 * Copies history from another session file while creating a new session file in the current sessionDir.
+	 */
+	static async forkFrom(
+		sourcePath: string,
+		cwd: string,
+		sessionDir?: string,
+		storage: SessionStorage = new FileSessionStorage(),
+	): Promise<SessionManager> {
+		const dir = sessionDir ?? getDefaultSessionDir(cwd, storage);
+		const manager = new SessionManager(cwd, dir, true, storage);
+		const forkEntries = structuredClone(loadEntriesFromFile(sourcePath, storage)) as FileEntry[];
+		migrateToCurrentVersion(forkEntries);
+		const sourceHeader = forkEntries.find((e) => e.type === "session") as SessionHeader | undefined;
+		const historyEntries = forkEntries.filter((entry) => entry.type !== "session") as SessionEntry[];
+		manager._newSessionSync({ parentSession: sourceHeader?.id });
+		const newHeader = manager.fileEntries[0] as SessionHeader;
+		newHeader.title = sourceHeader?.title;
+		manager.fileEntries = [newHeader, ...historyEntries];
+		manager.sessionTitle = newHeader.title;
+		manager._buildIndex();
+		await manager._rewriteFile();
+		return manager;
+	}
+
 	/**
 	 * Open a specific session file.
 	 * @param path Path to session file
@@ -1699,82 +1847,26 @@ export class SessionManager {
 	 */
 	static list(cwd: string, sessionDir?: string, storage: SessionStorage = new FileSessionStorage()): SessionInfo[] {
 		const dir = sessionDir ?? getDefaultSessionDir(cwd, storage);
-		const sessions: SessionInfo[] = [];
-
 		try {
 			const files = storage.listFilesSync(dir, "*.jsonl");
-
-			for (const file of files) {
-				try {
-					const content = storage.readTextSync(file);
-					const lines = content.trim().split("\n");
-					if (lines.length === 0) continue;
-
-					// Check first line for valid session header
-					let header: { type: string; id: string; cwd?: string; title?: string; timestamp: string } | null = null;
-					try {
-						const first = JSON.parse(lines[0]);
-						if (first.type === "session" && first.id) {
-							header = first;
-						}
-					} catch {
-						// Not valid JSON
-					}
-					if (!header) continue;
-
-					const stats = storage.statSync(file);
-					let messageCount = 0;
-					let firstMessage = "";
-					const allMessages: string[] = [];
-
-					for (let i = 1; i < lines.length; i++) {
-						try {
-							const entry = JSON.parse(lines[i]);
-
-							if (entry.type === "message") {
-								messageCount++;
-
-								if (entry.message.role === "user" || entry.message.role === "assistant") {
-									const textContent = entry.message.content
-										.filter((c: any) => c.type === "text")
-										.map((c: any) => c.text)
-										.join(" ");
-
-									if (textContent) {
-										allMessages.push(textContent);
-
-										if (!firstMessage && entry.message.role === "user") {
-											firstMessage = textContent;
-										}
-									}
-								}
-							}
-						} catch {
-							// Skip malformed lines
-						}
-					}
-
-					sessions.push({
-						path: file,
-						id: header.id,
-						cwd: typeof header.cwd === "string" ? header.cwd : "",
-						title: header.title,
-						created: new Date(header.timestamp),
-						modified: stats.mtime,
-						messageCount,
-						firstMessage: firstMessage || "(no messages)",
-						allMessagesText: allMessages.join(" "),
-					});
-				} catch {
-					// Skip files that can't be read
-				}
-			}
-
-			sessions.sort((a, b) => b.modified.getTime() - a.modified.getTime());
+			return collectSessionsFromFiles(files, storage);
 		} catch {
-			// Return empty list on error
+			return [];
 		}
+	}
 
-		return sessions;
+	/**
+	 * List all sessions across all project directories.
+	 */
+	static listAll(storage: SessionStorage = new FileSessionStorage()): SessionInfo[] {
+		const sessionsRoot = join(getDefaultAgentDir(), "sessions");
+		try {
+			const files = Array.from(new Bun.Glob("**/*.jsonl").scanSync(sessionsRoot)).map((name) =>
+				join(sessionsRoot, name),
+			);
+			return collectSessionsFromFiles(files, storage);
+		} catch {
+			return [];
+		}
 	}
 }

package/src/core/settings-manager-python.test.ts

@@ -0,0 +1,23 @@
+import { describe, expect, it } from "bun:test";
+import { SettingsManager } from "./settings-manager";
+
+describe("SettingsManager python settings", () => {
+	it("defaults to both and session", () => {
+		const settings = SettingsManager.inMemory();
+
+		expect(settings.getPythonToolMode()).toBe("both");
+		expect(settings.getPythonKernelMode()).toBe("session");
+	});
+
+	it("persists python tool and kernel modes", async () => {
+		const settings = SettingsManager.inMemory();
+
+		await settings.setPythonToolMode("bash-only");
+		await settings.setPythonKernelMode("per-call");
+
+		expect(settings.getPythonToolMode()).toBe("bash-only");
+		expect(settings.getPythonKernelMode()).toBe("per-call");
+		expect(settings.serialize().python?.toolMode).toBe("bash-only");
+		expect(settings.serialize().python?.kernelMode).toBe("per-call");
+	});
+});