@prads01/blackbox 0.1.0

package/dist/tui/app.js

@@ -0,0 +1,408 @@
+import blessed from "blessed";
+import { fetchApiReachability, fetchIncidents, loadTuiConfig, triggerCreatePr, triggerAnalysis, triggerSandboxFix, updateIncidentStatus, } from "./data.js";
+import { attachKeybindings } from "./keybindings.js";
+import { indexToView, palette, renderFooter, renderMain, renderSidebar, viewToIndex, } from "./render.js";
+import { TuiWatchService } from "./watch-service.js";
+let crashHandlersInstalled = false;
+function installCrashHandlers() {
+    if (crashHandlersInstalled)
+        return;
+    crashHandlersInstalled = true;
+    process.on("uncaughtException", (error) => {
+        console.error("[blackbox:tui] uncaughtException:", error);
+        process.exit(1);
+    });
+    process.on("unhandledRejection", (reason) => {
+        console.error("[blackbox:tui] unhandledRejection:", reason);
+        process.exit(1);
+    });
+}
+function createInitialState(config) {
+    return {
+        view: "dashboard",
+        focusZone: "nav",
+        selectedNavIndex: 0,
+        config,
+        apiReachable: false,
+        incidents: [],
+        selectedIncidentIndex: 0,
+        incidentsMode: "list",
+        sandboxMode: "list",
+        selectedSandboxIndex: 0,
+        lastSandboxIncidentId: null,
+        watchActive: false,
+        watchLogs: [],
+        lastAnalysisAt: null,
+        lastSandboxResult: null,
+        sandboxResultsByIncidentId: {},
+        sandboxPrResult: null,
+        sandboxPrError: null,
+        sandboxPrInFlight: false,
+        analyzeInFlight: false,
+        busyMessage: null,
+        statusMessage: null,
+        errorMessage: null,
+    };
+}
+function getSandboxReadyIncidents(state) {
+    return state.incidents.filter((incident) => {
+        const result = state.sandboxResultsByIncidentId[incident.id];
+        return !result || result.status !== "success";
+    });
+}
+function hexToRgb(hex) {
+    const normalized = hex.replace("#", "");
+    const bigint = Number.parseInt(normalized, 16);
+    const r = (bigint >> 16) & 255;
+    const g = (bigint >> 8) & 255;
+    const b = bigint & 255;
+    return [r, g, b];
+}
+function rgbToHex(r, g, b) {
+    const toHex = (value) => value.toString(16).padStart(2, "0");
+    return `#${toHex(r)}${toHex(g)}${toHex(b)}`;
+}
+function blendTowardsWhite(hex, amount) {
+    const [r, g, b] = hexToRgb(hex);
+    const clamped = Math.max(0, Math.min(1, amount));
+    const nr = Math.round(r + (255 - r) * clamped);
+    const ng = Math.round(g + (255 - g) * clamped);
+    const nb = Math.round(b + (255 - b) * clamped);
+    return rgbToHex(nr, ng, nb);
+}
+export async function runTui() {
+    installCrashHandlers();
+    const config = await loadTuiConfig();
+    const state = createInitialState(config);
+    const screen = blessed.screen({
+        smartCSR: true,
+        title: "BlackBox TUI",
+        fullUnicode: true,
+    });
+    const header = blessed.box({
+        parent: screen,
+        top: 0,
+        left: 0,
+        width: "100%",
+        height: 10,
+        tags: true,
+        border: "line",
+        padding: { left: 1, right: 1, top: 0, bottom: 0 },
+        style: {
+            fg: "white",
+            border: { fg: palette.accent },
+        },
+        content: (() => {
+            const bannerLines = [
+                "██████╗ ██╗      █████╗  ██████╗██╗  ██╗██████╗  ██████╗ ██╗  ██╗",
+                "██╔══██╗██║     ██╔══██╗██╔════╝██║ ██╔╝██╔══██╗██╔═══██╗╚██╗██╔╝",
+                "██████╔╝██║     ███████║██║     █████╔╝ ██████╔╝██║   ██║ ╚███╔╝ ",
+                "██╔══██╗██║     ██╔══██║██║     ██╔═██╗ ██╔══██╗██║   ██║ ██╔██╗ ",
+                "██████╔╝███████╗██║  ██║╚██████╗██║  ██╗██████╔╝╚██████╔╝██╔╝ ██╗",
+                "╚═════╝ ╚══════╝╚═╝  ╚═╝ ╚═════╝╚═╝  ╚═╝╚═════╝  ╚═════╝ ╚═╝  ╚═╝",
+            ];
+            const steps = [0, 0.18, 0.35, 0.55, 0.78, 0.92];
+            const gradientLines = bannerLines.map((line, index) => {
+                const color = blendTowardsWhite(palette.accentHex, steps[index] ?? 1);
+                return `{bold}{${color}-fg}${line}{/${color}-fg}{/bold}`;
+            });
+            gradientLines.push("{gray-fg}Production Incident Forensics{/gray-fg}");
+            return gradientLines.join("\n");
+        })(),
+    });
+    const sidebar = blessed.list({
+        parent: screen,
+        top: 10,
+        left: 0,
+        width: 24,
+        height: "100%-13",
+        tags: true,
+        keys: true,
+        vi: true,
+        mouse: true,
+        border: "line",
+        label: " Navigation ",
+        style: {
+            fg: "white",
+            border: { fg: palette.borderDefault },
+            selected: { fg: "white", bg: palette.accent },
+            item: { fg: "white" },
+        },
+    });
+    const main = blessed.box({
+        parent: screen,
+        top: 10,
+        left: 24,
+        width: "100%-24",
+        height: "100%-13",
+        tags: true,
+        border: "line",
+        label: " View ",
+        scrollable: true,
+        alwaysScroll: true,
+        keys: true,
+        mouse: true,
+        padding: { left: 1, right: 1, top: 1, bottom: 1 },
+        style: {
+            fg: "white",
+            border: { fg: palette.borderDefault },
+        },
+    });
+    const footer = blessed.box({
+        parent: screen,
+        bottom: 0,
+        left: 0,
+        width: "100%",
+        height: 3,
+        tags: true,
+        border: "line",
+        style: {
+            fg: "white",
+            border: { fg: palette.accent },
+        },
+    });
+    let refreshTimer = null;
+    let statusTimer = null;
+    let closed = false;
+    let resolveClose = null;
+    let lastAnalyzeStartedAt = 0;
+    const render = () => {
+        sidebar.setLabel(state.focusZone === "nav" ? " Navigation (Focused) " : " Navigation ");
+        main.setLabel(state.focusZone === "view" ? " View (Focused) " : " View ");
+        sidebar.style.border.fg = state.focusZone === "nav" ? palette.accent : palette.borderDefault;
+        main.style.border.fg = state.focusZone === "view" ? palette.accent : palette.borderDefault;
+        renderSidebar(sidebar, state);
+        sidebar.select(state.selectedNavIndex);
+        renderMain(main, state);
+        renderFooter(footer, state);
+        screen.render();
+    };
+    const withBusy = async (message, action) => {
+        state.busyMessage = message;
+        state.statusMessage = null;
+        state.errorMessage = null;
+        render();
+        try {
+            await action();
+        }
+        catch (error) {
+            state.errorMessage = error instanceof Error ? error.message : String(error);
+        }
+        finally {
+            state.busyMessage = null;
+            render();
+        }
+    };
+    const refreshData = async () => {
+        try {
+            state.apiReachable = await fetchApiReachability(config);
+            state.incidents = await fetchIncidents(config);
+            if (state.selectedIncidentIndex > state.incidents.length - 1) {
+                state.selectedIncidentIndex = Math.max(0, state.incidents.length - 1);
+            }
+            const ready = getSandboxReadyIncidents(state);
+            if (state.selectedSandboxIndex > ready.length - 1) {
+                state.selectedSandboxIndex = Math.max(0, ready.length - 1);
+            }
+            state.errorMessage = null;
+        }
+        catch (error) {
+            state.errorMessage = error instanceof Error ? error.message : String(error);
+        }
+    };
+    const runAnalyzeOnce = async () => {
+        const now = Date.now();
+        if (state.analyzeInFlight)
+            return;
+        if (now - lastAnalyzeStartedAt < 1200)
+            return;
+        lastAnalyzeStartedAt = now;
+        state.analyzeInFlight = true;
+        let didSucceed = false;
+        await withBusy("Analyzing...", async () => {
+            await triggerAnalysis(config);
+            state.lastAnalysisAt = new Date().toISOString();
+            await refreshData();
+            state.view = "dashboard";
+            state.selectedNavIndex = viewToIndex("dashboard");
+            didSucceed = true;
+        });
+        state.analyzeInFlight = false;
+        if (didSucceed) {
+            state.statusMessage = "Analysis complete";
+            if (statusTimer)
+                clearTimeout(statusTimer);
+            statusTimer = setTimeout(() => {
+                state.statusMessage = null;
+                render();
+            }, 2000);
+        }
+        render();
+    };
+    const markIncidentStatus = async (status) => {
+        if (state.view !== "incidents")
+            return;
+        const selectedIncident = state.incidents[state.selectedIncidentIndex];
+        if (!selectedIncident)
+            return;
+        await withBusy(`Marking ${status}...`, async () => {
+            await updateIncidentStatus(config, selectedIncident.id, status);
+            await refreshData();
+            state.statusMessage =
+                status === "fixed" ? "Incident marked fixed" : "Incident marked investigating";
+        });
+    };
+    const watchService = new TuiWatchService(config, {
+        onLog: (line) => {
+            state.watchLogs.push(line);
+            if (state.watchLogs.length > 100)
+                state.watchLogs = state.watchLogs.slice(-100);
+            render();
+        },
+        onChangeAnalyze: async () => {
+            if (state.analyzeInFlight)
+                return;
+            await runAnalyzeOnce();
+            render();
+        },
+    });
+    const closeApp = async () => {
+        if (closed)
+            return;
+        closed = true;
+        if (refreshTimer) {
+            clearInterval(refreshTimer);
+            refreshTimer = null;
+        }
+        if (statusTimer) {
+            clearTimeout(statusTimer);
+            statusTimer = null;
+        }
+        await watchService.stop();
+        try {
+            screen.destroy();
+        }
+        catch {
+            // no-op
+        }
+        if (resolveClose)
+            resolveClose();
+    };
+    attachKeybindings(screen, state, {
+        render,
+        quit: closeApp,
+        refresh: async () => {
+            await withBusy("Refreshing status...", async () => {
+                await refreshData();
+            });
+        },
+        runAnalyze: runAnalyzeOnce,
+        toggleWatch: async () => {
+            await withBusy(state.watchActive ? "Stopping watch..." : "Starting watch...", async () => {
+                if (state.watchActive) {
+                    await watchService.stop();
+                    state.watchActive = false;
+                }
+                else {
+                    await watchService.start();
+                    state.watchActive = true;
+                }
+                state.view = "watch";
+                state.selectedNavIndex = viewToIndex("watch");
+            });
+        },
+        runSandboxFix: async () => {
+            await withBusy("Running sandbox fix...", async () => {
+                const ready = getSandboxReadyIncidents(state);
+                const selected = ready[state.selectedSandboxIndex];
+                if (!selected) {
+                    throw new Error("No sandbox-ready incident available.");
+                }
+                const result = await triggerSandboxFix(config, selected.id);
+                await refreshData();
+                state.lastSandboxIncidentId = selected.id;
+                state.lastSandboxResult = result;
+                state.sandboxResultsByIncidentId[selected.id] = result;
+                state.sandboxPrResult = null;
+                state.sandboxPrError = null;
+                state.sandboxPrInFlight = false;
+                if (result.status === "success") {
+                    const nextReady = getSandboxReadyIncidents(state);
+                    if (state.selectedSandboxIndex > nextReady.length - 1) {
+                        state.selectedSandboxIndex = Math.max(0, nextReady.length - 1);
+                    }
+                }
+                state.view = "sandbox";
+                state.sandboxMode = "result";
+                state.selectedNavIndex = viewToIndex("sandbox");
+            });
+        },
+        createPr: async () => {
+            const last = state.lastSandboxResult;
+            if (!last)
+                return;
+            if (!last.verification.passed)
+                return;
+            if (!state.lastSandboxIncidentId)
+                return;
+            if (!last.workspacePath.trim())
+                return;
+            state.sandboxPrInFlight = true;
+            state.sandboxPrError = null;
+            state.sandboxPrResult = null;
+            await withBusy("Creating PR...", async () => {
+                try {
+                    const result = await triggerCreatePr(config, state.lastSandboxIncidentId, last.workspacePath);
+                    await refreshData();
+                    state.sandboxPrResult = result;
+                    if (result.status === "success") {
+                        state.statusMessage = "PR created successfully";
+                    }
+                    else {
+                        state.sandboxPrError = result.summary;
+                    }
+                }
+                catch (error) {
+                    state.sandboxPrError = error instanceof Error ? error.message : String(error);
+                }
+            });
+            state.sandboxPrInFlight = false;
+            render();
+        },
+        markIncidentFixed: async () => {
+            await markIncidentStatus("fixed");
+        },
+        markIncidentInvestigating: async () => {
+            await markIncidentStatus("investigating");
+        },
+    });
+    sidebar.on("select", (_item, index) => {
+        state.selectedNavIndex = index;
+        if (state.focusZone === "nav") {
+            state.view = indexToView(index);
+            if (state.view === "sandbox")
+                state.sandboxMode = "list";
+        }
+        render();
+    });
+    await withBusy("Loading data...", async () => {
+        await refreshData();
+    });
+    refreshTimer = setInterval(() => {
+        void refreshData().then(() => render());
+    }, 10000);
+    screen.on("destroy", () => {
+        if (refreshTimer) {
+            clearInterval(refreshTimer);
+            refreshTimer = null;
+        }
+        if (!closed && resolveClose) {
+            closed = true;
+            resolveClose();
+        }
+    });
+    render();
+    await new Promise((resolve) => {
+        resolveClose = resolve;
+    });
+}

