@freesyntax/notch-cli 0.5.17 → 0.5.19

package/dist/chunk-75K7DQVI.js

@@ -0,0 +1,630 @@
+import {
+  grepTool
+} from "./chunk-6CZCFY6H.js";
+import {
+  globTool
+} from "./chunk-6U3ZAGYA.js";
+import {
+  webFetchTool
+} from "./chunk-FFB7GK3Y.js";
+import {
+  githubTool
+} from "./chunk-GBZGR6ID.js";
+import {
+  lspTool
+} from "./chunk-TH6GKC7E.js";
+import {
+  notebookTool
+} from "./chunk-KZAS754V.js";
+import {
+  taskTool
+} from "./chunk-UR4XL6OM.js";
+import {
+  pluginManager
+} from "./chunk-3QUV4JEX.js";
+import {
+  readTool
+} from "./chunk-CQMAVWLJ.js";
+import {
+  writeTool
+} from "./chunk-O3WZW7GS.js";
+import {
+  editTool
+} from "./chunk-YAYPQTOU.js";
+import {
+  applyPatchTool
+} from "./chunk-C4CPDDMN.js";
+import {
+  shellTool
+} from "./chunk-W4FAGQFL.js";
+import {
+  gitTool
+} from "./chunk-FAULT7VE.js";
+
+// src/tools/index.ts
+import { tool } from "ai";
+
+// src/mcp/client.ts
+import { z } from "zod";
+
+// src/mcp/transport.ts
+function detectTransport(config) {
+  if (config.transport) return config.transport;
+  if (config.url) return "http";
+  return "stdio";
+}
+
+// src/mcp/stdio-transport.ts
+import { spawn } from "child_process";
+var StdioTransport = class {
+  constructor(config, name) {
+    this.config = config;
+    this.name = name;
+  }
+  config;
+  process = null;
+  requestId = 0;
+  pendingRequests = /* @__PURE__ */ new Map();
+  buffer = "";
+  name;
+  async connect() {
+    if (!this.config.command) {
+      throw new Error(`Stdio transport requires 'command' in config for server ${this.name}`);
+    }
+    this.process = spawn(this.config.command, this.config.args ?? [], {
+      stdio: ["pipe", "pipe", "pipe"],
+      env: { ...process.env, ...this.config.env },
+      cwd: this.config.cwd
+    });
+    this.process.stdout?.setEncoding("utf-8");
+    this.process.stdout?.on("data", (data) => {
+      this.buffer += data;
+      this.processBuffer();
+    });
+    this.process.on("error", (err) => {
+      for (const [id, pending] of this.pendingRequests) {
+        pending.reject(new Error(`MCP server ${this.name} error: ${err.message}`));
+        this.pendingRequests.delete(id);
+      }
+    });
+    this.process.on("exit", (code) => {
+      for (const [id, pending] of this.pendingRequests) {
+        pending.reject(new Error(`MCP server ${this.name} exited with code ${code}`));
+        this.pendingRequests.delete(id);
+      }
+    });
+  }
+  disconnect() {
+    if (this.process) {
+      this.process.stdin?.end();
+      this.process.kill();
+      this.process = null;
+    }
+    this.pendingRequests.clear();
+  }
+  get isAlive() {
+    return this.process !== null && this.process.exitCode === null && !this.process.killed;
+  }
+  sendRequest(method, params) {
+    return new Promise((resolve, reject) => {
+      const id = ++this.requestId;
+      const msg = { jsonrpc: "2.0", id, method, params };
+      this.pendingRequests.set(id, { resolve, reject });
+      const data = JSON.stringify(msg);
+      const header = `Content-Length: ${Buffer.byteLength(data)}\r
+\r
+`;
+      this.process?.stdin?.write(header + data);
+      setTimeout(() => {
+        if (this.pendingRequests.has(id)) {
+          this.pendingRequests.delete(id);
+          reject(new Error(`MCP request ${method} timed out`));
+        }
+      }, 3e4);
+    });
+  }
+  sendNotification(method, params) {
+    const msg = { jsonrpc: "2.0", method, params };
+    const data = JSON.stringify(msg);
+    const header = `Content-Length: ${Buffer.byteLength(data)}\r
+\r
+`;
+    this.process?.stdin?.write(header + data);
+  }
+  processBuffer() {
+    while (this.buffer.length > 0) {
+      const headerEnd = this.buffer.indexOf("\r\n\r\n");
+      if (headerEnd === -1) break;
+      const header = this.buffer.slice(0, headerEnd);
+      const lengthMatch = header.match(/Content-Length:\s*(\d+)/i);
+      if (!lengthMatch) {
+        const nlIdx = this.buffer.indexOf("\n");
+        if (nlIdx === -1) break;
+        const line = this.buffer.slice(0, nlIdx).trim();
+        this.buffer = this.buffer.slice(nlIdx + 1);
+        if (line) this.handleMessage(line);
+        continue;
+      }
+      const contentLength = parseInt(lengthMatch[1], 10);
+      const messageStart = headerEnd + 4;
+      if (this.buffer.length < messageStart + contentLength) break;
+      const body = this.buffer.slice(messageStart, messageStart + contentLength);
+      this.buffer = this.buffer.slice(messageStart + contentLength);
+      this.handleMessage(body);
+    }
+  }
+  handleMessage(raw) {
+    try {
+      const msg = JSON.parse(raw);
+      if (msg.id !== void 0 && this.pendingRequests.has(msg.id)) {
+        const pending = this.pendingRequests.get(msg.id);
+        this.pendingRequests.delete(msg.id);
+        if (msg.error) {
+          pending.reject(new Error(`MCP error: ${msg.error.message}`));
+        } else {
+          pending.resolve(msg.result);
+        }
+      }
+    } catch {
+    }
+  }
+};
+
+// src/mcp/http-transport.ts
+var HttpTransport = class {
+  requestId = 0;
+  connected = false;
+  name;
+  baseUrl;
+  headers;
+  constructor(config, name) {
+    this.name = name;
+    if (!config.url) {
+      throw new Error(`HTTP transport requires 'url' in config for server ${name}`);
+    }
+    this.baseUrl = config.url.replace(/\/$/, "");
+    this.headers = {
+      "Content-Type": "application/json",
+      ...config.headers
+    };
+  }
+  async connect() {
+    try {
+      const response = await fetch(`${this.baseUrl}`, {
+        method: "POST",
+        headers: this.headers,
+        body: JSON.stringify({
+          jsonrpc: "2.0",
+          id: ++this.requestId,
+          method: "initialize",
+          params: {
+            protocolVersion: "2024-11-05",
+            capabilities: {},
+            clientInfo: { name: "notch-cli", version: "0.4.8" }
+          }
+        }),
+        signal: AbortSignal.timeout(15e3)
+      });
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+      this.sendNotification("notifications/initialized", {});
+      this.connected = true;
+    } catch (err) {
+      throw new Error(`MCP HTTP server ${this.name} unreachable: ${err.message}`);
+    }
+  }
+  disconnect() {
+    this.connected = false;
+  }
+  get isAlive() {
+    return this.connected;
+  }
+  async sendRequest(method, params) {
+    const id = ++this.requestId;
+    const body = { jsonrpc: "2.0", id, method, params };
+    const response = await fetch(this.baseUrl, {
+      method: "POST",
+      headers: this.headers,
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(3e4)
+    });
+    if (!response.ok) {
+      throw new Error(`MCP HTTP error (${this.name}): ${response.status} ${response.statusText}`);
+    }
+    const json = await response.json();
+    if (json.error) {
+      throw new Error(`MCP error (${this.name}): ${json.error.message}`);
+    }
+    return json.result;
+  }
+  sendNotification(method, params) {
+    void fetch(this.baseUrl, {
+      method: "POST",
+      headers: this.headers,
+      body: JSON.stringify({ jsonrpc: "2.0", method, params }),
+      signal: AbortSignal.timeout(1e4)
+    }).catch(() => {
+    });
+  }
+};
+
+// src/mcp/sse-transport.ts
+var SSETransport = class {
+  requestId = 0;
+  pendingRequests = /* @__PURE__ */ new Map();
+  abortController = null;
+  connected = false;
+  name;
+  baseUrl;
+  messageEndpoint;
+  sseEndpoint;
+  headers;
+  constructor(config, name) {
+    this.name = name;
+    if (!config.url) {
+      throw new Error(`SSE transport requires 'url' in config for server ${name}`);
+    }
+    this.baseUrl = config.url.replace(/\/$/, "");
+    this.sseEndpoint = `${this.baseUrl}/sse`;
+    this.messageEndpoint = `${this.baseUrl}/message`;
+    this.headers = {
+      "Content-Type": "application/json",
+      ...config.headers
+    };
+  }
+  async connect() {
+    this.abortController = new AbortController();
+    const ssePromise = this.startSSEListener();
+    await new Promise((resolve) => setTimeout(resolve, 500));
+    const initResult = await this.sendRequest("initialize", {
+      protocolVersion: "2024-11-05",
+      capabilities: {},
+      clientInfo: { name: "notch-cli", version: "0.4.8" }
+    });
+    if (!initResult) {
+      throw new Error(`MCP SSE server ${this.name} failed to initialize`);
+    }
+    this.sendNotification("notifications/initialized", {});
+    this.connected = true;
+    ssePromise.catch(() => {
+      this.connected = false;
+    });
+  }
+  disconnect() {
+    this.abortController?.abort();
+    this.abortController = null;
+    this.connected = false;
+    for (const [id, pending] of this.pendingRequests) {
+      pending.reject(new Error(`MCP SSE transport disconnected`));
+      this.pendingRequests.delete(id);
+    }
+  }
+  get isAlive() {
+    return this.connected;
+  }
+  async sendRequest(method, params) {
+    const id = ++this.requestId;
+    const body = { jsonrpc: "2.0", id, method, params };
+    const resultPromise = new Promise((resolve, reject) => {
+      this.pendingRequests.set(id, { resolve, reject });
+      setTimeout(() => {
+        if (this.pendingRequests.has(id)) {
+          this.pendingRequests.delete(id);
+          reject(new Error(`MCP SSE request ${method} timed out`));
+        }
+      }, 3e4);
+    });
+    const response = await fetch(this.messageEndpoint, {
+      method: "POST",
+      headers: this.headers,
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (!response.ok) {
+      this.pendingRequests.delete(id);
+      throw new Error(`MCP SSE POST error (${this.name}): ${response.status} ${response.statusText}`);
+    }
+    return resultPromise;
+  }
+  sendNotification(method, params) {
+    const body = { jsonrpc: "2.0", method, params };
+    void fetch(this.messageEndpoint, {
+      method: "POST",
+      headers: this.headers,
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(1e4)
+    }).catch(() => {
+    });
+  }
+  /**
+   * Start listening for Server-Sent Events.
+   * Parses the SSE stream and resolves pending requests.
+   */
+  async startSSEListener() {
+    const response = await fetch(this.sseEndpoint, {
+      headers: {
+        Accept: "text/event-stream",
+        ...this.headers
+      },
+      signal: this.abortController?.signal
+    });
+    if (!response.ok || !response.body) {
+      throw new Error(`SSE connection failed: ${response.status}`);
+    }
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const events = buffer.split("\n\n");
+        buffer = events.pop() ?? "";
+        for (const event of events) {
+          const lines = event.split("\n");
+          let data = "";
+          for (const line of lines) {
+            if (line.startsWith("data: ")) {
+              data += line.slice(6);
+            }
+          }
+          if (data) {
+            this.handleSSEMessage(data);
+          }
+        }
+      }
+    } catch (err) {
+      if (err.name !== "AbortError") {
+        this.connected = false;
+      }
+    }
+  }
+  handleSSEMessage(raw) {
+    try {
+      const msg = JSON.parse(raw);
+      if (msg.id !== void 0 && this.pendingRequests.has(msg.id)) {
+        const pending = this.pendingRequests.get(msg.id);
+        this.pendingRequests.delete(msg.id);
+        if (msg.error) {
+          pending.reject(new Error(`MCP SSE error: ${msg.error.message}`));
+        } else {
+          pending.resolve(msg.result);
+        }
+      }
+    } catch {
+    }
+  }
+};
+
+// src/mcp/client.ts
+function createTransport(config, name) {
+  const type = detectTransport(config);
+  switch (type) {
+    case "http":
+      return new HttpTransport(config, name);
+    case "sse":
+      return new SSETransport(config, name);
+    case "stdio":
+    default:
+      return new StdioTransport(config, name);
+  }
+}
+var MCPClient = class {
+  transport;
+  serverName;
+  _tools = [];
+  constructor(config, serverName) {
+    this.serverName = serverName;
+    this.transport = createTransport(config, serverName);
+  }
+  /**
+   * Start the MCP server and initialize the connection.
+   */
+  async connect() {
+    await this.transport.connect();
+    await this.transport.sendRequest("initialize", {
+      protocolVersion: "2024-11-05",
+      capabilities: {},
+      clientInfo: { name: "notch-cli", version: "0.4.8" }
+    });
+    this.transport.sendNotification("notifications/initialized", {});
+    const result = await this.transport.sendRequest("tools/list", {});
+    this._tools = result.tools ?? [];
+  }
+  /**
+   * Get discovered tools from this server.
+   */
+  get tools() {
+    return this._tools;
+  }
+  /**
+   * Check if the MCP server is still alive.
+   */
+  get isAlive() {
+    return this.transport.isAlive;
+  }
+  /**
+   * Call a tool on the MCP server. Auto-reconnects if the server has crashed.
+   */
+  async callTool(name, args) {
+    if (!this.isAlive) {
+      try {
+        await this.transport.connect();
+      } catch (err) {
+        throw new Error(`MCP server ${this.serverName} is down and could not reconnect: ${err.message}`);
+      }
+    }
+    return this.transport.sendRequest("tools/call", { name, arguments: args });
+  }
+  /**
+   * Disconnect from the MCP server.
+   */
+  disconnect() {
+    this.transport.disconnect();
+  }
+};
+function mcpToolsToNotch(client, serverName) {
+  return client.tools.map((toolDef) => {
+    const params = z.record(z.unknown()).describe(
+      toolDef.description || `MCP tool from ${serverName}`
+    );
+    const notchTool = {
+      name: `mcp_${serverName}_${toolDef.name}`,
+      description: `[MCP/${serverName}] ${toolDef.description}`,
+      parameters: params,
+      async execute(args, _ctx) {
+        try {
+          const result = await client.callTool(toolDef.name, args);
+          const mcpResult = result;
+          if (mcpResult?.content && Array.isArray(mcpResult.content)) {
+            const text = mcpResult.content.filter((c) => c.type === "text").map((c) => c.text).join("\n");
+            return { content: text || JSON.stringify(result) };
+          }
+          return { content: typeof result === "string" ? result : JSON.stringify(result, null, 2) };
+        } catch (err) {
+          return { content: `MCP error (${serverName}/${toolDef.name}): ${err.message}`, isError: true };
+        }
+      }
+    };
+    return notchTool;
+  });
+}
+function parseMCPConfig(config) {
+  const servers = config?.mcpServers;
+  if (!servers || typeof servers !== "object") return {};
+  const result = {};
+  for (const [name, cfg] of Object.entries(servers)) {
+    const c = cfg;
+    if (c?.command || c?.url) {
+      result[name] = {
+        command: c.command,
+        args: c.args,
+        env: c.env,
+        cwd: c.cwd,
+        transport: c.transport,
+        url: c.url,
+        headers: c.headers
+      };
+    }
+  }
+  return result;
+}
+
+// src/tools/index.ts
+var BUILTIN_TOOLS = [
+  readTool,
+  writeTool,
+  editTool,
+  applyPatchTool,
+  shellTool,
+  gitTool,
+  githubTool,
+  grepTool,
+  globTool,
+  webFetchTool,
+  lspTool,
+  notebookTool,
+  taskTool
+];
+var mcpClients = /* @__PURE__ */ new Map();
+var mcpTools = [];
+async function initMCPServers(config) {
+  const servers = parseMCPConfig(config);
+  let toolCount = 0;
+  for (const [name, serverConfig] of Object.entries(servers)) {
+    try {
+      const client = new MCPClient(serverConfig, name);
+      await client.connect();
+      mcpClients.set(name, client);
+      const tools = mcpToolsToNotch(client, name);
+      mcpTools.push(...tools);
+      toolCount += tools.length;
+    } catch (err) {
+      console.error(`  MCP server '${name}' failed to connect: ${err.message}`);
+    }
+  }
+  return toolCount;
+}
+function disconnectMCPServers() {
+  for (const [, client] of mcpClients) {
+    client.disconnect();
+  }
+  mcpClients.clear();
+  mcpTools = [];
+}
+function getAllTools() {
+  return [...BUILTIN_TOOLS, ...mcpTools, ...pluginManager.getTools()];
+}
+function buildToolMap(ctx) {
+  const map = {};
+  for (const t of getAllTools()) {
+    map[t.name] = tool({
+      description: t.description,
+      parameters: t.parameters,
+      execute: async (params) => {
+        if (ctx.checkPermission) {
+          await ctx.runHook?.("permission-request", { tool: t.name, args: params });
+          const level = ctx.checkPermission(t.name, params);
+          if (level === "deny") {
+            await ctx.runHook?.("permission-denied", { tool: t.name, args: params, reason: "denied-by-config" });
+            return {
+              content: `Permission denied: ${t.name} is not allowed by your permission config.`,
+              isError: true
+            };
+          }
+          if (level === "prompt" && ctx.requireConfirm) {
+            const paramSummary = Object.entries(params).map(([k, v]) => `${k}=${String(v).slice(0, 80)}`).join(", ");
+            const confirmed = await ctx.confirm(
+              `Tool ${t.name}(${paramSummary}) requires approval. Proceed?`
+            );
+            if (!confirmed) {
+              await ctx.runHook?.("permission-denied", { tool: t.name, args: params, reason: "cancelled-by-user" });
+              return { content: "Cancelled by user.", isError: true };
+            }
+          }
+        }
+        if (ctx.dryRun && ["write", "edit", "apply_patch", "shell", "git"].includes(t.name)) {
+          const paramSummary = JSON.stringify(params, null, 2).slice(0, 500);
+          return {
+            content: `[DRY RUN] Would execute ${t.name}:
+${paramSummary}`
+          };
+        }
+        await ctx.runHook?.("pre-tool", { tool: t.name, args: params });
+        const result = await t.execute(params, ctx);
+        await ctx.runHook?.("post-tool", {
+          tool: t.name,
+          args: params,
+          result: result.content.slice(0, 500),
+          isError: result.isError ?? false
+        });
+        return result;
+      }
+    });
+  }
+  return map;
+}
+function listToolNames() {
+  return getAllTools().map((t) => t.name);
+}
+function describeTools() {
+  return getAllTools().map(
+    (t) => `- **${t.name}**: ${t.description}`
+  ).join("\n");
+}
+function mcpToolCount() {
+  return mcpTools.length;
+}
+
+export {
+  MCPClient,
+  parseMCPConfig,
+  initMCPServers,
+  disconnectMCPServers,
+  buildToolMap,
+  listToolNames,
+  describeTools,
+  mcpToolCount
+};