@goke/mcp 0.0.5 → 0.0.6

package/README.md

@@ -62,6 +62,62 @@ notion-mcp-cli notion-retrieve-page --page_id "abc123"
 notion-mcp-cli notion-list-users
 ```
 
+## Turn a goke CLI into an MCP server
+
+`addCliToolsToMcp()` does the inverse mapping: every CLI command becomes an MCP tool.
+
+- Command description → MCP tool description
+- Option schema (Zod or any Standard Schema library) → MCP `inputSchema` JSON Schema
+- Command names are sanitized into valid MCP tool names (invalid characters become `_`)
+- Composable with existing MCP tools already registered on the same server
+
+### With low-level `Server`
+
+```ts
+import { goke } from "goke"
+import { z } from "zod"
+import { Server } from "@modelcontextprotocol/sdk/server/index.js"
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
+import { addCliToolsToMcp } from "@goke/mcp"
+
+const cli = goke("my-cli")
+
+cli
+  .command("notion search", "Search Notion pages")
+  .option("--query <query>", z.string().describe("Search query"))
+  .action((options) => ({ query: options.query }))
+
+const server = new Server(
+  { name: "my-cli-mcp", version: "1.0.0" },
+  { capabilities: {} },
+)
+
+addCliToolsToMcp({ cli, server })
+
+const transport = new StdioServerTransport()
+await server.connect(transport)
+```
+
+Run it with Node:
+
+```bash
+node dist/server.js
+```
+
+### With high-level `McpServer`
+
+```ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js"
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
+import { addCliToolsToMcp } from "@goke/mcp"
+
+const mcp = new McpServer({ name: "my-cli-mcp", version: "1.0.0" })
+addCliToolsToMcp({ cli, server: mcp })
+
+const transport = new StdioServerTransport()
+await mcp.connect(transport)
+```
+
 ## Full example (with config persistence)
 
 This is the pattern used by [notion-mcp-cli](../notion-mcp-cli):

package/dist/src/auth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth.d.ts","sourceRoot":"","sources":["../../src/auth.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAiB,eAAe,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AA0BxF;;;;;;;;;;;;GAYG;AACH,wBAAsB,cAAc,CAAC,OAAO,EAAE,qBAAqB,GAAG,OAAO,CAAC,eAAe,CAAC,CA4E7F;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAazD"}

package/dist/src/cli-to-mcp.d.ts

@@ -0,0 +1,17 @@
+/**
+ * CLI to MCP adapter.
+ *
+ * Exposes goke commands as MCP tools on either a low-level Server
+ * or a high-level McpServer by mounting tools/list + tools/call handlers.
+ */
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { type Goke } from "goke";
+export interface AddCliToolsToMcpOptions {
+    cli: Goke;
+    server: Server | McpServer;
+    commandFilter?: (commandName: string) => boolean;
+    sanitizeToolName?: (commandName: string) => string;
+}
+export declare function addCliToolsToMcp(options: AddCliToolsToMcpOptions): void;
+//# sourceMappingURL=cli-to-mcp.d.ts.map

package/dist/src/cli-to-mcp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli-to-mcp.d.ts","sourceRoot":"","sources":["../../src/cli-to-mcp.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AACzE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,2CAA2C,CAAC;AASxE,OAAO,EAAmD,KAAK,IAAI,EAA6B,MAAM,MAAM,CAAC;AAwD7G,MAAM,WAAW,uBAAuB;IACtC,GAAG,EAAE,IAAI,CAAC;IACV,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3B,aAAa,CAAC,EAAE,CAAC,WAAW,EAAE,MAAM,KAAK,OAAO,CAAC;IACjD,gBAAgB,CAAC,EAAE,CAAC,WAAW,EAAE,MAAM,KAAK,MAAM,CAAC;CACpD;AA4XD,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,uBAAuB,GAAG,IAAI,CAyCvE"}

package/dist/src/cli-to-mcp.js

@@ -0,0 +1,380 @@
+/**
+ * CLI to MCP adapter.
+ *
+ * Exposes goke commands as MCP tools on either a low-level Server
+ * or a high-level McpServer by mounting tools/list + tools/call handlers.
+ */
+import { CallToolRequestSchema, ErrorCode, ListToolsRequestSchema, McpError, } from "@modelcontextprotocol/sdk/types.js";
+import { coerceBySchema, extractJsonSchema } from "goke";
+const CLI_TO_MCP_STATE = Symbol.for("@goke/mcp/cli-to-mcp-state");
+function isMountableCommand(command, commandFilter) {
+    if (!command.commandAction) {
+        return false;
+    }
+    if (command.name === "") {
+        return false;
+    }
+    if (commandFilter && !commandFilter(command.name)) {
+        return false;
+    }
+    return true;
+}
+function isMcpServer(value) {
+    return "server" in value;
+}
+function resolveServer(value) {
+    if (isMcpServer(value)) {
+        return value.server;
+    }
+    return value;
+}
+function getToolCallArguments(args, name) {
+    if (name in args) {
+        return args[name];
+    }
+    const parts = name.split(".");
+    let current = args;
+    for (const part of parts) {
+        if (current != null && typeof current === "object" && part in current) {
+            current = current[part];
+        }
+        else {
+            return undefined;
+        }
+    }
+    return current;
+}
+function setDotProp(target, keys, value) {
+    let current = target;
+    for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
+        if (i === keys.length - 1) {
+            current[key] = value;
+            return;
+        }
+        const existing = current[key];
+        if (existing != null && typeof existing === "object" && !Array.isArray(existing)) {
+            current = existing;
+            continue;
+        }
+        const next = {};
+        current[key] = next;
+        current = next;
+    }
+}
+function defaultSanitizeToolName(commandName) {
+    let name = commandName.trim();
+    name = name.replace(/\s+/g, "_");
+    name = name.replace(/[^A-Za-z0-9._-]/g, "_");
+    name = name.replace(/_+/g, "_");
+    name = name.replace(/^[._-]+|[._-]+$/g, "");
+    if (!name) {
+        name = "tool";
+    }
+    if (name.length > 128) {
+        name = name.slice(0, 128);
+    }
+    return name;
+}
+function uniqueToolName(baseName, usedNames) {
+    if (!usedNames.has(baseName)) {
+        return baseName;
+    }
+    for (let i = 2; i < 10_000; i++) {
+        const suffix = `_${i}`;
+        const prefixMax = 128 - suffix.length;
+        const candidate = `${baseName.slice(0, Math.max(1, prefixMax))}${suffix}`;
+        if (!usedNames.has(candidate)) {
+            return candidate;
+        }
+    }
+    throw new Error(`Unable to generate a unique MCP tool name for ${baseName}`);
+}
+function normalizeOptionSchema(option) {
+    const schemaFromOption = option.schema ? extractJsonSchema(option.schema) : undefined;
+    const schema = schemaFromOption ? { ...schemaFromOption } : {
+        type: option.isBoolean ? "boolean" : "string",
+    };
+    if (typeof schema.description !== "string" && option.description) {
+        schema.description = option.description;
+    }
+    if (schema.default === undefined && option.default !== undefined) {
+        schema.default = option.default;
+    }
+    return { schema, jsonSchema: schemaFromOption };
+}
+function commandDescription(command) {
+    const description = command.description.trim();
+    if (description) {
+        return description;
+    }
+    return `Run CLI command ${command.name}`;
+}
+function formatTextResult(value) {
+    if (typeof value === "string") {
+        return value;
+    }
+    if (value == null) {
+        return "";
+    }
+    if (typeof value === "number" || typeof value === "boolean") {
+        return String(value);
+    }
+    try {
+        return JSON.stringify(value, null, 2);
+    }
+    catch {
+        return String(value);
+    }
+}
+function toCallToolResult(value) {
+    if (value && typeof value === "object" && "content" in value) {
+        return value;
+    }
+    return {
+        content: [{
+                type: "text",
+                text: formatTextResult(value),
+            }],
+    };
+}
+function getExistingRequestHandler(server, method) {
+    const handlerMap = server._requestHandlers;
+    if (!(handlerMap instanceof Map)) {
+        return undefined;
+    }
+    return handlerMap.get(method);
+}
+function isToolNotFoundError(error, toolName) {
+    if (!(error instanceof McpError)) {
+        return false;
+    }
+    if (error.code !== ErrorCode.InvalidParams) {
+        return false;
+    }
+    const message = String(error.message).toLowerCase();
+    return message.includes("tool") && message.includes("not found") && message.includes(toolName.toLowerCase());
+}
+function isToolNotFoundResult(result, toolName) {
+    if (!result || typeof result !== "object") {
+        return false;
+    }
+    const maybe = result;
+    if (!maybe.isError || !Array.isArray(maybe.content)) {
+        return false;
+    }
+    const textBlock = maybe.content.find((entry) => entry?.type === "text");
+    const text = String(textBlock?.text ?? "").toLowerCase();
+    return text.includes("tool") && text.includes("not found") && text.includes(toolName.toLowerCase());
+}
+async function runCliTool(binding, argumentsObject) {
+    for (const requiredName of binding.requiredNames) {
+        if (getToolCallArguments(argumentsObject, requiredName) === undefined) {
+            throw new McpError(ErrorCode.InvalidParams, `Missing required argument: ${requiredName}`);
+        }
+    }
+    const positionalValues = [];
+    for (const arg of binding.positionalArgs) {
+        const value = getToolCallArguments(argumentsObject, arg.value);
+        if (arg.variadic) {
+            if (value === undefined) {
+                positionalValues.push([]);
+            }
+            else if (Array.isArray(value)) {
+                positionalValues.push(value.map((entry) => String(entry)));
+            }
+            else {
+                positionalValues.push([String(value)]);
+            }
+        }
+        else {
+            positionalValues.push(value === undefined ? undefined : String(value));
+        }
+    }
+    const optionsObject = {};
+    for (const option of binding.options) {
+        let optionValue = getToolCallArguments(argumentsObject, option.name);
+        if (optionValue === undefined && option.defaultValue !== undefined) {
+            optionValue = option.defaultValue;
+        }
+        if (optionValue !== undefined && option.jsonSchema) {
+            const isStringArray = Array.isArray(optionValue) && optionValue.every((value) => typeof value === "string");
+            const isCoercibleType = typeof optionValue === "string" || typeof optionValue === "boolean" || isStringArray;
+            if (isCoercibleType) {
+                optionValue = coerceBySchema(optionValue, option.jsonSchema, option.name);
+            }
+        }
+        if (optionValue !== undefined) {
+            setDotProp(optionsObject, option.name.split("."), optionValue);
+        }
+    }
+    const action = binding.command.commandAction;
+    if (!action) {
+        throw new McpError(ErrorCode.InvalidParams, `Command ${binding.command.name} has no action`);
+    }
+    try {
+        const result = await Promise.resolve(action(...positionalValues, optionsObject));
+        return toCallToolResult(result);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            isError: true,
+            content: [{ type: "text", text: message }],
+        };
+    }
+}
+function createBinding(command, toolName) {
+    const positionalArgs = command.args;
+    const options = command.options;
+    const properties = {};
+    const requiredNames = [];
+    const optionBindings = [];
+    for (const arg of positionalArgs) {
+        if (arg.variadic) {
+            properties[arg.value] = {
+                type: "array",
+                items: { type: "string" },
+                description: `Positional argument ${arg.value}`,
+            };
+        }
+        else {
+            properties[arg.value] = {
+                type: "string",
+                description: `Positional argument ${arg.value}`,
+            };
+        }
+        if (arg.required) {
+            requiredNames.push(arg.value);
+        }
+    }
+    for (const option of options) {
+        const normalized = normalizeOptionSchema(option);
+        properties[option.name] = normalized.schema;
+        if (option.required) {
+            requiredNames.push(option.name);
+        }
+        optionBindings.push({
+            name: option.name,
+            defaultValue: option.default,
+            jsonSchema: normalized.jsonSchema,
+        });
+    }
+    const inputSchema = {
+        type: "object",
+        properties,
+        ...(requiredNames.length > 0 ? { required: Array.from(new Set(requiredNames)) } : {}),
+    };
+    return {
+        tool: {
+            name: toolName,
+            description: commandDescription(command),
+            inputSchema,
+        },
+        command,
+        positionalArgs,
+        options: optionBindings,
+        requiredNames: Array.from(new Set(requiredNames)),
+    };
+}
+function getOrInstallState(server) {
+    const serverWithState = server;
+    const existing = serverWithState[CLI_TO_MCP_STATE];
+    if (existing) {
+        return existing;
+    }
+    const existingListHandler = getExistingRequestHandler(server, "tools/list");
+    const existingCallHandler = getExistingRequestHandler(server, "tools/call");
+    if (!existingListHandler && !existingCallHandler) {
+        server.registerCapabilities({ tools: { listChanged: true } });
+    }
+    const state = {
+        toolsByName: new Map(),
+        commandToToolName: new Map(),
+    };
+    server.setRequestHandler(ListToolsRequestSchema, async (request, extra) => {
+        const localTools = Array.from(state.toolsByName.values()).map((binding) => binding.tool);
+        if (!existingListHandler) {
+            return { tools: localTools };
+        }
+        const previousResult = await Promise.resolve(existingListHandler(request, extra));
+        const merged = new Map();
+        for (const tool of previousResult.tools ?? []) {
+            merged.set(tool.name, tool);
+        }
+        for (const tool of localTools) {
+            if (!merged.has(tool.name)) {
+                merged.set(tool.name, tool);
+            }
+        }
+        return {
+            ...previousResult,
+            tools: Array.from(merged.values()),
+        };
+    });
+    server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
+        const binding = state.toolsByName.get(request.params.name);
+        const argumentsObject = request.params.arguments ?? {};
+        if (existingCallHandler) {
+            try {
+                const existingResult = await Promise.resolve(existingCallHandler(request, extra));
+                if (binding && isToolNotFoundResult(existingResult, request.params.name)) {
+                    return runCliTool(binding, argumentsObject);
+                }
+                return existingResult;
+            }
+            catch (error) {
+                if (!binding || !isToolNotFoundError(error, request.params.name)) {
+                    throw error;
+                }
+            }
+        }
+        if (!binding) {
+            throw new McpError(ErrorCode.InvalidParams, `Tool ${request.params.name} not found`);
+        }
+        return runCliTool(binding, argumentsObject);
+    });
+    Object.defineProperty(serverWithState, CLI_TO_MCP_STATE, {
+        value: state,
+        enumerable: false,
+        writable: false,
+        configurable: false,
+    });
+    return state;
+}
+export function addCliToolsToMcp(options) {
+    const { cli, commandFilter, sanitizeToolName = defaultSanitizeToolName } = options;
+    const server = resolveServer(options.server);
+    const state = getOrInstallState(server);
+    const usedNames = new Set(state.toolsByName.keys());
+    const activeCommandNames = new Set();
+    for (const command of cli.commands) {
+        if (isMountableCommand(command, commandFilter)) {
+            activeCommandNames.add(command.name);
+        }
+    }
+    for (const [commandName, toolName] of state.commandToToolName) {
+        if (!activeCommandNames.has(commandName)) {
+            state.commandToToolName.delete(commandName);
+            state.toolsByName.delete(toolName);
+            usedNames.delete(toolName);
+        }
+    }
+    for (const command of cli.commands) {
+        if (!isMountableCommand(command, commandFilter)) {
+            continue;
+        }
+        const existingToolName = state.commandToToolName.get(command.name);
+        if (existingToolName) {
+            state.toolsByName.delete(existingToolName);
+            state.commandToToolName.delete(command.name);
+            usedNames.delete(existingToolName);
+        }
+        const baseToolName = defaultSanitizeToolName(sanitizeToolName(command.name));
+        const toolName = uniqueToolName(baseToolName, usedNames);
+        usedNames.add(toolName);
+        const binding = createBinding(command, toolName);
+        state.toolsByName.set(toolName, binding);
+        state.commandToToolName.set(command.name, toolName);
+    }
+}

package/dist/{index.d.ts → src/index.d.ts}

@@ -42,6 +42,8 @@
 import type { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
 import type { Goke } from "goke";
 import type { McpOAuthConfig } from "./types.js";
+export { addCliToolsToMcp } from "./cli-to-mcp.js";
+export type { AddCliToolsToMcpOptions } from "./cli-to-mcp.js";
 export type { Transport };
 export type { McpOAuthConfig, McpOAuthState } from "./types.js";
 export interface CachedMcpTools {

package/dist/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AAIH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,+CAA+C,CAAC;AAC/E,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AAKjC,OAAO,KAAK,EAAE,cAAc,EAAiB,MAAM,YAAY,CAAC;AAChE,OAAO,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AACnD,YAAY,EAAE,uBAAuB,EAAE,MAAM,iBAAiB,CAAC;AAG/D,YAAY,EAAE,SAAS,EAAE,CAAC;AAC1B,YAAY,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAEhE,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,KAAK,CAAC;QACX,IAAI,EAAE,MAAM,CAAC;QACb,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,WAAW,CAAC,EAAE,OAAO,CAAC;KACvB,CAAC,CAAC;IACH,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAID,MAAM,WAAW,qBAAqB;IACpC,GAAG,EAAE,IAAI,CAAC;IACV;;;;OAIG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,MAAM,GAAG,SAAS,CAAC;IAErC;;;;;;OAMG;IACH,eAAe,CAAC,EAAE,CAAC,SAAS,CAAC,EAAE,MAAM,KAAK,SAAS,GAAG,IAAI,GAAG,OAAO,CAAC,SAAS,GAAG,IAAI,CAAC,CAAC;IAEvF;;;;;;;;;;;;;;OAcG;IACH,KAAK,CAAC,EAAE,cAAc,CAAC;IAEvB;;OAEG;IACH,SAAS,EAAE,MAAM,cAAc,GAAG,SAAS,CAAC;IAE5C;;OAEG;IACH,SAAS,EAAE,CAAC,KAAK,EAAE,cAAc,GAAG,SAAS,KAAK,IAAI,CAAC;CACxD;AAmID;;;;;;;;GAQG;AACH,wBAAsB,cAAc,CAAC,OAAO,EAAE,qBAAqB,GAAG,OAAO,CAAC,IAAI,CAAC,CAyMlF"}

package/dist/{index.js → src/index.js}

@@ -45,6 +45,7 @@ import { wrapJsonSchema } from "goke";
 import yaml from "js-yaml";
 import { FileOAuthProvider } from "./oauth-provider.js";
 import { startOAuthFlow, isAuthRequiredError } from "./auth.js";
+export { addCliToolsToMcp } from "./cli-to-mcp.js";
 const CACHE_TTL_MS = 60 * 60 * 1000; // 1 hour
 /**
  * Check if a schema represents a complex type (object/array) for help text display.
@@ -274,7 +275,7 @@ export async function addMcpCommands(options) {
                 }
                 else {
                     // Wrap the MCP tool's JSON Schema property into a StandardJSONSchemaV1
-                    // object so Goke can use it for type coercion (string → typed value).
+                    // so goke can use it for type coercion.
                     // Put the enriched description into the JSON Schema so it's extracted automatically.
                     // Boolean flags with defaults also go through this path to preserve the default.
                     const enrichedSchema = { ...propSchema, description: optionDesc };

package/dist/src/local-callback-server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"local-callback-server.d.ts","sourceRoot":"","sources":["../../src/local-callback-server.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AA2FxE;;;;;GAKG;AACH,wBAAsB,mBAAmB,CAAC,OAAO,GAAE,qBAA0B,GAAG,OAAO,CAAC;IACtF,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,eAAe,EAAE,MAAM,OAAO,CAAC,cAAc,CAAC,CAAC;IAC/C,KAAK,EAAE,MAAM,IAAI,CAAC;CACnB,CAAC,CAgFD"}

package/dist/src/oauth-provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"oauth-provider.d.ts","sourceRoot":"","sources":["../../src/oauth-provider.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,0CAA0C,CAAC;AACpF,OAAO,KAAK,EACV,sBAAsB,EACtB,0BAA0B,EAC1B,mBAAmB,EACnB,WAAW,EACZ,MAAM,0CAA0C,CAAC;AAClD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAEhD,MAAM,WAAW,wBAAwB;IACvC,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,iBAAiB,CAAC,EAAE,sBAAsB,CAAC;IAC3C,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;OAGG;IACH,cAAc,CAAC,EAAE,CAAC,KAAK,EAAE,aAAa,KAAK,IAAI,CAAC;CACjD;AAED;;;;;;GAMG;AACH,qBAAa,iBAAkB,YAAW,mBAAmB;IAC3D,OAAO,CAAC,kBAAkB,CAAqC;IAC/D,OAAO,CAAC,aAAa,CAAqB;IAC1C,OAAO,CAAC,OAAO,CAA0B;IACzC,OAAO,CAAC,qBAAqB,CAAkB;IAE/C,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;IACrC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;IACpC,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAC,CAAiC;gBAErD,OAAO,EAAE,wBAAwB;IAU7C,IAAI,WAAW,IAAI,MAAM,CAExB;IAED;;;OAGG;IACH,IAAI,oBAAoB,IAAI,GAAG,GAAG,SAAS,CAE1C;IAEK,iBAAiB,IAAI,OAAO,CAAC,sBAAsB,GAAG,SAAS,CAAC;IAIhE,qBAAqB,CAAC,iBAAiB,EAAE,0BAA0B,GAAG,OAAO,CAAC,IAAI,CAAC;IAKnF,YAAY,IAAI,OAAO,CAAC,MAAM,CAAC;IAO/B,gBAAgB,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAK3D,IAAI,cAAc,IAAI,mBAAmB,CAKxC;IAED;;;OAGG;IACH,uBAAuB,CAAC,gBAAgB,EAAE,GAAG,GAAG,IAAI;IAI9C,MAAM,IAAI,OAAO,CAAC,WAAW,GAAG,SAAS,CAAC;IAI1C,UAAU,CAAC,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;IAKpD;;OAEG;IACH,QAAQ,IAAI,aAAa;IASzB,OAAO,CAAC,kBAAkB;CAK3B;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,wBAAwB,GAAG,iBAAiB,CAE5F"}

package/dist/src/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,sBAAsB,EAAE,MAAM,0CAA0C,CAAC;AAEpG;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,iBAAiB,CAAC,EAAE,sBAAsB,CAAC;IAC3C,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,oDAAoD;IACpD,UAAU,EAAE,MAAM,CAAC;IAEnB;;OAEG;IACH,IAAI,EAAE,MAAM,aAAa,GAAG,SAAS,CAAC;IAEtC;;;OAGG;IACH,IAAI,EAAE,CAAC,KAAK,EAAE,aAAa,GAAG,SAAS,KAAK,IAAI,CAAC;IAEjD;;;OAGG;IACH,SAAS,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;IAElC;;OAEG;IACH,aAAa,CAAC,EAAE,MAAM,IAAI,CAAC;IAE3B;;OAEG;IACH,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;CACvC;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,aAAa,CAAC;IACtB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,mDAAmD;IACnD,aAAa,CAAC,EAAE,aAAa,CAAC;IAC9B,kDAAkD;IAClD,SAAS,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;IAClC,4DAA4D;IAC5D,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,sDAAsD;IACtD,OAAO,CAAC,EAAE,CAAC,WAAW,EAAE,MAAM,KAAK,IAAI,CAAC;IACxC,uCAAuC;IACvC,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;CACf"}

package/dist/test/add-cli-tools-to-mcp.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * End-to-end tests for exposing a goke CLI as MCP tools.
+ */
+export {};
+//# sourceMappingURL=add-cli-tools-to-mcp.test.d.ts.map

package/dist/test/add-cli-tools-to-mcp.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"add-cli-tools-to-mcp.test.d.ts","sourceRoot":"","sources":["../../test/add-cli-tools-to-mcp.test.ts"],"names":[],"mappings":"AAAA;;GAEG"}