opencroc 0.1.7 → 0.3.1

package/dist/cli/index.js

@@ -21,51 +21,1234 @@ var init_esm_shims = __esm({
 // src/cli/commands/init.ts
 var init_exports = {};
 __export(init_exports, {
+  buildConfigContent: () => buildConfigContent,
   initProject: () => initProject
 });
 import chalk from "chalk";
 import { writeFileSync, mkdirSync, existsSync } from "fs";
 import { join } from "path";
-async function initProject() {
+import { createInterface } from "readline/promises";
+import { stdin, stdout } from "process";
+function buildConfigContent(answers) {
+  const llmBlock = answers.llmProvider === "none" ? "" : `
+  llm: {
+    provider: '${answers.llmProvider}',${answers.llmProvider === "ollama" ? "" : "\n    // apiKey: process.env.OPENCROC_LLM_API_KEY,"}
+    model: '${answers.llmProvider === "zhipu" ? "glm-4" : answers.llmProvider === "ollama" ? "llama3" : "gpt-4o-mini"}',
+  },`;
+  return `import { defineConfig } from 'opencroc';
+
+export default defineConfig({
+  backendRoot: '${answers.backendRoot}',
+  adapter: '${answers.adapter}',${llmBlock}
+  outDir: '${answers.outDir}',
+  selfHealing: {
+    enabled: true,
+    maxIterations: 3,
+  },
+});
+`;
+}
+async function prompt(rl, question, defaultValue) {
+  const answer = await rl.question(`  ${question} ${chalk.gray(`(${defaultValue})`)}: `);
+  return answer.trim() || defaultValue;
+}
+async function promptChoice(rl, question, choices, defaultValue) {
+  const list = choices.map((c) => c === defaultValue ? chalk.underline(c) : c).join(" / ");
+  const answer = await rl.question(`  ${question} [${list}]: `);
+  const trimmed = answer.trim().toLowerCase();
+  if (!trimmed) return defaultValue;
+  return choices.find((c) => c.toLowerCase() === trimmed) || defaultValue;
+}
+async function collectAnswers() {
+  const rl = createInterface({ input: stdin, output: stdout });
+  try {
+    const backendRoot = await prompt(rl, "Backend source root", DEFAULTS.backendRoot);
+    const adapter = await promptChoice(rl, "ORM adapter", ADAPTERS, DEFAULTS.adapter);
+    const llmProvider = await promptChoice(rl, "LLM provider", LLM_PROVIDERS, DEFAULTS.llmProvider);
+    const outDir = await prompt(rl, "Test output directory", DEFAULTS.outDir);
+    return { backendRoot, adapter, llmProvider, outDir };
+  } finally {
+    rl.close();
+  }
+}
+function writeProject(cwd, answers) {
+  const configPath = join(cwd, "opencroc.config.ts");
+  writeFileSync(configPath, buildConfigContent(answers), "utf-8");
+  console.log(chalk.green("  \u2713 Created opencroc.config.ts"));
+  const outputDir = join(cwd, answers.outDir);
+  if (!existsSync(outputDir)) {
+    mkdirSync(outputDir, { recursive: true });
+    console.log(chalk.green(`  \u2713 Created ${answers.outDir}/`));
+  }
+}
+function printNextSteps(answers) {
+  const needsKey = answers.llmProvider !== "none" && answers.llmProvider !== "ollama";
+  console.log("");
+  console.log(chalk.cyan("  Next steps:"));
+  let step = 1;
+  console.log(`    ${step++}. Review opencroc.config.ts`);
+  if (needsKey) {
+    console.log(`    ${step++}. Set OPENCROC_LLM_API_KEY environment variable`);
+  }
+  console.log(`    ${step++}. npx opencroc generate --all`);
+  console.log(`    ${step}. npx opencroc test`);
+}
+async function initProject(opts) {
   const cwd = process.cwd();
   const configPath = join(cwd, "opencroc.config.ts");
   if (existsSync(configPath)) {
-    console.log(chalk.yellow("opencroc.config.ts already exists. Skipping."));
+    console.log(chalk.yellow("\n  \u26A0 opencroc.config.ts already exists. Skipping.\n"));
     return;
   }
-  writeFileSync(configPath, CONFIG_TEMPLATE, "utf-8");
-  console.log(chalk.green("\u2713 Created opencroc.config.ts"));
-  const outDir = join(cwd, "opencroc-output");
-  if (!existsSync(outDir)) {
-    mkdirSync(outDir, { recursive: true });
-    console.log(chalk.green("\u2713 Created opencroc-output/"));
-  }
+  console.log(chalk.cyan.bold("\n  \u{1F40A} OpenCroc \u2014 Project Setup\n"));
+  const answers = opts?.yes ? { ...DEFAULTS } : await collectAnswers();
+  console.log("");
+  writeProject(cwd, answers);
+  printNextSteps(answers);
   console.log("");
-  console.log(chalk.cyan("Next steps:"));
-  console.log("  1. Edit opencroc.config.ts with your project settings");
-  console.log("  2. Run: npx opencroc generate --all");
-  console.log("  3. Run: npx opencroc test");
 }
-var CONFIG_TEMPLATE;
+var ADAPTERS, LLM_PROVIDERS, DEFAULTS;
 var init_init = __esm({
   "src/cli/commands/init.ts"() {
     "use strict";
     init_esm_shims();
-    CONFIG_TEMPLATE = `import { defineConfig } from 'opencroc';
+    ADAPTERS = ["sequelize", "typeorm", "prisma"];
+    LLM_PROVIDERS = ["openai", "zhipu", "ollama", "none"];
+    DEFAULTS = {
+      backendRoot: "./backend",
+      adapter: "sequelize",
+      llmProvider: "openai",
+      outDir: "./opencroc-output"
+    };
+  }
+});
 
-export default defineConfig({
-  backendRoot: './backend',
-  adapter: 'sequelize',
-  llm: {
-    provider: 'openai',
-    model: 'gpt-4o-mini',
-  },
-  selfHealing: {
-    enabled: true,
-    maxIterations: 3,
-  },
+// src/cli/load-config.ts
+import { cosmiconfig } from "cosmiconfig";
+async function loadConfig(cwd) {
+  const explorer = cosmiconfig(MODULE_NAME, {
+    searchPlaces: SEARCH_PLACES,
+    ...cwd ? { stopDir: cwd } : {}
+  });
+  const result = cwd ? await explorer.search(cwd) : await explorer.search();
+  if (!result || result.isEmpty) {
+    throw new Error(
+      "No opencroc config found. Run `opencroc init` to create one."
+    );
+  }
+  const config = result.config?.default ?? result.config;
+  if (!config.backendRoot) {
+    throw new Error(
+      `Invalid config in ${result.filepath}: "backendRoot" is required.`
+    );
+  }
+  return { config, filepath: result.filepath };
+}
+var MODULE_NAME, SEARCH_PLACES;
+var init_load_config = __esm({
+  "src/cli/load-config.ts"() {
+    "use strict";
+    init_esm_shims();
+    MODULE_NAME = "opencroc";
+    SEARCH_PLACES = [
+      "opencroc.config.ts",
+      "opencroc.config.js",
+      "opencroc.config.json",
+      ".opencrocrc.json",
+      "package.json"
+    ];
+  }
 });
-`;
+
+// src/parsers/model-parser.ts
+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));
+}
+var init_model_parser = __esm({
+  "src/parsers/model-parser.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/parsers/controller-parser.ts
+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 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 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());
+}
+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/parsers/association-parser.ts
+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 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());
+}
+var init_association_parser = __esm({
+  "src/parsers/association-parser.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_model_parser();
+  }
+});
+
+// src/analyzers/api-chain-analyzer.ts
+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 path8 = [];
+  function dfs(node) {
+    color.set(node, 1 /* GRAY */);
+    path8.push(node);
+    for (const neighbor of adjacency.get(node) || []) {
+      const nc = color.get(neighbor);
+      if (nc === 1 /* GRAY */) {
+        const cycleStart = path8.indexOf(neighbor);
+        warnings.push(`Cycle detected: ${path8.slice(cycleStart).concat(neighbor).join(" \u2192 ")}`);
+      } else if (nc === 0 /* WHITE */) {
+        dfs(neighbor);
+      }
+    }
+    path8.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 {
+    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
+      };
+    }
+  };
+}
+var EXCLUDED_PARAMS;
+var init_api_chain_analyzer = __esm({
+  "src/analyzers/api-chain-analyzer.ts"() {
+    "use strict";
+    init_esm_shims();
+    EXCLUDED_PARAMS = /* @__PURE__ */ new Set(["tenantId"]);
+  }
+});
+
+// src/generators/er-diagram-generator.ts
+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 {
+    generate(tables, relations) {
+      const mermaidText = generateMermaidER(tables, relations);
+      return { tables, relations, mermaidText };
+    }
+  };
+}
+var init_er_diagram_generator = __esm({
+  "src/generators/er-diagram-generator.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/generators/test-code-generator.ts
+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) {
+      return chains.map((chain) => ({
+        filePath: `${chain.module}/${chain.name.replace(/\s+/g, "-").toLowerCase()}.spec.ts`,
+        content: generateTestFile(chain),
+        module: chain.module,
+        chain: chain.name
+      }));
+    }
+  };
+}
+var init_test_code_generator = __esm({
+  "src/generators/test-code-generator.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/validators/config-validator.ts
+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 report2 = config.report;
+    if (report2.format && Array.isArray(report2.format)) {
+      for (const fmt of report2.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;
+}
+var REQUIRED_FIELDS, VALID_ADAPTERS, VALID_STEPS, VALID_LLM_PROVIDERS, VALID_REPORT_FORMATS, VALID_HEAL_MODES;
+var init_config_validator = __esm({
+  "src/validators/config-validator.ts"() {
+    "use strict";
+    init_esm_shims();
+    REQUIRED_FIELDS = ["backendRoot"];
+    VALID_ADAPTERS = ["sequelize", "typeorm", "prisma"];
+    VALID_STEPS = ["scan", "er-diagram", "api-chain", "plan", "codegen", "validate"];
+    VALID_LLM_PROVIDERS = ["openai", "zhipu", "ollama", "custom"];
+    VALID_REPORT_FORMATS = ["html", "json", "markdown"];
+    VALID_HEAL_MODES = ["config-only", "config-and-source"];
+  }
+});
+
+// src/pipeline/index.ts
+import * as fs4 from "fs";
+import * as path5 from "path";
+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 };
+}
+var ALL_STEPS;
+var init_pipeline = __esm({
+  "src/pipeline/index.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_model_parser();
+    init_controller_parser();
+    init_association_parser();
+    init_api_chain_analyzer();
+    init_er_diagram_generator();
+    init_test_code_generator();
+    init_config_validator();
+    ALL_STEPS = ["scan", "er-diagram", "api-chain", "plan", "codegen", "validate"];
   }
 });
 
