@moikapy/origen-zero 0.1.0

package/dist/types-Dc-cDRjG.d.ts

@@ -0,0 +1,200 @@
+/**
+ * @moikapy/origen-zero — Type definitions
+ *
+ * All TypeScript interfaces and types for the ZeroLang → Origen bridge.
+ */
+/**
+ * The compiler interface. Both CLI and HTTP implementations satisfy this.
+ * Use ZeroCompiler for Node/Bun (subprocess), ZeroHTTPCompiler for
+ * Cloudflare Workers (HTTP fetch to a Zero service).
+ */
+interface ZeroCompilerLike {
+    check(source: string | ZeroSourceFile): Promise<ZeroCheckResult>;
+    graph(source: string | ZeroSourceFile): Promise<ZeroGraphResult>;
+    size(source: string | ZeroSourceFile): Promise<ZeroSizeResult>;
+    fix(source: string | ZeroSourceFile): Promise<ZeroFixResult>;
+    build(source: string | ZeroSourceFile, options?: ZeroBuildOptions): Promise<ZeroBuildResult>;
+    explain(diagnosticCode: string): Promise<string>;
+}
+/** Configuration for the local ZeroCompiler (subprocess-based). */
+interface ZeroCompilerConfig {
+    /** Path to zero CLI binary. Default: "zero" (must be on PATH) */
+    binaryPath?: string;
+    /** Working directory for compilation. Default: process.cwd() */
+    workingDir?: string;
+    /** Timeout for compiler invocations in ms. Default: 30000 */
+    timeout?: number;
+}
+/** Configuration for ZeroHTTPCompiler (fetch-based, works in Workers). */
+interface ZeroHTTPCompilerConfig {
+    /** Base URL of the Zero compiler service. Required. */
+    endpoint: string;
+    /** Authorization header value (e.g., "Bearer <token>"). Optional. */
+    apiKey?: string;
+    /** Custom headers to include in every request. Optional. */
+    headers?: Record<string, string>;
+    /** Timeout for HTTP requests in ms. Default: 30000 */
+    timeout?: number;
+    /** Custom fetch function. Defaults to globalThis.fetch. Useful for testing. */
+    fetch?: typeof globalThis.fetch;
+}
+/** A Zero source file: either a path on disk or inline content. */
+interface ZeroSourceFile {
+    /** File path (relative to workingDir). Used for error reporting. */
+    path: string;
+    /** Source content. If omitted, reads from disk at path. */
+    content?: string;
+}
+/** A single diagnostic from the Zero compiler. */
+interface ZeroDiagnostic {
+    /** Machine-readable code, e.g. "NAM003", "TYP001" */
+    code: string;
+    severity: "error" | "warning" | "info";
+    message: string;
+    line: number;
+    column?: number;
+    /** Repair metadata — structured suggestion from the compiler */
+    repair?: {
+        id: string;
+        suggestion?: string;
+    };
+}
+/** Result of `zero check --json`. */
+interface ZeroCheckResult {
+    ok: boolean;
+    diagnostics: ZeroDiagnostic[];
+    /** Raw JSON output from zero check --json */
+    raw: Record<string, unknown>;
+}
+/** Result of `zero graph --json`. */
+interface ZeroGraphResult {
+    ok: boolean;
+    /** Parsed symbol list from the graph output. */
+    symbols: ZeroGraphSymbol[];
+    /** Parsed function list from the graph output. */
+    functions: ZeroGraphFunction[];
+    /** Raw JSON output from zero graph. */
+    raw: Record<string, unknown>;
+}
+interface ZeroGraphSymbol {
+    name: string;
+    module: string;
+    kind: string;
+    public: boolean;
+    effects: string[];
+}
+interface ZeroGraphFunction {
+    name: string;
+    kind: string;
+    public: boolean;
+    params: number;
+    returnType: string;
+    raises: boolean;
+    effects: string[];
+    allocationBehavior: string;
+    targetSupport: {
+        status: string;
+        missingCapabilities: string[];
+    };
+}
+/** Result of `zero size --json`. */
+interface ZeroSizeResult {
+    ok: boolean;
+    /** Structured size/runtime analysis from the real CLI. */
+    portableRuntime?: ZeroPortableRuntime;
+    /** Raw JSON output from zero size. */
+    raw: Record<string, unknown>;
+}
+interface ZeroPortableRuntime {
+    target: string;
+    runtimeKind: string;
+    portable: boolean;
+    imports: {
+        functionCount: number;
+        functions: string[];
+        module: string | null;
+    };
+    memoryFloor?: {
+        floorBytes: number;
+        minimumPages: number;
+    };
+    capabilityRestrictions?: {
+        filesystem?: string;
+    };
+}
+/** Result of `zero fix --plan --json`. */
+interface ZeroFixResult {
+    ok: boolean;
+    fixes: ZeroFixSuggestion[];
+    raw: Record<string, unknown>;
+}
+/** A single repair suggestion from `zero fix --plan --json`. */
+interface ZeroFixSuggestion {
+    /** Fix identifier, e.g. "repair-syntax". */
+    id: string;
+    /** Associated diagnostic code, e.g. "PAR100". */
+    diagnosticCode: string;
+    /** Safety level: "safe" | "requires-human-review". */
+    safety: string;
+    /** Human-readable summary of the fix. */
+    summary: string;
+    /** Whether the fix can be applied automatically. */
+    appliesEdits: boolean;
+}
+/** Result of `zero build`. */
+interface ZeroBuildResult {
+    ok: boolean;
+    /** Path to compiled output */
+    outputPath?: string;
+    diagnostics: ZeroDiagnostic[];
+}
+/** Options for `zero build`. */
+interface ZeroBuildOptions {
+    /** Output path for compiled binary/wasm. */
+    out?: string;
+    /** Target triple, e.g., "linux-musl-x64" or "wasm32-web". */
+    target?: string;
+    /** Emit format: "exe" (default), "object", or "wasm". */
+    emit?: "exe" | "object" | "wasm";
+}
+/** Configuration for registering a Zero function as an OrigenTool. */
+interface ZeroToolConfig {
+    /** The Zero function to expose as a tool. */
+    functionName: string;
+    /** Human-readable description for the LLM. Required. */
+    description: string;
+    /** Execution mode for the compiled Zero program. */
+    execution: ZeroToolExecution;
+    /** Custom parameter schema for the OrigenTool. */
+    parameters?: Record<string, unknown>;
+    /** Origen-compatible Zod inputSchema. */
+    inputSchema?: unknown;
+    /** Zero compiler for verification before registration. Optional. */
+    compiler?: ZeroCompilerLike;
+    /** Whether to verify the tool compiles cleanly before registering. Default: true */
+    verify?: boolean;
+}
+/** How a Zero tool executes. Exactly one mode must be set. */
+type ZeroToolExecution = {
+    mode: "subprocess";
+    executablePath: string;
+} | {
+    mode: "http";
+    endpoint: string;
+    apiKey?: string;
+    headers?: Record<string, string>;
+    fetch?: typeof globalThis.fetch;
+} | {
+    mode: "wasm";
+    wasmBytes: ArrayBuffer | WebAssembly.Module;
+};
+/** Result of compileAndRegister on success. */
+interface ZeroToolRegistrationSuccess {
+    tools: unknown[];
+}
+/** Result of compileAndRegister on failure. */
+interface ZeroToolRegistrationFailure {
+    errors: ZeroDiagnostic[];
+}
+
+export type { ZeroBuildOptions as Z, ZeroBuildResult as a, ZeroCheckResult as b, ZeroCompilerConfig as c, ZeroCompilerLike as d, ZeroDiagnostic as e, ZeroFixResult as f, ZeroFixSuggestion as g, ZeroGraphResult as h, ZeroHTTPCompilerConfig as i, ZeroSizeResult as j, ZeroSourceFile as k, ZeroToolConfig as l, ZeroToolExecution as m, ZeroToolRegistrationFailure as n, ZeroToolRegistrationSuccess as o };

