effect-codemode 0.0.1 → 0.1.0-beta.0

package/dist/codemode.d.ts

@@ -0,0 +1,22 @@
+import { Runtime } from "effect";
+import type { ExecuteResult, Executor, ExecutorOptions, ToolDescriptor, ToolMiddleware } from "./types";
+export interface CodemodeTool {
+    /** The tool name for MCP registration */
+    readonly name: string;
+    /** Full description including generated TS declarations */
+    readonly description: string;
+    /** The generated TypeScript declarations (for debugging/display) */
+    readonly declarations: string;
+    /** Execute LLM-generated code, optionally streaming console output */
+    readonly execute: (code: string, options?: ExecutorOptions) => Promise<ExecuteResult>;
+}
+/**
+ * Creates the codemode tool by wiring together:
+ * - Type generation (for the LLM prompt)
+ * - The fn table (Effect services -> plain async functions)
+ * - The executor (sandbox)
+ *
+ * Accepts sandbox tools only — confirmation tools should be split out before calling.
+ */
+export declare function createCodemodeTool<R>(sandboxTools: Record<string, ToolDescriptor>, runtime: Runtime.Runtime<R>, executor: Executor, serviceStatuses?: string, middleware?: ReadonlyArray<ToolMiddleware>, groupNames?: ReadonlyArray<string>): CodemodeTool;
+//# sourceMappingURL=codemode.d.ts.map

package/dist/codemode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codemode.d.ts","sourceRoot":"","sources":["../src/codemode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,QAAQ,CAAA;AAIhC,OAAO,KAAK,EAAE,aAAa,EAAE,QAAQ,EAAE,eAAe,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAGvG,MAAM,WAAW,YAAY;IAC3B,yCAAyC;IACzC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,2DAA2D;IAC3D,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;IAC5B,oEAAoE;IACpE,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;IAC7B,sEAAsE;IACtE,QAAQ,CAAC,OAAO,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,eAAe,KAAK,OAAO,CAAC,aAAa,CAAC,CAAA;CACtF;AAoCD;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAClC,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,EAC5C,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,EAC3B,QAAQ,EAAE,QAAQ,EAClB,eAAe,CAAC,EAAE,MAAM,EACxB,UAAU,CAAC,EAAE,aAAa,CAAC,cAAc,CAAC,EAC1C,UAAU,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,GACjC,YAAY,CA+Fd"}

package/dist/executor-base.d.ts

@@ -0,0 +1,25 @@
+import type { Executor, ExecutorOptions } from "./types";
+/**
+ * Normalize user-provided code into a form suitable for `new Function()`.
+ *
+ * Uses acorn to parse the code as a module and determines the best wrapping:
+ * 1. Single ExpressionStatement that is an ArrowFunctionExpression -> call it directly
+ * 2. Body ends with an ExpressionStatement -> splice `return` before it, wrap in async IIFE
+ * 3. Otherwise -> wrap entire body in async IIFE
+ *
+ * Falls back to the regex heuristic if acorn parsing fails.
+ */
+export declare function normalizeCode(code: string): string;
+/**
+ * Build the sandbox globals object: console capture, network control, Effect modules, and tool fns.
+ */
+export declare function buildSandboxGlobals(fns: Record<string, (...args: Array<unknown>) => unknown>, options: ExecutorOptions | undefined, logs: string[]): Record<string, unknown>;
+/**
+ * Create an executor from a `runCode` function that handles the actual code execution mechanism.
+ *
+ * The `runCode` function receives the normalized code and sandbox globals, and must return
+ * a Promise of the raw result (before Effect detection). The shared infrastructure handles
+ * console capture, global injection, network blocking, Effect detection, timeout, and error handling.
+ */
+export declare function createBaseExecutor(runCode: (wrappedCode: string, globals: Record<string, unknown>) => Promise<unknown>): Executor;
+//# sourceMappingURL=executor-base.d.ts.map

package/dist/executor-base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"executor-base.d.ts","sourceRoot":"","sources":["../src/executor-base.ts"],"names":[],"mappings":"AAmBA,OAAO,KAAK,EAAiB,QAAQ,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AA+EvE;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAyClD;AAgDD;;GAEG;AACH,wBAAgB,mBAAmB,CACjC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,GAAG,IAAI,EAAE,KAAK,CAAC,OAAO,CAAC,KAAK,OAAO,CAAC,EACzD,OAAO,EAAE,eAAe,GAAG,SAAS,EACpC,IAAI,EAAE,MAAM,EAAE,GACb,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAkDzB;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,CAAC,WAAW,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,OAAO,CAAC,OAAO,CAAC,GACnF,QAAQ,CAkCV"}

