openapi-ai-generator 0.1.0 → 0.1.2

package/dist/cli.js

@@ -26,150 +26,13 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 // src/cli.ts
 var import_commander = require("commander");
 
-// src/config.ts
-var import_fs = require("fs");
-var import_path = require("path");
-var import_url = require("url");
-var defaults = {
-  jsdocMode: "context",
-  cache: true,
-  cacheDir: ".openapi-cache",
-  include: ["src/app/api/**/route.ts"],
-  exclude: []
-};
-function resolveConfig(config) {
-  return {
-    ...defaults,
-    ...config,
-    output: {
-      scalarDocs: false,
-      scalarPath: "src/app/api/docs/route.ts",
-      ...config.output
-    },
-    openapi: {
-      description: "",
-      servers: [],
-      ...config.openapi
-    }
-  };
-}
-async function loadConfig(configPath) {
-  const searchPaths = configPath ? [configPath] : [
-    "openapi-gen.config.ts",
-    "openapi-gen.config.js",
-    "openapi-gen.config.mjs",
-    "openapi-gen.config.cjs"
-  ];
-  for (const p of searchPaths) {
-    const abs = (0, import_path.resolve)(process.cwd(), p);
-    if ((0, import_fs.existsSync)(abs)) {
-      const mod = await importConfig(abs);
-      const config = mod.default ?? mod;
-      return resolveConfig(config);
-    }
-  }
-  throw new Error(
-    "No openapi-gen.config.ts found. Create one at your project root."
-  );
-}
-async function importConfig(filePath) {
-  if (filePath.endsWith(".ts")) {
-    return importTypeScriptConfig(filePath);
-  }
-  const url = (0, import_url.pathToFileURL)(filePath).href;
-  return import(url);
-}
-async function importTypeScriptConfig(filePath) {
-  try {
-    const { register } = await import("module");
-    const url = (0, import_url.pathToFileURL)(filePath).href;
-    return await import(url);
-  } catch {
-    try {
-      require("ts-node/register");
-      return require(filePath);
-    } catch {
-      throw new Error(
-        `Cannot load TypeScript config file: ${filePath}. Install tsx or ts-node, or use a .js config file.`
-      );
-    }
-  }
-}
-
-// src/scanner.ts
-var import_fs2 = require("fs");
-var import_glob = require("glob");
-var import_path2 = require("path");
-async function scanRoutes(include, exclude, cwd = process.cwd()) {
-  const files = await (0, import_glob.glob)(include, {
-    cwd,
-    ignore: exclude,
-    absolute: true
-  });
-  return files.map((filePath) => parseRoute(filePath, cwd));
-}
-function parseRoute(filePath, cwd) {
-  const relativePath = (0, import_path2.relative)(cwd, filePath);
-  const sourceCode = (0, import_fs2.readFileSync)(filePath, "utf8");
-  const urlPath = filePathToUrlPath(relativePath);
-  const { jsdocComments, hasExactJsdoc, exactPathItem } = extractJsdoc(sourceCode);
-  return {
-    filePath,
-    relativePath,
-    urlPath,
-    sourceCode,
-    jsdocComments,
-    hasExactJsdoc,
-    exactPathItem
-  };
-}
-function filePathToUrlPath(filePath) {
-  let path = filePath.replace(/\\/g, "/");
-  path = path.replace(/^(src\/)?app\//, "");
-  path = path.replace(/\/route\.(ts|tsx|js|jsx)$/, "");
-  path = path.replace(/\[([^\]]+)\]/g, (_, param) => {
-    if (param.startsWith("...")) {
-      return `{${param.slice(3)}}`;
-    }
-    return `{${param}}`;
-  });
-  if (!path.startsWith("/")) {
-    path = "/" + path;
-  }
-  return path;
-}
-function extractJsdoc(sourceCode) {
-  const jsdocRegex = /\/\*\*([\s\S]*?)\*\//g;
-  const jsdocComments = [];
-  let hasExactJsdoc = false;
-  let exactPathItem;
-  let match;
-  while ((match = jsdocRegex.exec(sourceCode)) !== null) {
-    const comment = match[0];
-    jsdocComments.push(comment);
-    if (/@openapi-exact/.test(comment)) {
-      hasExactJsdoc = true;
-      const openapiMatch = comment.match(/@openapi\s+([\s\S]*?)(?=\s*\*\/|\s*\*\s*@)/);
-      if (openapiMatch) {
-        try {
-          const jsonStr = openapiMatch[1].split("\n").map((line) => line.replace(/^\s*\*\s?/, "")).join("\n").trim();
-          exactPathItem = JSON.parse(jsonStr);
-        } catch {
-          hasExactJsdoc = false;
-        }
-      }
-    }
-  }
-  return { jsdocComments, hasExactJsdoc, exactPathItem };
-}
-
 // src/analyzer.ts
 var import_ai = require("ai");
 
 // src/cache.ts
 var import_crypto = require("crypto");
