tickmarkr 1.72.0 → 1.74.0

package/dist/tui/ink/studio-app.js

@@ -0,0 +1,320 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render, useApp, useInput } from "ink";
+import { useEffect, useRef, useState } from "react";
+import { allAdapters, doctorAgeMs, readDoctor } from "../../adapters/registry.js";
+import { fleetEditableFromConfig, loadConfig } from "../../config/config.js";
+import { loadGraph } from "../../graph/graph.js";
+import { Journal, readAllTelemetry, RUNS_WINDOW, } from "../../run/journal.js";
+import { buildSaveProposal, confirmSave } from "../save.js";
+import { FleetStaging } from "../staging.js";
+import { DiffConfirmationScreen, StudioScreen, } from "./components.js";
+const STATUS = {
+    "task-dispatch": "running", "task-done": "done", "task-failed": "failed",
+    "task-human": "human", "task-approved": "pending",
+};
+const HELP = [
+    "Key bindings",
+    "1-5      switch view",
+    "tab      cycle views",
+    "?        show this help",
+    "esc / q  quit",
+    "u        revert staged changes",
+    "s        save staged changes",
+];
+function loadFleetData(repoRoot) {
+    try {
+        const cfg = loadConfig(repoRoot);
+        const health = readDoctor(repoRoot);
+        if (!health)
+            return undefined;
+        const editable = fleetEditableFromConfig(cfg);
+        const adapters = allAdapters().flatMap((adapter) => {
+            if (!health[adapter.id]?.installed)
+                return [];
+            const models = adapter.channels(cfg).map((channel) => ({
+                model: channel.model,
+                tier: channel.tier,
+                channel: channel.channel,
+            }));
+            return models.length ? [{ adapter: adapter.id, models }] : [];
+        });
+        return {
+            adapters,
+            health,
+            doctorAgeMs: doctorAgeMs(repoRoot),
+            denyAdapters: editable.denyAdapters,
+            denyModels: editable.denyModels,
+            telemetry: readAllTelemetry(repoRoot, RUNS_WINDOW),
+        };
+    }
+    catch {
+        // Best-effort read surface: line-mode commands remain the diagnostic path when config is unavailable.
+        return undefined;
+    }
+}
+function emptyStaging() {
+    return new FleetStaging({
+        denyAdapters: [],
+        denyModels: [],
+        tiers: {},
+        map: {},
+        floors: {},
+    });
+}
+function loadStaging(repoRoot) {
+    try {
+        return new FleetStaging(fleetEditableFromConfig(loadConfig(repoRoot)));
+    }
+    catch {
+        return emptyStaging();
+    }
+}
+const componentView = (id, label, line) => ({ id, label, render: () => [line] });
+const createView = (id, label) => (..._) => componentView(id, label, `${label} view`);
+const createFleetView = createView("fleet", "Fleet"), createRoutingView = createView("routing", "Routing"), createPreviewView = createView("preview", "Preview"), createProfileView = createView("profile", "Profile"), createRunsView = createView("runs", "Runs");
+function defaultViews(repoRoot, staging) {
+    return [
+        createFleetView(loadFleetData(repoRoot), staging),
+        createRoutingView({ repoRoot, staging }),
+        createPreviewView({ cwd: repoRoot }),
+        createProfileView({ repoRoot }),
+        createRunsView(undefined, { repoRoot }),
+    ];
+}
+const emptyGraph = () => ({ version: 1, spec: { source: "prd", paths: [], hash: "" }, tasks: [] });
+function loadRunsData(repoRoot) {
+    const runId = Journal.latestRunId(repoRoot, { withJournal: true }) ?? undefined;
+    let graph = emptyGraph();
+    try {
+        graph = loadGraph(repoRoot);
+    }
+    catch { /* no graph loaded */ }
+    return { runId, events: runId ? Journal.open(repoRoot, runId).read() : [], graph };
+}
+export function foldConsultDossier(data, taskId) {
+    let prompt = 0;
+    const verdicts = data.events.flatMap((event) => {
+        if (event.taskId !== taskId || event.event !== "consult-verdict")
+            return [];
+        const action = event.data.action;
+        if (!["retry", "reroute", "decompose", "human"].includes(action))
+            return [];
+        return [{
+                action,
+                reason: typeof event.data.reason === "string" ? event.data.reason : undefined,
+                prompt: data.prompts?.[taskId]?.[prompt++],
+            }];
+    });
+    return { taskId, verdicts };
+}
+export function buildRunsCockpitTasks(data, nowMs) {
+    return data.graph.tasks.map((task) => {
+        const events = data.events.filter((event) => event.taskId === task.id);
+        const state = [...events].reverse().find((event) => STATUS[event.event]);
+        const status = STATUS[state?.event ?? ""] ?? task.status;
+        const phaseStart = [...events].reverse().find((event) => event.event === "phase-start");
+        const start = phaseStart ?? (state?.event === "task-dispatch" ? state : undefined);
+        const phase = typeof phaseStart?.data.phase === "string" ? phaseStart.data.phase : undefined;
+        const running = status === "running" && start !== undefined;
+        const elapsedMs = running ? Math.max(0, nowMs - Date.parse(start.ts)) : 0;
+        return {
+            id: task.id, status,
+            ...(running ? { phase: phase ?? "worker",
+                elapsed: `${Math.floor(elapsedMs / 1000)}s` } : {}),
+            consultCount: foldConsultDossier(data, task.id).verdicts.length,
+        };
+    });
+}
+function dossierLines(data) {
+    if (!data)
+        return ["d opens consult dossier"];
+    if (!data.verdicts.length)
+        return [`no consult verdicts recorded for ${data.taskId}`];
+    return [`Consult dossier — ${data.taskId}`, "d back", ...data.verdicts.flatMap((verdict, index) => [
+            `❯ ${index + 1}. ${verdict.action}${verdict.reason ? ` — ${verdict.reason}` : ""}`,
+            `  prompt ${index + 1}`,
+            ...(verdict.prompt ?? "(prompt unavailable)").split("\n")
+                .map((line) => `  ${line.replace(/^#{1,6}\s+/, "")}`),
+        ])];
+}
+function runsLines(runId, tasks, cursor) {
+    if (!runId)
+        return ["Runs cockpit", "no run loaded"];
+    return [`Runs cockpit — ${runId}`, "d consult dossier", ...tasks.flatMap((task, index) => [
+            `${index === cursor ? "❯ " : "  "}${task.id} — ${task.status}`,
+            `  ${task.phase ? `${task.phase} · ${task.elapsed}` : "waiting"}${task.consultCount ? ` · ${task.consultCount} consult verdict` : ""}`,
+        ])];
+}
+export function StudioApp({ views: suppliedViews, repoRoot = process.cwd(), globalDir, staging: suppliedStaging, runsData: suppliedRunsData, clock = Date.now, columns = 80, rows = 24, }) {
+    const { exit } = useApp();
+    const stagingRef = useRef(undefined);
+    stagingRef.current ??= suppliedStaging ?? loadStaging(repoRoot);
+    const staging = stagingRef.current;
+    const viewsRef = useRef(undefined);
+    viewsRef.current ??= suppliedViews ?? defaultViews(repoRoot, staging);
+    const views = viewsRef.current;
+    const [active, setActive] = useState(0);
+    const [help, setHelp] = useState(false);
+    const [saveProposal, setSaveProposal] = useState(null);
+    const [notice, setNotice] = useState(null);
+    const [runsData, setRunsData] = useState(() => suppliedRunsData ?? loadRunsData(repoRoot));
+    const [nowMs, setNowMs] = useState(clock);
+    const [dossierOpen, setDossierOpen] = useState(false);
+    const [, repaint] = useState(0);
+    const nativeRuns = suppliedViews === undefined && views[active]?.id === "runs";
+    const runTasks = buildRunsCockpitTasks(runsData, nowMs);
+    const runsCursor = Math.max(0, runTasks.findIndex((task) => task.consultCount > 0));
+    const selectedRunTask = runTasks[runsCursor];
+    const dossier = selectedRunTask ? foldConsultDossier(runsData, selectedRunTask.id) : undefined;
+    useEffect(() => {
+        if (!nativeRuns)
+            return;
+        const timer = setInterval(() => {
+            setNowMs(clock());
+            if (!suppliedRunsData)
+                setRunsData(loadRunsData(repoRoot));
+        }, 250);
+        return () => clearInterval(timer);
+    }, [clock, nativeRuns, repoRoot, suppliedRunsData]);
+    useInput((input, key) => {
+        if (key.escape) {
+            if (help)
+                setHelp(false);
+            else if (saveProposal)
+                setSaveProposal(null);
+            else
+                exit();
+            return;
+        }
+        if (key.ctrl && input === "c") {
+            exit();
+            return;
+        }
+        if (saveProposal) {
+            if (input === "n") {
+                setSaveProposal(null);
+            }
+            else if (input === "t") {
+                const target = saveProposal.target === "repo" ? "global" : "repo";
+                setSaveProposal(buildSaveProposal({
+                    repoRoot,
+                    loaded: staging.loadedState,
+                    staged: staging.current,
+                    target,
+                    globalDir,
+                }));
+            }
+            else if (input === "y") {
+                const result = confirmSave({
+                    repoRoot,
+                    loaded: staging.loadedState,
+                    staged: staging.current,
+                    target: saveProposal.target,
+                    globalDir,
+                });
+                if (result.kind === "written") {
+                    const nextStaging = new FleetStaging(staging.current);
+                    stagingRef.current = nextStaging;
+                    if (!suppliedViews)
+                        viewsRef.current = defaultViews(repoRoot, nextStaging);
+                    setNotice(`wrote ${result.path}`);
+                }
+                else if (result.kind === "refused") {
+                    setNotice(`save refused: ${result.reason}`);
+                }
+                setSaveProposal(null);
+            }
+            return;
+        }
+        if (input === "q") {
+            if (!help)
+                exit();
+            return;
+        }
+        if (input === "?") {
+            setHelp(true);
+            return;
+        }
+        if (help)
+            return;
+        if (nativeRuns && input === "d" && (dossierOpen || selectedRunTask)) {
+            setDossierOpen((open) => !open);
+            return;
+        }
+        if (input === "s") {
+            if (!staging.isDirty) {
+                setNotice("no staged changes");
+            }
+            else {
+                setNotice(null);
+                setSaveProposal(buildSaveProposal({
+                    repoRoot,
+                    loaded: staging.loadedState,
+                    staged: staging.current,
+                    target: "repo",
+                    globalDir,
+                }));
+            }
+            return;
+        }
+        if (input === "u") {
+            staging.revert();
+            setNotice(staging.isDirty ? null : "no staged changes");
+            repaint((revision) => revision + 1);
+            return;
+        }
+        if (key.tab) {
+            setActive((index) => (index + 1) % views.length);
+            setNotice(null);
+            setDossierOpen(false);
+            return;
+        }
+        if (/^[1-9]$/.test(input)) {
+            const index = Number(input) - 1;
+            if (index < views.length) {
+                setActive(index);
+                setNotice(null);
+                setDossierOpen(false);
+            }
+            return;
+        }
+        const name = key.upArrow ? "up" : key.downArrow ? "down" : null;
+        if (name) {
+            views[active]?.key?.(name);
+            repaint((revision) => revision + 1);
+        }
+    });
+    const view = views[active];
+    const lines = help
+        ? HELP
+        : nativeRuns
+            ? dossierOpen
+                ? dossierLines(dossier)
+                : runsLines(runsData.runId, runTasks, runsCursor)
+            : [
+                ...view.render({ cols: columns, rows: Math.max(rows - 2, 1) }),
+                ...(notice ? [notice] : []),
+            ];
+    const count = staging.changeCount;
+    const status = staging.isDirty
+        ? `● ${count} staged change${count === 1 ? "" : "s"}`
+        : "no staged changes";
+    return (_jsx(StudioScreen, { tabs: views.map((candidate) => candidate.label), active: active, lines: lines, status: status, children: saveProposal
+            ? (_jsx(DiffConfirmationScreen, { target: saveProposal.target, targetPath: saveProposal.targetPath, diff: saveProposal.diff, liveRun: saveProposal.liveRun }))
+            : undefined }));
+}
+export async function runStudioInk({ input, output, views, repoRoot, globalDir, staging, runsData, clock, debug = false, }) {
+    const app = render(_jsx(StudioApp, { views: views, repoRoot: repoRoot, globalDir: globalDir, staging: staging, runsData: runsData, clock: clock, columns: output.columns, rows: output.rows }), {
+        stdin: input,
+        stdout: output,
+        exitOnCtrlC: false,
+        patchConsole: false,
+        debug,
+    });
+    try {
+        await app.waitUntilExit();
+    }
+    finally {
+        app.unmount();
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tickmarkr",
-  "version": "1.72.0",
+  "version": "1.74.0",
   "description": "Spec in, verified work out.",
   "type": "module",
   "license": "MIT",

package/dist/tui/app.d.ts

@@ -1,72 +0,0 @@
-import { type OutputStream } from "../tui/engine.js";
-import type { InputStream } from "../tui/input.js";
-import type { FleetEditable } from "../config/config.js";
-import { type FleetEdit } from "./staging.js";
-export type View = {
-    id: string;
-    label: string;
-    render(props: {
-        cols: number;
-        rows: number;
-    }): string[];
-    /** Optional per-view key handler (e.g. up/down cursor movement). */
-    key?(name: string): void;
-};
-export type StudioOptions = {
-    input: InputStream;
-    output: OutputStream;
-    /** Loaded fleet state the buffer wraps. Defaults to an empty editable for the no-arg shell path. */
-    loaded?: FleetEditable;
-    /** Repository root used for overlay paths and live-run detection. Defaults to cwd. */
-    repoRoot?: string;
-    /** Global config directory override. */
-    globalDir?: string;
-};
-export declare class StudioApp {
-    private engine;
-    private views;
-    private active;
-    private showingHelp;
-    private confirmingQuit;
-    private showingSave;
-    private saveTarget;
-    private saveProposal;
-    private notice;
-    private staging;
-    private repoRoot;
-    private globalDir;
-    private _lines;
-    private resolveExit;
-    readonly exited: Promise<void>;
-    constructor(opts: StudioOptions);
-    /** Current line model last rendered or prepared. */
-    get lines(): string[];
-    /** Labels of every registered view, in order. */
-    get viewLabels(): string[];
-    /** Enter the alternate screen and start routing input. */
-    start(): void;
-    /** Restore the terminal and release the input stream. */
-    stop(): void;
-    /** Apply an edit to the staging buffer and repaint. Intended as the test seam and future edit hook. */
-    stageEdit(edit: FleetEdit): void;
-    private get isModalOpen();
-    private bindKeys;
-    private handleEscape;
-    private handleQuit;
-    private handleSaveOpen;
-    private handleSaveToggle;
-    private handleConfirm;
-    private handleCancel;
-    private executeSave;
-    private closeSave;
-    private handleRevert;
-    private setView;
-    private forwardViewKey;
-    private showNotice;
-    private paint;
-    private buildFrame;
-    private renderTabBar;
-    private renderStatusBar;
-    private renderHelp;
-    private renderQuitConfirm;
-}