@gamflaz/opencode-todolist 1.0.4 → 1.0.5

package/dist/todos/hint.js

@@ -0,0 +1,187 @@
+import { readFileSync, renameSync, writeFileSync } from "node:fs";
+import { getHintMarkerPath, readTodoData, TodoStore } from "../storage/todo-store";
+import { TodoTree } from "./todo-tree";
+export const DEFAULT_STALE_MS = 30 * 60 * 1000; // 30 minutes (prompt fallback)
+export const CONTEXT_STALE_MS = 6 * 60 * 60 * 1000; // 6 hours
+const UPCOMING_LIMIT = 3;
+export const TODO_HINT = "<todo_hint>Active todos exist. If continuing previous work, call " +
+    "manage_todo_list [read] first. Ignore if the user is discussing something else.</todo_hint>";
+function isOpen(status) {
+    return TodoTree.isOpenStatus(status);
+}
+function isTaskActive(task) {
+    if (isOpen(task.status))
+        return true;
+    return !!task.children && task.children.some((c) => isOpen(c.status));
+}
+export function isAnyTodoActive(todos) {
+    return todos.some(isTaskActive);
+}
+function atomicWrite(file, data) {
+    const tmp = `${file}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
+    writeFileSync(tmp, data, "utf8");
+    renameSync(tmp, file);
+}
+export function consumeTodoHint(sessionID, options) {
+    try {
+        if (!sessionID)
+            return undefined;
+        const safeSessionID = TodoStore.normalizeSessionID(sessionID);
+        const state = readTodoData(safeSessionID);
+        if (!state)
+            return undefined;
+        const todos = state.todos;
+        if (todos.length === 0 || !isAnyTodoActive(todos))
+            return undefined;
+        const staleMs = options?.staleMs ?? DEFAULT_STALE_MS;
+        const now = options?.now ?? Date.now();
+        const updatedAt = Date.parse(state.updated_at);
+        if (Number.isFinite(updatedAt) && now - updatedAt > staleMs) {
+            return undefined;
+        }
+        const markerFile = getHintMarkerPath(safeSessionID);
+        let hintedVersion = -1;
+        try {
+            const marker = JSON.parse(readFileSync(markerFile, "utf8"));
+            if (typeof marker?.version === "number")
+                hintedVersion = marker.version;
+        }
+        catch {
+            // Marker missing or corrupt
+        }
+        if (hintedVersion === state.version)
+            return undefined;
+        atomicWrite(markerFile, JSON.stringify({ version: state.version }));
+        return TODO_HINT;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function flattenLeaves(todos) {
+    return todos.flatMap((t) => (t.children?.length ? t.children : [t]));
+}
+export function findNextTodo(todos) {
+    // Strict order: only the first open root is relevant; later roots wait.
+    for (const root of todos) {
+        if (root.status === "completed" || root.status === "cancelled")
+            continue;
+        const children = root.children ?? [];
+        const errorChild = children.find((c) => c.status === "error");
+        if (root.status === "error")
+            return root;
+        if (errorChild)
+            return errorChild;
+        const activeChild = children.find((c) => c.status === "in_progress");
+        if (activeChild)
+            return activeChild;
+        if (root.status === "in_progress") {
+            return children.find((c) => c.status === "pending") ?? root;
+        }
+        return children.find((c) => c.status === "pending") ?? root;
+    }
+    return undefined;
+}
+export function findStuckParent(todos) {
+    return todos.find((t) => !!t.children?.length &&
+        isOpen(t.status) &&
+        !t.children.some((c) => isOpen(c.status)));
+}
+function renderCompactHint(todos) {
+    const leaves = flattenLeaves(todos);
+    const done = leaves.filter((t) => t.status === "completed").length;
+    const lines = [`Progress ${done}/${leaves.length} completed.`];
+    const openRoot = todos.find((root) => root.status !== "completed" && root.status !== "cancelled");
+    if (!openRoot) {
+        lines.push("Now: nothing is open.");
+        return lines.join("\n");
+    }
+    const children = openRoot.children ?? [];
+    const activeChild = children.find((c) => c.status === "in_progress");
+    const errorChild = children.find((c) => c.status === "error");
+    const nextPendingChild = children.find((c) => c.status === "pending");
+    let nowId;
+    if (openRoot.status === "error" || errorChild) {
+        const bad = openRoot.status === "error" ? openRoot : errorChild;
+        nowId = bad.id;
+        lines.push(`Now: ${bad.id} ${bad.content} is 'error'. Fix it or mark it cancelled via manage_todo_list [update], then continue.`);
+    }
+    else if (activeChild) {
+        nowId = activeChild.id;
+        lines.push(`Now: ${activeChild.id} ${activeChild.content}`);
+    }
+    else if (openRoot.status === "in_progress" && nextPendingChild) {
+        nowId = nextPendingChild.id;
+        lines.push(`Now: root ${openRoot.id} is in_progress. Start subtask ${nextPendingChild.id} "${nextPendingChild.content}" via manage_todo_list [update] and continue.`);
+    }
+    else if (openRoot.status === "in_progress" && children.length > 0) {
+        nowId = openRoot.id;
+        lines.push(`Now: all children of ${openRoot.id} are done. Set ${openRoot.id} to completed via manage_todo_list [update].`);
+    }
+    else if (openRoot.status === "pending" && nextPendingChild) {
+        nowId = nextPendingChild.id;
+        lines.push(`Now: start root ${openRoot.id} "${openRoot.content}" (or subtask ${nextPendingChild.id}) via manage_todo_list [update] and continue.`);
+    }
+    else if (openRoot.status === "pending") {
+        nowId = openRoot.id;
+        lines.push(`Now: start root ${openRoot.id} "${openRoot.content}" via manage_todo_list [update] and continue.`);
+    }
+    else {
+        nowId = openRoot.id;
+        lines.push(`Now: resolve ${openRoot.id} ${openRoot.content} via manage_todo_list [update].`);
+    }
+    // Next: pending items in root order, root by root, skipping the item named above.
+    const next = [];
+    for (const root of todos) {
+        if (root.status === "completed" || root.status === "cancelled")
+            continue;
+        const candidates = root.children?.length
+            ? (root.children ?? []).filter((c) => c.status === "pending")
+            : root.status === "pending"
+                ? [root]
+                : [];
+        for (const item of candidates) {
+            if (item.id === nowId)
+                continue;
+            next.push(`${item.id} ${item.content}`);
+            if (next.length === UPCOMING_LIMIT)
+                break;
+        }
+        if (next.length === UPCOMING_LIMIT)
+            break;
+    }
+    if (next.length > 0)
+        lines.push(`Next: ${next.join("; ")}`);
+    return lines.join("\n");
+}
+export function buildTodoHint(sessionID, options) {
+    try {
+        if (!sessionID)
+            return undefined;
+        const safeSessionID = TodoStore.normalizeSessionID(sessionID);
+        const state = readTodoData(safeSessionID);
+        if (!state)
+            return undefined;
+        const todos = state.todos;
+        if (todos.length === 0 || !isAnyTodoActive(todos))
+            return undefined;
+        const staleMs = options?.staleMs ?? CONTEXT_STALE_MS;
+        const now = options?.now ?? Date.now();
+        const updatedAt = Date.parse(state.updated_at);
+        if (Number.isFinite(updatedAt) && now - updatedAt > staleMs) {
+            return undefined;
+        }
+        return (`<todo_state>\n${renderCompactHint(todos)}\n</todo_state>\n` +
+            "<todo_rules>Open todos remain. Continue the in_progress item now. " +
+            "Progress moves forward only and roots run in order: never reopen a finished item, " +
+            "never start a later root while the current one is open. " +
+            "Do not end your turn or write a final summary while items are open, " +
+            "unless you are blocked or need user input. " +
+            "Call manage_todo_list [read] for the full list. " +
+            "Change items with manage_todo_list [update]; use [write] only to initialize an empty list or to clear it with []. " +
+            "Ignore only if the user clearly changed topic or asked to stop or pause.</todo_rules>");
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/todos/todo-tree.d.ts

@@ -0,0 +1,63 @@
+import { type TodoStatus } from "../schemas/status.js";
+import type { TodoChildern, TodoRootItem } from "../schemas/todo";
+export interface TodoProgress {
+    completed: number;
+    total: number;
+    label: string;
+}
+export interface TodoStats {
+    totalSteps: number;
+    completedSteps: number;
+    totalSubTasks: number;
+    completedSubTasks: number;
+    percent: number;
+}
+export type TodoValidationResult = {
+    valid: true;
+    data: TodoRootItem[];
+} | {
+    valid: false;
+    error: string;
+};
+/**
+ * A todo list (roots + children) with validation, statistics and rendering.
+ *
+ * Instance methods operate on the list passed to the constructor; helpers that
+ * do not depend on a list (status checks, progress bar, id formatting) are
+ * `static`.
+ */
+export declare class TodoTree {
+    readonly todos: readonly TodoRootItem[];
+    private static readonly STATUS_ICONS;
+    private static readonly DEFAULT_ICON;
+    private static readonly BAR_FILLED;
+    private static readonly BAR_UNFILLED;
+    constructor(todos: readonly TodoRootItem[]);
+    static isOpenStatus(status: TodoStatus): boolean;
+    static calculateProgress(children?: readonly TodoChildern[]): TodoProgress | null;
+    static renderProgressBar(percent: number, width?: number): {
+        filled: string;
+        unfilled: string;
+    };
+    /**
+     * Display prefix for an id. Roots render as "1. ", children as "1.1 ".
+     * (All ids are numeric now, so every id is a "point id".)
+     */
+    static formatIdPrefix(id: number, depth: number): string;
+    private static nonCancelled;
+    private static contentIncludesId;
+    private static duplicateIdError;
+    calculateStats(): TodoStats;
+    validateAndNormalize(): TodoValidationResult;
+    /** Returns an error message, or null when the structure is valid. */
+    private validateStructure;
+    /**
+     * Rejects completed parents with unfinished children, and auto-completes a
+     * parent whose children are all completed.
+     */
+    private normalize;
+    render(): string;
+    private static icon;
+    /** Content with strike-through when completed, prefixed with its id unless it already starts with it. */
+    private static renderLabel;
+}

package/dist/todos/todo-tree.js

@@ -0,0 +1,188 @@
+import { OPEN_STATUSES } from "../schemas/status.js";
+/**
+ * A todo list (roots + children) with validation, statistics and rendering.
+ *
+ * Instance methods operate on the list passed to the constructor; helpers that
+ * do not depend on a list (status checks, progress bar, id formatting) are
+ * `static`.
+ */
+export class TodoTree {
+    todos;
+    static STATUS_ICONS = {
+        pending: "[ ]",
+        in_progress: "[~]",
+        completed: "[x]",
+        cancelled: "[-]",
+        error: "[!]",
+    };
+    static DEFAULT_ICON = "[ ]";
+    static BAR_FILLED = "█";
+    static BAR_UNFILLED = "░";
+    constructor(todos) {
+        this.todos = todos;
+    }
+    // Static helpers
+    static isOpenStatus(status) {
+        return OPEN_STATUSES.includes(status);
+    }
+    static calculateProgress(children) {
+        if (!children || children.length === 0)
+            return null;
+        const nonCancelled = TodoTree.nonCancelled(children);
+        const completed = nonCancelled.filter((c) => c.status === "completed").length;
+        const total = nonCancelled.length;
+        return { completed, total, label: `${completed}/${total}` };
+    }
+    static renderProgressBar(percent, width = 10) {
+        const clamped = Math.max(0, Math.min(100, percent));
+        const filledCount = Math.round((clamped / 100) * width);
+        const unfilledCount = width - filledCount;
+        return {
+            filled: TodoTree.BAR_FILLED.repeat(filledCount),
+            unfilled: TodoTree.BAR_UNFILLED.repeat(unfilledCount),
+        };
+    }
+    /**
+     * Display prefix for an id. Roots render as "1. ", children as "1.1 ".
+     * (All ids are numeric now, so every id is a "point id".)
+     */
+    static formatIdPrefix(id, depth) {
+        return depth > 0 ? `${id} ` : `${id}. `;
+    }
+    static nonCancelled(items) {
+        return items.filter((item) => item.status !== "cancelled");
+    }
+    static contentIncludesId(content, id) {
+        const key = String(id);
+        return (content === key ||
+            content.startsWith(`${key}. `) ||
+            content.startsWith(`${key}: `) ||
+            content.startsWith(`${key} `));
+    }
+    static duplicateIdError(id) {
+        return `Duplicate ID found: '${id}'. Every ID must be unique across the tree.`;
+    }
+    // Statistics
+    calculateStats() {
+        const totalSteps = this.todos.length;
+        const completedSteps = this.todos.filter((t) => t.status === "completed").length;
+        let totalSubTasks = 0;
+        let completedSubTasks = 0;
+        for (const item of this.todos) {
+            if (item.children && item.children.length > 0) {
+                const nonCancelled = TodoTree.nonCancelled(item.children);
+                totalSubTasks += nonCancelled.length;
+                completedSubTasks += nonCancelled.filter((c) => c.status === "completed").length;
+            }
+            else if (item.status !== "cancelled") {
+                // A root without children counts as a single unit of work.
+                totalSubTasks += 1;
+                if (item.status === "completed")
+                    completedSubTasks += 1;
+            }
+        }
+        const percent = totalSubTasks > 0
+            ? Math.round((completedSubTasks / totalSubTasks) * 100)
+            : 0;
+        return {
+            totalSteps,
+            completedSteps,
+            totalSubTasks,
+            completedSubTasks,
+            percent,
+        };
+    }
+    // Validation
+    validateAndNormalize() {
+        const error = this.validateStructure();
+        if (error)
+            return { valid: false, error };
+        return this.normalize();
+    }
+    /** Returns an error message, or null when the structure is valid. */
+    validateStructure() {
+        const seenIds = new Set();
+        const activeParents = [];
+        for (const parent of this.todos) {
+            if (seenIds.has(parent.id))
+                return TodoTree.duplicateIdError(parent.id);
+            seenIds.add(parent.id);
+            if (parent.status === "in_progress")
+                activeParents.push(parent.id);
+            const activeChildren = [];
+            for (const child of parent.children ?? []) {
+                if (seenIds.has(child.id))
+                    return TodoTree.duplicateIdError(child.id);
+                seenIds.add(child.id);
+                if (child.status === "in_progress")
+                    activeChildren.push(child.id);
+            }
+            if (activeChildren.length > 1) {
+                return `Task '${parent.id}' has ${activeChildren.length} subtasks 'in_progress'. At most 1 is allowed.`;
+            }
+            if (activeChildren.length === 1 && parent.status !== "in_progress") {
+                return `Subtask '${activeChildren[0]}' is 'in_progress' but parent '${parent.id}' is '${parent.status}'. Set parent to 'in_progress' first.`;
+            }
+        }
+        if (activeParents.length > 1) {
+            return `Only 1 top-level task can be 'in_progress'. Found: ${activeParents.join(", ")}.`;
+        }
+        return null;
+    }
+    /**
+     * Rejects completed parents with unfinished children, and auto-completes a
+     * parent whose children are all completed.
+     */
+    normalize() {
+        const normalized = [];
+        for (const item of this.todos) {
+            const children = item.children;
+            if (!children || children.length === 0) {
+                normalized.push(item);
+                continue;
+            }
+            const hasUnfinishedChildren = children.some((c) => c.status === "pending" ||
+                c.status === "in_progress" ||
+                c.status === "error");
+            if (item.status === "completed" && hasUnfinishedChildren) {
+                return {
+                    valid: false,
+                    error: `Task '${item.id}' cannot be marked 'completed' while it still has pending, in-progress or errored subtasks.`,
+                };
+            }
+            const allChildrenCompleted = children.every((c) => c.status === "completed");
+            normalized.push({
+                ...item,
+                status: allChildrenCompleted ? "completed" : item.status,
+            });
+        }
+        return { valid: true, data: normalized };
+    }
+    // Rendering
+    render() {
+        const lines = [];
+        for (const parent of this.todos) {
+            const progress = TodoTree.calculateProgress(parent.children);
+            const progressText = progress ? ` (${progress.label})` : "";
+            lines.push(`${TodoTree.icon(parent.status)} ${TodoTree.renderLabel(parent, 0)}${progressText}`);
+            if (parent.note)
+                lines.push(`    ↳ note: ${parent.note}`);
+            for (const child of parent.children ?? []) {
+                lines.push(`    ${TodoTree.icon(child.status)} ${TodoTree.renderLabel(child, 1)}`);
+                if (child.note)
+                    lines.push(`        ↳ note: ${child.note}`);
+            }
+        }
+        return lines.join("\n");
+    }
+    static icon(status) {
+        return TodoTree.STATUS_ICONS[status] ?? TodoTree.DEFAULT_ICON;
+    }
+    /** Content with strike-through when completed, prefixed with its id unless it already starts with it. */
+    static renderLabel(item, depth) {
+        const content = item.status === "completed" ? `~~${item.content}~~` : item.content;
+        return TodoTree.contentIncludesId(item.content, item.id)
+            ? content
+            : `${TodoTree.formatIdPrefix(item.id, depth)}${content}`;
+    }
+}

package/dist/todos/update.d.ts

@@ -0,0 +1,35 @@
+import type { Priority, TodoStatus } from "../schemas/status";
+import type { TodoRootItem, TodoUpdateInput } from "../schemas/todo";
+type UpdatableTodo = {
+    content: string;
+    status: TodoStatus;
+    priority?: Priority;
+    note?: string;
+};
+export interface UpdatedTodo {
+    id: number;
+    scope: "root" | "child";
+    content: string;
+    status: TodoStatus;
+}
+/**
+ * Order rules for one update:
+ *
+ * 1. Forward-only. A status never moves backward, and finished items are locked.
+ * 2. Strict order. Only the first unfinished root — and the children inside it —
+ *    may change. Every later root waits until the previous ones are completed
+ *    or cancelled.
+ * 3. Error exception. A root that holds `error` may be fixed early, but only
+ *    that root and its own children; nothing else may be touched.
+ * 4. Single active root. Starting `in_progress` work is refused while another
+ *    root is still `in_progress`, so a started root is finished before the next.
+ */
+export declare function assertSequentialScope(todos: TodoRootItem[], input: TodoUpdateInput): {
+    targetRoot: TodoRootItem;
+    target: UpdatableTodo;
+};
+export declare function updateTodoById(todos: TodoRootItem[], input: TodoUpdateInput): {
+    todos: TodoRootItem[];
+    updated: UpdatedTodo;
+};
+export {};

package/dist/todos/update.js

@@ -0,0 +1,140 @@
+const FINAL_STATUSES = ["completed", "cancelled"];
+/**
+ * Forward-only progress: a status may advance or stay the same, never move
+ * backward. `error` is reportable from any open status and fixable back to
+ * `in_progress`/`completed`/`cancelled`.
+ */
+const FORWARD_TRANSITIONS = {
+    pending: ["in_progress", "completed", "cancelled", "error"],
+    in_progress: ["completed", "cancelled", "error"],
+    error: ["in_progress", "completed", "cancelled"],
+    completed: [],
+    cancelled: [],
+};
+function isFinal(status) {
+    return FINAL_STATUSES.includes(status);
+}
+function applyUpdate(item, changes) {
+    const next = { ...item };
+    if (changes.content !== undefined)
+        next.content = changes.content;
+    if (changes.status !== undefined)
+        next.status = changes.status;
+    if (changes.priority !== undefined) {
+        if (changes.priority === null)
+            delete next.priority;
+        else
+            next.priority = changes.priority;
+    }
+    if (changes.note !== undefined) {
+        if (changes.note === null)
+            delete next.note;
+        else
+            next.note = changes.note;
+    }
+    return next;
+}
+function assertForwardTransition(from, to, id) {
+    if (from === to)
+        return;
+    if (!(FORWARD_TRANSITIONS[from] ?? []).includes(to)) {
+        throw new Error(`[manage_todo_list] todo ${id} cannot move from '${from}' to '${to}'. Progress only moves forward; use 'error' to report a failure and fix it from there.`);
+    }
+}
+/** Any root still open, an `error` root included. */
+function activeRoot(todos) {
+    return todos.find((root) => root.status === "in_progress");
+}
+function hasError(root) {
+    return (root.status === "error" ||
+        root.children?.some((child) => child.status === "error") === true);
+}
+/**
+ * Order rules for one update:
+ *
+ * 1. Forward-only. A status never moves backward, and finished items are locked.
+ * 2. Strict order. Only the first unfinished root — and the children inside it —
+ *    may change. Every later root waits until the previous ones are completed
+ *    or cancelled.
+ * 3. Error exception. A root that holds `error` may be fixed early, but only
+ *    that root and its own children; nothing else may be touched.
+ * 4. Single active root. Starting `in_progress` work is refused while another
+ *    root is still `in_progress`, so a started root is finished before the next.
+ */
+export function assertSequentialScope(todos, input) {
+    const targetRoot = todos.find((root) => root.id === input.id ||
+        root.children?.some((child) => child.id === input.id));
+    if (!targetRoot) {
+        throw new Error(`[manage_todo_list] todo id ${input.id} was not found`);
+    }
+    const firstOpen = todos.findIndex((root) => !isFinal(root.status));
+    if (firstOpen === -1) {
+        throw new Error("[manage_todo_list] every todo is already finished; nothing can be updated.");
+    }
+    const targetRootIndex = todos.indexOf(targetRoot);
+    if (targetRootIndex !== firstOpen && !hasError(targetRoot)) {
+        const blocking = todos[firstOpen];
+        throw new Error(`[manage_todo_list] root ${targetRoot.id} is out of order: finish root ${blocking.id} "${blocking.content}" first (or cancel it). Only a root in 'error' may be fixed early.`);
+    }
+    const target = targetRoot.id === input.id
+        ? targetRoot
+        : targetRoot.children?.find((child) => child.id === input.id);
+    if (!target) {
+        throw new Error(`[manage_todo_list] todo id ${input.id} was not found`);
+    }
+    if (isFinal(target.status)) {
+        throw new Error(`[manage_todo_list] todo ${input.id} is '${target.status}' and final; it cannot be changed.`);
+    }
+    assertForwardTransition(target.status, input.status, input.id);
+    if (input.status === "in_progress") {
+        const running = activeRoot(todos);
+        if (running && running.id !== targetRoot.id) {
+            throw new Error(`[manage_todo_list] root ${running.id} is still in_progress. Finish it (or cancel it) before starting ${targetRoot.id}; an error root may be fixed early only when nothing else is running.`);
+        }
+        const busyChild = targetRoot.children?.find((child) => child.status === "in_progress" && child.id !== input.id);
+        if (busyChild) {
+            throw new Error(`[manage_todo_list] subtask ${busyChild.id} is still in_progress. Finish it (or cancel it) before starting ${input.id}.`);
+        }
+    }
+    return { targetRoot, target };
+}
+export function updateTodoById(todos, input) {
+    const { targetRoot } = assertSequentialScope(todos, input);
+    let updated;
+    const nextTodos = todos.map((root) => {
+        if (root.id === input.id) {
+            const item = applyUpdate(root, input);
+            updated = {
+                id: item.id,
+                scope: "root",
+                content: item.content,
+                status: item.status,
+            };
+            return item;
+        }
+        if (root.id !== targetRoot.id)
+            return root;
+        const children = (root.children ?? []).map((child) => {
+            if (child.id !== input.id)
+                return child;
+            const item = applyUpdate(child, input);
+            updated = {
+                id: item.id,
+                scope: "child",
+                content: item.content,
+                status: item.status,
+            };
+            return item;
+        });
+        // A running child implies a running parent. Finished or errored parents
+        // keep their status so the order rules stay visible.
+        const status = input.status === "in_progress" && root.status === "pending"
+            ? "in_progress"
+            : root.status;
+        return { ...root, status, children };
+    });
+    if (!updated) {
+        throw new Error(`[manage_todo_list] todo id ${input.id} was not found`);
+    }
+    return { todos: nextTodos, updated };
+}

package/dist/tui/layout.d.ts

@@ -0,0 +1,18 @@
+/** Rendered prefix of an error detail row. */
+export declare const ERROR_PREFIX = "\u21B3 error: ";
+/**
+ * Rendered width of a row: the indentation, the icon cell and the title.
+ *
+ * Rows must be sized explicitly, otherwise the scroll content never grows
+ * wider than the viewport and horizontal scrolling has nothing to move.
+ */
+export declare function RowWidth(row: {
+    id?: number;
+    content: string;
+    depth: number;
+}): number;
+/** Rendered width of an expanded error line under its row. */
+export declare function ErrorRowWidth(row: {
+    error: string;
+    depth: number;
+}): number;

package/dist/tui/layout.js

@@ -0,0 +1,22 @@
+import { TodoTree } from "../todos/todo-tree";
+/** Rendered prefix of an error detail row. */
+export const ERROR_PREFIX = "↳ error: ";
+/**
+ * Rendered width of a row: the indentation, the icon cell and the title.
+ *
+ * Rows must be sized explicitly, otherwise the scroll content never grows
+ * wider than the viewport and horizontal scrolling has nothing to move.
+ */
+export function RowWidth(row) {
+    const indent = row.depth > 0 ? 2 : 0;
+    const label = row.id !== undefined
+        ? `${TodoTree.formatIdPrefix(row.id, row.depth)}${row.content}`
+        : row.content;
+    // icon glyph + 1 space, then the title.
+    return indent + 1 + 1 + [...label].length;
+}
+/** Rendered width of an expanded error line under its row. */
+export function ErrorRowWidth(row) {
+    const indent = row.depth > 0 ? 4 : 2;
+    return indent + [...(ERROR_PREFIX + row.error)].length;
+}

package/dist/tui/text.d.ts

@@ -0,0 +1,2 @@
+/** Shorten prompt text without cutting the trailing ellipsis. */
+export declare function shorten(text: string, max: number): string;

package/dist/tui/text.js

@@ -0,0 +1,4 @@
+/** Shorten prompt text without cutting the trailing ellipsis. */
+export function shorten(text, max) {
+    return text.length <= max ? text : `${text.slice(0, max - 3).trimEnd()}...`;
+}