package/dist/tui/data.js

@@ -0,0 +1,150 @@
+import { isApiReachable } from "../api.js";
+import { readConfig } from "../config.js";
+import { loadEvidenceFromConfig } from "../files.js";
+function assertIncidentsResponse(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const candidate = value;
+    if (!Array.isArray(candidate.incidents))
+        return false;
+    return candidate.incidents.every((item) => {
+        if (!item || typeof item !== "object")
+            return false;
+        const i = item;
+        return (typeof i.id === "string" &&
+            typeof i.incidentTitle === "string" &&
+            typeof i.severity === "string" &&
+            (i.status === undefined ||
+                i.status === "new" ||
+                i.status === "investigating" ||
+                i.status === "sandbox_verified" ||
+                i.status === "pr_opened" ||
+                i.status === "fixed") &&
+            typeof i.topContradiction === "string" &&
+            typeof i.rootCause === "string" &&
+            typeof i.impact === "string" &&
+            typeof i.nextAction === "string" &&
+            (i.evidencePoints === undefined || Array.isArray(i.evidencePoints)) &&
+            typeof i.timestamp === "string");
+    });
+}
+export async function loadTuiConfig() {
+    return readConfig();
+}
+export async function fetchApiReachability(config) {
+    return isApiReachable(config);
+}
+export async function fetchIncidents(config) {
+    const response = await fetch(`${config.api_base_url}/api/incidents`, {
+        method: "GET",
+    });
+    if (!response.ok) {
+        throw new Error(`Incidents request failed with status ${response.status}`);
+    }
+    const payload = (await response.json());
+    if (!assertIncidentsResponse(payload)) {
+        throw new Error("Invalid incidents response shape");
+    }
+    return payload.incidents.map((incident) => ({
+        ...incident,
+        status: incident.status ?? "new",
+    }));
+}
+export async function triggerAnalysis(config) {
+    const evidence = await loadEvidenceFromConfig(config);
+    const payload = {
+        project: {
+            name: config.project_name,
+            environment: config.environment,
+        },
+        evidence,
+    };
+    const response = await fetch(`${config.api_base_url}/api/analyze`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify(payload),
+    });
+    if (!response.ok) {
+        const body = await response.text();
+        throw new Error(`Analyze failed (${response.status}): ${body}`);
+    }
+    const data = (await response.json());
+    if (!data || typeof data !== "object") {
+        throw new Error("Analyze response was invalid.");
+    }
+    const result = data.result;
+    if (!result || typeof result !== "object") {
+        throw new Error("Analyze response missing result.");
+    }
+    return result;
+}
+function assertSandboxResult(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const candidate = value;
+    return ((candidate.status === "success" || candidate.status === "failed") &&
+        typeof candidate.workspacePath === "string" &&
+        typeof candidate.patchSummary === "string" &&
+        Array.isArray(candidate.filesChanged) &&
+        !!candidate.verification &&
+        !!candidate.prPreview);
+}
+function assertCreatePrResult(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const candidate = value;
+    return ((candidate.status === "success" || candidate.status === "failed") &&
+        typeof candidate.branchName === "string" &&
+        typeof candidate.commitSha === "string" &&
+        typeof candidate.prUrl === "string" &&
+        (candidate.prNumber === null || typeof candidate.prNumber === "number") &&
+        typeof candidate.summary === "string");
+}
+export async function triggerSandboxFix(config, incidentId) {
+    const response = await fetch(`${config.api_base_url}/api/fix-runner`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify({ incidentId }),
+    });
+    const payload = (await response.json());
+    if (!assertSandboxResult(payload)) {
+        throw new Error("Sandbox runner returned invalid payload.");
+    }
+    return payload;
+}
+export async function triggerCreatePr(config, incidentId, workspacePath) {
+    const response = await fetch(`${config.api_base_url}/api/create-pr`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify({ incidentId, workspacePath }),
+    });
+    const payload = (await response.json());
+    if (!assertCreatePrResult(payload)) {
+        throw new Error("Create PR endpoint returned invalid payload.");
+    }
+    return payload;
+}
+export async function updateIncidentStatus(config, incidentId, status) {
+    const response = await fetch(`${config.api_base_url}/api/incidents/${incidentId}/status`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify({ status }),
+    });
+    if (!response.ok) {
+        const body = await response.text();
+        throw new Error(`Status update failed (${response.status}): ${body}`);
+    }
+    const payload = (await response.json());
+    if (!payload.incident) {
+        throw new Error("Status update response missing incident.");
+    }
+    return payload.incident;
+}

