pi-ui-extend 0.1.1

package/dist/app/todo-model.js

@@ -0,0 +1,179 @@
+import { TODO_ACTIONS, TODO_PRIORITIES, TODO_STATUSES } from "./constants.js";
+import { isNumberArray, isRecord, isStringArray } from "./guards.js";
+import { APP_ICONS } from "./icons.js";
+export function isTodoAction(value) {
+    return typeof value === "string" && TODO_ACTIONS.includes(value);
+}
+export function isTodoStatus(value) {
+    return typeof value === "string" && TODO_STATUSES.includes(value);
+}
+export function isTodoPriority(value) {
+    return typeof value === "string" && TODO_PRIORITIES.includes(value);
+}
+export function isTodoTask(value) {
+    if (!isRecord(value))
+        return false;
+    if (typeof value.id !== "number")
+        return false;
+    if (typeof value.subject !== "string")
+        return false;
+    if (!isTodoStatus(value.status))
+        return false;
+    if (value.description !== undefined && typeof value.description !== "string")
+        return false;
+    if (value.activeForm !== undefined && typeof value.activeForm !== "string")
+        return false;
+    if (value.priority !== undefined && !isTodoPriority(value.priority))
+        return false;
+    if (value.parentId !== undefined && typeof value.parentId !== "number")
+        return false;
+    if (value.blockedBy !== undefined && !isNumberArray(value.blockedBy))
+        return false;
+    if (value.tags !== undefined && !isStringArray(value.tags))
+        return false;
+    if (value.owner !== undefined && typeof value.owner !== "string")
+        return false;
+    if (value.metadata !== undefined && !isRecord(value.metadata))
+        return false;
+    return true;
+}
+export function isTodoDetails(value) {
+    if (!isRecord(value))
+        return false;
+    if (!isTodoAction(value.action))
+        return false;
+    if (!isRecord(value.params))
+        return false;
+    if (!Array.isArray(value.tasks))
+        return false;
+    if (typeof value.nextId !== "number")
+        return false;
+    if (value.error !== undefined && typeof value.error !== "string")
+        return false;
+    return value.tasks.every(isTodoTask);
+}
+export function isTodoLiveStateEvent(value) {
+    if (!isRecord(value))
+        return false;
+    if (value.version !== 1)
+        return false;
+    if (!isTodoDetails(value.details))
+        return false;
+    if (value.sessionFile !== undefined && typeof value.sessionFile !== "string")
+        return false;
+    return typeof value.checkedAt === "number" && Number.isFinite(value.checkedAt);
+}
+export function todoStatusIcon(status) {
+    switch (status) {
+        case "pending":
+            return APP_ICONS.circleOutline;
+        case "in_progress":
+            return APP_ICONS.timerSand;
+        case "deferred":
+            return APP_ICONS.deferred;
+        case "completed":
+            return APP_ICONS.checkCircle;
+        case "deleted":
+            return APP_ICONS.deleted;
+    }
+}
+export function visibleTodoTasks(details, showDeleted = false) {
+    return showDeleted ? details.tasks : details.tasks.filter((task) => task.status !== "deleted");
+}
+export function hasOpenTodoTasks(details) {
+    return visibleTodoTasks(details).some((task) => task.status !== "completed");
+}
+export function visibleTodoTaskRows(details, showDeleted = false) {
+    const tasks = visibleTodoTasks(details, showDeleted);
+    const tasksById = new Map(tasks.map((task) => [task.id, task]));
+    const childrenByParentId = new Map();
+    const roots = [];
+    for (const task of tasks) {
+        if (task.parentId !== undefined && task.parentId !== task.id && tasksById.has(task.parentId)) {
+            const children = childrenByParentId.get(task.parentId) ?? [];
+            children.push(task);
+            childrenByParentId.set(task.parentId, children);
+        }
+        else {
+            roots.push(task);
+        }
+    }
+    const rows = [];
+    const emitted = new Set();
+    const emitTask = (task, depth) => {
+        if (emitted.has(task.id))
+            return;
+        emitted.add(task.id);
+        rows.push({ task, depth });
+        for (const child of childrenByParentId.get(task.id) ?? [])
+            emitTask(child, depth + 1);
+    };
+    for (const task of roots)
+        emitTask(task, 0);
+    for (const task of tasks)
+        emitTask(task, 0);
+    return rows;
+}
+export function todoTaskLineParts(task, options = {}) {
+    const treePrefix = todoTaskTreePrefix(options.depth ?? 0);
+    const parts = [{ text: `${treePrefix}${todoStatusIcon(task.status)}` }, { text: `#${task.id}`, muted: true }, { text: task.subject }];
+    if (task.status === "in_progress" && task.activeForm)
+        parts.push({ text: `— ${task.activeForm}` });
+    if (task.priority)
+        parts.push({ text: `(${task.priority})`, muted: true });
+    if (task.parentId !== undefined)
+        parts.push({ text: `parent:#${task.parentId}` });
+    if (task.blockedBy && task.blockedBy.length > 0)
+        parts.push({ text: `blocked:${task.blockedBy.map((id) => `#${id}`).join(",")}` });
+    if (task.tags && task.tags.length > 0)
+        parts.push({ text: task.tags.map((tag) => `#${tag}`).join(" "), muted: true });
+    return parts;
+}
+export function formatTodoTaskLine(task, options = {}) {
+    return todoTaskLineParts(task, options).map((part) => part.text).join(" ");
+}
+export function todoTaskLineSegments(task, mutedColor, options = {}) {
+    const segments = [];
+    let offset = 0;
+    for (const [index, part] of todoTaskLineParts(task, options).entries()) {
+        if (index > 0)
+            offset += 1;
+        const start = offset;
+        const end = start + part.text.length;
+        const segment = { start, end };
+        if (part.muted)
+            segment.foreground = mutedColor;
+        if (task.status === "completed" && index > 0)
+            segment.strikethrough = true;
+        if ((segment.foreground || segment.strikethrough) && end > start)
+            segments.push(segment);
+        offset = end;
+    }
+    return segments;
+}
+function todoTaskTreePrefix(depth) {
+    if (depth <= 0)
+        return "";
+    return `${"  ".repeat(depth)}↳ `;
+}
+export function shiftSegmentsToSlice(segments, start, length) {
+    const end = start + length;
+    return segments
+        .map((segment) => ({
+        ...segment,
+        start: Math.max(segment.start, start) - start,
+        end: Math.min(segment.end, end) - start,
+    }))
+        .filter((segment) => segment.end > segment.start);
+}
+export function formatTodoPanelStats(tasks) {
+    const stats = [
+        { count: tasks.filter((task) => task.status === "in_progress").length, label: "active" },
+        { count: tasks.filter((task) => task.status === "pending").length, label: "pending" },
+        { count: tasks.filter((task) => task.status === "completed").length, label: "done" },
+        { count: tasks.filter((task) => task.status === "deferred").length, label: "deferred" },
+    ]
+        .filter(({ count }) => count > 0)
+        .map(({ count, label }) => `${count} ${label}`);
+    return stats.join(", ");
+}

package/dist/app/todo-widget-controller.d.ts

@@ -0,0 +1,21 @@
+import type { TodoDetails } from "./types.js";
+export type TodoWidgetControllerHost = {
+    sessionFile?(): string | undefined;
+    isRunning(): boolean;
+    render(): void;
+};
+export declare class AppTodoWidgetController {
+    private readonly host;
+    private unscopedDetails;
+    private readonly detailsBySessionFile;
+    constructor(host: TodoWidgetControllerHost);
+    get widgetDetails(): TodoDetails | undefined;
+    reset(): void;
+    observeToolResult(toolName: string, details: unknown, isError?: boolean): void;
+    observeLiveState(data: unknown): void;
+    private visibleDetails;
+    private updateDetailsForCurrentSession;
+    private updateDetailsForSession;
+    private currentSessionDetails;
+    private sessionKey;
+}

package/dist/app/todo-widget-controller.js

@@ -0,0 +1,59 @@
+import { resolve } from "node:path";
+import { TODO_TOOL_NAME } from "./constants.js";
+import { stringifyUnknown } from "./message-content.js";
+import { hasOpenTodoTasks, isTodoDetails, isTodoLiveStateEvent } from "./todo-model.js";
+export class AppTodoWidgetController {
+    host;
+    unscopedDetails;
+    detailsBySessionFile = new Map();
+    constructor(host) {
+        this.host = host;
+    }
+    get widgetDetails() {
+        return this.currentSessionDetails();
+    }
+    reset() {
+        this.updateDetailsForCurrentSession(undefined, { preserveScoped: true });
+    }
+    observeToolResult(toolName, details, isError = false) {
+        if (toolName !== TODO_TOOL_NAME)
+            return;
+        if (isError || !isTodoDetails(details) || details.error)
+            return;
+        this.updateDetailsForCurrentSession(this.visibleDetails(details));
+    }
+    observeLiveState(data) {
+        if (!isTodoLiveStateEvent(data))
+            return;
+        this.updateDetailsForSession(data.sessionFile ?? this.host.sessionFile?.(), this.visibleDetails(data.details));
+    }
+    visibleDetails(details) {
+        return hasOpenTodoTasks(details) ? details : undefined;
+    }
+    updateDetailsForCurrentSession(next, options = {}) {
+        this.updateDetailsForSession(this.host.sessionFile?.(), next, options);
+    }
+    updateDetailsForSession(sessionFile, next, options = {}) {
+        const previous = stringifyUnknown(this.currentSessionDetails());
+        const key = this.sessionKey(sessionFile);
+        if (key) {
+            if (next)
+                this.detailsBySessionFile.set(key, next);
+            else if (options.preserveScoped !== true)
+                this.detailsBySessionFile.delete(key);
+        }
+        else {
+            this.unscopedDetails = next;
+        }
+        const visibleNext = stringifyUnknown(this.currentSessionDetails());
+        if (previous !== visibleNext && this.host.isRunning())
+            this.host.render();
+    }
+    currentSessionDetails() {
+        const key = this.sessionKey(this.host.sessionFile?.());
+        return key ? this.detailsBySessionFile.get(key) : this.unscopedDetails;
+    }
+    sessionKey(sessionFile) {
+        return sessionFile ? resolve(sessionFile) : undefined;
+    }
+}

package/dist/app/tool-block-renderer.d.ts

@@ -0,0 +1,26 @@
+import { type ResolvedToolRule } from "../config.js";
+import type { ToolBodySyntaxHighlights } from "../syntax-highlight.js";
+import type { Theme } from "../theme.js";
+import type { RenderedLine } from "./types.js";
+import type { ToolBodyLineStyle, ToolHeaderSegment } from "../tool-renderers/types.js";
+export type ToolBlockEntry = {
+    id: string;
+    toolName: string;
+    headerArgs?: string | undefined;
+    headerArgsSegments?: readonly ToolHeaderSegment[] | undefined;
+    bodyLineStyles?: readonly ToolBodyLineStyle[] | undefined;
+    bodyStyle?: "diff" | undefined;
+    preserveAnsi?: boolean | undefined;
+    expanded: boolean;
+    status: "running" | "done";
+    isError: boolean;
+    output: string;
+    collapsedBody: string;
+    expandedText: string;
+    bodyWrap?: "char" | "word" | undefined;
+    syntaxHighlight?: ToolBodySyntaxHighlights | undefined;
+};
+export type ToolBlockRenderOptions = {
+    superCompact?: boolean;
+};
+export declare function renderToolBlock(entry: ToolBlockEntry, rule: ResolvedToolRule, width: number, colors: Theme["colors"], options?: ToolBlockRenderOptions): RenderedLine[];