@@ -75,15 +1258,82 @@ __export(generate_exports, {
   generate: () => generate
 });
 import chalk2 from "chalk";
+import { writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, existsSync as existsSync6 } from "fs";
+import { dirname } from "path";
+function parseSteps(raw) {
+  if (!raw) return void 0;
+  const names = raw.split(",").map((s) => s.trim());
+  for (const name of names) {
+    if (!VALID_STEPS2.includes(name)) {
+      throw new Error(`Unknown pipeline step "${name}". Valid steps: ${VALID_STEPS2.join(", ")}`);
+    }
+  }
+  return names;
+}
+function writeGeneratedFiles(result) {
+  let written = 0;
+  for (const file of result.generatedFiles) {
+    const dir = dirname(file.filePath);
+    if (!existsSync6(dir)) {
+      mkdirSync2(dir, { recursive: true });
+    }
+    writeFileSync2(file.filePath, file.content, "utf-8");
+    written++;
+    console.log(chalk2.green(`  \u2713 ${file.filePath}`));
+  }
+  return written;
+}
+function printSummary(result, dryRun) {
+  console.log("");
+  console.log(chalk2.cyan.bold("  Summary"));
+  console.log(`    Modules discovered : ${result.modules.length}`);
+  console.log(`    ER diagrams        : ${result.erDiagrams.size}`);
+  console.log(`    Chain plans        : ${result.chainPlans.size}`);
+  console.log(`    Generated files    : ${result.generatedFiles.length}${dryRun ? " (dry-run, not written)" : ""}`);
+  if (result.validationErrors.length > 0) {
+    const errors = result.validationErrors.filter((e) => e.severity === "error");
+    const warnings = result.validationErrors.filter((e) => e.severity === "warning");
+    if (errors.length > 0) console.log(chalk2.red(`    Errors             : ${errors.length}`));
+    if (warnings.length > 0) console.log(chalk2.yellow(`    Warnings           : ${warnings.length}`));
+    for (const err of result.validationErrors) {
+      const icon = err.severity === "error" ? chalk2.red("\u2717") : chalk2.yellow("\u26A0");
+      console.log(`    ${icon} [${err.module}] ${err.message}`);
+    }
+  }
+  console.log(chalk2.gray(`    Duration           : ${result.duration}ms`));
+  console.log("");
+}
 async function generate(opts) {
-  console.log(chalk2.cyan("\u{1F40A} OpenCroc \u2014 Generating E2E tests...\n"));
-  console.log(chalk2.yellow("Generation pipeline is under development."));
-  console.log("Options:", opts);
+  console.log(chalk2.cyan.bold("\n  \u{1F40A} OpenCroc \u2014 Generate E2E Tests\n"));
+  const { config, filepath } = await loadConfig();
+  console.log(chalk2.gray(`  Config: ${filepath}`));
+  if (opts.module) {
+    config.modules = [opts.module];
+  }
+  const steps = parseSteps(opts.steps);
+  const pipeline = createPipeline(config);
+  const result = await pipeline.run(steps);
+  if (!opts.dryRun && result.generatedFiles.length > 0) {
+    console.log("");
+    console.log(chalk2.cyan("  Generated files:"));
+    writeGeneratedFiles(result);
+  } else if (opts.dryRun && result.generatedFiles.length > 0) {
+    console.log("");
+    console.log(chalk2.yellow("  Dry-run \u2014 files that would be generated:"));
+    for (const file of result.generatedFiles) {
+      console.log(chalk2.gray(`    ${file.filePath}`));
+    }
+  }
+  printSummary(result, !!opts.dryRun);
 }
