voidforge-build 23.11.0 → 23.11.2

package/dist/wizard/lib/asset-scanner.js

@@ -1,107 +0,0 @@
-/**
- * PRD asset scanner — identifies image/visual requirements from PRD prose.
- * Used by Celebrimbor's /imagine command to find what needs generating.
- * Pure text analysis — no API calls, no side effects.
- */
-/** Patterns that indicate a visual asset requirement in PRD prose. */
-const ASSET_PATTERNS = [
-    { pattern: /illustrat(?:ion|ed|e)/i, category: 'illustration' },
-    { pattern: /portrait/i, category: 'portrait' },
-    { pattern: /silhouette/i, category: 'portrait' },
-    { pattern: /avatar/i, category: 'portrait' },
-    { pattern: /(?:custom\s+)?\bicon\b/i, category: 'icon' },
-    { pattern: /og[:\s-]image/i, category: 'og-image' },
-    { pattern: /social\s+(?:sharing\s+)?image/i, category: 'og-image' },
-    { pattern: /hero\s+(?:image|banner|art)/i, category: 'hero' },
-    { pattern: /splash\s+(?:page|screen)/i, category: 'hero' },
-    { pattern: /background\s+image/i, category: 'background' },
-    { pattern: /cover\s+image/i, category: 'background' },
-    { pattern: /\blogo\b/i, category: 'logo' },
-    { pattern: /\bfavicon\b/i, category: 'icon' },
-    { pattern: /comic\s+strip/i, category: 'illustration' },
-    { pattern: /comic\s+panel/i, category: 'illustration' },
-    { pattern: /screenshot/i, category: 'screenshot' },
-    { pattern: /mockup/i, category: 'screenshot' },
-];
-/** Default dimensions per asset category. */
-const CATEGORY_DIMENSIONS = {
-    'portrait': { width: 1024, height: 1024 },
-    'illustration': { width: 1024, height: 1024 },
-    'og-image': { width: 1200, height: 630 },
-    'hero': { width: 1792, height: 1024 },
-    'background': { width: 1792, height: 1024 },
-    'logo': { width: 512, height: 512 },
-    'icon': { width: 512, height: 512 },
-    'screenshot': { width: 1280, height: 720 },
-};
-/**
- * Scan a PRD document for visual asset requirements.
- * Returns a list of assets that need generating.
- */
-export function scanPrdForAssets(prdContent) {
-    const assets = [];
-    const lines = prdContent.split('\n');
-    let currentSection = '';
-    for (let i = 0; i < lines.length; i++) {
-        const line = lines[i];
-        // Track section headers
-        const headerMatch = line.match(/^#{1,4}\s+(.+)/);
-        if (headerMatch) {
-            currentSection = headerMatch[1].trim();
-            continue;
-        }
-        // Check each line against asset patterns
-        for (const { pattern, category } of ASSET_PATTERNS) {
-            if (pattern.test(line)) {
-                // Extract surrounding context (current line + next line for description)
-                const contextLines = lines.slice(Math.max(0, i - 1), Math.min(lines.length, i + 3));
-                const context = contextLines.join(' ').trim();
-                const dims = CATEGORY_DIMENSIONS[category] || { width: 1024, height: 1024 };
-                assets.push({
-                    description: line.trim(),
-                    category,
-                    context,
-                    width: dims.width,
-                    height: dims.height,
-                    section: currentSection,
-                });
-                break; // One match per line is enough
-            }
-        }
-    }
-    // Deduplicate by description similarity
-    const seen = new Set();
-    return assets.filter(a => {
-        const key = a.description.toLowerCase().slice(0, 60);
-        if (seen.has(key))
-            return false;
-        seen.add(key);
-        return true;
-    });
-}
-/**
- * Extract brand/style keywords from the PRD for style prefix generation.
- * Looks for Section 14 (Brand) or any section mentioning "brand", "style", "aesthetic".
- */
-export function extractBrandStyle(prdContent) {
-    const keywords = [];
-    const lines = prdContent.split('\n');
-    let inBrandSection = false;
-    for (const line of lines) {
-        const headerMatch = line.match(/^#{1,4}\s+(.+)/);
-        if (headerMatch) {
-            const title = headerMatch[1].toLowerCase();
-            inBrandSection = title.includes('brand') || title.includes('style') || title.includes('aesthetic') || title.includes('design') || title.includes('personality');
-            continue;
-        }
-        if (inBrandSection && line.trim()) {
-            // Extract adjectives and style keywords
-            const styleWords = line.match(/\b(minimal|bold|playful|professional|elegant|modern|retro|vintage|comic|pulp|neon|dark|light|cinematic|warm|cool|vibrant|muted|halftone|watercolor|photorealistic|illustration|flat|gradient|geometric|organic)\b/gi);
-            if (styleWords) {
-                keywords.push(...styleWords.map(w => w.toLowerCase()));
-            }
-        }
-    }
-    // Deduplicate
-    return [...new Set(keywords)];
-}

package/dist/wizard/lib/build-analytics.d.ts

@@ -1,39 +0,0 @@
-/**
- * Build analytics — tracks metrics across projects for trend analysis.
- * Stored at ~/.voidforge/analytics.json. No external dependencies.
- *
- * Wong guards the knowledge. The Sanctum grows.
- */
-export interface PhaseMetric {
-    phase: string;
-    findingsCount: number;
-    fixesApplied: number;
-    /** Duration in seconds (optional — only if measurable) */
-    durationSeconds?: number;
-}
-export interface BuildRecord {
-    projectName: string;
-    framework: string;
-    database: string;
-    deployTarget: string;
-    timestamp: string;
-    version: string;
-    phases: PhaseMetric[];
-    totalFindings: number;
-    totalFixes: number;
-    testCount?: number;
-    lessonsExtracted: number;
-}
-export interface AnalyticsStore {
-    builds: BuildRecord[];
-}
-/** Record a completed build. */
-export declare function recordBuild(record: BuildRecord): Promise<void>;
-/** Surface trends across past builds. Returns human-readable insights. */
-export declare function surfaceTrends(currentFramework?: string): Promise<string[]>;
-/** Get a summary of all recorded builds. */
-export declare function getBuildHistory(): Promise<{
-    count: number;
-    frameworks: string[];
-    latestBuild: string | null;
-}>;

package/dist/wizard/lib/build-analytics.js

@@ -1,91 +0,0 @@
-/**
- * Build analytics — tracks metrics across projects for trend analysis.
- * Stored at ~/.voidforge/analytics.json. No external dependencies.
- *
- * Wong guards the knowledge. The Sanctum grows.
- */
-import { readFile, writeFile, mkdir } from 'node:fs/promises';
-import { join } from 'node:path';
-import { homedir } from 'node:os';
-const ANALYTICS_DIR = join(homedir(), '.voidforge');
-const ANALYTICS_FILE = join(ANALYTICS_DIR, 'analytics.json');
-async function ensureDir() {
-    try {
-        await mkdir(ANALYTICS_DIR, { recursive: true });
-    }
-    catch { /* exists */ }
-}
-async function loadStore() {
-    try {
-        const raw = await readFile(ANALYTICS_FILE, 'utf-8');
-        return JSON.parse(raw);
-    }
-    catch {
-        return { builds: [] };
-    }
-}
-async function saveStore(store) {
-    await ensureDir();
-    await writeFile(ANALYTICS_FILE, JSON.stringify(store, null, 2), 'utf-8');
-}
-/** Record a completed build. */
-export async function recordBuild(record) {
-    const store = await loadStore();
-    store.builds.push(record);
-    // Keep last 100 builds to prevent unbounded growth
-    if (store.builds.length > 100) {
-        store.builds = store.builds.slice(-100);
-    }
-    await saveStore(store);
-}
-/** Surface trends across past builds. Returns human-readable insights. */
-export async function surfaceTrends(currentFramework) {
-    const store = await loadStore();
-    const builds = store.builds;
-    if (builds.length < 2)
-        return [];
-    const insights = [];
-    // Finding hotspots — which phases consistently produce the most findings?
-    const phaseFindings = {};
-    for (const build of builds) {
-        for (const phase of build.phases) {
-            if (!phaseFindings[phase.phase])
-                phaseFindings[phase.phase] = [];
-            phaseFindings[phase.phase].push(phase.findingsCount);
-        }
-    }
-    for (const [phase, counts] of Object.entries(phaseFindings)) {
-        const avg = counts.reduce((a, b) => a + b, 0) / counts.length;
-        if (avg > 5 && counts.length >= 2) {
-            insights.push(`Phase "${phase}" averages ${avg.toFixed(1)} findings across ${counts.length} builds — consider proactive checks in earlier phases.`);
-        }
-    }
-    // Framework-specific patterns
-    if (currentFramework) {
-        const frameworkBuilds = builds.filter(b => b.framework === currentFramework);
-        if (frameworkBuilds.length >= 2) {
-            const avgFindings = frameworkBuilds.reduce((a, b) => a + b.totalFindings, 0) / frameworkBuilds.length;
-            insights.push(`Your ${currentFramework} projects average ${avgFindings.toFixed(0)} findings per build (${frameworkBuilds.length} builds).`);
-        }
-    }
-    // Fix-to-finding ratio trend
-    const ratios = builds.map(b => b.totalFindings > 0 ? b.totalFixes / b.totalFindings : 1);
-    const recentRatios = ratios.slice(-5);
-    const avgRatio = recentRatios.reduce((a, b) => a + b, 0) / recentRatios.length;
-    if (avgRatio < 0.8) {
-        insights.push(`Fix-to-finding ratio is ${(avgRatio * 100).toFixed(0)}% — some findings are being deferred. Consider addressing all findings in each build.`);
-    }
-    // Lessons trend
-    const totalLessons = builds.reduce((a, b) => a + b.lessonsExtracted, 0);
-    if (totalLessons > 0) {
-        insights.push(`${totalLessons} lessons extracted across ${builds.length} builds. The forge is learning.`);
-    }
-    return insights;
-}
-/** Get a summary of all recorded builds. */
-export async function getBuildHistory() {
-    const store = await loadStore();
-    const frameworks = [...new Set(store.builds.map(b => b.framework))];
-    const latest = store.builds.length > 0 ? store.builds[store.builds.length - 1].timestamp : null;
-    return { count: store.builds.length, frameworks, latestBuild: latest };
-}

package/dist/wizard/lib/codegen/erd-gen.d.ts

@@ -1,16 +0,0 @@
-/**
- * Database ERD generation from Prisma schema (ADR-025).
- * Parses prisma/schema.prisma and produces a Mermaid entity-relationship diagram.
- * Conditional — only runs if prisma/schema.prisma exists.
- */
-import type { ProvisionEmitter } from '../provisioners/types.js';
-export interface ERDResult {
-    success: boolean;
-    file: string;
-    modelCount: number;
-    error?: string;
-}
-/**
- * Generate a Mermaid ERD from the Prisma schema.
- */
-export declare function generateERD(projectDir: string, emit: ProvisionEmitter): Promise<ERDResult>;

package/dist/wizard/lib/codegen/erd-gen.js

@@ -1,98 +0,0 @@
-/**
- * Database ERD generation from Prisma schema (ADR-025).
- * Parses prisma/schema.prisma and produces a Mermaid entity-relationship diagram.
- * Conditional — only runs if prisma/schema.prisma exists.
- */
-import { existsSync } from 'node:fs';
-import { join } from 'node:path';
-import { readFile, writeFile, mkdir } from 'node:fs/promises';
-/**
- * Minimal Prisma schema parser — extracts model names and fields.
- * Not a full parser — handles the common cases for ERD generation.
- */
-function parsePrismaSchema(content) {
-    const models = [];
-    const modelRegex = /model\s+(\w+)\s*\{([^}]+)\}/g;
-    let match;
-    while ((match = modelRegex.exec(content)) !== null) {
-        const name = match[1];
-        const body = match[2];
-        const fields = [];
-        for (const line of body.split('\n')) {
-            const trimmed = line.trim();
-            if (!trimmed || trimmed.startsWith('//') || trimmed.startsWith('@@'))
-                continue;
-            const fieldMatch = trimmed.match(/^(\w+)\s+(\w+)(\[\])?\s*(\?)?\s*/);
-            if (fieldMatch) {
-                const fieldName = fieldMatch[1];
-                const fieldType = fieldMatch[2];
-                const isArray = !!fieldMatch[3];
-                const isOptional = !!fieldMatch[4];
-                // Skip Prisma directives like @id, @default, etc. — those are on the same line
-                const builtinTypes = ['String', 'Int', 'Float', 'Boolean', 'DateTime', 'Json', 'BigInt', 'Decimal', 'Bytes'];
-                const isRelation = !builtinTypes.includes(fieldType);
-                fields.push({ name: fieldName, type: fieldType, isRelation, isOptional, isArray });
-            }
-        }
-        models.push({ name, fields });
-    }
-    return models;
-}
-function generateMermaidERD(models) {
-    const lines = [
-        '```mermaid',
-        'erDiagram',
-    ];
-    // Generate entity definitions
-    for (const model of models) {
-        lines.push(`    ${model.name} {`);
-        for (const field of model.fields) {
-            if (!field.isRelation) {
-                const optional = field.isOptional ? '?' : '';
-                lines.push(`        ${field.type}${optional} ${field.name}`);
-            }
-        }
-        lines.push('    }');
-    }
-    // Generate relationships
-    for (const model of models) {
-        for (const field of model.fields) {
-            if (field.isRelation) {
-                const cardinality = field.isArray ? '}o--||' : '}o--o|';
-                lines.push(`    ${model.name} ${cardinality} ${field.type} : "${field.name}"`);
-            }
-        }
-    }
-    lines.push('```');
-    return lines.join('\n');
-}
-/**
- * Generate a Mermaid ERD from the Prisma schema.
- */
-export async function generateERD(projectDir, emit) {
-    const schemaPath = join(projectDir, 'prisma', 'schema.prisma');
-    if (!existsSync(schemaPath)) {
-        emit({ step: 'erd', status: 'skipped', message: 'No prisma/schema.prisma found — ERD generation skipped' });
-        return { success: true, file: '', modelCount: 0 };
-    }
-    emit({ step: 'erd', status: 'started', message: 'Generating database ERD from Prisma schema' });
-    try {
-        const schema = await readFile(schemaPath, 'utf-8');
-        const models = parsePrismaSchema(schema);
-        if (models.length === 0) {
-            emit({ step: 'erd', status: 'skipped', message: 'No models found in Prisma schema' });
-            return { success: true, file: '', modelCount: 0 };
-        }
-        const mermaid = generateMermaidERD(models);
-        const content = `# Database Schema\n\nAuto-generated from \`prisma/schema.prisma\` by VoidForge (ADR-025).\n\n${mermaid}\n`;
-        const docsDir = join(projectDir, 'docs');
-        await mkdir(docsDir, { recursive: true });
-        await writeFile(join(docsDir, 'schema.md'), content, 'utf-8');
-        emit({ step: 'erd', status: 'done', message: `Generated docs/schema.md — ${models.length} models mapped` });
-        return { success: true, file: 'docs/schema.md', modelCount: models.length };
-    }
-    catch (err) {
-        emit({ step: 'erd', status: 'error', message: 'Failed to generate ERD', detail: err.message });
-        return { success: false, file: '', modelCount: 0, error: err.message };
-    }
-}

package/dist/wizard/lib/codegen/openapi-gen.d.ts

@@ -1,15 +0,0 @@
-/**
- * OpenAPI/Swagger spec generation (ADR-025).
- * Generates a starter OpenAPI spec from framework conventions.
- * Framework-aware: Express, Next.js API routes.
- */
-import type { ProvisionEmitter } from '../provisioners/types.js';
-export interface OpenAPIResult {
-    success: boolean;
-    file: string;
-    error?: string;
-}
-/**
- * Generate an OpenAPI spec file for the project.
- */
-export declare function generateOpenAPIDoc(projectDir: string, projectName: string, framework: string, emit: ProvisionEmitter): Promise<OpenAPIResult>;

package/dist/wizard/lib/codegen/openapi-gen.js

@@ -1,79 +0,0 @@
-/**
- * OpenAPI/Swagger spec generation (ADR-025).
- * Generates a starter OpenAPI spec from framework conventions.
- * Framework-aware: Express, Next.js API routes.
- */
-import { writeFile, mkdir } from 'node:fs/promises';
-import { join } from 'node:path';
-function generateOpenAPISpec(projectName, framework) {
-    const isNextjs = framework === 'next.js';
-    // Strip YAML-unsafe characters — only allow alphanumeric, spaces, hyphens, underscores
-    const safeName = projectName.replace(/[^a-zA-Z0-9 _-]/g, '').slice(0, 100) || 'My Project';
-    return `# OpenAPI Specification
-# Generated by VoidForge (ADR-025)
-# Edit this file to document your API endpoints
-# Serve with: npx swagger-ui-express (Express) or next-swagger-doc (Next.js)
-
-openapi: "3.1.0"
-info:
-  title: "${safeName} API"
-  version: "1.0.0"
-  description: "API documentation for ${safeName}"
-
-servers:
-  - url: http://localhost:${isNextjs ? '3000' : '3001'}
-    description: Development server
-
-paths:
-  /api/health:
-    get:
-      summary: Health check
-      responses:
-        "200":
-          description: Service is healthy
-          content:
-            application/json:
-              schema:
-                type: object
-                properties:
-                  status:
-                    type: string
-                    example: "ok"
-                  timestamp:
-                    type: string
-                    format: date-time
-
-  # Add your API endpoints below
-  # Example:
-  # /api/users:
-  #   get:
-  #     summary: List users
-  #     parameters:
-  #       - in: query
-  #         name: page
-  #         schema:
-  #           type: integer
-  #           default: 1
-  #     responses:
-  #       "200":
-  #         description: List of users
-`;
-}
-/**
- * Generate an OpenAPI spec file for the project.
- */
-export async function generateOpenAPIDoc(projectDir, projectName, framework, emit) {
-    emit({ step: 'openapi', status: 'started', message: 'Generating OpenAPI spec' });
-    try {
-        const docsDir = join(projectDir, 'docs');
-        await mkdir(docsDir, { recursive: true });
-        const spec = generateOpenAPISpec(projectName, framework);
-        await writeFile(join(docsDir, 'api.yaml'), spec, 'utf-8');
-        emit({ step: 'openapi', status: 'done', message: 'Generated docs/api.yaml — edit to document your API endpoints' });
-        return { success: true, file: 'docs/api.yaml' };
-    }
-    catch (err) {
-        emit({ step: 'openapi', status: 'error', message: 'Failed to generate OpenAPI spec', detail: err.message });
-        return { success: false, file: '', error: err.message };
-    }
-}

package/dist/wizard/lib/codegen/prisma-types.d.ts

@@ -1,15 +0,0 @@
-/**
- * Type generation from Prisma schema (ADR-025).
- * After Prisma schema changes, runs prisma generate and creates a barrel export.
- * Conditional — only runs if prisma/schema.prisma exists.
- */
-import type { ProvisionEmitter } from '../provisioners/types.js';
-export interface PrismaTypesResult {
-    success: boolean;
-    files: string[];
-    error?: string;
-}
-/**
- * Run prisma generate and create a barrel export for types.
- */
-export declare function generatePrismaTypes(projectDir: string, emit: ProvisionEmitter): Promise<PrismaTypesResult>;

package/dist/wizard/lib/codegen/prisma-types.js

@@ -1,44 +0,0 @@
-/**
- * Type generation from Prisma schema (ADR-025).
- * After Prisma schema changes, runs prisma generate and creates a barrel export.
- * Conditional — only runs if prisma/schema.prisma exists.
- */
-import { existsSync } from 'node:fs';
-import { join } from 'node:path';
-import { writeFile, mkdir } from 'node:fs/promises';
-import { execCommand } from '../exec.js';
-/**
- * Run prisma generate and create a barrel export for types.
- */
-export async function generatePrismaTypes(projectDir, emit) {
-    const schemaPath = join(projectDir, 'prisma', 'schema.prisma');
-    if (!existsSync(schemaPath)) {
-        emit({ step: 'prisma-types', status: 'skipped', message: 'No prisma/schema.prisma found — type generation skipped' });
-        return { success: true, files: [] };
-    }
-    emit({ step: 'prisma-types', status: 'started', message: 'Generating Prisma types' });
-    try {
-        // Run prisma generate
-        await execCommand('npx', ['prisma', 'generate'], {
-            cwd: projectDir,
-            timeout: 60_000,
-        });
-        // Create barrel export
-        const typesDir = join(projectDir, 'types');
-        await mkdir(typesDir, { recursive: true });
-        const barrelContent = `// Auto-generated barrel export for Prisma types
-// Re-run: npx prisma generate
-// Generated by VoidForge (ADR-025)
-
-export * from '@prisma/client';
-export type { Prisma } from '@prisma/client';
-`;
-        await writeFile(join(typesDir, 'index.ts'), barrelContent, 'utf-8');
-        emit({ step: 'prisma-types', status: 'done', message: 'Prisma types generated — import from types/index.ts' });
-        return { success: true, files: ['types/index.ts'] };
-    }
-    catch (err) {
-        emit({ step: 'prisma-types', status: 'error', message: 'Failed to generate Prisma types', detail: err.message });
-        return { success: false, files: [], error: err.message };
-    }
-}

package/dist/wizard/lib/codegen/seed-gen.d.ts

@@ -1,16 +0,0 @@
-/**
- * Database seeding script generation (ADR-025).
- * Generates seed.ts with factory functions for all Prisma models.
- * Conditional — only runs if prisma/schema.prisma exists.
- */
-import type { ProvisionEmitter } from '../provisioners/types.js';
-export interface SeedResult {
-    success: boolean;
-    file: string;
-    modelCount: number;
-    error?: string;
-}
-/**
- * Generate a database seed script from the Prisma schema.
- */
-export declare function generateSeedScript(projectDir: string, emit: ProvisionEmitter): Promise<SeedResult>;

package/dist/wizard/lib/codegen/seed-gen.js

@@ -1,128 +0,0 @@
-/**
- * Database seeding script generation (ADR-025).
- * Generates seed.ts with factory functions for all Prisma models.
- * Conditional — only runs if prisma/schema.prisma exists.
- */
-import { existsSync } from 'node:fs';
-import { join } from 'node:path';
-import { readFile, writeFile, mkdir } from 'node:fs/promises';
-/** Map Prisma types to TypeScript factory values. */
-const FACTORY_VALUES = {
-    'String': "'Test value'",
-    'Int': '1',
-    'Float': '1.0',
-    'Boolean': 'true',
-    'DateTime': 'new Date()',
-    'Json': '{}',
-    'BigInt': 'BigInt(1)',
-    'Decimal': '1.0',
-};
-function parseSeedModels(content) {
-    const models = [];
-    const modelRegex = /model\s+(\w+)\s*\{([^}]+)\}/g;
-    let match;
-    while ((match = modelRegex.exec(content)) !== null) {
-        const name = match[1];
-        const body = match[2];
-        const fields = [];
-        const builtinTypes = ['String', 'Int', 'Float', 'Boolean', 'DateTime', 'Json', 'BigInt', 'Decimal', 'Bytes'];
-        for (const line of body.split('\n')) {
-            const trimmed = line.trim();
-            if (!trimmed || trimmed.startsWith('//') || trimmed.startsWith('@@'))
-                continue;
-            const fieldMatch = trimmed.match(/^(\w+)\s+(\w+)(\[\])?\s*(\?)?\s*(.*)/);
-            if (fieldMatch) {
-                const fieldName = fieldMatch[1];
-                const fieldType = fieldMatch[2];
-                const isOptional = !!fieldMatch[4];
-                const rest = fieldMatch[5] || '';
-                const hasDefault = rest.includes('@default');
-                const isId = rest.includes('@id');
-                const isRelation = !builtinTypes.includes(fieldType);
-                if (!isRelation && !fieldMatch[3]) { // Skip arrays (relations)
-                    fields.push({ name: fieldName, type: fieldType, isOptional, hasDefault, isId, isRelation });
-                }
-            }
-        }
-        models.push({ name, fields });
-    }
-    return models;
-}
-function buildSeedContent(models) {
-    const factories = [];
-    const seedCalls = [];
-    for (const model of models) {
-        const lowerName = model.name.charAt(0).toLowerCase() + model.name.slice(1);
-        const factoryFields = model.fields
-            .filter(f => !f.isId && !f.hasDefault && !f.isOptional)
-            .map(f => `    ${f.name}: ${FACTORY_VALUES[f.type] || "'TODO'"},`)
-            .join('\n');
-        factories.push(`function create${model.name}(overrides: Partial<Prisma.${model.name}CreateInput> = {}): Prisma.${model.name}CreateInput {
-  return {
-${factoryFields}
-    ...overrides,
-  };
-}`);
-        seedCalls.push(`  // ${model.name}
-  const ${lowerName} = await prisma.${lowerName}.create({ data: create${model.name}() });
-  console.log('Created ${model.name}:', ${lowerName}.id ?? '(no id)');`);
-    }
-    return `// Database seed script — generated by VoidForge (ADR-025)
-// Run: npx tsx prisma/seed.ts
-// Or: npm run seed (add "seed": "npx tsx prisma/seed.ts" to package.json scripts)
-
-import { PrismaClient, Prisma } from '@prisma/client';
-
-const prisma = new PrismaClient();
-
-// ── Factory Functions ────────────────────────────────────
-
-${factories.join('\n\n')}
-
-// ── Seed ─────────────────────────────────────────────────
-
-async function seed() {
-  console.log('Seeding database...');
-
-${seedCalls.join('\n\n')}
-
-  console.log('Seeding complete.');
-}
-
-seed()
-  .catch((e) => {
-    console.error('Seed failed:', e);
-    process.exit(1);
-  })
-  .finally(() => prisma.$disconnect());
-`;
-}
-/**
- * Generate a database seed script from the Prisma schema.
- */
-export async function generateSeedScript(projectDir, emit) {
-    const schemaPath = join(projectDir, 'prisma', 'schema.prisma');
-    if (!existsSync(schemaPath)) {
-        emit({ step: 'seed', status: 'skipped', message: 'No prisma/schema.prisma found — seed generation skipped' });
-        return { success: true, file: '', modelCount: 0 };
-    }
-    emit({ step: 'seed', status: 'started', message: 'Generating database seed script' });
-    try {
-        const schema = await readFile(schemaPath, 'utf-8');
-        const models = parseSeedModels(schema);
-        if (models.length === 0) {
-            emit({ step: 'seed', status: 'skipped', message: 'No models found in Prisma schema' });
-            return { success: true, file: '', modelCount: 0 };
-        }
-        const prismaDir = join(projectDir, 'prisma');
-        await mkdir(prismaDir, { recursive: true });
-        const script = buildSeedContent(models);
-        await writeFile(join(prismaDir, 'seed.ts'), script, 'utf-8');
-        emit({ step: 'seed', status: 'done', message: `Generated prisma/seed.ts — ${models.length} model factories. Run: npx tsx prisma/seed.ts` });
-        return { success: true, file: 'prisma/seed.ts', modelCount: models.length };
-    }
-    catch (err) {
-        emit({ step: 'seed', status: 'error', message: 'Failed to generate seed script', detail: err.message });
-        return { success: false, file: '', modelCount: 0, error: err.message };
-    }
-}