opencroc 0.1.6

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 opencroc
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,282 @@
+<p align="center">
+  <img src="docs/assets/logo-placeholder.png" alt="OpenCroc" width="200" />
+</p>
+
+<h1 align="center">OpenCroc</h1>
+
+<p align="center">
+  <strong>AI-native E2E testing framework that reads your source code, generates tests, and self-heals failures.</strong>
+</p>
+
+<p align="center">
+  <a href="https://www.npmjs.com/package/opencroc"><img src="https://img.shields.io/npm/v/opencroc?color=green" alt="npm version" /></a>
+  <a href="https://github.com/opencroc/opencroc/blob/main/LICENSE"><img src="https://img.shields.io/github/license/opencroc/opencroc" alt="MIT License" /></a>
+  <a href="https://opencroc.com"><img src="https://img.shields.io/badge/docs-opencroc.com-blue" alt="Documentation" /></a>
+</p>
+
+---
+
+## What is OpenCroc?
+
+OpenCroc is an **AI-native end-to-end testing framework** built on top of [Playwright](https://playwright.dev). Instead of writing test scripts by hand, OpenCroc **reads your backend source code** (models, controllers, DTOs) and automatically generates complete E2E test suites — including API chains, seed data, request bodies, and assertions.
+
+When tests fail, OpenCroc doesn't just report errors — it **traces the root cause** through the full request chain, **generates fix patches**, and **re-runs tests to verify the fix** — all autonomously.
+
+### Key Capabilities
+
+| Capability | Description |
+|---|---|
+| **Source-Aware Test Generation** | Parses Sequelize/TypeORM models, Express/NestJS controllers, and DTO decorators via [ts-morph](https://ts-morph.com) to understand your API surface |
+| **AI-Driven Configuration** | LLM generates request body templates, seed data, parameter mappings — validated by 3-layer verification (schema → semantic → dry-run) |
+| **Intelligent Chain Planning** | Builds API dependency DAGs, performs topological sorting, and plans test chains with greedy coverage optimization |
+| **Log-Driven Completion Detection** | Goes beyond `networkidle` — verifies request completion by matching backend execution logs (`api_exec end`) |
+| **Failure Chain Attribution** | Traces failures through the full call chain: network errors → slow APIs → backend logs → root cause |
+| **Controlled Self-Healing** | `backup → AI patch → dry-run → apply → re-run → verify → rollback` — with safety gates at every step |
+| **Impact Analysis** | BFS traversal of foreign key relations to map blast radius, auto-generates Mermaid diagrams |
+
+## Quick Start
+
+### Prerequisites
+
+- Node.js >= 18
+- A backend project with Express/NestJS + Sequelize/TypeORM
+
+### Installation
+
+```bash
+npm install opencroc --save-dev
+```
+
+### Initialize
+
+```bash
+npx opencroc init
+```
+
+This will:
+1. Scan your project structure
+2. Detect your ORM and framework
+3. Create `opencroc.config.ts` with sensible defaults
+4. Generate a sample test suite
+
+### Generate Tests
+
+```bash
+# Generate tests for a single module
+npx opencroc generate --module=knowledge-base
+
+# Generate tests for all detected modules
+npx opencroc generate --all
+
+# Dry-run (preview without writing files)
+npx opencroc generate --all --dry-run
+```
+
+### Run Tests
+
+```bash
+# Run all generated tests
+npx opencroc test
+
+# Run specific module
+npx opencroc test --module=knowledge-base
+
+# Run with self-healing enabled
+npx opencroc test --self-heal
+```
+
+### Validate AI Configs
+
+```bash
+# Validate generated configurations
+npx opencroc validate --all
+
+# Compare AI-generated vs baseline results
+npx opencroc compare --baseline=report-a.json --current=report-b.json
+```
+
+## Architecture
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                     CLI / Orchestrator                       │
+├──────────┬──────────┬──────────┬──────────┬─────────────────┤
+│  Source   │  Chain   │  Test    │ Execution│   Self-Healing  │
+│  Parser   │ Planner  │Generator │  Engine  │     Engine      │
+│           │          │          │          │                 │
+│ ts-morph  │ DAG +    │ Template │Playwright│ AI Attribution  │
+│ Model     │ Topo     │ + AI     │ + Log    │ + Controlled    │
+│ Controller│ Sort +   │ Config   │ Driven   │ Fix + Verify    │
+│ DTO       │ Greedy   │ Merge    │ Assert   │ + Rollback      │
+├──────────┴──────────┴──────────┴──────────┴─────────────────┤
+│              Observation Bus (Network + Backend Logs)         │
+├──────────────────────────────────────────────────────────────┤
+│              Report Engine (HTML / JSON / Markdown)           │
+└──────────────────────────────────────────────────────────────┘
+```
+
+### 6-Stage Pipeline
+
+```
+Source Scan → ER Diagram → API Analysis → Chain Planning → Test Generation → Failure Analysis
+     │            │             │              │                │                  │
+  ts-morph    Mermaid      Dependency       Topological     Playwright +      Root Cause +
+  parsing     erDiagram    DAG builder      + greedy        AI body/seed      Impact map
+```
+
+## How It Works
+
+### 1. Source Parsing
+
+OpenCroc uses [ts-morph](https://ts-morph.com) to statically analyze your backend:
+
+- **Models**: Extracts table names, column types, indexes, and foreign keys from Sequelize `Model.init()` / TypeORM `@Entity()`
+- **Controllers**: Extracts routes, HTTP methods, path parameters from Express `router.get/post/put/delete`
+- **DTOs**: Extracts validation rules from `@IsString()`, `@IsNumber()`, `@IsOptional()` decorators
+
+### 2. AI Configuration Generation
+
+For each module, OpenCroc calls an LLM (OpenAI / ZhiPu / any OpenAI-compatible API) to generate:
+
+- **Request body templates** — field-accurate POST/PUT payloads
+- **Seed data** — `beforeAll` setup steps with correct API sequences
+- **Parameter mappings** — path parameter aliases (`/:id` → `categoryId`)
+- **ID aliases** — preventing ID conflicts across multi-resource chains
+
+Each config is validated through **3 layers**:
+1. **Schema validation** — JSON structure completeness
+2. **Semantic validation** — field values match source code metadata
+3. **Dry-run validation** — TypeScript compilation check
+
+Failed configs are **automatically fixed** (up to 3 rounds) before being written.
+
+### 3. Log-Driven Completion
+
+Instead of relying on fragile `networkidle` signals:
+
+```
+Frontend Request → Backend api_exec start log → Backend processing → api_exec end log
+                                                                          ↓
+                                              OpenCroc polls end logs to confirm completion
+```
+
+This catches cases where the frontend appears idle but the backend is still processing.
+
+### 4. Self-Healing Loop
+
+```
+Test Failure
+  → AI Attribution (LLM + heuristic fallback)
+  → Generate Fix Patch
+  → Dry-Run Validation
+  → Apply Patch (with backup)
+  → Re-run Failed Tests
+  → Verify Fix
+  → Commit or Rollback
+```
+
+## Configuration
+
+```typescript
+// opencroc.config.ts
+import { defineConfig } from 'opencroc';
+
+export default defineConfig({
+  // Backend source paths
+  backend: {
+    modelsDir: 'src/models',
+    controllersDir: 'src/controllers',
+    servicesDir: 'src/services',
+  },
+
+  // Target application
+  baseUrl: 'http://localhost:3000',
+  apiBaseUrl: 'http://localhost:3000/api',
+
+  // AI configuration
+  ai: {
+    provider: 'openai',        // 'openai' | 'zhipu' | 'custom'
+    apiKey: process.env.AI_API_KEY,
+    model: 'gpt-4o-mini',
+  },
+
+  // Test execution
+  execution: {
+    workers: 4,
+    timeout: 30_000,
+    retries: 1,
+  },
+
+  // Log-driven completion (requires backend instrumentation)
+  logCompletion: {
+    enabled: true,
+    endpoint: '/internal/test-logs',
+    pollIntervalMs: 500,
+    timeoutMs: 10_000,
+  },
+
+  // Self-healing
+  selfHealing: {
+    enabled: false,
+    fixScope: 'config-only',   // 'config-only' | 'config-and-source'
+    maxFixRounds: 3,
+    dryRunFirst: true,
+  },
+});
+```
+
+## Supported Tech Stacks
+
+| Layer | Supported | Planned |
+|---|---|---|
+| **ORM** | Sequelize | TypeORM, Prisma, Drizzle |
+| **Framework** | Express | NestJS, Fastify, Koa |
+| **Test Runner** | Playwright | — |
+| **LLM** | OpenAI, ZhiPu (GLM) | Anthropic, Ollama (local) |
+| **Database** | MySQL, PostgreSQL | SQLite, MongoDB |
+
+## Comparison
+
+| Feature | OpenCroc | Playwright | Metersphere | auto-playwright |
+|---|---|---|---|---|
+| Source-aware generation | ✅ | ❌ | ❌ | ❌ |
+| AI config generation + validation | ✅ | ❌ | ❌ | ❌ |
+| Log-driven completion | ✅ | ❌ | ❌ | ❌ |
+| Failure chain attribution | ✅ | ❌ | Partial | ❌ |
+| Self-healing with rollback | ✅ | ❌ | ❌ | ❌ |
+| API dependency DAG | ✅ | ❌ | ❌ | ❌ |
+| Zero-config test generation | ✅ | Codegen only | Manual | NL→action |
+| Impact blast radius analysis | ✅ | ❌ | ❌ | ❌ |
+
+## Roadmap
+
+- [x] 6-stage source-to-test pipeline
+- [x] AI configuration generation with 3-layer validation
+- [x] Controlled self-healing loop
+- [x] Log-driven completion detection
+- [x] Failure chain attribution + impact analysis
+- [ ] TypeORM / Prisma adapter
+- [ ] NestJS controller parser
+- [ ] Visual dashboard (opencroc.com)
+- [ ] GitHub Actions integration
+- [ ] VS Code extension
+- [ ] Ollama local LLM support
+
+## Documentation
+
+Visit **[opencroc.com](https://opencroc.com)** for full documentation, or browse:
+
+- [Architecture Guide](docs/architecture.md)
+- [Configuration Reference](docs/configuration.md)
+- [Backend Instrumentation Guide](docs/backend-instrumentation.md)
+- [AI Provider Setup](docs/ai-providers.md)
+- [Self-Healing Guide](docs/self-healing.md)
+- [Troubleshooting](docs/troubleshooting.md)
+
+## Contributing
+
+We welcome contributions! See [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines.
+
+## License
+
+[MIT](LICENSE) © 2026 OpenCroc Contributors

package/dist/cli/index.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli/index.js

@@ -0,0 +1,170 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// node_modules/tsup/assets/esm_shims.js
+import path from "path";
+import { fileURLToPath } from "url";
+var init_esm_shims = __esm({
+  "node_modules/tsup/assets/esm_shims.js"() {
+    "use strict";
+  }
+});
+
+// src/cli/commands/init.ts
+var init_exports = {};
+__export(init_exports, {
+  initProject: () => initProject
+});
+import chalk from "chalk";
+import { writeFileSync, mkdirSync, existsSync } from "fs";
+import { join } from "path";
+async function initProject() {
+  const cwd = process.cwd();
+  const configPath = join(cwd, "opencroc.config.ts");
+  if (existsSync(configPath)) {
+    console.log(chalk.yellow("opencroc.config.ts already exists. Skipping."));
+    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("");
+  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 init_init = __esm({
+  "src/cli/commands/init.ts"() {
+    "use strict";
+    init_esm_shims();
+    CONFIG_TEMPLATE = `import { defineConfig } from 'opencroc';
+
+export default defineConfig({
+  backendRoot: './backend',
+  adapter: 'sequelize',
+  llm: {
+    provider: 'openai',
+    model: 'gpt-4o-mini',
+  },
+  selfHealing: {
+    enabled: true,
+    maxIterations: 3,
+  },
+});
+`;
+  }
+});
+
+// src/cli/commands/generate.ts
+var generate_exports = {};
+__export(generate_exports, {
+  generate: () => generate
+});
+import chalk2 from "chalk";
+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);
+}
+var init_generate = __esm({
+  "src/cli/commands/generate.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/cli/commands/test.ts
+var test_exports = {};
+__export(test_exports, {
+  runTests: () => runTests
+});
+import chalk3 from "chalk";
+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);
+}
+var init_test = __esm({
+  "src/cli/commands/test.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/cli/commands/validate.ts
+var validate_exports = {};
+__export(validate_exports, {
+  validate: () => validate
+});
+import chalk4 from "chalk";
+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);
+}
+var init_validate = __esm({
+  "src/cli/commands/validate.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/cli/commands/heal.ts
+var heal_exports = {};
+__export(heal_exports, {
+  heal: () => heal
+});
+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);
+}
+var init_heal = __esm({
+  "src/cli/commands/heal.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// 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.1.0");
+program.command("init").description("Initialize OpenCroc in the current project").action(async () => {
+  const { initProject: initProject2 } = await Promise.resolve().then(() => (init_init(), init_exports));
+  await initProject2();
+});
+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));
+  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) => {
+  const { runTests: runTests2 } = await Promise.resolve().then(() => (init_test(), test_exports));
+  await runTests2(opts);
+});
+program.command("validate").description("Validate module configurations and generated tests").option("-m, --module <name>", "Validate a specific module").action(async (opts) => {
+  const { validate: validate2 } = await Promise.resolve().then(() => (init_validate(), validate_exports));
+  await validate2(opts);
+});
+program.command("heal").description("Run self-healing loop on failed tests").option("-m, --module <name>", "Heal a specific module").option("--max-iterations <n>", "Maximum healing iterations", "3").action(async (opts) => {
+  const { heal: heal2 } = await Promise.resolve().then(() => (init_heal(), heal_exports));
+  await heal2(opts);
+});
+program.parse();
+//# sourceMappingURL=index.js.map

package/dist/cli/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../node_modules/tsup/assets/esm_shims.js","../../src/cli/commands/init.ts","../../src/cli/commands/generate.ts","../../src/cli/commands/test.ts","../../src/cli/commands/validate.ts","../../src/cli/commands/heal.ts","../../src/cli/index.ts"],"sourcesContent":["// Shim globals in esm bundle\nimport path from 'node:path'\nimport { fileURLToPath } from 'node:url'\n\nconst getFilename = () => fileURLToPath(import.meta.url)\nconst getDirname = () => path.dirname(getFilename())\n\nexport const __dirname = /* @__PURE__ */ getDirname()\nexport const __filename = /* @__PURE__ */ getFilename()\n","import chalk from 'chalk';\nimport { writeFileSync, mkdirSync, existsSync } from 'node:fs';\nimport { join } from 'node:path';\n\nconst CONFIG_TEMPLATE = `import { defineConfig } from 'opencroc';\n\nexport default defineConfig({\n  backendRoot: './backend',\n  adapter: 'sequelize',\n  llm: {\n    provider: 'openai',\n    model: 'gpt-4o-mini',\n  },\n  selfHealing: {\n    enabled: true,\n    maxIterations: 3,\n  },\n});\n`;\n\nexport async function initProject(): Promise<void> {\n  const cwd = process.cwd();\n  const configPath = join(cwd, 'opencroc.config.ts');\n\n  if (existsSync(configPath)) {\n    console.log(chalk.yellow('opencroc.config.ts already exists. Skipping.'));\n    return;\n  }\n\n  writeFileSync(configPath, CONFIG_TEMPLATE, 'utf-8');\n  console.log(chalk.green('✓ Created opencroc.config.ts'));\n\n  const outDir = join(cwd, 'opencroc-output');\n  if (!existsSync(outDir)) {\n    mkdirSync(outDir, { recursive: true });\n    console.log(chalk.green('✓ Created opencroc-output/'));\n  }\n\n  console.log('');\n  console.log(chalk.cyan('Next steps:'));\n  console.log('  1. Edit opencroc.config.ts with your project settings');\n  console.log('  2. Run: npx opencroc generate --all');\n  console.log('  3. Run: npx opencroc test');\n}\n","import chalk from 'chalk';\n\ninterface GenerateOptions {\n  module?: string;\n  all?: boolean;\n  steps?: string;\n  dryRun?: boolean;\n}\n\nexport async function generate(opts: GenerateOptions): Promise<void> {\n  console.log(chalk.cyan('🐊 OpenCroc — Generating E2E tests...\\n'));\n\n  // TODO: Load config, create pipeline, and run generation\n  console.log(chalk.yellow('Generation pipeline is under development.'));\n  console.log('Options:', opts);\n}\n","import chalk from 'chalk';\n\ninterface TestOptions {\n  module?: string;\n  headed?: boolean;\n}\n\nexport async function runTests(opts: TestOptions): Promise<void> {\n  console.log(chalk.cyan('🐊 OpenCroc — Running E2E tests...\\n'));\n\n  // TODO: Load config, discover generated tests, and run with Playwright\n  console.log(chalk.yellow('Test runner is under development.'));\n  console.log('Options:', opts);\n}\n","import chalk from 'chalk';\n\ninterface ValidateOptions {\n  module?: string;\n}\n\nexport async function validate(opts: ValidateOptions): Promise<void> {\n  console.log(chalk.cyan('🐊 OpenCroc — Validating configurations...\\n'));\n\n  // TODO: Load config, validate module configs, and report results\n  console.log(chalk.yellow('Validation pipeline is under development.'));\n  console.log('Options:', opts);\n}\n","import chalk from 'chalk';\n\ninterface HealOptions {\n  module?: string;\n  maxIterations?: string;\n}\n\nexport async function heal(opts: HealOptions): Promise<void> {\n  console.log(chalk.cyan('🐊 OpenCroc — Running self-healing loop...\\n'));\n\n  // TODO: Load config, detect failures, and run controlled fix loop\n  console.log(chalk.yellow('Self-healing loop is under development.'));\n  console.log('Options:', opts);\n}\n","#!/usr/bin/env node\n\nimport { Command } from 'commander';\n\nconst program = new Command();\n\nprogram\n  .name('opencroc')\n  .description('AI-native E2E testing framework')\n  .version('0.1.0');\n\nprogram\n  .command('init')\n  .description('Initialize OpenCroc in the current project')\n  .action(async () => {\n    const { initProject } = await import('./commands/init.js');\n    await initProject();\n  });\n\nprogram\n  .command('generate')\n  .description('Generate E2E test cases from source code')\n  .option('-m, --module <name>', 'Generate for a specific module')\n  .option('-a, --all', 'Generate for all discovered modules')\n  .option('--steps <steps>', 'Run specific pipeline steps (comma-separated)')\n  .option('--dry-run', 'Preview without writing files')\n  .action(async (opts) => {\n    const { generate } = await import('./commands/generate.js');\n    await generate(opts);\n  });\n\nprogram\n  .command('test')\n  .description('Run generated E2E tests')\n  .option('-m, --module <name>', 'Run tests for a specific module')\n  .option('--headed', 'Run in headed browser mode')\n  .action(async (opts) => {\n    const { runTests } = await import('./commands/test.js');\n    await runTests(opts);\n  });\n\nprogram\n  .command('validate')\n  .description('Validate module configurations and generated tests')\n  .option('-m, --module <name>', 'Validate a specific module')\n  .action(async (opts) => {\n    const { validate } = await import('./commands/validate.js');\n    await validate(opts);\n  });\n\nprogram\n  .command('heal')\n  .description('Run self-healing loop on failed tests')\n  .option('-m, --module <name>', 'Heal a specific module')\n  .option('--max-iterations <n>', 'Maximum healing iterations', '3')\n  .action(async (opts) => {\n    const { heal } = await import('./commands/heal.js');\n    await heal(opts);\n  });\n\nprogram.parse();\n"],"mappings":";;;;;;;;;;;;AACA,OAAO,UAAU;AACjB,SAAS,qBAAqB;AAF9B;AAAA;AAAA;AAAA;AAAA;;;ACAA;AAAA;AAAA;AAAA;AAAA,OAAO,WAAW;AAClB,SAAS,eAAe,WAAW,kBAAkB;AACrD,SAAS,YAAY;AAkBrB,eAAsB,cAA6B;AACjD,QAAM,MAAM,QAAQ,IAAI;AACxB,QAAM,aAAa,KAAK,KAAK,oBAAoB;AAEjD,MAAI,WAAW,UAAU,GAAG;AAC1B,YAAQ,IAAI,MAAM,OAAO,8CAA8C,CAAC;AACxE;AAAA,EACF;AAEA,gBAAc,YAAY,iBAAiB,OAAO;AAClD,UAAQ,IAAI,MAAM,MAAM,mCAA8B,CAAC;AAEvD,QAAM,SAAS,KAAK,KAAK,iBAAiB;AAC1C,MAAI,CAAC,WAAW,MAAM,GAAG;AACvB,cAAU,QAAQ,EAAE,WAAW,KAAK,CAAC;AACrC,YAAQ,IAAI,MAAM,MAAM,iCAA4B,CAAC;AAAA,EACvD;AAEA,UAAQ,IAAI,EAAE;AACd,UAAQ,IAAI,MAAM,KAAK,aAAa,CAAC;AACrC,UAAQ,IAAI,yDAAyD;AACrE,UAAQ,IAAI,uCAAuC;AACnD,UAAQ,IAAI,6BAA6B;AAC3C;AA3CA,IAIM;AAJN;AAAA;AAAA;AAAA;AAIA,IAAM,kBAAkB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACJxB;AAAA;AAAA;AAAA;AAAA,OAAOA,YAAW;AASlB,eAAsB,SAAS,MAAsC;AACnE,UAAQ,IAAIA,OAAM,KAAK,qDAAyC,CAAC;AAGjE,UAAQ,IAAIA,OAAM,OAAO,2CAA2C,CAAC;AACrE,UAAQ,IAAI,YAAY,IAAI;AAC9B;AAfA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAA;AAAA;AAAA;AAAA;AAAA,OAAOC,YAAW;AAOlB,eAAsB,SAAS,MAAkC;AAC/D,UAAQ,IAAIA,OAAM,KAAK,kDAAsC,CAAC;AAG9D,UAAQ,IAAIA,OAAM,OAAO,mCAAmC,CAAC;AAC7D,UAAQ,IAAI,YAAY,IAAI;AAC9B;AAbA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAA;AAAA;AAAA;AAAA;AAAA,OAAOC,YAAW;AAMlB,eAAsB,SAAS,MAAsC;AACnE,UAAQ,IAAIA,OAAM,KAAK,0DAA8C,CAAC;AAGtE,UAAQ,IAAIA,OAAM,OAAO,2CAA2C,CAAC;AACrE,UAAQ,IAAI,YAAY,IAAI;AAC9B;AAZA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAA;AAAA;AAAA;AAAA;AAAA,OAAOC,YAAW;AAOlB,eAAsB,KAAK,MAAkC;AAC3D,UAAQ,IAAIA,OAAM,KAAK,0DAA8C,CAAC;AAGtE,UAAQ,IAAIA,OAAM,OAAO,yCAAyC,CAAC;AACnE,UAAQ,IAAI,YAAY,IAAI;AAC9B;AAbA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAA;AAEA,SAAS,eAAe;AAExB,IAAM,UAAU,IAAI,QAAQ;AAE5B,QACG,KAAK,UAAU,EACf,YAAY,iCAAiC,EAC7C,QAAQ,OAAO;AAElB,QACG,QAAQ,MAAM,EACd,YAAY,4CAA4C,EACxD,OAAO,YAAY;AAClB,QAAM,EAAE,aAAAC,aAAY,IAAI,MAAM;AAC9B,QAAMA,aAAY;AACpB,CAAC;AAEH,QACG,QAAQ,UAAU,EAClB,YAAY,0CAA0C,EACtD,OAAO,uBAAuB,gCAAgC,EAC9D,OAAO,aAAa,qCAAqC,EACzD,OAAO,mBAAmB,+CAA+C,EACzE,OAAO,aAAa,+BAA+B,EACnD,OAAO,OAAO,SAAS;AACtB,QAAM,EAAE,UAAAC,UAAS,IAAI,MAAM;AAC3B,QAAMA,UAAS,IAAI;AACrB,CAAC;AAEH,QACG,QAAQ,MAAM,EACd,YAAY,yBAAyB,EACrC,OAAO,uBAAuB,iCAAiC,EAC/D,OAAO,YAAY,4BAA4B,EAC/C,OAAO,OAAO,SAAS;AACtB,QAAM,EAAE,UAAAC,UAAS,IAAI,MAAM;AAC3B,QAAMA,UAAS,IAAI;AACrB,CAAC;AAEH,QACG,QAAQ,UAAU,EAClB,YAAY,oDAAoD,EAChE,OAAO,uBAAuB,4BAA4B,EAC1D,OAAO,OAAO,SAAS;AACtB,QAAM,EAAE,UAAAC,UAAS,IAAI,MAAM;AAC3B,QAAMA,UAAS,IAAI;AACrB,CAAC;AAEH,QACG,QAAQ,MAAM,EACd,YAAY,uCAAuC,EACnD,OAAO,uBAAuB,wBAAwB,EACtD,OAAO,wBAAwB,8BAA8B,GAAG,EAChE,OAAO,OAAO,SAAS;AACtB,QAAM,EAAE,MAAAC,MAAK,IAAI,MAAM;AACvB,QAAMA,MAAK,IAAI;AACjB,CAAC;AAEH,QAAQ,MAAM;","names":["chalk","chalk","chalk","chalk","initProject","generate","runTests","validate","heal"]}

package/dist/index.d.ts

@@ -0,0 +1,253 @@
+interface OpenCrocConfig {
+    /** Path to the backend source code root */
+    backendRoot: string;
+    /** Test output directory (default: ./opencroc-output) */
+    outDir?: string;
+    /** Backend adapter: 'sequelize' | 'typeorm' | 'prisma' | custom BackendAdapter */
+    adapter?: string | BackendAdapter;
+    /** LLM provider configuration */
+    llm?: LlmConfig;
+    /** Playwright configuration overrides */
+    playwright?: PlaywrightOverrides;
+    /** Module filter — only process these modules */
+    modules?: string[];
+    /** Pipeline step selection */
+    steps?: PipelineStep[];
+    /** Self-healing configuration */
+    selfHealing?: SelfHealingConfig;
+    /** Report configuration */
+    report?: ReportConfig;
+}
+interface ResolvedConfig extends Required<OpenCrocConfig> {
+    _resolved: true;
+}
+interface LlmConfig {
+    provider: 'openai' | 'zhipu' | 'ollama' | 'custom';
+    apiKey?: string;
+    baseUrl?: string;
+    model?: string;
+    maxTokens?: number;
+    temperature?: number;
+}
+interface PlaywrightOverrides {
+    baseURL?: string;
+    headless?: boolean;
+    timeout?: number;
+}
+interface SelfHealingConfig {
+    enabled?: boolean;
+    maxIterations?: number;
+    mode?: 'config-only' | 'config-and-source';
+}
+interface ReportConfig {
+    format?: ('html' | 'json' | 'markdown')[];
+    outputDir?: string;
+}
+type PipelineStep = 'scan' | 'er-diagram' | 'api-chain' | 'plan' | 'codegen' | 'validate';
+interface ModuleDefinition {
+    name: string;
+    label?: string;
+    modelDir: string;
+    controllerDir: string;
+    associationFile?: string;
+}
+interface RouteEntry {
+    method: string;
+    path: string;
+    handler: string;
+    controllerClass: string;
+}
+interface FieldSchema {
+    name: string;
+    type: string;
+    allowNull?: boolean;
+    defaultValue?: unknown;
+    primaryKey?: boolean;
+    unique?: boolean;
+    comment?: string;
+}
+interface TableSchema {
+    tableName: string;
+    className: string;
+    fields: FieldSchema[];
+    indexes?: IndexSchema[];
+}
+interface IndexSchema {
+    name?: string;
+    unique?: boolean;
+    fields: string[];
+}
+interface ForeignKeyRelation {
+    sourceTable: string;
+    targetTable: string;
+    sourceColumn: string;
+    targetColumn: string;
+    type: 'belongsTo' | 'hasMany' | 'hasOne' | 'belongsToMany';
+}
+interface ApiEndpoint {
+    method: string;
+    path: string;
+    handler: string;
+    module: string;
+    params?: string[];
+    bodyFields?: string[];
+}
+interface ApiDependency {
+    from: ApiEndpoint;
+    to: ApiEndpoint;
+    reason: string;
+}
+interface ERDiagramResult {
+    tables: TableSchema[];
+    relations: ForeignKeyRelation[];
+    mermaidText: string;
+}
+interface TestStep {
+    order: number;
+    action: string;
+    endpoint: ApiEndpoint;
+    description: string;
+    assertions: string[];
+}
+interface TestChain {
+    name: string;
+    module: string;
+    steps: TestStep[];
+}
+interface ChainPlanResult {
+    chains: TestChain[];
+    totalSteps: number;
+}
+interface GeneratedTestFile {
+    filePath: string;
+    content: string;
+    module: string;
+    chain: string;
+}
+interface PipelineRunResult {
+    modules: string[];
+    erDiagrams: Map<string, ERDiagramResult>;
+    chainPlans: Map<string, ChainPlanResult>;
+    generatedFiles: GeneratedTestFile[];
+    validationErrors: ValidationError[];
+    duration: number;
+}
+interface ChainFailureResult {
+    chain: string;
+    failedStep: number;
+    error: string;
+    rootCause?: string;
+    impactedChains: string[];
+}
+interface ImpactReport {
+    affectedModules: string[];
+    affectedChains: string[];
+    affectedEndpoints: ApiEndpoint[];
+    mermaidText: string;
+}
+interface ValidationError {
+    module: string;
+    field: string;
+    message: string;
+    severity: 'error' | 'warning';
+}
+interface BackendAdapter {
+    name: string;
+    parseModels(dir: string): Promise<TableSchema[]>;
+    parseAssociations(file: string): Promise<ForeignKeyRelation[]>;
+    parseControllers(dir: string): Promise<RouteEntry[]>;
+}
+interface LlmProvider {
+    name: string;
+    chat(messages: Array<{
+        role: string;
+        content: string;
+    }>): Promise<string>;
+    estimateTokens(text: string): number;
+}
+
+/**
+ * Define an OpenCroc configuration with type checking.
+ *
+ * @example
+ * ```ts
+ * // opencroc.config.ts
+ * import { defineConfig } from 'opencroc';
+ *
+ * export default defineConfig({
+ *   backendRoot: './backend',
+ *   adapter: 'sequelize',
+ *   llm: {
+ *     provider: 'openai',
+ *     model: 'gpt-4o-mini',
+ *   },
+ * });
+ * ```
+ */
+declare function defineConfig(config: OpenCrocConfig): OpenCrocConfig;
+
+interface Pipeline {
+    run(steps?: PipelineStep[]): Promise<PipelineRunResult>;
+}
+declare function createPipeline(_config: OpenCrocConfig): Pipeline;
+
+interface ModelParser {
+    parseFile(filePath: string): Promise<TableSchema>;
+    parseDirectory(dirPath: string): Promise<TableSchema[]>;
+}
+declare function createModelParser(): ModelParser;
+
+interface ControllerParser {
+    parseFile(filePath: string): Promise<RouteEntry[]>;
+    parseDirectory(dirPath: string): Promise<RouteEntry[]>;
+}
+declare function createControllerParser(): ControllerParser;
+
+interface AssociationParser {
+    parseFile(filePath: string): Promise<ForeignKeyRelation[]>;
+}
+declare function createAssociationParser(): AssociationParser;
+
+interface TestCodeGenerator {
+    generate(chains: TestChain[]): GeneratedTestFile[];
+}
+declare function createTestCodeGenerator(): TestCodeGenerator;
+
+interface MockDataGenerator {
+    generateForTable(schema: TableSchema): Record<string, unknown>;
+    generateForTables(schemas: TableSchema[]): Map<string, Record<string, unknown>[]>;
+}
+declare function createMockDataGenerator(): MockDataGenerator;
+
+interface ERDiagramGenerator {
+    generate(tables: TableSchema[], relations: ForeignKeyRelation[]): ERDiagramResult;
+}
+declare function createERDiagramGenerator(): ERDiagramGenerator;
+
+interface ApiChainAnalyzer {
+    analyze(endpoints: ApiEndpoint[]): {
+        dependencies: ApiDependency[];
+        topologicalOrder: ApiEndpoint[];
+    };
+}
+declare function createApiChainAnalyzer(): ApiChainAnalyzer;
+
+interface ImpactReporter {
+    analyze(failedEndpoints: string[]): Promise<ImpactReport>;
+}
+declare function createImpactReporter(): ImpactReporter;
+
+declare function validateConfig(_config: Record<string, unknown>): ValidationError[];
+
+interface SelfHealingLoop {
+    run(testResultsDir: string): Promise<SelfHealingResult>;
+}
+interface SelfHealingResult {
+    iterations: number;
+    fixed: string[];
+    remaining: string[];
+    totalTokensUsed: number;
+}
+declare function createSelfHealingLoop(_config: SelfHealingConfig): SelfHealingLoop;
+
+export { type ApiDependency, type ApiEndpoint, type BackendAdapter, type ChainFailureResult, type ChainPlanResult, type ERDiagramResult, type FieldSchema, type ForeignKeyRelation, type GeneratedTestFile, type ImpactReport, type LlmProvider, type ModuleDefinition, type OpenCrocConfig, type PipelineRunResult, type ResolvedConfig, type RouteEntry, type TableSchema, type TestChain, type TestStep, createApiChainAnalyzer, createAssociationParser, createControllerParser, createERDiagramGenerator, createImpactReporter, createMockDataGenerator, createModelParser, createPipeline, createSelfHealingLoop, createTestCodeGenerator, defineConfig, validateConfig };

package/dist/index.js

@@ -0,0 +1,123 @@
+// src/config.ts
+function defineConfig(config) {
+  return config;
+}
+
+// src/pipeline/index.ts
+function createPipeline(_config) {
+  return {
+    async run(_steps) {
+      throw new Error("Pipeline not yet implemented");
+    }
+  };
+}
+
+// src/parsers/model-parser.ts
+function createModelParser() {
+  return {
+    async parseFile(_filePath) {
+      throw new Error("Model parser not yet implemented");
+    },
+    async parseDirectory(_dirPath) {
+      throw new Error("Model parser not yet implemented");
+    }
+  };
+}
+
+// src/parsers/controller-parser.ts
+function createControllerParser() {
+  return {
+    async parseFile(_filePath) {
+      throw new Error("Controller parser not yet implemented");
+    },
+    async parseDirectory(_dirPath) {
+      throw new Error("Controller parser not yet implemented");
+    }
+  };
+}
+
+// src/parsers/association-parser.ts
+function createAssociationParser() {
+  return {
+    async parseFile(_filePath) {
+      throw new Error("Association parser not yet implemented");
+    }
+  };
+}
+
+// src/generators/test-code-generator.ts
+function createTestCodeGenerator() {
+  return {
+    generate(_chains) {
+      throw new Error("Test code generator not yet implemented");
+    }
+  };
+}
+
+// src/generators/mock-data-generator.ts
+function createMockDataGenerator() {
+  return {
+    generateForTable(_schema) {
+      throw new Error("Mock data generator not yet implemented");
+    },
+    generateForTables(_schemas) {
+      throw new Error("Mock data generator not yet implemented");
+    }
+  };
+}
+
+// src/generators/er-diagram-generator.ts
+function createERDiagramGenerator() {
+  return {
+    generate(_tables, _relations) {
+      throw new Error("ER diagram generator not yet implemented");
+    }
+  };
+}
+
+// src/analyzers/api-chain-analyzer.ts
+function createApiChainAnalyzer() {
+  return {
+    analyze(_endpoints) {
+      throw new Error("API chain analyzer not yet implemented");
+    }
+  };
+}
+
+// src/analyzers/impact-reporter.ts
+function createImpactReporter() {
+  return {
+    async analyze(_failedEndpoints) {
+      throw new Error("Impact reporter not yet implemented");
+    }
+  };
+}
+
+// src/validators/config-validator.ts
+function validateConfig(_config) {
+  return [];
+}
+
+// src/self-healing/index.ts
+function createSelfHealingLoop(_config) {
+  return {
+    async run(_testResultsDir) {
+      throw new Error("Self-healing loop not yet implemented");
+    }
+  };
+}
+export {
+  createApiChainAnalyzer,
+  createAssociationParser,
+  createControllerParser,
+  createERDiagramGenerator,
+  createImpactReporter,
+  createMockDataGenerator,
+  createModelParser,
+  createPipeline,
+  createSelfHealingLoop,
+  createTestCodeGenerator,
+  defineConfig,
+  validateConfig
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/config.ts","../src/pipeline/index.ts","../src/parsers/model-parser.ts","../src/parsers/controller-parser.ts","../src/parsers/association-parser.ts","../src/generators/test-code-generator.ts","../src/generators/mock-data-generator.ts","../src/generators/er-diagram-generator.ts","../src/analyzers/api-chain-analyzer.ts","../src/analyzers/impact-reporter.ts","../src/validators/config-validator.ts","../src/self-healing/index.ts"],"sourcesContent":["import type { OpenCrocConfig } from './types.js';\n\n/**\n * Define an OpenCroc configuration with type checking.\n *\n * @example\n * ```ts\n * // opencroc.config.ts\n * import { defineConfig } from 'opencroc';\n *\n * export default defineConfig({\n *   backendRoot: './backend',\n *   adapter: 'sequelize',\n *   llm: {\n *     provider: 'openai',\n *     model: 'gpt-4o-mini',\n *   },\n * });\n * ```\n */\nexport function defineConfig(config: OpenCrocConfig): OpenCrocConfig {\n  return config;\n}\n","import type {\n  OpenCrocConfig,\n  PipelineRunResult,\n  PipelineStep,\n} from '../types.js';\n\nexport interface Pipeline {\n  run(steps?: PipelineStep[]): Promise<PipelineRunResult>;\n}\n\nexport function createPipeline(_config: OpenCrocConfig): Pipeline {\n  return {\n    async run(_steps) {\n      // TODO: Implement 6-stage pipeline\n      // 1. Scan — discover modules via adapter\n      // 2. ER Diagram — parse models and generate relationship graphs\n      // 3. API Chain — analyze controller routes and build dependency DAG\n      // 4. Plan — generate test chains with topological ordering\n      // 5. Codegen — emit Playwright test files from chain plans\n      // 6. Validate — run multi-layer validation on generated configs\n      throw new Error('Pipeline not yet implemented');\n    },\n  };\n}\n","import type { TableSchema } from '../types.js';\n\nexport interface ModelParser {\n  parseFile(filePath: string): Promise<TableSchema>;\n  parseDirectory(dirPath: string): Promise<TableSchema[]>;\n}\n\nexport function createModelParser(): ModelParser {\n  return {\n    async parseFile(_filePath) {\n      // TODO: Use ts-morph to parse Sequelize/TypeORM/Prisma model files\n      throw new Error('Model parser not yet implemented');\n    },\n    async parseDirectory(_dirPath) {\n      throw new Error('Model parser not yet implemented');\n    },\n  };\n}\n","import type { RouteEntry } from '../types.js';\n\nexport interface ControllerParser {\n  parseFile(filePath: string): Promise<RouteEntry[]>;\n  parseDirectory(dirPath: string): Promise<RouteEntry[]>;\n}\n\nexport function createControllerParser(): ControllerParser {\n  return {\n    async parseFile(_filePath) {\n      // TODO: Use ts-morph to extract route definitions from controllers\n      throw new Error('Controller parser not yet implemented');\n    },\n    async parseDirectory(_dirPath) {\n      throw new Error('Controller parser not yet implemented');\n    },\n  };\n}\n","import type { ForeignKeyRelation } from '../types.js';\n\nexport interface AssociationParser {\n  parseFile(filePath: string): Promise<ForeignKeyRelation[]>;\n}\n\nexport function createAssociationParser(): AssociationParser {\n  return {\n    async parseFile(_filePath) {\n      // TODO: Use ts-morph to extract association definitions\n      throw new Error('Association parser not yet implemented');\n    },\n  };\n}\n","import type { GeneratedTestFile, TestChain } from '../types.js';\n\nexport interface TestCodeGenerator {\n  generate(chains: TestChain[]): GeneratedTestFile[];\n}\n\nexport function createTestCodeGenerator(): TestCodeGenerator {\n  return {\n    generate(_chains) {\n      // TODO: Generate Playwright test files from chain plans\n      throw new Error('Test code generator not yet implemented');\n    },\n  };\n}\n","import type { TableSchema } from '../types.js';\n\nexport interface MockDataGenerator {\n  generateForTable(schema: TableSchema): Record<string, unknown>;\n  generateForTables(schemas: TableSchema[]): Map<string, Record<string, unknown>[]>;\n}\n\nexport function createMockDataGenerator(): MockDataGenerator {\n  return {\n    generateForTable(_schema) {\n      // TODO: Generate realistic mock data based on field types and constraints\n      throw new Error('Mock data generator not yet implemented');\n    },\n    generateForTables(_schemas) {\n      throw new Error('Mock data generator not yet implemented');\n    },\n  };\n}\n","import type { ERDiagramResult, TableSchema, ForeignKeyRelation } from '../types.js';\n\nexport interface ERDiagramGenerator {\n  generate(tables: TableSchema[], relations: ForeignKeyRelation[]): ERDiagramResult;\n}\n\nexport function createERDiagramGenerator(): ERDiagramGenerator {\n  return {\n    generate(_tables, _relations) {\n      // TODO: Generate Mermaid ER diagram from parsed schemas\n      throw new Error('ER diagram generator not yet implemented');\n    },\n  };\n}\n","import type { ApiEndpoint, ApiDependency } from '../types.js';\n\nexport interface ApiChainAnalyzer {\n  analyze(endpoints: ApiEndpoint[]): {\n    dependencies: ApiDependency[];\n    topologicalOrder: ApiEndpoint[];\n  };\n}\n\nexport function createApiChainAnalyzer(): ApiChainAnalyzer {\n  return {\n    analyze(_endpoints) {\n      // TODO: Build DAG of API dependencies and compute topological sort\n      throw new Error('API chain analyzer not yet implemented');\n    },\n  };\n}\n","import type { ImpactReport } from '../types.js';\n\nexport interface ImpactReporter {\n  analyze(failedEndpoints: string[]): Promise<ImpactReport>;\n}\n\nexport function createImpactReporter(): ImpactReporter {\n  return {\n    async analyze(_failedEndpoints) {\n      // TODO: Trace failure impact through dependency chains\n      throw new Error('Impact reporter not yet implemented');\n    },\n  };\n}\n","import type { ValidationError } from '../types.js';\n\nexport function validateConfig(_config: Record<string, unknown>): ValidationError[] {\n  // TODO: Implement 3-layer validation (schema → semantic → dry-run)\n  return [];\n}\n","import type { SelfHealingConfig } from '../types.js';\n\nexport interface SelfHealingLoop {\n  run(testResultsDir: string): Promise<SelfHealingResult>;\n}\n\nexport interface SelfHealingResult {\n  iterations: number;\n  fixed: string[];\n  remaining: string[];\n  totalTokensUsed: number;\n}\n\nexport function createSelfHealingLoop(_config: SelfHealingConfig): SelfHealingLoop {\n  return {\n    async run(_testResultsDir) {\n      // TODO: Implement the dialog loop:\n      // 1. Parse test failures\n      // 2. Attribute root cause via LLM\n      // 3. Generate controlled fix (config-only or config-and-source)\n      // 4. Re-run tests\n      // 5. Repeat until success or max iterations\n      throw new Error('Self-healing loop not yet implemented');\n    },\n  };\n}\n"],"mappings":";AAoBO,SAAS,aAAa,QAAwC;AACnE,SAAO;AACT;;;ACZO,SAAS,eAAe,SAAmC;AAChE,SAAO;AAAA,IACL,MAAM,IAAI,QAAQ;AAQhB,YAAM,IAAI,MAAM,8BAA8B;AAAA,IAChD;AAAA,EACF;AACF;;;AChBO,SAAS,oBAAiC;AAC/C,SAAO;AAAA,IACL,MAAM,UAAU,WAAW;AAEzB,YAAM,IAAI,MAAM,kCAAkC;AAAA,IACpD;AAAA,IACA,MAAM,eAAe,UAAU;AAC7B,YAAM,IAAI,MAAM,kCAAkC;AAAA,IACpD;AAAA,EACF;AACF;;;ACVO,SAAS,yBAA2C;AACzD,SAAO;AAAA,IACL,MAAM,UAAU,WAAW;AAEzB,YAAM,IAAI,MAAM,uCAAuC;AAAA,IACzD;AAAA,IACA,MAAM,eAAe,UAAU;AAC7B,YAAM,IAAI,MAAM,uCAAuC;AAAA,IACzD;AAAA,EACF;AACF;;;ACXO,SAAS,0BAA6C;AAC3D,SAAO;AAAA,IACL,MAAM,UAAU,WAAW;AAEzB,YAAM,IAAI,MAAM,wCAAwC;AAAA,IAC1D;AAAA,EACF;AACF;;;ACPO,SAAS,0BAA6C;AAC3D,SAAO;AAAA,IACL,SAAS,SAAS;AAEhB,YAAM,IAAI,MAAM,yCAAyC;AAAA,IAC3D;AAAA,EACF;AACF;;;ACNO,SAAS,0BAA6C;AAC3D,SAAO;AAAA,IACL,iBAAiB,SAAS;AAExB,YAAM,IAAI,MAAM,yCAAyC;AAAA,IAC3D;AAAA,IACA,kBAAkB,UAAU;AAC1B,YAAM,IAAI,MAAM,yCAAyC;AAAA,IAC3D;AAAA,EACF;AACF;;;ACXO,SAAS,2BAA+C;AAC7D,SAAO;AAAA,IACL,SAAS,SAAS,YAAY;AAE5B,YAAM,IAAI,MAAM,0CAA0C;AAAA,IAC5D;AAAA,EACF;AACF;;;ACJO,SAAS,yBAA2C;AACzD,SAAO;AAAA,IACL,QAAQ,YAAY;AAElB,YAAM,IAAI,MAAM,wCAAwC;AAAA,IAC1D;AAAA,EACF;AACF;;;ACVO,SAAS,uBAAuC;AACrD,SAAO;AAAA,IACL,MAAM,QAAQ,kBAAkB;AAE9B,YAAM,IAAI,MAAM,qCAAqC;AAAA,IACvD;AAAA,EACF;AACF;;;ACXO,SAAS,eAAe,SAAqD;AAElF,SAAO,CAAC;AACV;;;ACQO,SAAS,sBAAsB,SAA6C;AACjF,SAAO;AAAA,IACL,MAAM,IAAI,iBAAiB;AAOzB,YAAM,IAAI,MAAM,uCAAuC;AAAA,IACzD;AAAA,EACF;AACF;","names":[]}

package/package.json

@@ -0,0 +1,71 @@
+{
+  "name": "opencroc",
+  "version": "0.1.6",
+  "description": "AI-native E2E testing framework — source-aware test generation, intelligent validation, and self-healing",
+  "keywords": [
+    "e2e",
+    "testing",
+    "ai",
+    "playwright",
+    "test-generation",
+    "self-healing",
+    "source-aware"
+  ],
+  "homepage": "https://opencroc.com",
+  "bugs": {
+    "url": "https://github.com/opencroc/opencroc/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/opencroc/opencroc.git"
+  },
+  "license": "MIT",
+  "author": "OpenCroc Contributors",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "bin": {
+    "opencroc": "./dist/cli/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "lint": "eslint src/",
+    "lint:fix": "eslint src/ --fix",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "commander": "^12.1.0",
+    "cosmiconfig": "^9.0.0",
+    "glob": "^10.3.10",
+    "ts-morph": "^22.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.0",
+    "eslint": "^9.0.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.4.0",
+    "vitest": "^1.6.0"
+  },
+  "peerDependencies": {
+    "@playwright/test": ">=1.40.0"
+  },
+  "peerDependenciesMeta": {
+    "@playwright/test": {
+      "optional": false
+    }
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}