package/dist/tui/keybindings.js

@@ -0,0 +1,122 @@
+import { indexToView, NAV_ITEMS } from "./render.js";
+function moveInView(state, delta) {
+    if (state.view === "incidents" && state.incidentsMode === "list") {
+        state.selectedIncidentIndex = Math.max(0, Math.min(state.incidents.length - 1, state.selectedIncidentIndex + delta));
+        return;
+    }
+    if (state.view === "sandbox" && state.sandboxMode === "list") {
+        const unresolvedCount = state.incidents.filter((incident) => {
+            const result = state.sandboxResultsByIncidentId[incident.id];
+            return !result || result.status !== "success";
+        }).length;
+        state.selectedSandboxIndex = Math.max(0, Math.min(Math.max(0, unresolvedCount - 1), state.selectedSandboxIndex + delta));
+    }
+}
+export function attachKeybindings(screen, state, actions) {
+    screen.key(["C-c", "q", "escape"], () => {
+        void actions.quit();
+    });
+    screen.key(["left"], () => {
+        state.focusZone = "nav";
+        actions.render();
+    });
+    screen.key(["right"], () => {
+        state.focusZone = "view";
+        actions.render();
+    });
+    screen.key(["up", "k"], () => {
+        if (state.focusZone === "nav") {
+            state.selectedNavIndex = Math.max(0, state.selectedNavIndex - 1);
+            actions.render();
+            return;
+        }
+        moveInView(state, -1);
+        actions.render();
+    });
+    screen.key(["down", "j"], () => {
+        if (state.focusZone === "nav") {
+            state.selectedNavIndex = Math.min(NAV_ITEMS.length - 1, state.selectedNavIndex + 1);
+            actions.render();
+            return;
+        }
+        moveInView(state, 1);
+        actions.render();
+    });
+    screen.key(["enter"], () => {
+        if (state.focusZone === "nav") {
+            state.view = indexToView(state.selectedNavIndex);
+            if (state.view === "incidents") {
+                state.incidentsMode = "list";
+            }
+            if (state.view === "sandbox") {
+                state.sandboxMode = "list";
+            }
+            actions.render();
+            return;
+        }
+        if (state.view === "incidents" && state.incidentsMode === "list" && state.incidents.length > 0) {
+            state.incidentsMode = "detail";
+            actions.render();
+            return;
+        }
+        if (state.view === "sandbox" && state.sandboxMode === "list") {
+            void actions.runSandboxFix();
+        }
+    });
+    screen.key(["backspace"], () => {
+        if (state.view === "incidents" && state.incidentsMode === "detail") {
+            state.incidentsMode = "list";
+            actions.render();
+            return;
+        }
+        if (state.view === "sandbox" && state.sandboxMode === "result") {
+            state.sandboxMode = "list";
+            actions.render();
+        }
+    });
+    screen.key(["d"], () => {
+        state.view = "dashboard";
+        state.selectedNavIndex = 0;
+        actions.render();
+    });
+    screen.key(["i"], () => {
+        state.view = "incidents";
+        state.incidentsMode = "list";
+        state.selectedNavIndex = 1;
+        actions.render();
+    });
+    screen.key(["s"], () => {
+        state.view = "sandbox";
+        state.sandboxMode = "list";
+        state.selectedNavIndex = 4;
+        actions.render();
+    });
+    screen.key(["r"], () => {
+        void actions.refresh();
+    });
+    screen.key(["a"], () => {
+        void actions.runAnalyze();
+    });
+    screen.key(["w"], () => {
+        void actions.toggleWatch();
+    });
+    screen.key(["x"], () => {
+        void actions.runSandboxFix();
+    });
+    screen.key(["c"], () => {
+        const canCreatePr = state.view === "sandbox" &&
+            state.sandboxMode === "result" &&
+            !!state.lastSandboxResult &&
+            state.lastSandboxResult.verification.passed &&
+            state.lastSandboxResult.workspacePath.trim().length > 0;
+        if (!canCreatePr)
+            return;
+        void actions.createPr();
+    });
+    screen.key(["f"], () => {
+        void actions.markIncidentFixed();
+    });
+    screen.key(["v"], () => {
+        void actions.markIncidentInvestigating();
+    });
+}