noumen 0.1.0 → 0.2.0

package/dist/acp/index.d.ts

@@ -0,0 +1,129 @@
+import { A as Agent } from '../agent-BrkbZyOT.js';
+import { A as AcpTransport } from '../types-QwfylltH.js';
+export { a as ACP_METHODS, b as AcpCapabilities, c as AcpInitializeParams, d as AcpInitializeResult, e as AcpSessionNewParams, f as AcpSessionPromptParams } from '../types-QwfylltH.js';
+import { V as VirtualFs, R as ReadOptions, F as FileEntry, i as FileStat, j as VirtualComputer, E as ExecOptions, C as CommandResult } from '../types-CwKKucOF.js';
+import '../types-3c88cRKH.js';
+import '../cache-DVqaCX8v.js';
+import '../types-2kTLUCnD.js';
+import '@modelcontextprotocol/sdk/client/index.js';
+import '@modelcontextprotocol/sdk/client/auth.js';
+import '@modelcontextprotocol/sdk/shared/auth.js';
+import '../types-DwdzmXfs.js';
+
+/**
+ * ACP protocol handler: maps ACP JSON-RPC methods to Agent/Thread APIs.
+ */
+
+interface AcpHandlerOptions {
+    agentName?: string;
+    agentVersion?: string;
+}
+declare class AcpHandler {
+    private code;
+    private transport;
+    private options;
+    private sessions;
+    private initialized;
+    private clientCapabilities;
+    private pendingRequests;
+    private nextRequestId;
+    constructor(code: Agent, transport: AcpTransport, options?: AcpHandlerOptions);
+    /**
+     * Send a JSON-RPC request to the client and wait for the response.
+     * Used by AcpClientSandbox to invoke client-side fs/terminal methods.
+     */
+    sendClientRequest(method: string, params: unknown): Promise<unknown>;
+    private handleMessage;
+    private dispatch;
+    private handleInitialize;
+    private handleSessionNew;
+    private handleSessionPrompt;
+    private handleSessionLoad;
+    private emitStreamEvent;
+    private bridgePermission;
+    private bridgeUserInput;
+    private handleClose;
+}
+
+/**
+ * ACP stdio transport: newline-delimited JSON-RPC over stdin/stdout.
+ */
+
+declare class StdioTransport implements AcpTransport {
+    private input;
+    private output;
+    private messageHandler;
+    private closeHandler;
+    private buffer;
+    private closed;
+    constructor(input?: NodeJS.ReadableStream, output?: NodeJS.WritableStream);
+    send(message: unknown): void;
+    onMessage(handler: (message: unknown) => void): void;
+    onClose(handler: () => void): void;
+    close(): void;
+    private onData;
+    private handleClose;
+}
+
+/**
+ * AcpClientSandbox: VirtualFs + VirtualComputer backed by the ACP client.
+ *
+ * In the ACP model, the **client** (editor/IDE) provides filesystem and
+ * terminal access. This sandbox implementation sends JSON-RPC requests to
+ * the client for every fs/shell operation. It's a natural fit for noumen's
+ * pluggable sandbox architecture.
+ */
+
+declare class AcpClientSandbox {
+    private transport;
+    private sendRequest;
+    readonly fs: AcpClientFs;
+    readonly computer: AcpClientComputer;
+    constructor(transport: AcpTransport, sendRequest: (method: string, params: unknown) => Promise<unknown>);
+}
+declare class AcpClientFs implements VirtualFs {
+    private sendRequest;
+    constructor(sendRequest: (method: string, params: unknown) => Promise<unknown>);
+    readFile(path: string, _opts?: ReadOptions): Promise<string>;
+    readFileBytes(path: string, maxBytes?: number): Promise<Buffer>;
+    writeFile(path: string, content: string): Promise<void>;
+    appendFile(path: string, content: string): Promise<void>;
+    deleteFile(path: string, opts?: {
+        recursive?: boolean;
+    }): Promise<void>;
+    mkdir(path: string, opts?: {
+        recursive?: boolean;
+    }): Promise<void>;
+    readdir(path: string, _opts?: {
+        recursive?: boolean;
+    }): Promise<FileEntry[]>;
+    exists(path: string): Promise<boolean>;
+    stat(path: string): Promise<FileStat>;
+}
+declare class AcpClientComputer implements VirtualComputer {
+    private sendRequest;
+    constructor(sendRequest: (method: string, params: unknown) => Promise<unknown>);
+    executeCommand(command: string, opts?: ExecOptions): Promise<CommandResult>;
+}
+
+/**
+ * ACP (Agent Client Protocol) adapter for noumen.
+ *
+ * Usage:
+ *   import { createAcpServer, StdioTransport, AcpClientSandbox } from "noumen/acp";
+ *
+ *   // Stdio mode (editor launches agent as subprocess)
+ *   const transport = new StdioTransport();
+ *   const handler = createAcpServer(code, transport);
+ *
+ *   // Or use AcpClientSandbox to let the client provide fs/terminal
+ *   const sandbox = new AcpClientSandbox(transport, handler.sendClientRequest);
+ *   const agent = new Agent({ provider, sandbox });
+ */
+
+/**
+ * Create an ACP server that bridges an ACP transport to an Agent instance.
+ */
+declare function createAcpServer(code: Agent, transport: AcpTransport, options?: AcpHandlerOptions): AcpHandler;
+
+export { AcpClientSandbox, AcpHandler, type AcpHandlerOptions, AcpTransport, StdioTransport, createAcpServer };

