pi-ui-extend 0.1.13 → 0.1.17

package/dist/app/session/tabs-controller.js

@@ -1,8 +1,8 @@
 import { createHash } from "node:crypto";
 import { existsSync } from "node:fs";
-import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
-import { dirname, join, resolve } from "node:path";
-import { getAgentDir, SessionManager, } from "@earendil-works/pi-coding-agent";
+import { mkdir, readFile, readdir, rename, stat, unlink, writeFile } from "node:fs/promises";
+import { basename, dirname, extname, join, resolve } from "node:path";
+import { getAgentDir, } from "@earendil-works/pi-coding-agent";
 import { isRecord } from "../guards.js";
 import { createId } from "../id.js";
 import { createStartupInfoMessage, isEmptyStartupSession } from "../cli/startup-info.js";
@@ -10,6 +10,7 @@ import { tabPanelRows } from "../rendering/tab-line-renderer.js";
 const TAB_STATE_VERSION = 3;
 const MAX_RESTORED_TABS = 8;
 const TAB_ATTENTION_BLINK_KEY = "tab-attention";
+const LOADING_TAB_TITLE_PATTERN = /^loading(?:…|\.\.\.)?$/iu;
 export class AppTabsController {
     host;
     tabItems = [];
@@ -21,6 +22,8 @@ export class AppTabsController {
     pendingActiveTabId;
     historyLoadGeneration = 0;
     restored = false;
+    retentionCleanupRunning = false;
+    retentionCleanupScheduled = false;
     constructor(host) {
         this.host = host;
     }
@@ -67,9 +70,11 @@ export class AppTabsController {
         return this.inputStatesByTabId.get(tabId);
     }
     async setInputStateForTab(tabId, state) {
+        const attachments = state.attachments?.map(clonePersistedAttachment) ?? [];
         const nextState = {
             text: state.text,
             cursor: Math.max(0, Math.min(state.text.length, Math.trunc(state.cursor))),
+            ...(attachments.length > 0 ? { attachments } : {}),
         };
         const targetTabId = tabId ?? this.activeTabId;
         if (targetTabId) {
@@ -153,17 +158,21 @@ export class AppTabsController {
         if (!runtime)
             return;
         this.syncActiveTabFromRuntime({ save: false });
-        if (this.host.options.noSession)
+        if (this.host.options.noSession) {
+            this.settleStartupTabPlaceholders();
             return;
+        }
         const saved = await this.loadTabs();
         if (!saved || saved.tabs.length === 0) {
+            this.settleStartupTabPlaceholders();
             await this.saveTabs();
             return;
         }
-        const sessionTitles = await this.loadSessionTitles();
-        const restoredTabs = this.restoredTabs(saved, sessionTitles);
+        const restoredTabs = this.restoredTabs(saved);
         if (restoredTabs.length === 0) {
+            this.settleStartupTabPlaceholders();
             await this.saveTabs();
+            this.scheduleProjectSessionRetention();
             return;
         }
         const currentPath = runtime.session.sessionFile ? resolve(runtime.session.sessionFile) : undefined;
@@ -180,35 +189,41 @@ export class AppTabsController {
         if (explicitSessionPath && currentPath)
             this.ensureCurrentSessionTab(runtime.session);
         if (!desiredPath) {
+            this.settleStartupTabPlaceholders();
             await this.saveTabs();
+            this.scheduleProjectSessionRetention();
             return;
         }
+        let restoredRuntime = runtime;
         if (currentPath !== desiredPath) {
             this.host.setStatus("restoring tabs");
             this.host.render();
             try {
-                const result = await runtime.switchSession(desiredPath);
-                if (result.cancelled)
-                    throw new Error("restore cancelled");
+                restoredRuntime = await this.host.createRuntimeForSession(desiredPath);
+                await this.host.activateRuntime(restoredRuntime);
             }
             catch {
                 this.host.showToast("Could not restore the previous active tab", "warning");
                 this.replaceTabs([this.tabFromSession(runtime.session), ...restoredTabs], currentPath);
                 this.storeActiveRuntime(runtime);
+                this.settleStartupTabPlaceholders();
                 await this.saveTabs();
+                this.scheduleProjectSessionRetention();
                 return;
             }
         }
         this.syncActiveTabFromRuntime({ save: false });
+        this.settleStartupTabPlaceholders();
         this.host.resetSessionView();
         if (this.activeTabId)
             this.restoreDeferredUserMessages(this.activeTabId);
         this.host.loadSessionHistory();
-        this.host.setSessionStatus(runtime.session);
-        this.host.setSessionActivity(this.sessionActivity(runtime.session));
+        this.host.setSessionStatus(restoredRuntime.session);
+        this.host.setSessionActivity(this.sessionActivity(restoredRuntime.session));
         if (this.activeTabId)
             this.restoreInputState(this.activeTabId);
         await this.saveTabs();
+        this.scheduleProjectSessionRetention();
     }
     async openNewTab() {
         if (this.pendingActiveTabId) {
@@ -237,6 +252,7 @@ export class AppTabsController {
         this.updateTabFromSession(tab, newRuntime.session);
         this.setRuntimeForTab(tab.id, newRuntime);
         this.restoreInputState(tab.id);
+        this.host.closeMenusForTabSwitch?.();
         try {
             await this.host.activateRuntime(newRuntime);
         }
@@ -245,6 +261,7 @@ export class AppTabsController {
                 this.pendingActiveTabId = undefined;
         }
         void this.saveTabs();
+        this.scheduleProjectSessionRetention();
         this.host.resetSessionView();
         this.restoreDeferredUserMessages(tab.id);
         if (isEmptyStartupSession(newRuntime)) {
@@ -307,6 +324,7 @@ export class AppTabsController {
         this.updateTabFromSession(tab, newRuntime.session);
         this.setRuntimeForTab(tab.id, newRuntime);
         this.restoreInputState(tab.id);
+        this.host.closeMenusForTabSwitch?.();
         try {
             await this.host.activateRuntime(newRuntime);
         }
@@ -316,6 +334,7 @@ export class AppTabsController {
             this.activeTabId = previousTabId;
             if (previousTabId)
                 this.restoreInputState(previousTabId);
+            this.host.closeMenusForTabSwitch?.();
             if (this.host.runtime() !== previousRuntime) {
                 try {
                     await this.host.activateRuntime(previousRuntime);
@@ -346,6 +365,120 @@ export class AppTabsController {
         await this.loadActiveSessionHistory(newRuntime);
         return true;
     }
+    async forkSessionEntryInNewTab(entryId) {
+        if (this.pendingActiveTabId) {
+            this.host.showToast("Wait for the tab to finish loading", "info");
+            return false;
+        }
+        const runtime = this.idleRuntime("fork");
+        if (!runtime)
+            return false;
+        if (this.host.options.noSession) {
+            this.host.showToast("Fork in new tab is unavailable with --no-session", "warning");
+            return false;
+        }
+        const currentSessionPath = runtime.session.sessionFile ? resolve(runtime.session.sessionFile) : undefined;
+        if (!currentSessionPath) {
+            this.host.showToast("Fork in new tab requires a persisted session", "warning");
+            return false;
+        }
+        this.cancelHistoryLoad();
+        this.syncActiveTabFromRuntime({ save: false });
+        this.storeActiveInputState();
+        this.storeActiveDeferredUserMessages();
+        const previousTabId = this.activeTabId;
+        const previousRuntime = runtime;
+        this.host.setStatus("forking session tab");
+        this.host.render();
+        let forkRuntime;
+        try {
+            forkRuntime = await this.host.createRuntimeForSession(currentSessionPath);
+        }
+        catch {
+            this.host.showToast("Could not fork in new tab", "warning");
+            this.host.setSessionStatus(previousRuntime.session);
+            this.host.render();
+            return false;
+        }
+        let result;
+        try {
+            result = await forkRuntime.fork(entryId);
+        }
+        catch (error) {
+            void this.host.disposeRuntime(forkRuntime);
+            throw error;
+        }
+        if (result.cancelled) {
+            void this.host.disposeRuntime(forkRuntime);
+            this.host.addEntry({ id: createId("system"), kind: "system", text: "Fork cancelled." });
+            this.host.setSessionStatus(previousRuntime.session);
+            this.host.render();
+            return false;
+        }
+        const existingTab = this.findTabForSession(forkRuntime.session);
+        if (existingTab) {
+            if (result.selectedText)
+                this.inputStatesByTabId.set(existingTab.id, this.inputStateFromText(result.selectedText));
+            void this.host.disposeRuntime(forkRuntime);
+            await this.switchToTab(existingTab.id);
+            this.host.showToast("Fork opened in existing tab", "success");
+            return true;
+        }
+        const tab = this.tabFromSession(forkRuntime.session, { titlePlaceholder: "new" });
+        this.tabItems.push(tab);
+        this.activeTabId = tab.id;
+        this.pendingActiveTabId = tab.id;
+        this.clearTabAttention(tab);
+        this.updateTabFromSession(tab, forkRuntime.session);
+        this.setRuntimeForTab(tab.id, forkRuntime);
+        if (result.selectedText)
+            this.inputStatesByTabId.set(tab.id, this.inputStateFromText(result.selectedText));
+        this.restoreInputState(tab.id);
+        this.host.closeMenusForTabSwitch?.();
+        try {
+            await this.host.activateRuntime(forkRuntime);
+        }
+        catch {
+            this.pendingActiveTabId = undefined;
+            this.removeTab(tab.id);
+            this.activeTabId = previousTabId;
+            if (previousTabId)
+                this.restoreInputState(previousTabId);
+            this.host.closeMenusForTabSwitch?.();
+            if (this.host.runtime() !== previousRuntime) {
+                try {
+                    await this.host.activateRuntime(previousRuntime);
+                }
+                catch {
+                    // Keep the best available runtime below and surface the switch failure.
+                }
+            }
+            void this.host.disposeRuntime(forkRuntime);
+            this.host.showToast("Could not open fork tab", "warning");
+            this.host.resetSessionView();
+            if (previousTabId)
+                this.restoreDeferredUserMessages(previousTabId);
+            this.host.loadSessionHistory();
+            this.host.setSessionStatus(this.host.runtime()?.session);
+            this.host.setSessionActivity(this.sessionActivity(this.host.runtime()?.session));
+            this.host.render();
+            return false;
+        }
+        this.pendingActiveTabId = undefined;
+        this.activeTabId = tab.id;
+        this.clearTabAttention(tab);
+        this.updateTabFromSession(tab, forkRuntime.session);
+        this.setRuntimeForTab(tab.id, forkRuntime);
+        this.restoreInputState(tab.id);
+        void this.saveTabs();
+        this.scheduleProjectSessionRetention();
+        await this.loadActiveSessionHistory(forkRuntime);
+        this.host.addEntry({ id: createId("system"), kind: "system", text: `Forked from entry ${entryId} in a new tab.` });
+        this.host.setSessionStatus(forkRuntime.session);
+        this.host.showToast("Fork opened in new tab", "success");
+        this.host.render();
+        return true;
+    }
     async switchToTab(tabId) {
         if (this.pendingActiveTabId) {
             this.host.showToast("Wait for the tab to finish loading", "info");
@@ -376,6 +509,7 @@ export class AppTabsController {
         target.activity = "thinking";
         this.clearTabAttention(target);
         this.restoreInputState(target.id);
+        this.host.closeMenusForTabSwitch?.();
         this.host.resetSessionView();
         this.restoreDeferredUserMessages(target.id);
         this.host.setStatus("switching tab");
@@ -397,6 +531,7 @@ export class AppTabsController {
             this.activeTabId = previousTabId;
             if (previousTabId)
                 this.restoreInputState(previousTabId);
+            this.host.closeMenusForTabSwitch?.();
             if (this.host.runtime() !== previousRuntime) {
                 try {
                     await this.host.activateRuntime(previousRuntime);
@@ -481,6 +616,7 @@ export class AppTabsController {
         this.updateTabFromSession(nextTab, nextRuntime.session);
         this.setRuntimeForTab(nextTab.id, nextRuntime);
         this.restoreInputState(nextTab.id);
+        this.host.closeMenusForTabSwitch?.();
         void this.host.disposeRuntime(runtime);
         void this.saveTabs();
         await this.loadActiveSessionHistory(nextRuntime);
@@ -509,6 +645,7 @@ export class AppTabsController {
         this.inputStatesByTabId.delete(tab.id);
         this.deferredUserMessagesByTabId.delete(tab.id);
         this.restoreInputState(tab.id);
+        this.host.closeMenusForTabSwitch?.();
         this.stopAttentionBlinkIfIdle();
         this.host.resetSessionView();
         this.restoreDeferredUserMessages(tab.id);
@@ -522,6 +659,7 @@ export class AppTabsController {
         this.host.setSessionStatus(runtime.session);
         this.host.setSessionActivity(this.sessionActivity(runtime.session));
         void this.saveTabs();
+        this.scheduleProjectSessionRetention();
         this.host.render();
     }
     async loadActiveSessionHistory(runtime) {
@@ -539,6 +677,7 @@ export class AppTabsController {
                 if (!isCancelled())
                     this.host.render();
             },
+            lazyOlderHistory: true,
         });
         if (!completed || isCancelled())
             return;
@@ -583,6 +722,12 @@ export class AppTabsController {
     activeTab() {
         return this.activeTabId ? this.tabItems.find((tab) => tab.id === this.activeTabId) : undefined;
     }
+    settleStartupTabPlaceholders() {
+        for (const tab of this.tabItems) {
+            if (tab.titlePlaceholder === "loading")
+                tab.titlePlaceholder = "new";
+        }
+    }
     storeActiveRuntime(runtime = this.host.runtime()) {
         if (!this.activeTabId || !runtime)
             return;
@@ -643,9 +788,11 @@ export class AppTabsController {
         if (!this.activeTabId)
             return;
         const state = this.host.captureInputState();
+        const attachments = state.attachments?.map(clonePersistedAttachment) ?? [];
         this.inputStatesByTabId.set(this.activeTabId, {
             text: state.text,
             cursor: state.cursor,
+            ...(attachments.length > 0 ? { attachments } : {}),
         });
     }
     storeActiveDeferredUserMessages() {
@@ -662,6 +809,9 @@ export class AppTabsController {
     restoreInputState(tabId) {
         this.host.restoreInputState(this.inputStatesByTabId.get(tabId) ?? { text: "", cursor: 0 });
     }
+    inputStateFromText(text) {
+        return { text, cursor: text.length };
+    }
     restoreDeferredUserMessages(tabId) {
         this.host.restoreDeferredUserMessages?.(this.deferredUserMessagesByTabId.get(tabId) ?? []);
     }
@@ -712,6 +862,7 @@ export class AppTabsController {
             this.tabItems.push({
                 id: tab.id,
                 title: tab.title,
+                ...(tab.titlePlaceholder ? { titlePlaceholder: tab.titlePlaceholder } : {}),
                 status: "waiting",
                 activity: tab.activity ?? "idle",
                 ...(sessionPath ? { sessionPath } : {}),
@@ -800,8 +951,11 @@ export class AppTabsController {
         return session.sessionFile ? resolve(session.sessionFile) : undefined;
     }
     sessionTitle(session) {
-        const name = session.sessionName?.trim();
-        return name ? name : `session ${session.sessionId.slice(0, 8)}`;
+        return this.sessionTitleFromParts(session.sessionId, session.sessionName);
+    }
+    sessionTitleFromParts(sessionId, sessionName) {
+        const name = sessionName?.trim();
+        return name && !LOADING_TAB_TITLE_PATTERN.test(name) ? name : `session ${sessionId.slice(0, 8)}`;
     }
     sessionActivity(session) {
         return session?.isStreaming || session?.isCompacting ? "running" : "idle";
@@ -833,19 +987,7 @@ export class AppTabsController {
             initialVisible: true,
         });
     }
-    async loadSessionTitles() {
-        try {
-            const sessions = await SessionManager.list(this.host.options.cwd);
-            return new Map(sessions.map((session) => [
-                resolve(session.path),
-                (session.name?.trim() || `session ${session.id.slice(0, 8)}`),
-            ]));
-        }
-        catch {
-            return new Map();
-        }
-    }
-    restoredTabs(saved, titles) {
+    restoredTabs(saved) {
         const tabs = [];
         const seen = new Set();
         for (const tab of saved.tabs) {
@@ -855,10 +997,13 @@ export class AppTabsController {
             if (seen.has(sessionPath) || (!existsSync(sessionPath) && !hasDraftInput && !hasDeferredQueue))
                 continue;
             seen.add(sessionPath);
-            const title = titles.get(sessionPath) ?? tab.title?.trim();
+            const savedTitle = tab.title?.trim();
+            const restoredLoadingTitle = savedTitle !== undefined && LOADING_TAB_TITLE_PATTERN.test(savedTitle);
+            const title = restoredLoadingTitle ? this.defaultSessionTitleFromPath(sessionPath) : savedTitle;
             tabs.push({
                 id: createId("tab"),
                 title: title || "session",
+                ...(restoredLoadingTitle ? { titlePlaceholder: "new" } : {}),
                 status: "waiting",
                 sessionPath,
             });
@@ -867,6 +1012,12 @@ export class AppTabsController {
         }
         return tabs;
     }
+    defaultSessionTitleFromPath(sessionPath) {
+        const fileName = basename(sessionPath, extname(sessionPath));
+        const sessionId = /^[0-9a-f]{8}/iu.exec(fileName)?.[0]?.toLowerCase()
+            ?? createHash("sha256").update(sessionPath).digest("hex").slice(0, 8);
+        return `session ${sessionId}`;
+    }
     async loadTabs() {
         try {
             const raw = await readFile(this.filePath(), "utf8");
@@ -905,7 +1056,10 @@ export class AppTabsController {
         const cursor = typeof value.cursor === "number" && Number.isFinite(value.cursor)
             ? Math.max(0, Math.min(value.text.length, Math.trunc(value.cursor)))
             : value.text.length;
-        return { text: value.text, cursor };
+        const attachments = Array.isArray(value.attachments)
+            ? value.attachments.flatMap(parsePersistedAttachment)
+            : [];
+        return { text: value.text, cursor, ...(attachments.length > 0 ? { attachments } : {}) };
     }
     parsePersistedSubmittedUserMessages(value) {
         if (!Array.isArray(value))
@@ -943,10 +1097,11 @@ export class AppTabsController {
                 seen.add(sessionPath);
                 const persistedTab = { path: sessionPath, title: tab.title };
                 const input = this.inputStatesByTabId.get(tab.id);
-                if (input?.text.length) {
+                if (input && (input.text.length > 0 || (input.attachments?.length ?? 0) > 0)) {
                     persistedTab.input = {
                         text: input.text,
                         cursor: Math.max(0, Math.min(input.text.length, Math.trunc(input.cursor))),
+                        ...(input.attachments && input.attachments.length > 0 ? { attachments: input.attachments.map(clonePersistedAttachment) } : {}),
                     };
                 }
                 const deferredUserMessages = this.deferredUserMessagesByTabId.get(tab.id);
@@ -978,4 +1133,128 @@ export class AppTabsController {
         const key = createHash("sha256").update(resolve(this.host.options.cwd)).digest("hex").slice(0, 24);
         return join(getAgentDir(), "pix", "tabs", `${key}.json`);
     }
+    sessionDir() {
+        const safePath = `--${resolve(this.host.options.cwd).replace(/^[/\\]/, "").replace(/[/\\:]/g, "-")}--`;
+        return join(getAgentDir(), "sessions", safePath);
+    }
+    scheduleProjectSessionRetention() {
+        if (this.host.options.noSession || this.maxProjectSessions() <= 0 || this.retentionCleanupScheduled || this.retentionCleanupRunning)
+            return;
+        this.retentionCleanupScheduled = true;
+        setTimeout(() => {
+            this.retentionCleanupScheduled = false;
+            void this.cleanupOldProjectSessions();
+        }, 0);
+    }
+    async cleanupOldProjectSessions() {
+        if (this.retentionCleanupRunning)
+            return;
+        this.retentionCleanupRunning = true;
+        try {
+            const maxProjectSessions = this.maxProjectSessions();
+            if (maxProjectSessions <= 0)
+                return;
+            const sessionDir = this.sessionDir();
+            const preserved = this.preservedSessionPaths();
+            const entries = await readdir(sessionDir, { withFileTypes: true });
+            const sessions = [];
+            for (const entry of entries) {
+                if (!entry.isFile() || extname(entry.name) !== ".jsonl")
+                    continue;
+                const path = resolve(sessionDir, entry.name);
+                try {
+                    const info = await stat(path);
+                    sessions.push({ path, modifiedMs: info.mtimeMs });
+                }
+                catch {
+                    // Ignore files that disappear while cleanup is scanning.
+                }
+            }
+            if (sessions.length <= maxProjectSessions)
+                return;
+            sessions.sort((a, b) => b.modifiedMs - a.modifiedMs);
+            const keep = new Set(preserved);
+            for (const session of sessions) {
+                if (keep.size >= maxProjectSessions)
+                    break;
+                keep.add(session.path);
+            }
+            for (const session of sessions) {
+                if (keep.has(session.path))
+                    continue;
+                try {
+                    await unlink(session.path);
+                }
+                catch {
+                    // Session retention must never interrupt the terminal UI.
+                }
+            }
+        }
+        catch {
+            // Session retention must never interrupt the terminal UI.
+        }
+        finally {
+            this.retentionCleanupRunning = false;
+        }
+    }
+    preservedSessionPaths() {
+        const preserved = new Set();
+        const add = (sessionPath) => {
+            if (sessionPath)
+                preserved.add(resolve(sessionPath));
+        };
+        add(this.host.options.sessionPath);
+        add(this.host.runtime()?.session.sessionFile);
+        for (const tab of this.tabItems)
+            add(tab.sessionPath);
+        return preserved;
+    }
+    maxProjectSessions() {
+        const value = this.host.maxProjectSessions;
+        return typeof value === "number" && Number.isFinite(value) ? Math.max(0, Math.floor(value)) : 0;
+    }
+}
+function parsePersistedAttachment(value) {
+    if (!isRecord(value) || typeof value.kind !== "string" || typeof value.tag !== "string")
+        return [];
+    if (value.kind === "image") {
+        const image = parsePersistedImage(value.image);
+        return image ? [{ kind: "image", tag: value.tag, image }] : [];
+    }
+    if (value.kind === "pasted-text") {
+        if (typeof value.text !== "string" || typeof value.lineCount !== "number" || !Number.isFinite(value.lineCount))
+            return [];
+        return [{ kind: "pasted-text", tag: value.tag, text: value.text, lineCount: Math.max(1, Math.trunc(value.lineCount)) }];
+    }
+    if (value.kind === "file") {
+        if (typeof value.path !== "string")
+            return [];
+        const image = parsePersistedImage(value.image);
+        return [{
+                kind: "file",
+                tag: value.tag,
+                path: value.path,
+                ...(typeof value.content === "string" ? { content: value.content } : {}),
+                ...(image ? { image } : {}),
+            }];
+    }
+    return [];
+}
+function parsePersistedImage(value) {
+    return isRecord(value) && value.type === "image" && typeof value.data === "string" && typeof value.mimeType === "string"
+        ? { type: "image", data: value.data, mimeType: value.mimeType }
+        : undefined;
+}
+function clonePersistedAttachment(attachment) {
+    if (attachment.kind === "image")
+        return { kind: "image", tag: attachment.tag, image: { ...attachment.image } };
+    if (attachment.kind === "pasted-text")
+        return { kind: "pasted-text", tag: attachment.tag, text: attachment.text, lineCount: attachment.lineCount };
+    return {
+        kind: "file",
+        tag: attachment.tag,
+        path: attachment.path,
+        ...(attachment.content === undefined ? {} : { content: attachment.content }),
+        ...(attachment.image === undefined ? {} : { image: { ...attachment.image } }),
+    };
 }

package/dist/app/todo/todo-model.d.ts

@@ -1,7 +1,7 @@
-import type { StyledSegment, TodoAction, TodoDetails, TodoLiveStateEvent, TodoPriority, TodoStatus, TodoTask, TodoTaskLinePart, TodoTaskRow } from "../types.js";
+import type { StyledSegment, ThinkingLevel, TodoAction, TodoDetails, TodoLiveStateEvent, TodoStatus, TodoTask, TodoTaskLinePart, TodoTaskRow } from "../types.js";
 export declare function isTodoAction(value: unknown): value is TodoAction;
 export declare function isTodoStatus(value: unknown): value is TodoStatus;
-export declare function isTodoPriority(value: unknown): value is TodoPriority;
+export declare function isTodoThinkingLevel(value: unknown): value is ThinkingLevel;
 export declare function isTodoTask(value: unknown): value is TodoTask;
 export declare function isTodoDetails(value: unknown): value is TodoDetails;
 export declare function isTodoLiveStateEvent(value: unknown): value is TodoLiveStateEvent;
@@ -17,6 +17,8 @@ export declare function formatTodoTaskLine(task: TodoTask, options?: {
 }): string;
 export declare function todoTaskLineSegments(task: TodoTask, mutedColor: string, options?: {
     depth?: number;
+    thinkingColor?: (level: ThinkingLevel) => string;
+    statusColor?: (status: TodoStatus) => string;
 }): StyledSegment[];
 export declare function shiftSegmentsToSlice(segments: readonly StyledSegment[], start: number, length: number): StyledSegment[];
 export declare function formatTodoPanelStats(tasks: readonly TodoTask[]): string;

package/dist/app/todo/todo-model.js

@@ -1,5 +1,5 @@
-import { TODO_ACTIONS, TODO_PRIORITIES, TODO_STATUSES } from "../constants.js";
-import { isNumberArray, isRecord, isStringArray } from "../guards.js";
+import { THINKING_LEVELS, TODO_ACTIONS, TODO_STATUSES } from "../constants.js";
+import { isNumberArray, isRecord } from "../guards.js";
 import { APP_ICONS } from "../icons.js";
 export function isTodoAction(value) {
     return typeof value === "string" && TODO_ACTIONS.includes(value);
@@ -7,8 +7,8 @@ export function isTodoAction(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 isTodoThinkingLevel(value) {
+    return typeof value === "string" && THINKING_LEVELS.includes(value);
 }
 export function isTodoTask(value) {
     if (!isRecord(value))
@@ -23,14 +23,12 @@ export function isTodoTask(value) {
         return false;
     if (value.activeForm !== undefined && typeof value.activeForm !== "string")
         return false;
-    if (value.priority !== undefined && !isTodoPriority(value.priority))
+    if (value.thinking !== undefined && !isTodoThinkingLevel(value.thinking))
         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))
@@ -116,17 +114,19 @@ export function visibleTodoTaskRows(details, showDeleted = false) {
 }
 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 }];
+    const subjectPart = { text: `${task.id}.${task.subject}` };
+    if (task.thinking)
+        subjectPart.thinking = task.thinking;
+    const parts = [
+        { text: `${treePrefix}${todoStatusIcon(task.status)}` },
+        subjectPart,
+    ];
     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 = {}) {
@@ -141,7 +141,17 @@ export function todoTaskLineSegments(task, mutedColor, options = {}) {
         const start = offset;
         const end = start + part.text.length;
         const segment = { start, end };
-        if (part.muted)
+        if (index === 0 && options.statusColor) {
+            const foreground = options.statusColor(task.status);
+            if (foreground)
+                segment.foreground = foreground;
+        }
+        else if (part.thinking) {
+            const foreground = options.thinkingColor?.(part.thinking);
+            if (foreground)
+                segment.foreground = foreground;
+        }
+        else if (part.muted)
             segment.foreground = mutedColor;
         if (task.status === "completed" && index > 0)
             segment.strikethrough = true;