@keq-request/cli 5.0.0-alpha.10 → 5.0.0-alpha.11

package/dist/cli.js

@@ -4,7 +4,27 @@
 import semver from "semver";
 import { Argument, Command, Option } from "commander";
 
-// src/tasks/index.ts
+// src/constants/supported-methods.ts
+var SupportedMethods = [
+  "get",
+  "post",
+  "put",
+  "delete",
+  "patch",
+  "head",
+  "options"
+];
+
+// src/utils/logger.ts
+import chalk from "chalk";
+var logger = {
+  log: (str) => console.log(chalk.green(str)),
+  warn: (str) => console.warn(chalk.yellow(str)),
+  error: (str) => console.error(chalk.red(str))
+};
+
+// src/compiler/compiler.ts
+import { AsyncSeriesHook, AsyncSeriesWaterfallHook, SyncHook } from "tapable";
 import { Listr } from "listr2";
 
 // src/tasks/setup/index.ts
@@ -81,7 +101,8 @@ var RuntimeConfig = Type2.Object({
   /**
    * Whether to tolerate wrong swagger structure
    */
-  tolerant: Type2.Optional(Type2.Boolean({ default: false }))
+  tolerant: Type2.Optional(Type2.Boolean({ default: false })),
+  plugins: Type2.Optional(Type2.Array(Type2.Any(), { default: [] }))
 });
 
 // src/utils/ignore-matcher.ts
