@opencode/codemode 0.0.0-dev-19959 → 0.0.0-dev-19962

package/dist/interpreter/interpreter.js

@@ -6,7 +6,7 @@ import { checkStringLength } from "./limits.js";
 import { locate, materialize } from "./errors.js";
 import { primitivePrototype } from "./intrinsics.js";
 import { globals } from "./globals.js";
-import { assign, Callable, define, get, hostCursor, IteratorObj, has, hasPrototype, keys, Native, parseArrayIndex, Arr, Fn, GeneratorObj, Obj, PromiseObj, record, remove, set, coerceToNumber, coerceToString, } from "./objects.js";
+import { assign, Callable, define, get, hostCursor, IteratorObj, has, hidden, hasPrototype, keys, Native, parseArrayIndex, Arr, Fn, GeneratorObj, Obj, PromiseObj, record, remove, set, coerceToNumber, coerceToString, } from "./objects.js";
 import { preserveConsumerError } from "./callback.js";
 import { Pending, resolvePromise, resolvePromiseValue } from "./promises.js";
 import { containsOpaqueReference, describeValue, rejectCircularInsertion, typeofValue } from "./references.js";
@@ -318,7 +318,16 @@ class Frame {
         }).pipe(Effect.ensuring(Effect.sync(() => self.scopes.pop())));
     }
     createFunction(node, name = node.type === "ArrowFunctionExpression" ? "" : (node.id?.name ?? "")) {
-        return new Fn(this.ctx.builtins.Function, name, node.params, node.body, this.scopes.capture(), node.async, node.generator);
+        const builtins = this.ctx.builtins;
+        const fn = new Fn(builtins.Function, name, node.params, node.body, this.scopes.capture(), node.async, node.generator);
+        // Each generator function gets its own prototype, so `g() instanceof g` holds as in JS.
+        if (node.generator)
+            define(fn, "prototype", new Obj(node.async ? builtins.AsyncGenerator : builtins.Generator), hidden);
+        // The body of a named function expression sees its own name, read-only.
+        if (node.type === "FunctionExpression" && node.id) {
+            fn.capturedScopes.push(new Map([[node.id.name, { mutable: false, value: fn, initialized: true }]]));
+        }
+        return fn;
     }
     // NamedEvaluation: an anonymous function definition takes the name of what it is assigned to.
     evaluateNamed(node, name) {
@@ -327,11 +336,12 @@ class Frame {
         }
         return this.evaluateExpression(node);
     }
+    // Repeated `function` declarations and `var` clashes are legal: the last declaration wins.
     hoistFunctions(statements) {
         for (const node of statements) {
             if (node.type !== "FunctionDeclaration")
                 continue;
-            this.scopes.declare(node.id.name, this.createFunction(node), true, node);
+            this.scopes.current().set(node.id.name, { mutable: true, value: this.createFunction(node), initialized: true });
         }
     }
     // Hoisted `var` bindings start undefined, or copy a same-named parameter. Function bodies hoist
@@ -1373,13 +1383,14 @@ class Frame {
                 return yield* invocation.evaluateExpression(fn.body);
             });
             if (fn.generator)
-                return Effect.succeed(this.createGenerator(invocation, run, fn.async));
+                return Effect.succeed(this.createGenerator(invocation, run, fn));
             if (!fn.async)
                 return run;
             return this.ctx.pending.createWithSelf((self) => Effect.flatMap(run, (value) => resolvePromiseValue(invocation.ctx, value, self)));
         });
     }
