vericify 0.1.0

package/src/tui/app.js

@@ -0,0 +1,571 @@
+import { readFileSync, openSync } from "node:fs";
+import { emitKeypressEvents } from "node:readline";
+import { stdin as processStdin, stdout } from "node:process";
+import tty from "node:tty";
+import { createDebouncedWatch } from "../core/fs.js";
+import { appendProcessPost } from "../post/process-posts.js";
+import { upsertHandoff } from "../store/handoffs.js";
+import { appendRunLedgerEntry } from "../store/run-ledger.js";
+import { appendStatusEvent } from "../store/status-events.js";
+import { upsertTodoNode } from "../store/todo-state.js";
+import { formatTimestamp } from "../core/util.js";
+import { completeCommand, executeCommand } from "./commands.js";
+import {
+  buildCompareSections,
+  buildHistorySections,
+  buildHubMetrics,
+  buildHubSections,
+  buildInspectSections,
+  buildRunBoardSection,
+  layoutTierForWidth,
+} from "./panels.js";
+import { createRuntimeRecorder } from "./runtime-activity.js";
+
+function altBufferOn() {
+  stdout.write("\x1b[?1049h\x1b[?25l\x1b[2J\x1b[H");
+}
+
+function altBufferOff() {
+  stdout.write("\x1b[?25h\x1b[?1049l");
+}
+
+function clearScreen() {
+  stdout.write("\x1b[2J\x1b[H");
+}
+
+function truncate(text, width) {
+  const plain = String(text ?? "");
+  return plain.length <= width ? plain : `${plain.slice(0, Math.max(0, width - 1))}…`;
+}
+
+function line(text = "") {
+  stdout.write(`${text}\n`);
+}
+
+function boxTitle(text, width) {
+  return `┌${truncate(` ${text} `, Math.max(1, width - 2)).padEnd(Math.max(1, width - 2), "─")}┐`;
+}
+
+function boxFooter(width) {
+  return `└${"─".repeat(Math.max(1, width - 2))}┘`;
+}
+
+function padRight(text, width) {
+  return String(text ?? "").padEnd(Math.max(0, width), " ");
+}
+
+function bestCompareTarget(run) {
+  return run?.similarity?.neighbors?.[0]?.run_id;
+}
+
+function panelTitle(section) {
+  return section.tone ? `${section.title} · ${section.tone}` : section.title;
+}
+
+function renderPanelLines(section, width) {
+  const innerWidth = Math.max(1, width - 2);
+  const rows = Array.isArray(section.rows) && section.rows.length ? section.rows : ["No data."];
+  const lines = [
+    boxTitle(panelTitle(section), width),
+  ];
+  for (const row of rows) {
+    for (const fragment of String(row ?? "").split("\n")) {
+      const content = truncate(` ${fragment}`, innerWidth).padEnd(innerWidth, " ");
+      lines.push(`│${content}│`);
+    }
+  }
+  lines.push(boxFooter(width));
+  return lines;
+}
+
+function renderPanelRow(sections, width) {
+  if (!sections.length) return;
+  const columns = sections.length;
+  const gap = 2;
+  const panelWidth = Math.max(24, Math.floor((width - gap * (columns - 1)) / columns));
+  const rendered = sections.map((section) => renderPanelLines(section, panelWidth));
+  const rowHeight = Math.max(...rendered.map((panel) => panel.length));
+  for (let lineIndex = 0; lineIndex < rowHeight; lineIndex += 1) {
+    const row = rendered
+      .map((panel) => padRight(panel[lineIndex] ?? "", panelWidth))
+      .join(" ".repeat(gap));
+    line(truncate(row, width));
+  }
+}
+
+function renderPanelGrid(sections, width, tier) {
+  const columns = tier === "narrow" ? 1 : 2;
+  let row = [];
+  const flush = () => {
+    if (!row.length) return;
+    renderPanelRow(row, width);
+    row = [];
+  };
+  for (const section of sections) {
+    if (section.fullWidth) {
+      flush();
+      renderPanelRow([section], width);
+      continue;
+    }
+    row.push(section);
+    if (row.length >= columns) flush();
+  }
+  flush();
+}
+
+export async function runHub({ workspaceRoot, feedFile, loadState, watchedPaths }) {
+  const state = {
+    view: "hub",
+    mode: "normal",
+    selectedIndex: 0,
+    compareTarget: undefined,
+    commandBuffer: "",
+    commandHistory: [],
+    commandHistoryIndex: -1,
+    message: "Vericify ready.",
+    projected: loadState(),
+  };
+  const hubSourceModule = "vericify-hub";
+  const hubTraceId = `hub-${process.pid}-${Date.now()}`;
+  let suppressWatchUntil = 0;
+  const runtimeRecorder = createRuntimeRecorder({
+    workspaceRoot,
+    traceId: hubTraceId,
+    sourceModule: hubSourceModule,
+    isInteractive: !feedFile && Boolean(processStdin.isTTY),
+  });
+
+  const fallbackRun = {
+    run: { title: "No runs", run_id: "-", status: "-", updated_at: "-" },
+    branches: [],
+    lanes: [],
+    nodes: [],
+    handoff_timeline: { items: [] },
+    recent_checkpoints: [],
+    deltas: [],
+    activity_items: [],
+    process_posts: [],
+    similarity: { neighbors: [] },
+  };
+
+  const rerender = () => {
+    clearScreen();
+    const width = Math.max(80, stdout.columns || 80);
+    const tier = layoutTierForWidth(width);
+    const runs = state.projected.runs;
+    const selected = runs[state.selectedIndex] ?? runs[0] ?? fallbackRun;
+    const compareRun = state.compareTarget
+      ? runs.find((run) => run.run.run_id === state.compareTarget)
+      : runs.find((run) => run.run.run_id === bestCompareTarget(selected));
+    const sections = [
+      buildRunBoardSection(state.projected, selected, { tier }),
+      ...(state.view === "compare"
+        ? buildCompareSections(selected, compareRun, { tier })
+        : state.view === "inspect"
+          ? buildInspectSections(selected, { tier })
+          : state.view === "history"
+            ? buildHistorySections(state.projected, selected, { tier })
+            : buildHubSections(state.projected, selected, { tier })),
+    ];
+
+    line(boxTitle(` Vericify Hub | ${state.mode} | ${workspaceRoot} `, width));
+    line(truncate(`Runs: ${runs.length} | Generated: ${formatTimestamp(state.projected.generated_at)} | View: ${state.view} | Layout: ${tier} | Message: ${state.message}`, width));
+    line(truncate(buildHubMetrics(state.projected, { tier }), width));
+    line("─".repeat(width));
+    renderPanelGrid(sections, width, tier);
+    const prompt = state.mode === "command"
+      ? `/${state.commandBuffer}`
+      : "[q quit] [j/k move] [Enter inspect] [c compare] [y history] [r refresh] [/ command] [h hub]";
+    line(truncate(prompt, width));
+    line(boxFooter(width));
+  };
+
+  const refresh = () => {
+    state.projected = loadState();
+    const max = Math.max(0, state.projected.runs.length - 1);
+    state.selectedIndex = Math.min(state.selectedIndex, max);
+    rerender();
+  };
+
+  const selectedRunId = () => state.projected.runs[state.selectedIndex]?.run?.run_id;
+
+  const captureRuntimeState = () => ({
+    view: state.view,
+    runId: selectedRunId(),
+  });
+
+  const recordInteractiveTransition = (before, {
+    source = "keyboard",
+    refreshReason,
+    commandActionType,
+  } = {}) => {
+    const after = captureRuntimeState();
+    let wrote = false;
+    if (before.view !== after.view) {
+      wrote = runtimeRecorder.recordViewChange(after.view, after.runId, { source }) || wrote;
+    }
+    if (before.runId !== after.runId) {
+      wrote = runtimeRecorder.recordFocus(after.runId, { view: after.view, source }) || wrote;
+    }
+    if (refreshReason) {
+      wrote = runtimeRecorder.recordRefresh(after.runId, {
+        view: after.view,
+        source,
+        reason: refreshReason,
+        runCount: state.projected.runs.length,
+      }) || wrote;
+    }
+    if (commandActionType) {
+      wrote = runtimeRecorder.recordCommandWrite(commandActionType, after.runId, { view: after.view }) || wrote;
+    }
+    if (wrote) {
+      suppressWatch();
+      state.projected = loadState();
+      const max = Math.max(0, state.projected.runs.length - 1);
+      state.selectedIndex = Math.min(state.selectedIndex, max);
+      rerender();
+    }
+  };
+
+  const parseOptionalJson = (raw) => {
+    if (!raw) return undefined;
+    return JSON.parse(raw);
+  };
+
+  const suppressWatch = (durationMs = 1200) => {
+    suppressWatchUntil = Math.max(suppressWatchUntil, Date.now() + durationMs);
+  };
+
+  const executeStoreAction = async (action) => {
+    if (!action) return;
+    suppressWatch();
+    if (action.type === "post") {
+      appendProcessPost(workspaceRoot, action.params);
+      return;
+    }
+    if (action.type === "handoff") {
+      upsertHandoff(workspaceRoot, action.params);
+      return;
+    }
+    if (action.type === "todo") {
+      upsertTodoNode(workspaceRoot, action.params);
+      return;
+    }
+    if (action.type === "ledger") {
+      appendRunLedgerEntry(workspaceRoot, {
+        ...action.params,
+        metadata: parseOptionalJson(action.params.metadata_json),
+      });
+      return;
+    }
+    if (action.type === "event") {
+      appendStatusEvent(workspaceRoot, {
+        ...action.params,
+        payload: parseOptionalJson(action.params.payload_json),
+      });
+    }
+  };
+
+  const emitHubEvent = async (eventType, status, summary, runId = "workspace:current") => {
+    suppressWatch();
+    appendStatusEvent(workspaceRoot, {
+      trace_id: hubTraceId,
+      source_module: hubSourceModule,
+      event_type: eventType,
+      status,
+      payload: {
+        summary,
+        run_id: runId,
+        workspace_root: workspaceRoot,
+      },
+    });
+  };
+
+  const applyCommandResult = async (result, { source = "keyboard" } = {}) => {
+    if (!result) return false;
+    const before = captureRuntimeState();
+    if (result.quit) return true;
+    if (result.patch?.view) state.view = result.patch.view;
+    if (result.patch?.compareTarget !== undefined) state.compareTarget = result.patch.compareTarget;
+    if (result.patch?.selectedIndexDelta) {
+      const total = state.projected.runs.length || 1;
+      state.selectedIndex = (state.selectedIndex + result.patch.selectedIndexDelta + total) % total;
+    }
+    if (result.patch?.selectTarget) {
+      const raw = result.patch.selectTarget;
+      const numeric = Number(raw);
+      if (Number.isInteger(numeric) && numeric >= 1 && numeric <= state.projected.runs.length) {
+        state.selectedIndex = numeric - 1;
+      } else {
+        const match = state.projected.runs.findIndex((run) => run.run.run_id === raw);
+        if (match >= 0) state.selectedIndex = match;
+      }
+    }
+    if (result.action) {
+      await executeStoreAction(result.action);
+    }
+    if (result.refresh) refresh();
+    if (result.message) state.message = result.message;
+    recordInteractiveTransition(before, {
+      source,
+      refreshReason: result.refresh ? "command_result" : undefined,
+      commandActionType: result.action?.type,
+    });
+    return false;
+  };
+
+  const runFeedCommands = async (lines) => {
+    if (!lines.length) return;
+    state.mode = "feed";
+    rerender();
+    for (const rawLine of lines) {
+      const trimmed = rawLine.trim();
+      if (!trimmed) continue;
+      const shouldQuit = await applyCommandResult(executeCommand(trimmed.replace(/^\//, ""), state), { source: "feed" });
+      rerender();
+      if (shouldQuit) return true;
+    }
+    state.mode = "normal";
+    state.message = "Feed complete. Keyboard control restored.";
+    rerender();
+    return false;
+  };
+
+  altBufferOn();
+  rerender();
+  await emitHubEvent("HUB_SESSION_STARTED", "started", "Vericify hub started.");
+  refresh();
+
+  const stopWatching = createDebouncedWatch(watchedPaths, () => {
+    if (Date.now() < suppressWatchUntil) return;
+    const before = captureRuntimeState();
+    state.message = "Workspace artifacts changed.";
+    refresh();
+    recordInteractiveTransition(before, {
+      source: "watch",
+      refreshReason: "workspace_change",
+    });
+  });
+
+  let keyboardInput = processStdin;
+  const setupKeyboard = (inputStream) => {
+    keyboardInput = inputStream;
+    if (!feedFile) runtimeRecorder.setInteractive(true);
+    emitKeypressEvents(keyboardInput);
+    if (keyboardInput.isTTY) keyboardInput.setRawMode(true);
+    keyboardInput.resume();
+    keyboardInput.on("keypress", onKeypress);
+    if (runtimeRecorder.recordInitialSelection(selectedRunId(), state.view)) {
+      suppressWatch();
+      refresh();
+    }
+  };
+
+  const teardownKeyboard = () => {
+    if (!keyboardInput) return;
+    keyboardInput.off("keypress", onKeypress);
+    if (keyboardInput.isTTY) keyboardInput.setRawMode(false);
+  };
+
+  const restoreKeyboardFromTty = () => {
+    if (processStdin.isTTY) {
+      setupKeyboard(processStdin);
+      return;
+    }
+    try {
+      const fd = openSync("/dev/tty", "r");
+      const ttyInput = new tty.ReadStream(fd);
+      setupKeyboard(ttyInput);
+    } catch {
+      state.message = "Feed complete. No interactive TTY available.";
+      rerender();
+    }
+  };
+
+  const exit = async () => {
+    try {
+      await emitHubEvent("HUB_SESSION_STOPPED", "done", "Vericify hub stopped.");
+    } catch {
+      // ignore shutdown write failures
+    }
+    teardownKeyboard();
+    stopWatching();
+    altBufferOff();
+  };
+
+  const onKeypress = async (str, key = {}) => {
+    if (key.sequence === "\u001a") {
+      state.message = "Suspending Vericify.";
+      rerender();
+      teardownKeyboard();
+      altBufferOff();
+      process.kill(process.pid, "SIGSTOP");
+      return;
+    }
+    if (state.mode === "command") {
+      if (key.name === "return") {
+        const command = state.commandBuffer;
+        state.commandHistory.push(command);
+        state.commandHistoryIndex = state.commandHistory.length;
+        state.commandBuffer = "";
+        state.mode = "normal";
+        const shouldQuit = await applyCommandResult(executeCommand(command, state), { source: "command" });
+        rerender();
+        if (shouldQuit) await exit();
+        return;
+      }
+      if (key.name === "escape") {
+        state.mode = "normal";
+        state.commandBuffer = "";
+        state.message = "Command cancelled.";
+        rerender();
+        return;
+      }
+      if (key.name === "backspace") {
+        state.commandBuffer = state.commandBuffer.slice(0, -1);
+        rerender();
+        return;
+      }
+      if (key.name === "up") {
+        state.commandHistoryIndex = Math.max(0, state.commandHistoryIndex - 1);
+        state.commandBuffer = state.commandHistory[state.commandHistoryIndex] ?? state.commandBuffer;
+        rerender();
+        return;
+      }
+      if (key.name === "down") {
+        state.commandHistoryIndex = Math.min(state.commandHistory.length, state.commandHistoryIndex + 1);
+        state.commandBuffer = state.commandHistory[state.commandHistoryIndex] ?? "";
+        rerender();
+        return;
+      }
+      if (key.name === "tab") {
+        state.commandBuffer = completeCommand(
+          state.commandBuffer,
+          state.projected.runs.map((run) => run.run.run_id)
+        );
+        rerender();
+        return;
+      }
+      if (key.ctrl && key.name === "r") {
+        const query = state.commandBuffer.trim();
+        const match = [...state.commandHistory].reverse().find((item) => item.includes(query));
+        state.commandBuffer = match ?? state.commandBuffer;
+        state.message = match ? "History search matched a prior command." : "History search found no match.";
+        rerender();
+        return;
+      }
+      if (str) {
+        state.commandBuffer += str;
+        rerender();
+      }
+      return;
+    }
+
+    if (key.name === "q" || (key.ctrl && key.name === "c")) {
+      await exit();
+      return;
+    }
+    if (key.name === "j" || key.name === "down") {
+      const before = captureRuntimeState();
+      if (state.projected.runs.length > 0) {
+        state.selectedIndex = Math.min(state.projected.runs.length - 1, state.selectedIndex + 1);
+      }
+      rerender();
+      recordInteractiveTransition(before, { source: "keyboard" });
+      return;
+    }
+    if (key.name === "k" || key.name === "up") {
+      const before = captureRuntimeState();
+      if (state.projected.runs.length > 0) {
+        state.selectedIndex = Math.max(0, state.selectedIndex - 1);
+      }
+      rerender();
+      recordInteractiveTransition(before, { source: "keyboard" });
+      return;
+    }
+    if (key.name === "return") {
+      const before = captureRuntimeState();
+      state.view = state.view === "inspect" ? "hub" : "inspect";
+      rerender();
+      recordInteractiveTransition(before, { source: "keyboard" });
+      return;
+    }
+    if (key.name === "c") {
+      const before = captureRuntimeState();
+      state.view = "compare";
+      state.compareTarget = bestCompareTarget(state.projected.runs[state.selectedIndex]);
+      rerender();
+      recordInteractiveTransition(before, { source: "keyboard" });
+      return;
+    }
+    if (key.name === "y") {
+      const before = captureRuntimeState();
+      state.view = "history";
+      rerender();
+      recordInteractiveTransition(before, { source: "keyboard" });
+      return;
+    }
+    if (key.name === "h") {
+      const before = captureRuntimeState();
+      state.view = "hub";
+      rerender();
+      recordInteractiveTransition(before, { source: "keyboard" });
+      return;
+    }
+    if (key.name === "r") {
+      const before = captureRuntimeState();
+      refresh();
+      recordInteractiveTransition(before, {
+        source: "keyboard",
+        refreshReason: "manual_refresh",
+      });
+      return;
+    }
+    if (str === "/") {
+      state.mode = "command";
+      state.commandBuffer = "";
+      rerender();
+    }
+  };
+
+  process.on("SIGCONT", () => {
+    altBufferOn();
+    restoreKeyboardFromTty();
+    state.message = "Resumed Vericify.";
+    suppressWatch();
+    appendStatusEvent(workspaceRoot, {
+      trace_id: hubTraceId,
+      source_module: hubSourceModule,
+      event_type: "HUB_SESSION_RESUMED",
+      status: "started",
+      payload: {
+        summary: "Vericify hub resumed.",
+        workspace_root: workspaceRoot,
+      },
+    });
+    refresh();
+  });
+
+  if (feedFile) {
+    const lines = readFileSync(feedFile, "utf8").split(/\r?\n/);
+    const quit = await runFeedCommands(lines);
+    if (quit) {
+      await exit();
+      return;
+    }
+  }
+
+  if (!processStdin.isTTY) {
+    const rl = createInterface({ input: processStdin, terminal: false });
+    const lines = [];
+    for await (const lineValue of rl) lines.push(lineValue);
+    const quit = await runFeedCommands(lines);
+    if (quit) {
+      await exit();
+      return;
+    }
+    restoreKeyboardFromTty();
+  } else {
+    setupKeyboard(processStdin);
+  }
+}