@opencode/codemode 0.0.0-reserved → 2.0.1

package/dist/interpreter/errors.js

@@ -0,0 +1,112 @@
+import { Effect } from "effect";
+import { ToolError } from "../tool-error.js";
+import { toData, ToolRuntimeError } from "../data.js";
+import { formatLocation, InterpreterRuntimeError, ProgramThrow, sourceLocation } from "./model.js";
+import { containsRuntimeReference } from "./references.js";
+import { HostFunction } from "./host.js";
+import { createErrorValue, isErrorType } from "./intrinsics.js";
+import { get, hasPrototype, ProgramArray, ProgramError, ProgramObject, set } from "./objects.js";
+import {} from "./runner.js";
+import { coerceToString } from "../stdlib/value.js";
+export const normalizeError = (error) => {
+    if (error instanceof InterpreterRuntimeError) {
+        return {
+            kind: error.kind,
+            message: `${error.message}${formatLocation(error.node)}`,
+            ...(error.node?.loc ? { location: sourceLocation(error.node) } : {}),
+            ...(error.suggestions ? { suggestions: error.suggestions } : {}),
+        };
+    }
+    if (error instanceof ToolRuntimeError) {
+        return {
+            kind: error.kind,
+            message: error.message,
+            ...(error.suggestions.length > 0 ? { suggestions: error.suggestions } : {}),
+        };
+    }
+    if (error instanceof ToolError) {
+        return { kind: "ToolFailure", message: error.message };
+    }
+    if (error instanceof ProgramThrow) {
+        const value = error.value;
+        let message;
+        if (containsRuntimeReference(value)) {
+            // Never expose runtime reference internals through thrown values.
+            message = "a non-data value";
+        }
+        else if (typeof value === "string") {
+            message = value;
+        }
+        else if (value instanceof ProgramObject && typeof get(value, "message") === "string") {
+            message = get(value, "message");
+        }
+        else {
+            try {
+                message = JSON.stringify(toData(value, "Thrown value")) ?? String(value);
+            }
+            catch {
+                message = String(value);
+            }
+        }
+        return { kind: "ExecutionFailure", message: `Uncaught: ${message}` };
+    }
+    if (error instanceof RangeError && /call stack|recursion/i.test(error.message)) {
+        return {
+            kind: "ExecutionFailure",
+            message: "Execution exceeded the maximum nesting depth.",
+        };
+    }
+    if (error instanceof Error) {
+        return {
+            kind: error.name === "SyntaxError" ? "ParseError" : "ExecutionFailure",
+            message: error.message,
+        };
+    }
+    return {
+        kind: "ExecutionFailure",
+        message: String(error),
+    };
+};
+export const caughtErrorValue = (runner, thrown) => {
+    if (thrown instanceof ProgramThrow)
+        return thrown.value;
+    const prototypes = runner.intrinsics.errors;
+    if (thrown instanceof InterpreterRuntimeError)
+        return createErrorValue(prototypes[thrown.type], thrown.message);
+    const type = thrown instanceof Error && isErrorType(thrown.name) ? thrown.name : "Error";
+    return createErrorValue(prototypes[type], normalizeError(thrown).message);
+};
+export const createAggregateErrorValue = (runner, errors, message) => {
+    const value = createErrorValue(runner.intrinsics.errors.AggregateError, message);
+    set(value, "errors", new ProgramArray(errors));
+    return value;
+};
+const constructAggregateErrorValue = (runner, args, node) => Effect.gen(function* () {
+    const cursor = yield* runner.syncIterator(args[0], node);
+    if (cursor === undefined) {
+        throw new InterpreterRuntimeError("new AggregateError(...) expects a synchronous iterable of errors.", node);
+    }
+    const errors = [];
+    while (true) {
+        const step = yield* cursor.next;
+        if (step.done) {
+            return createAggregateErrorValue(runner, errors, args[1] === undefined ? "" : coerceToString(args[1]));
+        }
+        errors.push(step.value);
+    }
+});
+/** An error constructor such as `Error` or `TypeError`; callable with or without `new`, like JS. */
+export const errorGlobal = (type, runner) => {
+    const prototype = runner.intrinsics.errors[type];
+    const construct = (args, node) => type === "AggregateError"
+        ? constructAggregateErrorValue(runner, args, node)
+        : Effect.sync(() => createErrorValue(prototype, args[0] === undefined ? undefined : coerceToString(args[0])));
+    const fn = new HostFunction({
+        name: type,
+        call: construct,
+        construct,
+        instanceOf: (value) => hasPrototype(value, prototype),
+    });
+    set(prototype, "constructor", fn);
+    return fn;
+};

