voidforge-build 23.9.1 → 23.10.0

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 };
-    }
-}

package/dist/wizard/lib/correlation-engine.d.ts

@@ -1,59 +0,0 @@
-/**
- * Chakotay's Correlation Engine — connects product changes to metric outcomes (v12.2).
- *
- * Maintains an event log of product changes (campaigns, deploys) and metric
- * observations (traffic, conversions, revenue, performance scores). Computes
- * before/after comparisons to identify which changes drove which outcomes.
- *
- * PRD Reference: ROADMAP v12.2, DEEP_CURRENT.md LEARN step
- */
-import type { CampaignProposal } from './campaign-proposer.js';
-interface ChangeEvent {
-    type: 'campaign_complete' | 'deploy' | 'config_change';
-    date: string;
-    campaign?: string;
-    missions?: number;
-    dimension?: string;
-    description: string;
-}
-interface MetricObservation {
-    type: 'metric';
-    date: string;
-    metric: string;
-    value: number;
-    source: string;
-}
-interface Correlation {
-    type: 'correlation';
-    date: string;
-    productChange: string;
-    metric: string;
-    valueBefore: number;
-    valueAfter: number;
-    delta: string;
-    confidence: 'high' | 'medium' | 'low';
-    lagDays: number;
-}
-export declare function logCampaignComplete(name: string, missions: number, dimension: string): Promise<void>;
-export declare function logMetric(metric: string, value: number, source: string): Promise<void>;
-/**
- * Detect correlations between recent campaigns and metric changes.
- * Uses before/after comparison with configurable lag windows.
- */
-export declare function detectCorrelations(lagDays?: number): Promise<Correlation[]>;
-interface PredictionRecord {
-    proposalId: string;
-    proposalName: string;
-    predictedImpact: string;
-    actualImpact?: string;
-    accuracy?: number;
-    recordedAt: string;
-    evaluatedAt?: string;
-}
-export declare function recordPrediction(proposal: CampaignProposal): Promise<void>;
-export declare function evaluatePrediction(proposalId: string, actualImpact: string, accuracy: number): Promise<void>;
-/**
- * Calculate average prediction accuracy across all evaluated predictions.
- */
-export declare function getAveragePredictionAccuracy(): Promise<number>;
-export type { ChangeEvent, MetricObservation, Correlation, PredictionRecord };