@opencode-ai/codemode 0.0.0-dev-17471

package/dist/interpreter/references.js

@@ -0,0 +1,114 @@
+import { CodeModeFunction, CodeModeGenerator, CoercionFunction, ErrorConstructorReference, GlobalMethodReference, GlobalNamespace, GeneratorMethodReference, InterpreterRuntimeError, IntrinsicReference, JsonMethodReference, PromiseCapabilityFunction, PromiseInstanceMethodReference, PromiseMethodReference, PromiseNamespace, SearchFunction, SymbolNamespace, UriFunction, } from "./model.js";
+import { ToolReference } from "../tool-runtime.js";
+import { isCodeModeValue, CodeModePromise } from "../values.js";
+export const isRuntimeReference = (value) => value instanceof CodeModeFunction ||
+    value instanceof CodeModeGenerator ||
+    value instanceof GeneratorMethodReference ||
+    value instanceof ToolReference ||
+    value instanceof IntrinsicReference ||
+    value instanceof GlobalNamespace ||
+    value instanceof GlobalMethodReference ||
+    value instanceof JsonMethodReference ||
+    value instanceof PromiseNamespace ||
+    value instanceof PromiseMethodReference ||
+    value instanceof PromiseInstanceMethodReference ||
+    value instanceof CodeModePromise ||
+    value instanceof CoercionFunction ||
+    value instanceof UriFunction ||
+    value instanceof SearchFunction ||
+    value instanceof PromiseCapabilityFunction ||
+    value instanceof ErrorConstructorReference ||
+    value instanceof SymbolNamespace ||
+    isCodeModeValue(value);
+function* childValues(value) {
+    if (Array.isArray(value)) {
+        const length = value.length;
+        for (let index = 0; index < length; index++)
+            yield value[index];
+        return;
+    }
+    yield* Object.values(value);
+}
+export const containsRuntimeReference = (value) => {
+    const pending = [[value].values()];
+    const seen = new Set();
+    while (pending.length > 0) {
+        const next = pending.at(-1).next();
+        if (next.done) {
+            pending.pop();
+            continue;
+        }
+        const current = next.value;
+        if (isRuntimeReference(current))
+            return true;
+        if (current === null || typeof current !== "object" || seen.has(current))
+            continue;
+        seen.add(current);
+        pending.push(childValues(current));
+    }
+    return false;
+};
+// CodeMode values are data here, not opaque interpreter references.
+export const containsOpaqueReference = (value) => {
+    const pending = [[value].values()];
+    const seen = new Set();
+    while (pending.length > 0) {
+        const next = pending.at(-1).next();
+        if (next.done) {
+            pending.pop();
+            continue;
+        }
+        const current = next.value;
+        if (isCodeModeValue(current))
+            continue;
+        if (isRuntimeReference(current))
+            return true;
+        if (current === null || typeof current !== "object" || seen.has(current))
+            continue;
+        seen.add(current);
+        pending.push(childValues(current));
+    }
+    return false;
+};
+// Reject cycles before mutation so later boundary walks remain safe.
+export const rejectCircularInsertion = (container, value, label, node) => {
+    const pending = [[value].values()];
+    const seen = new Set();
+    while (pending.length > 0) {
+        const next = pending.at(-1).next();
+        if (next.done) {
+            pending.pop();
+            continue;
+        }
+        const current = next.value;
+        if (current === container)
+            throw new InterpreterRuntimeError(`${label} contains a circular value.`, node, "InvalidDataValue");
+        if (current === null || typeof current !== "object" || isRuntimeReference(current) || seen.has(current))
+            continue;
+        seen.add(current);
+        pending.push(Array.isArray(current) ? current[Symbol.iterator]() : childValues(current));
+    }
+};
+export const typeofValue = (value) => {
+    if (value instanceof CodeModeFunction ||
+        value instanceof GeneratorMethodReference ||
+        value instanceof CoercionFunction ||
+        value instanceof IntrinsicReference ||
+        value instanceof GlobalMethodReference ||
+        value instanceof JsonMethodReference ||
+        value instanceof PromiseMethodReference ||
+        value instanceof PromiseInstanceMethodReference ||
+        value instanceof PromiseNamespace ||
+        value instanceof PromiseCapabilityFunction ||
+        value instanceof ErrorConstructorReference ||
+        value instanceof SymbolNamespace)
+        return "function";
+    if (value instanceof UriFunction || value instanceof SearchFunction)
+        return "function";
+    if (value instanceof ToolReference)
+        return value.path.length > 0 ? "function" : "object";
+    if (value instanceof GlobalNamespace) {
+        return value.name === "Math" || value.name === "JSON" || value.name === "console" ? "object" : "function";
+    }
+    return typeof value;
+};