package/dist/interpreter/execute.d.ts

@@ -0,0 +1,5 @@
+import { Effect } from "effect";
+import type { ResolvedExecutionLimits, Result } from "../codemode.js";
+import { ToolRuntime } from "../tool-runtime.js";
+import type { Host } from "./globals.js";
+export declare const executeProgram: <R>(code: string, prepared: ToolRuntime.Prepared<R>, limits: ResolvedExecutionLimits, hooks: ToolRuntime.ToolCallHooks<R>, extraGlobals?: (host: Host<R>) => ReadonlyArray<readonly [string, unknown]>) => Effect.Effect<Result, never, R>;

package/dist/interpreter/execute.js

@@ -0,0 +1,171 @@
+import { parse } from "acorn";
+import { Cause, Effect, Scope } from "effect";
+// #transpile: conditional import — full typescript on node/bun, an identity
+// pass-through on workerd (the compiler is ~11 MiB and can't init there).
+import { transpile } from "#transpile";
+import { toData } from "../data.js";
+import { ToolRuntime } from "../tool-runtime.js";
+import { normalizeError } from "./errors.js";
+import { InterpreterRuntimeError } from "./model.js";
+import { PromiseRuntime } from "./promises.js";
+import { Runtime } from "./runtime.js";
+export const executeProgram = (code, prepared, limits, hooks, extraGlobals) => {
+    if (code.trim().length === 0) {
+        return Effect.succeed({
+            ok: false,
+            error: { kind: "ParseError", message: "Code cannot be empty." },
+            toolCalls: [],
+        });
+    }
+    // Allocate execution state inside suspension so reused Effects never share it.
+    return Effect.suspend(() => {
+        const tools = ToolRuntime.make(prepared, limits.maxToolCalls, hooks);
+        const logs = [];
+        const logged = () => (logs.length > 0 ? { logs: [...logs] } : {});
+        // Set only after copy-out so timeouts cannot report invalid values as completed.
+        let returned;
+        const base = Effect.acquireUseRelease(Scope.make("parallel"), (scope) => Effect.gen(function* () {
+            const program = parseProgram(code);
+            const promises = new PromiseRuntime(scope);
+            const value = yield* new Runtime(tools.execute, tools.search, tools.keys, promises, logs, extraGlobals).run(program);
+            const result = toData(value, "Execution result", "result");
+            returned = { value: result, promises };
+            const warnings = yield* promises.interrupt();
+            return {
+                ok: true,
+                value: result,
+                ...(warnings.length > 0 ? { warnings } : {}),
+                ...logged(),
+                toolCalls: tools.calls,
+            };
+        }), (scope, exit) => Scope.close(scope, exit));
+        const timeoutMs = limits.timeoutMs;
+        const operation = timeoutMs === undefined
+            ? base
+            : base.pipe(Effect.timeoutOrElse({
+                duration: timeoutMs,
+                orElse: () => Effect.sync(() => {
+                    if (returned === undefined) {
+                        return {
+                            ok: false,
+                            error: { kind: "TimeoutExceeded", message: `Execution timed out after ${timeoutMs}ms.` },
+                            ...logged(),
+                            toolCalls: tools.calls,
+                        };
+                    }
+                    // Keep the timeout warning first so truncation preserves it.
+                    return {
+                        ok: true,
+                        value: returned.value,
+                        warnings: [
+                            {
+                                kind: "TimeoutExceeded",
+                                message: `The program returned, but background work was still running at the ${timeoutMs}ms timeout and was interrupted. Await all started promises.`,
+                            },
+                            ...returned.promises.diagnostics(),
+                        ],
+                        ...logged(),
+                        toolCalls: tools.calls,
+                    };
+                }),
+            }));
+        return operation.pipe(Effect.catchCause((cause) => Cause.hasInterruptsOnly(cause)
+            ? Effect.interrupt
+            : Effect.succeed({
+                ok: false,
+                error: normalizeError(Cause.squash(cause)),
+                ...logged(),
+                toolCalls: tools.calls,
+            })), Effect.map((result) => limits.maxOutputBytes === undefined ? result : boundOutput(result, limits.maxOutputBytes)));
+    });
+};
+const parseProgram = (code) => {
+    const transpiled = transpile(`async function __codemode__() {\n${code}\n}`);
+    if (transpiled.error !== undefined) {
+        throw new InterpreterRuntimeError(`Failed to parse TypeScript: ${transpiled.error}`, undefined, "ParseError");
+    }
+    const bodyStart = transpiled.outputText.indexOf("{") + 1;
+    const bodyEnd = transpiled.outputText.lastIndexOf("}");
+    const executableCode = transpiled.outputText.slice(bodyStart, bodyEnd);
+    return parse(executableCode, {
+        ecmaVersion: "latest",
+        sourceType: "script",
+        allowReturnOutsideFunction: true,
+        allowAwaitOutsideFunction: true,
+        locations: true,
+    });
+};
+const utf8ByteLength = (value) => new TextEncoder().encode(value).byteLength;
+// Drop a replacement character produced by truncating inside a UTF-8 sequence.
+const utf8Truncate = (value, maxBytes) => {
+    const bytes = new TextEncoder().encode(value);
+    if (bytes.byteLength <= maxBytes)
+        return value;
+    const text = new TextDecoder("utf-8").decode(bytes.slice(0, Math.max(0, maxBytes)));
+    return text.endsWith("\uFFFD") ? text.slice(0, -1) : text;
+};
+// Warnings have a separate budget so result data cannot starve diagnostics.
+const boundOutput = (result, maxOutputBytes) => {
+    let truncated = false;
+    let value = null;
+    let valueBytes = 0;
+    if (result.ok) {
+        const serialized = JSON.stringify(result.value) ?? "null";
+        const bytes = utf8ByteLength(serialized);
+        if (bytes > maxOutputBytes) {
+            truncated = true;
+            value = `${utf8Truncate(serialized, maxOutputBytes)} [result truncated: ${bytes} bytes exceeds the ${maxOutputBytes}-byte output limit; return a smaller value]`;
+            valueBytes = maxOutputBytes;
+        }
+        else {
+            value = result.value;
+            valueBytes = bytes;
+        }
+    }
+    const warnings = result.ok ? (result.warnings ?? []) : [];
+    const keptWarnings = [];
+    let warningBytes = 0;
+    for (const warning of warnings) {
+        const bytes = utf8ByteLength(JSON.stringify(warning)) + 1;
+        if (warningBytes + bytes > maxOutputBytes)
+            break;
+        warningBytes += bytes;
+        keptWarnings.push(warning);
+    }
+    if (keptWarnings.length < warnings.length) {
+        truncated = true;
+        keptWarnings.push({
+            kind: "Truncated",
+            message: `${warnings.length - keptWarnings.length} additional warnings omitted by the output limit.`,
+        });
+    }
+    const logs = result.logs ?? [];
+    const kept = [];
+    const logBudget = Math.max(0, maxOutputBytes - valueBytes);
+    let logBytes = 0;
+    for (const line of logs) {
+        const lineBytes = utf8ByteLength(line) + 1;
+        if (logBytes + lineBytes > logBudget)
+            break;
+        logBytes += lineBytes;
+        kept.push(line);
+    }
+    if (kept.length < logs.length) {
+        truncated = true;
+        kept.push(`[logs truncated: showing ${kept.length} of ${logs.length} lines]`);
+    }
+    if (!truncated)
+        return result;
+    const warningsPart = keptWarnings.length > 0 ? { warnings: keptWarnings } : {};
+    const logsPart = kept.length > 0 ? { logs: kept } : {};
+    return result.ok
+        ? {
+            ok: true,
+            value,
+            ...warningsPart,
+            ...logsPart,
+            truncated: true,
+            toolCalls: result.toolCalls,
+        }
+        : { ok: false, error: result.error, ...logsPart, truncated: true, toolCalls: result.toolCalls };
+};

