@prads01/blackbox 0.1.0

package/dist/tui/render.js

@@ -0,0 +1,292 @@
+const ACCENT = "#7c3aed";
+const ACCENT_HEX = "#7c3aed";
+export const NAV_ITEMS = [
+    { key: "dashboard", label: "Dashboard" },
+    { key: "incidents", label: "Incidents" },
+    { key: "analyze", label: "Analyze" },
+    { key: "watch", label: "Watch" },
+    { key: "sandbox", label: "Sandbox" },
+    { key: "settings", label: "Settings" },
+];
+function severityTag(severity) {
+    if (severity === "critical")
+        return "{red-fg}CRITICAL{/red-fg}";
+    if (severity === "high")
+        return "{yellow-fg}HIGH{/yellow-fg}";
+    if (severity === "medium")
+        return `{${ACCENT}-fg}MEDIUM{/${ACCENT}-fg}`;
+    return "{green-fg}LOW{/green-fg}";
+}
+function incidentStatusTag(status) {
+    if (status === "investigating")
+        return "{yellow-fg}INVESTIGATING{/yellow-fg}";
+    if (status === "sandbox_verified")
+        return `{${ACCENT}-fg}SANDBOX VERIFIED{/${ACCENT}-fg}`;
+    if (status === "pr_opened")
+        return `{${ACCENT}-fg}PR OPENED{/${ACCENT}-fg}`;
+    if (status === "fixed")
+        return "{green-fg}FIXED{/green-fg}";
+    return "{white-fg}NEW{/white-fg}";
+}
+function formatTimestamp(value) {
+    if (!value)
+        return "N/A";
+    const date = new Date(value);
+    if (Number.isNaN(date.getTime()))
+        return value;
+    return date.toLocaleString();
+}
+function getSandboxReadyIncidents(state) {
+    return state.incidents.filter((incident) => {
+        const sandboxResult = state.sandboxResultsByIncidentId[incident.id];
+        return !sandboxResult || sandboxResult.status !== "success";
+    });
+}
+function canCreatePrFromSandbox(state) {
+    return (state.view === "sandbox" &&
+        state.sandboxMode === "result" &&
+        !!state.lastSandboxResult &&
+        state.lastSandboxResult.verification.passed &&
+        state.lastSandboxResult.workspacePath.trim().length > 0);
+}
+function renderDashboard(state) {
+    const now = Date.now();
+    const recent = state.incidents.slice(0, 5);
+    const total = state.incidents.length;
+    const critical = state.incidents.filter((incident) => incident.severity === "critical").length;
+    const last10Min = state.incidents.filter((incident) => {
+        const ts = new Date(incident.timestamp).getTime();
+        return Number.isFinite(ts) && now - ts <= 10 * 60 * 1000;
+    }).length;
+    const unresolved = getSandboxReadyIncidents(state).length;
+    const sandboxReady = unresolved;
+    return [
+        "{bold}{white-fg}BlackBox Operational Summary{/white-fg}{/bold}",
+        "",
+        "{bold}{white-fg}Core Metrics{/white-fg}{/bold}",
+        `Total Incidents: ${total}`,
+        `Critical Incidents: ${critical}`,
+        `Incidents (last 10m): ${last10Min}`,
+        `Unresolved Incidents: ${unresolved}`,
+        `Sandbox-Ready Incidents: ${sandboxReady}`,
+        "",
+        "{bold}{white-fg}Live System Status{/white-fg}{/bold}",
+        `API Reachable: ${state.apiReachable ? "{green-fg}YES{/green-fg}" : "{red-fg}NO{/red-fg}"}`,
+        `Watch Status: ${state.watchActive ? "{green-fg}ACTIVE{/green-fg}" : "{yellow-fg}STOPPED{/yellow-fg}"}`,
+        `Environment: ${state.config.environment}`,
+        `Monitored Log: ${state.config.log_file}`,
+        `Last Analysis: ${formatTimestamp(state.lastAnalysisAt)}`,
+        `Last Sandbox Result: ${state.lastSandboxResult
+            ? state.lastSandboxResult.status === "success"
+                ? "{green-fg}SUCCESS{/green-fg}"
+                : "{red-fg}FAILED{/red-fg}"
+            : "NONE"}`,
+        "",
+        "{bold}{white-fg}Recent Activity{/white-fg}{/bold}",
+        ...(recent.length > 0
+            ? recent.map((incident, index) => `${index + 1}. ${incident.incidentTitle} [${incidentStatusTag(incident.status)}]`)
+            : ["No recent incidents."]),
+    ].join("\n");
+}
+function renderIncidentList(state) {
+    if (state.incidents.length === 0) {
+        return "No incidents available. Press 'a' to run analysis.";
+    }
+    return [
+        "{bold}{white-fg}Incidents{/white-fg}{/bold}",
+        "{gray-fg}Use Up/Down to select, Enter to open details.{/gray-fg}",
+        "",
+        ...state.incidents.slice(0, 50).map((incident, index) => {
+            const selected = index === state.selectedIncidentIndex;
+            const pointer = selected ? ">" : " ";
+            return `${pointer} ${incident.incidentTitle} | ${incident.severity.toUpperCase()} | ${formatTimestamp(incident.timestamp)} | ${incidentStatusTag(incident.status)}`;
+        }),
+    ].join("\n");
+}
+function renderIncidentDetail(state) {
+    const incident = state.incidents[state.selectedIncidentIndex];
+    if (!incident) {
+        return "Incident not found.";
+    }
+    return [
+        "{bold}{white-fg}Incident Report{/white-fg}{/bold}",
+        "{gray-fg}Backspace to return to incidents list.{/gray-fg}",
+        "",
+        `{bold}Title{/bold}: ${incident.incidentTitle}`,
+        `{bold}Severity{/bold}: ${severityTag(incident.severity)}`,
+        `{bold}Status{/bold}: ${incidentStatusTag(incident.status)}`,
+        `{bold}Timestamp{/bold}: ${formatTimestamp(incident.timestamp)}`,
+        "",
+        "{bold}{white-fg}Contradiction{/white-fg}{/bold}",
+        incident.topContradiction,
+        "",
+        "{bold}{white-fg}Root Cause{/white-fg}{/bold}",
+        incident.rootCause,
+        "",
+        "{bold}{white-fg}Impact{/white-fg}{/bold}",
+        incident.impact,
+        "",
+        "{bold}{white-fg}Proposed Fix{/white-fg}{/bold}",
+        incident.fixSuggestion?.trim() || "No fix suggestion available.",
+        "",
+        "{bold}{white-fg}Evidence Points{/white-fg}{/bold}",
+        ...(incident.evidencePoints?.length
+            ? incident.evidencePoints.slice(0, 5).map((point) => `- ${point}`)
+            : ["- No evidence points available."]),
+    ].join("\n");
+}
+function renderIncidents(state) {
+    return state.incidentsMode === "detail" ? renderIncidentDetail(state) : renderIncidentList(state);
+}
+function renderAnalyze(state) {
+    return [
+        "{bold}{white-fg}Analyze{/white-fg}{/bold}",
+        "",
+        `Status: ${state.analyzeInFlight ? "{yellow-fg}ANALYZING...{/yellow-fg}" : "{green-fg}IDLE{/green-fg}"}`,
+        `Last run: ${formatTimestamp(state.lastAnalysisAt)}`,
+        "",
+        "Press {bold}a{/bold} to trigger analysis once.",
+        "Repeated keypresses are ignored while analysis is running.",
+    ].join("\n");
+}
+function renderWatch(state) {
+    const logs = state.watchLogs.length === 0 ? ["No watch events yet."] : state.watchLogs;
+    return [
+        "{bold}{white-fg}Watch Monitor{/white-fg}{/bold}",
+        `Status: ${state.watchActive ? "{green-fg}ACTIVE{/green-fg}" : "{yellow-fg}STOPPED{/yellow-fg}"}`,
+        `Monitored log file: ${state.config.log_file}`,
+        "",
+        ...logs.slice(-14),
+    ].join("\n");
+}
+function renderSandbox(state) {
+    const ready = getSandboxReadyIncidents(state);
+    if (state.sandboxMode === "result" && state.lastSandboxResult) {
+        const result = state.lastSandboxResult;
+        const status = result.status === "success" ? "{green-fg}SUCCESS{/green-fg}" : "{red-fg}FAILED{/red-fg}";
+        return [
+            "{bold}{white-fg}Sandbox Fix Runner{/white-fg}{/bold}",
+            "{gray-fg}Backspace to return to sandbox-ready incident list. Press c to create PR.{/gray-fg}",
+            "",
+            `Status: ${status}`,
+            "",
+            `{bold}Patch Summary{/bold}: ${result.patchSummary}`,
+            `{bold}Files Changed{/bold}: ${result.filesChanged.join(", ") || "N/A"}`,
+            `{bold}Workspace{/bold}: ${result.workspacePath}`,
+            "",
+            `{bold}Verification{/bold}: ${result.verification.passed ? "{green-fg}PASSED{/green-fg}" : "{red-fg}FAILED{/red-fg}"}`,
+            result.verification.summary,
+            ...result.verification.details.map((line) => `- ${line}`),
+            "",
+            "{bold}{white-fg}PR Preview{/white-fg}{/bold}",
+            `Title: ${result.prPreview.title}`,
+            `Branch: ${result.prPreview.branchName}`,
+            `Diff: ${result.prPreview.diffSnippet || "N/A"}`,
+            "",
+            "{bold}{white-fg}PR Creation{/white-fg}{/bold}",
+            `State: ${state.sandboxPrInFlight
+                ? "{yellow-fg}Creating PR...{/yellow-fg}"
+                : state.sandboxPrResult?.status === "success"
+                    ? "{green-fg}Created{/green-fg}"
+                    : state.sandboxPrError
+                        ? "{red-fg}Failed{/red-fg}"
+                        : "Not started"}`,
+            ...(state.sandboxPrResult
+                ? [
+                    `PR Number: ${state.sandboxPrResult.prNumber ?? "N/A"}`,
+                    `PR URL: ${state.sandboxPrResult.prUrl || "N/A"}`,
+                    `Branch: ${state.sandboxPrResult.branchName || "N/A"}`,
+                    `Commit SHA: ${state.sandboxPrResult.commitSha || "N/A"}`,
+                    `${state.sandboxPrResult.status === "success" ? "{green-fg}" : "{red-fg}"}${state.sandboxPrResult.summary}${state.sandboxPrResult.status === "success" ? "{/green-fg}" : "{/red-fg}"}`,
+                ]
+                : state.sandboxPrError
+                    ? [`{red-fg}${state.sandboxPrError}{/red-fg}`]
+                    : ["Press c to create a real GitHub PR."]),
+        ].join("\n");
+    }
+    if (ready.length === 0) {
+        return [
+            "{bold}{white-fg}Sandbox Fix Runner{/white-fg}{/bold}",
+            "",
+            "{yellow-fg}No sandbox-ready incidents.{/yellow-fg}",
+            "",
+            "Analyze incidents first, then run sandbox verification from this view.",
+        ].join("\n");
+    }
+    return [
+        "{bold}{white-fg}Sandbox Fix Runner{/white-fg}{/bold}",
+        "{gray-fg}Use Up/Down to select. Press Enter or x to run sandbox fix.{/gray-fg}",
+        "",
+        ...ready.map((incident, index) => {
+            const selected = index === state.selectedSandboxIndex;
+            const pointer = selected ? ">" : " ";
+            return `${pointer} ${incident.incidentTitle} | ${incident.severity.toUpperCase()} | ${formatTimestamp(incident.timestamp)}`;
+        }),
+    ].join("\n");
+}
+function renderSettings(state) {
+    return [
+        "{bold}{white-fg}Settings{/white-fg}{/bold}",
+        "",
+        `Project: ${state.config.project_name}`,
+        `Environment: ${state.config.environment}`,
+        `API Base URL: ${state.config.api_base_url}`,
+        `Log File: ${state.config.log_file}`,
+        `Expected File: ${state.config.expected_file}`,
+        `Config File: ${state.config.config_file}`,
+        `Commit File: ${state.config.commit_file}`,
+        "",
+        `API Reachable: ${state.apiReachable ? "{green-fg}YES{/green-fg}" : "{red-fg}NO{/red-fg}"}`,
+    ].join("\n");
+}
+export function viewToIndex(view) {
+    const index = NAV_ITEMS.findIndex((item) => item.key === view);
+    return index >= 0 ? index : 0;
+}
+export function indexToView(index) {
+    return NAV_ITEMS[Math.max(0, Math.min(index, NAV_ITEMS.length - 1))].key;
+}
+export function renderSidebar(sidebar, state) {
+    sidebar.setItems(NAV_ITEMS.map((item, index) => {
+        const cursor = index === state.selectedNavIndex ? ">" : " ";
+        const active = item.key === state.view ? "*" : " ";
+        return `${cursor}${active} ${item.label}`;
+    }));
+}
+export function renderMain(main, state) {
+    if (state.view === "dashboard")
+        main.setContent(renderDashboard(state));
+    if (state.view === "incidents")
+        main.setContent(renderIncidents(state));
+    if (state.view === "analyze")
+        main.setContent(renderAnalyze(state));
+    if (state.view === "watch")
+        main.setContent(renderWatch(state));
+    if (state.view === "sandbox")
+        main.setContent(renderSandbox(state));
+    if (state.view === "settings")
+        main.setContent(renderSettings(state));
+}
+export function renderFooter(footer, state) {
+    const hotkeysBase = "a analyze | w watch | i incidents | d dashboard | s sandbox | x sandbox-fix | f mark-fixed | v mark-investigating";
+    const hotkeys = canCreatePrFromSandbox(state)
+        ? `${hotkeysBase} | c create-pr | r refresh | q quit`
+        : `${hotkeysBase} | r refresh | q quit`;
+    const status = [
+        `focus:${state.focusZone.toUpperCase()}`,
+        `api:${state.apiReachable ? "up" : "down"}`,
+        `env:${state.config.environment}`,
+        `last:${formatTimestamp(state.lastAnalysisAt)}`,
+        `watch:${state.watchActive ? "on" : "off"}`,
+        `sandbox-ready:${getSandboxReadyIncidents(state).length}`,
+    ].join(" | ");
+    const busy = state.busyMessage ? `  {yellow-fg}${state.busyMessage}{/yellow-fg}` : "";
+    const statusMessage = state.statusMessage ? `  {green-fg}${state.statusMessage}{/green-fg}` : "";
+    const error = state.errorMessage ? `  {red-fg}${state.errorMessage}{/red-fg}` : "";
+    footer.setContent(`${hotkeys}\n${status}${busy}${statusMessage}${error}`);
+}
+export const palette = {
+    accent: ACCENT,
+    accentHex: ACCENT_HEX,
+    borderDefault: "gray",
+};