package/dist/executor.d.ts

@@ -0,0 +1,18 @@
+import { Context, Layer } from "effect";
+import type { Executor } from "./types";
+export { normalizeCode } from "./executor-base";
+declare const CodeExecutor_base: Context.TagClass<CodeExecutor, "@effect-codemode/Executor", Executor>;
+/**
+ * Effect service for code execution.
+ *
+ * Provides multiple Layer implementations following the @effect/platform pattern:
+ * - `CodeExecutor.Direct` — uses `new Function()` (fast, less isolated)
+ * - `CodeExecutor.Vm` — uses `node:vm` (stronger isolation)
+ * - `CodeExecutor.Default` — alias for `Vm`
+ */
+export declare class CodeExecutor extends CodeExecutor_base {
+    static readonly Direct: Layer.Layer<CodeExecutor, never, never>;
+    static readonly Vm: Layer.Layer<CodeExecutor, never, never>;
+    static readonly Default: Layer.Layer<CodeExecutor, never, never>;
+}
+//# sourceMappingURL=executor.d.ts.map

package/dist/executor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"executor.d.ts","sourceRoot":"","sources":["../src/executor.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAA;AAGvC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAA;AAGvC,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;;AA+B/C;;;;;;;GAOG;AACH,qBAAa,YAAa,SAAQ,iBAAkE;IAClG,MAAM,CAAC,QAAQ,CAAC,MAAM,0CAAsD;IAC5E,MAAM,CAAC,QAAQ,CAAC,EAAE,0CAAkD;IACpE,MAAM,CAAC,QAAQ,CAAC,OAAO,0CAAkB;CAC1C"}

package/dist/group.d.ts

@@ -0,0 +1,71 @@
+import { Effect, Layer } from "effect";
+import { CodemodeRegistry } from "./registry";
+import type { TaggedErrorClassLike, ToolShape } from "./tool";
+import type { ToolMiddleware } from "./types";
+/**
+ * Shorthand for any ToolShape regardless of its type parameters.
+ */
+type AnyToolShape = ToolShape<string, unknown, unknown, ReadonlyArray<TaggedErrorClassLike>>;
+/**
+ * Extract the input type from a ToolShape.
+ */
+type ExtractInput<T> = T extends ToolShape<string, infer I, unknown, ReadonlyArray<TaggedErrorClassLike>> ? I : never;
+/**
+ * Extract the output type from a ToolShape.
+ */
+type ExtractOutput<T> = T extends ToolShape<string, unknown, infer O, ReadonlyArray<TaggedErrorClassLike>> ? O : never;
+/**
+ * Extract the error types from a ToolShape as a union.
+ */
+type ExtractErrors<T> = T extends ToolShape<string, unknown, unknown, infer Errors> ? Errors[number] extends abstract new (...args: ReadonlyArray<never>) => infer E ? E : never : never;
+/**
+ * Maps tool shapes to a handler record type.
+ * Each key is a tool name, each value is a handler function.
+ */
+export type HandlersFrom<Tools extends ReadonlyArray<AnyToolShape>> = {
+    readonly [T in Tools[number] as T["name"]]: (input: ExtractInput<T>) => Effect.Effect<ExtractOutput<T>, ExtractErrors<T>>;
+};
+/**
+ * Options for `toLayer`.
+ */
+export interface ToLayerOptions {
+    readonly middleware?: ReadonlyArray<ToolMiddleware>;
+}
+/**
+ * The class returned by `group()`.
+ */
+export interface GroupClass<GroupName extends string, Tools extends ReadonlyArray<AnyToolShape>> {
+    new (_: never): {};
+    readonly groupName: GroupName;
+    readonly tools: Tools;
+    toLayer(factory: HandlersFrom<Tools>, options?: ToLayerOptions): Layer.Layer<CodemodeRegistry, never, never>;
+    toLayer<E, R>(factory: Effect.Effect<HandlersFrom<Tools>, E, R>, options?: ToLayerOptions): Layer.Layer<CodemodeRegistry, never, R>;
+    middleware(...mws: ReadonlyArray<ToolMiddleware>): GroupClass<GroupName, Tools>;
+}
+/**
+ * Create a tool group — bundles related tool shapes under a name.
+ *
+ * Returns a class suitable for `class TodoTools extends Codemode.group("todos", TodoGet, ...) {}`.
+ * The class has:
+ * - `static groupName` — the group name
+ * - `static tools` — the tool shape array
+ * - `static toLayer(factory)` — returns a `Layer.Layer<CodemodeRegistry, never, R>`
+ *
+ * ```ts
+ * class TodoTools extends Codemode.group("todos", TodoGet, TodoList, TodoCreate) {}
+ *
+ * const TodoToolsLive = TodoTools.toLayer(
+ *   Effect.gen(function* () {
+ *     const svc = yield* TodoService
+ *     return {
+ *       todo_get: ({ id }) => svc.get(id),
+ *       todo_list: (input) => svc.list(input),
+ *       todo_create: (input) => svc.create(input),
+ *     }
+ *   })
+ * ).pipe(Layer.provide(TodoServiceLive))
+ * ```
+ */
+export declare function group<GroupName extends string, Tools extends ReadonlyArray<AnyToolShape>>(name: GroupName, ...tools: Tools): GroupClass<GroupName, Tools>;
+export {};
+//# sourceMappingURL=group.d.ts.map