package/dist/wasi-runtime.d.ts

@@ -0,0 +1,41 @@
+/**
+ * @moikapy/origen-zero — WASI runtime for Zero WASM modules
+ *
+ * Full WASI snapshot preview 1 implementation matching the Zero CLI's
+ * wasm-runtime-smoke.mjs. Supports: args, env, fd_read, fd_write,
+ * path_open, fd_close, fd_filestat_get, fd_readdir, path_mkdir,
+ * path_remove_directory, path_unlink_file, path_rename.
+ *
+ * Zero programs that use World (stdout/stderr), std.args, std.env,
+ * or std.fs (Fs resource) all route through these WASI imports.
+ *
+ * Uses only Uint8Array/TextEncoder/TextDecoder — no Node.js Buffer.
+ * Works in Cloudflare Workers, browsers, and Node.js.
+ */
+interface ZeroWASIRuntimeConfig {
+    /** Command-line args (default: ["zero"]). */
+    args?: string[];
+    /** Environment variables (default: []). Format: "KEY=VALUE". */
+    env?: string[];
+    /** Pre-populated files: Map<path, Uint8Array>. */
+    files?: Map<string, Uint8Array>;
+    /** Pre-populated directories. */
+    dirs?: Set<string>;
+}
+interface ZeroWASIRuntime {
+    /** WASI imports to pass to WebAssembly.instantiate(). */
+    imports: Record<string, Record<string, WebAssembly.ImportValue>>;
+    /** Get all captured stdout output. */
+    getStdout(): string;
+    /** Get all captured stderr output. */
+    getStderr(): string;
+    /** Get the virtual filesystem state. */
+    getFiles(): Map<string, Uint8Array>;
+    /** Get the virtual directory set. */
+    getDirs(): Set<string>;
+    /** Set the instance reference (called after instantiation). */
+    setInstance(instance: WebAssembly.Instance): void;
+}
+declare function createZeroWASIRuntime(config?: ZeroWASIRuntimeConfig): ZeroWASIRuntime;
+
+export { type ZeroWASIRuntime, type ZeroWASIRuntimeConfig, createZeroWASIRuntime };

