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

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,
+	};
+}