@@ -232,9 +253,8 @@ function getProjectModuleSystem(pkgInfo) {
 
 // src/tasks/setup/index.ts
 var explore = cosmiconfig("keq");
-function createSetupTask(options) {
+function main(compiler, options) {
   return {
-    title: "Setup",
     task: async (context, task) => {
       const result = options?.config ? await explore.load(options.config) : await explore.search();
       if (!result || "isEmpty" in result && result.isEmpty) {
@@ -259,13 +279,23 @@ function createSetupTask(options) {
         const moduleSystem = getProjectModuleSystem(packageJsonInfo);
         rc.esm = moduleSystem === "esm";
       }
-      let filter2 = new IgnoreMatcher([]);
+      let matcher = new IgnoreMatcher([]);
       if (result.filepath) {
         const ignoreFilepath = path2.resolve(path2.dirname(result.filepath), ".keqignore");
         if (await fs3.exists(ignoreFilepath)) {
-          filter2 = await IgnoreMatcher.read(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
+        });
+      }
       if (options?.modules && options.modules.length) {
         const notExistModules = options.modules.filter((moduleName) => !(moduleName in rc.modules));
         if (notExistModules.length) {
@@ -273,7 +303,7 @@ function createSetupTask(options) {
         }
         const ignoredModules = R3.difference(R3.keys(rc.modules), options.modules);
         for (const moduleName of ignoredModules) {
-          filter2.append({
+          matcher.append({
             persist: false,
             ignore: true,
             moduleName,
@@ -282,10 +312,33 @@ function createSetupTask(options) {
           });
         }
       }
-      context.setup = { rc, matcher: filter2 };
+      context.setup = { rc, matcher };
+      if (rc.plugins && rc.plugins.length) {
+        for (const plugin of rc.plugins) {
+          plugin.apply(compiler);
+        }
+      }
     }
   };
 }
+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
+      }
+    )
+  };
+}
 
 // src/tasks/download/index.ts
 import { PRESET_TIMER } from "listr2";
@@ -311,17 +364,6 @@ import { upgrade, validate } from "@scalar/openapi-parser";
 // src/tasks/utils/api-document_v3_1.ts
 import * as R6 from "ramda";
 
-// src/constants/supported-methods.ts
-var SupportedMethods = [
-  "get",
-  "post",
-  "put",
-  "delete",
-  "patch",
-  "head",
-  "options"
-];
-
 // src/tasks/utils/operation-definition.ts
 import * as R5 from "ramda";
 
@@ -489,16 +531,8 @@ var OperationDefinition = class {
   }
 };
 
-// src/utils/logger.ts
-import chalk from "chalk";
-var logger = {
-  log: (str) => console.log(chalk.green(str)),
-  warn: (str) => console.warn(chalk.yellow(str)),
-  error: (str) => console.error(chalk.red(str))
-};
-
 // src/tasks/utils/api-document_v3_1.ts
-import OpenapiShaking from "@opendoc/openapi-shaking";
+import { openapiShakingSync } from "@opendoc/openapi-shaking";
 var ApiDocumentV3_1 = class _ApiDocumentV3_1 {
   module;
   swagger;
@@ -554,7 +588,7 @@ var ApiDocumentV3_1 = class _ApiDocumentV3_1 {
       });
       return filter2(operationDefinition);
     };
-    const sharkedSwagger = OpenapiShaking.openapiShakingSync(
+    const sharkedSwagger = openapiShakingSync(
       this.swagger,
       isAccepted,
       { tolerant: true }
@@ -748,8 +782,8 @@ function dereferenceDeep($ref, swagger) {
   const stack = [$ref];
   let value;
   while (true) {
-    const last = stack[stack.length - 1];
-    value = dereference(last, swagger);
+    const last2 = stack[stack.length - 1];
+    value = dereference(last2, swagger);
     if (JsonSchemaUtils.isRef(value)) {
       if (!stack.includes(value.$ref)) {
         stack.push(value.$ref);
@@ -860,11 +894,8 @@ var ApiDocument = class _ApiDocument {
 };
 
 // src/tasks/download/index.ts
-function createDownloadTask(options) {
+function main2(compiler, options) {
   return {
-    title: "Download",
-    enabled: options?.enabled,
-    skip: options?.skip,
     task: (context, task) => {
       if (!context.setup) {
         throw new Error("Please run setup task first.");
@@ -902,13 +933,28 @@ function createDownloadTask(options) {
     }
   };
 }
-
-// src/tasks/validate/index.ts
-function createValidateTask(options) {
+function createDownloadTask(compiler, options) {
   return {
-    title: "Validate",
+    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/tasks/validate/index.ts
+function main3() {
+  return {
     task: (context, task) => {
       if (!context.setup) throw new Error("Please run setup task first.");
       if (!context.downloaded) throw new Error("Please run download task first.");
@@ -945,13 +991,28 @@ ${errors?.map((e) => `  - ${e.message}`).join("\n")}`;
     }
   };
 }
-
-// src/tasks/shaking/index.ts
-function createShakingTask(options) {
+function createValidateTask(compiler, options) {
   return {
-    title: "Shaking",
+    title: "Validate",
     enabled: options?.enabled,
     skip: options?.skip,
+    task: (context, task) => task.newListr(
+      [
+        main3(),
+        {
+          task: (context2, task2) => compiler.hooks.afterValidate.promise(task2)
+        }
+      ],
+      {
+        concurrent: false
+      }
+    )
+  };
+}
+
+// src/tasks/shaking/index.ts
+function main4(compiler, options) {
+  return {
     task: (context, task) => {
       if (!context.setup) throw new Error("Please run setup task first.");
       if (!context.validated) throw new Error("Please run validate task first.");
@@ -989,15 +1050,31 @@ function createShakingTask(options) {
     }
   };
 }
+function createShakingTask(compiler, options) {
+  return {
+    title: "Shaking",
+    enabled: options?.enabled,
+    skip: options?.skip,
+    task: (context, task) => task.newListr(
+      [
+        main4(compiler, options),
+        {
+          task: (context2, task2) => compiler.hooks.afterShaking.promise(task2)
+        }
+      ],
+      {
+        concurrent: false
+      }
+    )
+  };
+}
 
 // src/tasks/persist/index.ts
 import * as path6 from "path";
 import fs6 from "fs-extra";
-function createPersistArtifactTask(options) {
+function createPersistArtifactTask() {
   return {
     title: "Write files",
-    enabled: options?.persistArtifacts,
-    skip: options?.skip,
     task: async (context, task) => {
       if (!context.setup) throw new Error("Please run setup task first.");
       if (!context.compiled) throw new Error("Please run compile task first.");
@@ -1008,21 +1085,21 @@ function createPersistArtifactTask(options) {
       }
       const total = artifacts.length;
       let completed = 0;
-      await Promise.all(artifacts.map(async (artifact) => {
+      const files = await Promise.all(artifacts.map(async (artifact) => {
         const realpath = `./${path6.join(rc.outdir, artifact.filepath)}`;
         await fs6.ensureFile(realpath);
         await fs6.writeFile(realpath, artifact.toCode({ esm: !!rc.esm }));
         completed += 1;
         task.output = `Persisted ${completed}/${total} files`;
+        return { path: path6.resolve(realpath) };
       }));
+      context.persisted = { files };
     }
   };
 }
-function createPersistIgnoreTask(options) {
+function createPersistIgnoreTask() {
   return {
     title: "Update .keqignore",
-    enabled: options?.persistIgnore,
-    skip: options?.skip,
     task: async (context, task) => {
       if (!context.setup) throw new Error("Please run setup task first.");
       const matcher = context.setup.matcher;
@@ -1030,15 +1107,12 @@ function createPersistIgnoreTask(options) {
     }
   };
 }
-function createPersistTask(options) {
+function main5() {
   return {
-    title: "Persist",
-    enabled: options?.enabled,
-    skip: options?.skip,
     task: (context, task) => task.newListr(
       [
-        createPersistArtifactTask(options),
-        createPersistIgnoreTask(options)
+        createPersistArtifactTask(),
+        createPersistIgnoreTask()
       ],
       {
         concurrent: true,
@@ -1049,8 +1123,29 @@ function createPersistTask(options) {
     )
   };
 }
+function createPersistTask(compiler, options) {
+  return {
+    title: "Persist",
+    enabled: options?.enabled,
+    skip: options?.skip,
+    task: (context, task) => task.newListr(
+      [
+        main5(),
+        {
+          task: (context2, task2) => compiler.hooks.afterPersist.promise(task2)
+        }
+      ],
+      {
+        concurrent: false
+      }
+    )
+  };
+}
 
 // src/tasks/compile/utils/compile-schema-definition.ts
+import * as R14 from "ramda";
+
+// src/renderer/json-schema/index.ts
 import * as R12 from "ramda";
 
 // src/renderer/utils/generate-schema.ts
@@ -1176,14 +1271,102 @@ async function jsonSchemaRenderer(schemaDefinition) {
   let $comment = generateComment(schemaDefinition.schema);
   if ($comment) $comment += "\n";
   if (typeof schemaDefinition.schema === "boolean") {
-    return `${$comment}type ${schemaDefinition.name} = unknown`;
+    return [
+      "/* @anchor:file:start */",
+      "",
+      $comment || void 0,
+      `type ${schemaDefinition.name} = unknown`,
+      "",
+      "/* @anchor:file:end */"
+    ].filter(R12.isNotNil).join("\n");
   }
   if (JsonSchemaUtils.isNonArray(schemaDefinition.schema) && schemaDefinition.schema.type === "object") {
-    return `${$comment}export interface ${schemaDefinition.name} ${generateSchema(schemaDefinition.schema)}`;
+    return [
+      "/* @anchor:file:start */",
+      "",
+      $comment || void 0,
+      `export interface ${schemaDefinition.name} ${generateSchema(schemaDefinition.schema)}`,
+      "",
+      "/* @anchor:file:end */"
+    ].filter(R12.isNotNil).join("\n");
   }
-  return `${$comment}export type ${schemaDefinition.name} = ${generateSchema(schemaDefinition.schema)}`;
+  return [
+    "/* @anchor:file:start */",
+    "",
+    $comment || void 0,
+    `export type ${schemaDefinition.name} = ${generateSchema(schemaDefinition.schema)}`,
+    "",
+    "/* @anchor:file:end */"
+  ].filter(R12.isNotNil).join("\n");
 }
 
+// src/tasks/utils/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/tasks/utils/artifact.ts
 import * as path8 from "path";
 import * as changeCase from "change-case";
@@ -1268,6 +1451,7 @@ var Artifact = class {
   warns = [];
   content;
   extensionName;
+  anchor = new Anchor(this);
   constructor(options) {
     this.id = options.id;
     this.filepath = options.filepath;
@@ -1324,6 +1508,10 @@ var Artifact = class {
   }
 };
 
+// src/tasks/utils/json-schema.ts
+import * as R13 from "ramda";
+import { JSONPath as JSONPath5 } from "jsonpath-plus";
+
 // src/tasks/compile/utils/compile-schema-definition.ts
 function genSchemaDefinitionFilepath(schemaDefinition) {
   const filename = `${schemaDefinition.name}.schema.ts`;
@@ -1348,17 +1536,18 @@ var isArtifactCompiledBy = function(schemaDefinition) {
   return (artifact) => artifact.id === genSchemaDefinitionFilepath(schemaDefinition);
 };
 async function compileSchemaDefinition(options) {
-  const { schemaDefinitions } = options;
+  const { task, compiler, schemaDefinitions } = options;
   const artifacts = await Promise.all(
     schemaDefinitions.map(async (schemaDefinition) => {
       const content = await jsonSchemaRenderer(schemaDefinition);
       const filepath = genSchemaDefinitionFilepath(schemaDefinition);
-      return new Artifact({
+      const artifact = new Artifact({
         id: filepath,
         filepath,
         content,
         extensionName: ".schema.ts"
       });
+      return await compiler.hooks.afterCompileSchema.promise(artifact, schemaDefinition, task);
     })
   );
   for (const schemaDefinition of schemaDefinitions) {
@@ -1374,7 +1563,7 @@ async function compileSchemaDefinition(options) {
       artifact.addDependence(dependentArtifact, [dependentSchemaDefinition.name]);
     }
   }
-  const schemaDefinitionsGroupByModuleName = R12.groupBy(
+  const schemaDefinitionsGroupByModuleName = R14.groupBy(
     (schemaDefinition) => schemaDefinition.module.name,
     schemaDefinitions
   );
@@ -1399,41 +1588,93 @@ async function compileSchemaDefinition(options) {
 }
 
 // src/tasks/compile/utils/compile-operation-definition.ts
-import * as R15 from "ramda";
+import * as R17 from "ramda";
 
 // src/renderer/operation-type/index.ts
-import * as R13 from "ramda";
+import * as R15 from "ramda";
 import * as changeCase2 from "change-case";
 function typeNameFactory(operationDefinition) {
   const pascalCaseOperationId = changeCase2.pascalCase(operationDefinition.operationId);
   return (name) => `${pascalCaseOperationId}${name}`;
 }
-async function operationTypeRenderer(operationDefinition, alias = R13.identity) {
-  const { operation } = operationDefinition;
-  if (!operation.responses) return "";
-  const typeName = typeNameFactory(operationDefinition);
+function responseBodies(operation, alias = R15.identity, typeName) {
+  if (!operation.responses || R15.isEmpty(operation.responses)) {
+    return `export interface ${typeName("ResponseBodies")} {}`;
+  }
   const $responses = Object.entries(operation.responses).map(([statusCode, response]) => {
     if (!JsonSchemaUtils.isRef(response)) {
       const $value = Object.values(response.content || {}).map((mediaTypeObject) => mediaTypeObject.schema).filter((schema) => !!schema).map((schema) => generateSchema(schema, alias)).join(" | ");
       return indent(2, `${statusCode}: ${$value || "void"}`);
     }
   }).join("\n");
-  let $requestBody = `export type ${typeName("RequestBody")} = {}`;
-  if (operation.requestBody && !JsonSchemaUtils.isRef(operation.requestBody)) {
-    const $value = Object.entries(operation.requestBody.content || {}).map(([mediaType, mediaTypeObject]) => [mediaType, mediaTypeObject.schema]).filter(([, schema]) => !!schema).map(([mediaType, schema]) => {
-      if (mediaType === "multipart/form-data") {
-        return `FormData | ${generateSchema(schema, alias)}`;
-      } else if (mediaType === "application/x-www-form-urlencoded") {
-        return `URLSearchParams | ${generateSchema(schema, alias)}`;
-      }
-      return generateSchema(schema, alias);
-    }).join(" | ");
-    $requestBody = `export type ${typeName("RequestBody")} = ${$value || "unknown"}`;
-  }
   return [
     `export interface ${typeName("ResponseBodies")} {`,
     $responses,
-    "}",
+    "}"
+  ].join("\n");
+}
+function requestBodies(operation, alias = R15.identity, typeName) {
+  let $requestBodies = `export interface ${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)}: ${generateSchema(schema, alias)}`;
+    }).map((pair) => indent(2, pair));
+    $requestBodies = [
+      `export interface ${typeName("RequestBodies")} {`,
+      ...$mediaTypes,
+      "}"
+    ].join("\n");
+  }
+  return $requestBodies;
+}
+function parameterBodies(operationDefinition, alias = R15.identity, typeName) {
+  const { operation } = operationDefinition;
+  let parameterBodies2 = "";
+  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) ? SwaggerUtils.dereferenceDeep(schemaOrRef.$ref, operationDefinition.document.swagger) : schemaOrRef;
+      if (schema.type === "object" || schema.properties) {
+        return `${JSON.stringify(mediaType)}: ${generateSchema(schemaOrRef, alias)} & { [key: string]: any }`;
+      }
+      return `${JSON.stringify(mediaType)}: { [key: string]: any }`;
+    }).map((pair) => indent(2, pair));
+    parameterBodies2 = [
+      `interface ${typeName("ParameterBodies")} {`,
+      ...$mediaTypes,
+      "}",
+      ""
+    ].join("\n");
+  }
+  return parameterBodies2;
+}
+function requestParameters(operation, alias = R15.identity, typeName) {
+  const mediaTypes = operation.requestBody && !JsonSchemaUtils.isRef(operation.requestBody) ? Object.keys(operation.requestBody.content || {}) : [];
+  const base = `${typeName("RequestQuery")} & ${typeName("RouteParameters")} & ${typeName("RequestHeaders")}`;
+  if (mediaTypes.length === 1) {
+    return `export type ${typeName("RequestParameters")} = ${base} & ${typeName("RequestBodies")}[${JSON.stringify(mediaTypes[0])}]`;
+  }
+  if (mediaTypes.length > 1) {
+    const unions = mediaTypes.map((mediaType) => `(${base} & ${typeName("RequestBodies")}[${JSON.stringify(mediaType)}] & { "content-type": ${JSON.stringify(mediaType)} })`).join("\n| ");
+    return `export type ${typeName("RequestParameters")} = ${unions}`;
+  }
+  return `export type ${typeName("RequestParameters")} = ${base}`;
+}
+async function operationTypeRenderer(operationDefinition, alias = R15.identity) {
+  const { operation } = operationDefinition;
+  if (!operation.responses) return "";
+  const typeName = typeNameFactory(operationDefinition);
+  const $responseBodies = responseBodies(operation, alias, typeName);
+  const $requestBodies = requestBodies(operation, alias, typeName);
+  const $parameterBodies = parameterBodies(operationDefinition, alias, typeName);
+  const $requestParameters = requestParameters(operation, alias, typeName);
+  return [
+    "/* @anchor:file:start */",
+    "",
+    $responseBodies,
+    "",
+    $requestBodies,
     "",
     generateParameters(`${typeName("RequestQuery")}`, operation.parameters?.filter((p) => !JsonSchemaUtils.isRef(p) && p.in === "query") || [], alias),
     "",
@@ -1441,18 +1682,19 @@ async function operationTypeRenderer(operationDefinition, alias = R13.identity)
     "",
     generateParameters(`${typeName("RequestHeaders")}`, operation.parameters?.filter((p) => !JsonSchemaUtils.isRef(p) && p.in === "header") || [], alias),
     "",
-    $requestBody,
+    $parameterBodies || void 0,
+    $requestParameters,
     "",
-    `export type ${typeName("RequestParameters")} = ${typeName("RequestQuery")} & ${typeName("RouteParameters")} & ${typeName("RequestHeaders")} & ${typeName("RequestBody")}`,
-    "",
-    `export interface Operation<STATUS extends keyof ${typeName("ResponseBodies")}> extends KeqOperation {`,
-    `  requestParams: ${typeName("RouteParameters")} & { [key: string]: KeqParamValue }`,
-    `  requestQuery: ${typeName("RequestQuery")} & { [key: string]: KeqQueryValue }`,
+    `export interface Operation<STATUS extends keyof ${typeName("ResponseBodies")}, CONTENT_TYPE extends keyof ${typeName("ParameterBodies")}> extends KeqOperation {`,
+    `  requestParams: ${typeName("RouteParameters")} & { [key: string]: KeqPathParameterInit }`,
+    `  requestQuery: ${typeName("RequestQuery")} & { [key: string]: KeqQueryInit }`,
     `  requestHeaders: ${typeName("RequestHeaders")} & { [key: string]: string | number }`,
-    `  requestBody: ${typeName("RequestBody")}`,
+    `  requestBody: ${$parameterBodies ? `${typeName("ParameterBodies")}[CONTENT_TYPE] | ` : "object | "}BodyInit`,
     `  responseBody: ${typeName("ResponseBodies")}[STATUS]`,
-    "}"
-  ].join("\n");
+    "}",
+    "",
+    "/* @anchor:file:end */"
+  ].filter(R15.isNotNil).join("\n");
 }
 function generateParameters(name, parameters, alias) {
   if (parameters.length === 0) {
@@ -1472,7 +1714,7 @@ function generateParameters(name, parameters, alias) {
 }
 
 // src/renderer/operation-request/index.ts
-import * as R14 from "ramda";
+import * as R16 from "ramda";
 function errorToComment(err, mediaType) {
   const $err = String(err).split("\n").map(((line) => ` * ${line}`)).join("\n");
   return [
@@ -1482,23 +1724,8 @@ function errorToComment(err, mediaType) {
     " */"
   ].join("\n");
 }
-async function operationRequestRenderer(operationDefinition, options) {
-  const { operation, operationId, method, pathname } = operationDefinition;
-  const { qs } = options;
-  if (!operation.responses) return "";
-  const typeName = typeNameFactory(operationDefinition);
-  const moduleName = operationDefinition.module.name;
-  const parameters = operation.parameters?.filter((p) => !JsonSchemaUtils.isRef(p)) || [];
-  const queryParameters = parameters.filter((p) => p.in === "query");
-  const headersParameters = parameters.filter((p) => p.in === "header");
-  const pathParameters = parameters.filter((p) => p.in === "path");
-  const $queryParameters = queryParameters.map((p) => {
-    const option = qs(p);
-    const $option = !option || R14.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})`;
-  }).concat("").join("\n");
-  const $headerParameters = headersParameters.map((p) => `  if (args && ${JSON.stringify(p.name)} in args) req.header(${JSON.stringify(p.name)}, args[${JSON.stringify(p.name)}])`).concat("").join("\n");
-  const $pathParameters = pathParameters.map((p) => `  if (args && ${JSON.stringify(p.name)} in args) req.params(${JSON.stringify(p.name)}, args[${JSON.stringify(p.name)}])`).concat("").join("\n");
+function requestBodyRenderer(operationDefinition, typeName) {
+  const { operation } = operationDefinition;
   const requestBodyContent = operation.requestBody?.content || {};
   const $requestBody = Object.entries(requestBodyContent).map(([mediaType, mediaTypeObject]) => {
     if (!mediaTypeObject.schema) return;
@@ -1527,27 +1754,107 @@ async function operationRequestRenderer(operationDefinition, options) {
     } catch (err) {
       return indent(2, errorToComment(err, mediaType));
     }
-  }).filter(R14.isNotNil).join("\n");
+  }).filter(R16.isNotNil).join("\n");
+  return $requestBody;
+}
+function requestHeadersRenderer(operationDefinition, typeName) {
+  const { operation } = 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)}])`).concat("").join("\n");
+  return $headers;
+}
+function requestQueryRenderer(operationDefinition, qs, typeName) {
+  const { operation } = operationDefinition;
+  const $query = (operation.parameters || []).filter((p) => !JsonSchemaUtils.isRef(p)).filter((p) => p.in === "query").map((p) => {
+    const option = qs(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})`;
+  }).concat("").join("\n");
+  return $query;
+}
+function requestPathParametersRenderer(operationDefinition, typeName) {
+  const { operation } = 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)}])`).concat("").join("\n");
+  return $pathParameters;
+}
+function getRequestMediaTypes(operationDefinition) {
+  const { operation } = operationDefinition;
+  const requestBodyContent = operation.requestBody?.content || {};
+  return Object.keys(requestBodyContent);
+}
+function mediaTypeRenderer(operationDefinition) {
+  const mediaTypes = getRequestMediaTypes(operationDefinition);
+  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 "";
+}
+function operationDeclarationRenderer(operationDefinition, typeName) {
+  const { operationId } = operationDefinition;
+  const mediaTypes = getRequestMediaTypes(operationDefinition);
+  if (mediaTypes.length === 0) {
+    return `function ${operationId}<STATUS extends keyof ${typeName("ResponseBodies")}>(args?: ${typeName("RequestParameters")}): Keq<Operation<STATUS, never>>`;
+  } else if (mediaTypes.length === 1) {
+    return `function ${operationId}<STATUS extends keyof ${typeName("ResponseBodies")}>(args?: ${typeName("RequestParameters")}): Keq<Operation<STATUS, ${JSON.stringify(mediaTypes[0])}>>`;
+  } else if (mediaTypes.length > 1) {
+    return `function ${operationId}<STATUS extends keyof ${typeName("ResponseBodies")}, CONTENT_TYPE extends ${typeName("RequestParameters")}["content-type"]>(args?: Extract<${typeName("RequestParameters")}, { "content-type": CONTENT_TYPE }>): Keq<Operation<STATUS, CONTENT_TYPE>>`;
+  }
+  throw new Error("[operationDeclarationRenderer] Unreachable");
+}
+async function operationRequestRenderer(operationDefinition, options) {
+  const { operation, operationId, method, pathname } = operationDefinition;
+  const { qs } = options;
+  if (!operation.responses) return "";
+  const typeName = typeNameFactory(operationDefinition);
+  const moduleName = operationDefinition.module.name;
+  const $queryParameters = requestQueryRenderer(operationDefinition, qs, typeName);
+  const $headerParameters = requestHeadersRenderer(operationDefinition, typeName);
+  const $pathParameters = requestPathParametersRenderer(operationDefinition, typeName);
+  const $mediaType = mediaTypeRenderer(operationDefinition);
+  const $requestBody = requestBodyRenderer(operationDefinition, typeName);
+  const $operationDeclaration = operationDeclarationRenderer(operationDefinition, typeName);
   return [
+    "/* @anchor:file:start */",
+    "",
     `const moduleName = "${moduleName}"`,
     `const method = "${method}"`,
     `const pathname = "${pathname}"`,
     "",
-    `export function ${operationId}<STATUS extends keyof ${typeName("ResponseBodies")}>(args?: ${typeName("RequestParameters")}): Keq<Operation<STATUS>> {`,
+    "/* @anchor:operation-declaration */",
+    `export ${$operationDeclaration} {`,
     `  const req = request.post<${typeName("ResponseBodies")}[STATUS]>("${pathname}")`,
     "    .option('module', { name: moduleName, pathname, method })",
     "",
+    $mediaType || void 0,
+    "  /* @anchor:query:start */",
     $queryParameters || void 0,
+    "  /* @anchor:query:end */",
+    "",
+    "  /* @anchor:headers:start */",
     $headerParameters || void 0,
+    "  /* @anchor:headers:end */",
+    "",
+    "  /* @anchor:path-parameters:start */",
     $pathParameters || void 0,
-    $requestBody ? `${$requestBody}
-` : void 0,
-    "  return req",
+    "  /* @anchor:path-parameters:end */",
+    "",
+    "  /* @anchor:body:start */",
+    $requestBody || void 0,
+    "  /* @anchor:body:end */",
+    "",
+    "  /* @anchor:operation-return */",
+    `  return req as ReturnType<typeof ${operationId}>`,
     "}",
     "",
     `${operationId}.pathname = pathname`,
-    `${operationId}.method = method`
-  ].filter(R14.isNotNil).join("\n");
+    `${operationId}.method = method`,
+    "/* @anchor:file:end */"
+  ].filter(R16.isNotNil).join("\n");
 }
 
 // src/tasks/compile/utils/compile-operation-definition.ts
@@ -1578,7 +1885,7 @@ function genEntrypointFilepath2(moduleName) {
   ].join("/");
 }
 async function compileOperationDefinition(options) {
-  const { rc, requestArtifact, schemaArtifacts, operationDefinitions } = options;
+  const { compiler, task, rc, requestArtifact, schemaArtifacts, operationDefinitions } = options;
   const alias = (name) => `${name}Schema`;
   const qs = (parameter) => {
     if (typeof rc.qs === "function") {
@@ -1612,7 +1919,7 @@ async function compileOperationDefinition(options) {
       content,
       extensionName: ".type.ts"
     });
-    typeArtifact.addDependence("keq", ["KeqOperation", "KeqQueryValue", "KeqParamValue"]);
+    typeArtifact.addDependence("keq", ["KeqOperation", "KeqQueryInit", "KeqPathParameterInit"]);
     const dependentSchemaDefinitions = operationDefinition.getDependencies();
     for (const dependentSchemaDefinition of dependentSchemaDefinitions) {
       const dependentArtifact = schemaArtifacts.find(isArtifactCompiledBy(dependentSchemaDefinition));
@@ -1624,7 +1931,7 @@ async function compileOperationDefinition(options) {
         new DependencyIdentifier(dependentSchemaDefinition.name, alias(dependentSchemaDefinition.name))
       ]);
     }
-    return typeArtifact;
+    return await compiler.hooks.afterCompileOperationType.promise(typeArtifact, operationDefinition, task);
   }
   async function createRequestArtifact(operationDefinition, typeArtifact) {
     const typeName = typeNameFactory(operationDefinition);
@@ -1651,13 +1958,13 @@ async function compileOperationDefinition(options) {
       [
         `${typeName("RequestQuery")}`,
         `${typeName("RequestHeaders")}`,
-        `${typeName("RequestBody")}`
+        `${typeName("RequestBodies")}`
       ],
       { export: true }
     );
-    return artifact;
+    return await compiler.hooks.afterCompileOperationRequest.promise(artifact, operationDefinition, task);
   }
-  const artifacts = R15.unnest(
+  const artifacts = R17.unnest(
     await Promise.all(
       operationDefinitions.map(async (operationDefinition) => {
         const typeArtifact = await createTypeArtifact(operationDefinition);
@@ -1666,7 +1973,7 @@ async function compileOperationDefinition(options) {
       })
     )
   );
-  const operationDefinitionsGroupByModuleName = R15.groupBy(
+  const operationDefinitionsGroupByModuleName = R17.groupBy(
     (operationDefinition) => operationDefinition.module.name,
     operationDefinitions
   );
@@ -1694,32 +2001,38 @@ async function compileOperationDefinition(options) {
 async function requestRenderer() {
   return [
     "import { KeqRequest } from 'keq'",
-    "export const request = new KeqRequest()"
+    "",
+    "/* @anchor:file:start */",
+    "",
+    "/* @anchor:request-declaration */",
+    "export const request = new KeqRequest()",
+    "",
+    "/* @anchor:file:end"
   ].join("\n");
 }
 
 // src/tasks/compile/index.ts
-function createCompileTask(options) {
+function main6(compiler) {
   return {
-    title: "Compile",
-    enabled: options?.enabled,
-    skip: options?.skip,
     task: async (context, task) => {
       if (!context.setup) throw new Error("Please run setup task first.");
       if (!context.shaken) throw new Error("Please run shaking task first.");
       const rc = context.setup.rc;
       const matcher = context.setup.matcher;
       const documents = context.shaken.documents.filter((document) => !matcher.isModuleIgnored(document.module));
-      const requestArtifact = new Artifact({
-        id: "request",
-        filepath: "request",
-        content: await requestRenderer(),
-        extensionName: ".ts"
-      });
+      const requestArtifact = await compiler.hooks.afterCompileKeqRequest.promise(
+        new Artifact({
+          id: "request",
+          filepath: "request",
+          content: await requestRenderer(),
+          extensionName: ".ts"
+        }),
+        task
+      );
       const schemaDefinitions = documents.flatMap((document) => document.schemas);
       const operationDefinitions = documents.flatMap((document) => document.operations);
-      const schemaArtifacts = await compileSchemaDefinition({ schemaDefinitions });
-      const operationArtifacts = await compileOperationDefinition({ rc, operationDefinitions, schemaArtifacts, requestArtifact });
+      const schemaArtifacts = await compileSchemaDefinition({ compiler, task, schemaDefinitions });
+      const operationArtifacts = await compileOperationDefinition({ compiler, task, rc, operationDefinitions, schemaArtifacts, requestArtifact });
       const artifacts = [requestArtifact, ...schemaArtifacts, ...operationArtifacts];
       context.compiled = {
         artifacts
@@ -1727,24 +2040,22 @@ function createCompileTask(options) {
     }
   };
 }
-
-// src/tasks/append-ignore-rule/index.ts
-function createAppendIgnoreRulesTask(options) {
+function createCompileTask(compiler, options) {
   return {
-    title: "Update .keqignore file",
-    task: (context, task) => {
-      if (!context.setup) throw new Error("Setup task has not been executed.");
-      const matcher = context.setup.matcher;
-      for (const rule of options.rules) {
-        matcher.append({
-          persist: true,
-          ignore: options.mode === "add",
-          moduleName: rule.moduleName,
-          operationMethod: rule.operationMethod,
-          operationPathname: rule.operationPathname
-        });
+    title: "Compile",
+    enabled: options?.enabled,
+    skip: options?.skip,
+    task: (context, task) => task.newListr(
+      [
+        main6(compiler),
+        {
+          task: (context2, task2) => compiler.hooks.afterCompile.promise(task2)
+        }
+      ],
+      {
+        concurrent: false
       }
-    }
+    )
   };
 }
 
@@ -1783,7 +2094,7 @@ function createInteractiveTask(options) {
       const documents = context.validated.documents;
       const operationDefinitions = documents.flatMap((document) => document.operations);
       const selectedOperationDefinitions = await selectOperationDefinitions(task, operationDefinitions);
-      if (options.override) {
+      if (options.clear) {
         matcher.append({
           persist: false,
           ignore: true,
@@ -1794,7 +2105,7 @@ function createInteractiveTask(options) {
       }
       for (const op of selectedOperationDefinitions) {
         matcher.append({
-          persist: true,
+          persist: !!options.persist,
           ignore: options.mode === "add",
           moduleName: op.module.name,
           operationMethod: op.method,
@@ -1805,110 +2116,250 @@ function createInteractiveTask(options) {
   };
 }
 
-// src/tasks/index.ts
-async function build(options) {
-  const tasks = new Listr(
-    [
-      createSetupTask(options),
-      createDownloadTask({ skipIgnoredModules: !options.interactive }),
-      createValidateTask(),
-      createInteractiveTask({ mode: "except", override: true, enabled: !!options.interactive }),
-      createShakingTask({ skipIgnoredModules: true, skipEmptyDocuments: true }),
-      createCompileTask(),
-      createPersistTask({ persistIgnore: false })
-    ],
-    {
-      concurrent: false,
-      renderer: "default",
-      rendererOptions: {
-        suffixSkips: true,
-        collapseSubtasks: false,
-        collapseErrors: false
+// src/compiler/intercepter/perfect-error-message.ts
+import * as R18 from "ramda";
+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 = R18.last(args);
+          return fn(...R18.init(args), (err, result) => {
+            prefix(err);
+            return callback(err, result);
+          });
+        };
+      }
+      return tap;
     }
-  );
-  await tasks.run({});
-}
-async function ignore(options) {
-  const tasks = new Listr(
-    [
-      createSetupTask(options),
-      createAppendIgnoreRulesTask(options),
-      createDownloadTask({ enabled: !!options.interactive }),
-      createValidateTask({ enabled: !!options.interactive }),
-      createInteractiveTask({ mode: options.mode, override: false, enabled: !!options.interactive }),
-      createShakingTask({ enabled: !!options.build, skipIgnoredModules: true, skipEmptyDocuments: true }),
-      createCompileTask({ enabled: !!options.build }),
-      createPersistTask({ persistArtifacts: !!options.build, persistIgnore: true })
-    ],
-    {
-      concurrent: false,
-      renderer: "default",
-      rendererOptions: {
-        suffixSkips: true,
-        collapseSubtasks: false,
-        collapseErrors: false
+  };
+}
+
+// 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;
     }
-  );
-  await tasks.run({});
+  });
+}
+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;
+    }
+  };
 }
 
+// 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));
+  }
+  context = {};
+  hooks = {
+    // core
+    afterSetup: new AsyncSeriesHook(["task"]),
+    afterDownload: new AsyncSeriesHook(["task"]),
+    afterValidate: new AsyncSeriesHook(["task"]),
+    afterShaking: new AsyncSeriesHook(["task"]),
+    afterCompile: new AsyncSeriesHook(["task"]),
+    afterPersist: new AsyncSeriesHook(["task"]),
+    done: new SyncHook(),
+    // compile
+    afterCompileKeqRequest: new AsyncSeriesWaterfallHook(["artifact", "task"]),
+    afterCompileSchema: new AsyncSeriesWaterfallHook(["artifact", "schema", "task"]),
+    afterCompileOperationType: new AsyncSeriesWaterfallHook(["artifact", "operation", "task"]),
+    afterCompileOperationRequest: new AsyncSeriesWaterfallHook(["artifact", "operation", "task"])
+  };
+  async run() {
+    const options = this.options;
+    const tasks = new Listr(
+      [
+        createSetupTask(this, options),
+        createDownloadTask(this, { skipIgnoredModules: !options.interactive }),
+        createValidateTask(this, { enabled: !!options.build }),
+        createInteractiveTask({ enabled: !!options.interactive, ...typeof options.interactive === "object" ? options.interactive : { mode: "except" } }),
+        createShakingTask(this, { enabled: !!options.build, ...typeof options.build === "object" ? options.build.shaking : void 0 }),
+        createCompileTask(this, { enabled: !!options.build }),
+        createPersistTask(this, { enabled: !!options.build })
+      ],
+      {
+        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 (semver.lt(process.version, "18.0.0")) {
   throw new Error("Node.js version must be greater than 18");
 }
 var program = new 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 structure").option("-i --interactive", "Interactive select the scope of generation").action(async (options) => {
-  await build({
+  const compiler = new Compiler({
+    build: {
+      shaking: {
+        skipIgnoredModules: true,
+        skipEmptyDocuments: true
+      }
+    },
     config: options.config,
     modules: options.module,
-    debug: options.debug,
-    tolerant: options.tolerant,
-    interactive: options.interactive
+    debug: !!options.debug,
+    tolerant: !!options.tolerant,
+    interactive: !!options.interactive
   });
+  await compiler.run();
 });
 program.command("ignore").addArgument(
-  new Argument("<mode>", "The ignore mode").choices(["add", "except"]).argRequired()
+  new 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 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) => {
-  if (options.interactive) {
+  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,
+      modules: 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'");
     }
-    await ignore({
-      mode,
-      interactive: options.interactive,
+    compiler = new Compiler({
+      build: !!options.build && {
+        shaking: {
+          skipIgnoredModules: true,
+          skipEmptyDocuments: true
+        }
+      },
       config: options.config,
-      debug: options.debug,
       modules: options.module,
-      rules: [],
-      build: options.build
+      debug: !!options.debug,
+      interactive: {
+        mode,
+        persist: true
+      }
     });
   } else {
-    if (!options.module) throw new Error("required option '--module <module>' not specified");
-    if (!options.method) throw new Error("required option '--method <method>' not specified");
-    if (!options.pathname) throw new Error("required option '--pathname <pathnames>' not specified");
-    await ignore({
-      mode,
+    if (!options.module && !options.method && !options.pathname) {
+      throw new Error("at least one of '--module', '--method' or '--pathname' must be specified");
+    }
+    const moduleNames = options.module || ["*"];
+    compiler = new Compiler({
+      build: !!options.build && {
+        shaking: {
+          skipIgnoredModules: true,
+          skipEmptyDocuments: true
+        }
+      },
       config: options.config,
-      debug: options.debug,
+      debug: !!options.debug,
       modules: options.module,
-      rules: options.module.map((moduleName) => ({
-        moduleName,
-        operationMethod: options.method,
-        operationPathname: options.pathname
-      })),
-      build: options.build
+      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 main() {
+async function main7() {
   program.on("command:*", function(operands) {
     throw new Error(`Unknown command '${String(operands[0])}'`);
   });
@@ -1922,5 +2373,5 @@ async function main() {
     }
   }
 }
-void main();
+void main7();
 //# sourceMappingURL=cli.js.map