@litfamily/litopencode 1.0.36 → 1.0.38

package/dist/v2/tui-footer.d.ts

@@ -0,0 +1,20 @@
+import type { MissionView } from "../tui/mission-model.ts";
+import type { MotionFrame } from "../tui/mission-motion.ts";
+import { type Line, type MissionPalette } from "../tui/mission-text.ts";
+/** The session sidebar, which a wide terminal is taken to have open (the setting is not readable by a plugin). */
+export declare const sidebarCells = 42;
+export declare function footerBudget(input: {
+    readonly columns: number;
+    readonly sidebar: boolean;
+    readonly busy: boolean;
+}): number;
+export type FooterInput = {
+    /** The discipline the latest lit prompt started, as the server wrote it into the message. */
+    readonly name: string;
+    readonly view: MissionView | undefined;
+    readonly frame: MotionFrame;
+    readonly palette: MissionPalette;
+    readonly budget: number;
+};
+/** The footer line for `budget` cells, as segments; empty when not even the flame fits. */
+export declare function footerStatus(input: FooterInput): Line;

package/dist/v2/tui-footer.js

@@ -0,0 +1,56 @@
+// What OpenCode 2's prompt footer row holds besides our line, and how our line steps down to the room left.
+// The row is the host's spinner and `esc interrupt` hint on the left and its token, goal and `ctrl+p commands`
+// figures on the right; our line is squeezed between them, and the host clips it mid-word when it is too long.
+// So the line is chosen by width: the ignition mark with the whole stage chip, the chip at a smaller size,
+// the chip as `🔥 1/3`, the bare flame, then nothing. The numbers were measured on opencode2 2.2.5.
+import { activationDiscipline } from "../activation-probe.js";
+import { cellWidth, chipLine, lineWidth } from "../tui/mission-text.js";
+/** The session sidebar, which a wide terminal is taken to have open (the setting is not readable by a plugin). */
+export const sidebarCells = 42;
+// Right of our line: with a turn running `↓ 1 shell · ◎ goal  ctrl+p commands`, idle `◎ goal paused · 42.3K (8%) · $0.07  ctrl+p commands`.
+const hostRightBusy = 38;
+const hostRightIdle = 54;
+// Left of it, the least the host keeps: the spinner and a shortened `esc …rrupt` while running, a shortened path when idle.
+const hostLeftBusy = 24;
+const hostLeftIdle = 6;
+const gap = 2;
+export function footerBudget(input) {
+    const main = input.columns - (input.sidebar ? sidebarCells : 0);
+    const host = input.busy ? hostRightBusy + hostLeftBusy : hostRightIdle + hostLeftIdle;
+    return Math.max(0, main - host);
+}
+const flameWidth = 2;
+/** The footer line for `budget` cells, as segments; empty when not even the flame fits. */
+export function footerStatus(input) {
+    const { palette, budget } = input;
+    const discipline = activationDiscipline(input.name);
+    const mark = (text) => [{ text, fg: palette.primary, bold: true }];
+    const full = `🔥 LIT IGNITED · ${discipline}`;
+    const active = input.view !== undefined && input.view.active;
+    const chipFor = (room, largest) => {
+        if (!active || input.view === undefined || room < flameWidth)
+            return [];
+        const chip = chipLine(input.view, input.frame, palette, room, largest);
+        return lineWidth(chip) <= room ? chip : [];
+    };
+    if (!active) {
+        if (cellWidth(full) <= budget)
+            return mark(full);
+    }
+    else {
+        const beside = chipFor(budget - cellWidth(full) - gap, "full");
+        if (beside.length > 0)
+            return [...mark(full), { text: " ".repeat(gap), fg: palette.muted }, ...beside];
+        // The chip is worth more than the mark's words, so it stays alone when both do not fit. Alone it never
+        // grows past the middle size, so the line only gets smaller as the room does.
+        const alone = chipFor(budget, "medium");
+        if (alone.length > 0)
+            return alone;
+    }
+    const short = `🔥 ${discipline}`;
+    if (cellWidth(short) <= budget)
+        return mark(short);
+    if (budget >= flameWidth)
+        return mark("🔥");
+    return [];
+}

package/dist/v2/tui-notices.d.ts

@@ -0,0 +1,7 @@
+import { type MissionNotice, type MissionView } from "../tui/mission-model.ts";
+import type { ThreadRow } from "../tui/mission-threads.ts";
+/**
+ * Stage, discipline and lane changes between two views. A first view never toasts its history. A lane
+ * counts as started when its key is new and working, and as finished when a working lane is gone or done.
+ */
+export declare function v2StageNotices(prev: MissionView | undefined, next: MissionView, before: readonly ThreadRow[], after: readonly ThreadRow[]): readonly MissionNotice[];

package/dist/v2/tui-notices.js

