@litfamily/litopencode 1.0.18 → 1.0.20

package/dist/tui/mission-band.js

@@ -0,0 +1,290 @@
+// The band: a status card in OpenCode's full-width app_bottom slot that stays on screen for the
+// whole session, plus an opt-in detail card. Its border carries the LIT mark, the discipline and the
+// phase; row one is the phase track, row two the skill chips, and the bottom border the live figures.
+// It reuses the chip's pills, the panel's bar and the shared motion frame, so the chip, the panel and
+// the band always move together.
+import { ease, mixHex, motionTiming, seg } from "./mission-motion.js";
+import { contextWarnPercent, missionStatus } from "./mission-model.js";
+import { cellWidth, chipSparkCells, chipSparkWidth, fade, lineWidth, missionPanel, progressBar, shimmerAt, shine, statusSegments, stepPill, truncateCells } from "./mission-text.js";
+/**
+ * Reads the band switches from the plugin's tui.json options: `band: false` turns the band off,
+ * `band: { card: true }` adds the detail card under the status card. Anything else keeps the defaults.
+ */
+export function readBandOptions(options) {
+    const band = typeof options === "object" && options !== null ? options.band : undefined;
+    if (band === false)
+        return { enabled: false, card: false };
+    const card = typeof band === "object" && band !== null && band.card === true;
+    return { enabled: true, card };
+}
+const minimumText = 12;
+function elapsedText(minutes) {
+    const total = Math.max(0, minutes ?? 0);
+    return total < 60 ? `${total}m` : `${Math.floor(total / 60)}h${String(total % 60).padStart(2, "0")}`;
+}
+/** The text after the bar: a warning (⚑ and words) replaces the next task; a finished mission shows COMPLETE. */
+function trailing(view, frame, palette, room) {
+    if (view.complete) {
+        // Before COMPLETE pops in, the slot stays empty rather than flashing the header's "● active".
+        if (frame.celebrate !== undefined && frame.celebrate < motionTiming.popAt)
+            return [];
+        const status = statusSegments(view, frame, palette);
+        const lead = Math.max(1, 2 + status.offset);
+        return [{ text: " ".repeat(lead), fg: palette.muted }, ...status.segments];
+    }
+    const warning = view.warnings[0];
+    if (warning !== undefined) {
+        const color = warning.kind === "retry" ? mixHex(palette.warning, palette.error, 0.5) : palette.warning;
+        return [{ text: "  ⚑ ", fg: color, bold: true }, { text: truncateCells(warning.text, room - 4), fg: color }];
+    }
+    if (view.next === undefined)
+        return [];
+    return [{ text: "  ▸ ", fg: palette.muted }, { text: truncateCells(view.next, room - 4), fg: palette.text }];
+}
+/** Cuts or pads a line to exactly `width` cells, keeping wide glyphs whole. */
+function fitLine(line, width, palette) {
+    const out = [];
+    let used = 0;
+    for (const segment of line) {
+        const room = width - used;
+        if (room <= 0)
+            break;
+        if (cellWidth(segment.text) <= room) {
+            out.push(segment);
+            used += cellWidth(segment.text);
+            continue;
+        }
+        let text = "";
+        let taken = 0;
+        for (const char of segment.text) {
+            const w = cellWidth(char);
+            if (taken + w > room)
+                break;
+            text += char;
+            taken += w;
+        }
+        if (text !== "")
+            out.push({ ...segment, text });
+        used += taken;
+        break;
+    }
+    if (used < width)
+        out.push({ text: " ".repeat(width - used), fg: palette.muted });
+    return out;
+}
+/** A border row: corner, optional left label, rule, optional right label, corner; undefined when it does not fit. */
+function ruled(lead, left, right, tail, width, border) {
+    const space = { text: " ", fg: border };
+    const l = left.length > 0 ? [space, ...left, space] : [];
+    const r = right.length > 0 ? [space, ...right, space] : [];
+    const fill = width - cellWidth(lead) - lineWidth(l) - lineWidth(r) - cellWidth(tail);
+    if (fill < 1)
+        return undefined;
+    return [{ text: lead, fg: border }, ...l, { text: "─".repeat(fill), fg: border }, ...r, { text: tail, fg: border }];
+}
+function borderColor(view, frame, palette) {
+    if (!view.active)
+        return palette.borderActive;
+    const enter = frame.chipEnter ? ease.outCubic(seg(frame.t, 0, motionTiming.entry)) : 1;
+    const done = view.complete ? (frame.celebrate === undefined ? 1 : ease.inOutCubic(seg(frame.celebrate, 0, motionTiming.crossfade))) : 0;
+    return mixHex(palette.borderActive, mixHex(mixHex(palette.accent, palette.warning, frame.warn), palette.success, done), enter);
+}
+/** The phase on the right of the title: always a glyph plus words. */
+function phaseLabel(view, frame, palette) {
+    if (!view.active)
+        return { text: "○ IDLE", fg: palette.muted };
+    const status = missionStatus(view);
+    if (status.tone === "success")
+        return { text: "✓ COMPLETE", fg: palette.success, bold: true };
+    if (status.tone === "warning")
+        return { text: `⚑ ${status.text}`, fg: mixHex(palette.info, palette.warning, Math.max(frame.warn, 0.5)), bold: true };
+    return { text: `● ${view.phase.toUpperCase()}`, fg: palette.info, bold: true };
+}
+function topLine(view, frame, palette, width, border) {
+    const brand = [{ text: "🔥 ", fg: palette.text }, { text: "LIT", fg: shine(palette.primary, palette, 0.5, shimmerAt(frame), 0.6), bold: true }];
+    const name = view.active ? view.discipline : "ready";
+    const right = [phaseLabel(view, frame, palette)];
+    const withName = (room) => [...brand, { text: " · ", fg: palette.muted }, { text: truncateCells(name, room), fg: view.active ? palette.text : palette.muted }];
+    const nameRoom = width - cellWidth("╭─") - lineWidth(withName(0)) - 2 - (lineWidth(right) + 2) - cellWidth("─╮") - 1;
+    const attempts = [];
+    if (nameRoom >= Math.min(4, cellWidth(name)))
+        attempts.push([withName(nameRoom), right]);
+    attempts.push([brand, right], [brand, []]);
+    for (const [left, label] of attempts) {
+        const line = ruled("╭─", left, label, "─╮", width, border);
+        if (line !== undefined)
+            return line;
+    }
+    return fitLine([{ text: "╭" + "─".repeat(Math.max(0, width)), fg: border }], width, palette);
+}
+/** The figures in the bottom border, most important first; the last ones go first when room runs out. */
+function figureParts(view, figures, palette) {
+    const parts = [];
+    if (figures.contextPercent !== null) {
+        const percent = Math.round(figures.contextPercent);
+        parts.push({ text: `ctx ${percent}%`, fg: percent >= contextWarnPercent ? palette.warning : palette.muted });
+    }
+    if (view.active)
+        parts.push({ text: `⟳ ${elapsedText(view.elapsedMinutes)}${figures.inLane ? " · in lane" : ""}`, fg: palette.muted });
+    if (figures.branch !== undefined)
+        parts.push({ text: `⎇ ${truncateCells(figures.branch, 24)}`, fg: palette.muted });
+    return parts;
+}
+function bottomLine(view, figures, palette, width, border) {
+    const parts = figureParts(view, figures, palette);
+    for (let count = parts.length; count >= 0; count -= 1) {
+        const right = [];
+        parts.slice(0, count).forEach((part, index) => right.push(...(index === 0 ? [] : [{ text: " · ", fg: palette.muted }]), part));
+        const line = ruled("╰", [], right, "─╯", width, border);
+        if (line !== undefined)
+            return line;
+    }
+    return fitLine([{ text: "╰" + "─".repeat(Math.max(0, width)), fg: border }], width, palette);
+}
+function trackPills(view, frame, palette, tight) {
+    const alpha = (index) => (frame.chipEnter ? ease.outCubic(seg(frame.t, index * motionTiming.stagger, motionTiming.entry)) : 1);
+    if (tight) {
+        const current = view.steps.find((step) => step.state === "now" || step.state === "warn") ?? view.steps[view.complete ? 2 : view.active ? 1 : 0];
+        return [fade(stepPill(current, view, frame, palette), alpha(0), palette)];
+    }
+    const out = [];
+    view.steps.forEach((step, index) => {
+        if (index > 0)
+            out.push(fade({ text: " ━ ", fg: view.steps[index - 1].state === "done" ? palette.success : palette.borderSubtle }, alpha(index), palette));
+        out.push(fade(stepPill(step, view, frame, palette), alpha(index), palette));
+    });
+    return out;
+}
+/** The text after the track in an idle session: the project's last goal, or how to start. */
+function idleText(last, palette, room) {
+    if (last === undefined || last.title === "")
+        return [{ text: "  ", fg: palette.muted }, { text: truncateCells("add lit to a prompt to start", room - 2), fg: palette.muted }];
+    const mark = last.complete ? { text: ` ✓ ${last.passed}/${last.total}`, fg: palette.success } : { text: ` ● ${last.passed}/${last.total}`, fg: palette.info };
+    const head = { text: "  last: ", fg: palette.muted };
+    return [head, { text: truncateCells(last.title, room - cellWidth(head.text) - cellWidth(mark.text)), fg: palette.text }, mark];
+}
+// Shedding order as the row narrows: the next-task text, bar width, the bar, the criteria count and
+// then the step labels. Each plan is tried in turn and the first that fits wins.
+const trackPlans = [
+    { tight: false, bar: 16, criteria: true, text: true },
+    { tight: false, bar: 16, criteria: true, text: false },
+    { tight: false, bar: 8, criteria: true, text: false },
+    { tight: false, bar: 0, criteria: true, text: false },
+    { tight: false, bar: 0, criteria: false, text: false },
+    { tight: true, bar: 0, criteria: false, text: false }
+];
+function trackRow(view, frame, palette, width, last) {
+    const sweep = shimmerAt(frame);
+    const gap = { text: "  ", fg: palette.muted };
+    for (const plan of trackPlans) {
+        const pills = trackPills(view, frame, palette, plan.tight);
+        const bar = plan.bar > 0 && view.progress !== undefined ? [gap, ...progressBar(frame.barRatio, plan.bar, palette, sweep)] : [];
+        const goal = view.goal;
+        const criteria = plan.criteria && goal !== undefined ? [gap, { text: `${goal.passed}/${goal.total} criteria`, fg: goal.total > 0 && goal.passed === goal.total ? palette.success : palette.muted }] : [];
+        const fixed = lineWidth(pills) + lineWidth(bar) + lineWidth(criteria);
+        if (fixed > width)
+            continue;
+        const room = width - fixed;
+        const after = plan.text ? (view.active ? trailing(view, frame, palette, room) : idleText(last, palette, room)) : [];
+        const keepText = plan.text && after.length > 0 && (view.complete ? lineWidth(after) <= room : room >= minimumText);
+        if (plan.text && after.length > 0 && !keepText)
+            continue;
+        const body = [...pills, ...bar, ...criteria, ...(keepText ? after : [])];
+        // Sparks sit after the text, in the free space, so the pills never shift while they play.
+        const sparks = frame.celebrate !== undefined && lineWidth(body) + chipSparkWidth <= width ? chipSparkCells(frame.celebrate, palette) ?? [] : [];
+        return fitLine([...body, ...sparks], width, palette);
+    }
+    return fitLine(trackPills(view, frame, palette, true), width, palette);
+}
+function chipSegments(chip, shimmer, palette) {
+    const text = ` ${chip.name} `;
+    if (!chip.current)
+        return [{ text, fg: palette.muted, ...(palette.element === undefined ? {} : { bg: palette.element }) }];
+    const sweep = shimmer?.names.includes(chip.name) === true ? shimmer.sweep : -1;
+    if (sweep < 0)
+        return [{ text, fg: palette.onFill, bg: palette.accent, bold: true }];
+    const chars = [...text];
+    return chars.map((char, index) => ({ text: char, fg: palette.onFill, bg: shine(palette.accent, palette, index / (chars.length - 1), sweep, 0.3), bold: true }));
+}
+/**
+ * The skill chips row, exactly `width` cells: bright accent pills for the current request first, then
+ * dim recent names, and `+N` for the ones that do not fit. The label goes before any chip does.
+ */
+export function skillRow(chips, shimmer, palette, width) {
+    const label = { text: "skills ", fg: palette.muted };
+    if (chips.length === 0)
+        return fitLine([label, { text: " none yet", fg: palette.muted }], width, palette);
+    const pills = chips.map((chip) => chipSegments(chip, shimmer, palette));
+    const space = { text: " ", fg: palette.muted };
+    for (const lead of [[label], []]) {
+        const all = lineWidth(lead) + pills.reduce((total, pill, index) => total + lineWidth(pill) + (index === 0 ? 0 : 1), 0);
+        let shown = pills.length;
+        if (all > width) {
+            let used = lineWidth(lead);
+            shown = 0;
+            for (const pill of pills) {
+                const next = used + (shown === 0 ? 0 : 1) + lineWidth(pill);
+                if (next + cellWidth(` +${pills.length - shown - 1}`) > width)
+                    break;
+                used = next;
+                shown += 1;
+            }
+        }
+        if (shown === 0 && lead.length > 0)
+            continue;
+        const out = [...lead];
+        pills.slice(0, shown).forEach((pill, index) => out.push(...(index === 0 ? [] : [space]), ...pill));
+        if (shown < pills.length)
+            out.push({ text: `${shown === 0 ? "" : " "}+${pills.length - shown}`, fg: palette.muted });
+        return fitLine(out, width, palette);
+    }
+    return fitLine([{ text: `+${pills.length}`, fg: palette.muted }], width, palette);
+}
+/**
+ * The status card: four rows of exactly `width` cells whether the session is idle or working, so
+ * the prompt never moves. Each row sheds its own low-priority parts as the terminal narrows.
+ */
+export function statusCard(input, palette, width) {
+    const { view, frame } = input;
+    const border = borderColor(view, frame, palette);
+    const inner = width - 4;
+    const row = (content) => (inner < 0 ? fitLine([], width, palette) : [{ text: "│ ", fg: border }, ...fitLine(content, inner, palette), { text: " │", fg: border }]);
+    return [
+        topLine(view, frame, palette, width, border),
+        row(trackRow(view, frame, palette, Math.max(0, inner), input.last)),
+        row(skillRow(input.chips, input.shimmer, palette, Math.max(0, inner))),
+        bottomLine(view, input.figures, palette, width, border)
+    ];
+}
+const cardRows = 4;
+/**
+ * The opt-in detail card under the status card. It keeps a fixed four rows whenever a goal exists, warnings
+ * first, so turning a warning on or off never moves the prompt.
+ */
+export function bandCard(view, frame, palette, width) {
+    if (!view.active || (view.goal === undefined && view.warnings.length === 0))
+        return undefined;
+    const panel = missionPanel(view, frame, palette);
+    if (panel === undefined)
+        return undefined;
+    const inner = Math.max(8, width - 4);
+    const rows = [];
+    for (const warning of view.warnings.slice(0, 2)) {
+        rows.push([{ text: "⚑ ", fg: palette.warning, bold: true }, { text: truncateCells(warning.text, inner - 2), fg: palette.warning }]);
+    }
+    if (view.next !== undefined && !view.complete)
+        rows.push([{ text: "next  ", fg: palette.muted }, { text: truncateCells(`▸ ${view.next}`, inner - 6), fg: palette.text }]);
+    if (view.goal !== undefined) {
+        const criteria = view.goal.criteria.map((criterion) => `${criterion.status === "pass" ? "✓" : criterion.status === "fail" ? "✗" : "○"}${criterion.id}`).join(" ");
+        const title = truncateCells(view.goal.title, Math.max(4, inner - 8 - cellWidth(criteria)));
+        rows.push([
+            { text: "goal  ", fg: palette.muted },
+            { text: title, fg: palette.text, bold: true },
+            { text: "  ", fg: palette.muted },
+            { text: truncateCells(criteria, Math.max(0, inner - 8 - cellWidth(title))), fg: palette.muted }
+        ]);
+    }
+    while (rows.length < cardRows)
+        rows.push([]);
+    return { title: panel.title, border: panel.border, rows: rows.slice(0, cardRows) };
+}