package/dist/interpreter/globals.d.ts

@@ -0,0 +1,13 @@
+import { Effect } from "effect";
+import { type PromiseRuntime } from "./promises.js";
+import type { Runner } from "./runner.js";
+/** What the built-in globals need from the interpreter that owns them. */
+export type Host<R> = {
+    readonly runner: Runner<R>;
+    readonly promises: PromiseRuntime<R>;
+    readonly search: (args: Array<unknown>) => Effect.Effect<unknown, unknown, R>;
+    readonly toolKeys: (path: ReadonlyArray<string>) => ReadonlyArray<string>;
+    readonly logs: Array<string>;
+};
+/** The immutable global bindings of every program, in declaration order. */
+export declare const globals: <R>(host: Host<R>) => ReadonlyArray<readonly [string, unknown]>;

package/dist/interpreter/globals.js

@@ -0,0 +1,64 @@
+import { Effect } from "effect";
+import { arrayGlobal } from "../stdlib/array.js";
+import { mapGlobal, setGlobal } from "../stdlib/collections.js";
+import { consoleGlobal } from "../stdlib/console.js";
+import { dateGlobal } from "../stdlib/date.js";
+import { jsonGlobal } from "../stdlib/json.js";
+import { mathGlobal } from "../stdlib/math.js";
+import { numberGlobal } from "../stdlib/number.js";
+import { objectGlobal } from "../stdlib/object.js";
+import { regexpGlobal } from "../stdlib/regexp.js";
+import { stringGlobal } from "../stdlib/string.js";
+import { uriGlobal, urlGlobal, urlSearchParamsGlobal } from "../stdlib/url.js";
+import { coercion } from "../stdlib/value.js";
+import { atobGlobal, btoaGlobal, cryptoGlobal } from "../stdlib/web.js";
+import { ToolReference } from "../tool-runtime.js";
+import { errorGlobal } from "./errors.js";
+import { errorTypes } from "./intrinsics.js";
+import { HostFunction } from "./host.js";
+import { AsyncIteratorSymbol, InterpreterRuntimeError, IteratorSymbol } from "./model.js";
+import { promiseGlobal } from "./promises.js";
+const symbolGlobal = new HostFunction({
+    name: "Symbol",
+    call: (_, node) => Effect.sync(() => {
+        throw new InterpreterRuntimeError("Symbol is not callable; only Symbol.asyncIterator and Symbol.iterator are available.", node);
+    }),
+    callback: false,
+    members: { asyncIterator: AsyncIteratorSymbol, iterator: IteratorSymbol },
+});
+/** The immutable global bindings of every program, in declaration order. */
+export const globals = (host) => [
+    ["tools", new ToolReference([])],
+    ["search", new HostFunction({ name: "search", call: (args) => host.search(args), callback: false })],
+    ["undefined", undefined],
+    ["NaN", NaN],
+    ["Infinity", Infinity],
+    ["Object", objectGlobal(host.runner, host.toolKeys)],
+    ["Array", arrayGlobal(host.runner)],
+    ["Math", mathGlobal(host.runner)],
+    ["JSON", jsonGlobal(host.runner)],
+    ["console", consoleGlobal(host.logs)],
+    ["Promise", promiseGlobal(host.runner, host.promises)],
+    ["Symbol", symbolGlobal],
+    ["Number", numberGlobal],
+    ["String", stringGlobal],
+    ["Boolean", coercion("Boolean", { instanceOf: () => false })],
+    ["parseInt", coercion("parseInt")],
+    ["parseFloat", coercion("parseFloat")],
+    ["isFinite", coercion("isFinite")],
+    ["isNaN", coercion("isNaN")],
+    ["Date", dateGlobal(host.runner)],
+    ["RegExp", regexpGlobal],
+    ["Map", mapGlobal(host.runner)],
+    ["Set", setGlobal(host.runner)],
+    ["URL", urlGlobal],
+    ["URLSearchParams", urlSearchParamsGlobal(host.runner)],
+    ["encodeURI", uriGlobal("encodeURI")],
+    ["encodeURIComponent", uriGlobal("encodeURIComponent")],
+    ["decodeURI", uriGlobal("decodeURI")],
+    ["decodeURIComponent", uriGlobal("decodeURIComponent")],
+    ["atob", atobGlobal],
+    ["btoa", btoaGlobal],
+    ["crypto", cryptoGlobal],
+    ...errorTypes.map((type) => [type, errorGlobal(type, host.runner)]),
+];