package/dist/wasi-runtime.js

@@ -0,0 +1,7 @@
+import {
+  createZeroWASIRuntime
+} from "./chunk-QUQPQFU6.js";
+export {
+  createZeroWASIRuntime
+};
+//# sourceMappingURL=wasi-runtime.js.map

package/dist/wasi-runtime.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/wasm-tool.d.ts

@@ -0,0 +1,54 @@
+import { OrigenTool } from '@moikapy/origen';
+import { ZeroWASIRuntimeConfig } from './wasi-runtime.js';
+
+/**
+ * @moikapy/origen-zero — WASM tool execution
+ *
+ * Executes compiled Zero WASM modules in-process via WebAssembly.instantiate().
+ * Works in Cloudflare Workers, browsers, and Node.js — no subprocess needed.
+ *
+ * WASM modules compiled from Zero export:
+ *   - `memory`: WebAssembly.Memory (1+ pages, 64KB each)
+ *   - `main()`: Program entry point (returns i32, 0 = success)
+ * They import WASI snapshot preview 1 functions for I/O.
+ *
+ * For Origen tool invocation, args are passed via WASI (args_get/args_sizes_get)
+ * for wasm32-wasi targets, or encoded to memory for wasm32-web targets that
+ * read from environ.
+ */
+
+interface ZeroWASMToolConfig {
+    /** Tool function name. */
+    functionName: string;
+    /** Human-readable description for the LLM. */
+    description: string;
+    /** Compiled WASM module bytes. */
+    wasmBytes: ArrayBuffer | WebAssembly.Module;
+    /** Optional pre-instantiated module cache (for Workers global scope). */
+    module?: WebAssembly.Module;
+    /** WASI runtime config (args, env, files, dirs). */
+    runtimeConfig?: ZeroWASIRuntimeConfig;
+    /** Custom parameter schema for the OrigenTool. */
+    parameters?: Record<string, unknown>;
+}
+/**
+ * Create an OrigenTool that executes a compiled Zero WASM module in-process.
+ *
+ * The tool instantiates the WASM module with a full WASI runtime,
+ * passes args via WASI args_get, calls the exported main() function,
+ * and returns the stdout output.
+ *
+ * Works in Cloudflare Workers, browsers, and Node.js.
+ */
+declare function createZeroWASMTool(config: ZeroWASMToolConfig): OrigenTool;
+/**
+ * Create multiple tools from a single Zero WASM module.
+ * If the module exports a single main(), creates one tool.
+ * Future: parse module exports to discover multiple functions.
+ */
+declare function createZeroWASMTools(wasmBytes: ArrayBuffer | WebAssembly.Module, options?: {
+    descriptions?: Record<string, string>;
+    parameters?: Record<string, Record<string, unknown>>;
+}): OrigenTool[];
+
+export { type ZeroWASMToolConfig, createZeroWASMTool, createZeroWASMTools };

package/dist/wasm-tool.js

@@ -0,0 +1,10 @@
+import {
+  createZeroWASMTool,
+  createZeroWASMTools
+} from "./chunk-PJFVSOEI.js";
+import "./chunk-QUQPQFU6.js";
+export {
+  createZeroWASMTool,
+  createZeroWASMTools
+};
+//# sourceMappingURL=wasm-tool.js.map

package/dist/wasm-tool.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@moikapy/origen-zero",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "Bridge package connecting Origen agents to ZeroLang compiler and runtime",
+  "license": "MIT",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./tools": {
+      "types": "./dist/tools.d.ts",
+      "import": "./dist/tools.js",
+      "default": "./dist/tools.js"
+    },
+    "./compiler": {
+      "types": "./dist/compiler.d.ts",
+      "import": "./dist/compiler.js",
+      "default": "./dist/compiler.js"
+    },
+    "./http-compiler": {
+      "types": "./dist/http-compiler.d.ts",
+      "import": "./dist/http-compiler.js",
+      "default": "./dist/http-compiler.js"
+    },
+    "./wasm-tool": {
+      "types": "./dist/wasm-tool.d.ts",
+      "import": "./dist/wasm-tool.js",
+      "default": "./dist/wasm-tool.js"
+    },
+    "./wasi-runtime": {
+      "types": "./dist/wasi-runtime.d.ts",
+      "import": "./dist/wasi-runtime.js",
+      "default": "./dist/wasi-runtime.js"
+    }
+  },
+  "files": [
+    "dist/"
+  ],
+  "scripts": {
+    "build": "tsup --no-dts --no-sourcemap",
+    "build:release": "tsup",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "bun run build:release"
+  },
+  "peerDependencies": {
+    "@moikapy/origen": "^0.6.0"
+  },
+  "dependencies": {
+    "zod": "^4.4.2"
+  },
+  "devDependencies": {
+    "@moikapy/origen": "^0.6.0",
+    "tsup": "^8.5.1",
+    "typescript": "^5",
+    "vitest": "^3"
+  }
+}