@opencode/codemode 0.0.0-reserved → 2.0.0

package/dist/openapi/types.d.ts

@@ -0,0 +1,122 @@
+import { Effect } from "effect";
+import { HttpClient } from "effect/unstable/http";
+import type { Tool, JsonSchema } from "../tool.js";
+/** A parsed OpenAPI 3.x document. YAML must be parsed by the host. */
+export type Document = Record<string, unknown>;
+/** The operation identity handed to auth resolution and errors. */
+export type Operation = {
+    readonly operationId: string | undefined;
+    readonly method: string;
+    readonly path: string;
+    readonly summary: string | undefined;
+    readonly description: string | undefined;
+};
+/** A resolved OpenAPI security scheme from `components.securitySchemes`. */
+export type SecurityScheme = {
+    readonly type: "apiKey";
+    readonly name: string;
+    readonly in: "header" | "query" | "cookie";
+} | {
+    readonly type: "http";
+    readonly scheme: string;
+} | {
+    readonly type: "oauth2";
+} | {
+    readonly type: "openIdConnect";
+};
+/**
+ * Credential material returned by a host auth resolver. `apiKey` uses the scheme's carrier;
+ * `header` supports nonstandard schemes.
+ */
+export type Credential = {
+    readonly type: "bearer";
+    readonly token: string;
+} | {
+    readonly type: "basic";
+    readonly username: string;
+    readonly password: string;
+} | {
+    readonly type: "apiKey";
+    readonly value: string;
+} | {
+    readonly type: "header";
+    readonly name: string;
+    readonly value: string;
+};
+/**
+ * Resolves credentials at call time. `undefined` tries the next OR alternative; failure aborts.
+ */
+export type AuthResolver = (context: {
+    readonly name: string;
+    readonly definition: SecurityScheme;
+    readonly scopes: ReadonlyArray<string>;
+    readonly operation: Operation;
+}) => Effect.Effect<Credential | undefined, unknown>;
+export type Options = {
+    readonly spec: Document;
+    /** Overrides all document, path, and operation `servers`. Required when no applicable absolute server URL exists. */
+    readonly baseUrl?: string | undefined;
+    /** Host credential resolution, keyed by security scheme name. */
+    readonly auth?: {
+        readonly resolve: AuthResolver;
+    } | undefined;
+    /** Static headers on every request. Not model-visible; declared header params may override them, auth always wins. */
+    readonly headers?: Readonly<Record<string, string>> | undefined;
+};
+/** An operation that could not be represented as a tool, and why. */
+export type Skipped = {
+    readonly method: string;
+    readonly path: string;
+    readonly reason: string;
+};
+export type Tools = {
+    [name: string]: Tool<HttpClient.HttpClient> | Tools;
+};
+export type Result = {
+    /** Namespaced tools; the host places them under a key in its `tools` object. */
+    readonly tools: Tools;
+    readonly skipped: ReadonlyArray<Skipped>;
+};
+export type Parsed<T> = {
+    readonly ok: true;
+    readonly value: T;
+} | {
+    readonly ok: false;
+    readonly reason: string;
+};
+export type InputLocation = "path" | "query" | "header" | "body";
+export type InputField = {
+    readonly inputName: string;
+    readonly name: string;
+    readonly location: InputLocation;
+    readonly required: boolean;
+    readonly schema: JsonSchema;
+    readonly style: "simple" | "form" | "deepObject" | undefined;
+    readonly explode: boolean | undefined;
+};
+export type Body = {
+    readonly required: boolean;
+    readonly mode: "object" | "value";
+    readonly mediaType: string;
+};
+export type OperationInput = {
+    readonly fields: ReadonlyArray<InputField>;
+    readonly body: Body | undefined;
+};
+export type SecurityRequirement = Readonly<Record<string, ReadonlyArray<string>>>;
+export type Plan = {
+    readonly operation: Operation;
+    readonly url: string;
+    readonly fields: ReadonlyArray<InputField>;
+    readonly body: Body | undefined;
+    readonly security: ReadonlyArray<SecurityRequirement>;
+    readonly schemes: Readonly<Record<string, SecurityScheme>>;
+    readonly auth: {
+        readonly resolve: AuthResolver;
+    } | undefined;
+    readonly headers: Readonly<Record<string, string>>;
+};
+export type AppliedAuth = {
+    readonly headers: Readonly<Record<string, string>>;
+    readonly query: Readonly<Record<string, string>>;
+};

