@easynet/agent-tool 1.0.0

package/dist/chunk-BM4EVYI5.js

@@ -0,0 +1,1069 @@
+import * as fs3 from 'fs/promises';
+import { readdir, readFile } from 'fs/promises';
+import * as path5 from 'path';
+import { join, extname, relative, basename } from 'path';
+import * as fs2 from 'fs';
+import * as ts2 from 'typescript';
+import yaml from 'js-yaml';
+import { fileURLToPath } from 'url';
+import { spawn } from 'child_process';
+
+// src/codegen/init.ts
+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 = path5.resolve(options.targetPath ?? process.cwd());
+  const filesCreated = [];
+  await fs3.mkdir(targetPath, { recursive: true });
+  for (const [relPath, content] of Object.entries(TEMPLATES)) {
+    const fullPath = path5.join(targetPath, relPath);
+    await fs3.mkdir(path5.dirname(fullPath), { recursive: true });
+    try {
+      await fs3.access(fullPath);
+      if (relPath === "package.json") continue;
+    } catch {
+    }
+    await fs3.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, found) {
+  let entries;
+  try {
+    const e = await 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)) {
+    found.push(dir);
+  }
+  for (const entry of entries) {
+    if (!entry.isDirectory || entry.name === "node_modules" || entry.name.startsWith(".")) {
+      continue;
+    }
+    await collectDirsWithFile(join(dir, entry.name), fileName, found);
+  }
+}
+function pathToToolName(sourcePath, programName) {
+  const normalized = sourcePath.replace(/\\/g, "/").replace(/\.(ts|tsx|js|mjs|json)$/i, "");
+  const segments = normalized.split("/").filter(Boolean);
+  if (segments.length === 0) return programName;
+  const pathPart = segments.join(".");
+  return `${pathPart}.${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);
+  }
+  return {
+    schema: {
+      type: "object",
+      properties,
+      ...required.length > 0 ? { required } : {}
+    },
+    required
+  };
+}
+function typeToJsonSchema(type, typeChecker, onWarn) {
+  const flags = type.flags;
+  if (flags & ts2.TypeFlags.String) return { type: "string" };
+  if (flags & ts2.TypeFlags.Number) return { type: "number" };
+  if (flags & ts2.TypeFlags.Boolean) return { type: "boolean" };
+  if (flags & ts2.TypeFlags.Null) return { type: "null" };
+  if (flags & ts2.TypeFlags.Undefined || flags & ts2.TypeFlags.Void) return {};
+  if (flags & ts2.TypeFlags.Any || flags & ts2.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.TypeFlags.Undefined) && !(t.flags & ts2.TypeFlags.Void)
+    );
+    if (withoutUndef.length === 1) return typeToJsonSchema(withoutUndef[0], typeChecker, onWarn);
+    if (withoutUndef.length === 0) return {};
+  }
+  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.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/codegen/scan/scanner.ts
+var TOOL_TAG = "@tool";
+var EFFECT_VALUES = ["none", "local_write", "external_write", "destructive"];
+function scanForTools(options) {
+  const projectPath = path5.resolve(options.projectPath);
+  const tsconfigPath = options.tsconfigPath ?? path5.join(projectPath, "tsconfig.json");
+  const include = options.include ?? ["**/*.ts"];
+  const errors = [];
+  const warnings = [];
+  let config;
+  let configPathResolved = path5.resolve(projectPath, tsconfigPath);
+  if (!fs2.existsSync(configPathResolved)) {
+    configPathResolved = path5.join(projectPath, "tsconfig.json");
+  }
+  if (fs2.existsSync(configPathResolved)) {
+    const configFile = ts2.readConfigFile(configPathResolved, ts2.sys.readFile);
+    if (configFile.error) {
+      errors.push({ file: configPathResolved, message: String(configFile.error.messageText) });
+      return { specs: [], errors, warnings };
+    }
+    const parsed = ts2.parseJsonConfigFileContent(
+      configFile.config,
+      ts2.sys,
+      path5.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.ScriptTarget.ES2022,
+        module: ts2.ModuleKind.ESNext,
+        moduleResolution: ts2.ModuleResolutionKind.NodeNext,
+        strict: true,
+        skipLibCheck: true,
+        noEmit: true
+      },
+      fileNames: resolveGlob(projectPath, include),
+      errors: []
+    };
+  }
+  const program = ts2.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) => path5.resolve(f) === path5.resolve(fileName))) continue;
+    ts2.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 = path5.relative(projectPath, fileName) || path5.basename(fileName);
+      const toolName = pathToToolName(sourcePath, name);
+      specs.push({
+        kind: "function",
+        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 = path5.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 = path5.join(projectPath, p);
+    if (full.includes("*")) {
+      const baseDir = full.replace(/\*\*\/.*$/, "").replace(/\*.*$/, "").replace(/\/?$/, "") || ".";
+      const dir = path5.resolve(projectPath, baseDir);
+      if (fs2.existsSync(dir)) walk(dir, add);
+    } else {
+      const resolved = path5.resolve(projectPath, full);
+      if (fs2.existsSync(resolved)) {
+        if (fs2.statSync(resolved).isFile()) add(resolved);
+        else walk(resolved, add);
+      }
+    }
+  }
+  if (result.length > 0) return result;
+  const srcDir = path5.join(projectPath, "src");
+  if (fs2.existsSync(srcDir)) return walkCollect(srcDir);
+  return [];
+}
+function walkCollect(dir) {
+  const out = [];
+  walk(dir, (fullPath) => {
+    if (fullPath.endsWith(".ts") && !fullPath.endsWith(".d.ts")) out.push(path5.resolve(fullPath));
+  });
+  return out;
+}
+var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", "generated", "dist"]);
+function walk(dir, visit) {
+  try {
+    const entries = fs2.readdirSync(dir, { withFileTypes: true });
+    for (const e of entries) {
+      const full = path5.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.isFunctionDeclaration(node) && node.name) {
+    const exported = (ts2.getModifiers(node) ?? []).some((m) => m.kind === ts2.SyntaxKind.ExportKeyword);
+    if (exported) return { func: node, name: node.name.getText() };
+    return null;
+  }
+  if (ts2.isVariableStatement(node)) {
+    const exported = (ts2.getModifiers(node) ?? []).some((m) => m.kind === ts2.SyntaxKind.ExportKeyword);
+    if (!exported) return null;
+    for (const decl of node.declarationList.declarations) {
+      const init = decl.initializer;
+      if (init && ts2.isArrowFunction(init)) {
+        const name = decl.name.getText();
+        return { func: init, name };
+      }
+      if (init && ts2.isFunctionExpression(init)) {
+        const name = decl.name.getText();
+        return { func: init, name };
+      }
+    }
+  }
+  return null;
+}
+function getJSDocHost(node) {
+  const parent = node.parent;
+  if (ts2.isVariableDeclaration(parent)) {
+    const gp = parent.parent;
+    if (ts2.isVariableDeclarationList(gp) && gp.parent && ts2.isVariableStatement(gp.parent)) return gp.parent;
+  }
+  return node;
+}
+function getJSDocComments(host) {
+  const all = ts2.getJSDocCommentsAndTags(host);
+  return all.filter((t) => ts2.isJSDoc(t));
+}
+function hasToolTag(host) {
+  const tags = ts2.getJSDocTags(host);
+  for (const tag of tags) {
+    const name = tag.tagName?.getText() ?? "";
+    if (name === "tool") return true;
+  }
+  const all = ts2.getJSDocCommentsAndTags(host);
+  for (const t of all) {
+    if (ts2.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.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.getJSDocCommentsAndTags(host);
+  for (const t of all) {
+    if (ts2.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();
+}
+
+// src/discovery/load/SkillManifest.ts
+var SkillManifestError = class extends Error {
+  constructor(path8, field, message) {
+    super(`SKILL.md error in ${path8}: ${message}`);
+    this.path = path8;
+    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})`
+      );
+    }
+  }
+}
+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.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 readdir(currentPath, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    const fullPath = 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 = extname(entry.name).toLowerCase();
+      const relPath = 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 = join(dirPath, "SKILL.md");
+  let content;
+  try {
+    content = await 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/discovery/errors.ts
+var DiscoveryError = class extends Error {
+  /** Absolute path to the tool directory that caused the error */
+  toolDir;
+  /** Phase in which the error occurred */
+  phase;
+  /** The underlying cause */
+  cause;
+  constructor(toolDir, phase, message, cause) {
+    super(`[${phase}] ${toolDir}: ${message}`);
+    this.name = "DiscoveryError";
+    this.toolDir = toolDir;
+    this.phase = phase;
+    this.cause = cause;
+  }
+};
+var defaultInputSchema = { type: "object", properties: {}, additionalProperties: true };
+async function scanForSkill(projectPath) {
+  const projectRoot = path5.resolve(projectPath);
+  const dirs = await findDirsContainingFile(projectRoot, "SKILL.md");
+  const skills = [];
+  const errors = [];
+  for (const dirPath of dirs) {
+    const relativePath = path5.relative(projectRoot, dirPath) || path5.basename(dirPath);
+    try {
+      const skillDef = await loadSkillDefinition(dirPath);
+      const name = pathToToolName(relativePath, skillDef.frontmatter.name);
+      skills.push({
+        kind: "skill",
+        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 readWorkflowMeta(dirPath, workflowFileName = "workflow.json") {
+  const workflowPath = join(dirPath, workflowFileName);
+  let raw;
+  try {
+    raw = await 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 || 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/codegen/scan/scanN8n.ts
+var defaultInputSchema2 = { type: "object", properties: {}, additionalProperties: true };
+async function scanForN8n(projectPath) {
+  const projectRoot = path5.resolve(projectPath);
+  const dirs = await findDirsContainingFile(projectRoot, "workflow.json");
+  const n8n = [];
+  const errors = [];
+  for (const dirPath of dirs) {
+    const relativePath = path5.relative(projectRoot, dirPath) || path5.basename(dirPath);
+    try {
+      const { name: wfName, description: wfDesc, webhookUrl } = await readWorkflowMeta(dirPath);
+      const toolName = pathToToolName(relativePath, wfName);
+      n8n.push({
+        kind: "n8n",
+        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 };
+}
+
+// src/codegen/scan/scanTools.ts
+async function scanForAllTools(projectPath, options = {}) {
+  const include = options.include ?? ["**/*.ts"];
+  const tsconfigPath = options.tsconfigPath;
+  const includeN8n = options.includeN8n === true;
+  const [functionResult, skillResult, n8nResult] = await Promise.all([
+    Promise.resolve(scanForTools({ projectPath, include, tsconfigPath })),
+    scanForSkill(projectPath),
+    includeN8n ? scanForN8n(projectPath) : Promise.resolve({ n8n: [], errors: [] })
+  ]);
+  const specs = [
+    ...functionResult.specs,
+    ...skillResult.skills,
+    ...n8nResult.n8n
+  ];
+  const errors = [
+    ...functionResult.errors,
+    ...skillResult.errors.map((e) => ({ file: e.dir, message: e.message })),
+    ...includeN8n ? n8nResult.errors.map((e) => ({ file: e.dir, message: e.message })) : []
+  ];
+  const warnings = [...functionResult.warnings];
+  return { specs, errors, warnings };
+}
+var __dirname$1 = path5.dirname(fileURLToPath(import.meta.url));
+async function loadTemplate(name) {
+  for (const dir of [
+    path5.join(__dirname$1, "templates"),
+    path5.join(__dirname$1, "..", "templates")
+  ]) {
+    try {
+      return await fs3.readFile(path5.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 = path5.join(fromGeneratedToProject, s.sourcePath).replace(/\\/g, "/");
+    return `    case "${s.name}": return (await import("${modPath}")).${s.exportName};`;
+  }).join("\n");
+}
+function buildSkillInvokerCases(specs, fromGeneratedToProject) {
+  return specs.map((s) => {
+    const handlerPath = path5.join(fromGeneratedToProject, s.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 url = s.webhookUrl ? `"${s.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.mkdir(outDir, { recursive: true });
+  const functionSpecs = specs.filter((s) => s.kind === "function");
+  const skillSpecs = specs.filter((s) => s.kind === "skill");
+  const n8nSpecs = specs.filter((s) => s.kind === "n8n");
+  const toolSpecsJson = specs.map((s) => ({
+    kind: s.kind,
+    name: s.name,
+    description: s.description,
+    inputSchema: s.inputSchema,
+    ...s.kind === "function" && {
+      outputSchema: s.outputSchema ?? { type: "object", additionalProperties: true },
+      sourcePath: s.sourcePath,
+      exportName: s.exportName
+    },
+    _meta: s._meta,
+    ...s.kind === "skill" && { sourcePath: s.sourcePath },
+    ...s.kind === "n8n" && { sourcePath: s.sourcePath, webhookUrl: s.webhookUrl }
+  }));
+  await fs3.writeFile(
+    path5.join(outDir, "tool-specs.json"),
+    JSON.stringify(toolSpecsJson, null, 2),
+    "utf-8"
+  );
+  const configJson = { projectPath: path5.resolve(projectPath) };
+  await fs3.writeFile(path5.join(outDir, "config.json"), JSON.stringify(configJson, null, 2), "utf-8");
+  const rel = path5.relative(outDir, projectPath) || ".";
+  const fromGeneratedToProject = rel.split(path5.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.writeFile(path5.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.writeFile(path5.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.writeFile(path5.join(outDir, "n8n-invoker.ts"), n8nInvokerTs, "utf-8");
+  await fs3.writeFile(path5.join(outDir, "mcp-server.ts"), mcpServerTemplate, "utf-8");
+  const mcpJson = {
+    command: "npx",
+    args: ["-y", "tsx", path5.join(outDir, "mcp-server.ts")]
+  };
+  await fs3.writeFile(path5.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.writeFile(path5.join(outDir, "package.json"), JSON.stringify(packageJson, null, 2), "utf-8");
+  return {
+    entryPath: path5.join(outDir, "mcp-server.ts"),
+    mcpJsonPath: path5.join(outDir, "mcp.json")
+  };
+}
+
+// src/codegen/build.ts
+async function buildMcpPackage(options = {}) {
+  const projectPath = path5.resolve(options.projectPath ?? process.cwd());
+  const outDir = path5.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 = [
+    path5.join(base, "mcp-server.ts"),
+    path5.join(base, "mcp-server.js"),
+    path5.join(base, "dist", "mcp-server.ts"),
+    path5.join(base, "dist", "mcp-server.js"),
+    path5.join(base, "generated", "mcp-server.ts"),
+    path5.join(base, "generated", "mcp-server.js")
+  ];
+  let entry = "";
+  for (const p of candidates) {
+    try {
+      await fs3.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 = path5.dirname(entry);
+  const child = spawn("npx", ["-y", "tsx", path5.basename(entry)], {
+    cwd: dir,
+    stdio: ["pipe", "pipe", "inherit"],
+    shell: false
+  });
+  return { process: child };
+}
+var runGeneratedMCP = runMcpServer;
+
+export { DiscoveryError, SkillManifestError, buildFunctionToTool, buildMcpPackage, initProject, loadN8nTool, loadSkillDefinition, parseSkillMd, runGeneratedMCP, runMcpServer, scanForTools, scanSkillResources, validateFrontmatter };
+//# sourceMappingURL=chunk-BM4EVYI5.js.map
+//# sourceMappingURL=chunk-BM4EVYI5.js.map