@oh-my-pi/pi-coding-agent 14.5.14 → 14.6.1

package/src/edit/modes/patch.ts

@@ -1717,13 +1717,6 @@ export async function executePatchSingle(
 	const resolvedPath = resolvePlanPath(session, path);
 	const resolvedRename = rename ? resolvePlanPath(session, rename) : undefined;
 
-	if (path.endsWith(".ipynb")) {
-		throw new Error("Cannot edit Jupyter notebooks with the Edit tool. Use the NotebookEdit tool instead.");
-	}
-	if (rename?.endsWith(".ipynb")) {
-		throw new Error("Cannot edit Jupyter notebooks with the Edit tool. Use the NotebookEdit tool instead.");
-	}
-
 	await assertEditableFile(resolvedPath, path);
 
 	const input: PatchInput = { path: resolvedPath, op, rename: resolvedRename, diff };

package/src/edit/modes/replace.ts

@@ -1026,10 +1026,6 @@ export async function executeReplaceSingle(
 
 	enforcePlanModeWrite(session, path);
 
-	if (path.endsWith(".ipynb")) {
-		throw new Error("Cannot edit Jupyter notebooks with the Edit tool. Use the NotebookEdit tool instead.");
-	}
-
 	if (old_text.length === 0) {
 		throw new Error("old_text must not be empty.");
 	}

package/src/edit/renderer.ts

@@ -106,7 +106,7 @@ type EditRenderEntry = {
 	op?: Operation;
 };
 
-interface AtomRenderSummary {
+interface HashlineInputRenderSummary {
 	entries: Array<{ path: string }>;
 }
 
@@ -309,9 +309,9 @@ function getCallPreview(
 }
 
 const MISSING_APPLY_PATCH_END_ERROR = "The last line of the patch must be '*** End Patch'";
-const ATOM_HEADER_PREFIX = "---";
+const HASHLINE_INPUT_HEADER_PREFIX = "@";
 
-function normalizeAtomPreviewPath(rawPath: string): string {
+function normalizeHashlineInputPreviewPath(rawPath: string): string {
 	const trimmed = rawPath.trim();
 	if (trimmed.length < 2) return trimmed;
 	const first = trimmed[0];
@@ -322,30 +322,32 @@ function normalizeAtomPreviewPath(rawPath: string): string {
 	return trimmed;
 }
 
-function parseAtomPreviewHeader(line: string): string | null {
-	if (!line.startsWith(ATOM_HEADER_PREFIX)) return null;
-	let body = line.slice(ATOM_HEADER_PREFIX.length);
-	if (body.startsWith(" ")) body = body.slice(1);
-	const previewPath = normalizeAtomPreviewPath(body);
+function parseHashlineInputPreviewHeader(line: string): string | null {
+	if (!line.startsWith(HASHLINE_INPUT_HEADER_PREFIX)) return null;
+	const body = line.slice(HASHLINE_INPUT_HEADER_PREFIX.length).trim();
+	const previewPath = normalizeHashlineInputPreviewPath(body);
 	return previewPath.length > 0 ? previewPath : null;
 }
 
-function getAtomInputPaths(input: string): string[] {
+function getHashlineInputPaths(input: string): string[] {
 	const stripped = input.startsWith("\uFEFF") ? input.slice(1) : input;
 	const paths: string[] = [];
 	for (const rawLine of stripped.split("\n")) {
 		const line = rawLine.replace(/\r$/, "");
-		const path = parseAtomPreviewHeader(line);
+		const path = parseHashlineInputPreviewHeader(line);
 		if (path) paths.push(path);
 	}
 	return paths;
 }
 
-function getAtomRenderSummary(args: EditRenderArgs, editMode: EditMode | undefined): AtomRenderSummary | undefined {
-	if (editMode !== "atom" || typeof args.input !== "string") {
+function getHashlineInputRenderSummary(
+	args: EditRenderArgs,
+	editMode: EditMode | undefined,
+): HashlineInputRenderSummary | undefined {
+	if (editMode !== "hashline" || typeof args.input !== "string") {
 		return undefined;
 	}
-	return { entries: getAtomInputPaths(args.input).map(path => ({ path })) };
+	return { entries: getHashlineInputPaths(args.input).map(path => ({ path })) };
 }
 
 function getApplyPatchRenderSummary(
@@ -447,10 +449,10 @@ export const editToolRenderer = {
 		}
 
 		const editArgs = args as EditRenderArgs;
-		const atomSummary = getAtomRenderSummary(editArgs, renderContext?.editMode);
+		const hashlineInputSummary = getHashlineInputRenderSummary(editArgs, renderContext?.editMode);
 		const applyPatchSummary = getApplyPatchRenderSummary(editArgs, options.isPartial, renderContext?.editMode);
 		const firstApplyPatchEntry = applyPatchSummary?.entries[0];
-		const firstAtomEntry = atomSummary?.entries[0];
+		const firstHashlineInputEntry = hashlineInputSummary?.entries[0];
 		// Extract path from first edit entry when top-level path is absent (new schema)
 		const firstEdit = Array.isArray(editArgs.edits) && editArgs.edits.length > 0 ? editArgs.edits[0] : undefined;
 		const rawPath =
@@ -458,7 +460,7 @@ export const editToolRenderer = {
 			editArgs.path ||
 			filePathFromEditEntry(firstEdit?.path) ||
 			getPartialJsonEditPath(editArgs) ||
-			firstAtomEntry?.path ||
+			firstHashlineInputEntry?.path ||
 			firstApplyPatchEntry?.path ||
 			"";
 		const rename = editArgs.rename || firstEdit?.rename || firstEdit?.move || firstApplyPatchEntry?.rename;
@@ -468,7 +470,7 @@ export const editToolRenderer = {
 			options?.spinnerFrame !== undefined ? formatStatusIcon("running", uiTheme, options.spinnerFrame) : "";
 		let text = `${formatTitle(getOperationTitle(op), uiTheme)} ${spinner ? `${spinner} ` : ""}${description}`;
 		// Show file count hint for multi-file edits
-		let fileCount = atomSummary?.entries.length ?? applyPatchSummary?.entries.length ?? 0;
+		let fileCount = hashlineInputSummary?.entries.length ?? applyPatchSummary?.entries.length ?? 0;
 		if (Array.isArray(editArgs.edits)) {
 			fileCount = countEditFiles(editArgs.edits);
 		}
@@ -519,14 +521,14 @@ function renderSingleFileResult(
 	const details = result.details;
 	const isError = result.isError ?? (details && "isError" in details ? details.isError : false);
 	const firstEdit = args?.edits?.[0];
-	const atomSummary = getAtomRenderSummary(args ?? {}, options.renderContext?.editMode);
-	const firstAtomEntry = atomSummary?.entries[0];
+	const hashlineInputSummary = getHashlineInputRenderSummary(args ?? {}, options.renderContext?.editMode);
+	const firstHashlineInputEntry = hashlineInputSummary?.entries[0];
 	const rawPath =
 		args?.file_path ||
 		args?.path ||
 		filePathFromEditEntry(firstEdit?.path) ||
 		(details && "path" in details ? details.path : "") ||
-		firstAtomEntry?.path ||
+		firstHashlineInputEntry?.path ||
 		"";
 	const op = args?.op || firstEdit?.op || details?.op;
 	const rename = args?.rename || firstEdit?.rename || firstEdit?.move || details?.move;

package/src/edit/streaming.ts

@@ -16,7 +16,7 @@ import type { Theme } from "../modes/theme/theme";
 import { type EditMode, resolveEditMode } from "../utils/edit-mode";
 import { computeEditDiff, type DiffError, type DiffResult } from "./diff";
 import { type ApplyPatchEntry, expandApplyPatchToEntries, expandApplyPatchToPreviewEntries } from "./modes/apply-patch";
-import { computeHashlineDiff, type HashlineToolEdit } from "./modes/hashline";
+import { computeHashlineDiff } from "./modes/hashline";
 import { computePatchDiff, type PatchEditEntry } from "./modes/patch";
 import type { ReplaceEditEntry } from "./modes/replace";
 
@@ -210,22 +210,22 @@ const patchStrategy: EditStreamingStrategy<PatchArgs> = {
 };
 
 interface HashlineArgs {
+	input?: string;
 	path?: string;
-	edits?: HashlineToolEdit[];
 	__partialJson?: string;
 }
 
 const hashlineStrategy: EditStreamingStrategy<HashlineArgs> = {
-	extractCompleteEdits(args, partialJson) {
-		if (!args?.edits) return args;
-		return { ...args, edits: dropIncompleteLastEdit(args.edits, partialJson, "edits") };
+	extractCompleteEdits(args) {
+		return args;
 	},
 	async computeDiffPreview(args, ctx) {
-		if (!args.path || !args.edits?.length) return null;
+		if (typeof args.input !== "string" || args.input.length === 0) return null;
 		ctx.signal.throwIfAborted();
-		const result = await computeHashlineDiff({ path: args.path, edits: args.edits }, ctx.cwd);
+		const result = await computeHashlineDiff({ input: args.input, path: args.path }, ctx.cwd);
 		ctx.signal.throwIfAborted();
-		return [toPerFilePreview(args.path, result)];
+		if ("error" in result && !args.path) return [{ path: "", error: result.error }];
+		return [toPerFilePreview(args.path ?? "", result)];
 	},
 	renderStreamingFallback() {
 		return "";
@@ -289,32 +289,12 @@ const vimStrategy: EditStreamingStrategy<unknown> = {
 	},
 };
 
-interface AtomArgs {
-	input?: string;
-	__partialJson?: string;
-}
-
-const atomStrategy: EditStreamingStrategy<AtomArgs> = {
-	extractCompleteEdits(args) {
-		return args;
-	},
-	async computeDiffPreview() {
-		// Atom edits can target file headers plus compact diff statements.
-		// We intentionally avoid speculative parsing while args are partial.
-		return null;
-	},
-	renderStreamingFallback() {
-		return "";
-	},
-};
-
 export const EDIT_MODE_STRATEGIES: Record<EditMode, EditStreamingStrategy<unknown>> = {
 	replace: replaceStrategy as EditStreamingStrategy<unknown>,
 	patch: patchStrategy as EditStreamingStrategy<unknown>,
 	hashline: hashlineStrategy as EditStreamingStrategy<unknown>,
 	apply_patch: applyPatchStrategy as EditStreamingStrategy<unknown>,
 	vim: vimStrategy,
-	atom: atomStrategy as EditStreamingStrategy<unknown>,
 };
 
 export { resolveEditMode };

package/src/eval/eval.lark

@@ -1,43 +1,37 @@
 %import common.LF
 %import common.WS_INLINE
 
-// Strict canonical surface for the eval tool. Callers MUST emit exactly this
-// form. The runtime parser accepts additional lenient shapes (positional
-// title/duration, alias keys, long-form lang tokens, mixed casing, fence
-// runs of any length ≥ 3, etc.) but those are fallback only and MUST NOT
-// be relied on.
+// Canonical Eval input. Each cell is introduced by a header line:
 //
-// Each cell is a fenced code block opened and closed by exactly three
-// (or exactly five) backticks or tildes — five lets callers nest a 3-char
-// fence inside a cell verbatim. The opening fence carries an optional info
-// string with up to four parts, IN THIS ORDER:
+//   ===== <info> =====
 //
-//   lang?  id_attr?  t_attr?  rst_attr?
+// where each side is at least 5 equal signs. The info between the bars is
+// a list of space-separated tokens, all optional, in any order:
 //
-// where:
-//   lang    = "py" | "js" | "ts"
-//   id_attr = id="..."        (double-quoted cell id)
-//   t_attr  = t=<duration>    (bare integer with optional ms/s/m unit)
-//   rst_attr= rst=0|1         (per-language kernel reset for this cell)
+//   py | js | ts                  language for this cell
+//   py:"..." | js:"..." | ts:"..." language plus title shorthand
+//   id:"..."                      cell title (when language unchanged)
+//   t:<digits>(ms|s|m)?           per-cell timeout (default 30s)
+//   rst                           reset this language's kernel before running
+//
+// Everything between one header line and the next (or end of input) is
+// the cell's code, verbatim. The runtime additionally accepts content
+// before the first header as an implicit default-language cell, but that
+// is lenient fallback only and MUST NOT be relied on.
 
 start: cell+
+cell:  header LF code_line*
 
-cell: backtick_cell | tilde_cell
-
-backtick_cell: BACKTICKS info? LF code_line* BACKTICKS LF
-tilde_cell:    TILDES   info? LF code_line* TILDES   LF
-
-info: lang (WS_INLINE id_attr)? (WS_INLINE t_attr)? (WS_INLINE rst_attr)?
-    | id_attr (WS_INLINE t_attr)? (WS_INLINE rst_attr)?
-    | t_attr (WS_INLINE rst_attr)?
-    | rst_attr
+header: BAR (WS_INLINE attr)+ WS_INLINE BAR
+      | BAR WS_INLINE? BAR
 
-lang:     "py" | "js" | "ts"
-id_attr:  "id="  /"[^"\r\n]*"/
-t_attr:   "t="   /\d+(ms|s|m)?/
-rst_attr: "rst=" /[01]/
+attr: LANG_TITLE | LANG | ID_ATTR | T_ATTR | RST_FLAG
 
 code_line: /[^\r\n]*/ LF
 
-BACKTICKS: "```"   | "`````"
-TILDES:    "~~~"   | "~~~~~"
+BAR:        /={5,}/
+LANG:       "py" | "js" | "ts"
+LANG_TITLE: ("py" | "js" | "ts") ":\"" /[^"\r\n]*/ "\""
+ID_ATTR:    "id:\"" /[^"\r\n]*/ "\""
+T_ATTR:     "t:" /\d+(ms|s|m)?/
+RST_FLAG:   "rst"

package/src/eval/js/context-manager.ts

@@ -24,12 +24,8 @@ interface VmHelperOptions {
 	path?: string;
 	hidden?: boolean;
 	maxDepth?: number;
-	ignoreCase?: boolean;
-	literal?: boolean;
 	limit?: number;
 	offset?: number;
-	globPattern?: string;
-	flags?: string;
 	reverse?: boolean;
 	unique?: boolean;
 	count?: boolean;
@@ -169,50 +165,6 @@ function clearTrackedTimeout(state: VmContextState, repeat: boolean, timer: Node
 	state.timers.delete(timer);
 }
 
-async function listFiles(
-	state: VmContextState,
-	pattern: string,
-	searchPath: string,
-	options: VmHelperOptions,
-): Promise<string[]> {
-	const resolved = resolvePath(state, searchPath);
-	const hasRecursivePattern = pattern.includes("**");
-	const normalizedPattern = hasRecursivePattern ? pattern : `**/${pattern}`;
-	const matches = await Array.fromAsync(
-		new Bun.Glob(normalizedPattern).scan({
-			cwd: resolved,
-			dot: options.hidden ?? false,
-			absolute: true,
-			onlyFiles: false,
-		}),
-	);
-	const limited = matches.slice(0, options.limit ?? 1000).map(match => path.normalize(match));
-	return limited.sort();
-}
-
-async function grepFile(
-	filePath: string,
-	pattern: string,
-	options: VmHelperOptions,
-): Promise<Array<{ line: number; text: string }>> {
-	const content = await Bun.file(filePath).text();
-	const lines = content.split(/\r?\n/);
-	const matcher = options.literal
-		? (line: string) =>
-				options.ignoreCase ? line.toLowerCase().includes(pattern.toLowerCase()) : line.includes(pattern)
-		: (line: string) => new RegExp(pattern, options.flags ?? (options.ignoreCase ? "i" : "")).test(line);
-	const hits: Array<{ line: number; text: string }> = [];
-	for (let index = 0; index < lines.length; index++) {
-		if (matcher(lines[index])) {
-			hits.push({ line: index + 1, text: lines[index] });
-			if (hits.length >= (options.limit ?? 200)) {
-				break;
-			}
-		}
-	}
-	return hits;
-}
-
 async function createHelpers(state: VmContextState) {
 	return {
 		read: async (rawPath: string, options: VmHelperOptions = {}): Promise<string> => {
@@ -258,103 +210,6 @@ async function createHelpers(state: VmContextState) {
 			});
 			return target;
 		},
-		stat: async (
-			rawPath: string,
-		): Promise<{ path: string; size: number; is_file: boolean; is_dir: boolean; mtime: string }> => {
-			const target = resolvePath(state, rawPath);
-			const info = await Bun.file(target).stat();
-			const result = {
-				path: target,
-				size: info.size,
-				is_file: info.isFile(),
-				is_dir: info.isDirectory(),
-				mtime: new Date(info.mtimeMs).toISOString(),
-			};
-			emitStatus(state, { op: "stat", path: target, size: result.size, is_dir: result.is_dir, mtime: result.mtime });
-			return result;
-		},
-		find: async (pattern: string, searchPath = ".", options: VmHelperOptions = {}): Promise<string[]> => {
-			const matches = await listFiles(state, pattern, searchPath, options);
-			emitStatus(state, {
-				op: "find",
-				pattern,
-				path: resolvePath(state, searchPath),
-				count: matches.length,
-				matches: matches.slice(0, 20),
-			});
-			return matches;
-		},
-		glob: async (pattern: string, searchPath = ".", options: VmHelperOptions = {}): Promise<string[]> => {
-			const resolved = resolvePath(state, searchPath);
-			const matches = await Array.fromAsync(
-				new Bun.Glob(pattern).scan({
-					cwd: resolved,
-					dot: options.hidden ?? false,
-					absolute: true,
-					onlyFiles: false,
-				}),
-			);
-			const limited = matches
-				.slice(0, options.limit ?? 1000)
-				.map(match => path.normalize(match))
-				.sort();
-			emitStatus(state, {
-				op: "glob",
-				pattern,
-				path: resolved,
-				count: limited.length,
-				matches: limited.slice(0, 20),
-			});
-			return limited;
-		},
-		grep: async (
-			pattern: string,
-			rawPath: string,
-			options: VmHelperOptions = {},
-		): Promise<Array<{ line: number; text: string }>> => {
-			const filePath = resolvePath(state, rawPath);
-			const hits = await grepFile(filePath, pattern, options);
-			emitStatus(state, { op: "grep", pattern, path: filePath, count: hits.length, hits: hits.slice(0, 10) });
-			return hits;
-		},
-		rgrep: async (
-			pattern: string,
-			searchPath = ".",
-			options: VmHelperOptions = {},
-		): Promise<Array<{ file: string; line: number; text: string }>> => {
-			const files = await listFiles(state, options.globPattern ?? "*", searchPath, {
-				...options,
-				limit: options.limit ?? 100,
-			});
-			const hits: Array<{ file: string; line: number; text: string }> = [];
-			for (const file of files) {
-				const fileStat = await Bun.file(file)
-					.stat()
-					.catch(() => undefined);
-				if (!fileStat || fileStat.isDirectory()) continue;
-				for (const hit of await grepFile(file, pattern, options)) {
-					hits.push({ file, line: hit.line, text: hit.text });
-					if (hits.length >= (options.limit ?? 100)) {
-						emitStatus(state, {
-							op: "rgrep",
-							pattern,
-							path: resolvePath(state, searchPath),
-							count: hits.length,
-							hits: hits.slice(0, 10),
-						});
-						return hits;
-					}
-				}
-			}
-			emitStatus(state, {
-				op: "rgrep",
-				pattern,
-				path: resolvePath(state, searchPath),
-				count: hits.length,
-				hits: hits.slice(0, 10),
-			});
-			return hits;
-		},
 		sortText: (text: string, options: VmHelperOptions = {}): string => {
 			const lines = String(text).split(/\r?\n/);
 			const deduped = options.unique ? Array.from(new Set(lines)) : lines;
@@ -403,22 +258,6 @@ async function createHelpers(state: VmContextState) {
 			emitStatus(state, { op: "counter", unique: counts.size, total: values.length, top: limited.slice(0, 10) });
 			return limited;
 		},
-		sed: async (
-			rawPath: string,
-			pattern: string,
-			replacement: string,
-			options: VmHelperOptions = {},
-		): Promise<number> => {
-			const filePath = resolvePath(state, rawPath);
-			const content = await Bun.file(filePath).text();
-			const regex = new RegExp(pattern, options.flags ?? "g");
-			const matches = content.match(regex);
-			const updated = content.replace(regex, replacement);
-			await Bun.write(filePath, updated);
-			const count = matches?.length ?? 0;
-			emitStatus(state, { op: "sed", path: filePath, count });
-			return count;
-		},
 		diff: async (rawA: string, rawB: string): Promise<string> => {
 			const fileA = resolvePath(state, rawA);
 			const fileB = resolvePath(state, rawB);
@@ -590,7 +429,10 @@ async function createVmState(
 	const context = vm.createContext(contextGlobals);
 	context.globalThis = context;
 	state.context = context;
-	vm.runInContext(JAVASCRIPT_PRELUDE_SOURCE, context, { filename: "js-prelude.js" });
+	vm.runInContext(JAVASCRIPT_PRELUDE_SOURCE, context, {
+		filename: "js-prelude.js",
+		importModuleDynamically: vm.constants.USE_MAIN_CONTEXT_DEFAULT_LOADER,
+	});
 	return state;
 }
 
@@ -691,6 +533,7 @@ export async function executeInVmContext(options: {
 			const value = vm.runInContext(wrapped.source, state.context, {
 				filename: options.filename,
 				timeout: options.timeoutMs,
+				importModuleDynamically: vm.constants.USE_MAIN_CONTEXT_DEFAULT_LOADER,
 			});
 			const awaited = await awaitMaybePromise(value, options.runState.signal);
 			displayValue(state, awaited);

package/src/eval/js/prelude.txt

@@ -7,15 +7,9 @@ if (!globalThis.__omp_js_prelude_loaded__) {
 	const read = (path, opts = {}) => callHelper("read", path, toOptions(opts));
 	const write = async (path, data) => callHelper("writeFile", path, data);
 	const append = (path, content) => callHelper("append", path, content);
-	const stat = path => callHelper("stat", path);
-	const grep = (pattern, path, opts = {}) => callHelper("grep", pattern, path, toOptions(opts));
-	const rgrep = (pattern, path = ".", opts = {}) => callHelper("rgrep", pattern, path, toOptions(opts));
-	const find = (pattern, path = ".", opts = {}) => callHelper("find", pattern, path, toOptions(opts));
-	const glob = (pattern, path = ".", opts = {}) => callHelper("glob", pattern, path, toOptions(opts));
 	const sort = (text, opts = {}) => callHelper("sortText", text, toOptions(opts));
 	const uniq = (text, opts = {}) => callHelper("uniqText", text, toOptions(opts));
 	const counter = (items, opts = {}) => callHelper("counter", items, toOptions(opts));
-	const sed = (path, pattern, repl, opts = {}) => callHelper("sed", path, pattern, repl, toOptions(opts));
 	const diff = (a, b) => callHelper("diff", a, b);
 	const tree = (path = ".", opts = {}) => callHelper("tree", path, toOptions(opts));
 	const run = (cmd, opts = {}) => callHelper("run", cmd, toOptions(opts));
@@ -68,15 +62,9 @@ if (!globalThis.__omp_js_prelude_loaded__) {
 	globalThis.read = read;
 	globalThis.write = write;
 	globalThis.append = append;
-	globalThis.stat = stat;
-	globalThis.grep = grep;
-	globalThis.rgrep = rgrep;
-	globalThis.find = find;
-	globalThis.glob = glob;
 	globalThis.sort = sort;
 	globalThis.uniq = uniq;
 	globalThis.counter = counter;
-	globalThis.sed = sed;
 	globalThis.diff = diff;
 	globalThis.tree = tree;
 	globalThis.run = run;