@@ -0,0 +1,45 @@
+// The toasts OpenCode 2 raises beyond the shared gate events (plan saved, goal set, criterion passed,
+// blockers, complete): the workflow stage moving, a discipline switching, a lane starting or finishing.
+// They are pure: the TUI hands in the previous and next view and thread rows and gets notices back,
+// which leadingNotice folds into one toast with a `+N more` tail.
+import { stepName } from "../tui/mission-model.js";
+const maxNamed = 1;
+function runningStage(view) {
+    const step = view.steps.find((candidate) => candidate.state === "now");
+    if (step === undefined)
+        return undefined;
+    const count = view.progress !== undefined && view.progress.total > 0 ? ` ${view.progress.done}/${view.progress.total}` : "";
+    return { id: `${view.family}:${step.id}`, label: `${stepName(step.id, view)}${count}` };
+}
+function laneNotice(rows, verb) {
+    if (rows.length === 0)
+        return undefined;
+    const message = rows.length > maxNamed ? `${rows.length} lanes ${verb}` : `lane ${verb} · ${rows[0].name}`;
+    return { variant: "info", title: "🔥 Lane", message };
+}
+/**
+ * Stage, discipline and lane changes between two views. A first view never toasts its history. A lane
+ * counts as started when its key is new and working, and as finished when a working lane is gone or done.
+ */
+export function v2StageNotices(prev, next, before, after) {
+    if (prev === undefined || !next.active)
+        return [];
+    const notices = [];
+    if (prev.active && prev.discipline !== next.discipline && next.discipline !== "") {
+        notices.push({ variant: "info", title: `🔥 ${prev.discipline} → ${next.discipline}`, message: "Discipline switched." });
+    }
+    else if (prev.active && !next.complete) {
+        const was = runningStage(prev);
+        const now = runningStage(next);
+        if (was !== undefined && now !== undefined && was.id !== now.id)
+            notices.push({ variant: "info", title: "🔥 Stage", message: now.label });
+    }
+    const priorKeys = new Set(before.map((row) => row.key));
+    const nextByKey = new Map(after.map((row) => [row.key, row]));
+    const started = after.filter((row) => row.status === "working" && !priorKeys.has(row.key));
+    const finished = before.filter((row) => row.status === "working" && (nextByKey.get(row.key) === undefined || nextByKey.get(row.key)?.status === "done"));
+    for (const notice of [laneNotice(started, "started"), laneNotice(finished, "finished")])
+        if (notice !== undefined)
+            notices.push(notice);
+    return notices;
+}

package/dist/v2/tui.d.ts

@@ -5,6 +5,11 @@ export type TuiRuntime = {
     readonly createSignal: <T>(value: T) => readonly [() => T, (value: T) => T];
     readonly createEffect: (fn: () => void) => void;
     readonly createRoot: <T>(fn: (dispose: () => void) => T) => T;
+    /** The host's terminal size, reactive; a stand-in runtime may leave it out. */
+    readonly useTerminalDimensions?: () => () => {
+        readonly width: number;
+        readonly height: number;
+    };
 };
 type PromptFooterInput = {
     readonly sessionID?: string;
@@ -19,15 +24,44 @@ export type SlotClaimLike = {
 } | {
     readonly append: "prompt.footer.status";
     readonly render: (input: PromptFooterInput) => unknown;
+} | {
+    readonly append: "app";
+    readonly render: (input: Record<string, never>) => unknown;
+} | {
+    readonly append: "home.footer";
+    readonly render: (input: Record<string, never>) => unknown;
 };
 export type TuiContextLike = {
+    readonly options?: unknown;
     readonly location: {
         readonly directory: string;
     } | undefined;
     readonly theme: unknown;
     readonly themeMode: "dark" | "light";
+    /** The host's API client; only `usage.limits` is read, and a host without it simply shows no plan figures. */
+    readonly client?: {
+        readonly usage?: {
+            readonly limits?: () => Promise<unknown>;
+        };
+    };
+    readonly attention?: {
+        readonly notify: (options: {
+            readonly title?: string;
+            readonly message: string;
+            readonly notification?: boolean;
+            readonly sound?: boolean | {
+                readonly name?: "done";
+            };
+        }) => Promise<unknown>;
+    };
     readonly ui: {
         readonly slot: (claim: SlotClaimLike) => () => void;
+        readonly router?: {
+            current(): {
+                readonly type: string;
+                readonly sessionID?: string;
+            };
+        };
         readonly toast: {
             readonly show: (options: {
                 readonly title?: string;
@@ -49,11 +83,19 @@ export type TuiContextLike = {
                 readonly type: string;
             };
         }) => void) => () => void;
-        readonly location: {
+        readonly location: MissionDataV2["location"] & {
             default(): {
                 readonly directory: string;
             };
         };
+        readonly session: MissionDataV2["session"] & {
+            get?(sessionID: string): {
+                readonly parentID?: string;
+                readonly time?: {
+                    readonly created?: number;
+                };
+            } | undefined;
+        };
     };
 };
 /** OpenCode 2 theme tokens under the names the mission palette reads. */