@hraness/dawg 0.6.1 → 0.7.0

package/tui/activity.ts

@@ -23,6 +23,33 @@ export interface ActivityCard {
   trackId?: string | undefined;
   /** Key hint shown after the card, e.g. "u undo". */
   hint?: string | undefined;
+  /**
+   * A one-time info card (a launch note, a tip): it leaves the strip after
+   * `ONCE_TTL_MS` or `ONCE_ACTIONS` later actions, whichever comes first.
+   */
+  once?: boolean | undefined;
+  /** Repeats of the same text and tone, shown as `×N` (absent is 1). */
+  count?: number | undefined;
+  /** A quieter note joined to the card, e.g. the auto-name. */
+  suffix?: string | undefined;
+  /** `actions` when the card was pushed, for the `once` expiry. */
+  atAction?: number | undefined;
+}
+
+/** A `once` card's lifetime in milliseconds. */
+export const ONCE_TTL_MS = 8_000;
+/** Actions (receipts, requests) after which a `once` card leaves. */
+export const ONCE_ACTIONS = 3;
+/** Age after which an older error fades to the faint role. */
+export const ERROR_FADE_MS = 6_000;
+
+/** One strip line: newlines read as ` · `, runs of space collapse. */
+export function stripLine(text: string): string {
+  return text
+    .split(/\s*\n\s*/)
+    .map((part) => part.replace(/[ \t]+/g, " ").trim())
+    .filter(Boolean)
+    .join(" · ");
 }
 
 export type TranscriptKind =