package/dist/interpreter/host.d.ts

@@ -0,0 +1,41 @@
+import { Effect } from "effect";
+import { type AstNode } from "./model.js";
+export type HostCall<R> = (args: Array<unknown>, node: AstNode) => Effect.Effect<unknown, unknown, R>;
+type HostMember = (key: PropertyKey, node: AstNode) => unknown;
+type HostFunctionOptions<R> = {
+    readonly name: string;
+    readonly call: HostCall<R>;
+    /** `new name(...)`; without it `new` is unsupported syntax. */
+    readonly construct?: HostCall<R>;
+    /** Static members read through `name.key`; unknown keys read as `undefined` unless the function decides otherwise. */
+    readonly members?: Record<string, unknown> | HostMember;
+    /** `value instanceof name`; without it the operator rejects this right-hand side. */
+    readonly instanceOf?: (value: unknown) => boolean;
+    /** Whether callback sites (array methods, replacers, promise reactions) admit this function. Defaults to true. */
+    readonly callback?: boolean;
+};
+/** A host-implemented function value. `typeof` is "function". */
+export declare class HostFunction<R = never> {
+    readonly name: string;
+    readonly call: HostCall<R>;
+    readonly construct: HostCall<R> | undefined;
+    readonly member: HostMember;
+    readonly instanceOf: ((value: unknown) => boolean) | undefined;
+    readonly callback: boolean;
+    constructor(options: HostFunctionOptions<R>);
+}
+/** A host-implemented object of static members. `typeof` is "object" and it is not callable. */
+export declare class HostNamespace {
+    readonly name: string;
+    readonly member: HostMember;
+    constructor(name: string, members: Record<string, unknown> | HostMember);
+}
+export type SyncOptions = Omit<HostFunctionOptions<never>, "name" | "call">;
+type SyncImpl = (args: Array<unknown>, node: AstNode) => unknown;
+/** Lifts a synchronous implementation, which may throw `InterpreterRuntimeError`, into a host call. */
+export declare const syncCall: (impl: SyncImpl) => HostCall<never>;
+/** A synchronous host function. */
+export declare const sync: (name: string, impl: SyncImpl, options?: SyncOptions) => HostFunction<never>;
+/** The `call` of a constructor that JS requires to be invoked with `new`. */
+export declare const requiresNew: (name: string) => HostCall<never>;
+export {};

