dinorex 1.0.0 → 1.0.2

package/src/agent.groq.js

@@ -1,279 +0,0 @@
-/**
- * agent.groq.js — Free Groq/Llama3 version of the Dinorex AI agent.
- *
- * Get a free API key at: https://console.groq.com
- * Set it:  export GROQ_API_KEY=gsk_your_key_here
- *
- * To use this instead of the Anthropic agent, change the import in cli.js and server.js:
- *   import { analyzeWithAI, analyzeIncremental } from "./agent.groq.js";
- */
-
-const GROQ_API_URL = "https://api.groq.com/openai/v1/chat/completions";
-const MODEL = "llama-3.3-70b-versatile";
-const MAX_CHARS = 12000; // safe limit per request (~3000 tokens of context)
-
-function buildContext(files) {
-  return files.map(f => `### ${f.path}\n\`\`\`\n${f.content}\n\`\`\``).join("\n\n");
-}
-
-const SYSTEM_FULL = `You are an expert API analyst. Analyze source code (JavaScript OR TypeScript) and extract a complete API specification.
-
-Supported frameworks — recognize ALL of these:
-- Express / Fastify / Koa: router.get('/path', handler), app.post('/path', handler)
-- NestJS decorators: @Controller('base'), @Get(':id'), @Post(), @Put(), @Patch(), @Delete(), @Body(), @Param(), @Query(), @UseGuards()
-- TypeScript DTOs, interfaces, type aliases, class properties
-- Mongoose / Sequelize / TypeORM / Prisma schemas
-- Zod / Joi / Yup schemas: extract field names and types
-- class-validator decorators: @IsString(), @IsEmail(), etc.
-
-Rules:
-- Return ONLY valid JSON. No markdown, no explanation, no code fences.
-- Infer realistic example values from model/schema field names and types.
-- Group endpoints into logical collections (e.g. "Users", "Auth", "Products").
-- Detect auth guards: @UseGuards(), authMiddleware, isAuthenticated, verifyToken, requireAuth, JwtAuthGuard → requiresAuth: true.
-- For NestJS: combine @Controller('users') prefix with method paths (@Get(':id') → /users/:id).
-- TypeScript optional fields (field?: type) → required: false.
-
-Return ONLY this JSON structure, nothing else:
-{
-  "projectName": "string",
-  "baseUrl": "http://localhost:3000",
-  "version": "1.0.0",
-  "description": "string",
-  "collections": [
-    {
-      "name": "string",
-      "description": "string",
-      "endpoints": [
-        {
-          "id": "unique-kebab-slug",
-          "method": "GET|POST|PUT|PATCH|DELETE",
-          "path": "/api/resource/:id",
-          "summary": "Short title",
-          "description": "Longer description",
-          "requiresAuth": false,
-          "pathParams": [{ "name": "id", "type": "string", "description": "...", "example": "abc123" }],
-          "queryParams": [{ "name": "page", "type": "integer", "description": "...", "example": 1 }],
-          "requestBody": {
-            "contentType": "application/json",
-            "schema": {
-              "fieldName": { "type": "string", "example": "value", "required": true, "description": "..." }
-            }
-          },
-          "responses": {
-            "200": { "description": "Success", "example": {} },
-            "400": { "description": "Bad Request" },
-            "401": { "description": "Unauthorized" },
-            "404": { "description": "Not Found" },
-            "500": { "description": "Server Error" }
-          }
-        }
-      ]
-    }
-  ]
-}`;
-
-const SYSTEM_INCREMENTAL = `You are an expert API analyst doing an INCREMENTAL update to an existing API spec.
-
-You understand JavaScript AND TypeScript including Express, NestJS decorators, DTOs, Zod schemas, Mongoose/TypeORM/Prisma models.
-
-You will receive:
-1. The EXISTING spec (full JSON)
-2. NEW or CHANGED source files to analyze
-
-Your job:
-- Extract endpoints from new/changed files
-- If endpoint already exists (same method + path): update it if code changed, keep it if unchanged
-- If it is NEW: add it to the correct collection (create collection if needed)
-- Remove endpoints whose source files are listed under REMOVED FILES
-- Keep all existing endpoints from unchanged files
-
-Return the COMPLETE updated spec JSON. No markdown, no explanation, ONLY JSON.`;
-
-async function callGroq(systemPrompt, userMessage) {
-  const apiKey = process.env.GROQ_API_KEY;
-  if (!apiKey) {
-    throw new Error(
-      "GROQ_API_KEY is not set.\nGet a free key at https://console.groq.com\nThen run: export GROQ_API_KEY=gsk_your_key_here"
-    );
-  }
-
-  const response = await fetch(GROQ_API_URL, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      "Authorization": `Bearer ${apiKey}`,
-    },
-    body: JSON.stringify({
-      model: MODEL,
-      temperature: 0.1, // low temp = more deterministic JSON output
-      max_tokens: 8000,
-      messages: [
-        { role: "system", content: systemPrompt },
-        { role: "user", content: userMessage },
-      ],
-    }),
-  });
-
-  if (!response.ok) {
-    const err = await response.text();
-    throw new Error(`Groq API error ${response.status}: ${err}`);
-  }
-
-  const data = await response.json();
-  const raw = data.choices?.[0]?.message?.content || "";
-  return raw;
-}
-
-function parseJSON(raw) {
-  // Strip any accidental markdown fences Llama might add
-  const cleaned = raw
-    .trim()
-    .replace(/^```json\s*/i, "")
-    .replace(/^```\s*/i, "")
-    .replace(/```\s*$/i, "")
-    .trim();
-
-  // Find the first { and last } to extract just the JSON object
-  const start = cleaned.indexOf("{");
-  const end = cleaned.lastIndexOf("}");
-  if (start === -1 || end === -1) {
-    throw new Error(`No JSON object found in response.\n\nSnippet: ${raw.slice(0, 300)}`);
-  }
-
-  const jsonStr = cleaned.slice(start, end + 1);
-
-  try {
-    return JSON.parse(jsonStr);
-  } catch (err) {
-    throw new Error(`Invalid JSON from Groq: ${err.message}\n\nSnippet: ${jsonStr.slice(0, 300)}`);
-  }
-}
-
-/**
- * Split files into batches that fit within MAX_CHARS each.
- */
-function batchFiles(files) {
-  const batches = [];
-  let current = [];
-  let size = 0;
-
-  for (const f of files) {
-    const len = f.content.length + f.path.length + 20;
-    if (size + len > MAX_CHARS && current.length > 0) {
-      batches.push(current);
-      current = [];
-      size = 0;
-    }
-    // If a single file is too large, truncate it
-    const truncated = { ...f, content: f.content.slice(0, MAX_CHARS) };
-    current.push(truncated);
-    size += len;
-  }
-  if (current.length > 0) batches.push(current);
-  return batches;
-}
-
-/**
- * Merge multiple partial specs into one, deduplicating endpoints by method+path.
- */
-function mergeSpecs(specs) {
-  const base = specs[0];
-  const collectionsMap = {};
-
-  for (const spec of specs) {
-    for (const col of spec.collections) {
-      if (!collectionsMap[col.name]) {
-        collectionsMap[col.name] = { ...col, endpoints: [] };
-      }
-      for (const ep of col.endpoints) {
-        const key = `${ep.method}:${ep.path}`;
-        const existing = collectionsMap[col.name].endpoints.find(
-          e => `${e.method}:${e.path}` === key
-        );
-        if (!existing) collectionsMap[col.name].endpoints.push(ep);
-      }
-    }
-  }
-
-  return {
-    ...base,
-    collections: Object.values(collectionsMap),
-  };
-}
-
-export async function analyzeWithAI(collected, projectName = "API") {
-  // Priority order: routes+controllers first (most important), then services, then models
-  const allFiles = [
-    ...collected.routes.map(f => ({ ...f, kind: "ROUTE" })),
-    ...collected.controllers.map(f => ({ ...f, kind: "CONTROLLER" })),
-    ...collected.services.map(f => ({ ...f, kind: "SERVICE" })),
-    ...collected.models.map(f => ({ ...f, kind: "MODEL" })),
-  ];
-
-  const batches = batchFiles(allFiles);
-  console.log(`\n  📦 Sending ${batches.length} batch(es) to Groq (${allFiles.length} files total)...`);
-
-  const partialSpecs = [];
-
-  for (let i = 0; i < batches.length; i++) {
-    const batch = batches[i];
-    const context = batch
-      .map(f => `### [${f.kind}] ${f.path}\n\`\`\`\n${f.content}\n\`\`\``)
-      .join("\n\n");
-
-    const userMessage = `Project name: "${projectName}" (batch ${i + 1} of ${batches.length})
-
-${context}
-
-Extract all API endpoints found in these files and return ONLY the JSON spec.`;
-
-    const raw = await callGroq(SYSTEM_FULL, userMessage);
-    const partial = parseJSON(raw);
-    partialSpecs.push(partial);
-
-    // Small delay between batches to avoid rate limiting
-    if (i < batches.length - 1) await sleep(1000);
-  }
-
-  return batches.length === 1 ? partialSpecs[0] : mergeSpecs(partialSpecs);
-}
-
-function sleep(ms) {
-  return new Promise(resolve => setTimeout(resolve, ms));
-}
-
-export async function analyzeIncremental(existingSpec, diff) {
-  const { newFiles, changedFiles, removedFiles } = diff;
-
-  if (!newFiles.length && !changedFiles.length && !removedFiles.length) {
-    return { spec: existingSpec, changed: false };
-  }
-
-  const filesToAnalyze = [...newFiles, ...changedFiles];
-  const removedContext = removedFiles.length > 0
-    ? `\n\nREMOVED FILES (delete their endpoints):\n${removedFiles.join("\n")}`
-    : "";
-
-  // Spec JSON itself can be large — truncate for incremental context
-  const specStr = JSON.stringify(existingSpec, null, 2);
-  const specTruncated = specStr.length > 6000
-    ? specStr.slice(0, 6000) + "\n... [truncated]"
-    : specStr;
-
-  const changedContext = filesToAnalyze
-    .map(f => `### ${f.path}\n\`\`\`\n${f.content.slice(0, 3000)}\n\`\`\``)
-    .join("\n\n");
-
-  const userMessage = `EXISTING SPEC:
-${specTruncated}
-
-NEW/CHANGED FILES:
-${changedContext}${removedContext}
-
-Return the complete updated spec JSON only.`;
-
-  const raw = await callGroq(SYSTEM_INCREMENTAL, userMessage);
-  const updated = parseJSON(raw);
-  return { spec: updated, changed: true };
-}

