@codex-infinity/pi-infinity 0.52.4 → 0.60.2

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

@@ -13,13 +13,17 @@ class TreeList {
     toolCallMap = new Map();
     multipleRoots = false;
     activePathIds = new Set();
+    visibleParentMap = new Map();
+    visibleChildrenMap = new Map();
     lastSelectedId = null;
+    foldedNodes = new Set();
     onSelect;
     onCancel;
     onLabelEdit;
-    constructor(tree, currentLeafId, maxVisibleLines, initialSelectedId) {
+    constructor(tree, currentLeafId, maxVisibleLines, initialSelectedId, initialFilterMode) {
         this.currentLeafId = currentLeafId;
         this.maxVisibleLines = maxVisibleLines;
+        this.filterMode = initialFilterMode ?? "default";
         this.multipleRoots = tree.length > 1;
         this.flatNodes = this.flattenTree(tree);
         this.buildActivePath();
@@ -217,7 +221,8 @@ class TreeList {
             const isSettingsEntry = entry.type === "label" ||
                 entry.type === "custom" ||
                 entry.type === "model_change" ||
-                entry.type === "thinking_level_change";
+                entry.type === "thinking_level_change" ||
+                entry.type === "session_info";
             switch (this.filterMode) {
                 case "user-only":
                     // Just user messages
@@ -249,6 +254,17 @@ class TreeList {
             }
             return true;
         });
+        // Filter out descendants of folded nodes.
+        if (this.foldedNodes.size > 0) {
+            const skipSet = new Set();
+            for (const flatNode of this.flatNodes) {
+                const { id, parentId } = flatNode.node.entry;
+                if (parentId != null && (this.foldedNodes.has(parentId) || skipSet.has(parentId))) {
+                    skipSet.add(id);
+                }
+            }
+            this.filteredNodes = this.filteredNodes.filter((flatNode) => !skipSet.has(flatNode.node.entry.id));
+        }
         // Recalculate visual structure (indent, connectors, gutters) based on visible tree
         this.recalculateVisualStructure();
         // Try to preserve cursor on the same node, or find nearest visible ancestor
@@ -373,6 +389,9 @@ class TreeList {
                 ]);
             }
         }
