@oh-my-pi/pi-coding-agent 16.1.13 → 16.1.14

package/src/config/settings-schema.ts

@@ -122,7 +122,7 @@ export const TAB_GROUPS: Record<SettingTab, readonly string[]> = {
 	context: ["General", "Compaction", "Rules (TTSR)", "Experimental"],
 	memory: ["General", "Auto-Learn", "Mnemopi", "Hindsight"],
 	files: ["Editing", "Reading", "Read Summaries", "LSP"],
-	shell: ["Bash", "Eval & Python"],
+	shell: ["Bash", "Eval & Runtimes"],
 	tools: [
 		"Available Tools",
 		"Todos",
@@ -2703,18 +2703,6 @@ export const SETTINGS_SCHEMA = {
 		},
 	},
 
-	readHashLines: {
-		type: "boolean",
-		default: true,
-		ui: {
-			tab: "files",
-			group: "Reading",
-			label: "Hash Lines",
-			description:
-				"Include snapshot-tag headers and line numbers in read output for hashline edit mode ([PATH#TAG] plus LINE:content)",
-		},
-	},
-
 	"read.defaultLimit": {
 		type: "number",
 		default: 300,
@@ -2981,7 +2969,7 @@ export const SETTINGS_SCHEMA = {
 		default: true,
 		ui: {
 			tab: "shell",
-			group: "Eval & Python",
+			group: "Eval & Runtimes",
 			label: "Python Eval Backend",
 			description: "Allow the eval tool to dispatch Python cells to the IPython kernel",
 		},
@@ -2992,20 +2980,42 @@ export const SETTINGS_SCHEMA = {
 		default: true,
 		ui: {
 			tab: "shell",
-			group: "Eval & Python",
+			group: "Eval & Runtimes",
 			label: "JavaScript Eval Backend",
 			description: "Allow the eval tool to dispatch JavaScript cells to the in-process runtime",
 		},
 	},
 
-	// Python kernel knobs (consumed by the eval py backend and the /python slash command)
+	"eval.rb": {
+		type: "boolean",
+		default: false,
+		ui: {
+			tab: "shell",
+			group: "Eval & Runtimes",
+			label: "Ruby Eval Backend",
+			description: "Allow the eval tool to dispatch Ruby cells to the persistent Ruby kernel",
+		},
+	},
+
+	"eval.jl": {
+		type: "boolean",
+		default: false,
+		ui: {
+			tab: "shell",
+			group: "Eval & Runtimes",
+			label: "Julia Eval Backend",
+			description: "Allow the eval tool to dispatch Julia cells to the persistent Julia kernel",
+		},
+	},
+
+	// Runtime knobs (consumed by eval backends and the /python slash command)
 	"python.kernelMode": {
 		type: "enum",
 		values: ["session", "per-call"] as const,
 		default: "session",
 		ui: {
 			tab: "shell",
-			group: "Eval & Python",
+			group: "Eval & Runtimes",
 			label: "Python Kernel Mode",
 			description: "Keep the IPython kernel alive across eval calls or start fresh each time",
 		},
@@ -3015,12 +3025,34 @@ export const SETTINGS_SCHEMA = {
 		default: "",
 		ui: {
 			tab: "shell",
-			group: "Eval & Python",
+			group: "Eval & Runtimes",
 			label: "Python Interpreter",
 			description:
 				"Optional path to an exact Python executable. When set, automatic Python runtime discovery is skipped.",
 		},
 	},
+	"ruby.interpreter": {
+		type: "string",
+		default: "",
+		ui: {
+			tab: "shell",
+			group: "Eval & Runtimes",
+			label: "Ruby Interpreter",
+			description:
+				"Optional path to an exact Ruby executable. When set, automatic Ruby runtime discovery is skipped.",
+		},
+	},
+	"julia.interpreter": {
+		type: "string",
+		default: "",
+		ui: {
+			tab: "shell",
+			group: "Eval & Runtimes",
+			label: "Julia Interpreter",
+			description:
+				"Optional path to an exact Julia executable. When set, automatic Julia runtime discovery is skipped.",
+		},
+	},
 
 	// ────────────────────────────────────────────────────────────────────────
 	// Tools

package/src/config/settings.ts

@@ -949,6 +949,11 @@ export class Settings {
 			delete raw["power.preventDisplaySleep"];
 		}
 
+		// readHashLines: removed. Hashline anchors are now driven solely by
+		// edit.mode === "hashline"; the separate read toggle only ever produced
+		// the incoherent "hashline edits without addressable anchors" state.
+		delete raw.readHashLines;
+
 		return raw;
 	}
 

package/src/dap/client.ts

@@ -1,6 +1,7 @@
 import * as fs from "node:fs/promises";
 import { isEnoent, logger, ptree } from "@oh-my-pi/pi-utils";
 import { NON_INTERACTIVE_ENV } from "../exec/non-interactive-env";
+import { MessageFramer } from "../jsonrpc/message-framing";
 import { ToolAbortError } from "../tools/tool-errors";
 import type {
 	DapCapabilities,
@@ -29,69 +30,6 @@ type DapReverseRequestHandler = (args: unknown) => unknown | Promise<unknown>;
 
 const DEFAULT_REQUEST_TIMEOUT_MS = 30_000;
 
-// Reused for all full decodes; each decode() resets state, so a single
-// instance is safe and avoids per-message TextDecoder allocation.
-const MESSAGE_DECODER = new TextDecoder("utf-8");
-
-/**
- * Locate the `\r\n\r\n` header terminator across the pending chunk list.
- * Returns the absolute byte index of the first `\r`, or -1 when not present.
- * Equivalent to scanning the contiguous concatenation of the chunks.
- */
-function findHeaderEndInChunks(chunks: Buffer[]): number {
-	let global = 0;
-	let b0 = -1;
-	let b1 = -1;
-	let b2 = -1;
-	for (const chunk of chunks) {
-		for (let i = 0; i < chunk.length; i++) {
-			const b3 = chunk[i];
-			if (b0 === 13 && b1 === 10 && b2 === 13 && b3 === 10) {
-				return global - 3;
-			}
-			b0 = b1;
-			b1 = b2;
-			b2 = b3;
-			global++;
-		}
-	}
-	return -1;
-}
-
-/** Copy the byte range [from, to) out of the pending chunk list into one Buffer. */
-function copyChunkRange(chunks: Buffer[], from: number, to: number): Buffer {
-	const out = Buffer.allocUnsafe(to - from);
-	let global = 0;
-	let written = 0;
-	for (const chunk of chunks) {
-		const chunkEnd = global + chunk.length;
-		if (chunkEnd > from && global < to) {
-			const start = Math.max(from, global) - global;
-			const end = Math.min(to, chunkEnd) - global;
-			chunk.copy(out, written, start, end);
-			written += end - start;
-		}
-		global = chunkEnd;
-		if (global >= to) break;
-	}
-	return out;
-}
-
-/** Drop the first `count` bytes from the pending chunk list in place. */
-function dropChunkFront(chunks: Buffer[], count: number): void {
-	let removed = 0;
-	while (chunks.length > 0) {
-		const head = chunks[0];
-		if (removed + head.length <= count) {
-			removed += head.length;
-			chunks.shift();
-		} else {
-			chunks[0] = head.subarray(count - removed);
-			break;
-		}
-	}
-}
-
 async function writeMessage(sink: DapWriteSink, message: DapRequestMessage | DapResponseMessage): Promise<void> {
 	const content = JSON.stringify(message);
 	sink.write(`Content-Length: ${Buffer.byteLength(content, "utf-8")}\r\n\r\n`);
@@ -452,52 +390,25 @@ export class DapClient {
 		this.#isReading = true;
 		const reader = this.#readable.getReader();
 
-		// Incoming bytes are buffered as a list of chunks and only joined when a
-		// full message is framed (mirrors the LSP reader) — concatenating the
-		// accumulator on every read is O(n^2) for messages spanning many reads.
-		const pendingChunks: Buffer[] = [];
-		let pendingLen = 0;
-		if (this.#messageBuffer.length > 0) {
-			pendingChunks.push(this.#messageBuffer);
-			pendingLen = this.#messageBuffer.length;
-		}
+		const framer = new MessageFramer(this.#messageBuffer);
 
 		try {
 			while (true) {
 				const { done, value } = await reader.read();
 				if (done) break;
 
-				pendingChunks.push(Buffer.from(value));
-				pendingLen += value.length;
+				framer.push(Buffer.from(value));
 
 				// Drain every complete message currently buffered.
-				while (true) {
-					const headerEnd = findHeaderEndInChunks(pendingChunks);
-					if (headerEnd === -1) break;
-
-					const headerText = MESSAGE_DECODER.decode(copyChunkRange(pendingChunks, 0, headerEnd));
-					const contentLengthMatch = headerText.match(/Content-Length: (\d+)/i);
-					if (!contentLengthMatch) {
-						// Non-protocol bytes (e.g. an adapter printing to stdout).
-						// Drop past the bogus terminator and resync instead of
-						// stalling on the same junk header forever.
-						logger.warn("DAP framing resync: header block without Content-Length", {
-							adapter: this.adapter.name,
-							header: headerText.slice(0, 200),
-						});
-						dropChunkFront(pendingChunks, headerEnd + 4);
-						pendingLen -= headerEnd + 4;
-						continue;
-					}
-
-					const contentLength = Number.parseInt(contentLengthMatch[1], 10);
-					const messageStart = headerEnd + 4; // Skip \r\n\r\n
-					const messageEnd = messageStart + contentLength;
-					if (pendingLen < messageEnd) break;
-
-					const messageText = MESSAGE_DECODER.decode(copyChunkRange(pendingChunks, messageStart, messageEnd));
-					dropChunkFront(pendingChunks, messageEnd);
-					pendingLen -= messageEnd;
+				for (const messageText of framer.drain(headerText => {
+					// Non-protocol bytes (e.g. an adapter printing to stdout).
+					// Drop past the bogus terminator and resync instead of
+					// stalling on the same junk header forever.
+					logger.warn("DAP framing resync: header block without Content-Length", {
+						adapter: this.adapter.name,
+						header: headerText.slice(0, 200),
+					});
+				})) {
 					this.#lastActivity = Date.now();
 
 					// A malformed message must not kill the reader — later
@@ -523,12 +434,7 @@ export class DapClient {
 			this.#rejectPendingRequests(new Error(`DAP connection closed: ${toErrorMessage(error)}`));
 		} finally {
 			// Persist any unparsed remainder so a restarted reader resumes mid-message.
-			this.#messageBuffer =
-				pendingChunks.length === 0
-					? Buffer.alloc(0)
-					: pendingChunks.length === 1
-						? pendingChunks[0]
-						: Buffer.concat(pendingChunks, pendingLen);
+			this.#messageBuffer = framer.remainder();
 			reader.releaseLock();
 			this.#isReading = false;
 		}

package/src/eval/__tests__/julia-prelude.test.ts

@@ -0,0 +1,77 @@
+import { afterEach, describe, expect, it } from "bun:test";
+import * as path from "node:path";
+import { $which, TempDir } from "@oh-my-pi/pi-utils";
+import { disposeJuliaKernelSessionsByOwner, executeJulia } from "../jl/executor";
+
+const HAS_JULIA = Boolean($which("julia"));
+const OWNER_ID = "julia-prelude-tests";
+
+describe.skipIf(!HAS_JULIA)("eval Julia prelude helpers", () => {
+	afterEach(async () => {
+		await disposeJuliaKernelSessionsByOwner(OWNER_ID);
+	});
+
+	it("supports tree keyword options and unified diff", async () => {
+		using tempDir = TempDir.createSync("@omp-eval-julia-helpers-");
+		await Bun.write(path.join(tempDir.path(), "a.txt"), "same\nold\n");
+		await Bun.write(path.join(tempDir.path(), "b.txt"), "same\nnew\n");
+		await Bun.write(path.join(tempDir.path(), "dir", "child.txt"), "child");
+
+		const result = await executeJulia(
+			`
+d = diff("a.txt", "b.txt")
+println("DIFF_DELETE=", occursin("-old", d))
+println("DIFF_ADD=", occursin("+new", d))
+t = tree(".", max_depth=2)
+println("TREE_CHILD=", occursin("child.txt", t))
+nothing
+`,
+			{
+				cwd: tempDir.path(),
+				sessionId: `julia-prelude-diff:${crypto.randomUUID()}`,
+				kernelOwnerId: OWNER_ID,
+				reset: true,
+			},
+		);
+
+		expect(result.exitCode).toBe(0);
+		expect(result.output).toContain("DIFF_DELETE=true");
+		expect(result.output).toContain("DIFF_ADD=true");
+		expect(result.output).toContain("TREE_CHILD=true");
+	});
+
+	it("supports output ranges, JSON queries, metadata, and ANSI stripping", async () => {
+		using tempDir = TempDir.createSync("@omp-eval-julia-output-");
+		const artifactsDir = path.join(tempDir.path(), "session-artifacts");
+		await Bun.write(path.join(artifactsDir, "alpha.md"), "one\ntwo\nthree\nfour");
+		await Bun.write(path.join(artifactsDir, "json.md"), JSON.stringify({ items: [{ name: "a" }, { name: "b" }] }));
+		await Bun.write(path.join(artifactsDir, "ansi.md"), "\u001b[31mred\u001b[0m");
+
+		const result = await executeJulia(
+			`
+println("RANGE=", replace(output("alpha", offset=2, limit=2), "\\n" => "|"))
+println("QUERY=", output("json", query=".items[1].name"))
+println("STRIPPED=", output("ansi", format="stripped"))
+meta = output("alpha", format="json")
+println("META=", meta["id"], ":", meta["char_count"] > 0)
+multi = output("alpha", "json")
+println("MULTI=", length(multi), ":", multi[1]["id"], ":", multi[2]["id"])
+nothing
+`,
+			{
+				cwd: tempDir.path(),
+				artifactsDir,
+				sessionId: `julia-prelude-output:${crypto.randomUUID()}`,
+				kernelOwnerId: OWNER_ID,
+				reset: true,
+			},
+		);
+
+		expect(result.exitCode).toBe(0);
+		expect(result.output).toContain("RANGE=two|three");
+		expect(result.output).toContain('QUERY="b"');
+		expect(result.output).toContain("STRIPPED=red");
+		expect(result.output).toContain("META=alpha:true");
+		expect(result.output).toContain("MULTI=2:alpha:json");
+	});
+});

package/src/eval/backend-helpers.ts

@@ -0,0 +1,48 @@
+/**
+ * Helpers shared by the per-language eval backend definitions (jl/js/py/rb
+ * index modules): session-id namespacing, settings access, and projection of
+ * executor results into the ExecutorBackend result shape.
+ */
+import type { ToolSession } from "../tools";
+import type { ExecutorBackendResult } from "./backend";
+import type { EvalDisplayOutput } from "./types";
+
+export function namespaceSessionId(sessionId: string, prefix: string): string {
+	return sessionId.startsWith(prefix) ? sessionId : `${prefix}${sessionId}`;
+}
+
+export 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 function readInterpreterSetting(session: ToolSession, key: string): string | undefined {
+	const value = readSetting<unknown>(session, key);
+	return typeof value === "string" ? value.trim() || undefined : undefined;
+}
+
+export function toExecutorBackendResult(result: {
+	output: string;
+	exitCode: number | undefined;
+	cancelled: boolean;
+	truncated: boolean;
+	artifactId?: string | undefined;
+	totalLines: number;
+	totalBytes: number;
+	outputLines: number;
+	outputBytes: number;
+	displayOutputs: EvalDisplayOutput[];
+}): ExecutorBackendResult {
+	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,
+	};
+}