@higherdev/cli 0.3.0 → 0.5.0

package/dist/tui/height.js

@@ -0,0 +1,58 @@
+import { HELP_FOOTER } from "./Help.js";
+/**
+ * How many terminal rows each part of the app is about to occupy.
+ *
+ * This exists because of one Ink behaviour: while the frame fits the window,
+ * Ink erases and repaints in place, but the moment the frame is taller than
+ * the window it stops emitting erase sequences altogether and appends the
+ * whole frame again. Every repaint then scrolls a fresh copy past. The app
+ * budgets its live frame against these, and the banner uses the same numbers
+ * to decide whether it is safe to keep flashing.
+ *
+ * Estimates run high on purpose. Guessing tall costs a still banner; guessing
+ * short costs the terminal.
+ */
+/** Rows a run of text takes once Ink wraps it into `width` columns. */
+export function wrappedRows(text, width) {
+    if (width <= 0)
+        return 1;
+    return text
+        .split("\n")
+        .reduce((total, line) => total + Math.max(1, Math.ceil(line.length / width)), 0);
+}
+export function bubbleRows(message, width) {
+    const inner = Math.max(1, width - 4);
+    const body = message.body.trim() ? wrappedRows(message.body.trim(), inner) : message.pending ? 1 : 0;
+    // Two border rows, the speaker label, the tool lines, then a blank row after.
+    return 2 + 1 + (message.steps?.length ?? 0) + body + 1;
+}
+/**
+ * The name column is as wide as the longest command needs. Fixing it at
+ * eighteen meant a longer command wrapped onto a second row, which the count
+ * below did not know about, and an undercounted command list is a splash
+ * taller than the window.
+ */
+export function helpNameColumn(commands) {
+    return commands.reduce((widest, command) => Math.max(widest, `${command.name}${command.args ? ` ${command.args}` : ""}`.length + 1), 12);
+}
+/**
+ * Rows the command list takes, borders and padding included. A narrow terminal
+ * wraps the longer descriptions onto a second row, so they are counted rather
+ * than assumed.
+ */
+export function helpRows(commands, width) {
+    const inner = Math.max(1, width - 6);
+    const column = helpNameColumn(commands);
+    const lines = commands.reduce((total, command) => total +
+        Math.max(wrappedRows(command.help, Math.max(1, inner - column)), 
+        // The name itself can be wider than the room left for it.
+        Math.ceil(column / Math.max(1, inner))), 0);
+    // Two rows of border, the title, the commands, and the footer.
+    return 2 + 1 + lines + wrappedRows(HELP_FOOTER, inner);
+}
+/** The status line and the margin above it, and the prompt under it. */
+export const FRAME_CHROME = 3;
+/** The blank row between the cockpit and the stream. */
+export const PANEL_GAP = 1;
+/** Rows the one-line stand-in for the command list takes, its margin included. */
+export const HELP_HINT_ROWS = 2;

package/dist/tui/launch.js

@@ -0,0 +1,20 @@
+import { loadConfig } from "../config.js";
+import { canLaunchApp } from "./capability.js";
+import { loadSnapshot } from "./data.js";
+/** Opens HigherDEV. Shared by `hd` and by the end of `hd login`. */
+export async function launchApp(slug) {
+    // Keep this guard here as well as at command call sites. Ink cannot enter raw
+    // mode unless both streams are terminals.
+    if (!canLaunchApp())
+        return;
+    const initial = await loadSnapshot(loadConfig(slug));
+    const [{ render }, React, { App }] = await Promise.all([
+        import("ink"),
+        import("react"),
+        import("./App.js"),
+    ]);
+    const instance = render(React.createElement(App, {
+        initial,
+    }), { exitOnCtrlC: false });
+    await instance.waitUntilExit();
+}

package/dist/tui/layout.js