+var VALID_STEPS2;
 var init_generate = __esm({
   "src/cli/commands/generate.ts"() {
     "use strict";
     init_esm_shims();
+    init_load_config();
+    init_pipeline();
+    VALID_STEPS2 = ["scan", "er-diagram", "api-chain", "plan", "codegen", "validate"];
   }
 });
 
@@ -93,15 +1343,62 @@ __export(test_exports, {
   runTests: () => runTests
 });
 import chalk3 from "chalk";
+import { readdirSync as readdirSync5, existsSync as existsSync7 } from "fs";
+import { join as join6, resolve as resolve5 } from "path";
+import { execFileSync } from "child_process";
+function discoverTestFiles(outDir, moduleFilter) {
+  const absDir = resolve5(outDir);
+  if (!existsSync7(absDir)) return [];
+  const files = [];
+  const entries = readdirSync5(absDir, { withFileTypes: true, recursive: true });
+  for (const entry of entries) {
+    if (!entry.isFile()) continue;
+    if (!entry.name.endsWith(".spec.ts") && !entry.name.endsWith(".test.ts")) continue;
+    const fullPath = join6(entry.parentPath || entry.path || absDir, entry.name);
+    if (moduleFilter && !fullPath.includes(moduleFilter)) continue;
+    files.push(fullPath);
+  }
+  return files;
+}
 async function runTests(opts) {
-  console.log(chalk3.cyan("\u{1F40A} OpenCroc \u2014 Running E2E tests...\n"));
-  console.log(chalk3.yellow("Test runner is under development."));
-  console.log("Options:", opts);
+  console.log(chalk3.cyan.bold("\n  \u{1F40A} OpenCroc \u2014 Run E2E Tests\n"));
+  const { config, filepath } = await loadConfig();
+  console.log(chalk3.gray(`  Config: ${filepath}`));
+  const outDir = config.outDir || "./opencroc-output";
+  const testFiles = discoverTestFiles(outDir, opts.module);
+  if (testFiles.length === 0) {
+    console.log(chalk3.yellow("  No test files found. Run `opencroc generate` first.\n"));
+    return;
+  }
+  console.log(`  Found ${testFiles.length} test file(s)`);
+  for (const f of testFiles) {
+    console.log(chalk3.gray(`    ${f}`));
+  }
+  console.log("");
+  const args = ["test", ...testFiles];
+  if (!opts.headed) {
+    args.push("--reporter=list");
+  } else {
+    args.push("--headed");
+  }
+  const npxCmd = process.platform === "win32" ? "npx.cmd" : "npx";
+  try {
+    console.log(chalk3.cyan("  Running Playwright...\n"));
+    execFileSync(npxCmd, ["playwright", ...args], {
+      stdio: "inherit",
+      cwd: process.cwd()
+    });
+    console.log(chalk3.green("\n  \u2713 All tests passed.\n"));
+  } catch {
+    console.log(chalk3.red("\n  \u2717 Some tests failed.\n"));
+    process.exitCode = 1;
+  }
 }
 var init_test = __esm({
   "src/cli/commands/test.ts"() {
     "use strict";
     init_esm_shims();
+    init_load_config();
   }
 });
 
