@introspection-ai/recipes 0.13.0 → 0.14.0

package/dist/mcp-chunks/chunk-XANPGTLI.js

@@ -0,0 +1,364 @@
+import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
+
+// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/cli/generate/tools.js
+function resolveSchemaType(value) {
+  if (value === "integer") {
+    return "number";
+  }
+  if (value === "string" || value === "number" || value === "boolean" || value === "array" || value === "object") {
+    return value;
+  }
+  return void 0;
+}
+function resolveArrayItemType(value) {
+  if (value === "integer") {
+    return "number";
+  }
+  if (value === "string" || value === "number" || value === "boolean" || value === "object") {
+    return value;
+  }
+  return void 0;
+}
+function buildToolMetadata(tool) {
+  const methodName = toProxyMethodName(tool.name);
+  const properties = extractOptions(tool);
+  return {
+    tool,
+    methodName,
+    options: properties
+  };
+}
+function buildToolMetadataList(tools, options = {}) {
+  const result = tools.map((tool) => buildToolMetadata(tool));
+  if (options.sort !== false) {
+    result.sort((left, right) => left.tool.name.localeCompare(right.tool.name));
+  }
+  const methods = /* @__PURE__ */ new Map();
+  for (const entry of result) {
+    const previous = methods.get(entry.methodName);
+    if (previous) {
+      throw new Error(`Generated proxy method collision '${entry.methodName}' for tools '${previous}' and '${entry.tool.name}'.`);
+    }
+    methods.set(entry.methodName, entry.tool.name);
+  }
+  return result;
+}
+function buildEmbeddedSchemaMap(tools) {
+  const result = {};
+  for (const entry of tools.toSorted((left, right) => left.tool.name.localeCompare(right.tool.name))) {
+    if (entry.tool.inputSchema && typeof entry.tool.inputSchema === "object") {
+      result[entry.tool.name] = entry.tool.inputSchema;
+    }
+  }
+  return result;
+}
+function extractOptions(tool) {
+  const schema = tool.inputSchema;
+  if (!schema || typeof schema !== "object") {
+    return [];
+  }
+  const record = schema;
+  if (record.type !== "object" || typeof record.properties !== "object") {
+    return [];
+  }
+  const properties = record.properties;
+  const requiredList = Array.isArray(record.required) ? record.required : [];
+  return Object.entries(properties).map(([property, descriptor]) => {
+    const type = inferType(descriptor);
+    const arrayItemType = type === "array" ? inferArrayItemType(descriptor) : void 0;
+    const enumValues = getEnumValues(descriptor);
+    const defaultValue = getDescriptorDefault(descriptor);
+    const formatInfo = getDescriptorFormatHint(descriptor);
+    const placeholder = buildPlaceholder(property, type, enumValues, formatInfo?.slug);
+    const exampleValue = buildExampleValue(property, type, enumValues, defaultValue, arrayItemType);
+    return {
+      property,
+      cliName: toCliOption(property),
+      description: getDescriptorDescription(descriptor),
+      required: requiredList.includes(property),
+      type,
+      arrayItemType,
+      placeholder,
+      exampleValue,
+      enumValues,
+      defaultValue,
+      formatHint: formatInfo?.display
+    };
+  });
+}
+function getEnumValues(descriptor) {
+  if (!descriptor || typeof descriptor !== "object") {
+    return void 0;
+  }
+  const record = descriptor;
+  if (Array.isArray(record.enum)) {
+    const values = record.enum.filter((entry) => typeof entry === "string");
+    return values.length > 0 ? values : void 0;
+  }
+  if (record.type === "array" && typeof record.items === "object" && record.items !== null) {
+    const nested = record.items;
+    if (Array.isArray(nested.enum)) {
+      const values = nested.enum.filter((entry) => typeof entry === "string");
+      return values.length > 0 ? values : void 0;
+    }
+  }
+  return void 0;
+}
+function getDescriptorDefault(descriptor) {
+  if (!descriptor || typeof descriptor !== "object") {
+    return void 0;
+  }
+  const record = descriptor;
+  if (record.default !== void 0) {
+    return record.default;
+  }
+  if (record.type === "array" && typeof record.items === "object" && record.items !== null) {
+    return Array.isArray(record.default) ? record.default : void 0;
+  }
+  return void 0;
+}
+function buildPlaceholder(property, type, enumValues, formatSlug) {
+  const normalized = property.replace(/[A-Z]/g, (char) => `-${char.toLowerCase()}`).replace(/_/g, "-");
+  if (enumValues && enumValues.length > 0) {
+    return `<${normalized}:${enumValues.join("|")}>`;
+  }
+  switch (type) {
+    case "number":
+      return `<${normalized}:number>`;
+    case "boolean":
+      return `<${normalized}:true|false>`;
+    case "array":
+      return `<${normalized}:value1,value2>`;
+    case "object":
+      return `<${normalized}:json>`;
+    default:
+      if (formatSlug) {
+        return `<${normalized}:${formatSlug}>`;
+      }
+      return `<${normalized ?? "value"}>`;
+  }
+}
+function buildExampleValue(property, type, enumValues, defaultValue, arrayItemType) {
+  if (enumValues && enumValues.length > 0) {
+    return enumValues[0];
+  }
+  if (defaultValue !== void 0) {
+    try {
+      return typeof defaultValue === "string" ? defaultValue : JSON.stringify(defaultValue);
+    } catch {
+      return void 0;
+    }
+  }
+  switch (type) {
+    case "number":
+      return "1";
+    case "boolean":
+      return "true";
+    case "array":
+      switch (arrayItemType) {
+        case "number":
+          return "1,2";
+        case "boolean":
+          return "true,false";
+        case "object":
+          return '[{"key":"value"}]';
+        default:
+          return "value1,value2";
+      }
+    case "object":
+      return '{"key":"value"}';
+    default:
+      if (property.toLowerCase().includes("path")) {
+        return "/path/to/file.md";
+      }
+      if (property.toLowerCase().includes("id")) {
+        return "example-id";
+      }
+      return void 0;
+  }
+}
+function pickExampleLiteral(option) {
+  if (option.type === "array") {
+    if (Array.isArray(option.defaultValue)) {
+      try {
+        return JSON.stringify(option.defaultValue);
+      } catch {
+        return void 0;
+      }
+    }
+    if (option.enumValues && option.enumValues.length > 0) {
+      return JSON.stringify([option.enumValues[0]]);
+    }
+    switch (option.arrayItemType) {
+      case "number":
+        return "[1, 2]";
+      case "boolean":
+        return "[true, false]";
+      case "object":
+        return '[{"key":"value"}]';
+      default:
+        break;
+    }
+  }
+  if (option.enumValues && option.enumValues.length > 0) {
+    return JSON.stringify(option.enumValues[0]);
+  }
+  if (!option.exampleValue) {
+    return void 0;
+  }
+  if (option.type === "array") {
+    const values = option.exampleValue.split(",").map((entry) => entry.trim()).filter(Boolean);
+    if (values.length === 0) {
+      return void 0;
+    }
+    return `[${values.map((entry) => JSON.stringify(entry)).join(", ")}]`;
+  }
+  if (option.type === "number" || option.type === "boolean" || option.type === "object") {
+    return option.exampleValue;
+  }
+  try {
+    const parsed = JSON.parse(option.exampleValue);
+    if (typeof parsed === "number" || typeof parsed === "boolean") {
+      return option.exampleValue;
+    }
+  } catch {
+  }
+  return JSON.stringify(option.exampleValue);
+}
+function buildFallbackLiteral(option) {
+  switch (option.type) {
+    case "number":
+      return "1";
+    case "boolean":
+      return "true";
+    case "array":
+      switch (option.arrayItemType) {
+        case "number":
+          return "[1]";
+        case "boolean":
+          return "[true]";
+        case "object":
+          return '[{"key":"value"}]';
+        default:
+          return '["value1"]';
+      }
+    case "object":
+      return '{"key":"value"}';
+    default: {
+      if (option.property.toLowerCase().includes("id")) {
+        return JSON.stringify("example-id");
+      }
+      if (option.property.toLowerCase().includes("url")) {
+        return JSON.stringify("https://example.com");
+      }
+      return JSON.stringify("value");
+    }
+  }
+}
+function inferType(descriptor) {
+  if (!descriptor || typeof descriptor !== "object") {
+    return "unknown";
+  }
+  const type = descriptor.type;
+  if (Array.isArray(type)) {
+    for (const entry of type) {
+      const resolved2 = resolveSchemaType(entry);
+      if (resolved2) {
+        return resolved2;
+      }
+    }
+    return "unknown";
+  }
+  const resolved = resolveSchemaType(type);
+  if (resolved) {
+    return resolved;
+  }
+  return "unknown";
+}
+function inferArrayItemType(descriptor) {
+  if (!descriptor || typeof descriptor !== "object") {
+    return "unknown";
+  }
+  const record = descriptor;
+  if (record.type !== "array" || !record.items || typeof record.items !== "object") {
+    return "unknown";
+  }
+  const items = record.items;
+  const itemType = items.type;
+  if (Array.isArray(itemType)) {
+    for (const entry of itemType) {
+      const resolved2 = resolveArrayItemType(entry);
+      if (resolved2) {
+        return resolved2;
+      }
+    }
+    return "unknown";
+  }
+  const resolved = resolveArrayItemType(itemType);
+  if (resolved) {
+    return resolved;
+  }
+  return "unknown";
+}
+function getDescriptorDescription(descriptor) {
+  if (typeof descriptor !== "object" || descriptor === null) {
+    return void 0;
+  }
+  const record = descriptor;
+  return typeof record.description === "string" ? record.description : void 0;
+}
+function getDescriptorFormatHint(descriptor) {
+  if (typeof descriptor !== "object" || descriptor === null) {
+    return void 0;
+  }
+  const record = descriptor;
+  const formatRaw = typeof record.format === "string" ? record.format : void 0;
+  const description = typeof record.description === "string" ? record.description : void 0;
+  const iso8601FromDescription = !formatRaw && description && /\biso[-\s]*8601\b/i.test(description) ? "iso-8601" : void 0;
+  const isoFormatFromDescription = !formatRaw && !iso8601FromDescription && description && /\biso\s+format\b/i.test(description) ? "iso-8601" : void 0;
+  const formatFromDescription = iso8601FromDescription ?? isoFormatFromDescription;
+  const slug = formatRaw ?? formatFromDescription;
+  if (!slug) {
+    return void 0;
+  }
+  let display;
+  switch (slug) {
+    case "date-time":
+    case "iso-8601":
+      display = "ISO 8601";
+      break;
+    case "uuid":
+      display = "UUID";
+      break;
+    default:
+      display = slug.replace(/[_-]/g, " ");
+      display = display.charAt(0).toUpperCase() + display.slice(1);
+      break;
+  }
+  return {
+    display: display.replace(/\b\w/g, (char) => char.toUpperCase()),
+    slug
+  };
+}
+function toProxyMethodName(toolName) {
+  return toolName.replace(/[-_](\w)/g, (_, char) => char.toUpperCase()).replace(/^(\w)/, (match) => match.toLowerCase());
+}
+function toCliOption(property) {
+  return property.replace(/[A-Z]/g, (char) => `-${char.toLowerCase()}`).replace(/_/g, "-");
+}
+var toolsTestHelpers = {
+  getEnumValues,
+  getDescriptorDefault,
+  buildPlaceholder,
+  buildExampleValue,
+  pickExampleLiteral,
+  buildFallbackLiteral
+};
+
+export {
+  buildToolMetadataList,
+  buildEmbeddedSchemaMap,
+  pickExampleLiteral,
+  buildFallbackLiteral,
+  toolsTestHelpers
+};

package/dist/mcp-chunks/chunk-XQK2JSW4.js

@@ -0,0 +1,35 @@
+import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
+
+// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/cli/flag-utils.js
+function extractFlags(args, keys) {
+  const flags = {};
+  let index = 0;
+  while (index < args.length) {
+    const token = args[index];
+    if (token === "--") {
+      break;
+    }
+    if (token === void 0 || !keys.includes(token)) {
+      index += 1;
+      continue;
+    }
+    const value = args[index + 1];
+    if (value === void 0) {
+      throw new Error(`Flag '${token}' requires a value.`);
+    }
+    flags[token] = value;
+    args.splice(index, 2);
+  }
+  return flags;
+}
+function expectValue(flag, value) {
+  if (value === void 0) {
+    throw new Error(`Flag '${flag}' requires a value.`);
+  }
+  return value;
+}
+
+export {
+  extractFlags,
+  expectValue
+};