pi-repl-py 0.6.1 → 0.6.3

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pi-repl-py",
-	"version": "0.6.1",
+	"version": "0.6.3",
 	"type": "module",
 	"description": "A pi extension with a single tool: execute, running a TypeScript host with a persistent Python (ipykernel) evaluator and a user-configurable toolbox of functions.",
 	"keywords": [

package/src/engine/index.ts

@@ -162,6 +162,15 @@ export class EngineManager {
 				env: this.options.env,
 				timeoutMs,
 			});
+			// --- an unexpected kernel death must not survive the next execute: drop the dying
+			// --- instance and clear the boot cache so start() rebuilds it on the next cell. ---
+			const current = this.kernel;
+			current.setOnUnexpectedExit(() => {
+				if (this.kernel !== current) return;
+				this.kernel = undefined;
+				this.startPromise = undefined;
+				this.lastNamespaceNames = undefined;
+			});
 		} catch (error) {
 			if (this.state === "starting") this.state = "idle";
 			liveEngines.delete(this);
@@ -215,6 +224,13 @@ export class EngineManager {
 				throw new Error("Engine has been shut down");
 			}
 			await this.start();
+			// --- the kernel may have died after the boot promise resolved but before the async
+			// --- exit event surfaced it; drop the zombie and rebuild so the next cell runs. ---
+			if (this.kernel && !this.kernel.isRunning) {
+				this.kernel = undefined;
+				this.startPromise = undefined;
+				await this.start();
+			}
 			if (this.isShutdown()) {
 				throw new Error("Engine has been shut down");
 			}

package/src/engine/kernel.ts

@@ -19,6 +19,7 @@ import {
 import { ZmtpSocket } from "./zmtp.js";
 
 const KERNEL_READY_TIMEOUT_MS = 30_000;
+const SILENCE_KILL_GRACE_MS = 2000;
 const DEFAULT_MAX_OUTPUT_CHARS = 1_000_000;
 
 export interface KernelOptions {
@@ -169,8 +170,13 @@ export class KernelClient {
 	private ready = false;
 	/** Serializes all kernel ops: one execute at a time, snapshots between cells. */
 	private queue: Promise<unknown> = Promise.resolve();
-	private onUnexpectedExit?: () => void;
+	private _onUnexpectedExit?: () => void;
+	/** Engine hook: an unexpected kernel death (not a deliberate kill) should drop the instance. */
+	setOnUnexpectedExit(fn: () => void): void {
+		this._onUnexpectedExit = fn;
+	}
 	private watchdog?: ReturnType<typeof setInterval>;
+	private silenceKillTimer?: ReturnType<typeof setTimeout>;
 	private pendingReplies = new Map<
 		string,
 		{ resolve(m: ParsedMessage): void; timer?: ReturnType<typeof setTimeout> }
@@ -223,9 +229,18 @@ export class KernelClient {
 		kc.child = child;
 		kc.connectionFilePath = connPath;
 		child.on("exit", () => {
-			// --- a dead kernel settles the running cell; the engine rebuilds ---
+			// --- a dead kernel settles the running cell; the engine rebuilds. clear child/ready
+			// --- so isRunning reflects death and the engine never resumes a zombie process. ---
 			kc.settleActive(new Error("kernel process exited"));
-			kc.onUnexpectedExit?.();
+			kc.child = undefined;
+			kc.ready = false;
+			kc.shell?.close();
+			kc.control?.close();
+			kc.iopub?.close();
+			kc.shell = undefined;
+			kc.control = undefined;
+			kc.iopub = undefined;
+			kc._onUnexpectedExit?.();
 		});
 
 		try {
@@ -494,6 +509,12 @@ export class KernelClient {
 				if (quiet >= this.timeoutMs && !active.settled) {
 					active.timedOut = true;
 					this.interrupt();
+					// --- the interrupt is a real KeyboardInterrupt, but a cell that swallows/ignores
+					// --- it never replies; escalate to a kill so the queue is freed, mirroring index.ts. ---
+					this.silenceKillTimer ??= setTimeout(() => {
+						if (!active.settled) this.kill();
+					}, SILENCE_KILL_GRACE_MS);
+					this.silenceKillTimer.unref?.();
 				}
 			},
 			Math.min(250, this.timeoutMs),
@@ -506,6 +527,10 @@ export class KernelClient {
 			clearInterval(this.watchdog);
 			this.watchdog = undefined;
 		}
+		if (this.silenceKillTimer) {
+			clearTimeout(this.silenceKillTimer);
+			this.silenceKillTimer = undefined;
+		}
 	}
 
 	/** Genuine KeyboardInterrupt via control-channel interrupt_request; the kernel survives. */

package/src/extension/prompt.ts

@@ -32,7 +32,7 @@ export function buildPromptGuidelines(preloaded: string[]): string[] {
 		"Surgical old-text/new-text: read the region, fix an exact unique anchor that appears once, replace, verify. Many small edits over one big rewrite, a parse error can strand an anchor; after an error, read the file back from disk first. Make the smallest valid change, preserve conventions, never invent files, APIs, conventions, or test results. Prune generated dirs when walking trees. Pass a `timeout` to any `subprocess.run(...)`, a silent cell must die, not hang.",
 		"",
 		"## Print is expensive",
-		"Print small, exact slices, bounded to what the decision actually needs. Keep the whole in a variable and print only on demand. Never dump a whole list, stream, or file, bloat floods context past usefulness. Prefer quality over quantity.",
+		"Every token you print is spent from the context you need for the turns to come, and it never comes back. Treat printing as debt, not reward. Print only the exact fragment the next decision consumes and hold the whole in a variable. Every other print is waste, it buys nothing and closes the room you have left to think. Ask before you print: does this decide the next step, or is it just noise? When it is noise, cut it. When in doubt, cut it. A tight transcript is the sign you actually worked; a bloated one is the sign you did not.",
 		"",
 		...(preloaded.length
 			? [

package/src/extension/render-core.ts

@@ -39,7 +39,7 @@ export interface RenderDeps {
 }
 
 const OUTPUT_INDENT = "  ";
-const SPINNER_FRAMES = ["◐", "◓", "◑", "◒"];
+const SPINNER_FRAMES = [">..", ".>.", "..>", ".>."];
 
 export function formatDuration(durationMs: number | undefined): string | undefined {
 	if (durationMs === undefined) return undefined;
@@ -105,13 +105,68 @@ function marker(state: ExecuteRenderState, deps: RenderDeps): string {
 			return deps.fg("success", "✓");
 		case "running": {
 			const now = deps.now?.() ?? Date.now();
-			return deps.fg("accent", SPINNER_FRAMES[Math.floor(now / 160) % SPINNER_FRAMES.length]);
+			return deps.fg("accent", SPINNER_FRAMES[Math.floor(now / 120) % SPINNER_FRAMES.length]);
 		}
 		default:
 			return deps.fg("muted", "◇");
 	}
 }
 
+/**
+ * highlight.js python emits no scope for plain identifiers, so they arrive as raw (uncolored)
+ * text mixed with SGR-colored tokens and bare punctuation. Re-color only whole identifier runs
+ * that sit outside any colored span, leaving keywords, strings, numbers, and other already
+ * colored tokens untouched.
+ */
+function colorBareIdentifiers(line: string, paint: (id: string) => string): string {
+	if (!line.includes("\x1b") && !/[a-zA-Z_]/.test(line)) return line;
+	const out: string[] = [];
+	let pending = "";
+	let colored = false;
+	const pushRaw = (s: string) => {
+		let last = 0;
+		for (const m of s.matchAll(/[a-zA-Z_][a-zA-Z0-9_]*/g)) {
+			const index = m.index ?? 0;
+			out.push(s.slice(last, index), paint(m[0]));
+			last = index + m[0].length;
+		}
+		out.push(s.slice(last));
+	};
+	let i = 0;
+	const isFgColor = (seq: string) => /\x1b\[(?:38|9?[0-7])/.test(seq);
+	while (i < line.length) {
+		if (line[i] === "\x1b") {
+			const end = line.indexOf("m", i) + 1;
+			const seq = line.slice(i, end);
+			if (isFgColor(seq)) {
+				if (pending) {
+					pushRaw(pending);
+					pending = "";
+				}
+				out.push(seq);
+				colored = true;
+			} else if (seq.includes("39") || seq.includes("0m")) {
+				if (colored) {
+					out.push(seq);
+					colored = false;
+				} else {
+					pending += seq;
+				}
+			} else {
+				pending += seq;
+			}
+			i = end;
+			continue;
+		}
+		// only raw (uncolored) text may be repainted; colored tokens pass through untouched
+		if (colored) out.push(line[i]);
+		else pending += line[i];
+		i++;
+	}
+	if (pending) pushRaw(pending);
+	return out.join("");
+}
+
 function highlightLines(code: string, deps: RenderDeps): string[] {
 	if (!code) return [];
 	return deps.highlight(code);
@@ -211,14 +266,15 @@ function addWrapped(
 	text: string,
 	width: number,
 	deps: RenderDeps,
-	options: { sanitize?: boolean } = {},
+	options: { sanitize?: boolean; indentAfter?: number } = {},
 ): void {
 	const safe = options.sanitize === false ? text : sanitizeTuiOutput(text);
 	const available = Math.max(1, width - 1 - deps.visibleWidth(prefix));
 	const wrapped = deps.wrapTextWithAnsi(safe, available);
 	for (const [index, line] of (wrapped.length > 0 ? wrapped : [""]).entries()) {
 		const linePrefix = index === 0 ? prefix : " ".repeat(deps.visibleWidth(prefix));
-		lines.push(deps.truncateToWidth(` ${linePrefix}${closeOpenSgr(line)}`, width, ""));
+		const continuationIndent = index > 0 && options.indentAfter ? " ".repeat(options.indentAfter) : "";
+		lines.push(deps.truncateToWidth(` ${linePrefix}${continuationIndent}${closeOpenSgr(line)}`, width, ""));
 	}
 }
 
@@ -229,8 +285,13 @@ function renderCode(state: ExecuteRenderState, lines: string[], width: number, d
 	const highlighted = highlightLines(code, deps);
 	for (const [index, rawLine] of code.split("\n").entries()) {
 		const prefix = index === 0 ? deps.fg("dim", "› ") : deps.fg("dim", "  ");
-		// --- code is already highlighted; don't strip its ANSI ---
-		addWrapped(lines, prefix, highlighted[index] ?? rawLine, width, deps, { sanitize: false });
+		const paint = (id: string) => deps.fg("syntaxVariable", id);
+		const hlLine = colorBareIdentifiers(highlighted[index] ?? rawLine, paint);
+		const indent = /^[ \t]*/.exec(rawLine)?.[0] ?? "";
+		addWrapped(lines, prefix, hlLine, width, deps, {
+			sanitize: false,
+			indentAfter: deps.visibleWidth(indent),
+		});
 	}
 	return true;
 }

package/src/extension/render.ts

@@ -43,7 +43,7 @@ function renderVersion(state: ExecuteRenderState): string {
 		state.executionStarted,
 		state.hasResult,
 		// --- fold the animation frame in while running so the spinner still turns ---
-		statusKind(state) === "running" ? Math.floor(Date.now() / 160) % 4 : -1,
+		statusKind(state) === "running" ? Math.floor(Date.now() / 120) % 4 : -1,
 	].join("|");
 }