@contractspec/lib.source-extractors 0.11.0 → 0.13.0

package/dist/browser/index.js

@@ -0,0 +1,1215 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// src/codegen/index.ts
+var exports_codegen = {};
+__export(exports_codegen, {
+  generateSchemas: () => generateSchemas,
+  generateSchema: () => generateSchema,
+  generateRegistry: () => generateRegistry,
+  generateOperations: () => generateOperations,
+  generateOperation: () => generateOperation
+});
+
+// src/codegen/operation-gen.ts
+function generateOperation(endpoint, options) {
+  const specName = toSpecName(endpoint);
+  const fileName = `${toFileName(endpoint)}.ts`;
+  const code = generateOperationCode(endpoint, specName, options);
+  return {
+    path: fileName,
+    content: code,
+    type: "operation"
+  };
+}
+function generateOperations(ir, options) {
+  return ir.endpoints.map((endpoint) => generateOperation(endpoint, options));
+}
+function toSpecName(endpoint) {
+  const parts = endpoint.path.replace(/^\//, "").split("/").filter((p) => p && !p.startsWith(":") && !p.startsWith("{"));
+  const methodPart = endpoint.method.toLowerCase();
+  const pathPart = parts.map((p) => p.charAt(0).toUpperCase() + p.slice(1)).join("");
+  return `${methodPart}${pathPart}Spec`;
+}
+function toFileName(endpoint) {
+  const parts = endpoint.path.replace(/^\//, "").split("/").filter((p) => p && !p.startsWith(":") && !p.startsWith("{"));
+  const methodPart = endpoint.method.toLowerCase();
+  const pathPart = parts.join("-");
+  return `${methodPart}-${pathPart}`.replace(/--+/g, "-");
+}
+function generateOperationCode(endpoint, specName, options) {
+  const isCommand = endpoint.kind === "command";
+  const defineFunc = isCommand ? "defineCommand" : "defineQuery";
+  const auth = options.defaultAuth ?? "user";
+  const owners = options.defaultOwners ?? ["team"];
+  const lines = [
+    `/**`,
+    ` * ${endpoint.method} ${endpoint.path}`,
+    ` *`,
+    ` * Generated from: ${endpoint.source.file}:${endpoint.source.startLine}`,
+    ` * Confidence: ${endpoint.confidence.level}`,
+    ` */`,
+    ``,
+    `import { ${defineFunc} } from '@contractspec/lib.contracts';`,
+    `import { fromZod } from '@contractspec/lib.schema';`,
+    `import { z } from 'zod';`,
+    ``,
+    `// TODO: Define input schema based on extracted information`,
+    `const inputSchema = fromZod(z.object({`,
+    `  // Add fields here`,
+    `}));`,
+    ``,
+    `// TODO: Define output schema`,
+    `const outputSchema = fromZod(z.object({`,
+    `  // Add fields here`,
+    `}));`,
+    ``,
+    `export const ${specName} = ${defineFunc}({`,
+    `  meta: {`,
+    `    name: '${endpoint.handlerName ?? endpoint.id}',`,
+    `    version: 1,`,
+    `    stability: 'experimental',`,
+    `    owners: ${JSON.stringify(owners)},`,
+    `    goal: 'TODO: Describe the business goal',`,
+    `    context: 'Generated from ${endpoint.source.file}',`,
+    `  },`,
+    `  io: {`,
+    `    input: inputSchema,`,
+    `    output: outputSchema,`,
+    `  },`,
+    `  policy: {`,
+    `    auth: '${auth}',`,
+    `  },`,
+    `  transport: {`,
+    `    rest: {`,
+    `      method: '${endpoint.method}',`,
+    `      path: '${endpoint.path}',`,
+    `    },`,
+    `  },`,
+    `});`,
+    ``
+  ];
+  return lines.join(`
+`);
+}
+// src/codegen/schema-gen.ts
+function generateSchema(schema, _options) {
+  const fileName = `${toFileName2(schema.name)}.ts`;
+  const code = generateSchemaCode(schema);
+  return {
+    path: `schemas/${fileName}`,
+    content: code,
+    type: "schema"
+  };
+}
+function generateSchemas(ir, options) {
+  return ir.schemas.map((schema) => generateSchema(schema, options));
+}
+function toFileName2(name) {
+  return name.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/([A-Z])([A-Z][a-z])/g, "$1-$2").toLowerCase();
+}
+function generateSchemaCode(schema) {
+  const lines = [
+    `/**`,
+    ` * ${schema.name}`,
+    ` *`,
+    ` * Generated from: ${schema.source.file}:${schema.source.startLine}`,
+    ` * Schema type: ${schema.schemaType}`,
+    ` * Confidence: ${schema.confidence.level}`,
+    ` */`,
+    ``,
+    `import { fromZod } from '@contractspec/lib.schema';`,
+    `import { z } from 'zod';`,
+    ``
+  ];
+  if (schema.rawDefinition && schema.schemaType === "zod") {
+    lines.push(`// Original definition from source:`);
+    lines.push(`// ${schema.rawDefinition.split(`
+`)[0]}`);
+    lines.push(``);
+  }
+  lines.push(`export const ${schema.name}Schema = fromZod(z.object({`);
+  if (schema.fields && schema.fields.length > 0) {
+    for (const field of schema.fields) {
+      const zodType = mapToZodType(field.type, field.optional);
+      lines.push(`  ${field.name}: ${zodType},`);
+    }
+  } else {
+    lines.push(`  // TODO: Define schema fields`);
+  }
+  lines.push(`}));`);
+  lines.push(``);
+  lines.push(`export type ${schema.name} = z.infer<typeof ${schema.name}Schema.zodSchema>;`);
+  lines.push(``);
+  return lines.join(`
+`);
+}
+function mapToZodType(tsType, optional) {
+  let zodType;
+  switch (tsType.toLowerCase()) {
+    case "string":
+      zodType = "z.string()";
+      break;
+    case "number":
+      zodType = "z.number()";
+      break;
+    case "boolean":
+      zodType = "z.boolean()";
+      break;
+    case "date":
+      zodType = "z.date()";
+      break;
+    case "string[]":
+    case "array<string>":
+      zodType = "z.array(z.string())";
+      break;
+    case "number[]":
+    case "array<number>":
+      zodType = "z.array(z.number())";
+      break;
+    default:
+      zodType = "z.unknown()";
+  }
+  return optional ? `${zodType}.optional()` : zodType;
+}
+// src/codegen/registry-gen.ts
+function generateRegistry(operationFiles) {
+  const operationImports = operationFiles.filter((f) => f.type === "operation").map((f) => {
+    const name = f.path.replace(".ts", "").replace(/-/g, "_");
+    const specName = toPascalCase(name) + "Spec";
+    return { path: f.path, name, specName };
+  });
+  const lines = [
+    `/**`,
+    ` * Generated operation registry.`,
+    ` */`,
+    ``,
+    `import { OperationSpecRegistry } from '@contractspec/lib.contracts';`,
+    ``
+  ];
+  for (const op of operationImports) {
+    const importPath = `./${op.path.replace(".ts", "")}`;
+    lines.push(`import { ${op.specName} } from '${importPath}';`);
+  }
+  lines.push(``);
+  lines.push(`export const operationRegistry = new OperationSpecRegistry();`);
+  lines.push(``);
+  for (const op of operationImports) {
+    lines.push(`operationRegistry.register(${op.specName});`);
+  }
+  lines.push(``);
+  return {
+    path: "registry.ts",
+    content: lines.join(`
+`),
+    type: "registry"
+  };
+}
+function toPascalCase(str) {
+  return str.split(/[-_]/).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+}
+// src/extractors/index.ts
+var exports_extractors = {};
+__export(exports_extractors, {
+  registerAllExtractors: () => registerAllExtractors,
+  ZodSchemaExtractor: () => ZodSchemaExtractor,
+  TrpcExtractor: () => TrpcExtractor,
+  NextApiExtractor: () => NextApiExtractor,
+  NestJsExtractor: () => NestJsExtractor,
+  HonoExtractor: () => HonoExtractor,
+  FastifyExtractor: () => FastifyExtractor,
+  ExpressExtractor: () => ExpressExtractor,
+  ElysiaExtractor: () => ElysiaExtractor,
+  BaseExtractor: () => BaseExtractor
+});
+
+// src/registry.ts
+class ExtractorRegistry {
+  extractors = new Map;
+  register(extractor) {
+    this.extractors.set(extractor.id, extractor);
+  }
+  unregister(id) {
+    return this.extractors.delete(id);
+  }
+  get(id) {
+    return this.extractors.get(id);
+  }
+  getAll() {
+    return Array.from(this.extractors.values());
+  }
+  async findMatching(project) {
+    const matches = [];
+    for (const extractor of this.extractors.values()) {
+      try {
+        if (await extractor.detect(project)) {
+          matches.push(extractor);
+        }
+      } catch {}
+    }
+    return matches.sort((a, b) => b.priority - a.priority);
+  }
+  findByFramework(framework) {
+    const matches = [];
+    for (const extractor of this.extractors.values()) {
+      if (extractor.frameworks.includes(framework)) {
+        matches.push(extractor);
+      }
+    }
+    return matches.sort((a, b) => b.priority - a.priority);
+  }
+  findForFramework(framework) {
+    return this.findByFramework(framework);
+  }
+  hasExtractorFor(framework) {
+    for (const extractor of this.extractors.values()) {
+      if (extractor.frameworks.includes(framework) || extractor.id === framework) {
+        return true;
+      }
+    }
+    return false;
+  }
+  getSupportedFrameworks() {
+    const frameworks = new Set;
+    for (const extractor of this.extractors.values()) {
+      frameworks.add(extractor.id);
+      for (const fw of extractor.frameworks) {
+        frameworks.add(fw);
+      }
+    }
+    return Array.from(frameworks);
+  }
+}
+var extractorRegistry = new ExtractorRegistry;
+function registerBuiltInExtractors() {}
+
+// src/extract.ts
+async function extractFromProject(project, options = {}) {
+  let extractors;
+  if (options.framework) {
+    extractors = extractorRegistry.findByFramework(options.framework);
+    if (extractors.length === 0) {
+      return {
+        success: false,
+        errors: [
+          {
+            code: "EXTRACTOR_NOT_FOUND",
+            message: `No extractor found for framework: ${options.framework}`,
+            recoverable: false
+          }
+        ]
+      };
+    }
+  } else {
+    extractors = await extractorRegistry.findMatching(project);
+    if (extractors.length === 0) {
+      return {
+        success: false,
+        errors: [
+          {
+            code: "NO_FRAMEWORK_DETECTED",
+            message: "No supported framework detected in project",
+            recoverable: false
+          }
+        ]
+      };
+    }
+  }
+  const extractor = extractors[0];
+  if (!extractor) {
+    return {
+      success: false,
+      errors: [
+        {
+          code: "NO_EXTRACTOR",
+          message: "No extractor available",
+          recoverable: false
+        }
+      ]
+    };
+  }
+  const result = await extractor.extract(project, options);
+  return result;
+}
+function mergeIRs(irs) {
+  if (irs.length === 0) {
+    throw new Error("Cannot merge empty IR array");
+  }
+  if (irs.length === 1) {
+    if (!irs[0])
+      throw new Error("First IR is undefined");
+    return irs[0];
+  }
+  const first = irs[0];
+  if (!first)
+    throw new Error("First IR is undefined");
+  const merged = {
+    version: "1.0",
+    extractedAt: new Date().toISOString(),
+    project: first.project,
+    endpoints: [],
+    schemas: [],
+    errors: [],
+    events: [],
+    ambiguities: [],
+    stats: {
+      filesScanned: 0,
+      endpointsFound: 0,
+      schemasFound: 0,
+      errorsFound: 0,
+      eventsFound: 0,
+      ambiguitiesFound: 0,
+      highConfidence: 0,
+      mediumConfidence: 0,
+      lowConfidence: 0
+    }
+  };
+  for (const ir of irs) {
+    merged.endpoints.push(...ir.endpoints);
+    merged.schemas.push(...ir.schemas);
+    merged.errors.push(...ir.errors);
+    merged.events.push(...ir.events);
+    merged.ambiguities.push(...ir.ambiguities);
+    merged.stats.filesScanned += ir.stats.filesScanned;
+    merged.stats.endpointsFound += ir.stats.endpointsFound;
+    merged.stats.schemasFound += ir.stats.schemasFound;
+    merged.stats.errorsFound += ir.stats.errorsFound;
+    merged.stats.eventsFound += ir.stats.eventsFound;
+    merged.stats.ambiguitiesFound += ir.stats.ambiguitiesFound;
+    merged.stats.highConfidence += ir.stats.highConfidence;
+    merged.stats.mediumConfidence += ir.stats.mediumConfidence;
+    merged.stats.lowConfidence += ir.stats.lowConfidence;
+  }
+  return merged;
+}
+function createEmptyIR(project) {
+  return {
+    version: "1.0",
+    extractedAt: new Date().toISOString(),
+    project,
+    endpoints: [],
+    schemas: [],
+    errors: [],
+    events: [],
+    ambiguities: [],
+    stats: {
+      filesScanned: 0,
+      endpointsFound: 0,
+      schemasFound: 0,
+      errorsFound: 0,
+      eventsFound: 0,
+      ambiguitiesFound: 0,
+      highConfidence: 0,
+      mediumConfidence: 0,
+      lowConfidence: 0
+    }
+  };
+}
+
+// src/extractors/base.ts
+class BaseExtractor {
+  priority = 10;
+  fs;
+  setFs(fs) {
+    this.fs = fs;
+  }
+  async detect(project) {
+    return project.frameworks.some((fw) => this.frameworks.includes(fw.id));
+  }
+  async extract(project, options) {
+    if (!this.fs) {
+      return {
+        success: false,
+        errors: [
+          {
+            code: "NO_FS_ADAPTER",
+            message: "File system adapter not configured",
+            recoverable: false
+          }
+        ]
+      };
+    }
+    const ir = createEmptyIR(project);
+    const ctx = {
+      project,
+      options,
+      fs: this.fs,
+      ir
+    };
+    try {
+      await this.doExtract(ctx);
+      this.calculateStats(ir);
+      return { success: true, ir };
+    } catch (error) {
+      return {
+        success: false,
+        errors: [
+          {
+            code: "EXTRACTION_ERROR",
+            message: error instanceof Error ? error.message : String(error),
+            recoverable: false
+          }
+        ]
+      };
+    }
+  }
+  calculateStats(ir) {
+    ir.stats.endpointsFound = ir.endpoints.length;
+    ir.stats.schemasFound = ir.schemas.length;
+    ir.stats.errorsFound = ir.errors.length;
+    ir.stats.eventsFound = ir.events.length;
+    ir.stats.ambiguitiesFound = ir.ambiguities.length;
+    const allItems = [
+      ...ir.endpoints,
+      ...ir.schemas,
+      ...ir.errors,
+      ...ir.events
+    ];
+    for (const item of allItems) {
+      switch (item.confidence.level) {
+        case "high":
+          ir.stats.highConfidence++;
+          break;
+        case "medium":
+          ir.stats.mediumConfidence++;
+          break;
+        case "low":
+        case "ambiguous":
+          ir.stats.lowConfidence++;
+          break;
+      }
+    }
+  }
+  generateEndpointId(method, path, handlerName) {
+    const pathPart = path.replace(/^\//, "").replace(/\//g, ".").replace(/:/g, "").replace(/\{/g, "").replace(/\}/g, "");
+    const base = `${method.toLowerCase()}.${pathPart}`;
+    return handlerName ? `${base}.${handlerName}` : base;
+  }
+  generateSchemaId(name, file) {
+    const filePart = file.replace(/\.ts$/, "").replace(/\//g, ".").replace(/^\.+/, "");
+    return `${filePart}.${name}`;
+  }
+  methodToOpKind(method) {
+    switch (method) {
+      case "GET":
+      case "HEAD":
+      case "OPTIONS":
+        return "query";
+      default:
+        return "command";
+    }
+  }
+  createLocation(file, startLine, endLine) {
+    return { file, startLine, endLine };
+  }
+  createConfidence(level, ...reasons) {
+    return { level, reasons };
+  }
+  addEndpoint(ctx, endpoint) {
+    ctx.ir.endpoints.push(endpoint);
+  }
+  addSchema(ctx, schema) {
+    ctx.ir.schemas.push(schema);
+  }
+}
+// src/extractors/nestjs/extractor.ts
+var PATTERNS = {
+  controller: /@Controller\s*\(\s*['"`]([^'"`]*)['"`]\s*\)/g,
+  route: /@(Get|Post|Put|Patch|Delete|Head|Options)\s*\(\s*(?:['"`]([^'"`]*)['"`])?\s*\)/g,
+  body: /@Body\s*\(\s*\)/g,
+  param: /@Param\s*\(\s*(?:['"`]([^'"`]*)['"`])?\s*\)/g,
+  query: /@Query\s*\(\s*(?:['"`]([^'"`]*)['"`])?\s*\)/g,
+  dto: /class\s+(\w+(?:Dto|DTO|Request|Response|Input|Output))\s*\{/g,
+  classValidator: /@(IsString|IsNumber|IsBoolean|IsArray|IsOptional|IsNotEmpty|Min|Max|Length|Matches)/g
+};
+
+class NestJsExtractor extends BaseExtractor {
+  id = "nestjs";
+  name = "NestJS Extractor";
+  frameworks = ["nestjs"];
+  priority = 20;
+  async doExtract(ctx) {
+    const { project, options, fs } = ctx;
+    const pattern = options.scope?.length ? options.scope.map((s) => `${s}/**/*.ts`).join(",") : "**/*.ts";
+    const files = await fs.glob(pattern, { cwd: project.rootPath });
+    ctx.ir.stats.filesScanned = files.length;
+    for (const file of files) {
+      if (file.includes("node_modules") || file.includes(".spec.") || file.includes(".test.")) {
+        continue;
+      }
+      const fullPath = `${project.rootPath}/${file}`;
+      const content = await fs.readFile(fullPath);
+      await this.extractControllers(ctx, file, content);
+      await this.extractDtos(ctx, file, content);
+    }
+  }
+  async extractControllers(ctx, file, content) {
+    const controllerMatches = [...content.matchAll(PATTERNS.controller)];
+    for (const controllerMatch of controllerMatches) {
+      const basePath = controllerMatch[1] || "";
+      const controllerIndex = controllerMatch.index ?? 0;
+      const afterDecorator = content.slice(controllerIndex);
+      const classMatch = afterDecorator.match(/class\s+(\w+)/);
+      const controllerName = classMatch?.[1] ?? "UnknownController";
+      const nextController = content.indexOf("@Controller", controllerIndex + 1);
+      const controllerBlock = nextController > 0 ? content.slice(controllerIndex, nextController) : content.slice(controllerIndex);
+      const routeMatches = [...controllerBlock.matchAll(PATTERNS.route)];
+      for (const routeMatch of routeMatches) {
+        const method = routeMatch[1]?.toUpperCase();
+        const routePath = routeMatch[2] || "";
+        const fullPath = this.normalizePath(`/${basePath}/${routePath}`);
+        const afterRoute = controllerBlock.slice(routeMatch.index ?? 0);
+        const methodMatch = afterRoute.match(/(?:async\s+)?(\w+)\s*\([^)]*\)\s*(?::\s*\w+(?:<[^>]+>)?)?\s*\{/);
+        const handlerName = methodMatch?.[1] ?? "unknownHandler";
+        const absoluteIndex = controllerIndex + (routeMatch.index ?? 0);
+        const lineNumber = content.slice(0, absoluteIndex).split(`
+`).length;
+        const hasBody = PATTERNS.body.test(afterRoute.slice(0, 200));
+        const hasParams = PATTERNS.param.test(afterRoute.slice(0, 200));
+        const hasQuery = PATTERNS.query.test(afterRoute.slice(0, 200));
+        const endpoint = {
+          id: this.generateEndpointId(method, fullPath, handlerName),
+          method,
+          path: fullPath,
+          kind: this.methodToOpKind(method),
+          handlerName,
+          controllerName,
+          source: this.createLocation(file, lineNumber, lineNumber + 10),
+          confidence: this.createConfidence("medium", "decorator-hints"),
+          frameworkMeta: {
+            hasBody,
+            hasParams,
+            hasQuery
+          }
+        };
+        this.addEndpoint(ctx, endpoint);
+      }
+    }
+  }
+  async extractDtos(ctx, file, content) {
+    const dtoMatches = [...content.matchAll(PATTERNS.dto)];
+    for (const match of dtoMatches) {
+      const name = match[1] ?? "UnknownDto";
+      const index = match.index ?? 0;
+      const lineNumber = content.slice(0, index).split(`
+`).length;
+      const hasClassValidator = content.includes("class-validator") || content.includes("@IsString") || content.includes("@IsNumber");
+      const schema = {
+        id: this.generateSchemaId(name, file),
+        name,
+        schemaType: hasClassValidator ? "class-validator" : "typescript",
+        source: this.createLocation(file, lineNumber, lineNumber + 20),
+        confidence: this.createConfidence(hasClassValidator ? "high" : "medium", hasClassValidator ? "explicit-schema" : "inferred-types")
+      };
+      this.addSchema(ctx, schema);
+    }
+  }
+  normalizePath(path) {
+    return "/" + path.replace(/\/+/g, "/").replace(/^\/+|\/+$/g, "");
+  }
+}
+// src/extractors/express/extractor.ts
+var PATTERNS2 = {
+  route: /(?:app|router)\.(get|post|put|patch|delete|head|options)\s*\(\s*['"`]([^'"`]+)['"`]/gi,
+  routerUse: /(?:app|router)\.use\s*\(\s*['"`]([^'"`]+)['"`]/gi,
+  zodValidate: /validate\s*\(\s*(\w+)\s*\)/g
+};
+
+class ExpressExtractor extends BaseExtractor {
+  id = "express";
+  name = "Express Extractor";
+  frameworks = ["express"];
+  priority = 15;
+  async doExtract(ctx) {
+    const { project, options, fs } = ctx;
+    const pattern = options.scope?.length ? options.scope.map((s) => `${s}/**/*.ts`).join(",") : "**/*.ts";
+    const files = await fs.glob(pattern, { cwd: project.rootPath });
+    ctx.ir.stats.filesScanned = files.length;
+    for (const file of files) {
+      if (file.includes("node_modules") || file.includes(".test."))
+        continue;
+      const fullPath = `${project.rootPath}/${file}`;
+      const content = await fs.readFile(fullPath);
+      await this.extractRoutes(ctx, file, content);
+    }
+  }
+  async extractRoutes(ctx, file, content) {
+    const matches = [...content.matchAll(PATTERNS2.route)];
+    for (const match of matches) {
+      const method = match[1]?.toUpperCase() ?? "GET";
+      const path = match[2] ?? "/";
+      const index = match.index ?? 0;
+      const lineNumber = content.slice(0, index).split(`
+`).length;
+      const afterMatch = content.slice(index, index + 500);
+      const handlerMatch = afterMatch.match(/(?:async\s+)?(?:function\s+)?(\w+)|,\s*(\w+)\s*\)/);
+      const handlerName = handlerMatch?.[1] ?? handlerMatch?.[2] ?? "handler";
+      const hasZodValidation = PATTERNS2.zodValidate.test(afterMatch);
+      const endpoint = {
+        id: this.generateEndpointId(method, path, handlerName),
+        method,
+        path,
+        kind: this.methodToOpKind(method),
+        handlerName,
+        source: this.createLocation(file, lineNumber, lineNumber + 5),
+        confidence: this.createConfidence(hasZodValidation ? "high" : "medium", hasZodValidation ? "explicit-schema" : "decorator-hints")
+      };
+      this.addEndpoint(ctx, endpoint);
+    }
+  }
+}
+// src/extractors/fastify/extractor.ts
+var PATTERNS3 = {
+  route: /(?:fastify|app|server)\.(get|post|put|patch|delete|head|options)\s*\(\s*['"`]([^'"`]+)['"`]/gi,
+  schemaOption: /schema\s*:\s*\{/g,
+  bodySchema: /body\s*:\s*(\w+)/g,
+  responseSchema: /response\s*:\s*\{/g
+};
+
+class FastifyExtractor extends BaseExtractor {
+  id = "fastify";
+  name = "Fastify Extractor";
+  frameworks = ["fastify"];
+  priority = 15;
+  async doExtract(ctx) {
+    const { project, options, fs } = ctx;
+    const pattern = options.scope?.length ? options.scope.map((s) => `${s}/**/*.ts`).join(",") : "**/*.ts";
+    const files = await fs.glob(pattern, { cwd: project.rootPath });
+    ctx.ir.stats.filesScanned = files.length;
+    for (const file of files) {
+      if (file.includes("node_modules") || file.includes(".test."))
+        continue;
+      const fullPath = `${project.rootPath}/${file}`;
+      const content = await fs.readFile(fullPath);
+      await this.extractRoutes(ctx, file, content);
+    }
+  }
+  async extractRoutes(ctx, file, content) {
+    const matches = [...content.matchAll(PATTERNS3.route)];
+    for (const match of matches) {
+      const method = match[1]?.toUpperCase() ?? "GET";
+      const path = match[2] ?? "/";
+      const index = match.index ?? 0;
+      const lineNumber = content.slice(0, index).split(`
+`).length;
+      const afterMatch = content.slice(index, index + 1000);
+      const hasSchema = PATTERNS3.schemaOption.test(afterMatch);
+      const endpoint = {
+        id: this.generateEndpointId(method, path),
+        method,
+        path,
+        kind: this.methodToOpKind(method),
+        handlerName: "handler",
+        source: this.createLocation(file, lineNumber, lineNumber + 10),
+        confidence: this.createConfidence(hasSchema ? "high" : "medium", hasSchema ? "explicit-schema" : "decorator-hints"),
+        frameworkMeta: { hasSchema }
+      };
+      this.addEndpoint(ctx, endpoint);
+    }
+  }
+}
+// src/extractors/hono/extractor.ts
+var PATTERNS4 = {
+  route: /(?:app|hono)\.(get|post|put|patch|delete|all)\s*\(\s*['"`]([^'"`]+)['"`]/gi,
+  zodValidator: /zValidator\s*\(\s*['"`](\w+)['"`]\s*,\s*(\w+)/g
+};
+
+class HonoExtractor extends BaseExtractor {
+  id = "hono";
+  name = "Hono Extractor";
+  frameworks = ["hono"];
+  priority = 15;
+  async doExtract(ctx) {
+    const { project, options, fs } = ctx;
+    const pattern = options.scope?.length ? options.scope.map((s) => `${s}/**/*.ts`).join(",") : "**/*.ts";
+    const files = await fs.glob(pattern, { cwd: project.rootPath });
+    ctx.ir.stats.filesScanned = files.length;
+    for (const file of files) {
+      if (file.includes("node_modules") || file.includes(".test."))
+        continue;
+      const fullPath = `${project.rootPath}/${file}`;
+      const content = await fs.readFile(fullPath);
+      await this.extractRoutes(ctx, file, content);
+    }
+  }
+  async extractRoutes(ctx, file, content) {
+    const matches = [...content.matchAll(PATTERNS4.route)];
+    for (const match of matches) {
+      const method = match[1]?.toUpperCase() ?? "GET";
+      const path = match[2] ?? "/";
+      const index = match.index ?? 0;
+      const lineNumber = content.slice(0, index).split(`
+`).length;
+      const afterMatch = content.slice(index, index + 500);
+      const hasZodValidator = PATTERNS4.zodValidator.test(afterMatch);
+      const endpoint = {
+        id: this.generateEndpointId(method, path),
+        method,
+        path,
+        kind: this.methodToOpKind(method),
+        handlerName: "handler",
+        source: this.createLocation(file, lineNumber, lineNumber + 5),
+        confidence: this.createConfidence(hasZodValidator ? "high" : "medium", hasZodValidator ? "explicit-schema" : "decorator-hints")
+      };
+      this.addEndpoint(ctx, endpoint);
+    }
+  }
+}
+// src/extractors/elysia/extractor.ts
+var PATTERNS5 = {
+  route: /\.(get|post|put|patch|delete)\s*\(\s*['"`]([^'"`]+)['"`]/gi,
+  tSchema: /body:\s*t\.\w+/g
+};
+
+class ElysiaExtractor extends BaseExtractor {
+  id = "elysia";
+  name = "Elysia Extractor";
+  frameworks = ["elysia"];
+  priority = 15;
+  async doExtract(ctx) {
+    const { project, options, fs } = ctx;
+    const pattern = options.scope?.length ? options.scope.map((s) => `${s}/**/*.ts`).join(",") : "**/*.ts";
+    const files = await fs.glob(pattern, { cwd: project.rootPath });
+    ctx.ir.stats.filesScanned = files.length;
+    for (const file of files) {
+      if (file.includes("node_modules") || file.includes(".test."))
+        continue;
+      const fullPath = `${project.rootPath}/${file}`;
+      const content = await fs.readFile(fullPath);
+      if (!content.includes("elysia"))
+        continue;
+      await this.extractRoutes(ctx, file, content);
+    }
+  }
+  async extractRoutes(ctx, file, content) {
+    const matches = [...content.matchAll(PATTERNS5.route)];
+    for (const match of matches) {
+      const method = match[1]?.toUpperCase() ?? "GET";
+      const path = match[2] ?? "/";
+      const index = match.index ?? 0;
+      const lineNumber = content.slice(0, index).split(`
+`).length;
+      const afterMatch = content.slice(index, index + 500);
+      const hasTSchema = PATTERNS5.tSchema.test(afterMatch);
+      const endpoint = {
+        id: this.generateEndpointId(method, path),
+        method,
+        path,
+        kind: this.methodToOpKind(method),
+        handlerName: "handler",
+        source: this.createLocation(file, lineNumber, lineNumber + 5),
+        confidence: this.createConfidence(hasTSchema ? "high" : "medium", hasTSchema ? "explicit-schema" : "decorator-hints")
+      };
+      this.addEndpoint(ctx, endpoint);
+    }
+  }
+}
+// src/extractors/trpc/extractor.ts
+var PATTERNS6 = {
+  procedure: /\.(query|mutation)\s*\(\s*(?:\{[^}]*\}|[^)]+)\)/gi,
+  procedureName: /(\w+)\s*:\s*(?:publicProcedure|protectedProcedure|procedure)/g,
+  zodInput: /\.input\s*\(\s*(\w+)/g,
+  zodOutput: /\.output\s*\(\s*(\w+)/g
+};
+
+class TrpcExtractor extends BaseExtractor {
+  id = "trpc";
+  name = "tRPC Extractor";
+  frameworks = ["trpc"];
+  priority = 15;
+  async doExtract(ctx) {
+    const { project, options, fs } = ctx;
+    const pattern = options.scope?.length ? options.scope.map((s) => `${s}/**/*.ts`).join(",") : "**/*.ts";
+    const files = await fs.glob(pattern, { cwd: project.rootPath });
+    ctx.ir.stats.filesScanned = files.length;
+    for (const file of files) {
+      if (file.includes("node_modules") || file.includes(".test."))
+        continue;
+      const fullPath = `${project.rootPath}/${file}`;
+      const content = await fs.readFile(fullPath);
+      if (!content.includes("trpc") && !content.includes("Procedure"))
+        continue;
+      await this.extractProcedures(ctx, file, content);
+    }
+  }
+  async extractProcedures(ctx, file, content) {
+    const nameMatches = [...content.matchAll(PATTERNS6.procedureName)];
+    for (const match of nameMatches) {
+      const procedureName = match[1] ?? "unknownProcedure";
+      const index = match.index ?? 0;
+      const lineNumber = content.slice(0, index).split(`
+`).length;
+      const afterMatch = content.slice(index, index + 500);
+      const isQuery = afterMatch.includes(".query(");
+      const isMutation = afterMatch.includes(".mutation(");
+      if (!isQuery && !isMutation)
+        continue;
+      const hasZodInput = PATTERNS6.zodInput.test(afterMatch);
+      const hasZodOutput = PATTERNS6.zodOutput.test(afterMatch);
+      const hasSchema = hasZodInput || hasZodOutput;
+      const method = isMutation ? "POST" : "GET";
+      const endpoint = {
+        id: `trpc.${procedureName}`,
+        method,
+        path: `/trpc/${procedureName}`,
+        kind: isMutation ? "command" : "query",
+        handlerName: procedureName,
+        source: this.createLocation(file, lineNumber, lineNumber + 10),
+        confidence: this.createConfidence(hasSchema ? "high" : "medium", hasSchema ? "explicit-schema" : "inferred-types"),
+        frameworkMeta: {
+          procedureType: isMutation ? "mutation" : "query",
+          hasInput: hasZodInput,
+          hasOutput: hasZodOutput
+        }
+      };
+      this.addEndpoint(ctx, endpoint);
+    }
+  }
+}
+// src/extractors/next-api/extractor.ts
+var PATTERNS7 = {
+  appRouterExport: /export\s+(?:async\s+)?function\s+(GET|POST|PUT|PATCH|DELETE|HEAD|OPTIONS)/gi,
+  pagesHandler: /export\s+default\s+(?:async\s+)?function/g,
+  zodSchema: /z\.\w+\(/g
+};
+
+class NextApiExtractor extends BaseExtractor {
+  id = "next-api";
+  name = "Next.js API Extractor";
+  frameworks = ["next-api"];
+  priority = 15;
+  async doExtract(ctx) {
+    const { project, fs } = ctx;
+    const appRoutes = await fs.glob("**/app/api/**/route.ts", {
+      cwd: project.rootPath
+    });
+    const pagesRoutes = await fs.glob("**/pages/api/**/*.ts", {
+      cwd: project.rootPath
+    });
+    const allRoutes = [...appRoutes, ...pagesRoutes];
+    ctx.ir.stats.filesScanned = allRoutes.length;
+    for (const file of allRoutes) {
+      const fullPath = `${project.rootPath}/${file}`;
+      const content = await fs.readFile(fullPath);
+      if (file.includes("/app/api/")) {
+        await this.extractAppRoutes(ctx, file, content);
+      } else {
+        await this.extractPagesRoutes(ctx, file, content);
+      }
+    }
+  }
+  async extractAppRoutes(ctx, file, content) {
+    const pathMatch = file.match(/app\/api\/(.+)\/route\.ts$/);
+    const routePath = pathMatch ? `/api/${pathMatch[1]}` : "/api";
+    const matches = [...content.matchAll(PATTERNS7.appRouterExport)];
+    for (const match of matches) {
+      const method = match[1]?.toUpperCase() ?? "GET";
+      const index = match.index ?? 0;
+      const lineNumber = content.slice(0, index).split(`
+`).length;
+      const hasZod = PATTERNS7.zodSchema.test(content);
+      const endpoint = {
+        id: this.generateEndpointId(method, routePath),
+        method,
+        path: routePath.replace(/\[(\w+)\]/g, ":$1"),
+        kind: this.methodToOpKind(method),
+        handlerName: method,
+        source: this.createLocation(file, lineNumber, lineNumber + 10),
+        confidence: this.createConfidence(hasZod ? "high" : "medium", hasZod ? "explicit-schema" : "inferred-types"),
+        frameworkMeta: { routeType: "app-router" }
+      };
+      this.addEndpoint(ctx, endpoint);
+    }
+  }
+  async extractPagesRoutes(ctx, file, content) {
+    const pathMatch = file.match(/pages\/api\/(.+)\.ts$/);
+    const routePath = pathMatch ? `/api/${pathMatch[1]}` : "/api";
+    if (!PATTERNS7.pagesHandler.test(content))
+      return;
+    const lineNumber = 1;
+    const _hasZod = PATTERNS7.zodSchema.test(content);
+    const methods = ["GET", "POST"];
+    for (const method of methods) {
+      const endpoint = {
+        id: this.generateEndpointId(method, routePath),
+        method,
+        path: routePath.replace(/\[(\w+)\]/g, ":$1"),
+        kind: this.methodToOpKind(method),
+        handlerName: "handler",
+        source: this.createLocation(file, lineNumber, lineNumber + 20),
+        confidence: this.createConfidence("low", "naming-convention"),
+        frameworkMeta: { routeType: "pages-router" }
+      };
+      this.addEndpoint(ctx, endpoint);
+    }
+  }
+}
+// src/extractors/zod/extractor.ts
+var PATTERNS8 = {
+  zodSchema: /(?:export\s+)?const\s+(\w+)\s*=\s*z\.(?:object|string|number|boolean|array|enum|union|intersection|literal|tuple|record)/g,
+  zodInfer: /type\s+(\w+)\s*=\s*z\.infer<typeof\s+(\w+)>/g
+};
+
+class ZodSchemaExtractor extends BaseExtractor {
+  id = "zod";
+  name = "Zod Schema Extractor";
+  frameworks = ["zod"];
+  priority = 5;
+  async detect() {
+    return true;
+  }
+  async doExtract(ctx) {
+    const { project, options, fs } = ctx;
+    const pattern = options.scope?.length ? options.scope.map((s) => `${s}/**/*.ts`).join(",") : "**/*.ts";
+    const files = await fs.glob(pattern, { cwd: project.rootPath });
+    ctx.ir.stats.filesScanned = files.length;
+    for (const file of files) {
+      if (file.includes("node_modules") || file.includes(".test."))
+        continue;
+      const fullPath = `${project.rootPath}/${file}`;
+      const content = await fs.readFile(fullPath);
+      if (!content.includes("z."))
+        continue;
+      await this.extractSchemas(ctx, file, content);
+    }
+  }
+  async extractSchemas(ctx, file, content) {
+    const matches = [...content.matchAll(PATTERNS8.zodSchema)];
+    for (const match of matches) {
+      const name = match[1] ?? "unknownSchema";
+      const index = match.index ?? 0;
+      const lineNumber = content.slice(0, index).split(`
+`).length;
+      let depth = 0;
+      let endIndex = index;
+      for (let i = index;i < content.length; i++) {
+        const char = content[i];
+        if (char === "(" || char === "{" || char === "[")
+          depth++;
+        if (char === ")" || char === "}" || char === "]")
+          depth--;
+        if (depth === 0 && (char === ";" || char === `
+`)) {
+          endIndex = i;
+          break;
+        }
+      }
+      const rawDefinition = content.slice(index, endIndex + 1);
+      const endLineNumber = lineNumber + rawDefinition.split(`
+`).length - 1;
+      const schema = {
+        id: this.generateSchemaId(name, file),
+        name,
+        schemaType: "zod",
+        rawDefinition,
+        source: this.createLocation(file, lineNumber, endLineNumber),
+        confidence: this.createConfidence("high", "explicit-schema")
+      };
+      this.addSchema(ctx, schema);
+    }
+  }
+}
+// src/extractors/index.ts
+function registerAllExtractors() {
+  extractorRegistry.register(new NestJsExtractor);
+  extractorRegistry.register(new ExpressExtractor);
+  extractorRegistry.register(new FastifyExtractor);
+  extractorRegistry.register(new HonoExtractor);
+  extractorRegistry.register(new ElysiaExtractor);
+  extractorRegistry.register(new TrpcExtractor);
+  extractorRegistry.register(new NextApiExtractor);
+  extractorRegistry.register(new ZodSchemaExtractor);
+}
+// src/detect.ts
+var FRAMEWORK_RULES = [
+  {
+    id: "nestjs",
+    name: "NestJS",
+    packages: ["@nestjs/core", "@nestjs/common"],
+    importPatterns: [/@nestjs\//]
+  },
+  {
+    id: "express",
+    name: "Express",
+    packages: ["express"],
+    importPatterns: [/from ['"]express['"]/]
+  },
+  {
+    id: "fastify",
+    name: "Fastify",
+    packages: ["fastify"],
+    importPatterns: [/from ['"]fastify['"]/]
+  },
+  {
+    id: "hono",
+    name: "Hono",
+    packages: ["hono"],
+    importPatterns: [/from ['"]hono['"]/]
+  },
+  {
+    id: "elysia",
+    name: "Elysia",
+    packages: ["elysia"],
+    importPatterns: [/from ['"]elysia['"]/]
+  },
+  {
+    id: "trpc",
+    name: "tRPC",
+    packages: ["@trpc/server"],
+    importPatterns: [/@trpc\/server/]
+  },
+  {
+    id: "next-api",
+    name: "Next.js API",
+    packages: ["next"],
+    filePatterns: [/app\/api\/.*\/route\.ts$/, /pages\/api\/.*\.ts$/]
+  },
+  {
+    id: "koa",
+    name: "Koa",
+    packages: ["koa", "@koa/router"],
+    importPatterns: [/from ['"]koa['"]/]
+  },
+  {
+    id: "hapi",
+    name: "Hapi",
+    packages: ["@hapi/hapi"],
+    importPatterns: [/@hapi\/hapi/]
+  }
+];
+function detectFrameworksFromPackageJson(packageJson) {
+  const allDeps = {
+    ...packageJson.dependencies,
+    ...packageJson.devDependencies,
+    ...packageJson.peerDependencies
+  };
+  const detected = [];
+  for (const rule of FRAMEWORK_RULES) {
+    for (const pkg of rule.packages) {
+      if (pkg in allDeps) {
+        detected.push({
+          id: rule.id,
+          name: rule.name,
+          version: allDeps[pkg],
+          confidence: "high"
+        });
+        break;
+      }
+    }
+  }
+  return detected;
+}
+function detectFrameworksFromCode(sourceCode) {
+  const detected = [];
+  const seenIds = new Set;
+  for (const rule of FRAMEWORK_RULES) {
+    if (!rule.importPatterns)
+      continue;
+    for (const pattern of rule.importPatterns) {
+      if (pattern.test(sourceCode) && !seenIds.has(rule.id)) {
+        detected.push({
+          id: rule.id,
+          name: rule.name,
+          confidence: "medium"
+        });
+        seenIds.add(rule.id);
+        break;
+      }
+    }
+  }
+  return detected;
+}
+function detectFrameworksFromPaths(filePaths) {
+  const detected = [];
+  const seenIds = new Set;
+  for (const rule of FRAMEWORK_RULES) {
+    if (!rule.filePatterns)
+      continue;
+    for (const pattern of rule.filePatterns) {
+      for (const filePath of filePaths) {
+        if (pattern.test(filePath) && !seenIds.has(rule.id)) {
+          detected.push({
+            id: rule.id,
+            name: rule.name,
+            confidence: "medium"
+          });
+          seenIds.add(rule.id);
+          break;
+        }
+      }
+    }
+  }
+  return detected;
+}
+function mergeFrameworkDetections(...detections) {
+  const byId = new Map;
+  const confidenceOrder = {
+    high: 3,
+    medium: 2,
+    low: 1,
+    ambiguous: 0
+  };
+  for (const group of detections) {
+    for (const fw of group) {
+      const existing = byId.get(fw.id);
+      if (!existing || confidenceOrder[fw.confidence] > confidenceOrder[existing.confidence]) {
+        byId.set(fw.id, fw);
+      }
+    }
+  }
+  return Array.from(byId.values());
+}
+async function detectFramework(rootPath, options) {
+  const project = {
+    rootPath,
+    frameworks: []
+  };
+  if (options?.readFile) {
+    try {
+      const packageJsonPath = `${rootPath}/package.json`;
+      const content = await options.readFile(packageJsonPath);
+      const packageJson = JSON.parse(content);
+      project.packageJsonPath = packageJsonPath;
+      project.frameworks = detectFrameworksFromPackageJson(packageJson);
+    } catch {}
+  }
+  if (options?.readFile) {
+    try {
+      const tsConfigPath = `${rootPath}/tsconfig.json`;
+      await options.readFile(tsConfigPath);
+      project.tsConfigPath = tsConfigPath;
+    } catch {}
+  }
+  return project;
+}
+function getSupportedFrameworks() {
+  return FRAMEWORK_RULES.map((r) => r.id);
+}
+function isFrameworkSupported(id) {
+  return FRAMEWORK_RULES.some((r) => r.id === id);
+}
+export {
+  registerBuiltInExtractors,
+  mergeIRs,
+  mergeFrameworkDetections,
+  isFrameworkSupported,
+  getSupportedFrameworks,
+  exports_extractors as extractors,
+  extractorRegistry,
+  extractFromProject,
+  detectFrameworksFromPaths,
+  detectFrameworksFromPackageJson,
+  detectFrameworksFromCode,
+  detectFramework,
+  createEmptyIR,
+  exports_codegen as codegen,
+  ExtractorRegistry
+};