package/dist/tui/mission-model.d.ts

@@ -0,0 +1,139 @@
+export type LitMark = {
+    readonly at: number;
+    readonly mode?: string;
+    readonly command?: string;
+    readonly operation?: string;
+    readonly blocked?: boolean;
+};
+export type TodoInput = {
+    readonly content: string;
+    readonly status: string;
+};
+export type MissionInput = {
+    readonly marks: readonly LitMark[];
+    readonly agent?: string;
+    readonly todos: readonly TodoInput[];
+    readonly ledger?: unknown;
+    readonly sessionStatus?: string;
+    readonly retryMessage?: string;
+    readonly pendingPermissions?: number;
+    readonly pendingQuestions?: number;
+    readonly contextPercent?: number | null;
+    readonly now: number;
+};
+export type StepId = "plan" | "work" | "review";
+export type StepState = "done" | "skip" | "now" | "todo" | "warn";
+export type MissionStep = {
+    readonly id: StepId;
+    readonly state: StepState;
+};
+export type MissionWarning = {
+    readonly kind: "blocker" | "decision" | "retry" | "permission" | "question" | "context" | "plan";
+    readonly text: string;
+};
+export type MissionCriterion = {
+    readonly id: string;
+    readonly status: string;
+};
+export type MissionGoal = {
+    readonly title: string;
+    readonly status: string;
+    readonly passed: number;
+    readonly total: number;
+    readonly criteria: readonly MissionCriterion[];
+};
+export type MissionEvent = {
+    readonly ago: string;
+    readonly kind: string;
+    readonly label: string;
+};
+export type MissionView = {
+    readonly active: boolean;
+    readonly discipline: string;
+    readonly phase: StepId | "done";
+    readonly steps: readonly MissionStep[];
+    readonly progress?: {
+        readonly done: number;
+        readonly total: number;
+    };
+    readonly next?: string;
+    readonly goal?: MissionGoal;
+    readonly blockers: readonly {
+        readonly id: string;
+        readonly detail: string;
+        readonly needsUserDecision: boolean;
+    }[];
+    readonly warnings: readonly MissionWarning[];
+    readonly timeline: readonly MissionEvent[];
+    readonly planSaved: boolean;
+    readonly complete: boolean;
+    /** Whole minutes since this session's first lit turn; only an active view carries it. */
+    readonly elapsedMinutes?: number;
+};
+export type MissionNotice = {
+    readonly variant: "info" | "success" | "warning" | "error";
+    readonly title: string;
+    readonly message: string;
+    readonly celebrate?: boolean;
+};
+export declare const contextWarnPercent = 75;
+export declare const idleMission: MissionView;
+/** Reads one part's `metadata.litopencode` mark. Anything without that shape is not a mark. */
+export declare function readLitMark(metadata: unknown, at: number): LitMark | undefined;
+type LedgerCriterion = {
+    readonly id: string;
+    readonly scenario: string;
+    readonly status: string;
+    readonly evidence: readonly {
+        readonly kind: string;
+        readonly ref: string;
+        readonly at: string;
+    }[];
+};
+type LedgerGoal = {
+    readonly title: string;
+    readonly status: string;
+    readonly createdAt: string;
+    readonly updatedAt: string;
+    readonly criteria: readonly LedgerCriterion[];
+    readonly checkpoints: readonly {
+        readonly summary: string;
+        readonly at: string;
+    }[];
+    readonly reviewBlockers: readonly {
+        readonly id: string;
+        readonly detail: string;
+        readonly resolved: boolean;
+        readonly needsUserDecision: boolean;
+    }[];
+};
+/** Lenient read of goals.json: the active goal, or undefined when the file is absent or not the ledger shape. */
+export declare function readActiveGoal(raw: unknown): LedgerGoal | undefined;
+export declare function formatAgo(at: string, now: number): string;
+export declare function buildMissionView(input: MissionInput): MissionView;
+/**
+ * OpenCode shows one toast at a time, so several gate events from one refresh collapse into the most
+ * urgent one (completion first), with the rest counted in its message. The panel still lists them all.
+ */
+export declare function leadingNotice(notices: readonly MissionNotice[]): MissionNotice | undefined;
+/** The gate events between two views. A first view never toasts its whole history. */
+export declare function missionNotices(prev: MissionView | undefined, next: MissionView): readonly MissionNotice[];
+/** The short status beside the header: always a glyph plus words, never colour alone. */
+export declare function missionStatus(view: MissionView): {
+    readonly glyph: string;
+    readonly text: string;
+    readonly tone: "info" | "warning" | "success";
+};
+/**
+ * Stable keys for the panel rows a view shows. Motion compares two views' keys to decide which rows
+ * slide in, so a new goal animates its own rows without replaying the header.
+ */
+export declare function missionRowKeys(view: MissionView): readonly string[];
+/** The project's last goal for the home line, or undefined when the ledger holds none. */
+export declare function lastMission(raw: unknown): {
+    readonly title: string;
+    readonly passed: number;
+    readonly total: number;
+    readonly complete: boolean;
+} | undefined;
+export {};