@litfamily/litopencode 1.0.17 → 1.0.19

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

@@ -0,0 +1,56 @@
+import { type MissionInput, type TodoInput } from "./mission-model.ts";
+type MessageLike = {
+    readonly id: string;
+    readonly role: string;
+    readonly agent?: unknown;
+    readonly time?: {
+        readonly created?: unknown;
+    };
+    readonly providerID?: unknown;
+    readonly modelID?: unknown;
+    readonly tokens?: {
+        readonly input?: unknown;
+        readonly output?: unknown;
+        readonly reasoning?: unknown;
+        readonly cache?: {
+            readonly read?: unknown;
+            readonly write?: unknown;
+        };
+    };
+};
+export type MissionStateSource = {
+    readonly path: {
+        readonly worktree?: string;
+        readonly directory?: string;
+    };
+    readonly provider: ReadonlyArray<{
+        readonly id: string;
+        readonly models: Readonly<Record<string, {
+            readonly limit?: {
+                readonly context?: number;
+            };
+        }>>;
+    }>;
+    readonly session: {
+        messages(sessionID: string): ReadonlyArray<MessageLike>;
+        todo(sessionID: string): ReadonlyArray<TodoInput>;
+        status(sessionID: string): {
+            readonly type: string;
+            readonly message?: string;
+        } | undefined;
+        permission(sessionID: string): ReadonlyArray<unknown>;
+        question(sessionID: string): ReadonlyArray<unknown>;
+    };
+    part(messageID: string): ReadonlyArray<{
+        readonly metadata?: unknown;
+    }>;
+};
+/** The same root the server plugin uses: the worktree unless it is the filesystem root, else the directory. */
+export declare function missionProjectRoot(paths: MissionStateSource["path"]): string | undefined;
+/**
+ * Reads goals.json under `root`, refusing symbolic links and oversized files. The result is cached
+ * on mtime and size, so calling it on every refresh costs one lstat.
+ */
+export declare function createLedgerReader(): (root: string | undefined) => unknown;
+export declare function readMissionInput(state: MissionStateSource, sessionID: string, ledger: unknown, now: number): MissionInput;
+export {};

package/dist/tui/mission-source.js

