@higherdev/cli 0.4.0 → 0.5.0

package/README.md

@@ -12,17 +12,24 @@ Create `~/.config/hd/config.json` with an existing workspace API key:
 
 ```json
 {
-  "url": "https://hdx-higher-ops.vercel.app",
-  "api_key": "hdx_...",
-  "slug": "workspace"
+  "current": "workspace",
+  "workspaces": {
+    "workspace": {
+      "url": "https://hdx-higher-ops.vercel.app",
+      "api_key": "hdx_..."
+    }
+  }
 }
 ```
 
+The previous single-workspace config shape is migrated automatically when it is read.
+
 ## Commands
 
 | Command | Purpose |
 | --- | --- |
-| `hd` | Show the HigherDEV banner and usage |
+| `hd` | Open the live TUI when attached to a terminal |
+| `hd --help` | Show the HigherDEV banner and usage |
 | `hd status` | Show workspace, ticket, run, and decision status |
 | `hd ticket list` | List tickets |
 | `hd ticket show KEY` | Show one ticket |
@@ -39,4 +46,6 @@ Create `~/.config/hd/config.json` with an existing workspace API key:
 | `hd init [options]` | Configure this host and runner service |
 | `hd upgrade [options]` | Refresh this host configuration |
 
-Run `hd` for the compact command summary.
+Inside the TUI, use `/board`, `/inbox`, `/ticket`, `/decide`, `/agents`,
+`/settings`, `/workspace`, `/feed`, `/orchestrator`, `/refresh`, `/help`, or
+`/exit`. The display refreshes from the HDX API every five seconds.

package/dist/api.js

@@ -22,24 +22,19 @@ async function request(config, method, path, body) {
     }
     return parsed;
 }
