pi-repl-py 0.6.1 → 0.6.2

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pi-repl-py",
-	"version": "0.6.1",
+	"version": "0.6.2",
 	"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/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("|");
 }