voidforge-build 23.9.1 → 23.10.0

package/dist/wizard/lib/correlation-engine.js

@@ -1,152 +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 { appendFile, readFile, mkdir } from 'node:fs/promises';
-import { existsSync } from 'node:fs';
-import { correlationsPath, predictionsPath, deepCurrentDir } from './deep-current.js';
-import { findProjectRoot } from './marker.js';
-// ── Event Logging ─────────────────────────────────────
-async function appendEvent(entry) {
-    await mkdir(deepCurrentDir(findProjectRoot() ?? process.cwd()), { recursive: true });
-    await appendFile(correlationsPath(findProjectRoot() ?? process.cwd()), JSON.stringify(entry) + '\n', 'utf-8');
-}
-export async function logCampaignComplete(name, missions, dimension) {
-    await appendEvent({
-        type: 'campaign_complete',
-        date: new Date().toISOString(),
-        campaign: name,
-        missions,
-        dimension,
-        description: `Campaign "${name}" completed (${missions} missions, targeting ${dimension})`,
-    });
-}
-export async function logMetric(metric, value, source) {
-    await appendEvent({
-        type: 'metric',
-        date: new Date().toISOString(),
-        metric,
-        value,
-        source,
-    });
-}
-// ── Correlation Detection ─────────────────────────────
-/**
- * Detect correlations between recent campaigns and metric changes.
- * Uses before/after comparison with configurable lag windows.
- */
-export async function detectCorrelations(lagDays = 7) {
-    if (!existsSync(correlationsPath(findProjectRoot() ?? process.cwd())))
-        return [];
-    const content = await readFile(correlationsPath(findProjectRoot() ?? process.cwd()), 'utf-8');
-    const lines = content.trim().split('\n').filter(Boolean);
-    const events = lines.map(l => { try {
-        return JSON.parse(l);
-    }
-    catch {
-        return null;
-    } }).filter(Boolean);
-    const changes = events.filter(e => e.type === 'campaign_complete');
-    const metrics = events.filter(e => e.type === 'metric');
-    const correlations = [];
-    for (const change of changes) {
-        const changeDate = new Date(change.date).getTime();
-        // Find metrics of the same type before and after the change
-        const metricNames = [...new Set(metrics.map(m => m.metric))];
-        for (const metricName of metricNames) {
-            const metricsOfType = metrics.filter(m => m.metric === metricName);
-            // Before: last metric reading before the change
-            const before = metricsOfType
-                .filter(m => new Date(m.date).getTime() < changeDate)
-                .sort((a, b) => new Date(b.date).getTime() - new Date(a.date).getTime())[0];
-            // After: first metric reading lagDays after the change
-            const afterCutoff = changeDate + lagDays * 24 * 60 * 60 * 1000;
-            const after = metricsOfType
-                .filter(m => {
-                const t = new Date(m.date).getTime();
-                return t > changeDate && t <= afterCutoff;
-            })
-                .sort((a, b) => new Date(b.date).getTime() - new Date(a.date).getTime())[0];
-            if (before && after && before.value !== after.value) {
-                const delta = after.value - before.value;
-                const pctChange = before.value !== 0 ? Math.round((delta / before.value) * 100) : 0;
-                const significance = Math.abs(pctChange);
-                // Only record meaningful changes (>5%)
-                if (significance > 5) {
-                    const correlation = {
-                        type: 'correlation',
-                        date: new Date().toISOString(),
-                        productChange: change.campaign || change.description,
-                        metric: metricName,
-                        valueBefore: before.value,
-                        valueAfter: after.value,
-                        delta: `${delta > 0 ? '+' : ''}${pctChange}%`,
-                        confidence: significance > 30 ? 'high' : significance > 15 ? 'medium' : 'low',
-                        lagDays,
-                    };
-                    correlations.push(correlation);
-                    await appendEvent(correlation); // Record the correlation in the log
-                }
-            }
-        }
-    }
-    return correlations;
-}
-export async function recordPrediction(proposal) {
-    await mkdir(deepCurrentDir(findProjectRoot() ?? process.cwd()), { recursive: true });
-    const record = {
-        proposalId: proposal.id,
-        proposalName: proposal.name,
-        predictedImpact: proposal.expectedImpact,
-        recordedAt: new Date().toISOString(),
-    };
-    await appendFile(predictionsPath(findProjectRoot() ?? process.cwd()), JSON.stringify(record) + '\n', 'utf-8');
-}
-export async function evaluatePrediction(proposalId, actualImpact, accuracy) {
-    // Read existing predictions, find the matching one, update it
-    if (!existsSync(predictionsPath(findProjectRoot() ?? process.cwd())))
-        return;
-    const content = await readFile(predictionsPath(findProjectRoot() ?? process.cwd()), 'utf-8');
-    const lines = content.trim().split('\n').filter(Boolean);
-    const updated = lines.map(line => {
-        try {
-            const record = JSON.parse(line);
-            if (record.proposalId === proposalId) {
-                record.actualImpact = actualImpact;
-                record.accuracy = accuracy;
-                record.evaluatedAt = new Date().toISOString();
-            }
-            return JSON.stringify(record);
-        }
-        catch {
-            return line;
-        }
-    });
-    const { writeFile: wf } = await import('node:fs/promises');
-    await wf(predictionsPath(findProjectRoot() ?? process.cwd()), updated.join('\n') + '\n');
-}
-/**
- * Calculate average prediction accuracy across all evaluated predictions.
- */
-export async function getAveragePredictionAccuracy() {
-    if (!existsSync(predictionsPath(findProjectRoot() ?? process.cwd())))
-        return 0;
-    const content = await readFile(predictionsPath(findProjectRoot() ?? process.cwd()), 'utf-8');
-    const records = content.trim().split('\n').filter(Boolean)
-        .map(l => { try {
-        return JSON.parse(l);
-    }
-    catch {
-        return null;
-    } })
-        .filter(Boolean);
-    const evaluated = records.filter(r => r.accuracy !== undefined);
-    if (evaluated.length === 0)
-        return 0;
-    return evaluated.reduce((sum, r) => sum + (r.accuracy || 0), 0) / evaluated.length;
-}