package/dist/group.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"group.d.ts","sourceRoot":"","sources":["../src/group.ts"],"names":[],"mappings":"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"}

package/dist/index.d.ts

@@ -0,0 +1,37 @@
+/**
+ * effect-codemode — Effect-native codemode for MCP
+ *
+ * Give LLMs a typed Effect SDK instead of individual tool calls.
+ * Tools return Effects with typed errors. The LLM writes Effect.gen code.
+ */
+import { Layer } from "effect";
+import { group } from "./group";
+import { CodemodeRegistry } from "./registry";
+import { serve } from "./serve";
+import { tool } from "./tool";
+export declare const Codemode: {
+    readonly tool: typeof tool;
+    readonly group: typeof group;
+    readonly serve: typeof serve;
+    readonly live: () => Layer.Layer<never, Error, CodemodeRegistry | import("@effect/ai/McpServer").McpServer>;
+    readonly StdioTransport: (stdin: import("effect/Stream").Stream<Uint8Array<ArrayBufferLike>, unknown, unknown>, stdout: import("effect/Sink").Sink<unknown, string | Uint8Array<ArrayBufferLike>, unknown, unknown, unknown>, options?: {
+        name?: string;
+        version?: string;
+    } | undefined) => Layer.Layer<import("@effect/ai/McpServer").McpServer | import("@effect/ai/McpSchema").McpServerClient, never, unknown>;
+    readonly withMiddleware: (mw: import("./types").ToolMiddleware) => Layer.Layer<never, never, CodemodeRegistry>;
+    readonly CodemodeRegistry: typeof CodemodeRegistry;
+};
+export { tool, type ToolShape } from "./tool";
+export { group } from "./group";
+export { serve } from "./serve";
+export { StdioTransport } from "./transport";
+export { withMiddleware } from "./middleware";
+export { CodemodeRegistry } from "./registry";
+export type { ToolDescriptor, ToolInvocation, ToolMiddleware, ExecuteResult, Executor, ExecutorOptions } from "./types";
+export { CodeExecutor, normalizeCode } from "./executor";
+export { buildTestTool, buildInspector } from "./testing";
+export { generateDeclarations, astToTypeScript } from "./typegen";
+export { searchTools, listToolSummary } from "./search";
+export { effectToEffectFn, buildEffectFnTable, unwrapEffectTypes } from "./bridge";
+export { sanitizeToolName } from "./sanitize";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAA;AAG9B,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAE/B,OAAO,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAA;AAC7C,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAC/B,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAA;AAS7B,eAAO,MAAM,QAAQ;;;;;;;;;;;CAQX,CAAA;AAGV,OAAO,EAAE,IAAI,EAAE,KAAK,SAAS,EAAE,MAAM,QAAQ,CAAA;AAC7C,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAG/B,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAG/B,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAA;AAG5C,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAA;AAG7C,OAAO,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAA;AAG7C,YAAY,EAAE,cAAc,EAAE,cAAc,EAAE,cAAc,EAAE,aAAa,EAAE,QAAQ,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAGvH,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,YAAY,CAAA;AAGxD,OAAO,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,WAAW,CAAA;AAGzD,OAAO,EAAE,oBAAoB,EAAE,eAAe,EAAE,MAAM,WAAW,CAAA;AAGjE,OAAO,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAGvD,OAAO,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAA;AAGlF,OAAO,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAA"}