package/dist/acp/index.js

@@ -0,0 +1,498 @@
+import {
+  INTERNAL_ERROR,
+  INVALID_PARAMS,
+  METHOD_NOT_FOUND,
+  formatError,
+  formatNotification,
+  formatResponse,
+  isRequest
+} from "../chunk-AMYIJSAZ.js";
+import {
+  contentToString
+} from "../chunk-JACGEMTF.js";
+import "../chunk-DGUM43GV.js";
+
+// src/acp/types.ts
+var ACP_METHODS = {
+  INITIALIZE: "initialize",
+  SESSION_NEW: "session/new",
+  SESSION_PROMPT: "session/prompt",
+  SESSION_LOAD: "session/load",
+  SESSION_ABORT: "session/abort",
+  // Client-invoked
+  FS_READ: "fs/read_text_file",
+  FS_READ_BYTES: "fs/read_bytes",
+  FS_WRITE: "fs/write_text_file",
+  FS_STAT: "fs/stat",
+  FS_EXISTS: "fs/exists",
+  FS_READDIR: "fs/readdir",
+  FS_MKDIR: "fs/mkdir",
+  FS_DELETE: "fs/delete",
+  TERMINAL_EXEC: "terminal/exec",
+  // Notifications (agent -> client)
+  STREAM_TEXT: "stream/text",
+  STREAM_THINKING: "stream/thinking",
+  STREAM_TOOL_USE: "stream/toolUse",
+  STREAM_TOOL_RESULT: "stream/toolResult",
+  STREAM_COMPLETE: "stream/complete",
+  STREAM_ERROR: "stream/error",
+  PERMISSION_REQUEST: "permission/request",
+  PERMISSION_RESPONSE: "permission/response",
+  USER_INPUT_REQUEST: "userInput/request",
+  USER_INPUT_RESPONSE: "userInput/response"
+};
+
+// src/acp/handler.ts
+var AcpHandler = class {
+  code;
+  transport;
+  options;
+  sessions = /* @__PURE__ */ new Map();
+  initialized = false;
+  clientCapabilities = {};
+  pendingRequests = /* @__PURE__ */ new Map();
+  nextRequestId = 1;
+  constructor(code, transport, options) {
+    this.code = code;
+    this.transport = transport;
+    this.options = options ?? {};
+    transport.onMessage((msg) => this.handleMessage(msg));
+    transport.onClose(() => this.handleClose());
+  }
+  /**
+   * Send a JSON-RPC request to the client and wait for the response.
+   * Used by AcpClientSandbox to invoke client-side fs/terminal methods.
+   */
+  async sendClientRequest(method, params) {
+    const id = this.nextRequestId++;
+    return new Promise((resolve, reject) => {
+      this.pendingRequests.set(id, { resolve, reject });
+      this.transport.send({
+        jsonrpc: "2.0",
+        id,
+        method,
+        params
+      });
+    });
+  }
+  async handleMessage(msg) {
+    if ("result" in msg || "error" in msg) {
+      const response = msg;
+      const pending = this.pendingRequests.get(response.id);
+      if (pending) {
+        this.pendingRequests.delete(response.id);
+        if ("error" in response && response.error) {
+          pending.reject(new Error(response.error.message));
+        } else {
+          pending.resolve(response.result);
+        }
+      }
+      return;
+    }
+    if (!isRequest(msg)) return;
+    const request = msg;
+    try {
+      const result = await this.dispatch(request);
+      if (result !== void 0) {
+        this.transport.send(formatResponse(request.id, result));
+      }
+    } catch (err) {
+      this.transport.send(
+        formatError(
+          request.id,
+          INTERNAL_ERROR,
+          err instanceof Error ? err.message : String(err)
+        )
+      );
+    }
+  }
+  async dispatch(request) {
+    switch (request.method) {
+      case ACP_METHODS.INITIALIZE:
+        return this.handleInitialize(request.params);
+      case ACP_METHODS.SESSION_NEW:
+        return this.handleSessionNew(request.params);
+      case ACP_METHODS.SESSION_PROMPT:
+        this.handleSessionPrompt(
+          request.id,
+          request.params
+        );
+        return void 0;
+      case ACP_METHODS.SESSION_LOAD:
+        return this.handleSessionLoad(request.params);
+      case ACP_METHODS.SESSION_ABORT: {
+        const p = request.params;
+        const session = this.sessions.get(p.sessionId);
+        if (session) {
+          session.abortController?.abort();
+        }
+        return { ok: true };
+      }
+      case ACP_METHODS.PERMISSION_RESPONSE: {
+        const p = request.params;
+        const session = this.sessions.get(p.sessionId);
+        if (session?.pendingPermission) {
+          session.pendingPermission.resolve({
+            allow: p.allow,
+            feedback: p.feedback
+          });
+          session.pendingPermission = null;
+        }
+        return { ok: true };
+      }
+      case ACP_METHODS.USER_INPUT_RESPONSE: {
+        const p = request.params;
+        const session = this.sessions.get(p.sessionId);
+        if (session?.pendingInput) {
+          session.pendingInput.resolve(p.answer ?? "");
+          session.pendingInput = null;
+        }
+        return { ok: true };
+      }
+      default:
+        throw Object.assign(
+          new Error(`Unknown method: ${request.method}`),
+          { code: METHOD_NOT_FOUND }
+        );
+    }
+  }
+  handleInitialize(params) {
+    this.initialized = true;
+    this.clientCapabilities = params.capabilities ?? {};
+    return {
+      agentName: this.options.agentName ?? "noumen",
+      agentVersion: this.options.agentVersion ?? "0.1.0",
+      protocolVersion: "0.1.0",
+      capabilities: {
+        streaming: true,
+        permissions: true,
+        sessions: true
+      }
+    };
+  }
+  handleSessionNew(params) {
+    const thread = this.code.createThread({
+      sessionId: params.sessionId,
+      permissionHandler: (req) => this.bridgePermission(thread.sessionId, req),
+      userInputHandler: (question) => this.bridgeUserInput(thread.sessionId, question)
+    });
+    this.sessions.set(thread.sessionId, {
+      thread,
+      running: false,
+      abortController: null,
+      pendingPermission: null,
+      pendingInput: null
+    });
+    return { sessionId: thread.sessionId };
+  }
+  async handleSessionPrompt(requestId, params) {
+    const session = this.sessions.get(params.sessionId);
+    if (!session) {
+      this.transport.send(
+        formatError(requestId, INVALID_PARAMS, `Session not found: ${params.sessionId}`)
+      );
+      return;
+    }
+    session.running = true;
+    session.abortController = new AbortController();
+    this.transport.send(formatResponse(requestId, { ok: true }));
+    try {
+      for await (const event of session.thread.run(params.prompt, {
+        signal: session.abortController.signal
+      })) {
+        this.emitStreamEvent(params.sessionId, event);
+      }
+    } catch (err) {
+      this.transport.send(
+        formatNotification(ACP_METHODS.STREAM_ERROR, {
+          sessionId: params.sessionId,
+          error: err instanceof Error ? err.message : String(err)
+        })
+      );
+    } finally {
+      session.running = false;
+      session.abortController = null;
+    }
+  }
+  handleSessionLoad(params) {
+    const thread = this.code.resumeThread(params.sessionId, {
+      permissionHandler: (req) => this.bridgePermission(params.sessionId, req),
+      userInputHandler: (question) => this.bridgeUserInput(params.sessionId, question)
+    });
+    this.sessions.set(params.sessionId, {
+      thread,
+      running: false,
+      abortController: null,
+      pendingPermission: null,
+      pendingInput: null
+    });
+    return { sessionId: params.sessionId };
+  }
+  emitStreamEvent(sessionId, event) {
+    switch (event.type) {
+      case "text_delta":
+        this.transport.send(
+          formatNotification(ACP_METHODS.STREAM_TEXT, {
+            sessionId,
+            text: event.text
+          })
+        );
+        break;
+      case "thinking_delta":
+        this.transport.send(
+          formatNotification(ACP_METHODS.STREAM_THINKING, {
+            sessionId,
+            text: event.text
+          })
+        );
+        break;
+      case "tool_use_start":
+        this.transport.send(
+          formatNotification(ACP_METHODS.STREAM_TOOL_USE, {
+            sessionId,
+            toolName: event.toolName,
+            toolUseId: event.toolUseId,
+            phase: "start"
+          })
+        );
+        break;
+      case "tool_result":
+        this.transport.send(
+          formatNotification(ACP_METHODS.STREAM_TOOL_RESULT, {
+            sessionId,
+            toolName: event.toolName,
+            toolUseId: event.toolUseId,
+            result: contentToString(event.result.content),
+            isError: event.result.isError
+          })
+        );
+        break;
+      case "message_complete":
+        this.transport.send(
+          formatNotification(ACP_METHODS.STREAM_COMPLETE, {
+            sessionId,
+            text: event.message.content
+          })
+        );
+        break;
+      case "turn_complete":
+        this.transport.send(
+          formatNotification(ACP_METHODS.STREAM_COMPLETE, {
+            sessionId,
+            done: true,
+            usage: event.usage
+          })
+        );
+        break;
+      case "error":
+        this.transport.send(
+          formatNotification(ACP_METHODS.STREAM_ERROR, {
+            sessionId,
+            error: event.error.message
+          })
+        );
+        break;
+      case "permission_request":
+        this.transport.send(
+          formatNotification(ACP_METHODS.PERMISSION_REQUEST, {
+            sessionId,
+            toolName: event.toolName,
+            input: event.input,
+            message: event.message
+          })
+        );
+        break;
+      case "user_input_request":
+        this.transport.send(
+          formatNotification(ACP_METHODS.USER_INPUT_REQUEST, {
+            sessionId,
+            toolUseId: event.toolUseId,
+            question: event.question
+          })
+        );
+        break;
+    }
+  }
+  bridgePermission(sessionId, request) {
+    return new Promise((resolve) => {
+      const session = this.sessions.get(sessionId);
+      if (session) {
+        session.pendingPermission = { resolve };
+      }
+    });
+  }
+  bridgeUserInput(sessionId, question) {
+    return new Promise((resolve) => {
+      const session = this.sessions.get(sessionId);
+      if (session) {
+        session.pendingInput = { resolve };
+      }
+    });
+  }
+  handleClose() {
+    for (const session of this.sessions.values()) {
+      session.abortController?.abort();
+    }
+    this.sessions.clear();
+  }
+};
+
+// src/acp/transport-stdio.ts
+var StdioTransport = class {
+  constructor(input = process.stdin, output = process.stdout) {
+    this.input = input;
+    this.output = output;
+    this.input.setEncoding?.("utf-8");
+    this.input.on("data", (chunk) => this.onData(chunk));
+    this.input.on("end", () => this.handleClose());
+    this.input.on("error", () => this.handleClose());
+  }
+  input;
+  output;
+  messageHandler = null;
+  closeHandler = null;
+  buffer = "";
+  closed = false;
+  send(message) {
+    if (this.closed) return;
+    const line = JSON.stringify(message) + "\n";
+    this.output.write(line);
+  }
+  onMessage(handler) {
+    this.messageHandler = handler;
+  }
+  onClose(handler) {
+    this.closeHandler = handler;
+  }
+  close() {
+    if (this.closed) return;
+    this.closed = true;
+    this.handleClose();
+  }
+  onData(chunk) {
+    this.buffer += chunk;
+    const lines = this.buffer.split("\n");
+    this.buffer = lines.pop() ?? "";
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      try {
+        const msg = JSON.parse(trimmed);
+        this.messageHandler?.(msg);
+      } catch {
+      }
+    }
+  }
+  handleClose() {
+    this.closed = true;
+    this.closeHandler?.();
+  }
+};
+
+// src/acp/client-sandbox.ts
+var AcpClientSandbox = class {
+  constructor(transport, sendRequest) {
+    this.transport = transport;
+    this.sendRequest = sendRequest;
+    this.fs = new AcpClientFs(sendRequest);
+    this.computer = new AcpClientComputer(sendRequest);
+  }
+  transport;
+  sendRequest;
+  fs;
+  computer;
+};
+var AcpClientFs = class {
+  constructor(sendRequest) {
+    this.sendRequest = sendRequest;
+  }
+  sendRequest;
+  async readFile(path, _opts) {
+    const result = await this.sendRequest(ACP_METHODS.FS_READ, { path });
+    return result.content;
+  }
+  async readFileBytes(path, maxBytes) {
+    const result = await this.sendRequest(ACP_METHODS.FS_READ_BYTES, {
+      path,
+      maxBytes
+    });
+    return Buffer.from(result.data, "base64");
+  }
+  async writeFile(path, content) {
+    await this.sendRequest(ACP_METHODS.FS_WRITE, { path, content });
+  }
+  async appendFile(path, content) {
+    let existing = "";
+    try {
+      existing = await this.readFile(path);
+    } catch {
+    }
+    await this.writeFile(path, existing + content);
+  }
+  async deleteFile(path, opts) {
+    await this.sendRequest(ACP_METHODS.FS_DELETE, {
+      path,
+      recursive: opts?.recursive ?? false
+    });
+  }
+  async mkdir(path, opts) {
+    await this.sendRequest(ACP_METHODS.FS_MKDIR, {
+      path,
+      recursive: opts?.recursive ?? false
+    });
+  }
+  async readdir(path, _opts) {
+    const result = await this.sendRequest(ACP_METHODS.FS_READDIR, {
+      path
+    });
+    return result;
+  }
+  async exists(path) {
+    const result = await this.sendRequest(ACP_METHODS.FS_EXISTS, {
+      path
+    });
+    return result;
+  }
+  async stat(path) {
+    const result = await this.sendRequest(ACP_METHODS.FS_STAT, {
+      path
+    });
+    return {
+      size: result.size,
+      isDirectory: result.isDirectory,
+      isFile: result.isFile,
+      modifiedAt: result.modifiedAt ? new Date(result.modifiedAt) : void 0
+    };
+  }
+};
+var AcpClientComputer = class {
+  constructor(sendRequest) {
+    this.sendRequest = sendRequest;
+  }
+  sendRequest;
+  async executeCommand(command, opts) {
+    const result = await this.sendRequest(ACP_METHODS.TERMINAL_EXEC, {
+      command,
+      cwd: opts?.cwd,
+      timeout: opts?.timeout
+    });
+    return {
+      exitCode: result.exitCode,
+      stdout: result.stdout,
+      stderr: result.stderr
+    };
+  }
+};
+
+// src/acp/index.ts
+function createAcpServer(code, transport, options) {
+  return new AcpHandler(code, transport, options);
+}
+export {
+  ACP_METHODS,
+  AcpClientSandbox,
+  AcpHandler,
+  StdioTransport,
+  createAcpServer
+};
+//# sourceMappingURL=index.js.map