package/dist/wizard/lib/desktop-notify.d.ts

@@ -1,27 +0,0 @@
-/**
- * Desktop Notifications — macOS/Linux native notifications for daemon events.
- *
- * Uses osascript on macOS and notify-send on Linux. No dependencies.
- * Notifications are non-blocking and failure-tolerant (notification failure
- * should never crash the daemon).
- *
- * PRD Reference: §9.7 (Danger Room shows warning), v11.3 deliverables
- */
-type NotificationUrgency = 'low' | 'normal' | 'critical';
-interface NotificationOptions {
-    title: string;
-    message: string;
-    urgency?: NotificationUrgency;
-    sound?: boolean;
-}
-/**
- * Send a desktop notification. Fails silently — never throws.
- */
-export declare function notify(opts: NotificationOptions): void;
-export declare function notifySpendSpike(platform: string, amount: string): void;
-export declare function notifyCampaignKilled(name: string, reason: string): void;
-export declare function notifyTokenExpiring(platform: string, hoursLeft: number): void;
-export declare function notifyReconciliationDiscrepancy(platform: string, amount: string): void;
-export declare function notifyVaultExpiring(hoursLeft: number): void;
-export declare function notifyRevenueMilestone(amount: string): void;
-export {};

package/dist/wizard/lib/desktop-notify.js