package/dist/openapi/types.js

@@ -0,0 +1,2 @@
+import { Effect } from "effect";
+import { HttpClient } from "effect/unstable/http";

package/dist/stdlib/array.d.ts

@@ -0,0 +1,3 @@
+import { HostFunction } from "../interpreter/host.js";
+import { type Runner } from "../interpreter/runner.js";
+export declare const arrayGlobal: <R>(runner: Runner<R>) => HostFunction<R>;

package/dist/stdlib/array.js

@@ -0,0 +1,68 @@
+import { Effect } from "effect";
+import { HostFunction, sync, syncCall } from "../interpreter/host.js";
+import { CodeModeGenerator, InterpreterRuntimeError } from "../interpreter/model.js";
+import { get, ProgramArray, ProgramObject } from "../interpreter/objects.js";
+import { describeValue } from "../interpreter/references.js";
+import { applyCollectionCallback, preserveConsumerError } from "../interpreter/runner.js";
+const constructArray = (args, node) => {
+    if (args.length !== 1)
+        return new ProgramArray([...args]);
+    const first = args[0];
+    if (typeof first !== "number")
+        return new ProgramArray([first]);
+    if (!Number.isInteger(first) || first < 0 || first > 4294967295) {
+        throw new InterpreterRuntimeError("Invalid array length.", node).as("RangeError");
+    }
+    // Sparse like JS: Array(3) has holes, and combinator loops already skip them.
+    return new ProgramArray(new Array(first));
+};
+const arrayLikeSource = (source, node) => {
+    if (source instanceof ProgramObject && typeof get(source, "length") === "number") {
+        const length = get(source, "length");
+        const normalized = Number.isNaN(length) || length <= 0 ? 0 : Math.trunc(length);
+        if (normalized > 4_294_967_295)
+            throw new RangeError("Invalid array length");
+        return { length: normalized, source };
+    }
+    throw new InterpreterRuntimeError(`Array.from expects an array, string, Map, Set, or array-like value, received ${describeValue(source)}.`, node, "InvalidDataValue");
+};
+const arrayFrom = (runner, args, node) => {
+    const source = args[0];
+    const apply = args.length < 2 || args[1] === undefined ? undefined : applyCollectionCallback(runner, args[1], "Array.from", node);
+    return Effect.gen(function* () {
+        const cursor = yield* runner.syncIterator(source, node);
+        if (cursor === undefined) {
+            if (source instanceof CodeModeGenerator) {
+                throw new InterpreterRuntimeError("Array.from expects a synchronous iterable or array-like value.", node).as("TypeError");
+            }
+            const arrayLike = arrayLikeSource(source, node);
+            const values = [];
+            for (let index = 0; index < arrayLike.length; index += 1) {
+                const item = get(arrayLike.source, index);
+                values.push(apply === undefined ? item : yield* apply([item, index]));
+            }
+            return new ProgramArray(values);
+        }
+        const values = [];
+        let index = 0;
+        while (true) {
+            const step = yield* cursor.next;
+            if (step.done)
+                return new ProgramArray(values);
+            values.push(apply === undefined ? step.value : yield* preserveConsumerError(cursor, apply([step.value, index])));
+            index += 1;
+        }
+    });
+};
+// Array constructs identically with or without new, like JS.
+export const arrayGlobal = (runner) => new HostFunction({
+    name: "Array",
+    call: syncCall(constructArray),
+    construct: syncCall(constructArray),
+    instanceOf: (value) => value instanceof ProgramArray,
+    members: {
+        isArray: sync("Array.isArray", (args) => args[0] instanceof ProgramArray),
+        of: sync("Array.of", (args) => new ProgramArray([...args])),
+        from: new HostFunction({ name: "Array.from", call: (args, node) => arrayFrom(runner, args, node) }),
+    },
+});

package/dist/stdlib/collections.d.ts

@@ -0,0 +1,9 @@
+import { HostFunction } from "../interpreter/host.js";
+import { type Runner } from "../interpreter/runner.js";
+export declare const arrayMethods: Set<string>;
+export declare const mapMethods: Set<string>;
+export declare const setMethods: Set<string>;
+/** `Map.groupBy` and `Object.groupBy`: the same iteration, keyed into a Map or a data object. */
+export declare const groupBy: <R>(runner: Runner<R>, namespace: "Map" | "Object") => HostFunction<R>;
+export declare const mapGlobal: <R>(runner: Runner<R>) => HostFunction<R>;
+export declare const setGlobal: <R>(runner: Runner<R>) => HostFunction<R>;