+        // Store visible tree maps for ancestor/descendant lookups in navigation
+        this.visibleParentMap = visibleParent;
+        this.visibleChildrenMap = visibleChildren;
     }
     /** Get searchable text content from a node */
     getSearchableText(node) {
@@ -411,6 +430,11 @@ class TreeList {
             case "branch_summary":
                 parts.push("branch summary", entry.summary);
                 break;
+            case "session_info":
+                parts.push("title");
+                if (entry.name)
+                    parts.push(entry.name);
+                break;
             case "model_change":
                 parts.push("model", entry.modelId);
                 break;
@@ -479,6 +503,7 @@ class TreeList {
             // Build prefix char by char, placing gutters and connector at their positions
             const totalChars = displayIndent * 3;
             const prefixChars = [];
+            const isFolded = this.foldedNodes.has(entry.id);
             for (let i = 0; i < totalChars; i++) {
                 const level = Math.floor(i / 3);
                 const posInLevel = i % 3;
@@ -493,12 +518,13 @@ class TreeList {
                     }
                 }
                 else if (connector && level === connectorPosition) {
-                    // Connector at this level
+                    // Connector at this level, with fold indicator
                     if (posInLevel === 0) {
                         prefixChars.push(flatNode.isLast ? "└" : "├");
                     }
                     else if (posInLevel === 1) {
-                        prefixChars.push("─");
+                        const foldable = this.isFoldable(entry.id);
+                        prefixChars.push(isFolded ? "⊞" : foldable ? "⊟" : "─");
                     }
                     else {
                         prefixChars.push(" ");
@@ -509,12 +535,15 @@ class TreeList {
                 }
             }
             const prefix = prefixChars.join("");
+            // Fold marker for nodes without connectors (roots)
+            const showsFoldInConnector = flatNode.showConnector && !flatNode.isVirtualRootChild;
+            const foldMarker = isFolded && !showsFoldInConnector ? theme.fg("accent", "⊞ ") : "";
             // Active path marker - shown right before the entry text
             const isOnActivePath = this.activePathIds.has(entry.id);
             const pathMarker = isOnActivePath ? theme.fg("accent", "• ") : "";
             const label = flatNode.node.label ? theme.fg("warning", `[${flatNode.node.label}] `) : "";
             const content = this.getEntryDisplayText(flatNode.node, isSelected);
-            let line = cursor + theme.fg("dim", prefix) + pathMarker + label + content;
+            let line = cursor + theme.fg("dim", prefix) + foldMarker + pathMarker + label + content;
             if (isSelected) {
                 line = theme.bg("selectedBg", line);
             }
@@ -602,6 +631,11 @@ class TreeList {
             case "label":
                 result = theme.fg("dim", `[label: ${entry.label ?? "(cleared)"}]`);
                 break;
+            case "session_info":
+                result = entry.name
+                    ? [theme.fg("dim", "[title: "), theme.fg("dim", entry.name), theme.fg("dim", "]")].join("")
+                    : [theme.fg("dim", "[title: "), theme.italic(theme.fg("dim", "empty")), theme.fg("dim", "]")].join("");
+                break;
             default:
                 result = "";
         }
@@ -703,11 +737,31 @@ class TreeList {
         else if (kb.matches(keyData, "selectDown")) {
             this.selectedIndex = this.selectedIndex === this.filteredNodes.length - 1 ? 0 : this.selectedIndex + 1;
         }
-        else if (kb.matches(keyData, "cursorLeft")) {
+        else if (kb.matches(keyData, "treeFoldOrUp")) {
+            const currentId = this.filteredNodes[this.selectedIndex]?.node.entry.id;
+            if (currentId && this.isFoldable(currentId) && !this.foldedNodes.has(currentId)) {
+                this.foldedNodes.add(currentId);
+                this.applyFilter();
+            }
+            else {
+                this.selectedIndex = this.findBranchSegmentStart("up");
+            }
+        }
+        else if (kb.matches(keyData, "treeUnfoldOrDown")) {
+            const currentId = this.filteredNodes[this.selectedIndex]?.node.entry.id;
+            if (currentId && this.foldedNodes.has(currentId)) {
+                this.foldedNodes.delete(currentId);
+                this.applyFilter();
+            }
+            else {
+                this.selectedIndex = this.findBranchSegmentStart("down");
+            }
+        }
+        else if (kb.matches(keyData, "cursorLeft") || kb.matches(keyData, "selectPageUp")) {
             // Page up
             this.selectedIndex = Math.max(0, this.selectedIndex - this.maxVisibleLines);
         }
-        else if (kb.matches(keyData, "cursorRight")) {
+        else if (kb.matches(keyData, "cursorRight") || kb.matches(keyData, "selectPageDown")) {
             // Page down
             this.selectedIndex = Math.min(this.filteredNodes.length - 1, this.selectedIndex + this.maxVisibleLines);
         }
@@ -720,6 +774,7 @@ class TreeList {
         else if (kb.matches(keyData, "selectCancel")) {
             if (this.searchQuery) {
                 this.searchQuery = "";
+                this.foldedNodes.clear();
                 this.applyFilter();
             }
             else {
@@ -729,26 +784,31 @@ class TreeList {
         else if (matchesKey(keyData, "ctrl+d")) {
             // Direct filter: default
             this.filterMode = "default";
+            this.foldedNodes.clear();
             this.applyFilter();
         }
         else if (matchesKey(keyData, "ctrl+t")) {
             // Toggle filter: no-tools ↔ default
             this.filterMode = this.filterMode === "no-tools" ? "default" : "no-tools";
+            this.foldedNodes.clear();
             this.applyFilter();
         }
         else if (matchesKey(keyData, "ctrl+u")) {
             // Toggle filter: user-only ↔ default
             this.filterMode = this.filterMode === "user-only" ? "default" : "user-only";
+            this.foldedNodes.clear();
             this.applyFilter();
         }
         else if (matchesKey(keyData, "ctrl+l")) {
             // Toggle filter: labeled-only ↔ default
             this.filterMode = this.filterMode === "labeled-only" ? "default" : "labeled-only";
+            this.foldedNodes.clear();
             this.applyFilter();
         }
         else if (matchesKey(keyData, "ctrl+a")) {
             // Toggle filter: all ↔ default
             this.filterMode = this.filterMode === "all" ? "default" : "all";
+            this.foldedNodes.clear();
             this.applyFilter();
         }
         else if (matchesKey(keyData, "shift+ctrl+o")) {
@@ -756,6 +816,7 @@ class TreeList {
             const modes = ["default", "no-tools", "user-only", "labeled-only", "all"];
             const currentIndex = modes.indexOf(this.filterMode);
             this.filterMode = modes[(currentIndex - 1 + modes.length) % modes.length];
+            this.foldedNodes.clear();
             this.applyFilter();
         }
         else if (matchesKey(keyData, "ctrl+o")) {
@@ -763,11 +824,13 @@ class TreeList {
             const modes = ["default", "no-tools", "user-only", "labeled-only", "all"];
             const currentIndex = modes.indexOf(this.filterMode);
             this.filterMode = modes[(currentIndex + 1) % modes.length];
+            this.foldedNodes.clear();
             this.applyFilter();
         }
         else if (kb.matches(keyData, "deleteCharBackward")) {
             if (this.searchQuery.length > 0) {
                 this.searchQuery = this.searchQuery.slice(0, -1);
+                this.foldedNodes.clear();
                 this.applyFilter();
             }
         }
@@ -784,10 +847,64 @@ class TreeList {
             });
             if (!hasControlChars && keyData.length > 0) {
                 this.searchQuery += keyData;
+                this.foldedNodes.clear();
                 this.applyFilter();
             }
         }
     }
+    /**
+     * Whether a node can be folded. A node is foldable if it has visible children
+     * and is either a root (no visible parent) or a segment start (visible parent
+     * has multiple visible children).
+     */
+    isFoldable(entryId) {
+        const children = this.visibleChildrenMap.get(entryId);
+        if (!children || children.length === 0)
+            return false;
+        const parentId = this.visibleParentMap.get(entryId);
+        if (parentId === null || parentId === undefined)
+            return true;
+        const siblings = this.visibleChildrenMap.get(parentId);
+        return siblings !== undefined && siblings.length > 1;
+    }
+    /**
+     * Find the index of the next branch segment start in the given direction.
+     * A segment start is the first child of a branch point.
+     *
+     * "up" walks the visible parent chain; "down" walks visible children
+     * (always following the first child).
+     */
+    findBranchSegmentStart(direction) {
+        const selectedId = this.filteredNodes[this.selectedIndex]?.node.entry.id;
+        if (!selectedId)
+            return this.selectedIndex;
+        const indexByEntryId = new Map(this.filteredNodes.map((node, i) => [node.node.entry.id, i]));
+        let currentId = selectedId;
+        if (direction === "down") {
+            while (true) {
+                const children = this.visibleChildrenMap.get(currentId) ?? [];
+                if (children.length === 0)
+                    return indexByEntryId.get(currentId);
+                if (children.length > 1)
+                    return indexByEntryId.get(children[0]);
+                currentId = children[0];
+            }
+        }
+        // direction === "up"
+        while (true) {
+            const parentId = this.visibleParentMap.get(currentId) ?? null;
+            if (parentId === null)
+                return indexByEntryId.get(currentId);
+            const children = this.visibleChildrenMap.get(parentId) ?? [];
+            if (children.length > 1) {
+                const segmentStart = indexByEntryId.get(currentId);
+                if (segmentStart < this.selectedIndex) {
+                    return segmentStart;
+                }
+            }
+            currentId = parentId;
+        }
+    }
 }
 /** Component that displays the current search query */
 class SearchLine {
@@ -872,11 +989,11 @@ export class TreeSelectorComponent extends Container {
             this.labelInput.focused = value;
         }
     }
-    constructor(tree, currentLeafId, terminalHeight, onSelect, onCancel, onLabelChange, initialSelectedId) {
+    constructor(tree, currentLeafId, terminalHeight, onSelect, onCancel, onLabelChange, initialSelectedId, initialFilterMode) {
         super();
         this.onLabelChangeCallback = onLabelChange;
         const maxVisibleLines = Math.max(5, Math.floor(terminalHeight / 2));
-        this.treeList = new TreeList(tree, currentLeafId, maxVisibleLines, initialSelectedId);
+        this.treeList = new TreeList(tree, currentLeafId, maxVisibleLines, initialSelectedId, initialFilterMode);
         this.treeList.onSelect = onSelect;
         this.treeList.onCancel = onCancel;
         this.treeList.onLabelEdit = (entryId, currentLabel) => this.showLabelInput(entryId, currentLabel);
@@ -886,7 +1003,7 @@ export class TreeSelectorComponent extends Container {
         this.addChild(new Spacer(1));
         this.addChild(new DynamicBorder());
         this.addChild(new Text(theme.bold("  Session Tree"), 1, 0));
-        this.addChild(new TruncatedText(theme.fg("muted", "  ↑/↓: move. ←/→: page. Shift+L: label. ") +
+        this.addChild(new TruncatedText(theme.fg("muted", "  ↑/↓: move. ←/→: page. ^←/^→ or Alt+←/Alt+→: fold/branch. Shift+L: label. ") +
             theme.fg("muted", "^D/^T/^U/^L/^A: filters (^O/⇧^O cycle)"), 0, 0));
         this.addChild(new SearchLine(this.treeList));
         this.addChild(new DynamicBorder());