package/src/cli.js

@@ -1,198 +0,0 @@
-#!/usr/bin/env node
-import { program } from "commander";
-import chalk from "chalk";
-import ora from "ora";
-import { readFileSync, existsSync } from "fs";
-import { fileURLToPath } from "url";
-import path from "path";
-import { execSync } from "child_process";
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const pkgPath = path.join(__dirname, "../package.json");
-const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
-
-function banner() {
-  console.log();
-  console.log(chalk.green.bold("  🦕  DINOREX") + chalk.dim(" v" + pkg.version));
-  console.log(chalk.dim("  AI-powered API documentation — one command, full docs."));
-  console.log();
-}
-
-function checkApiKey(options) {
-  const isAnthropic = options.provider === "anthropic" || process.env.DINOREX_PROVIDER === "anthropic";
-
-  if (isAnthropic) {
-    if (options.apiKey) process.env.ANTHROPIC_API_KEY = options.apiKey;
-    if (!process.env.ANTHROPIC_API_KEY) {
-      console.log(chalk.red("  ✗ ANTHROPIC_API_KEY is not set.\n"));
-      console.log(chalk.dim("  Option 1 — env var:   export ANTHROPIC_API_KEY=sk-ant-..."));
-      console.log(chalk.dim("  Option 2 — flag:      dinorex scan --provider anthropic --api-key sk-ant-..."));
-      console.log();
-      process.exit(1);
-    }
-  } else {
-    if (options.apiKey) process.env.GROQ_API_KEY = options.apiKey;
-    if (!process.env.GROQ_API_KEY) {
-      console.log(chalk.red("  ✗ GROQ_API_KEY is not set.\n"));
-      console.log(chalk.dim("  Get a free key at: https://console.groq.com"));
-      console.log(chalk.dim("  Then: export GROQ_API_KEY=gsk_your_key_here"));
-      console.log(chalk.dim("  Or:   dinorex scan --api-key gsk_..."));
-      console.log(chalk.dim("  To use Anthropic instead: dinorex scan --provider anthropic --api-key sk-ant-..."));
-      console.log();
-      process.exit(1);
-    }
-  }
-}
-
-// ── dinorex scan [dir] ────────────────────────────────────────────────────
-program
-  .name("dinorex")
-  .version(pkg.version)
-  .description("AI-powered API documentation generator");
-
-program
-  .command("scan [directory]")
-  .alias("init")
-  .description("Scan a project and launch the interactive docs UI")
-  .option("-p, --port <port>", "Port for the docs server", "4321")
-  .option("--no-open", "Skip auto-opening browser")
-  .option("--api-key <key>", "Anthropic API key")
-  .option("--provider <name>", "AI provider: anthropic (default) or groq")
-  .action(async (directory = ".", options) => {
-    banner();
-    checkApiKey(options);
-
-    const targetDir = path.resolve(directory);
-    const port = parseInt(options.port, 10);
-
-    const { scanProject }     = await import("./scanner.js");
-    const agentFile = options.provider === "anthropic" || process.env.DINOREX_PROVIDER === "anthropic"
-      ? "./agent.js"
-      : "./agent.groq.js";
-    const { analyzeWithAI, analyzeIncremental } = await import(agentFile);
-    const { startServer }     = await import("./server.js");
-    const { loadStore, saveStore, diffScan } = await import("./store.js");
-    const { createHash }      = await import("crypto");
-
-    console.log(chalk.dim(`  📂 ${targetDir}`));
-    const providerLabel = (options.provider === "anthropic" || process.env.DINOREX_PROVIDER === "anthropic") ? "anthropic" : "groq (free)";
-    console.log(chalk.dim(`  🤖 Provider: ${providerLabel}\n`));
-
-    // ── 1. Scan ──
-    const s1 = ora({ text: "Scanning project files…", color: "green" }).start();
-    let scanResult;
-    try { scanResult = await scanProject(targetDir); }
-    catch (e) { s1.fail(chalk.red(e.message)); process.exit(1); }
-
-    const { summary, collected } = scanResult;
-    const total = Object.values(summary).reduce((a,b)=>a+b,0);
-    if (!total) {
-      s1.fail(chalk.red("No API files found. Make sure you're in an Express/Nest/Fastify project."));
-      process.exit(1);
-    }
-    s1.succeed(chalk.green("Discovered: ") + chalk.white(
-      `${summary.routes} routes  ${summary.controllers} controllers  ${summary.services} services  ${summary.models} models`
-    ));
-
-    // ── 2. AI analysis (full or incremental) ──
-    const stored = loadStore(targetDir);
-    const allFiles = [...collected.routes, ...collected.controllers, ...collected.services, ...collected.models];
-    let spec;
-
-    if (stored?.spec && stored?.hashes) {
-      const diff = diffScan(stored.hashes, allFiles);
-      const hasChanges = diff.newFiles.length || diff.changedFiles.length || diff.removedFiles.length;
-
-      if (hasChanges) {
-        const s2 = ora({ text: `Incremental update — ${diff.newFiles.length} new, ${diff.changedFiles.length} changed files…`, color: "cyan" }).start();
-        try {
-          const result = await analyzeIncremental(stored.spec, diff);
-          spec = result.spec;
-          const hashes = {};
-          for (const f of allFiles) hashes[f.path] = { hash: createHash("md5").update(f.content).digest("hex") };
-          saveStore(targetDir, { spec, hashes, lastScan: new Date().toISOString() });
-          s2.succeed(chalk.cyan("Incremental update complete."));
-        } catch(e) { s2.fail(chalk.red(e.message)); process.exit(1); }
-      } else {
-        spec = stored.spec;
-        console.log(chalk.dim("  ✓ No changes since last scan — using cached spec."));
-      }
-    } else {
-      const s2 = ora({ text: "Running full AI analysis (~15s)…", color: "cyan" }).start();
-      try {
-        spec = await analyzeWithAI(collected, path.basename(targetDir));
-        const hashes = {};
-        for (const f of allFiles) hashes[f.path] = { hash: createHash("md5").update(f.content).digest("hex") };
-        saveStore(targetDir, { spec, hashes, lastScan: new Date().toISOString() });
-        s2.succeed(chalk.cyan("Analysis complete — ") + chalk.white(
-          `${spec.collections.reduce((a,c)=>a+c.endpoints.length,0)} endpoints across ${spec.collections.length} collections`
-        ));
-      } catch(e) { s2.fail(chalk.red(e.message)); process.exit(1); }
-    }
-
-    // ── 3. Start server ──
-    const s3 = ora({ text: `Starting docs server on :${port}…`, color: "yellow" }).start();
-    let srv;
-    try { srv = await startServer(targetDir, { port, _cachedSpec: spec }); }
-    catch(e) { s3.fail(chalk.red(e.message)); process.exit(1); }
-    s3.succeed(chalk.yellow("Docs server running!"));
-
-    console.log();
-    console.log(chalk.green.bold(`  ✓ Dinorex docs → ${srv.url}`));
-    console.log(chalk.dim(`  Postman export → ${srv.url}/api/export/postman`));
-    console.log(chalk.dim(`  Swagger export → ${srv.url}/api/export/swagger`));
-    console.log();
-    console.log(chalk.dim("  Tip: run  dinorex scan  again anytime to pick up new endpoints."));
-    console.log(chalk.dim("  Ctrl+C to stop.\n"));
-
-    if (options.open !== false) {
-      try {
-        const cmd = process.platform==="darwin" ? `open ${srv.url}` : process.platform==="win32" ? `start ${srv.url}` : `xdg-open ${srv.url}`;
-        execSync(cmd, { stdio: "ignore" });
-      } catch {}
-    }
-
-    process.on("SIGINT", () => { console.log(chalk.dim("\n  Dinorex stopped. 🦕\n")); process.exit(0); });
-  });
-
-// ── dinorex generate [dir] — just files, no server ────────────────────────
-program
-  .command("generate [directory]")
-  .description("Generate Postman + Swagger files only (no server)")
-  .option("--out <dir>", "Output directory", "./dinorex-output")
-  .option("--api-key <key>", "Anthropic API key")
-  .action(async (directory = ".", options) => {
-    banner();
-    checkApiKey(options);
-
-    const targetDir = path.resolve(directory);
-    const outputDir = path.resolve(options.out);
-
-    const { scanProject }     = await import("./scanner.js");
-    const { analyzeWithAI }   = await import("./agent.js");
-    const { generatePostmanCollection } = await import("./generators/postman.js");
-    const { generateSwaggerSpec }       = await import("./generators/swagger.js");
-    const { mkdirSync, writeFileSync }  = await import("fs");
-    const { createHash }      = await import("crypto");
-    const { loadStore, saveStore, diffScan } = await import("./store.js");
-
-    const s1 = ora("Scanning…").start();
-    const { collected } = await scanProject(targetDir);
-    s1.succeed("Scanned");
-
-    const s2 = ora("AI analysis…").start();
-    const spec = await analyzeWithAI(collected, path.basename(targetDir));
-    s2.succeed("Done");
-
-    mkdirSync(outputDir, { recursive: true });
-    const slug = spec.projectName.replace(/\s+/g, "-");
-    const { writeFileSync: wf } = await import("fs");
-    wf(path.join(outputDir, `${slug}-postman.json`), JSON.stringify(generatePostmanCollection(spec), null, 2));
-    wf(path.join(outputDir, `${slug}-openapi.yaml`), generateSwaggerSpec(spec));
-    wf(path.join(outputDir, `${slug}-spec.json`), JSON.stringify(spec, null, 2));
-
-    console.log(chalk.green.bold(`\n  ✓ Written to ${outputDir}/`));
-    console.log(chalk.dim(`    ${slug}-postman.json\n    ${slug}-openapi.yaml\n    ${slug}-spec.json\n`));
-  });
-
-program.parse();