@@ -0,0 +1,54 @@
+import { BANNER_HEIGHT, bannerSize } from "./Banner.js";
+import { COMMANDS } from "./Help.js";
+import { FRAME_CHROME, HELP_HINT_ROWS, PANEL_GAP, helpRows } from "./height.js";
+export function planLayout(input) {
+    const banner = input.splash ? BANNER_HEIGHT[bannerSize(input.columns, input.rows)] + 1 : 0;
+    const notice = input.notice ? 2 : 0;
+    // One row spare, so the frame never lands exactly on the window's last line.
+    const other = input.inFlight + notice + FRAME_CHROME + 1;
+    // What yields first, and in what order, is the whole design here. The
+    // command list yields before the decision does: a decision is blocking work
+    // and the list is reference material that `/help` reprints into the log.
+    const wantHelp = input.splash && input.ready ? helpRows(COMMANDS, input.width) : 0;
+    const hint = input.splash && input.ready ? HELP_HINT_ROWS : 0;
+    const helpFull = wantHelp > 0 && banner + wantHelp + input.decision + other <= input.rows;
+    const help = wantHelp === 0 ? 0 : helpFull ? wantHelp : hint;
+    // Whatever is left is the flag's, down to the one line it collapses to. It
+    // never disappears: a decision nobody sees is the thing this panel exists to
+    // prevent.
+    const decision = input.decision === 0
+        ? 0
+        : Math.max(1, Math.min(input.decision, input.rows - banner - help - other));
+    const fixed = banner + help + decision + input.inFlight + notice;
+    const empty = { cockpit: 0, stream: 0, panels: 0 };
+    const finish = (parts) => {
+        const total = fixed + parts.panels + FRAME_CHROME;
+        return { banner, help, helpFull, decision, ...parts, total, fits: total < input.rows };
+    };
+    // The splash shows the banner and the list instead of the board, and a
+    // window with no room for a panel worth reading goes without one. Drawing a
+    // two row panel anyway is what put the frame over the window before.
+    if (input.splash)
+        return finish(empty);
+    const gap = input.home ? PANEL_GAP : 0;
+    const room = input.rows - fixed - FRAME_CHROME - gap - 1;
+    if (room < 4)
+        return finish(empty);
+    // The stream stops growing once it is deep enough to follow; past that the
+    // extra rows go to the board, which is the thing you are actually reading.
+    const stream = Math.max(2, Math.min(14, Math.round(room * 0.4)));
+    const cockpit = Math.max(2, room - stream);
+    return finish({ cockpit, stream, panels: input.home ? cockpit + stream + gap : room });
+}
+/**
+ * A view that stacks two panels with a blank row between them, inside one
+ * budget. Below the size where both are worth reading it stops splitting and
+ * gives everything to the first, rather than flooring each at two rows and
+ * spending one more than it was given, which is how the frame has outgrown the
+ * window before.
+ */
+export function splitPanels(budget) {
+    const bottom = Math.min(14, Math.round((budget - PANEL_GAP) * 0.4));
+    const top = budget - PANEL_GAP - bottom;
+    return bottom >= 3 && top >= 3 ? { top, bottom } : { top: Math.max(0, budget), bottom: 0 };
+}

package/dist/tui/parse.js

@@ -0,0 +1,48 @@
+/**
+ * What a typed line means. Kept separate from the component so the behaviour
+ * can be tested without a terminal, a database, or a render.
+ */
+export function parseLine(raw) {
+    const text = raw.trim();
+    if (!text)
+        return { kind: "noop" };
+    if (!text.startsWith("/"))
+        return { kind: "say", text };
+    const [word, ...rest] = text.slice(1).split(/\s+/);
+    const argument = rest.join(" ").trim();
+    switch (word.toLowerCase()) {
+        case "orchestrator":
+            return { kind: "mode", mode: "orchestrator" };
+        case "board":
+        case "agents":
+        case "feed":
+        case "inbox":
+        case "settings":
+            return { kind: "view", view: word.toLowerCase() };
+        case "help":
+            return { kind: "help" };
+        case "workspace":
+        case "ws": {
+            return { kind: "workspace", slug: argument || null };
+        }
+        case "ticket":
+            return argument
+                ? { kind: "ticket", key: argument.toUpperCase() }
+                : { kind: "unknown", command: "ticket needs a key" };
+        case "decide": {
+            const dismiss = /(^|\s)--(skip|dismiss)(\s|$)/.test(argument);
+            return {
+                kind: "decide",
+                answer: argument.replace(/(^|\s)--(skip|dismiss)(\s|$)/g, " ").trim(),
+                dismiss,
+            };
+        }
+        case "refresh":
+            return { kind: "refresh" };
+        case "exit":
+        case "quit":
+            return { kind: "exit" };
+        default:
+            return { kind: "unknown", command: word };
+    }
+}

