opencroc 0.1.7 → 0.3.1

package/dist/index.js

@@ -1,123 +1,2699 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// node_modules/tsup/assets/esm_shims.js
+import path from "path";
+import { fileURLToPath } from "url";
+var init_esm_shims = __esm({
+  "node_modules/tsup/assets/esm_shims.js"() {
+    "use strict";
+  }
+});
+
+// src/parsers/controller-parser.ts
+var controller_parser_exports = {};
+__export(controller_parser_exports, {
+  createControllerParser: () => createControllerParser,
+  inferRelatedTables: () => inferRelatedTables,
+  parseControllerDirectory: () => parseControllerDirectory,
+  parseControllerFile: () => parseControllerFile
+});
+import * as fs2 from "fs";
+import * as path3 from "path";
+import {
+  Project as Project2,
+  SyntaxKind as SyntaxKind2
+} from "ts-morph";
+function parseControllerFile(filePath) {
+  const absolutePath = path3.resolve(filePath);
+  if (!fs2.existsSync(absolutePath)) return [];
+  try {
+    const project = new Project2({ compilerOptions: { strict: false } });
+    const sourceFile = project.addSourceFileAtPath(absolutePath);
+    const endpoints = [];
+    endpoints.push(...extractRouterCalls(sourceFile));
+    endpoints.push(...extractBaseCrudRoutes(sourceFile));
+    return deduplicateEndpoints(endpoints);
+  } catch {
+    return [];
+  }
+}
+function parseControllerDirectory(dirPath) {
+  const absoluteDir = path3.resolve(dirPath);
+  if (!fs2.existsSync(absoluteDir)) return [];
+  const files = fs2.readdirSync(absoluteDir).filter(
+    (f) => f.endsWith(".ts") && !f.endsWith(".test.ts") && !f.endsWith(".spec.ts") && f !== "index.ts"
+  );
+  const endpoints = [];
+  for (const file of files) {
+    endpoints.push(...parseControllerFile(path3.join(absoluteDir, file)));
+  }
+  return deduplicateEndpoints(endpoints);
+}
+function extractRouterCalls(sourceFile) {
+  const endpoints = [];
+  const calls = sourceFile.getDescendantsOfKind(SyntaxKind2.CallExpression);
+  for (const call of calls) {
+    const expr = call.getExpression();
+    if (expr.getKind() !== SyntaxKind2.PropertyAccessExpression) continue;
+    const propAccess = expr;
+    const methodName = propAccess.getName().toLowerCase();
+    if (!HTTP_METHODS.has(methodName)) continue;
+    const objectText = propAccess.getExpression().getText().trim();
+    if (!isRouterLike(objectText)) continue;
+    const args = call.getArguments();
+    if (args.length === 0) continue;
+    const routePath = resolveRoutePath(args[0], sourceFile);
+    if (!routePath) continue;
+    endpoints.push({
+      method: METHOD_MAP[methodName],
+      path: routePath,
+      pathParams: extractPathParams(routePath),
+      queryParams: [],
+      bodyFields: [],
+      responseFields: [],
+      relatedTables: [],
+      description: extractDescription(call)
+    });
+  }
+  return endpoints;
+}
+function isRouterLike(text) {
+  return text === "router" || text === "this.router";
+}
+function extractBaseCrudRoutes(sourceFile) {
+  const endpoints = [];
+  let isBaseCrud = false;
+  for (const cls of sourceFile.getClasses()) {
+    const heritage = cls.getExtends();
+    if (heritage?.getText().includes("BaseCrudController")) {
+      isBaseCrud = true;
+      break;
+    }
+  }
+  if (!isBaseCrud) return endpoints;
+  const calls = sourceFile.getDescendantsOfKind(SyntaxKind2.CallExpression);
+  let resourcePath = null;
+  for (const call of calls) {
+    const exprText = call.getExpression().getText();
+    if ((exprText === "super.registerRoutes" || exprText.endsWith(".registerRoutes")) && !exprText.includes("Custom")) {
+      const args = call.getArguments();
+      if (args.length >= 2) resourcePath = extractStringLiteral(args[1]);
+    }
+  }
+  if (!resourcePath) return endpoints;
+  const basePath = `/v1/:tenantId/${resourcePath}`;
+  const crudRoutes = [
+    { method: "GET", path: basePath, desc: `List ${resourcePath}` },
+    { method: "GET", path: `${basePath}/:id`, desc: `Get ${resourcePath} by ID` },
+    { method: "POST", path: basePath, desc: `Create ${resourcePath}` },
+    { method: "PUT", path: `${basePath}/:id`, desc: `Update ${resourcePath}` },
+    { method: "DELETE", path: `${basePath}/:id`, desc: `Delete ${resourcePath}` },
+    { method: "POST", path: `${basePath}/batch-delete`, desc: `Batch delete ${resourcePath}` }
+  ];
+  for (const route of crudRoutes) {
+    endpoints.push({
+      method: route.method,
+      path: route.path,
+      pathParams: extractPathParams(route.path),
+      queryParams: [],
+      bodyFields: [],
+      responseFields: [],
+      relatedTables: [],
+      description: route.desc
+    });
+  }
+  return endpoints;
+}
+function inferRelatedTables(servicePaths) {
+  const tables = /* @__PURE__ */ new Set();
+  for (const sp of servicePaths) {
+    const absolutePath = path3.resolve(sp);
+    if (!fs2.existsSync(absolutePath)) continue;
+    try {
+      const content = fs2.readFileSync(absolutePath, "utf-8");
+      const importRegex = /import\s*\{([^}]+)\}\s*from\s*['"][^'"]*models[^'"]*['"]/g;
+      let match;
+      while ((match = importRegex.exec(content)) !== null) {
+        const names = match[1].split(",").map((s) => s.trim());
+        for (const name of names) {
+          const cleanName = name.replace(/\s+as\s+\w+/, "").trim();
+          if (cleanName) tables.add(pascalToSnake(cleanName));
+        }
+      }
+    } catch {
+    }
+  }
+  return Array.from(tables);
+}
+function resolveRoutePath(node, sourceFile) {
+  const kind = node.getKind();
+  if (kind === SyntaxKind2.StringLiteral) return node.getText().slice(1, -1);
+  if (kind === SyntaxKind2.TemplateExpression || kind === SyntaxKind2.NoSubstitutionTemplateLiteral) {
+    return resolveTemplateLiteral(node, sourceFile);
+  }
+  if (kind === SyntaxKind2.Identifier) {
+    return resolveVariableValue(sourceFile, node.getText().trim());
+  }
+  return null;
+}
+function resolveTemplateLiteral(node, sourceFile) {
+  let result = node.getText().slice(1, -1);
+  result = result.replace(/\$\{([^}]+)\}/g, (_match, expr) => {
+    const resolved = resolveVariableValue(sourceFile, expr.trim());
+    return resolved || `{${expr.trim()}}`;
+  });
+  return result;
+}
+function resolveVariableValue(sourceFile, varName) {
+  for (const decl of sourceFile.getDescendantsOfKind(SyntaxKind2.VariableDeclaration)) {
+    if (decl.getName() === varName) {
+      const init = decl.getInitializer();
+      if (!init) continue;
+      const t = init.getText().trim();
+      if (t.startsWith("'") && t.endsWith("'") || t.startsWith('"') && t.endsWith('"'))
+        return t.slice(1, -1);
+      if (t.startsWith("`") && t.endsWith("`"))
+        return resolveTemplateLiteral(init, sourceFile);
+    }
+  }
+  return null;
+}
+function extractPathParams(routePath) {
+  const params = [];
+  const regex = /:(\w+)/g;
+  let match;
+  while ((match = regex.exec(routePath)) !== null) params.push(match[1]);
+  return params;
+}
+function extractDescription(call) {
+  let current = call;
+  while (current.getParent() && current.getParent().getKind() !== SyntaxKind2.SourceFile && current.getParent().getKind() !== SyntaxKind2.Block) {
+    current = current.getParent();
+  }
+  const fullText = current.getFullText();
+  const leadingText = fullText.substring(0, fullText.indexOf(current.getText()));
+  const jsdocMatch = leadingText.match(/\/\*\*[\s\S]*?\*\s+(.+?)(?:\n|\*\/)/);
+  if (jsdocMatch) return jsdocMatch[1].replace(/^\*\s*/, "").trim();
+  const lineMatch = leadingText.match(/\/\/\s*(.+)/);
+  if (lineMatch) return lineMatch[1].trim();
+  return "";
+}
+function extractStringLiteral(node) {
+  const t = node.getText().trim();
+  if (t.startsWith("'") && t.endsWith("'") || t.startsWith('"') && t.endsWith('"'))
+    return t.slice(1, -1);
+  return null;
+}
+function pascalToSnake(name) {
+  return name.replace(/([A-Z])/g, "_$1").toLowerCase().replace(/^_/, "");
+}
+function deduplicateEndpoints(endpoints) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const ep of endpoints) {
+    const key = `${ep.method}:${ep.path}`;
+    if (!seen.has(key)) {
+      seen.set(key, ep);
+    } else {
+      const existing = seen.get(key);
+      const merged = /* @__PURE__ */ new Set([...existing.relatedTables, ...ep.relatedTables]);
+      existing.relatedTables = Array.from(merged);
+      if (!existing.description && ep.description) existing.description = ep.description;
+    }
+  }
+  return Array.from(seen.values());
+}
+function createControllerParser() {
+  return {
+    async parseFile(filePath) {
+      return parseControllerFile(filePath);
+    },
+    async parseDirectory(dirPath) {
+      return parseControllerDirectory(dirPath);
+    }
+  };
+}
+var HTTP_METHODS, METHOD_MAP;
+var init_controller_parser = __esm({
+  "src/parsers/controller-parser.ts"() {
+    "use strict";
+    init_esm_shims();
+    HTTP_METHODS = /* @__PURE__ */ new Set(["get", "post", "put", "delete", "patch"]);
+    METHOD_MAP = {
+      get: "GET",
+      post: "POST",
+      put: "PUT",
+      delete: "DELETE",
+      patch: "PATCH"
+    };
+  }
+});
+
+// src/index.ts
+init_esm_shims();
+
 // src/config.ts
+init_esm_shims();
 function defineConfig(config) {
   return config;
 }
 
 // src/pipeline/index.ts
