@contractspec/lib.source-extractors 0.11.0 → 0.13.0

package/dist/node/extractors/index.js

@@ -0,0 +1,835 @@
+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/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);
+}
+export {
+  registerAllExtractors,
+  ZodSchemaExtractor,
+  TrpcExtractor,
+  NextApiExtractor,
+  NestJsExtractor,
+  HonoExtractor,
+  FastifyExtractor,
+  ExpressExtractor,
+  ElysiaExtractor,
+  BaseExtractor
+};