token-goat 2.6.36 → 2.8.1

package/dist/token-goat-chunk-324QOJYZ.mjs

@@ -0,0 +1,91 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import "./token-goat-chunk-AEX54RUZ.mjs";
+
+// src/mcp_stdio.ts
+import process from "node:process";
+var STDIO_MAX_BUFFER_BYTES = 10 * 1024 * 1024;
+var StdioServerTransport = class {
+  stdin;
+  stdout;
+  buffer;
+  started = false;
+  onmessage;
+  onclose;
+  onerror;
+  // Arrow properties rather than bound methods so `off()` can remove the exact same function
+  // reference `on()` added -- a fresh `.bind(this)` at removal time would leave the listener
+  // attached, and a second `mcp-serve` in the same process would then see every message twice.
+  ondata = (chunk) => {
+    const size = (this.buffer?.length ?? 0) + chunk.length;
+    if (size > STDIO_MAX_BUFFER_BYTES) {
+      this.buffer = void 0;
+      this.onerror?.(new Error(`MCP stdio read buffer exceeded ${STDIO_MAX_BUFFER_BYTES} bytes`));
+      void this.close();
+      return;
+    }
+    this.buffer = this.buffer === void 0 ? chunk : Buffer.concat([this.buffer, chunk]);
+    this.drain();
+  };
+  onstreamerror = (error) => {
+    this.onerror?.(error);
+  };
+  constructor(stdin = process.stdin, stdout = process.stdout) {
+    this.stdin = stdin;
+    this.stdout = stdout;
+  }
+  async start() {
+    if (this.started) throw new Error("StdioServerTransport already started");
+    this.started = true;
+    this.stdin.on("data", this.ondata);
+    this.stdin.on("error", this.onstreamerror);
+    return Promise.resolve();
+  }
+  /**
+   * Consumes every complete line currently buffered. A line that is not valid JSON is reported and
+   * skipped rather than closing the connection: one malformed message is not a reason to drop a
+   * working session, and the next line may well be fine.
+   */
+  drain() {
+    for (; ; ) {
+      const buffer = this.buffer;
+      if (buffer === void 0) return;
+      const index = buffer.indexOf("\n");
+      if (index === -1) return;
+      const line = buffer.toString("utf8", 0, index).replace(/\r$/, "");
+      this.buffer = buffer.subarray(index + 1);
+      if (line.trim().length === 0) continue;
+      let message;
+      try {
+        message = JSON.parse(line);
+      } catch (err) {
+        this.onerror?.(err instanceof Error ? err : new Error(String(err)));
+        continue;
+      }
+      this.onmessage?.(message);
+    }
+  }
+  /**
+   * Resolves once the message is handed off. Waiting for `drain` when the stream says it is full
+   * is what keeps a long reply from being silently truncated on a slow or small pipe.
+   */
+  send(message) {
+    return new Promise((resolve) => {
+      if (this.stdout.write(`${JSON.stringify(message)}
+`)) resolve();
+      else this.stdout.once("drain", resolve);
+    });
+  }
+  async close() {
+    this.stdin.off("data", this.ondata);
+    this.stdin.off("error", this.onstreamerror);
+    if (this.stdin.listenerCount("data") === 0) this.stdin.pause();
+    this.buffer = void 0;
+    this.onclose?.();
+    return Promise.resolve();
+  }
+};
+export {
+  STDIO_MAX_BUFFER_BYTES,
+  StdioServerTransport
+};

package/dist/token-goat-chunk-5CVKO3DA.mjs