@@ -1,98 +0,0 @@
-/**
- * Desktop Notifications — macOS/Linux native notifications for daemon events.
- *
- * Uses osascript on macOS and notify-send on Linux. No dependencies.
- * Notifications are non-blocking and failure-tolerant (notification failure
- * should never crash the daemon).
- *
- * PRD Reference: §9.7 (Danger Room shows warning), v11.3 deliverables
- */
-import { execFileSync } from 'node:child_process';
-import { platform } from 'node:os';
-/**
- * Send a desktop notification. Fails silently — never throws.
- */
-export function notify(opts) {
-    try {
-        if (platform() === 'darwin') {
-            notifyMacOS(opts);
-        }
-        else if (platform() === 'linux') {
-            notifyLinux(opts);
-        }
-        // Windows: notifications deferred — WSL2 path recommended
-    }
-    catch {
-        // Notification failure is never fatal
-    }
-}
-function notifyMacOS(opts) {
-    // SEC-005: Use execFileSync with args array to prevent shell injection
-    const sound = opts.sound !== false ? ' sound name "Submarine"' : '';
-    const script = `display notification "${sanitize(opts.message)}" with title "VoidForge"${sound} subtitle "${sanitize(opts.title)}"`;
-    try {
-        execFileSync('osascript', ['-e', script], { timeout: 5000, stdio: 'ignore' });
-    }
-    catch { /* notification failure is never fatal */ }
-}
-function notifyLinux(opts) {
-    // SEC-006: Use execFileSync with args array, validate urgency enum
-    const validUrgencies = ['low', 'normal', 'critical'];
-    const urgency = validUrgencies.includes(opts.urgency || '') ? opts.urgency : 'normal';
-    try {
-        execFileSync('notify-send', ['-u', urgency, '-a', 'VoidForge', sanitize(opts.title), sanitize(opts.message)], { timeout: 5000, stdio: 'ignore' });
-    }
-    catch { /* notification failure is never fatal */ }
-}
-/** Strip characters that could be dangerous in shell/AppleScript contexts */
-function sanitize(input) {
-    return input.replace(/[`$\\"\n\r\0]/g, '').slice(0, 200);
-}
-// ── Daemon Event Notifications ────────────────────────
-// Pre-built notifications for common daemon events (§9.20.7 agent voice)
-export function notifySpendSpike(platform, amount) {
-    notify({
-        title: `Spend Spike — ${platform}`,
-        message: `Wax reports: ${platform} spend is ${amount} above average this hour.`,
-        urgency: 'critical',
-        sound: true,
-    });
-}
-export function notifyCampaignKilled(name, reason) {
-    notify({
-        title: 'Campaign Paused',
-        message: `Wax pulled the trigger on "${name}" — ${reason}.`,
-        urgency: 'normal',
-    });
-}
-export function notifyTokenExpiring(platform, hoursLeft) {
-    notify({
-        title: `Token Expiring — ${platform}`,
-        message: `Breeze warns: ${platform} token expires in ${hoursLeft} hours. Refresh needed.`,
-        urgency: hoursLeft < 2 ? 'critical' : 'normal',
-        sound: hoursLeft < 2,
-    });
-}
-export function notifyReconciliationDiscrepancy(platform, amount) {
-    notify({
-        title: 'Reconciliation Alert',
-        message: `Dockson: Numbers don't match on ${platform} — ${amount} discrepancy.`,
-        urgency: 'critical',
-        sound: true,
-    });
-}
-export function notifyVaultExpiring(hoursLeft) {
-    notify({
-        title: 'Vault Session Expiring',
-        message: `Vault session expires in ${hoursLeft} hour(s). Run \`voidforge heartbeat unlock\` to extend.`,
-        urgency: 'critical',
-        sound: true,
-    });
-}
-export function notifyRevenueMilestone(amount) {
-    notify({
-        title: 'Revenue Milestone!',
-        message: `Dockson: ${amount} total revenue. Every coin has a story — this one's a good chapter.`,
-        urgency: 'low',
-    });
-}

package/dist/wizard/lib/image-gen.d.ts

@@ -1,56 +0,0 @@
-/**
- * Image generation provider abstraction — Celebrimbor's forge tools.
- * Default: OpenAI (gpt-image-1). Extensible to other providers.
- * Uses the same vault system as other VoidForge credentials.
- */
-import type { ProvisionEmitter } from './provisioners/types.js';
-export interface ImageGenerationOptions {
-    prompt: string;
-    width: number;
-    height: number;
-    model?: string;
-    quality?: 'low' | 'medium' | 'high';
-}
-export interface GeneratedAsset {
-    name: string;
-    filename: string;
-    prompt: string;
-    size: string;
-    generatedAt: string;
-    hash: string;
-}
-export interface AssetManifest {
-    generated: string;
-    model: string;
-    style: string;
-    assets: GeneratedAsset[];
-}
-/**
- * Generate an image via OpenAI's API.
- * Returns the raw image bytes as a Buffer.
- */
-export declare function generateImage(apiKey: string, options: ImageGenerationOptions, emit: ProvisionEmitter): Promise<Buffer | null>;
-/**
- * Validate an OpenAI API key by making a lightweight models list request.
- */
-export declare function validateOpenAIKey(apiKey: string): Promise<boolean>;
-/**
- * Estimate the cost of generating N images.
- */
-export declare function estimateImageCost(count: number, model?: string): number;
-/**
- * Read the asset manifest from disk.
- */
-export declare function readManifest(imagesDir: string): Promise<AssetManifest | null>;
-/**
- * Write the asset manifest to disk.
- */
-export declare function writeManifest(imagesDir: string, manifest: AssetManifest): Promise<void>;
-/**
- * Save a generated image to disk and update the manifest.
- */
-export declare function saveGeneratedImage(imagesDir: string, category: string, name: string, imageBuffer: Buffer, prompt: string, size: string, manifest: AssetManifest): Promise<string>;
-/**
- * Check if an asset already exists on disk.
- */
-export declare function assetExists(imagesDir: string, category: string, name: string): boolean;

