shokupan 0.0.1 → 0.1.0

package/dist/openapi-analyzer-CFqgSLNK.cjs

@@ -0,0 +1,769 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const fs = require("node:fs");
+const path = require("node:path");
+const ts = require("typescript");
+class OpenAPIAnalyzer {
+  constructor(rootDir, entrypoint) {
+    this.rootDir = rootDir;
+    if (entrypoint) {
+      this.entrypoint = path.resolve(entrypoint);
+    }
+  }
+  files = [];
+  applications = [];
+  program;
+  entrypoint;
+  /**
+   * Main analysis entry point
+   */
+  /**
+   * Main analysis entry point
+   */
+  async analyze() {
+    await this.parseTypeScriptFiles();
+    await this.processSourceMaps();
+    await this.findApplications();
+    await this.extractRoutes();
+    return { applications: this.applications };
+  }
+  /**
+   * Recursively scan directory for TypeScript/JavaScript files
+   */
+  async scanDirectory(dir) {
+    try {
+      const entries = fs.readdirSync(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+          if (entry.name === "node_modules" || entry.name === ".git" || entry.name === "dist") {
+            continue;
+          }
+          await this.scanDirectory(fullPath);
+        } else {
+          const ext = path.extname(entry.name);
+          if (ext === ".ts") {
+            this.files.push({ path: fullPath, type: "ts" });
+          } else if (ext === ".js") {
+            this.files.push({ path: fullPath, type: "js" });
+          } else if (ext === ".map") {
+            this.files.push({ path: fullPath, type: "map" });
+          }
+        }
+      }
+    } catch (error) {
+      if (error.code !== "ENOENT" && error.code !== "EACCES") {
+        throw error;
+      }
+    }
+  }
+  /**
+   * Process source maps to reconstruct TypeScript
+   */
+  async processSourceMaps() {
+    const jsFiles = this.files.filter((f) => f.type === "js");
+    const mapFiles = this.files.filter((f) => f.type === "map");
+    for (const jsFile of jsFiles) {
+      const mapFile = mapFiles.find((m) => m.path === jsFile.path + ".map");
+      if (mapFile && !this.files.some((f) => f.path === jsFile.path.replace(/\.js$/, ".ts"))) {
+        console.log(`Note: Found ${jsFile.path} with source map but no .ts file. Will parse JS directly.`);
+      }
+    }
+  }
+  /**
+   * Parse TypeScript files and create AST
+   */
+  async parseTypeScriptFiles() {
+    let fileNames = [];
+    if (this.entrypoint) {
+      fileNames = [this.entrypoint];
+    } else {
+      await this.scanDirectory(this.rootDir);
+      const tsFiles = this.files.filter((f) => f.type === "ts" || f.type === "js");
+      fileNames = tsFiles.map((f) => f.path);
+    }
+    this.program = ts.createProgram(fileNames, {
+      target: ts.ScriptTarget.ESNext,
+      module: ts.ModuleKind.ESNext,
+      allowJs: true,
+      moduleResolution: ts.ModuleResolutionKind.Node10,
+      rootDir: this.rootDir,
+      skipLibCheck: true,
+      skipDefaultLibCheck: true
+    });
+    if (this.entrypoint) {
+      this.files = this.program.getSourceFiles().filter((sf) => !sf.fileName.includes("node_modules")).map((sf) => ({ path: sf.fileName, type: sf.fileName.endsWith(".js") ? "js" : "ts" }));
+    }
+  }
+  /**
+   * Find all Shokupan/ShokupanRouter instances
+   */
+  async findApplications() {
+    if (!this.program) return;
+    const typeChecker = this.program.getTypeChecker();
+    for (const sourceFile of this.program.getSourceFiles()) {
+      if (sourceFile.fileName.includes("node_modules")) continue;
+      if (sourceFile.isDeclarationFile) continue;
+      if (sourceFile.fileName.includes(".test.ts") || sourceFile.fileName.includes(".spec.ts")) continue;
+      ts.forEachChild(sourceFile, (node) => {
+        this.visitNode(node, sourceFile, typeChecker);
+      });
+    }
+  }
+  /**
+   * Visit AST node to find application instances
+   */
+  visitNode(node, sourceFile, typeChecker) {
+    if (ts.isClassDeclaration(node)) {
+      let isController = false;
+      let className = node.name?.getText(sourceFile);
+      if (node.decorators) {
+        const controllerDecorator = node.decorators.find((d) => {
+          const expr = d.expression;
+          if (ts.isCallExpression(expr)) {
+            const identifier = expr.expression.getText(sourceFile);
+            return identifier === "Controller";
+          }
+          return false;
+        });
+        if (controllerDecorator) isController = true;
+      }
+      if (!isController) {
+        const hasRouteDecorators = node.members.some((m) => {
+          if (ts.isMethodDeclaration(m) || m.kind === 175 || m.kind === 170 || m.kind === 171) {
+            const decs = m.decorators || m.modifiers?.filter((mod) => ts.isDecorator(mod));
+            if (decs) {
+              return decs.some((d) => {
+                const expr = d.expression;
+                if (ts.isCallExpression(expr)) {
+                  const identifier = expr.expression.getText(sourceFile);
+                  return ["Get", "Post", "Put", "Delete", "Patch", "Options", "Head"].includes(identifier);
+                }
+                return false;
+              });
+            }
+          }
+          return false;
+        });
+        if (hasRouteDecorators) {
+          isController = true;
+        }
+      }
+      if (isController && className) {
+        this.applications.push({
+          name: className,
+          filePath: sourceFile.fileName,
+          className: "Controller",
+          routes: [],
+          mounted: []
+        });
+      }
+    }
+    if (ts.isVariableDeclaration(node) && node.initializer) {
+      if (ts.isNewExpression(node.initializer)) {
+        const expr = node.initializer;
+        const className = expr.expression.getText(sourceFile);
+        if (className === "Shokupan" || className === "ShokupanRouter") {
+          const varName = node.name.getText(sourceFile);
+          this.applications.push({
+            name: varName,
+            filePath: sourceFile.fileName,
+            className,
+            routes: [],
+            mounted: []
+          });
+        }
+      }
+    }
+    ts.forEachChild(node, (child) => this.visitNode(child, sourceFile, typeChecker));
+  }
+  /**
+   * Extract route information from applications
+   */
+  async extractRoutes() {
+    if (!this.program) return;
+    for (const app of this.applications) {
+      const sourceFile = this.program.getSourceFile(app.filePath);
+      if (!sourceFile) continue;
+      this.extractRoutesFromFile(app, sourceFile);
+    }
+  }
+  /**
+   * Extract routes from a Controller class
+   */
+  extractRoutesFromController(app, classNode, sourceFile) {
+    const methods = classNode.members.filter((m) => ts.isMethodDeclaration(m) || m.kind === 175);
+    for (const method of methods) {
+      const methodNode = method;
+      if (!methodNode.decorators && !methodNode.modifiers) continue;
+      const decorators = methodNode.decorators || methodNode.modifiers?.filter((m) => ts.isDecorator(m));
+      if (!decorators) continue;
+      const routeDecorator = decorators.find((d) => {
+        const expr = d.expression;
+        if (ts.isCallExpression(expr)) {
+          const identifier = expr.expression.getText(sourceFile);
+          return ["Get", "Post", "Put", "Delete", "Patch", "Options", "Head"].includes(identifier);
+        }
+        return false;
+      });
+      if (routeDecorator && ts.isCallExpression(routeDecorator.expression)) {
+        const decoratorName = routeDecorator.expression.expression.getText(sourceFile);
+        const httpMethod = decoratorName.toUpperCase();
+        let routePath = "/";
+        const pathArg = routeDecorator.expression.arguments[0];
+        if (pathArg && ts.isStringLiteral(pathArg)) {
+          routePath = pathArg.text;
+        }
+        routePath = routePath.replace(/:([a-zA-Z0-9_]+)/g, "{$1}");
+        const handlerName = `${app.name}.${methodNode.name.getText(sourceFile)}`;
+        const analysis = this.analyzeHandler(methodNode, sourceFile);
+        app.routes.push({
+          method: httpMethod,
+          path: routePath,
+          handlerName,
+          handlerSource: methodNode.getText(sourceFile),
+          requestTypes: analysis.requestTypes,
+          responseType: analysis.responseType,
+          responseSchema: analysis.responseSchema
+        });
+      }
+    }
+  }
+  /**
+   * Extract routes from a specific file
+   */
+  extractRoutesFromFile(app, sourceFile) {
+    if (app.className === "Controller") {
+      const classNode = sourceFile.statements.find((s) => ts.isClassDeclaration(s) && s.name?.getText(sourceFile) === app.name);
+      if (classNode) {
+        this.extractRoutesFromController(app, classNode, sourceFile);
+      }
+    } else {
+      const visit = (node) => {
+        if (ts.isCallExpression(node)) {
+          const expr = node.expression;
+          if (ts.isPropertyAccessExpression(expr)) {
+            const objName = expr.expression.getText(sourceFile);
+            const methodName = expr.name.getText(sourceFile);
+            if (objName === app.name) {
+              if (["get", "post", "put", "delete", "patch", "options", "head"].includes(methodName)) {
+                const route = this.extractRouteFromCall(node, sourceFile, methodName.toUpperCase());
+                if (route) {
+                  app.routes.push(route);
+                }
+              } else if (methodName === "mount") {
+                const mount = this.extractMountFromCall(node, sourceFile);
+                if (mount) {
+                  app.mounted.push(mount);
+                }
+              }
+            }
+          }
+        }
+        ts.forEachChild(node, visit);
+      };
+      ts.forEachChild(sourceFile, visit);
+    }
+  }
+  /**
+   * Extract route information from a route call (e.g., app.get('/path', handler))
+   */
+  extractRouteFromCall(node, sourceFile, method) {
+    const args = node.arguments;
+    if (args.length < 2) return null;
+    const pathArg = args[0];
+    let routePath = "/";
+    if (ts.isStringLiteral(pathArg)) {
+      routePath = pathArg.text;
+    }
+    const normalizedPath = routePath.replace(/:([a-zA-Z0-9_]+)/g, "{$1}");
+    let metadata = {};
+    if (args.length >= 3 && ts.isObjectLiteralExpression(args[1])) {
+      const metaObj = args[1];
+      this.convertExpressionToSchema(metaObj, sourceFile, /* @__PURE__ */ new Map());
+      for (const prop of metaObj.properties) {
+        if (ts.isPropertyAssignment(prop) && prop.name) {
+          const name = prop.name.getText(sourceFile);
+          const val = prop.initializer;
+          if (ts.isStringLiteral(val)) {
+            metadata[name] = val.text;
+          } else if (ts.isArrayLiteralExpression(val) && name === "tags") {
+            metadata.tags = val.elements.filter((e) => ts.isStringLiteral(e)).map((e) => e.text);
+          } else if (name === "operationId" && ts.isStringLiteral(val)) {
+            metadata.operationId = val.text;
+          }
+        }
+      }
+    }
+    const handlerArg = args[args.length - 1];
+    const handlerInfo = this.analyzeHandler(handlerArg, sourceFile);
+    return {
+      method,
+      path: normalizedPath,
+      handlerName: handlerArg.getText(sourceFile).substring(0, 50),
+      // Truncate for display
+      handlerSource: handlerArg.getText(sourceFile),
+      requestTypes: handlerInfo.requestTypes,
+      responseType: handlerInfo.responseType,
+      responseSchema: handlerInfo.responseSchema,
+      ...metadata
+    };
+  }
+  /**
+   * Analyze a route handler to extract type information
+   */
+  analyzeHandler(handler, sourceFile) {
+    const requestTypes = {};
+    let responseType;
+    let responseSchema;
+    const scope = /* @__PURE__ */ new Map();
+    if (ts.isFunctionLike(handler)) {
+      handler.parameters.forEach((param) => {
+        if (ts.isIdentifier(param.name) && param.type) {
+          const paramName = param.name.getText(sourceFile);
+          const paramType = this.convertTypeNodeToSchema(param.type, sourceFile);
+          if (paramType) {
+            scope.set(paramName, paramType);
+          }
+        }
+      });
+    }
+    const analyzeReturnExpression = (expr) => {
+      let node = expr;
+      if (ts.isAwaitExpression(node)) {
+        node = node.expression;
+      }
+      if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression)) {
+        const callObj = node.expression.expression.getText(sourceFile);
+        const callProp = node.expression.name.getText(sourceFile);
+        if ((callObj === "ctx" || callObj.endsWith(".ctx")) && callProp === "json") {
+          if (node.arguments.length > 0) {
+            responseSchema = this.convertExpressionToSchema(node.arguments[0], sourceFile, scope);
+            responseType = "object";
+          }
+          return;
+        }
+      }
+      if (!responseSchema || responseSchema.type === "object") {
+        const schema = this.convertExpressionToSchema(node, sourceFile, scope);
+        if (schema && (schema.type !== "object" || Object.keys(schema.properties || {}).length > 0)) {
+          responseSchema = schema;
+          responseType = schema.type;
+        }
+      }
+      if (!responseSchema && !responseType) {
+        const returnText = node.getText(sourceFile);
+        if (returnText.startsWith("{")) {
+          responseType = "object";
+        } else if (returnText.startsWith("[")) {
+          responseType = "array";
+        } else if (returnText.startsWith('"') || returnText.startsWith("'")) {
+          responseType = "string";
+        }
+      }
+    };
+    let body;
+    if (ts.isArrowFunction(handler) || ts.isFunctionExpression(handler) || ts.isMethodDeclaration(handler) || handler.kind === 175) {
+      body = handler.body;
+      const visit = (node) => {
+        if (ts.isAsExpression(node)) {
+          if (this.isCtxBodyCall(node.expression, sourceFile)) {
+            const schema = this.convertTypeNodeToSchema(node.type, sourceFile);
+            if (schema) {
+              requestTypes.body = schema;
+              if (ts.isVariableDeclaration(node.parent)) {
+                const varName = node.parent.name.getText(sourceFile);
+                scope.set(varName, schema);
+              }
+            }
+          }
+        }
+        if (ts.isPropertyAccessExpression(node)) {
+          const objText = node.expression.getText(sourceFile);
+          const propText = node.name.getText(sourceFile);
+          if (objText === "ctx" || objText.endsWith(".ctx")) {
+            if (propText === "body") {
+              if (!requestTypes.body) {
+                requestTypes.body = { type: "object" };
+              }
+            } else if (propText === "query") {
+              if (!requestTypes.query) requestTypes.query = {};
+            } else if (propText === "params") {
+              if (!requestTypes.params) requestTypes.params = {};
+            } else if (propText === "headers") {
+              if (!requestTypes.headers) requestTypes.headers = {};
+            }
+          }
+        }
+        if (ts.isReturnStatement(node) && node.expression) {
+          analyzeReturnExpression(node.expression);
+        }
+        if (ts.isArrowFunction(node) && !ts.isBlock(node.body)) {
+          analyzeReturnExpression(node.body);
+        }
+        ts.forEachChild(node, visit);
+      };
+      if (ts.isBlock(body)) {
+        ts.forEachChild(body, visit);
+      } else {
+        analyzeReturnExpression(body);
+        ts.forEachChild(body, visit);
+      }
+    }
+    return { requestTypes, responseType, responseSchema };
+  }
+  /**
+   * Convert an Expression node to an OpenAPI schema (best effort)
+   */
+  convertExpressionToSchema(node, sourceFile, scope) {
+    if (ts.isObjectLiteralExpression(node)) {
+      const schema = {
+        type: "object",
+        properties: {},
+        required: []
+      };
+      for (const prop of node.properties) {
+        if (ts.isPropertyAssignment(prop)) {
+          const name = prop.name.getText(sourceFile);
+          const valueSchema = this.convertExpressionToSchema(prop.initializer, sourceFile, scope);
+          schema.properties[name] = valueSchema;
+          schema.required.push(name);
+        } else if (ts.isShorthandPropertyAssignment(prop)) {
+          const name = prop.name.getText(sourceFile);
+          const scopedSchema = scope.get(name);
+          schema.properties[name] = scopedSchema || { type: "object" };
+          schema.required.push(name);
+        }
+      }
+      if (schema.required.length === 0) {
+        delete schema.required;
+      }
+      return schema;
+    }
+    if (ts.isArrayLiteralExpression(node)) {
+      const schema = { type: "array" };
+      if (node.elements.length > 0) {
+        schema.items = this.convertExpressionToSchema(node.elements[0], sourceFile, scope);
+      } else {
+        schema.items = {};
+      }
+      return schema;
+    }
+    if (ts.isConditionalExpression(node)) {
+      const trueSchema = this.convertExpressionToSchema(node.whenTrue, sourceFile, scope);
+      return trueSchema;
+    }
+    if (ts.isTemplateExpression(node)) {
+      return { type: "string" };
+    }
+    if (ts.isIdentifier(node)) {
+      const name = node.getText(sourceFile);
+      const scopedSchema = scope.get(name);
+      if (scopedSchema) return scopedSchema;
+      return { type: "object" };
+    }
+    if (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)) return { type: "string" };
+    if (ts.isNumericLiteral(node)) return { type: "number" };
+    if (node.kind === ts.SyntaxKind.TrueKeyword || node.kind === ts.SyntaxKind.FalseKeyword) return { type: "boolean" };
+    return { type: "object" };
+  }
+  /**
+   * Check if an expression is a call to ctx.body()
+   */
+  isCtxBodyCall(node, sourceFile) {
+    if (ts.isAwaitExpression(node)) {
+      return this.isCtxBodyCall(node.expression, sourceFile);
+    }
+    if (ts.isCallExpression(node)) {
+      if (ts.isPropertyAccessExpression(node.expression)) {
+        const objText = node.expression.expression.getText(sourceFile);
+        const propText = node.expression.name.getText(sourceFile);
+        return (objText === "ctx" || objText.endsWith(".ctx")) && propText === "body";
+      }
+    }
+    return false;
+  }
+  /**
+   * Convert a TypeScript TypeNode to an OpenAPI schema
+   */
+  convertTypeNodeToSchema(typeNode, sourceFile) {
+    switch (typeNode.kind) {
+      case ts.SyntaxKind.StringKeyword:
+        return { type: "string" };
+      case ts.SyntaxKind.NumberKeyword:
+        return { type: "number" };
+      case ts.SyntaxKind.BooleanKeyword:
+        return { type: "boolean" };
+      case ts.SyntaxKind.AnyKeyword:
+      case ts.SyntaxKind.UnknownKeyword:
+        return {};
+      // Any/Unknown -> empty schema (accepts anything)
+      case ts.SyntaxKind.TypeLiteral: {
+        const literal = typeNode;
+        const schema = {
+          type: "object",
+          properties: {},
+          required: []
+        };
+        for (const member of literal.members) {
+          if (ts.isPropertySignature(member) && member.type) {
+            const name = member.name.getText(sourceFile);
+            const propSchema = this.convertTypeNodeToSchema(member.type, sourceFile);
+            schema.properties[name] = propSchema;
+            if (!member.questionToken) {
+              schema.required.push(name);
+            }
+          }
+        }
+        if (schema.required.length === 0) {
+          delete schema.required;
+        }
+        return schema;
+      }
+      case ts.SyntaxKind.ArrayType: {
+        const arrayType = typeNode;
+        return {
+          type: "array",
+          items: this.convertTypeNodeToSchema(arrayType.elementType, sourceFile)
+        };
+      }
+      // Handle Type References (e.g. Array<string>)
+      case ts.SyntaxKind.TypeReference: {
+        const typeRef = typeNode;
+        const typeName = typeRef.typeName.getText(sourceFile);
+        if (typeName === "Array" && typeRef.typeArguments && typeRef.typeArguments.length > 0) {
+          return {
+            type: "array",
+            items: this.convertTypeNodeToSchema(typeRef.typeArguments[0], sourceFile)
+          };
+        }
+        return { type: "object", description: `Ref: ${typeName}` };
+      }
+      default:
+        return { type: "object" };
+    }
+  }
+  /**
+   * Extract mount information from mount call
+   */
+  extractMountFromCall(node, sourceFile) {
+    const args = node.arguments;
+    if (args.length < 2) return null;
+    const pathArg = args[0];
+    const targetArg = args[1];
+    let prefix = "/";
+    if (ts.isStringLiteral(pathArg)) {
+      prefix = pathArg.text;
+    }
+    const target = targetArg.getText(sourceFile);
+    const dependency = this.checkIfExternalDependency(target, sourceFile);
+    return {
+      prefix,
+      target,
+      dependency
+    };
+  }
+  /**
+   * Check if a reference is to an external dependency
+   */
+  checkIfExternalDependency(identifier, sourceFile) {
+    const imports = [];
+    ts.forEachChild(sourceFile, (node) => {
+      if (ts.isImportDeclaration(node)) {
+        imports.push(node);
+      }
+    });
+    for (const imp of imports) {
+      const moduleSpecifier = imp.moduleSpecifier;
+      if (ts.isStringLiteral(moduleSpecifier)) {
+        const modulePath = moduleSpecifier.text;
+        if (!modulePath.startsWith(".") && !modulePath.startsWith("/")) {
+          const namedBindings = imp.importClause?.namedBindings;
+          if (namedBindings && ts.isNamedImports(namedBindings)) {
+            for (const element of namedBindings.elements) {
+              if (element.name.text === identifier) {
+                const version = this.getPackageVersion(modulePath);
+                return {
+                  packageName: modulePath,
+                  version,
+                  importPath: modulePath,
+                  isExternal: true
+                };
+              }
+            }
+          }
+        }
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Get package version from package.json
+   */
+  getPackageVersion(packageName) {
+    try {
+      const packageJsonPath = path.join(this.rootDir, "node_modules", packageName, "package.json");
+      if (fs.existsSync(packageJsonPath)) {
+        const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+        return packageJson.version;
+      }
+    } catch (e) {
+    }
+    return void 0;
+  }
+  /**
+   * Generate OpenAPI specification
+   */
+  generateOpenAPISpec() {
+    const paths = {};
+    const collectRoutes = (app, prefix = "") => {
+      for (const route of app.routes) {
+        const cleanPrefix = prefix.endsWith("/") ? prefix.slice(0, -1) : prefix;
+        const cleanPath = route.path.startsWith("/") ? route.path : "/" + route.path;
+        const fullPath = cleanPrefix + cleanPath || "/";
+        const pathKey = fullPath.replace(/:([a-zA-Z0-9_]+)/g, "{$1}");
+        if (!paths[pathKey]) {
+          paths[pathKey] = {};
+        }
+        const method = route.method.toLowerCase();
+        const operation = {
+          summary: route.summary || `${route.method.toUpperCase()} ${pathKey}`,
+          description: route.description,
+          tags: route.tags,
+          operationId: route.operationId,
+          responses: {
+            "200": {
+              description: "Successful response"
+            }
+          }
+        };
+        if (!operation.description) delete operation.description;
+        if (!operation.tags) delete operation.tags;
+        if (!operation.operationId) delete operation.operationId;
+        if (route.responseSchema) {
+          operation.responses["200"].content = {
+            "application/json": {
+              schema: route.responseSchema
+            }
+          };
+        } else if (route.responseType) {
+          const contentType = route.responseType === "string" ? "text/plain" : "application/json";
+          operation.responses["200"].content = {
+            [contentType]: {
+              schema: { type: route.responseType }
+            }
+          };
+        } else {
+          operation.responses["200"].content = {
+            "application/json": {
+              schema: { type: "object" }
+            }
+          };
+        }
+        if (route.requestTypes?.body) {
+          operation.requestBody = {
+            content: {
+              "application/json": {
+                schema: route.requestTypes.body
+              }
+            }
+          };
+        }
+        const parameters = [];
+        if (route.requestTypes?.query) {
+          for (const [key] of Object.entries(route.requestTypes.query)) {
+            parameters.push({
+              name: key,
+              in: "query",
+              schema: { type: "string" }
+            });
+          }
+        }
+        if (route.requestTypes?.params) {
+          for (const [key] of Object.entries(route.requestTypes.params)) {
+            parameters.push({
+              name: key,
+              in: "path",
+              required: true,
+              schema: { type: "string" }
+            });
+          }
+        }
+        const pathParams = pathKey.match(/{([^}]+)}/g);
+        if (pathParams) {
+          pathParams.forEach((p) => {
+            const name = p.slice(1, -1);
+            if (!parameters.some((param) => param.name === name && param.in === "path")) {
+              parameters.push({
+                name,
+                in: "path",
+                required: true,
+                schema: { type: "string" }
+                // Default to string
+              });
+            }
+          });
+        }
+        if (parameters.length > 0) {
+          operation.parameters = parameters;
+        }
+        paths[pathKey][method] = operation;
+      }
+      for (const mount of app.mounted) {
+        const mountedApp = this.applications.find((a) => a.name === mount.target || a.className === mount.target);
+        if (mountedApp) {
+          if (mountedApp === app) continue;
+          const cleanPrefix = prefix.endsWith("/") ? prefix.slice(0, -1) : prefix;
+          const mountPrefix = mount.prefix.startsWith("/") ? mount.prefix : "/" + mount.prefix;
+          const nextPrefix = cleanPrefix + mountPrefix;
+          collectRoutes(mountedApp, nextPrefix);
+        }
+      }
+    };
+    for (const app of this.applications) {
+      const isMounted = this.applications.some(
+        (parent) => parent.mounted.some((m) => m.target === app.name || m.target === app.className)
+      );
+      if (!isMounted) {
+        collectRoutes(app);
+      }
+    }
+    return {
+      openapi: "3.1.0",
+      info: {
+        title: "Shokupan API",
+        version: "1.0.0",
+        description: "Auto-generated from Shokupan application analysis"
+      },
+      paths,
+      components: {
+        schemas: {}
+      }
+    };
+  }
+  /**
+   * Convert a type string to an OpenAPI schema
+   */
+  typeToSchema(type) {
+    switch (type) {
+      case "string":
+        return { type: "string" };
+      case "number":
+        return { type: "number" };
+      case "boolean":
+        return { type: "boolean" };
+      case "array":
+        return { type: "array", items: {} };
+      case "object":
+      default:
+        return { type: "object" };
+    }
+  }
+}
+async function analyzeDirectory(directory) {
+  const analyzer = new OpenAPIAnalyzer(directory);
+  return await analyzer.analyze();
+}
+exports.OpenAPIAnalyzer = OpenAPIAnalyzer;
+exports.analyzeDirectory = analyzeDirectory;
+//# sourceMappingURL=openapi-analyzer-CFqgSLNK.cjs.map