package/dist/stdlib/collections.js

@@ -0,0 +1,173 @@
+import { Effect } from "effect";
+import { HostFunction, requiresNew } from "../interpreter/host.js";
+import { InterpreterRuntimeError } from "../interpreter/model.js";
+import { getOwn, ProgramArray, ProgramObject, set } from "../interpreter/objects.js";
+import { describeValue, isRuntimeReference } from "../interpreter/references.js";
+import { applyCollectionCallback, preserveConsumerError, toPrimitive } from "../interpreter/runner.js";
+import { Values } from "../values.js";
+import { coerceToString } from "./value.js";
+export const arrayMethods = new Set([
+    "map",
+    "filter",
+    "find",
+    "findIndex",
+    "findLast",
+    "findLastIndex",
+    "some",
+    "every",
+    "includes",
+    "join",
+    "reduce",
+    "reduceRight",
+    "flatMap",
+    "forEach",
+    "sort",
+    "toSorted",
+    "slice",
+    "concat",
+    "indexOf",
+    "lastIndexOf",
+    "at",
+    "flat",
+    "reverse",
+    "toReversed",
+    "with",
+    "push",
+    "pop",
+    "shift",
+    "unshift",
+    "splice",
+    "toSpliced",
+    "fill",
+    "copyWithin",
+    "keys",
+    "values",
+    "entries",
+]);
+export const mapMethods = new Set(["get", "set", "has", "delete", "clear", "forEach", "keys", "values", "entries"]);
+export const setMethods = new Set([
+    "add",
+    "has",
+    "delete",
+    "clear",
+    "forEach",
+    "keys",
+    "values",
+    "entries",
+    "union",
+    "intersection",
+    "difference",
+    "symmetricDifference",
+    "isSubsetOf",
+    "isSupersetOf",
+    "isDisjointFrom",
+]);
+const coerceGroupByPropertyKey = (runner, value, node) => {
+    if (value instanceof Values.Promise)
+        return Effect.succeed("[object Promise]");
+    if (!Values.isValue(value) && isRuntimeReference(value)) {
+        throw new InterpreterRuntimeError(`Object.groupBy callback must return a data value, received ${describeValue(value)}.`, node, "InvalidDataValue");
+    }
+    return Effect.map(toPrimitive(runner, value, "string", node), coerceToString);
+};
+/** `Map.groupBy` and `Object.groupBy`: the same iteration, keyed into a Map or a data object. */
+export const groupBy = (runner, namespace) => new HostFunction({
+    name: `${namespace}.groupBy`,
+    call: (args, node) => {
+        const source = args[0];
+        if (source === null || source === undefined) {
+            throw new InterpreterRuntimeError(`${namespace}.groupBy expects an iterable collection.`, node).as("TypeError");
+        }
+        const apply = applyCollectionCallback(runner, args[1], `${namespace}.groupBy`, node);
+        return Effect.gen(function* () {
+            const cursor = yield* runner.syncIterator(source, node);
+            if (cursor === undefined) {
+                throw new InterpreterRuntimeError(`${namespace}.groupBy expects an iterable collection.`, node).as("TypeError");
+            }
+            if (namespace === "Map") {
+                const result = new Values.Map();
+                let index = 0;
+                while (true) {
+                    const step = yield* cursor.next;
+                    if (step.done)
+                        return result;
+                    const item = step.value;
+                    const key = yield* preserveConsumerError(cursor, apply([item, index]));
+                    const group = result.map.get(key);
+                    if (group === undefined)
+                        result.map.set(key, new ProgramArray([item]));
+                    else
+                        group.items.push(item);
+                    index += 1;
+                }
+            }
+            const result = new ProgramObject();
+            let index = 0;
+            while (true) {
+                const step = yield* cursor.next;
+                if (step.done)
+                    return result;
+                const item = step.value;
+                const key = yield* preserveConsumerError(cursor, Effect.flatMap(apply([item, index]), (value) => coerceGroupByPropertyKey(runner, value, node)));
+                const group = getOwn(result, key);
+                if (group === undefined)
+                    set(result, key, new ProgramArray([item]));
+                else
+                    group.items.push(item);
+                index += 1;
+            }
+        });
+    },
+});
+const constructMap = (runner, init, node) => {
+    const target = new Values.Map();
+    if (init === undefined || init === null)
+        return Effect.succeed(target);
+    return Effect.gen(function* () {
+        const cursor = yield* runner.syncIterator(init, node);
+        if (cursor === undefined) {
+            throw new InterpreterRuntimeError("new Map(...) expects an iterable of [key, value] pairs or no argument.", node).as("TypeError");
+        }
+        while (true) {
+            const step = yield* cursor.next;
+            if (step.done)
+                return target;
+            yield* preserveConsumerError(cursor, Effect.sync(() => {
+                if (!(step.value instanceof ProgramObject)) {
+                    throw new InterpreterRuntimeError("new Map(...) expects [key, value] pairs as entry objects.", node).as("TypeError");
+                }
+                target.map.set(getOwn(step.value, 0), getOwn(step.value, 1));
+            }));
+        }
+    });
+};
+const constructSet = (runner, init, node) => {
+    const target = new Values.Set();
+    if (init === undefined || init === null)
+        return Effect.succeed(target);
+    return Effect.gen(function* () {
+        const cursor = yield* runner.syncIterator(init, node);
+        if (cursor === undefined) {
+            throw new InterpreterRuntimeError("new Set(...) expects a synchronous iterable or no argument.", node).as("TypeError");
+        }
+        while (true) {
+            const step = yield* cursor.next;
+            if (step.done)
+                return target;
+            target.set.add(step.value);
+        }
+    });
+};
+export const mapGlobal = (runner) => new HostFunction({
+    name: "Map",
+    call: requiresNew("Map"),
+    construct: (args, node) => constructMap(runner, args[0], node),
+    instanceOf: (value) => value instanceof Values.Map,
+    members: { groupBy: groupBy(runner, "Map") },
+});
+export const setGlobal = (runner) => new HostFunction({
+    name: "Set",
+    call: requiresNew("Set"),
+    construct: (args, node) => constructSet(runner, args[0], node),
+    instanceOf: (value) => value instanceof Values.Set,
+});

