@introspection-ai/recipes 0.13.0 → 0.14.0

package/dist/mcp-chunks/emit-ts-command-VBXVXO6V.js

@@ -0,0 +1,386 @@
+import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
+import {
+  extractGeneratorFlags,
+  readPackageMetadata
+} from "./chunk-DHBE7UBH.js";
+import {
+  buildToolDoc
+} from "./chunk-MZ2NARG7.js";
+import {
+  loadToolMetadata
+} from "./chunk-IABRYROW.js";
+import "./chunk-XANPGTLI.js";
+import "./chunk-N46NEFAF.js";
+import "./chunk-BNV3TPE4.js";
+import {
+  findServerByHttpUrl
+} from "./chunk-TEUKFFQL.js";
+import {
+  extractHttpServerTarget
+} from "./chunk-M3TPODXI.js";
+import {
+  consumeOutputFormat
+} from "./chunk-YVZKMV5H.js";
+import "./chunk-4SQKWYFF.js";
+import "./chunk-LRKZP7DJ.js";
+
+// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/cli/emit-ts-command.js
+import fs from "node:fs/promises";
+import path2 from "node:path";
+
+// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/cli/emit-ts-templates.js
+import path from "node:path";
+function renderTypesModule(input) {
+  const lines = [];
+  lines.push(...renderHeader(input.metadata));
+  lines.push("import type { CallResult } from 'mcporter';");
+  lines.push("");
+  lines.push(`export interface ${input.interfaceName} {`);
+  input.docs.forEach((entry, index) => {
+    lines.push(...renderDocComment(entry.doc.docLines, "  "));
+    const methodSignature = toInterfaceSignature(entry.doc.tsSignature, entry.toolName, { wrapInPromise: true });
+    lines.push(`  ${methodSignature}`);
+    if (entry.doc.optionalSummary) {
+      lines.push(`  // ${entry.doc.optionalSummary.replace(/^\/\//, "").trim()}`);
+    }
+    if (index !== input.docs.length - 1) {
+      lines.push("");
+    }
+  });
+  if (input.docs.length === 0) {
+    lines.push("  // No tools reported for this server.");
+  }
+  lines.push("}");
+  lines.push("");
+  return lines.join("\n");
+}
+function renderClientModule(input) {
+  const lines = [];
+  lines.push(...renderHeader(input.metadata));
+  lines.push("import { createRuntime, createServerProxy, wrapCallResult } from 'mcporter';");
+  lines.push(`import type { ${input.interfaceName} } from '${input.typesImportPath}';`);
+  lines.push("");
+  lines.push("type RuntimeInstance = Awaited<ReturnType<typeof createRuntime>>;");
+  const clientType = `${input.interfaceName.replace(/Tools$/, "Client")}`;
+  const factoryName = `create${input.interfaceName.replace(/Tools$/, "")}Client`;
+  const serverName = input.metadata.server.name;
+  lines.push(`export type ${clientType} = ${input.interfaceName} & { close(): Promise<void> };`);
+  lines.push("");
+  lines.push("export interface CreateClientOptions {");
+  lines.push("  runtime?: RuntimeInstance;");
+  lines.push("  configPath?: string;");
+  lines.push("  rootDir?: string;");
+  lines.push("}");
+  lines.push("");
+  lines.push(`export async function ${factoryName}(options: CreateClientOptions = {}): Promise<${clientType}> {`);
+  lines.push("  const runtime = options.runtime ?? (await createRuntime({");
+  lines.push("    configPath: options.configPath,");
+  lines.push("    rootDir: options.rootDir,");
+  lines.push("  }));");
+  lines.push("  const ownsRuntime = !options.runtime;");
+  lines.push(`  const proxy = createServerProxy(runtime, ${JSON.stringify(serverName)});`);
+  lines.push(`  const client: ${clientType} = {`);
+  input.docs.forEach((entry, _index) => {
+    const memberName = toMemberName(entry.toolName);
+    const indexKey = toIndexKey(entry.toolName);
+    lines.push(`    async ${memberName}(params: Parameters<${input.interfaceName}[${indexKey}]>[0]) {`);
+    lines.push(`      const tool = proxy.${entry.methodName} as (args: Parameters<${input.interfaceName}[${indexKey}]>[0]) => Promise<unknown>;`);
+    lines.push("      const raw = await tool(params);");
+    lines.push("      return wrapCallResult(raw).callResult;");
+    lines.push("    },");
+    lines.push("");
+  });
+  lines.push("    async close() {");
+  lines.push("      if (ownsRuntime) {");
+  lines.push(`        await runtime.close(${JSON.stringify(serverName)}).catch(() => {});`);
+  lines.push("      }");
+  lines.push("    },");
+  lines.push("  };");
+  lines.push("  return client;");
+  lines.push("}");
+  lines.push("");
+  return lines.join("\n");
+}
+function renderHeader(metadata) {
+  const lines = [];
+  const timestamp = metadata.generatedAt.toISOString();
+  lines.push(`// Generated on ${timestamp} by ${metadata.generatorLabel}`);
+  if (metadata.server.description) {
+    lines.push(`// Server: ${metadata.server.name} \u2014 ${metadata.server.description}`);
+  } else {
+    lines.push(`// Server: ${metadata.server.name}`);
+  }
+  const source = describeSource(metadata.server);
+  if (source) {
+    lines.push(`// Source: ${source}`);
+  }
+  const transport = describeTransport(metadata.server);
+  if (transport) {
+    lines.push(`// Transport: ${transport}`);
+  }
+  lines.push("");
+  return lines;
+}
+function renderDocComment(docLines, indent) {
+  if (!docLines || docLines.length === 0) {
+    return [];
+  }
+  return docLines.map((line) => `${indent}${line}`);
+}
+function toInterfaceSignature(signature, toolName, options) {
+  const trimmed = signature.trim();
+  const match = trimmed.match(/^function\s+([^(]+)\((.*)\)\s*(?::\s*([^;]+))?;?$/);
+  if (!match) {
+    return trimmed.replace(/^function\s+/, "");
+  }
+  const [, , params, returnTypeRaw] = match;
+  const returnType = (returnTypeRaw ?? "void").trim();
+  const finalReturn = options?.wrapInPromise ? `Promise<${returnType}>` : returnType;
+  return `${toMemberName(toolName)}(${params}): ${finalReturn};`;
+}
+var SAFE_IDENTIFIER = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+function toMemberName(name) {
+  return SAFE_IDENTIFIER.test(name) ? name : JSON.stringify(name);
+}
+function toIndexKey(name) {
+  return JSON.stringify(name);
+}
+function describeTransport(definition) {
+  if (definition.command.kind === "http") {
+    const url = definition.command.url instanceof URL ? definition.command.url.href : String(definition.command.url);
+    return `HTTP ${url}`;
+  }
+  if (definition.command.kind === "stdio") {
+    const cmd = [definition.command.command, ...definition.command.args ?? []].join(" ").trim();
+    return cmd.length > 0 ? `STDIO ${cmd}` : "STDIO";
+  }
+  return void 0;
+}
+function describeSource(definition) {
+  if (definition.source?.kind === "import") {
+    return path.normalize(definition.source.path);
+  }
+  if (definition.source?.kind === "local") {
+    return definition.source.path;
+  }
+  return void 0;
+}
+
+// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/cli/emit-ts-command.js
+async function handleEmitTs(runtime, args) {
+  const options = parseEmitTsArgs(args);
+  const definition = getServerDefinition(runtime, options.server);
+  const metadataEntries = await loadToolMetadata(runtime, options.server, {
+    includeSchema: true,
+    autoAuthorize: false
+  });
+  const generator = await readPackageMetadata();
+  const metadata = {
+    server: definition,
+    generatorLabel: `${generator.name}@${generator.version}`,
+    generatedAt: /* @__PURE__ */ new Date()
+  };
+  const docEntries = buildDocEntries(options.server, metadataEntries, options.includeOptional);
+  const interfaceName = buildInterfaceName(options.server);
+  if (options.mode === "types") {
+    const source = renderTypesModule({ interfaceName, docs: docEntries, metadata });
+    await writeFile(options.outPath, source);
+    if (options.format === "json") {
+      console.log(JSON.stringify({
+        mode: "types",
+        server: options.server,
+        outPath: options.outPath
+      }, null, 2));
+    } else {
+      console.log(`Emitted TypeScript definitions for ${options.server} \u2192 ${options.outPath}`);
+    }
+    return;
+  }
+  const typesOutPath = options.typesOutPath ?? deriveTypesOutPath(options.outPath);
+  const relativeImportPath = computeImportPath(options.outPath, typesOutPath);
+  const typesSource = renderTypesModule({ interfaceName, docs: docEntries, metadata });
+  const clientSource = renderClientModule({
+    interfaceName,
+    docs: docEntries,
+    metadata,
+    typesImportPath: relativeImportPath
+  });
+  await writeFile(typesOutPath, typesSource);
+  await writeFile(options.outPath, clientSource);
+  if (options.format === "json") {
+    console.log(JSON.stringify({
+      mode: "client",
+      server: options.server,
+      clientOutPath: options.outPath,
+      typesOutPath
+    }, null, 2));
+  } else {
+    console.log(`Emitted client + types for ${options.server} \u2192 ${options.outPath} / ${typesOutPath}`);
+  }
+}
+function printEmitTsHelp() {
+  console.error([
+    "Usage: mcporter emit-ts <server> --out <file> [flags]",
+    "",
+    "Flags:",
+    "  --mode types|client     Emit declarations only or client + declarations.",
+    "  --out <path>            Output .ts/.d.ts file.",
+    "  --types-out <path>      Declaration output path for --mode client.",
+    "  --include-optional      Include optional schema fields in signatures.",
+    "  --json                  Print a JSON summary."
+  ].join("\n"));
+}
+function parseEmitTsArgs(args) {
+  const flags = {
+    mode: "types",
+    includeOptional: false,
+    format: "text"
+  };
+  const common = extractGeneratorFlags(args, { allowIncludeOptional: true });
+  if (common.includeOptional) {
+    flags.includeOptional = true;
+  }
+  flags.format = consumeOutputFormat(args, {
+    defaultFormat: "text",
+    allowed: ["text", "json"],
+    enableRawShortcut: false,
+    jsonShortcutFlag: "--json"
+  });
+  let index = 0;
+  while (index < args.length) {
+    const token = args[index];
+    if (!token) {
+      index += 1;
+      continue;
+    }
+    if (token === "--out") {
+      const value = args[index + 1];
+      if (!value) {
+        throw new Error("Flag '--out' requires a path.");
+      }
+      flags.outPath = value;
+      args.splice(index, 2);
+      continue;
+    }
+    if (token === "--types-out") {
+      const value = args[index + 1];
+      if (!value) {
+        throw new Error("Flag '--types-out' requires a path.");
+      }
+      flags.typesOutPath = value;
+      args.splice(index, 2);
+      continue;
+    }
+    if (token === "--mode") {
+      const value = args[index + 1];
+      if (value !== "types" && value !== "client") {
+        throw new Error("--mode must be 'types' or 'client'.");
+      }
+      flags.mode = value;
+      args.splice(index, 2);
+      continue;
+    }
+    if (token.startsWith("--")) {
+      throw new Error(`Unknown flag '${token}' for emit-ts.`);
+    }
+    index += 1;
+  }
+  const server = args.shift();
+  if (!server) {
+    throw new Error("Usage: mcporter emit-ts <server> --out <file> [--mode types|client]");
+  }
+  const outPath = flags.outPath;
+  if (!outPath) {
+    throw new Error("Flag '--out' is required for emit-ts.");
+  }
+  if (flags.mode === "client" && !outPath.endsWith(".ts")) {
+    throw new Error("--out should point to a .ts file when --mode client is used.");
+  }
+  if (flags.mode === "types" && !outPath.endsWith(".ts") && !outPath.endsWith(".d.ts")) {
+    throw new Error("--out should be a .ts or .d.ts file for --mode types.");
+  }
+  return {
+    server,
+    outPath: path2.resolve(outPath),
+    mode: flags.mode,
+    includeOptional: flags.includeOptional,
+    typesOutPath: flags.typesOutPath ? path2.resolve(flags.typesOutPath) : void 0,
+    format: flags.format
+  };
+}
+function getServerDefinition(runtime, selector) {
+  try {
+    return runtime.getDefinition(selector);
+  } catch (error) {
+    const resolved = resolveHttpServerName(runtime, selector);
+    if (resolved) {
+      return runtime.getDefinition(resolved);
+    }
+    if (error instanceof Error) {
+      throw new Error(error.message, { cause: error });
+    }
+    throw error;
+  }
+}
+function resolveHttpServerName(runtime, selector) {
+  const target = extractHttpServerTarget(selector);
+  if (!target) {
+    return void 0;
+  }
+  return findServerByHttpUrl(runtime.getDefinitions(), target);
+}
+function buildDocEntries(serverName, metadataEntries, includeOptional) {
+  return metadataEntries.map((entry) => {
+    const doc = buildToolDoc({
+      serverName,
+      toolName: entry.tool.name,
+      description: entry.tool.description,
+      outputSchema: entry.tool.outputSchema,
+      options: entry.options,
+      requiredOnly: !includeOptional,
+      colorize: false,
+      defaultReturnType: "CallResult"
+    });
+    return {
+      toolName: entry.tool.name,
+      methodName: entry.methodName,
+      doc
+    };
+  });
+}
+function buildInterfaceName(serverName) {
+  const cleaned = serverName.split(/[^A-Za-z0-9]+/).filter(Boolean).map((segment) => segment.charAt(0).toUpperCase() + segment.slice(1)).join("");
+  const base = cleaned.length > 0 ? cleaned : "Server";
+  return `${base}Tools`;
+}
+function deriveTypesOutPath(tsPath) {
+  const dir = path2.dirname(tsPath);
+  const base = path2.basename(tsPath, path2.extname(tsPath));
+  return path2.join(dir, `${base}.d.ts`);
+}
+async function writeFile(targetPath, contents) {
+  await fs.mkdir(path2.dirname(targetPath), { recursive: true });
+  await fs.writeFile(targetPath, `${contents}
+`, "utf8");
+}
+function computeImportPath(fromPath, typesPath) {
+  const fromDir = path2.dirname(fromPath);
+  const relative = path2.relative(fromDir, typesPath).replace(/\\/g, "/");
+  const withoutExt = relative.endsWith(".d.ts") ? relative.slice(0, -5) : relative.replace(/\.[^.]+$/, "");
+  if (withoutExt.startsWith(".")) {
+    return withoutExt;
+  }
+  return `./${withoutExt}`;
+}
+var __test = {
+  parseEmitTsArgs,
+  buildInterfaceName,
+  deriveTypesOutPath,
+  computeImportPath,
+  buildDocEntries
+};
+export {
+  __test,
+  handleEmitTs,
+  printEmitTsHelp
+};