package/dist/wizard/lib/image-gen.js

@@ -1,159 +0,0 @@
-/**
- * Image generation provider abstraction — Celebrimbor's forge tools.
- * Default: OpenAI (gpt-image-1). Extensible to other providers.
- * Uses the same vault system as other VoidForge credentials.
- */
-import { writeFile, readFile, mkdir } from 'node:fs/promises';
-import { existsSync } from 'node:fs';
-import { join } from 'node:path';
-import { createHash } from 'node:crypto';
-import { httpsPost, httpsGet, safeJsonParse } from './provisioners/http-client.js';
-// ── OpenAI Provider ──────────────────────────────────────
-const OPENAI_API = 'api.openai.com';
-/**
- * Generate an image via OpenAI's API.
- * Returns the raw image bytes as a Buffer.
- */
-export async function generateImage(apiKey, options, emit) {
-    const model = options.model || 'gpt-image-1';
-    const size = `${options.width}x${options.height}`;
-    // OpenAI only supports specific sizes — map to nearest and warn
-    const validSizes = ['1024x1024', '1792x1024', '1024x1792'];
-    const actualSize = validSizes.includes(size) ? size : '1024x1024';
-    if (actualSize !== size) {
-        emit({ step: 'image-gen', status: 'started', message: `Requested ${size} → using ${actualSize} (API constraint)` });
-    }
-    const body = JSON.stringify({
-        model,
-        prompt: options.prompt,
-        n: 1,
-        size: actualSize,
-        quality: options.quality || 'medium',
-        response_format: 'b64_json',
-    });
-    // Retry logic: 3 attempts with exponential backoff (1s, 3s, 9s)
-    // DALL-E 3 returns 500 errors on ~15% of requests (field report #1)
-    const MAX_RETRIES = 3;
-    const BACKOFF_BASE_MS = 1000;
-    for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
-        try {
-            const res = await httpsPost(OPENAI_API, '/v1/images/generations', {
-                'Authorization': `Bearer ${apiKey}`,
-                'Content-Type': 'application/json',
-            }, body, 120_000); // 2 min timeout for image generation
-            if (res.status === 500 || res.status === 502 || res.status === 503) {
-                // Server error — retry with backoff
-                if (attempt < MAX_RETRIES) {
-                    const delay = BACKOFF_BASE_MS * Math.pow(3, attempt - 1);
-                    emit({ step: 'image-gen', status: 'started', message: `Server error (${res.status}), retrying in ${delay / 1000}s (attempt ${attempt}/${MAX_RETRIES})` });
-                    await new Promise((resolve) => setTimeout(resolve, delay));
-                    continue;
-                }
-                emit({ step: 'image-gen', status: 'error', message: `Server error (${res.status}) after ${MAX_RETRIES} attempts` });
-                return null;
-            }
-            if (res.status !== 200) {
-                const errData = safeJsonParse(res.body);
-                const errMsg = errData?.error?.message || `API returned ${res.status}`;
-                emit({ step: 'image-gen', status: 'error', message: `Generation failed: ${errMsg}` });
-                return null;
-            }
-            const data = safeJsonParse(res.body);
-            const b64 = data?.data?.[0]?.b64_json;
-            if (!b64) {
-                emit({ step: 'image-gen', status: 'error', message: 'No image data in API response' });
-                return null;
-            }
-            if (attempt > 1) {
-                emit({ step: 'image-gen', status: 'done', message: `Succeeded on attempt ${attempt}` });
-            }
-            return Buffer.from(b64, 'base64');
-        }
-        catch (err) {
-            if (attempt < MAX_RETRIES) {
-                const delay = BACKOFF_BASE_MS * Math.pow(3, attempt - 1);
-                emit({ step: 'image-gen', status: 'started', message: `Request failed, retrying in ${delay / 1000}s (attempt ${attempt}/${MAX_RETRIES})`, detail: err.message });
-                await new Promise((resolve) => setTimeout(resolve, delay));
-                continue;
-            }
-            emit({ step: 'image-gen', status: 'error', message: `Image generation failed after ${MAX_RETRIES} attempts`, detail: err.message });
-            return null;
-        }
-    }
-    return null;
-}
-/**
- * Validate an OpenAI API key by making a lightweight models list request.
- */
-export async function validateOpenAIKey(apiKey) {
-    try {
-        const res = await httpsGet(OPENAI_API, '/v1/models', {
-            'Authorization': `Bearer ${apiKey}`,
-        }, 10_000);
-        return res.status === 200;
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * Estimate the cost of generating N images.
- */
-export function estimateImageCost(count, model = 'gpt-image-1') {
-    const costPerImage = {
-        'gpt-image-1': 0.04,
-        'dall-e-3': 0.08,
-    };
-    return count * (costPerImage[model] || 0.04);
-}
-// ── Asset Manifest ──────────────────────────────────────
-const MANIFEST_FILENAME = 'manifest.json';
-/**
- * Read the asset manifest from disk.
- */
-export async function readManifest(imagesDir) {
-    const manifestPath = join(imagesDir, MANIFEST_FILENAME);
-    try {
-        const content = await readFile(manifestPath, 'utf-8');
-        return JSON.parse(content);
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * Write the asset manifest to disk.
- */
-export async function writeManifest(imagesDir, manifest) {
-    await mkdir(imagesDir, { recursive: true });
-    await writeFile(join(imagesDir, MANIFEST_FILENAME), JSON.stringify(manifest, null, 2) + '\n', 'utf-8');
-}
-/**
- * Save a generated image to disk and update the manifest.
- */
-export async function saveGeneratedImage(imagesDir, category, name, imageBuffer, prompt, size, manifest) {
-    const categoryDir = join(imagesDir, category);
-    await mkdir(categoryDir, { recursive: true });
-    const filename = `${category}/${name}.png`;
-    const filepath = join(imagesDir, filename);
-    await writeFile(filepath, imageBuffer);
-    const hash = createHash('sha256').update(imageBuffer).digest('hex');
-    // Remove any existing entry with the same filename (dedup for --regen)
-    manifest.assets = manifest.assets.filter(a => a.filename !== filename);
-    manifest.assets.push({
-        name,
-        filename,
-        prompt,
-        size,
-        generatedAt: new Date().toISOString(),
-        hash: `sha256:${hash}`,
-    });
-    await writeManifest(imagesDir, manifest);
-    return filepath;
-}
-/**
- * Check if an asset already exists on disk.
- */
-export function assetExists(imagesDir, category, name) {
-    return existsSync(join(imagesDir, category, `${name}.png`));
-}

package/dist/wizard/lib/natural-language-deploy.d.ts

@@ -1,30 +0,0 @@
-/**
- * Natural Language Deploy — resolve prose deployment descriptions to YAML frontmatter.
- *
- * Parse: "I want a $20/month server with SSL and daily backups"
- * → { deploy: 'vps', instanceType: 't3.small', hostname: '', resilience: { backups: 'daily', ... } }
- *
- * Uses keyword matching and heuristics — no AI API call required.
- */
-export interface DeployConfig {
-    deploy: 'vps' | 'vercel' | 'railway' | 'cloudflare' | 'static' | 'docker';
-    instanceType: string;
-    hostname: string;
-    estimatedMonthlyCost: string;
-    resilience: {
-        multiEnv: boolean;
-        previewDeploys: boolean;
-        rollback: boolean;
-        migrations: 'auto' | 'manual' | 'no';
-        backups: 'daily' | 'weekly' | 'no';
-        healthCheck: boolean;
-        gracefulShutdown: boolean;
-        errorBoundaries: boolean;
-        rateLimiting: boolean;
-        deadLetterQueue: boolean;
-    };
-    reasoning: string[];
-}
-export declare function resolveDeployConfig(prose: string): DeployConfig | null;
-/** Convert a DeployConfig to YAML frontmatter fragment. */
-export declare function toFrontmatter(config: DeployConfig): string;