@@ -111,15 +1408,128 @@ __export(validate_exports, {
   validate: () => validate
 });
 import chalk4 from "chalk";
+function printErrors(errors) {
+  for (const err of errors) {
+    const icon = err.severity === "error" ? chalk4.red("\u2717") : chalk4.yellow("\u26A0");
+    const scope = err.module === "config" ? "" : ` [${err.module}]`;
+    console.log(`  ${icon}${scope} ${err.field}: ${err.message}`);
+  }
+}
 async function validate(opts) {
-  console.log(chalk4.cyan("\u{1F40A} OpenCroc \u2014 Validating configurations...\n"));
-  console.log(chalk4.yellow("Validation pipeline is under development."));
-  console.log("Options:", opts);
+  console.log(chalk4.cyan.bold("\n  \u{1F40A} OpenCroc \u2014 Validate\n"));
+  const { config, filepath } = await loadConfig();
+  console.log(chalk4.gray(`  Config: ${filepath}`));
+  const configErrors = validateConfig(config);
+  if (opts.module) {
+    config.modules = [opts.module];
+  }
+  const pipeline = createPipeline(config);
+  const result = await pipeline.run(["scan", "validate"]);
+  const allErrors = [...configErrors, ...result.validationErrors];
+  const errors = allErrors.filter((e) => e.severity === "error");
+  const warnings = allErrors.filter((e) => e.severity === "warning");
+  if (allErrors.length === 0) {
+    console.log(chalk4.green("  \u2713 Configuration is valid."));
+    console.log(chalk4.gray(`    Modules: ${result.modules.join(", ") || "(none)"}
+`));
+    return;
+  }
+  if (errors.length > 0) {
+    console.log(chalk4.red(`  ${errors.length} error(s):`));
+    printErrors(errors);
+  }
+  if (warnings.length > 0) {
+    console.log(chalk4.yellow(`  ${warnings.length} warning(s):`));
+    printErrors(warnings);
+  }
+  console.log("");
+  if (errors.length > 0) {
+    process.exitCode = 1;
+  }
 }
 var init_validate = __esm({
   "src/cli/commands/validate.ts"() {
     "use strict";
     init_esm_shims();
+    init_load_config();
+    init_config_validator();
+    init_pipeline();
+  }
+});
+
+// src/llm/openai.ts
+var init_openai = __esm({
+  "src/llm/openai.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/llm/ollama.ts
+var init_ollama = __esm({
+  "src/llm/ollama.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/llm/index.ts
+var init_llm = __esm({
+  "src/llm/index.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_openai();
+    init_ollama();
+    init_openai();
+    init_ollama();
+  }
+});
+
+// src/self-healing/index.ts
+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
+      };
+    }
+  };
+}
+var init_self_healing = __esm({
+  "src/self-healing/index.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_llm();
   }
 });
 
