@botbotgo/kit 1.0.104

package/dist/chunk-AZUXVVGV.cjs

@@ -0,0 +1,1073 @@
+'use strict';
+
+var chunkJW4EMVTE_cjs = require('./chunk-JW4EMVTE.cjs');
+var path = require('path');
+var promises = require('fs/promises');
+var utils = require('@botbotgo/common/utils');
+var url = require('url');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var path__namespace = /*#__PURE__*/_interopNamespace(path);
+
+// src/tools/mcp/support/types.ts
+var MCP_KIND = "mcp";
+var DEFAULT_EXTENSIONS = [".js", ".mjs"];
+async function resolveEntryPoint(dirPath, baseName, extensions = DEFAULT_EXTENSIONS) {
+  if (extensions.some((ext) => baseName.endsWith(ext))) {
+    const fullPath = path.join(dirPath, baseName);
+    await promises.stat(fullPath);
+    return fullPath;
+  }
+  for (const ext of extensions) {
+    const fullPath = path.join(dirPath, `${baseName}${ext}`);
+    try {
+      await promises.stat(fullPath);
+      return fullPath;
+    } catch {
+    }
+  }
+  throw new Error(
+    `Could not find entry point in ${dirPath}. Tried: ${extensions.map((e) => baseName + e).join(", ")}`
+  );
+}
+
+// src/tools/skill/SkillManifest.ts
+var SkillManifestError = class extends Error {
+  constructor(path6, field, message) {
+    super(`SKILL.md error in ${path6}: ${message}`);
+    this.path = path6;
+    this.field = field;
+    this.name = "SkillManifestError";
+  }
+};
+var NAME_PATTERN = /^[a-z0-9-]+$/;
+var NAME_MAX_LENGTH = 64;
+var DESCRIPTION_MAX_LENGTH = 1024;
+var COMPATIBILITY_MAX_LENGTH = 500;
+var RESERVED_WORDS = ["anthropic", "claude"];
+var XML_TAG_PATTERN = /<\/?[a-zA-Z][^>]*>/;
+function validateFrontmatter(fm, filePath) {
+  if (!fm.name || typeof fm.name !== "string") {
+    throw new SkillManifestError(filePath, "name", "name is required");
+  }
+  if (fm.name.length > NAME_MAX_LENGTH) {
+    throw new SkillManifestError(
+      filePath,
+      "name",
+      `name must be at most ${NAME_MAX_LENGTH} characters (got ${fm.name.length})`
+    );
+  }
+  if (!NAME_PATTERN.test(fm.name)) {
+    throw new SkillManifestError(
+      filePath,
+      "name",
+      "name must contain only lowercase letters, numbers, and hyphens"
+    );
+  }
+  if (fm.name.startsWith("-") || fm.name.endsWith("-")) {
+    throw new SkillManifestError(
+      filePath,
+      "name",
+      "name must not start or end with a hyphen"
+    );
+  }
+  if (fm.name.includes("--")) {
+    throw new SkillManifestError(
+      filePath,
+      "name",
+      "name must not contain consecutive hyphens"
+    );
+  }
+  if (XML_TAG_PATTERN.test(fm.name)) {
+    throw new SkillManifestError(filePath, "name", "name cannot contain XML tags");
+  }
+  for (const reserved of RESERVED_WORDS) {
+    if (fm.name.includes(reserved)) {
+      throw new SkillManifestError(
+        filePath,
+        "name",
+        `name cannot contain reserved word "${reserved}"`
+      );
+    }
+  }
+  if (!fm.description || typeof fm.description !== "string") {
+    throw new SkillManifestError(
+      filePath,
+      "description",
+      "description is required and must be non-empty"
+    );
+  }
+  if (fm.description.length > DESCRIPTION_MAX_LENGTH) {
+    throw new SkillManifestError(
+      filePath,
+      "description",
+      `description must be at most ${DESCRIPTION_MAX_LENGTH} characters (got ${fm.description.length})`
+    );
+  }
+  if (XML_TAG_PATTERN.test(fm.description)) {
+    throw new SkillManifestError(
+      filePath,
+      "description",
+      "description cannot contain XML tags"
+    );
+  }
+  if (fm.compatibility != null && typeof fm.compatibility === "string") {
+    if (fm.compatibility.length > COMPATIBILITY_MAX_LENGTH) {
+      throw new SkillManifestError(
+        filePath,
+        "compatibility",
+        `compatibility must be at most ${COMPATIBILITY_MAX_LENGTH} characters (got ${fm.compatibility.length})`
+      );
+    }
+  }
+}
+
+// src/tools/skill/SkillMdParser.ts
+var CODE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".py",
+  ".js",
+  ".mjs",
+  ".ts",
+  ".sh",
+  ".bash",
+  ".rb",
+  ".go"
+]);
+var INSTRUCTION_EXTENSIONS = /* @__PURE__ */ new Set([".md", ".markdown", ".txt"]);
+var EXCLUDED_FILES = /* @__PURE__ */ new Set(["SKILL.md", "tool.json"]);
+function parseSkillMd(content, filePath) {
+  let raw;
+  let body = "";
+  try {
+    const parsed = utils.parseMarkdownYamlFrontmatter(content, filePath);
+    raw = parsed.frontmatter;
+    body = parsed.body;
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new SkillManifestError(
+      filePath,
+      "frontmatter",
+      `Invalid YAML frontmatter: ${message}`
+    );
+  }
+  const name = stringField(raw, "name", filePath);
+  const description = stringField(raw, "description", filePath);
+  if (!name || !description) {
+    throw new SkillManifestError(
+      filePath,
+      "frontmatter",
+      !name ? "name is required" : "description is required"
+    );
+  }
+  const license = stringField(raw, "license");
+  const compatibility = stringField(raw, "compatibility");
+  const allowedTools = stringField(raw, "allowed-tools");
+  const metadata = normalizeMetadata(raw.metadata);
+  const frontmatter = {
+    name,
+    description,
+    ...license && { license },
+    ...compatibility && { compatibility },
+    ...allowedTools && { allowedTools },
+    ...metadata && Object.keys(metadata).length > 0 && { metadata }
+  };
+  validateFrontmatter(frontmatter, filePath);
+  return { frontmatter, instructions: body };
+}
+function stringField(raw, key, filePath) {
+  const v = raw[key];
+  if (v == null) return "";
+  if (typeof v === "string") return v;
+  if (typeof v === "number" || typeof v === "boolean") return String(v);
+  if (Array.isArray(v)) {
+    return v.map((x) => typeof x === "string" ? x : String(x)).join("\n");
+  }
+  if (filePath) {
+    throw new SkillManifestError(
+      filePath,
+      "frontmatter",
+      `Frontmatter field "${key}" must be a string, number, boolean, or array`
+    );
+  }
+  return String(v);
+}
+function normalizeMetadata(val) {
+  if (val == null) return void 0;
+  if (typeof val === "object" && !Array.isArray(val)) {
+    const out = {};
+    for (const [k, v] of Object.entries(val)) {
+      if (typeof k === "string" && v !== void 0 && v !== null) {
+        out[k] = typeof v === "object" ? JSON.stringify(v) : String(v);
+      }
+    }
+    return Object.keys(out).length ? out : void 0;
+  }
+  if (typeof val === "string" || typeof val === "number" || typeof val === "boolean") {
+    return { value: String(val) };
+  }
+  return void 0;
+}
+async function scanSkillResources(dirPath) {
+  const resources = [];
+  await scanDir(dirPath, dirPath, resources);
+  return resources;
+}
+async function scanDir(basePath, currentPath, resources) {
+  let entries;
+  try {
+    entries = await promises.readdir(currentPath, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    const fullPath = path.join(currentPath, entry.name);
+    if (entry.isDirectory()) {
+      if (entry.name.startsWith(".") || entry.name === "node_modules") {
+        continue;
+      }
+      await scanDir(basePath, fullPath, resources);
+    } else if (entry.isFile()) {
+      if (EXCLUDED_FILES.has(entry.name)) {
+        continue;
+      }
+      const ext = path.extname(entry.name).toLowerCase();
+      const relPath = path.relative(basePath, fullPath);
+      resources.push({
+        relativePath: relPath,
+        absolutePath: fullPath,
+        extension: ext,
+        type: inferResourceType(ext)
+      });
+    }
+  }
+}
+function inferResourceType(ext) {
+  if (CODE_EXTENSIONS.has(ext)) return "code";
+  if (INSTRUCTION_EXTENSIONS.has(ext)) return "instructions";
+  return "data";
+}
+async function loadSkillDefinition(dirPath) {
+  const skillMdPath = path.join(dirPath, "SKILL.md");
+  let content;
+  try {
+    content = await promises.readFile(skillMdPath, "utf-8");
+  } catch (err) {
+    throw new SkillManifestError(
+      skillMdPath,
+      "file",
+      `Cannot read SKILL.md: ${err.message}`
+    );
+  }
+  const { frontmatter, instructions } = parseSkillMd(content, skillMdPath);
+  const resources = await scanSkillResources(dirPath);
+  return {
+    frontmatter,
+    instructions,
+    resources,
+    dirPath,
+    skillMdPath
+  };
+}
+
+// src/tools/skill/scanSkill.ts
+var defaultInputSchema = { type: "object", properties: {}, additionalProperties: true };
+async function scanForSkill(projectPath) {
+  const projectRoot = path__namespace.resolve(projectPath);
+  const dirs = await chunkJW4EMVTE_cjs.findDirsContainingFile(projectRoot, "SKILL.md");
+  const skills = [];
+  const errors = [];
+  for (const dirPath of dirs) {
+    const relativePath = path__namespace.relative(projectRoot, dirPath) || path__namespace.basename(dirPath);
+    try {
+      const skillDef = await loadSkillDefinition(dirPath);
+      const name = chunkJW4EMVTE_cjs.pathToToolName(relativePath, skillDef.frontmatter.name);
+      skills.push({
+        kind: chunkJW4EMVTE_cjs.SKILL_KIND,
+        name,
+        description: skillDef.frontmatter.description,
+        inputSchema: defaultInputSchema,
+        _meta: { hitl: { sideEffect: "none" } },
+        sourcePath: relativePath.replace(/\\/g, "/")
+      });
+    } catch (err) {
+      errors.push({ dir: relativePath, message: err instanceof Error ? err.message : String(err) });
+    }
+  }
+  return { skills, errors };
+}
+async function scan2(projectPath, _options = {}) {
+  const root = path__namespace.resolve(projectPath);
+  const result = await scanForSkill(root);
+  const specs = result.skills.map((s) => chunkJW4EMVTE_cjs.mcpSpecToToolSpec(s, root));
+  return {
+    specs,
+    errors: result.errors.map((e) => ({ file: e.dir, message: e.message }))
+  };
+}
+async function readWorkflowMeta(dirPath, workflowFileName = "workflow.json") {
+  const workflowPath = path.join(dirPath, workflowFileName);
+  let raw;
+  try {
+    raw = await promises.readFile(workflowPath, "utf-8");
+  } catch (err) {
+    throw new DiscoveryError(
+      dirPath,
+      "load",
+      `Failed to read workflow: ${workflowPath}`,
+      err
+    );
+  }
+  let workflowDef;
+  try {
+    workflowDef = JSON.parse(raw);
+  } catch (err) {
+    throw new DiscoveryError(
+      dirPath,
+      "load",
+      `Invalid JSON in ${workflowPath}`,
+      err
+    );
+  }
+  if (!workflowDef.nodes || !Array.isArray(workflowDef.nodes)) {
+    throw new DiscoveryError(
+      dirPath,
+      "validate",
+      `workflow.json must have a "nodes" array`
+    );
+  }
+  const meta = workflowDef.meta;
+  const name = workflowDef.name || meta?.name || path.basename(dirPath);
+  const description = workflowDef.description || meta?.description || `n8n workflow: ${name}`;
+  let webhookUrl;
+  const nodes = workflowDef.nodes;
+  if (Array.isArray(nodes)) {
+    const webhookNode = nodes.find(
+      (n) => n.type === "n8n-nodes-base.webhook" || n.type?.includes("webhook")
+    );
+    if (webhookNode?.parameters && typeof webhookNode.parameters === "object") {
+      const params = webhookNode.parameters;
+      const pathVal = params.path ?? params.webhookPath;
+      if (typeof pathVal === "string" && pathVal.startsWith("http")) {
+        webhookUrl = pathVal;
+      }
+    }
+  }
+  return { name, description, webhookUrl, workflowDef };
+}
+async function loadN8nTool(dirPath, manifest) {
+  const { workflowDef } = await readWorkflowMeta(
+    dirPath,
+    manifest.entryPoint ?? "workflow.json"
+  );
+  return { manifest, dirPath, workflowDef };
+}
+
+// src/tools/n8n/scanN8n.ts
+var defaultInputSchema2 = { type: "object", properties: {}, additionalProperties: true };
+async function scanForN8n(projectPath) {
+  const projectRoot = path__namespace.resolve(projectPath);
+  const dirs = await chunkJW4EMVTE_cjs.findDirsContainingFile(projectRoot, "workflow.json");
+  const n8n = [];
+  const errors = [];
+  for (const dirPath of dirs) {
+    const relativePath = path__namespace.relative(projectRoot, dirPath) || path__namespace.basename(dirPath);
+    try {
+      const { name: wfName, description: wfDesc, webhookUrl } = await readWorkflowMeta(dirPath);
+      const toolName = chunkJW4EMVTE_cjs.pathToToolName(relativePath, wfName);
+      n8n.push({
+        kind: chunkJW4EMVTE_cjs.N8N_KIND,
+        name: toolName,
+        description: wfDesc,
+        inputSchema: defaultInputSchema2,
+        _meta: { hitl: { sideEffect: "external_write" } },
+        sourcePath: relativePath.replace(/\\/g, "/"),
+        webhookUrl
+      });
+    } catch (err) {
+      errors.push({ dir: relativePath, message: err instanceof Error ? err.message : String(err) });
+    }
+  }
+  return { n8n, errors };
+}
+async function scan3(projectPath, _options = {}) {
+  const root = path__namespace.resolve(projectPath);
+  const result = await scanForN8n(root);
+  const specs = result.n8n.map((s) => chunkJW4EMVTE_cjs.mcpSpecToToolSpec(s, root));
+  return {
+    specs,
+    errors: result.errors.map((e) => ({ file: e.dir, message: e.message }))
+  };
+}
+async function scan4(projectPath, options = {}) {
+  const root = path__namespace.resolve(projectPath);
+  const namespace = options.namespace ?? "dir";
+  const errors = [];
+  const scanner = new DirectoryScanner({
+    roots: [root],
+    namespace,
+    extensions: options.extensions,
+    onError: (dir, err) => {
+      errors.push({ file: dir, message: err.message });
+      options.onError?.(dir, err);
+    }
+  });
+  let specs;
+  try {
+    specs = await scanner.scan();
+  } catch (err) {
+    errors.push({
+      file: root,
+      message: err instanceof Error ? err.message : String(err)
+    });
+    return { specs: [], errors };
+  }
+  const filtered = specs.filter((s) => s.kind === MCP_KIND);
+  return { specs: filtered, errors };
+}
+
+// src/tools/langchain/types.ts
+var LANGCHAIN_KIND = "langchain";
+var LANGCHAIN_DIR_NAME = "langchain";
+
+// src/tools/langchain/scanner.ts
+async function scan5(projectPath, options = {}) {
+  const root = path__namespace.resolve(projectPath);
+  const namespace = options.namespace ?? "dir";
+  const errors = [];
+  const scanner = new DirectoryScanner({
+    roots: [root],
+    namespace,
+    extensions: options.extensions,
+    onError: (dir, err) => {
+      errors.push({ file: dir, message: err.message });
+      options.onError?.(dir, err);
+    }
+  });
+  let specs;
+  try {
+    specs = await scanner.scan();
+  } catch (err) {
+    errors.push({
+      file: root,
+      message: err instanceof Error ? err.message : String(err)
+    });
+    return { specs: [], errors };
+  }
+  const filtered = specs.filter((s) => s.kind === LANGCHAIN_KIND);
+  return { specs: filtered, errors };
+}
+async function loadLangChainTool(dirPath, manifest, extensions) {
+  let entryFile;
+  try {
+    entryFile = await resolveEntryPoint(
+      dirPath,
+      manifest.entryPoint ?? "index",
+      extensions
+    );
+  } catch (err) {
+    throw new DiscoveryError(
+      dirPath,
+      "load",
+      `Cannot find LangChain entry point`,
+      err
+    );
+  }
+  let mod;
+  try {
+    mod = await import(url.pathToFileURL(entryFile).href);
+  } catch (err) {
+    throw new DiscoveryError(
+      dirPath,
+      "load",
+      `Failed to import ${entryFile}`,
+      err
+    );
+  }
+  const tool = mod.default ?? mod.tool ?? mod;
+  if (!tool || typeof tool.invoke !== "function") {
+    throw new DiscoveryError(
+      dirPath,
+      "validate",
+      `Entry point must export an object with invoke() method (LangChainToolLike)`
+    );
+  }
+  return { manifest, dirPath, impl: tool };
+}
+var DEFAULT_EXTENSIONS2 = [".js", ".mjs"];
+async function listSkillProgramFiles(dirPath, extensions = DEFAULT_EXTENSIONS2) {
+  let entries;
+  try {
+    const dirEntries = await promises.readdir(dirPath, { withFileTypes: true });
+    entries = dirEntries.map((entry) => ({
+      name: entry.name,
+      isFile: entry.isFile()
+    }));
+  } catch {
+    return [];
+  }
+  return entries.filter((e) => e.isFile).map((e) => e.name).filter((name) => {
+    if (name.startsWith(".") || name.startsWith("_")) return false;
+    if (name.includes(".test.") || name.includes(".spec.")) return false;
+    return extensions.some((ext) => name.endsWith(ext));
+  }).sort((a, b) => {
+    if (a === "handler.js" || a === "index.js") return -1;
+    if (b === "handler.js" || b === "index.js") return 1;
+    return a.localeCompare(b);
+  });
+}
+function isLangChainLikeTool(val) {
+  return val != null && typeof val === "object" && "invoke" in val && typeof val.invoke === "function";
+}
+function isConstructable(val) {
+  return typeof val === "function" && typeof val.prototype === "object";
+}
+async function loadOneSkillProgram(dirPath, manifest, entryFile, skillDef, programKey, extensions) {
+  let impl;
+  try {
+    const fullPath = await resolveEntryPoint(dirPath, entryFile, extensions ?? [".js", ".mjs"]);
+    const mod = await import(url.pathToFileURL(fullPath).href);
+    const fn = mod.default ?? mod.handler ?? mod.Tool;
+    if (isLangChainLikeTool(fn)) {
+      impl = fn;
+    } else if (isConstructable(fn)) {
+      const instance = new fn();
+      if (isLangChainLikeTool(instance)) impl = instance;
+    } else if (typeof fn === "function") {
+      impl = fn;
+    }
+  } catch {
+  }
+  return {
+    manifest,
+    dirPath,
+    impl,
+    skillDefinition: skillDef,
+    programKey
+  };
+}
+async function loadSkillTools(dirPath, manifest, extensions) {
+  let skillDef;
+  try {
+    skillDef = await loadSkillDefinition(dirPath);
+  } catch (err) {
+    throw new DiscoveryError(
+      dirPath,
+      "load",
+      `Failed to parse SKILL.md: ${err.message}`,
+      err
+    );
+  }
+  const programs = manifest.programs;
+  if (programs && typeof programs === "object" && Object.keys(programs).length > 0) {
+    const result = [];
+    for (const [programKey, entryFile2] of Object.entries(programs)) {
+      const loaded2 = await loadOneSkillProgram(
+        dirPath,
+        manifest,
+        entryFile2,
+        skillDef,
+        programKey,
+        extensions
+      );
+      result.push(loaded2);
+    }
+    return result;
+  }
+  const exts = extensions ?? DEFAULT_EXTENSIONS2;
+  const files = await listSkillProgramFiles(dirPath, exts);
+  if (files.length >= 2) {
+    const result = [];
+    for (let i = 0; i < files.length; i++) {
+      const file = files[i];
+      const programKey = i === 0 ? "default" : file.replace(/\.[^.]+$/, "");
+      const loaded2 = await loadOneSkillProgram(
+        dirPath,
+        manifest,
+        file,
+        skillDef,
+        programKey,
+        extensions
+      );
+      result.push(loaded2);
+    }
+    return result;
+  }
+  const entryFile = manifest.entryPoint ?? files[0] ?? "handler";
+  const loaded = await loadOneSkillProgram(
+    dirPath,
+    manifest,
+    entryFile,
+    skillDef,
+    void 0,
+    extensions
+  );
+  return [loaded];
+}
+async function listLangchainEntryFiles(dirPath, extensions) {
+  let entries;
+  try {
+    const dirEntries = await promises.readdir(dirPath, { withFileTypes: true });
+    entries = dirEntries.map((entry) => ({
+      name: entry.name,
+      isFile: entry.isFile()
+    }));
+  } catch {
+    return [];
+  }
+  return entries.filter((e) => e.isFile).map((e) => e.name).filter((name) => {
+    if (name.startsWith(".") || name.startsWith("_")) return false;
+    if (name.endsWith(".d.ts")) return false;
+    if (name.includes(".test.") || name.includes(".spec.")) return false;
+    return extensions.some((ext) => name.endsWith(ext));
+  });
+}
+async function loadLangChainToolsFromDir(dirPath, dirName, manifest, strict, namespace, extensions, langchainDirName, toSpec, onError) {
+  const entryFiles = await listLangchainEntryFiles(dirPath, extensions);
+  if (entryFiles.length === 0) {
+    if (strict) {
+      throw new DiscoveryError(dirPath, "load", "No LangChain entry files found");
+    }
+    return [];
+  }
+  const specs = [];
+  const useDirNameForSingle = dirName !== langchainDirName;
+  for (const entryFile of entryFiles) {
+    const fileManifest = { ...manifest, entryPoint: entryFile };
+    try {
+      const loaded = await loadLangChainTool(dirPath, fileManifest, extensions);
+      const fileBase = path.basename(entryFile).replace(/\.[^.]+$/, "");
+      const nameHint = entryFiles.length === 1 && useDirNameForSingle ? dirName : fileBase;
+      specs.push(toSpec(loaded, nameHint, dirPath, namespace));
+    } catch (error) {
+      const err = error;
+      if (err instanceof DiscoveryError && err.phase === "validate") {
+        if (strict) throw err;
+        continue;
+      }
+      onError?.(path.join(dirPath, entryFile), err);
+      if (strict) throw err;
+    }
+  }
+  return specs;
+}
+function isCursorFormat(obj) {
+  return typeof obj === "object" && obj !== null && "mcpServers" in obj && typeof obj.mcpServers === "object" && obj.mcpServers !== null;
+}
+function extractMCPConfig(parsed, toolName) {
+  if (isCursorFormat(parsed)) {
+    const servers = parsed.mcpServers;
+    const keys = Object.keys(servers);
+    if (keys.length === 0) {
+      return {};
+    }
+    const name = toolName && keys.includes(toolName) ? toolName : keys[0];
+    return servers[name];
+  }
+  return parsed;
+}
+async function loadMCPTool(dirPath, manifest) {
+  const mcpPath = path.join(dirPath, manifest.entryPoint ?? "mcp.json");
+  let raw;
+  try {
+    raw = await promises.readFile(mcpPath, "utf-8");
+  } catch (err) {
+    throw new DiscoveryError(
+      dirPath,
+      "load",
+      `Failed to read MCP config: ${mcpPath}`,
+      err
+    );
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    throw new DiscoveryError(
+      dirPath,
+      "load",
+      `Invalid JSON in ${mcpPath}`,
+      err
+    );
+  }
+  const baseName = manifest.name?.split("/").pop();
+  const config = extractMCPConfig(parsed, baseName);
+  if (!config.command && !config.url) {
+    throw new DiscoveryError(
+      dirPath,
+      "validate",
+      `mcp.json must have either "command" or "url" field`
+    );
+  }
+  return { manifest, dirPath, mcpConfig: config };
+}
+
+// src/tools/mcp/directoryApply.ts
+function applyLoadedToSpec(spec, loaded, _manifest, _defaultDirName, _namespace) {
+  if (loaded.mcpConfig?.url) spec.endpoint = loaded.mcpConfig.url;
+  spec.impl = loaded.mcpConfig;
+}
+var directoryMarker = {
+  kind: "mcp",
+  markerFile: "mcp.json",
+  defaultEntryPoint: "mcp.json"
+};
+
+// src/tools/langchain/directoryApply.ts
+function applyLoadedToSpec2(spec, loaded, manifest, _defaultDirName, namespace) {
+  spec.impl = loaded.impl;
+  if (!manifest.name && loaded.impl) {
+    const toolName = loaded.impl.name;
+    if (toolName) spec.name = `${namespace}/${toolName}`;
+  }
+  if (!manifest.description && loaded.impl) {
+    const d = loaded.impl.description;
+    if (d) spec.description = d;
+  }
+  if (!manifest.inputSchema && loaded.impl) {
+    const schema = loaded.impl.schema;
+    if (schema) spec.inputSchema = schema;
+  }
+}
+
+// src/tools/skill/directoryApply.ts
+function applyLoadedToSpec3(spec, loaded, manifest, defaultDirName, namespace) {
+  const skillDef = loaded.skillDefinition;
+  if (skillDef) {
+    spec.name = manifest.name ?? skillDef.frontmatter.name;
+    spec.description = skillDef.frontmatter.description;
+    if (loaded.programKey === "default") {
+      spec.name = `${namespace}/${defaultDirName}`;
+    } else if (loaded.programKey) {
+      spec.name = `${namespace}/${defaultDirName}/${loaded.programKey}`;
+    }
+    const impl = loaded.impl;
+    if (impl && typeof impl === "object" && typeof impl.invoke === "function") {
+      if (impl.description != null && impl.description !== "")
+        spec.description = impl.description;
+      if (impl.schema != null && typeof impl.schema === "object")
+        spec.inputSchema = impl.schema;
+    }
+    spec.impl = { ...skillDef, handler: loaded.impl };
+  } else {
+    spec.impl = loaded.impl;
+  }
+}
+var directoryMarker2 = {
+  kind: "skill",
+  markerFile: "SKILL.md",
+  defaultEntryPoint: "handler"
+};
+
+// src/tools/n8n/directoryApply.ts
+function applyLoadedToSpec4(spec, loaded, manifest, _defaultDirName, _namespace) {
+  const workflow = loaded.workflowDef;
+  if (workflow?.id) spec.resourceId = String(workflow.id);
+  if (!manifest.description && workflow) {
+    const d = workflow.description ?? workflow.meta?.description ?? (typeof workflow.name === "string" ? workflow.name : void 0);
+    if (d) spec.description = d;
+  }
+  spec.impl = loaded.workflowDef;
+}
+var directoryMarker3 = {
+  kind: "n8n",
+  markerFile: "workflow.json",
+  defaultEntryPoint: "workflow.json"
+};
+
+// src/tools/discoveryFactory.ts
+var DiscoveryError = class extends Error {
+  toolDir;
+  phase;
+  cause;
+  constructor(toolDir, phase, message, cause) {
+    super(`[${phase}] ${toolDir}: ${message}`);
+    this.name = "DiscoveryError";
+    this.toolDir = toolDir;
+    this.phase = phase;
+    this.cause = cause;
+  }
+};
+var DIRECTORY_KINDS = ["mcp", "langchain", "skill", "n8n"];
+var DIRECTORY_DISCOVERABLE_KINDS = DIRECTORY_KINDS;
+var DIRECTORY_KIND_MARKERS = [
+  directoryMarker2,
+  directoryMarker3,
+  directoryMarker
+];
+var DIRECTORY_LOADERS = {
+  mcp: async (dirPath, manifest) => [await loadMCPTool(dirPath, manifest)],
+  langchain: async (dirPath, manifest, ext) => [await loadLangChainTool(dirPath, manifest, ext)],
+  skill: (dirPath, manifest, ext) => loadSkillTools(dirPath, manifest, ext),
+  n8n: async (dirPath, manifest) => [await loadN8nTool(dirPath, manifest)]
+};
+function getDirectoryLoader(kind) {
+  const loader = DIRECTORY_LOADERS[kind];
+  if (!loader) {
+    throw new DiscoveryError("", "manifest", `Unknown directory tool kind: "${kind}"`);
+  }
+  return loader;
+}
+function applyDirectoryLoadedToSpec(spec, loaded, manifest, defaultDirName, namespace) {
+  switch (manifest.kind) {
+    case "mcp":
+      return applyLoadedToSpec(spec, loaded);
+    case "langchain":
+      return applyLoadedToSpec2(spec, loaded, manifest, defaultDirName, namespace);
+    case "skill":
+      return applyLoadedToSpec3(spec, loaded, manifest, defaultDirName, namespace);
+    case "n8n":
+      return applyLoadedToSpec4(spec, loaded, manifest);
+  }
+}
+async function discoverTools(type, projectPath, options = {}) {
+  const root = path__namespace.resolve(projectPath);
+  switch (type) {
+    case "function":
+      return chunkJW4EMVTE_cjs.scan(root, options);
+    case "skill":
+      return scan2(root, options);
+    case "n8n":
+      return scan3(root, options);
+    case "mcp":
+      return scan4(root, options);
+    case "langchain":
+      return scan5(root, options);
+    default: {
+      const _ = type;
+      return _;
+    }
+  }
+}
+var DEFAULT_EXTENSIONS3 = [".js", ".mjs"];
+var DirectoryScanner = class {
+  roots;
+  extensions;
+  onError;
+  constructor(options) {
+    const defaultNamespace = options.namespace ?? "dir";
+    this.roots = options.roots.map((root) => {
+      if (typeof root === "string") {
+        return { path: root, namespace: defaultNamespace };
+      }
+      return {
+        path: root.path,
+        namespace: root.namespace ?? defaultNamespace
+      };
+    });
+    this.extensions = options.extensions ?? DEFAULT_EXTENSIONS3;
+    this.onError = options.onError;
+  }
+  async scan() {
+    const specs = [];
+    for (const root of this.roots) {
+      const rootSpecs = await this.scanRoot(root.path, root.namespace);
+      specs.push(...rootSpecs);
+    }
+    return specs;
+  }
+  async scanRoot(rootPath, namespace) {
+    return this.scanRecursive(rootPath, namespace);
+  }
+  async scanRecursive(dirPath, namespace) {
+    const specs = [];
+    let dirEntries;
+    try {
+      const entries = await promises.readdir(dirPath, { withFileTypes: true });
+      dirEntries = entries.map((entry) => ({
+        name: entry.name,
+        isDirectory: entry.isDirectory()
+      }));
+    } catch (error) {
+      this.onError?.(dirPath, error);
+      return specs;
+    }
+    const dirName = path.basename(dirPath);
+    try {
+      const loadedSpecs = await this.loadToolDir(dirPath, dirName, namespace);
+      if (loadedSpecs.length > 0) specs.push(...loadedSpecs);
+    } catch (error) {
+      this.onError?.(dirPath, error);
+    }
+    for (const entry of dirEntries) {
+      if (!entry.isDirectory) continue;
+      const childPath = path.join(dirPath, entry.name);
+      try {
+        const childSpecs = await this.scanRecursive(childPath, namespace);
+        specs.push(...childSpecs);
+      } catch (error) {
+        this.onError?.(childPath, error);
+      }
+    }
+    return specs;
+  }
+  async loadToolDir(dirPath, dirName, namespace) {
+    const manifestPath = path.join(dirPath, "tool.json");
+    let manifestRaw;
+    try {
+      manifestRaw = await promises.readFile(manifestPath, "utf-8");
+    } catch {
+      const inferred = await this.inferManifest(dirPath, dirName);
+      if (!inferred) return [];
+      if (inferred.kind === "langchain") {
+        if (inferred.entryPoint) {
+          const loaded3 = await loadLangChainTool(dirPath, inferred, this.extensions);
+          return [this.toToolSpec(loaded3, dirName, dirPath, namespace)];
+        }
+        return loadLangChainToolsFromDir(
+          dirPath,
+          dirName,
+          inferred,
+          false,
+          namespace,
+          this.extensions,
+          LANGCHAIN_DIR_NAME,
+          (loaded3, nameHint, dp, ns) => this.toToolSpec(loaded3, nameHint, dp, ns),
+          this.onError
+        );
+      }
+      if (inferred.kind === "skill") {
+        const loadedList = await loadSkillTools(dirPath, inferred, this.extensions);
+        return loadedList.map(
+          (loaded3) => this.toToolSpec(loaded3, dirName, dirPath, namespace)
+        );
+      }
+      const loaded2 = await this.loadByKind(dirPath, inferred);
+      return [this.toToolSpec(loaded2, dirName, dirPath, namespace)];
+    }
+    let manifest;
+    try {
+      manifest = JSON.parse(manifestRaw);
+    } catch (err) {
+      throw new DiscoveryError(dirPath, "manifest", "Invalid JSON in tool.json", err);
+    }
+    if (!manifest.kind) {
+      throw new DiscoveryError(dirPath, "manifest", `tool.json must have a "kind" field`);
+    }
+    if (manifest.enabled === false) return [];
+    if (manifest.kind === "langchain") {
+      if (manifest.entryPoint) {
+        const loaded2 = await loadLangChainTool(dirPath, manifest, this.extensions);
+        return [this.toToolSpec(loaded2, dirName, dirPath, namespace)];
+      }
+      return loadLangChainToolsFromDir(
+        dirPath,
+        dirName,
+        manifest,
+        true,
+        namespace,
+        this.extensions,
+        LANGCHAIN_DIR_NAME,
+        (loaded2, nameHint, dp, ns) => this.toToolSpec(loaded2, nameHint, dp, ns),
+        this.onError
+      );
+    }
+    if (manifest.kind === "skill") {
+      const loadedList = await loadSkillTools(dirPath, manifest, this.extensions);
+      return loadedList.map(
+        (loaded2) => this.toToolSpec(loaded2, dirName, dirPath, namespace)
+      );
+    }
+    const loaded = await this.loadByKind(dirPath, manifest);
+    return [this.toToolSpec(loaded, dirName, dirPath, namespace)];
+  }
+  async inferManifest(dirPath, dirName) {
+    const kinds = [];
+    for (const m of DIRECTORY_KIND_MARKERS) {
+      if (await this.fileExists(path.join(dirPath, m.markerFile))) kinds.push(m.kind);
+    }
+    const isLangchainDir = dirName === LANGCHAIN_DIR_NAME;
+    const hasLangchain = isLangchainDir ? (await listLangchainEntryFiles(dirPath, this.extensions)).length > 0 : dirName !== chunkJW4EMVTE_cjs.SKILL_DIR_NAME && await this.hasEntryPoint(dirPath, "index");
+    if (hasLangchain) kinds.push("langchain");
+    if (kinds.length === 0) return null;
+    if (kinds.length > 1) {
+      throw new DiscoveryError(
+        dirPath,
+        "manifest",
+        `Ambiguous tool kind (found ${kinds.join(", ")}). Add tool.json to disambiguate.`
+      );
+    }
+    const kind = kinds[0];
+    const manifest = { kind };
+    const marker = DIRECTORY_KIND_MARKERS.find((m) => m.kind === kind);
+    if (marker) {
+      manifest.entryPoint = marker.defaultEntryPoint;
+    }
+    if (kind === "langchain" && !isLangchainDir) manifest.entryPoint = "index";
+    return manifest;
+  }
+  async fileExists(path6) {
+    try {
+      await promises.access(path6);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async hasEntryPoint(dirPath, baseName) {
+    try {
+      await resolveEntryPoint(dirPath, baseName, this.extensions);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async loadByKind(dirPath, manifest) {
+    const kind = manifest.kind;
+    const loader = getDirectoryLoader(kind);
+    const result = await loader(dirPath, manifest, this.extensions);
+    const list = Array.isArray(result) ? result : [result];
+    if (list.length === 0) {
+      throw new DiscoveryError(dirPath, "load", "No tools loaded", new Error("empty"));
+    }
+    return list[0];
+  }
+  toToolSpec(loaded, dirName, dirPath, namespace) {
+    const { manifest } = loaded;
+    const kindDirNames = new Set(DIRECTORY_DISCOVERABLE_KINDS);
+    const parentName = path.basename(path.join(dirPath, ".."));
+    const isKindDir = kindDirNames.has(dirName);
+    const defaultDirName = isKindDir ? parentName : dirName;
+    const inferredName = isKindDir ? `${namespace}/${defaultDirName}-${dirName}` : `${namespace}/${defaultDirName}`;
+    const name = manifest.name ?? inferredName;
+    const spec = this.buildBaseSpec(manifest, name, dirName);
+    applyDirectoryLoadedToSpec(spec, loaded, manifest, defaultDirName, namespace);
+    return spec;
+  }
+  buildBaseSpec(manifest, name, dirName) {
+    return {
+      name,
+      version: manifest.version ?? "1.0.0",
+      kind: manifest.kind,
+      description: manifest.description ?? `${manifest.kind} tool: ${dirName}`,
+      tags: manifest.tags,
+      inputSchema: manifest.inputSchema ?? { type: "object", additionalProperties: true },
+      outputSchema: manifest.outputSchema ?? { type: "object", additionalProperties: true },
+      capabilities: manifest.capabilities ?? [],
+      costHints: manifest.costHints
+    };
+  }
+};
+
+exports.DirectoryScanner = DirectoryScanner;
+exports.LANGCHAIN_KIND = LANGCHAIN_KIND;
+exports.MCP_KIND = MCP_KIND;
+exports.discoverTools = discoverTools;
+//# sourceMappingURL=chunk-AZUXVVGV.cjs.map
+//# sourceMappingURL=chunk-AZUXVVGV.cjs.map