@oh-my-pi/pi-coding-agent 15.5.15 → 15.7.0

package/src/eval/py/kernel.ts

@@ -17,7 +17,7 @@ import { Settings } from "../../config/settings";
 import { type KernelDisplayOutput, renderKernelDisplay } from "./display";
 import { PYTHON_PRELUDE } from "./prelude";
 import RUNNER_SCRIPT from "./runner.py" with { type: "text" };
-import { filterEnv, resolvePythonRuntime } from "./runtime";
+import { enumeratePythonRuntimes, filterEnv, type PythonRuntime, resolvePythonRuntime } from "./runtime";
 
 export type { KernelDisplayOutput, PythonStatusEvent } from "./display";
 export { renderKernelDisplay } from "./display";
@@ -106,6 +106,8 @@ export interface PythonKernelAvailability {
 	ok: boolean;
 	pythonPath?: string;
 	reason?: string;
+	/** The probed-working runtime, when one was found. */
+	runtime?: PythonRuntime;
 }
 
 function getRemainingTimeMs(deadlineMs?: number): number | undefined {
@@ -134,19 +136,34 @@ export async function checkPythonKernelAvailability(cwd: string): Promise<Python
 		const settings = await Settings.init();
 		const { env } = settings.getShellConfig();
 		const baseEnv = filterEnv(env);
-		const runtime = resolvePythonRuntime(cwd, baseEnv);
-		const probe = await $`${runtime.pythonPath} -c "import sys;sys.exit(0)"`
-			.quiet()
-			.nothrow()
-			.cwd(cwd)
-			.env(runtime.env);
-		if (probe.exitCode === 0) {
-			return { ok: true, pythonPath: runtime.pythonPath };
+		const runtimes = enumeratePythonRuntimes(cwd, baseEnv);
+		if (runtimes.length === 0) {
+			return { ok: false, reason: "Python executable not found on PATH" };
+		}
+		// Probe each candidate in priority order and use the first that actually
+		// runs. A managed env left behind by a removed `uv` install can exist on
+		// disk yet fail to execute; falling through to the next candidate lets a
+		// working system Python take over instead of failing the whole session.
+		const failures: string[] = [];
+		for (const runtime of runtimes) {
+			try {
+				const probe = await $`${runtime.pythonPath} -c "import sys;sys.exit(0)"`
+					.quiet()
+					.nothrow()
+					.cwd(cwd)
+					.env(runtime.env);
+				if (probe.exitCode === 0) {
+					return { ok: true, pythonPath: runtime.pythonPath, runtime };
+				}
+				failures.push(`${runtime.pythonPath} (exit code ${probe.exitCode})`);
+			} catch (err) {
+				failures.push(`${runtime.pythonPath} (${err instanceof Error ? err.message : String(err)})`);
+			}
 		}
 		return {
 			ok: false,
-			pythonPath: runtime.pythonPath,
-			reason: `Python interpreter at ${runtime.pythonPath} returned exit code ${probe.exitCode}`,
+			pythonPath: runtimes[0].pythonPath,
+			reason: `No working Python interpreter found. Tried: ${failures.join("; ")}`,
 		};
 	} catch (err) {
 		return { ok: false, reason: err instanceof Error ? err.message : String(err) };
@@ -207,10 +224,15 @@ export class PythonKernel {
 			throw new Error(availability.reason ?? "Python kernel unavailable");
 		}
 
-		const settings = await Settings.init();
-		const { env: shellEnv } = settings.getShellConfig();
-		const baseEnv = filterEnv(shellEnv);
-		const runtime = resolvePythonRuntime(options.cwd, baseEnv);
+		// Reuse the interpreter the availability probe selected so the spawned
+		// kernel matches what we verified actually runs. The fallback computes a
+		// runtime only for the skip-check fast path (test runtime /
+		// PI_PYTHON_SKIP_CHECK), where no candidate was probed.
+		let runtime = availability.runtime;
+		if (!runtime) {
+			const { env: shellEnv } = (await Settings.init()).getShellConfig();
+			runtime = resolvePythonRuntime(options.cwd, filterEnv(shellEnv));
+		}
 		const spawnEnv: Record<string, string> = {};
 		for (const [key, value] of Object.entries(runtime.env)) {
 			if (typeof value === "string") spawnEnv[key] = value;

package/src/eval/py/runtime.ts

@@ -162,49 +162,78 @@ export function resolveVenvPath(cwd: string): string | undefined {
 }
 
 /**
- * Resolve Python runtime including executable path, environment, and venv detection.
+ * Apply a venv-style PATH/VIRTUAL_ENV layout onto a fresh copy of `baseEnv` for
+ * the interpreter living in `binDir`.
  */
-export function resolvePythonRuntime(cwd: string, baseEnv: Record<string, string | undefined>): PythonRuntime {
+function applyVenvEnv(
+	baseEnv: Record<string, string | undefined>,
+	venvPath: string,
+	binDir: string,
+): Record<string, string | undefined> {
 	const env = { ...baseEnv };
-	const venvPath = env.VIRTUAL_ENV ?? resolveVenvPath(cwd);
+	env.VIRTUAL_ENV = venvPath;
+	const pathKey = resolvePathKey(env);
+	const currentPath = env[pathKey];
+	env[pathKey] = currentPath ? `${binDir}${path.delimiter}${currentPath}` : binDir;
+	return env;
+}
+
+function venvBinDir(venvPath: string): string {
+	return process.platform === "win32" ? path.join(venvPath, "Scripts") : path.join(venvPath, "bin");
+}
+
+/**
+ * Enumerate candidate Python runtimes in priority order: an active/project venv,
+ * the managed `~/.omp/python-env`, then the system interpreter on PATH. Every
+ * candidate that physically exists is returned so callers can probe each in turn
+ * rather than committing to the first — a managed env left behind by a removed
+ * `uv` install no longer shadows a working system Python.
+ */
+export function enumeratePythonRuntimes(cwd: string, baseEnv: Record<string, string | undefined>): PythonRuntime[] {
+	const runtimes: PythonRuntime[] = [];
+	const seen = new Set<string>();
+	const push = (runtime: PythonRuntime): void => {
+		if (seen.has(runtime.pythonPath)) return;
+		seen.add(runtime.pythonPath);
+		runtimes.push(runtime);
+	};
 
+	const venvPath = baseEnv.VIRTUAL_ENV ?? resolveVenvPath(cwd);
 	if (venvPath) {
-		env.VIRTUAL_ENV = venvPath;
-		const binDir = process.platform === "win32" ? path.join(venvPath, "Scripts") : path.join(venvPath, "bin");
+		const binDir = venvBinDir(venvPath);
 		const pythonCandidate = path.join(binDir, process.platform === "win32" ? "python.exe" : "python");
 		if (fs.existsSync(pythonCandidate)) {
-			const pathKey = resolvePathKey(env);
-			const currentPath = env[pathKey];
-			env[pathKey] = currentPath ? `${binDir}${path.delimiter}${currentPath}` : binDir;
-			return {
-				pythonPath: pythonCandidate,
-				env,
-				venvPath,
-			};
+			push({ pythonPath: pythonCandidate, env: applyVenvEnv(baseEnv, venvPath, binDir), venvPath });
 		}
 	}
 
 	const managed = resolveManagedPythonCandidate();
 	if (fs.existsSync(managed.pythonPath)) {
-		env.VIRTUAL_ENV = managed.venvPath;
-		const pathKey = resolvePathKey(env);
-		const currentPath = env[pathKey];
-		const managedBin =
-			process.platform === "win32" ? path.join(managed.venvPath, "Scripts") : path.join(managed.venvPath, "bin");
-		env[pathKey] = currentPath ? `${managedBin}${path.delimiter}${currentPath}` : managedBin;
-		return {
+		const managedBin = path.dirname(managed.pythonPath);
+		push({
 			pythonPath: managed.pythonPath,
-			env,
+			env: applyVenvEnv(baseEnv, managed.venvPath, managedBin),
 			venvPath: managed.venvPath,
-		};
+		});
 	}
 
-	const pythonPath = $which("python") ?? $which("python3");
-	if (!pythonPath) {
+	const systemPath = $which("python") ?? $which("python3");
+	if (systemPath) {
+		push({ pythonPath: systemPath, env: { ...baseEnv } });
+	}
+
+	return runtimes;
+}
+
+/**
+ * Resolve the highest-priority Python runtime. Prefer {@link enumeratePythonRuntimes}
+ * when you can probe candidates; this returns only the first one and throws when
+ * no interpreter exists.
+ */
+export function resolvePythonRuntime(cwd: string, baseEnv: Record<string, string | undefined>): PythonRuntime {
+	const [runtime] = enumeratePythonRuntimes(cwd, baseEnv);
+	if (!runtime) {
 		throw new Error("Python executable not found on PATH");
 	}
-	return {
-		pythonPath,
-		env,
-	};
+	return runtime;
 }