@@ -134,7 +161,10 @@ export class ActivityFeed {
   private spinnerLabel: string | undefined;
   private spinnerSince = 0;
   private streamText = "";
+  private turnReceipt = "";
   private queue = 0;
+  /** Receipts and requests so far: the clock `once` cards expire on. */
+  private actions = 0;
   private listeners = new Set<() => void>();
   /** Increments on every change; renderers can skip work when unchanged. */
   version = 0;
@@ -167,6 +197,36 @@ export class ActivityFeed {
     return this.cardList[this.cardList.length - 1];
   }
 
+  /**
+   * The cards the strip shows at `nowMs`, first slot first: the newest
+   * receipt leads, live `once` notes follow it, and expired `once` notes
+   * are gone.
+   */
+  visible(nowMs: number = this.clock()): ActivityCard[] {
+    const live = this.cardList.filter(
+      (card) =>
+        !card.once ||
+        (nowMs - card.atMs < ONCE_TTL_MS &&
+          this.actions - (card.atAction ?? 0) < ONCE_ACTIONS),
+    );
+    const newest = [...live].reverse();
+    return [
+      ...newest.filter((card) => !card.once),
+      ...newest.filter((card) => card.once),
+    ];
+  }
+
+  /** The next time a `once` card expires on the clock, for frame wakeups. */
+  nextExpiry(nowMs: number = this.clock()): number | undefined {
+    let next: number | undefined;
+    for (const card of this.cardList) {
+      if (!card.once) continue;
+      const at = card.atMs + ONCE_TTL_MS;
+      if (at > nowMs && (next === undefined || at < next)) next = at;
+    }
+    return next;
+  }
+
   subscribe(listener: () => void): () => void {
     this.listeners.add(listener);
     return () => this.listeners.delete(listener);
@@ -176,32 +236,85 @@ export class ActivityFeed {
     text: string,
     details: Omit<Partial<ActivityCard>, "id" | "atMs" | "text"> = {},
   ): ActivityCard {
+    const line = stripLine(text);
+    const once = details.once === true;
+    if (!once) this.actions += 1;
+    const last = this.cardList[this.cardList.length - 1];
+    const tone = details.tone ?? "info";
+    // The same message again reads `×N` instead of filling the strip.
+    if (
+      last &&
+      last.text === line &&
+      last.tone === tone &&
+      last.resultRevision === details.resultRevision
+    ) {
+      const repeat: ActivityCard = {
+        ...last,
+        count: (last.count ?? 1) + 1,
+        atMs: this.clock(),
+        atAction: this.actions,
+      };
+      this.cardList = [...this.cardList.slice(0, -1), repeat];
+      this.record(tone === "error" ? "error" : "op", line);
+      this.changed();
+      return repeat;
+    }
     const card: ActivityCard = {
       id: this.nextId++,
-      text,
-      tone: details.tone ?? "info",
+      text: line,
+      tone,
       atMs: this.clock(),
       baseRevision: details.baseRevision,
       resultRevision: details.resultRevision,
       trackId: details.trackId,
       hint: details.hint,
+      ...(once ? { once: true } : {}),
+      ...(details.suffix ? { suffix: stripLine(details.suffix) } : {}),
+      atAction: this.actions,
     };
     this.cardList = [...this.cardList, card].slice(-this.maxCards);
     const revision = revisionLabel(card.baseRevision, card.resultRevision);
     this.record(
       card.tone === "error" ? "error" : "op",
-      revision ? `${text} · ${revision}` : text,
+      revision ? `${line} · ${revision}` : line,
     );
     this.changed();
     return card;
   }
 
+  /**
+   * Join a quiet note to the newest receipt (`… · named "dusk loop"`), so
+   * it rides in the first slot instead of pushing the receipt aside. With
+   * no receipt in the last few seconds it becomes a `once` card.
+   */
+  attachNote(text: string, withinMs = ONCE_TTL_MS): ActivityCard {
+    const line = stripLine(text);
+    const last = this.cardList[this.cardList.length - 1];
+    if (
+      last &&
+      !last.once &&
+      last.tone !== "error" &&
+      this.clock() - last.atMs < withinMs
+    ) {
+      const joined: ActivityCard = {
+        ...last,
+        suffix: last.suffix ? `${last.suffix} · ${line}` : line,
+      };
+      this.cardList = [...this.cardList.slice(0, -1), joined];
+      this.record("note", line);
+      this.changed();
+      return joined;
+    }
+    return this.pushCard(line, { tone: "info", once: true });
+  }
+
   pushError(message: string): ActivityCard {
     return this.pushCard(message, { tone: "error" });
   }
 
   /** Record a user request in the transcript without adding a strip card. */
   pushRequest(text: string): void {
+    this.actions += 1;
     this.record("request", text);
     this.changed();
   }
@@ -227,6 +340,23 @@ export class ActivityFeed {
     this.changed();
   }
 
+  /**
+   * The musical receipt of the running agent turn (`musicalReceipt` of the
+   * score before and after), shown as the turn's closing card.
+   */
+  setTurnReceipt(text: string): void {
+    this.turnReceipt = text;
+  }
+
+  /**
+   * The latest prose sentence of the streaming agent text, for the faint
+   * tail of the spinner: a complete sentence when one has ended, else the
+   * one being written.
+   */
+  get streamSentence(): string {
+    return latestSentence(this.streamText);
+  }
+
   /** Adapter for the agent lane's streaming events. */
   applyAgentEvent(event: AgentActivityEvent): void {
     switch (event.type) {
@@ -271,7 +401,7 @@ export class ActivityFeed {
           baseRevision: event.baseRevision,
           resultRevision: event.resultRevision,
           trackId: event.trackId,
-          hint: unchanged ? undefined : "^z undo",
+          hint: unchanged ? undefined : "ctrl-z undo",
         });
         return;
       }
@@ -287,9 +417,20 @@ export class ActivityFeed {
       case "done": {
         if (this.streamText) this.record("agent", this.streamText);
         this.streamText = "";
+        // A turn that changed the music ends on what it changed, in musical
+        // terms; its prose stays in the ctrl-o log.
+        const receipt = this.turnReceipt;
+        this.turnReceipt = "";
         const summary =
-          event.summary ?? event.text?.split("\n")[0]?.slice(0, 160);
-        if (summary) this.pushCard(summary, { tone: "agent" });
+          receipt ||
+          event.summary ||
+          firstSentence(event.text ?? "").slice(0, 160) ||
+          undefined;
+        if (summary)
+          this.pushCard(summary, {
+            tone: "agent",
+            hint: receipt ? "ctrl-z undo" : undefined,
+          });
         else if (event.applied === 0)
           this.pushCard("agent made no changes", { tone: "info" });
         this.setSpinner(undefined);
@@ -300,7 +441,7 @@ export class ActivityFeed {
         this.setSpinner(undefined);
         if (event.code === "aborted")
           this.pushCard(
-            `cancelled${event.revision === undefined ? "" : ` · kept rev ${event.revision}`}`,
+            `canceled${event.revision === undefined ? "" : ` · kept rev ${event.revision}`}`,
             { tone: "warning" },
           );
         else
@@ -331,11 +472,16 @@ export class ActivityFeed {
  * success, `false` a failure, `"warn"` a no-op or conflict. Handlers return
  * these so the strip never infers failure from prose.
  */
-export type Receipt = Readonly<{ ok: boolean | "warn"; text: string }>;
+export type Receipt = Readonly<{
+  ok: boolean | "warn" | "info";
+  text: string;
+}>;
 
 export const ok = (text: string): Receipt => ({ ok: true, text });
 export const fail = (text: string): Receipt => ({ ok: false, text });
 export const warn = (text: string): Receipt => ({ ok: "warn", text });
+/** A status read (`•`): nothing changed (bare `fx`, `tracks`). */
+export const note = (text: string): Receipt => ({ ok: "info", text });
 
 /** Tone of a structured receipt; strings fall back to `receiptTone`. */
 export function toneOf(receipt: string | Receipt): CardTone {
@@ -344,7 +490,9 @@ export function toneOf(receipt: string | Receipt): CardTone {
     ? "success"
     : receipt.ok === "warn"
       ? "warning"
-      : "error";
+      : receipt.ok === "info"
+        ? "info"
+        : "error";
 }
 
 /**
@@ -362,3 +510,26 @@ export function receiptTone(message: string): CardTone {
     return "warning";
   return "success";
 }
+
+/** The first sentence of a reply (up to its first `.`, `!` or `?`). */
+export function firstSentence(text: string): string {
+  const flat = text.replace(/\s+/g, " ").trim();
+  const match = /^.*?[.!?](?=\s|$)/.exec(flat);
+  return (match ? match[0] : flat).trim();
+}
+
+/** The last complete sentence of streaming text, or the one in progress. */
+export function latestSentence(text: string): string {
+  const flat = text.replace(/\s+/g, " ").trim();
+  if (!flat) return "";
+  const sentences = flat.match(/[^.!?]+[.!?]+(?=\s|$)|[^.!?]+$/g) ?? [flat];
+  const last = sentences[sentences.length - 1]!.trim();
+  // A fragment of a few words reads as noise; keep the sentence before it.
+  if (
+    !/[.!?]$/.test(last) &&
+    last.split(" ").length < 4 &&
+    sentences.length > 1
+  )
+    return sentences[sentences.length - 2]!.trim();
+  return last;
+}