-    createGenerator(invocation, run, asynchronous) {
+    createGenerator(invocation, run, fn) {
+        const asynchronous = fn.async;
         const state = { started: false, completed: false, draining: false, pending: [], pendingIndex: 0 };
         invocation.generatorState = state;
         invocation.generatorAsync = asynchronous;
@@ -1438,8 +1449,8 @@ class Frame {
             }
             return Deferred.await(request.response);
         };
-        const generator = new GeneratorObj(asynchronous ? builtins.AsyncGenerator : builtins.Generator, asynchronous, request);
-        return generator;
+        const proto = get(fn, "prototype");
+        return new GeneratorObj(proto instanceof Obj ? proto : builtins.Generator, asynchronous, request);
     }
     completeGeneratorRequests(state, asynchronous) {
         const self = this;
@@ -1751,9 +1762,11 @@ class Frame {
     }
     evaluateDeleteExpression(argument) {
         const target = argument.type === "ChainExpression" ? argument.expression : argument;
-        if (target.type !== "MemberExpression") {
+        if (target.type === "Identifier")
             throw typeError("Only data fields may be deleted.", argument);
-        }
+        // `delete <non-reference>` evaluates the operand and is true, as in JS.
+        if (target.type !== "MemberExpression")
+            return Effect.map(this.evaluateExpression(target), () => true);
         return Effect.map(this.getMemberReference(target), (reference) => {
             if (reference === OptionalShortCircuit)
                 return true;

package/dist/interpreter/objects.d.ts

@@ -87,10 +87,10 @@ export declare abstract class Callable extends Opaque {
 export declare class Fn extends Callable {
     readonly parameters: ReadonlyArray<Pattern>;
     readonly body: BlockStatement | Expression;
-    readonly capturedScopes: ReadonlyArray<Map<string, Binding>>;
+    readonly capturedScopes: Array<Map<string, Binding>>;
     readonly async: boolean;
     readonly generator: boolean;
-    constructor(proto: Obj, name: string, parameters: ReadonlyArray<Pattern>, body: BlockStatement | Expression, capturedScopes: ReadonlyArray<Map<string, Binding>>, async: boolean, generator: boolean);
+    constructor(proto: Obj, name: string, parameters: ReadonlyArray<Pattern>, body: BlockStatement | Expression, capturedScopes: Array<Map<string, Binding>>, async: boolean, generator: boolean);
 }
 export type NativeCall<R> = (thisValue: Value, args: Array<Value>) => Effect.Effect<Value, unknown, R>;
 export type NativeConstruct<R> = (args: Array<Value>, newTarget: Callable) => Effect.Effect<Value, unknown, R>;

package/dist/stdlib/collections.js

@@ -166,7 +166,7 @@ export const mapGlobal = (ctx) => {
                 const target = self(thisValue, "forEach");
                 const apply = applyCollectionCallback(ctx, args[0], "Map.forEach");
                 return Effect.gen(function* () {
-                    for (const [key, item] of Array.from(target.map.entries()))
+                    for (const [key, item] of target.map.entries())
                         yield* apply([item, key, target]);
                     return undefined;
                 });
@@ -356,7 +356,7 @@ export const setGlobal = (ctx) => {
                 const target = self(thisValue, "forEach");
                 const apply = applyCollectionCallback(ctx, args[0], "Set.forEach");
                 return Effect.gen(function* () {
-                    for (const item of Array.from(target.set.values()))
+                    for (const item of target.set.values())
                         yield* apply([item, item, target]);
                     return undefined;
                 });

package/dist/tool-runtime.js

@@ -109,6 +109,24 @@ const termForms = (term) => {
         forms.push(term.slice(0, -1));
     return forms;
 };
+const rank = (entries, query) => {
+    const terms = tokenize(query).map(termForms);
+    return entries
+        .map((entry) => {
+        const path = entry.description.path.toLowerCase();
+        const description = entry.description.description.toLowerCase();
+        const score = terms.reduce((total, forms) => total +
+            (forms.some((form) => path === form || path.endsWith(`.${form}`)) ? 20 : 0) +
+            (forms.some((form) => entry.pathWords.includes(form)) ? 12 : 0) +
+            (forms.some((form) => path.includes(form)) ? 8 : 0) +
+            (forms.some((form) => description.includes(form)) ? 4 : 0) +
+            (forms.some((form) => entry.searchText.includes(form)) ? 2 : 0), 0);
+        return { entry, score };
+    })
+        .filter(({ score }) => terms.length === 0 || score > 0)
+        .sort((left, right) => right.score - left.score || compareText(left.entry.description.path, right.entry.description.path))
+        .map(({ entry }) => entry);
+};
 const makeSearchTool = (searchIndex) => ({
     _tag: "CodeModeTool",
     description: "Search available tools",
@@ -133,24 +151,7 @@ const makeSearchTool = (searchIndex) => ({
         const exact = pathQuery === ""
             ? undefined
             : scoped.find((entry) => entry.description.path === pathQuery || toolExpression(entry.description.path) === trimmed);
-        const terms = tokenize(query).map(termForms);
-        const ranked = exact !== undefined
-            ? [exact]
-            : scoped
-                .map((entry) => {
-                const path = entry.description.path.toLowerCase();
-                const description = entry.description.description.toLowerCase();
-                const score = terms.reduce((total, forms) => total +
-                    (forms.some((form) => path === form || path.endsWith(`.${form}`)) ? 20 : 0) +
-                    (forms.some((form) => entry.pathWords.includes(form)) ? 12 : 0) +
-                    (forms.some((form) => path.includes(form)) ? 8 : 0) +
-                    (forms.some((form) => description.includes(form)) ? 4 : 0) +
-                    (forms.some((form) => entry.searchText.includes(form)) ? 2 : 0), 0);
-                return { entry, score };
-            })
-                .filter(({ score }) => terms.length === 0 || score > 0)
-                .sort((left, right) => right.score - left.score || compareText(left.entry.description.path, right.entry.description.path))
-                .map(({ entry }) => entry);
+        const ranked = exact !== undefined ? [exact] : rank(scoped, query);
         const items = ranked.slice(offset, offset + (request.limit ?? defaultSearchLimit)).map(({ description }) => ({
             ...description,
             path: toolExpression(description.path),
@@ -207,13 +208,16 @@ const namespaceKeys = (root, path) => {
     }
     return Array.from(node.children.keys());
 };
-const resolve = (root, path) => {
+const resolve = (root, path, index) => {
     const segments = canonicalSegments(path);
     const node = lookup(root, segments);
     if (node === undefined) {
-        throw new ToolRuntimeError("UnknownTool", `Unknown tool '${segments.join(".")}'.`, [
-            "The tool may have been removed or renamed. Use search to find available tools.",
-        ]);
+        const name = segments.join(".");
+        const ns = segments.length > 1 && root.children.has(segments[0]) ? segments[0] : undefined;
+        const closest = rank(ns ? index.filter((entry) => entry.description.path.startsWith(`${ns}.`)) : index, ns ? segments.slice(1).join(" ") : name)[0];
+        throw new ToolRuntimeError("UnknownTool", closest
+            ? `Unknown tool '${name}'. Did you mean ${toolExpression(closest.description.path)}?`
+            : `Unknown tool '${name}'.`, ["Use search to find available tools."]);
     }
     if (node.tool === undefined) {
         throw new ToolRuntimeError("UnknownTool", `Tool '${segments.join(".")}' is not callable.`);
@@ -277,7 +281,7 @@ export const make = (prepared, maxToolCalls, hooks = {}) => {
             // Models often write `tools.search(...)` for the bare `search(...)`; honor it unless a tool owns that path.
             if (segments.length === 1 && segments[0] === "search" && lookup(root, segments) === undefined)
                 return executeTool("search", makeSearchTool(prepared.searchIndex), args);
-            return executeTool(segments.join("."), resolve(root, path), args);
+            return executeTool(segments.join("."), resolve(root, path, prepared.searchIndex), args);
         }),
     };
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@opencode/codemode",
-  "version": "0.0.0-dev-19959",
+  "version": "0.0.0-dev-19962",
   "description": "Effect-native confined code execution over schema-described tools",
   "type": "module",
   "license": "MIT",