adorn-api 1.0.15 → 1.0.16

package/dist/cli.js

@@ -7,8 +7,8 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
 });
 
 // src/cli.ts
-import { writeFileSync, mkdirSync, rmSync, existsSync, readFileSync as readFileSync2 } from "fs";
-import { resolve as resolve2 } from "path";
+import { writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, rmSync, existsSync as existsSync2, readFileSync as readFileSync3, statSync } from "fs";
+import { resolve as resolve3 } from "path";
 
 // src/compiler/runner/createProgram.ts
 import ts from "typescript";
@@ -2333,16 +2333,961 @@ function writeCache(params) {
   fs3.writeFileSync(path3.join(outDirAbs, "cache.json"), JSON.stringify(cache, null, 2), "utf8");
 }
 
-// src/cli.ts
-import ts12 from "typescript";
+// src/cli/progress.ts
 import process from "process";
+var ProgressTracker = class {
+  phases = /* @__PURE__ */ new Map();
+  startTime;
+  verbose = false;
+  quiet = false;
+  indentLevel = 0;
+  constructor(options = {}) {
+    this.verbose = options.verbose ?? false;
+    this.quiet = options.quiet ?? false;
+    this.startTime = performance.now();
+  }
+  /**
+   * Start a new phase.
+   */
+  startPhase(name, message) {
+    this.phases.set(name, {
+      name,
+      startTime: performance.now(),
+      status: "running",
+      message
+    });
+    if (!this.quiet) {
+      this.log(`\u25CF ${message || name}`);
+    }
+  }
+  /**
+   * Complete a phase successfully.
+   */
+  completePhase(name, message) {
+    const phase = this.phases.get(name);
+    if (phase) {
+      phase.endTime = performance.now();
+      phase.status = "completed";
+      phase.message = message;
+    }
+    if (!this.quiet) {
+      const elapsed = phase ? this.formatElapsed(phase.startTime, phase.endTime) : "";
+      const status = this.verbose ? `\u2713 ${message || name} ${elapsed}` : `\u2713 ${message || name}`;
+      this.log(status);
+    }
+  }
+  /**
+   * Mark a phase as failed.
+   */
+  failPhase(name, message) {
+    const phase = this.phases.get(name);
+    if (phase) {
+      phase.endTime = performance.now();
+      phase.status = "failed";
+      phase.message = message;
+    }
+    if (!this.quiet) {
+      this.log(`\u2717 ${message || name}`);
+    }
+  }
+  /**
+   * Log a verbose message.
+   */
+  verboseLog(message) {
+    if (this.verbose && !this.quiet) {
+      const elapsed = this.formatElapsed(this.startTime);
+      this.log(`[${elapsed}] ${message}`);
+    }
+  }
+  /**
+   * Log a regular message.
+   */
+  log(message) {
+    const indent = "  ".repeat(this.indentLevel);
+    process.stdout.write(indent + message + "\n");
+  }
+  /**
+   * Log a sub-message (indented).
+   */
+  logSub(message) {
+    this.indentLevel++;
+    this.log(message);
+    this.indentLevel--;
+  }
+  /**
+   * Get the total elapsed time in milliseconds.
+   */
+  getTotalElapsed() {
+    return performance.now() - this.startTime;
+  }
+  /**
+   * Format elapsed time as a human-readable string.
+   */
+  formatElapsed(startTime, endTime) {
+    const elapsed = (endTime ?? performance.now()) - (startTime ?? this.startTime);
+    if (elapsed < 1) {
+      return `${(elapsed * 1e3).toFixed(0)}ms`;
+    } else if (elapsed < 1e3) {
+      return `${elapsed.toFixed(0)}ms`;
+    } else {
+      return `${(elapsed / 1e3).toFixed(2)}s`;
+    }
+  }
+  /**
+   * Get all completed phases with their timings.
+   */
+  getPhases() {
+    return Array.from(this.phases.values());
+  }
+  /**
+   * Print a build summary.
+   */
+  printSummary(stats) {
+    if (this.quiet) return;
+    const totalTime = this.getTotalElapsed();
+    this.log("");
+    this.log("Build Summary:");
+    this.log(`  Controllers:     ${stats.controllers}`);
+    this.log(`  Operations:      ${stats.operations}`);
+    this.log(`  Schemas:         ${stats.schemas}`);
+    this.log(`  Source files:    ${stats.sourceFiles}`);
+    this.log(`  Output dir:      ${stats.artifactsWritten[0]?.split("/").slice(0, -1).join("/") || ".adorn"}`);
+    this.log("");
+    this.log("Timings:");
+    for (const phase of this.phases.values()) {
+      if (phase.status === "completed" && phase.endTime) {
+        const elapsed = phase.endTime - phase.startTime;
+        const timeStr = elapsed < 1 ? `${(elapsed * 1e3).toFixed(0)}ms` : elapsed < 1e3 ? `${elapsed.toFixed(0)}ms` : `${(elapsed / 1e3).toFixed(2)}s`;
+        this.log(`  ${phase.name.padEnd(20)} ${timeStr}`);
+      }
+    }
+    this.log(`  ${"\u2500".repeat(21)}`);
+    this.log(`  Total time:      ${this.formatElapsed()}`);
+    this.log("");
+  }
+  /**
+   * Print artifact list.
+   */
+  printArtifacts(artifacts) {
+    if (this.quiet) return;
+    this.log("Written artifacts:");
+    for (const artifact of artifacts) {
+      const sizeStr = artifact.size ? ` (${artifact.size >= 1024 ? `${(artifact.size / 1024).toFixed(1)} KB` : `${artifact.size} B`})` : "";
+      this.log(`  \u251C\u2500\u2500 ${artifact.name}${sizeStr}`);
+    }
+  }
+};
+var Spinner = class {
+  frames = ["\u280B", "\u2819", "\u2839", "\u2838", "\u28B0", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+  interval;
+  message;
+  constructor(message = "") {
+    this.message = message;
+  }
+  /**
+   * Start the spinner.
+   */
+  start() {
+    let frameIndex = 0;
+    this.interval = setInterval(() => {
+      const frame = this.frames[frameIndex];
+      process.stdout.write(`\r${frame} ${this.message}`);
+      frameIndex = (frameIndex + 1) % this.frames.length;
+    }, 80);
+  }
+  /**
+   * Stop the spinner with a completion message.
+   */
+  stop(completedMessage) {
+    if (this.interval) {
+      clearInterval(this.interval);
+      this.interval = void 0;
+    }
+    process.stdout.write("\r" + " ".repeat(50) + "\r");
+    if (completedMessage) {
+      process.stdout.write(completedMessage + "\n");
+    }
+  }
+  /**
+   * Stop the spinner with a failure message.
+   */
+  fail(failedMessage) {
+    this.stop();
+    if (failedMessage) {
+      process.stdout.write(`\u2717 ${failedMessage}
+`);
+    }
+  }
+};
+
+// src/compiler/schema/partitioner.ts
+var DEFAULT_CONFIG = {
+  strategy: "auto",
+  threshold: 50,
+  maxGroupSize: 50,
+  complexityThreshold: 10,
+  verbose: false
+};
+function calculateSchemaComplexity(schema) {
+  let propertyCount = 0;
+  let nestedDepth = 0;
+  let refCount = 0;
+  let hasUnion = false;
+  let hasIntersection = false;
+  let hasEnum = false;
+  const jsonSize = JSON.stringify(schema).length;
+  const analyze = (s, depth) => {
+    if (!s || typeof s !== "object") return;
+    nestedDepth = Math.max(nestedDepth, depth);
+    if (s.type === "object" && s.properties) {
+      propertyCount += Object.keys(s.properties).length;
+      for (const prop of Object.values(s.properties)) {
+        analyze(prop, depth + 1);
+      }
+    }
+    if (s.$ref) refCount++;
+    if (s.anyOf || s.oneOf) hasUnion = true;
+    if (s.allOf) hasIntersection = true;
+    if (s.enum) hasEnum = true;
+    if (s.items) {
+      analyze(s.items, depth + 1);
+    }
+  };
+  analyze(schema, 0);
+  const complexity = propertyCount * 1 + nestedDepth * 2 + refCount * 0.5 + (hasUnion ? 5 : 0) + (hasIntersection ? 5 : 0) + (hasEnum ? 1 : 0);
+  return {
+    propertyCount,
+    nestedDepth,
+    refCount,
+    hasUnion,
+    hasIntersection,
+    hasEnum,
+    jsonSize
+  };
+}
+function countExternalRefs(schema, allSchemas) {
+  let count = 0;
+  const analyze = (s) => {
+    if (!s || typeof s !== "object") return;
+    if (s.$ref && typeof s.$ref === "string") {
+      const refName = s.$ref.replace("#/components/schemas/", "");
+      if (refName && allSchemas.has(refName)) {
+        count++;
+      }
+    }
+    if (s.properties) {
+      for (const prop of Object.values(s.properties)) {
+        analyze(prop);
+      }
+    }
+    if (s.items) analyze(s.items);
+    if (s.anyOf) s.anyOf.forEach(analyze);
+    if (s.oneOf) s.oneOf.forEach(analyze);
+    if (s.allOf) s.allOf.forEach(analyze);
+  };
+  analyze(schema);
+  return count;
+}
+function analyzeDependencyDensity(schemas) {
+  let totalDeps = 0;
+  let maxDeps = 0;
+  for (const schema of schemas.values()) {
+    const deps = countExternalRefs(schema, schemas);
+    totalDeps += deps;
+    maxDeps = Math.max(maxDeps, deps);
+  }
+  return {
+    avgDeps: schemas.size > 0 ? totalDeps / schemas.size : 0,
+    maxDeps
+  };
+}
+function partitionByController(schemas, graph, config) {
+  const groups = /* @__PURE__ */ new Map();
+  const sharedSchemas = /* @__PURE__ */ new Map();
+  groups.set("_shared", sharedSchemas);
+  const schemaUsage = /* @__PURE__ */ new Map();
+  for (const [nodeId, node] of graph.nodes.entries()) {
+    if (node.kind === "Operation") {
+      const opNode = node;
+      const returnType = opNode.operation?.returnType;
+      if (returnType && schemas.has(returnType)) {
+        if (!schemaUsage.has(returnType)) {
+          schemaUsage.set(returnType, /* @__PURE__ */ new Set());
+        }
+        schemaUsage.get(returnType).add(node.metadata.name);
+      }
+    }
+  }
+  for (const [schemaName, schema] of schemas.entries()) {
+    const usage = schemaUsage.get(schemaName);
+    if (!usage || usage.size === 0) {
+      sharedSchemas.set(schemaName, schema);
+    } else if (usage.size === 1) {
+      const controllerName = Array.from(usage)[0].split(":")[0] || "default";
+      const groupName = controllerName.toLowerCase();
+      if (!groups.has(groupName)) {
+        groups.set(groupName, /* @__PURE__ */ new Map());
+      }
+      groups.get(groupName).set(schemaName, schema);
+    } else {
+      sharedSchemas.set(schemaName, schema);
+    }
+  }
+  return Array.from(groups.entries()).map(([name, schemaMap]) => {
+    let totalComplexity = 0;
+    const dependencies = [];
+    for (const [schemaName, schema] of schemaMap.entries()) {
+      totalComplexity += calculateSchemaComplexity(schema).propertyCount;
+      const deps = countExternalRefs(schema, schemas);
+      for (let i = 0; i < deps; i++) {
+        dependencies.push(schemaName);
+      }
+    }
+    return {
+      name,
+      schemas: schemaMap,
+      complexity: totalComplexity,
+      dependencies
+    };
+  });
+}
+function partitionByDependency(schemas, schemaGraph, config) {
+  const groups = /* @__PURE__ */ new Map();
+  const sccs = schemaGraph.findStronglyConnectedComponents();
+  const processed = /* @__PURE__ */ new Set();
+  for (const scc of sccs) {
+    if (scc.length === 1 && processed.has(scc[0])) continue;
+    const groupSchemas = /* @__PURE__ */ new Map();
+    const groupName = `dependent-${groups.size + 1}`;
+    for (const nodeId of scc) {
+      const node = schemaGraph.getGraph().nodes.get(nodeId);
+      if (node && node.kind === "TypeDefinition") {
+        const schemaName = node.metadata.name;
+        if (schemas.has(schemaName)) {
+          groupSchemas.set(schemaName, schemas.get(schemaName));
+          processed.add(nodeId);
+        }
+      }
+    }
+    if (groupSchemas.size > 0) {
+      groups.set(groupName, groupSchemas);
+    }
+  }
+  for (const [nodeId, node] of schemaGraph.getGraph().nodes.entries()) {
+    if (processed.has(nodeId)) continue;
+    if (node.kind !== "TypeDefinition") continue;
+    const schemaName = node.metadata.name;
+    if (!schemas.has(schemaName)) continue;
+    const groupSchemas = /* @__PURE__ */ new Map();
+    groupSchemas.set(schemaName, schemas.get(schemaName));
+    groups.set(`standalone-${groups.size + 1}`, groupSchemas);
+    processed.add(nodeId);
+  }
+  return Array.from(groups.entries()).map(([name, schemaMap]) => {
+    let totalComplexity = 0;
+    const dependencies = [];
+    for (const [schemaName, schema] of schemaMap.entries()) {
+      totalComplexity += calculateSchemaComplexity(schema).propertyCount;
+      const deps = countExternalRefs(schema, schemas);
+      for (let i = 0; i < deps; i++) {
+        dependencies.push(schemaName);
+      }
+    }
+    return {
+      name,
+      schemas: schemaMap,
+      complexity: totalComplexity,
+      dependencies
+    };
+  });
+}
+function partitionBySize(schemas, config) {
+  const sortedSchemas = Array.from(schemas.entries()).sort((a, b) => {
+    const complexityA = calculateSchemaComplexity(a[1]).propertyCount;
+    const complexityB = calculateSchemaComplexity(b[1]).propertyCount;
+    return complexityB - complexityA;
+  });
+  const groups = /* @__PURE__ */ new Map();
+  let currentGroup = /* @__PURE__ */ new Map();
+  let currentCount = 0;
+  let groupIndex = 1;
+  for (const [schemaName, schema] of sortedSchemas) {
+    if (currentCount >= config.maxGroupSize) {
+      groups.set(`group-${groupIndex}`, currentGroup);
+      currentGroup = /* @__PURE__ */ new Map();
+      currentCount = 0;
+      groupIndex++;
+    }
+    currentGroup.set(schemaName, schema);
+    currentCount++;
+  }
+  if (currentCount > 0) {
+    groups.set(`group-${groupIndex}`, currentGroup);
+  }
+  return Array.from(groups.entries()).map(([name, schemaMap]) => {
+    let totalComplexity = 0;
+    const dependencies = [];
+    for (const [schemaName, schema] of schemaMap.entries()) {
+      totalComplexity += calculateSchemaComplexity(schema).propertyCount;
+      const deps = countExternalRefs(schema, schemas);
+      for (let i = 0; i < deps; i++) {
+        dependencies.push(schemaName);
+      }
+    }
+    return {
+      name,
+      schemas: schemaMap,
+      complexity: totalComplexity,
+      dependencies
+    };
+  });
+}
+function determineBestStrategy(schemas, graph, schemaGraph, config) {
+  const schemaCount = schemas.size;
+  const { avgDeps } = analyzeDependencyDensity(schemas);
+  let controllerGroups = 0;
+  for (const node of graph.nodes.values()) {
+    if (node.kind === "Controller") {
+      controllerGroups++;
+    }
+  }
+  if (schemaCount < config.threshold) {
+    return "none";
+  }
+  if (avgDeps > 3) {
+    return "dependency";
+  }
+  if (controllerGroups > 1 && avgDeps < 2) {
+    return "controller";
+  }
+  return "size";
+}
+function partitionSchemas(schemas, graph, schemaGraph, config = {}) {
+  const finalConfig = { ...DEFAULT_CONFIG, ...config };
+  const schemaCount = schemas.size;
+  let totalComplexity = 0;
+  let totalSchemas = 0;
+  const { avgDeps } = analyzeDependencyDensity(schemas);
+  let controllerGroups = 0;
+  for (const node of graph.nodes.values()) {
+    if (node.kind === "Controller") {
+      controllerGroups++;
+    }
+  }
+  for (const schema of schemas.values()) {
+    totalComplexity += calculateSchemaComplexity(schema).propertyCount;
+    totalSchemas++;
+  }
+  const avgComplexity = totalSchemas > 0 ? totalComplexity / totalSchemas : 0;
+  let strategy = finalConfig.strategy;
+  let recommendation = "";
+  if (strategy === "auto") {
+    strategy = determineBestStrategy(schemas, graph, schemaGraph, finalConfig);
+    if (schemaCount < finalConfig.threshold) {
+      recommendation = `Schema count (${schemaCount}) below threshold (${finalConfig.threshold}), single file optimal`;
+    } else if (strategy === "dependency") {
+      recommendation = `High dependency density (${avgDeps.toFixed(2)} avg refs/schema), using dependency-based partitioning`;
+    } else if (strategy === "controller") {
+      recommendation = `Found ${controllerGroups} controller groups with low coupling, using controller-based partitioning`;
+    } else {
+      recommendation = `Using size-based partitioning with max ${finalConfig.maxGroupSize} schemas per group`;
+    }
+  }
+  let groups = [];
+  if (strategy === "none") {
+    groups = [{
+      name: "all",
+      schemas: new Map(schemas),
+      complexity: totalComplexity,
+      dependencies: []
+    }];
+    recommendation = recommendation || "Single file mode (--no-split)";
+  } else if (strategy === "controller") {
+    groups = partitionByController(schemas, graph, finalConfig);
+  } else if (strategy === "dependency") {
+    groups = partitionByDependency(schemas, schemaGraph, finalConfig);
+  } else {
+    groups = partitionBySize(schemas, finalConfig);
+  }
+  const shouldSplit = strategy !== "none" && schemaCount >= finalConfig.threshold;
+  return {
+    shouldSplit,
+    strategy,
+    groups,
+    recommendation,
+    metrics: {
+      totalSchemas: schemaCount,
+      averageComplexity: avgComplexity,
+      avgDependencyDensity: avgDeps,
+      controllerGroups
+    }
+  };
+}
+
+// src/compiler/schema/splitOpenapi.ts
+import { writeFileSync, mkdirSync, existsSync, readFileSync as readFileSync2 } from "fs";
+import { resolve as resolve2 } from "path";
+function sanitizeFilename(name) {
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
+function getSchemaFilename(group) {
+  const name = sanitizeFilename(group.name);
+  return `schemas/${name}.json`;
+}
+function collectAllSchemas(groups) {
+  const result = /* @__PURE__ */ new Map();
+  for (const group of groups) {
+    for (const [schemaName, schema] of group.schemas.entries()) {
+      result.set(schemaName, { schema, group: group.name });
+    }
+  }
+  return result;
+}
+function convertToExternalRef(schema, schemaMap) {
+  if (!schema || typeof schema !== "object") return schema;
+  const result = { ...schema };
+  if (schema.$ref && typeof schema.$ref === "string") {
+    const refName = schema.$ref.replace("#/components/schemas/", "");
+    if (refName && schemaMap.has(refName)) {
+      const target = schemaMap.get(refName);
+      const filename = sanitizeFilename(target.group);
+      result.$ref = `schemas/${filename}.json#/components/schemas/${refName}`;
+    }
+  }
+  const nestedProps = ["properties", "items", "additionalProperties"];
+  for (const prop of nestedProps) {
+    if (prop in result) {
+      const value = result[prop];
+      if (Array.isArray(value)) {
+        result[prop] = value.map(
+          (item) => typeof item === "object" ? convertToExternalRef(item, schemaMap) : item
+        );
+      } else if (typeof value === "object" && value !== null) {
+        result[prop] = convertToExternalRef(value, schemaMap);
+      }
+    }
+  }
+  const arrayProps = ["anyOf", "oneOf", "allOf"];
+  for (const prop of arrayProps) {
+    if (prop in result && Array.isArray(result[prop])) {
+      result[prop] = result[prop].map(
+        (item) => typeof item === "object" ? convertToExternalRef(item, schemaMap) : item
+      );
+    }
+  }
+  return result;
+}
+function generateSchemaFileContent(group, schemaMap) {
+  const content = {};
+  for (const [schemaName, schema] of group.schemas.entries()) {
+    content[schemaName] = convertToExternalRef(schema, schemaMap);
+  }
+  return content;
+}
+function generateSchemaIndex(groups, schemaMap) {
+  const index = {
+    schemas: {}
+  };
+  for (const [schemaName, { group }] of schemaMap.entries()) {
+    const filename = sanitizeFilename(group);
+    index.schemas[schemaName] = {
+      $ref: `schemas/${filename}.json#/components/schemas/${schemaName}`
+    };
+  }
+  return index;
+}
+function generateModularOpenAPI(openapi, partitioning, config) {
+  const {
+    outputDir,
+    schemasDir = "schemas",
+    createIndexFile = true,
+    prettyPrint = true
+  } = config;
+  const indent = prettyPrint ? 2 : 0;
+  let totalSize = 0;
+  const schemaFiles = [];
+  if (!partitioning.shouldSplit || partitioning.groups.length === 1) {
+    const mainPath2 = resolve2(outputDir, "openapi.json");
+    writeFileSync(mainPath2, JSON.stringify(openapi, null, indent));
+    totalSize = Buffer.byteLength(JSON.stringify(openapi));
+    return {
+      mainSpec: mainPath2,
+      schemaFiles: [],
+      totalSize,
+      splitEnabled: false
+    };
+  }
+  const schemasPath = resolve2(outputDir, schemasDir);
+  mkdirSync(schemasPath, { recursive: true });
+  const schemaMap = collectAllSchemas(partitioning.groups);
+  const schemaToFile = /* @__PURE__ */ new Map();
+  for (const group of partitioning.groups) {
+    const filename = getSchemaFilename(group);
+    const filePath = resolve2(outputDir, filename);
+    const content = generateSchemaFileContent(group, schemaMap);
+    writeFileSync(filePath, JSON.stringify(content, null, indent));
+    for (const schemaName of group.schemas.keys()) {
+      schemaToFile.set(schemaName, filename);
+    }
+    schemaFiles.push(filePath);
+    totalSize += Buffer.byteLength(JSON.stringify(content));
+  }
+  let indexFile;
+  if (createIndexFile) {
+    const indexPath = resolve2(outputDir, "schemas/index.json");
+    const indexContent = generateSchemaIndex(partitioning.groups, schemaMap);
+    writeFileSync(indexPath, JSON.stringify(indexContent, null, indent));
+    totalSize += Buffer.byteLength(JSON.stringify(indexContent));
+    indexFile = indexPath;
+  }
+  const mainSpec = generateMainSpec(openapi, schemaMap, schemaToFile);
+  const mainPath = resolve2(outputDir, "openapi.json");
+  writeFileSync(mainPath, JSON.stringify(mainSpec, null, indent));
+  totalSize += Buffer.byteLength(JSON.stringify(mainSpec));
+  return {
+    mainSpec: mainPath,
+    schemaFiles,
+    indexFile,
+    totalSize,
+    splitEnabled: true
+  };
+}
+function generateMainSpec(original, schemaMap, schemaToFile) {
+  const schemas = {};
+  for (const [schemaName, { group }] of schemaMap.entries()) {
+    const filename = sanitizeFilename(group);
+    schemas[schemaName] = {
+      $ref: `schemas/${filename}.json#/components/schemas/${schemaName}`
+    };
+  }
+  return {
+    ...original,
+    components: {
+      ...original.components,
+      schemas
+    },
+    "x-original-schemas": Object.keys(schemaMap).length,
+    "x-split-enabled": true,
+    "x-schema-files": Array.from(new Set(schemaToFile.values()))
+  };
+}
+
+// src/compiler/graph/types.ts
+function createGraph(tsVersion) {
+  return {
+    nodes: /* @__PURE__ */ new Map(),
+    roots: /* @__PURE__ */ new Set(),
+    version: "1.0.0",
+    metadata: {
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      generatedBy: "adorn-api-gems",
+      tsVersion
+    }
+  };
+}
+function addNode(graph, node) {
+  graph.nodes.set(node.id, node);
+}
+function addEdge(graph, sourceId, targetId, relation, properties) {
+  const sourceNode = graph.nodes.get(sourceId);
+  if (!sourceNode) {
+    throw new Error(`Source node ${sourceId} not found`);
+  }
+  const targetExists = graph.nodes.has(targetId);
+  if (!targetExists) {
+    throw new Error(`Target node ${targetId} not found`);
+  }
+  sourceNode.edges.push({
+    targetId,
+    relation,
+    properties
+  });
+}
+function getEdgesByRelation(graph, relation) {
+  const edges = [];
+  for (const [id, node] of graph.nodes.entries()) {
+    for (const edge of node.edges) {
+      if (edge.relation === relation) {
+        edges.push({ sourceId: id, edge });
+      }
+    }
+  }
+  return edges;
+}
+
+// src/compiler/graph/builder.ts
+import ts12 from "typescript";
+
+// src/compiler/graph/schemaGraph.ts
+var SchemaGraph = class {
+  graph;
+  adjacency = /* @__PURE__ */ new Map();
+  reverseAdjacency = /* @__PURE__ */ new Map();
+  constructor(graph) {
+    this.graph = graph;
+    this.buildAdjacencyLists();
+  }
+  /**
+   * Build adjacency lists for faster traversal
+   */
+  buildAdjacencyLists() {
+    for (const [id, node] of this.graph.nodes.entries()) {
+      this.adjacency.set(id, /* @__PURE__ */ new Set());
+      this.reverseAdjacency.set(id, /* @__PURE__ */ new Set());
+    }
+    for (const [sourceId, node] of this.graph.nodes.entries()) {
+      for (const edge of node.edges) {
+        this.adjacency.get(sourceId)?.add(edge.targetId);
+        this.reverseAdjacency.get(edge.targetId)?.add(sourceId);
+      }
+    }
+  }
+  /**
+   * Find all nodes that use a given type
+   */
+  findTypeUsages(typeId) {
+    const usages = [];
+    const usesEdges = getEdgesByRelation(this.graph, "uses");
+    for (const { sourceId, edge } of usesEdges) {
+      if (edge.targetId === typeId) {
+        usages.push(sourceId);
+      }
+    }
+    return usages;
+  }
+  /**
+   * Detect cycles in the dependency graph
+   */
+  detectCycles() {
+    const visited = /* @__PURE__ */ new Set();
+    const recursionStack = /* @__PURE__ */ new Set();
+    const cycles = [];
+    for (const nodeId of this.graph.nodes.keys()) {
+      if (!visited.has(nodeId)) {
+        this.detectCyclesDFS(nodeId, visited, recursionStack, [], cycles);
+      }
+    }
+    return {
+      hasCycles: cycles.length > 0,
+      cycles,
+      cycleCount: cycles.length
+    };
+  }
+  /**
+   * Depth-first search for cycle detection
+   */
+  detectCyclesDFS(nodeId, visited, recursionStack, path4, cycles) {
+    visited.add(nodeId);
+    recursionStack.add(nodeId);
+    path4.push(nodeId);
+    const neighbors = this.adjacency.get(nodeId) || /* @__PURE__ */ new Set();
+    for (const neighbor of neighbors) {
+      if (!visited.has(neighbor)) {
+        this.detectCyclesDFS(neighbor, visited, recursionStack, path4, cycles);
+      } else if (recursionStack.has(neighbor)) {
+        const cycleStart = path4.indexOf(neighbor);
+        cycles.push([...path4.slice(cycleStart), neighbor]);
+      }
+    }
+    recursionStack.delete(nodeId);
+    path4.pop();
+  }
+  /**
+   * Find strongly connected components using Tarjan's algorithm
+   */
+  findStronglyConnectedComponents() {
+    let index = 0;
+    const stack = [];
+    const indices = /* @__PURE__ */ new Map();
+    const lowlinks = /* @__PURE__ */ new Map();
+    const onStack = /* @__PURE__ */ new Set();
+    const sccs = [];
+    const strongConnect = (v) => {
+      indices.set(v, index);
+      lowlinks.set(v, index);
+      index++;
+      stack.push(v);
+      onStack.add(v);
+      const neighbors = this.adjacency.get(v) || /* @__PURE__ */ new Set();
+      for (const w of neighbors) {
+        if (!indices.has(w)) {
+          strongConnect(w);
+          lowlinks.set(v, Math.min(lowlinks.get(v), lowlinks.get(w)));
+        } else if (onStack.has(w)) {
+          lowlinks.set(v, Math.min(lowlinks.get(v), indices.get(w)));
+        }
+      }
+      if (lowlinks.get(v) === indices.get(v)) {
+        const scc = [];
+        let w;
+        do {
+          w = stack.pop();
+          onStack.delete(w);
+          scc.push(w);
+        } while (w !== v);
+        sccs.push(scc);
+      }
+    };
+    for (const nodeId of this.graph.nodes.keys()) {
+      if (!indices.has(nodeId)) {
+        strongConnect(nodeId);
+      }
+    }
+    return sccs;
+  }
+  /**
+   * Topological sort of the graph
+   */
+  topologicalSort() {
+    const inDegree = /* @__PURE__ */ new Map();
+    for (const nodeId of this.graph.nodes.keys()) {
+      inDegree.set(nodeId, 0);
+    }
+    for (const [sourceId, node] of this.graph.nodes.entries()) {
+      for (const edge of node.edges) {
+        inDegree.set(
+          edge.targetId,
+          (inDegree.get(edge.targetId) || 0) + 1
+        );
+      }
+    }
+    const queue = [];
+    for (const [nodeId, degree] of inDegree.entries()) {
+      if (degree === 0) {
+        queue.push(nodeId);
+      }
+    }
+    const sorted = [];
+    while (queue.length > 0) {
+      const current = queue.shift();
+      sorted.push(current);
+      const neighbors = this.adjacency.get(current) || /* @__PURE__ */ new Set();
+      for (const neighbor of neighbors) {
+        inDegree.set(neighbor, inDegree.get(neighbor) - 1);
+        if (inDegree.get(neighbor) === 0) {
+          queue.push(neighbor);
+        }
+      }
+    }
+    return sorted;
+  }
+  /**
+   * Find nodes reachable from a given start node
+   */
+  findReachable(startNodeId) {
+    const reachable = /* @__PURE__ */ new Set();
+    const visited = /* @__PURE__ */ new Set();
+    const queue = [startNodeId];
+    while (queue.length > 0) {
+      const current = queue.shift();
+      if (visited.has(current)) continue;
+      visited.add(current);
+      reachable.add(current);
+      const neighbors = this.adjacency.get(current) || /* @__PURE__ */ new Set();
+      for (const neighbor of neighbors) {
+        if (!visited.has(neighbor)) {
+          queue.push(neighbor);
+        }
+      }
+    }
+    return reachable;
+  }
+  /**
+   * Find shortest path between two nodes (BFS)
+   */
+  findShortestPath(fromId, toId) {
+    const visited = /* @__PURE__ */ new Set();
+    const previous = /* @__PURE__ */ new Map();
+    const queue = [fromId];
+    visited.add(fromId);
+    while (queue.length > 0) {
+      const current = queue.shift();
+      if (current === toId) {
+        return this.reconstructPath(previous, toId);
+      }
+      const neighbors = this.adjacency.get(current) || /* @__PURE__ */ new Set();
+      for (const neighbor of neighbors) {
+        if (!visited.has(neighbor)) {
+          visited.add(neighbor);
+          previous.set(neighbor, current);
+          queue.push(neighbor);
+        }
+      }
+    }
+    return null;
+  }
+  /**
+   * Reconstruct path from previous map
+   */
+  reconstructPath(previous, toId) {
+    const path4 = [toId];
+    let current = toId;
+    while (current !== void 0) {
+      current = previous.get(current);
+      if (current !== void 0) {
+        path4.unshift(current);
+      }
+    }
+    return path4;
+  }
+  /**
+   * Get nodes grouped by their depth from roots
+   */
+  getDepthGroups() {
+    const depths = /* @__PURE__ */ new Map();
+    const groups = /* @__PURE__ */ new Map();
+    for (const rootId of this.graph.roots) {
+      const queue = [rootId];
+      depths.set(rootId, 0);
+      while (queue.length > 0) {
+        const current = queue.shift();
+        const currentDepth = depths.get(current);
+        for (const neighbor of this.adjacency.get(current) || /* @__PURE__ */ new Set()) {
+          const newDepth = currentDepth + 1;
+          if (!depths.has(neighbor) || depths.get(neighbor) > newDepth) {
+            depths.set(neighbor, newDepth);
+            queue.push(neighbor);
+          }
+        }
+      }
+    }
+    for (const [nodeId, depth] of depths.entries()) {
+      if (!groups.has(depth)) {
+        groups.set(depth, []);
+      }
+      groups.get(depth).push(nodeId);
+    }
+    return groups;
+  }
+  /**
+   * Get the underlying graph
+   */
+  getGraph() {
+    return this.graph;
+  }
+};
+
+// src/cli.ts
+import ts13 from "typescript";
+import process2 from "process";
 var ADORN_VERSION = "0.1.0";
-function log(msg) {
-  process.stdout.write(msg + "\n");
+function log(msg, options) {
+  if (options?.indent) {
+    process2.stdout.write("  " + msg + "\n");
+  } else {
+    process2.stdout.write(msg + "\n");
+  }
 }
-function debug(...args) {
-  if (process.env.ADORN_DEBUG) {
-    console.error("[adorn-api]", ...args);
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+function getFileSize(path4) {
+  try {
+    return statSync(path4).size;
+  } catch {
+    return void 0;
   }
 }
 function sanitizeForJson(obj) {
@@ -2365,49 +3310,241 @@ function sanitizeForJson(obj) {
   }
   return result;
 }
+function buildControllerGraph(controllers) {
+  const graph = createGraph(ts13.version);
+  const nodeMap = /* @__PURE__ */ new Map();
+  for (const ctrl of controllers) {
+    const nodeId = `Controller:${ctrl.className}`;
+    const node = {
+      id: nodeId,
+      kind: "Controller",
+      metadata: {
+        name: ctrl.className,
+        sourceLocation: { filePath: "", line: 0, column: 0 },
+        tags: /* @__PURE__ */ new Set(),
+        annotations: /* @__PURE__ */ new Map()
+      },
+      edges: [],
+      controller: {
+        basePath: ctrl.basePath
+      }
+    };
+    addNode(graph, node);
+    nodeMap.set(nodeId, node);
+  }
+  let opIndex = 0;
+  for (const ctrl of controllers) {
+    for (const op of ctrl.operations) {
+      const nodeId = `Operation:${op.operationId}`;
+      const node = {
+        id: nodeId,
+        kind: "Operation",
+        metadata: {
+          name: op.operationId,
+          sourceLocation: { filePath: "", line: 0, column: 0 },
+          tags: /* @__PURE__ */ new Set(),
+          annotations: /* @__PURE__ */ new Map()
+        },
+        edges: [],
+        operation: {
+          httpMethod: op.httpMethod,
+          path: op.path,
+          operationId: op.operationId,
+          returnType: op.returnType || ""
+        }
+      };
+      addNode(graph, node);
+      nodeMap.set(nodeId, node);
+      const ctrlNode = nodeMap.get(`Controller:${ctrl.className}`);
+      if (ctrlNode) {
+        addEdge(graph, ctrlNode.id, node.id, "contains");
+      }
+      opIndex++;
+    }
+  }
+  for (const ctrl of controllers) {
+    for (const op of ctrl.operations) {
+      if (op.returnType && !nodeMap.has(op.returnType)) {
+        const node = {
+          id: op.returnType,
+          kind: "TypeDefinition",
+          metadata: {
+            name: op.returnType,
+            sourceLocation: { filePath: "", line: 0, column: 0 },
+            tags: /* @__PURE__ */ new Set(),
+            annotations: /* @__PURE__ */ new Map()
+          },
+          edges: [],
+          typeDef: {
+            isGeneric: false,
+            properties: /* @__PURE__ */ new Map()
+          }
+        };
+        addNode(graph, node);
+        nodeMap.set(op.returnType, node);
+        const opNodeId = `Operation:${op.operationId}`;
+        const opNode = nodeMap.get(opNodeId);
+        if (opNode) {
+          addEdge(graph, opNode.id, node.id, "uses");
+        }
+      }
+    }
+  }
+  return graph;
+}
 async function buildCommand(args) {
+  const progress = new ProgressTracker({ verbose: args.includes("--verbose"), quiet: args.includes("--quiet") });
   const projectIndex = args.indexOf("-p");
   const projectPath = projectIndex !== -1 ? args[projectIndex + 1] : "./tsconfig.json";
   const outputDir = args.includes("--output") ? args[args.indexOf("--output") + 1] : ".adorn";
   const ifStale = args.includes("--if-stale");
   const validationModeIndex = args.indexOf("--validation-mode");
   const validationMode = validationModeIndex !== -1 ? args[validationModeIndex + 1] : "ajv-runtime";
+  const verbose = args.includes("--verbose");
+  const quiet = args.includes("--quiet");
+  const noSplit = args.includes("--no-split");
+  const splitStrategyIndex = args.indexOf("--split-strategy");
+  const splitStrategy = splitStrategyIndex !== -1 ? args[splitStrategyIndex + 1] : void 0;
+  const splitThresholdIndex = args.indexOf("--split-threshold");
+  const splitThreshold = splitThresholdIndex !== -1 ? parseInt(args[splitThresholdIndex + 1], 10) : 50;
   if (validationMode !== "none" && validationMode !== "ajv-runtime" && validationMode !== "precompiled") {
     console.error(`Invalid validation mode: ${validationMode}. Valid values: none, ajv-runtime, precompiled`);
-    process.exit(1);
+    process2.exit(1);
+  }
+  const outputPath = resolve3(outputDir);
+  if (!quiet) {
+    log(`adorn-api v${ADORN_VERSION} - Building API artifacts`);
+    log("");
   }
-  const outputPath = resolve2(outputDir);
   if (ifStale) {
+    progress.startPhase("staleness-check", "Checking for stale artifacts");
     const stale = await isStale({
       outDir: outputDir,
       project: projectPath,
       adornVersion: ADORN_VERSION,
-      typescriptVersion: ts12.version
+      typescriptVersion: ts13.version
     });
     if (!stale.stale) {
-      log("adorn-api: artifacts up-to-date");
+      progress.completePhase("staleness-check");
+      if (!quiet) {
+        log("adorn-api: artifacts up-to-date");
+      }
       return;
     }
-    log(`adorn-api: building artifacts (reason: ${stale.reason}${stale.detail ? `: ${stale.detail}` : ""})`);
-    debug("Stale detail:", stale.detail);
+    progress.completePhase("staleness-check", `Artifacts stale (${stale.reason})`);
+    if (verbose) {
+      progress.verboseLog(`Stale reason: ${stale.detail || stale.reason}`);
+    }
   } else {
-    log("adorn-api: building artifacts (reason: forced-build)");
+    progress.startPhase("configuration", "Initializing build");
+    progress.completePhase("configuration", "Build forced (--if-stale not used)");
+  }
+  progress.startPhase("program", "Loading TypeScript configuration");
+  if (verbose) {
+    progress.verboseLog(`Loading ${projectPath}`);
   }
   const { program, checker, sourceFiles } = createProgramFromConfig(projectPath);
+  const projectSourceFiles = sourceFiles.filter((sf) => !sf.fileName.includes("node_modules"));
+  progress.completePhase("program");
+  if (verbose) {
+    progress.verboseLog(`Found ${projectSourceFiles.length} source files`);
+  }
+  progress.startPhase("scan", "Scanning for controllers");
   const controllers = scanControllers(sourceFiles, checker);
   if (controllers.length === 0) {
     console.warn("No controllers found!");
-    process.exit(1);
+    process2.exit(1);
+  }
+  const totalOperations = controllers.reduce((sum, ctrl) => sum + ctrl.operations.length, 0);
+  progress.completePhase("scan", `Found ${controllers.length} controller(s) with ${totalOperations} operation(s)`);
+  if (verbose) {
+    for (const ctrl of controllers) {
+      progress.verboseLog(`Controller: ${ctrl.className} (${ctrl.basePath}) - ${ctrl.operations.length} operations`);
+    }
+  }
+  progress.startPhase("openapi", "Generating OpenAPI schema");
+  if (verbose) {
+    progress.verboseLog("Processing schemas from type definitions");
   }
-  log(`Found ${controllers.length} controller(s)`);
   const openapi = generateOpenAPI(controllers, checker, { title: "API", version: "1.0.0" });
+  const schemaCount = Object.keys(openapi.components?.schemas || {}).length;
+  let splitEnabled = false;
+  if (!noSplit && schemaCount >= splitThreshold) {
+    progress.verboseLog(`Schema count (${schemaCount}) >= threshold (${splitThreshold}), analyzing for auto-split...`);
+    const graph = buildControllerGraph(controllers);
+    const schemaGraph = new SchemaGraph(graph);
+    const schemasMap = new Map(Object.entries(openapi.components?.schemas || {}));
+    const strategy = splitStrategy || "auto";
+    const partitioning = partitionSchemas(schemasMap, graph, schemaGraph, {
+      strategy,
+      threshold: splitThreshold,
+      verbose
+    });
+    splitEnabled = partitioning.shouldSplit;
+    if (splitEnabled) {
+      progress.verboseLog(`Partitioning result: ${partitioning.strategy} strategy`);
+      progress.verboseLog(`Recommendation: ${partitioning.recommendation}`);
+      generateModularOpenAPI(openapi, partitioning, {
+        outputDir: outputPath,
+        schemasDir: "schemas",
+        createIndexFile: true,
+        prettyPrint: true
+      });
+      if (!quiet) {
+        log(`  Auto-split enabled: ${partitioning.strategy} strategy`);
+        log(`  Schema groups: ${partitioning.groups.length}`);
+      }
+    } else {
+      if (!quiet) {
+        log(`  Auto-split not needed: ${partitioning.recommendation}`);
+      }
+    }
+  } else if (noSplit) {
+    if (!quiet) {
+      log(`  Splitting disabled (--no-split)`);
+    }
+  } else {
+    if (!quiet) {
+      log(`  Schema count (${schemaCount}) below threshold (${splitThreshold}), single file mode`);
+    }
+  }
+  progress.completePhase("openapi", `Generated ${schemaCount} schema(s)${splitEnabled ? " (split into groups)" : ""}`);
+  progress.startPhase("manifest", "Generating manifest");
   const manifest = generateManifest(controllers, checker, ADORN_VERSION, validationMode);
-  mkdirSync(outputPath, { recursive: true });
-  writeFileSync(resolve2(outputPath, "openapi.json"), JSON.stringify(sanitizeForJson(openapi), null, 2));
-  writeFileSync(resolve2(outputPath, "manifest.json"), JSON.stringify(manifest, null, 2));
+  progress.completePhase("manifest");
+  progress.startPhase("write", "Writing artifacts");
+  mkdirSync2(outputPath, { recursive: true });
+  const openapiPath = resolve3(outputPath, "openapi.json");
+  const manifestPath = resolve3(outputPath, "manifest.json");
+  if (!splitEnabled) {
+    writeFileSync2(openapiPath, JSON.stringify(sanitizeForJson(openapi), null, 2));
+  }
+  writeFileSync2(manifestPath, JSON.stringify(manifest, null, 2));
+  const artifacts = [
+    { name: "openapi.json", size: getFileSize(openapiPath) },
+    { name: "manifest.json", size: getFileSize(manifestPath) }
+  ];
+  if (splitEnabled) {
+    const schemasDir = resolve3(outputPath, "schemas");
+    if (existsSync2(schemasDir)) {
+      const fs4 = await import("fs");
+      const files = fs4.readdirSync(schemasDir);
+      for (const file of files) {
+        const filePath = resolve3(schemasDir, file);
+        artifacts.push({ name: `schemas/${file}`, size: getFileSize(filePath) });
+      }
+    }
+  }
+  if (verbose) {
+    for (const artifact of artifacts) {
+      progress.verboseLog(`Written: ${artifact.name} (${formatBytes(artifact.size || 0)})`);
+    }
+  }
   if (validationMode === "precompiled") {
-    log("Generating precompiled validators...");
-    const manifestObj = JSON.parse(readFileSync2(resolve2(outputPath, "manifest.json"), "utf-8"));
+    progress.startPhase("validators", "Generating precompiled validators");
+    const manifestObj = JSON.parse(readFileSync3(manifestPath, "utf-8"));
+    const spinner = new Spinner("Generating validators...");
+    if (!quiet) spinner.start();
     await emitPrecompiledValidators({
       outDir: outputPath,
       openapi,
@@ -2415,45 +3552,71 @@ async function buildCommand(args) {
       strict: "off",
       formatsMode: "full"
     });
+    if (!quiet) spinner.stop();
     manifestObj.validation = {
       mode: "precompiled",
       precompiledModule: "./validators.mjs"
     };
-    writeFileSync(resolve2(outputPath, "manifest.json"), JSON.stringify(manifestObj, null, 2));
-    log("  - validators.cjs");
-    log("  - validators.mjs");
-    log("  - validators.meta.json");
+    writeFileSync2(manifestPath, JSON.stringify(manifestObj, null, 2));
+    const validatorsCjsPath = resolve3(outputPath, "validators.cjs");
+    const validatorsMjsPath = resolve3(outputPath, "validators.mjs");
+    const validatorsMetaPath = resolve3(outputPath, "validators.meta.json");
+    artifacts.push(
+      { name: "validators.cjs", size: getFileSize(validatorsCjsPath) },
+      { name: "validators.mjs", size: getFileSize(validatorsMjsPath) },
+      { name: "validators.meta.json", size: getFileSize(validatorsMetaPath) }
+    );
+    progress.completePhase("validators");
+    if (verbose) {
+      progress.verboseLog("Precompiled validators generated successfully");
+    }
   }
+  progress.startPhase("cache", "Writing cache");
   writeCache({
     outDir: outputDir,
-    tsconfigAbs: resolve2(projectPath),
+    tsconfigAbs: resolve3(projectPath),
     program,
     adornVersion: ADORN_VERSION
   });
-  log(`Written to ${outputPath}/`);
-  log("  - openapi.json");
-  log("  - manifest.json");
-  log("  - cache.json");
+  const cachePath = resolve3(outputPath, "cache.json");
+  artifacts.push({ name: "cache.json", size: getFileSize(cachePath) });
+  progress.completePhase("cache");
+  if (verbose) {
+    progress.verboseLog(`Written: cache.json (${formatBytes(getFileSize(cachePath) || 0)})`);
+  }
+  const stats = {
+    controllers: controllers.length,
+    operations: totalOperations,
+    schemas: schemaCount,
+    sourceFiles: projectSourceFiles.length,
+    artifactsWritten: artifacts.map((a) => a.name),
+    splitEnabled
+  };
+  progress.printSummary(stats);
+  progress.printArtifacts(artifacts);
 }
 function cleanCommand(args) {
+  const quiet = args.includes("--quiet");
   const outputDir = args.includes("--output") ? args[args.indexOf("--output") + 1] : ".adorn";
-  const outputPath = resolve2(outputDir);
-  if (existsSync(outputPath)) {
+  const outputPath = resolve3(outputDir);
+  if (existsSync2(outputPath)) {
     rmSync(outputPath, { recursive: true, force: true });
   }
-  log(`adorn-api: cleaned ${outputDir}`);
+  if (!quiet) {
+    log(`adorn-api: cleaned ${outputDir}`);
+  }
 }
-var command = process.argv[2];
+var command = process2.argv[2];
 if (command === "build") {
-  buildCommand(process.argv.slice(3)).catch((err) => {
+  buildCommand(process2.argv.slice(3)).catch((err) => {
     console.error(err);
-    process.exit(1);
+    process2.exit(1);
   });
 } else if (command === "clean") {
-  cleanCommand(process.argv.slice(3));
+  cleanCommand(process2.argv.slice(3));
 } else {
   console.log(`
-adorn-api CLI
+adorn-api CLI v${ADORN_VERSION}
 
 Commands:
   build     Generate OpenAPI and manifest from TypeScript source
@@ -2464,11 +3627,20 @@ Options:
   --output <dir>           Output directory (default: .adorn)
   --if-stale               Only rebuild if artifacts are stale
   --validation-mode <mode> Validation mode: none, ajv-runtime, precompiled (default: ajv-runtime)
+  --no-split               Disable automatic schema splitting (default: auto-split enabled)
+  --split-strategy <mode>  Override splitting strategy: controller, dependency, size, auto (default: auto)
+  --split-threshold <num>  Schema count threshold for auto-split (default: 50)
+  --verbose                Show detailed progress information
+  --quiet                  Suppress non-essential output
 
 Examples:
   adorn-api build -p ./tsconfig.json --output .adorn
   adorn-api build --if-stale
   adorn-api build --validation-mode precompiled
+  adorn-api build --verbose
+  adorn-api build --no-split              # Force single file mode
+  adorn-api build --split-strategy controller  # Force controller-based splitting
+  adorn-api build --split-threshold 100   # Increase threshold to 100
   adorn-api clean
   `);
 }