package/dist/interpreter/host.js

@@ -0,0 +1,44 @@
+import { Effect } from "effect";
+import { InterpreterRuntimeError } from "./model.js";
+/** A host-implemented function value. `typeof` is "function". */
+export class HostFunction {
+    name;
+    call;
+    construct;
+    member;
+    instanceOf;
+    callback;
+    constructor(options) {
+        this.name = options.name;
+        this.call = options.call;
+        this.construct = options.construct;
+        this.member = memberLookup(options.members);
+        this.instanceOf = options.instanceOf;
+        this.callback = options.callback ?? true;
+    }
+}
+/** A host-implemented object of static members. `typeof` is "object" and it is not callable. */
+export class HostNamespace {
+    name;
+    member;
+    constructor(name, members) {
+        this.name = name;
+        this.member = memberLookup(members);
+    }
+}
+const memberLookup = (members) => {
+    if (members === undefined)
+        return () => undefined;
+    if (typeof members === "function")
+        return members;
+    const table = new Map(Object.entries(members));
+    return (key) => (typeof key === "string" ? table.get(key) : undefined);
+};
+/** Lifts a synchronous implementation, which may throw `InterpreterRuntimeError`, into a host call. */
+export const syncCall = (impl) => (args, node) => Effect.sync(() => impl(args, node));
+/** A synchronous host function. */
+export const sync = (name, impl, options = {}) => new HostFunction({ name, call: syncCall(impl), ...options });
+/** The `call` of a constructor that JS requires to be invoked with `new`. */
+export const requiresNew = (name) => (_, node) => Effect.sync(() => {
+    throw new InterpreterRuntimeError(`Constructor ${name} requires 'new'.`, node);
+});