@@ -0,0 +1,88 @@
+// Gathers the mission input from the OpenCode TUI state and the project's evidence ledger. The state
+// shape is the slice of `api.state` the plugin reads, so tests can pass a plain object.
+import fs from "node:fs";
+import path from "node:path";
+import { readLitMark } from "./mission-model.js";
+const ledgerByteLimit = 1024 * 1024;
+/** The same root the server plugin uses: the worktree unless it is the filesystem root, else the directory. */
+export function missionProjectRoot(paths) {
+    const worktree = paths.worktree?.trim();
+    if (worktree !== undefined && worktree !== "" && worktree !== "/")
+        return worktree;
+    const directory = paths.directory?.trim();
+    return directory === undefined || directory === "" ? undefined : directory;
+}
+/**
+ * Reads goals.json under `root`, refusing symbolic links and oversized files. The result is cached
+ * on mtime and size, so calling it on every refresh costs one lstat.
+ */
+export function createLedgerReader() {
+    let cache;
+    return (root) => {
+        if (root === undefined)
+            return undefined;
+        const file = path.join(root, ".litopencode", "litgoal", "lit-loop", "goals.json");
+        let stat;
+        try {
+            stat = fs.lstatSync(file);
+        }
+        catch {
+            return undefined;
+        }
+        if (!stat.isFile() || stat.size > ledgerByteLimit)
+            return undefined;
+        const stamp = `${stat.mtimeMs}:${stat.size}`;
+        if (cache?.file === file && cache.stamp === stamp)
+            return cache.value;
+        let value;
+        try {
+            value = JSON.parse(fs.readFileSync(file, "utf8"));
+        }
+        catch {
+            value = undefined;
+        }
+        cache = { file, stamp, value };
+        return value;
+    };
+}
+function num(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+function contextPercent(state, messages) {
+    const last = [...messages].reverse().find((message) => message.role === "assistant" && num(message.tokens?.output) > 0);
+    if (last === undefined)
+        return null;
+    const tokens = num(last.tokens?.input) + num(last.tokens?.output) + num(last.tokens?.reasoning) + num(last.tokens?.cache?.read) + num(last.tokens?.cache?.write);
+    const limit = state.provider.find((provider) => provider.id === last.providerID)?.models[String(last.modelID)]?.limit?.context;
+    return typeof limit === "number" && limit > 0 ? (tokens / limit) * 100 : null;
+}
+export function readMissionInput(state, sessionID, ledger, now) {
+    const messages = state.session.messages(sessionID);
+    const marks = [];
+    let agent;
+    for (const message of messages) {
+        if (message.role !== "user")
+            continue;
+        if (typeof message.agent === "string")
+            agent = message.agent;
+        const at = num(message.time?.created);
+        for (const part of state.part(message.id)) {
+            const mark = readLitMark(part.metadata, at);
+            if (mark !== undefined)
+                marks.push(mark);
+        }
+    }
+    const status = state.session.status(sessionID);
+    return {
+        marks,
+        ...(agent === undefined ? {} : { agent }),
+        todos: state.session.todo(sessionID),
+        ledger,
+        ...(status === undefined ? {} : { sessionStatus: status.type }),
+        ...(status?.type === "retry" && typeof status.message === "string" ? { retryMessage: status.message } : {}),
+        pendingPermissions: state.session.permission(sessionID).length,
+        pendingQuestions: state.session.question(sessionID).length,
+        contextPercent: contextPercent(state, messages),
+        now
+    };
+}

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

@@ -0,0 +1,103 @@
+import { type MotionFrame } from "./mission-motion.ts";
+import { type MissionView } from "./mission-model.ts";
+export type Segment = {
+    readonly text: string;
+    readonly fg: string;
+    readonly bg?: string;
+    readonly bold?: boolean;
+};
+export type Line = readonly Segment[];
+export type MissionPalette = {
+    readonly primary: string;
+    readonly accent: string;
+    readonly info: string;
+    readonly warning: string;
+    readonly success: string;
+    readonly error: string;
+    readonly text: string;
+    readonly muted: string;
+    readonly borderActive: string;
+    readonly borderSubtle: string;
+    /** Opaque fills only; undefined when the theme leaves that surface transparent. */
+    readonly background?: string;
+    readonly panel?: string;
+    readonly element?: string;
+    /** What fades and tints mix toward: the panel, else the background, else a neutral for the mode. */
+    readonly mixBase: string;
+    /** Text drawn on a filled pill. */
+    readonly onFill: string;
+};
+/** Panel box width in cells, and the content width inside its border and one cell of padding per side. */
+export declare const panelWidth = 36;
+export declare const panelInnerWidth: number;
+/** Theme tokens arrive as RGBA objects; plain hex strings pass through. Alpha is ignored here. */
+export declare function colorToHex(value: unknown, fallback: string): string;
+/**
+ * Builds the palette from `api.theme.current`. A surface token with alpha 0 (the system and
+ * lucent-orng themes) means "draw no background", never black.
+ */
+export declare function paletteFromTheme(theme: Record<string, unknown> | undefined, mode?: "dark" | "light"): MissionPalette;
+/**
+ * Columns the prompt row leaves for the chip. OpenCode shows the sidebar when the session is not a
+ * child, the stored `sidebar` setting is "auto" and the terminal is wider than 120 columns. An unknown
+ * setting is treated as open, the narrower and safe guess.
+ */
+export declare function chipBudget(input: {
+    readonly width: number;
+    readonly sidebar: string | undefined;
+    readonly child: boolean;
+}): number;
+export declare function cellWidth(value: string): number;
+/** Cuts `value` to at most `max` cells, ending in an ellipsis when anything was dropped. */
+export declare function truncateCells(value: string, max: number): string;
+export declare function padCells(value: string, width: number): string;
+export declare function lineWidth(line: Line): number;
+export declare function gradientAt(stops: readonly string[], position: number): string;
+export declare function shimmerAt(frame: MotionFrame): number;
+/**
+ * A bar of `cells` cells filled to `ratio` with eighth-cell blocks, each cell its own step of the
+ * primary-to-accent gradient. The empty track is a thin muted rule, never a dither.
+ */
+export declare function progressBar(ratio: number, cells: number, palette: MissionPalette, sweep?: number): Segment[];
+export type ChipTier = "full" | "medium" | "tight";
+export type ChipGroup = readonly Segment[];
+/** The chip's pill groups for a tier; the five-segment bar is appended unless `withMicroBar` is false. */
+export declare function chipGroups(view: MissionView, frame: MotionFrame, palette: MissionPalette, tier: ChipTier, withMicroBar?: boolean): ChipGroup[];
+export declare function groupsWidth(groups: readonly ChipGroup[]): number;
+export declare function fade(segment: Segment, alpha: number, palette: MissionPalette): Segment;
+export declare const chipSparkWidth = 7;
+export declare function chipSparkCells(t: number, palette: MissionPalette): Segment[] | undefined;
+export declare function chipTier(view: MissionView, frame: MotionFrame, palette: MissionPalette, budget: number): ChipTier;
+/**
+ * The phase chip on the right of the prompt's agent/model row: `🔥 LIT` `PLAN` › `WORK n/m` › `REVIEW`
+ * and a five-segment bar, shedding labels before values as `budget` shrinks. Idle sessions render nothing.
+ */
+export declare function chipLine(view: MissionView, frame: MotionFrame, palette: MissionPalette, budget: number): Line;
+/** The header status: a glyph and words, or the COMPLETE badge that pops in and settles to green text. */
+export declare function statusSegments(view: MissionView, frame: MotionFrame, palette: MissionPalette): {
+    readonly segments: Segment[];
+    readonly offset: number;
+};
+export type MissionPanel = {
+    readonly border: string;
+    readonly title: string;
+    readonly titleColor: string;
+    readonly bottomTitle?: string;
+    readonly background?: string;
+    readonly rows: readonly Line[];
+};
+/**
+ * The sidebar mission panel: a rounded box whose border carries the state (accent while working,
+ * warning on a warning, success when complete), a tiny LIT header, the goal title, the phase line,
+ * the bar, the next item, criteria, warnings and the evidence timeline. Rows are at most
+ * `panelInnerWidth` cells.
+ */
+export declare function missionPanel(view: MissionView, frame: MotionFrame, palette: MissionPalette): MissionPanel | undefined;
+export type LastMission = {
+    readonly title: string;
+    readonly passed: number;
+    readonly total: number;
+    readonly complete: boolean;
+};
+/** The home-screen line under the prompt: `🔥 lit ready · last: <goal> ✓ n/m`, labels shed first when narrow. */
+export declare function homeLine(last: LastMission | undefined, palette: MissionPalette, budget: number): Line;