allaboard 0.0.0-stage → 0.5.0

package/dist/core/reply/fold.js

@@ -0,0 +1,175 @@
+import { failsCounted, folded } from "./previews.js";
+import { STOPPED } from "./words.js";
+export const ENDED = ["complete", "error"];
+export const SEPARATOR = ", ";
+// The most command lines a run's card lists: its last ones, as a subagent's card lists its calls.
+const RUN_COMMANDS = 10;
+/**
+ * The preview, on a call that finished well and only there: a failed, running or task card keeps
+ * its own view whatever it carries, so no path can show a preview over an error.
+ */
+export function shownPreview(update) {
+    return update.status === "complete" && !update.task ? update.preview : null;
+}
+/**
+ * Whether a call is drawn on its run's card rather than on a card of its own. A call that failed
+ * is counted with the others only where the terminal was seen to count it so (a command that
+ * exits with an error, `previews.failsCounted`); any other failed call keeps a card that says
+ * why.
+ */
+export function folds(update) {
+    if (update.status === "error" && !failsCounted(update.name))
+        return false;
+    return (update.name !== "" && !update.task && shownPreview(update) === null && update.output !== STOPPED);
+}
+/**
+ * Ended calls as counts in the terminal's words, joined as it joins them: a comma between two
+ * counts, and a capital on the first alone. A failed call is counted with the others.
+ */
+export function counts(calls) {
+    // In the order each name first ended, as the terminal lists them.
+    const byName = new Map();
+    for (const call of calls)
+        byName.set(call.name, (byName.get(call.name) ?? 0) + 1);
+    return [...byName].map(([name, n], index) => folded(name, n, index === 0)).join(SEPARATOR);
+}
+function newRun() {
+    return { calls: new Map(), ended: [], card: null, open: true };
+}
+function samePreview(a, b) {
+    if (a === null || b === null)
+        return a === b;
+    return (a.title === b.title &&
+        a.summary === b.summary &&
+        a.body === b.body &&
+        a.language === b.language &&
+        a.plain === b.plain &&
+        a.record === b.record);
+}
+/** Whether two states of a line say the same, field by field. */
+function sameUpdate(a, b) {
+    return (a !== undefined &&
+        a.id === b.id &&
+        a.title === b.title &&
+        a.status === b.status &&
+        a.details === b.details &&
+        a.output === b.output &&
+        a.name === b.name &&
+        a.task === b.task &&
+        a.calls === b.calls &&
+        a.folded === b.folded &&
+        a.startedAt === b.startedAt &&
+        samePreview(a.preview, b.preview));
+}
+function remove(list, item) {
+    const index = list.indexOf(item);
+    if (index !== -1)
+        list.splice(index, 1);
+}
+/**
+ * Turns the calls of one reply into the cards that show them. `task` returns the cards a call's
+ * new state changes, in the order they are to appear; `text` ends the run.
+ */
+export class Fold {
+    /** Call id to its run. */
+    runs = new Map();
+    /** Call id to the card that is its own. */
+    own = new Map();
+    current = null;
+    sent = new Map();
+    /** Text was written: the calls after it are a new run. */
+    text() {
+        if (this.current !== null)
+            this.current.open = false;
+    }
+    task(update) {
+        const own = this.own.get(update.id);
+        if (own !== undefined)
+            return this.changed([{ ...update, id: own }]);
+        let run = this.runs.get(update.id);
+        if (run === undefined) {
+            if (!folds(update)) {
+                this.text();
+                this.own.set(update.id, update.id);
+                return this.changed([update]);
+            }
+            if (this.current === null || !this.current.open)
+                this.current = newRun();
+            run = this.current;
+            this.runs.set(update.id, run);
+        }
+        else if (!folds(update)) {
+            return this.changed([this.leave(run, update), ...this.draw(run)]);
+        }
+        run.calls.set(update.id, update);
+        if (!ENDED.includes(update.status)) {
+            remove(run.ended, update.id);
+        }
+        else if (!run.ended.includes(update.id)) {
+            run.ended.push(update.id);
+        }
+        return this.changed(this.draw(run));
+    }
+    /**
+     * A call that no longer folds gets a card of its own. The run's only call keeps the run's
+     * card, which showed it. The run takes no new call.
+     */
+    leave(run, update) {
+        run.calls.delete(update.id);
+        this.runs.delete(update.id);
+        remove(run.ended, update.id);
+        run.open = false;
+        let card = update.id;
+        if (run.calls.size === 0 && run.card !== null) {
+            card = run.card;
+            run.card = null;
+        }
+        this.own.set(update.id, card);
+        return { ...update, id: card };
+    }
+    /** The run's card as it stands: the call that runs now, else the counts of what ended. */
+    draw(run) {
+        const first = run.calls.values().next().value;
+        if (first === undefined)
+            return [];
+        // Named after the run's first call: a call that takes a card of its own is named by its id.
+        run.card ??= `fold:${first.id}`;
+        // The command of each timed call of the run, which the card lists when it is expanded.
+        const lines = [...run.calls.values()].flatMap((call) => call.startedAt !== null && call.details !== null ? [call.details] : []);
+        const details = lines.length === 0 ? null : lines.slice(-RUN_COMMANDS).join("\n");
+        const running = [...run.calls.values()].filter((call) => !ENDED.includes(call.status));
+        const now = running.at(-1);
+        // A call still running when the reply's body ends has no count yet and stays a card.
+        if (now !== undefined) {
+            return [card(run.card, now.title, now.status, now.name, null, now.startedAt, details)];
+        }
+        const ended = run.ended.flatMap((id) => run.calls.get(id) ?? []);
+        const line = counts(ended);
+        const status = ended.some((call) => call.status === "complete")
+            ? "complete"
+            : "error";
+        return [card(run.card, line, status, "", line, null, details)];
+    }
+    changed(cards) {
+        const out = cards.filter((card) => !sameUpdate(this.sent.get(card.id), card));
+        for (const card of out)
+            this.sent.set(card.id, card);
+        return out;
+    }
+}
+/** A run's card: a title and a state, and the line that replaces it at the reply's end. */
+function card(id, title, status, name, line, startedAt, details) {
+    return {
+        id,
+        title,
+        status,
+        details,
+        output: null,
+        name,
+        task: false,
+        calls: 0,
+        preview: null,
+        folded: line,
+        startedAt,
+    };
+}

