keq 2.8.13 → 2.9.0

package/packages/cli/dist/cli.cjs

@@ -1,2922 +1,1364 @@
 #!/usr/bin/env node
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-
-// src/cli.ts
-var import_semver = __toESM(require("semver"), 1);
-var import_commander = require("commander");
-
-// src/constants/supported-methods.ts
-var SupportedMethods = [
-  "get",
-  "post",
-  "put",
-  "delete",
-  "patch",
-  "head",
-  "options"
-];
-
-// src/utils/logger.ts
-var import_chalk = __toESM(require("chalk"), 1);
-var logger = {
-  log: (str) => console.log(import_chalk.default.green(str)),
-  warn: (str) => console.warn(import_chalk.default.yellow(str)),
-  error: (str) => console.error(import_chalk.default.red(str))
-};
-
-// src/compiler/compiler.ts
-var import_listr22 = require("listr2");
-var import_tapable4 = require("tapable");
-
-// src/compiler/tasks/setup/index.ts
-var import_fs_extra2 = __toESM(require("fs-extra"), 1);
-var import_path = __toESM(require("path"), 1);
-var import_value = require("@sinclair/typebox/value");
-var import_cosmiconfig = require("cosmiconfig");
-
-// src/utils/ignore-matcher.ts
-var R = __toESM(require("ramda"), 1);
-var import_fs_extra = __toESM(require("fs-extra"), 1);
-var IgnoreMatcher = class _IgnoreMatcher {
-  rules;
-  constructor(rules) {
-    this.rules = rules;
-  }
-  static async read(filepath) {
-    let content = await import_fs_extra.default.readFile(filepath, "utf-8");
-    content = content.replace(/\r\n/g, "\n").replace(/\r/g, "\n").replace(/#.*$/gm, "").replace(/\n+/g, "\n").trim();
-    let rules = content.split("\n").map((line) => line.trim()).filter((line) => line.length > 0).map((line) => {
-      const matched = line.match(/^(!)?\s*([^\s/]+)\s+([^\s/]+)\s+([^\s]+)$/);
-      if (!matched) throw new Error(`Invalid ignore rule: "${line}"`);
-      const [, flag, moduleName, operationMethod, operationPathname] = matched;
-      return {
-        persist: true,
-        ignore: !flag,
-        moduleName,
-        operationMethod: operationMethod.toLowerCase(),
-        operationPathname
-      };
-    });
-    rules = R.sortBy(
-      R.prop("ignore"),
-      rules
-    );
-    rules = R.uniqWith(
-      (a, b) => a.moduleName === b.moduleName && a.operationMethod === b.operationMethod && a.operationPathname === b.operationPathname,
-      rules
-    );
-    return new _IgnoreMatcher(rules);
-  }
-  async write(filepath) {
-    const ruleGroups = R.compose(
-      R.groupBy((rule) => rule.moduleName),
-      R.reverse,
-      R.uniqWith(
-        (a, b) => a.moduleName === b.moduleName && a.operationMethod === b.operationMethod && a.operationPathname === b.operationPathname
-      ),
-      R.filter((rule) => rule.persist)
-    )(this.rules);
-    const content = Object.entries(ruleGroups).sort((a, b) => {
-      const aModuleName = a[0];
-      const bModuleName = b[0];
-      if (aModuleName === "*") return -1;
-      if (bModuleName === "*") return 1;
-      return aModuleName.localeCompare(bModuleName);
-    }).map(([, rules]) => (rules || []).sort((a, b) => {
-      if (a.ignore !== b.ignore) return a.ignore ? -1 : 1;
-      if (a.operationMethod === "*") return -1;
-      if (b.operationMethod === "*") return 1;
-      if (a.operationPathname === "*") return -1;
-      if (b.operationPathname === "*") return 1;
-      if (a.operationMethod !== b.operationMethod) return a.operationMethod.localeCompare(b.operationMethod);
-      if (a.operationPathname !== b.operationPathname) return a.operationPathname.localeCompare(b.operationPathname);
-      return 0;
-    }).map((rule) => `${rule.ignore ? "" : "! "}${rule.moduleName} ${rule.operationMethod.toUpperCase()} ${rule.operationPathname}`).join("\n")).join("\n\n");
-    await import_fs_extra.default.writeFile(filepath, content, "utf-8");
-  }
-  append(rule) {
-    this.rules.unshift(rule);
-  }
-  // if operation is ignored, return true
-  isOperationIgnored(operationDefinition) {
-    const moduleName = operationDefinition.module.name;
-    const operationMethod = operationDefinition.method.toLowerCase();
-    const operationPathname = operationDefinition.pathname;
-    for (const rule of this.rules) {
-      if (rule.moduleName !== "*" && rule.moduleName !== moduleName) continue;
-      if (rule.operationMethod !== "*" && rule.operationMethod !== operationMethod) continue;
-      if (rule.operationPathname !== "*" && rule.operationPathname !== operationPathname) continue;
-      return rule.ignore;
-    }
-    return false;
-  }
-  isModuleIgnored(moduleDefinition) {
-    const moduleName = moduleDefinition.name;
-    for (const rule of this.rules) {
-      if (!rule.ignore) {
-        if (rule.moduleName === "*" || rule.moduleName === moduleName) return false;
-        continue;
-      }
-      if (rule.operationMethod !== "*") continue;
-      if (rule.operationPathname !== "*") continue;
-      if (rule.moduleName === "*" || rule.moduleName === moduleName) return true;
-    }
-    return false;
-  }
-};
-
-// src/types/runtime-config.ts
-var import_typebox = require("@sinclair/typebox");
-
-// src/constants/file-naming-style.ts
-var FileNamingStyle = /* @__PURE__ */ ((FileNamingStyle2) => {
-  FileNamingStyle2["camelCase"] = "camelCase";
-  FileNamingStyle2["capitalCase"] = "capitalCase";
-  FileNamingStyle2["constantCase"] = "constantCase";
-  FileNamingStyle2["dotCase"] = "dotCase";
-  FileNamingStyle2["headerCase"] = "headerCase";
-  FileNamingStyle2["noCase"] = "noCase";
-  FileNamingStyle2["paramCase"] = "paramCase";
-  FileNamingStyle2["pascalCase"] = "pascalCase";
-  FileNamingStyle2["pathCase"] = "pathCase";
-  FileNamingStyle2["sentenceCase"] = "sentenceCase";
-  FileNamingStyle2["snakeCase"] = "snakeCase";
-  return FileNamingStyle2;
-})(FileNamingStyle || {});
-
-// src/types/runtime-config.ts
-var RuntimeConfig = import_typebox.Type.Object({
-  mode: import_typebox.Type.Optional(
-    import_typebox.Type.Union([
-      import_typebox.Type.Literal("micro-function"),
-      import_typebox.Type.Literal("nestjs-module"),
-      import_typebox.Type.Literal("none")
-    ], { default: "micro-function" })
-  ),
-  /**
-   * Whether to generate ES Module code
-   *
-   * If not specified, the module system will be inferred from the nearest package.json "type" field
-   * or defaults to "cjs" if no package.json is found.
-   */
-  esm: import_typebox.Type.Optional(import_typebox.Type.Boolean({ default: false })),
-  /**
-   * Output directory for generated files
-   */
-  outdir: import_typebox.Type.String({ default: `${process.cwd()}/api` }),
-  /**
-   * File naming style for generated files
-   */
-  fileNamingStyle: import_typebox.Type.Enum(FileNamingStyle, { default: "snakeCase" /* snakeCase */ }),
-  modules: import_typebox.Type.Record(import_typebox.Type.String(), import_typebox.Type.String()),
-  debug: import_typebox.Type.Optional(import_typebox.Type.Boolean({ default: false })),
-  /**
-   * Whether to tolerate wrong openapi/swagger structure
-   */
-  tolerant: import_typebox.Type.Optional(import_typebox.Type.Boolean({ default: false })),
-  plugins: import_typebox.Type.Optional(import_typebox.Type.Array(import_typebox.Type.Any(), { default: [] }))
-});
-
-// src/compiler/tasks/setup/utils/validate-modules.ts
-var R2 = __toESM(require("ramda"), 1);
-var import_validator = __toESM(require("validator"), 1);
-function validateModules(modules) {
-  const keys2 = Object.keys(modules);
-  for (const key of keys2) {
-    if (!/^[A-Za-z_][A-Za-z0-9_$]*$/.test(key)) {
-      throw new Error(`Module name "${key}" is not valid. It must start with a letter or underscore, and can only contain letters, numbers, and underscores.`);
-    }
-  }
-  const keysGroupByLowerCase = R2.groupBy(R2.toLower, keys2);
-  for (const groupKey in keysGroupByLowerCase) {
-    const keys3 = keysGroupByLowerCase[groupKey] || [];
-    if (keys3.length > 1) {
-      throw new Error(`Module names ${keys3.map((name) => `"${name}"`).join(", ")} are case-insensitively duplicated.`);
-    }
-  }
-  for (const key in modules) {
-    const address = modules[key];
-    if (import_validator.default.isURL(address, { require_host: true, require_protocol: true, protocols: ["http", "https"] })) {
-      continue;
-    }
-    if (/^(\/|\.\/|\.\.\/)/.test(address)) {
-      continue;
-    }
-    throw new Error(`Module address "${address}" of module "${key}" is not valid. It must be a URL or a local path.`);
-  }
-}
-
-// src/compiler/tasks/setup/utils/find-nearest-package-json.ts
-var import_node_fs = __toESM(require("fs"), 1);
-var import_node_path = __toESM(require("path"), 1);
-function findNearestPackageJson(startDir = process.cwd()) {
-  let dir = startDir;
-  while (true) {
-    const pkgPath = import_node_path.default.join(dir, "package.json");
-    if (import_node_fs.default.existsSync(pkgPath)) {
-      const json = JSON.parse(import_node_fs.default.readFileSync(pkgPath, "utf8"));
-      return { json, path: pkgPath };
-    }
-    const parent = import_node_path.default.dirname(dir);
-    if (parent === dir) break;
-    dir = parent;
-  }
-  return null;
-}
-
-// src/compiler/tasks/setup/utils/get-project-module-system.ts
-function getProjectModuleSystem(pkgInfo) {
-  if (!pkgInfo?.json) return "cjs";
-  const { json } = pkgInfo;
-  if (json.type === "module") return "esm";
-  return "cjs";
-}
-
-// src/compiler/tasks/setup/index.ts
-var explore = (0, import_cosmiconfig.cosmiconfig)("keq");
-function main(compiler, options) {
-  return {
-    task: async (context, task) => {
-      const result = options?.config ? await explore.load(options.config) : await explore.search();
-      if (!result || "isEmpty" in result && result.isEmpty) {
-        throw new Error("Cannot find config file.");
-      }
-      if (!import_value.Value.Check(RuntimeConfig, result.config)) {
-        const errors = [...import_value.Value.Errors(RuntimeConfig, result.config)];
-        const message = errors.map(({ path: path13, message: message2 }) => `${path13}: ${message2}`).join("\n");
-        throw new Error(`Invalid Config: ${message}`);
-      }
-      const rc = import_value.Value.Default(RuntimeConfig, result.config);
-      validateModules(rc.modules);
-      if (options?.debug) {
-        await import_fs_extra2.default.ensureDir(".keq");
-        rc.debug = true;
-      }
-      rc.tolerant = Boolean(rc.tolerant);
-      const packageJsonInfo = findNearestPackageJson();
-      if (packageJsonInfo) {
-        const moduleSystem = getProjectModuleSystem(packageJsonInfo);
-        rc.esm = moduleSystem === "esm";
-      }
-      context.rc = rc;
-      let matcher = new IgnoreMatcher([]);
-      if (result.filepath) {
-        const ignoreFilepath = import_path.default.resolve(import_path.default.dirname(result.filepath), ".keqignore");
-        if (await import_fs_extra2.default.exists(ignoreFilepath)) {
-          matcher = await IgnoreMatcher.read(ignoreFilepath);
-        }
-      }
-      const ignoreRules = options.ignore === false ? [] : options.ignore?.rules || [];
-      for (const rule of ignoreRules) {
-        matcher.append({
-          persist: !!rule.persist,
-          ignore: rule.ignore,
-          moduleName: rule.moduleName,
-          operationMethod: rule.operationMethod,
-          operationPathname: rule.operationPathname
-        });
-      }
-      context.matcher = matcher;
-      await compiler.hooks.setup.promise(task);
-    }
-  };
+const require_logger = require("./logger-D7PyVZo3.cjs");
+const require_compiler = require("./compiler-0Kli6UCr.cjs");
+const require_plugins = require("./plugins-CgMhaNZq.cjs");
+let fs_extra = require("fs-extra");
+fs_extra = require_logger.__toESM(fs_extra, 1);
+let path = require("path");
+path = require_logger.__toESM(path, 1);
+let cosmiconfig = require("cosmiconfig");
+let ramda = require("ramda");
+ramda = require_logger.__toESM(ramda, 1);
+let picomatch = require("picomatch");
+picomatch = require_logger.__toESM(picomatch, 1);
+let js_yaml = require("js-yaml");
+js_yaml = require_logger.__toESM(js_yaml, 1);
+let semver = require("semver");
+semver = require_logger.__toESM(semver, 1);
+let commander = require("commander");
+let os = require("os");
+os = require_logger.__toESM(os, 1);
+let _modelcontextprotocol_sdk_server_mcp_js = require("@modelcontextprotocol/sdk/server/mcp.js");
+let _modelcontextprotocol_sdk_server_stdio_js = require("@modelcontextprotocol/sdk/server/stdio.js");
+let zod = require("zod");
+//#region src/utils/xprod-merge.ts
+/**
+* 对多个对象数组执行笛卡尔积合并
+* @example
+* xprodMerge([{ a: 1 }, { a: 2 }], [{b: 1}], [{ c: 1 }])
+* // => [{ a: 1, b: 1, c: 1}, { a: 2, b:1, c: 1 }]
+*/
+function xprodMerge(...lists) {
+	if (lists.length === 0) return [];
+	if (lists.length === 1) return lists[0];
+	return lists.reduce((acc, curr) => ramda.chain((item1) => ramda.map((item2) => ramda.mergeAll([item1, item2]), curr), acc));
 }
-function createSetupTask(compiler, options) {
-  return {
-    title: "Setup",
-    enabled: options?.enabled,
-    skip: options?.skip,
-    task: (context, task) => task.newListr(
-      [
-        main(compiler, options),
-        {
-          task: (context2, task2) => compiler.hooks.afterSetup.promise(task2)
-        }
-      ],
-      {
-        concurrent: false
-      }
-    )
-  };
+//#endregion
+//#region src/commands/utils/xprod-filter-rules.ts
+function xprodFilterRules(options) {
+	return xprodMerge((options.module || ["*"]).map((moduleName) => ({
+		deny: false,
+		persist: options.persist,
+		moduleName
+	})), options.method ? [{ operationMethod: options.method.toLowerCase() }] : [{ operationMethod: "*" }], options.pathname ? [{ operationPathname: options.pathname }] : [{ operationPathname: "/**" }]);
 }
-
-// src/compiler/tasks/download/index.ts
-var import_listr2 = require("listr2");
-var import_openapi_parser2 = require("@scalar/openapi-parser");
-
-// src/models/artifact.ts
-var path3 = __toESM(require("path"), 1);
-
-// src/models/anchor.ts
-var AnchorBlock = class {
-  constructor(artifact) {
-    this.artifact = artifact;
-  }
-  /**
-   * Append content to the end of the anchor block.
-   */
-  append(anchorName, content) {
-    const lines = this.artifact.content.split("\n");
-    const anchor = `@anchor:${anchorName}:end`;
-    const anchorIndex = lines.findIndex((line) => line.includes(`/* ${anchor} */`));
-    if (anchorIndex === -1) {
-      throw new Error(`"${anchor}" not found in artifact "${this.artifact.filepath}".`);
-    }
-    lines.splice(anchorIndex, 0, content);
-    this.artifact.content = lines.join("\n");
-  }
-  prepend(anchorName, content) {
-    const lines = this.artifact.content.split("\n");
-    const anchor = `@anchor:${anchorName}:start`;
-    const anchorIndex = lines.findIndex((line) => line.includes(`/* ${anchor} */`));
-    if (anchorIndex === -1) {
-      throw new Error(`"${anchor}" not found in artifact "${this.artifact.filepath}".`);
-    }
-    lines.splice(anchorIndex + 1, 0, content);
-    this.artifact.content = lines.join("\n");
-  }
-  replace(anchorName, content) {
-    const lines = this.artifact.content.split("\n");
-    const startIndex = lines.findIndex((line) => line.includes(`/* @anchor:${anchorName}:start */`));
-    const endIndex = lines.findIndex((line) => line.includes(`/* @anchor:${anchorName}:end */`));
-    if (startIndex === -1 || endIndex === -1 || endIndex <= startIndex) {
-      throw new Error(`"@anchor:${anchorName}:start" or "@anchor:${anchorName}:end" not found in artifact "${this.artifact.filepath}".`);
-    }
-    lines.splice(startIndex + 1, endIndex - startIndex - 1, content);
-    this.artifact.content = lines.join("\n");
-  }
-};
-var Anchor = class {
-  constructor(artifact) {
-    this.artifact = artifact;
-    this.block = new AnchorBlock(artifact);
-  }
-  block;
-  append(anchorName, content) {
-    const lines = this.artifact.content.split("\n");
-    const anchor = `@anchor:${anchorName}`;
-    const anchorIndex = lines.findIndex((line) => line.includes(`/* ${anchor} */`));
-    if (anchorIndex === -1) {
-      throw new Error(`"${anchor}" not found in artifact "${this.artifact.filepath}".`);
-    }
-    lines.splice(anchorIndex + 1, 0, content);
-    this.artifact.content = lines.join("\n");
-  }
-  prepend(anchorName, content) {
-    const lines = this.artifact.content.split("\n");
-    const anchor = `@anchor:${anchorName}`;
-    const anchorIndex = lines.findIndex((line) => line.includes(`/* ${anchor} */`));
-    if (anchorIndex === -1) {
-      throw new Error(`"${anchor}" not found in artifact "${this.artifact.filepath}".`);
-    }
-    lines.splice(anchorIndex, 0, content);
-    this.artifact.content = lines.join("\n");
-  }
-};
-
-// src/models/artifact.ts
-var HeaderComment = [
-  "// Code generated by keq-cli. DO NOT EDIT.",
-  "// Code generated by keq-cli. DO NOT EDIT.",
-  "// Code generated by keq-cli. DO NOT EDIT.",
-  "",
-  ""
-].join("\n");
-var Artifact = class {
-  id;
-  filepath;
-  content;
-  extensionName;
-  anchor = new Anchor(this);
-  constructor(options) {
-    this.id = options.id;
-    this.filepath = options.filepath;
-    this.extensionName = options.extensionName || path3.extname(options.filepath);
-    this.content = options.content;
-  }
-  get dirname() {
-    return path3.dirname(this.filepath);
-  }
-  renderer() {
-    return `${HeaderComment}${this.content}`;
-  }
-};
-
-// src/models/api-document_v3_1.ts
-var R5 = __toESM(require("ramda"), 1);
-
-// src/models/module-definition.ts
-var ModuleDefinition = class _ModuleDefinition {
-  name;
-  address;
-  constructor(name, address) {
-    this.name = name;
-    this.address = address;
-  }
-  static unknown() {
-    return new _ModuleDefinition("", "");
-  }
-};
-
-// src/models/operation-definition.ts
-var R4 = __toESM(require("ramda"), 1);
-
-// src/utils/is-keywords.ts
-var keywords = [
-  "break",
-  "case",
-  "catch",
-  "continue",
-  "default",
-  "delete",
-  "do",
-  "else",
-  "finally",
-  "for",
-  "function",
-  "if",
-  "in",
-  "instanceof",
-  "new",
-  "return",
-  "switch",
-  "this",
-  "throw",
-  "try",
-  "typeof",
-  "var",
-  "void",
-  "while",
-  "with"
-];
-function isKeywords(str) {
-  return keywords.includes(str);
+//#endregion
+//#region src/commands/build.ts
+function registerBuildCommand(program) {
+	program.command("build").description("Build and generate API client code from OpenAPI/Swagger specifications").option("-c --config <config>", "The keq-cli config file").option("--module <modules...>", "Filter module(s) to generate").option("--debug", "Print debug information").option("--tolerant", "Tolerate wrong swagger/openapi structure").option("--fresh", "Clean the output directory before building").option("-i --interactive", "Interactive select the scope of generation").addOption(new commander.Option("--method <method>", "Only generate files of the specified operation method").choices([...require_plugins.SupportedMethods, ...require_plugins.SupportedMethods.map((method) => method.toUpperCase())])).option("--pathname <pathname>", "Only generate files of the specified operation pathname").action(async (options) => {
+		const filterRules = [];
+		if (options.module || options.method || options.pathname) filterRules.push({
+			deny: true,
+			persist: false,
+			moduleName: "*",
+			operationMethod: "*",
+			operationPathname: "/**"
+		}, ...xprodFilterRules({
+			module: options.module,
+			method: options.method,
+			pathname: options.pathname,
+			persist: false
+		}));
+		else if (options.interactive) filterRules.push({
+			deny: true,
+			persist: false,
+			moduleName: "*",
+			operationMethod: "*",
+			operationPathname: "/**"
+		});
+		await new require_compiler.Compiler({
+			build: true,
+			persist: true,
+			fresh: !!options.fresh,
+			config: options.config,
+			debug: !!options.debug,
+			tolerant: !!options.tolerant,
+			interactive: !!options.interactive && { mode: "allow" },
+			filter: filterRules.length > 0 ? { rules: filterRules } : void 0
+		}).run();
+	});
 }
-
-// src/utils/is-reserved-word.ts
-var reservedWords = [
-  "abstract",
-  "boolean",
-  "byte",
-  "char",
-  "class",
-  "const",
-  "debugger",
-  "double",
-  "enum",
-  "export",
-  "extends",
-  "final",
-  "float",
-  "goto",
-  "implements",
-  "import",
-  "int",
-  "interface",
-  "long",
-  "native",
-  "package",
-  "private",
-  "protected",
-  "public",
-  "short",
-  "static",
-  "super",
-  "synchronized",
-  "throws",
-  "transient",
-  "volatile"
-];
-function isReservedWord(str) {
-  return reservedWords.includes(str);
+//#endregion
+//#region src/commands/filter.ts
+function registerFilterCommand(program) {
+	program.command("filter").description("Manage filter rules for API generation using .keqfilter file").addArgument(new commander.Argument("<mode>", "The filter mode").choices([
+		"all",
+		"deny",
+		"allow"
+	]).argRequired()).option("-c --config <config>", "The keq-cli config file").option("--debug", "Print debug information").option("--tolerant", "Tolerate wrong swagger/openapi structure").option("--module <modules...>").option("--build", "Build after updating .keqfilter file").addOption(new commander.Option("--method <method>", "Only generate files of the specified operation method").choices([...require_plugins.SupportedMethods, ...require_plugins.SupportedMethods.map((method) => method.toUpperCase())])).option("--pathname <pathnames>", "Only generate files of the specified operation pathname").option("-i --interactive", "Interactive select the scope of generation").action(async (mode, options) => {
+		let compiler;
+		if (mode === "all") {
+			if (options.build) throw new Error("'--build' cannot be used with 'all' mode");
+			if (options.interactive) throw new Error("'--interactive' cannot be used with 'all' mode");
+			if (options.module) throw new Error("'--module' cannot be used with 'all' mode");
+			if (options.method) throw new Error("'--method' cannot be used with 'all' mode");
+			if (options.pathname) throw new Error("'--pathname' cannot be used with 'all' mode");
+			compiler = new require_compiler.Compiler({
+				build: false,
+				persist: true,
+				config: options.config,
+				debug: !!options.debug,
+				tolerant: !!options.tolerant,
+				interactive: false,
+				filter: { rules: [{
+					persist: true,
+					deny: true,
+					moduleName: "*",
+					operationMethod: "*",
+					operationPathname: "/**"
+				}] }
+			});
+		} else if (options.interactive) {
+			if (options.interactive) {
+				if (options.method) throw new Error("'--method' cannot be used with '--interactive'");
+				if (options.pathname) throw new Error("'--pathname' cannot be used with '--interactive'");
+			}
+			compiler = new require_compiler.Compiler({
+				build: !!options.build,
+				persist: true,
+				config: options.config,
+				debug: !!options.debug,
+				tolerant: !!options.tolerant,
+				interactive: {
+					mode,
+					persist: true
+				},
+				filter: { rules: [{
+					persist: false,
+					deny: true,
+					moduleName: "*",
+					operationMethod: "*",
+					operationPathname: "/**"
+				}] }
+			});
+		} else {
+			if (!options.method && !options.pathname) throw new Error("at least one of '-i --interactive', '--method' or '--pathname' must be specified");
+			const moduleNames = options.module || ["*"];
+			compiler = new require_compiler.Compiler({
+				build: !!options.build,
+				persist: true,
+				config: options.config,
+				debug: !!options.debug,
+				tolerant: !!options.tolerant,
+				filter: { rules: moduleNames.map((moduleNames) => ({
+					persist: true,
+					deny: mode === "deny",
+					moduleName: moduleNames,
+					operationMethod: options.method,
+					operationPathname: options.pathname
+				})) },
+				interactive: false
+			});
+		}
+		await compiler.run();
+	});
 }
-
-// src/models/operation-definition.ts
-var import_jsonpath_plus2 = require("jsonpath-plus");
-
-// src/models/schema-definition.ts
-var R3 = __toESM(require("ramda"), 1);
-var import_jsonpath_plus = require("jsonpath-plus");
-var SchemaDefinition = class _SchemaDefinition {
-  name;
-  schema;
-  module;
-  document;
-  get id() {
-    return `${this.module.address}#/components/schemas/${this.name}`;
-  }
-  constructor(args) {
-    this.module = args.module;
-    this.name = args.name;
-    this.schema = args.schema;
-    this.document = args.document;
-  }
-  getDependencies() {
-    const refs = R3.uniq((0, import_jsonpath_plus.JSONPath)({
-      path: "$..*['$ref']",
-      json: this.schema
-    }));
-    return refs.filter((ref) => typeof ref === "string" && !!ref.trim()).map((ref) => {
-      const definition = this.document.dereference(ref);
-      if (definition) return definition;
-      return _SchemaDefinition.unknown();
-    });
-  }
-  static unknown() {
-    return new _SchemaDefinition({
-      name: "",
-      schema: {},
-      module: ModuleDefinition.unknown(),
-      document: ApiDocumentV3_1.unknown()
-    });
-  }
-  static isUnknown(definition) {
-    return definition.name === "";
-  }
-};
-
-// src/models/operation-definition.ts
-var OperationDefinition = class {
-  module;
-  operationId;
-  method;
-  pathname;
-  operation;
-  document;
-  get id() {
-    return `${this.module.address}#/paths/${this.pathname}/${this.method}`;
-  }
-  constructor(args) {
-    this.module = args.module;
-    this.method = args.method.toLowerCase();
-    this.pathname = args.pathname;
-    this.document = args.document;
-    this.operationId = this.formatOperationId(args.method, args.pathname, args.operation);
-    this.operation = {
-      ...args.operation,
-      operationId: this.operationId
-    };
-  }
-  formatOperationId(method, pathname, operation) {
-    const operationId = operation.operationId;
-    if (operationId && operationId !== "index" && !isKeywords(operationId) && !isReservedWord(operationId)) {
-      return operationId;
-    }
-    return `${method}_${pathname}`.replace(/\//g, "_").replace(/-/g, "_").replace(/:/g, "$$").replace(/{(.+)}/, "$$$1");
-  }
-  getDependencies() {
-    const refs = R4.uniq([
-      ...(0, import_jsonpath_plus2.JSONPath)({
-        path: "$.requestBody.content..schema..$ref",
-        json: this.operation
-      }),
-      ...(0, import_jsonpath_plus2.JSONPath)({
-        path: "$.responses..content..schema..$ref",
-        json: this.operation
-      }),
-      ...(0, import_jsonpath_plus2.JSONPath)({
-        path: "$.parameters..schema..$ref",
-        json: this.operation
-      })
-    ]);
-    const dependencies = refs.filter((ref) => typeof ref === "string" && ref).map((ref) => {
-      const schemaDefinition = this.document.dereference(ref);
-      if (schemaDefinition) return schemaDefinition;
-      return SchemaDefinition.unknown();
-    });
-    return dependencies;
-  }
-};
-
-// src/models/api-document_v3_1.ts
-var ApiDocumentV3_1 = class _ApiDocumentV3_1 {
-  module;
-  specification;
-  constructor(specification, module2) {
-    this.module = module2;
-    this.specification = specification;
-  }
-  get schemas() {
-    const module2 = this.module;
-    return Object.entries(this.specification.components?.schemas || {}).map(([name, schema]) => new SchemaDefinition({
-      name,
-      schema,
-      module: module2,
-      document: this
-    }));
-  }
-  get operations() {
-    const module2 = this.module;
-    return Object.entries(this.specification.paths || {}).flatMap(([pathname, pathItem]) => Object.entries(pathItem || {}).filter(([method]) => SupportedMethods.includes(method.toLowerCase())).map(([method, operation]) => new OperationDefinition({
-      method,
-      pathname,
-      operation,
-      module: module2,
-      document: this
-    })));
-  }
-  isEmpty() {
-    return R5.isEmpty(this.specification.paths);
-  }
-  dereference($ref) {
-    if ($ref.startsWith("#/")) {
-      return this.schemas.find((schema) => schema.id.endsWith($ref));
-    }
-    logger.warn(`The $ref(${$ref}) is not defined in ${this.module.name} openapi/swagger.`);
-  }
-  isRefDefined($ref) {
-    if ($ref.startsWith("#/")) {
-      const path13 = $ref.replace("#/", "").split("/");
-      return R5.path(path13, this.specification) !== void 0;
-    }
-    return false;
-  }
-  static unknown() {
-    return new _ApiDocumentV3_1({}, ModuleDefinition.unknown());
-  }
-};
-
-// src/models/asset.ts
-var Asset = class {
-  path;
-  constructor(path13) {
-    this.path = path13;
-  }
-};
-
-// src/exception.ts
-var import_ts_custom_error = require("ts-custom-error");
-var import_word_wrap = __toESM(require("word-wrap"), 1);
-var Exception = class extends import_ts_custom_error.CustomError {
-  constructor(module2, message) {
-    const moduleName = typeof module2 === "string" ? module2 : module2.name;
-    const msg = (0, import_word_wrap.default)(message, { width: 60, indent: "    " });
-    super(`${moduleName} module failed to compile:
-${msg}`);
-    Object.defineProperty(this, "name", { value: "KeqCLI_Exception" });
-  }
-};
-
-// src/utils/openapi-utils/dereference.ts
-function dereference($ref, swagger) {
-  let value;
-  for (const key of $ref.split("/")) {
-    if (key === "#") {
-      value = swagger;
-    } else {
-      value = value[key];
-    }
-    if (!value) break;
-  }
-  return value;
+//#endregion
+//#region src/utils/scan-generated-files.ts
+/**
+* Recursively find all files in a directory
+*/
+async function findAllFiles(dir, extensions) {
+	const results = [];
+	async function scan(currentDir) {
+		let entries;
+		try {
+			entries = await fs_extra.default.readdir(currentDir);
+		} catch (err) {
+			return;
+		}
+		for (const entry of entries) {
+			if (entry === "node_modules" || entry === ".git") continue;
+			const fullPath = path.join(currentDir, entry);
+			let stat;
+			try {
+				stat = await fs_extra.default.stat(fullPath);
+			} catch (err) {
+				continue;
+			}
+			if (stat.isDirectory()) await scan(fullPath);
+			else if (stat.isFile()) if (!extensions) results.push(fullPath);
+			else {
+				const ext = path.extname(fullPath);
+				if (extensions.includes(ext)) results.push(fullPath);
+			}
+		}
+	}
+	await scan(dir);
+	return results;
 }
-
-// src/utils/openapi-utils/dereference-operation.ts
-var R8 = __toESM(require("ramda"), 1);
-var import_jsonpointer2 = __toESM(require("jsonpointer"), 1);
-var import_jsonpath_plus4 = require("jsonpath-plus");
-
-// src/utils/openapi-utils/remove-undefined-ref.ts
-var R7 = __toESM(require("ramda"), 1);
-var import_jsonpointer = __toESM(require("jsonpointer"), 1);
-var import_jsonpath_plus3 = require("jsonpath-plus");
-
-// src/utils/openapi-utils/is-ref-defined.ts
-var R6 = __toESM(require("ramda"), 1);
-function isRefDefined($ref, swagger) {
-  if ($ref.startsWith("#/")) {
-    const path13 = $ref.replace("#/", "").split("/");
-    return R6.path(path13, swagger) !== void 0;
-  }
-  return false;
+/**
+* Scan all files in the output directory
+* @param outdir The output directory to scan
+* @returns List of all files with their paths
+*/
+async function scanAllFiles(outdir) {
+	const absoluteOutdir = path.resolve(outdir);
+	if (!await fs_extra.default.exists(absoluteOutdir)) return [];
+	return (await findAllFiles(absoluteOutdir)).map((file) => ({
+		absolutePath: file,
+		relativePath: path.relative(absoluteOutdir, file)
+	}));
 }
-
-// src/utils/openapi-utils/remove-undefined-ref.ts
-function removeUndefinedRef(swagger) {
-  const shadow = R7.clone(swagger);
-  const matches = (0, import_jsonpath_plus3.JSONPath)({
-    path: "$..*['$ref']^",
-    json: swagger,
-    resultType: "all"
-  });
-  for (const match of matches) {
-    if (match.value.$ref && !isRefDefined(match.value.$ref, swagger)) {
-      import_jsonpointer.default.set(shadow, match.pointer, R7.omit(["$ref"], match.value));
-    }
-  }
-  return shadow;
+/**
+* Find invalid files that are not in the current artifacts list
+* This includes both non-generated files and outdated generated files
+* @param outdir The output directory
+* @param validFilePaths List of valid file paths (relative to outdir)
+* @returns List of invalid files
+*/
+async function findInvalidFiles(outdir, validFilePaths) {
+	const allFiles = await scanAllFiles(outdir);
+	const validPathsSet = new Set(validFilePaths.map((p) => path.normalize(p)));
+	return allFiles.filter((file) => {
+		const normalizedPath = path.normalize(file.relativePath);
+		return !validPathsSet.has(normalizedPath);
+	});
 }
-
-// src/utils/openapi-utils/dereference-operation.ts
-function dereferencePathObject(swagger) {
-  const matches = (0, import_jsonpath_plus4.JSONPath)({
-    path: "$.paths.*.$ref^",
-    json: swagger,
-    resultType: "all"
-  });
-  for (const match of matches) {
-    const value = dereference(match.value.$ref, swagger);
-    import_jsonpointer2.default.set(swagger, match.pointer, value);
-  }
+//#endregion
+//#region src/commands/list.ts
+function registerListCommand(program) {
+	program.command("list").description("List generated files based on current configuration").option("-c --config <config>", "The keq-cli config file").option("--invalid", "List only invalid generated files (files not in current build)").option("--debug", "Print debug information").option("--tolerant", "Tolerate wrong swagger/openapi structure").action(async (options) => {
+		const compiler = new require_compiler.Compiler({
+			build: true,
+			persist: false,
+			silent: true,
+			config: options.config,
+			debug: !!options.debug,
+			tolerant: !!options.tolerant
+		});
+		await compiler.run();
+		const context = compiler.context;
+		if (!context.rc) throw new Error("Failed to load configuration");
+		if (options.invalid) {
+			const validFilePaths = (context.artifacts || []).map((artifact) => artifact.filepath);
+			const invalidFiles = await findInvalidFiles(context.rc.outdir, validFilePaths);
+			for (const file of invalidFiles) {
+				const fullPath = `./${path.join(context.rc.outdir, file.relativePath)}`;
+				console.log(fullPath);
+			}
+		} else {
+			const artifacts = context.artifacts || [];
+			for (const artifact of artifacts) {
+				const fullPath = `./${path.join(context.rc.outdir, artifact.filepath)}`;
+				console.log(fullPath);
+			}
+		}
+	});
 }
-function dereferenceRequestBody(swagger) {
-  const matches = (0, import_jsonpath_plus4.JSONPath)({
-    path: "$.paths.*.*.requestBody.$ref^",
-    json: swagger,
-    resultType: "all"
-  });
-  for (const match of matches) {
-    const value = dereference(match.value.$ref, swagger);
-    import_jsonpointer2.default.set(swagger, match.pointer, value);
-  }
+//#endregion
+//#region src/commands/apis.ts
+function registerApisCommand(program) {
+	program.command("apis").description("List API operations and components from OpenAPI/Swagger specifications").option("-c --config <config>", "The keq-cli config file").option("--tolerant", "Tolerate wrong swagger/openapi structure").addOption(new commander.Option("--includes <includes...>", "Include specific parts").choices(["operations", "components"])).option("--module <modules...>", "Filter module(s) to list").addOption(new commander.Option("--method <method>", "Only generate files of the specified operation method").choices([...require_plugins.SupportedMethods, ...require_plugins.SupportedMethods.map((method) => method.toUpperCase())])).option("--pathname <pathnames>", "Only generate files of the specified operation pathname").addOption(new commander.Option("--format <format>", "Output format").choices(["compact", "json"])).option("--json", "Output in JSON format (shortcut for --format json)").option("--all", "Ignore .keqfilter rules and show all modules/operations").option("--debug", "Print debug information").action(async (options) => {
+		if (options.all && (options.module || options.method || options.pathname)) throw new Error("'--all' cannot be used with '--module', '--method', or '--pathname'");
+		const filterRules = [];
+		if (options.module || options.method || options.pathname) filterRules.push({
+			deny: true,
+			persist: false,
+			moduleName: "*",
+			operationMethod: "*",
+			operationPathname: "/**"
+		}, ...xprodFilterRules({
+			module: options.module,
+			method: options.method,
+			pathname: options.pathname,
+			persist: false
+		}));
+		const compiler = new require_compiler.Compiler({
+			build: true,
+			persist: false,
+			silent: true,
+			config: options.config,
+			debug: !!options.debug,
+			tolerant: !!options.tolerant,
+			filter: options.all ? false : filterRules.length > 0 ? { rules: filterRules } : void 0
+		});
+		await compiler.run();
+		const documents = compiler.context.documents || [];
+		const includesList = options.includes || ["operations", "components"];
+		const includeOperations = includesList.includes("operations");
+		const includeComponents = includesList.includes("components");
+		const result = documents.map((document) => {
+			const item = { module: document.module.name };
+			if (includeOperations) item.operations = document.operations.map((operation) => ({
+				method: operation.method.toUpperCase(),
+				path: operation.pathname,
+				operationId: operation.operationId,
+				summary: operation.operation.summary || "",
+				description: operation.operation.description || ""
+			}));
+			if (includeComponents) item.components = { schemas: document.schemas.map((schema) => {
+				const schemaObj = schema.schema;
+				return {
+					name: schema.name,
+					description: schemaObj.description || ""
+				};
+			}) };
+			return item;
+		});
+		const format = options.format || (options.json ? "json" : void 0);
+		if (format === "json") console.log(JSON.stringify(result, null, 2));
+		else if (format === "compact") {
+			for (const item of result) {
+				console.log(`\nModule: ${item.module}`);
+				console.log("─".repeat(70));
+				if (includeOperations) {
+					console.log("\n  APIs:");
+					if (!item.operations || item.operations.length === 0) console.log("    (No APIs)");
+					else for (const operation of item.operations) {
+						const method = operation.method.padEnd(7);
+						const desc = operation.summary || operation.description;
+						const descText = desc ? `  ${desc}` : "";
+						console.log(`    ${method} ${operation.path}${descText}`);
+					}
+				}
+				if (includeComponents) {
+					console.log("\n  Schemas:");
+					if (!item.components || item.components.schemas.length === 0) console.log("    (No Schemas)");
+					else for (const schema of item.components.schemas) {
+						const desc = schema.description ? `  ${schema.description}` : "";
+						console.log(`    ${schema.name}${desc}`);
+					}
+				}
+			}
+			const totalApis = result.reduce((sum, item) => sum + (item.operations?.length || 0), 0);
+			const totalSchemas = result.reduce((sum, item) => sum + (item.components?.schemas.length || 0), 0);
+			console.log("\n" + "─".repeat(70));
+			const parts = [`${result.length} modules`];
+			if (includeOperations) parts.push(`${totalApis} APIs`);
+			if (includeComponents) parts.push(`${totalSchemas} Schemas`);
+			console.log(`Total: ${parts.join(", ")}`);
+		} else {
+			for (const item of result) {
+				console.log(`\nModule: ${item.module}`);
+				console.log("─".repeat(70));
+				if (includeOperations) {
+					console.log("\n  APIs:");
+					if (!item.operations || item.operations.length === 0) console.log("    (No APIs)");
+					else for (const operation of item.operations) {
+						const method = operation.method.padEnd(7);
+						console.log(`    ${method} ${operation.path}`);
+						const desc = operation.summary || operation.description;
+						if (desc) console.log(`    ${desc}`);
+					}
+				}
+				if (includeComponents) {
+					console.log("\n  Schemas:");
+					if (!item.components || item.components.schemas.length === 0) console.log("    (No Schemas)");
+					else for (const schema of item.components.schemas) {
+						console.log(`    ${schema.name}`);
+						if (schema.description) console.log(`    ${schema.description}`);
+					}
+				}
+			}
+			const totalApis = result.reduce((sum, item) => sum + (item.operations?.length || 0), 0);
+			const totalSchemas = result.reduce((sum, item) => sum + (item.components?.schemas.length || 0), 0);
+			console.log("\n" + "─".repeat(70));
+			const parts = [`${result.length} modules`];
+			if (includeOperations) parts.push(`${totalApis} APIs`);
+			if (includeComponents) parts.push(`${totalSchemas} Schemas`);
+			console.log(`Total: ${parts.join(", ")}`);
+		}
+	});
 }
-function dereferenceResponses(swagger) {
-  const matches = [
-    ...(0, import_jsonpath_plus4.JSONPath)({
-      path: "$.paths.*.*.responses.*.$ref^",
-      json: swagger,
-      resultType: "all"
-    }),
-    ...(0, import_jsonpath_plus4.JSONPath)({
-      path: "$.paths.*.*.responses.*.headers.*.$ref^",
-      json: swagger,
-      resultType: "all"
-    })
-  ];
-  for (const match of matches) {
-    const value = dereference(match.value.$ref, swagger);
-    import_jsonpointer2.default.set(swagger, match.pointer, value);
-  }
+//#endregion
+//#region src/commands/mock.ts
+function registerMockCommand(program) {
+	program.command("mock").description("Start a mock server based on OpenAPI specifications").option("-c --config <config>", "The keq-cli config file").option("-p --port <port>", "Port to listen on", "3939").option("--host <host>", "Host to bind to", "localhost").option("--module <modules...>", "Filter module(s) to mock").option("--cors", "Enable CORS headers", true).option("--delay <delay>", "Response delay in ms (or min-max range like \"100-500\")").option("--max-depth <depth>", "Max schema depth for mock data generation", "10").option("--ref-depth <depth>", "Max $ref recursion depth for circular schemas", "5").option("--debug", "Print debug information").option("--tolerant", "Tolerate wrong swagger/openapi structure").action(async (options) => {
+		const { mockCommand } = await Promise.resolve().then(() => require("./mock-command-WZcfy5Iq.cjs"));
+		await mockCommand(options);
+	});
 }
-function dereferenceParameters(swagger) {
-  const matches = (0, import_jsonpath_plus4.JSONPath)({
-    path: "$.paths.*.*.parameters.*.$ref^",
-    json: swagger,
-    resultType: "all"
-  });
-  for (const match of matches) {
-    const value = dereference(match.value.$ref, swagger);
-    import_jsonpointer2.default.set(swagger, match.pointer, value);
-  }
+//#endregion
+//#region src/commands/init.ts
+function registerInitCommand(program) {
+	program.command("init").description("Initialize keq configuration file").option("-f --force", "Force overwrite existing config file").action(async (options) => {
+		const { initConfig } = await Promise.resolve().then(() => require("./init-DqxLcRSQ.cjs"));
+		await initConfig(options);
+	});
 }
-function dereferenceOperation(swagger) {
-  const shadow = R8.clone(swagger);
-  dereferencePathObject(shadow);
-  dereferenceRequestBody(shadow);
-  dereferenceResponses(shadow);
-  dereferenceParameters(shadow);
-  return removeUndefinedRef(shadow);
+//#endregion
+//#region src/search/embedder.ts
+const MODEL_NAME = "intfloat/multilingual-e5-small";
+const CACHE_DIR = path.default.join(os.default.homedir(), ".cache", "keq", "models");
+let transformers = null;
+let loadError = null;
+let extractor = null;
+var EmbedderUnavailableError = class extends Error {
+	constructor(cause) {
+		super("@huggingface/transformers is not installed. Semantic search is unavailable.\nRun `pnpm add @huggingface/transformers` to enable this feature.");
+		this.name = "EmbedderUnavailableError";
+		if (cause) this.cause = cause;
+	}
+};
+async function loadTransformers() {
+	if (transformers) return transformers;
+	if (loadError) throw new EmbedderUnavailableError(loadError);
+	try {
+		transformers = await import("@huggingface/transformers");
+		return transformers;
+	} catch (e) {
+		loadError = e instanceof Error ? e : new Error(String(e));
+		throw new EmbedderUnavailableError(loadError);
+	}
 }
-
-// src/utils/json-schema-utils/is-array.ts
-function isArray(schema) {
-  return schema.type === "array";
+async function getEmbedder() {
+	if (extractor) return extractor;
+	const { pipeline, env } = await loadTransformers();
+	env.cacheDir = CACHE_DIR;
+	env.allowLocalModels = true;
+	extractor = await pipeline("feature-extraction", MODEL_NAME, { dtype: "fp32" });
+	return extractor;
 }
-
-// src/utils/json-schema-utils/is-mixed.ts
-function isMixed(schema) {
-  return Array.isArray(schema.type);
+async function embed(texts) {
+	return (await (await getEmbedder())(texts.map((t) => `query: ${t}`), {
+		pooling: "mean",
+		normalize: true
+	})).tolist().map((vec) => new Float32Array(vec));
 }
-
-// src/utils/json-schema-utils/is-non-array.ts
-function isNonArray(schema) {
-  return typeof schema.type === "string" && schema.type !== "array";
+async function embedDocuments(texts) {
+	return (await (await getEmbedder())(texts.map((t) => `passage: ${t}`), {
+		pooling: "mean",
+		normalize: true
+	})).tolist().map((vec) => new Float32Array(vec));
 }
-
-// src/utils/json-schema-utils/is-ref.ts
-function isRef(schema) {
-  return "$ref" in schema;
+function cosineSimilarity(a, b) {
+	let dot = 0;
+	for (let i = 0; i < a.length; i++) dot += a[i] * b[i];
+	return dot;
 }
-
-// src/utils/json-schema-utils/index.ts
-var JsonSchemaUtils = class {
-  static isRef = isRef;
-  static isArray = isArray;
-  static isNonArray = isNonArray;
-  static isMixed = isMixed;
+//#endregion
+//#region src/search/search-engine.ts
+var SearchEngine = class {
+	operations = [];
+	async buildIndex(documents) {
+		this.operations = [];
+		for (const document of documents) for (const op of document.operations) {
+			const tags = op.operation.tags || [];
+			const summary = op.operation.summary || "";
+			const description = op.operation.description || "";
+			const text = [
+				op.method.toUpperCase(),
+				op.pathname,
+				op.operationId,
+				summary,
+				description,
+				...tags
+			].filter(Boolean).join(" ");
+			this.operations.push({
+				id: `${document.module.name}:${op.method}:${op.pathname}`,
+				module: document.module.name,
+				method: op.method.toUpperCase(),
+				pathname: op.pathname,
+				operationId: op.operationId,
+				summary,
+				description,
+				tags,
+				text,
+				operation: op.operation
+			});
+		}
+		const embeddings = await embedDocuments(this.operations.map((op) => op.text));
+		for (let i = 0; i < this.operations.length; i++) this.operations[i].embedding = embeddings[i];
+	}
+	async search(query, options) {
+		const limit = options?.limit ?? 10;
+		const modules = options?.module;
+		let candidates = this.operations;
+		if (modules && modules.length > 0) candidates = candidates.filter((op) => modules.includes(op.module));
+		if (candidates.length === 0) return [];
+		const [queryEmbedding] = await embed([query]);
+		return candidates.filter((op) => op.embedding).map((op) => ({
+			op,
+			score: cosineSimilarity(queryEmbedding, op.embedding)
+		})).sort((a, b) => b.score - a.score).slice(0, limit).map(({ op, score }) => ({
+			score: Math.round(score * 1e3) / 1e3,
+			module: op.module,
+			method: op.method,
+			pathname: op.pathname,
+			operationId: op.operationId,
+			summary: op.summary,
+			description: op.description,
+			tags: op.tags
+		}));
+	}
+	getDetail(module, method, pathname) {
+		const op = this.operations.find((o) => o.module === module && o.method === method.toUpperCase() && o.pathname === pathname);
+		if (!op) return void 0;
+		const operation = op.operation;
+		return {
+			score: 1,
+			module: op.module,
+			method: op.method,
+			pathname: op.pathname,
+			operationId: op.operationId,
+			summary: op.summary,
+			description: op.description,
+			tags: op.tags,
+			parameters: operation.parameters || [],
+			requestBody: operation.requestBody || null,
+			responses: operation.responses || null
+		};
+	}
+	listModules() {
+		return [...new Set(this.operations.map((op) => op.module))];
+	}
 };
-
-// src/utils/openapi-utils/dereference-deep.ts
-function dereferenceDeep($ref, swagger) {
-  const stack = [$ref];
-  let value;
-  while (true) {
-    const last2 = stack[stack.length - 1];
-    value = dereference(last2, swagger);
-    if (JsonSchemaUtils.isRef(value)) {
-      if (!stack.includes(value.$ref)) {
-        stack.push(value.$ref);
-        continue;
-      } else {
-        throw new Error(`Circular reference detected: ${stack.join(" -> ")} -> ${value.$ref}`);
-      }
-    }
-    break;
-  }
-  return value;
-}
-
-// src/utils/openapi-utils/to-3_1.ts
-var import_openapi_parser = require("@scalar/openapi-parser");
-function To3_1(openapi) {
-  const { specification } = (0, import_openapi_parser.upgrade)(openapi);
-  return specification;
+//#endregion
+//#region src/commands/search.ts
+function registerSearchCommand(program) {
+	program.command("search").description("Semantic search for API operations using natural language").argument("<query>", "Natural language search query").option("-c --config <config>", "The keq-cli config file").option("--module <modules...>", "Filter module(s) to search").option("--limit <limit>", "Maximum number of results", "10").option("--detail", "Include full request/response schema in results").addOption(new commander.Option("--format <format>", "Output format").choices(["json", "compact"]).default("json")).option("--all", "Ignore .keqfilter rules").option("--tolerant", "Tolerate wrong swagger/openapi structure").option("--debug", "Print debug information").action(async (query, options) => {
+		const filterRules = [];
+		if (options.module && !options.all) filterRules.push({
+			deny: true,
+			persist: false,
+			moduleName: "*",
+			operationMethod: "*",
+			operationPathname: "/**"
+		}, ...xprodFilterRules({
+			module: options.module,
+			persist: false
+		}));
+		const compiler = new require_compiler.Compiler({
+			build: true,
+			persist: false,
+			silent: true,
+			config: options.config,
+			debug: !!options.debug,
+			tolerant: !!options.tolerant,
+			filter: options.all ? false : filterRules.length > 0 ? { rules: filterRules } : void 0
+		});
+		await compiler.run();
+		const documents = compiler.context.documents || [];
+		const engine = new SearchEngine();
+		try {
+			await engine.buildIndex(documents);
+		} catch (e) {
+			if (e instanceof EmbedderUnavailableError) {
+				console.error(e.message);
+				process.exit(1);
+			}
+			throw e;
+		}
+		const limit = parseInt(options.limit, 10);
+		const results = await engine.search(query, {
+			limit,
+			module: options.module
+		});
+		if (options.detail) printResults(results.map((r) => {
+			return engine.getDetail(r.module, r.method, r.pathname) || r;
+		}), options.format);
+		else printResults(results, options.format);
+	});
 }
-
-// src/utils/openapi-utils/map-operation.ts
-var R9 = __toESM(require("ramda"), 1);
-function mapOperation(specification, mapper) {
-  const shadow = R9.clone(specification);
-  for (const [pathname, pathItem] of Object.entries(shadow.paths || {})) {
-    for (const m in pathItem) {
-      const method = m.toLowerCase();
-      if (!SupportedMethods.includes(method)) continue;
-      if (typeof pathItem[m] !== "object" || Array.isArray(pathItem[m]) || pathItem[m] === null) continue;
-      const operation = pathItem[m];
-      pathItem[m] = mapper(method, pathname, operation);
-    }
-  }
-  return shadow;
+function printResults(results, format) {
+	if (format === "json") console.log(JSON.stringify({
+		results,
+		total: results.length
+	}, null, 2));
+	else {
+		for (const r of results) {
+			const method = String(r.method).padEnd(7);
+			const score = String(r.score);
+			console.log(`  [${score}] ${method} ${String(r.pathname)}`);
+			if (typeof r.summary === "string") console.log(`         ${r.summary}`);
+			console.log(`         ${String(r.module)} | ${String(r.operationId)}`);
+			console.log();
+		}
+		console.log(`Total: ${results.length} results`);
+	}
 }
-
-// src/utils/openapi-utils/map-parameter.ts
-function mapParameter(specification, mapper) {
-  return mapOperation(specification, (method, pathname, operation) => {
-    if (!operation.parameters) return operation;
-    operation.parameters = operation.parameters.map((parameter) => mapper(method, pathname, operation, parameter));
-    return operation;
-  });
-}
-
-// src/utils/openapi-utils/index.ts
-var OpenapiUtils = class {
-  static isRefDefined = isRefDefined;
-  static dereference = dereference;
-  static dereferenceDeep = dereferenceDeep;
-  static removeUndefinedRef = removeUndefinedRef;
-  static dereferenceOperation = dereferenceOperation;
-  static mapOperation = mapOperation;
-  static mapParameter = mapParameter;
-  // static updateOperationId = updateOperationId
-  static to3_1 = To3_1;
+//#endregion
+//#region src/mcp/compiler-provider.ts
+/**
+* Manages the Compiler lifecycle with automatic lazy reload.
+* Tracks .keqrc and .keqfilter for changes; getters transparently
+* re-compile when config files are modified, with built-in concurrency protection.
+*/
+var CompilerProvider = class CompilerProvider {
+	tracker = new require_plugins.FileTracker();
+	_engine = new SearchEngine();
+	_engineAvailable = false;
+	_documents = [];
+	_context = {};
+	_matcher = new require_compiler.Matcher([]);
+	_keqfilterPath = "";
+	_configPath = "";
+	_loaded = false;
+	_loadPromise = null;
+	options;
+	constructor(options) {
+		this.options = options;
+	}
+	get configPath() {
+		return this._configPath;
+	}
+	static async init(options) {
+		const provider = new CompilerProvider(options);
+		const explore = (0, cosmiconfig.cosmiconfig)("keq");
+		const result = options.config ? await explore.load(options.config) : await explore.search();
+		if (!result) throw new Error("Cannot find config file.");
+		const configFilepath = result.filepath;
+		const keqfilterPath = path.default.resolve(path.default.dirname(configFilepath), ".keqfilter");
+		provider._keqfilterPath = keqfilterPath;
+		provider._configPath = configFilepath;
+		await provider.tracker.track(configFilepath);
+		await provider.tracker.track(keqfilterPath);
+		return provider;
+	}
+	async getDocuments() {
+		await this.ensureLoaded();
+		return this._documents;
+	}
+	async getEngine() {
+		await this.ensureLoaded();
+		if (!this._engineAvailable) throw new EmbedderUnavailableError();
+		return this._engine;
+	}
+	async getContext() {
+		await this.ensureLoaded();
+		return this._context;
+	}
+	async getMatcher() {
+		await this.ensureLoaded();
+		return this._matcher;
+	}
+	async invalidate() {
+		await this.tracker.forceReload(() => this.reload());
+	}
+	async ensureLoaded() {
+		if (this._loaded) {
+			await this.tracker.ensureFresh(() => this.reload());
+			return;
+		}
+		if (this._loadPromise) {
+			await this._loadPromise;
+			return;
+		}
+		this._loadPromise = this.reload().finally(() => {
+			this._loadPromise = null;
+		});
+		await this._loadPromise;
+	}
+	async reload() {
+		const { config, debug, tolerant } = this.options;
+		const compiler = new require_compiler.Compiler({
+			build: true,
+			persist: false,
+			silent: true,
+			config,
+			debug,
+			tolerant,
+			filter: false
+		});
+		await compiler.run();
+		this._context = compiler.context;
+		this._documents = compiler.context.documents || [];
+		try {
+			await this._engine.buildIndex(this._documents);
+			this._engineAvailable = true;
+		} catch (e) {
+			if (e instanceof EmbedderUnavailableError) this._engineAvailable = false;
+			else throw e;
+		}
+		if (await fs_extra.default.exists(this._keqfilterPath)) this._matcher = await require_compiler.Matcher.read(this._keqfilterPath);
+		else this._matcher = new require_compiler.Matcher([]);
+		await this.tracker.snapshot();
+		this._loaded = true;
+	}
 };
-
-// src/compiler/tasks/download/index.ts
-function main2(compiler, options) {
-  return {
-    task: (context, task) => {
-      if (!context.rc || !context.matcher) {
-        throw new Error("Please run setup task first.");
-      }
-      const rc = context.rc;
-      const matcher = context.matcher;
-      context.documents = [];
-      return task.newListr(
-        Object.entries(rc.modules).map(([moduleName, address]) => new ModuleDefinition(moduleName, address)).map((moduleDefinition) => ({
-          title: moduleDefinition.name,
-          task: async (ctx, task2) => {
-            if (options?.skipIgnoredModules && matcher.isModuleIgnored(moduleDefinition)) {
-              task2.skip(`(${moduleDefinition.name}) is ignored`);
-              return;
-            }
-            task2.output = `Downloaded from ${moduleDefinition.address}`;
-            const content = await compiler.hooks.download.promise(moduleDefinition.address, moduleDefinition, task2);
-            if (!content) {
-              throw new Exception(moduleDefinition, `Cannot download document from ${moduleDefinition.address}`);
-            }
-            const spec = JSON.parse(content);
-            const { valid, errors } = await (0, import_openapi_parser2.validate)(spec);
-            if (!valid) {
-              const message = `${moduleDefinition.name} module openapi/swagger file does not conform to the openapi specifications or have grammatical errors, which may cause unexpected errors: 
-${errors?.map((e) => `  - ${e.message}`).join("\n")}`;
-              task2.output = message;
-            }
-            OpenapiUtils.dereferenceOperation(spec);
-            const document = new ApiDocumentV3_1(
-              spec,
-              moduleDefinition
-            );
-            ctx.documents?.push(document);
-          }
-        })),
-        {
-          concurrent: true,
-          exitOnError: false,
-          collectErrors: "minimal",
-          rendererOptions: {
-            collapseSubtasks: false,
-            // collapseSkips: false,
-            suffixSkips: true,
-            timer: import_listr2.PRESET_TIMER
-          }
-        }
-      );
-    }
-  };
-}
-function createDownloadTask(compiler, options) {
-  return {
-    title: "Download",
-    enabled: options?.enabled,
-    skip: options?.skip,
-    task: (_, task) => task.newListr(
-      [
-        main2(compiler, options),
-        {
-          task: (context, task2) => compiler.hooks.afterDownload.promise(task2)
-        }
-      ],
-      {
-        concurrent: false
-      }
-    )
-  };
-}
-
-// src/compiler/tasks/persist/index.ts
-var path6 = __toESM(require("path"), 1);
-var import_fs_extra3 = __toESM(require("fs-extra"), 1);
-function createPersistArtifactTask() {
-  return {
-    title: "Write files",
-    task: async (context, task) => {
-      if (!context.rc) throw new Error("Please run setup task first.");
-      if (!context.artifacts || context.artifacts.length === 0) {
-        task.skip("No compiled artifacts to persist.");
-        return;
-      }
-      const rc = context.rc;
-      const artifacts = context.artifacts;
-      const total = artifacts.length;
-      let completed = 0;
-      const files = await Promise.all(artifacts.map(async (artifact) => {
-        const realpath = `./${path6.join(rc.outdir, artifact.filepath)}`;
-        await import_fs_extra3.default.ensureFile(realpath);
-        await import_fs_extra3.default.writeFile(realpath, artifact.renderer());
-        completed += 1;
-        task.output = `Persisted ${completed}/${total} files`;
-        return new Asset(path6.resolve(realpath));
-      }));
-      context.assets = files;
-    }
-  };
-}
-function createPersistIgnoreTask() {
-  return {
-    title: "Update .keqignore",
-    task: async (context, task) => {
-      if (!context.matcher) throw new Error("Please run setup task first.");
-      const matcher = context.matcher;
-      await matcher.write(".keqignore");
-    }
-  };
-}
-function main3() {
-  return {
-    task: (context, task) => task.newListr(
-      [
-        createPersistArtifactTask(),
-        createPersistIgnoreTask()
-      ],
-      {
-        concurrent: true,
-        rendererOptions: {
-          collapseSubtasks: true
-        }
-      }
-    )
-  };
-}
-function createPersistTask(compiler, options) {
-  return {
-    title: "Persist",
-    enabled: options?.enabled,
-    skip: options?.skip,
-    task: (context, task) => task.newListr(
-      [
-        main3(),
-        {
-          task: (context2, task2) => compiler.hooks.afterPersist.promise(task2)
-        }
-      ],
-      {
-        concurrent: false
-      }
-    )
-  };
-}
-
-// src/compiler/tasks/compile/index.ts
-function main4(compiler) {
-  return {
-    task: async (context, task) => {
-      if (!context.rc) throw new Error("Please run setup task first.");
-      if (!context.documents) throw new Error("Please run shaking task first.");
-      context.artifacts = [];
-      await compiler.hooks.compile.promise(task);
-    }
-  };
+//#endregion
+//#region src/mcp/find-config-in-dir.ts
+const CONFIG_FILENAMES = [
+	".keqrc",
+	".keqrc.ts",
+	".keqrc.js",
+	".keqrc.mjs",
+	".keqrc.cjs",
+	".keqrc.json",
+	".keqrc.yml",
+	".keqrc.yaml",
+	"keq.config.ts",
+	"keq.config.js",
+	"keq.config.mjs",
+	"keq.config.cjs",
+	"keq.config.json",
+	"keq.config.yml",
+	"keq.config.yaml"
+];
+async function findConfigInDir(dir) {
+	for (const filename of CONFIG_FILENAMES) {
+		const filePath = path.default.resolve(dir, filename);
+		if (await fs_extra.default.pathExists(filePath)) return filePath;
+	}
+	return null;
 }
-function createCompileTask(compiler, options) {
-  return {
-    title: "Compile",
-    enabled: options?.enabled,
-    skip: options?.skip,
-    task: (context, task) => task.newListr(
-      [
-        {
-          task: (context2, task2) => compiler.hooks.beforeCompile.promise(task2)
-        },
-        main4(compiler),
-        {
-          task: (context2, task2) => compiler.hooks.afterCompile.promise(task2)
-        }
-      ],
-      {
-        concurrent: false
-      }
-    )
-  };
+//#endregion
+//#region src/mcp/compiler-provider-registry.ts
+/**
+* Manages multiple CompilerProvider instances for monorepo/multi-project support.
+* Lazily initializes providers on first access and dynamically registers new projects
+* when an unknown project directory is requested.
+*/
+var CompilerProviderRegistry = class {
+	entries = /* @__PURE__ */ new Map();
+	providers = /* @__PURE__ */ new Map();
+	options;
+	constructor(options) {
+		this.options = options;
+	}
+	register(entry) {
+		this.entries.set(entry.projectDir, entry);
+	}
+	has(projectDir) {
+		return this.entries.has(projectDir);
+	}
+	list() {
+		return [...this.entries.values()];
+	}
+	async resolve(projectDir) {
+		const entry = await this.resolveEntry(projectDir);
+		const cached = this.providers.get(entry.projectDir);
+		if (cached) return cached;
+		const provider = await CompilerProvider.init({
+			config: entry.configPath,
+			debug: this.options.debug,
+			tolerant: this.options.tolerant
+		});
+		this.providers.set(entry.projectDir, provider);
+		return provider;
+	}
+	getConfigPath(projectDir) {
+		return this.resolveEntrySync(projectDir).configPath;
+	}
+	async resolveEntry(projectDir) {
+		if (!projectDir) return this.resolveDefault();
+		if (!path.default.isAbsolute(projectDir)) throw new Error(`The 'project' parameter must be an absolute path. Received: ${projectDir}`);
+		const existing = this.entries.get(projectDir);
+		if (existing) return existing;
+		const configPath = await findConfigInDir(projectDir);
+		if (!configPath) throw new Error(`No keqrc config file found in ${projectDir}`);
+		const entry = {
+			configPath,
+			projectDir
+		};
+		this.register(entry);
+		return entry;
+	}
+	resolveEntrySync(projectDir) {
+		if (!projectDir) return this.resolveDefault();
+		if (!path.default.isAbsolute(projectDir)) throw new Error(`The 'project' parameter must be an absolute path. Received: ${projectDir}`);
+		const existing = this.entries.get(projectDir);
+		if (!existing) throw new Error(`No keqrc config file found in ${projectDir}`);
+		return existing;
+	}
+	resolveDefault() {
+		if (this.entries.size === 0) throw new Error("No keq project found. Please specify 'project' parameter with the absolute path to your project directory containing a keqrc config file.");
+		if (this.entries.size === 1) return this.entries.values().next().value;
+		const projects = [...this.entries.values()].map((e) => `- ${e.projectDir} (${path.default.basename(e.configPath)})`).join("\n");
+		throw new Error(`This is a monorepo with multiple keq projects. Please specify 'project' parameter with one of the following project directories:\n${projects}`);
+	}
+};
+//#endregion
+//#region src/mcp/discover-projects.ts
+async function discoverProjects(config) {
+	if (config) {
+		const configPath = path.default.resolve(config);
+		return [{
+			configPath,
+			projectDir: path.default.dirname(configPath)
+		}];
+	}
+	const monorepoEntries = await discoverFromMonorepo(process.cwd());
+	if (monorepoEntries.length > 0) return monorepoEntries;
+	const result = await (0, cosmiconfig.cosmiconfig)("keq").search();
+	if (result) return [{
+		configPath: result.filepath,
+		projectDir: path.default.dirname(result.filepath)
+	}];
+	return [];
 }
-
-// src/compiler/intercepter/print-information.ts
-function proxyTaskWrapper(pluginName, task) {
-  return new Proxy(task, {
-    set(target, prop2, value) {
-      if (prop2 !== "output") {
-        return Reflect.set(target, prop2, value);
-      }
-      target.output = `[Plugin: ${pluginName}] ${value}`;
-      return true;
-    }
-  });
+async function discoverFromMonorepo(root) {
+	const workspaceGlobs = await getWorkspaceGlobs(root);
+	if (workspaceGlobs.length === 0) return [];
+	const dirs = [root, ...await expandWorkspaceGlobs(root, workspaceGlobs)];
+	const entries = [];
+	for (const dir of dirs) {
+		const configPath = await findConfigInDir(dir);
+		if (configPath) entries.push({
+			configPath,
+			projectDir: dir
+		});
+	}
+	return entries;
 }
-function printInformation(taskIndex) {
-  return {
-    register: (tap) => {
-      const fn = tap.fn;
-      if (tap.type === "promise") {
-        tap.fn = (...args) => {
-          const task = args[taskIndex];
-          const proxyTask = proxyTaskWrapper(tap.name, task);
-          args[taskIndex] = proxyTask;
-          proxyTask.output = "Processing...";
-          return fn(...args);
-        };
-      }
-      if (tap.type === "sync") {
-        tap.fn = (...args) => {
-          const task = args[taskIndex];
-          const proxyTask = proxyTaskWrapper(tap.name, task);
-          args[taskIndex] = proxyTask;
-          proxyTask.output = "Processing...";
-          return fn(...args);
-        };
-      }
-      if (tap.type === "async") {
-        tap.fn = (...args) => {
-          const task = args[taskIndex];
-          const proxyTask = proxyTaskWrapper(tap.name, task);
-          args[taskIndex] = proxyTask;
-          proxyTask.output = "Processing...";
-          return fn(...args);
-        };
-      }
-      return tap;
-    }
-  };
+async function getWorkspaceGlobs(root) {
+	const pnpmWorkspacePath = path.default.join(root, "pnpm-workspace.yaml");
+	if (await fs_extra.default.pathExists(pnpmWorkspacePath)) {
+		const content = await fs_extra.default.readFile(pnpmWorkspacePath, "utf-8");
+		const parsed = js_yaml.load(content);
+		if (parsed?.packages) return parsed.packages;
+	}
+	const packageJsonPath = path.default.join(root, "package.json");
+	if (await fs_extra.default.pathExists(packageJsonPath)) {
+		const pkg = await fs_extra.default.readJson(packageJsonPath);
+		if (Array.isArray(pkg.workspaces)) return pkg.workspaces;
+		if (Array.isArray(pkg.workspaces?.packages)) return pkg.workspaces.packages;
+	}
+	return [];
 }
-
-// src/compiler/intercepter/perfect-error-message.ts
-var R10 = __toESM(require("ramda"), 1);
-function perfectErrorMessage() {
-  return {
-    register: (tap) => {
-      const fn = tap.fn;
-      function prefix(err) {
-        if (err instanceof Error) {
-          err.message = `[Plugin: ${tap.name}] ${err.message}`;
-        }
-      }
-      if (tap.type === "promise") {
-        tap.fn = async (...args) => {
-          try {
-            return await fn(...args);
-          } catch (err) {
-            prefix(err);
-            throw err;
-          }
-        };
-      }
-      if (tap.type === "sync") {
-        tap.fn = (...args) => {
-          try {
-            return fn(...args);
-          } catch (err) {
-            prefix(err);
-            throw err;
-          }
-        };
-      }
-      if (tap.type === "async") {
-        tap.fn = (...args) => {
-          const callback = R10.last(args);
-          return fn(...R10.init(args), (err, result) => {
-            prefix(err);
-            return callback(err, result);
-          });
-        };
-      }
-      return tap;
-    }
-  };
+async function expandWorkspaceGlobs(root, globs) {
+	const dirs = [];
+	for (const glob of globs) {
+		const parts = glob.split("/");
+		const baseParts = [];
+		let globPart = "";
+		for (let i = 0; i < parts.length; i++) {
+			if (parts[i].includes("*") || parts[i].includes("{") || parts[i].includes("?")) {
+				globPart = parts.slice(i).join("/");
+				break;
+			}
+			baseParts.push(parts[i]);
+		}
+		const baseDir = path.default.join(root, ...baseParts);
+		if (!await fs_extra.default.pathExists(baseDir)) continue;
+		if (!globPart) {
+			const fullPath = path.default.resolve(root, glob);
+			if (await fs_extra.default.pathExists(fullPath)) dirs.push(fullPath);
+			continue;
+		}
+		const matcher = (0, picomatch.default)(globPart);
+		const candidates = await fs_extra.default.readdir(baseDir, { withFileTypes: true });
+		for (const entry of candidates) {
+			if (!entry.isDirectory()) continue;
+			if (matcher(entry.name)) dirs.push(path.default.join(baseDir, entry.name));
+		}
+	}
+	return dirs;
 }
-
-// src/plugins/eslint/index.ts
-var import_eslint = require("eslint");
-
-// src/plugins/prettier/prettier.plugin.ts
-var import_child_process = require("child_process");
-var import_util = require("util");
-var execAsync = (0, import_util.promisify)(import_child_process.exec);
-
-// src/plugins/body-fallback/index.ts
-var R22 = __toESM(require("ramda"), 1);
-
-// src/plugins/generate-micro-function/generate-micro-function.plugin.ts
-var import_tapable2 = require("tapable");
-
-// src/plugins/generate-micro-function/constants/metadata-storage.ts
-var MetadataStorage = /* @__PURE__ */ new WeakMap();
-
-// src/plugins/generate-micro-function/generators/micro_function/micro-function.generator.ts
-var R21 = __toESM(require("ramda"), 1);
-var path10 = __toESM(require("path"), 1);
-var changeCase6 = __toESM(require("change-case"), 1);
-
-// src/plugins/generate-declaration/generate-declaration.plugin.ts
-var import_tapable = require("tapable");
-
-// src/plugins/generate-declaration/generators/operation-declaration/operation.generator.ts
-var path9 = __toESM(require("path"), 1);
-var changeCase5 = __toESM(require("change-case"), 1);
-
-// src/transformers/json-schema/comment.renderer.ts
-var CommentRenderer = class {
-  constructor(schema) {
-    this.schema = schema;
-  }
-  render() {
-    const schema = this.schema;
-    const lines = ["/**"];
-    if (schema.description) {
-      const description = schema.description.replace("*/", "*\\/");
-      lines.push(...description.split("\n").map((line) => ` * ${line}`));
-    }
-    if (schema.deprecated) {
-      lines.push(" * @deprecated");
-    }
-    if (schema.readOnly) {
-      lines.push(" * @readonly");
-    }
-    if (schema.format) {
-      lines.push(` * @format ${schema.format}`);
-    }
-    lines.push(" */");
-    if (lines.length === 2) return "";
-    return lines.join("\n");
-  }
-};
-
-// src/transformers/json-schema/declaration.renderer.ts
-var R12 = __toESM(require("ramda"), 1);
-
-// src/utils/indent.ts
-function indent(space, text) {
-  if (text === "") return "";
-  const indentation = " ".repeat(space);
-  return text.split("\n").map((line) => line ? `${indentation}${line}` : line).join("\n");
+//#endregion
+//#region src/commands/mcp.ts
+function getFilterAnnotation(matcher, op) {
+	if (op && matcher.isOperationDenied(op)) return "This API is excluded from the code generation list by .keqfilter rules";
+	return "This API is included in the code generation list";
 }
-
-// src/transformers/json-schema/reference.transformer.ts
-var R11 = __toESM(require("ramda"), 1);
-var ReferenceTransformer = class {
-  static toDeclaration(schema, alias2 = R11.identity) {
-    if (!schema.$ref || !schema.$ref.startsWith("#")) return `unknown /* ${schema.$ref.replace("*/", "*\\/")} */`;
-    const parts = schema.$ref.split("/");
-    return alias2(parts[parts.length - 1]) || "unknown";
-  }
-};
-
-// src/transformers/json-schema/declaration.renderer.ts
-var DeclarationRenderer = class {
-  constructor(schema, options = {}) {
-    this.schema = schema;
-    this.options = options;
-  }
-  render() {
-    return this.renderSchema(this.schema);
-  }
-  renderSchema(schema) {
-    if (typeof schema === "boolean") return "unknown";
-    if (JsonSchemaUtils.isRef(schema)) return this.renderReference(schema);
-    if (JsonSchemaUtils.isMixed(schema)) return this.renderMixed(schema);
-    if (JsonSchemaUtils.isArray(schema)) return this.renderArray(schema);
-    if (schema.type === "object") return this.renderObject(schema);
-    if (schema.enum) return this.renderEnum(schema);
-    if (schema.oneOf) return this.renderOneOf(schema);
-    if (schema.anyOf) return this.renderAnyOf(schema);
-    if (schema.allOf) return this.renderAllOf(schema);
-    if (schema.type === "string") return this.renderString(schema);
-    if (schema.type === "number") return this.renderNumber(schema);
-    if (schema.type === "boolean") return this.renderBoolean(schema);
-    if (schema.type === "null") return this.renderNull(schema);
-    if (schema.type === "integer") return this.renderInteger(schema);
-    return "unknown";
-  }
-  renderMixed(schema) {
-    if (Array.isArray(schema.type)) {
-      schema.type.map((type) => ({ ...schema, type })).map((schema2) => this.renderSchema(schema2)).join(" | ");
-    }
-    return "unknown";
-  }
-  renderReference(schema) {
-    if (!this.options.referenceTransformer) {
-      return ReferenceTransformer.toDeclaration(schema);
-    }
-    return this.options.referenceTransformer(schema);
-  }
-  renderArray(schema) {
-    if (schema.items && Array.isArray(schema.items)) {
-      const items = schema.items.map((s) => this.renderSchema(s)).join(", ");
-      return `[${items}]`;
-    }
-    if (schema.items && typeof schema.items === "object") {
-      return `${this.renderSchema(schema.items)}[]`;
-    }
-    return "any[]";
-  }
-  renderObject(schema) {
-    if ((!schema.properties || R12.isEmpty(schema.properties)) && (!schema.additionalProperties || R12.isEmpty(schema.additionalProperties))) {
-      return "object";
-    }
-    const $properties = Object.entries(schema.properties || {}).map(([propertyName, propertySchema]) => {
-      let $comment = new CommentRenderer(propertySchema).render();
-      if ($comment) $comment += "\n";
-      const $key = `"${propertyName}"${schema.required?.includes(propertyName) ? "" : "?"}`;
-      const $value = this.renderSchema(propertySchema);
-      return indent(2, `${$comment}${$key}: ${$value}`);
-    });
-    if (schema.additionalProperties) {
-      const $value = schema.additionalProperties === true ? "any" : this.renderSchema(schema.additionalProperties);
-      $properties.push(indent(2, `[key: string]: ${$value}`));
-    }
-    return [
-      "{",
-      ...$properties,
-      "}"
-    ].join("\n");
-  }
-  renderOneOf(schema) {
-    if (!schema.oneOf) return "unknown";
-    return schema.oneOf.map((s) => this.renderSchema(s)).join(" | ");
-  }
-  renderAnyOf(schema) {
-    if (!schema.anyOf) return "unknown";
-    return schema.anyOf.map((s) => this.renderSchema(s)).join(" | ");
-  }
-  renderAllOf(schema) {
-    if (!schema.allOf) return "unknown";
-    return schema.allOf.map((s) => this.renderSchema(s)).join(" & ");
-  }
-  renderEnum(schema) {
-    if (!schema.enum) return "unknown";
-    return schema.enum.map((v) => JSON.stringify(v)).join(" | ");
-  }
-  renderString(schema) {
-    if (schema.contentMediaType === "application/octet-stream") return "Blob | Buffer";
-    if (schema.format === "binary") return "Blob | Buffer";
-    return "string";
-  }
-  renderNumber(schema) {
-    return "number";
-  }
-  renderBoolean(schema) {
-    return "boolean";
-  }
-  renderNull(schema) {
-    return "null";
-  }
-  renderInteger(schema) {
-    return "number";
-  }
-};
-
-// src/transformers/json-schema/json-schema.transformer.ts
-var JsonSchemaTransformer = class {
-  static toComment(schema) {
-    return new CommentRenderer(schema).render();
-  }
-  static toDeclaration(schema, options) {
-    return new DeclarationRenderer(schema, options).render();
-  }
-};
-
-// src/transformers/schema-definition/schema-definition.transformer.ts
-var R13 = __toESM(require("ramda"), 1);
-var SchemaDefinitionTransformer = class {
-  static toDeclaration(schemaDefinition, options) {
-    const dependencies = schemaDefinition.getDependencies();
-    let $dependencies = dependencies.filter((dep) => !SchemaDefinition.isUnknown(dep)).map((dep) => {
-      const filepath = options.getDependentSchemaDefinitionFilepath(dep);
-      return `import type { ${dep.name} } from "${filepath}"`;
-    }).map((str) => str.replace(/ from "(\.\.?\/.+?)(\.ts|\.mts|\.cts|\.js|\.cjs|\.mjs)?"/, options.esm ? ' from "$1.js"' : ' from "$1"')).join("\n");
-    if ($dependencies) $dependencies += "\n";
-    let $comment = JsonSchemaTransformer.toComment(schemaDefinition.schema);
-    if ($comment) $comment += "\n";
-    if (typeof schemaDefinition.schema === "boolean") {
-      return [
-        "/* @anchor:file:start */",
-        "",
-        $dependencies,
-        $comment || void 0,
-        `type ${schemaDefinition.name} = unknown`,
-        "",
-        "/* @anchor:file:end */"
-      ].filter(R13.isNotNil).join("\n");
-    }
-    if (JsonSchemaUtils.isNonArray(schemaDefinition.schema) && schemaDefinition.schema.type === "object") {
-      const $schema = JsonSchemaTransformer.toDeclaration(schemaDefinition.schema);
-      const $declaration = $schema.startsWith("{") ? `export interface ${schemaDefinition.name} ${$schema}` : `export type ${schemaDefinition.name} = ${$schema}`;
-      return [
-        "/* @anchor:file:start */",
-        "",
-        $dependencies,
-        $comment || void 0,
-        $declaration,
-        "",
-        "/* @anchor:file:end */"
-      ].filter(R13.isNotNil).join("\n");
-    }
-    return [
-      "/* @anchor:file:start */",
-      "",
-      $dependencies,
-      $comment || void 0,
-      `export type ${schemaDefinition.name} = ${JsonSchemaTransformer.toDeclaration(schemaDefinition.schema)}`,
-      "",
-      "/* @anchor:file:end */"
-    ].filter(R13.isNotNil).join("\n");
-  }
-};
-
-// src/transformers/operation-definition/comment.renderer.ts
-var R14 = __toESM(require("ramda"), 1);
-var CommentRenderer2 = class {
-  constructor(operationDefinition) {
-    this.operationDefinition = operationDefinition;
-  }
-  render() {
-    const operation = this.operationDefinition.operation;
-    if (!operation.summary && !operation.description) return "";
-    const lines = ["/**"];
-    if (operation.summary && typeof operation.summary === "string") {
-      lines.push(` * ${R14.trim(operation.summary)}`);
-      lines.push(" *");
-    }
-    if (operation.description && typeof operation.description === "string") {
-      lines.push(` * @description ${R14.trim(operation.description)}`);
-    }
-    lines.push(" */");
-    return lines.join("\n");
-  }
-};
-
-// src/transformers/operation-definition/declaration.renderer.ts
-var R15 = __toESM(require("ramda"), 1);
-
-// src/transformers/operation-definition/utils/type-name-factory.ts
-var changeCase = __toESM(require("change-case"), 1);
-function typeNameFactory(operationDefinition) {
-  const pascalCaseOperationId = changeCase.pascalCase(operationDefinition.operationId);
-  return (name) => `${pascalCaseOperationId}${name}`;
+function registerMcpCommand(program) {
+	program.command("mcp").description("Start keq MCP server").option("-c --config <config>", "The keq-cli config file").option("--tolerant", "Tolerate wrong swagger/openapi structure").option("--debug", "Print debug information").action(async (options) => {
+		const config = options.config;
+		const tolerant = !!options.tolerant;
+		const debug = !!options.debug;
+		const entries = await discoverProjects(config);
+		const registry = new CompilerProviderRegistry({
+			debug,
+			tolerant
+		});
+		for (const entry of entries) registry.register(entry);
+		const server = new _modelcontextprotocol_sdk_server_mcp_js.McpServer({
+			name: "keq",
+			version: "1.0.0",
+			description: "查询和搜索项目中对接的所有后端服务 API 接口。当用户想了解后端有哪些接口、查找某个功能的 API、查看接口的请求参数和响应格式时使用。支持自然语言语义搜索（中英文）。也可为接口生成 TypeScript 客户端代码。数据来源：项目配置的 Swagger/OpenAPI 规范文档。"
+		});
+		const projectParam = zod.z.string().optional().describe("项目目录绝对路径，用于 monorepo 中指定操作哪个子项目。非 monorepo 项目无需提供。");
+		server.registerTool("search_apis", {
+			description: "通过语义匹配搜索项目中的后端 API 接口。仅当用户描述了具体功能或业务场景（如\"用户登录\"、\"搜索商品\"）来查找相关接口时使用。如果用户想查看所有接口或按模块/路径浏览接口列表，应使用 list_apis 而非此工具。支持中英文自然语言，返回按相关度排序的接口列表。",
+			inputSchema: {
+				project: projectParam,
+				query: zod.z.string().describe("自然语言搜索词，如\"用户登录\"、\"搜索商品\"、\"订单列表\"等"),
+				module: zod.z.array(zod.z.string()).optional().describe("按模块名筛选，限定在特定后端服务中搜索"),
+				limit: zod.z.number().optional().default(10).describe("返回结果数量上限")
+			},
+			annotations: {
+				readOnlyHint: true,
+				destructiveHint: false
+			}
+		}, async ({ project, query, module, limit }) => {
+			try {
+				const provider = await registry.resolve(project);
+				const engine = await provider.getEngine();
+				const matcher = await provider.getMatcher();
+				const documents = await provider.getDocuments();
+				const annotated = (await engine.search(query, {
+					limit,
+					module
+				})).map((result) => {
+					const { score, ...rest } = result;
+					const op = documents.find((d) => d.module.name === result.module)?.operations.find((o) => o.method.toLowerCase() === result.method.toLowerCase() && o.pathname === result.pathname);
+					return {
+						...rest,
+						"x-keq-score": score,
+						"x-keq-filter": getFilterAnnotation(matcher, op)
+					};
+				});
+				return { content: [{
+					type: "text",
+					text: JSON.stringify(annotated, null, 2)
+				}] };
+			} catch (error) {
+				return {
+					content: [{
+						type: "text",
+						text: `Error: ${error instanceof Error ? error.message : String(error)}`
+					}],
+					isError: true
+				};
+			}
+		});
+		server.registerTool("get_api_detail", {
+			description: "获取某个 API 接口的完整详情，包含请求参数、请求体、响应体的结构定义。当用户想知道某个接口怎么调用、需要传什么参数、返回什么数据时使用。需要先通过 search_apis 或 list_apis 获取接口的 module、method、pathname。",
+			inputSchema: {
+				project: projectParam,
+				module: zod.z.string().describe("Module name"),
+				method: zod.z.string().describe("HTTP method (GET, POST, PUT, DELETE, etc.)"),
+				pathname: zod.z.string().describe("API pathname (e.g. /api/v1/users)")
+			},
+			annotations: {
+				readOnlyHint: true,
+				destructiveHint: false
+			}
+		}, async ({ project, module, method, pathname }) => {
+			try {
+				const provider = await registry.resolve(project);
+				const engine = await provider.getEngine();
+				const matcher = await provider.getMatcher();
+				const documents = await provider.getDocuments();
+				const detail = engine.getDetail(module, method, pathname);
+				if (!detail) return {
+					content: [{
+						type: "text",
+						text: "API not found"
+					}],
+					isError: true
+				};
+				const op = documents.find((d) => d.module.name === module)?.operations.find((o) => o.method.toLowerCase() === method.toLowerCase() && o.pathname === pathname);
+				return { content: [{
+					type: "text",
+					text: JSON.stringify({
+						...detail,
+						"x-keq-filter": getFilterAnnotation(matcher, op)
+					}, null, 2)
+				}] };
+			} catch (error) {
+				return {
+					content: [{
+						type: "text",
+						text: `Error: ${error instanceof Error ? error.message : String(error)}`
+					}],
+					isError: true
+				};
+			}
+		});
+		server.registerTool("list_modules", {
+			description: "列出项目对接的所有后端服务模块。当用户想知道项目接入了哪些后端系统、有哪些服务可用时使用。每个模块对应一个后端服务的 API 文档。",
+			inputSchema: { project: projectParam },
+			annotations: {
+				readOnlyHint: true,
+				destructiveHint: false
+			}
+		}, async ({ project }) => {
+			try {
+				const modules = (await (await registry.resolve(project)).getEngine()).listModules();
+				return { content: [{
+					type: "text",
+					text: JSON.stringify(modules, null, 2)
+				}] };
+			} catch (error) {
+				return {
+					content: [{
+						type: "text",
+						text: `Error: ${error instanceof Error ? error.message : String(error)}`
+					}],
+					isError: true
+				};
+			}
+		});
+		server.registerTool("list_apis", {
+			description: "列出项目中所有可用的后端 API 接口。当用户想查看所有接口、浏览某个服务的全部接口、查询某个系统有哪些接口、或按条件筛选接口（如只看 GET 请求或某个路径下的接口）时使用。如果用户描述了具体功能来查找接口（如\"搜索商品的接口\"），应使用 search_apis。",
+			inputSchema: {
+				project: projectParam,
+				module: zod.z.array(zod.z.string()).optional().describe("Filter by module names"),
+				method: zod.z.string().optional().describe("Filter by HTTP method (GET, POST, PUT, DELETE, etc.)"),
+				pathname: zod.z.string().optional().describe("Filter by pathname pattern (glob supported)"),
+				includes: zod.z.array(zod.z.enum(["operations", "components"])).optional().default(["operations"]).describe("What to include in results")
+			},
+			annotations: {
+				readOnlyHint: true,
+				destructiveHint: false
+			}
+		}, async ({ project, module, method, pathname, includes }) => {
+			try {
+				const provider = await registry.resolve(project);
+				const documents = await provider.getDocuments();
+				const matcher = await provider.getMatcher();
+				const result = documents.filter((doc) => !module || module.includes(doc.module.name)).map((document) => {
+					const item = { module: document.module.name };
+					if (includes.includes("operations")) {
+						let ops = document.operations;
+						if (method) ops = ops.filter((op) => op.method.toLowerCase() === method.toLowerCase());
+						if (pathname) {
+							const match = (0, picomatch.default)(pathname);
+							ops = ops.filter((op) => match(op.pathname));
+						}
+						item.operations = ops.map((op) => ({
+							method: op.method.toUpperCase(),
+							path: op.pathname,
+							operationId: op.operationId,
+							summary: op.operation.summary || "",
+							description: op.operation.description || "",
+							"x-keq-filter": getFilterAnnotation(matcher, op)
+						}));
+					}
+					if (includes.includes("components")) item.components = { schemas: document.schemas.map((schema) => {
+						const schemaObj = schema.schema;
+						return {
+							name: schema.name,
+							description: schemaObj.description || ""
+						};
+					}) };
+					return item;
+				});
+				return { content: [{
+					type: "text",
+					text: JSON.stringify(result, null, 2)
+				}] };
+			} catch (error) {
+				return {
+					content: [{
+						type: "text",
+						text: `Error: ${error instanceof Error ? error.message : String(error)}`
+					}],
+					isError: true
+				};
+			}
+		});
+		server.registerTool("build_apis", {
+			description: "为后端 API 接口生成类型安全的 TypeScript 请求函数代码。当用户想生成某个接口的调用代码、需要类型安全的 HTTP 客户端时使用。可按模块、方法、路径范围筛选要生成的接口。生成的文件写入项目配置的输出目录。",
+			inputSchema: {
+				project: projectParam,
+				module: zod.z.array(zod.z.string()).optional().describe("Module(s) to generate code for"),
+				method: zod.z.string().optional().describe("HTTP method filter (e.g. GET, POST)"),
+				pathname: zod.z.string().optional().describe("Pathname filter (glob pattern supported, e.g. /api/v1/users/**)"),
+				fresh: zod.z.boolean().optional().default(false).describe("Clean output directory before building")
+			},
+			annotations: {
+				readOnlyHint: false,
+				destructiveHint: false
+			}
+		}, async ({ project, module, method, pathname, fresh }) => {
+			try {
+				const provider = await registry.resolve(project);
+				const configPath = registry.getConfigPath(project);
+				const filterRules = [];
+				if (module || method || pathname) filterRules.push({
+					deny: true,
+					persist: false,
+					moduleName: "*",
+					operationMethod: "*",
+					operationPathname: "/**"
+				}, ...xprodFilterRules({
+					module,
+					method,
+					pathname,
+					persist: false
+				}));
+				const buildCompiler = new require_compiler.Compiler({
+					build: true,
+					persist: true,
+					silent: true,
+					fresh,
+					config: configPath,
+					debug,
+					tolerant,
+					filter: filterRules.length > 0 ? { rules: filterRules } : void 0
+				});
+				await buildCompiler.run();
+				const artifacts = buildCompiler.context.artifacts || [];
+				const rc = buildCompiler.context.rc;
+				const files = artifacts.map((a) => rc ? `./${path.join(rc.outdir, a.filepath)}` : a.filepath);
+				await provider.invalidate();
+				return { content: [{
+					type: "text",
+					text: JSON.stringify({
+						generated: files.length,
+						files
+					}, null, 2)
+				}] };
+			} catch (error) {
+				return {
+					content: [{
+						type: "text",
+						text: `Error: ${error instanceof Error ? error.message : String(error)}`
+					}],
+					isError: true
+				};
+			}
+		});
+		server.registerTool("list_generated_files", {
+			description: "列出已生成的 API 客户端代码文件。当用户想查看哪些接口已经生成了代码、或想找出过期/无效的生成文件时使用。",
+			inputSchema: {
+				project: projectParam,
+				invalid: zod.z.boolean().optional().default(false).describe("If true, only list invalid/stale files not matching current build")
+			},
+			annotations: {
+				readOnlyHint: true,
+				destructiveHint: false
+			}
+		}, async ({ project, invalid }) => {
+			try {
+				const context = await (await registry.resolve(project)).getContext();
+				const rc = context.rc;
+				if (!rc) return {
+					content: [{
+						type: "text",
+						text: "Error: Failed to load configuration"
+					}],
+					isError: true
+				};
+				if (invalid) {
+					const validFilePaths = (context.artifacts || []).map((a) => a.filepath);
+					const files = (await findInvalidFiles(rc.outdir, validFilePaths)).map((f) => `./${path.join(rc.outdir, f.relativePath)}`);
+					return { content: [{
+						type: "text",
+						text: JSON.stringify({
+							count: files.length,
+							files
+						}, null, 2)
+					}] };
+				}
+				const files = (context.artifacts || []).map((a) => `./${path.join(rc.outdir, a.filepath)}`);
+				return { content: [{
+					type: "text",
+					text: JSON.stringify({
+						count: files.length,
+						files
+					}, null, 2)
+				}] };
+			} catch (error) {
+				return {
+					content: [{
+						type: "text",
+						text: `Error: ${error instanceof Error ? error.message : String(error)}`
+					}],
+					isError: true
+				};
+			}
+		});
+		server.registerTool("get_filter_rules", {
+			description: "查看当前的接口过滤规则。过滤规则决定哪些 API 接口会被纳入代码生成范围。当用户想了解哪些接口被排除或包含在生成列表中时使用。",
+			inputSchema: { project: projectParam },
+			annotations: {
+				readOnlyHint: true,
+				destructiveHint: false
+			}
+		}, async ({ project }) => {
+			try {
+				await registry.resolve(project);
+				const configPath = registry.getConfigPath(project);
+				const filterPath = path.resolve(path.dirname(configPath), ".keqfilter");
+				if (!await fs_extra.default.exists(filterPath)) return { content: [{
+					type: "text",
+					text: JSON.stringify({
+						exists: false,
+						content: ""
+					}, null, 2)
+				}] };
+				const content = await fs_extra.default.readFile(filterPath, "utf-8");
+				return { content: [{
+					type: "text",
+					text: JSON.stringify({
+						exists: true,
+						content
+					}, null, 2)
+				}] };
+			} catch (error) {
+				return {
+					content: [{
+						type: "text",
+						text: `Error: ${error instanceof Error ? error.message : String(error)}`
+					}],
+					isError: true
+				};
+			}
+		});
+		server.registerTool("add_filter_rule", {
+			description: "添加接口过滤规则，控制哪些 API 需要生成代码。当用户想排除某些不需要的接口、或只保留特定接口时使用。deny 模式排除接口，allow 模式包含接口。",
+			inputSchema: {
+				project: projectParam,
+				mode: zod.z.enum(["deny", "allow"]).describe("Rule mode: deny excludes APIs, allow includes them"),
+				module: zod.z.string().optional().default("*").describe("Module name pattern (glob supported)"),
+				method: zod.z.string().optional().default("*").describe("HTTP method pattern (e.g. GET, POST, or * for all)"),
+				pathname: zod.z.string().describe("Pathname pattern (glob supported, e.g. /api/v1/users/**)"),
+				build: zod.z.boolean().optional().default(false).describe("Whether to rebuild after adding the rule")
+			},
+			annotations: {
+				readOnlyHint: false,
+				destructiveHint: false
+			}
+		}, async ({ project, mode, module, method, pathname, build }) => {
+			try {
+				const provider = await registry.resolve(project);
+				await new require_compiler.Compiler({
+					build,
+					persist: true,
+					silent: true,
+					config: registry.getConfigPath(project),
+					debug,
+					tolerant,
+					filter: { rules: [{
+						persist: true,
+						deny: mode === "deny",
+						moduleName: module,
+						operationMethod: method.toLowerCase(),
+						operationPathname: pathname
+					}] }
+				}).run();
+				if (build) await provider.invalidate();
+				return { content: [{
+					type: "text",
+					text: JSON.stringify({
+						success: true,
+						rule: {
+							mode,
+							module,
+							method,
+							pathname
+						}
+					}, null, 2)
+				}] };
+			} catch (error) {
+				return {
+					content: [{
+						type: "text",
+						text: `Error: ${error instanceof Error ? error.message : String(error)}`
+					}],
+					isError: true
+				};
+			}
+		});
+		server.registerTool("remove_filter_rule", {
+			description: "移除已有的接口过滤规则。当用户想恢复之前被排除的接口、或调整过滤策略时使用。",
+			inputSchema: {
+				project: projectParam,
+				mode: zod.z.enum(["deny", "allow"]).describe("Which section the rule is in"),
+				module: zod.z.string().describe("Exact module name pattern to match"),
+				method: zod.z.string().describe("Exact method pattern to match"),
+				pathname: zod.z.string().describe("Exact pathname pattern to match"),
+				build: zod.z.boolean().optional().default(false).describe("Whether to rebuild after removing the rule")
+			},
+			annotations: {
+				readOnlyHint: false,
+				destructiveHint: false
+			}
+		}, async ({ project, mode, module, method, pathname, build }) => {
+			try {
+				const provider = await registry.resolve(project);
+				const configPath = registry.getConfigPath(project);
+				const filterPath = path.resolve(path.dirname(configPath), ".keqfilter");
+				if (!await fs_extra.default.exists(filterPath)) return {
+					content: [{
+						type: "text",
+						text: "Error: .keqfilter file not found"
+					}],
+					isError: true
+				};
+				const content = await fs_extra.default.readFile(filterPath, "utf-8");
+				const isDeny = mode === "deny";
+				const targetMethod = method.toLowerCase();
+				const lines = content.split("\n");
+				const resultLines = [];
+				let currentSection = null;
+				let skipNext = false;
+				for (const line of lines) {
+					const trimmed = line.replace(/#.*$/, "").trim();
+					if (trimmed === "[deny]") {
+						currentSection = "deny";
+						resultLines.push(line);
+						continue;
+					}
+					if (trimmed === "[allow]") {
+						currentSection = "allow";
+						resultLines.push(line);
+						continue;
+					}
+					if (!trimmed) {
+						if (!skipNext) resultLines.push(line);
+						skipNext = false;
+						continue;
+					}
+					const matched = trimmed.match(/^([^\s]+)\s+([^:\s]+):(.*)$/);
+					if (matched && currentSection === (isDeny ? "deny" : "allow")) {
+						const [, ruleMethod, ruleModule, rulePathname] = matched;
+						if (ruleMethod.toLowerCase() === targetMethod && ruleModule === module && rulePathname === pathname) {
+							skipNext = false;
+							continue;
+						}
+					}
+					resultLines.push(line);
+					skipNext = false;
+				}
+				await fs_extra.default.writeFile(filterPath, resultLines.join("\n"), "utf-8");
+				if (build) {
+					await new require_compiler.Compiler({
+						build: true,
+						persist: true,
+						silent: true,
+						config: configPath,
+						debug,
+						tolerant
+					}).run();
+					await provider.invalidate();
+				}
+				return { content: [{
+					type: "text",
+					text: JSON.stringify({
+						success: true,
+						removed: {
+							mode,
+							module,
+							method,
+							pathname
+						}
+					}, null, 2)
+				}] };
+			} catch (error) {
+				return {
+					content: [{
+						type: "text",
+						text: `Error: ${error instanceof Error ? error.message : String(error)}`
+					}],
+					isError: true
+				};
+			}
+		});
+		const transport = new _modelcontextprotocol_sdk_server_stdio_js.StdioServerTransport();
+		await server.connect(transport);
+		if (registry.list().length === 1) (await registry.resolve()).getEngine().catch(() => {});
+	});
 }
-
-// src/transformers/operation-definition/declaration.renderer.ts
-var alias = (name) => `${name}Schema`;
-var DeclarationRenderer2 = class {
-  constructor(operationDefinition, options) {
-    this.operationDefinition = operationDefinition;
-    this.options = options;
-    this.typeName = typeNameFactory(operationDefinition);
-  }
-  typeName;
-  renderResponseBodies(operation, options) {
-    if (!operation.responses || R15.isEmpty(operation.responses)) {
-      return `export interface ${this.typeName("ResponseBodies")} {}`;
-    }
-    const $responses = Object.entries(operation.responses).map(([statusCode, response]) => {
-      if (!JsonSchemaUtils.isRef(response)) {
-        const $value = Object.entries(response.content || {}).map(([mediaType, mediaTypeObject]) => [mediaType, mediaTypeObject.schema]).map(([mediaType, schema]) => {
-          if (mediaType.includes("text/event-stream")) return "ReadableStream<ServerSentEvent>";
-          if (mediaType.includes("multipart/form-data")) return "FormData";
-          if (!schema) return "unknown";
-          return JsonSchemaTransformer.toDeclaration(schema, options);
-        }).join(" | ");
-        return indent(2, `${statusCode}: ${$value || "void"}`);
-      }
-    }).join("\n");
-    return [
-      `export interface ${this.typeName("ResponseBodies")} {`,
-      $responses,
-      "}"
-    ].join("\n");
-  }
-  renderRequestBodies(operation, options) {
-    let $requestBodies = `export interface ${this.typeName("RequestBodies")} {}`;
-    if (operation.requestBody && !JsonSchemaUtils.isRef(operation.requestBody)) {
-      const $mediaTypes = Object.entries(operation.requestBody.content || {}).map(([mediaType, mediaTypeObject]) => [mediaType, mediaTypeObject.schema]).map(([mediaType, schema]) => {
-        if (!schema) return `${JSON.stringify(mediaType)}: unknown`;
-        return `${JSON.stringify(mediaType)}: ${JsonSchemaTransformer.toDeclaration(schema, options)}`;
-      }).map((pair) => indent(2, pair));
-      $requestBodies = [
-        `export interface ${this.typeName("RequestBodies")} {`,
-        ...$mediaTypes,
-        "}"
-      ].join("\n");
-    }
-    return $requestBodies;
-  }
-  renderParameterBodies(operationDefinition, options) {
-    const { operation } = operationDefinition;
-    let parameterBodies = "";
-    if (operation.requestBody && !JsonSchemaUtils.isRef(operation.requestBody)) {
-      const $mediaTypes = Object.entries(operation.requestBody.content || {}).map(([mediaType, mediaTypeObject]) => [mediaType, mediaTypeObject.schema]).map(([mediaType, schemaOrRef]) => {
-        if (!schemaOrRef) return `${JSON.stringify(mediaType)}: unknown`;
-        const schema = JsonSchemaUtils.isRef(schemaOrRef) ? OpenapiUtils.dereferenceDeep(schemaOrRef.$ref, operationDefinition.document.specification) : schemaOrRef;
-        if (schema.type === "object" || schema.properties) {
-          return `${JSON.stringify(mediaType)}: ${JsonSchemaTransformer.toDeclaration(schemaOrRef, options)} & { [key: string]: any }`;
-        }
-        return `${JSON.stringify(mediaType)}: { [key: string]: any }`;
-      }).map((pair) => indent(2, pair));
-      parameterBodies = [
-        `interface ${this.typeName("ParameterBodies")} {`,
-        ...$mediaTypes,
-        "}",
-        ""
-      ].join("\n");
-    }
-    return parameterBodies;
-  }
-  renderRequestParameters(operation, options) {
-    const mediaTypes = operation.requestBody && !JsonSchemaUtils.isRef(operation.requestBody) ? Object.keys(operation.requestBody.content || {}) : [];
-    const base = `${this.typeName("RequestQuery")} & ${this.typeName("RouteParameters")} & ${this.typeName("RequestHeaders")}`;
-    if (mediaTypes.length === 1) {
-      return `export type ${this.typeName("RequestParameters")} = ${base} & ${this.typeName("RequestBodies")}[${JSON.stringify(mediaTypes[0])}]`;
-    }
-    if (mediaTypes.length > 1) {
-      const unions = mediaTypes.map((mediaType) => `(${base} & ${this.typeName("RequestBodies")}[${JSON.stringify(mediaType)}] & { "content-type": ${JSON.stringify(mediaType)} })`).join("\n| ");
-      return `export type ${this.typeName("RequestParameters")} = ${unions}`;
-    }
-    return `export type ${this.typeName("RequestParameters")} = ${base}`;
-  }
-  rendererParameters(name, parameters, options) {
-    if (parameters.length === 0) {
-      return `export type ${name} = {}`;
-    }
-    const $parameters = parameters.map((parameter) => {
-      const parameterName = `"${parameter.name}"`;
-      const $key = parameter.required ? parameterName : `${parameterName}?`;
-      const $value = JsonSchemaTransformer.toDeclaration(parameter.schema || { type: "any" }, options);
-      return indent(2, `${$key}: ${$value}`);
-    }).join("\n");
-    return [
-      `export type ${name} = {`,
-      $parameters,
-      "}"
-    ].filter(Boolean).join("\n");
-  }
-  renderDependencies() {
-    const schemaDefinitions = this.operationDefinition.getDependencies().filter((schemaDefinition) => !SchemaDefinition.isUnknown(schemaDefinition));
-    const $schemaDefinitions = schemaDefinitions.map((schemaDefinition) => {
-      const filepath = this.options.getDependentSchemaDefinitionFilepath(schemaDefinition);
-      const schemaName = schemaDefinition.name;
-      return `import type { ${schemaName} as ${alias(schemaName)} } from "${filepath}"`;
-    }).map((str) => str.replace(/ from "(\.\.?\/.+?)(\.ts|\.mts|\.cts|\.js|\.cjs|\.mjs)?"/, this.options.esm ? ' from "$1.js"' : ' from "$1"'));
-    return [
-      'import type { KeqOperation, KeqPathParameterInit, KeqQueryInit, ServerSentEvent } from "keq"',
-      ...$schemaDefinitions
-    ].join("\n");
-  }
-  render() {
-    const { operation } = this.operationDefinition;
-    if (!operation.responses) return "";
-    const jsonSchemaDeclarationRendererOptions = {
-      referenceTransformer: (schema) => {
-        return ReferenceTransformer.toDeclaration(schema, alias);
-      }
-    };
-    const $dependencies = this.renderDependencies();
-    const $responseBodies = this.renderResponseBodies(operation, jsonSchemaDeclarationRendererOptions);
-    const $requestBodies = this.renderRequestBodies(operation, jsonSchemaDeclarationRendererOptions);
-    const $parameterBodies = this.renderParameterBodies(this.operationDefinition, jsonSchemaDeclarationRendererOptions);
-    const $requestParameters = this.renderRequestParameters(operation, jsonSchemaDeclarationRendererOptions);
-    const $requestQuery = this.rendererParameters(
-      `${this.typeName("RequestQuery")}`,
-      operation.parameters?.filter((p) => !JsonSchemaUtils.isRef(p) && p.in === "query") || [],
-      jsonSchemaDeclarationRendererOptions
-    );
-    const $routeParameters = this.rendererParameters(
-      `${this.typeName("RouteParameters")}`,
-      operation.parameters?.filter((p) => !JsonSchemaUtils.isRef(p) && p.in === "path") || [],
-      jsonSchemaDeclarationRendererOptions
-    );
-    const $requestHeaders = this.rendererParameters(
-      `${this.typeName("RequestHeaders")}`,
-      operation.parameters?.filter((p) => !JsonSchemaUtils.isRef(p) && p.in === "header") || [],
-      jsonSchemaDeclarationRendererOptions
-    );
-    return [
-      "/* @anchor:file:start */",
-      "",
-      $dependencies,
-      "",
-      $responseBodies,
-      "",
-      $requestBodies,
-      "",
-      $requestQuery,
-      "",
-      $routeParameters,
-      "",
-      $requestHeaders,
-      "",
-      $parameterBodies || void 0,
-      $requestParameters,
-      "",
-      `export interface ${this.typeName("Operation")}<STATUS extends keyof ${this.typeName("ResponseBodies")}, CONTENT_TYPE extends ${$parameterBodies ? `keyof ${this.typeName("ParameterBodies")}` : "string"} > extends KeqOperation {`,
-      `  requestParams: ${this.typeName("RouteParameters")} & { [key: string]: KeqPathParameterInit }`,
-      `  requestQuery: ${this.typeName("RequestQuery")} & { [key: string]: KeqQueryInit }`,
-      `  requestHeaders: ${this.typeName("RequestHeaders")} & { [key: string]: string | number }`,
-      `  requestBody: ${$parameterBodies ? `${this.typeName("ParameterBodies")}[CONTENT_TYPE] | ` : "object | "}BodyInit`,
-      `  responseBody: ${this.typeName("ResponseBodies")}[STATUS]`,
-      "}",
-      "",
-      "/* @anchor:file:end */"
-    ].filter(R15.isNotNil).join("\n");
-  }
-};
-
-// src/transformers/operation-definition/micro-function.renderer.ts
-var R17 = __toESM(require("ramda"), 1);
-
-// src/transformers/operation-definition/typescript-snippet.ts
-var R16 = __toESM(require("ramda"), 1);
-
-// src/constants/qs-array-format.ts
-var QsArrayFormat = /* @__PURE__ */ ((QsArrayFormat2) => {
-  QsArrayFormat2["brackets"] = "brackets";
-  QsArrayFormat2["indices"] = "indices";
-  QsArrayFormat2["repeat"] = "repeat";
-  QsArrayFormat2["comma"] = "comma";
-  QsArrayFormat2["space"] = "space";
-  QsArrayFormat2["pipe"] = "pipe";
-  return QsArrayFormat2;
-})(QsArrayFormat || {});
-
-// src/transformers/operation-definition/typescript-snippet.ts
-var OperationDefinitionSnippet = class {
-  constructor(operationDefinition, options) {
-    this.operationDefinition = operationDefinition;
-    this.options = options;
-    this.typeName = typeNameFactory(operationDefinition);
-  }
-  typeName;
-  getQsParameters(parameter) {
-    let arrayFormat;
-    let allowDots;
-    let indices;
-    const style = parameter.style || "form";
-    const explode = parameter.explode ?? true;
-    if ("x-qs-array-format" in parameter) {
-      arrayFormat = parameter["x-qs-array-format"];
-    } else {
-      if (style === "deepObject") {
-        arrayFormat = "brackets" /* brackets */;
-      } else if (explode) {
-        arrayFormat = "repeat" /* repeat */;
-      } else {
-        if (style === "form") {
-          arrayFormat = "comma" /* comma */;
-        } else if (style === "spaceDelimited") {
-          arrayFormat = "space" /* space */;
-        } else if (style === "pipeDelimited") {
-          arrayFormat = "pipe" /* pipe */;
-        }
-      }
-    }
-    if ("x-qs-allow-dots" in parameter) {
-      allowDots = Boolean(parameter["x-qs-allow-dots"]);
-    }
-    if ("x-qs-indices" in parameter) {
-      indices = Boolean(parameter["x-qs-indices"]);
-    }
-    if (arrayFormat || allowDots !== void 0 || indices !== void 0) {
-      return {
-        ...arrayFormat ? { arrayFormat } : {},
-        ...allowDots !== void 0 ? { allowDots } : {},
-        ...indices !== void 0 ? { indices } : {}
-      };
-    }
-    return void 0;
-  }
-  // render: "if (args && 'Authorization' in args) req.header('Authorization', args['Authorization'])"
-  renderRequestHeaders() {
-    const { operation } = this.operationDefinition;
-    const $headers = (operation.parameters || []).filter((p) => !JsonSchemaUtils.isRef(p)).filter((p) => p.in === "header").map((p) => `if (args && ${JSON.stringify(p.name)} in args) req.header(${JSON.stringify(p.name)}, args[${JSON.stringify(p.name)}])`).join("\n");
-    return $headers;
-  }
-  // render: "if (args && 'id' in args) req.query('id', args['id'], options)"
-  renderRequestQuery() {
-    const { operation } = this.operationDefinition;
-    const $query = (operation.parameters || []).filter((p) => !JsonSchemaUtils.isRef(p)).filter((p) => p.in === "query").map((p) => {
-      const option = this.getQsParameters(p);
-      const $option = !option || R16.isEmpty(option) ? "" : `, ${JSON.stringify(option)}`;
-      return `if (args && ${JSON.stringify(p.name)} in args) req.query(${JSON.stringify(p.name)}, args[${JSON.stringify(p.name)}]${$option})`;
-    }).join("\n");
-    return $query;
-  }
-  // render: "if (args && 'id' in args) req.params('id', args['id'])"
-  renderRequestPathParameters() {
-    const { operation } = this.operationDefinition;
-    const $pathParameters = (operation.parameters || []).filter((p) => !JsonSchemaUtils.isRef(p)).filter((p) => p.in === "path").map((p) => `if (args && ${JSON.stringify(p.name)} in args) req.params(${JSON.stringify(p.name)}, args[${JSON.stringify(p.name)}])`).join("\n");
-    return $pathParameters;
-  }
-  getRequestMediaTypes() {
-    const { operation } = this.operationDefinition;
-    const requestBodyContent = operation.requestBody?.content || {};
-    return Object.keys(requestBodyContent);
-  }
-  // render "req.type("application/json")"
-  renderMediaType() {
-    const mediaTypes = this.getRequestMediaTypes();
-    if (mediaTypes.length === 1 && !mediaTypes[0].endsWith("/*")) {
-      return `req.type("${mediaTypes[0]}")
-`;
-    } else if (mediaTypes.some((mediaType) => mediaType === "*/*")) {
-    } else if (mediaTypes.some((mediaType) => mediaType.endsWith("/*"))) {
-      return 'if(args?.["content-type"]) req.type(args["content-type"])\n';
-    } else if (mediaTypes.length > 1) {
-      return 'if(args?.["content-type"]) req.type(args["content-type"])\n';
-    }
-    return "";
-  }
-  // render body
-  requestBodyFormDataPropertyRenderer(propertyName, propertySchema, mediaType) {
-    try {
-      const $propertyName = JSON.stringify(propertyName);
-      const schema = JsonSchemaUtils.isRef(propertySchema) ? OpenapiUtils.dereferenceDeep(propertySchema.$ref, this.operationDefinition.document.specification) : propertySchema;
-      if (schema.type === "string" && schema.format === "binary" || schema.contentMediaType === "application/octet-stream") {
-        return `if (args && ${$propertyName} in args && args[${$propertyName}]) req.attach(${$propertyName}, args[${$propertyName}])`;
-      } else if (schema.type === "string" || schema.type === "array" && schema.items && schema.items.type === "string") {
-        return `if (args && ${$propertyName} in args && args[${$propertyName}] !== undefined) req.field(${$propertyName}, args[${$propertyName}])`;
-      } else if (schema.type === "number" || schema.type === "integer") {
-        return `if (args && ${$propertyName} in args && args[${$propertyName}] !== undefined) req.field(${$propertyName}, String(args[${$propertyName}]))`;
-      }
-      return `if (args && ${$propertyName} in args && args[${$propertyName}] !== undefined) req.field(${$propertyName}, String(args[${$propertyName}]) /* type is non-string in schema; triggers type coercion here */)`;
-    } catch (err) {
-      return this.renderErrorComment(err, mediaType);
-    }
-  }
-  requestBodyPropertyRenderer(propertyName, propertySchema, mediaType) {
-    if (mediaType === "application/json") {
-      const $propertyName = JSON.stringify(propertyName);
-      return `if (args && ${$propertyName} in args) req.send({ ${$propertyName}: args[${$propertyName}] })`;
-    } else if (mediaType === "multipart/form-data") {
-      return this.requestBodyFormDataPropertyRenderer(propertyName, propertySchema, mediaType);
-    } else {
-      throw new Error(`Unsupported media type: ${mediaType}`);
-    }
-  }
-  renderRequestBody() {
-    const { operation } = this.operationDefinition;
-    const requestBodyContent = operation.requestBody?.content || {};
-    const $requestBody = Object.entries(requestBodyContent).map(([mediaType, mediaTypeObject]) => {
-      if (!mediaTypeObject.schema) return;
-      try {
-        const schema = JsonSchemaUtils.isRef(mediaTypeObject.schema) ? OpenapiUtils.dereferenceDeep(mediaTypeObject.schema.$ref, this.operationDefinition.document.specification) : mediaTypeObject.schema;
-        if (schema.type !== "object") return;
-        const properties = schema.properties || {};
-        return Object.entries(properties).map(([propertyName, propertySchema]) => this.requestBodyPropertyRenderer(propertyName, propertySchema, mediaType)).join("\n");
-      } catch (err) {
-        return this.renderErrorComment(err, mediaType);
-      }
-    }).filter(R16.isNotNil).join("\n");
-    return $requestBody;
-  }
-  renderErrorComment(err, mediaType) {
-    const $err = String(err).split("\n").map(((line) => ` * ${line}`)).join("\n");
-    return [
-      "/**",
-      ` * Unable to dereference schema for media type ${mediaType}`,
-      $err,
-      " */"
-    ].join("\n");
-  }
-};
-
-// src/transformers/operation-definition/micro-function.renderer.ts
-var OperationDefinitionMicroFunctionRenderer = class {
-  constructor(operationDefinition, options) {
-    this.operationDefinition = operationDefinition;
-    this.options = options;
-    this.typeName = typeNameFactory(operationDefinition);
-    this.helper = new OperationDefinitionSnippet(operationDefinition, options);
-  }
-  helper;
-  typeName;
-  render() {
-    const { operation, operationId, method, pathname } = this.operationDefinition;
-    if (!operation.responses) return "";
-    const $dependencies = this.renderDependencies();
-    const $comment = new CommentRenderer2(this.operationDefinition).render();
-    const moduleName = this.operationDefinition.module.name;
-    const $method = method.toLowerCase();
-    const $queryParameters = this.helper.renderRequestQuery();
-    const $headerParameters = this.helper.renderRequestHeaders();
-    const $pathParameters = this.helper.renderRequestPathParameters();
-    const $mediaType = this.helper.renderMediaType();
-    const $requestBody = this.helper.renderRequestBody();
-    const $operationDeclaration = this.renderOperationDeclaration();
-    return [
-      "/* @anchor:file:start */",
-      "",
-      $dependencies,
-      "",
-      `const moduleName = "${moduleName}"`,
-      `const method = "${method}"`,
-      `const pathname = "${pathname}"`,
-      "",
-      $comment || void 0,
-      `export ${$operationDeclaration} {`,
-      `  const req = request.${$method}<${this.typeName("ResponseBodies")}[STATUS]>("${pathname}")`,
-      "    .option('module', { name: moduleName, pathname, method })",
-      "",
-      $mediaType ? indent(2, $mediaType) : void 0,
-      "  /* @anchor:query:start */",
-      $queryParameters ? indent(2, $queryParameters) : void 0,
-      "  /* @anchor:query:end */",
-      "",
-      "  /* @anchor:headers:start */",
-      $headerParameters ? indent(2, $headerParameters) : void 0,
-      "  /* @anchor:headers:end */",
-      "",
-      "  /* @anchor:path-parameters:start */",
-      $pathParameters ? indent(2, $pathParameters) : void 0,
-      "  /* @anchor:path-parameters:end */",
-      "",
-      "  /* @anchor:body:start */",
-      $requestBody ? indent(2, $requestBody) : void 0,
-      "  /* @anchor:body:end */",
-      "",
-      "  /* @anchor:operation-return */",
-      `  return req as ReturnType<typeof ${operationId}<STATUS${$operationDeclaration.includes("CONTENT_TYPE") ? ", CONTENT_TYPE" : ""}>>`,
-      "}",
-      "",
-      `${operationId}.pathname = pathname`,
-      `${operationId}.method = method`,
-      "/* @anchor:file:end */"
-    ].filter(R17.isNotNil).join("\n");
-  }
-  renderDependencies() {
-    const declarationFilepath = this.options.getOperationDefinitionDeclarationFilepath(this.operationDefinition);
-    const requestFilepath = this.options.getRequestFilepath();
-    return [
-      'import { Keq } from "keq"',
-      `import { request } from "${requestFilepath}"`,
-      `import type { ${this.typeName("Operation")}, ${this.typeName("ResponseBodies")}, ${this.typeName("RequestParameters")} } from "${declarationFilepath}"`,
-      `export type { ${this.typeName("RequestQuery")}, ${this.typeName("RequestHeaders")}, ${this.typeName("RequestBodies")} } from "${declarationFilepath}"`
-    ].map((str) => str.replace(/ from "(\.\.?\/.+?)(\.ts|\.mts|\.cts|\.js|\.cjs|\.mjs)?"/, this.options.esm ? ' from "$1.js"' : ' from "$1"')).join("\n");
-  }
-  renderOperationDeclaration() {
-    const { operationId } = this.operationDefinition;
-    const mediaTypes = this.helper.getRequestMediaTypes();
-    if (mediaTypes.length === 0) {
-      return `function ${operationId}<STATUS extends keyof ${this.typeName("ResponseBodies")}, CONTENT_TYPE extends never = never>(args?: ${this.typeName("RequestParameters")}): Keq<${this.typeName("Operation")}<STATUS, CONTENT_TYPE>>`;
-    } else if (mediaTypes.length === 1) {
-      return `function ${operationId}<STATUS extends keyof ${this.typeName("ResponseBodies")}, CONTENT_TYPE extends ${JSON.stringify(mediaTypes[0])} = ${JSON.stringify(mediaTypes[0])}>(args?: ${this.typeName("RequestParameters")}): Keq<${this.typeName("Operation")}<STATUS, CONTENT_TYPE>>`;
-    } else if (mediaTypes.length > 1) {
-      return `function ${operationId}<STATUS extends keyof ${this.typeName("ResponseBodies")}, CONTENT_TYPE extends ${this.typeName("RequestParameters")}["content-type"]>(args?: Extract<${this.typeName("RequestParameters")}, { "content-type": CONTENT_TYPE }>): Keq<${this.typeName("Operation")}<STATUS, CONTENT_TYPE>>`;
-    }
-    throw new Exception(this.operationDefinition.module, "[operationDeclarationRenderer] Unreachable");
-  }
-};
-
-// src/transformers/operation-definition/nestjs-method.renderer.ts
-var R18 = __toESM(require("ramda"), 1);
-var OperationDefinitionNestjsMethodRenderer = class {
-  constructor(operationDefinition, options) {
-    this.operationDefinition = operationDefinition;
-    this.options = options;
-    this.typeName = typeNameFactory(operationDefinition);
-    this.helper = new OperationDefinitionSnippet(operationDefinition, options);
-  }
-  helper;
-  typeName;
-  render() {
-    const pathname = this.operationDefinition.pathname;
-    const $comment = new CommentRenderer2(this.operationDefinition).render();
-    const $method = this.operationDefinition.method.toLowerCase();
-    const $mediaType = this.helper.renderMediaType();
-    const $operationDeclaration = this.renderOperationDeclaration(this.operationDefinition);
-    const $queryParameters = this.helper.renderRequestQuery();
-    const $headerParameters = this.helper.renderRequestHeaders();
-    const $pathParameters = this.helper.renderRequestPathParameters();
-    const $requestBody = this.helper.renderRequestBody();
-    return [
-      $comment,
-      `${$operationDeclaration} {`,
-      `  const req = this.request.${$method}<${this.typeName("ResponseBodies")}[STATUS]>(${JSON.stringify(pathname)})`,
-      "    .option(",
-      '      "module",',
-      "      {",
-      `        name: ${JSON.stringify(this.operationDefinition.module.name)},`,
-      `        pathname: ${JSON.stringify(pathname)},`,
-      `        method: ${JSON.stringify($method)},`,
-      "      },",
-      "    )",
-      "",
-      $mediaType ? indent(2, $mediaType) : void 0,
-      "",
-      "  /* @anchor:query:start */",
-      $queryParameters ? indent(2, $queryParameters) : void 0,
-      "  /* @anchor:query:end */",
-      "",
-      "  /* @anchor:headers:start */",
-      $headerParameters ? indent(2, $headerParameters) : void 0,
-      "  /* @anchor:headers:end */",
-      "",
-      "  /* @anchor:path-parameters:start */",
-      $pathParameters ? indent(2, $pathParameters) : void 0,
-      "  /* @anchor:path-parameters:end */",
-      "",
-      "  /* @anchor:body:start */",
-      $requestBody ? indent(2, $requestBody) : void 0,
-      "  /* @anchor:body:end */",
-      "",
-      "  return req",
-      "}"
-    ].filter(R18.isNotNil).join("\n");
-  }
-  renderOperationDeclaration(operationDefinition) {
-    const { operationId } = operationDefinition;
-    const typeName = typeNameFactory(operationDefinition);
-    const mediaTypes = this.helper.getRequestMediaTypes();
-    if (mediaTypes.length === 0) {
-      return `${operationId}<STATUS extends keyof ${typeName("ResponseBodies")}, CONTENT_TYPE extends never = never>(args?: ${typeName("RequestParameters")}): Keq<${typeName("Operation")}<STATUS, CONTENT_TYPE>>`;
-    } else if (mediaTypes.length === 1) {
-      return `${operationId}<STATUS extends keyof ${typeName("ResponseBodies")}, CONTENT_TYPE extends ${JSON.stringify(mediaTypes[0])} = ${JSON.stringify(mediaTypes[0])}>(args?: ${typeName("RequestParameters")}): Keq<${typeName("Operation")}<STATUS, CONTENT_TYPE>>`;
-    } else if (mediaTypes.length > 1) {
-      return `${operationId}<STATUS extends keyof ${typeName("ResponseBodies")}, CONTENT_TYPE extends ${typeName("RequestParameters")}["content-type"]>(args?: Extract<${typeName("RequestParameters")}, { "content-type": CONTENT_TYPE }>): Keq<${typeName("Operation")}<STATUS, CONTENT_TYPE>>`;
-    }
-    throw new Exception(operationDefinition.module, "[operationDeclarationRenderer] Unreachable");
-  }
-};
-
-// src/transformers/operation-definition/operation-definition.transformer.ts
-var OperationDefinitionTransformer = class {
-  static toDeclaration(operationDefinition, options) {
-    return new DeclarationRenderer2(operationDefinition, options).render();
-  }
-  static toMicroFunction(operationDefinition, options) {
-    return new OperationDefinitionMicroFunctionRenderer(operationDefinition, options).render();
-  }
-  static toNestjsMethod(operationDefinition, options) {
-    return new OperationDefinitionNestjsMethodRenderer(operationDefinition, options).render();
-  }
-  static toComment(operationDefinition) {
-    return new CommentRenderer2(operationDefinition).render();
-  }
-};
-
-// src/transformers/entrypoint/entrypoint.transformer.ts
-var path7 = __toESM(require("path"), 1);
-var EntrypointTransformer = class {
-  static toTypescript(exports2, options) {
-    const $exports = exports2.map((exportArtifact) => {
-      const relativePath = path7.relative(
-        options.dirpath,
-        exportArtifact.filepath
-      ).replace(/(\.ts|\.mts|\.cts|\.js|\.cjs|\.mjs)?$/, options.esm ? ".js" : "");
-      return relativePath.startsWith(".") ? `export * from '${relativePath}'` : `export * from './${relativePath}'`;
-    });
-    return [
-      "/* @anchor:file:start */",
-      "",
-      ...$exports,
-      "",
-      "/* @anchor:file:end */"
-    ].join("\n");
-  }
-};
-
-// src/transformers/api-document/nestjs-client.renderer.ts
-var R19 = __toESM(require("ramda"), 1);
-var changeCase2 = __toESM(require("change-case"), 1);
-var NestjsClientRenderer = class {
-  constructor(document, options) {
-    this.document = document;
-    this.options = options;
-  }
-  renderDependencies() {
-    const $operations = this.document.operations.map((operationDefinition) => {
-      const filepath = this.options.getOperationDefinitionDeclarationFilepath(operationDefinition);
-      const typeName = typeNameFactory(operationDefinition);
-      return `import type { ${typeName("Operation")}, ${typeName("ResponseBodies")}, ${typeName("RequestParameters")} } from "${filepath}"`;
-    }).map((str) => str.replace(/ from "(\.\.?\/.+?)(\.ts|\.mts|\.cts|\.js|\.cjs|\.mjs)?"/, this.options.esm ? ' from "$1.js"' : ' from "$1"'));
-    return [
-      'import { Injectable, Logger } from "@nestjs/common"',
-      'import { Keq, KeqRequest } from "keq"',
-      ...$operations
-    ].join("\n");
-  }
-  render() {
-    const moduleName = changeCase2.pascalCase(this.document.module.name);
-    const $dependencies = this.renderDependencies();
-    const $operations = this.document.operations.map((operation) => OperationDefinitionTransformer.toNestjsMethod(operation, {
-      esm: this.options.esm
-    })).join("\n\n");
-    return [
-      "/* @anchor:file:start */",
-      "",
-      $dependencies,
-      "",
-      "@Injectable()",
-      `export class ${moduleName}Client {`,
-      `  private readonly logger = new Logger(${moduleName}Client.name)`,
-      "",
-      "  constructor(",
-      "    // @anchor:client-constructor-parameters:start",
-      "    private readonly request: KeqRequest,",
-      "    // @anchor:client-constructor-parameters:end",
-      "  ) {}",
-      "",
-      indent(2, $operations),
-      "}",
-      "",
-      "/* @anchor:file:end */"
-    ].filter(R19.isNotNil).join("\n");
-  }
-};
-
-// src/transformers/api-document/nestjs-module.renderer.ts
-var changeCase3 = __toESM(require("change-case"), 1);
-var NestjsModuleRenderer = class {
-  constructor(document, options) {
-    this.document = document;
-    this.options = options;
-  }
-  render() {
-    const moduleName = changeCase3.pascalCase(this.document.module.name);
-    const clientFilepath = this.options.getNestjsClientFilepath(this.document).replace(/(\.ts|\.mts|\.cts|\.js|\.cjs|\.mjs)?$/, this.options.esm ? ".js" : "");
-    return [
-      "/* @anchor:file:start */",
-      'import { Module, Inject, ConfigurableModuleBuilder, Global } from "@nestjs/common"',
-      'import { KeqRequest } from "keq"',
-      'import { KeqModuleOptions } from "@keq-request/nestjs"',
-      `import { ${moduleName}Client } from "${clientFilepath}"`,
-      "",
-      "",
-      "const { ConfigurableModuleClass, MODULE_OPTIONS_TOKEN, OPTIONS_TYPE, ASYNC_OPTIONS_TYPE } = new ConfigurableModuleBuilder<KeqModuleOptions>().build()",
-      "",
-      "@Global()",
-      "@Module({",
-      "  imports: [],",
-      "  controllers: [],",
-      `  providers: [${moduleName}Client],`,
-      `  exports: [${moduleName}Client],`,
-      "})",
-      `export class ${moduleName}Module extends ConfigurableModuleClass {`,
-      "",
-      "  constructor(",
-      "    @Inject(MODULE_OPTIONS_TOKEN) private readonly options: KeqModuleOptions,",
-      "    private readonly request: KeqRequest,",
-      "  ) {",
-      "    super()",
-      "  }",
-      "",
-      "  onModuleInit() {",
-      "    if (this.options.middlewares) {",
-      "      for (const middleware of this.options.middlewares) {",
-      "        this.request.use(middleware)",
-      "      }",
-      "    }",
-      "  }",
-      "}",
-      "",
-      "/* @anchor:file:end */"
-    ].join("\n");
-  }
-};
-
-// src/transformers/api-document/api-document.transformer.ts
-var ApiDocumentTransformer = class {
-  static toNestjsModule(document, options) {
-    return new NestjsModuleRenderer(document, options).render();
-  }
-  static toNestjsClient(document, options) {
-    return new NestjsClientRenderer(document, options).render();
-  }
-};
-
-// src/plugins/generate-declaration/generators/schema-declaration/schema.generator.ts
-var R20 = __toESM(require("ramda"), 1);
-var path8 = __toESM(require("path"), 1);
-var changeCase4 = __toESM(require("change-case"), 1);
-
-// src/plugins/generate-declaration/constants/metadata-storage.ts
-var MetadataStorage2 = /* @__PURE__ */ new WeakMap();
-
-// src/plugins/generate-declaration/generators/schema-declaration/schema.generator.ts
-var SCHEMA_GENERATOR = "schemaGenerator";
-var SchemaDeclarationGenerator = class _SchemaDeclarationGenerator {
-  async compile(compiler, task) {
-    const context = compiler.context;
-    const metadata = MetadataStorage2.get(compiler);
-    const rc = context.rc;
-    const documents = context.documents;
-    const schemaDefinitions = documents.flatMap((document) => document.schemas);
-    const artifactMap = new Map(
-      await Promise.all(
-        schemaDefinitions.map(async (schemaDefinition) => [
-          schemaDefinition,
-          await metadata.hooks.afterSchemaDeclarationArtifactGenerated.promise(
-            this.generateSchemaDefinitionsArtifact(schemaDefinition, rc),
-            schemaDefinition,
-            task
-          )
-        ])
-      )
-    );
-    const entrypoints = R20.collectBy(
-      (schemaDefinition) => schemaDefinition.module.name,
-      schemaDefinitions
-    ).map((schemaDefinitions2) => [
-      schemaDefinitions2[0].module,
-      schemaDefinitions2.map((schemaDefinition) => artifactMap.get(schemaDefinition)).filter((artifact) => Boolean(artifact))
-    ]).map(([moduleDefinition, artifacts]) => this.generateEntrypointArtifact(
-      moduleDefinition,
-      artifacts,
-      rc
-    ));
-    return [...artifactMap.values(), ...entrypoints];
-  }
-  generateSchemaDefinitionsArtifact(schemaDefinition, rc) {
-    const filepath = _SchemaDeclarationGenerator.getSchemaDefinitionArtifactFilepath(schemaDefinition, rc.fileNamingStyle);
-    const dirpath = path8.dirname(filepath);
-    const artifact = new Artifact({
-      id: _SchemaDeclarationGenerator.getSchemaDefinitionArtifactId(schemaDefinition),
-      filepath,
-      content: SchemaDefinitionTransformer.toDeclaration(
-        schemaDefinition,
-        {
-          esm: rc.esm,
-          getDependentSchemaDefinitionFilepath(dependentSchemaDefinition) {
-            const relativePath = path8.relative(
-              dirpath,
-              _SchemaDeclarationGenerator.getSchemaDefinitionArtifactFilepath(dependentSchemaDefinition, rc.fileNamingStyle)
-            );
-            return relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
-          }
-        }
-      ),
-      extensionName: ".schema.ts"
-    });
-    return artifact;
-  }
-  generateEntrypointArtifact(moduleDefinition, exports2, rc) {
-    const filepath = _SchemaDeclarationGenerator.getEntrypointArtifactFilepath(moduleDefinition, rc.fileNamingStyle);
-    const dirpath = path8.dirname(filepath);
-    const artifact = new Artifact({
-      id: _SchemaDeclarationGenerator.getEntrypointArtifactId(moduleDefinition),
-      filepath,
-      content: EntrypointTransformer.toTypescript(exports2, { dirpath })
-    });
-    return artifact;
-  }
-  static getEntrypointArtifactFilepath(moduleDefinition, fileNamingStyle) {
-    return [
-      ".",
-      changeCase4[fileNamingStyle](moduleDefinition.name),
-      "types",
-      "components",
-      "schemas",
-      "index.ts"
-    ].join("/");
-  }
-  static getEntrypointArtifactId(moduleDefinition) {
-    return `${moduleDefinition.address}/components/schemas/entrypoint?generator=${SCHEMA_GENERATOR}`;
-  }
-  static getSchemaDefinitionArtifactFilepath(schemaDefinition, fileNamingStyle) {
-    const filename = `${changeCase4[fileNamingStyle](schemaDefinition.name)}.schema.ts`;
-    return [
-      ".",
-      changeCase4[fileNamingStyle](schemaDefinition.module.name),
-      "types",
-      "components",
-      "schemas",
-      filename
-    ].join("/");
-  }
-  static getSchemaDefinitionArtifactId(schemaDefinition) {
-    return `${schemaDefinition.id}?generator=${SCHEMA_GENERATOR}`;
-  }
-};
-
-// src/plugins/generate-declaration/generators/operation-declaration/operation.generator.ts
-var OPERATION_GENERATOR = "operationDeclarationGenerator";
-var OperationDeclarationGenerator = class _OperationDeclarationGenerator {
-  async compile(compiler, task) {
-    const context = compiler.context;
-    const metadata = MetadataStorage2.get(compiler);
-    const rc = context.rc;
-    const documents = context.documents;
-    const operationDefinitions = documents.flatMap((document) => document.operations);
-    const artifactMap = new Map(
-      await Promise.all(
-        operationDefinitions.map(async (operationDefinition) => [
-          operationDefinition,
-          await metadata.hooks.afterOperationDeclarationArtifactGenerated.promise(
-            this.generateOperationDefinitionArtifact(operationDefinition, rc),
-            operationDefinition,
-            task
-          )
-        ])
-      )
-    );
-    return Array.from(artifactMap.values());
-  }
-  generateOperationDefinitionArtifact(operationDefinition, rc) {
-    const filepath = _OperationDeclarationGenerator.getOperationDefinitionArtifactFilepath(operationDefinition, rc.fileNamingStyle);
-    const dirpath = path9.dirname(filepath);
-    const artifact = new Artifact({
-      id: _OperationDeclarationGenerator.getOperationDefinitionArtifactId(operationDefinition),
-      filepath,
-      content: OperationDefinitionTransformer.toDeclaration(
-        operationDefinition,
-        {
-          esm: rc.esm,
-          getDependentSchemaDefinitionFilepath(dependentSchemaDefinition) {
-            const relativePath = path9.relative(
-              dirpath,
-              SchemaDeclarationGenerator.getSchemaDefinitionArtifactFilepath(dependentSchemaDefinition, rc.fileNamingStyle)
-            );
-            return relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
-          }
-        }
-      ),
-      extensionName: ".type.ts"
-    });
-    return artifact;
-  }
-  generateEntrypointArtifact(moduleDefinition, exports2, rc) {
-    const filepath = _OperationDeclarationGenerator.getEntrypointArtifactFilepath(moduleDefinition, rc.fileNamingStyle);
-    const dirpath = path9.dirname(filepath);
-    const artifact = new Artifact({
-      id: _OperationDeclarationGenerator.getEntrypointArtifactId(moduleDefinition),
-      filepath,
-      content: EntrypointTransformer.toTypescript(exports2, { dirpath })
-    });
-    return artifact;
-  }
-  static getOperationDefinitionArtifactFilepath(operationDefinition, fileNamingStyle) {
-    const filename = `${changeCase5[fileNamingStyle](operationDefinition.operationId)}.type.ts`;
-    const filepath = [
-      ".",
-      changeCase5[fileNamingStyle](operationDefinition.module.name),
-      "types",
-      "operations",
-      filename
-    ].join("/");
-    return filepath;
-  }
-  static getOperationDefinitionArtifactId(operationDefinition) {
-    return `${operationDefinition.id}?generator=${OPERATION_GENERATOR}`;
-  }
-  static getEntrypointArtifactFilepath(moduleDefinition, fileNamingStyle) {
-    return [
-      ".",
-      changeCase5[fileNamingStyle](moduleDefinition.name),
-      "types",
-      "operations",
-      "index.ts"
-    ].join("/");
-  }
-  static getEntrypointArtifactId(moduleDefinition) {
-    return `${moduleDefinition.address}/paths/entrypoint?generator=${OPERATION_GENERATOR}`;
-  }
-};
-
-// src/plugins/generate-declaration/generate-declaration.plugin.ts
-var DECLARATION_GENERATOR = "declarationGenerator";
-var GenerateDeclarationPlugin = class _GenerateDeclarationPlugin {
-  name = DECLARATION_GENERATOR;
-  operationGenerator = new OperationDeclarationGenerator();
-  schemaGenerator = new SchemaDeclarationGenerator();
-  constructor() {
-  }
-  apply(compiler) {
-    _GenerateDeclarationPlugin.register(compiler);
-    compiler.hooks.compile.tapPromise(_GenerateDeclarationPlugin.name, async (task) => {
-      compiler.context.artifacts?.push(
-        ...await this.schemaGenerator.compile(compiler, task),
-        ...await this.operationGenerator.compile(compiler, task)
-      );
-    });
-  }
-  static register(compiler) {
-    if (!MetadataStorage2.has(compiler)) {
-      MetadataStorage2.set(compiler, {
-        hooks: {
-          afterEntrypointArtifactGenerated: new import_tapable.AsyncSeriesWaterfallHook(["artifact", "task"]),
-          afterSchemaDeclarationArtifactGenerated: new import_tapable.AsyncSeriesWaterfallHook(["artifact", "schemaDefinition", "task"]),
-          afterOperationDeclarationArtifactGenerated: new import_tapable.AsyncSeriesWaterfallHook(["artifact", "operationDefinition", "task"])
-        }
-      });
-    }
-    return MetadataStorage2.get(compiler);
-  }
-  static of(compiler) {
-    return this.register(compiler);
-  }
-};
-
-// src/plugins/generate-micro-function/generators/request/request.generator.ts
-var MICRO_FUNCTION_REQUEST_GENERATOR = "microFunctionRequestGenerator";
-var RequestGenerator = class _RequestGenerator {
-  generateRequestArtifact() {
-    const content = [
-      "/* @anchor:file:start */",
-      "",
-      'import { KeqRequest } from "keq"',
-      "",
-      "/* @anchor:request-declaration */",
-      "export const request = new KeqRequest()",
-      "",
-      "/* @anchor:file:end */"
-    ].join("\n");
-    return new Artifact({
-      id: _RequestGenerator.getRequestArtifactId(),
-      filepath: _RequestGenerator.getRequestArtifactFilepath(),
-      content
-    });
-  }
-  // eslint-disable-next-line @typescript-eslint/require-await
-  async compile(compiler, task) {
-    return [
-      this.generateRequestArtifact()
-    ];
-  }
-  static getRequestArtifactFilepath() {
-    return "./request.ts";
-  }
-  static getRequestArtifactId() {
-    return `request?generator=${MICRO_FUNCTION_REQUEST_GENERATOR}`;
-  }
-};
-
-// src/plugins/generate-micro-function/generators/micro_function/micro-function.generator.ts
-var MICRO_FUNCTION_GENERATOR = "microFunctionGenerator";
-var MicroFunctionGenerator = class _MicroFunctionGenerator {
-  async compile(compiler, task) {
-    const metadata = MetadataStorage.get(compiler);
-    const context = compiler.context;
-    const rc = context.rc;
-    const documents = context.documents;
-    const operationDefinitions = documents.flatMap((document) => document.operations);
-    const artifactMap = new Map(
-      await Promise.all(
-        operationDefinitions.map(async (operationDefinition) => [
-          operationDefinition,
-          await metadata.hooks.afterMicroFunctionArtifactGenerated.promise(
-            this.generateOperationDefinitionArtifact(operationDefinition, rc),
-            operationDefinition,
-            task
-          )
-        ])
-      )
-    );
-    const entrypoints = await Promise.all(
-      R21.collectBy(
-        (operationDefinition) => operationDefinition.module.name,
-        operationDefinitions
-      ).map((operationDefinitions2) => [
-        operationDefinitions2[0].module,
-        operationDefinitions2.map((operationDefinition) => artifactMap.get(operationDefinition)).filter((artifact) => Boolean(artifact))
-      ]).map(async ([moduleDefinition, artifacts]) => await metadata.hooks.afterEntrypointArtifactGenerated.promise(
-        this.generateEntrypointArtifact(
-          moduleDefinition,
-          artifacts,
-          rc
-        ),
-        task
-      ))
-    );
-    return [...entrypoints, ...artifactMap.values()];
-  }
-  generateOperationDefinitionArtifact(operationDefinition, rc) {
-    const filepath = _MicroFunctionGenerator.getOperationDefinitionArtifactFilepath(operationDefinition, rc.fileNamingStyle);
-    const dirpath = path10.dirname(filepath);
-    const artifact = new Artifact({
-      id: _MicroFunctionGenerator.getOperationDefinitionArtifactId(operationDefinition),
-      filepath,
-      content: OperationDefinitionTransformer.toMicroFunction(operationDefinition, {
-        esm: rc.esm,
-        getOperationDefinitionDeclarationFilepath(operationDefinition2) {
-          const relativePath = path10.relative(
-            dirpath,
-            OperationDeclarationGenerator.getOperationDefinitionArtifactFilepath(operationDefinition2, rc.fileNamingStyle)
-          );
-          return relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
-        },
-        getRequestFilepath() {
-          const relativePath = path10.relative(
-            dirpath,
-            RequestGenerator.getRequestArtifactFilepath()
-          );
-          return relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
-        }
-      }),
-      extensionName: ".type.ts"
-    });
-    return artifact;
-  }
-  generateEntrypointArtifact(moduleDefinition, exports2, rc) {
-    const filepath = _MicroFunctionGenerator.getEntrypointArtifactFilepath(moduleDefinition, rc.fileNamingStyle);
-    const dirpath = filepath.substring(0, filepath.lastIndexOf("/"));
-    const artifact = new Artifact({
-      id: _MicroFunctionGenerator.getEntrypointArtifactId(moduleDefinition),
-      filepath,
-      content: EntrypointTransformer.toTypescript(exports2, { dirpath })
-    });
-    return artifact;
-  }
-  static getOperationDefinitionArtifactFilepath(operationDefinition, fileNamingStyle) {
-    const filename = `${changeCase6[fileNamingStyle](operationDefinition.operationId)}.fn.ts`;
-    const filepath = [
-      ".",
-      changeCase6[fileNamingStyle](operationDefinition.module.name),
-      "operations",
-      filename
-    ].join("/");
-    return filepath;
-  }
-  static getOperationDefinitionArtifactId(operationDefinition) {
-    return `${operationDefinition.id}?generator=${MICRO_FUNCTION_GENERATOR}`;
-  }
-  static getEntrypointArtifactFilepath(moduleDefinition, fileNamingStyle) {
-    return [
-      ".",
-      changeCase6[fileNamingStyle](moduleDefinition.name),
-      "operations",
-      "index.ts"
-    ].join("/");
-  }
-  static getEntrypointArtifactId(moduleDefinition) {
-    return `${moduleDefinition.address}/paths/entrypoint?generator=${MICRO_FUNCTION_GENERATOR}`;
-  }
-};
-
-// src/plugins/generate-micro-function/generate-micro-function.plugin.ts
-var GenerateMicroFunctionPlugin = class _GenerateMicroFunctionPlugin {
-  microFunctionGenerator = new MicroFunctionGenerator();
-  requestGenerator = new RequestGenerator();
-  apply(compiler) {
-    _GenerateMicroFunctionPlugin.register(compiler);
-    compiler.hooks.compile.tapPromise(_GenerateMicroFunctionPlugin.name, async (task) => {
-      const artifacts = [
-        ...await this.requestGenerator.compile(compiler, task),
-        ...await this.microFunctionGenerator.compile(compiler, task)
-      ];
-      compiler.context.artifacts.push(...artifacts);
-    });
-  }
-  static register(compiler) {
-    if (!MetadataStorage.has(compiler)) {
-      MetadataStorage.set(compiler, {
-        hooks: {
-          afterEntrypointArtifactGenerated: new import_tapable2.AsyncSeriesWaterfallHook(["artifact", "task"]),
-          afterMicroFunctionArtifactGenerated: new import_tapable2.AsyncSeriesWaterfallHook(["artifact", "operationDefinition", "task"])
-        }
-      });
-    }
-    return MetadataStorage.get(compiler);
-  }
-  static of(compiler) {
-    return this.register(compiler);
-  }
-};
-
-// src/plugins/generate-nestjs-module/generate-nestjs-module.ts
-var import_tapable3 = require("tapable");
-
-// src/plugins/generate-nestjs-module/constants/metadata-storage.ts
-var MetadataStorage3 = /* @__PURE__ */ new WeakMap();
-
-// src/plugins/generate-nestjs-module/generators/nestjs-module.generator.ts
-var path11 = __toESM(require("path"), 1);
-var changeCase7 = __toESM(require("change-case"), 1);
-var NESTJS_MODULE_GENERATOR = "nestjs-module-generator";
-var NestjsModuleGenerator = class _NestjsModuleGenerator {
-  generateNestjsModuleArtifact(document, rc) {
-    const filepath = _NestjsModuleGenerator.getNestjsModuleArtifactFilepath(document, rc.fileNamingStyle);
-    const dirname6 = path11.dirname(filepath);
-    const artifact = new Artifact({
-      id: _NestjsModuleGenerator.getNestjsModuleArtifactId(document),
-      filepath,
-      content: ApiDocumentTransformer.toNestjsModule(document, {
-        esm: rc.esm,
-        getNestjsClientFilepath(document2) {
-          const relativePath = path11.relative(
-            dirname6,
-            _NestjsModuleGenerator.getNestjsClientArtifactFilepath(document2, rc.fileNamingStyle)
-          );
-          return relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
-        }
-      })
-    });
-    return artifact;
-  }
-  generateNestjsClientArtifact(document, rc) {
-    const filepath = _NestjsModuleGenerator.getNestjsClientArtifactFilepath(document, rc.fileNamingStyle);
-    const dirpath = path11.dirname(filepath);
-    const artifact = new Artifact({
-      id: _NestjsModuleGenerator.getNestjsClientArtifactId(document),
-      filepath,
-      content: ApiDocumentTransformer.toNestjsClient(document, {
-        esm: rc.esm,
-        getOperationDefinitionDeclarationFilepath(operationDefinition) {
-          const relativePath = path11.relative(
-            dirpath,
-            OperationDeclarationGenerator.getOperationDefinitionArtifactFilepath(operationDefinition, rc.fileNamingStyle)
-          );
-          return relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
-        }
-      })
-    });
-    return artifact;
-  }
-  async compile(compiler, task) {
-    const metadata = MetadataStorage3.get(compiler);
-    const rc = compiler.context.rc;
-    const documents = compiler.context.documents;
-    const nestjsModuleArtifacts = await Promise.all(
-      documents.map((document) => metadata.hooks.afterNestjsModuleArtifactGenerated.promise(
-        this.generateNestjsModuleArtifact(document, rc),
-        document,
-        task
-      ))
-    );
-    const nestjsClientArtifacts = await Promise.all(
-      documents.map((document) => metadata.hooks.afterNestjsModuleArtifactGenerated.promise(
-        this.generateNestjsClientArtifact(document, rc),
-        document,
-        task
-      ))
-    );
-    return [...nestjsModuleArtifacts, ...nestjsClientArtifacts];
-  }
-  static getNestjsModuleArtifactFilepath(document, fileNamingStyle) {
-    const filename = `${changeCase7[fileNamingStyle](document.module.name)}.module.ts`;
-    const filepath = [
-      ".",
-      changeCase7[fileNamingStyle](document.module.name),
-      filename
-    ];
-    return filepath.join("/");
-  }
-  static getNestjsModuleArtifactId(document) {
-    return `${document.module.address}?generate=${NESTJS_MODULE_GENERATOR}`;
-  }
-  static getNestjsClientArtifactFilepath(document, fileNamingStyle) {
-    const filename = `${changeCase7[fileNamingStyle](document.module.name)}.client.ts`;
-    const filepath = [
-      ".",
-      changeCase7[fileNamingStyle](document.module.name),
-      filename
-    ];
-    return filepath.join("/");
-  }
-  static getNestjsClientArtifactId(document) {
-    return `${document.module.address}?generate=${NESTJS_MODULE_GENERATOR}-client`;
-  }
-};
-
-// src/plugins/generate-nestjs-module/generate-nestjs-module.ts
-var GenerateNestjsModulePlugin = class _GenerateNestjsModulePlugin {
-  nestjsModuleGenerator = new NestjsModuleGenerator();
-  apply(compiler) {
-    _GenerateNestjsModulePlugin.register(compiler);
-    compiler.hooks.compile.tapPromise(_GenerateNestjsModulePlugin.name, async (task) => {
-      const artifacts = await this.nestjsModuleGenerator.compile(compiler, task);
-      compiler.context.artifacts.push(...artifacts);
-    });
-  }
-  static register(compiler) {
-    if (!MetadataStorage3.has(compiler)) {
-      MetadataStorage3.set(compiler, {
-        hooks: {
-          afterNestjsModuleArtifactGenerated: new import_tapable3.AsyncSeriesWaterfallHook(["artifact", "document", "task"])
-        }
-      });
-    }
-    return MetadataStorage3.get(compiler);
-  }
-  static of(compiler) {
-    return MetadataStorage3.get(compiler);
-  }
-};
-
-// src/plugins/chinese-to-pinyin/chinese-to-pinyin.plugin.ts
-var import_swagger_fix = require("swagger-fix");
-
-// src/plugins/download-http-file/download-http-file.plugin.ts
-var validUrl = __toESM(require("valid-url"), 1);
-var DownloadHttpFilePlugin = class _DownloadHttpFilePlugin {
-  apply(compiler) {
-    compiler.hooks.download.tapPromise(_DownloadHttpFilePlugin.name, async (address, task) => {
-      if (!validUrl.isUri(address)) return void 0;
-      const content = await this.download(address);
-      const spec = this.deserialize(content);
-      return JSON.stringify(spec);
-    });
-  }
-  async download(address) {
-    try {
-      const res = await fetch(address);
-      if (res.status >= 400) throw new Error(`failed with status code ${res.status}`);
-      return await res.text();
-    } catch (e) {
-      if (e instanceof Error) {
-        e.message = `Unable get the openapi/swagger file from ${address}: ${e.message}`;
-      }
-      throw e;
-    }
-  }
-  deserialize(content) {
-    const json = JSON.parse(content);
-    const spec = OpenapiUtils.to3_1(json);
-    return spec;
-  }
-};
-
-// src/plugins/download-local-file/download-local-file.plugin.ts
-var path12 = __toESM(require("path"), 1);
-var fs5 = __toESM(require("fs/promises"), 1);
-var yaml = __toESM(require("js-yaml"), 1);
-var DownloadLocalFilePlugin = class _DownloadLocalFilePlugin {
-  apply(compiler) {
-    compiler.hooks.download.tapPromise(_DownloadLocalFilePlugin.name, async (address, task) => {
-      if (!address.startsWith("./") && !address.startsWith("/") && !address.startsWith("../")) return void 0;
-      const fileExt = path12.extname(address);
-      const content = await fs5.readFile(address, "utf8");
-      if ([".yml", ".yaml"].includes(fileExt)) {
-        const value = yaml.load(content);
-        return JSON.stringify(OpenapiUtils.to3_1(value));
-      } else if (fileExt === ".json") {
-        return JSON.stringify(OpenapiUtils.to3_1(JSON.parse(content)));
-      }
-    });
-  }
-};
-
-// src/plugins/shaking/shaking.plugin.ts
-var import_openapi_shaking = require("@opendoc/openapi-shaking");
-var ShakingPlugin = class _ShakingPlugin {
-  apply(compiler) {
-    compiler.hooks.beforeCompile.tap(_ShakingPlugin.name, (task) => {
-      const matcher = compiler.context.matcher;
-      const documents = compiler.context.documents;
-      compiler.context.documents = documents.map((document) => this.shaking(compiler, document)).filter((document) => !document.isEmpty()).filter((document) => !matcher.isModuleIgnored(document.module));
-    });
-  }
-  shaking(compiler, document) {
-    const rc = compiler.context.rc;
-    const matcher = compiler.context.matcher;
-    const isAccepted = (pathname, method, operation) => {
-      if (!SupportedMethods.includes(method)) return false;
-      return !matcher.isOperationIgnored(new OperationDefinition({
-        method,
-        pathname,
-        operation,
-        module: document.module,
-        document
-      }));
-    };
-    const sharkedSwagger = (0, import_openapi_shaking.openapiShakingSync)(
-      document.specification,
-      isAccepted,
-      { tolerant: rc.tolerant }
-    );
-    return new ApiDocumentV3_1(
-      sharkedSwagger,
-      new ModuleDefinition(
-        document.module.name,
-        `file://${document.module.name}.v3_1.sharked.json`
-      )
-    );
-  }
-};
-
-// src/plugins/terminal-select/utils/select-operation-definitions.ts
-var import_inquirer_select_pro = require("inquirer-select-pro");
-var import_prompt_adapter_inquirer = require("@listr2/prompt-adapter-inquirer");
-async function selectOperationDefinitions(task, operationDefinitions) {
-  const selectedOperationDefinitions = await task.prompt(import_prompt_adapter_inquirer.ListrInquirerPromptAdapter).run(
-    import_inquirer_select_pro.select,
-    {
-      message: "Select Pathname",
-      defaultValue: [],
-      options: (input) => {
-        const items = operationDefinitions.map((op) => ({ name: `${op.module.name} ${op.method.toUpperCase()} ${op.pathname}`, value: op }));
-        if (!input) return items;
-        const keys2 = input.trim().toLowerCase().split(/\s+/);
-        return items.filter((i) => {
-          const name = i.name.toLowerCase();
-          return keys2.every((q) => name.includes(q));
-        });
-      }
-    }
-  );
-  return selectedOperationDefinitions;
+//#endregion
+//#region src/cli.ts
+if (semver.default.lt(process.version, "20.0.0")) throw new Error("Node.js version must be greater than 20");
+const program = new commander.Command();
+registerBuildCommand(program);
+registerFilterCommand(program);
+registerListCommand(program);
+registerApisCommand(program);
+registerMockCommand(program);
+registerInitCommand(program);
+registerSearchCommand(program);
+registerMcpCommand(program);
+async function main() {
+	program.on("command:*", function(operands) {
+		throw new Error(`Unknown command '${String(operands[0])}'`);
+	});
+	try {
+		await program.parseAsync(process.argv);
+	} catch (err) {
+		if (process.argv.includes("--debug")) console.error(err);
+		else require_logger.logger.error(err instanceof Error ? err.message : String(err));
+		process.exit(1);
+	}
 }
+main();
+//#endregion
 
-// src/plugins/terminal-select/terminal-select.plugin.ts
-var TerminalSelectPlugin = class _TerminalSelectPlugin {
-  constructor(options) {
-    this.options = options;
-  }
-  apply(compiler) {
-    compiler.hooks.afterDownload.tapPromise(_TerminalSelectPlugin.name, async (task) => {
-      const context = compiler.context;
-      const matcher = context.matcher;
-      const documents = context.documents;
-      const operationDefinitions = documents.flatMap((document) => document.operations);
-      const selectedOperationDefinitions = await selectOperationDefinitions(task, operationDefinitions);
-      if (this.options.clear) {
-        matcher.append({
-          persist: false,
-          ignore: true,
-          moduleName: "*",
-          operationMethod: "*",
-          operationPathname: "*"
-        });
-      }
-      for (const op of selectedOperationDefinitions) {
-        matcher.append({
-          persist: !!this.options.persist,
-          ignore: this.options.mode === "add",
-          moduleName: op.module.name,
-          operationMethod: op.method,
-          operationPathname: op.pathname
-        });
-      }
-    });
-  }
-};
-
-// src/plugins/initialize/initialize.plugin.ts
-var R23 = __toESM(require("ramda"), 1);
-var InitializePlugin = class _InitializePlugin {
-  constructor(options) {
-    this.options = options;
-  }
-  apply(compiler) {
-    compiler.hooks.setup.tap(_InitializePlugin.name, (task) => {
-      new DownloadHttpFilePlugin().apply(compiler);
-      new DownloadLocalFilePlugin().apply(compiler);
-      new GenerateDeclarationPlugin().apply(compiler);
-      if (this.options.build) {
-        new ShakingPlugin().apply(compiler);
-      }
-      if (this.options.interactive) {
-        new TerminalSelectPlugin(
-          typeof this.options.interactive === "object" ? this.options.interactive : { mode: "except" }
-        ).apply(compiler);
-      }
-      const rc = compiler.context.rc;
-      if (rc.mode === "micro-function") {
-        new GenerateMicroFunctionPlugin().apply(compiler);
-      } else if (rc.mode === "nestjs-module") {
-        new GenerateNestjsModulePlugin().apply(compiler);
-      }
-      if (rc.plugins && rc.plugins.length) {
-        for (const plugin of rc.plugins) {
-          plugin.apply(compiler);
-        }
-      }
-    });
-    if (this.options.includes && this.options.includes.length) {
-      const modulesIncludes = this.options.includes;
-      compiler.hooks.afterSetup.tap(_InitializePlugin.name, (task) => {
-        const rc = compiler.context.rc;
-        const matcher = compiler.context.matcher;
-        const notExistModules = modulesIncludes.filter((moduleName) => !(moduleName in rc.modules));
-        if (notExistModules.length) {
-          throw new Error(`Cannot find module(s) ${notExistModules.join(", ")} in config file.`);
-        }
-        const ignoredModules = R23.difference(R23.keys(rc.modules), modulesIncludes);
-        for (const moduleName of ignoredModules) {
-          matcher.append({
-            persist: false,
-            ignore: true,
-            moduleName,
-            operationMethod: "*",
-            operationPathname: "*"
-          });
-        }
-      });
-    }
-  }
-};
-
-// src/plugins/overwrite-query-options/overwrite-query-options.plugin.ts
-var QsArrayFormatUnion = Object.values(QsArrayFormat);
-
-// src/compiler/compiler.ts
-var Compiler = class {
-  constructor(options) {
-    this.options = options;
-    for (const hook of Object.values(this.hooks)) {
-      hook.intercept(perfectErrorMessage());
-    }
-    this.hooks.afterSetup.intercept(printInformation(0));
-    this.hooks.afterPersist.intercept(printInformation(0));
-    new InitializePlugin({
-      build: options.build,
-      interactive: options.interactive,
-      includes: options.includes
-    }).apply(this);
-  }
-  context = {};
-  hooks = {
-    setup: new import_tapable4.AsyncParallelHook(["task"]),
-    afterSetup: new import_tapable4.AsyncSeriesHook(["task"]),
-    beforeDownload: new import_tapable4.AsyncSeriesHook(["task"]),
-    download: new import_tapable4.AsyncSeriesBailHook(["address", "moduleDefinition", "task"]),
-    afterDownload: new import_tapable4.AsyncSeriesHook(["task"]),
-    beforeCompile: new import_tapable4.AsyncSeriesHook(["task"]),
-    compile: new import_tapable4.AsyncParallelHook(["task"]),
-    afterCompile: new import_tapable4.AsyncSeriesHook(["task"]),
-    beforePersist: new import_tapable4.AsyncSeriesHook(["task"]),
-    persist: new import_tapable4.AsyncParallelHook(["task"]),
-    afterPersist: new import_tapable4.AsyncSeriesHook(["task"]),
-    done: new import_tapable4.SyncHook()
-  };
-  async run() {
-    const options = this.options;
-    const tasks = new import_listr22.Listr(
-      [
-        createSetupTask(this, options),
-        createDownloadTask(this, { skipIgnoredModules: !options.interactive }),
-        createCompileTask(this, { enabled: !!options.build }),
-        createPersistTask(this)
-      ],
-      {
-        concurrent: false,
-        renderer: "default",
-        rendererOptions: {
-          suffixSkips: true,
-          collapseSubtasks: false,
-          collapseErrors: false
-        }
-      }
-    );
-    await tasks.run(this.context);
-    await this.hooks.done.promise();
-  }
-};
-
-// src/cli.ts
-if (import_semver.default.lt(process.version, "20.0.0")) {
-  throw new Error("Node.js version must be greater than 20");
-}
-var program = new import_commander.Command();
-program.command("build").option("-c --config <config>", "The keq-cli config file").option("--module <modules...>", "Filter module(s) to generate").option("--debug", "Print debug information").option("--tolerant", "Tolerate wrong swagger/openapi structure").option("-i --interactive", "Interactive select the scope of generation").action(async (options) => {
-  const compiler = new Compiler({
-    build: true,
-    config: options.config,
-    includes: options.module,
-    debug: !!options.debug,
-    tolerant: !!options.tolerant,
-    interactive: !!options.interactive && {
-      mode: "except",
-      clear: true
-    }
-  });
-  await compiler.run();
-});
-program.command("ignore").addArgument(
-  new import_commander.Argument("<mode>", "The ignore mode").choices(["all", "add", "except"]).argRequired()
-).option("-c --config <config>", "The keq-cli config file").option("--debug", "Print debug information").option("--module <modules...>").option("--build", "Build after updating .keqignore file").addOption(
-  new import_commander.Option("--method <method>", "Only generate files of the specified operation method").choices([
-    ...SupportedMethods,
-    ...SupportedMethods.map((method) => method.toUpperCase())
-  ])
-).option("--pathname <pathnames>", "Only generate files of the specified operation pathname").option("-i --interactive", "Interactive select the scope of generation").action(async (mode, options) => {
-  let compiler;
-  if (mode === "all") {
-    if (options.build) throw new Error("'--build' cannot be used with 'all' mode");
-    compiler = new Compiler({
-      build: false,
-      config: options.config,
-      includes: options.module,
-      debug: !!options.debug,
-      interactive: false,
-      ignore: {
-        rules: [{
-          persist: true,
-          ignore: true,
-          moduleName: "*",
-          operationMethod: "*",
-          operationPathname: "*"
-        }]
-      }
-    });
-  } else if (options.interactive) {
-    if (options.interactive) {
-      if (options.method) throw new Error("'--method' cannot be used with '--interactive'");
-      if (options.pathname) throw new Error("'--pathname' cannot be used with '--interactive'");
-    }
-    compiler = new Compiler({
-      build: !!options.build,
-      config: options.config,
-      includes: options.module,
-      debug: !!options.debug,
-      interactive: {
-        mode,
-        persist: true
-      }
-    });
-  } else {
-    if (!options.method && !options.pathname) {
-      throw new Error("at least one of '-i --interactive', '--method' or '--pathname' must be specified");
-    }
-    const moduleNames = options.module || ["*"];
-    compiler = new Compiler({
-      build: !!options.build,
-      config: options.config,
-      debug: !!options.debug,
-      includes: options.module,
-      ignore: {
-        rules: moduleNames.map((moduleNames2) => ({
-          persist: true,
-          ignore: mode === "add",
-          moduleName: moduleNames2,
-          operationMethod: options.method,
-          operationPathname: options.pathname
-        }))
-      },
-      interactive: false
-    });
-  }
-  await compiler.run();
-});
-async function main5() {
-  program.on("command:*", function(operands) {
-    throw new Error(`Unknown command '${String(operands[0])}'`);
-  });
-  try {
-    await program.parseAsync(process.argv);
-  } catch (err) {
-    if (process.argv.includes("--debug")) {
-      console.error(err);
-    } else {
-      logger.error(err instanceof Error ? err.message : String(err));
-    }
-  }
-}
-void main5();
 //# sourceMappingURL=cli.cjs.map