package/dist/interpreter/intrinsics.d.ts

@@ -0,0 +1,10 @@
+import { ProgramError, ProgramObject } from "./objects.js";
+export declare const errorTypes: readonly ["Error", "TypeError", "RangeError", "SyntaxError", "ReferenceError", "EvalError", "URIError", "AggregateError"];
+export type ErrorType = (typeof errorTypes)[number];
+export declare const isErrorType: (name: string) => name is ErrorType;
+/** The built-in prototype objects of one runtime. Constructors attach themselves as `constructor` when created. */
+export type Intrinsics = {
+    readonly errors: Readonly<Record<ErrorType, ProgramObject>>;
+};
+export declare const createErrorValue: (prototype: ProgramObject, message: string | undefined) => ProgramError;
+export declare const createIntrinsics: () => Intrinsics;

package/dist/interpreter/intrinsics.js

@@ -0,0 +1,41 @@
+import { ProgramError, ProgramObject, set } from "./objects.js";
+export const errorTypes = [
+    "Error",
+    "TypeError",
+    "RangeError",
+    "SyntaxError",
+    "ReferenceError",
+    "EvalError",
+    "URIError",
+    "AggregateError",
+];
+export const isErrorType = (name) => errorTypes.includes(name);
+export const createErrorValue = (prototype, message) => {
+    const value = new ProgramError(prototype);
+    if (message !== undefined)
+        set(value, "message", message);
+    return value;
+};
+export const createIntrinsics = () => {
+    const error = new ProgramObject();
+    set(error, "name", "Error");
+    set(error, "message", "");
+    const derived = (type) => {
+        const proto = new ProgramObject(error);
+        set(proto, "name", type);
+        set(proto, "message", "");
+        return proto;
+    };
+    return {
+        errors: {
+            Error: error,
+            TypeError: derived("TypeError"),
+            RangeError: derived("RangeError"),
+            SyntaxError: derived("SyntaxError"),
+            ReferenceError: derived("ReferenceError"),
+            EvalError: derived("EvalError"),
+            URIError: derived("URIError"),
+            AggregateError: derived("AggregateError"),
+        },
+    };
+};

package/dist/interpreter/methods.d.ts

@@ -0,0 +1,4 @@
+import { Effect } from "effect";
+import { type AstNode, IntrinsicReference } from "./model.js";
+import { type Runner } from "./runner.js";
+export declare const invokeIntrinsic: <R>(runner: Runner<R>, ref: IntrinsicReference, args: Array<unknown>, node: AstNode) => Effect.Effect<unknown, unknown, R>;