@easynet/agent-tool 1.0.53 → 1.0.55

package/dist/chunk-K45PQLZI.cjs

@@ -1,1868 +0,0 @@
-'use strict';
-
-var chunkWFPHIYB6_cjs = require('./chunk-WFPHIYB6.cjs');
-var chunkQEJF3KDV_cjs = require('./chunk-QEJF3KDV.cjs');
-var fs3 = require('fs/promises');
-var path9 = require('path');
-var fs2 = require('fs');
-var ts2 = require('typescript');
-var yaml = require('js-yaml');
-var url = require('url');
-var child_process = require('child_process');
-
-var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
-function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
-
-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 fs3__namespace = /*#__PURE__*/_interopNamespace(fs3);
-var path9__namespace = /*#__PURE__*/_interopNamespace(path9);
-var fs2__namespace = /*#__PURE__*/_interopNamespace(fs2);
-var ts2__namespace = /*#__PURE__*/_interopNamespace(ts2);
-var yaml__default = /*#__PURE__*/_interopDefault(yaml);
-
-var TEMPLATES = {
-  "package.json": `{
-  "name": "my-mcp-tools",
-  "version": "1.0.0",
-  "private": true,
-  "type": "module",
-  "scripts": {
-    "build": "node build.mjs",
-    "start": "node start.mjs"
-  },
-  "devDependencies": {
-    "@easynet/agent-tool": "latest"
-  }
-}
-`,
-  "build.mjs": `import { buildMcpPackage } from "@easynet/agent-tool";
-
-const result = await buildMcpPackage({ outDir: "dist" });
-console.log("Built", result.toolCount, "tool(s) ->", result.outDir);
-`,
-  "start.mjs": `import { runMcpServer } from "@easynet/agent-tool";
-
-const { process: child } = await runMcpServer({ path: "./dist" });
-child.stdin?.pipe(process.stdin);
-child.stdout?.pipe(process.stdout);
-child.stderr?.pipe(process.stderr);
-process.stdin?.ref();
-child.on("close", (code) => process.exit(code ?? 0));
-`,
-  "tsconfig.json": `{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "ESNext",
-    "strict": true,
-    "skipLibCheck": true,
-    "noEmit": true
-  },
-  "include": ["src/**/*.ts"]
-}
-`,
-  "src/tools/example.ts": `/**
- * Add two numbers.
- * @tool
- */
-export async function add(a: number, b: number): Promise<number> {
-  return a + b;
-}
-`,
-  "skills/hello-skill/SKILL.md": `---
-name: hello-skill
-description: Say hello with a name.
----
-
-# Hello Skill
-
-Returns a greeting for the given name.
-`,
-  "skills/hello-skill/handler.js": `export default async function handler(args, ctx) {
-  const name = args?.name ?? "World";
-  return { message: \`Hello, \${name}!\` };
-}
-`,
-  "README.md": `# MCP Tool Project
-
-Scaffolded by \`agent-tool init\`. Workflow:
-
-1. **init** \u2014 create project template (you are here)
-2. **npm install** \u2014 install dependencies
-3. **npm run build** \u2014 generate MCP package under \`dist/\`
-4. **npm start** \u2014 start the MCP server for testing
-
-## Quick start
-
-\`\`\`bash
-npm install
-npm run build
-npm start
-\`\`\`
-
-Edit \`src/tools/*.ts\` (add \`@tool\` JSDoc) and/or \`skills/*/SKILL.md\`, then \`npm run build\` again.
-`
-};
-async function initProject(options = {}) {
-  const targetPath = path9__namespace.resolve(options.targetPath ?? process.cwd());
-  const filesCreated = [];
-  await fs3__namespace.mkdir(targetPath, { recursive: true });
-  for (const [relPath, content] of Object.entries(TEMPLATES)) {
-    const fullPath = path9__namespace.join(targetPath, relPath);
-    await fs3__namespace.mkdir(path9__namespace.dirname(fullPath), { recursive: true });
-    try {
-      await fs3__namespace.access(fullPath);
-      if (relPath === "package.json") continue;
-    } catch {
-    }
-    await fs3__namespace.writeFile(fullPath, content, "utf8");
-    filesCreated.push(relPath);
-  }
-  return { targetPath, filesCreated };
-}
-async function findDirsContainingFile(rootPath, fileName) {
-  const found = [];
-  await collectDirsWithFile(rootPath, fileName, found);
-  return found;
-}
-async function collectDirsWithFile(dir, fileName, acc) {
-  let entries;
-  try {
-    const e = await fs3.readdir(dir, { withFileTypes: true });
-    entries = e.map((x) => ({
-      name: x.name,
-      isDirectory: x.isDirectory(),
-      isFile: x.isFile()
-    }));
-  } catch {
-    return;
-  }
-  if (entries.some((x) => x.isFile && x.name === fileName)) acc.push(dir);
-  for (const entry of entries) {
-    if (!entry.isDirectory || entry.name === "node_modules" || entry.name.startsWith(".")) continue;
-    await collectDirsWithFile(path9.join(dir, entry.name), fileName, acc);
-  }
-}
-function pathToToolName(sourcePath, programName) {
-  const normalized = sourcePath.replace(/\\/g, "/").replace(/\.(ts|tsx|js|mjs|json)$/i, "");
-  const segments = normalized.split("/").filter(Boolean);
-  return segments.length === 0 ? programName : `${segments.join(".")}.${programName}`;
-}
-function buildOutputSchemaFromReturnType(node, typeChecker, onWarn) {
-  const sig = typeChecker.getSignatureFromDeclaration(node);
-  if (!sig) {
-    onWarn?.("Could not get signature for return type, using object");
-    return { type: "object", additionalProperties: true };
-  }
-  let returnType = typeChecker.getReturnTypeOfSignature(sig);
-  if (returnType.getSymbol?.()?.getName() === "Promise") {
-    const typeArgs = returnType.typeArguments;
-    if (typeArgs?.[0]) returnType = typeArgs[0];
-  }
-  const schema = typeToJsonSchema(returnType, typeChecker, onWarn);
-  const hasProps = typeof schema === "object" && schema.type === "object" && Object.keys(schema.properties ?? {}).length > 0;
-  return hasProps ? schema : { type: "object", additionalProperties: true };
-}
-function buildInputSchemaFromParams(node, typeChecker, onWarn) {
-  const properties = {};
-  const required = [];
-  if (!node.parameters.length) {
-    return { schema: { type: "object", properties: {} }, required: [] };
-  }
-  for (const param of node.parameters) {
-    const name = param.name.getText();
-    if (name.startsWith("_") && name.length <= 2) continue;
-    const sym = param.symbol;
-    const paramType = sym ? typeChecker.getTypeOfSymbolAtLocation(sym, param) : typeChecker.getTypeAtLocation(param);
-    const isOptional = !!param.questionToken || param.initializer !== void 0;
-    const propSchema = typeToJsonSchema(paramType, typeChecker, onWarn);
-    properties[name] = propSchema;
-    if (!isOptional) required.push(name);
-  }
-  const paramNames = Object.keys(properties);
-  if (paramNames.length === 1) {
-    const soleName = paramNames[0];
-    const inner = properties[soleName];
-    if (inner && typeof inner === "object" && inner.type === "object" && inner.properties && typeof inner.properties === "object") {
-      return {
-        schema: {
-          type: "object",
-          properties: inner.properties,
-          ...Array.isArray(inner.required) && inner.required.length > 0 ? { required: inner.required } : {},
-          ...inner.additionalProperties !== void 0 ? { additionalProperties: inner.additionalProperties } : {}
-        },
-        required: inner.required ?? []
-      };
-    }
-  }
-  return {
-    schema: {
-      type: "object",
-      properties,
-      ...required.length > 0 ? { required } : {}
-    },
-    required
-  };
-}
-function typeToJsonSchema(type, typeChecker, onWarn) {
-  const flags = type.flags;
-  if (flags & ts2__namespace.TypeFlags.String) return { type: "string" };
-  if (flags & ts2__namespace.TypeFlags.Number) return { type: "number" };
-  if (flags & ts2__namespace.TypeFlags.Boolean) return { type: "boolean" };
-  if (flags & ts2__namespace.TypeFlags.BooleanLiteral) return { type: "boolean" };
-  if (flags & ts2__namespace.TypeFlags.Null) return { type: "null" };
-  if (flags & ts2__namespace.TypeFlags.Undefined || flags & ts2__namespace.TypeFlags.Void) return {};
-  if (flags & ts2__namespace.TypeFlags.Any || flags & ts2__namespace.TypeFlags.Unknown) {
-    onWarn?.(`Unsupported type: any/unknown, using empty schema`);
-    return {};
-  }
-  if (type.isUnion?.()) {
-    const union = type;
-    const types = union.types;
-    const withoutUndef = types.filter(
-      (t) => !(t.flags & ts2__namespace.TypeFlags.Undefined) && !(t.flags & ts2__namespace.TypeFlags.Void)
-    );
-    if (withoutUndef.length === 1) return typeToJsonSchema(withoutUndef[0], typeChecker, onWarn);
-    if (withoutUndef.length === 0) return {};
-    const stringEnumValues = [];
-    let allStringLiterals = true;
-    for (const t of withoutUndef) {
-      if (t.flags & ts2__namespace.TypeFlags.StringLiteral) {
-        const lit = t;
-        if (typeof lit.value === "string") stringEnumValues.push(lit.value);
-      } else {
-        allStringLiterals = false;
-        break;
-      }
-    }
-    if (allStringLiterals && stringEnumValues.length > 0) {
-      return { type: "string", enum: [...new Set(stringEnumValues)] };
-    }
-    let allBooleanLiterals = true;
-    for (const t of withoutUndef) {
-      if (!(t.flags & ts2__namespace.TypeFlags.BooleanLiteral)) {
-        allBooleanLiterals = false;
-        break;
-      }
-    }
-    if (allBooleanLiterals) return { type: "boolean" };
-  }
-  if (flags & ts2__namespace.TypeFlags.StringLiteral) {
-    const lit = type;
-    if (typeof lit.value === "string") {
-      return { type: "string", enum: [lit.value] };
-    }
-    return { type: "string" };
-  }
-  if (typeChecker.isArrayType(type)) {
-    const typeRef = type;
-    const typeArgs = typeRef.typeArguments;
-    const itemType = typeArgs?.[0];
-    const items = itemType ? typeToJsonSchema(itemType, typeChecker, onWarn) : {};
-    return { type: "array", items: Object.keys(items).length ? items : {} };
-  }
-  const str = typeChecker.typeToString(type);
-  if (str === "string") return { type: "string" };
-  if (str === "number") return { type: "number" };
-  if (str === "boolean") return { type: "boolean" };
-  if (str.endsWith("[]")) {
-    const inner = str.slice(0, -2).trim();
-    const itemType = inner === "string" ? { type: "string" } : inner === "number" ? { type: "number" } : {};
-    return { type: "array", items: itemType };
-  }
-  if (type.getProperties && type.getProperties().length >= 0) {
-    const props = type.getProperties();
-    const properties = {};
-    const required = [];
-    for (const p of props) {
-      const decl = p.valueDeclaration;
-      const propType = decl ? typeChecker.getTypeAtLocation(decl) : typeChecker.getTypeOfSymbolAtLocation(p, p.valueDeclaration);
-      const optional = decl && ts2__namespace.isPropertySignature(decl) ? !!decl.questionToken : false;
-      properties[p.name] = typeToJsonSchema(propType, typeChecker, onWarn);
-      if (!optional) required.push(p.name);
-    }
-    return { type: "object", properties, ...required.length ? { required } : {} };
-  }
-  onWarn?.(`Unsupported type: ${str}, using object`);
-  return { type: "object" };
-}
-
-// src/tools/function/types.ts
-var FUNCTION_KIND = "function";
-
-// src/tools/skill/types.ts
-var SKILL_KIND = "skill";
-var SKILL_DIR_NAME = "skill";
-
-// src/tools/n8n/types.ts
-var N8N_KIND = "n8n";
-
-// src/tools/mcp/mcpSpecToToolSpec.ts
-var DEFAULT_OUTPUT = { type: "object", additionalProperties: true };
-function mcpSpecToToolSpec(spec, projectPath) {
-  const base = {
-    name: spec.name,
-    version: "1.0.0",
-    kind: spec.kind,
-    description: spec.description,
-    inputSchema: spec.inputSchema ?? DEFAULT_OUTPUT,
-    outputSchema: "outputSchema" in spec && spec.outputSchema ? spec.outputSchema : chunkQEJF3KDV_cjs.DEFAULT_OUTPUT_SCHEMA,
-    capabilities: [],
-    _meta: spec._meta,
-    ...spec.kind === N8N_KIND && "webhookUrl" in spec && spec.webhookUrl ? { endpoint: spec.webhookUrl } : {}
-  };
-  if (spec.kind === FUNCTION_KIND && "sourcePath" in spec && "exportName" in spec) {
-    base._meta = {
-      ...base._meta,
-      sourcePath: spec.sourcePath,
-      exportName: spec.exportName,
-      ...projectPath && { projectPath }
-    };
-  }
-  if (spec.kind === SKILL_KIND && "sourcePath" in spec && projectPath) {
-    base._meta = { ...base._meta, sourcePath: spec.sourcePath, projectPath };
-  }
-  if (spec.kind === N8N_KIND && "sourcePath" in spec && projectPath) {
-    base._meta = { ...base._meta, sourcePath: spec.sourcePath, projectPath };
-  }
-  return base;
-}
-
-// src/tools/function/scanner.ts
-var TOOL_TAG = "@tool";
-var EFFECT_VALUES = ["none", "local_write", "external_write", "destructive"];
-function scanForTools(options) {
-  const projectPath = path9__namespace.resolve(options.projectPath);
-  const tsconfigPath = options.tsconfigPath ?? path9__namespace.join(projectPath, "tsconfig.json");
-  const include = options.include ?? ["**/*.ts"];
-  const errors = [];
-  const warnings = [];
-  let config;
-  let configPathResolved = path9__namespace.resolve(projectPath, tsconfigPath);
-  if (!fs2__namespace.existsSync(configPathResolved)) {
-    configPathResolved = path9__namespace.join(projectPath, "tsconfig.json");
-  }
-  if (fs2__namespace.existsSync(configPathResolved)) {
-    const configFile = ts2__namespace.readConfigFile(configPathResolved, ts2__namespace.sys.readFile);
-    if (configFile.error) {
-      errors.push({ file: configPathResolved, message: String(configFile.error.messageText) });
-      return { specs: [], errors, warnings };
-    }
-    const parsed = ts2__namespace.parseJsonConfigFileContent(
-      configFile.config,
-      ts2__namespace.sys,
-      path9__namespace.dirname(configPathResolved)
-    );
-    if (parsed.errors.length) {
-      for (const e of parsed.errors) {
-        errors.push({ file: e.file?.fileName ?? "tsconfig", message: String(e.messageText) });
-      }
-      return { specs: [], errors, warnings };
-    }
-    config = parsed;
-  } else {
-    config = {
-      options: {
-        target: ts2__namespace.ScriptTarget.ES2022,
-        module: ts2__namespace.ModuleKind.ESNext,
-        moduleResolution: ts2__namespace.ModuleResolutionKind.NodeNext,
-        strict: true,
-        skipLibCheck: true,
-        noEmit: true
-      },
-      fileNames: resolveGlob(projectPath, include),
-      errors: []
-    };
-  }
-  const program = ts2__namespace.createProgram(config.fileNames, config.options);
-  const typeChecker = program.getTypeChecker();
-  const specs = [];
-  for (const sourceFile of program.getSourceFiles()) {
-    const fileName = sourceFile.fileName;
-    if (fileName.includes("node_modules") || fileName.endsWith(".d.ts")) continue;
-    if (!config.fileNames.some((f) => path9__namespace.resolve(f) === path9__namespace.resolve(fileName))) continue;
-    ts2__namespace.forEachChild(sourceFile, (node) => {
-      const decl = getExportedFunctionDeclaration(node);
-      if (!decl) return;
-      const func = decl.func;
-      const name = decl.name;
-      if (!name) return;
-      const host = getJSDocHost(func);
-      if (!hasToolTag(host)) return;
-      const jsDoc = getJSDocComments(host);
-      const description = getDescription(jsDoc);
-      if (!description) {
-        warnings.push({ file: fileName, message: `Tool ${name}: missing description, using humanized name` });
-      }
-      const sideEffect = getEffect(host);
-      const onWarn = (msg) => warnings.push({ file: fileName, message: `${name}: ${msg}` });
-      const { schema } = buildInputSchemaFromParams(func, typeChecker, onWarn);
-      const inputSchema = Object.keys(schema.properties ?? {}).length > 0 ? schema : { type: "object", properties: {} };
-      const outputSchema = buildOutputSchemaFromReturnType(func, typeChecker, onWarn);
-      const sourcePath = path9__namespace.relative(projectPath, fileName) || path9__namespace.basename(fileName);
-      const toolName = pathToToolName(sourcePath, name);
-      specs.push({
-        kind: FUNCTION_KIND,
-        name: toolName,
-        description: description || humanize(name),
-        inputSchema,
-        outputSchema,
-        _meta: { hitl: { sideEffect } },
-        sourcePath,
-        exportName: name
-      });
-    });
-  }
-  return { specs, errors, warnings };
-}
-function resolveGlob(projectPath, patterns) {
-  const result = [];
-  const seen = /* @__PURE__ */ new Set();
-  const add = (f) => {
-    const abs = path9__namespace.resolve(f);
-    if (f.endsWith(".ts") && !f.endsWith(".d.ts") && !seen.has(abs)) {
-      seen.add(abs);
-      result.push(abs);
-    }
-  };
-  for (const p of patterns) {
-    const full = path9__namespace.join(projectPath, p);
-    if (full.includes("*")) {
-      const baseDir = full.replace(/\*\*\/.*$/, "").replace(/\*.*$/, "").replace(/\/?$/, "") || ".";
-      const dir = path9__namespace.resolve(projectPath, baseDir);
-      if (fs2__namespace.existsSync(dir)) walk(dir, add);
-    } else {
-      const resolved = path9__namespace.resolve(projectPath, full);
-      if (fs2__namespace.existsSync(resolved)) {
-        if (fs2__namespace.statSync(resolved).isFile()) add(resolved);
-        else walk(resolved, add);
-      }
-    }
-  }
-  if (result.length > 0) return result;
-  const srcDir = path9__namespace.join(projectPath, "src");
-  if (fs2__namespace.existsSync(srcDir)) return walkCollect(srcDir);
-  return [];
-}
-function walkCollect(dir) {
-  const out = [];
-  walk(dir, (fullPath) => {
-    if (fullPath.endsWith(".ts") && !fullPath.endsWith(".d.ts")) out.push(path9__namespace.resolve(fullPath));
-  });
-  return out;
-}
-var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", "generated", "dist"]);
-function walk(dir, visit) {
-  try {
-    const entries = fs2__namespace.readdirSync(dir, { withFileTypes: true });
-    for (const e of entries) {
-      const full = path9__namespace.join(dir, e.name);
-      if (e.isDirectory() && !SKIP_DIRS.has(e.name)) walk(full, visit);
-      else if (e.isFile()) visit(full);
-    }
-  } catch {
-  }
-}
-function getExportedFunctionDeclaration(node, _sourceFile) {
-  if (ts2__namespace.isFunctionDeclaration(node) && node.name) {
-    const exported = (ts2__namespace.getModifiers(node) ?? []).some((m) => m.kind === ts2__namespace.SyntaxKind.ExportKeyword);
-    if (exported) return { func: node, name: node.name.getText() };
-    return null;
-  }
-  if (ts2__namespace.isVariableStatement(node)) {
-    const exported = (ts2__namespace.getModifiers(node) ?? []).some((m) => m.kind === ts2__namespace.SyntaxKind.ExportKeyword);
-    if (!exported) return null;
-    for (const decl of node.declarationList.declarations) {
-      let init = decl.initializer;
-      while (init && (ts2__namespace.isParenthesizedExpression(init) || ts2__namespace.isAsExpression(init)))
-        init = init.expression;
-      if (init && ts2__namespace.isArrowFunction(init)) {
-        const name = decl.name.getText();
-        return { func: init, name };
-      }
-      if (init && ts2__namespace.isFunctionExpression(init)) {
-        const name = decl.name.getText();
-        return { func: init, name };
-      }
-    }
-  }
-  return null;
-}
-function getJSDocHost(node) {
-  const parent = node.parent;
-  if (ts2__namespace.isVariableDeclaration(parent)) {
-    const gp = parent.parent;
-    if (ts2__namespace.isVariableDeclarationList(gp) && gp.parent && ts2__namespace.isVariableStatement(gp.parent)) return gp.parent;
-  }
-  return node;
-}
-function getJSDocComments(host) {
-  const all = ts2__namespace.getJSDocCommentsAndTags(host);
-  return all.filter((t) => ts2__namespace.isJSDoc(t));
-}
-function hasToolTag(host) {
-  const tags = ts2__namespace.getJSDocTags(host);
-  for (const tag of tags) {
-    const name = tag.tagName?.getText() ?? "";
-    if (name === "tool") return true;
-  }
-  const all = ts2__namespace.getJSDocCommentsAndTags(host);
-  for (const t of all) {
-    if (ts2__namespace.isJSDoc(t)) {
-      const full = t.getFullText();
-      if (full.includes(TOOL_TAG)) return true;
-    }
-  }
-  return false;
-}
-function getDescription(jsDocs, fallbackName) {
-  for (const doc of jsDocs) {
-    const comment = doc.comment;
-    if (typeof comment === "string") {
-      const first = comment.split(/\n/)[0]?.trim() ?? "";
-      if (first && !first.startsWith("@")) return first;
-    }
-    if (Array.isArray(comment)) {
-      const first = comment[0];
-      if (first && typeof first === "object" && "text" in first) {
-        const t = first.text.trim();
-        if (t && !t.startsWith("@")) return t;
-      }
-    }
-    const full = doc.getFullText();
-    const match = full.match(/\*\s*@tool\s+(.+?)(?=\n|$|\*\/)/s);
-    if (match?.[1]) return match[1].trim();
-  }
-  return "";
-}
-function getEffect(host) {
-  const tags = ts2__namespace.getJSDocTags(host);
-  for (const tag of tags) {
-    const name = tag.tagName?.getText() ?? "";
-    if (name === "effect") {
-      const comment = tag.comment;
-      const v = (typeof comment === "string" ? comment : "").trim().toLowerCase();
-      if (EFFECT_VALUES.includes(v)) return v;
-    }
-  }
-  const all = ts2__namespace.getJSDocCommentsAndTags(host);
-  for (const t of all) {
-    if (ts2__namespace.isJSDoc(t)) {
-      const full = t.getFullText();
-      const match = full.match(/\*\s*@effect\s+(\w+)/);
-      if (match && EFFECT_VALUES.includes(match[1])) return match[1];
-    }
-  }
-  return "none";
-}
-function humanize(name) {
-  return name.replace(/([A-Z])/g, " $1").replace(/^./, (s) => s.toUpperCase()).trim();
-}
-function scan(projectPath, options = {}) {
-  const root = path9__namespace.resolve(projectPath);
-  const result = scanForTools({
-    projectPath: root,
-    include: options.include ?? ["**/*.ts"],
-    tsconfigPath: options.tsconfigPath
-  });
-  const specs = result.specs.map((s) => mcpSpecToToolSpec(s, root));
-  return Promise.resolve({
-    specs,
-    errors: result.errors,
-    warnings: result.warnings
-  });
-}
-var DEFAULT_EXTENSIONS = [".js", ".mjs"];
-async function resolveEntryPoint(dirPath, baseName, extensions = DEFAULT_EXTENSIONS) {
-  if (extensions.some((ext) => baseName.endsWith(ext))) {
-    const fullPath = path9.join(dirPath, baseName);
-    await fs3.stat(fullPath);
-    return fullPath;
-  }
-  for (const ext of extensions) {
-    const fullPath = path9.join(dirPath, `${baseName}${ext}`);
-    try {
-      await fs3.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(path12, field, message) {
-    super(`SKILL.md error in ${path12}: ${message}`);
-    this.path = path12;
-    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) {
-  const trimmed = content.trimStart();
-  if (!trimmed.startsWith("---")) {
-    throw new SkillManifestError(
-      filePath,
-      "frontmatter",
-      "SKILL.md must start with YAML frontmatter (---)"
-    );
-  }
-  const endIndex = trimmed.indexOf("\n---", 3);
-  if (endIndex === -1) {
-    throw new SkillManifestError(
-      filePath,
-      "frontmatter",
-      "SKILL.md frontmatter is not closed (missing closing ---)"
-    );
-  }
-  const yamlBlock = trimmed.slice(4, endIndex).trim();
-  const body = trimmed.slice(endIndex + 4).trim();
-  let raw;
-  try {
-    const parsed = yaml__default.default.load(yamlBlock);
-    if (parsed == null || typeof parsed !== "object" || Array.isArray(parsed)) {
-      throw new SkillManifestError(
-        filePath,
-        "frontmatter",
-        "YAML frontmatter must be an object (key: value)"
-      );
-    }
-    raw = parsed;
-  } 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 fs3.readdir(currentPath, { withFileTypes: true });
-  } catch {
-    return;
-  }
-  for (const entry of entries) {
-    const fullPath = path9.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 = path9.extname(entry.name).toLowerCase();
-      const relPath = path9.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 = path9.join(dirPath, "SKILL.md");
-  let content;
-  try {
-    content = await fs3.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 = path9__namespace.resolve(projectPath);
-  const dirs = await findDirsContainingFile(projectRoot, "SKILL.md");
-  const skills = [];
-  const errors = [];
-  for (const dirPath of dirs) {
-    const relativePath = path9__namespace.relative(projectRoot, dirPath) || path9__namespace.basename(dirPath);
-    try {
-      const skillDef = await loadSkillDefinition(dirPath);
-      const name = pathToToolName(relativePath, skillDef.frontmatter.name);
-      skills.push({
-        kind: 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 = path9__namespace.resolve(projectPath);
-  const result = await scanForSkill(root);
-  const specs = result.skills.map((s) => 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 = path9.join(dirPath, workflowFileName);
-  let raw;
-  try {
-    raw = await fs3.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 || path9.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 = path9__namespace.resolve(projectPath);
-  const dirs = await findDirsContainingFile(projectRoot, "workflow.json");
-  const n8n = [];
-  const errors = [];
-  for (const dirPath of dirs) {
-    const relativePath = path9__namespace.relative(projectRoot, dirPath) || path9__namespace.basename(dirPath);
-    try {
-      const { name: wfName, description: wfDesc, webhookUrl } = await readWorkflowMeta(dirPath);
-      const toolName = pathToToolName(relativePath, wfName);
-      n8n.push({
-        kind: 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 = path9__namespace.resolve(projectPath);
-  const result = await scanForN8n(root);
-  const specs = result.n8n.map((s) => mcpSpecToToolSpec(s, root));
-  return {
-    specs,
-    errors: result.errors.map((e) => ({ file: e.dir, message: e.message }))
-  };
-}
-async function scan4(projectPath, options = {}) {
-  const root = path9__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 === chunkWFPHIYB6_cjs.MCP_KIND);
-  return { specs: filtered, errors };
-}
-async function scan5(projectPath, options = {}) {
-  const root = path9__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 === chunkWFPHIYB6_cjs.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 fs3.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 fs3.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 = path9.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?.(path9.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 = path9.join(dirPath, manifest.entryPoint ?? "mcp.json");
-  let raw;
-  try {
-    raw = await fs3.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 = path9__namespace.resolve(projectPath);
-  switch (type) {
-    case "function":
-      return 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 fs3.readdir(dirPath, { withFileTypes: true });
-      dirEntries = entries.map((entry) => ({
-        name: entry.name,
-        isDirectory: entry.isDirectory()
-      }));
-    } catch (error) {
-      this.onError?.(dirPath, error);
-      return specs;
-    }
-    const dirName = path9.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 = path9.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 = path9.join(dirPath, "tool.json");
-    let manifestRaw;
-    try {
-      manifestRaw = await fs3.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,
-          chunkWFPHIYB6_cjs.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,
-        chunkWFPHIYB6_cjs.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(path9.join(dirPath, m.markerFile))) kinds.push(m.kind);
-    }
-    const isLangchainDir = dirName === chunkWFPHIYB6_cjs.LANGCHAIN_DIR_NAME;
-    const hasLangchain = isLangchainDir ? (await listLangchainEntryFiles(dirPath, this.extensions)).length > 0 : dirName !== 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(path12) {
-    try {
-      await fs3.access(path12);
-      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 = path9.basename(path9.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
-    };
-  }
-};
-
-// src/tools/scanPackage.ts
-async function scanForAllTools(projectPath, options = {}) {
-  const include = options.include ?? ["**/*.ts"];
-  const tsconfigPath = options.tsconfigPath;
-  const includeN8n = options.includeN8n === true;
-  const opts = { include, tsconfigPath };
-  const results = await Promise.all([
-    discoverTools("function", projectPath, opts),
-    discoverTools("skill", projectPath, opts),
-    ...includeN8n ? [discoverTools("n8n", projectPath, opts)] : []
-  ]);
-  const specs = results.flatMap((r) => r.specs);
-  const errors = results.flatMap((r) => r.errors);
-  const warnings = results.flatMap((r) => r.warnings ?? []);
-  return { specs, errors, warnings };
-}
-var __dirname$1 = path9__namespace.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('chunk-K45PQLZI.cjs', document.baseURI).href))));
-async function loadTemplate(name) {
-  for (const dir of [
-    path9__namespace.join(__dirname$1, "templates"),
-    path9__namespace.join(__dirname$1, "..", "templates")
-  ]) {
-    try {
-      return await fs3__namespace.readFile(path9__namespace.join(dir, name), "utf-8");
-    } catch {
-      continue;
-    }
-  }
-  throw new Error(`Template not found: ${name}. Tried templates/ next to generator and ../templates.`);
-}
-var TEMPLATE_NAMES = {
-  mcpServer: "mcp-server.js",
-  toolIndex: "tool-index.js",
-  skillInvoker: "skill-invoker.js",
-  n8nInvoker: "n8n-invoker.js"
-};
-function buildToolIndexCases(specs, fromGeneratedToProject) {
-  return specs.map((s) => {
-    const modPath = path9__namespace.join(fromGeneratedToProject, s._meta.sourcePath).replace(/\\/g, "/");
-    return `    case "${s.name}": return (await import("${modPath}")).${s._meta.exportName};`;
-  }).join("\n");
-}
-function buildSkillInvokerCases(specs, fromGeneratedToProject) {
-  return specs.map((s) => {
-    const handlerPath = path9__namespace.join(fromGeneratedToProject, s._meta.sourcePath, "handler").replace(/\\/g, "/");
-    const descEscaped = (s.description ?? "").replace(/"/g, '\\"');
-    return `    case "${s.name}": {
-      const mod = await import("${handlerPath}.js").catch(() => import("${handlerPath}.mjs"));
-      const fn = mod.default ?? mod.handler;
-      if (typeof fn !== "function") return { result: null, error: "No handler" };
-      const ctx = { requestId: "mcp", taskId: "mcp", skill: { name: "${s.name}", description: "${descEscaped}", instructions: "", resources: [], readResource: async () => "", getResourcesByType: () => [], dirPath: "" } };
-      const out = await fn(args, ctx);
-      return out?.result !== undefined ? out.result : out;
-    }`;
-  }).join("\n");
-}
-function buildN8nInvokerCases(specs) {
-  return specs.map((s) => {
-    const webhookUrl = s.endpoint;
-    const url = webhookUrl ? `"${webhookUrl}"` : "process.env.N8N_WEBHOOK_" + s.name.replace(/[^a-zA-Z0-9]/g, "_").toUpperCase() + " ?? null";
-    return `    case "${s.name}": {
-      const url = ${url};
-      if (!url) throw new Error("n8n webhook not configured for ${s.name}. Set N8N_WEBHOOK_* or add webhook to workflow.");
-      const res = await fetch(url, { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify(args) });
-      if (!res.ok) throw new Error("n8n request failed: " + res.status);
-      return res.json().catch(() => ({}));
-    }`;
-  }).join("\n");
-}
-async function generate(options) {
-  const { specs, outDir, projectPath } = options;
-  await fs3__namespace.mkdir(outDir, { recursive: true });
-  const functionSpecs = specs.filter(
-    (s) => s.kind === FUNCTION_KIND && s._meta?.sourcePath != null && s._meta?.exportName != null
-  );
-  const skillSpecs = specs.filter(
-    (s) => s.kind === SKILL_KIND && s._meta?.sourcePath != null
-  );
-  const n8nSpecs = specs.filter((s) => s.kind === N8N_KIND);
-  const toolSpecsJson = specs.map((s) => ({
-    kind: s.kind,
-    name: s.name,
-    description: s.description,
-    inputSchema: s.inputSchema,
-    ...s.kind === FUNCTION_KIND && s._meta?.sourcePath != null && s._meta?.exportName != null && {
-      outputSchema: s.outputSchema ?? { type: "object", additionalProperties: true },
-      sourcePath: s._meta.sourcePath,
-      exportName: s._meta.exportName
-    },
-    _meta: s._meta,
-    ...s.kind === SKILL_KIND && s._meta?.sourcePath != null && { sourcePath: s._meta.sourcePath },
-    ...s.kind === N8N_KIND && {
-      sourcePath: s._meta?.sourcePath,
-      webhookUrl: s.endpoint
-    }
-  }));
-  await fs3__namespace.writeFile(
-    path9__namespace.join(outDir, "tool-specs.json"),
-    JSON.stringify(toolSpecsJson, null, 2),
-    "utf-8"
-  );
-  const configJson = { projectPath: path9__namespace.resolve(projectPath) };
-  await fs3__namespace.writeFile(path9__namespace.join(outDir, "config.json"), JSON.stringify(configJson, null, 2), "utf-8");
-  const rel = path9__namespace.relative(outDir, projectPath) || ".";
-  const fromGeneratedToProject = rel.split(path9__namespace.sep).length ? rel : ".";
-  const [mcpServerTemplate, toolIndexTemplate, skillInvokerTemplate, n8nInvokerTemplate] = await Promise.all([
-    loadTemplate(TEMPLATE_NAMES.mcpServer),
-    loadTemplate(TEMPLATE_NAMES.toolIndex),
-    loadTemplate(TEMPLATE_NAMES.skillInvoker),
-    loadTemplate(TEMPLATE_NAMES.n8nInvoker)
-  ]);
-  const toolIndexTs = toolIndexTemplate.replace("{{CASES}}", buildToolIndexCases(functionSpecs, fromGeneratedToProject));
-  await fs3__namespace.writeFile(path9__namespace.join(outDir, "tool-index.ts"), toolIndexTs, "utf-8");
-  const skillCases = buildSkillInvokerCases(skillSpecs, fromGeneratedToProject);
-  const skillDefaultCase = skillSpecs.length === 0 ? "default: throw new Error('Unknown skill: ' + name);" : 'default: throw new Error("Unknown skill: " + name);';
-  const skillInvokerTs = skillInvokerTemplate.replace("{{CASES}}", skillCases).replace("{{DEFAULT_CASE}}", skillDefaultCase);
-  await fs3__namespace.writeFile(path9__namespace.join(outDir, "skill-invoker.ts"), skillInvokerTs, "utf-8");
-  const n8nCases = buildN8nInvokerCases(n8nSpecs);
-  const n8nDefaultCase = n8nSpecs.length === 0 ? "default: throw new Error('Unknown n8n tool: ' + name);" : 'default: throw new Error("Unknown n8n tool: " + name);';
-  const n8nInvokerTs = n8nInvokerTemplate.replace("{{CASES}}", n8nCases).replace("{{DEFAULT_CASE}}", n8nDefaultCase);
-  await fs3__namespace.writeFile(path9__namespace.join(outDir, "n8n-invoker.ts"), n8nInvokerTs, "utf-8");
-  await fs3__namespace.writeFile(path9__namespace.join(outDir, "mcp-server.ts"), mcpServerTemplate, "utf-8");
-  const mcpJson = {
-    command: "npx",
-    args: ["-y", "tsx", path9__namespace.join(outDir, "mcp-server.ts")]
-  };
-  await fs3__namespace.writeFile(path9__namespace.join(outDir, "mcp.json"), JSON.stringify(mcpJson, null, 2), "utf-8");
-  const packageJson = {
-    name: "function-tools-mcp",
-    version: "1.0.0",
-    type: "module",
-    description: "MCP server generated from @tool functions, SKILL.md, and workflow.json",
-    main: "mcp-server.ts",
-    scripts: { start: "npx tsx mcp-server.ts" },
-    dependencies: {
-      "@modelcontextprotocol/sdk": "^1.25.3",
-      typescript: ">=5.0.0",
-      tsx: ">=4.0.0"
-    }
-  };
-  await fs3__namespace.writeFile(path9__namespace.join(outDir, "package.json"), JSON.stringify(packageJson, null, 2), "utf-8");
-  return {
-    entryPath: path9__namespace.join(outDir, "mcp-server.ts"),
-    mcpJsonPath: path9__namespace.join(outDir, "mcp.json")
-  };
-}
-
-// src/api/expose/mcp-build/build.ts
-async function buildMcpPackage(options = {}) {
-  const projectPath = path9__namespace.resolve(options.projectPath ?? process.cwd());
-  const outDir = path9__namespace.resolve(projectPath, options.outDir ?? "dist");
-  const include = options.include ?? ["**/*.ts"];
-  const tsconfigPath = options.tsconfigPath;
-  const scanResult = await scanForAllTools(projectPath, {
-    include,
-    tsconfigPath,
-    includeN8n: options.includeN8n
-  });
-  if (scanResult.errors.length > 0) {
-    const msg = scanResult.errors.map((e) => `${e.file}: ${e.message}`).join("; ");
-    throw new Error(`Scan failed: ${msg}`);
-  }
-  const allSpecs = scanResult.specs;
-  if (allSpecs.length === 0) {
-    throw new Error(
-      "No tools found. Add @tool functions (JSDoc), SKILL.md directories, or workflow.json directories."
-    );
-  }
-  const { entryPath, mcpJsonPath } = await generate({
-    specs: allSpecs,
-    outDir,
-    projectPath
-  });
-  return {
-    outDir,
-    toolCount: allSpecs.length,
-    entryPath,
-    mcpJsonPath
-  };
-}
-var buildFunctionToTool = buildMcpPackage;
-async function runMcpServer(options = {}) {
-  const base = options.path ?? process.cwd();
-  const candidates = [
-    path9__namespace.join(base, "mcp-server.ts"),
-    path9__namespace.join(base, "mcp-server.js"),
-    path9__namespace.join(base, "dist", "mcp-server.ts"),
-    path9__namespace.join(base, "dist", "mcp-server.js"),
-    path9__namespace.join(base, "generated", "mcp-server.ts"),
-    path9__namespace.join(base, "generated", "mcp-server.js")
-  ];
-  let entry = "";
-  for (const p of candidates) {
-    try {
-      await fs3__namespace.access(p);
-      entry = p;
-      break;
-    } catch {
-    }
-  }
-  if (!entry) {
-    throw new Error(
-      `MCP entrypoint not found. Run "agent-tool build" first, or pass --path to a directory containing mcp-server.ts. Tried: ${candidates.join(", ")}`
-    );
-  }
-  const dir = path9__namespace.dirname(entry);
-  const child = child_process.spawn("npx", ["-y", "tsx", path9__namespace.basename(entry)], {
-    cwd: dir,
-    stdio: ["pipe", "pipe", "inherit"],
-    shell: false
-  });
-  return { process: child };
-}
-var runGeneratedMCP = runMcpServer;
-
-exports.buildFunctionToTool = buildFunctionToTool;
-exports.buildMcpPackage = buildMcpPackage;
-exports.initProject = initProject;
-exports.runGeneratedMCP = runGeneratedMCP;
-exports.runMcpServer = runMcpServer;
-exports.scan = scan;
-exports.scanForTools = scanForTools;
-//# sourceMappingURL=chunk-K45PQLZI.cjs.map
-//# sourceMappingURL=chunk-K45PQLZI.cjs.map