package/dist/interpreter/runtime.d.ts

@@ -0,0 +1,98 @@
+import { Effect } from "effect";
+import { type ProgramNode } from "./model.js";
+import { PromiseRuntime } from "./promises.js";
+export declare class Interpreter<R> {
+    private scopes;
+    private readonly executeTool;
+    private readonly invokeSearch;
+    private readonly toolKeys;
+    private readonly logs;
+    private readonly promises;
+    private generatorState?;
+    private generatorAsync;
+    private readonly runner;
+    constructor(executeTool: (path: ReadonlyArray<string>, args: Array<unknown>) => Effect.Effect<unknown, unknown, R>, invokeSearch: (args: Array<unknown>) => Effect.Effect<unknown, unknown, R>, toolKeys: (path: ReadonlyArray<string>) => ReadonlyArray<string>, promises: PromiseRuntime<R>, logs?: Array<string>);
+    run(program: ProgramNode): Effect.Effect<unknown, unknown, R>;
+    private createToolCallPromise;
+    private createPromise;
+    private settlePromise;
+    private evaluateStatement;
+    private evaluateBlock;
+    private createFunction;
+    private hoistFunctions;
+    private predeclareLexical;
+    private predeclarePattern;
+    private evaluateIfStatement;
+    private evaluateSwitchStatement;
+    private evaluateWhileStatement;
+    private evaluateDoWhileStatement;
+    private evaluateForStatement;
+    private evaluateForOfStatement;
+    private awaitValue;
+    private awaitAsyncFromSyncValue;
+    private syncIterator;
+    private customIterator;
+    private nextIteratorResult;
+    private closeIterator;
+    private requireIteratorObject;
+    private requireIterator;
+    private requireIteratorMethod;
+    private enumerableKeys;
+    private evaluateForInStatement;
+    private evaluateBreakStatement;
+    private evaluateContinueStatement;
+    private evaluateLabeledStatement;
+    private evaluateThrowStatement;
+    private evaluateTryStatement;
+    private evaluateVariableDeclaration;
+    private declarePattern;
+    private assignPattern;
+    private destructureArrayPattern;
+    private destructuringPropertyKey;
+    private destructuringPropertyValue;
+    private evaluateExpression;
+    private evaluateNewExpression;
+    private constructArray;
+    private constructObject;
+    private constructDate;
+    private toDatePrimitive;
+    private constructRegExp;
+    private constructMap;
+    private constructSet;
+    private constructURL;
+    private constructURLSearchParams;
+    private readURLSearchParamsPair;
+    private evaluateBinaryExpression;
+    private applyBinaryOperator;
+    private evaluateLogicalExpression;
+    private evaluateUnaryExpression;
+    private evaluateAssignmentExpression;
+    private evaluateLogicalAssignment;
+    private evaluateUpdateExpression;
+    private evaluateCallExpression;
+    private invokeCallable;
+    private invokeObjectMethodOnTools;
+    private invokeConsole;
+    private evaluateCallArguments;
+    private invokeFunction;
+    private createGenerator;
+    private completeGeneratorRequests;
+    private takeGeneratorRequest;
+    private dequeueGeneratorRequest;
+    private evaluateYieldExpression;
+    private suspendGenerator;
+    private delegateYield;
+    private evaluateObjectExpression;
+    private evaluateArrayExpression;
+    private evaluateTemplateLiteral;
+    private evaluateConditionalExpression;
+    private applyCompoundAssignment;
+    private getMemberReference;
+    private readMember;
+    private writeMember;
+    private evaluateDeleteExpression;
+    private modifyMember;
+    private readReferenceValue;
+    private assignToReference;
+    private toPropertyKey;
+}