@oh-my-pi/pi-coding-agent 15.0.1 → 15.1.0

package/src/edit/modes/apply-patch.ts

@@ -8,19 +8,20 @@
  * the `patch` mode.
  */
 
-import { type Static, Type } from "@sinclair/typebox";
+import * as z from "zod/v4";
 import { parseApplyPatch, parseApplyPatchStreaming } from "../apply-patch/parser";
 import { ApplyPatchError } from "../diff";
 import type { PatchEditEntry } from "./patch";
 
-export const applyPatchSchema = Type.Object({
-	input: Type.String({
-		description:
+export const applyPatchSchema = z.object({
+	input: z
+		.string()
+		.describe(
 			"Full Codex apply_patch envelope, including '*** Begin Patch' and '*** End Patch'. Contains any mix of Add/Delete/Update (with optional Move to) file operations.",
-	}),
+		),
 });
 
-export type ApplyPatchParams = Static<typeof applyPatchSchema>;
+export type ApplyPatchParams = z.infer<typeof applyPatchSchema>;
 
 export type ApplyPatchEntry = PatchEditEntry & { path: string };
 

package/src/edit/modes/patch.ts

@@ -8,9 +8,8 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import type { AgentToolResult } from "@oh-my-pi/pi-agent-core";
-import { StringEnum } from "@oh-my-pi/pi-ai";
 import { isEnoent } from "@oh-my-pi/pi-utils";
-import { type Static, Type } from "@sinclair/typebox";
+import * as z from "zod/v4";
 import {
 	type FileDiagnosticsResult,
 	flushLspWritethroughBatch,
@@ -1577,29 +1576,23 @@ export async function computePatchDiff(
 	}
 }
 
-export const patchEditEntrySchema = Type.Object(
-	{
-		op: Type.Optional(
-			StringEnum(["create", "delete", "update"], {
-				description: "Operation (default: update)",
-			}),
-		),
-		rename: Type.Optional(Type.String({ description: "New path for move" })),
-		diff: Type.Optional(Type.String({ description: "Diff hunks (update) or full content (create)" })),
-	},
-	{ additionalProperties: false },
-);
-
-export const patchEditSchema = Type.Object(
-	{
-		path: Type.String({ description: "file path for edits" }),
-		edits: Type.Array(patchEditEntrySchema, { description: "Patch operations", minItems: 1 }),
-	},
-	{ additionalProperties: false },
-);
-
-export type PatchEditEntry = Static<typeof patchEditEntrySchema>;
-export type PatchParams = Static<typeof patchEditSchema>;
+export const patchEditEntrySchema = z
+	.object({
+		op: z.enum(["create", "delete", "update"]).optional().describe("Operation (default: update)"),
+		rename: z.string().describe("New path for move").optional(),
+		diff: z.string().describe("Diff hunks (update) or full content (create)").optional(),
+	})
+	.strict();
+
+export const patchEditSchema = z
+	.object({
+		path: z.string().describe("file path for edits"),
+		edits: z.array(patchEditEntrySchema).min(1).describe("Patch operations"),
+	})
+	.strict();
+
+export type PatchEditEntry = z.infer<typeof patchEditEntrySchema>;
+export type PatchParams = z.infer<typeof patchEditSchema>;
 
 export interface ExecutePatchSingleOptions {
 	session: ToolSession;

package/src/edit/modes/replace.ts

@@ -5,7 +5,7 @@
  * fallback strategies for finding text in files.
  */
 import type { AgentToolResult } from "@oh-my-pi/pi-agent-core";
-import { type Static, Type } from "@sinclair/typebox";
+import * as z from "zod/v4";
 import type { WritethroughCallback, WritethroughDeferredHandle } from "../../lsp";
 import type { ToolSession } from "../../tools";
 import { invalidateFsScanAfterWrite } from "../../tools/fs-cache-invalidation";
@@ -976,25 +976,23 @@ export function findContextLine(
 	return { index: undefined, confidence: bestScore };
 }
 
-export const replaceEditEntrySchema = Type.Object(
-	{
-		old_text: Type.String({ description: "Text to find (fuzzy whitespace matching enabled)" }),
-		new_text: Type.String({ description: "Replacement text" }),
-		all: Type.Optional(Type.Boolean({ description: "Replace all occurrences (default: unique match required)" })),
-	},
-	{ additionalProperties: false },
-);
-
-export const replaceEditSchema = Type.Object(
-	{
-		path: Type.String({ description: "file path for edits" }),
-		edits: Type.Array(replaceEditEntrySchema, { description: "Replacements", minItems: 1 }),
-	},
-	{ additionalProperties: false },
-);
-
-export type ReplaceEditEntry = Static<typeof replaceEditEntrySchema>;
-export type ReplaceParams = Static<typeof replaceEditSchema>;
+export const replaceEditEntrySchema = z
+	.object({
+		old_text: z.string().describe("Text to find (fuzzy whitespace matching enabled)"),
+		new_text: z.string().describe("Replacement text"),
+		all: z.boolean().describe("Replace all occurrences (default: unique match required)").optional(),
+	})
+	.strict();
+
+export const replaceEditSchema = z
+	.object({
+		path: z.string().describe("file path for edits"),
+		edits: z.array(replaceEditEntrySchema).min(1).describe("Replacements"),
+	})
+	.strict();
+
+export type ReplaceEditEntry = z.infer<typeof replaceEditEntrySchema>;
+export type ReplaceParams = z.infer<typeof replaceEditSchema>;
 
 export interface ExecuteReplaceSingleOptions {
 	session: ToolSession;

package/src/eval/js/shared/rewrite-imports.ts

@@ -22,9 +22,32 @@ type BabelImportDeclaration = {
 	}>;
 };
 
-type BabelLexicalDecl =
-	| { type: "VariableDeclaration"; kind: "const" | "let" | "var"; start: number; end: number }
-	| { type: "ClassDeclaration"; start: number; end: number; id: { start: number; end: number; name: string } | null };
+type BabelBindingPattern = {
+	type: string;
+	name?: string;
+	properties?: ReadonlyArray<unknown>;
+	elements?: ReadonlyArray<unknown | null>;
+	argument?: unknown;
+	left?: unknown;
+	value?: unknown;
+};
+
+type BabelVariableDeclaration = {
+	type: "VariableDeclaration";
+	kind: "const" | "let" | "var";
+	start: number;
+	end: number;
+	declarations?: ReadonlyArray<{ id: BabelBindingPattern }>;
+};
+
+type BabelClassDeclaration = {
+	type: "ClassDeclaration";
+	start: number;
+	end: number;
+	id: { start: number; end: number; name: string } | null;
+};
+
+type BabelLexicalDecl = BabelVariableDeclaration | BabelClassDeclaration;
 
 type BabelExpressionStatement = {
 	type: "ExpressionStatement";
@@ -167,6 +190,53 @@ export function rewriteImports(code: string): string {
 	return result;
 }
 
+function collectBindingNames(pattern: unknown, names: string[]): void {
+	if (!pattern || typeof pattern !== "object") return;
+	const node = pattern as BabelBindingPattern & { parameter?: unknown };
+	switch (node.type) {
+		case "Identifier":
+			if (typeof node.name === "string") names.push(node.name);
+			return;
+		case "ObjectPattern":
+			for (const property of node.properties ?? []) collectBindingNames(property, names);
+			return;
+		case "ObjectProperty":
+		case "Property":
+			collectBindingNames(node.value, names);
+			return;
+		case "ArrayPattern":
+			for (const element of node.elements ?? []) collectBindingNames(element, names);
+			return;
+		case "AssignmentPattern":
+			collectBindingNames(node.left, names);
+			return;
+		case "RestElement":
+			collectBindingNames(node.argument, names);
+			return;
+		case "TSParameterProperty":
+			collectBindingNames(node.parameter, names);
+			return;
+		default:
+			return;
+	}
+}
+
+function getLexicalBindingNames(node: BabelLexicalDecl): string[] {
+	const names: string[] = [];
+	if (node.type === "VariableDeclaration") {
+		for (const declaration of node.declarations ?? []) collectBindingNames(declaration.id, names);
+	} else if (node.id) {
+		names.push(node.id.name);
+	}
+	return names;
+}
+
+function appendGlobalBindingPublish(source: string, names: readonly string[]): string {
+	if (names.length === 0) return source;
+	const assignments = names.map(name => `this[${JSON.stringify(name)}] = ${name};`).join("\n");
+	return `${source};\n${assignments}`;
+}
+
 /**
  * Demote top-level `const`/`let`/`class` declarations to `var` so they persist on the
  * worker's globalThis across indirect `eval` calls. Indirect eval gives each call its own
@@ -177,10 +247,14 @@ export function rewriteImports(code: string): string {
  *   let { a, b } = obj;      -> var { a, b } = obj;
  *   class Foo extends Bar {} -> var Foo = class extends Bar {};
  *
+ * When the source must run inside the async wrapper, demoted `var`s would normally become
+ * function-scoped. In that mode we publish each top-level binding back to the wrapper's
+ * lexical `this`, which is the worker global object.
+ *
  * Nested declarations (inside functions, blocks, classes) are left alone \u2014 they're
  * scoped to their enclosing function/block regardless of `var` vs `let`/`const`.
  */
-function demoteTopLevelLexicals(code: string): string {
+function demoteTopLevelLexicals(code: string, options: { publishGlobals?: boolean } = {}): string {
 	if (!/\b(?:const|let|class)\b/.test(code)) return code;
 
 	const ast = parseProgram(code);
@@ -191,10 +265,10 @@ function demoteTopLevelLexicals(code: string): string {
 	const targets: BabelLexicalDecl[] = [];
 	for (const node of ast.program.body) {
 		if (node.type === "VariableDeclaration") {
-			const decl = node as unknown as BabelLexicalDecl & { kind: string };
-			if (decl.kind === "const" || decl.kind === "let") targets.push(decl as BabelLexicalDecl);
+			const decl = node as unknown as BabelVariableDeclaration;
+			if (decl.kind === "const" || decl.kind === "let") targets.push(decl);
 		} else if (node.type === "ClassDeclaration") {
-			const decl = node as unknown as Extract<BabelLexicalDecl, { type: "ClassDeclaration" }>;
+			const decl = node as unknown as BabelClassDeclaration;
 			if (decl.id) targets.push(decl);
 		}
 	}
@@ -204,6 +278,7 @@ function demoteTopLevelLexicals(code: string): string {
 	let result = code;
 	for (const node of targets) {
 		const segment = result.slice(node.start, node.end);
+		const bindingNames = options.publishGlobals ? getLexicalBindingNames(node) : [];
 		let replacement: string;
 		if (node.type === "VariableDeclaration") {
 			replacement = `var${segment.slice(node.kind.length)}`;
@@ -215,7 +290,8 @@ function demoteTopLevelLexicals(code: string): string {
 			const hasTrailingSemi = segment.endsWith(";");
 			replacement = `var ${id.name} = class${tail}${hasTrailingSemi ? "" : ";"}`;
 		}
-		result = result.slice(0, node.start) + replacement + result.slice(node.end);
+		result =
+			result.slice(0, node.start) + appendGlobalBindingPublish(replacement, bindingNames) + result.slice(node.end);
 	}
 	return result;
 }
@@ -238,6 +314,50 @@ function returnFinalExpression(code: string): { source: string; returned: boolea
 	return { source: `${prefix}__omp_set_final_expr__((${trimmedStatement}));${suffix}`, returned: true };
 }
 
+function isExecutionBoundary(type: string): boolean {
+	return (
+		type === "FunctionDeclaration" ||
+		type === "FunctionExpression" ||
+		type === "ArrowFunctionExpression" ||
+		type === "ObjectMethod" ||
+		type === "ClassMethod" ||
+		type === "ClassPrivateMethod" ||
+		type === "PrivateMethod"
+	);
+}
+
+function containsAsyncWrapperSyntax(value: unknown): boolean {
+	if (!value || typeof value !== "object") return false;
+	if (Array.isArray(value)) {
+		for (const item of value) {
+			if (containsAsyncWrapperSyntax(item)) return true;
+		}
+		return false;
+	}
+
+	const node = value as Record<string, unknown>;
+	const type = node.type;
+	if (type === "ReturnStatement" || type === "AwaitExpression") return true;
+	if (type === "ForOfStatement" && node.await === true) return true;
+	if (typeof type === "string" && isExecutionBoundary(type)) return false;
+
+	for (const key in node) {
+		if (key === "loc" || key === "extra" || key === "range") continue;
+		if (key === "leadingComments" || key === "trailingComments" || key === "innerComments") continue;
+		if (containsAsyncWrapperSyntax(node[key])) return true;
+	}
+	return false;
+}
+
+function requiresAsyncWrapper(code: string): boolean {
+	const ast = parseProgram(code);
+	if (!ast) return false;
+	for (const node of ast.program.body) {
+		if (containsAsyncWrapperSyntax(node)) return true;
+	}
+	return false;
+}
+
 /**
  * Strip TypeScript syntax (type annotations, `interface`, `as`, `satisfies`, generics in
  * call expressions, etc.) before the import/lexical rewriters parse the code. We use Bun's
@@ -267,11 +387,12 @@ const LOOKS_LIKE_TS =
 export function wrapCode(code: string): { source: string; asyncWrapped: boolean; finalExpressionReturned: boolean } {
 	const stripped = stripTypeScript(code);
 	const finalExpression = returnFinalExpression(stripped);
+	const importsRewritten = rewriteImports(finalExpression.source);
+	const needsAsyncWrapper = requiresAsyncWrapper(importsRewritten);
 	const rewritten = {
-		source: demoteTopLevelLexicals(rewriteImports(finalExpression.source)),
+		source: demoteTopLevelLexicals(importsRewritten, { publishGlobals: needsAsyncWrapper }),
 		returned: finalExpression.returned,
 	};
-	const needsAsyncWrapper = /\bawait\b|\breturn\b/.test(rewritten.source);
 	if (!needsAsyncWrapper) {
 		return { source: rewritten.source, asyncWrapped: false, finalExpressionReturned: rewritten.returned };
 	}