package/dist/tui/settings-model.js

@@ -0,0 +1,76 @@
+import { efforts, providers } from "./data.js";
+export function settingsRows(workspace, agents) {
+    const rows = [
+        { key: "h:workspace", kind: "heading", label: workspace.slug, value: workspace.repo },
+        { key: "w:branch", kind: "readonly", label: "branch", value: workspace.default_branch },
+        { key: "w:host", kind: "readonly", label: "host", value: workspace.default_host },
+    ];
+    for (const provider of providers) {
+        rows.push({
+            key: `w:cap:${provider}`,
+            kind: "number",
+            label: `cap ${provider}`,
+            value: String(workspace.provider_caps[provider] ?? 0),
+            hint: "a whole number, 0 to stop using it",
+        });
+    }
+    for (const agent of agents) {
+        rows.push({ key: `h:${agent.id}`, kind: "heading", label: agent.display_name, value: agent.role });
+        rows.push({
+            key: `a:${agent.id}:enabled`, kind: "toggle", label: "enabled",
+            value: agent.enabled ? "yes" : "no", agent: agent.display_name,
+        });
+        rows.push({
+            key: `a:${agent.id}:provider`, kind: "choice", label: "provider",
+            value: agent.provider, choices: providers, agent: agent.display_name,
+        });
+        rows.push({
+            key: `a:${agent.id}:model`, kind: "text", label: "model",
+            value: agent.model, agent: agent.display_name, hint: "the provider's model id",
+        });
+        rows.push({
+            key: `a:${agent.id}:effort`, kind: "choice", label: "effort",
+            value: agent.effort, choices: efforts, agent: agent.display_name,
+        });
+    }
+    return rows;
+}
+export function editableKeys(rows) {
+    return rows.filter((row) => !["heading", "readonly"].includes(row.kind)).map((row) => row.key);
+}
+export function nextValue(row) {
+    if (row.kind === "toggle")
+        return row.value === "yes" ? "no" : "yes";
+    if (row.kind === "choice" && row.choices?.length) {
+        const at = row.choices.indexOf(row.value);
+        return row.choices[(at + 1) % row.choices.length];
+    }
+    return null;
+}
+export function seedFor(row) {
+    return row.value;
+}
+export function editFor(row, raw) {
+    const value = raw.trim();
+    const [scope, id, field] = row.key.split(":");
+    if (scope === "w" && id === "cap" && field) {
+        const cap = Number(value);
+        if (!Number.isInteger(cap) || cap < 0)
+            return { ok: false, error: `${field} cap must be an integer >= 0.` };
+        return { ok: true, value: { target: "cap", provider: field, cap } };
+    }
+    if (scope !== "a" || !id || !field)
+        return { ok: false, error: `Nothing to change on ${row.label}.` };
+    if (field === "enabled") {
+        return { ok: true, value: { target: "agent", id, fields: { enabled: value === "yes" } } };
+    }
+    if (field === "provider" && !providers.includes(value)) {
+        return { ok: false, error: `provider must be one of ${providers.join(", ")}.` };
+    }
+    if (field === "effort" && !efforts.includes(value)) {
+        return { ok: false, error: `effort must be one of ${efforts.join(", ")}.` };
+    }
+    if (field === "model" && !value)
+        return { ok: false, error: "model is required." };
+    return { ok: true, value: { target: "agent", id, fields: { [field]: value } } };
+}

package/dist/tui/stream.js