package/dist/core/reply/previews.js

@@ -0,0 +1,258 @@
+import { ANSWERED, fill, named, TASK_LAUNCHED, TASKS_LAUNCHED, TASKS_LAUNCHED_BRANCH, TASKS_LAUNCHED_LAST, } from "../texts.js";
+import { oneLine, spaced, splitLines, TITLE_LIMIT } from "./words.js";
+// How the terminal folds finished calls of these tools. Captured from the terminal on Claude Code
+// 2.1.283 (2026-09-27), where Bash also does the searching (the CLI has no Grep or Glob tool):
+// `echo hi` read `Ran 1 shell command`, `ls` `Listed 1 directory`, a grep `Searched for 1
+// pattern`. That classification of the command is undocumented, so every Bash call reads here as
+// a shell command.
+export const WORDS = {
+    Bash: ["Ran {n} shell command", "Ran {n} shell commands"],
+    Read: ["Read {n} file", "Read {n} files"],
+};
+// A diff line's colour where Slack draws none (mobile); an emoji is two columns wide, so a
+// context line gets two spaces and the numbers stay aligned.
+export const MARKS = {
+    "-": "\u{1f7e5}",
+    "+": "\u{1f7e9}",
+    " ": "  ",
+};
+// The terminal shows a new file's first lines, then how many it leaves out.
+export const NEW_FILE_LINES = 10;
+// The tools `preview` reads. A reply shows a call of one only once it has ended: a stream cannot
+// take back a card, and a call that ended well is its preview alone.
+export const PREVIEWED = new Set(["Edit", "Write"]);
+// The tools whose call a reply holds until it ends, as for `PREVIEWED`: a question the owner
+// answers leaves a record in place of its card (`answered`).
+export const ASKERS = new Set(["AskUserQuestion"]);
+// The tools that start an agent. A reply holds a call of one until its task says how it runs: in
+// the background the terminal writes a line and no more (`launched`), and a stream cannot take
+// back a card.
+export const LAUNCHERS = new Set(["Agent"]);
+// The type the terminal does not name in an agent's launch line: it reads `Agent(...)`, the
+// call's name, as for no type.
+const PLAIN_AGENT = "general-purpose";
+/**
+ * The launch line of a task started in the background: the agent's type when it names one, else
+ * the name of the call that started it, then what the task does.
+ */
+export function launched(launch) {
+    const { name, agentType, description, model } = launch;
+    const shown = agentType === null || agentType === PLAIN_AGENT ? name : agentType;
+    return fill(TASK_LAUNCHED, {
+        name: shown,
+        description: oneLine(description, TITLE_LIMIT),
+        model: model === null ? "" : ` ${model}`,
+    });
+}
+/**
+ * The lines for the tasks one message started in the background: one task's own line, or for
+ * several a count and what each does, with no name.
+ */
+export function launchedTogether(launches) {
+    const [only] = launches;
+    if (only !== undefined && launches.length === 1)
+        return launched(only);
+    const lines = launches.map(({ description }, index) => fill(index === launches.length - 1 ? TASKS_LAUNCHED_LAST : TASKS_LAUNCHED_BRANCH, {
+        description: oneLine(description, TITLE_LIMIT),
+    }));
+    return [fill(TASKS_LAUNCHED, { n: launches.length }), ...lines].join("\n");
+}
+// The tools whose failed call the terminal counts with the others and says nothing more of: a
+// command that exits with an error was seen counted in `ran 4 shell commands` (captured on
+// Claude Code 2.1.296, 2026-10-13). No other tool's failure was captured.
+const FAILS_COUNTED = new Set(["Bash"]);
+/** Whether a failed call of that tool is counted in its run with the calls that ended well. */
+export function failsCounted(name) {
+    return FAILS_COUNTED.has(name);
+}
+// The input the terminal titles a running call by: a command's line reads its description
+// (`Sleeping 20 seconds then printing marker`), with the command itself under it.
+const DESCRIBED = { Bash: "description" };
+/** The terminal's title for a call that runs, where it has one of its own; null for any other. */
+export function described(name, input) {
+    const said = Object.hasOwn(DESCRIBED, name) ? input[DESCRIBED[name]] : undefined;
+    return typeof said === "string" && said.trim() !== "" ? oneLine(said, TITLE_LIMIT) : null;
+}
+// The input a timed call shows under its title, after a prompt mark: a running command's line in
+// the terminal reads `$ <command> (5s)` (captured on Claude Code 2.1.301, 2026-10-16).
+const COMMANDED = { Bash: "command" };
+const COMMAND_LIMIT = 200;
+/**
+ * The line a call the terminal times lists under its title (`$ sleep 20`); null for any other
+ * call, and for one whose input holds no text there.
+ */
+export function commandLine(name, input) {
+    const said = Object.hasOwn(COMMANDED, name) ? input[COMMANDED[name]] : undefined;
+    return typeof said === "string" && said.trim() !== ""
+        ? `$ ${oneLine(said, COMMAND_LIMIT)}`
+        : null;
+}
+// The calls that continue an agent already started, and the input that names it: the terminal
+// draws no line for such a call, and writes `Resuming agent` under the agent (captured on
+// Claude Code 2.1.301, 2026-10-16).
+const CONTINUERS = { SendMessage: "to" };
+const RESUMING = "\u23bf Resuming agent {id}";
+// The terminal names an agent by the first characters of its id.
+const AGENT_ID_CHARS = 7;
+/** The task a call continues, when its tool is one that continues an agent; null otherwise. */
+export function continued(name, input) {
+    const to = Object.hasOwn(CONTINUERS, name) ? input[CONTINUERS[name]] : undefined;
+    return typeof to === "string" && to !== "" ? to : null;
+}
+/** The line that says the task `taskId` is resumed. */
+export function resuming(taskId) {
+    return fill(RESUMING, { id: taskId.slice(0, AGENT_ID_CHARS) });
+}
+/**
+ * How `n` finished calls of `name` read in a folded line. The terminal's words take a capital
+ * only when they open the line (`Read 1 file, ran 4 shell commands`); a tool's name is its own.
+ */
+export function folded(name, n, first = true) {
+    const words = Object.hasOwn(WORDS, name) ? WORDS[name] : undefined;
+    if (words === undefined) {
+        return n === 1 ? name : `${name} ×${n}`;
+    }
+    const said = fill(n === 1 ? words[0] : words[1], { n });
+    return first ? said : said.charAt(0).toLowerCase() + said.slice(1);
+}
+function counted(n, noun = "line") {
+    return `${n} ${noun}${n === 1 ? "" : "s"}`;
+}
+/** The parts of a POSIX path as Python's `PurePosixPath` keeps them: no empty part, no `.`. */
+function parts(path) {
+    return path.split("/").filter((part) => part !== "" && part !== ".");
+}
+/** The path as the terminal names it: relative to the session's folder when inside it. */
+function shown(path, cwd) {
+    if (!cwd)
+        return path;
+    const base = parts(cwd);
+    const inner = parts(path);
+    const inside = path.startsWith("/") === cwd.startsWith("/") &&
+        base.length <= inner.length &&
+        base.every((part, index) => inner[index] === part);
+    if (!inside)
+        return path;
+    return inner.slice(base.length).join("/") || ".";
+}
+/**
+ * Lines added and removed, and the hunks numbered as the terminal numbers them: a removed line
+ * by its old number, any other by its new one, `...` between hunks. The sign leads the line,
+ * where Slack desktop's diff highlighting looks for it; a coloured square follows, since Slack
+ * mobile does not highlight (both measured 2026-09-27): `-🟥 7 sette`, `+🟩 7 7`.
+ */
+function diff(hunks) {
+    let added = 0;
+    let removed = 0;
+    const rows = [];
+    for (const [index, hunk] of hunks.entries()) {
+        let { oldStart: old, newStart: fresh } = hunk;
+        if (index > 0)
+            rows.push([0, "..."]);
+        for (const line of hunk.lines) {
+            const sign = line.charAt(0);
+            const text = line.slice(1);
+            if (sign === "-") {
+                rows.push([old, `-${text}`]);
+                old += 1;
+                removed += 1;
+            }
+            else if (sign === "+") {
+                rows.push([fresh, `+${text}`]);
+                fresh += 1;
+                added += 1;
+            }
+            else if (sign === " ") {
+                rows.push([fresh, ` ${text}`]);
+                old += 1;
+                fresh += 1;
+            }
+            else if (sign !== "\\") {
+                // `` is about the line above: skipped
+                return null;
+            }
+        }
+    }
+    const width = String(Math.max(0, ...rows.map(([n]) => n))).length;
+    const body = rows.map(([n, text]) => {
+        const sign = text.charAt(0);
+        return n === 0 ? text : `${sign}${MARKS[sign]} ${String(n).padStart(width)} ${text.slice(1)}`;
+    });
+    return { added, removed, body };
+}
+function changed(added, removed) {
+    const said = added > 0 ? [`Added ${counted(added)}`] : [];
+    if (removed > 0) {
+        said.push(said.length > 0 ? `removed ${counted(removed)}` : `Removed ${counted(removed)}`);
+    }
+    return said.join(", ") || "No change";
+}
+/**
+ * The answers to a question as the terminal keeps them: a line per question that has one,
+ * `· question → answer`, a multi-select's answers joined by commas. Null with no answer.
+ * `names` fill the title, which names who wrote the questions.
+ */
+export function answered(questions, answers, names) {
+    const lines = [];
+    for (const question of questions) {
+        const answer = Object.hasOwn(answers, question.text) ? (answers[question.text] ?? "") : "";
+        const said = typeof answer === "string" ? answer : answer.join(", ");
+        if (said !== "") {
+            // One line each, however the question or a typed answer was written.
+            lines.push(`· ${spaced(question.text)} → ${spaced(said)}`);
+        }
+    }
+    if (lines.length === 0)
+        return null;
+    return {
+        title: named(ANSWERED, names),
+        summary: "",
+        body: lines.join("\n"),
+        language: "",
+        plain: true,
+        record: true,
+    };
+}
+/**
+ * The terminal's view of a finished `Edit` or `Write` from what it did to a file, or null for
+ * any other tool and for a call that reports no change. `cwd` is the session's folder.
+ */
+export function preview(name, change, cwd) {
+    if (change === null)
+        return null;
+    const path = shown(change.path, cwd);
+    if (name === "Write" && change.kind === "created") {
+        if (change.content === null)
+            return null;
+        const lines = splitLines(change.content);
+        const width = String(Math.min(lines.length, NEW_FILE_LINES)).length;
+        const body = lines
+            .slice(0, NEW_FILE_LINES)
+            .map((line, index) => `${String(index + 1).padStart(width)} ${line}`);
+        if (lines.length > NEW_FILE_LINES)
+            body.push(`… +${counted(lines.length - NEW_FILE_LINES)}`);
+        return {
+            title: `Write(${path})`,
+            summary: `Wrote ${counted(lines.length)} to ${path}`,
+            body: body.join("\n"),
+            language: "",
+            plain: false,
+            record: false,
+        };
+    }
+    if (PREVIEWED.has(name) && change.hunks.length > 0) {
+        const numbered = diff(change.hunks);
+        if (numbered === null)
+            return null;
+        // The terminal names an edit `Update`, and a Write over an existing file keeps `Write`.
+        return {
+            title: `${name === "Edit" ? "Update" : "Write"}(${path})`,
+            summary: changed(numbered.added, numbered.removed),
+            body: numbered.body.join("\n"),
+            language: "diff",
+            plain: false,
+            record: false,
+        };
+    }
+    return null;
+}