package/dist/tui/types.js

@@ -0,0 +1 @@
+export {};

package/dist/tui/watch-service.js

@@ -0,0 +1,73 @@
+import chokidar from "chokidar";
+import path from "node:path";
+const WATCH_DEBOUNCE_MS = 1200;
+const WATCH_COOLDOWN_MS = 2000;
+export class TuiWatchService {
+    config;
+    callbacks;
+    watcher = null;
+    debounceTimer = null;
+    isAnalyzing = false;
+    lastRunAt = 0;
+    absoluteLogPath;
+    constructor(config, callbacks) {
+        this.config = config;
+        this.callbacks = callbacks;
+        this.absoluteLogPath = path.resolve(process.cwd(), config.log_file);
+    }
+    async start() {
+        if (this.watcher)
+            return;
+        this.callbacks.onLog(`[WATCH] Monitoring ${this.absoluteLogPath}`);
+        this.watcher = chokidar.watch(this.absoluteLogPath, {
+            awaitWriteFinish: {
+                stabilityThreshold: 1500,
+                pollInterval: 100,
+            },
+        });
+        this.watcher.on("change", () => {
+            if (this.isAnalyzing)
+                return;
+            if (Date.now() - this.lastRunAt < WATCH_COOLDOWN_MS)
+                return;
+            if (this.debounceTimer) {
+                clearTimeout(this.debounceTimer);
+            }
+            this.debounceTimer = setTimeout(() => {
+                this.debounceTimer = null;
+                void this.runAnalyze();
+            }, WATCH_DEBOUNCE_MS);
+        });
+    }
+    async stop() {
+        if (this.debounceTimer) {
+            clearTimeout(this.debounceTimer);
+            this.debounceTimer = null;
+        }
+        if (this.watcher) {
+            await this.watcher.close();
+            this.watcher = null;
+            this.callbacks.onLog("[WATCH] Stopped monitoring.");
+        }
+    }
+    async runAnalyze() {
+        if (this.isAnalyzing)
+            return;
+        if (Date.now() - this.lastRunAt < WATCH_COOLDOWN_MS)
+            return;
+        this.isAnalyzing = true;
+        this.callbacks.onLog("[DETECTED] Log change detected. Re-running analysis...");
+        try {
+            await this.callbacks.onChangeAnalyze();
+            this.callbacks.onLog("[WATCH] Analysis complete.");
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            this.callbacks.onLog(`[WATCH][ERROR] ${message}`);
+        }
+        finally {
+            this.isAnalyzing = false;
+            this.lastRunAt = Date.now();
+        }
+    }
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/format.js

@@ -0,0 +1,18 @@
+import pc from "picocolors";
+export const colors = {
+    title: (value) => pc.bold(pc.cyan(value)),
+    muted: (value) => pc.dim(value),
+    ok: (value) => pc.green(value),
+    warn: (value) => pc.yellow(value),
+    bad: (value) => pc.red(value),
+    key: (value) => pc.bold(pc.white(value)),
+};
+export function section(title) {
+    console.log(`\n${colors.title(`=== ${title} ===`)}`);
+}
+export function row(label, value) {
+    console.log(`${colors.key(label)} ${value}`);
+}
+export function line() {
+    console.log(colors.muted("------------------------------------------------------------"));
+}

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@prads01/blackbox",
+  "version": "0.1.0",
+  "description": "BlackBox CLI for local incident analysis and sandboxed fixes",
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/index.js",
+  "bin": {
+    "blackbox": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json && chmod +x dist/index.js",
+    "dev": "tsx src/index.ts",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@clack/prompts": "^1.1.0",
+    "@types/blessed": "^0.1.27",
+    "blessed": "^0.1.81",
+    "boxen": "^8.0.1",
+    "chalk": "^5.4.1",
+    "chokidar": "^4.0.3",
+    "commander": "^13.1.0",
+    "js-yaml": "^4.1.0",
+    "ora": "^8.2.0",
+    "picocolors": "^1.1.1"
+  },
+  "devDependencies": {
+    "@types/node": "^20.19.19",
+    "tsx": "^4.20.6",
+    "typescript": "^5.9.3"
+  }
+}