@@ -130,14 +1540,490 @@ __export(heal_exports, {
 });
 import chalk5 from "chalk";
 async function heal(opts) {
-  console.log(chalk5.cyan("\u{1F40A} OpenCroc \u2014 Running self-healing loop...\n"));
-  console.log(chalk5.yellow("Self-healing loop is under development."));
-  console.log("Options:", opts);
+  console.log(chalk5.cyan.bold("\n  \u{1F40A} OpenCroc \u2014 Self-Healing\n"));
+  const { config, filepath } = await loadConfig();
+  console.log(chalk5.gray(`  Config: ${filepath}`));
+  const outDir = config.outDir || "./opencroc-output";
+  const maxIterations = opts.maxIterations ? parseInt(opts.maxIterations, 10) : 3;
+  const healingConfig = {
+    enabled: true,
+    maxIterations,
+    mode: config.selfHealing?.mode || "config-only"
+  };
+  console.log(chalk5.gray(`  Mode: ${healingConfig.mode}`));
+  console.log(chalk5.gray(`  Max iterations: ${maxIterations}`));
+  if (opts.module) {
+    console.log(chalk5.gray(`  Module: ${opts.module}`));
+  }
+  console.log("");
+  const loop = createSelfHealingLoop(healingConfig);
+  const result = await loop.run(outDir);
+  console.log(chalk5.cyan("  Results:"));
+  console.log(`    Iterations   : ${result.iterations}`);
+  console.log(`    Fixed        : ${result.fixed.length > 0 ? chalk5.green(result.fixed.join(", ")) : chalk5.gray("(none)")}`);
+  console.log(`    Remaining    : ${result.remaining.length > 0 ? chalk5.yellow(result.remaining.join(", ")) : chalk5.gray("(none)")}`);
+  if (result.totalTokensUsed > 0) {
+    console.log(`    Tokens used  : ${result.totalTokensUsed}`);
+  }
+  console.log("");
+  if (result.remaining.length > 0) {
+    console.log(chalk5.yellow("  Some issues could not be auto-fixed. Manual review needed.\n"));
+  } else if (result.fixed.length > 0) {
+    console.log(chalk5.green("  \u2713 All issues resolved.\n"));
+  } else {
+    console.log(chalk5.gray("  No issues detected.\n"));
+  }
 }
 var init_heal = __esm({
   "src/cli/commands/heal.ts"() {
     "use strict";
     init_esm_shims();
+    init_load_config();
+    init_self_healing();
+  }
+});
+
+// src/ci/index.ts
+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
+`;
+}
+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);
+}
+var TEMPLATES;
+var init_ci = __esm({
+  "src/ci/index.ts"() {
+    "use strict";
+    init_esm_shims();
+    TEMPLATES = {
+      github: generateGitHubActionsTemplate,
+      gitlab: generateGitLabCITemplate
+    };
+  }
+});
+
+// src/cli/commands/ci.ts
+var ci_exports = {};
+__export(ci_exports, {
+  ci: () => ci
+});
+import * as fs5 from "fs";
+import * as path6 from "path";
+import chalk6 from "chalk";
+async function ci(opts) {
+  const platform = opts.platform ?? "github";
+  const available = listCiPlatforms();
+  if (!available.includes(platform)) {
+    console.error(chalk6.red(`Unknown platform: "${platform}". Available: ${available.join(", ")}`));
+    process.exitCode = 1;
+    return;
+  }
+  const templateOpts = {
+    selfHeal: opts.selfHeal ?? false
+  };
+  if (opts.node) {
+    templateOpts.nodeVersions = opts.node.split(",").map((s) => s.trim());
+  }
+  const content = generateCiTemplate(platform, templateOpts);
+  let outputPath;
+  if (platform === "github") {
+    outputPath = path6.join(".github", "workflows", "opencroc.yml");
+  } else if (platform === "gitlab") {
+    outputPath = ".gitlab-ci.yml";
+  } else {
+    outputPath = `opencroc-ci-${platform}.yml`;
+  }
+  const dir = path6.dirname(outputPath);
+  if (dir !== "." && !fs5.existsSync(dir)) {
+    fs5.mkdirSync(dir, { recursive: true });
+  }
+  fs5.writeFileSync(outputPath, content, "utf-8");
+  console.log(chalk6.green(`\u2714 CI template written to ${outputPath}`));
+  console.log(chalk6.dim(`  Platform: ${platform}`));
+}
+var init_ci2 = __esm({
+  "src/cli/commands/ci.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_ci();
+  }
+});
+
+// src/reporters/index.ts
+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"
+  };
+}
+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);
+  });
+}
+var REPORTERS;
+var init_reporters = __esm({
+  "src/reporters/index.ts"() {
+    "use strict";
+    init_esm_shims();
+    REPORTERS = {
+      html: generateHtmlReport,
+      json: generateJsonReport,
+      markdown: generateMarkdownReport
+    };
+  }
+});
+
+// src/cli/commands/report.ts
+var report_exports = {};
+__export(report_exports, {
+  report: () => report
+});
+import * as fs6 from "fs";
+import * as path7 from "path";
+import chalk7 from "chalk";
+async function report(opts) {
+  let loaded;
+  try {
+    loaded = await loadConfig();
+  } catch {
+    console.error(chalk7.red("No opencroc config found. Run `opencroc init` first."));
+    process.exitCode = 1;
+    return;
+  }
+  const { config } = loaded;
+  console.log(chalk7.cyan("Running pipeline to generate report..."));
+  const pipeline = createPipeline(config);
+  const result = await pipeline.run();
+  const formats = (opts.format ?? "html").split(",").map((s) => s.trim());
+  const reports = generateReports(result, formats);
+  const outDir = opts.output ?? config.outDir ?? "./opencroc-output";
+  if (!fs6.existsSync(outDir)) {
+    fs6.mkdirSync(outDir, { recursive: true });
+  }
+  for (const r of reports) {
+    const filePath = path7.join(outDir, r.filename);
+    fs6.writeFileSync(filePath, r.content, "utf-8");
+    console.log(chalk7.green(`\u2714 ${r.format} report \u2192 ${filePath}`));
+  }
+  console.log(chalk7.dim(`  ${result.modules.length} modules, ${result.generatedFiles.length} files, ${result.duration}ms`));
+}
+var init_report = __esm({
+  "src/cli/commands/report.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_load_config();
+    init_pipeline();
+    init_reporters();
   }
 });
 
@@ -145,10 +2031,10 @@ var init_heal = __esm({
 init_esm_shims();
 import { Command } from "commander";
 var program = new Command();
-program.name("opencroc").description("AI-native E2E testing framework").version("0.1.0");
-program.command("init").description("Initialize OpenCroc in the current project").action(async () => {
+program.name("opencroc").description("AI-native E2E testing framework").version("0.3.1");
+program.command("init").description("Initialize OpenCroc in the current project").option("-y, --yes", "Skip prompts and use defaults").action(async (opts) => {
   const { initProject: initProject2 } = await Promise.resolve().then(() => (init_init(), init_exports));
-  await initProject2();
+  await initProject2(opts);
 });
 program.command("generate").description("Generate E2E test cases from source code").option("-m, --module <name>", "Generate for a specific module").option("-a, --all", "Generate for all discovered modules").option("--steps <steps>", "Run specific pipeline steps (comma-separated)").option("--dry-run", "Preview without writing files").action(async (opts) => {
   const { generate: generate2 } = await Promise.resolve().then(() => (init_generate(), generate_exports));
@@ -166,5 +2052,13 @@ program.command("heal").description("Run self-healing loop on failed tests").opt
   const { heal: heal2 } = await Promise.resolve().then(() => (init_heal(), heal_exports));
   await heal2(opts);
 });
+program.command("ci").description("Generate CI/CD pipeline template").option("-p, --platform <name>", "CI platform (github, gitlab)", "github").option("--self-heal", "Include self-healing step").option("--node <versions>", "Node.js versions (comma-separated)", "20.x").action(async (opts) => {
+  const { ci: ci2 } = await Promise.resolve().then(() => (init_ci2(), ci_exports));
+  await ci2(opts);
+});
+program.command("report").description("Generate pipeline report (HTML/JSON/Markdown)").option("-f, --format <formats>", "Report formats (comma-separated)", "html").option("-o, --output <dir>", "Output directory").action(async (opts) => {
+  const { report: report2 } = await Promise.resolve().then(() => (init_report(), report_exports));
+  await report2(opts);
+});
 program.parse();
 //# sourceMappingURL=index.js.map