@opencode-ai/codemode 0.0.0-beta-17492

package/dist/tool-schema.js

@@ -0,0 +1,213 @@
+import { JsonPointer, Schema } from "effect";
+const isEffectSchema = (schema) => Schema.isSchema(schema);
+const renderLiteral = (value) => JSON.stringify(value) ?? "unknown";
+export const identifierSegment = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+const renderKey = (name) => (identifierSegment.test(name) ? name : JSON.stringify(name));
+const effectNumberSentinel = (schema) => schema.type === "string" &&
+    Array.isArray(schema.enum) &&
+    schema.enum.length === 1 &&
+    (schema.enum[0] === "NaN" || schema.enum[0] === "Infinity" || schema.enum[0] === "-Infinity");
+const intersection = (members) => {
+    const concrete = members.filter((member) => member !== "unknown");
+    if (concrete.length === 0)
+        return "unknown";
+    if (concrete.length === 1)
+        return concrete[0];
+    return concrete.map((member) => (member.includes(" | ") ? `(${member})` : member)).join(" & ");
+};
+const MAX_RENDER_DEPTH = 8;
+const hasUnresolvedRef = (schema, definitions, seen = new Set(), visited = new Set()) => {
+    if (visited.has(schema))
+        return false;
+    const nextVisited = new Set([...visited, schema]);
+    if (schema.$ref !== undefined) {
+        const segment = schema.$ref.match(/^#\/(?:\$defs|definitions)\/([^/]+)$/)?.[1];
+        const name = segment === undefined ? undefined : JsonPointer.unescapeToken(segment);
+        if (name === undefined || definitions[name] === undefined || seen.has(name))
+            return true;
+        if (hasUnresolvedRef(definitions[name], definitions, new Set([...seen, name]), nextVisited))
+            return true;
+    }
+    return [
+        ...(schema.anyOf ?? []),
+        ...(schema.oneOf ?? []),
+        ...(schema.allOf ?? []),
+        ...Object.values(schema.properties ?? {}),
+        ...(schema.items === undefined ? [] : [schema.items]),
+        ...(typeof schema.additionalProperties === "object" ? [schema.additionalProperties] : []),
+    ].some((item) => hasUnresolvedRef(item, definitions, seen, nextVisited));
+};
+const docTags = (schema) => {
+    const tags = [];
+    if (schema.deprecated === true)
+        tags.push("@deprecated");
+    if (schema.default !== undefined) {
+        try {
+            const rendered = JSON.stringify(schema.default);
+            if (rendered !== undefined)
+                tags.push(`@default ${rendered}`);
+        }
+        catch { }
+    }
+    if (typeof schema.format === "string")
+        tags.push(`@format ${schema.format}`);
+    if (typeof schema.minItems === "number")
+        tags.push(`@minItems ${schema.minItems}`);
+    if (typeof schema.maxItems === "number")
+        tags.push(`@maxItems ${schema.maxItems}`);
+    return tags;
+};
+// Neutralize `*\/` so model-provided schema text cannot terminate generated documentation.
+const jsdoc = (description, tags, pad) => {
+    const lines = [...(description === undefined ? [] : description.split("\n")), ...tags].map((line) => line.replaceAll("*/", "* /").replace(/\s+$/, ""));
+    while (lines.length > 0 && lines[0].trim() === "")
+        lines.shift();
+    while (lines.length > 0 && lines[lines.length - 1].trim() === "")
+        lines.pop();
+    if (lines.length === 0)
+        return "";
+    if (lines.length === 1)
+        return `${pad}/** ${lines[0]} */\n`;
+    const body = lines.map((line) => `${pad} *${line === "" ? "" : ` ${line}`}`).join("\n");
+    return `${pad}/**\n${body}\n${pad} */\n`;
+};
+const renderSchema = (schema, ctx, depth = 0, seen = new Set()) => {
+    if (depth > MAX_RENDER_DEPTH)
+        return "unknown";
+    const nested = schema.definitions === undefined && schema.$defs === undefined
+        ? ctx
+        : { ...ctx, definitions: { ...ctx.definitions, ...(schema.definitions ?? {}), ...(schema.$defs ?? {}) } };
+    if (schema.$ref) {
+        const segment = schema.$ref.match(/^#\/(?:\$defs|definitions)\/([^/]+)$/)?.[1];
+        const name = segment === undefined ? undefined : JsonPointer.unescapeToken(segment);
+        if (!name || !nested.definitions[name] || seen.has(name))
+            return "unknown";
+        return intersection([
+            renderSchema(nested.definitions[name], nested, depth, new Set([...seen, name])),
+            renderSchema({ ...schema, $ref: undefined }, nested, depth + 1, seen),
+        ]);
+    }
+    if (schema.const !== undefined)
+        return renderLiteral(schema.const);
+    if (schema.enum)
+        return schema.enum.map(renderLiteral).join(" | ");
+    const alternatives = schema.anyOf ?? schema.oneOf;
+    if (alternatives) {
+        if (alternatives.some((item) => item.type === "number") &&
+            alternatives.every((item) => item.type === "number" || effectNumberSentinel(item)))
+            return "number";
+        if (alternatives.length === 2 &&
+            alternatives[0]?.type === "object" &&
+            alternatives[0].properties === undefined &&
+            alternatives[1]?.type === "array" &&
+            alternatives[1].items === undefined) {
+            return "{}";
+        }
+        const members = alternatives.map((item) => renderSchema(item, nested, depth + 1, seen));
+        if (members.some((member) => member === "unknown"))
+            return "unknown";
+        return intersection([
+            members.join(" | "),
+            renderSchema({ ...schema, anyOf: undefined, oneOf: undefined }, nested, depth + 1, seen),
+        ]);
+    }
+    if (schema.allOf) {
+        const members = schema.allOf.map((item) => renderSchema(item, nested, depth + 1, seen));
+        if (schema.allOf.some((item) => hasUnresolvedRef(item, nested.definitions)))
+            return "unknown";
+        return intersection([renderSchema({ ...schema, allOf: undefined }, nested, depth + 1, seen), ...members]);
+    }
+    if (Array.isArray(schema.type)) {
+        return schema.type.map((item) => renderSchema({ ...schema, type: item }, nested, depth + 1, seen)).join(" | ");
+    }
+    if (schema.type === "string")
+        return "string";
+    if (schema.type === "number" || schema.type === "integer")
+        return "number";
+    if (schema.type === "boolean")
+        return "boolean";
+    if (schema.type === "null")
+        return "null";
+    if (schema.type === "array")
+        return `Array<${renderSchema(schema.items ?? {}, nested, depth + 1, seen)}>`;
+    if (schema.type === "object" || schema.properties) {
+        const required = new Set(schema.required ?? []);
+        const properties = Object.entries(schema.properties ?? {});
+        const additional = schema.additionalProperties;
+        const indexType = additional && typeof additional === "object" ? renderSchema(additional, nested, depth + 1, seen) : undefined;
+        const field = ([name, value]) => `${renderKey(name)}${required.has(name) ? "" : "?"}: ${renderSchema(value, nested, depth + 1, seen)}`;
+        if (!ctx.pretty) {
+            const fields = properties.map(field);
+            if (indexType !== undefined)
+                fields.push(`[key: string]: ${indexType}`);
+            return fields.length === 0 ? "{}" : `{ ${fields.join("; ")} }`;
+        }
+        if (properties.length === 0 && indexType === undefined)
+            return "{}";
+        const pad = "  ".repeat(depth + 1);
+        const lines = properties.map((entry) => `${jsdoc(entry[1].description, docTags(entry[1]), pad)}${pad}${field(entry)},`);
+        if (indexType !== undefined)
+            lines.push(`${pad}[key: string]: ${indexType},`);
+        return `{\n${lines.join("\n")}\n${"  ".repeat(depth)}}`;
+    }
+    return "unknown";
+};
+export const toTypeScript = (schema, decoded = false, pretty = false) => {
+    try {
+        const visible = decoded ? Schema.toType(schema) : schema;
+        const document = Schema.toJsonSchemaDocument(visible);
+        return renderSchema(document.schema, { definitions: document.definitions ?? {}, pretty });
+    }
+    catch {
+        return "unknown";
+    }
+};
+export const jsonSchemaToTypeScript = (schema, pretty = false) => {
+    try {
+        return renderSchema(schema, { definitions: { ...(schema.definitions ?? {}), ...(schema.$defs ?? {}) }, pretty });
+    }
+    catch {
+        return "unknown";
+    }
+};
+export const inputProperties = (tool) => {
+    try {
+        const document = isEffectSchema(tool.input)
+            ? Schema.toJsonSchemaDocument(tool.input)
+            : {
+                schema: tool.input,
+                definitions: { ...(tool.input.definitions ?? {}), ...(tool.input.$defs ?? {}) },
+            };
+        const definitions = document.definitions ?? {};
+        let schema = document.schema;
+        if (schema.$ref !== undefined) {
+            const segment = schema.$ref.match(/^#\/(?:\$defs|definitions)\/([^/]+)$/)?.[1];
+            const name = segment === undefined ? undefined : JsonPointer.unescapeToken(segment);
+            const resolved = name === undefined ? undefined : definitions[name];
+            if (resolved === undefined)
+                return [];
+            schema = resolved;
+        }
+        const required = new Set(schema.required ?? []);
+        return Object.entries(schema.properties ?? {}).map(([name, value]) => ({
+            name,
+            description: typeof value.description === "string" ? value.description : undefined,
+            required: required.has(name),
+        }));
+    }
+    catch {
+        return [];
+    }
+};
+export const inputTypeScript = (tool, pretty = false) => isEffectSchema(tool.input) ? toTypeScript(tool.input, false, pretty) : jsonSchemaToTypeScript(tool.input, pretty);
+export const outputTypeScript = (tool, pretty = false) => tool.output === undefined
+    ? "void"
+    : isEffectSchema(tool.output)
+        ? toTypeScript(tool.output, true, pretty)
+        : jsonSchemaToTypeScript(tool.output, pretty);
+export const decodeInput = (tool, value) => isEffectSchema(tool.input) ? Schema.decodeUnknownSync(tool.input)(value) : value;
+export const decodeOutput = (tool, value) => tool.output === undefined
+    ? undefined
+    : isEffectSchema(tool.output)
+        ? Schema.decodeUnknownSync(tool.output)(value)
+        : value;

package/dist/tool.d.ts

@@ -0,0 +1,55 @@
+import { Effect, Schema } from "effect";
+/**
+ * JSON Schema subset for model-visible signatures. CodeMode does not validate values against
+ * these schemas.
+ */
+export type JsonSchema = {
+    readonly type?: string | ReadonlyArray<string>;
+    readonly enum?: ReadonlyArray<unknown>;
+    readonly const?: unknown;
+    readonly anyOf?: ReadonlyArray<JsonSchema>;
+    readonly oneOf?: ReadonlyArray<JsonSchema>;
+    readonly allOf?: ReadonlyArray<JsonSchema>;
+    readonly properties?: Readonly<Record<string, JsonSchema>>;
+    readonly required?: ReadonlyArray<string>;
+    readonly items?: JsonSchema;
+    readonly additionalProperties?: boolean | JsonSchema;
+    readonly description?: string;
+    readonly default?: unknown;
+    readonly format?: string;
+    readonly deprecated?: boolean;
+    readonly minItems?: number;
+    readonly maxItems?: number;
+    readonly $ref?: string;
+    readonly $defs?: Readonly<Record<string, JsonSchema>>;
+    readonly definitions?: Readonly<Record<string, JsonSchema>>;
+};
+/** Either a validating Effect Schema or a render-only JSON Schema document. */
+export type SchemaType = Schema.Decoder<unknown> | JsonSchema;
+/** Executable tool exposed through CodeMode's `tools` object. */
+export type Tool<R = never> = {
+    readonly _tag: "CodeModeTool";
+    readonly description: string;
+    readonly input: SchemaType;
+    readonly output: SchemaType | undefined;
+    readonly execute: (input: unknown) => Effect.Effect<unknown, unknown, R>;
+};
+type InputType<S> = S extends Schema.Decoder<unknown> ? S["Type"] : unknown;
+type ResultType<S> = S extends undefined ? void : S extends Schema.Decoder<unknown> ? S["Encoded"] : unknown;
+/** Options for declaring one CodeMode tool. */
+export type Options<I extends SchemaType, O extends SchemaType | undefined, R = never> = {
+    readonly description: string;
+    readonly input: I;
+    readonly output?: O;
+    readonly execute: (input: InputType<I>) => Effect.Effect<ResultType<O>, unknown, R>;
+};
+export declare const isTool: <R = never>(value: unknown) => value is Tool<R>;
+/**
+ * Declares one schema-described tool available to a CodeMode program through `tools.*`.
+ *
+ * Effect Schemas validate values; JSON Schemas only shape the model-visible signature.
+ * Without `output`, results are exposed as `void`. Hosts remain responsible for authorization
+ * and durable side effects.
+ */
+export declare const make: <I extends SchemaType, const O extends SchemaType | undefined = undefined, R = never>(options: Options<I, O, R>) => Tool<R>;
+export {};

package/dist/tool.js

@@ -0,0 +1,21 @@
+import { Effect, Schema } from "effect";
+// Object.hasOwn: an inherited _tag must not classify a namespace as a Tool.
+export const isTool = (value) => typeof value === "object" &&
+    value !== null &&
+    "_tag" in value &&
+    Object.hasOwn(value, "_tag") &&
+    value._tag === "CodeModeTool";
+/**
+ * Declares one schema-described tool available to a CodeMode program through `tools.*`.
+ *
+ * Effect Schemas validate values; JSON Schemas only shape the model-visible signature.
+ * Without `output`, results are exposed as `void`. Hosts remain responsible for authorization
+ * and durable side effects.
+ */
+export const make = (options) => ({
+    _tag: "CodeModeTool",
+    description: options.description,
+    input: options.input,
+    output: options.output,
+    execute: (input) => options.execute(input),
+});

package/dist/tools.d.ts

@@ -0,0 +1,4 @@
+import type { Tool } from "./tool.js";
+export type Tools<R = never> = {
+    readonly [name: string]: Tool<R> | Tools<R>;
+};

package/dist/tools.js

@@ -0,0 +1 @@
+export {};

package/dist/values.d.ts

@@ -0,0 +1,31 @@
+import type { Fiber } from "effect";
+export declare class CodeModePromise {
+    readonly fiber: Fiber.Fiber<unknown, unknown>;
+    constructor(fiber: Fiber.Fiber<unknown, unknown>);
+}
+export declare class CodeModeDate {
+    time: number;
+    constructor(time: number);
+}
+export declare class CodeModeRegExp {
+    readonly regex: RegExp;
+    constructor(pattern: string, flags: string);
+    get lastIndex(): unknown;
+    set lastIndex(value: unknown);
+}
+export declare class CodeModeMap {
+    readonly map: Map<unknown, unknown>;
+}
+export declare class CodeModeSet {
+    readonly set: Set<unknown>;
+}
+export declare class CodeModeURLSearchParams {
+    readonly params: URLSearchParams;
+    constructor(params: URLSearchParams);
+}
+export declare class CodeModeURL {
+    readonly url: URL;
+    readonly searchParams: CodeModeURLSearchParams;
+    constructor(url: URL);
+}
+export declare const isCodeModeValue: (value: unknown) => value is CodeModeDate | CodeModeRegExp | CodeModeMap | CodeModeSet | CodeModeURL | CodeModeURLSearchParams;

package/dist/values.js

@@ -0,0 +1,50 @@
+export class CodeModePromise {
+    fiber;
+    constructor(fiber) {
+        this.fiber = fiber;
+    }
+}
+export class CodeModeDate {
+    time;
+    constructor(time) {
+        this.time = time;
+    }
+}
+export class CodeModeRegExp {
+    regex;
+    constructor(pattern, flags) {
+        this.regex = new RegExp(pattern, flags);
+    }
+    get lastIndex() {
+        return Reflect.get(this.regex, "lastIndex");
+    }
+    set lastIndex(value) {
+        Reflect.set(this.regex, "lastIndex", value);
+    }
+}
+export class CodeModeMap {
+    map = new Map();
+}
+export class CodeModeSet {
+    set = new Set();
+}
+export class CodeModeURLSearchParams {
+    params;
+    constructor(params) {
+        this.params = params;
+    }
+}
+export class CodeModeURL {
+    url;
+    searchParams;
+    constructor(url) {
+        this.url = url;
+        this.searchParams = new CodeModeURLSearchParams(url.searchParams);
+    }
+}
+export const isCodeModeValue = (value) => value instanceof CodeModeDate ||
+    value instanceof CodeModeRegExp ||
+    value instanceof CodeModeMap ||
+    value instanceof CodeModeSet ||
+    value instanceof CodeModeURL ||
+    value instanceof CodeModeURLSearchParams;

package/package.json

@@ -0,0 +1,46 @@
+{
+  "$schema": "https://json.schemastore.org/package.json",
+  "name": "@opencode-ai/codemode",
+  "version": "0.0.0-beta-17492",
+  "description": "Effect-native confined code execution over schema-described tools",
+  "type": "module",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/anomalyco/opencode.git",
+    "directory": "packages/codemode"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "imports": {
+    "#transpile": {
+      "workerd": "./src/interpreter/transpile.workerd.ts",
+      "default": "./src/interpreter/transpile.node.ts"
+    }
+  },
+  "scripts": {
+    "build": "bun run script/build.ts",
+    "typecheck": "tsgo --noEmit",
+    "test": "bun test"
+  },
+  "dependencies": {
+    "acorn": "8.15.0",
+    "effect": "4.0.0-beta.101",
+    "typescript": "5.8.2"
+  },
+  "devDependencies": {
+    "@tsconfig/bun": "1.0.9",
+    "@types/bun": "1.3.13",
+    "@typescript/native-preview": "7.0.0-dev.20251207.1"
+  }
+}