@auto-engineer/component-implementor-react 1.102.0 → 1.103.0

package/package.json

@@ -6,13 +6,13 @@
   "dependencies": {
     "ai": "^6.0.0",
     "debug": "^4.4.1",
-    "@auto-engineer/message-bus": "1.102.0",
-    "@auto-engineer/model-factory": "1.102.0"
+    "@auto-engineer/message-bus": "1.103.0",
+    "@auto-engineer/model-factory": "1.103.0"
   },
   "devDependencies": {
     "vitest": "^3.2.1"
   },
-  "version": "1.102.0",
+  "version": "1.103.0",
   "publishConfig": {
     "access": "public"
   },

package/scripts/generate-all.ts

@@ -0,0 +1,673 @@
+import 'dotenv/config';
+import { execSync } from 'node:child_process';
+import {
+  existsSync,
+  readFileSync as fsReadFileSync,
+  mkdirSync,
+  readdirSync,
+  rmSync,
+  statSync,
+  writeFileSync,
+} from 'node:fs';
+import { mkdir } from 'node:fs/promises';
+import path, { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createModelFromEnv } from '@auto-engineer/model-factory';
+import {
+  buildPipelineSteps,
+  type PipelineConfig,
+  type PipelineContext,
+  type PipelineModels,
+  runPipeline,
+} from '../src/pipeline/run-pipeline';
+import { buildFullProjectSection } from '../src/project-context';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const PKG_ROOT = resolve(__dirname, '..');
+const INPUTS_DIR = resolve(PKG_ROOT, 'inputs');
+const OUTPUTS_DIR = resolve(PKG_ROOT, 'outputs');
+const BIOME_SOURCE = resolve(PKG_ROOT, '..', 'generate-react-client', 'starter', 'biome.json');
+
+type ArchitectComponent = {
+  componentId: string;
+  componentName: string;
+  isNew: boolean;
+  atomicType: string;
+  composes?: string[];
+  specDeltas: {
+    structure: string[];
+    rendering: string[];
+    interaction: string[];
+    styling: string[];
+  };
+  props?: Array<{
+    name: string;
+    type: string;
+    required: boolean;
+    default?: string;
+    description: string;
+    category: 'data' | 'callback' | 'slot' | 'visual' | 'state' | 'config';
+  }>;
+  storyVariants?: Array<{
+    name: string;
+    description: string;
+    args: Record<string, unknown>;
+    needsPlayFunction?: boolean;
+    playDescription?: string;
+  }>;
+  dataContract?: Record<string, unknown>;
+};
+
+function log(msg: string) {
+  console.log(`  ${msg}`);
+}
+
+function heading(msg: string) {
+  console.log(`\n${'─'.repeat(60)}`);
+  console.log(`  ${msg}`);
+  console.log(`${'─'.repeat(60)}\n`);
+}
+
+function pascalCase(id: string): string {
+  return id
+    .split('-')
+    .map((s) => s.charAt(0).toUpperCase() + s.slice(1))
+    .join('');
+}
+
+function isUiComponent(id: string): boolean {
+  return id.startsWith('ui-components-');
+}
+
+function uiComponentName(id: string): string {
+  return pascalCase(id.replace('ui-components-', ''));
+}
+
+function componentPath(id: string): string {
+  if (isUiComponent(id)) {
+    return `src/components/ui/${uiComponentName(id)}.tsx`;
+  }
+  return `src/components/${pascalCase(id)}.tsx`;
+}
+
+function filePathToImportAlias(filePath: string): string {
+  let rel = filePath;
+  if (rel.startsWith('./')) {
+    rel = rel.slice(2);
+  }
+  if (rel.startsWith('src/')) {
+    rel = rel.slice(4);
+  }
+  rel = rel.replace(/\.tsx?$/, '');
+  return `@/${rel}`;
+}
+
+function discoverModels(): string[] {
+  if (!existsSync(INPUTS_DIR)) return [];
+
+  return readdirSync(INPUTS_DIR)
+    .filter((entry) => {
+      const entryPath = resolve(INPUTS_DIR, entry);
+      return (
+        entry.startsWith('model-') &&
+        statSync(entryPath).isDirectory() &&
+        existsSync(resolve(entryPath, 'spec-deltas.json'))
+      );
+    })
+    .sort();
+}
+
+function loadSpecDeltas(model: string): ArchitectComponent[] {
+  const filePath = resolve(INPUTS_DIR, model, 'spec-deltas.json');
+  const raw = JSON.parse(fsReadFileSync(filePath, 'utf-8'));
+  return raw as ArchitectComponent[];
+}
+
+function collectUiComponentIds(components: ArchitectComponent[]): Set<string> {
+  const ids = new Set<string>();
+  for (const comp of components) {
+    for (const dep of comp.composes ?? []) {
+      if (isUiComponent(dep)) {
+        ids.add(dep);
+      }
+    }
+    if (isUiComponent(comp.componentId)) {
+      ids.add(comp.componentId);
+    }
+  }
+  return ids;
+}
+
+function topologicalSort(components: ArchitectComponent[]): ArchitectComponent[] {
+  const idToComponent = new Map<string, ArchitectComponent>();
+  for (const comp of components) {
+    idToComponent.set(comp.componentId, comp);
+  }
+
+  const visited = new Set<string>();
+  const sorted: ArchitectComponent[] = [];
+
+  function visit(id: string) {
+    if (visited.has(id)) return;
+    visited.add(id);
+
+    const comp = idToComponent.get(id);
+    if (!comp) return;
+
+    for (const dep of comp.composes ?? []) {
+      if (!isUiComponent(dep) && idToComponent.has(dep)) {
+        visit(dep);
+      }
+    }
+
+    sorted.push(comp);
+  }
+
+  for (const comp of components) {
+    visit(comp.componentId);
+  }
+
+  return sorted;
+}
+
+function getSemanticElement(name: string): { tag: string; selfClosing: boolean; extraProps: string } {
+  const lower = name.toLowerCase();
+  if (lower.includes('button')) return { tag: 'button', selfClosing: false, extraProps: ' type="button"' };
+  if (lower.includes('input') || lower === 'textarea')
+    return { tag: lower === 'textarea' ? 'textarea' : 'input', selfClosing: lower !== 'textarea', extraProps: '' };
+  if (lower.includes('label')) return { tag: 'label', selfClosing: false, extraProps: '' };
+  if (lower.includes('separator') || lower.includes('divider'))
+    return { tag: 'hr', selfClosing: true, extraProps: ' role="separator"' };
+  if (lower.includes('dialog') || lower.includes('modal'))
+    return { tag: 'div', selfClosing: false, extraProps: ' role="dialog"' };
+  if (lower.includes('checkbox')) return { tag: 'input', selfClosing: true, extraProps: ' type="checkbox"' };
+  if (lower.includes('select')) return { tag: 'select', selfClosing: false, extraProps: '' };
+  if (lower.includes('link') || lower.includes('anchor'))
+    return { tag: 'a', selfClosing: false, extraProps: ' href="#"' };
+  if (lower.includes('image') || lower.includes('avatar') || lower.includes('img'))
+    return { tag: 'img', selfClosing: true, extraProps: ' alt="" src=""' };
+  if (lower.includes('heading')) return { tag: 'h2', selfClosing: false, extraProps: '' };
+  if (lower.includes('badge') || lower.includes('chip')) return { tag: 'span', selfClosing: false, extraProps: '' };
+  if (lower.includes('list')) return { tag: 'ul', selfClosing: false, extraProps: '' };
+  if (lower.includes('table')) return { tag: 'table', selfClosing: false, extraProps: '' };
+  if (lower.includes('form')) return { tag: 'form', selfClosing: false, extraProps: '' };
+  if (lower.includes('nav')) return { tag: 'nav', selfClosing: false, extraProps: '' };
+  if (lower.includes('section')) return { tag: 'section', selfClosing: false, extraProps: '' };
+  if (lower.includes('header')) return { tag: 'header', selfClosing: false, extraProps: '' };
+  if (lower.includes('footer')) return { tag: 'footer', selfClosing: false, extraProps: '' };
+  return { tag: 'div', selfClosing: false, extraProps: '' };
+}
+
+function generateUiStub(name: string): string {
+  const { tag, selfClosing, extraProps } = getSemanticElement(name);
+
+  if (selfClosing) {
+    return [
+      `import type React from 'react';`,
+      ``,
+      `export type ${name}Props = {`,
+      `  children?: React.ReactNode;`,
+      `  className?: string;`,
+      `  [key: string]: unknown;`,
+      `};`,
+      ``,
+      `export function ${name}({ className, ...props }: ${name}Props) {`,
+      `  return <${tag} className={className}${extraProps} {...props} />;`,
+      `}`,
+      ``,
+    ].join('\n');
+  }
+
+  return [
+    `import type React from 'react';`,
+    ``,
+    `export type ${name}Props = {`,
+    `  children?: React.ReactNode;`,
+    `  className?: string;`,
+    `  [key: string]: unknown;`,
+    `};`,
+    ``,
+    `export function ${name}({ children, className, ...props }: ${name}Props) {`,
+    `  return <${tag} className={className}${extraProps} {...props}>{children}</${tag}>;`,
+    `}`,
+    ``,
+  ].join('\n');
+}
+
+function scaffoldClientProject(targetDir: string, uiComponentIds: Set<string>) {
+  mkdirSync(resolve(targetDir, 'src/components/ui'), { recursive: true });
+  mkdirSync(resolve(targetDir, 'src/components'), { recursive: true });
+  mkdirSync(resolve(targetDir, 'src/lib'), { recursive: true });
+
+  writeFileSync(
+    resolve(targetDir, 'package.json'),
+    JSON.stringify(
+      {
+        name: 'generated-client',
+        private: true,
+        type: 'module',
+        scripts: {
+          'type-check': 'tsc --noEmit',
+          test: 'vitest run',
+          lint: 'biome check src/',
+          'lint:fix': 'biome check --write src/',
+        },
+        dependencies: {
+          react: '^19.0.0',
+          'react-dom': '^19.0.0',
+          'class-variance-authority': '^0.7.1',
+          clsx: '^2.1.1',
+          'tailwind-merge': '^3.0.0',
+        },
+        devDependencies: {
+          '@biomejs/biome': '2.3.10',
+          '@testing-library/jest-dom': '^6.6.0',
+          '@testing-library/react': '^16.0.0',
+          '@testing-library/user-event': '^14.5.0',
+          '@types/react': '^19.0.0',
+          '@types/react-dom': '^19.0.0',
+          '@storybook/react-vite': '^8.0.0',
+          jsdom: '^25.0.0',
+          typescript: '^5.7.0',
+          vitest: '^3.2.0',
+          tailwindcss: '^4.0.0',
+        },
+      },
+      null,
+      2,
+    ),
+  );
+
+  writeFileSync(
+    resolve(targetDir, 'tsconfig.json'),
+    JSON.stringify(
+      {
+        compilerOptions: {
+          target: 'ES2022',
+          module: 'ESNext',
+          moduleResolution: 'bundler',
+          jsx: 'react-jsx',
+          strict: true,
+          esModuleInterop: true,
+          skipLibCheck: true,
+          outDir: 'dist',
+          rootDir: '.',
+          baseUrl: '.',
+          paths: { '@/*': ['./src/*'] },
+          types: ['vitest/globals'],
+        },
+        include: ['src'],
+      },
+      null,
+      2,
+    ),
+  );
+
+  writeFileSync(
+    resolve(targetDir, 'vitest.config.ts'),
+    [
+      `import { defineConfig } from 'vitest/config';`,
+      `import path from 'path';`,
+      ``,
+      `export default defineConfig({`,
+      `  test: {`,
+      `    environment: 'jsdom',`,
+      `    globals: true,`,
+      `    setupFiles: ['./src/test-setup.ts'],`,
+      `  },`,
+      `  resolve: {`,
+      `    alias: {`,
+      `      '@': path.resolve(__dirname, './src'),`,
+      `    },`,
+      `  },`,
+      `});`,
+      ``,
+    ].join('\n'),
+  );
+
+  writeFileSync(resolve(targetDir, 'src/test-setup.ts'), `import '@testing-library/jest-dom/vitest';\n`);
+
+  writeFileSync(
+    resolve(targetDir, 'src/index.css'),
+    [
+      `@import 'tailwindcss';`,
+      ``,
+      `@theme {`,
+      `  --color-background: #ffffff;`,
+      `  --color-foreground: #0a0a0a;`,
+      `  --color-primary: #171717;`,
+      `  --color-primary-foreground: #fafafa;`,
+      `  --color-secondary: #f5f5f5;`,
+      `  --color-secondary-foreground: #171717;`,
+      `  --color-muted: #f5f5f5;`,
+      `  --color-muted-foreground: #737373;`,
+      `  --color-accent: #f5f5f5;`,
+      `  --color-accent-foreground: #171717;`,
+      `  --color-destructive: #ef4444;`,
+      `  --color-destructive-foreground: #fafafa;`,
+      `  --color-border: #e5e5e5;`,
+      `  --color-input: #e5e5e5;`,
+      `  --color-ring: #171717;`,
+      `  --color-popover: #ffffff;`,
+      `  --color-popover-foreground: #0a0a0a;`,
+      `  --color-card: #ffffff;`,
+      `  --color-card-foreground: #0a0a0a;`,
+      `  --radius-sm: 0.25rem;`,
+      `  --radius-md: 0.375rem;`,
+      `  --radius-lg: 0.5rem;`,
+      `}`,
+      ``,
+    ].join('\n'),
+  );
+
+  writeFileSync(
+    resolve(targetDir, 'src/lib/utils.ts'),
+    [
+      `import { type ClassValue, clsx } from 'clsx';`,
+      `import { twMerge } from 'tailwind-merge';`,
+      ``,
+      `export function cn(...inputs: ClassValue[]) {`,
+      `  return twMerge(clsx(inputs));`,
+      `}`,
+      ``,
+    ].join('\n'),
+  );
+
+  if (existsSync(BIOME_SOURCE)) {
+    const biomeConfig = JSON.parse(fsReadFileSync(BIOME_SOURCE, 'utf-8'));
+    biomeConfig.vcs = { enabled: false };
+    writeFileSync(resolve(targetDir, 'biome.json'), JSON.stringify(biomeConfig, null, '\t'));
+  }
+
+  for (const uiId of uiComponentIds) {
+    const name = uiComponentName(uiId);
+    const stubPath = resolve(targetDir, 'src/components/ui', `${name}.tsx`);
+    writeFileSync(stubPath, generateUiStub(name));
+  }
+
+  const barrelLines: string[] = [];
+  for (const uiId of [...uiComponentIds].sort()) {
+    const name = uiComponentName(uiId);
+    barrelLines.push(`export { ${name} } from './${name}';`);
+    barrelLines.push(`export type { ${name}Props } from './${name}';`);
+  }
+  writeFileSync(resolve(targetDir, 'src/components/ui/index.ts'), `${barrelLines.join('\n')}\n`);
+}
+
+function buildPipelineConfig(): PipelineConfig {
+  return {
+    models: {
+      generateTest:
+        process.env.STEP_GENERATE_TEST_MODEL ??
+        process.env.IMPL_MODEL ??
+        process.env.CUSTOM_PROVIDER_DEFAULT_MODEL ??
+        '',
+      generateComponent:
+        process.env.STEP_GENERATE_COMPONENT_MODEL ??
+        process.env.IMPL_MODEL ??
+        process.env.CUSTOM_PROVIDER_DEFAULT_MODEL ??
+        '',
+      typeFixer:
+        process.env.STEP_TYPE_FIXER_MODEL ??
+        process.env.IMPL_FIXER_MODEL ??
+        process.env.IMPL_MODEL ??
+        process.env.CUSTOM_PROVIDER_DEFAULT_MODEL ??
+        '',
+      testFixer:
+        process.env.STEP_TEST_FIXER_MODEL ??
+        process.env.IMPL_FIXER_MODEL ??
+        process.env.IMPL_MODEL ??
+        process.env.CUSTOM_PROVIDER_DEFAULT_MODEL ??
+        '',
+      lintFixer:
+        process.env.STEP_LINT_FIXER_MODEL ??
+        process.env.IMPL_FIXER_MODEL ??
+        process.env.IMPL_MODEL ??
+        process.env.CUSTOM_PROVIDER_DEFAULT_MODEL ??
+        '',
+      storyFixer:
+        process.env.STEP_STORY_FIXER_MODEL ??
+        process.env.IMPL_FIXER_MODEL ??
+        process.env.IMPL_MODEL ??
+        process.env.CUSTOM_PROVIDER_DEFAULT_MODEL ??
+        '',
+    },
+    maxTypeFixIterations: 3,
+    maxTestFixIterations: 5,
+    maxLintFixIterations: 3,
+    maxStoryFixIterations: 2,
+    enableStorybookTest: process.env.ENABLE_STORYBOOK_TEST === 'true',
+    enableVisualTest: process.env.ENABLE_VISUAL_TEST === 'true',
+  };
+}
+
+type ComponentResult = {
+  componentId: string;
+  success: boolean;
+  error?: string;
+  llmCalls: number;
+  fixIterations: number;
+  typeFixIterations: number;
+  testFixIterations: number;
+  lintFixIterations: number;
+  storyFixIterations: number;
+};
+
+async function generateModel(model: string): Promise<ComponentResult[]> {
+  heading(`Model: ${model}`);
+
+  const allComponents = loadSpecDeltas(model);
+  log(`Loaded ${allComponents.length} total specs from spec-deltas.json`);
+
+  const components = allComponents.filter((c) => !isUiComponent(c.componentId));
+  log(
+    `${components.length} components to generate (${allComponents.length - components.length} ui-component stubs excluded)`,
+  );
+
+  const uiComponentIds = collectUiComponentIds(allComponents);
+  log(`${uiComponentIds.size} ui-component stubs to scaffold`);
+
+  const targetDir = resolve(OUTPUTS_DIR, model, 'client');
+
+  if (existsSync(targetDir)) {
+    rmSync(targetDir, { recursive: true, force: true });
+  }
+
+  scaffoldClientProject(targetDir, uiComponentIds);
+  log(`Scaffolded client project at ${targetDir}`);
+
+  log('Installing dependencies...');
+  execSync('pnpm install --ignore-workspace --no-frozen-lockfile', { cwd: targetDir, stdio: 'pipe' });
+  log('Dependencies installed');
+
+  const sorted = topologicalSort(components);
+  log(`Generation order: ${sorted.map((c) => c.componentId).join(' → ')}`);
+
+  const llmModel = createModelFromEnv();
+  const pipelineModels: PipelineModels = {
+    generateTest: llmModel,
+    generateComponent: llmModel,
+    typeFixer: llmModel,
+    testFixer: llmModel,
+    lintFixer: llmModel,
+    storyFixer: llmModel,
+  };
+  const pipelineConfig = buildPipelineConfig();
+
+  const results: ComponentResult[] = [];
+
+  for (const comp of sorted) {
+    const startTime = Date.now();
+    log(`\n  ── ${comp.componentId} ──`);
+
+    const componentName = pascalCase(comp.componentId);
+    const rawPath = `src/components/${componentName}.tsx`;
+    const compPath = componentPath(comp.componentId);
+    const storyPath = compPath.replace('.tsx', '.stories.tsx');
+    const compFullPath = path.resolve(targetDir, compPath);
+    const testFullPath = path.join(path.dirname(compFullPath), `${componentName}.test.tsx`);
+    const storyFullPath = path.resolve(targetDir, storyPath);
+    const componentImportPath = filePathToImportAlias(rawPath);
+
+    const composesResolved = (comp.composes ?? []).map((depId) => ({
+      id: depId,
+      path: componentPath(depId),
+    }));
+
+    const projectSection = await buildFullProjectSection(targetDir, composesResolved);
+    await mkdir(path.dirname(testFullPath), { recursive: true });
+
+    const ctx: PipelineContext = {
+      componentName,
+      componentPath: compFullPath,
+      testPath: testFullPath,
+      storyPath: storyFullPath,
+      componentImportPath,
+      targetDir,
+      specDeltas: {
+        structure: comp.specDeltas.structure,
+        rendering: comp.specDeltas.rendering,
+        interaction: comp.specDeltas.interaction,
+        styling: comp.specDeltas.styling,
+      },
+      projectSection,
+      props: comp.props,
+      composes: composesResolved,
+      isModify: false,
+      storyVariants: comp.storyVariants,
+      llmCalls: 0,
+      fixIterations: 0,
+      typeFixIterations: 0,
+      testFixIterations: 0,
+      lintFixIterations: 0,
+      storyFixIterations: 0,
+    };
+
+    const steps = buildPipelineSteps(pipelineModels, pipelineConfig, ctx);
+
+    try {
+      const result = await runPipeline(steps, ctx);
+      const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
+
+      if (result.success) {
+        log(`  ✓ ${componentName} (${elapsed}s) [llm=${result.llmCalls} fix=${result.fixIterations}]`);
+      } else {
+        log(`  ✗ ${componentName}: ${result.error} (${elapsed}s)`);
+      }
+
+      results.push({
+        componentId: comp.componentId,
+        success: result.success,
+        error: result.error,
+        llmCalls: result.llmCalls,
+        fixIterations: result.fixIterations,
+        typeFixIterations: result.typeFixIterations,
+        testFixIterations: result.testFixIterations,
+        lintFixIterations: result.lintFixIterations,
+        storyFixIterations: result.storyFixIterations,
+      });
+    } catch (error) {
+      const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      log(`  ✗ ${componentName}: ${errorMessage} (${elapsed}s)`);
+      results.push({
+        componentId: comp.componentId,
+        success: false,
+        error: errorMessage,
+        llmCalls: ctx.llmCalls,
+        fixIterations: ctx.fixIterations,
+        typeFixIterations: ctx.typeFixIterations,
+        testFixIterations: ctx.testFixIterations,
+        lintFixIterations: ctx.lintFixIterations,
+        storyFixIterations: ctx.storyFixIterations,
+      });
+    }
+  }
+
+  return results;
+}
+
+function printSummary(allResults: Map<string, ComponentResult[]>) {
+  console.log('\n');
+  console.log('╔══════════════════════════════════════════════════╗');
+  console.log('║           Generation Summary                     ║');
+  console.log('╚══════════════════════════════════════════════════╝');
+
+  let totalComponents = 0;
+  let totalSuccess = 0;
+
+  for (const [model, results] of allResults) {
+    const succeeded = results.filter((r) => r.success).length;
+    const failed = results.filter((r) => !r.success).length;
+    totalComponents += results.length;
+    totalSuccess += succeeded;
+
+    console.log(`\n  ${model}: ${succeeded}/${results.length} succeeded, ${failed} failed`);
+
+    for (const r of results) {
+      const status = r.success ? '✓' : '✗';
+      const metrics = `llm=${r.llmCalls} fix=${r.fixIterations} (type=${r.typeFixIterations} test=${r.testFixIterations} lint=${r.lintFixIterations} story=${r.storyFixIterations})`;
+      const error = r.error ? ` — ${r.error.slice(0, 80)}` : '';
+      console.log(`    ${status} ${r.componentId} [${metrics}]${error}`);
+    }
+  }
+
+  console.log(`\n  Total: ${totalSuccess}/${totalComponents} components succeeded`);
+  console.log('');
+}
+
+async function main() {
+  const agentModel = process.env.CUSTOM_PROVIDER_DEFAULT_MODEL ?? 'unknown';
+  const providerName = process.env.CUSTOM_PROVIDER_NAME ?? 'unknown';
+
+  const args = process.argv.slice(2);
+  const modelArgIndex = args.indexOf('--model');
+  const singleModel = modelArgIndex !== -1 ? args[modelArgIndex + 1] : undefined;
+
+  console.log('');
+  console.log('╔══════════════════════════════════════════════════╗');
+  console.log('║   Component Implementor — Generate All Models    ║');
+  console.log('╠══════════════════════════════════════════════════╣');
+  console.log(`║   Model:    ${agentModel.padEnd(37)}║`);
+  console.log(`║   Provider: ${providerName.padEnd(37)}║`);
+  if (singleModel) {
+    console.log(`║   Filter:   ${singleModel.padEnd(37)}║`);
+  }
+  console.log('╚══════════════════════════════════════════════════╝');
+
+  const allModels = discoverModels();
+
+  if (allModels.length === 0) {
+    console.error('\n  ERROR: No models found in inputs/');
+    console.error('  Expected: inputs/model-a/spec-deltas.json');
+    process.exit(1);
+  }
+
+  const models = singleModel ? allModels.filter((m) => m === singleModel) : allModels;
+
+  if (models.length === 0) {
+    console.error(`\n  ERROR: Model "${singleModel}" not found in inputs/`);
+    console.error(`  Available: ${allModels.join(', ')}`);
+    process.exit(1);
+  }
+
+  log(`Running ${models.length} model(s): ${models.join(', ')}`);
+
+  const allResults = new Map<string, ComponentResult[]>();
+
+  for (const model of models) {
+    const results = await generateModel(model);
+    allResults.set(model, results);
+
+    const summaryPath = resolve(OUTPUTS_DIR, model, 'results.json');
+    writeFileSync(summaryPath, JSON.stringify(results, null, 2));
+  }
+
+  printSummary(allResults);
+}
+
+main().catch((err) => {
+  console.error('Fatal error:', err);
+  process.exit(1);
+});