-var import_fs3 = require("fs");
-var import_path3 = require("path");
+var import_fs = require("fs");
+var import_path = require("path");
 function computeHash(content, provider, modelId) {
   return (0, import_crypto.createHash)("sha256").update(content).update(provider).update(modelId).digest("hex");
 }
@@ -179,15 +42,15 @@ var RouteCache = class {
     this.cacheDir = cacheDir;
   }
   ensureDir() {
-    if (!(0, import_fs3.existsSync)(this.cacheDir)) {
-      (0, import_fs3.mkdirSync)(this.cacheDir, { recursive: true });
+    if (!(0, import_fs.existsSync)(this.cacheDir)) {
+      (0, import_fs.mkdirSync)(this.cacheDir, { recursive: true });
     }
   }
   get(hash) {
-    const filePath = (0, import_path3.join)(this.cacheDir, `${hash}.json`);
-    if (!(0, import_fs3.existsSync)(filePath)) return null;
+    const filePath = (0, import_path.join)(this.cacheDir, `${hash}.json`);
+    if (!(0, import_fs.existsSync)(filePath)) return null;
     try {
-      const entry = JSON.parse((0, import_fs3.readFileSync)(filePath, "utf8"));
+      const entry = JSON.parse((0, import_fs.readFileSync)(filePath, "utf8"));
       return entry.pathItem;
     } catch {
       return null;
@@ -200,8 +63,8 @@ var RouteCache = class {
       pathItem,
       cachedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
-    const filePath = (0, import_path3.join)(this.cacheDir, `${hash}.json`);
-    (0, import_fs3.writeFileSync)(filePath, JSON.stringify(entry, null, 2), "utf8");
+    const filePath = (0, import_path.join)(this.cacheDir, `${hash}.json`);
+    (0, import_fs.writeFileSync)(filePath, JSON.stringify(entry, null, 2), "utf8");
   }
 };
 
@@ -222,10 +85,11 @@ function createModel(provider) {
 }
 function createAzureModel() {
   const endpoint = requireEnv("AZURE_OPENAI_ENDPOINT");
+  const resourceName = endpoint?.match(/https?:\/\/([^.]+)/)?.[1];
   const apiKey = requireEnv("AZURE_OPENAI_API_KEY");
   const deployment = requireEnv("AZURE_OPENAI_DEPLOYMENT");
   const { createAzure } = require("@ai-sdk/azure");
-  const azure = createAzure({ endpoint, apiKey });
+  const azure = createAzure({ resourceName, apiKey });
   return azure(deployment);
 }
 function createOpenAIModel() {
@@ -307,7 +171,25 @@ async function analyzeRoute(route, options, modelId, cache, getModel) {
       };
     }
   }
-  const pathItem = await callLLM(route, options.jsdocMode, getModel());
+  let pathItem;
+  try {
+    pathItem = await callLLM(route, options.jsdocMode, getModel());
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    const isContentFilter = message.includes("content filtering policy") || message.includes("content_filter") || err?.status === 400;
+    if (isContentFilter) {
+      console.warn(
+        `Warning: Content filter blocked response for ${route.urlPath}. Skipping route. Use @openapi-exact JSDoc to provide the spec manually.`
+      );
+      return {
+        urlPath: route.urlPath,
+        pathItem: {},
+        fromCache: false,
+        skippedLLM: false
+      };
+    }
+    throw err;
+  }
   if (cache) {
     cache.set(hash, pathItem);
   }
@@ -321,30 +203,40 @@ async function analyzeRoute(route, options, modelId, cache, getModel) {
 function buildPrompt(route, jsdocMode) {
   const jsDocSection = route.jsdocComments.length > 0 ? `JSDoc COMMENTS (use as ${jsdocMode === "context" ? "additional context" : "primary source"}):
 ${route.jsdocComments.join("\n\n")}` : "No JSDoc comments found.";
-  return `You are an OpenAPI 3.1 specification generator. Analyze the following Next.js API route and extract a complete OpenAPI PathItem object.
+  return `You are a technical documentation tool that reads existing source code and produces OpenAPI 3.1 documentation data. You do not write or execute code \u2014 you only read and describe it.
+
+## Task
 
-FILE PATH: ${route.relativePath}
-INFERRED URL PATH: ${route.urlPath}
+Read the Next.js API route source file below and produce a JSON object that documents its HTTP endpoints according to the OpenAPI 3.1 PathItem schema.
+
+## Route metadata
+
+- File: ${route.relativePath}
+- URL path: ${route.urlPath}
+
+## Source file contents
 
-SOURCE CODE:
 \`\`\`typescript
 ${route.sourceCode}
 \`\`\`
 
 ${jsDocSection}
 
-Extract the following for EACH exported HTTP method handler (GET, POST, PUT, PATCH, DELETE):
-- operationId (camelCase, unique)
-- summary (short description)
-- description (detailed description)
-- path parameters (from URL segments like [id])
-- query parameters (from NextRequest.nextUrl.searchParams usage)
-- request body schema (from request.json() usage and TypeScript types)
-- response schemas (per status code, from NextResponse.json() calls and return types)
-- tags (infer from path segments)
-- security requirements (if auth middleware or token checks are present)
+## Instructions
+
+For each exported function named GET, POST, PUT, PATCH, or DELETE, document:
+- operationId: a unique camelCase identifier
+- summary: a short one-line description
+- description: a fuller explanation of what the endpoint does
+- parameters: path params from URL segments like {id}, and query params from searchParams usage
+- requestBody: schema inferred from request.json() calls and TypeScript types (POST/PUT/PATCH only)
+- responses: per status code, inferred from NextResponse.json() calls and return type annotations
+- tags: inferred from the URL path segments
+- security: noted if the code checks for auth tokens, session cookies, or middleware guards
 
-Return ONLY a valid JSON object matching the OpenAPI 3.1 PathItem schema. No explanation, no markdown, no code blocks. Just the raw JSON object.`;
+## Output format
+
+Return a single raw JSON object matching the OpenAPI 3.1 PathItem schema. No explanation, no markdown fences, no extra text \u2014 only the JSON object.`;
 }
 async function callLLM(route, jsdocMode, model) {
   const prompt = buildPrompt(route, jsdocMode);
@@ -375,9 +267,75 @@ function parsePathItem(text, urlPath) {
   }
 }
 
+// src/config.ts
+var import_fs2 = require("fs");
+var import_path2 = require("path");
+var import_url = require("url");
+var defaults = {
+  jsdocMode: "context",
+  cache: true,
+  cacheDir: ".openapi-cache",
+  include: ["src/app/api/**/route.ts"],
+  exclude: [],
+  envFile: [".env", ".env.local"]
+};
+function resolveConfig(config) {
+  let envFile;
+  if (config.envFile === false) {
+    envFile = false;
+  } else if (typeof config.envFile === "string") {
+    envFile = [config.envFile];
+  } else {
+    envFile = config.envFile ?? defaults.envFile;
+  }
+  return {
+    ...defaults,
+    ...config,
+    envFile,
+    output: {
+      scalarDocs: false,
+      scalarPath: "src/app/api/docs/route.ts",
+      ...config.output
+    },
+    openapi: {
+      description: "",
+      servers: [],
+      ...config.openapi
+    }
+  };
+}
+async function loadConfig(configPath) {
+  const searchPaths = configPath ? [configPath] : [
+    "openapi-gen.config.ts",
+    "openapi-gen.config.js",
+    "openapi-gen.config.mjs",
+    "openapi-gen.config.cjs"
+  ];
+  for (const p of searchPaths) {
+    const abs = (0, import_path2.resolve)(process.cwd(), p);
+    if ((0, import_fs2.existsSync)(abs)) {
+      const mod = await importConfig(abs);
+      const config = mod.default ?? mod;
+      return resolveConfig(config);
+    }
+  }
+  throw new Error("No openapi-gen.config.ts found. Create one at your project root.");
+}
+async function importConfig(filePath) {
+  if (filePath.endsWith(".ts")) {
+    return importTypeScriptConfig(filePath);
+  }
+  const url = (0, import_url.pathToFileURL)(filePath).href;
+  return import(url);
+}
+async function importTypeScriptConfig(filePath) {
+  require("tsx/cjs");
+  return require(filePath);
+}
+
 // src/generator.ts
-var import_fs4 = require("fs");
-var import_path4 = require("path");
+var import_fs3 = require("fs");
+var import_path3 = require("path");
 function assembleSpec(config, routes) {
   const paths = {};
   for (const route of routes) {
@@ -406,11 +364,11 @@ function writeOutputFiles(config, spec, cwd = process.cwd()) {
   }
 }
 function writeSpecFiles(config, spec, cwd) {
-  const specRoutePath = (0, import_path4.resolve)(cwd, config.output.specPath);
-  const specDir = (0, import_path4.dirname)(specRoutePath);
+  const specRoutePath = (0, import_path3.resolve)(cwd, config.output.specPath);
+  const specDir = (0, import_path3.dirname)(specRoutePath);
   ensureDir(specDir);
-  const specJsonPath = (0, import_path4.join)(specDir, "spec.json");
-  (0, import_fs4.writeFileSync)(specJsonPath, JSON.stringify(spec, null, 2), "utf8");
+  const specJsonPath = (0, import_path3.join)(specDir, "spec.json");
+  (0, import_fs3.writeFileSync)(specJsonPath, JSON.stringify(spec, null, 2), "utf8");
   const routeContent = `import spec from './spec.json';
 
 export const dynamic = 'force-static';
@@ -419,11 +377,11 @@ export function GET() {
   return Response.json(spec);
 }
 `;
-  (0, import_fs4.writeFileSync)(specRoutePath, routeContent, "utf8");
+  (0, import_fs3.writeFileSync)(specRoutePath, routeContent, "utf8");
 }
 function writeScalarRoute(config, cwd) {
-  const scalarRoutePath = (0, import_path4.resolve)(cwd, config.output.scalarPath);
-  ensureDir((0, import_path4.dirname)(scalarRoutePath));
+  const scalarRoutePath = (0, import_path3.resolve)(cwd, config.output.scalarPath);
+  ensureDir((0, import_path3.dirname)(scalarRoutePath));
   const specUrl = filePathToApiUrl(config.output.specPath);
   const routeContent = `export const dynamic = 'force-static';
 
@@ -448,27 +406,101 @@ export function GET() {
   );
 }
 `;
-  (0, import_fs4.writeFileSync)(scalarRoutePath, routeContent, "utf8");
+  (0, import_fs3.writeFileSync)(scalarRoutePath, routeContent, "utf8");
 }
 function filePathToApiUrl(filePath) {
   let path = filePath.replace(/\\/g, "/");
   path = path.replace(/^(src\/)?app\//, "");
   path = path.replace(/\/route\.(ts|tsx|js|jsx)$/, "");
-  if (!path.startsWith("/")) path = "/" + path;
+  if (!path.startsWith("/")) path = `/${path}`;
   return path;
 }
 function ensureDir(dir) {
-  if (!(0, import_fs4.existsSync)(dir)) {
-    (0, import_fs4.mkdirSync)(dir, { recursive: true });
+  if (!(0, import_fs3.existsSync)(dir)) {
+    (0, import_fs3.mkdirSync)(dir, { recursive: true });
   }
 }
 
+// src/scanner.ts
+var import_fs4 = require("fs");
+var import_path4 = require("path");
+async function scanRoutes(include, exclude, cwd = process.cwd()) {
+  const { default: fg } = await import("fast-glob");
+  const files = await fg(include, {
+    cwd,
+    ignore: exclude,
+    absolute: true
+  });
+  return files.map((filePath) => parseRoute(filePath, cwd));
+}
+function parseRoute(filePath, cwd) {
+  const relativePath = (0, import_path4.relative)(cwd, filePath);
+  const sourceCode = (0, import_fs4.readFileSync)(filePath, "utf8");
+  const urlPath = filePathToUrlPath(relativePath);
+  const { jsdocComments, hasExactJsdoc, exactPathItem } = extractJsdoc(sourceCode);
+  return {
+    filePath,
+    relativePath,
+    urlPath,
+    sourceCode,
+    jsdocComments,
+    hasExactJsdoc,
+    exactPathItem
+  };
+}
+function filePathToUrlPath(filePath) {
+  let path = filePath.replace(/\\/g, "/");
+  path = path.replace(/^(src\/)?app\//, "");
+  path = path.replace(/\/route\.(ts|tsx|js|jsx)$/, "");
+  path = path.replace(/\[([^\]]+)\]/g, (_, param) => {
+    if (param.startsWith("...")) {
+      return `{${param.slice(3)}}`;
+    }
+    return `{${param}}`;
+  });
+  if (!path.startsWith("/")) {
+    path = `/${path}`;
+  }
+  return path;
+}
+function extractJsdoc(sourceCode) {
+  const jsdocRegex = /\/\*\*([\s\S]*?)\*\//g;
+  const jsdocComments = [];
+  let hasExactJsdoc = false;
+  let exactPathItem;
+  const match = jsdocRegex.exec(sourceCode);
+  while (match !== null) {
+    const comment = match[0];
+    jsdocComments.push(comment);
+    if (/@openapi-exact/.test(comment)) {
+      hasExactJsdoc = true;
+      const openapiMatch = comment.match(/@openapi\s+([\s\S]*?)(?=\s*\*\/|\s*\*\s*@)/);
+      if (openapiMatch) {
+        try {
+          const jsonStr = openapiMatch[1].split("\n").map((line) => line.replace(/^\s*\*\s?/, "")).join("\n").trim();
+          exactPathItem = JSON.parse(jsonStr);
+        } catch {
+          hasExactJsdoc = false;
+        }
+      }
+    }
+  }
+  return { jsdocComments, hasExactJsdoc, exactPathItem };
+}
+
 // src/index.ts
+var import_node_path = require("path");
 async function generate(options = {}) {
   const cwd = options.cwd ?? process.cwd();
   const config = await loadConfig(options.config);
   if (options.provider) config.provider = options.provider;
   if (options.cache === false) config.cache = false;
+  if (config.envFile !== false) {
+    const { config: dotenvConfig } = await import("dotenv");
+    for (const file of config.envFile) {
+      dotenvConfig({ path: (0, import_node_path.resolve)(cwd, file), override: false });
+    }
+  }
   console.log(`[openapi-ai-generator] Scanning routes...`);
   const routes = await scanRoutes(config.include, config.exclude, cwd);
   console.log(`[openapi-ai-generator] Found ${routes.length} route(s)`);
@@ -501,10 +533,7 @@ async function generate(options = {}) {
 // src/cli.ts
 var program = new import_commander.Command();
 program.name("openapi-ai-generator").description("Generate OpenAPI 3.1 specs from Next.js API routes using AI").version("0.1.0");
-program.command("generate").description("Scan Next.js API routes and generate an OpenAPI spec").option("-c, --config <path>", "Path to config file (default: openapi-gen.config.ts)").option(
-  "-p, --provider <provider>",
-  "Override provider (azure | openai | anthropic)"
-).option("--no-cache", "Disable caching (always re-analyze all routes)").action(async (opts) => {
+program.command("generate").description("Scan Next.js API routes and generate an OpenAPI spec").option("-c, --config <path>", "Path to config file (default: openapi-gen.config.ts)").option("-p, --provider <provider>", "Override provider (azure | openai | anthropic)").option("--no-cache", "Disable caching (always re-analyze all routes)").action(async (opts) => {
   try {
     const result = await generate({
       config: opts.config,
@@ -515,7 +544,9 @@ program.command("generate").description("Scan Next.js API routes and generate an
 \u2713 OpenAPI spec generated successfully`);
     console.log(`  Routes analyzed:    ${result.routesAnalyzed}`);
     console.log(`  From cache:         ${result.routesFromCache}`);
-    console.log(`  LLM calls made:     ${result.routesAnalyzed - result.routesFromCache - (result.routesSkippedLLM - result.routesFromCache)}`);
+    console.log(
+      `  LLM calls made:     ${result.routesAnalyzed - result.routesFromCache - (result.routesSkippedLLM - result.routesFromCache)}`
+    );
     console.log(`  Spec written to:    ${result.specPath}`);
   } catch (err) {
     console.error("[openapi-ai-generator] Error:", err instanceof Error ? err.message : err);