@higherdev/cli 0.15.4 → 0.17.0

package/dist/tui/stream.js

@@ -1,3 +1,4 @@
+import { narrateEvents } from "./narrate.js";
 /** How much of the stream is kept. Older lines have already scrolled past. */
 export const STREAM_LIMIT = 200;
 /**
@@ -5,31 +6,43 @@ export const STREAM_LIMIT = 200;
  * 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) {
+export function toStreamLines(events, runs, raw = false) {
     const lines = [];
-    for (const event of events) {
-        const run = runs.get(event.run_id);
-        if (!run)
-            continue;
+    for (const run of runs.values()) {
+        const target = run.ticket ? ` on ${run.ticket}` : "";
+        lines.push({ id: `${run.runId}:start`, sourceIds: [`${run.runId}:start`], runId: run.runId,
+            agent: run.agent, at: run.startedAt ?? "", seq: -1, kind: "status",
+            title: `${run.agent} started ${run.kind}${target} (attempt ${run.attempt})` });
+    }
+    for (const run of runs.values()) {
         // 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) => {
+        narrateEvents(events.filter((event) => event.run_id === run.runId), raw).forEach((line) => {
             lines.push({
-                id: `${event.id}:${index}`,
-                runId: event.run_id,
+                id: line.id,
+                sourceIds: [line.sourceId],
+                runId: run.runId,
                 agent: run.agent,
-                at: String(event.at),
-                seq: event.seq,
+                at: line.at,
+                seq: line.seq,
                 kind: line.kind,
                 title: line.title,
             });
         });
     }
-    return lines;
+    for (const run of runs.values()) {
+        if (["queued", "running"].includes(run.status) || !run.summary)
+            continue;
+        const target = run.ticket ? ` on ${run.ticket}` : "";
+        lines.push({ id: `${run.runId}:end`, sourceIds: [`${run.runId}:end`], runId: run.runId,
+            agent: run.agent, at: run.endedAt ?? "", seq: Number.MAX_SAFE_INTEGER,
+            kind: run.status === "failed" || run.status === "killed" ? "error" : "status",
+            title: `${run.agent} finished ${run.kind}${target}: ${run.summary}` });
+    }
+    return collapse(lines.sort((a, b) => a.at.localeCompare(b.at) || a.seq - b.seq), raw);
 }
 /**
  * Adds lines to the stream without letting it grow forever and without showing
@@ -40,11 +53,14 @@ export function toStreamLines(events, runs) {
 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));
+    const seen = new Set(prior.flatMap((line) => line.sourceIds ?? [line.id]));
+    const fresh = incoming.flatMap((line) => {
+        const ids = (line.sourceIds ?? [line.id]).filter((id) => !seen.has(id));
+        return ids.length ? [{ ...line, sourceIds: ids, count: line.count ? ids.length : undefined }] : [];
+    });
     if (fresh.length === 0)
         return prior;
-    const next = [...prior, ...fresh].sort((left, right) => left.at.localeCompare(right.at) || left.seq - right.seq);
+    const next = collapse([...prior, ...fresh].sort((left, right) => left.at.localeCompare(right.at) || left.seq - right.seq));
     return next.length > limit ? next.slice(next.length - limit) : next;
 }
 /**
@@ -82,33 +98,32 @@ export async function backfill(opts) {
         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 }];
+function collapse(lines, raw = false) {
+    if (raw)
+        return lines;
+    const out = [];
+    for (const line of lines) {
+        const previous = out.at(-1);
+        const gap = previous ? Date.parse(line.at) - Date.parse(previous.at) : Infinity;
+        if (previous && previous.runId === line.runId && previous.kind === line.kind && previous.title === line.title && gap <= 2_000) {
+            previous.count = (previous.count ?? 1) + (line.count ?? 1);
+            previous.sourceIds = [...(previous.sourceIds ?? [previous.id]), ...(line.sourceIds ?? [line.id])];
+        }
+        else
+            out.push({ ...line });
+    }
+    return out;
 }
 /**
  * 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) {
+export function runLabels(board, now = Date.now()) {
     const map = new Map();
     for (const run of board.runs) {
-        if (run.status !== "running")
+        const ended = run.ended_at ? Date.parse(run.ended_at) : NaN;
+        if (run.status !== "running" && (!Number.isFinite(ended) || now - ended > 15 * 60_000))
             continue;
         const agent = board.agents.find((row) => row.id === run.agent_id);
         const ticket = board.tickets.find((row) => row.id === run.ticket_id);
@@ -116,6 +131,8 @@ export function runLabels(board) {
             runId: run.id,
             agent: agent?.display_name ?? run.kind,
             ticket: ticket?.key ?? null,
+            kind: run.kind, status: run.status, attempt: ticket?.attempts ?? 1,
+            startedAt: run.started_at, endedAt: run.ended_at ?? null, summary: run.summary ?? null,
         });
     }
     return map;

package/dist/tui/ticket-view.js

@@ -0,0 +1,226 @@
+export const TICKET_SECTIONS = ["body", "acceptance", "timeline", "messages", "pr", "runs", "decisions"];
+export function ticketPr(ticket) {
+    if (!ticket.pr_url && ticket.pr_number == null)
+        return null;
+    const reason = ticket.stuck_reason ?? "";
+    let checks = "unknown";
+    let mergeability = "open";
+    if (/^Checks failing/i.test(reason)) {
+        checks = reason.replace(/^Checks failing(?: \(details unavailable:[^)]+\))?:?\s*/i, "") || reason;
+    }
+    else if (ticket.status === "merged" || ticket.status === "approved") {
+        checks = "passing";
+    }
+    if (/conflicts with main/i.test(reason))
+        mergeability = "conflicting";
+    else if (ticket.status === "merged")
+        mergeability = "merged";
+    else if (ticket.status === "approved" && !/^Checks failing/i.test(reason))
+        mergeability = "ready";
+    return { url: ticket.pr_url, number: ticket.pr_number ?? null, checks, mergeability };
+}
+export function wrapLines(text, width) {
+    if (!text)
+        return [""];
+    const lines = [];
+    const max = Math.max(8, width);
+    for (const paragraph of text.split("\n")) {
+        if (!paragraph) {
+            lines.push("");
+            continue;
+        }
+        let line = "";
+        for (const word of paragraph.split(/\s+/).filter(Boolean)) {
+            const candidate = line ? `${line} ${word}` : word;
+            if (candidate.length <= max) {
+                line = candidate;
+                continue;
+            }
+            if (line)
+                lines.push(line);
+            let rest = word;
+            while (rest.length > max) {
+                lines.push(rest.slice(0, max));
+                rest = rest.slice(max);
+            }
+            line = rest;
+        }
+        if (line)
+            lines.push(line);
+    }
+    return lines;
+}
+function elapsedLabel(ms) {
+    if (ms == null)
+        return "elapsed unknown";
+    const seconds = Math.round(ms / 1000);
+    return seconds < 60 ? `${seconds}s` : `${Math.floor(seconds / 60)}m ${seconds % 60}s`;
+}
+function pushWrapped(lines, section, prefix, text, width) {
+    wrapLines(text, Math.max(8, width - prefix.length)).forEach((row, index) => {
+        lines.push({
+            key: `${section}:${prefix}:${index}:${row.slice(0, 12)}`,
+            kind: "line",
+            section,
+            text: `${prefix}${row}`,
+        });
+    });
+}
+export function ticketViewLines(ticket, width, collapsed = []) {
+    const lines = [];
+    const hidden = new Set(collapsed);
+    const pr = ticket.pr ?? ticketPr(ticket);
+    lines.push({
+        key: "header:title", kind: "line", section: "header",
+        text: `${ticket.key} ${ticket.title}`.trim(),
+    });
+    lines.push({
+        key: "header:status", kind: "line", section: "header",
+        text: [
+            ticket.status.replaceAll("_", " "),
+            ticket.area,
+            ticket.agent_name ?? (ticket.provider ?? "unassigned"),
+            ticket.attempts ? `attempt ${ticket.attempts}` : "",
+        ].filter(Boolean).join("  "),
+    });
+    const why = ticket.stuck ?? ticket.stuck_reason;
+    if (why) {
+        pushWrapped(lines, "header", "why: ", why, width);
+    }
+    if (ticket.blocker_keys?.length) {
+        lines.push({
+            key: "header:blocked", kind: "line", section: "header",
+            text: `blocked by ${ticket.blocker_keys.join(", ")}`,
+        });
+    }
+    if (ticket.branch) {
+        lines.push({ key: "header:branch", kind: "line", section: "header", text: ticket.branch });
+    }
+    const addSection = (id, title, fill, count) => {
+        const folded = hidden.has(id);
+        const note = folded ? " (folded)" : count != null ? ` (${count})` : "";
+        lines.push({
+            key: `section:${id}`, kind: "section", section: id,
+            text: `${folded ? "▸" : "▾"} ${title}${note}`,
+        });
+        if (folded)
+            return;
+        fill();
+    };
+    addSection("body", "Body", () => {
+        if (!ticket.body_md.trim()) {
+            lines.push({ key: "body:empty", kind: "line", section: "body", text: "  No body." });
+            return;
+        }
+        pushWrapped(lines, "body", "  ", ticket.body_md.trim(), width);
+    });
+    addSection("acceptance", "Acceptance", () => {
+        if (!ticket.acceptance_md.trim()) {
+            lines.push({ key: "acceptance:empty", kind: "line", section: "acceptance", text: "  No acceptance." });
+            return;
+        }
+        pushWrapped(lines, "acceptance", "  ", ticket.acceptance_md.trim(), width);
+    });
+    addSection("timeline", "Timeline", () => {
+        if (!ticket.timeline?.length) {
+            lines.push({ key: "timeline:empty", kind: "line", section: "timeline", text: "  No completed runs yet." });
+            return;
+        }
+        for (const event of ticket.timeline) {
+            pushWrapped(lines, "timeline", "  ", event.headline, width);
+            lines.push({
+                key: `${event.id}:meta`, kind: "line", section: "timeline",
+                text: `  ${event.outcome} · ${event.kind}/${event.provider} · ${elapsedLabel(event.elapsed_ms)}`,
+            });
+            if (event.send_back_reason) {
+                pushWrapped(lines, "timeline", "  sent back because: ", event.send_back_reason, width);
+            }
+        }
+    }, ticket.timeline?.length);
+    addSection("messages", "Messages", () => {
+        if (!ticket.messages?.length) {
+            lines.push({ key: "messages:empty", kind: "line", section: "messages", text: "  No messages yet." });
+            return;
+        }
+        for (const message of ticket.messages) {
+            const sender = message.from_name?.trim() || message.from_role;
+            lines.push({
+                key: `${message.id}:meta`, kind: "line", section: "messages",
+                text: `  ${message.created_at.slice(0, 16).replace("T", " ")}  ${sender}`,
+            });
+            pushWrapped(lines, "messages", "  ", message.body_md.trim() || "(empty)", width);
+        }
+    }, ticket.messages?.length);
+    addSection("pr", "PR", () => {
+        if (!pr) {
+            lines.push({ key: "pr:empty", kind: "line", section: "pr", text: "  No pull request yet." });
+            return;
+        }
+        lines.push({
+            key: "pr:id", kind: "line", section: "pr",
+            text: `  ${pr.number != null ? `#${pr.number}  ` : ""}${pr.url ?? ""}`.trimEnd(),
+        });
+        lines.push({ key: "pr:checks", kind: "line", section: "pr", text: `  checks: ${pr.checks}` });
+        lines.push({
+            key: "pr:merge", kind: "line", section: "pr",
+            text: `  mergeability: ${pr.mergeability}`,
+        });
+    });
+    addSection("runs", "Runs", () => {
+        if (!ticket.runs?.length) {
+            lines.push({ key: "runs:empty", kind: "line", section: "runs", text: "  No runs yet." });
+            return;
+        }
+        for (const run of ticket.runs) {
+            lines.push({
+                key: `${run.id}:meta`, kind: "line", section: "runs",
+                text: `  ${run.kind} ${run.provider} ${run.status} ${elapsedLabel(run.elapsed_ms)}`,
+            });
+            if (run.summary?.trim())
+                pushWrapped(lines, "runs", "  ", run.summary.trim(), width);
+        }
+    }, ticket.runs?.length);
+    addSection("decisions", "Decisions", () => {
+        if (!ticket.decisions?.length) {
+            lines.push({ key: "decisions:empty", kind: "line", section: "decisions", text: "  No decisions yet." });
+            return;
+        }
+        for (const decision of ticket.decisions) {
+            const state = decision.answered_at ? "answered" : "asked";
+            pushWrapped(lines, "decisions", `  ${state} (${decision.asked_by_role}): `, decision.question_md.trim(), width);
+            if (decision.answer_md?.trim()) {
+                pushWrapped(lines, "decisions", "  answer: ", decision.answer_md.trim(), width);
+            }
+        }
+    }, ticket.decisions?.length);
+    return lines;
+}
+export function ticketScrollOffset(count, rows, offset) {
+    if (count <= rows)
+        return 0;
+    return Math.max(0, Math.min(offset, count - rows));
+}
+export function sectionAt(lines, index) {
+    if (!lines.length)
+        return null;
+    const start = Math.max(0, Math.min(index, lines.length - 1));
+    for (let i = start; i >= 0; i -= 1) {
+        if (lines[i].kind === "section")
+            return lines[i].section;
+    }
+    return null;
+}
+export function toggleSection(collapsed, section) {
+    if (!section || section === "header")
+        return collapsed;
+    return collapsed.includes(section)
+        ? collapsed.filter((id) => id !== section)
+        : [...collapsed, section];
+}
+export function formatElapsedMs(ms, started, ended) {
+    if (typeof ms === "number")
+        return ms;
+    const start = started ? Date.parse(started) : Number.NaN;
+    const end = ended ? Date.parse(ended) : Number.NaN;
+    return Number.isFinite(start) && Number.isFinite(end) ? Math.max(0, end - start) : null;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@higherdev/cli",
-  "version": "0.15.4",
+  "version": "0.17.0",
   "type": "module",
   "bin": {
     "hd": "dist/index.js"