@vaclav-synacek/pi-coding-agent-termux 0.50.7-1 → 0.51.1-0

package/dist/modes/interactive/components/session-selector.js

@@ -3,10 +3,11 @@ import { existsSync } from "node:fs";
 import { unlink } from "node:fs/promises";
 import * as os from "node:os";
 import { Container, getEditorKeybindings, Input, matchesKey, Spacer, Text, truncateToWidth, visibleWidth, } from "@mariozechner/pi-tui";
+import { KeybindingsManager } from "../../../core/keybindings.js";
 import { theme } from "../theme/theme.js";
 import { DynamicBorder } from "./dynamic-border.js";
-import { keyHint } from "./keybinding-hints.js";
-import { filterAndSortSessions } from "./session-selector-search.js";
+import { appKey, appKeyHint, keyHint } from "./keybinding-hints.js";
+import { filterAndSortSessions, hasSessionName } from "./session-selector-search.js";
 function shortenPath(path) {
     const home = os.homedir();
     if (!path)
@@ -23,20 +24,24 @@ function formatSessionDate(date) {
     const diffHours = Math.floor(diffMs / 3600000);
     const diffDays = Math.floor(diffMs / 86400000);
     if (diffMins < 1)
-        return "just now";
+        return "now";
     if (diffMins < 60)
-        return `${diffMins} minute${diffMins !== 1 ? "s" : ""} ago`;
+        return `${diffMins}m`;
     if (diffHours < 24)
-        return `${diffHours} hour${diffHours !== 1 ? "s" : ""} ago`;
-    if (diffDays === 1)
-        return "1 day ago";
+        return `${diffHours}h`;
     if (diffDays < 7)
-        return `${diffDays} days ago`;
-    return date.toLocaleDateString();
+        return `${diffDays}d`;
+    if (diffDays < 30)
+        return `${Math.floor(diffDays / 7)}w`;
+    if (diffDays < 365)
+        return `${Math.floor(diffDays / 30)}mo`;
+    return `${Math.floor(diffDays / 365)}y`;
 }
 class SessionSelectorHeader {
     scope;
     sortMode;
+    nameFilter;
+    keybindings;
     requestRender;
     loading = false;
     loadProgress = null;
@@ -45,9 +50,11 @@ class SessionSelectorHeader {
     statusMessage = null;
     statusTimeout = null;
     showRenameHint = false;
-    constructor(scope, sortMode, requestRender) {
+    constructor(scope, sortMode, nameFilter, keybindings, requestRender) {
         this.scope = scope;
         this.sortMode = sortMode;
+        this.nameFilter = nameFilter;
+        this.keybindings = keybindings;
         this.requestRender = requestRender;
     }
     setScope(scope) {
@@ -56,6 +63,9 @@ class SessionSelectorHeader {
     setSortMode(sortMode) {
         this.sortMode = sortMode;
     }
+    setNameFilter(nameFilter) {
+        this.nameFilter = nameFilter;
+    }
     setLoading(loading) {
         this.loading = loading;
         // Progress is scoped to the current load; clear whenever the loading state is set
@@ -94,8 +104,10 @@ class SessionSelectorHeader {
     render(width) {
         const title = this.scope === "current" ? "Resume Session (Current Folder)" : "Resume Session (All)";
         const leftText = theme.bold(title);
-        const sortLabel = this.sortMode === "recent" ? "Recent" : "Fuzzy";
+        const sortLabel = this.sortMode === "threaded" ? "Threaded" : this.sortMode === "recent" ? "Recent" : "Fuzzy";
         const sortText = theme.fg("muted", "Sort: ") + theme.fg("accent", sortLabel);
+        const nameLabel = this.nameFilter === "all" ? "All" : "Named";
+        const nameText = theme.fg("muted", "Name: ") + theme.fg("accent", nameLabel);
         let scopeText;
         if (this.loading) {
             const progressText = this.loadProgress ? `${this.loadProgress.loaded}/${this.loadProgress.total}` : "...";
@@ -107,7 +119,7 @@ class SessionSelectorHeader {
         else {
             scopeText = `${theme.fg("muted", "○ Current Folder | ")}${theme.fg("accent", "◉ All")}`;
         }
-        const rightText = truncateToWidth(`${scopeText}  ${sortText}`, width, "");
+        const rightText = truncateToWidth(`${scopeText}  ${nameText}  ${sortText}`, width, "");
         const availableLeft = Math.max(0, width - visibleWidth(rightText) - 1);
         const left = truncateToWidth(leftText, availableLeft, "");
         const spacing = Math.max(0, width - visibleWidth(left) - visibleWidth(rightText));
@@ -130,6 +142,7 @@ class SessionSelectorHeader {
             const hint1 = keyHint("tab", "scope") + sep + theme.fg("muted", 're:<pattern> regex · "phrase" exact');
             const hint2Parts = [
                 keyHint("toggleSessionSort", "sort"),
+                appKeyHint(this.keybindings, "toggleSessionNamedFilter", "named"),
                 keyHint("deleteSession", "delete"),
                 keyHint("toggleSessionPath", `path ${pathState}`),
             ];
@@ -143,20 +156,71 @@ class SessionSelectorHeader {
         return [`${left}${" ".repeat(spacing)}${rightText}`, hintLine1, hintLine2];
     }
 }
+/**
+ * Build a tree structure from sessions based on parentSessionPath.
+ * Returns root nodes sorted by modified date (descending).
+ */
+function buildSessionTree(sessions) {
+    const byPath = new Map();
+    for (const session of sessions) {
+        byPath.set(session.path, { session, children: [] });
+    }
+    const roots = [];
+    for (const session of sessions) {
+        const node = byPath.get(session.path);
+        const parentPath = session.parentSessionPath;
+        if (parentPath && byPath.has(parentPath)) {
+            byPath.get(parentPath).children.push(node);
+        }
+        else {
+            roots.push(node);
+        }
+    }
+    // Sort children and roots by modified date (descending)
+    const sortNodes = (nodes) => {
+        nodes.sort((a, b) => b.session.modified.getTime() - a.session.modified.getTime());
+        for (const node of nodes) {
+            sortNodes(node.children);
+        }
+    };
+    sortNodes(roots);
+    return roots;
+}
+/**
+ * Flatten tree into display list with tree structure metadata.
+ */
+function flattenSessionTree(roots) {
+    const result = [];
+    const walk = (node, depth, ancestorContinues, isLast) => {
+        result.push({ session: node.session, depth, isLast, ancestorContinues });
+        for (let i = 0; i < node.children.length; i++) {
+            const childIsLast = i === node.children.length - 1;
+            // Only show continuation line for non-root ancestors
+            const continues = depth > 0 ? !isLast : false;
+            walk(node.children[i], depth + 1, [...ancestorContinues, continues], childIsLast);
+        }
+    };
+    for (let i = 0; i < roots.length; i++) {
+        walk(roots[i], 0, [], i === roots.length - 1);
+    }
+    return result;
+}
 /**
  * Custom session list component with multi-line items and search
  */
 class SessionList {
     getSelectedSessionPath() {
         const selected = this.filteredSessions[this.selectedIndex];
-        return selected?.path;
+        return selected?.session.path;
     }
     allSessions = [];
     filteredSessions = [];
     selectedIndex = 0;
     searchInput;
     showCwd = false;
-    sortMode = "relevance";
+    sortMode = "threaded";
+    nameFilter = "all";
+    keybindings;
     showPath = false;
     confirmingDeletePath = null;
     currentSessionFilePath;
@@ -165,12 +229,13 @@ class SessionList {
     onExit = () => { };
     onToggleScope;
     onToggleSort;
+    onToggleNameFilter;
     onTogglePath;
     onDeleteConfirmationChange;
     onDeleteSession;
     onRenameSession;
     onError;
-    maxVisible = 5; // Max sessions visible (each session: message + metadata + optional path + blank)
+    maxVisible = 10; // Max sessions visible (one line each)
     // Focusable implementation - propagate to searchInput for IME cursor positioning
     _focused = false;
     get focused() {
@@ -180,19 +245,22 @@ class SessionList {
         this._focused = value;
         this.searchInput.focused = value;
     }
-    constructor(sessions, showCwd, sortMode, currentSessionFilePath) {
+    constructor(sessions, showCwd, sortMode, nameFilter, keybindings, currentSessionFilePath) {
         this.allSessions = sessions;
-        this.filteredSessions = sessions;
+        this.filteredSessions = [];
         this.searchInput = new Input();
         this.showCwd = showCwd;
         this.sortMode = sortMode;
+        this.nameFilter = nameFilter;
+        this.keybindings = keybindings;
         this.currentSessionFilePath = currentSessionFilePath;
+        this.filterSessions("");
         // Handle Enter in search input - select current item
         this.searchInput.onSubmit = () => {
             if (this.filteredSessions[this.selectedIndex]) {
                 const selected = this.filteredSessions[this.selectedIndex];
                 if (this.onSelect) {
-                    this.onSelect(selected.path);
+                    this.onSelect(selected.session.path);
                 }
             }
         };
@@ -201,13 +269,33 @@ class SessionList {
         this.sortMode = sortMode;
         this.filterSessions(this.searchInput.getValue());
     }
+    setNameFilter(nameFilter) {
+        this.nameFilter = nameFilter;
+        this.filterSessions(this.searchInput.getValue());
+    }
     setSessions(sessions, showCwd) {
         this.allSessions = sessions;
         this.showCwd = showCwd;
         this.filterSessions(this.searchInput.getValue());
     }
     filterSessions(query) {
-        this.filteredSessions = filterAndSortSessions(this.allSessions, query, this.sortMode);
+        const trimmed = query.trim();
+        const nameFiltered = this.nameFilter === "all" ? this.allSessions : this.allSessions.filter((session) => hasSessionName(session));
+        if (this.sortMode === "threaded" && !trimmed) {
+            // Threaded mode without search: show tree structure
+            const roots = buildSessionTree(nameFiltered);
+            this.filteredSessions = flattenSessionTree(roots);
+        }
+        else {
+            // Other modes or with search: flat list
+            const filtered = filterAndSortSessions(nameFiltered, query, this.sortMode, "all");
+            this.filteredSessions = filtered.map((session) => ({
+                session,
+                depth: 0,
+                isLast: true,
+                ancestorContinues: [],
+            }));
+        }
         this.selectedIndex = Math.min(this.selectedIndex, Math.max(0, this.filteredSessions.length - 1));
     }
     setConfirmingDeletePath(path) {
@@ -219,11 +307,11 @@ class SessionList {
         if (!selected)
             return;
         // Prevent deleting current session
-        if (this.currentSessionFilePath && selected.path === this.currentSessionFilePath) {
+        if (this.currentSessionFilePath && selected.session.path === this.currentSessionFilePath) {
             this.onError?.("Cannot delete the currently active session");
             return;
         }
-        this.setConfirmingDeletePath(selected.path);
+        this.setConfirmingDeletePath(selected.session.path);
     }
     invalidate() { }
     render(width) {
@@ -232,37 +320,68 @@ class SessionList {
         lines.push(...this.searchInput.render(width));
         lines.push(""); // Blank line after search
         if (this.filteredSessions.length === 0) {
-            if (this.showCwd) {
+            let emptyMessage;
+            if (this.nameFilter === "named") {
+                const toggleKey = appKey(this.keybindings, "toggleSessionNamedFilter");
+                if (this.showCwd) {
+                    emptyMessage = `  No named sessions found. Press ${toggleKey} to show all.`;
+                }
+                else {
+                    emptyMessage = `  No named sessions in current folder. Press ${toggleKey} to show all, or Tab to view all.`;
+                }
+            }
+            else if (this.showCwd) {
                 // "All" scope - no sessions anywhere that match filter
-                lines.push(theme.fg("muted", truncateToWidth("  No sessions found", width, "…")));
+                emptyMessage = "  No sessions found";
             }
             else {
                 // "Current folder" scope - hint to try "all"
-                lines.push(theme.fg("muted", truncateToWidth("  No sessions in current folder. Press Tab to view all.", width, "…")));
+                emptyMessage = "  No sessions in current folder. Press Tab to view all.";
             }
+            lines.push(theme.fg("muted", truncateToWidth(emptyMessage, width, "…")));
             return lines;
         }
         // Calculate visible range with scrolling
         const startIndex = Math.max(0, Math.min(this.selectedIndex - Math.floor(this.maxVisible / 2), this.filteredSessions.length - this.maxVisible));
         const endIndex = Math.min(startIndex + this.maxVisible, this.filteredSessions.length);
-        // Render visible sessions (message + metadata + optional path + blank line)
+        // Render visible sessions (one line each with tree structure)
         for (let i = startIndex; i < endIndex; i++) {
-            const session = this.filteredSessions[i];
+            const node = this.filteredSessions[i];
+            const session = node.session;
             const isSelected = i === this.selectedIndex;
             const isConfirmingDelete = session.path === this.confirmingDeletePath;
-            // Use session name if set, otherwise first message
+            const isCurrent = this.currentSessionFilePath === session.path;
+            // Build tree prefix
+            const prefix = this.buildTreePrefix(node);
+            // Session display text (name or first message)
             const hasName = !!session.name;
             const displayText = session.name ?? session.firstMessage;
             const normalizedMessage = displayText.replace(/\n/g, " ").trim();
-            // First line: cursor + message (truncate to visible width)
-            // Use warning color for custom names to distinguish from first message
+            // Right side: message count and age
+            const age = formatSessionDate(session.modified);
+            const msgCount = String(session.messageCount);
+            let rightPart = `${msgCount} ${age}`;
+            if (this.showCwd && session.cwd) {
+                rightPart = `${shortenPath(session.cwd)} ${rightPart}`;
+            }
+            if (this.showPath) {
+                rightPart = `${shortenPath(session.path)} ${rightPart}`;
+            }
+            // Cursor
             const cursor = isSelected ? theme.fg("accent", "› ") : "  ";
-            const maxMsgWidth = width - 2; // Account for cursor (2 visible chars)
-            const truncatedMsg = truncateToWidth(normalizedMessage, maxMsgWidth, "...");
+            // Calculate available width for message
+            const prefixWidth = visibleWidth(prefix);
+            const rightWidth = visibleWidth(rightPart) + 2; // +2 for spacing
+            const availableForMsg = width - 2 - prefixWidth - rightWidth; // -2 for cursor
+            const truncatedMsg = truncateToWidth(normalizedMessage, Math.max(10, availableForMsg), "…");
+            // Style message
             let messageColor = null;
             if (isConfirmingDelete) {
                 messageColor = "error";
             }
+            else if (isCurrent) {
+                messageColor = "accent";
+            }
             else if (hasName) {
                 messageColor = "warning";
             }
@@ -270,27 +389,16 @@ class SessionList {
             if (isSelected) {
                 styledMsg = theme.bold(styledMsg);
             }
-            const messageLine = cursor + styledMsg;
-            // Second line: metadata (dimmed) - also truncate for safety
-            const modified = formatSessionDate(session.modified);
-            const msgCount = `${session.messageCount} message${session.messageCount !== 1 ? "s" : ""}`;
-            const metadataParts = [modified, msgCount];
-            if (this.showCwd && session.cwd) {
-                metadataParts.push(shortenPath(session.cwd));
-            }
-            const metadata = `  ${metadataParts.join(" · ")}`;
-            const truncatedMetadata = truncateToWidth(metadata, width, "");
-            const metadataLine = theme.fg(isConfirmingDelete ? "error" : "dim", truncatedMetadata);
-            lines.push(messageLine);
-            lines.push(metadataLine);
-            // Optional third line: file path (when showPath is enabled)
-            if (this.showPath) {
-                const pathText = `  ${shortenPath(session.path)}`;
-                const truncatedPath = truncateToWidth(pathText, width, "…");
-                const pathLine = theme.fg(isConfirmingDelete ? "error" : "muted", truncatedPath);
-                lines.push(pathLine);
+            // Build line
+            const leftPart = cursor + theme.fg("dim", prefix) + styledMsg;
+            const leftWidth = visibleWidth(leftPart);
+            const spacing = Math.max(1, width - leftWidth - visibleWidth(rightPart));
+            const styledRight = theme.fg(isConfirmingDelete ? "error" : "dim", rightPart);
+            let line = leftPart + " ".repeat(spacing) + styledRight;
+            if (isSelected) {
+                line = theme.bg("selectedBg", line);
             }
-            lines.push(""); // Blank line between sessions
+            lines.push(truncateToWidth(line, width));
         }
         // Add scroll indicator if needed
         if (startIndex > 0 || endIndex < this.filteredSessions.length) {
@@ -300,6 +408,14 @@ class SessionList {
         }
         return lines;
     }
+    buildTreePrefix(node) {
+        if (node.depth === 0) {
+            return "";
+        }
+        const parts = node.ancestorContinues.map((continues) => (continues ? "│  " : "   "));
+        const branch = node.isLast ? "└─ " : "├─ ";
+        return parts.join("") + branch;
+    }
     handleInput(keyData) {
         const kb = getEditorKeybindings();
         // Handle delete confirmation state first - intercept all keys
@@ -328,6 +444,10 @@ class SessionList {
             this.onToggleSort?.();
             return;
         }
+        if (this.keybindings.matches(keyData, "toggleSessionNamedFilter")) {
+            this.onToggleNameFilter?.();
+            return;
+        }
         // Ctrl+P: toggle path display
         if (kb.matches(keyData, "toggleSessionPath")) {
             this.showPath = !this.showPath;
@@ -343,7 +463,7 @@ class SessionList {
         if (matchesKey(keyData, "ctrl+r")) {
             const selected = this.filteredSessions[this.selectedIndex];
             if (selected) {
-                this.onRenameSession?.(selected.path);
+                this.onRenameSession?.(selected.session.path);
             }
             return;
         }
@@ -378,7 +498,7 @@ class SessionList {
         else if (kb.matches(keyData, "selectConfirm")) {
             const selected = this.filteredSessions[this.selectedIndex];
             if (selected && this.onSelect) {
-                this.onSelect(selected.path);
+                this.onSelect(selected.session.path);
             }
         }
         // Escape - cancel
@@ -449,8 +569,10 @@ export class SessionSelectorComponent extends Container {
     canRename = true;
     sessionList;
     header;
+    keybindings;
     scope = "current";
-    sortMode = "relevance";
+    sortMode = "threaded";
+    nameFilter = "all";
     currentSessions = null;
     allSessions = null;
     currentSessionsLoader;
@@ -492,17 +614,18 @@ export class SessionSelectorComponent extends Container {
     }
     constructor(currentSessionsLoader, allSessionsLoader, onSelect, onCancel, onExit, requestRender, options, currentSessionFilePath) {
         super();
+        this.keybindings = options?.keybindings ?? KeybindingsManager.create();
         this.currentSessionsLoader = currentSessionsLoader;
         this.allSessionsLoader = allSessionsLoader;
         this.onCancel = onCancel;
         this.requestRender = requestRender;
-        this.header = new SessionSelectorHeader(this.scope, this.sortMode, this.requestRender);
+        this.header = new SessionSelectorHeader(this.scope, this.sortMode, this.nameFilter, this.keybindings, this.requestRender);
         const renameSession = options?.renameSession;
         this.renameSession = renameSession;
         this.canRename = !!renameSession;
         this.header.setShowRenameHint(options?.showRenameHint ?? this.canRename);
         // Create session list (starts empty, will be populated after load)
-        this.sessionList = new SessionList([], false, this.sortMode, currentSessionFilePath);
+        this.sessionList = new SessionList([], false, this.sortMode, this.nameFilter, this.keybindings, currentSessionFilePath);
         this.buildBaseLayout(this.sessionList);
         this.renameInput.onSubmit = (value) => {
             void this.confirmRename(value);
@@ -523,6 +646,7 @@ export class SessionSelectorComponent extends Container {
         };
         this.sessionList.onToggleScope = () => this.toggleScope();
         this.sessionList.onToggleSort = () => this.toggleSortMode();
+        this.sessionList.onToggleNameFilter = () => this.toggleNameFilter();
         this.sessionList.onRenameSession = (sessionPath) => {
             if (!renameSession)
                 return;
@@ -684,11 +808,18 @@ export class SessionSelectorComponent extends Container {
         }
     }
     toggleSortMode() {
-        this.sortMode = this.sortMode === "recent" ? "relevance" : "recent";
+        // Cycle: threaded -> recent -> relevance -> threaded
+        this.sortMode = this.sortMode === "threaded" ? "recent" : this.sortMode === "recent" ? "relevance" : "threaded";
         this.header.setSortMode(this.sortMode);
         this.sessionList.setSortMode(this.sortMode);
         this.requestRender();
     }
+    toggleNameFilter() {
+        this.nameFilter = this.nameFilter === "all" ? "named" : "all";
+        this.header.setNameFilter(this.nameFilter);
+        this.sessionList.setNameFilter(this.nameFilter);
+        this.requestRender();
+    }
     async refreshSessionsAfterMutation() {
         await this.loadScope(this.scope, "refresh");
     }