@@ -0,0 +1,185 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  external_exports
+} from "./token-goat-chunk-WN5T5EW5.mjs";
+import "./token-goat-chunk-AEX54RUZ.mjs";
+
+// src/mcp_jsonrpc.ts
+var LATEST_PROTOCOL_VERSION = "2025-11-25";
+var SUPPORTED_PROTOCOL_VERSIONS = [
+  LATEST_PROTOCOL_VERSION,
+  "2025-06-18",
+  "2025-03-26",
+  "2024-11-05",
+  "2024-10-07"
+];
+var JSONRPC_INVALID_REQUEST = -32600;
+var JSONRPC_METHOD_NOT_FOUND = -32601;
+var JSONRPC_INVALID_PARAMS = -32602;
+var DRAFT_07_SCHEMA_ID = "http://json-schema.org/draft-07/schema#";
+var MCP_INVALID_PARAMS_PREFIX = `MCP error ${JSONRPC_INVALID_PARAMS}: `;
+var EMPTY_OBJECT_JSON_SCHEMA = { type: "object", properties: {} };
+function buildJsonSchema(shape) {
+  if (shape === void 0 || Object.keys(shape).length === 0) return { ...EMPTY_OBJECT_JSON_SCHEMA };
+  const schema = external_exports.toJSONSchema(external_exports.object(shape), { io: "input" });
+  return { ...schema, $schema: DRAFT_07_SCHEMA_ID };
+}
+function describeParseError(error) {
+  return error.issues.map((issue) => {
+    if (issue.path.length === 0) return issue.message;
+    const dotted = issue.path.reduce(
+      (acc, seg, i) => i === 0 ? String(seg) : typeof seg === "number" ? `${acc}[${seg}]` : `${acc}.${String(seg)}`,
+      ""
+    );
+    return `${issue.message} at ${dotted}`;
+  }).join("\n");
+}
+function errorText(message) {
+  return { content: [{ type: "text", text: message }], isError: true };
+}
+function isRequest(message) {
+  return "method" in message && "id" in message && message.id !== void 0 && message.id !== null;
+}
+var McpServer = class {
+  info;
+  tools = /* @__PURE__ */ new Map();
+  handlers = /* @__PURE__ */ new Map();
+  transport;
+  /** Set by the caller to learn when the peer hung up; `mcp-serve` waits on exactly this. */
+  onclose;
+  constructor(info) {
+    this.info = info;
+  }
+  /**
+   * Registers a tool. Schema generation happens here rather than at `tools/list` time, which also
+   * means a malformed shape fails loudly at startup instead of on a client's first listing.
+   */
+  registerTool(name, definition, handler) {
+    if (this.tools.has(name)) throw new Error(`MCP tool registered twice: ${name}`);
+    const shape = definition.inputSchema;
+    this.tools.set(name, {
+      name,
+      description: definition.description,
+      jsonSchema: buildJsonSchema(shape),
+      // An absent shape still needs a validator, so an argumentless tool called with arguments is
+      // not silently handed them.
+      validator: external_exports.object(shape ?? {})
+    });
+    this.handlers.set(name, handler);
+  }
+  /**
+   * Wires this server to a transport and starts it.
+   *
+   * `onmessage` is assigned before `start()` on purpose: a transport may have buffered messages
+   * that arrive the moment it starts (the SDK's in-memory transport queues anything sent before a
+   * handler exists and drains the queue inside `start()`), so a server that started first would
+   * drop the client's `initialize`.
+   */
+  async connect(transport) {
+    this.transport = transport;
+    transport.onmessage = (message) => {
+      void this.handleMessage(message);
+    };
+    transport.onclose = () => {
+      this.transport = void 0;
+      this.onclose?.();
+    };
+    await transport.start();
+  }
+  async close() {
+    const transport = this.transport;
+    this.transport = void 0;
+    await transport?.close();
+  }
+  async send(message) {
+    try {
+      await this.transport?.send(message);
+    } catch {
+    }
+  }
+  async handleMessage(message) {
+    if (!isRequest(message)) return;
+    const { id, method } = message;
+    const params = message.params ?? {};
+    try {
+      switch (method) {
+        case "initialize":
+          await this.send({ jsonrpc: "2.0", id, result: this.initializeResult(params) });
+          return;
+        case "ping":
+          await this.send({ jsonrpc: "2.0", id, result: {} });
+          return;
+        case "tools/list":
+          await this.send({ jsonrpc: "2.0", id, result: { tools: this.listTools() } });
+          return;
+        case "tools/call":
+          await this.send({ jsonrpc: "2.0", id, result: await this.callTool(params) });
+          return;
+        default:
+          await this.sendError(id, JSONRPC_METHOD_NOT_FOUND, `Method not found: ${method}`);
+          return;
+      }
+    } catch (err) {
+      await this.sendError(id, JSONRPC_INVALID_REQUEST, err instanceof Error ? err.message : String(err));
+    }
+  }
+  async sendError(id, code, message) {
+    await this.send({ jsonrpc: "2.0", id, error: { code, message } });
+  }
+  initializeResult(params) {
+    const requested = params["protocolVersion"];
+    const protocolVersion = typeof requested === "string" && SUPPORTED_PROTOCOL_VERSIONS.includes(requested) ? requested : LATEST_PROTOCOL_VERSION;
+    return {
+      protocolVersion,
+      // Tools only, and they never change after startup, so no `listChanged`. This is the one
+      // place we deliberately do not copy the SDK, which declares `listChanged: true` because its
+      // McpServer is *able* to send that notification. Token-goat registers every tool before it
+      // connects and never adds or removes one, so we would be promising a notification we can
+      // never have cause to send. No client behaviour turns on it either way -- a subscription
+      // that never fires and an absent subscription are the same thing when the list is fixed --
+      // so the honest declaration wins. Contrast the tool-error text below, which a model reads as
+      // content and is therefore matched to the SDK exactly.
+      capabilities: { tools: {} },
+      serverInfo: { name: this.info.name, version: this.info.version }
+    };
+  }
+  listTools() {
+    return [...this.tools.values()].map((tool) => ({
+      name: tool.name,
+      ...tool.description !== void 0 ? { description: tool.description } : {},
+      inputSchema: tool.jsonSchema,
+      // The SDK emits this for every tool it registers, and it is literally true of ours: we do
+      // not implement task augmentation, so a client that asks for it gets refused. Emitting the
+      // same thing keeps `tools/list` byte-identical to what token-goat sent before, which is what
+      // the differential test in tests/mcp_jsonrpc.test.ts pins.
+      execution: { taskSupport: "forbidden" }
+    }));
+  }
+  async callTool(params) {
+    const name = params["name"];
+    if (typeof name !== "string") return errorText('Invalid params: tools/call requires a string "name"');
+    const tool = this.tools.get(name);
+    const handler = this.handlers.get(name);
+    if (tool === void 0 || handler === void 0) return errorText(`${MCP_INVALID_PARAMS_PREFIX}Tool ${name} not found`);
+    const parsed = tool.validator.safeParse(params["arguments"] ?? {});
+    if (!parsed.success) {
+      return errorText(
+        `${MCP_INVALID_PARAMS_PREFIX}Input validation error: Invalid arguments for tool ${name}: ${describeParseError(parsed.error)}`
+      );
+    }
+    try {
+      return await handler(parsed.data);
+    } catch (err) {
+      return errorText(err instanceof Error ? err.message : String(err));
+    }
+  }
+};
+export {
+  JSONRPC_INVALID_PARAMS,
+  JSONRPC_INVALID_REQUEST,
+  JSONRPC_METHOD_NOT_FOUND,
+  LATEST_PROTOCOL_VERSION,
+  McpServer,
+  SUPPORTED_PROTOCOL_VERSIONS
+};