-export async function getStatus() {
-    const config = loadConfig();
+export async function getStatus(config = loadConfig()) {
     return request(config, "GET", `/api/w/${config.slug}/status`);
 }
-export async function listTickets() {
-    const config = loadConfig();
+export async function listTickets(config = loadConfig()) {
     return request(config, "GET", `/api/w/${config.slug}/tickets`);
 }
-export async function showTicket(key) {
-    const config = loadConfig();
+export async function showTicket(key, config = loadConfig()) {
     return request(config, "GET", `/api/w/${config.slug}/tickets/${encodeURIComponent(key)}`);
 }
-export async function createTicket(fields) {
-    const config = loadConfig();
+export async function createTicket(fields, config = loadConfig()) {
     return request(config, "POST", `/api/w/${config.slug}/tickets`, fields);
 }
-export async function listTicketEvents(key, afterAt, afterId) {
-    const config = loadConfig();
+export async function listTicketEvents(key, afterAt, afterId, config = loadConfig()) {
     const query = new URLSearchParams();
     if (afterAt)
         query.set("after_at", afterAt);
@@ -48,29 +43,43 @@ export async function listTicketEvents(key, afterAt, afterId) {
     const suffix = query.size ? `?${query.toString()}` : "";
     return request(config, "GET", `/api/w/${config.slug}/tickets/${encodeURIComponent(key)}/events${suffix}`);
 }
-export async function postMessage(fields) {
-    const config = loadConfig();
+export async function postMessage(fields, config = loadConfig()) {
     return request(config, "POST", `/api/w/${config.slug}/messages`, fields);
 }
-export async function answerDecision(id, answer_md) {
-    const config = loadConfig();
+export async function answerDecision(id, answer_md, config = loadConfig()) {
     return request(config, "POST", `/api/w/${config.slug}/decisions/${encodeURIComponent(id)}/answer`, { answer_md });
 }
-export async function setPaused(paused) {
-    const config = loadConfig();
+export async function setPaused(paused, config = loadConfig()) {
     const path = paused ? `/api/w/${config.slug}/pause` : `/api/w/${config.slug}/resume`;
     return request(config, "POST", path);
 }
-export async function createWorkspace(fields) {
-    const config = loadConfig();
+export async function createWorkspace(fields, config = loadConfig()) {
     const result = await request(config, "POST", "/api/workspaces", fields);
     return { ...result, url: config.url };
 }
-export async function listAgents() {
-    const config = loadConfig();
+export async function listAgents(config = loadConfig()) {
     return request(config, "GET", `/api/w/${config.slug}/agents`);
 }
-export async function updateAgent(id, fields) {
-    const config = loadConfig();
+export async function updateAgent(id, fields, config = loadConfig()) {
     return request(config, "PATCH", `/api/w/${config.slug}/agents`, { id, ...fields });
 }
+export async function listEpics(config = loadConfig()) {
+    return request(config, "GET", `/api/w/${config.slug}/epics`);
+}
+export async function listMessages(options = {}, config = loadConfig()) {
+    const query = new URLSearchParams();
+    if (options.ticketId)
+        query.set("ticket_id", options.ticketId);
+    if (options.since)
+        query.set("since", options.since);
+    if (options.limit)
+        query.set("limit", String(options.limit));
+    const suffix = query.size ? `?${query.toString()}` : "";
+    return request(config, "GET", `/api/w/${config.slug}/messages${suffix}`);
+}
+export async function updateCaps(provider_caps, config = loadConfig()) {
+    return request(config, "PATCH", `/api/w/${config.slug}/caps`, { provider_caps });
+}
+export async function listFeed(config = loadConfig()) {
+    return request(config, "GET", `/api/w/${config.slug}/feed`);
+}

package/dist/config.js

@@ -1,26 +1,80 @@
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
-import { chmodSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 export function configPath() {
     return process.env.HD_CONFIG ?? join(homedir(), ".config/hd/config.json");
 }
-export function loadConfig() {
-    const path = configPath();
+function normalizeWorkspace(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return null;
+    const row = value;
+    if (typeof row.url !== "string" || typeof row.api_key !== "string" || !row.url || !row.api_key) {
+        return null;
+    }
+    return { url: row.url.replace(/\/$/, ""), api_key: row.api_key };
+}
+function missing(path) {
+    return new Error(`missing ${path}\nWrite { "current": "workspace", "workspaces": { "workspace": { "url": "https://hdx-higher-ops.vercel.app", "api_key": "hdx_..." } } }`);
+}
+export function loadStoredConfig(path = configPath()) {
     let raw;
     try {
         raw = readFileSync(path, "utf8");
     }
     catch {
-        throw new Error(`missing ${path}\nWrite { "url": "https://hdx-higher-ops.vercel.app", "api_key": "hdx_...", "slug": "workspace" }`);
+        throw missing(path);
     }
     const parsed = JSON.parse(raw);
-    if (!parsed.url || !parsed.api_key || !parsed.slug) {
-        throw new Error(`${path} needs url, api_key, and slug`);
+    // 0.4 and earlier stored one workspace at the top level. Rewrite it once so
+    // every later read sees the multi-workspace format.
+    const legacy = normalizeWorkspace(parsed);
+    if (legacy && typeof parsed.slug === "string" && parsed.slug) {
+        const migrated = { current: parsed.slug, workspaces: { [parsed.slug]: legacy } };
+        writeStoredConfig(migrated, path);
+        return migrated;
+    }
+    const current = typeof parsed.current === "string" ? parsed.current : "";
+    const source = parsed.workspaces;
+    if (!current || !source || typeof source !== "object" || Array.isArray(source)) {
+        throw new Error(`${path} needs current and workspaces`);
+    }
+    const workspaces = {};
+    for (const [slug, value] of Object.entries(source)) {
+        const workspace = normalizeWorkspace(value);
+        if (workspace)
+            workspaces[slug] = workspace;
     }
-    return { url: parsed.url.replace(/\/$/, ""), api_key: parsed.api_key, slug: parsed.slug };
+    if (!workspaces[current])
+        throw new Error(`${path} current workspace ${current} is not configured`);
+    return { current, workspaces };
 }
-export function writeHdConfig(config, path = configPath()) {
+export function loadConfig(slug) {
+    const stored = loadStoredConfig();
+    const selected = slug ?? stored.current;
+    const workspace = stored.workspaces[selected];
+    if (!workspace)
+        throw new Error(`No configured workspace ${selected}.`);
+    return { ...workspace, slug: selected };
+}
+export function writeStoredConfig(config, path = configPath()) {
     mkdirSync(dirname(path), { recursive: true });
     writeFileSync(path, `${JSON.stringify(config, null, 2)}\n`, { encoding: "utf8", mode: 0o600 });
     chmodSync(path, 0o600);
 }
+/** Store credentials for a workspace and make it current. */
+export function writeHdConfig(config, path = configPath()) {
+    const stored = existsSync(path)
+        ? loadStoredConfig(path)
+        : { current: config.slug, workspaces: {} };
+    stored.workspaces[config.slug] = { url: config.url.replace(/\/$/, ""), api_key: config.api_key };
+    stored.current = config.slug;
+    writeStoredConfig(stored, path);
+}
+export function switchWorkspace(slug, path = configPath()) {
+    const stored = loadStoredConfig(path);
+    const workspace = stored.workspaces[slug];
+    if (!workspace)
+        throw new Error(`No configured workspace ${slug}.`);
+    writeStoredConfig({ ...stored, current: slug }, path);
+    return { ...workspace, slug };
+}

package/dist/index.js

@@ -3,6 +3,7 @@ import { realpathSync } from "node:fs";
 import { pathToFileURL } from "node:url";
 import { answerDecision, createTicket, createWorkspace, getStatus, listAgents, listTicketEvents, listTickets, postMessage, setPaused, showTicket, updateAgent, } from "./api.js";
 import { initHost, parseHostFlags } from "./host.js";
+import { writeHdConfig } from "./config.js";
 import { banner, c, statusChip, table, truncate, usage } from "./out.js";
 function fail(message) {
     console.error(message);
@@ -184,7 +185,8 @@ async function cmdWorkspace(argv) {
     const result = await createWorkspace({ name: opts.name, repo: opts.repo, slug: opts.slug,
         default_branch: opts.branch ?? "main", default_host: opts.host ?? "box" });
     console.log(`workspace: ${result.workspace.slug}`);
-    console.log("api key shown once; switch with:");
+    writeHdConfig({ url: result.url, api_key: result.api_key, slug: result.workspace.slug });
+    console.log("saved and switched; configure another machine with:");
     console.log(`hd init --url ${result.url} --api-key ${result.api_key} --slug ${result.workspace.slug}`);
 }
 function selectAgent(agents, role, provider) {
@@ -225,6 +227,18 @@ export async function main(argv = process.argv.slice(2)) {
     const [cmd, ...rest] = argv;
     try {
         if (!cmd) {
+            const { canLaunchApp } = await import("./tui/capability.js");
+            if (canLaunchApp()) {
+                const { launchApp } = await import("./tui/launch.js");
+                await launchApp();
+                return;
+            }
+            console.log(banner());
+            console.log("");
+            console.log(usage());
+            return;
+        }
+        if (cmd === "--help" || cmd === "-h") {
             console.log(banner());
             console.log("");
             console.log(usage());

package/dist/out/format.js

@@ -0,0 +1,96 @@
+import { statusTone } from "../tui/data.js";
+import { c, DOT, ELLIPSIS, tone } from "./theme.js";
+export function truncate(text, max) {
+    const flat = String(text ?? "")
+        .replace(/\s+/g, " ")
+        .trim();
+    if (flat.length <= max)
+        return flat;
+    return `${flat.slice(0, Math.max(0, max - 1))}${ELLIPSIS}`;
+}
+const ANSI = new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*m`, "g");
+export function displayWidth(text) {
+    return text.replace(ANSI, "").length;
+}
+export function pad(text, width) {
+    const gap = width - displayWidth(text);
+    return gap > 0 ? text + " ".repeat(gap) : text;
+}
+export function padStart(text, width) {
+    const gap = width - displayWidth(text);
+    return gap > 0 ? " ".repeat(gap) + text : text;
+}
+/** Fixed-width table. Widths measure printable characters, not escape codes. */
+export function table(columns, rows) {
+    if (rows.length === 0)
+        return c.dim("none");
+    const widths = columns.map((column, i) => Math.max(displayWidth(column.header), ...rows.map((row) => displayWidth(row[i] ?? ""))));
+    const line = (cells) => cells
+        .map((cell, i) => {
+        if (i === cells.length - 1 && columns[i]?.align !== "right")
+            return cell;
+        return columns[i]?.align === "right" ? padStart(cell, widths[i]) : pad(cell, widths[i]);
+    })
+        .join("  ")
+        .trimEnd();
+    return [c.dim(line(columns.map((column) => column.header))), ...rows.map(line)].join("\n");
+}
+export function statusChip(status) {
+    return tone(statusTone(status), status.replaceAll("_", " "));
+}
+export function stateDot(state) {
+    return tone(state, DOT);
+}
+export function relativeTime(iso, now = Date.now()) {
+    if (!iso)
+        return "never";
+    const at = Date.parse(iso);
+    if (Number.isNaN(at))
+        return "never";
+    const seconds = Math.round((now - at) / 1000);
+    if (seconds < 0)
+        return "just now";
+    if (seconds < 60)
+        return `${seconds}s ago`;
+    const minutes = Math.round(seconds / 60);
+    if (minutes < 60)
+        return `${minutes}m ago`;
+    const hours = Math.round(minutes / 60);
+    if (hours < 48)
+        return `${hours}h ago`;
+    return `${Math.round(hours / 24)}d ago`;
+}
+export function elapsed(from, to, now = Date.now()) {
+    if (!from)
+        return "";
+    const start = Date.parse(from);
+    if (Number.isNaN(start))
+        return "";
+    const parsedEnd = to ? Date.parse(to) : now;
+    const end = Number.isNaN(parsedEnd) ? now : parsedEnd;
+    const seconds = Math.max(0, Math.round((end - start) / 1000));
+    if (seconds < 60)
+        return `${seconds}s`;
+    const minutes = Math.floor(seconds / 60);
+    if (minutes < 60)
+        return `${minutes}m${seconds % 60 ? ` ${seconds % 60}s` : ""}`;
+    const hours = Math.floor(minutes / 60);
+    return `${hours}h${minutes % 60 ? ` ${minutes % 60}m` : ""}`;
+}
+export function heading(text) {
+    return c.bold(text);
+}
+export function bullet(text) {
+    return `${c.dim("-")} ${text}`;
+}
+export function section(title, body) {
+    return `${heading(title)}\n${body}`;
+}
+/** A one-line horizontal bar for spend and progress. */
+export function bar(value, max, width = 20) {
+    if (!(max > 0))
+        return c.dim("-".repeat(width));
+    const filled = Math.max(0, Math.min(width, Math.round((value / max) * width)));
+    return c.blue("█".repeat(filled)) + c.dim("░".repeat(width - filled));
+}
+export { DOT };

package/dist/out/theme.js

@@ -0,0 +1,73 @@
+/**
+ * Terminal palette. The web app is light only by decision; a terminal is the
+ * user's own surface, so nothing here paints a background. Foreground and dim
+ * only, blue as the single accent, status colour confined to state.
+ */
+const ESC = `${String.fromCharCode(27)}[`;
+export function colorEnabled(stream = process.stdout) {
+    if (process.env.HIGHERDEV_FORCE_COLOR === "1")
+        return true;
+    if (process.env.NO_COLOR)
+        return false;
+    return Boolean(stream.isTTY);
+}
+const CODES = {
+    bold: 1,
+    dim: 2,
+    red: 31,
+    green: 32,
+    yellow: 33,
+    magenta: 35,
+    cyan: 36,
+    grey: 90,
+    blue: 94,
+};
+function wrap(name, text) {
+    if (!colorEnabled())
+        return text;
+    return `${ESC}${CODES[name]}m${text}${ESC}0m`;
+}
+export const c = {
+    bold: (t) => wrap("bold", t),
+    dim: (t) => wrap("dim", t),
+    blue: (t) => wrap("blue", t),
+    green: (t) => wrap("green", t),
+    yellow: (t) => wrap("yellow", t),
+    red: (t) => wrap("red", t),
+    grey: (t) => wrap("grey", t),
+    cyan: (t) => wrap("cyan", t),
+    magenta: (t) => wrap("magenta", t),
+};
+export function tone(value, text) {
+    switch (value) {
+        case "blue":
+            return c.blue(text);
+        case "success":
+            return c.green(text);
+        case "warning":
+            return c.yellow(text);
+        case "danger":
+            return c.red(text);
+        default:
+            return c.dim(text);
+    }
+}
+/** Ink colour name for the same tone, so plain and TUI output agree. */
+export function inkColor(value) {
+    switch (value) {
+        case "blue":
+            return "blueBright";
+        case "success":
+            return "green";
+        case "warning":
+            return "yellow";
+        case "danger":
+            return "red";
+        default:
+            return "gray";
+    }
+}
+export const DOT = "●";
+export const ARROW = "→";
+export const BAR = "│";
+export const ELLIPSIS = "…";