-function createPipeline(_config) {
+init_esm_shims();
+import * as fs4 from "fs";
+import * as path5 from "path";
+
+// src/parsers/model-parser.ts
+init_esm_shims();
+import * as fs from "fs";
+import * as path2 from "path";
+import {
+  Project,
+  SyntaxKind
+} from "ts-morph";
+function parseModelFile(filePath) {
+  const absolutePath = path2.resolve(filePath);
+  if (!fs.existsSync(absolutePath)) return null;
+  const project = new Project({ compilerOptions: { strict: false } });
+  const sourceFile = project.addSourceFileAtPath(absolutePath);
+  const initCall = findInitCall(sourceFile);
+  if (!initCall) return null;
+  const args = initCall.getArguments();
+  if (args.length < 2) return null;
+  const fields = parseFieldDefinitions(args[0]);
+  const { tableName, indexes } = parseOptions(args[1]);
+  if (!tableName) return null;
+  return { tableName, fields, indexes };
+}
+function parseModuleModels(modelDir) {
+  const absoluteDir = path2.resolve(modelDir);
+  if (!fs.existsSync(absoluteDir)) return [];
+  const files = fs.readdirSync(absoluteDir).filter(
+    (f) => f.endsWith(".ts") && !f.endsWith(".test.ts") && !f.endsWith(".spec.ts") && f !== "index.ts" && f !== "associations.ts"
+  );
+  const schemas = [];
+  for (const file of files) {
+    try {
+      const schema = parseModelFile(path2.join(absoluteDir, file));
+      if (schema) schemas.push(schema);
+    } catch {
+    }
+  }
+  return schemas;
+}
+function findInitCall(sourceFile) {
+  const calls = sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression);
+  for (const call of calls) {
+    const expr = call.getExpression();
+    if (expr.getKind() === SyntaxKind.PropertyAccessExpression) {
+      const propAccess = expr.asKindOrThrow(SyntaxKind.PropertyAccessExpression);
+      if (propAccess.getName() === "init") return call;
+    }
+  }
+  return null;
+}
+function parseFieldDefinitions(fieldsNode) {
+  const fields = [];
+  if (fieldsNode.getKind() !== SyntaxKind.ObjectLiteralExpression) return fields;
+  const objLiteral = fieldsNode;
+  for (const prop of objLiteral.getProperties()) {
+    if (prop.getKind() !== SyntaxKind.PropertyAssignment) continue;
+    const propAssign = prop;
+    const initializer = propAssign.getInitializer();
+    if (!initializer || initializer.getKind() !== SyntaxKind.ObjectLiteralExpression) continue;
+    fields.push(parseFieldObject(propAssign.getName(), initializer));
+  }
+  return fields;
+}
+function parseFieldObject(fieldName, fieldObj) {
+  const field = { name: fieldName, type: "STRING", allowNull: true, primaryKey: false };
+  for (const prop of fieldObj.getProperties()) {
+    if (prop.getKind() !== SyntaxKind.PropertyAssignment) continue;
+    const propAssign = prop;
+    const key = propAssign.getName();
+    const init = propAssign.getInitializer();
+    if (!init) continue;
+    switch (key) {
+      case "type":
+        field.type = extractDataType(init);
+        break;
+      case "allowNull":
+        field.allowNull = init.getText().trim() === "true";
+        break;
+      case "primaryKey":
+        field.primaryKey = init.getText().trim() === "true";
+        break;
+      case "defaultValue":
+        field.defaultValue = extractDefaultValue(init);
+        break;
+    }
+  }
+  return field;
+}
+function extractDataType(node) {
+  const text = node.getText().trim();
+  const callMatch = text.match(/^DataTypes\.(\w+)\((.+)\)$/);
+  if (callMatch) return `${callMatch[1]}(${callMatch[2]})`;
+  const propMatch = text.match(/^DataTypes\.(\w+)$/);
+  if (propMatch) return propMatch[1];
+  return text;
+}
+function extractDefaultValue(node) {
+  const text = node.getText().trim();
+  if (text === "DataTypes.NOW") return "DataTypes.NOW";
+  if (text.startsWith("'") && text.endsWith("'") || text.startsWith('"') && text.endsWith('"'))
+    return text.slice(1, -1);
+  if (/^-?\d+(\.\d+)?$/.test(text)) return Number(text);
+  if (text === "true") return true;
+  if (text === "false") return false;
+  if (text === "null") return null;
+  return text;
+}
+function parseOptions(optionsNode) {
+  let tableName = null;
+  let indexes = [];
+  if (optionsNode.getKind() !== SyntaxKind.ObjectLiteralExpression) return { tableName, indexes };
+  const objLiteral = optionsNode;
+  for (const prop of objLiteral.getProperties()) {
+    if (prop.getKind() !== SyntaxKind.PropertyAssignment) continue;
+    const propAssign = prop;
+    const key = propAssign.getName();
+    const init = propAssign.getInitializer();
+    if (!init) continue;
+    if (key === "tableName") tableName = extractStringValue(init);
+    if (key === "indexes") indexes = parseIndexes(init);
+  }
+  return { tableName, indexes };
+}
+function extractStringValue(node) {
+  const text = node.getText().trim();
+  if (text.startsWith("'") && text.endsWith("'") || text.startsWith('"') && text.endsWith('"'))
+    return text.slice(1, -1);
+  return null;
+}
+function parseIndexes(node) {
+  if (node.getKind() !== SyntaxKind.ArrayLiteralExpression) return [];
+  const arr = node.asKindOrThrow(SyntaxKind.ArrayLiteralExpression);
+  const indexes = [];
+  for (const el of arr.getElements()) {
+    if (el.getKind() !== SyntaxKind.ObjectLiteralExpression) continue;
+    const idx = parseIndexObject(el);
+    if (idx) indexes.push(idx);
+  }
+  return indexes;
+}
+function parseIndexObject(obj) {
+  let name = "";
+  let fields = [];
+  let unique = false;
+  for (const prop of obj.getProperties()) {
+    if (prop.getKind() !== SyntaxKind.PropertyAssignment) continue;
+    const pa = prop;
+    const init = pa.getInitializer();
+    if (!init) continue;
+    switch (pa.getName()) {
+      case "name":
+        name = extractStringValue(init) || "";
+        break;
+      case "fields":
+        fields = extractStringArray(init);
+        break;
+      case "unique":
+        unique = init.getText().trim() === "true";
+        break;
+    }
+  }
+  if (!name || fields.length === 0) return null;
+  return { name, fields, unique };
+}
+function extractStringArray(node) {
+  if (node.getKind() !== SyntaxKind.ArrayLiteralExpression) return [];
+  const arr = node.asKindOrThrow(SyntaxKind.ArrayLiteralExpression);
+  return arr.getElements().map((el) => el.getText().trim()).filter((t) => t.startsWith("'") || t.startsWith('"')).map((t) => t.slice(1, -1));
+}
+function createModelParser() {
   return {
-    async run(_steps) {
-      throw new Error("Pipeline not yet implemented");
+    async parseFile(filePath) {
+      return parseModelFile(filePath);
+    },
+    async parseDirectory(dirPath) {
+      return parseModuleModels(dirPath);
     }
   };
 }
 
-// src/parsers/model-parser.ts
-function createModelParser() {
+// src/pipeline/index.ts
+init_controller_parser();
+
+// src/parsers/association-parser.ts
+init_esm_shims();
+import * as fs3 from "fs";
+import * as path4 from "path";
+import {
+  Project as Project3,
+  SyntaxKind as SyntaxKind3
+} from "ts-morph";
+function parseAssociationFile(filePath, classToTableMap, moduleTablePrefix) {
+  const absolutePath = path4.resolve(filePath);
+  if (!fs3.existsSync(absolutePath)) return [];
+  const project = new Project3({ compilerOptions: { strict: false } });
+  const sourceFile = project.addSourceFileAtPath(absolutePath);
+  const importPathMap = collectImportPaths(sourceFile);
+  const rawAssociations = extractAssociationCalls(sourceFile, importPathMap);
+  if (rawAssociations.length === 0) return [];
+  return deduplicateRelations(rawAssociations, classToTableMap, moduleTablePrefix);
+}
+function buildClassToTableMap(modelDir) {
+  const map = /* @__PURE__ */ new Map();
+  const absoluteDir = path4.resolve(modelDir);
+  if (!fs3.existsSync(absoluteDir)) return map;
+  const files = fs3.readdirSync(absoluteDir).filter(
+    (f) => f.endsWith(".ts") && !f.endsWith(".test.ts") && !f.endsWith(".spec.ts") && f !== "index.ts" && f !== "associations.ts"
+  );
+  for (const file of files) {
+    try {
+      const schema = parseModelFile(path4.join(absoluteDir, file));
+      if (schema) {
+        const className = file.replace(".ts", "");
+        map.set(className, schema.tableName);
+      }
+    } catch {
+    }
+  }
+  return map;
+}
+function collectImportPaths(sourceFile) {
+  const map = /* @__PURE__ */ new Map();
+  for (const decl of sourceFile.getImportDeclarations()) {
+    const moduleSpecifier = decl.getModuleSpecifierValue();
+    for (const named of decl.getNamedImports()) {
+      map.set(named.getName(), moduleSpecifier);
+    }
+  }
+  return map;
+}
+function extractAssociationCalls(sourceFile, importPathMap) {
+  const associations = [];
+  const calls = sourceFile.getDescendantsOfKind(SyntaxKind3.CallExpression);
+  for (const call of calls) {
+    const expr = call.getExpression();
+    if (expr.getKind() !== SyntaxKind3.PropertyAccessExpression) continue;
+    const propAccess = expr.asKindOrThrow(SyntaxKind3.PropertyAccessExpression);
+    const methodName = propAccess.getName();
+    if (methodName !== "hasMany" && methodName !== "belongsTo" && methodName !== "hasOne") continue;
+    const sourceClass = propAccess.getExpression().getText().trim();
+    const args = call.getArguments();
+    if (args.length < 1) continue;
+    const targetClass = args[0].getText().trim();
+    let foreignKey = "";
+    if (args.length >= 2 && args[1].getKind() === SyntaxKind3.ObjectLiteralExpression) {
+      foreignKey = extractStringProperty(args[1], "foreignKey");
+    }
+    associations.push({
+      sourceClass,
+      targetClass,
+      foreignKey,
+      type: methodName,
+      importPath: importPathMap.get(targetClass)
+    });
+  }
+  return associations;
+}
+function extractStringProperty(obj, propertyName) {
+  for (const prop of obj.getProperties()) {
+    if (prop.getKind() !== SyntaxKind3.PropertyAssignment) continue;
+    const pa = prop;
+    if (pa.getName() !== propertyName) continue;
+    const init = pa.getInitializer();
+    if (!init) continue;
+    const text = init.getText().trim();
+    if (text.startsWith("'") && text.endsWith("'") || text.startsWith('"') && text.endsWith('"'))
+      return text.slice(1, -1);
+    return text;
+  }
+  return "";
+}
+function classNameToTableName(className) {
+  return className.replace(/([A-Z])/g, "_$1").toLowerCase().replace(/^_/, "");
+}
+function resolveTableName(className, classToTableMap) {
+  if (classToTableMap?.has(className)) return classToTableMap.get(className);
+  return classNameToTableName(className);
+}
+function isCrossModuleRef(targetTableName, importPath, moduleTablePrefix) {
+  if (moduleTablePrefix) return !targetTableName.startsWith(moduleTablePrefix);
+  if (importPath) {
+    const upLevels = (importPath.match(/\.\.\//g) || []).length;
+    return upLevels >= 2;
+  }
+  return false;
+}
+function deduplicateRelations(rawAssociations, classToTableMap, moduleTablePrefix) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const raw of rawAssociations) {
+    const sourceTable = resolveTableName(raw.sourceClass, classToTableMap);
+    const targetTable = resolveTableName(raw.targetClass, classToTableMap);
+    const crossModule = isCrossModuleRef(targetTable, raw.importPath, moduleTablePrefix);
+    let parentTable;
+    let childTable;
+    let cardinality;
+    switch (raw.type) {
+      case "hasMany":
+        parentTable = sourceTable;
+        childTable = targetTable;
+        cardinality = "1:N";
+        break;
+      case "belongsTo":
+        parentTable = targetTable;
+        childTable = sourceTable;
+        cardinality = "N:1";
+        break;
+      case "hasOne":
+        parentTable = sourceTable;
+        childTable = targetTable;
+        cardinality = "1:1";
+        break;
+    }
+    const dedupeKey = `${parentTable}|${childTable}|${raw.foreignKey}`;
+    if (seen.has(dedupeKey)) {
+      const existing = seen.get(dedupeKey);
+      if (existing.cardinality === "N:1" && (cardinality === "1:N" || cardinality === "1:1")) {
+        seen.set(dedupeKey, {
+          sourceTable: parentTable,
+          sourceField: "id",
+          targetTable: childTable,
+          targetField: raw.foreignKey,
+          cardinality,
+          isCrossModule: crossModule || existing.isCrossModule
+        });
+      }
+    } else {
+      seen.set(dedupeKey, {
+        sourceTable: parentTable,
+        sourceField: "id",
+        targetTable: childTable,
+        targetField: raw.foreignKey,
+        cardinality,
+        isCrossModule: crossModule
+      });
+    }
+  }
+  return Array.from(seen.values());
+}
+function createAssociationParser() {
   return {
-    async parseFile(_filePath) {
-      throw new Error("Model parser not yet implemented");
-    },
-    async parseDirectory(_dirPath) {
-      throw new Error("Model parser not yet implemented");
+    async parseFile(filePath) {
+      return parseAssociationFile(filePath);
     }
   };
 }
 
-// src/parsers/controller-parser.ts
-function createControllerParser() {
+// src/analyzers/api-chain-analyzer.ts
+init_esm_shims();
+var EXCLUDED_PARAMS = /* @__PURE__ */ new Set(["tenantId"]);
+function toNodeKey(endpoint) {
+  return `${endpoint.method} ${endpoint.path}`;
+}
+function paramToResourceHint(param) {
+  const stripped = param.endsWith("Id") ? param.slice(0, -2) : param;
+  return stripped.replace(/([A-Z])/g, "-$1").toLowerCase().replace(/^-/, "");
+}
+function postProducesResource(postEndpoint, resourceHint) {
+  const segments = postEndpoint.path.split("/").filter((s) => s && !s.startsWith(":"));
+  if (segments.length === 0) return false;
+  const lastSegment = segments[segments.length - 1].toLowerCase();
+  if (lastSegment.includes(resourceHint)) return true;
+  const parts = lastSegment.split("-");
+  if (parts.some((p) => p === resourceHint || p.startsWith(resourceHint))) return true;
+  if (resourceHint.length <= 4) {
+    const abbreviation = parts.map((p) => p[0]).join("");
+    if (abbreviation.startsWith(resourceHint)) return true;
+  }
+  return false;
+}
+function inferDependencies(endpoints) {
+  const dependencies = [];
+  const postEndpoints = endpoints.filter((ep) => ep.method === "POST");
+  for (const consumer of endpoints) {
+    const consumedParams = consumer.pathParams.filter((p) => !EXCLUDED_PARAMS.has(p));
+    if (consumedParams.length === 0) continue;
+    for (const param of consumedParams) {
+      if (param === "id") {
+        const basePath = consumer.path.replace(/\/:id(\/.*)?$/, "");
+        const producer2 = postEndpoints.find((ep) => ep.path === basePath);
+        if (producer2 && toNodeKey(producer2) !== toNodeKey(consumer)) {
+          dependencies.push({ from: consumer, to: producer2, paramMapping: { [`:${param}`]: "response.data.id" } });
+        }
+        continue;
+      }
+      const resourceHint = paramToResourceHint(param);
+      if (!resourceHint) continue;
+      const producer = postEndpoints.find((ep) => postProducesResource(ep, resourceHint));
+      if (producer && toNodeKey(producer) !== toNodeKey(consumer)) {
+        dependencies.push({ from: consumer, to: producer, paramMapping: { [`:${param}`]: "response.data.id" } });
+      }
+    }
+  }
+  return deduplicateDependencies(dependencies);
+}
+function deduplicateDependencies(deps) {
+  const map = /* @__PURE__ */ new Map();
+  for (const dep of deps) {
+    const key = `${toNodeKey(dep.from)}\u2192${toNodeKey(dep.to)}`;
+    if (map.has(key)) {
+      Object.assign(map.get(key).paramMapping, dep.paramMapping);
+    } else {
+      map.set(key, { ...dep, paramMapping: { ...dep.paramMapping } });
+    }
+  }
+  return Array.from(map.values());
+}
+function buildGraph(endpoints, dependencies) {
+  const nodeSet = /* @__PURE__ */ new Set();
+  for (const ep of endpoints) nodeSet.add(toNodeKey(ep));
+  const edges = [];
+  for (const dep of dependencies) {
+    edges.push({
+      from: toNodeKey(dep.from),
+      to: toNodeKey(dep.to),
+      label: Object.keys(dep.paramMapping).join(", ") || void 0
+    });
+  }
+  return { nodes: Array.from(nodeSet), edges };
+}
+function detectCycles(dag) {
+  const adjacency = /* @__PURE__ */ new Map();
+  for (const node of dag.nodes) adjacency.set(node, []);
+  for (const edge of dag.edges) adjacency.get(edge.from)?.push(edge.to);
+  const color = /* @__PURE__ */ new Map();
+  for (const node of dag.nodes) color.set(node, 0 /* WHITE */);
+  const warnings = [];
+  const path9 = [];
+  function dfs(node) {
+    color.set(node, 1 /* GRAY */);
+    path9.push(node);
+    for (const neighbor of adjacency.get(node) || []) {
+      const nc = color.get(neighbor);
+      if (nc === 1 /* GRAY */) {
+        const cycleStart = path9.indexOf(neighbor);
+        warnings.push(`Cycle detected: ${path9.slice(cycleStart).concat(neighbor).join(" \u2192 ")}`);
+      } else if (nc === 0 /* WHITE */) {
+        dfs(neighbor);
+      }
+    }
+    path9.pop();
+    color.set(node, 2 /* BLACK */);
+  }
+  for (const node of dag.nodes) {
+    if (color.get(node) === 0 /* WHITE */) dfs(node);
+  }
+  return warnings;
+}
+function topologicalSort(dag) {
+  const inDegree = /* @__PURE__ */ new Map();
+  const adjacency = /* @__PURE__ */ new Map();
+  for (const node of dag.nodes) {
+    inDegree.set(node, 0);
+    adjacency.set(node, []);
+  }
+  for (const edge of dag.edges) {
+    adjacency.get(edge.from)?.push(edge.to);
+    inDegree.set(edge.to, (inDegree.get(edge.to) || 0) + 1);
+  }
+  const queue = [];
+  for (const [node, degree] of inDegree) {
+    if (degree === 0) queue.push(node);
+  }
+  const sorted = [];
+  while (queue.length > 0) {
+    const node = queue.shift();
+    sorted.push(node);
+    for (const neighbor of adjacency.get(node) || []) {
+      const nd = (inDegree.get(neighbor) || 1) - 1;
+      inDegree.set(neighbor, nd);
+      if (nd === 0) queue.push(neighbor);
+    }
+  }
+  return sorted;
+}
+function createApiChainAnalyzer() {
   return {
-    async parseFile(_filePath) {
-      throw new Error("Controller parser not yet implemented");
-    },
-    async parseDirectory(_dirPath) {
-      throw new Error("Controller parser not yet implemented");
+    analyze(endpoints) {
+      const dependencies = inferDependencies(endpoints);
+      const dag = buildGraph(endpoints, dependencies);
+      const cycleWarnings = detectCycles(dag);
+      return {
+        moduleName: "",
+        endpoints,
+        dependencies,
+        dag,
+        hasCycles: cycleWarnings.length > 0,
+        cycleWarnings
+      };
     }
   };
 }
 
-// src/parsers/association-parser.ts
-function createAssociationParser() {
+// src/generators/er-diagram-generator.ts
+init_esm_shims();
+function toMermaidType(fieldType) {
+  const upper = fieldType.toUpperCase();
+  if (upper.startsWith("STRING")) return "string";
+  if (upper === "BIGINT" || upper === "INTEGER") return "bigint";
+  if (upper === "BOOLEAN") return "boolean";
+  if (upper.startsWith("DATE") || upper === "NOW") return "datetime";
+  if (upper === "JSON" || upper === "JSONB") return "json";
+  if (upper === "TEXT") return "text";
+  if (upper === "FLOAT" || upper === "DOUBLE" || upper === "DECIMAL") return "float";
+  if (upper === "UUID") return "uuid";
+  if (upper.startsWith("ENUM")) return "enum";
+  return "string";
+}
+function sanitizeEntityName(name) {
+  return name.replace(/[^a-zA-Z0-9_]/g, "_");
+}
+function generateMermaidER(tables, relations) {
+  const lines = ["erDiagram"];
+  for (const table of tables) {
+    const entityName = sanitizeEntityName(table.tableName);
+    lines.push(`  ${entityName} {`);
+    for (const field of table.fields) {
+      const mType = toMermaidType(field.type);
+      const pk = field.primaryKey ? "PK" : "";
+      const comment = field.comment ? ` "${field.comment}"` : "";
+      lines.push(`    ${mType} ${field.name}${pk ? " " + pk : ""}${comment}`);
+    }
+    lines.push("  }");
+  }
+  const tableNames = new Set(tables.map((t) => t.tableName));
+  for (const rel of relations) {
+    if (!tableNames.has(rel.sourceTable) || !tableNames.has(rel.targetTable)) continue;
+    const src = sanitizeEntityName(rel.sourceTable);
+    const tgt = sanitizeEntityName(rel.targetTable);
+    const linkStyle = rel.isCrossModule ? ".." : "--";
+    let cardinality;
+    switch (rel.cardinality) {
+      case "1:N":
+        cardinality = `||${linkStyle}o{`;
+        break;
+      case "N:1":
+        cardinality = `}o${linkStyle}||`;
+        break;
+      case "1:1":
+        cardinality = `||${linkStyle}||`;
+        break;
+      default:
+        cardinality = `||${linkStyle}o{`;
+    }
+    lines.push(`  ${src} ${cardinality} ${tgt} : "${rel.targetField}"`);
+  }
+  return lines.join("\n");
+}
+function createERDiagramGenerator() {
   return {
-    async parseFile(_filePath) {
-      throw new Error("Association parser not yet implemented");
+    generate(tables, relations) {
+      const mermaidText = generateMermaidER(tables, relations);
+      return { tables, relations, mermaidText };
     }
   };
 }
 
 // src/generators/test-code-generator.ts
+init_esm_shims();
+function resolvePathParam(param, ids) {
+  if (ids.includes(param)) return `createdIds['${param}']`;
+  const stripped = param.endsWith("Id") ? param.slice(0, -2) : param;
+  if (ids.includes(stripped)) return `createdIds['${stripped}']`;
+  if (param === "id") return `createdIds['id']`;
+  return `createdIds['${param}'] || '1'`;
+}
+function buildUrlCode(step) {
+  const pathParams = step.endpoint.pathParams;
+  if (pathParams.length === 0) return `const url = '${step.endpoint.path}';`;
+  let urlTemplate = step.endpoint.path;
+  const replacements = [];
+  for (const param of pathParams) {
+    urlTemplate = urlTemplate.replace(`:${param}`, `\${${resolvePathParam(param, pathParams)}}`);
+    replacements.push(param);
+  }
+  return `const url = \`${urlTemplate}\`;`;
+}
+function generateAssertions(step) {
+  const lines = [];
+  if (step.assertions.length > 0) {
+    for (const assertion of step.assertions) {
+      lines.push(`    expect(${assertion}).toBeTruthy();`);
+    }
+  } else {
+    if (step.endpoint.method === "POST") {
+      lines.push("    expect(response.status()).toBeLessThan(400);");
+      lines.push("    const body = await response.json();");
+      lines.push("    if (body.data?.id) createdIds['id'] = body.data.id;");
+    } else if (step.endpoint.method === "GET") {
+      lines.push("    expect(response.ok()).toBeTruthy();");
+    } else if (step.endpoint.method === "DELETE") {
+      lines.push("    expect(response.status()).toBeLessThan(400);");
+    } else {
+      lines.push("    expect(response.status()).toBeLessThan(400);");
+    }
+  }
+  return lines;
+}
+function generateTestFile(chain) {
+  const lines = [];
+  lines.push(`import { test, expect } from '@playwright/test';`);
+  lines.push("");
+  lines.push(`test.describe('${chain.name}', () => {`);
+  lines.push("  const createdIds: Record<string, string> = {};");
+  lines.push("");
+  for (const step of chain.steps) {
+    lines.push(`  test('Step ${step.order}: ${step.description}', async ({ request }) => {`);
+    lines.push(`    // ${step.action}: ${step.endpoint.method} ${step.endpoint.path}`);
+    lines.push(`    ${buildUrlCode(step)}`);
+    lines.push("");
+    if (step.endpoint.method === "GET") {
+      lines.push("    const response = await request.get(url);");
+    } else if (step.endpoint.method === "POST") {
+      lines.push("    const response = await request.post(url, { data: {} });");
+    } else if (step.endpoint.method === "PUT") {
+      lines.push("    const response = await request.put(url, { data: {} });");
+    } else if (step.endpoint.method === "DELETE") {
+      lines.push("    const response = await request.delete(url);");
+    } else if (step.endpoint.method === "PATCH") {
+      lines.push("    const response = await request.patch(url, { data: {} });");
+    }
+    lines.push("");
+    lines.push(...generateAssertions(step));
+    lines.push("  });");
+    lines.push("");
+  }
+  lines.push("});");
+  return lines.join("\n");
+}
 function createTestCodeGenerator() {
   return {
-    generate(_chains) {
-      throw new Error("Test code generator not yet implemented");
+    generate(chains) {
+      return chains.map((chain) => ({
+        filePath: `${chain.module}/${chain.name.replace(/\s+/g, "-").toLowerCase()}.spec.ts`,
+        content: generateTestFile(chain),
+        module: chain.module,
+        chain: chain.name
+      }));
     }
   };
 }
 
+// src/validators/config-validator.ts
+init_esm_shims();
+var REQUIRED_FIELDS = ["backendRoot"];
+var VALID_ADAPTERS = ["sequelize", "typeorm", "prisma"];
+var VALID_STEPS = ["scan", "er-diagram", "api-chain", "plan", "codegen", "validate"];
+var VALID_LLM_PROVIDERS = ["openai", "zhipu", "ollama", "custom"];
+var VALID_REPORT_FORMATS = ["html", "json", "markdown"];
+var VALID_HEAL_MODES = ["config-only", "config-and-source"];
+function validateConfig(config) {
+  const errors = [];
+  for (const field of REQUIRED_FIELDS) {
+    if (!config[field]) {
+      errors.push({
+        module: "config",
+        field,
+        message: `Missing required field: ${field}`,
+        severity: "error"
+      });
+    }
+  }
+  if (config.backendRoot && typeof config.backendRoot !== "string") {
+    errors.push({
+      module: "config",
+      field: "backendRoot",
+      message: "backendRoot must be a string path",
+      severity: "error"
+    });
+  }
+  if (config.adapter && typeof config.adapter === "string") {
+    if (!VALID_ADAPTERS.includes(config.adapter)) {
+      errors.push({
+        module: "config",
+        field: "adapter",
+        message: `Invalid adapter: ${config.adapter}. Must be one of: ${VALID_ADAPTERS.join(", ")}`,
+        severity: "error"
+      });
+    }
+  }
+  if (config.steps && Array.isArray(config.steps)) {
+    for (const step of config.steps) {
+      if (!VALID_STEPS.includes(step)) {
+        errors.push({
+          module: "config",
+          field: "steps",
+          message: `Invalid pipeline step: ${step}. Must be one of: ${VALID_STEPS.join(", ")}`,
+          severity: "error"
+        });
+      }
+    }
+  }
+  if (config.llm && typeof config.llm === "object") {
+    const llm = config.llm;
+    if (llm.provider && !VALID_LLM_PROVIDERS.includes(llm.provider)) {
+      errors.push({
+        module: "config",
+        field: "llm.provider",
+        message: `Invalid LLM provider: ${llm.provider}. Must be one of: ${VALID_LLM_PROVIDERS.join(", ")}`,
+        severity: "error"
+      });
+    }
+    if (llm.provider && llm.provider !== "ollama" && !llm.apiKey) {
+      errors.push({
+        module: "config",
+        field: "llm.apiKey",
+        message: "LLM apiKey is required for cloud providers",
+        severity: "warning"
+      });
+    }
+  }
+  if (config.report && typeof config.report === "object") {
+    const report = config.report;
+    if (report.format && Array.isArray(report.format)) {
+      for (const fmt of report.format) {
+        if (!VALID_REPORT_FORMATS.includes(fmt)) {
+          errors.push({
+            module: "config",
+            field: "report.format",
+            message: `Invalid report format: ${fmt}. Must be one of: ${VALID_REPORT_FORMATS.join(", ")}`,
+            severity: "error"
+          });
+        }
+      }
+    }
+  }
+  if (config.selfHealing && typeof config.selfHealing === "object") {
+    const sh = config.selfHealing;
+    if (sh.mode && !VALID_HEAL_MODES.includes(sh.mode)) {
+      errors.push({
+        module: "config",
+        field: "selfHealing.mode",
+        message: `Invalid self-healing mode: ${sh.mode}. Must be one of: ${VALID_HEAL_MODES.join(", ")}`,
+        severity: "error"
+      });
+    }
+    if (sh.maxIterations && (typeof sh.maxIterations !== "number" || sh.maxIterations < 1)) {
+      errors.push({
+        module: "config",
+        field: "selfHealing.maxIterations",
+        message: "maxIterations must be a positive number",
+        severity: "error"
+      });
+    }
+  }
+  return errors;
+}
+
+// src/pipeline/index.ts
+var ALL_STEPS = ["scan", "er-diagram", "api-chain", "plan", "codegen", "validate"];
+function createPipeline(config) {
+  return {
+    async run(steps) {
+      const startTime = Date.now();
+      const activeSteps = steps || config.steps || ALL_STEPS;
+      const result = {
+        modules: [],
+        erDiagrams: /* @__PURE__ */ new Map(),
+        chainPlans: /* @__PURE__ */ new Map(),
+        generatedFiles: [],
+        validationErrors: [],
+        duration: 0
+      };
+      if (activeSteps.includes("scan")) {
+        const backendRoot = path5.resolve(config.backendRoot);
+        const modelsDir = path5.join(backendRoot, "models");
+        if (fs4.existsSync(modelsDir)) {
+          const dirs = fs4.readdirSync(modelsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+          const moduleFilter = config.modules;
+          for (const dir of dirs) {
+            if (moduleFilter && !moduleFilter.includes(dir)) continue;
+            result.modules.push(dir);
+          }
+          if (result.modules.length === 0) {
+            result.modules.push("default");
+          } else {
+            const rootFiles = fs4.readdirSync(modelsDir).filter((f) => f.endsWith(".ts") && !f.endsWith(".test.ts") && f !== "index.ts");
+            if (rootFiles.length > 0) {
+              result.modules.unshift("default");
+            }
+          }
+        }
+      }
+      const resolveModelDir = (backendRoot, mod) => mod === "default" ? path5.join(backendRoot, "models") : path5.join(backendRoot, "models", mod);
+      const resolveControllerDir = (backendRoot, mod) => mod === "default" ? path5.join(backendRoot, "controllers") : path5.join(backendRoot, "controllers", mod);
+      if (activeSteps.includes("er-diagram")) {
+        const erGen = createERDiagramGenerator();
+        const backendRoot = path5.resolve(config.backendRoot);
+        for (const mod of result.modules) {
+          const modelDir = resolveModelDir(backendRoot, mod);
+          const tables = fs4.existsSync(modelDir) ? parseModuleModels(modelDir) : [];
+          const relations = [];
+          const assocFile = path5.join(modelDir, "associations.ts");
+          if (fs4.existsSync(assocFile)) {
+            relations.push(...parseAssociationFile(assocFile));
+          }
+          if (fs4.existsSync(modelDir)) {
+            const modelFiles = fs4.readdirSync(modelDir).filter((f) => f.endsWith(".ts") && !f.endsWith(".test.ts") && f !== "index.ts" && f !== "associations.ts");
+            for (const file of modelFiles) {
+              try {
+                const embedded = parseAssociationFile(path5.join(modelDir, file));
+                relations.push(...embedded);
+              } catch {
+              }
+            }
+          }
+          const erResult = erGen.generate(tables, relations);
+          result.erDiagrams.set(mod, erResult);
+        }
+      }
+      if (activeSteps.includes("api-chain")) {
+        const chainAnalyzer = createApiChainAnalyzer();
+        const backendRoot = path5.resolve(config.backendRoot);
+        for (const mod of result.modules) {
+          const controllerDir = resolveControllerDir(backendRoot, mod);
+          const endpoints = fs4.existsSync(controllerDir) ? parseControllerDirectory(controllerDir) : [];
+          const analysis = chainAnalyzer.analyze(endpoints);
+          analysis.moduleName = mod;
+          if (analysis.hasCycles) {
+            for (const warning of analysis.cycleWarnings) {
+              result.validationErrors.push({
+                module: mod,
+                field: "api-chain",
+                message: warning,
+                severity: "warning"
+              });
+            }
+          }
+        }
+      }
+      if (activeSteps.includes("plan")) {
+        const backendRoot = path5.resolve(config.backendRoot);
+        const chainAnalyzer = createApiChainAnalyzer();
+        for (const mod of result.modules) {
+          const controllerDir = resolveControllerDir(backendRoot, mod);
+          const endpoints = fs4.existsSync(controllerDir) ? parseControllerDirectory(controllerDir) : [];
+          const analysis = chainAnalyzer.analyze(endpoints);
+          const topoOrder = topologicalSort(analysis.dag);
+          const chains = generateChainPlan(mod, endpoints, topoOrder);
+          result.chainPlans.set(mod, chains);
+        }
+      }
+      if (activeSteps.includes("codegen")) {
+        const testGen = createTestCodeGenerator();
+        const outDir = config.outDir || "./opencroc-output";
+        for (const [_mod, plan] of result.chainPlans) {
+          const files = testGen.generate(plan.chains);
+          for (const file of files) {
+            file.filePath = path5.join(outDir, file.filePath);
+          }
+          result.generatedFiles.push(...files);
+        }
+      }
+      if (activeSteps.includes("validate")) {
+        const configErrors = validateConfig(config);
+        result.validationErrors.push(...configErrors);
+      }
+      result.duration = Date.now() - startTime;
+      return result;
+    }
+  };
+}
+function generateChainPlan(moduleName, endpoints, _topoOrder) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const ep of endpoints) {
+    const segments = ep.path.split("/").filter((s) => s && !s.startsWith(":"));
+    const resource = segments[segments.length - 1] || "default";
+    if (!groups.has(resource)) groups.set(resource, []);
+    groups.get(resource).push(ep);
+  }
+  const chains = [];
+  let totalSteps = 0;
+  for (const [resource, eps] of groups) {
+    const steps = eps.map((ep, i) => ({
+      order: i + 1,
+      action: ep.method,
+      endpoint: ep,
+      description: ep.description || `${ep.method} ${ep.path}`,
+      assertions: []
+    }));
+    chains.push({ name: `${resource} CRUD chain`, module: moduleName, steps });
+    totalSteps += steps.length;
+  }
+  return { chains, totalSteps };
+}
+
+// src/index.ts
+init_controller_parser();
+
 // src/generators/mock-data-generator.ts
+init_esm_shims();
+function randomInt(min, max) {
+  return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+function randomString(prefix, fieldName) {
+  const ts = Date.now().toString(36);
+  const rand = Math.random().toString(36).slice(2, 6);
+  return `${prefix}${fieldName}_${ts}_${rand}`;
+}
+function generateUUID() {
+  const hex = () => Math.random().toString(16).slice(2, 6);
+  return `${hex()}${hex()}-${hex()}-4${hex().slice(1)}-${(8 + randomInt(0, 3)).toString(16)}${hex().slice(1)}-${hex()}${hex()}${hex()}`;
+}
+function generateFieldValue(fieldName, fieldType, isForeignKey, parentTable) {
+  const upper = fieldType.toUpperCase();
+  if (isForeignKey && parentTable) {
+    return `{{parentRecordIds.${parentTable}}}`;
+  }
+  if (upper.startsWith("STRING") || upper === "TEXT") return randomString("test_", fieldName);
+  if (upper === "BIGINT" || upper === "INTEGER") return randomInt(1, 999999);
+  if (upper === "BOOLEAN") return true;
+  if (upper.startsWith("DATE") || upper === "NOW") return (/* @__PURE__ */ new Date()).toISOString();
+  if (upper === "UUID") return generateUUID();
+  if (upper.startsWith("ENUM")) return "ACTIVE";
+  if (upper === "JSON" || upper === "JSONB") return {};
+  if (upper === "FLOAT" || upper === "DOUBLE" || upper === "DECIMAL") return Math.round(Math.random() * 1e4) / 100;
+  return randomString("val_", fieldName);
+}
 function createMockDataGenerator() {
   return {
-    generateForTable(_schema) {
-      throw new Error("Mock data generator not yet implemented");
+    generateForTable(schema) {
+      const record = {};
+      const ts = Date.now().toString(36);
+      const rand = Math.random().toString(36).slice(2, 6);
+      for (const field of schema.fields) {
+        if (field.primaryKey) continue;
+        if (field.defaultValue !== void 0) continue;
+        const isForeignKey = field.name.endsWith("_id") && !field.primaryKey;
+        const parentTable = isForeignKey ? field.name.replace(/_id$/, "") : void 0;
+        let value = generateFieldValue(field.name, field.type, isForeignKey, parentTable);
+        if (field.unique && typeof value === "string") {
+          value = `${value}__e2e_test_${ts}_${rand}`;
+        }
+        record[field.name] = value;
+      }
+      return record;
     },
-    generateForTables(_schemas) {
-      throw new Error("Mock data generator not yet implemented");
+    generateForTables(schemas) {
+      const result = /* @__PURE__ */ new Map();
+      for (const schema of schemas) {
+        const record = this.generateForTable(schema);
+        result.set(schema.tableName, [record]);
+      }
+      return result;
     }
   };
 }
 
-// src/generators/er-diagram-generator.ts
-function createERDiagramGenerator() {
+// src/analyzers/impact-reporter.ts
+init_esm_shims();
+var MAX_BFS_DEPTH = 5;
+function extractTablesFromErrorChain(errorChainPath) {
+  const segments = errorChainPath.split("\u2192").map((s) => s.trim());
+  return segments.filter((s) => !s.includes("/") && !s.includes(" ") && s.includes("_"));
+}
+function buildTableAdjacency(relations) {
+  const adj = /* @__PURE__ */ new Map();
+  for (const rel of relations) {
+    if (!adj.has(rel.sourceTable)) adj.set(rel.sourceTable, /* @__PURE__ */ new Set());
+    if (!adj.has(rel.targetTable)) adj.set(rel.targetTable, /* @__PURE__ */ new Set());
+    adj.get(rel.sourceTable).add(rel.targetTable);
+    adj.get(rel.targetTable).add(rel.sourceTable);
+  }
+  return adj;
+}
+function bfsTraversal(seedTables, adjacency, maxDepth = MAX_BFS_DEPTH) {
+  const visited = /* @__PURE__ */ new Set();
+  const queue = [];
+  for (const t of seedTables) {
+    if (adjacency.has(t)) {
+      queue.push({ table: t, depth: 0 });
+      visited.add(t);
+    }
+  }
+  while (queue.length > 0) {
+    const { table, depth } = queue.shift();
+    if (depth >= maxDepth) continue;
+    for (const neighbor of adjacency.get(table) || []) {
+      if (!visited.has(neighbor)) {
+        visited.add(neighbor);
+        queue.push({ table: neighbor, depth: depth + 1 });
+      }
+    }
+  }
+  return Array.from(visited);
+}
+function findAffectedEndpoints(tables, analysisResults) {
+  const tableSet = new Set(tables);
+  const affected = [];
+  for (const result of analysisResults) {
+    for (const ep of result.endpoints) {
+      if (ep.relatedTables.some((t) => tableSet.has(t))) {
+        affected.push(ep);
+      }
+    }
+  }
+  return affected;
+}
+function generateMermaidDiagram(seedTables, affectedTables, relations) {
+  const relevantTables = /* @__PURE__ */ new Set([...seedTables, ...affectedTables]);
+  const lines = ["flowchart TD"];
+  const seedSet = new Set(seedTables);
+  for (const t of relevantTables) {
+    const label = seedSet.has(t) ? `${t}:::error` : t;
+    lines.push(`  ${sanitizeId(t)}["${label}"]`);
+  }
+  for (const rel of relations) {
+    if (relevantTables.has(rel.sourceTable) && relevantTables.has(rel.targetTable)) {
+      const arrow = rel.isCrossModule ? "-.->" : "-->";
+      lines.push(`  ${sanitizeId(rel.sourceTable)} ${arrow}|${rel.targetField}| ${sanitizeId(rel.targetTable)}`);
+    }
+  }
+  lines.push("  classDef error fill:#f96,stroke:#333,stroke-width:2px");
+  return lines.join("\n");
+}
+function sanitizeId(name) {
+  return name.replace(/[^a-zA-Z0-9_]/g, "_");
+}
+function createImpactReporter() {
   return {
-    generate(_tables, _relations) {
-      throw new Error("ER diagram generator not yet implemented");
+    analyze(failures, erDiagrams, analysisResults) {
+      const allRelations = [];
+      for (const er of erDiagrams.values()) {
+        allRelations.push(...er.relations);
+      }
+      const seedTables = [];
+      for (const failure of failures) {
+        if (failure.errorChainPath) {
+          seedTables.push(...extractTablesFromErrorChain(failure.errorChainPath));
+        }
+      }
+      const adjacency = buildTableAdjacency(allRelations);
+      const affectedTables = bfsTraversal(seedTables, adjacency);
+      const affectedEndpoints = findAffectedEndpoints(affectedTables, analysisResults);
+      const affectedModules = [...new Set(analysisResults.filter((r) => r.endpoints.some((ep) => affectedEndpoints.includes(ep))).map((r) => r.moduleName))];
+      const affectedChains = failures.map((f) => f.chain);
+      const mermaidText = generateMermaidDiagram(seedTables, affectedTables, allRelations);
+      const count = affectedEndpoints.length;
+      const severity = count > 10 ? "critical" : count > 5 ? "high" : count > 2 ? "medium" : "low";
+      return {
+        affectedModules,
+        affectedChains,
+        affectedEndpoints,
+        affectedTables,
+        severity,
+        mermaidText
+      };
     }
   };
 }
 
-// src/analyzers/api-chain-analyzer.ts
-function createApiChainAnalyzer() {
+// src/self-healing/index.ts
+init_esm_shims();
+
+// src/llm/index.ts
+init_esm_shims();
+
+// src/llm/openai.ts
+init_esm_shims();
+var DEFAULT_MODELS = {
+  openai: "gpt-4o-mini",
+  zhipu: "glm-4"
+};
+var DEFAULT_BASE_URLS = {
+  openai: "https://api.openai.com/v1",
+  zhipu: "https://open.bigmodel.cn/api/paas/v4"
+};
+function createOpenAIProvider(config) {
+  const provider = config.provider === "zhipu" ? "zhipu" : "openai";
+  const baseUrl = config.baseUrl || DEFAULT_BASE_URLS[provider];
+  const model = config.model || DEFAULT_MODELS[provider];
+  const maxTokens = config.maxTokens || 2048;
+  const temperature = config.temperature ?? 0.3;
+  if (!config.apiKey) {
+    throw new Error(
+      `API key is required for ${provider}. Set it in config or via OPENCROC_LLM_API_KEY env variable.`
+    );
+  }
   return {
-    analyze(_endpoints) {
-      throw new Error("API chain analyzer not yet implemented");
+    name: provider,
+    async chat(messages) {
+      const url = `${baseUrl}/chat/completions`;
+      const response = await fetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Authorization": `Bearer ${config.apiKey}`
+        },
+        body: JSON.stringify({
+          model,
+          messages,
+          max_tokens: maxTokens,
+          temperature
+        })
+      });
+      if (!response.ok) {
+        const errorText = await response.text().catch(() => "unknown error");
+        throw new Error(`LLM API error (${response.status}): ${errorText}`);
+      }
+      const data = await response.json();
+      const content = data.choices?.[0]?.message?.content;
+      if (!content) {
+        throw new Error("LLM returned empty response");
+      }
+      return content;
+    },
+    estimateTokens(text) {
+      const cjkChars = (text.match(/[\u4e00-\u9fff\u3000-\u303f]/g) || []).length;
+      const otherChars = text.length - cjkChars;
+      return Math.ceil(otherChars / 4 + cjkChars / 2);
     }
   };
 }
 
-// src/analyzers/impact-reporter.ts
-function createImpactReporter() {
+// src/llm/ollama.ts
+init_esm_shims();
+function createOllamaProvider(config) {
+  const baseUrl = config.baseUrl || "http://localhost:11434";
+  const model = config.model || "llama3";
   return {
-    async analyze(_failedEndpoints) {
-      throw new Error("Impact reporter not yet implemented");
+    name: "ollama",
+    async chat(messages) {
+      const url = `${baseUrl}/api/chat`;
+      const response = await fetch(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          model,
+          messages,
+          stream: false
+        })
+      });
+      if (!response.ok) {
+        const errorText = await response.text().catch(() => "unknown error");
+        throw new Error(`Ollama API error (${response.status}): ${errorText}`);
+      }
+      const data = await response.json();
+      const content = data.message?.content;
+      if (!content) {
+        throw new Error("Ollama returned empty response");
+      }
+      return content;
+    },
+    estimateTokens(text) {
+      const cjkChars = (text.match(/[\u4e00-\u9fff\u3000-\u303f]/g) || []).length;
+      const otherChars = text.length - cjkChars;
+      return Math.ceil(otherChars / 4 + cjkChars / 2);
     }
   };
 }
 
-// src/validators/config-validator.ts
-function validateConfig(_config) {
-  return [];
+// src/llm/index.ts
+function createLlmProvider(config) {
+  const resolved = {
+    ...config,
+    apiKey: config.apiKey || process.env.OPENCROC_LLM_API_KEY
+  };
+  switch (config.provider) {
+    case "openai":
+    case "zhipu":
+      return createOpenAIProvider(resolved);
+    case "ollama":
+      return createOllamaProvider(resolved);
+    default:
+      throw new Error(
+        `Unknown LLM provider: "${config.provider}". Available: openai, zhipu, ollama`
+      );
+  }
+}
+function createTokenTracker(provider) {
+  let total = 0;
+  return {
+    track(text) {
+      total += provider.estimateTokens(text);
+    },
+    trackChat(messages, response) {
+      for (const msg of messages) {
+        total += provider.estimateTokens(msg.content);
+      }
+      total += provider.estimateTokens(response);
+    },
+    get total() {
+      return total;
+    },
+    reset() {
+      total = 0;
+    }
+  };
 }
+var SYSTEM_PROMPTS = {
+  failureAnalysis: `You are an expert test failure analyst for an E2E testing framework.
+Given a test failure error message and its context, analyze the root cause and suggest a fix.
+Respond in JSON format: { "rootCause": string, "category": string, "suggestedFix": string, "confidence": number }
+Categories: backend-5xx, timeout, endpoint-not-found, data-constraint, network, frontend-render, test-script, unknown.`,
+  chainPlanning: `You are an API test chain planner.
+Given a list of API endpoints and their dependencies, generate an optimal test execution order.
+Consider data dependencies, authentication requirements, and cleanup steps.
+Respond in JSON format: { "chains": [{ "name": string, "steps": [{ "endpoint": string, "method": string, "description": string }] }] }`
+};
 
 // src/self-healing/index.ts
-function createSelfHealingLoop(_config) {
+function categorizeFailure(errorMessage) {
+  const msg = errorMessage.toLowerCase();
+  if (/5\d{2}|internal server error/.test(msg))
+    return { category: "backend-5xx", confidence: 0.9 };
+  if (/timeout|timed?\s*out/.test(msg))
+    return { category: "timeout", confidence: 0.8 };
+  if (/404|not found/.test(msg))
+    return { category: "endpoint-not-found", confidence: 0.85 };
+  if (/4[0-2]\d|validation|constraint/.test(msg))
+    return { category: "data-constraint", confidence: 0.75 };
+  if (/econnrefused|enotfound|network/.test(msg))
+    return { category: "network", confidence: 0.9 };
+  if (/selector|locator|element/.test(msg))
+    return { category: "frontend-render", confidence: 0.7 };
+  if (/storage\s*state|auth|login/.test(msg))
+    return { category: "test-script", confidence: 0.8 };
+  return { category: "unknown", confidence: 0.5 };
+}
+async function analyzeFailureWithLLM(errorMessage, llm) {
+  const heuristic = categorizeFailure(errorMessage);
+  if (!llm) {
+    return {
+      rootCause: errorMessage,
+      category: heuristic.category,
+      suggestedFix: "",
+      confidence: heuristic.confidence
+    };
+  }
+  try {
+    const response = await llm.chat([
+      { role: "system", content: SYSTEM_PROMPTS.failureAnalysis },
+      { role: "user", content: `Analyze this test failure:
+
+${errorMessage}` }
+    ]);
+    const parsed = JSON.parse(response);
+    return {
+      rootCause: parsed.rootCause || errorMessage,
+      category: parsed.category || heuristic.category,
+      suggestedFix: parsed.suggestedFix || "",
+      confidence: parsed.confidence || heuristic.confidence
+    };
+  } catch {
+    return {
+      rootCause: errorMessage,
+      category: heuristic.category,
+      suggestedFix: "",
+      confidence: heuristic.confidence
+    };
+  }
+}
+async function attemptConfigFix(_testResultsDir, _mode, _llm) {
+  return {
+    success: false,
+    scope: "config-only",
+    fixedItems: [],
+    rolledBack: false
+  };
+}
+function createSelfHealingLoop(config, llm) {
+  return {
+    async run(testResultsDir) {
+      const maxIterations = config.maxIterations || 3;
+      const mode = config.mode || "config-only";
+      const fixed = [];
+      const remaining = [];
+      let iterations = 0;
+      let totalTokensUsed = 0;
+      for (let i = 0; i < maxIterations; i++) {
+        iterations = i + 1;
+        const outcome = await attemptConfigFix(testResultsDir, mode, llm);
+        if (outcome.success) {
+          fixed.push(...outcome.fixedItems);
+        } else {
+          remaining.push(`iteration-${i + 1}: no fix applied`);
+        }
+        if (llm) {
+          totalTokensUsed += llm.estimateTokens(`iteration-${i + 1}`);
+        }
+        if (outcome.success && outcome.fixedItems.length > 0) break;
+      }
+      return {
+        iterations,
+        fixed,
+        remaining,
+        totalTokensUsed
+      };
+    }
+  };
+}
+
+// src/adapters/sequelize.ts
+init_esm_shims();
+init_controller_parser();
+function createSequelizeAdapter() {
+  return {
+    name: "sequelize",
+    async parseModels(dir) {
+      return parseModuleModels(dir);
+    },
+    async parseAssociations(file) {
+      return parseAssociationFile(file);
+    },
+    async parseControllers(dir) {
+      const endpoints = parseControllerDirectory(dir);
+      return endpoints.map((ep) => ({
+        method: ep.method,
+        path: ep.path,
+        handler: "",
+        controllerClass: ""
+      }));
+    }
+  };
+}
+
+// src/adapters/typeorm.ts
+init_esm_shims();
+import * as fs5 from "fs";
+import * as path6 from "path";
+import {
+  Project as Project4
+} from "ts-morph";
+var TYPEORM_TYPE_MAP = {
+  "PrimaryGeneratedColumn": "BIGINT",
+  "PrimaryColumn": "BIGINT",
+  "CreateDateColumn": "DATE",
+  "UpdateDateColumn": "DATE",
+  "DeleteDateColumn": "DATE",
+  "VersionColumn": "INTEGER"
+};
+var TYPEORM_COLUMN_TYPE_MAP = {
+  "varchar": "STRING",
+  "text": "TEXT",
+  "int": "INTEGER",
+  "integer": "INTEGER",
+  "bigint": "BIGINT",
+  "float": "FLOAT",
+  "double": "DOUBLE",
+  "decimal": "DECIMAL",
+  "boolean": "BOOLEAN",
+  "bool": "BOOLEAN",
+  "date": "DATEONLY",
+  "datetime": "DATE",
+  "timestamp": "DATE",
+  "json": "JSON",
+  "jsonb": "JSONB",
+  "enum": "ENUM",
+  "uuid": "UUID"
+};
+function tsTypeToFieldType(tsType) {
+  const t = tsType.toLowerCase().trim();
+  if (t === "string") return "STRING";
+  if (t === "number") return "INTEGER";
+  if (t === "boolean") return "BOOLEAN";
+  if (t === "date") return "DATE";
+  return "STRING";
+}
+function classNameToTableName2(name) {
+  return name.replace(/([A-Z])/g, "_$1").toLowerCase().replace(/^_/, "");
+}
+function extractDecoratorStringArg(decoratorText) {
+  const match = decoratorText.match(/\(\s*['"]([^'"]+)['"]\s*\)/);
+  return match?.[1];
+}
+function extractDecoratorObjectArg(decoratorText) {
+  const result = {};
+  const objMatch = decoratorText.match(/\(\s*\{([^}]*)\}\s*\)/);
+  if (!objMatch) return result;
+  const body = objMatch[1];
+  const pairs = body.matchAll(/(\w+)\s*:\s*['"]([^'"]*)['"]/g);
+  for (const pair of pairs) {
+    result[pair[1]] = pair[2];
+  }
+  const boolPairs = body.matchAll(/(\w+)\s*:\s*(true|false)/g);
+  for (const pair of boolPairs) {
+    result[pair[1]] = pair[2];
+  }
+  return result;
+}
+function parseTypeORMFile(filePath) {
+  const absolutePath = path6.resolve(filePath);
+  if (!fs5.existsSync(absolutePath)) return null;
+  const project = new Project4({ compilerOptions: { strict: false } });
+  const sourceFile = project.addSourceFileAtPath(absolutePath);
+  const classes = sourceFile.getClasses();
+  for (const cls of classes) {
+    const entityDecorator = cls.getDecorator("Entity");
+    if (!entityDecorator) continue;
+    const tableName = extractDecoratorStringArg(entityDecorator.getText()) || extractDecoratorObjectArg(entityDecorator.getText()).name || classNameToTableName2(cls.getName() || "unknown");
+    const fields = extractTypeORMFields(cls);
+    return { tableName, className: cls.getName(), fields };
+  }
+  return null;
+}
+function extractTypeORMFields(cls) {
+  const fields = [];
+  for (const prop of cls.getProperties()) {
+    const field = parseTypeORMProperty(prop);
+    if (field) fields.push(field);
+  }
+  return fields;
+}
+function parseTypeORMProperty(prop) {
+  const decorators = prop.getDecorators();
+  if (decorators.length === 0) return null;
+  const name = prop.getName();
+  let type = "STRING";
+  let primaryKey = false;
+  let allowNull = true;
+  let unique = false;
+  for (const dec of decorators) {
+    const decName = dec.getName();
+    const decText = dec.getText();
+    if (decName === "PrimaryGeneratedColumn" || decName === "PrimaryColumn") {
+      primaryKey = true;
+      type = TYPEORM_TYPE_MAP[decName] || "BIGINT";
+      allowNull = false;
+      const argType = extractDecoratorStringArg(decText);
+      if (argType === "uuid") type = "UUID";
+      if (argType === "increment") type = "BIGINT";
+    }
+    if (decName === "Column") {
+      const objArgs = extractDecoratorObjectArg(decText);
+      if (objArgs.type && TYPEORM_COLUMN_TYPE_MAP[objArgs.type]) {
+        type = TYPEORM_COLUMN_TYPE_MAP[objArgs.type];
+      } else {
+        const simpleType = extractDecoratorStringArg(decText);
+        if (simpleType && TYPEORM_COLUMN_TYPE_MAP[simpleType]) {
+          type = TYPEORM_COLUMN_TYPE_MAP[simpleType];
+        }
+      }
+      if (objArgs.nullable === "false") allowNull = false;
+      if (objArgs.unique === "true") unique = true;
+      if (type === "STRING") {
+        const tsType = prop.getType().getText();
+        type = tsTypeToFieldType(tsType);
+      }
+    }
+    if (decName in TYPEORM_TYPE_MAP) {
+      type = TYPEORM_TYPE_MAP[decName];
+    }
+    if (decName === "CreateDateColumn" || decName === "UpdateDateColumn" || decName === "DeleteDateColumn") {
+      allowNull = true;
+    }
+  }
+  const recognizedDecorators = [
+    "Column",
+    "PrimaryGeneratedColumn",
+    "PrimaryColumn",
+    "CreateDateColumn",
+    "UpdateDateColumn",
+    "DeleteDateColumn",
+    "VersionColumn",
+    "ManyToOne",
+    "OneToMany",
+    "OneToOne",
+    "ManyToMany",
+    "JoinColumn",
+    "JoinTable"
+  ];
+  const hasRecognized = decorators.some((d) => recognizedDecorators.includes(d.getName()));
+  if (!hasRecognized) return null;
+  const isRelationOnly = decorators.every(
+    (d) => ["ManyToOne", "OneToMany", "OneToOne", "ManyToMany", "JoinColumn", "JoinTable"].includes(d.getName())
+  );
+  if (isRelationOnly) return null;
+  return { name, type, allowNull, primaryKey, unique };
+}
+function parseTypeORMAssociations(filePath) {
+  const absolutePath = path6.resolve(filePath);
+  if (!fs5.existsSync(absolutePath)) return [];
+  const project = new Project4({ compilerOptions: { strict: false } });
+  const sourceFile = project.addSourceFileAtPath(absolutePath);
+  const relations = [];
+  for (const cls of sourceFile.getClasses()) {
+    const entityDecorator = cls.getDecorator("Entity");
+    if (!entityDecorator) continue;
+    const sourceTable = extractDecoratorStringArg(entityDecorator.getText()) || classNameToTableName2(cls.getName() || "unknown");
+    for (const prop of cls.getProperties()) {
+      const rel = extractRelationFromProperty(prop, sourceTable);
+      if (rel) relations.push(rel);
+    }
+  }
+  return relations;
+}
+function extractRelationFromProperty(prop, sourceTable) {
+  const decorators = prop.getDecorators();
+  for (const dec of decorators) {
+    const decName = dec.getName();
+    const decText = dec.getText();
+    if (decName === "ManyToOne") {
+      const targetClass = extractRelationTarget(decText);
+      if (!targetClass) continue;
+      const targetTable = classNameToTableName2(targetClass);
+      const fkField = findJoinColumnField(decorators) || `${prop.getName()}_id`;
+      return {
+        sourceTable,
+        sourceField: fkField,
+        targetTable,
+        targetField: "id",
+        cardinality: "N:1"
+      };
+    }
+    if (decName === "OneToMany") {
+      const targetClass = extractRelationTarget(decText);
+      if (!targetClass) continue;
+      const targetTable = classNameToTableName2(targetClass);
+      return {
+        sourceTable,
+        sourceField: "id",
+        targetTable,
+        targetField: `${classNameToTableName2(sourceTable)}_id`,
+        cardinality: "1:N"
+      };
+    }
+    if (decName === "OneToOne") {
+      const targetClass = extractRelationTarget(decText);
+      if (!targetClass) continue;
+      const targetTable = classNameToTableName2(targetClass);
+      return {
+        sourceTable,
+        sourceField: "id",
+        targetTable,
+        targetField: `${classNameToTableName2(sourceTable)}_id`,
+        cardinality: "1:1"
+      };
+    }
+  }
+  return null;
+}
+function extractRelationTarget(decoratorText) {
+  const match = decoratorText.match(/\(\s*(?:\(\)\s*=>|type\s*=>|\w+\s*=>)\s*(\w+)/);
+  return match?.[1] || null;
+}
+function findJoinColumnField(decorators) {
+  for (const dec of decorators) {
+    if (dec.getName() === "JoinColumn") {
+      const args = extractDecoratorObjectArg(dec.getText());
+      if (args.name) return args.name;
+    }
+  }
+  return null;
+}
+function parseTypeORMDirectory(dir) {
+  const absoluteDir = path6.resolve(dir);
+  if (!fs5.existsSync(absoluteDir)) return [];
+  const files = fs5.readdirSync(absoluteDir).filter(
+    (f) => f.endsWith(".ts") && !f.endsWith(".test.ts") && !f.endsWith(".spec.ts") && f !== "index.ts"
+  );
+  const schemas = [];
+  for (const file of files) {
+    try {
+      const schema = parseTypeORMFile(path6.join(absoluteDir, file));
+      if (schema) schemas.push(schema);
+    } catch {
+    }
+  }
+  return schemas;
+}
+function parseTypeORMAssociationsFromDir(dir) {
+  const absoluteDir = path6.resolve(dir);
+  if (!fs5.existsSync(absoluteDir)) return [];
+  const files = fs5.readdirSync(absoluteDir).filter(
+    (f) => f.endsWith(".ts") && !f.endsWith(".test.ts") && !f.endsWith(".spec.ts") && f !== "index.ts"
+  );
+  const relations = [];
+  for (const file of files) {
+    try {
+      relations.push(...parseTypeORMAssociations(path6.join(absoluteDir, file)));
+    } catch {
+    }
+  }
+  return relations;
+}
+function createTypeORMAdapter() {
   return {
-    async run(_testResultsDir) {
-      throw new Error("Self-healing loop not yet implemented");
+    name: "typeorm",
+    async parseModels(dir) {
+      return parseTypeORMDirectory(dir);
+    },
+    async parseAssociations(file) {
+      const dir = path6.dirname(file);
+      return parseTypeORMAssociationsFromDir(dir);
+    },
+    async parseControllers(dir) {
+      const { parseControllerDirectory: parseControllerDirectory2 } = await Promise.resolve().then(() => (init_controller_parser(), controller_parser_exports));
+      const endpoints = parseControllerDirectory2(dir);
+      return endpoints.map((ep) => ({
+        method: ep.method,
+        path: ep.path,
+        handler: "",
+        controllerClass: ""
+      }));
     }
   };
 }
+
+// src/adapters/prisma.ts
+init_esm_shims();
+import * as fs6 from "fs";
+import * as path7 from "path";
+var PRISMA_TYPE_MAP = {
+  "String": "STRING",
+  "Int": "INTEGER",
+  "BigInt": "BIGINT",
+  "Float": "FLOAT",
+  "Decimal": "DECIMAL",
+  "Boolean": "BOOLEAN",
+  "DateTime": "DATE",
+  "Json": "JSON",
+  "Bytes": "BLOB"
+};
+function parsePrismaSchema(content) {
+  const models = [];
+  const modelRegex = /model\s+(\w+)\s*\{([^}]*)\}/g;
+  let match;
+  while ((match = modelRegex.exec(content)) !== null) {
+    const modelName = match[1];
+    const body = match[2];
+    const fields = parsePrismaFields(body);
+    const mapDirective = body.match(/@@map\(["']([^"']+)["']\)/);
+    models.push({
+      name: modelName,
+      fields,
+      tableName: mapDirective?.[1]
+    });
+  }
+  return models;
+}
+function parsePrismaFields(body) {
+  const fields = [];
+  const lines = body.split("\n").map((l) => l.trim()).filter((l) => l && !l.startsWith("//") && !l.startsWith("@@"));
+  for (const line of lines) {
+    const field = parsePrismaFieldLine(line);
+    if (field) fields.push(field);
+  }
+  return fields;
+}
+function parsePrismaFieldLine(line) {
+  const match = line.match(/^(\w+)\s+(\w+)(\[\])?\??/);
+  if (!match) return null;
+  const name = match[1];
+  const rawType = match[2];
+  const isList = !!match[3];
+  const isOptional = line.includes("?");
+  const field = {
+    name,
+    type: rawType,
+    isOptional,
+    isList,
+    isId: /@id\b/.test(line),
+    isUnique: /@unique\b/.test(line),
+    isUpdatedAt: /@updatedAt\b/.test(line)
+  };
+  const defaultMatch = line.match(/@default\(([^)]+)\)/);
+  if (defaultMatch) field.defaultValue = defaultMatch[1];
+  const mapMatch = line.match(/@map\(["']([^"']+)["']\)/);
+  if (mapMatch) field.mapName = mapMatch[1];
+  const nativeMatch = line.match(/@db\.(\w+(?:\([^)]*\))?)/);
+  if (nativeMatch) field.nativeType = nativeMatch[1];
+  const relMatch = line.match(/@relation\(([^)]*)\)/);
+  if (relMatch) {
+    field.relation = parseRelationDirective(relMatch[1]);
+  }
+  return field;
+}
+function parseRelationDirective(content) {
+  const rel = {};
+  const nameMatch = content.match(/(?:name:\s*)?["']([^"']+)["']/);
+  if (nameMatch) rel.name = nameMatch[1];
+  const fieldsMatch = content.match(/fields:\s*\[([^\]]+)\]/);
+  if (fieldsMatch) {
+    rel.fields = fieldsMatch[1].split(",").map((s) => s.trim());
+  }
+  const refsMatch = content.match(/references:\s*\[([^\]]+)\]/);
+  if (refsMatch) {
+    rel.references = refsMatch[1].split(",").map((s) => s.trim());
+  }
+  return rel;
+}
+function modelNameToTableName(name) {
+  return name.replace(/([A-Z])/g, "_$1").toLowerCase().replace(/^_/, "");
+}
+function prismaModelsToSchemas(models) {
+  return models.map((model) => {
+    const tableName = model.tableName || modelNameToTableName(model.name);
+    const fields = [];
+    for (const f of model.fields) {
+      if (f.isList) continue;
+      if (!PRISMA_TYPE_MAP[f.type] && !f.relation) continue;
+      if (!PRISMA_TYPE_MAP[f.type] && f.relation && !f.relation.fields) continue;
+      const fieldType = PRISMA_TYPE_MAP[f.type] || "STRING";
+      fields.push({
+        name: f.mapName || f.name,
+        type: fieldType,
+        allowNull: f.isOptional,
+        primaryKey: f.isId,
+        unique: f.isUnique,
+        defaultValue: f.defaultValue
+      });
+    }
+    return { tableName, className: model.name, fields };
+  });
+}
+function prismaModelsToRelations(models) {
+  const relations = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const model of models) {
+    const sourceTable = model.tableName || modelNameToTableName(model.name);
+    for (const field of model.fields) {
+      if (!field.relation?.fields || !field.relation?.references) continue;
+      const targetModel = models.find((m) => m.name === field.type);
+      const targetTable = targetModel ? targetModel.tableName || modelNameToTableName(targetModel.name) : modelNameToTableName(field.type);
+      const sourceField = field.relation.fields[0];
+      const targetField = field.relation.references[0];
+      const key = `${sourceTable}|${sourceField}|${targetTable}|${targetField}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      const isList = field.isList;
+      relations.push({
+        sourceTable,
+        sourceField,
+        targetTable,
+        targetField,
+        cardinality: isList ? "1:N" : "N:1"
+      });
+    }
+  }
+  return relations;
+}
+function parsePrismaFile(filePath) {
+  const absolutePath = path7.resolve(filePath);
+  if (!fs6.existsSync(absolutePath)) return { schemas: [], relations: [] };
+  const content = fs6.readFileSync(absolutePath, "utf-8");
+  const models = parsePrismaSchema(content);
+  return {
+    schemas: prismaModelsToSchemas(models),
+    relations: prismaModelsToRelations(models)
+  };
+}
+function findPrismaSchemaFile(dir) {
+  const candidates = [
+    path7.join(dir, "schema.prisma"),
+    path7.join(dir, "prisma", "schema.prisma"),
+    path7.join(dir, "..", "prisma", "schema.prisma")
+  ];
+  for (const c of candidates) {
+    if (fs6.existsSync(c)) return c;
+  }
+  return null;
+}
+function createPrismaAdapter() {
+  return {
+    name: "prisma",
+    async parseModels(dir) {
+      const schemaFile = findPrismaSchemaFile(dir);
+      if (!schemaFile) return [];
+      const { schemas } = parsePrismaFile(schemaFile);
+      return schemas;
+    },
+    async parseAssociations(file) {
+      const schemaFile = findPrismaSchemaFile(path7.dirname(file)) || file;
+      const { relations } = parsePrismaFile(schemaFile);
+      return relations;
+    },
+    async parseControllers(dir) {
+      const { parseControllerDirectory: parseControllerDirectory2 } = await Promise.resolve().then(() => (init_controller_parser(), controller_parser_exports));
+      const endpoints = parseControllerDirectory2(dir);
+      return endpoints.map((ep) => ({
+        method: ep.method,
+        path: ep.path,
+        handler: "",
+        controllerClass: ""
+      }));
+    }
+  };
+}
+
+// src/adapters/registry.ts
+init_esm_shims();
+import * as fs7 from "fs";
+import * as path8 from "path";
+var ADAPTER_FACTORIES = {
+  sequelize: createSequelizeAdapter,
+  typeorm: createTypeORMAdapter,
+  prisma: createPrismaAdapter
+};
+function createAdapter(name) {
+  const factory = ADAPTER_FACTORIES[name];
+  if (!factory) {
+    throw new Error(`Unknown adapter: "${name}". Available: ${Object.keys(ADAPTER_FACTORIES).join(", ")}`);
+  }
+  return factory();
+}
+function detectAdapter(backendRoot) {
+  const root = path8.resolve(backendRoot);
+  const prismaLocations = [
+    path8.join(root, "prisma", "schema.prisma"),
+    path8.join(root, "schema.prisma"),
+    path8.join(root, "..", "prisma", "schema.prisma")
+  ];
+  for (const loc of prismaLocations) {
+    if (fs7.existsSync(loc)) return "prisma";
+  }
+  const modelsDir = path8.join(root, "models");
+  if (fs7.existsSync(modelsDir)) {
+    try {
+      const files = fs7.readdirSync(modelsDir, { recursive: true });
+      for (const file of files) {
+        const filePath = path8.join(modelsDir, String(file));
+        if (!filePath.endsWith(".ts")) continue;
+        try {
+          const content = fs7.readFileSync(filePath, "utf-8");
+          if (/@Entity\s*\(/.test(content)) return "typeorm";
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+  return "sequelize";
+}
+function resolveAdapter(adapterOrName, backendRoot) {
+  if (typeof adapterOrName === "object" && adapterOrName !== null) {
+    return adapterOrName;
+  }
+  const name = adapterOrName === "auto" || !adapterOrName ? detectAdapter(backendRoot) : adapterOrName;
+  return createAdapter(name);
+}
+
+// src/plugins/index.ts
+init_esm_shims();
+function createPluginRegistry() {
+  const plugins = [];
+  function register(plugin) {
+    if (!plugin.name) {
+      throw new Error("Plugin must have a name");
+    }
+    if (plugins.some((p) => p.name === plugin.name)) {
+      throw new Error(`Plugin "${plugin.name}" is already registered`);
+    }
+    plugins.push(plugin);
+  }
+  async function unregister(name) {
+    const idx = plugins.findIndex((p) => p.name === name);
+    if (idx === -1) return;
+    const plugin = plugins[idx];
+    if (plugin.teardown) {
+      await plugin.teardown();
+    }
+    plugins.splice(idx, 1);
+  }
+  function get(name) {
+    return plugins.find((p) => p.name === name);
+  }
+  function list() {
+    return plugins.map((p) => p.name);
+  }
+  async function invoke(hook, ...args) {
+    for (const plugin of plugins) {
+      const fn = plugin[hook];
+      if (typeof fn === "function") {
+        await fn.apply(plugin, args);
+      }
+    }
+  }
+  async function applyConfigTransforms(config) {
+    let result = config;
+    for (const plugin of plugins) {
+      if (plugin.transformConfig) {
+        result = await plugin.transformConfig(result);
+      }
+    }
+    return result;
+  }
+  return { register, unregister, get, list, invoke, applyConfigTransforms };
+}
+function definePlugin(plugin) {
+  return plugin;
+}
+
+// src/ci/index.ts
+init_esm_shims();
+function generateGitHubActionsTemplate(opts = {}) {
+  const nodeVersions = opts.nodeVersions ?? ["20.x"];
+  const install = opts.installCommand ?? "npm ci";
+  const genArgs = opts.generateArgs ?? "--all";
+  const testArgs = opts.testArgs ?? "";
+  const healStep = opts.selfHeal ? `
+      - name: Self-heal failures
+        if: failure()
+        run: npx opencroc heal --max-iterations 3` : "";
+  const matrix = nodeVersions.length > 1 ? `
+    strategy:
+      matrix:
+        node-version: [${nodeVersions.join(", ")}]` : "";
+  const nodeSetup = nodeVersions.length > 1 ? "${{ matrix.node-version }}" : nodeVersions[0];
+  return `# Generated by OpenCroc \u2014 AI-native E2E testing
+# https://github.com/opencroc/opencroc
+
+name: OpenCroc E2E
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  e2e:
+    runs-on: ubuntu-latest${matrix}
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '${nodeSetup}'
+
+      - name: Install dependencies
+        run: ${install}
+
+      - name: Install Playwright browsers
+        run: npx playwright install --with-deps chromium
+
+      - name: Generate E2E tests
+        run: npx opencroc generate ${genArgs}
+
+      - name: Run E2E tests
+        run: npx opencroc test ${testArgs}
+${healStep}
+      - name: Upload test report
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: opencroc-report
+          path: opencroc-output/
+          retention-days: 14
+`;
+}
+function generateGitLabCITemplate(opts = {}) {
+  const install = opts.installCommand ?? "npm ci";
+  const genArgs = opts.generateArgs ?? "--all";
+  const testArgs = opts.testArgs ?? "";
+  const nodeVersion = opts.nodeVersions?.[0] ?? "20";
+  return `# Generated by OpenCroc \u2014 AI-native E2E testing
+# https://github.com/opencroc/opencroc
+
+image: node:${nodeVersion}
+
+stages:
+  - generate
+  - test
+
+variables:
+  PLAYWRIGHT_BROWSERS_PATH: \${CI_PROJECT_DIR}/.cache/ms-playwright
+
+cache:
+  key: \${CI_COMMIT_REF_SLUG}
+  paths:
+    - node_modules/
+    - .cache/ms-playwright/
+
+generate:
+  stage: generate
+  script:
+    - ${install}
+    - npx opencroc generate ${genArgs}
+  artifacts:
+    paths:
+      - opencroc-output/
+    expire_in: 1 day
+
+e2e:
+  stage: test
+  needs: [generate]
+  before_script:
+    - ${install}
+    - npx playwright install --with-deps chromium
+  script:
+    - npx opencroc test ${testArgs}
+  artifacts:
+    when: always
+    paths:
+      - opencroc-output/
+    expire_in: 14 days
+`;
+}
+var TEMPLATES = {
+  github: generateGitHubActionsTemplate,
+  gitlab: generateGitLabCITemplate
+};
+function listCiPlatforms() {
+  return Object.keys(TEMPLATES);
+}
+function generateCiTemplate(platform, opts = {}) {
+  const generator = TEMPLATES[platform];
+  if (!generator) {
+    throw new Error(
+      `Unknown CI platform: "${platform}". Available: ${Object.keys(TEMPLATES).join(", ")}`
+    );
+  }
+  return generator(opts);
+}
+
+// src/reporters/index.ts
+init_esm_shims();
+function generateJsonReport(result) {
+  const serializable = {
+    modules: result.modules,
+    erDiagrams: Object.fromEntries(
+      Array.from(result.erDiagrams.entries()).map(([k, v]) => [
+        k,
+        { tables: v.tables.length, relations: v.relations.length, mermaidText: v.mermaidText }
+      ])
+    ),
+    chainPlans: Object.fromEntries(
+      Array.from(result.chainPlans.entries()).map(([k, v]) => [
+        k,
+        { chains: v.chains.length, totalSteps: v.totalSteps }
+      ])
+    ),
+    generatedFiles: result.generatedFiles.map((f) => ({
+      filePath: f.filePath,
+      module: f.module,
+      chain: f.chain
+    })),
+    validationErrors: result.validationErrors,
+    duration: result.duration
+  };
+  return {
+    format: "json",
+    content: JSON.stringify(serializable, null, 2),
+    filename: "opencroc-report.json"
+  };
+}
+function generateMarkdownReport(result) {
+  const lines = [
+    "# OpenCroc Report",
+    "",
+    `**Duration**: ${result.duration}ms`,
+    `**Modules**: ${result.modules.length} (${result.modules.join(", ")})`,
+    "",
+    "## ER Diagrams",
+    ""
+  ];
+  for (const [mod, er] of result.erDiagrams) {
+    lines.push(`### ${mod}`);
+    lines.push(`- Tables: ${er.tables.length}`);
+    lines.push(`- Relations: ${er.relations.length}`);
+    lines.push("");
+  }
+  lines.push("## Chain Plans", "");
+  for (const [mod, plan] of result.chainPlans) {
+    lines.push(`### ${mod}`);
+    lines.push(`- Chains: ${plan.chains.length}`);
+    lines.push(`- Total Steps: ${plan.totalSteps}`);
+    lines.push("");
+  }
+  lines.push(`## Generated Files (${result.generatedFiles.length})`, "");
+  for (const f of result.generatedFiles) {
+    lines.push(`- \`${f.filePath}\` (${f.module} / ${f.chain})`);
+  }
+  if (result.validationErrors.length > 0) {
+    lines.push("", "## Validation Issues", "");
+    const errors = result.validationErrors.filter((e) => e.severity === "error");
+    const warnings = result.validationErrors.filter((e) => e.severity === "warning");
+    if (errors.length > 0) {
+      lines.push(`### Errors (${errors.length})`, "");
+      for (const e of errors) {
+        lines.push(`- **[${e.module}]** ${e.field}: ${e.message}`);
+      }
+    }
+    if (warnings.length > 0) {
+      lines.push(`### Warnings (${warnings.length})`, "");
+      for (const w of warnings) {
+        lines.push(`- **[${w.module}]** ${w.field}: ${w.message}`);
+      }
+    }
+  }
+  lines.push("", "---", "*Generated by [OpenCroc](https://github.com/opencroc/opencroc)*");
+  return {
+    format: "markdown",
+    content: lines.join("\n"),
+    filename: "opencroc-report.md"
+  };
+}
+function escapeHtml(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function erSummaryRows(erDiagrams) {
+  const rows = [];
+  for (const [mod, er] of erDiagrams) {
+    rows.push(`<tr><td>${escapeHtml(mod)}</td><td>${er.tables.length}</td><td>${er.relations.length}</td></tr>`);
+  }
+  return rows.join("\n");
+}
+function chainSummaryRows(chainPlans) {
+  const rows = [];
+  for (const [mod, plan] of chainPlans) {
+    rows.push(`<tr><td>${escapeHtml(mod)}</td><td>${plan.chains.length}</td><td>${plan.totalSteps}</td></tr>`);
+  }
+  return rows.join("\n");
+}
+function fileListRows(files) {
+  return files.map((f) => `<tr><td><code>${escapeHtml(f.filePath)}</code></td><td>${escapeHtml(f.module)}</td><td>${escapeHtml(f.chain)}</td></tr>`).join("\n");
+}
+function validationRows(errors) {
+  return errors.map(
+    (e) => `<tr class="${e.severity}"><td><span class="badge ${e.severity}">${e.severity}</span></td><td>${escapeHtml(e.module)}</td><td>${escapeHtml(e.field)}</td><td>${escapeHtml(e.message)}</td></tr>`
+  ).join("\n");
+}
+function generateHtmlReport(result) {
+  const totalTables = Array.from(result.erDiagrams.values()).reduce((s, e) => s + e.tables.length, 0);
+  const totalRelations = Array.from(result.erDiagrams.values()).reduce((s, e) => s + e.relations.length, 0);
+  const totalChains = Array.from(result.chainPlans.values()).reduce((s, p) => s + p.chains.length, 0);
+  const totalSteps = Array.from(result.chainPlans.values()).reduce((s, p) => s + p.totalSteps, 0);
+  const errorCount = result.validationErrors.filter((e) => e.severity === "error").length;
+  const warnCount = result.validationErrors.filter((e) => e.severity === "warning").length;
+  const html = `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="utf-8" />
+<meta name="viewport" content="width=device-width, initial-scale=1" />
+<title>OpenCroc Report</title>
+<style>
+  :root { --bg: #0d1117; --fg: #c9d1d9; --card: #161b22; --border: #30363d; --accent: #58a6ff; --green: #3fb950; --yellow: #d29922; --red: #f85149; }
+  * { box-sizing: border-box; margin: 0; padding: 0; }
+  body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Helvetica, Arial, sans-serif; background: var(--bg); color: var(--fg); padding: 2rem; }
+  h1 { color: var(--accent); margin-bottom: 0.25rem; }
+  .subtitle { color: #8b949e; margin-bottom: 2rem; }
+  .grid { display: grid; grid-template-columns: repeat(auto-fit, minmax(200px, 1fr)); gap: 1rem; margin-bottom: 2rem; }
+  .card { background: var(--card); border: 1px solid var(--border); border-radius: 8px; padding: 1.25rem; }
+  .card .label { font-size: 0.85rem; color: #8b949e; }
+  .card .value { font-size: 2rem; font-weight: 700; color: var(--accent); }
+  .card .value.green { color: var(--green); }
+  .card .value.yellow { color: var(--yellow); }
+  .card .value.red { color: var(--red); }
+  section { margin-bottom: 2rem; }
+  h2 { color: var(--fg); border-bottom: 1px solid var(--border); padding-bottom: 0.5rem; margin-bottom: 1rem; }
+  table { width: 100%; border-collapse: collapse; background: var(--card); border-radius: 8px; overflow: hidden; }
+  th, td { text-align: left; padding: 0.6rem 1rem; border-bottom: 1px solid var(--border); }
+  th { background: #21262d; color: #8b949e; font-weight: 600; font-size: 0.85rem; text-transform: uppercase; }
+  tr:last-child td { border-bottom: none; }
+  code { background: #21262d; padding: 0.15rem 0.4rem; border-radius: 4px; font-size: 0.85rem; }
+  .badge { display: inline-block; padding: 0.15rem 0.5rem; border-radius: 12px; font-size: 0.75rem; font-weight: 600; text-transform: uppercase; }
+  .badge.error { background: rgba(248,81,73,0.15); color: var(--red); }
+  .badge.warning { background: rgba(210,153,34,0.15); color: var(--yellow); }
+  footer { margin-top: 3rem; text-align: center; color: #484f58; font-size: 0.85rem; }
+  footer a { color: var(--accent); text-decoration: none; }
+</style>
+</head>
+<body>
+<h1>OpenCroc Report</h1>
+<p class="subtitle">Generated in ${result.duration}ms &middot; ${result.modules.length} module(s)</p>
+
+<div class="grid">
+  <div class="card"><div class="label">Modules</div><div class="value">${result.modules.length}</div></div>
+  <div class="card"><div class="label">Tables</div><div class="value">${totalTables}</div></div>
+  <div class="card"><div class="label">Relations</div><div class="value">${totalRelations}</div></div>
+  <div class="card"><div class="label">Chains</div><div class="value">${totalChains}</div></div>
+  <div class="card"><div class="label">Steps</div><div class="value">${totalSteps}</div></div>
+  <div class="card"><div class="label">Files</div><div class="value green">${result.generatedFiles.length}</div></div>
+  <div class="card"><div class="label">Errors</div><div class="value${errorCount > 0 ? " red" : ""}">${errorCount}</div></div>
+  <div class="card"><div class="label">Warnings</div><div class="value${warnCount > 0 ? " yellow" : ""}">${warnCount}</div></div>
+</div>
+
+<section>
+<h2>ER Diagrams</h2>
+<table>
+<thead><tr><th>Module</th><th>Tables</th><th>Relations</th></tr></thead>
+<tbody>${erSummaryRows(result.erDiagrams)}</tbody>
+</table>
+</section>
+
+<section>
+<h2>Chain Plans</h2>
+<table>
+<thead><tr><th>Module</th><th>Chains</th><th>Steps</th></tr></thead>
+<tbody>${chainSummaryRows(result.chainPlans)}</tbody>
+</table>
+</section>
+
+<section>
+<h2>Generated Files (${result.generatedFiles.length})</h2>
+<table>
+<thead><tr><th>File</th><th>Module</th><th>Chain</th></tr></thead>
+<tbody>${fileListRows(result.generatedFiles)}</tbody>
+</table>
+</section>
+
+${result.validationErrors.length > 0 ? `<section>
+<h2>Validation Issues (${result.validationErrors.length})</h2>
+<table>
+<thead><tr><th>Severity</th><th>Module</th><th>Field</th><th>Message</th></tr></thead>
+<tbody>${validationRows(result.validationErrors)}</tbody>
+</table>
+</section>` : ""}
+
+<footer>
+  Generated by <a href="https://github.com/opencroc/opencroc">OpenCroc</a>
+</footer>
+</body>
+</html>`;
+  return {
+    format: "html",
+    content: html,
+    filename: "opencroc-report.html"
+  };
+}
+var REPORTERS = {
+  html: generateHtmlReport,
+  json: generateJsonReport,
+  markdown: generateMarkdownReport
+};
+function generateReports(result, formats = ["html"]) {
+  return formats.map((fmt) => {
+    const gen = REPORTERS[fmt];
+    if (!gen) throw new Error(`Unknown report format: "${fmt}". Available: ${Object.keys(REPORTERS).join(", ")}`);
+    return gen(result);
+  });
+}
+
+// src/vscode/index.ts
+init_esm_shims();
+var COMMANDS = [
+  { command: "opencroc.init", title: "Initialize Project", category: "OpenCroc" },
+  { command: "opencroc.generate", title: "Generate Tests", category: "OpenCroc" },
+  { command: "opencroc.generateModule", title: "Generate Tests for Module...", category: "OpenCroc" },
+  { command: "opencroc.test", title: "Run Tests", category: "OpenCroc" },
+  { command: "opencroc.testModule", title: "Run Tests for Module...", category: "OpenCroc" },
+  { command: "opencroc.validate", title: "Validate Configuration", category: "OpenCroc" },
+  { command: "opencroc.heal", title: "Self-Heal Failures", category: "OpenCroc" },
+  { command: "opencroc.openReport", title: "Open Report", category: "OpenCroc" },
+  { command: "opencroc.ci", title: "Generate CI Template", category: "OpenCroc" }
+];
+function buildModuleTree(modules) {
+  return modules.map((mod) => ({
+    label: mod,
+    description: "module",
+    iconId: "symbol-module",
+    children: [
+      { label: "Generate Tests", command: "opencroc.generateModule", iconId: "play" },
+      { label: "Run Tests", command: "opencroc.testModule", iconId: "testing-run-icon" },
+      { label: "View ER Diagram", command: "opencroc.openReport", iconId: "graph" }
+    ]
+  }));
+}
+function buildStatusTree(stats) {
+  return [
+    { label: `Modules: ${stats.modules}`, iconId: "symbol-module" },
+    { label: `Tables: ${stats.tables}`, iconId: "database" },
+    { label: `Relations: ${stats.relations}`, iconId: "git-merge" },
+    { label: `Generated: ${stats.generatedFiles} files`, iconId: "file-code" },
+    {
+      label: stats.errors > 0 ? `Errors: ${stats.errors}` : "No errors",
+      iconId: stats.errors > 0 ? "error" : "pass"
+    }
+  ];
+}
+function generateExtensionManifest() {
+  return {
+    name: "opencroc",
+    displayName: "OpenCroc",
+    description: "AI-native E2E testing \u2014 generate, run, and self-heal tests from VS Code",
+    version: "0.1.0",
+    publisher: "opencroc",
+    license: "MIT",
+    repository: { type: "git", url: "https://github.com/opencroc/opencroc" },
+    engines: { vscode: "^1.85.0" },
+    categories: ["Testing"],
+    keywords: ["e2e", "testing", "playwright", "ai", "self-healing"],
+    activationEvents: ["workspaceContains:opencroc.config.ts", "workspaceContains:opencroc.config.js"],
+    main: "./out/extension.js",
+    contributes: {
+      commands: COMMANDS.map((c) => ({
+        command: c.command,
+        title: c.title,
+        category: c.category
+      })),
+      viewsContainers: {
+        activitybar: [
+          {
+            id: "opencroc",
+            title: "OpenCroc",
+            icon: "resources/opencroc.svg"
+          }
+        ]
+      },
+      views: {
+        opencroc: [
+          { id: "opencroc.status", name: "Status" },
+          { id: "opencroc.modules", name: "Modules" }
+        ]
+      },
+      configuration: {
+        title: "OpenCroc",
+        properties: {
+          "opencroc.autoGenerate": {
+            type: "boolean",
+            default: false,
+            description: "Automatically regenerate tests on file save"
+          },
+          "opencroc.reportFormat": {
+            type: "string",
+            default: "html",
+            enum: ["html", "json", "markdown"],
+            description: "Default report format"
+          }
+        }
+      }
+    }
+  };
+}
+function generateExtensionEntrypoint() {
+  return `import * as vscode from 'vscode';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+
+const run = promisify(exec);
+
+export function activate(context: vscode.ExtensionContext) {
+  const outputChannel = vscode.window.createOutputChannel('OpenCroc');
+
+  async function runCommand(cmd: string) {
+    const workspaceFolder = vscode.workspace.workspaceFolders?.[0];
+    if (!workspaceFolder) {
+      vscode.window.showErrorMessage('No workspace folder open');
+      return;
+    }
+    outputChannel.show();
+    outputChannel.appendLine(\`> \${cmd}\`);
+    try {
+      const { stdout, stderr } = await run(cmd, { cwd: workspaceFolder.uri.fsPath });
+      if (stdout) outputChannel.appendLine(stdout);
+      if (stderr) outputChannel.appendLine(stderr);
+      vscode.window.showInformationMessage(\`OpenCroc: \${cmd} completed\`);
+    } catch (err: unknown) {
+      const message = err instanceof Error ? err.message : String(err);
+      outputChannel.appendLine(\`Error: \${message}\`);
+      vscode.window.showErrorMessage(\`OpenCroc: \${message}\`);
+    }
+  }
+
+  context.subscriptions.push(
+    vscode.commands.registerCommand('opencroc.init', () => runCommand('npx opencroc init --yes')),
+    vscode.commands.registerCommand('opencroc.generate', () => runCommand('npx opencroc generate --all')),
+    vscode.commands.registerCommand('opencroc.test', () => runCommand('npx opencroc test')),
+    vscode.commands.registerCommand('opencroc.validate', () => runCommand('npx opencroc validate')),
+    vscode.commands.registerCommand('opencroc.heal', () => runCommand('npx opencroc heal')),
+    vscode.commands.registerCommand('opencroc.ci', async () => {
+      const platform = await vscode.window.showQuickPick(['github', 'gitlab'], {
+        placeHolder: 'Select CI platform',
+      });
+      if (platform) {
+        await runCommand(\`npx opencroc ci --platform=\${platform}\`);
+      }
+    }),
+    vscode.commands.registerCommand('opencroc.generateModule', async () => {
+      const mod = await vscode.window.showInputBox({ prompt: 'Module name' });
+      if (mod) await runCommand(\`npx opencroc generate --module=\${mod}\`);
+    }),
+    vscode.commands.registerCommand('opencroc.testModule', async () => {
+      const mod = await vscode.window.showInputBox({ prompt: 'Module name' });
+      if (mod) await runCommand(\`npx opencroc test --module=\${mod}\`);
+    }),
+  );
+
+  outputChannel.appendLine('OpenCroc extension activated');
+}
+
+export function deactivate() {}
+`;
+}
 export {
+  SYSTEM_PROMPTS,
+  COMMANDS as VSCODE_COMMANDS,
+  analyzeFailureWithLLM,
+  buildClassToTableMap,
+  buildGraph,
+  buildModuleTree,
+  buildStatusTree,
+  categorizeFailure,
+  classNameToTableName,
+  createAdapter,
   createApiChainAnalyzer,
   createAssociationParser,
   createControllerParser,
   createERDiagramGenerator,
   createImpactReporter,
+  createLlmProvider,
   createMockDataGenerator,
   createModelParser,
+  createOllamaProvider,
+  createOpenAIProvider,
   createPipeline,
+  createPluginRegistry,
+  createPrismaAdapter,
   createSelfHealingLoop,
+  createSequelizeAdapter,
   createTestCodeGenerator,
+  createTokenTracker,
+  createTypeORMAdapter,
   defineConfig,
+  definePlugin,
+  detectAdapter,
+  detectCycles,
+  generateCiTemplate,
+  generateExtensionEntrypoint,
+  generateExtensionManifest,
+  generateGitHubActionsTemplate,
+  generateGitLabCITemplate,
+  generateHtmlReport,
+  generateJsonReport,
+  generateMarkdownReport,
+  generateReports,
+  inferDependencies,
+  inferRelatedTables,
+  listCiPlatforms,
+  parseAssociationFile,
+  parseControllerDirectory,
+  parseControllerFile,
+  parseModelFile,
+  parseModuleModels,
+  resolveAdapter,
+  topologicalSort,
   validateConfig
 };
 //# sourceMappingURL=index.js.map