@@ -0,0 +1,122 @@
+/** How much of the stream is kept. Older lines have already scrolled past. */
+export const STREAM_LIMIT = 200;
+/**
+ * Events to lines, attributed to whoever produced them. Events from a run the
+ * caller did not name are dropped, which is how another workspace's traffic
+ * stays out of this one's stream.
+ */
+export function toStreamLines(events, runs) {
+    const lines = [];
+    for (const event of events) {
+        const run = runs.get(event.run_id);
+        if (!run)
+            continue;
+        // The id has to be a property of the event, not of the batch it arrived in.
+        // Live delivery converts one row at a time and a backfill converts eighty,
+        // so an id carrying a batch position would give the same event two ids and
+        // defeat the dedupe below. One event can still produce several lines, which
+        // is what the second half counts.
+        const produced = transcriptLines(event);
+        produced.forEach((line, index) => {
+            lines.push({
+                id: `${event.id}:${index}`,
+                runId: event.run_id,
+                agent: run.agent,
+                at: String(event.at),
+                seq: event.seq,
+                kind: line.kind,
+                title: line.title,
+            });
+        });
+    }
+    return lines;
+}
+/**
+ * Adds lines to the stream without letting it grow forever and without showing
+ * the same event twice. Realtime redelivers on reconnect, and a backfill for a
+ * run that has already started overlaps whatever arrived live while it loaded,
+ * so late arrivals are sorted back into place rather than appended.
+ */
+export function appendLines(prior, incoming, limit = STREAM_LIMIT) {
+    if (incoming.length === 0)
+        return prior;
+    const seen = new Set(prior.map((line) => line.id));
+    const fresh = incoming.filter((line) => !seen.has(line.id));
+    if (fresh.length === 0)
+        return prior;
+    const next = [...prior, ...fresh].sort((left, right) => left.at.localeCompare(right.at) || left.seq - right.seq);
+    return next.length > limit ? next.slice(next.length - limit) : next;
+}
+/**
+ * Loads the tail of the live runs and adds it to the stream, provided the
+ * workspace it was asked for is still the one on screen.
+ *
+ * run_events is subscribed without a workspace filter, because the table has no
+ * workspace id to filter on. Dropping rows whose run is not in `runs` is the
+ * only thing keeping one workspace's traffic out of another's stream, so the
+ * run map is captured when the request goes out rather than read back when it
+ * returns. A switch that lands mid-flight would otherwise resolve against the
+ * new workspace's labels, or append the old workspace's rows onto a stream that
+ * has just been cleared, where they would sit until they aged out.
+ */
+export async function backfill(opts) {
+    if (opts.runIds.length === 0)
+        return;
+    // Copied, not referenced. The caller rebuilds this map on every board change,
+    // and a backfill that outlives one rebuild has to convert against the runs it
+    // was asked about rather than whichever ones are live when it lands.
+    const runs = new Map(opts.runs);
+    let events;
+    try {
+        events = await opts.load(opts.runIds);
+    }
+    catch {
+        // A failed backfill costs the lines that arrived before the board caught
+        // up with the run. The live feed carries everything after them.
+        return;
+    }
+    if (!opts.isCurrent())
+        return;
+    const lines = toStreamLines(events, runs);
+    if (lines.length === 0)
+        return;
+    opts.apply((prior) => appendLines(prior, lines));
+}
+function transcriptLines(event) {
+    const payload = event.payload && typeof event.payload === "object" && !Array.isArray(event.payload)
+        ? event.payload
+        : {};
+    const text = [payload.text, payload.message, payload.summary, payload.command, payload.path]
+        .find((value) => typeof value === "string");
+    const title = text?.trim() || JSON.stringify(event.payload) || event.type;
+    if (!title)
+        return [];
+    const kind = event.type === "error"
+        ? "error"
+        : ["tool_use", "tool_result", "command", "file_changed"].includes(event.type)
+            ? "tool"
+            : event.type === "status"
+                ? "status"
+                : "text";
+    return [{ kind, title }];
+}
+/**
+ * The live runs, keyed by id. Realtime hands over a run event before the board
+ * has caught up with the run that produced it, so anything this does not know
+ * about is dropped and recovered by the backfill when the board does catch up.
+ */
+export function runLabels(board) {
+    const map = new Map();
+    for (const run of board.runs) {
+        if (run.status !== "running")
+            continue;
+        const agent = board.agents.find((row) => row.id === run.agent_id);
+        const ticket = board.tickets.find((row) => row.id === run.ticket_id);
+        map.set(run.id, {
+            runId: run.id,
+            agent: agent?.display_name ?? run.kind,
+            ticket: ticket?.key ?? null,
+        });
+    }
+    return map;
+}

package/dist/tui/theme.js

