voidforge-build 23.9.1

package/dist/wizard/lib/dashboard-data.js

@@ -0,0 +1,314 @@
+/**
+ * Dashboard data parsers — shared between Danger Room and War Room.
+ * Reads campaign-state.md, assemble-state.md, log files, deploy logs, VERSION.md.
+ *
+ * v22.0 (ADR-041 M1): All project-scoped functions accept logsDir/projectDir
+ * from ProjectContext. Global data (context stats) stays at ~/.voidforge/.
+ *
+ * Parser fixes from field reports #127, #128:
+ * - parseCampaignState: rewritten for actual 5-column format, handles bold status
+ * - parseBuildState: explicit trim to remove capture artifacts
+ * - parseFindings: reads Known Issues from build-state.md first, falls back to regex
+ */
+import { readdir, unlink } from 'node:fs/promises';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { readFileOrNull } from './http-helpers.js';
+const VOIDFORGE_DIR = join(homedir(), '.voidforge');
+// ── Parsers ──────────────────────────────────────
+/**
+ * Parse campaign-state.md into structured campaign data.
+ *
+ * Handles the actual format written by /campaign:
+ *   | # | Mission | Scope | Status | Debrief |
+ *   | 1 | Name    | ...   | NOT STARTED | — |
+ *
+ * Status values may be wrapped in bold: **DONE**, **COMPLETE**
+ * Normalizes to: COMPLETE, ACTIVE, BLOCKED, PENDING, STRUCTURAL
+ */
+export async function parseCampaignState(logsDir) {
+    const content = await readFileOrNull(join(logsDir, 'campaign-state.md'));
+    if (!content)
+        return null;
+    const missions = [];
+    const re = /\|\s*(\d+)\s*\|\s*(.+?)\s*\|\s*(.+?)\s*\|\s*\*{0,2}(COMPLETE|DONE|IN PROGRESS|NOT STARTED|BLOCKED|STRUCTURAL|ACTIVE|ABANDONED)\*{0,2}\s*\|\s*(.+?)\s*\|/g;
+    let m;
+    while ((m = re.exec(content)) !== null) {
+        const rawStatus = m[4].trim();
+        const status = rawStatus === 'IN PROGRESS' ? 'ACTIVE'
+            : rawStatus === 'NOT STARTED' ? 'PENDING'
+                : rawStatus === 'DONE' ? 'COMPLETE'
+                    : rawStatus;
+        missions.push({
+            name: m[2].trim(),
+            status,
+            number: parseInt(m[1]),
+            debrief: m[5].trim() === '—' ? undefined : m[5].trim(),
+        });
+    }
+    if (missions.length === 0) {
+        if (content.length > 100) {
+            console.warn('parseCampaignState: no missions found in non-empty file (%d chars)', content.length);
+        }
+        return null;
+    }
+    const statusMatch = content.match(/CAMPAIGN STATUS:\s*(.+?)(?:\n|$)/);
+    const status = statusMatch ? statusMatch[1] : 'ACTIVE';
+    const sections = missions.map(mi => ({ name: mi.name, status: mi.status }));
+    return { missions, status, sections };
+}
+/**
+ * Parse assemble-state.md into phase pipeline data.
+ * Explicit trim on captures to remove leading artifacts.
+ */
+export async function parseBuildState(logsDir) {
+    const content = await readFileOrNull(join(logsDir, 'assemble-state.md'));
+    if (!content)
+        return null;
+    const phases = [];
+    const re = /\|\s*(?:\d+\.\s*)?(.+?)\s*\|\s*(COMPLETE|IN PROGRESS|NOT STARTED|PENDING|SKIPPED)\s*\|/g;
+    let m;
+    while ((m = re.exec(content)) !== null) {
+        const name = m[1].trim().replace(/^\|\s*/, '');
+        if (name === 'Phase' || name === 'Status' || name.startsWith('-') || name === '')
+            continue;
+        const raw = m[2].trim();
+        const normalized = raw === 'IN PROGRESS' ? 'active' : raw === 'NOT STARTED' ? 'pending' : raw.toLowerCase();
+        phases.push({ name, status: normalized });
+    }
+    return phases.length > 0 ? { phases } : null;
+}
+function countSeverity(content, severity) {
+    const tableHits = (content.match(new RegExp(`\\|\\s*${severity}\\s*\\|`, 'gi')) || []).length;
+    const boldHits = (content.match(new RegExp(`\\*\\*${severity}\\*\\*`, 'gi')) || []).length;
+    return tableHits + boldHits;
+}
+/**
+ * Parse findings — prefer Known Issues from build-state.md (curated, reflects open issues only).
+ * Falls back to regex counting across log files (historical totals, may overcount).
+ */
+export async function parseFindings(logsDir) {
+    const counts = { critical: 0, high: 0, medium: 0, low: 0 };
+    const buildState = await readFileOrNull(join(logsDir, 'build-state.md'));
+    if (buildState) {
+        const knownIssuesMatch = buildState.match(/## Known Issues[\s\S]*?(?=\n## |\n---|$)/);
+        if (knownIssuesMatch) {
+            const section = knownIssuesMatch[0];
+            counts.critical = countSeverity(section, 'CRITICAL');
+            counts.high = countSeverity(section, 'HIGH');
+            counts.medium = countSeverity(section, 'MEDIUM');
+            counts.low = countSeverity(section, 'LOW');
+            return counts;
+        }
+    }
+    try {
+        const files = await readdir(logsDir);
+        const logFiles = files.filter(f => f.startsWith('phase-') || f === 'gauntlet-state.md');
+        for (const file of logFiles) {
+            const content = await readFileOrNull(join(logsDir, file));
+            if (!content)
+                continue;
+            counts.critical += countSeverity(content, 'CRITICAL');
+            counts.high += countSeverity(content, 'HIGH');
+            counts.medium += countSeverity(content, 'MEDIUM');
+            counts.low += countSeverity(content, 'LOW');
+        }
+    }
+    catch { /* no logs directory */ }
+    return counts;
+}
+/** Read deploy log from project logs or .voidforge directory. Also reads deploy-state.md (v15.0). */
+export async function readDeployLog(logsDir) {
+    const jsonPaths = [
+        join(logsDir, 'deploy-log.json'),
+        join(VOIDFORGE_DIR, 'deploys', 'latest.json'),
+    ];
+    for (const p of jsonPaths) {
+        const content = await readFileOrNull(p);
+        if (!content)
+            continue;
+        try {
+            const data = JSON.parse(content);
+            return {
+                url: String(data.url || ''),
+                healthy: Boolean(data.healthy),
+                target: String(data.target || ''),
+                timestamp: String(data.timestamp || ''),
+            };
+        }
+        catch {
+            continue;
+        }
+    }
+    const deployState = await readFileOrNull(join(logsDir, 'deploy-state.md'));
+    if (deployState) {
+        const urlMatch = deployState.match(/(?:URL|Target):\s*(.+?)(?:\n|$)/i);
+        const statusMatch = deployState.match(/Status:\s*(.+?)(?:\n|$)/i);
+        const timestampMatch = deployState.match(/(?:Last deployed|Timestamp):\s*(.+?)(?:\n|$)/i);
+        const commitMatch = deployState.match(/Commit:\s*(.+?)(?:\n|$)/i);
+        if (urlMatch || statusMatch) {
+            return {
+                url: urlMatch ? urlMatch[1].trim() : '',
+                healthy: statusMatch ? statusMatch[1].trim().toLowerCase() === 'healthy' : false,
+                target: '',
+                timestamp: timestampMatch ? timestampMatch[1].trim() : '',
+                commit: commitMatch ? commitMatch[1].trim() : undefined,
+            };
+        }
+    }
+    return null;
+}
+/** Detect deployment drift — compare deployed commit against current HEAD. */
+export async function detectDeployDrift(logsDir, projectDir) {
+    const deployState = await readFileOrNull(join(logsDir, 'deploy-state.md'));
+    let deployedCommit = null;
+    if (deployState) {
+        const match = deployState.match(/Commit:\s*(\w+)/);
+        if (match)
+            deployedCommit = match[1];
+    }
+    if (!deployedCommit)
+        return null;
+    try {
+        const { execFile } = await import('node:child_process');
+        const { promisify } = await import('node:util');
+        const exec = promisify(execFile);
+        const result = await exec('git', ['rev-parse', '--short', 'HEAD'], { cwd: projectDir, timeout: 5000 });
+        const headCommit = result.stdout.trim();
+        return {
+            deployed_commit: deployedCommit,
+            head_commit: headCommit,
+            drifted: deployedCommit !== headCommit,
+        };
+    }
+    catch {
+        return { deployed_commit: deployedCommit, head_commit: null, drifted: true };
+    }
+}
+/** Read current version from VERSION.md. */
+export async function readVersion(projectDir) {
+    const content = await readFileOrNull(join(projectDir, 'VERSION.md'));
+    if (!content)
+        return { version: 'unknown', branch: 'unknown' };
+    const match = content.match(/\*\*Current:\*\*\s*([\d.]+)/);
+    return { version: match ? match[1] : 'unknown', branch: 'main' };
+}
+const STALENESS_THRESHOLD_MS = 60000; // 60 seconds
+/**
+ * Read context stats from the Status Line bridge (GLOBAL — not project-scoped).
+ * Reads per-session files (~/.voidforge/context-stats-*.json) and returns the most recent.
+ */
+export async function readContextStats() {
+    try {
+        const files = await readdir(VOIDFORGE_DIR);
+        const statsFiles = files.filter(f => f.startsWith('context-stats-') && f.endsWith('.json'));
+        if (statsFiles.length === 0)
+            return null;
+        let mostRecent = null;
+        let latestTime = 0;
+        const now = Date.now() / 1000;
+        const CLEANUP_AGE_S = 300;
+        for (const file of statsFiles) {
+            const filePath = join(VOIDFORGE_DIR, file);
+            const content = await readFileOrNull(filePath);
+            if (!content)
+                continue;
+            try {
+                const data = JSON.parse(content);
+                if (!data.updated_at)
+                    continue;
+                if (now - data.updated_at > CLEANUP_AGE_S) {
+                    try {
+                        await unlink(filePath);
+                    }
+                    catch { /* ignore */ }
+                    continue;
+                }
+                if (now - data.updated_at > STALENESS_THRESHOLD_MS / 1000)
+                    continue;
+                if (data.updated_at > latestTime) {
+                    latestTime = data.updated_at;
+                    mostRecent = data;
+                }
+            }
+            catch {
+                continue;
+            }
+        }
+        return mostRecent;
+    }
+    catch {
+        return null;
+    }
+}
+/** Read test results from test-results.json (written by test runner or hook). */
+export async function readTestResults(projectDir, logsDir) {
+    const paths = [
+        join(projectDir, 'test-results.json'),
+        join(logsDir, 'test-results.json'),
+    ];
+    for (const p of paths) {
+        const content = await readFileOrNull(p);
+        if (!content)
+            continue;
+        try {
+            const data = JSON.parse(content);
+            if (typeof data.total === 'number')
+                return data;
+        }
+        catch {
+            continue;
+        }
+    }
+    return null;
+}
+/** Read danger-room.config.json for project-specific panel settings. */
+export async function readDashboardConfig(projectDir) {
+    const paths = [
+        join(projectDir, 'wizard', 'danger-room.config.json'),
+        join(projectDir, 'danger-room.config.json'),
+    ];
+    for (const p of paths) {
+        const content = await readFileOrNull(p);
+        if (!content)
+            continue;
+        try {
+            return JSON.parse(content);
+        }
+        catch {
+            continue;
+        }
+    }
+    return {};
+}
+/** Read git status for the Git Status panel. */
+export async function readGitStatus(projectDir) {
+    try {
+        const { execFile } = await import('node:child_process');
+        const { promisify } = await import('node:util');
+        const exec = promisify(execFile);
+        const [branchResult, statusResult, logResult] = await Promise.all([
+            exec('git', ['branch', '--show-current'], { cwd: projectDir, timeout: 5000 }).catch(() => ({ stdout: 'unknown' })),
+            exec('git', ['status', '--porcelain'], { cwd: projectDir, timeout: 5000 }).catch(() => ({ stdout: '' })),
+            exec('git', ['log', '--oneline', '-1'], { cwd: projectDir, timeout: 5000 }).catch(() => ({ stdout: '—' })),
+        ]);
+        const branch = branchResult.stdout.trim() || 'unknown';
+        const uncommitted = statusResult.stdout.trim().split('\n').filter(Boolean).length;
+        const lastCommit = logResult.stdout.trim();
+        let ahead = 0;
+        let behind = 0;
+        try {
+            const abResult = await exec('git', ['rev-list', '--count', '--left-right', `origin/${branch}...HEAD`], { cwd: projectDir, timeout: 5000 });
+            const parts = abResult.stdout.trim().split('\t');
+            if (parts.length === 2) {
+                behind = parseInt(parts[0]) || 0;
+                ahead = parseInt(parts[1]) || 0;
+            }
+        }
+        catch { /* no upstream — normal for some branches */ }
+        return { branch, uncommitted, ahead, behind, lastCommit };
+    }
+    catch {
+        return null;
+    }
+}

package/dist/wizard/lib/dashboard-ws.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Dashboard WebSocket infrastructure factory.
+ * Creates WebSocket server instances for dashboards (Danger Room, War Room)
+ * with heartbeat, connection management, origin validation, and broadcast.
+ *
+ * v22.0 (ADR-041 M5): Subscription rooms — clients subscribe to a project ID,
+ * broadcasts are filtered by project. Global broadcasts (no projectId) reach all clients.
+ */
+import type { IncomingMessage } from 'node:http';
+import type { Duplex } from 'node:stream';
+export interface DashboardWs {
+    /** Broadcast a message to all clients, or only to clients subscribed to a specific project. */
+    broadcast: (data: {
+        type: string;
+        [key: string]: unknown;
+    }, projectId?: string) => void;
+    /** Handle WebSocket upgrade for this dashboard's path. */
+    handleUpgrade: (req: IncomingMessage, socket: Duplex, head: Buffer, projectId?: string) => void;
+    /** Close all connections and shut down. */
+    close: () => void;
+    /** Current number of connected clients. */
+    clientCount: () => number;
+}
+/**
+ * Create a new dashboard WebSocket instance.
+ * @param name — Human-readable name for logging (e.g., 'Danger Room')
+ */
+export declare function createDashboardWs(name: string): DashboardWs;

package/dist/wizard/lib/dashboard-ws.js

@@ -0,0 +1,117 @@
+/**
+ * Dashboard WebSocket infrastructure factory.
+ * Creates WebSocket server instances for dashboards (Danger Room, War Room)
+ * with heartbeat, connection management, origin validation, and broadcast.
+ *
+ * v22.0 (ADR-041 M5): Subscription rooms — clients subscribe to a project ID,
+ * broadcasts are filtered by project. Global broadcasts (no projectId) reach all clients.
+ */
+import { WebSocketServer, WebSocket } from 'ws';
+import { getServerPort, getServerHost } from './server-config.js';
+import { isLanMode } from './tower-auth.js';
+import { isPrivateOrigin } from './network.js';
+const HEARTBEAT_INTERVAL_MS = 30000;
+const MAX_CLIENTS = 50;
+// Symbol keys for WebSocket metadata
+const PROJECT_ID_KEY = Symbol.for('voidforge.ws.projectId');
+const IS_ALIVE_KEY = Symbol.for('voidforge.ws.isAlive');
+/**
+ * Create a new dashboard WebSocket instance.
+ * @param name — Human-readable name for logging (e.g., 'Danger Room')
+ */
+export function createDashboardWs(name) {
+    const wss = new WebSocketServer({ noServer: true, maxPayload: 64 * 1024 }); // 64KB max message
+    const clients = new Set();
+    const heartbeat = setInterval(() => {
+        for (const client of clients) {
+            const ext = client;
+            if (!ext[IS_ALIVE_KEY]) {
+                clients.delete(client);
+                client.terminate();
+                continue;
+            }
+            ext[IS_ALIVE_KEY] = false;
+            try {
+                client.ping();
+            }
+            catch {
+                clients.delete(client);
+            }
+        }
+    }, HEARTBEAT_INTERVAL_MS);
+    return {
+        broadcast(data, projectId) {
+            const message = JSON.stringify(data);
+            for (const client of clients) {
+                if (client.readyState !== WebSocket.OPEN)
+                    continue;
+                // If projectId is specified, only send to clients subscribed to that project
+                if (projectId) {
+                    const clientProject = client[PROJECT_ID_KEY];
+                    if (clientProject !== projectId)
+                        continue;
+                }
+                try {
+                    client.send(message);
+                }
+                catch { /* client gone */ }
+            }
+        },
+        handleUpgrade(req, socket, head, projectId) {
+            const origin = req.headers.origin || '';
+            const port = getServerPort();
+            const allowed = [`http://127.0.0.1:${port}`, `http://localhost:${port}`];
+            const remoteHost = getServerHost();
+            if (remoteHost)
+                allowed.push(`https://${remoteHost}`);
+            const originAllowed = allowed.includes(origin)
+                || (isLanMode() && isPrivateOrigin(origin));
+            if (!origin || !originAllowed) {
+                socket.write('HTTP/1.1 403 Forbidden\r\n\r\n');
+                socket.destroy();
+                return;
+            }
+            if (clients.size >= MAX_CLIENTS) {
+                socket.write('HTTP/1.1 503 Service Unavailable\r\n\r\n');
+                socket.destroy();
+                return;
+            }
+            wss.handleUpgrade(req, socket, head, (ws) => {
+                clients.add(ws);
+                const ext = ws;
+                ext[IS_ALIVE_KEY] = true;
+                // Tag with project ID if provided at upgrade time
+                if (projectId) {
+                    ext[PROJECT_ID_KEY] = projectId;
+                }
+                // Handle subscription messages from the client
+                ws.on('message', (raw) => {
+                    try {
+                        const msg = JSON.parse(String(raw));
+                        if (msg.type === 'subscribe' && typeof msg.projectId === 'string') {
+                            ext[PROJECT_ID_KEY] = msg.projectId;
+                        }
+                    }
+                    catch { /* ignore non-JSON or malformed messages */ }
+                });
+                ws.on('pong', () => { ext[IS_ALIVE_KEY] = true; });
+                ws.on('close', () => clients.delete(ws));
+                ws.on('error', () => clients.delete(ws));
+            });
+        },
+        close() {
+            clearInterval(heartbeat);
+            for (const client of clients) {
+                try {
+                    client.close(1001, 'Server shutting down');
+                }
+                catch { /* ignore */ }
+            }
+            clients.clear();
+            wss.close();
+        },
+        clientCount() {
+            return clients.size;
+        },
+    };
+}

package/dist/wizard/lib/deep-current.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Deep Current — Situation Model + Cold Start Intake (v12.0).
+ *
+ * The Deep Current maintains a persistent situation model that represents
+ * the system's understanding of the project at any point in time. The
+ * cold start intake classifies new projects and bootstraps the model.
+ *
+ * PRD Reference: ROADMAP v12.0, docs/methods/DEEP_CURRENT.md
+ */
+import type { SiteScanResult } from './site-scanner.js';
+declare function deepCurrentDir(projectDir: string): string;
+declare function situationPath(projectDir: string): string;
+declare function proposalsDir(projectDir: string): string;
+declare function predictionsPath(projectDir: string): string;
+declare function correlationsPath(projectDir: string): string;
+type ProjectState = 'GREENFIELD' | 'IDEA_PRD' | 'PARTIAL' | 'DEPLOYED' | 'OPERATING';
+interface ProjectClassification {
+    state: ProjectState;
+    hasCodebase: boolean;
+    hasPrd: boolean;
+    isDeployed: boolean;
+    hasAnalytics: boolean;
+    hasRevenue: boolean;
+    deployedUrl?: string;
+}
+/**
+ * Classify the current project's state by checking for key files and config.
+ */
+export declare function classifyProject(): Promise<ProjectClassification>;
+interface DimensionScore {
+    score: number;
+    gaps: string[];
+    lastUpdated: string;
+}
+interface CampaignRecord {
+    id: string;
+    name: string;
+    proposedDate: string;
+    executedDate?: string;
+    predictedImpact: string;
+    actualImpact?: string;
+    predictionAccuracy?: number;
+}
+interface SituationModel {
+    projectState: ProjectState;
+    projectName: string;
+    deployedUrl?: string;
+    lastScan: string;
+    dimensions: {
+        featureCompleteness: DimensionScore;
+        quality: DimensionScore;
+        performance: DimensionScore;
+        growthReadiness: DimensionScore;
+        revenuePotential: DimensionScore;
+    };
+    campaignHistory: CampaignRecord[];
+    pendingProposals: string[];
+    averagePredictionAccuracy: number;
+    autonomyTier: 1 | 2 | 3;
+    lastSiteScan?: SiteScanResult;
+}
+export declare function loadSituation(projectDir: string): Promise<SituationModel | null>;
+export declare function saveSituation(projectDir: string, model: SituationModel): Promise<void>;
+export declare function sense(model: SituationModel): Promise<SituationModel>;
+interface IntakeResult {
+    classification: ProjectClassification;
+    situation: SituationModel;
+    siteScan?: SiteScanResult;
+    recommendedFirstAction: string;
+}
+/**
+ * Cold start intake: classify the project, scan if deployed, create situation model.
+ * Returns the initial situation and a recommended first action.
+ */
+export declare function intake(projectName: string, projectDir?: string): Promise<IntakeResult>;
+export type { ProjectState, ProjectClassification, SituationModel, DimensionScore, CampaignRecord, IntakeResult };
+export { deepCurrentDir, situationPath, proposalsDir, predictionsPath, correlationsPath };