@turri-dev/cli 0.0.0-stage → 0.1.1

package/dist/regenerate/jobs-tree.js

@@ -0,0 +1,300 @@
+import { wrapTextWithAnsi } from "@earendil-works/pi-tui";
+import { describeAgents } from "./activity.js";
+import { didNotPass, finishedMark, pulseCost, spinner } from "./job-panel.js";
+import { formatDuration, pulseName } from "./jobs.js";
+import { diffFiles, fileHeader, PLAIN_PAINT } from "./diff-view.js";
+export const SECTIONS = ["running", "queued", "finished"];
+export function createJobsTreeState() {
+    return { open: { running: true, queued: true, finished: false }, openJobs: new Map(), openFiles: new Map(), cursor: 0, top: 0 };
+}
+export function sectionOf(job) {
+    return job.status === "running" ? "running" : job.status === "queued" ? "queued" : "finished";
+}
+/** The files of a job's diff, in the order they are shown - read once for each diff, not on every frame. */
+const filesSeen = new Map();
+function filesOf(job) {
+    if (job.diff === undefined || job.diff.trim() === "")
+        return [];
+    const seen = filesSeen.get(job.id);
+    if (seen !== undefined && seen.diff === job.diff)
+        return seen.files;
+    const files = diffFiles(job.diff, 80, undefined, job.diffWhere).map((file) => file.file);
+    filesSeen.set(job.id, { diff: job.diff, files });
+    return files;
+}
+/** Whether a file of a job's diff is open: as it was opened or closed, else open when it is the file being rendered - the first. */
+function isFileOpen(state, row) {
+    return state.openFiles.get(row.job.id)?.get(row.file) ?? row.first;
+}
+function setFileOpen(state, job, file, open) {
+    const files = state.openFiles.get(job.id) ?? new Map();
+    files.set(file, open);
+    state.openFiles.set(job.id, files);
+}
+/** Whether a job is open where it is now: one opened in another section, it closed when it left it. */
+function isOpen(state, job) {
+    const opened = state.openJobs.get(job.id);
+    if (opened === undefined)
+        return false;
+    if (opened === sectionOf(job))
+        return true;
+    state.openJobs.delete(job.id);
+    return false;
+}
+/** The rows, top to bottom: each section's header, and its jobs when it is open - finished ones newest first. */
+/** The pulse list put on one pulse: its section open, the pulse opened - its stages, its agents, its log - and the cursor on it. */
+export function selectJob(jobs, state, id) {
+    const job = jobs.find((entry) => entry.id === id);
+    if (job === undefined)
+        return false;
+    const section = job.status === "running" ? "running" : job.status === "queued" ? "queued" : "finished";
+    state.open[section] = true;
+    state.openJobs.set(id, section);
+    const at = jobsTreeRows(jobs, state).findIndex((row) => row.kind === "job" && row.job.id === id);
+    if (at !== -1)
+        state.cursor = at;
+    return at !== -1;
+}
+export function jobsTreeRows(jobs, state) {
+    // A job queued again as another is that other one: it is not listed apart.
+    const bySequence = jobs.filter((job) => job.replacedBy === undefined).sort((a, b) => a.sequence - b.sequence);
+    const of = (section) => {
+        const inSection = bySequence.filter((job) => sectionOf(job) === section);
+        return section === "finished" ? inSection.sort((a, b) => (b.finishedAt ?? b.sequence) - (a.finishedAt ?? a.sequence) || b.sequence - a.sequence) : inSection;
+    };
+    // Forget what is open for jobs that moved on - they close as they leave.
+    for (const job of jobs)
+        isOpen(state, job);
+    return SECTIONS.flatMap((section) => {
+        const inSection = of(section);
+        const jobRows = (job) => [
+            { kind: "job", section, job },
+            // An open job's diff, a row a file: each opens and closes on its own.
+            ...(isOpen(state, job) ? filesOf(job).map((file, index) => ({ kind: "file", section, job, file, first: index === 0 })) : []),
+        ];
+        return [{ kind: "section", section, count: inSection.length }, ...(state.open[section] ? inSection.flatMap(jobRows) : [])];
+    });
+}
+/**
+ * A job's status beside its name. Running is the panel's spinner, not a play mark: a `▶` next to the `▸` that opens the
+ * job reads as a second arrow to pick.
+ */
+const MARK = { running: spinner, queued: () => "·", succeeded: () => "✓", failed: () => "✗", stopped: () => "■" };
+/** A pulse's mark: running or queued as it is; finished, in the colour of how it ended - green it passed, red it failed or did not pass, stopped amber. */
+function markOf(job, style) {
+    if (sectionOf(job) !== "finished")
+        return MARK[job.status]?.(Date.now()) ?? "·";
+    return finishedMark(job, { success: style.success ?? style.added, error: style.error, warning: style.warning ?? style.accent });
+}
+function wrap(text, width, indent, colour = (t) => t) {
+    return text
+        .trimEnd()
+        .split("\n")
+        .flatMap((line) => (line === "" ? [""] : wrapTextWithAnsi(line, Math.max(10, width - indent.length))))
+        .map((line) => colour(`${indent}${line}`));
+}
+/** The spec diffs a module's render planned and queued, from its details. */
+function plannedOf(job) {
+    const planned = job.details?.planned;
+    return Array.isArray(planned) ? planned : [];
+}
+/** A job named for the one reading about another: what it was, and its id. */
+function named(jobs, id) {
+    const job = jobs.find((other) => other.id === id);
+    return job !== undefined ? `${pulseName(job)} (${job.module === undefined ? `pulse ${id}, ` : ""}${job.status})` : `pulse ${id}`;
+}
+/** All of a job, opened: what it builds, and - running - what it is doing; waiting, what it waits on; done, how it ended. */
+function detailLines(job, jobs, width, style) {
+    const indent = "        ";
+    const lines = [];
+    // A diff is shown a file at a time, in rows of their own after these.
+    if ((job.diff === undefined || job.diff.trim() === "") && job.building !== undefined) {
+        lines.push(style.muted(`${indent}${job.building.label}:`), ...wrap(job.building.text, width, `${indent}  `, style.accent));
+    }
+    if (job.follows !== undefined)
+        lines.push(style.muted(`${indent}the conformance of ${named(jobs, job.follows)}`));
+    // The job that planned it, for a spec diff a module's render queued; what a planning job planned, in order.
+    const planner = jobs.find((other) => plannedOf(other).some((step) => step.jobId === job.id));
+    if (planner !== undefined)
+        lines.push(style.muted(`${indent}planned by ${named(jobs, planner.id)}`));
+    plannedOf(job).forEach((step, index, all) => {
+        if (index === 0)
+            lines.push(style.muted(`${indent}planned ${all.length} spec diff${all.length === 1 ? "" : "s"}:`));
+        lines.push(style.muted(`${indent}  ${index + 1}. ${step.title} → ${named(jobs, step.jobId)}`));
+    });
+    if (job.status === "queued" && job.waitingOn.length > 0)
+        lines.push(style.muted(`${indent}waits for ${job.waitingOn.map((id) => `pulse ${id}`).join(", ")}`));
+    if (job.note !== undefined)
+        lines.push(...wrap(job.note, width, indent, style.accent));
+    if (job.status === "running") {
+        for (const line of job.activity)
+            lines.push(...wrap(line, width, indent, style.muted));
+        if (job.now !== undefined)
+            lines.push(style.muted(`${indent}… ${job.now.label} · ${Math.max(0, Math.round((Date.now() - job.now.since) / 1000))}s`));
+    }
+    if (job.status === "failed" && job.error !== undefined)
+        lines.push(...wrap(job.error.split("\n").slice(0, 6).join("\n"), width, indent, style.error));
+    if (sectionOf(job) === "finished")
+        lines.push(...whatWentOn(job, width, style));
+    return lines;
+}
+/**
+ * What went on in a finished pulse, opened: its agents and what each spent, and whether it passed - its report is
+ * the chat's, and its log has the rest. Its diff follows, a file a row.
+ */
+function whatWentOn(job, width, style) {
+    const indent = "        ";
+    const lines = [];
+    // Each agent's turns, tokens, cost and model - without its label, which says again what the pulse's line says.
+    for (const agent of describeAgents(job.agents.map((tally) => ({ ...tally, label: "" }))))
+        lines.push(...wrap(agent.replace(/^ · /, ""), width, indent, style.muted));
+    if (didNotPass(job))
+        lines.push(style.error(`${indent}did not pass`));
+    if (job.logFile !== undefined)
+        lines.push(style.muted(`${indent}log: ${job.logFile}`));
+    return lines;
+}
+/** The rows as lines, the cursor's marked, and where each row starts - for scrolling to it. */
+export function jobsTreeLines(jobs, state, width, style) {
+    const rows = jobsTreeRows(jobs, state);
+    state.cursor = Math.max(0, Math.min(state.cursor, rows.length - 1));
+    const lines = [];
+    const rowStarts = [];
+    rows.forEach((row, index) => {
+        rowStarts.push(lines.length);
+        const here = index === state.cursor;
+        const pointer = here ? "›" : " ";
+        if (row.kind === "section") {
+            if (index > 0) {
+                // A blank line between sections, kept off the cursor's row.
+                lines.push("");
+                rowStarts[index] = lines.length;
+            }
+            const header = `${pointer} ${state.open[row.section] ? "▾" : "▸"} ${row.section} (${row.count})`;
+            lines.push(here ? style.heading(header) : style.muted(header));
+            return;
+        }
+        if (row.kind === "file") {
+            const open = isFileOpen(state, row);
+            const paint = style.diff ?? { ...PLAIN_PAINT, added: style.added, removed: style.removed, muted: style.muted };
+            const shown = diffFiles(row.job.diff, Math.max(10, width - FILE_INDENT.length), paint, row.job.diffWhere).find((file) => file.file === row.file);
+            if (shown === undefined)
+                return;
+            const header = `${pointer}${FILE_INDENT.slice(1)}${fileHeader(shown, paint, open)}`;
+            lines.push(here ? style.heading(header) : header);
+            if (open)
+                lines.push(...shown.rows.map((line) => `${FILE_INDENT}${line}`));
+            return;
+        }
+        const { job } = row;
+        const open = isOpen(state, job);
+        // A line says which module, which pulse, how long and what it cost - and the mark where it is, or how it ended; the rest - what it regenerates too - is in it, opened.
+        // A queued pulse has not started: it has no time to show.
+        const time = job.status === "queued" ? "" : ` · ${formatDuration(job)}`;
+        const head = `${pointer}   ${open ? "▾" : "▸"} ${markOf(job, style)} ${pulseName(job)}${time}${pulseCost(job)}`;
+        const [first = "", ...rest] = wrapTextWithAnsi(head, Math.max(10, width));
+        lines.push(here ? style.heading(first) : first, ...rest.map((line) => `        ${line}`));
+        if (open)
+            lines.push(...detailLines(job, jobs, width, style));
+    });
+    return { lines, rowStarts, rows };
+}
+/** How far a job's files, and their lines, are indented under it. */
+const FILE_INDENT = "        ";
+/** Keep the cursor's row in sight: scroll only as far as that takes. */
+export function keepCursorInView(state, rowStarts, lineCount, height) {
+    const start = rowStarts[state.cursor] ?? 0;
+    const end = rowStarts[state.cursor + 1] ?? lineCount;
+    // A line of its row in sight is enough: a job opened longer than the screen is read by scrolling through it.
+    const inSight = start < state.top + height && end > state.top;
+    if (!inSight && start < state.top)
+        state.top = start;
+    if (!inSight && start >= state.top + height)
+        state.top = start - height + 1;
+    state.top = Math.max(0, Math.min(state.top, Math.max(0, lineCount - height)));
+}
+/** Scroll the view by lines, the cursor coming along to the first row in sight. */
+export function scrollTree(state, by, rowStarts, lineCount, height) {
+    state.top = Math.max(0, Math.min(state.top + by, Math.max(0, lineCount - height)));
+    const end = (row) => rowStarts[row + 1] ?? lineCount;
+    // The cursor's row still has a line in sight - a job opened longer than the screen, read as it scrolls by: it stays.
+    if ((rowStarts[state.cursor] ?? 0) < state.top + height && end(state.cursor) > state.top)
+        return;
+    // Otherwise onto the first row with a line in sight.
+    const first = rowStarts.findIndex((start, row) => start < state.top + height && end(row) > state.top);
+    state.cursor = Math.max(0, first);
+}
+/** A key in the Jobs view, and what it does to the tree. */
+export function treeKey(state, rows, key) {
+    const row = rows[state.cursor];
+    switch (key) {
+        case "up":
+            state.cursor = Math.max(0, state.cursor - 1);
+            return { kind: "handled" };
+        case "down":
+            state.cursor = Math.min(rows.length - 1, state.cursor + 1);
+            return { kind: "handled" };
+        case "toggle":
+            if (row === undefined)
+                return { kind: "none" };
+            if (row.kind === "section")
+                state.open[row.section] = !state.open[row.section];
+            else if (row.kind === "file")
+                setFileOpen(state, row.job, row.file, !isFileOpen(state, row));
+            else if (state.openJobs.has(row.job.id))
+                state.openJobs.delete(row.job.id);
+            else
+                state.openJobs.set(row.job.id, row.section);
+            return { kind: "handled" };
+        case "open":
+            if (row === undefined)
+                return { kind: "none" };
+            if (row.kind === "section")
+                state.open[row.section] = true;
+            else if (row.kind === "file")
+                setFileOpen(state, row.job, row.file, true);
+            else
+                state.openJobs.set(row.job.id, row.section);
+            return { kind: "handled" };
+        case "close":
+            if (row === undefined)
+                return { kind: "none" };
+            if (row.kind === "section")
+                state.open[row.section] = false;
+            else if (row.kind === "file") {
+                // Open, it closes; closed, the cursor goes up to its job.
+                if (isFileOpen(state, row))
+                    setFileOpen(state, row.job, row.file, false);
+                else
+                    state.cursor = rows.findLastIndex((other, index) => index < state.cursor && other.kind === "job" && other.job.id === row.job.id);
+            }
+            else if (state.openJobs.has(row.job.id))
+                state.openJobs.delete(row.job.id);
+            else
+                state.cursor = rows.findLastIndex((other, index) => index < state.cursor && other.kind === "section");
+            return { kind: "handled" };
+        case "openAll":
+        case "closeAll": {
+            if (row === undefined)
+                return { kind: "none" };
+            // On a file: every file of its job, to go through them quickly.
+            if (row.kind === "file") {
+                for (const other of rows)
+                    if (other.kind === "file" && other.job.id === row.job.id)
+                        setFileOpen(state, other.job, other.file, key === "openAll");
+                return { kind: "handled" };
+            }
+            const section = row.section;
+            state.open[section] = true;
+            for (const other of rows) {
+                if (other.kind !== "job" || other.section !== section)
+                    continue;
+                if (key === "openAll")
+                    state.openJobs.set(other.job.id, section);
+                else
+                    state.openJobs.delete(other.job.id);
+            }
+            return { kind: "handled" };
+        }
+    }
+}