@@ -0,0 +1,52 @@
+/**
+ * The terminal palette. Text is white everywhere; the boxes carry the meaning,
+ * so who is speaking is legible without reading a label.
+ */
+export const UI = {
+    /** Everything anyone says. */
+    text: "#FFFFFF",
+    dim: "gray",
+    /** The operator's own turns. */
+    cream: "#F5E9C8",
+    /** The brain's turns. */
+    bright: "#FFFFFF",
+    /** The orchestrator speaks from the platform, not from here. */
+    orchestratorBorder: "#FFFFFF",
+    orchestratorBg: "#000000",
+    accent: "#7FB2FF",
+    warn: "yellow",
+    danger: "red",
+    ok: "green",
+};
+/**
+ * A wide-spaced dotted frame. Ink repeats a single character across the width,
+ * so the spacing has to live in the glyph: U+2508 and U+250A are the quadruple
+ * dash pair, which reads as dotted rather than as a solid rule.
+ */
+export const DOTTED = {
+    topLeft: "┌",
+    top: "┈",
+    topRight: "┐",
+    left: "┊",
+    right: "┊",
+    bottomLeft: "└",
+    bottom: "┈",
+    bottomRight: "┘",
+};
+/** A solid thin frame, for the panel the orchestrator speaks from. */
+export const THIN = "single";
+export function speakerStyle(speaker) {
+    switch (speaker) {
+        case "you":
+            return { borderStyle: DOTTED, borderColor: UI.cream, label: "you" };
+        case "orchestrator":
+            return {
+                borderStyle: THIN,
+                borderColor: UI.orchestratorBorder,
+                backgroundColor: UI.orchestratorBg,
+                label: "orchestrator",
+            };
+        default:
+            return { borderStyle: DOTTED, borderColor: UI.dim, label: "" };
+    }
+}

package/dist/tui/workspace-load.js

@@ -0,0 +1,18 @@
+/** Tags asynchronous snapshots so a workspace switch can invalidate them. */
+export class WorkspaceLoads {
+    #workspaceId;
+    #generation = 0;
+    constructor(workspaceId) {
+        this.#workspaceId = workspaceId;
+    }
+    start(workspaceId) {
+        return { workspaceId, generation: this.#generation };
+    }
+    switchTo(workspaceId) {
+        this.#workspaceId = workspaceId;
+        this.#generation += 1;
+    }
+    isCurrent(token) {
+        return token.workspaceId === this.#workspaceId && token.generation === this.#generation;
+    }
+}

package/package.json

@@ -1,52 +1,26 @@
 {
   "name": "@higherdev/cli",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "type": "module",
-  "description": "HigherDEV in your terminal. Full control of the board, live.",
   "bin": {
     "hd": "dist/index.js"
   },
+  "main": "dist/index.js",
   "files": [
     "dist"
   ],
   "scripts": {
-    "dev": "tsx src/index.ts",
-    "build": "node scripts/sync-version.mjs && tsup",
-    "typecheck": "tsc --noEmit",
-    "test": "vitest run",
-    "prepublishOnly": "pnpm build",
-    "sync-version": "node scripts/sync-version.mjs"
+    "build": "tsc",
+    "test": "pnpm build && node --experimental-strip-types --test test/*.test.ts",
+    "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "1.30.0",
-    "@supabase/supabase-js": "2.112.3",
-    "commander": "15.0.0",
     "ink": "7.1.1",
-    "react": "19.2.8",
-    "zod": "4.4.3"
+    "react": "19.2.8"
   },
   "devDependencies": {
-    "@higherdev/db": "workspace:*",
-    "@higherdev/runner": "workspace:*",
-    "@types/node": "22.20.1",
+    "@types/node": "24.13.3",
     "@types/react": "19.2.18",
-    "ink-testing-library": "4.0.0",
-    "tsup": "8.5.1",
-    "tsx": "4.23.12",
-    "typescript": "5.9.3",
-    "vitest": "4.1.11"
-  },
-  "license": "UNLICENSED",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/craig-higherops/higherdev.git",
-    "directory": "apps/cli"
-  },
-  "homepage": "https://dev.higherops.io",
-  "engines": {
-    "node": ">=22"
-  },
-  "publishConfig": {
-    "access": "public"
+    "typescript": "7.0.2"
   }
 }