@oh-my-pi/pi-coding-agent 14.5.11 → 14.5.13

package/src/eval/parse.ts

@@ -0,0 +1,337 @@
+import type { EvalLanguage } from "./types";
+
+export type EvalLanguageOrigin = "default" | "fence";
+
+export interface ParsedEvalCell {
+	index: number;
+	title?: string;
+	code: string;
+	language: EvalLanguage;
+	languageOrigin: EvalLanguageOrigin;
+	timeoutMs: number;
+	reset: boolean;
+}
+
+export interface ParsedEvalInput {
+	cells: ParsedEvalCell[];
+}
+
+const DEFAULT_TIMEOUT_MS = 30_000;
+
+/**
+ * Canonical fenced-language tokens we map onto our two backends. Matched
+ * case-insensitively. Anything else found in a fence info string is treated as
+ * a title fragment rather than a language; this is intentional fallback
+ * behaviour and MUST NOT be advertised in the tool's prompt — the lark grammar
+ * describes the canonical surface we encourage callers to emit.
+ */
+const LANGUAGE_ALIASES: Record<string, EvalLanguage> = {
+	py: "python",
+	python: "python",
+	ipy: "python",
+	ipython: "python",
+	js: "js",
+	javascript: "js",
+	ts: "js",
+	typescript: "js",
+};
+
+function resolveLanguageAlias(token: string): EvalLanguage | undefined {
+	return LANGUAGE_ALIASES[token.toLowerCase()];
+}
+
+/**
+ * Map an attribute key (from `key=value` in a fence info string) to one of
+ * the three canonical roles. Canonical keys: `id`, `t`, `rst`. Fallback
+ * aliases — accepted but not advertised in the prompt — cover common
+ * synonyms the LLM is likely to reach for instead of the short canonical.
+ */
+const ID_KEYS = new Set(["id", "title", "name", "cell", "file", "label"]);
+const T_KEYS = new Set(["t", "timeout", "duration", "time"]);
+const RST_KEYS = new Set(["rst", "reset"]);
+
+function classifyAttrKey(key: string): "id" | "t" | "rst" | null {
+	if (ID_KEYS.has(key)) return "id";
+	if (T_KEYS.has(key)) return "t";
+	if (RST_KEYS.has(key)) return "rst";
+	return null;
+}
+
+interface RawBlock {
+	type: "raw";
+	lines: string[];
+	startLine: number;
+}
+
+interface FencedBlock {
+	type: "fenced";
+	info: string;
+	codeLines: string[];
+	startLine: number;
+}
+
+type Block = RawBlock | FencedBlock;
+
+interface FenceInfo {
+	language?: EvalLanguage;
+	title?: string;
+	timeoutMs?: number;
+	reset?: boolean;
+}
+
+const ATTR_TOKEN_RE = /^([a-zA-Z][\w-]*)=(?:"([^"]*)"|'([^']*)'|(.*))$/;
+const DURATION_TOKEN_RE = /^\d+(?:ms|s|m)?$/;
+
+function parseDurationMs(raw: string, lineNumber: number): number {
+	const match = /^(\d+)(ms|s|m)?$/.exec(raw.trim());
+	if (!match) {
+		throw new Error(
+			`Eval line ${lineNumber}: invalid duration \`${raw}\`; use a number with optional ms, s, or m units.`,
+		);
+	}
+	const value = Number.parseInt(match[1], 10);
+	const unit = match[2] ?? "s";
+	if (unit === "ms") return value;
+	if (unit === "s") return value * 1000;
+	return value * 60_000;
+}
+
+function parseBoolean(value: string): boolean | undefined {
+	const normalized = value.trim().toLowerCase();
+	if (normalized === "true" || normalized === "1" || normalized === "yes" || normalized === "on") return true;
+	if (normalized === "false" || normalized === "0" || normalized === "no" || normalized === "off") return false;
+	return undefined;
+}
+
+function trimOuterBlankLines(lines: string[]): string[] {
+	let start = 0;
+	let end = lines.length;
+	while (start < end && lines[start].trim() === "") start++;
+	while (end > start && lines[end - 1].trim() === "") end--;
+	return lines.slice(start, end);
+}
+
+function parseFenceOpener(line: string): { char: "`" | "~"; count: number; info: string } | null {
+	const opener = /^(`{3,}|~{3,})(.*)$/.exec(line);
+	if (!opener) return null;
+	const run = opener[1];
+	return { char: run[0] as "`" | "~", count: run.length, info: opener[2].trim() };
+}
+
+function isFenceCloser(line: string, char: "`" | "~", minCount: number): boolean {
+	let count = 0;
+	while (count < line.length && line[count] === char) count++;
+	if (count < minCount) return false;
+	return line.slice(count).trim() === "";
+}
+
+/**
+ * Tokenize a fence info string while preserving content inside matching
+ * single or double quotes as a single token. The opening and closing quote
+ * characters are kept verbatim so attribute parsing can strip them later.
+ */
+function tokenizeInfoString(info: string): string[] {
+	const tokens: string[] = [];
+	let i = 0;
+	while (i < info.length) {
+		while (i < info.length && /\s/.test(info[i])) i++;
+		if (i >= info.length) break;
+		let token = "";
+		while (i < info.length && !/\s/.test(info[i])) {
+			const ch = info[i];
+			if (ch === '"' || ch === "'") {
+				token += ch;
+				i++;
+				while (i < info.length && info[i] !== ch) {
+					token += info[i];
+					i++;
+				}
+				if (i < info.length) {
+					token += info[i];
+					i++;
+				}
+			} else {
+				token += ch;
+				i++;
+			}
+		}
+		tokens.push(token);
+	}
+	return tokens;
+}
+
+/**
+ * Decode a fence info string into language, title, timeout, and reset flag.
+ *
+ * Layout (positional → kv, all optional):
+ *   `<lang>? <duration>? <(title-fragment | key=value)>*`
+ *
+ * Canonical attribute keys (the only ones surfaced in the lark grammar):
+ *   - `id`  → cell title
+ *   - `t`   → per-cell timeout
+ *   - `rst` → boolean reset for this cell's kernel
+ *
+ * Lenient fallback aliases (NOT advertised in the prompt; we silently accept
+ * them when the LLM reaches for a more familiar key):
+ *   - id:  title, name, cell, file, label
+ *   - t:   timeout, duration, time
+ *   - rst: reset
+ *
+ * Truly unknown keys are silently dropped. First occurrence wins when a key
+ * is repeated (canonical or alias).
+ *
+ * - First token is consumed as a language alias when it matches one; otherwise
+ *   it falls through to the title-fragment branch and the cell inherits the
+ *   surrounding language.
+ * - The first remaining duration-shaped token (e.g. `15s`, `500ms`, `2m`,
+ *   `30`) becomes the positional timeout. The `t=` attribute always wins.
+ * - Anything else accumulates as positional title fragments joined by spaces.
+ */
+function parseFenceInfo(info: string, lineNumber: number): FenceInfo {
+	const tokens = tokenizeInfoString(info.trim());
+	if (tokens.length === 0) return {};
+
+	let language: EvalLanguage | undefined;
+	let positionalDurationMs: number | undefined;
+	const titleParts: string[] = [];
+	let idAttr: string | undefined;
+	let tAttr: string | undefined;
+	let rstAttr: string | undefined;
+
+	for (let idx = 0; idx < tokens.length; idx++) {
+		const token = tokens[idx];
+		const attrMatch = ATTR_TOKEN_RE.exec(token);
+		if (attrMatch) {
+			const key = attrMatch[1].toLowerCase();
+			const value = attrMatch[2] ?? attrMatch[3] ?? attrMatch[4] ?? "";
+			const role = classifyAttrKey(key);
+			if (role === "id" && idAttr === undefined) idAttr = value;
+			else if (role === "t" && tAttr === undefined) tAttr = value;
+			else if (role === "rst" && rstAttr === undefined) rstAttr = value;
+			// unknown / repeated keys silently dropped
+			continue;
+		}
+		if (idx === 0) {
+			const lang = resolveLanguageAlias(token);
+			if (lang) {
+				language = lang;
+				continue;
+			}
+		}
+		if (positionalDurationMs === undefined && DURATION_TOKEN_RE.test(token)) {
+			positionalDurationMs = parseDurationMs(token, lineNumber);
+			continue;
+		}
+		titleParts.push(token);
+	}
+
+	const explicitTitle = (idAttr ?? "").trim();
+	const positionalTitle = titleParts.join(" ").trim();
+	const title = explicitTitle.length > 0 ? explicitTitle : positionalTitle.length > 0 ? positionalTitle : undefined;
+
+	let timeoutMs: number | undefined;
+	if (tAttr !== undefined) {
+		timeoutMs = parseDurationMs(tAttr, lineNumber);
+	} else if (positionalDurationMs !== undefined) {
+		timeoutMs = positionalDurationMs;
+	}
+
+	let reset: boolean | undefined;
+	if (rstAttr !== undefined) {
+		const parsed = parseBoolean(rstAttr);
+		if (parsed === undefined) {
+			throw new Error(`Eval line ${lineNumber}: invalid rst value \`${rstAttr}\`; use true or false.`);
+		}
+		reset = parsed;
+	}
+
+	return { language, title, timeoutMs, reset };
+}
+
+/**
+ * Walk normalized lines and split into top-level fenced blocks and raw
+ * (between/around fences) blocks. Unclosed fences are leniently closed at
+ * end-of-input. Raw blocks with only blank lines are dropped.
+ */
+function splitIntoBlocks(lines: string[]): Block[] {
+	const blocks: Block[] = [];
+	let i = 0;
+	while (i < lines.length) {
+		const line = lines[i];
+		const opener = parseFenceOpener(line);
+		if (opener) {
+			const fenceStart = i + 1; // 1-indexed line number of opener
+			const codeLines: string[] = [];
+			let j = i + 1;
+			let closed = false;
+			while (j < lines.length) {
+				if (isFenceCloser(lines[j], opener.char, opener.count)) {
+					closed = true;
+					break;
+				}
+				codeLines.push(lines[j]);
+				j++;
+			}
+			blocks.push({ type: "fenced", info: opener.info, codeLines, startLine: fenceStart });
+			i = closed ? j + 1 : j;
+		} else {
+			const rawStart = i + 1;
+			const rawLines: string[] = [line];
+			let j = i + 1;
+			while (j < lines.length && !parseFenceOpener(lines[j])) {
+				rawLines.push(lines[j]);
+				j++;
+			}
+			const trimmed = trimOuterBlankLines(rawLines);
+			if (trimmed.length > 0) {
+				blocks.push({ type: "raw", lines: trimmed, startLine: rawStart });
+			}
+			i = j;
+		}
+	}
+	return blocks;
+}
+
+interface ExpansionState {
+	language: EvalLanguage;
+	languageOrigin: EvalLanguageOrigin;
+}
+
+export function parseEvalInput(input: string): ParsedEvalInput {
+	const normalized = input.replace(/\r\n?/g, "\n");
+	const lines = normalized.split("\n");
+	const blocks = splitIntoBlocks(lines);
+
+	const state: ExpansionState = { language: "python", languageOrigin: "default" };
+	const cells: ParsedEvalCell[] = [];
+	for (const block of blocks) {
+		if (block.type === "raw") {
+			cells.push({
+				index: cells.length,
+				title: undefined,
+				code: block.lines.join("\n"),
+				language: state.language,
+				languageOrigin: state.languageOrigin,
+				timeoutMs: DEFAULT_TIMEOUT_MS,
+				reset: false,
+			});
+			continue;
+		}
+		const fence = parseFenceInfo(block.info, block.startLine);
+		const language = fence.language ?? state.language;
+		const languageOrigin: EvalLanguageOrigin = fence.language ? "fence" : state.languageOrigin;
+		cells.push({
+			index: cells.length,
+			title: fence.title,
+			code: block.codeLines.join("\n"),
+			language,
+			languageOrigin,
+			timeoutMs: fence.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+			reset: fence.reset ?? false,
+		});
+		state.language = language;
+		state.languageOrigin = languageOrigin;
+	}
+
+	return { cells };
+}

package/src/{ipy → eval/py}/executor.ts

@@ -1,17 +1,13 @@
-import * as path from "node:path";
-import { getAgentDir, getProjectDir, isBunTestRuntime, isEnoent, logger } from "@oh-my-pi/pi-utils";
-import { OutputSink } from "../session/streaming-output";
+import { getProjectDir, logger } from "@oh-my-pi/pi-utils";
+import { OutputSink } from "../../session/streaming-output";
 import { shutdownSharedGateway } from "./gateway-coordinator";
 import {
 	checkPythonKernelAvailability,
 	type KernelDisplayOutput,
 	type KernelExecuteOptions,
 	type KernelExecuteResult,
-	type PreludeHelper,
 	PythonKernel,
 } from "./kernel";
-import { discoverPythonModules } from "./modules";
-import { PYTHON_PRELUDE } from "./prelude";
 
 const IDLE_TIMEOUT_MS = 5 * 60 * 1000; // 5 minutes
 const MAX_KERNEL_SESSIONS = 4;
@@ -101,7 +97,6 @@ interface KernelSession {
 
 const kernelSessions = new Map<string, KernelSession>();
 const disposingKernelSessions = new Set<KernelSession>();
-let cachedPreludeDocs: PreludeHelper[] | null = null;
 let cleanupTimer: NodeJS.Timeout | null = null;
 
 interface KernelSessionExecutionOptions {
@@ -256,110 +251,6 @@ function buildKernelStartOptions(
 	};
 }
 
-interface PreludeCacheSource {
-	path: string;
-	hash: string;
-}
-
-interface PreludeCachePayload {
-	helpers: PreludeHelper[];
-	sources: PreludeCacheSource[];
-}
-
-interface PreludeCacheState {
-	cacheKey: string;
-	cachePath: string;
-	sources: PreludeCacheSource[];
-}
-
-const PRELUDE_CACHE_DIR = "pycache";
-
-function hashPreludeContent(content: string): string {
-	return Bun.hash(content).toString(16);
-}
-
-async function buildPreludeCacheState(cwd: string): Promise<PreludeCacheState> {
-	const modules = await discoverPythonModules({ cwd });
-	const moduleSources = modules
-		.map(module => ({ path: module.path, hash: hashPreludeContent(module.content) }))
-		.sort((a, b) => a.path.localeCompare(b.path));
-	const sources: PreludeCacheSource[] = [
-		{ path: "omp:prelude", hash: hashPreludeContent(PYTHON_PRELUDE) },
-		...moduleSources,
-	];
-	const composite = sources.map(source => `${source.path}:${source.hash}`).join("|");
-	const cacheKey = Bun.hash(composite).toString(16);
-	const cachePath = path.join(getAgentDir(), PRELUDE_CACHE_DIR, `${cacheKey}.json`);
-	return { cacheKey, cachePath, sources };
-}
-
-async function readPreludeCache(state: PreludeCacheState): Promise<PreludeHelper[] | null> {
-	let raw: string;
-	try {
-		raw = await Bun.file(state.cachePath).text();
-	} catch (err) {
-		if (isEnoent(err)) return null;
-		logger.warn("Failed to read Python prelude cache", { path: state.cachePath, error: String(err) });
-		return null;
-	}
-	try {
-		const parsed = JSON.parse(raw) as PreludeCachePayload | PreludeHelper[];
-		const helpers = Array.isArray(parsed) ? parsed : parsed.helpers;
-		if (!Array.isArray(helpers) || helpers.length === 0) return null;
-		return helpers;
-	} catch (err) {
-		logger.warn("Failed to parse Python prelude cache", { path: state.cachePath, error: String(err) });
-		return null;
-	}
-}
-
-async function writePreludeCache(state: PreludeCacheState, helpers: PreludeHelper[]): Promise<void> {
-	const payload: PreludeCachePayload = { helpers, sources: state.sources };
-	try {
-		await Bun.write(state.cachePath, JSON.stringify(payload));
-	} catch (err) {
-		logger.warn("Failed to write Python prelude cache", { path: state.cachePath, error: String(err) });
-	}
-}
-
-function getPreludeIntrospectionOptions(
-	options: KernelSessionExecutionOptions = {},
-): Pick<KernelExecuteOptions, "signal" | "timeoutMs"> {
-	return {
-		signal: options.signal,
-		timeoutMs: requireRemainingTimeoutMs(options.deadlineMs),
-	};
-}
-
-async function cachePreludeDocs(
-	cwd: string,
-	docs: PreludeHelper[],
-	cacheState?: PreludeCacheState | null,
-): Promise<PreludeHelper[]> {
-	cachedPreludeDocs = docs;
-	if (!isBunTestRuntime() && docs.length > 0) {
-		const state = cacheState ?? (await buildPreludeCacheState(cwd));
-		await writePreludeCache(state, docs);
-	}
-	return docs;
-}
-
-async function ensurePreludeDocsLoaded(
-	kernel: PythonKernel,
-	cwd: string,
-	options: KernelSessionExecutionOptions = {},
-	cacheState?: PreludeCacheState | null,
-): Promise<PreludeHelper[]> {
-	if (cachedPreludeDocs && cachedPreludeDocs.length > 0) {
-		return cachedPreludeDocs;
-	}
-	const docs = await kernel.introspectPrelude(getPreludeIntrospectionOptions(options));
-	if (docs.length === 0) {
-		throw new Error("Python prelude helpers unavailable");
-	}
-	return cachePreludeDocs(cwd, docs, cacheState);
-}
-
 function startCleanupTimer(): void {
 	if (cleanupTimer) return;
 	cleanupTimer = setInterval(() => {
@@ -562,75 +453,6 @@ async function ensureKernelAvailable(
 	}
 }
 
-export async function warmPythonEnvironment(
-	cwd: string,
-	sessionId?: string,
-	useSharedGateway?: boolean,
-	sessionFile?: string,
-	kernelOwnerId?: string,
-	signal?: AbortSignal,
-): Promise<{ ok: boolean; reason?: string; docs: PreludeHelper[] }> {
-	let cacheState: PreludeCacheState | null = null;
-	const resolvedSessionId = sessionId ?? `session:${cwd}`;
-	try {
-		await logger.time("warmPython:ensureKernelAvailable", ensureKernelAvailable, cwd, { signal });
-	} catch (err: unknown) {
-		const reason = err instanceof Error ? err.message : String(err);
-		cachedPreludeDocs = [];
-		return { ok: false, reason, docs: [] };
-	}
-	if (!isBunTestRuntime()) {
-		try {
-			cacheState = await buildPreludeCacheState(cwd);
-			const cached = await readPreludeCache(cacheState);
-			if (cached) {
-				cachedPreludeDocs = cached;
-				attachKernelOwner(resolvedSessionId, kernelOwnerId);
-				return { ok: true, docs: cached };
-			}
-		} catch (err) {
-			logger.warn("Failed to resolve Python prelude cache", { error: String(err) });
-			cacheState = null;
-		}
-	}
-	if (cachedPreludeDocs && cachedPreludeDocs.length > 0) {
-		attachKernelOwner(resolvedSessionId, kernelOwnerId);
-		return { ok: true, docs: cachedPreludeDocs };
-	}
-	try {
-		const docs = await logger.time(
-			"warmPython:withKernelSession",
-			withKernelSession,
-			resolvedSessionId,
-			cwd,
-			kernel => ensurePreludeDocsLoaded(kernel, cwd, { useSharedGateway, sessionFile, signal }, cacheState),
-			{
-				useSharedGateway,
-				sessionFile,
-				kernelOwnerId,
-				signal,
-			},
-		);
-		return { ok: true, docs };
-	} catch (err: unknown) {
-		const reason = err instanceof Error ? err.message : String(err);
-		cachedPreludeDocs = [];
-		return { ok: false, reason, docs: [] };
-	}
-}
-
-export function getPreludeDocs(): PreludeHelper[] {
-	return cachedPreludeDocs ?? [];
-}
-
-export function setPreludeDocsCache(docs: PreludeHelper[]): void {
-	cachedPreludeDocs = docs;
-}
-
-export function resetPreludeDocsCache(): void {
-	cachedPreludeDocs = null;
-}
-
 function isResourceExhaustionError(error: unknown): boolean {
 	const message = error instanceof Error ? error.message : String(error);
 	return (

package/src/{ipy → eval/py}/gateway-coordinator.ts

@@ -1,10 +1,11 @@
 import * as fs from "node:fs";
 import { createServer } from "node:net";
 import * as path from "node:path";
+import { Process } from "@oh-my-pi/pi-natives";
 import { getAgentDir, isEnoent, logger, procmgr } from "@oh-my-pi/pi-utils";
 import type { Subprocess } from "bun";
-import { Settings } from "../config/settings";
-import { getOrCreateSnapshot } from "../utils/shell-snapshot";
+import { Settings } from "../../config/settings";
+import { getOrCreateSnapshot } from "../../utils/shell-snapshot";
 import { filterEnv, resolvePythonRuntime } from "./runtime";
 
 const GATEWAY_DIR_NAME = "python-gateway";
@@ -300,7 +301,7 @@ async function startGatewayProcess(
 
 async function killGateway(pid: number, context: string): Promise<void> {
 	try {
-		await procmgr.terminate({ target: pid });
+		await Process.fromPid(pid)?.terminate();
 	} catch (err) {
 		logger.warn("Failed to kill shared gateway process", {
 			error: err instanceof Error ? err.message : String(err),

package/src/eval/py/index.ts

@@ -0,0 +1,58 @@
+import type { ToolSession } from "../../tools";
+import type { ExecutorBackend, ExecutorBackendExecOptions, ExecutorBackendResult } from "../backend";
+import { executePython, type PythonExecutorOptions } from "./executor";
+import { checkPythonKernelAvailability } from "./kernel";
+
+const PYTHON_SESSION_PREFIX = "python:";
+
+function namespaceSessionId(sessionId: string): string {
+	return sessionId.startsWith(PYTHON_SESSION_PREFIX) ? sessionId : `${PYTHON_SESSION_PREFIX}${sessionId}`;
+}
+
+function readSetting<T>(session: ToolSession, key: string): T | undefined {
+	const settings = session.settings as { get?: (key: string) => T | undefined } | undefined;
+	return settings?.get?.(key);
+}
+
+export default {
+	id: "python",
+	label: "Python",
+	highlightLang: "python",
+
+	async isAvailable(session: ToolSession): Promise<boolean> {
+		const availability = await checkPythonKernelAvailability(session.cwd);
+		return availability.ok;
+	},
+
+	async execute(code: string, opts: ExecutorBackendExecOptions): Promise<ExecutorBackendResult> {
+		const useSharedGateway = readSetting<boolean>(opts.session, "python.sharedGateway");
+		const kernelMode = readSetting<PythonExecutorOptions["kernelMode"]>(opts.session, "python.kernelMode");
+		const executorOptions: PythonExecutorOptions = {
+			cwd: opts.cwd,
+			deadlineMs: opts.deadlineMs,
+			signal: opts.signal,
+			sessionId: namespaceSessionId(opts.sessionId),
+			kernelMode,
+			useSharedGateway,
+			sessionFile: opts.sessionFile,
+			kernelOwnerId: opts.kernelOwnerId,
+			reset: opts.reset,
+			artifactPath: opts.artifactPath,
+			artifactId: opts.artifactId,
+			onChunk: opts.onChunk,
+		};
+		const result = await executePython(code, executorOptions);
+		return {
+			output: result.output,
+			exitCode: result.exitCode,
+			cancelled: result.cancelled,
+			truncated: result.truncated,
+			artifactId: result.artifactId,
+			totalLines: result.totalLines,
+			totalBytes: result.totalBytes,
+			outputLines: result.outputLines,
+			outputBytes: result.outputBytes,
+			displayOutputs: result.displayOutputs,
+		};
+	},
+} satisfies ExecutorBackend;