package/src/generators/postman.js

@@ -1,84 +0,0 @@
-export function generatePostmanCollection(spec) {
-  const collection = {
-    info: {
-      name: spec.projectName,
-      description: spec.description,
-      schema: "https://schema.getpostman.com/json/collection/v2.1.0/collection.json",
-      version: spec.version,
-    },
-    variable: [
-      {
-        key: "baseUrl",
-        value: spec.baseUrl,
-        type: "string",
-      },
-    ],
-    item: [],
-  };
-
-  for (const col of spec.collections) {
-    const folder = {
-      name: col.name,
-      description: col.description,
-      item: [],
-    };
-
-    for (const ep of col.endpoints) {
-      const url = {
-        raw: `{{baseUrl}}${ep.path}`,
-        host: ["{{baseUrl}}"],
-        path: ep.path.split("/").filter(Boolean).map((p) => (p.startsWith(":") ? `{{${p.slice(1)}}}` : p)),
-      };
-
-      if (ep.queryParams && ep.queryParams.length > 0) {
-        url.query = ep.queryParams.map((q) => ({
-          key: q.name,
-          value: String(q.example ?? ""),
-          description: q.description,
-        }));
-      }
-
-      if (ep.pathParams && ep.pathParams.length > 0) {
-        url.variable = ep.pathParams.map((p) => ({
-          key: p.name,
-          value: String(p.example ?? ""),
-          description: p.description,
-        }));
-      }
-
-      const request = {
-        method: ep.method,
-        header: [
-          { key: "Content-Type", value: "application/json" },
-          ...(ep.requiresAuth
-            ? [{ key: "Authorization", value: "Bearer {{token}}", description: "Auth token" }]
-            : []),
-        ],
-        url,
-        description: ep.description,
-      };
-
-      if (ep.requestBody && ["POST", "PUT", "PATCH"].includes(ep.method)) {
-        const bodyExample = {};
-        for (const [field, def] of Object.entries(ep.requestBody.schema || {})) {
-          bodyExample[field] = def.example ?? "";
-        }
-        request.body = {
-          mode: "raw",
-          raw: JSON.stringify(bodyExample, null, 2),
-          options: { raw: { language: "json" } },
-        };
-      }
-
-      folder.item.push({
-        name: ep.summary,
-        request,
-        response: [],
-      });
-    }
-
-    collection.item.push(folder);
-  }
-
-  return collection;
-}

