@opencode-ai/codemode 0.0.0-dev-17471

package/dist/interpreter/execute.js

@@ -0,0 +1,178 @@
+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 { copyIn, copyOut, ToolRuntime } from "../tool-runtime.js";
+import { normalizeError } from "./errors.js";
+import { InterpreterRuntimeError, isRecord } from "./model.js";
+import { PromiseRuntime } from "./promises.js";
+import { Interpreter } from "./runtime.js";
+export const executeWithLimits = (options, limits, searchIndex) => {
+    if (options.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((options.tools ?? {}), limits.maxToolCalls, searchIndex, {
+            onToolCallStart: options.onToolCallStart,
+            onToolCallEnd: options.onToolCallEnd,
+        });
+        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(options.code);
+            const promises = new PromiseRuntime(scope);
+            const interpreter = new Interpreter(tools.execute, tools.search, tools.keys, promises, logs);
+            const value = yield* interpreter.run(program);
+            const result = copyOut(copyIn(value, "Execution result"), "nullify");
+            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);
+    const parsed = parse(executableCode, {
+        ecmaVersion: "latest",
+        sourceType: "script",
+        allowReturnOutsideFunction: true,
+        allowAwaitOutsideFunction: true,
+        locations: true,
+    });
+    if (!isRecord(parsed) || parsed.type !== "Program" || !Array.isArray(parsed.body)) {
+        throw new InterpreterRuntimeError("Failed to parse script as a Program node.");
+    }
+    return parsed;
+};
+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/iterator.d.ts

@@ -0,0 +1,13 @@
+import { Effect } from "effect";
+import type { AstNode } from "./model.js";
+export type IteratorCursor<R> = {
+    readonly next: Effect.Effect<{
+        readonly done: boolean;
+        readonly value: unknown;
+    }, unknown, R>;
+    readonly close: Effect.Effect<void, unknown, R>;
+};
+export type SyncIteratorRunner<R> = {
+    readonly syncIterator: (value: unknown, node: AstNode) => Effect.Effect<IteratorCursor<R> | undefined, unknown, R>;
+};
+export declare const preserveConsumerError: <A, R>(cursor: IteratorCursor<R>, effect: Effect.Effect<A, unknown, R>) => Effect.Effect<A, unknown, R>;

package/dist/interpreter/iterator.js

@@ -0,0 +1,4 @@
+import { Effect, Exit } from "effect";
+export const preserveConsumerError = (cursor, effect) => Effect.flatMap(Effect.exit(effect), (exit) => Exit.isSuccess(exit)
+    ? Effect.succeed(exit.value)
+    : Effect.andThen(Effect.exit(cursor.close), Effect.failCause(exit.cause)));

package/dist/interpreter/methods.d.ts

@@ -0,0 +1,17 @@
+import { Effect } from "effect";
+import { type AstNode, CodeModeFunction, CoercionFunction, ErrorConstructorReference, GlobalMethodReference, GlobalNamespace, IntrinsicReference, JsonMethodReference, PromiseCapabilityFunction, PromiseNamespace, UriFunction } from "./model.js";
+import { CodeModePromise } from "../values.js";
+import { type SyncIteratorRunner } from "./iterator.js";
+export type CallbackRunner<R> = {
+    readonly invokeFunction: (fn: CodeModeFunction, args: Array<unknown>) => Effect.Effect<unknown, unknown, R>;
+    readonly invokeCallable: (callable: unknown, args: Array<unknown>, node: AstNode) => Effect.Effect<unknown, unknown, R>;
+    readonly settlePromise: (promise: CodeModePromise) => Effect.Effect<unknown, unknown, never>;
+};
+export type SupportedCallback = CodeModeFunction | CoercionFunction | UriFunction | PromiseCapabilityFunction | GlobalMethodReference | JsonMethodReference | IntrinsicReference | ErrorConstructorReference | GlobalNamespace | PromiseNamespace;
+export declare const isSupportedCallback: (value: unknown) => value is SupportedCallback;
+export declare const invokeIntrinsic: <R>(runner: CallbackRunner<R>, ref: IntrinsicReference, args: Array<unknown>, node: AstNode) => Effect.Effect<unknown, unknown, R>;
+export declare const invokeGlobalMethod: (ref: GlobalMethodReference, args: Array<unknown>, node: AstNode) => unknown;
+export declare const arrayStatics: Set<string>;
+export declare const invokeArrayFrom: <R>(runner: CallbackRunner<R> & SyncIteratorRunner<R>, args: Array<unknown>, node: AstNode) => Effect.Effect<unknown, unknown, R>;
+export declare const invokeGroupBy: <R>(runner: CallbackRunner<R> & SyncIteratorRunner<R>, namespace: "Map" | "Object", args: Array<unknown>, node: AstNode) => Effect.Effect<unknown, unknown, R>;
+export declare const applyCollectionCallback: <R>(runner: CallbackRunner<R>, callback: unknown, name: string, node: AstNode) => ((args: Array<unknown>) => Effect.Effect<unknown, unknown, R>);