opencroc 0.6.1 → 1.3.0

package/dist/cli/index.js

@@ -1086,6 +1086,31 @@ var init_test_code_generator = __esm({
   }
 });
 
+// src/validators/schema-validator.ts
+var init_schema_validator = __esm({
+  "src/validators/schema-validator.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/validators/semantic-validator.ts
+var init_semantic_validator = __esm({
+  "src/validators/semantic-validator.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/validators/dryrun-validator.ts
+import { Project as Project4, DiagnosticCategory } from "ts-morph";
+var init_dryrun_validator = __esm({
+  "src/validators/dryrun-validator.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
 // src/validators/config-validator.ts
 function validateConfig(config) {
   const errors = [];
@@ -1182,6 +1207,49 @@ function validateConfig(config) {
       });
     }
   }
+  if (config.execution && typeof config.execution === "object") {
+    const execution = config.execution;
+    const hookFields = ["setupHook", "authHook", "teardownHook"];
+    for (const hookField of hookFields) {
+      const hook = execution[hookField];
+      if (hook === void 0) continue;
+      if (typeof hook === "string") continue;
+      if (typeof hook !== "object" || hook === null) {
+        errors.push({
+          module: "config",
+          field: `execution.${hookField}`,
+          message: `${hookField} must be a string command or an object { command, args?, cwd? }`,
+          severity: "error"
+        });
+        continue;
+      }
+      const hookObj = hook;
+      if (typeof hookObj.command !== "string" || hookObj.command.trim() === "") {
+        errors.push({
+          module: "config",
+          field: `execution.${hookField}.command`,
+          message: "command is required and must be a non-empty string",
+          severity: "error"
+        });
+      }
+      if (hookObj.args !== void 0 && (!Array.isArray(hookObj.args) || hookObj.args.some((a) => typeof a !== "string"))) {
+        errors.push({
+          module: "config",
+          field: `execution.${hookField}.args`,
+          message: "args must be an array of strings",
+          severity: "error"
+        });
+      }
+      if (hookObj.cwd !== void 0 && typeof hookObj.cwd !== "string") {
+        errors.push({
+          module: "config",
+          field: `execution.${hookField}.cwd`,
+          message: "cwd must be a string path",
+          severity: "error"
+        });
+      }
+    }
+  }
   return errors;
 }
 var REQUIRED_FIELDS, VALID_ADAPTERS, VALID_STEPS, VALID_LLM_PROVIDERS, VALID_REPORT_FORMATS, VALID_HEAL_MODES;
@@ -1189,8 +1257,11 @@ var init_config_validator = __esm({
   "src/validators/config-validator.ts"() {
     "use strict";
     init_esm_shims();
+    init_schema_validator();
+    init_semantic_validator();
+    init_dryrun_validator();
     REQUIRED_FIELDS = ["backendRoot"];
-    VALID_ADAPTERS = ["sequelize", "typeorm", "prisma"];
+    VALID_ADAPTERS = ["sequelize", "typeorm", "prisma", "drizzle"];
     VALID_STEPS = ["scan", "er-diagram", "api-chain", "plan", "codegen", "validate"];
     VALID_LLM_PROVIDERS = ["openai", "zhipu", "ollama", "custom"];
     VALID_REPORT_FORMATS = ["html", "json", "markdown"];
@@ -1446,6 +1517,39 @@ 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 normalizeHook(hook) {
+  if (!hook) return void 0;
+  if (typeof hook === "string") return hook.trim() ? hook : void 0;
+  return hook.command.trim() ? hook : void 0;
+}
+function runShellCommand(command) {
+  if (process.platform === "win32") {
+    execFileSync("cmd.exe", ["/d", "/s", "/c", command], {
+      stdio: "inherit",
+      cwd: process.cwd()
+    });
+    return;
+  }
+  execFileSync("sh", ["-lc", command], {
+    stdio: "inherit",
+    cwd: process.cwd()
+  });
+}
+function runHook(name, hook) {
+  const normalized = normalizeHook(hook);
+  if (!normalized) return;
+  console.log(chalk3.cyan(`  Running ${name} hook...`));
+  if (typeof normalized === "string") {
+    runShellCommand(normalized);
+    console.log(chalk3.green(`  \u2713 ${name} hook passed`));
+    return;
+  }
+  execFileSync(normalized.command, normalized.args ?? [], {
+    stdio: "inherit",
+    cwd: normalized.cwd ? resolve5(normalized.cwd) : process.cwd()
+  });
+  console.log(chalk3.green(`  \u2713 ${name} hook passed`));
+}
 function discoverTestFiles(outDir, moduleFilter) {
   const absDir = resolve5(outDir);
   if (!existsSync7(absDir)) return [];
@@ -1464,6 +1568,25 @@ async function runTests(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 execution = {
+    ...config.execution || {},
+    ...opts.setupHook ? { setupHook: opts.setupHook } : {},
+    ...opts.authHook ? { authHook: opts.authHook } : {},
+    ...opts.teardownHook ? { teardownHook: opts.teardownHook } : {}
+  };
+  try {
+    runHook("setup", execution.setupHook);
+    runHook("auth", execution.authHook);
+  } catch {
+    console.log(chalk3.red("  \u2717 setup/auth hook failed. Abort test run.\n"));
+    process.exitCode = 1;
+    try {
+      runHook("teardown", execution.teardownHook);
+    } catch {
+      console.log(chalk3.red("  \u2717 teardown hook also failed.\n"));
+    }
+    return;
+  }
   const outDir = config.outDir || "./opencroc-output";
   const testFiles = discoverTestFiles(outDir, opts.module);
   if (testFiles.length === 0) {
@@ -1492,6 +1615,13 @@ async function runTests(opts) {
   } catch {
     console.log(chalk3.red("\n  \u2717 Some tests failed.\n"));
     process.exitCode = 1;
+  } finally {
+    try {
+      runHook("teardown", execution.teardownHook);
+    } catch {
+      console.log(chalk3.red("  \u2717 teardown hook failed.\n"));
+      process.exitCode = 1;
+    }
   }
 }
 var init_test = __esm({
@@ -1585,6 +1715,32 @@ var init_llm = __esm({
   }
 });
 
+// src/self-healing/dialog-loop-runner.ts
+var init_dialog_loop_runner = __esm({
+  "src/self-healing/dialog-loop-runner.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/self-healing/controlled-fixer.ts
+import { existsSync as existsSync8, copyFileSync, readFileSync as readFileSync2, writeFileSync as writeFileSync3, mkdirSync as mkdirSync3, unlinkSync } from "fs";
+import { dirname as dirname2 } from "path";
+var init_controlled_fixer = __esm({
+  "src/self-healing/controlled-fixer.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/self-healing/auto-fix-generator.ts
+var init_auto_fix_generator = __esm({
+  "src/self-healing/auto-fix-generator.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
 // src/self-healing/index.ts
 async function attemptConfigFix(_testResultsDir, _mode, _llm) {
   return {
@@ -1630,6 +1786,9 @@ var init_self_healing = __esm({
     "use strict";
     init_esm_shims();
     init_llm();
+    init_dialog_loop_runner();
+    init_controlled_fixer();
+    init_auto_fix_generator();
   }
 });
 
@@ -1859,6 +2018,30 @@ var init_ci2 = __esm({
   }
 });
 
+// src/reporters/checklist-reporter.ts
+var init_checklist_reporter = __esm({
+  "src/reporters/checklist-reporter.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/reporters/workorder-reporter.ts
+var init_workorder_reporter = __esm({
+  "src/reporters/workorder-reporter.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/reporters/token-reporter.ts
+var init_token_reporter = __esm({
+  "src/reporters/token-reporter.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
 // src/reporters/index.ts
 function generateJsonReport(result) {
   const serializable = {
@@ -2075,6 +2258,9 @@ var init_reporters = __esm({
   "src/reporters/index.ts"() {
     "use strict";
     init_esm_shims();
+    init_checklist_reporter();
+    init_workorder_reporter();
+    init_token_reporter();
     REPORTERS = {
       html: generateHtmlReport,
       json: generateJsonReport,
@@ -2485,11 +2671,1215 @@ var init_dashboard2 = __esm({
   }
 });
 
+// src/runtime/playwright-config-generator.ts
+function generatePlaywrightConfig(config) {
+  const pw = config.playwright ?? {};
+  const rt = config.runtime ?? {};
+  const outDir = config.outDir || "./opencroc-output";
+  const baseURL = pw.baseURL ? `'${pw.baseURL}'` : "process.env.BASE_URL || 'http://localhost:3000'";
+  const timeout = pw.timeout ?? 3e4;
+  const workers = pw.workers ?? null;
+  const retries = pw.retries ?? null;
+  const actionTimeout = pw.actionTimeout ?? 1e4;
+  const navigationTimeout = pw.navigationTimeout ?? timeout;
+  const storageState = rt.auth?.storageStatePath || "playwright/.auth/user.json";
+  const hasAuth = !!rt.auth?.loginUrl;
+  const lines = [];
+  lines.push(`import { defineConfig, devices } from '@playwright/test';`);
+  lines.push("");
+  lines.push("export default defineConfig({");
+  lines.push(`  testDir: '${outDir}',`);
+  lines.push(`  testMatch: ['**/*.spec.ts', '**/*.test.ts'],`);
+  lines.push(`  fullyParallel: false,`);
+  lines.push(`  forbidOnly: !!process.env.CI,`);
+  lines.push(`  retries: ${retries !== null ? retries : "process.env.CI ? 1 : 0"},`);
+  lines.push(`  workers: ${workers !== null ? workers : "process.env.CI ? 4 : 2"},`);
+  lines.push(`  timeout: ${timeout},`);
+  lines.push(`  globalSetup: './global-setup.ts',`);
+  lines.push(`  globalTeardown: './global-teardown.ts',`);
+  lines.push(`  reporter: [['list'], ['html', { open: 'never' }]],`);
+  lines.push(`  use: {`);
+  lines.push(`    baseURL: ${baseURL},`);
+  lines.push(`    trace: 'retain-on-failure',`);
+  lines.push(`    screenshot: 'only-on-failure',`);
+  lines.push(`    video: 'retain-on-failure',`);
+  lines.push(`    actionTimeout: ${actionTimeout},`);
+  lines.push(`    navigationTimeout: ${navigationTimeout},`);
+  lines.push(`  },`);
+  lines.push(`  projects: [`);
+  if (hasAuth) {
+    lines.push(`    {`);
+    lines.push(`      name: 'setup',`);
+    lines.push(`      testMatch: '**/auth.setup.ts',`);
+    lines.push(`      use: { ...devices['Desktop Chrome'] },`);
+    lines.push(`    },`);
+    lines.push(`    {`);
+    lines.push(`      name: 'chromium',`);
+    lines.push(`      testIgnore: ['**/*.setup.ts'],`);
+    lines.push(`      dependencies: ['setup'],`);
+    lines.push(`      use: {`);
+    lines.push(`        ...devices['Desktop Chrome'],`);
+    lines.push(`        storageState: '${storageState}',`);
+    lines.push(`      },`);
+    lines.push(`    },`);
+    lines.push(`    {`);
+    lines.push(`      name: 'chromium-no-auth',`);
+    lines.push(`      testMatch: '**/login-flow.test.ts',`);
+    lines.push(`      testIgnore: ['**/*.setup.ts'],`);
+    lines.push(`      use: { ...devices['Desktop Chrome'] },`);
+    lines.push(`    },`);
+  } else {
+    lines.push(`    {`);
+    lines.push(`      name: 'chromium',`);
+    lines.push(`      use: { ...devices['Desktop Chrome'] },`);
+    lines.push(`    },`);
+  }
+  if (rt.extraProjects) {
+    for (const proj of rt.extraProjects) {
+      lines.push(`    {`);
+      lines.push(`      name: '${proj.name}',`);
+      lines.push(`      testMatch: '${proj.testMatch}',`);
+      if (proj.dependencies?.length) {
+        lines.push(`      dependencies: [${proj.dependencies.map((d) => `'${d}'`).join(", ")}],`);
+      }
+      if (proj.useAuth !== false && hasAuth) {
+        lines.push(`      use: {`);
+        lines.push(`        ...devices['Desktop Chrome'],`);
+        lines.push(`        storageState: '${storageState}',`);
+        lines.push(`      },`);
+      } else {
+        lines.push(`      use: { ...devices['Desktop Chrome'] },`);
+      }
+      lines.push(`    },`);
+    }
+  }
+  lines.push(`  ],`);
+  lines.push("});");
+  lines.push("");
+  return lines.join("\n");
+}
+var init_playwright_config_generator = __esm({
+  "src/runtime/playwright-config-generator.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/runtime/global-setup-generator.ts
+function generateGlobalSetup(config) {
+  const pw = config.playwright ?? {};
+  const rt = config.runtime ?? {};
+  const baseURL = pw.baseURL || "";
+  const hasSeedEndpoint = !!rt.db?.seedEndpoint;
+  const hasLogEndpoint = !!rt.logEndpoint;
+  const hasSeedFile = !!rt.db?.seedFile;
+  const lines = [];
+  lines.push(`/**`);
+  lines.push(` * Global setup \u2014 generated by OpenCroc.`);
+  lines.push(` * Runs once before all test projects.`);
+  lines.push(` */`);
+  lines.push("");
+  lines.push(`const BASE_URL = process.env.BASE_URL || '${baseURL || "http://localhost:3000"}';`);
+  lines.push("");
+  lines.push(`async function fetchWithRetry(`);
+  lines.push(`  url: string,`);
+  lines.push(`  options: RequestInit,`);
+  lines.push(`  retries = 3,`);
+  lines.push(`): Promise<Response | null> {`);
+  lines.push(`  for (let i = 0; i < retries; i++) {`);
+  lines.push(`    try {`);
+  lines.push(`      const resp = await fetch(url, { ...options, signal: AbortSignal.timeout(10_000) });`);
+  lines.push(`      if (resp.ok) return resp;`);
+  lines.push(`      console.warn(\`[global-setup] \${options.method} \${url} \u2192 \${resp.status} (\${i + 1}/\${retries})\`);`);
+  lines.push(`    } catch (err: unknown) {`);
+  lines.push(`      const msg = err instanceof Error ? err.message : String(err);`);
+  lines.push(`      console.warn(\`[global-setup] \${options.method} \${url} error (\${i + 1}/\${retries}): \${msg}\`);`);
+  lines.push(`    }`);
+  lines.push(`    if (i < retries - 1) await new Promise((r) => setTimeout(r, 1000 * Math.pow(2, i)));`);
+  lines.push(`  }`);
+  lines.push(`  return null;`);
+  lines.push(`}`);
+  lines.push("");
+  lines.push(`async function waitForBackend(origin: string, timeoutMs = 30_000): Promise<void> {`);
+  lines.push(`  const start = Date.now();`);
+  lines.push(`  while (Date.now() - start < timeoutMs) {`);
+  lines.push(`    try {`);
+  lines.push(`      const res = await fetch(\`\${origin}/health\`, { signal: AbortSignal.timeout(3_000) });`);
+  lines.push(`      if (res.ok) return;`);
+  lines.push(`    } catch {`);
+  lines.push(`      // not ready yet`);
+  lines.push(`    }`);
+  lines.push(`    await new Promise((r) => setTimeout(r, 1_000));`);
+  lines.push(`  }`);
+  lines.push(`  throw new Error(\`Backend not ready after \${timeoutMs}ms\`);`);
+  lines.push(`}`);
+  lines.push("");
+  lines.push(`export default async function globalSetup(): Promise<void> {`);
+  lines.push(`  console.log('[global-setup] Starting...');`);
+  lines.push("");
+  lines.push(`  // Backend readiness probe`);
+  lines.push(`  try {`);
+  lines.push(`    await waitForBackend(BASE_URL, 30_000);`);
+  lines.push(`    console.log('[global-setup] Backend is ready.');`);
+  lines.push(`  } catch (e: unknown) {`);
+  lines.push(`    console.warn(\`[global-setup] \${e instanceof Error ? e.message : String(e)}\`);`);
+  lines.push(`  }`);
+  lines.push("");
+  if (hasSeedEndpoint) {
+    lines.push(`  // Seed data via backend endpoint`);
+    lines.push(`  try {`);
+    lines.push(`    await fetchWithRetry(`);
+    lines.push(`      \`\${BASE_URL}${rt.db.seedEndpoint}\`,`);
+    lines.push(`      { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: '{}' },`);
+    lines.push(`    );`);
+    lines.push(`    console.log('[global-setup] Seed endpoint called.');`);
+    lines.push(`  } catch {`);
+    lines.push(`    console.warn('[global-setup] Seed endpoint failed.');`);
+    lines.push(`  }`);
+    lines.push("");
+  }
+  if (hasLogEndpoint) {
+    lines.push(`  // Clear test logs`);
+    lines.push(`  try {`);
+    lines.push(`    await fetchWithRetry(\`\${BASE_URL}${rt.logEndpoint}\`, { method: 'DELETE' });`);
+    lines.push(`    console.log('[global-setup] Test logs cleared.');`);
+    lines.push(`  } catch {`);
+    lines.push(`    console.warn('[global-setup] Failed to clear test logs.');`);
+    lines.push(`  }`);
+    lines.push("");
+  }
+  if (hasSeedFile) {
+    lines.push(`  // SQL seed file execution (placeholder \u2014 wire to your DB helper)`);
+    lines.push(`  // import { executeSeedSQL } from './utils/db-helper';`);
+    lines.push(`  // await executeSeedSQL('${rt.db.seedFile}');`);
+    lines.push("");
+  }
+  lines.push(`  console.log('[global-setup] Done.');`);
+  lines.push(`}`);
+  lines.push("");
+  return lines.join("\n");
+}
+var init_global_setup_generator = __esm({
+  "src/runtime/global-setup-generator.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/runtime/global-teardown-generator.ts
+function generateGlobalTeardown(config) {
+  const pw = config.playwright ?? {};
+  const rt = config.runtime ?? {};
+  const baseURL = pw.baseURL || "";
+  const hasCleanupEndpoint = !!rt.db?.cleanupEndpoint;
+  const hasCleanupFile = !!rt.db?.cleanupFile;
+  const lines = [];
+  lines.push(`/**`);
+  lines.push(` * Global teardown \u2014 generated by OpenCroc.`);
+  lines.push(` * Runs once after all test projects complete.`);
+  lines.push(` */`);
+  lines.push("");
+  lines.push(`const BASE_URL = process.env.BASE_URL || '${baseURL || "http://localhost:3000"}';`);
+  lines.push("");
+  lines.push(`export default async function globalTeardown(): Promise<void> {`);
+  lines.push(`  console.log('[global-teardown] Starting...');`);
+  lines.push("");
+  if (hasCleanupEndpoint) {
+    lines.push(`  // Cleanup via backend endpoint`);
+    lines.push(`  try {`);
+    lines.push(`    await fetch(\`\${BASE_URL}${rt.db.cleanupEndpoint}\`, { method: 'POST' });`);
+    lines.push(`    console.log('[global-teardown] Cleanup endpoint called.');`);
+    lines.push(`  } catch {`);
+    lines.push(`    console.warn('[global-teardown] Cleanup endpoint failed.');`);
+    lines.push(`  }`);
+    lines.push("");
+  }
+  if (hasCleanupFile) {
+    lines.push(`  // SQL cleanup file execution (placeholder \u2014 wire to your DB helper)`);
+    lines.push(`  // import { executeSeedSQL } from './utils/db-helper';`);
+    lines.push(`  // await executeSeedSQL('${rt.db.cleanupFile}');`);
+    lines.push("");
+  }
+  lines.push(`  console.log('[global-teardown] Done.');`);
+  lines.push(`}`);
+  lines.push("");
+  return lines.join("\n");
+}
+var init_global_teardown_generator = __esm({
+  "src/runtime/global-teardown-generator.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/runtime/auth-setup-generator.ts
+function generateAuthSetup(config) {
+  const rt = config.runtime ?? {};
+  const pw = config.playwright ?? {};
+  const auth = rt.auth ?? {};
+  const baseURL = pw.baseURL || "";
+  const storageStatePath = auth.storageStatePath || "playwright/.auth/user.json";
+  const lines = [];
+  lines.push(`import { test as setup, expect } from '@playwright/test';`);
+  lines.push(`import * as fs from 'fs/promises';`);
+  lines.push(`import * as path from 'path';`);
+  lines.push("");
+  lines.push(`const authFile = '${storageStatePath}';`);
+  lines.push("");
+  if (auth.loginUrl) {
+    lines.push(`setup('authenticate', async ({ request }) => {`);
+    lines.push(`  const loginUrl = process.env.AUTH_LOGIN_URL || '${auth.loginUrl}';`);
+    lines.push(`  const username = process.env.AUTH_USERNAME || '${auth.username || "admin"}';`);
+    lines.push(`  const password = process.env.AUTH_PASSWORD || '${auth.password || ""}';`);
+    lines.push("");
+    lines.push(`  // API login`);
+    lines.push(`  const response = await request.post(loginUrl, {`);
+    lines.push(`    data: { username, password },`);
+    lines.push(`  });`);
+    lines.push(`  expect(response.ok()).toBeTruthy();`);
+    lines.push("");
+    lines.push(`  const body = await response.json();`);
+    lines.push(`  const token = body.data?.token || body.token || '';`);
+    lines.push(`  console.log('[auth.setup] Login successful, token obtained:', !!token);`);
+    lines.push("");
+    lines.push(`  // Save storage state with auth cookie/localStorage`);
+    lines.push(`  await fs.mkdir(path.dirname(authFile), { recursive: true });`);
+    lines.push("");
+    lines.push(`  // Build storage state JSON`);
+    lines.push(`  const baseURL = process.env.BASE_URL || '${baseURL || "http://localhost:3000"}';`);
+    lines.push(`  const origin = new URL(baseURL).origin;`);
+    lines.push(`  const storageState = {`);
+    lines.push(`    cookies: [],`);
+    lines.push(`    origins: [`);
+    lines.push(`      {`);
+    lines.push(`        origin,`);
+    lines.push(`        localStorage: [`);
+    lines.push(`          { name: 'token', value: token },`);
+    lines.push(`        ],`);
+    lines.push(`      },`);
+    lines.push(`    ],`);
+    lines.push(`  };`);
+    lines.push("");
+    lines.push(`  await fs.writeFile(authFile, JSON.stringify(storageState, null, 2));`);
+    lines.push(`  console.log(\`[auth.setup] Storage state saved \u2192 \${authFile}\`);`);
+    lines.push(`});`);
+  } else {
+    lines.push(`setup('authenticate', async ({ browser }) => {`);
+    lines.push(`  const context = await browser.newContext();`);
+    lines.push(`  const page = await context.newPage();`);
+    lines.push("");
+    lines.push(`  // TODO: Implement your login flow here`);
+    lines.push(`  // await page.goto('/login');`);
+    lines.push(`  // await page.fill('[name=username]', 'admin');`);
+    lines.push(`  // await page.fill('[name=password]', 'password');`);
+    lines.push(`  // await page.click('button[type=submit]');`);
+    lines.push(`  // await page.waitForURL('/dashboard');`);
+    lines.push("");
+    lines.push(`  await fs.mkdir(path.dirname(authFile), { recursive: true });`);
+    lines.push(`  await context.storageState({ path: authFile });`);
+    lines.push(`  console.log(\`[auth.setup] Storage state saved \u2192 \${authFile}\`);`);
+    lines.push("");
+    lines.push(`  await context.close();`);
+    lines.push(`});`);
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+var init_auth_setup_generator = __esm({
+  "src/runtime/auth-setup-generator.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/cli/commands/init-runtime.ts
+var init_runtime_exports = {};
+__export(init_runtime_exports, {
+  initRuntime: () => initRuntime
+});
+import chalk9 from "chalk";
+import { existsSync as existsSync12, mkdirSync as mkdirSync7, writeFileSync as writeFileSync7 } from "fs";
+import { join as join10, resolve as resolve7 } from "path";
+function writeIfNotExists(filePath, content, force) {
+  if (existsSync12(filePath) && !force) {
+    console.log(chalk9.yellow(`  \u2298 ${filePath} already exists (use --force to overwrite)`));
+    return false;
+  }
+  const dir = resolve7(filePath, "..");
+  mkdirSync7(dir, { recursive: true });
+  writeFileSync7(filePath, content, "utf-8");
+  console.log(chalk9.green(`  \u2713 ${filePath}`));
+  return true;
+}
+async function initRuntime(opts) {
+  console.log(chalk9.cyan.bold("\n  \u{1F40A} OpenCroc \u2014 Initialize Playwright Runtime\n"));
+  const { config, filepath } = await loadConfig();
+  console.log(chalk9.gray(`  Config: ${filepath}`));
+  const outDir = resolve7(opts.output || ".");
+  const force = opts.force ?? false;
+  const hasAuth = !!config.runtime?.auth?.loginUrl;
+  let written = 0;
+  console.log(chalk9.cyan("\n  Generating runtime files...\n"));
+  if (writeIfNotExists(join10(outDir, "playwright.config.ts"), generatePlaywrightConfig(config), force)) written++;
+  if (writeIfNotExists(join10(outDir, "global-setup.ts"), generateGlobalSetup(config), force)) written++;
+  if (writeIfNotExists(join10(outDir, "global-teardown.ts"), generateGlobalTeardown(config), force)) written++;
+  if (hasAuth) {
+    if (writeIfNotExists(join10(outDir, "auth.setup.ts"), generateAuthSetup(config), force)) written++;
+  }
+  console.log("");
+  if (written > 0) {
+    console.log(chalk9.green(`  \u2713 Generated ${written} runtime file(s) in ${outDir}
+`));
+  } else {
+    console.log(chalk9.yellow(`  No files written. Use --force to overwrite existing files.
+`));
+  }
+}
+var init_init_runtime = __esm({
+  "src/cli/commands/init-runtime.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_load_config();
+    init_playwright_config_generator();
+    init_global_setup_generator();
+    init_global_teardown_generator();
+    init_auth_setup_generator();
+  }
+});
+
+// src/orchestrator/index.ts
+import { writeFileSync as writeFileSync8, mkdirSync as mkdirSync8, existsSync as existsSync13, readdirSync as readdirSync6 } from "fs";
+import { dirname as dirname4, join as join11 } from "path";
+import { execFileSync as execFileSync2 } from "child_process";
+function discoverTestFiles2(outDir, moduleFilter) {
+  const absDir = join11(process.cwd(), outDir);
+  if (!existsSync13(absDir)) return [];
+  const files = [];
+  const entries = readdirSync6(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 = join11(
+      entry.parentPath || entry.path || absDir,
+      entry.name
+    );
+    if (moduleFilter && !fullPath.includes(moduleFilter)) continue;
+    files.push(fullPath);
+  }
+  return files;
+}
+function parsePlaywrightOutput(stderr) {
+  const metrics = { passed: 0, failed: 0, skipped: 0, timedOut: 0 };
+  const passedMatch = stderr.match(/(\d+)\s+passed/);
+  const failedMatch = stderr.match(/(\d+)\s+failed/);
+  const skippedMatch = stderr.match(/(\d+)\s+skipped/);
+  const timedOutMatch = stderr.match(/(\d+)\s+timed?\s*out/i);
+  if (passedMatch) metrics.passed = parseInt(passedMatch[1], 10);
+  if (failedMatch) metrics.failed = parseInt(failedMatch[1], 10);
+  if (skippedMatch) metrics.skipped = parseInt(skippedMatch[1], 10);
+  if (timedOutMatch) metrics.timedOut = parseInt(timedOutMatch[1], 10);
+  return metrics;
+}
+function createOrchestrator(config, options = {}) {
+  const {
+    phases = ALL_PHASES,
+    selfHeal = false,
+    maxHealIterations = 3,
+    reportFormats = ["html", "json"],
+    headed = false,
+    module: moduleFilter,
+    tokenBudget = 0,
+    abortOnError = false
+  } = options;
+  const outDir = config.outDir || "./opencroc-output";
+  const phaseResults = [];
+  let pipelineResult;
+  let executionMetrics;
+  let healingResult;
+  let reports;
+  let tokensUsed = 0;
+  function isBudgetExceeded() {
+    return tokenBudget > 0 && tokensUsed >= tokenBudget;
+  }
+  function shouldRun(phase) {
+    if (phase === "heal" && !selfHeal) return false;
+    return phases.includes(phase);
+  }
+  async function runPhase(name, fn) {
+    const start = Date.now();
+    try {
+      const output = await fn();
+      const result = {
+        phase: name,
+        status: "success",
+        output,
+        durationMs: Date.now() - start
+      };
+      phaseResults.push(result);
+      return result;
+    } catch (err) {
+      const result = {
+        phase: name,
+        status: "error",
+        error: err instanceof Error ? err.message : String(err),
+        durationMs: Date.now() - start
+      };
+      phaseResults.push(result);
+      return result;
+    }
+  }
+  function skipPhase(name, reason) {
+    const result = {
+      phase: name,
+      status: "skipped",
+      error: reason,
+      durationMs: 0
+    };
+    phaseResults.push(result);
+    return result;
+  }
+  return {
+    async run() {
+      const orchestrationStart = Date.now();
+      if (shouldRun("generate")) {
+        const genResult = await runPhase("generate", async () => {
+          if (moduleFilter) config.modules = [moduleFilter];
+          const pipeline = createPipeline(config);
+          pipelineResult = await pipeline.run();
+          for (const file of pipelineResult.generatedFiles) {
+            const dir = dirname4(file.filePath);
+            if (!existsSync13(dir)) mkdirSync8(dir, { recursive: true });
+            writeFileSync8(file.filePath, file.content, "utf-8");
+          }
+          return pipelineResult;
+        });
+        if (genResult.status === "error" && abortOnError) {
+          return buildSummary(orchestrationStart);
+        }
+      }
+      if (shouldRun("execute")) {
+        const testFiles = discoverTestFiles2(outDir, moduleFilter);
+        if (testFiles.length === 0) {
+          skipPhase("execute", "No test files found");
+        } else {
+          const execResult = await runPhase("execute", async () => {
+            const args = ["test", ...testFiles];
+            if (!headed) args.push("--reporter=list");
+            else args.push("--headed");
+            const npxCmd = process.platform === "win32" ? "npx.cmd" : "npx";
+            try {
+              execFileSync2(npxCmd, ["playwright", ...args], {
+                cwd: process.cwd(),
+                stdio: ["ignore", "pipe", "pipe"],
+                timeout: 3e5
+              });
+              return { passed: testFiles.length, failed: 0, skipped: 0, timedOut: 0 };
+            } catch (err) {
+              const stderr = err?.stderr?.toString() ?? "";
+              const metrics = parsePlaywrightOutput(stderr);
+              if (metrics.passed === 0 && metrics.failed === 0) {
+                metrics.failed = testFiles.length;
+              }
+              executionMetrics = metrics;
+              if (metrics.failed > 0) {
+                throw new Error(`${metrics.failed} test(s) failed, ${metrics.passed} passed`, { cause: err });
+              }
+              return metrics;
+            }
+          });
+          if (!executionMetrics && execResult.output) {
+            executionMetrics = execResult.output;
+          }
+          if (execResult.status === "error" && abortOnError) {
+            return buildSummary(orchestrationStart);
+          }
+        }
+      }
+      if (shouldRun("analyze")) {
+        if (!pipelineResult || !executionMetrics || executionMetrics.failed === 0) {
+          skipPhase("analyze", "No failures to analyze");
+        } else {
+          await runPhase("analyze", async () => {
+            const pipeline = createPipeline(config);
+            const validationResult = await pipeline.run(["validate"]);
+            return {
+              validationErrors: validationResult.validationErrors,
+              failedTestCount: executionMetrics.failed
+            };
+          });
+        }
+      }
+      if (shouldRun("heal")) {
+        if (isBudgetExceeded()) {
+          skipPhase("heal", "Token budget exceeded");
+        } else if (!executionMetrics || executionMetrics.failed === 0) {
+          skipPhase("heal", "No failures to heal");
+        } else {
+          const healResult = await runPhase("heal", async () => {
+            const healConfig = {
+              enabled: true,
+              maxIterations: maxHealIterations,
+              mode: config.selfHealing?.mode || "config-only"
+            };
+            const loop = createSelfHealingLoop(healConfig);
+            const result = await loop.run(outDir);
+            tokensUsed += result.totalTokensUsed;
+            healingResult = result;
+            return result;
+          });
+          if (healResult.status === "success" && healingResult && healingResult.remaining.length > 0) {
+            healResult.status = "warn";
+            phaseResults[phaseResults.length - 1] = healResult;
+          }
+        }
+      }
+      if (shouldRun("report")) {
+        if (!pipelineResult) {
+          skipPhase("report", "No pipeline results to report");
+        } else {
+          await runPhase("report", async () => {
+            reports = generateReports(pipelineResult, reportFormats);
+            if (!existsSync13(outDir)) mkdirSync8(outDir, { recursive: true });
+            for (const r of reports) {
+              writeFileSync8(join11(outDir, r.filename), r.content, "utf-8");
+            }
+            return reports;
+          });
+        }
+      }
+      return buildSummary(orchestrationStart);
+    }
+  };
+  function buildSummary(startTime) {
+    const errorCount = phaseResults.filter((p) => p.status === "error").length;
+    const allSuccess = phaseResults.every((p) => p.status === "success" || p.status === "skipped");
+    let overallStatus;
+    if (allSuccess) overallStatus = "success";
+    else if (errorCount > 1) overallStatus = "fatal-fail";
+    else overallStatus = "partial-fail";
+    let recommendation;
+    if (executionMetrics && executionMetrics.failed > 0 && !selfHeal) {
+      recommendation = "Test failures detected. Consider running with --self-heal to attempt automated fixes.";
+    } else if (healingResult && healingResult.remaining.length > 0) {
+      recommendation = `${healingResult.remaining.length} issue(s) could not be auto-fixed. Manual review needed.`;
+    }
+    return {
+      overallStatus,
+      phases: phaseResults,
+      totalDurationMs: Date.now() - startTime,
+      modules: pipelineResult?.modules ?? [],
+      executionMetrics,
+      reports,
+      healingResult,
+      recommendation
+    };
+  }
+}
+var ALL_PHASES;
+var init_orchestrator = __esm({
+  "src/orchestrator/index.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_pipeline();
+    init_self_healing();
+    init_reporters();
+    ALL_PHASES = ["generate", "execute", "analyze", "heal", "report"];
+  }
+});
+
+// src/orchestrator/reporter.ts
+import { writeFileSync as writeFileSync9, mkdirSync as mkdirSync9, existsSync as existsSync14 } from "fs";
+import { join as join12 } from "path";
+function writeOrchestrationSummary(summary, options) {
+  const { outputDir, module: mod } = options;
+  if (!existsSync14(outputDir)) mkdirSync9(outputDir, { recursive: true });
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const moduleName = mod ?? "all";
+  const filename = `orchestration-${moduleName}-${timestamp}.json`;
+  const filePath = join12(outputDir, filename);
+  const serializable = {
+    ...summary,
+    phases: summary.phases.map((p) => ({
+      phase: p.phase,
+      status: p.status,
+      error: p.error,
+      durationMs: p.durationMs
+    })),
+    // Strip report content to avoid massive JSON
+    reports: summary.reports?.map((r) => ({
+      format: r.format,
+      filename: r.filename
+    }))
+  };
+  writeFileSync9(filePath, JSON.stringify(serializable, null, 2), "utf-8");
+  return filePath;
+}
+function formatPhase(p) {
+  const icons = {
+    success: "\u2713",
+    warn: "\u26A0",
+    error: "\u2717",
+    skipped: "\u25CB"
+  };
+  const icon = icons[p.status] ?? "?";
+  const dur = p.durationMs > 0 ? ` (${p.durationMs}ms)` : "";
+  const err = p.error ? ` \u2014 ${p.error}` : "";
+  return `  ${icon} ${p.phase}${dur}${err}`;
+}
+function printOrchestrationSummary(summary) {
+  const lines = [];
+  lines.push("");
+  lines.push("  \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550");
+  lines.push("  Orchestration Summary");
+  lines.push("  \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550");
+  lines.push("");
+  for (const p of summary.phases) {
+    lines.push(formatPhase(p));
+  }
+  lines.push("");
+  lines.push(`  Overall    : ${summary.overallStatus}`);
+  lines.push(`  Modules    : ${summary.modules.join(", ") || "(none)"}`);
+  lines.push(`  Duration   : ${summary.totalDurationMs}ms`);
+  if (summary.executionMetrics) {
+    const m = summary.executionMetrics;
+    lines.push(`  Tests      : ${m.passed} passed, ${m.failed} failed, ${m.skipped} skipped`);
+  }
+  if (summary.healingResult) {
+    const h = summary.healingResult;
+    lines.push(`  Healing    : ${h.fixed.length} fixed, ${h.remaining.length} remaining (${h.iterations} iterations)`);
+  }
+  if (summary.reports) {
+    lines.push(`  Reports    : ${summary.reports.map((r) => r.format).join(", ")}`);
+  }
+  if (summary.recommendation) {
+    lines.push("");
+    lines.push(`  \u2192 ${summary.recommendation}`);
+  }
+  lines.push("");
+  return lines;
+}
+var init_reporter = __esm({
+  "src/orchestrator/reporter.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/cli/commands/run.ts
+var run_exports = {};
+__export(run_exports, {
+  run: () => run
+});
+import chalk10 from "chalk";
+function parsePhases(raw) {
+  if (!raw) return void 0;
+  const names = raw.split(",").map((s) => s.trim());
+  for (const name of names) {
+    if (!VALID_PHASES.includes(name)) {
+      console.log(chalk10.red(`  Unknown phase "${name}". Valid: ${VALID_PHASES.join(", ")}`));
+      process.exitCode = 1;
+      return void 0;
+    }
+  }
+  return names;
+}
+async function run(opts) {
+  console.log(chalk10.cyan.bold("\n  \u{1F40A} OpenCroc \u2014 Full Orchestration\n"));
+  const { config, filepath } = await loadConfig();
+  console.log(chalk10.gray(`  Config: ${filepath}`));
+  const phases = parsePhases(opts.phases);
+  if (phases === void 0 && opts.phases) return;
+  const reportFormats = (opts.report ?? "html,json").split(",").map((s) => s.trim());
+  const orchestrator = createOrchestrator(config, {
+    phases,
+    selfHeal: opts.selfHeal ?? false,
+    headed: opts.headed ?? false,
+    module: opts.module,
+    reportFormats,
+    tokenBudget: opts.tokenBudget ? parseInt(opts.tokenBudget, 10) : 0,
+    abortOnError: opts.abortOnError ?? false
+  });
+  console.log(chalk10.gray(`  Phases: ${(phases ?? VALID_PHASES).join(" \u2192 ")}`));
+  if (opts.selfHeal) console.log(chalk10.gray("  Self-heal: enabled"));
+  console.log("");
+  const summary = await orchestrator.run();
+  const lines = printOrchestrationSummary(summary);
+  for (const line of lines) {
+    const color = summary.overallStatus === "success" ? chalk10.green : summary.overallStatus === "partial-fail" ? chalk10.yellow : chalk10.red;
+    console.log(color(line));
+  }
+  const outDir = config.outDir || "./opencroc-output";
+  const summaryPath = writeOrchestrationSummary(summary, { outputDir: outDir, module: opts.module });
+  console.log(chalk10.gray(`  Summary: ${summaryPath}
+`));
+  if (summary.overallStatus !== "success") {
+    process.exitCode = 1;
+  }
+}
+var VALID_PHASES;
+var init_run = __esm({
+  "src/cli/commands/run.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_load_config();
+    init_orchestrator();
+    init_reporter();
+    VALID_PHASES = ["generate", "execute", "analyze", "heal", "report"];
+  }
+});
+
+// src/server/routes/project.ts
+function registerProjectRoutes(app, office) {
+  app.get("/api/project", async () => {
+    return office.getProjectInfo();
+  });
+  app.get("/api/project/graph", async () => {
+    return office.buildKnowledgeGraph();
+  });
+  app.post("/api/project/refresh", async () => {
+    office.invalidateCache();
+    const graph = await office.buildKnowledgeGraph();
+    office.broadcast("graph:update", graph);
+    return { ok: true, nodes: graph.nodes.length, edges: graph.edges.length };
+  });
+}
+var init_project = __esm({
+  "src/server/routes/project.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/server/routes/agents.ts
+function registerAgentRoutes(app, office) {
+  app.get("/api/agents", async () => {
+    return office.getAgents();
+  });
+  app.get("/api/agents/:id", async (req, reply) => {
+    const agent = office.getAgent(req.params.id);
+    if (!agent) {
+      reply.code(404).send({ error: "Agent not found" });
+      return;
+    }
+    return agent;
+  });
+  app.post("/api/agents/:id/task", async (req, reply) => {
+    const agent = office.getAgent(req.params.id);
+    if (!agent) {
+      reply.code(404).send({ error: "Agent not found" });
+      return;
+    }
+    office.updateAgent(req.params.id, {
+      status: "working",
+      currentTask: req.body?.task || "Processing..."
+    });
+    setTimeout(() => {
+      office.updateAgent(req.params.id, {
+        status: "done",
+        currentTask: "Task completed"
+      });
+    }, 2e3);
+    return { ok: true, agent: req.params.id, task: req.body?.task };
+  });
+}
+var init_agents = __esm({
+  "src/server/routes/agents.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/server/croc-office.ts
+var DEFAULT_AGENTS, CrocOffice;
+var init_croc_office = __esm({
+  "src/server/croc-office.ts"() {
+    "use strict";
+    init_esm_shims();
+    DEFAULT_AGENTS = [
+      { id: "parser-croc", name: "\u89E3\u6790\u9CC4", role: "parser", sprite: "parser", status: "idle", tokensUsed: 0 },
+      { id: "analyzer-croc", name: "\u5206\u6790\u9CC4", role: "analyzer", sprite: "analyzer", status: "idle", tokensUsed: 0 },
+      { id: "tester-croc", name: "\u6D4B\u8BD5\u9CC4", role: "tester", sprite: "tester", status: "idle", tokensUsed: 0 },
+      { id: "healer-croc", name: "\u4FEE\u590D\u9CC4", role: "healer", sprite: "healer", status: "idle", tokensUsed: 0 },
+      { id: "planner-croc", name: "\u89C4\u5212\u9CC4", role: "planner", sprite: "planner", status: "idle", tokensUsed: 0 },
+      { id: "reporter-croc", name: "\u6C47\u62A5\u9CC4", role: "reporter", sprite: "reporter", status: "idle", tokensUsed: 0 }
+    ];
+    CrocOffice = class {
+      config;
+      cwd;
+      clients = /* @__PURE__ */ new Set();
+      agents;
+      cachedGraph = null;
+      constructor(config, cwd) {
+        this.config = config;
+        this.cwd = cwd;
+        this.agents = DEFAULT_AGENTS.map((a) => ({ ...a }));
+      }
+      addClient(ws) {
+        this.clients.add(ws);
+      }
+      removeClient(ws) {
+        this.clients.delete(ws);
+      }
+      broadcast(type, payload) {
+        const msg = JSON.stringify({ type, payload });
+        for (const client of this.clients) {
+          try {
+            client.send(msg);
+          } catch {
+            this.clients.delete(client);
+          }
+        }
+      }
+      getAgents() {
+        return this.agents;
+      }
+      getAgent(id) {
+        return this.agents.find((a) => a.id === id);
+      }
+      updateAgent(id, update) {
+        const agent = this.agents.find((a) => a.id === id);
+        if (agent) {
+          Object.assign(agent, update);
+          this.broadcast("agent:update", this.agents);
+        }
+      }
+      getConfig() {
+        return this.config;
+      }
+      getCwd() {
+        return this.cwd;
+      }
+      /** Build knowledge graph from project source code */
+      async buildKnowledgeGraph() {
+        if (this.cachedGraph) return this.cachedGraph;
+        this.updateAgent("parser-croc", { status: "working", currentTask: "Scanning project structure..." });
+        try {
+          const { resolve: resolvePath } = await import("path");
+          const { glob } = await import("glob");
+          const backendRoot = resolvePath(this.cwd, this.config.backendRoot);
+          const nodes = [];
+          const edges = [];
+          const moduleSet = /* @__PURE__ */ new Set();
+          const modelFiles = await glob("**/models/**/*.{ts,js}", {
+            cwd: backendRoot,
+            ignore: ["**/node_modules/**", "**/*.test.*", "**/*.spec.*", "**/index.*"]
+          });
+          for (const file of modelFiles) {
+            const parts = file.split("/");
+            const moduleName = parts.length >= 3 ? parts[parts.length - 3] : "default";
+            const fileName = parts[parts.length - 1].replace(/\.(ts|js)$/, "");
+            const nodeId = `model:${fileName}`;
+            moduleSet.add(moduleName);
+            nodes.push({
+              id: nodeId,
+              label: fileName,
+              type: "model",
+              status: "idle",
+              module: moduleName
+            });
+          }
+          const controllerFiles = await glob("**/controllers/**/*.{ts,js}", {
+            cwd: backendRoot,
+            ignore: ["**/node_modules/**", "**/*.test.*", "**/*.spec.*", "**/index.*"]
+          });
+          for (const file of controllerFiles) {
+            const parts = file.split("/");
+            const moduleName = parts.length >= 3 ? parts[parts.length - 3] : "default";
+            const fileName = parts[parts.length - 1].replace(/\.(ts|js)$/, "").replace(".controller", "");
+            const nodeId = `controller:${fileName}`;
+            moduleSet.add(moduleName);
+            nodes.push({
+              id: nodeId,
+              label: `${fileName} (ctrl)`,
+              type: "controller",
+              status: "idle",
+              module: moduleName
+            });
+            const modelNode = nodes.find((n) => n.type === "model" && n.label.toLowerCase() === fileName.toLowerCase());
+            if (modelNode) {
+              edges.push({ source: nodeId, target: modelNode.id, relation: "uses" });
+            }
+          }
+          for (const mod of moduleSet) {
+            const moduleNodeId = `module:${mod}`;
+            nodes.push({
+              id: moduleNodeId,
+              label: mod,
+              type: "module",
+              status: "idle"
+            });
+            for (const n of nodes) {
+              if (n.module === mod && n.type !== "module") {
+                edges.push({ source: moduleNodeId, target: n.id, relation: "contains" });
+              }
+            }
+          }
+          this.cachedGraph = { nodes, edges };
+          this.updateAgent("parser-croc", { status: "done", currentTask: `Found ${nodes.length} nodes` });
+          return this.cachedGraph;
+        } catch (err) {
+          this.updateAgent("parser-croc", { status: "error", currentTask: String(err) });
+          return { nodes: [], edges: [] };
+        }
+      }
+      invalidateCache() {
+        this.cachedGraph = null;
+      }
+      async getProjectInfo() {
+        const graph = await this.buildKnowledgeGraph();
+        const stats = {
+          modules: graph.nodes.filter((n) => n.type === "module").length,
+          models: graph.nodes.filter((n) => n.type === "model").length,
+          endpoints: graph.nodes.filter((n) => n.type === "api" || n.type === "controller").length,
+          relations: graph.edges.length
+        };
+        return {
+          name: this.config.backendRoot.split("/").pop() || "project",
+          backendRoot: this.config.backendRoot,
+          adapter: typeof this.config.adapter === "string" ? this.config.adapter : "custom",
+          stats,
+          graph,
+          agents: this.agents
+        };
+      }
+    };
+  }
+});
+
+// src/server/index.ts
+var server_exports = {};
+__export(server_exports, {
+  startServer: () => startServer
+});
+import Fastify from "fastify";
+import fastifyStatic from "@fastify/static";
+import fastifyWebsocket from "@fastify/websocket";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { dirname as dirname5, join as join13, resolve as resolve8 } from "path";
+import { existsSync as existsSync15 } from "fs";
+async function startServer(opts) {
+  const app = Fastify({ logger: false });
+  await app.register(fastifyWebsocket);
+  const webDir = resolve8(__dirname2, "../web");
+  if (existsSync15(webDir)) {
+    await app.register(fastifyStatic, {
+      root: webDir,
+      prefix: "/",
+      decorateReply: false
+    });
+  }
+  const office = new CrocOffice(opts.config, opts.cwd);
+  registerProjectRoutes(app, office);
+  registerAgentRoutes(app, office);
+  app.register(async (fastify) => {
+    fastify.get("/ws", { websocket: true }, (socket) => {
+      office.addClient(socket);
+      socket.on("close", () => office.removeClient(socket));
+    });
+  });
+  app.setNotFoundHandler((req, reply) => {
+    if (req.url.startsWith("/api/")) {
+      reply.code(404).send({ error: "Not found" });
+      return;
+    }
+    const indexPath = join13(webDir, "index.html");
+    if (existsSync15(indexPath)) {
+      reply.sendFile("index.html");
+    } else {
+      reply.code(200).header("content-type", "text/html").send(getEmbeddedHtml());
+    }
+  });
+  try {
+    await app.listen({ port: opts.port, host: opts.host });
+    const url = `http://${opts.host === "0.0.0.0" ? "localhost" : opts.host}:${opts.port}`;
+    console.log(`
+  \u{1F40A} OpenCroc Studio is running at ${url}
+`);
+    if (opts.open) {
+      const { exec } = await import("child_process");
+      const cmd = process.platform === "win32" ? "start" : process.platform === "darwin" ? "open" : "xdg-open";
+      exec(`${cmd} ${url}`);
+    }
+  } catch (err) {
+    console.error("Failed to start server:", err);
+    process.exit(1);
+  }
+}
+function getEmbeddedHtml() {
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>OpenCroc Studio \u{1F40A}</title>
+<style>
+  * { margin:0; padding:0; box-sizing:border-box; }
+  body { background:#1a1a2e; color:#e0e0e0; font-family:'Courier New',monospace; display:flex; justify-content:center; align-items:center; min-height:100vh; }
+  .container { text-align:center; }
+  h1 { font-size:3rem; color:#4ecca3; margin-bottom:1rem; }
+  .croc { font-size:6rem; animation: bounce 1s infinite alternate; }
+  @keyframes bounce { from{transform:translateY(0)} to{transform:translateY(-20px)} }
+  p { margin-top:1rem; color:#888; }
+  .status { margin-top:2rem; padding:1rem; background:#16213e; border-radius:8px; }
+  #graph-container { margin-top:2rem; min-height:400px; background:#0f3460; border-radius:8px; position:relative; }
+  .loading { color:#4ecca3; padding:2rem; }
+</style>
+</head>
+<body>
+<div class="container">
+  <div class="croc">\u{1F40A}</div>
+  <h1>OpenCroc Studio</h1>
+  <p>AI-native E2E testing \u2014 Pixel Croc Office</p>
+  <div class="status" id="status">Connecting...</div>
+  <div id="graph-container"><div class="loading">Loading project graph...</div></div>
+</div>
+<script>
+(async () => {
+  // Fetch project graph data
+  try {
+    const res = await fetch('/api/project');
+    const data = await res.json();
+    document.getElementById('status').innerHTML =
+      '<b>Project:</b> ' + (data.name || 'unknown') +
+      ' | <b>Modules:</b> ' + (data.stats?.modules || 0) +
+      ' | <b>Models:</b> ' + (data.stats?.models || 0) +
+      ' | <b>APIs:</b> ' + (data.stats?.endpoints || 0);
+
+    renderGraph(data.graph);
+  } catch(e) {
+    document.getElementById('status').textContent = 'Error loading project: ' + e.message;
+  }
+
+  // WebSocket for live updates
+  const protocol = location.protocol === 'https:' ? 'wss:' : 'ws:';
+  const ws = new WebSocket(protocol + '//' + location.host + '/ws');
+  ws.onmessage = (e) => {
+    try {
+      const msg = JSON.parse(e.data);
+      if (msg.type === 'agent:update') {
+        updateAgentStatus(msg.payload);
+      } else if (msg.type === 'graph:update') {
+        renderGraph(msg.payload);
+      }
+    } catch {}
+  };
+  ws.onclose = () => {
+    document.getElementById('status').textContent += ' [disconnected]';
+  };
+})();
+
+function renderGraph(graph) {
+  if (!graph || (!graph.nodes?.length)) {
+    document.getElementById('graph-container').innerHTML = '<div class="loading">No modules found. Run opencroc init first.</div>';
+    return;
+  }
+
+  const container = document.getElementById('graph-container');
+  const w = container.clientWidth || 800;
+  const h = 500;
+
+  // Simple force-directed placement
+  const nodes = graph.nodes.map((n, i) => ({
+    ...n,
+    x: w/2 + Math.cos(i * 2 * Math.PI / graph.nodes.length) * Math.min(w,h) * 0.35,
+    y: h/2 + Math.sin(i * 2 * Math.PI / graph.nodes.length) * Math.min(w,h) * 0.35,
+    vx: 0, vy: 0,
+  }));
+
+  const nodeMap = new Map(nodes.map(n => [n.id, n]));
+
+  // Render SVG
+  const colors = { model:'#4ecca3', controller:'#e94560', api:'#f39c12', dto:'#3498db', default:'#888' };
+
+  let svg = '<svg width="'+w+'" height="'+h+'" xmlns="http://www.w3.org/2000/svg">';
+
+  // Edges
+  for (const edge of (graph.edges || [])) {
+    const s = nodeMap.get(edge.source);
+    const t = nodeMap.get(edge.target);
+    if (s && t) {
+      svg += '<line x1="'+s.x+'" y1="'+s.y+'" x2="'+t.x+'" y2="'+t.y+'" stroke="#555" stroke-width="1.5" opacity="0.6"/>';
+    }
+  }
+
+  // Nodes
+  for (const n of nodes) {
+    const color = colors[n.type] || colors.default;
+    const statusColor = n.status === 'passed' ? '#4ecca3' : n.status === 'failed' ? '#e94560' : n.status === 'testing' ? '#f39c12' : '#555';
+    // Pixel-art style square nodes
+    svg += '<rect x="'+(n.x-16)+'" y="'+(n.y-16)+'" width="32" height="32" fill="'+color+'" rx="4" stroke="'+statusColor+'" stroke-width="2"/>';
+    svg += '<text x="'+n.x+'" y="'+(n.y+32)+'" text-anchor="middle" fill="#ccc" font-size="10" font-family="Courier New">'+escapeHtml(n.label || n.id)+'</text>';
+  }
+
+  svg += '</svg>';
+  container.innerHTML = svg;
+}
+
+function escapeHtml(s) { return s.replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;'); }
+
+function updateAgentStatus(agents) {
+  // Will be enhanced with pixel croc animations in M2
+  console.log('Agent update:', agents);
+}
+</script>
+</body>
+</html>`;
+}
+var __filename2, __dirname2;
+var init_server = __esm({
+  "src/server/index.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_project();
+    init_agents();
+    init_croc_office();
+    __filename2 = fileURLToPath2(import.meta.url);
+    __dirname2 = dirname5(__filename2);
+  }
+});
+
+// src/cli/commands/serve.ts
+var serve_exports = {};
+__export(serve_exports, {
+  serve: () => serve
+});
+import chalk11 from "chalk";
+async function serve(opts) {
+  let loaded;
+  try {
+    loaded = await loadConfig();
+  } catch {
+    console.error(chalk11.red("No opencroc config found. Run `opencroc init` first."));
+    process.exitCode = 1;
+    return;
+  }
+  const port = parseInt(opts.port || "8765", 10);
+  const host = opts.host || "localhost";
+  console.log(chalk11.cyan("\u{1F40A} Starting OpenCroc Studio..."));
+  console.log(chalk11.gray(`   Config: ${loaded.filepath}`));
+  console.log(chalk11.gray(`   Backend: ${loaded.config.backendRoot}`));
+  const { startServer: startServer2 } = await Promise.resolve().then(() => (init_server(), server_exports));
+  await startServer2({
+    port,
+    host,
+    open: opts.open ?? true,
+    config: loaded.config,
+    cwd: process.cwd()
+  });
+}
+var init_serve = __esm({
+  "src/cli/commands/serve.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_load_config();
+  }
+});
+
 // src/cli/index.ts
 init_esm_shims();
 import { Command } from "commander";
 var program = new Command();
-program.name("opencroc").description("AI-native E2E testing framework").version("0.6.1");
+program.name("opencroc").description("AI-native E2E testing framework").version("1.0.0");
 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(opts);
@@ -2498,7 +3888,7 @@ program.command("generate").description("Generate E2E test cases from source cod
   const { generate: generate2 } = await Promise.resolve().then(() => (init_generate(), generate_exports));
   await generate2(opts);
 });
-program.command("test").description("Run generated E2E tests").option("-m, --module <name>", "Run tests for a specific module").option("--headed", "Run in headed browser mode").action(async (opts) => {
+program.command("test").description("Run generated E2E tests").option("-m, --module <name>", "Run tests for a specific module").option("--headed", "Run in headed browser mode").option("--setup-hook <cmd>", "Run setup hook command before test execution").option("--auth-hook <cmd>", "Run auth hook command before test execution").option("--teardown-hook <cmd>", "Run teardown hook command after test execution").action(async (opts) => {
   const { runTests: runTests2 } = await Promise.resolve().then(() => (init_test(), test_exports));
   await runTests2(opts);
 });
@@ -2522,5 +3912,17 @@ program.command("dashboard").description("Generate visual dashboard (opencroc-da
   const { dashboard: dashboard2 } = await Promise.resolve().then(() => (init_dashboard2(), dashboard_exports));
   await dashboard2(opts);
 });
+program.command("init-runtime").description("Generate Playwright runtime infrastructure (config, setup, teardown, auth)").option("-o, --output <dir>", "Output directory for generated files", ".").option("--force", "Overwrite existing files").action(async (opts) => {
+  const { initRuntime: initRuntime2 } = await Promise.resolve().then(() => (init_init_runtime(), init_runtime_exports));
+  await initRuntime2(opts);
+});
+program.command("run").description("Full orchestration: generate \u2192 execute \u2192 analyze \u2192 heal \u2192 report").option("-m, --module <name>", "Run for a specific module").option("--phases <phases>", "Phases to run (comma-separated: generate,execute,analyze,heal,report)").option("--self-heal", "Enable self-healing on test failures").option("--headed", "Run Playwright in headed mode").option("--report <formats>", "Report formats (comma-separated)", "html,json").option("--token-budget <n>", "LLM token budget (0 = unlimited)").option("--abort-on-error", "Abort pipeline on first phase error").action(async (opts) => {
+  const { run: run2 } = await Promise.resolve().then(() => (init_run(), run_exports));
+  await run2(opts);
+});
+program.command("serve").description("Start OpenCroc Studio \u2014 pixel croc office + knowledge graph UI").option("-p, --port <port>", "Server port", "8765").option("-H, --host <host>", "Server host", "localhost").option("--no-open", "Do not auto-open browser").action(async (opts) => {
+  const { serve: serve2 } = await Promise.resolve().then(() => (init_serve(), serve_exports));
+  await serve2(opts);
+});
 program.parse();
 //# sourceMappingURL=index.js.map