package/dist/{token-goat-chunk-65BKISIS.mjs → token-goat-chunk-73MF6YWW.mjs}

@@ -25,7 +25,7 @@ import {
   runSkeleton,
   runSymbol,
   withPinnedReads
-} from "./token-goat-chunk-IYTVE6KN.mjs";
+} from "./token-goat-chunk-RMDQFTQD.mjs";
 import {
   buildProjectMap,
   embeddingsDepsAvailable,
@@ -34,7 +34,7 @@ import {
   getProjectIndexCounts,
   isWorkerRunning,
   mapLookupBytesSaved
-} from "./token-goat-chunk-UFOVM7ZN.mjs";
+} from "./token-goat-chunk-2G6RAB4G.mjs";
 import {
   VERSION,
   dataDir,
@@ -45,7 +45,7 @@ import {
   normalizePath,
   recordStat,
   resolveProjectRoot
-} from "./token-goat-chunk-V465YKOR.mjs";
+} from "./token-goat-chunk-ELDJRLHZ.mjs";
 import "./token-goat-chunk-AO2QD2AG.mjs";
 import "./token-goat-chunk-AEX54RUZ.mjs";
 
@@ -201,7 +201,7 @@ function withConfinedRead(pins, fn) {
   }
 }
 async function createMcpServer() {
-  const [{ McpServer }, { z }] = await Promise.all([import("@modelcontextprotocol/sdk/server/mcp.js"), import("./token-goat-chunk-DG53MVNJ.mjs")]);
+  const [{ McpServer }, { z }] = await Promise.all([import("./token-goat-chunk-5CVKO3DA.mjs"), import("./token-goat-chunk-R4SR7MQY.mjs")]);
   const server = new McpServer({ name: "token-goat", version: VERSION });
   const makeProjectRootField = (verb) => z.string().optional().describe(
     `absolute path to the workspace root to scope this ${verb} to; defaults to the MCP server process's cwd, which is not always the actual workspace root for MCP clients -- pass this explicitly when it might differ`

package/dist/{token-goat-chunk-MGOUYAA2.mjs → token-goat-chunk-7JDXDERZ.mjs}

@@ -4,7 +4,7 @@ import {
   loadConfig,
   redactSecrets,
   stripAnsiCodes
-} from "./token-goat-chunk-V465YKOR.mjs";
+} from "./token-goat-chunk-ELDJRLHZ.mjs";
 
 // src/tool_filters/helpers.ts
 import * as fs from "node:fs";