package/dist/stdlib/console.d.ts

@@ -0,0 +1,3 @@
+import { HostNamespace } from "../interpreter/host.js";
+/** Captured console: every method appends one formatted line to `logs`. */
+export declare const consoleGlobal: (logs: Array<string>) => HostNamespace;

package/dist/stdlib/console.js

@@ -0,0 +1,137 @@
+import { toData, toProgram } from "../data.js";
+import { HostNamespace, sync } from "../interpreter/host.js";
+import { get, ownEntries, ProgramArray, ProgramObject } from "../interpreter/objects.js";
+import { containsOpaqueReference, containsRuntimeReference, isRuntimeReference } from "../interpreter/references.js";
+import { Values } from "../values.js";
+import { coerceToString } from "./value.js";
+const consoleMethods = ["log", "info", "debug", "warn", "error", "dir", "table"];
+/** Captured console: every method appends one formatted line to `logs`. */
+export const consoleGlobal = (logs) => new HostNamespace("console", Object.fromEntries(consoleMethods.map((name) => [
+    name,
+    sync(`console.${name}`, (args) => {
+        logs.push(formatConsoleMessage(name, args));
+        return undefined;
+    }),
+])));
+const MAX_CONSOLE_DEPTH = 32;
+const formatConsoleMessage = (name, args) => {
+    if (name === "dir")
+        return args.length === 0 ? "undefined" : formatConsoleArgument(args[0]);
+    if (name === "table")
+        return formatConsoleTable(args[0], args[1]);
+    const prefix = name === "warn" ? "[warn] " : name === "error" ? "[error] " : name === "debug" ? "[debug] " : "";
+    return `${prefix}${args.map((arg) => formatConsoleArgument(arg)).join(" ")}`;
+};
+const formatConsoleArgument = (value) => {
+    if (value === undefined)
+        return "undefined";
+    if (typeof value === "string")
+        return value;
+    return formatConsoleValue(value, new Set(), 0);
+};
+const formatConsoleValue = (value, seen, depth) => {
+    if (value === null || value === undefined)
+        return "null";
+    if (typeof value === "string")
+        return JSON.stringify(value);
+    if (typeof value === "number" || typeof value === "boolean")
+        return String(value);
+    if (typeof value !== "object")
+        return String(value);
+    if (value instanceof Values.Promise)
+        return "[Promise (await it to get its value)]";
+    if (value instanceof Values.Date)
+        return coerceToString(value);
+    if (value instanceof Values.RegExp)
+        return coerceToString(value);
+    if (value instanceof Values.URL)
+        return coerceToString(value);
+    if (value instanceof Values.URLSearchParams)
+        return coerceToString(value);
+    if (depth > MAX_CONSOLE_DEPTH)
+        return "...";
+    if (seen.has(value))
+        return "[Circular]";
+    if (value instanceof Values.Map) {
+        seen.add(value);
+        try {
+            const entries = Array.from(value.map.entries(), ([key, item]) => new ProgramArray([key, item]));
+            return `Map(${value.map.size}) ${formatConsoleValue(new ProgramArray(entries), seen, depth + 1)}`;
+        }
+        finally {
+            seen.delete(value);
+        }
+    }
+    if (value instanceof Values.Set) {
+        seen.add(value);
+        try {
+            return `Set(${value.set.size}) ${formatConsoleValue(new ProgramArray([...value.set.values()]), seen, depth + 1)}`;
+        }
+        finally {
+            seen.delete(value);
+        }
+    }
+    if (isRuntimeReference(value))
+        return "[opaque reference]";
+    seen.add(value);
+    try {
+        if (value instanceof ProgramArray) {
+            return `[${value.items.map((item) => formatConsoleValue(item, seen, depth + 1)).join(",")}]`;
+        }
+        if (!(value instanceof ProgramObject))
+            return "[object Object]";
+        return `{${ownEntries(value)
+            .map(([key, item]) => `${JSON.stringify(key)}:${formatConsoleValue(item, seen, depth + 1)}`)
+            .join(",")}}`;
+    }
+    finally {
+        seen.delete(value);
+    }
+};
+const formatConsoleTable = (value, columnsArgument) => {
+    if (value === undefined)
+        return "undefined";
+    if (containsOpaqueReference(value))
+        return "[opaque reference]";
+    const data = toProgram(value, "console.table argument");
+    const columns = consoleTableColumns(columnsArgument);
+    const rows = consoleTableRows(data, columns);
+    const keys = columns ?? Array.from(new Set(rows.flatMap((row) => Object.keys(row.values))));
+    const header = ["(index)", ...keys].join("\t");
+    return [
+        header,
+        ...rows.map((row) => [row.index, ...keys.map((key) => formatConsoleTableCell(row.values[key]))].join("\t")),
+    ].join("\n");
+};
+const consoleTableColumns = (value) => {
+    if (value === undefined)
+        return undefined;
+    if (containsRuntimeReference(value))
+        return undefined;
+    const columns = toData(value, "console.table columns", "result");
+    return Array.isArray(columns) ? columns.map((column) => String(column)) : undefined;
+};
+const consoleTableRows = (data, columns) => {
+    if (data instanceof ProgramArray) {
+        return data.items.map((item, index) => ({ index: String(index), values: consoleTableValues(item, columns) }));
+    }
+    if (data instanceof ProgramObject) {
+        return ownEntries(data).map(([index, item]) => ({ index, values: consoleTableValues(item, columns) }));
+    }
+    return [{ index: "0", values: { Value: data } }];
+};
+const consoleTableValues = (value, columns) => {
+    if (value instanceof ProgramObject && !(value instanceof ProgramArray)) {
+        if (columns !== undefined)
+            return Object.fromEntries(columns.map((column) => [column, get(value, column)]));
+        return Object.fromEntries(ownEntries(value));
+    }
+    return { Value: value };
+};
+const formatConsoleTableCell = (value) => {
+    if (value === undefined)
+        return "";
+    if (typeof value === "string")
+        return value;
+    return formatConsoleValue(value, new Set(), 0);
+};

package/dist/stdlib/date.d.ts

@@ -0,0 +1,8 @@
+import { HostFunction } from "../interpreter/host.js";
+import { type AstNode } from "../interpreter/model.js";
+import { type Runner } from "../interpreter/runner.js";
+import { Values } from "../values.js";
+export declare const dateMethods: Set<string>;
+export declare const dateGlobal: <R>(runner: Runner<R>) => HostFunction<R>;
+export declare const dateSetterArgumentCount: (name: string) => number | undefined;
+export declare const invokeDateMethod: (value: Values.Date, name: string, args: Array<number>, node: AstNode, initialTime?: number) => unknown;