package/src/generators/swagger.js

@@ -1,121 +0,0 @@
-import yaml from "js-yaml";
-
-export function generateSwaggerSpec(spec) {
-  const openapi = {
-    openapi: "3.0.3",
-    info: {
-      title: spec.projectName,
-      description: spec.description,
-      version: spec.version,
-    },
-    servers: [{ url: spec.baseUrl }],
-    tags: spec.collections.map((c) => ({ name: c.name, description: c.description })),
-    paths: {},
-    components: {
-      securitySchemes: {
-        bearerAuth: {
-          type: "http",
-          scheme: "bearer",
-          bearerFormat: "JWT",
-        },
-      },
-    },
-  };
-
-  for (const col of spec.collections) {
-    for (const ep of col.endpoints) {
-      if (!openapi.paths[ep.path]) {
-        openapi.paths[ep.path] = {};
-      }
-
-      const operation = {
-        tags: [col.name],
-        summary: ep.summary,
-        description: ep.description,
-        operationId: ep.id,
-        parameters: [],
-        responses: {},
-      };
-
-      if (ep.requiresAuth) {
-        operation.security = [{ bearerAuth: [] }];
-      }
-
-      // Path params
-      for (const p of ep.pathParams || []) {
-        operation.parameters.push({
-          name: p.name,
-          in: "path",
-          required: true,
-          description: p.description,
-          schema: { type: p.type || "string", example: p.example },
-        });
-      }
-
-      // Query params
-      for (const q of ep.queryParams || []) {
-        operation.parameters.push({
-          name: q.name,
-          in: "query",
-          required: false,
-          description: q.description,
-          schema: { type: q.type || "string", example: q.example },
-        });
-      }
-
-      // Request body
-      if (ep.requestBody && ["post", "put", "patch"].includes(ep.method.toLowerCase())) {
-        const properties = {};
-        const required = [];
-
-        for (const [field, def] of Object.entries(ep.requestBody.schema || {})) {
-          properties[field] = {
-            type: def.type || "string",
-            example: def.example,
-            description: def.description,
-          };
-          if (def.required) required.push(field);
-        }
-
-        operation.requestBody = {
-          required: true,
-          content: {
-            "application/json": {
-              schema: {
-                type: "object",
-                properties,
-                ...(required.length > 0 ? { required } : {}),
-              },
-            },
-          },
-        };
-      }
-
-      // Responses
-      for (const [statusCode, res] of Object.entries(ep.responses || {})) {
-        operation.responses[statusCode] = {
-          description: res.description,
-          ...(res.example
-            ? {
-                content: {
-                  "application/json": {
-                    schema: { type: "object", example: res.example },
-                  },
-                },
-              }
-            : {}),
-        };
-      }
-
-      if (Object.keys(operation.responses).length === 0) {
-        operation.responses["200"] = { description: "Success" };
-      }
-
-      if (operation.parameters.length === 0) delete operation.parameters;
-
-      openapi.paths[ep.path][ep.method.toLowerCase()] = operation;
-    }
-  }
-
-  return yaml.dump(openapi, { noRefs: true, lineWidth: 120 });
-}