@mariozechner/pi-coding-agent 0.49.2 → 0.50.0

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

@@ -2,10 +2,10 @@ import { spawnSync } from "node:child_process";
 import { existsSync } from "node:fs";
 import { unlink } from "node:fs/promises";
 import * as os from "node:os";
-import { Container, getEditorKeybindings, Input, matchesKey, Spacer, truncateToWidth, visibleWidth, } from "@mariozechner/pi-tui";
+import { Container, getEditorKeybindings, Input, matchesKey, Spacer, Text, truncateToWidth, visibleWidth, } from "@mariozechner/pi-tui";
 import { theme } from "../theme/theme.js";
 import { DynamicBorder } from "./dynamic-border.js";
-import { keyHint, rawKeyHint } from "./keybinding-hints.js";
+import { keyHint } from "./keybinding-hints.js";
 import { filterAndSortSessions } from "./session-selector-search.js";
 function shortenPath(path) {
     const home = os.homedir();
@@ -44,6 +44,7 @@ class SessionSelectorHeader {
     confirmingDeletePath = null;
     statusMessage = null;
     statusTimeout = null;
+    showRenameHint = false;
     constructor(scope, sortMode, requestRender) {
         this.scope = scope;
         this.sortMode = sortMode;
@@ -66,6 +67,9 @@ class SessionSelectorHeader {
     setShowPath(showPath) {
         this.showPath = showPath;
     }
+    setShowRenameHint(show) {
+        this.showRenameHint = show;
+    }
     setConfirmingDeletePath(path) {
         this.confirmingDeletePath = path;
     }
@@ -124,11 +128,15 @@ class SessionSelectorHeader {
             const pathState = this.showPath ? "(on)" : "(off)";
             const sep = theme.fg("muted", " · ");
             const hint1 = keyHint("tab", "scope") + sep + theme.fg("muted", 're:<pattern> regex · "phrase" exact');
-            const hint2 = rawKeyHint("ctrl+r", "sort") +
-                sep +
-                rawKeyHint("ctrl+d", "delete") +
-                sep +
-                rawKeyHint("ctrl+p", `path ${pathState}`);
+            const hint2Parts = [
+                keyHint("toggleSessionSort", "sort"),
+                keyHint("deleteSession", "delete"),
+                keyHint("toggleSessionPath", `path ${pathState}`),
+            ];
+            if (this.showRenameHint) {
+                hint2Parts.push(keyHint("renameSession", "rename"));
+            }
+            const hint2 = hint2Parts.join(sep);
             hintLine1 = truncateToWidth(hint1, width, "…");
             hintLine2 = truncateToWidth(hint2, width, "…");
         }
@@ -139,6 +147,10 @@ class SessionSelectorHeader {
  * Custom session list component with multi-line items and search
  */
 class SessionList {
+    getSelectedSessionPath() {
+        const selected = this.filteredSessions[this.selectedIndex];
+        return selected?.path;
+    }
     allSessions = [];
     filteredSessions = [];
     selectedIndex = 0;
@@ -156,6 +168,7 @@ class SessionList {
     onTogglePath;
     onDeleteConfirmationChange;
     onDeleteSession;
+    onRenameSession;
     onError;
     maxVisible = 5; // Max sessions visible (each session: message + metadata + optional path + blank)
     // Focusable implementation - propagate to searchInput for IME cursor positioning
@@ -311,24 +324,32 @@ class SessionList {
             }
             return;
         }
-        if (matchesKey(keyData, "ctrl+r")) {
+        if (kb.matches(keyData, "toggleSessionSort")) {
             this.onToggleSort?.();
             return;
         }
         // Ctrl+P: toggle path display
-        if (matchesKey(keyData, "ctrl+p")) {
+        if (kb.matches(keyData, "toggleSessionPath")) {
             this.showPath = !this.showPath;
             this.onTogglePath?.(this.showPath);
             return;
         }
         // Ctrl+D: initiate delete confirmation (useful on terminals that don't distinguish Ctrl+Backspace from Backspace)
-        if (matchesKey(keyData, "ctrl+d")) {
+        if (kb.matches(keyData, "deleteSession")) {
             this.startDeleteConfirmationForSelectedSession();
             return;
         }
+        // Ctrl+R: rename selected session
+        if (matchesKey(keyData, "ctrl+r")) {
+            const selected = this.filteredSessions[this.selectedIndex];
+            if (selected) {
+                this.onRenameSession?.(selected.path);
+            }
+            return;
+        }
         // Ctrl+Backspace: non-invasive convenience alias for delete
         // Only triggers deletion when the query is empty; otherwise it is forwarded to the input
-        if (matchesKey(keyData, "ctrl+backspace")) {
+        if (kb.matches(keyData, "deleteSessionNoninvasive")) {
             if (this.searchInput.getValue().length > 0) {
                 this.searchInput.handleInput(keyData);
                 this.filterSessions(this.searchInput.getValue());
@@ -413,6 +434,19 @@ async function deleteSessionFile(sessionPath) {
  * Component that renders a session selector
  */
 export class SessionSelectorComponent extends Container {
+    handleInput(data) {
+        if (this.mode === "rename") {
+            const kb = getEditorKeybindings();
+            if (kb.matches(data, "selectCancel") || matchesKey(data, "ctrl+c")) {
+                this.exitRenameMode();
+                return;
+            }
+            this.renameInput.handleInput(data);
+            return;
+        }
+        this.sessionList.handleInput(data);
+    }
+    canRename = true;
     sessionList;
     header;
     scope = "current";
@@ -423,9 +457,13 @@ export class SessionSelectorComponent extends Container {
     allSessionsLoader;
     onCancel;
     requestRender;
+    renameSession;
     currentLoading = false;
     allLoading = false;
     allLoadSeq = 0;
+    mode = "list";
+    renameInput = new Input();
+    renameTargetPath = null;
     // Focusable implementation - propagate to sessionList for IME cursor positioning
     _focused = false;
     get focused() {
@@ -434,22 +472,41 @@ export class SessionSelectorComponent extends Container {
     set focused(value) {
         this._focused = value;
         this.sessionList.focused = value;
+        this.renameInput.focused = value;
+        if (value && this.mode === "rename") {
+            this.renameInput.focused = true;
+        }
     }
-    constructor(currentSessionsLoader, allSessionsLoader, onSelect, onCancel, onExit, requestRender, currentSessionFilePath) {
+    buildBaseLayout(content, options) {
+        this.clear();
+        this.addChild(new Spacer(1));
+        this.addChild(new DynamicBorder((s) => theme.fg("accent", s)));
+        this.addChild(new Spacer(1));
+        if (options?.showHeader ?? true) {
+            this.addChild(this.header);
+            this.addChild(new Spacer(1));
+        }
+        this.addChild(content);
+        this.addChild(new Spacer(1));
+        this.addChild(new DynamicBorder((s) => theme.fg("accent", s)));
+    }
+    constructor(currentSessionsLoader, allSessionsLoader, onSelect, onCancel, onExit, requestRender, options, currentSessionFilePath) {
         super();
         this.currentSessionsLoader = currentSessionsLoader;
         this.allSessionsLoader = allSessionsLoader;
         this.onCancel = onCancel;
         this.requestRender = requestRender;
         this.header = new SessionSelectorHeader(this.scope, this.sortMode, this.requestRender);
-        // Add header
-        this.addChild(new Spacer(1));
-        this.addChild(new DynamicBorder());
-        this.addChild(new Spacer(1));
-        this.addChild(this.header);
-        this.addChild(new Spacer(1));
+        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.buildBaseLayout(this.sessionList);
+        this.renameInput.onSubmit = (value) => {
+            void this.confirmRename(value);
+        };
         // Ensure header status timeouts are cleared when leaving the selector
         const clearStatusMessage = () => this.header.setStatusMessage(null);
         this.sessionList.onSelect = (sessionPath) => {
@@ -466,6 +523,17 @@ export class SessionSelectorComponent extends Container {
         };
         this.sessionList.onToggleScope = () => this.toggleScope();
         this.sessionList.onToggleSort = () => this.toggleSortMode();
+        this.sessionList.onRenameSession = (sessionPath) => {
+            if (!renameSession)
+                return;
+            if (this.scope === "current" && this.currentLoading)
+                return;
+            if (this.scope === "all" && this.allLoading)
+                return;
+            const sessions = this.scope === "all" ? (this.allSessions ?? []) : (this.currentSessions ?? []);
+            const session = sessions.find((s) => s.path === sessionPath);
+            this.enterRenameMode(sessionPath, session?.name);
+        };
         // Sync list events to header
         this.sessionList.onTogglePath = (showPath) => {
             this.header.setShowPath(showPath);
@@ -494,6 +562,7 @@ export class SessionSelectorComponent extends Container {
                 this.sessionList.setSessions(sessions, showCwd);
                 const msg = result.method === "trash" ? "Session moved to trash" : "Session deleted";
                 this.header.setStatusMessage({ type: "info", message: msg }, 2000);
+                await this.refreshSessionsAfterMutation();
             }
             else {
                 const errorMessage = result.error ?? "Unknown error";
@@ -501,43 +570,118 @@ export class SessionSelectorComponent extends Container {
             }
             this.requestRender();
         };
-        this.addChild(this.sessionList);
-        // Add bottom border
-        this.addChild(new Spacer(1));
-        this.addChild(new DynamicBorder());
         // Start loading current sessions immediately
         this.loadCurrentSessions();
     }
     loadCurrentSessions() {
-        this.currentLoading = true;
-        this.header.setScope("current");
+        void this.loadScope("current", "initial");
+    }
+    enterRenameMode(sessionPath, currentName) {
+        this.mode = "rename";
+        this.renameTargetPath = sessionPath;
+        this.renameInput.setValue(currentName ?? "");
+        this.renameInput.focused = true;
+        const panel = new Container();
+        panel.addChild(new Text(theme.bold("Rename Session"), 1, 0));
+        panel.addChild(new Spacer(1));
+        panel.addChild(this.renameInput);
+        panel.addChild(new Spacer(1));
+        panel.addChild(new Text(theme.fg("muted", "Enter to save · Esc/Ctrl+C to cancel"), 1, 0));
+        this.buildBaseLayout(panel, { showHeader: false });
+        this.requestRender();
+    }
+    exitRenameMode() {
+        this.mode = "list";
+        this.renameTargetPath = null;
+        this.buildBaseLayout(this.sessionList);
+        this.requestRender();
+    }
+    async confirmRename(value) {
+        const next = value.trim();
+        if (!next)
+            return;
+        const target = this.renameTargetPath;
+        if (!target) {
+            this.exitRenameMode();
+            return;
+        }
+        // Find current name for callback
+        const renameSession = this.renameSession;
+        if (!renameSession) {
+            this.exitRenameMode();
+            return;
+        }
+        try {
+            await renameSession(target, next);
+            await this.refreshSessionsAfterMutation();
+        }
+        finally {
+            this.exitRenameMode();
+        }
+    }
+    async loadScope(scope, reason) {
+        const showCwd = scope === "all";
+        // Mark loading
+        if (scope === "current") {
+            this.currentLoading = true;
+        }
+        else {
+            this.allLoading = true;
+        }
+        const seq = scope === "all" ? ++this.allLoadSeq : undefined;
+        this.header.setScope(scope);
         this.header.setLoading(true);
         this.requestRender();
-        this.currentSessionsLoader((loaded, total) => {
-            if (this.scope !== "current")
+        const onProgress = (loaded, total) => {
+            if (scope !== this.scope)
+                return;
+            if (seq !== undefined && seq !== this.allLoadSeq)
                 return;
             this.header.setProgress(loaded, total);
             this.requestRender();
-        })
-            .then((sessions) => {
-            this.currentSessions = sessions;
-            this.currentLoading = false;
-            if (this.scope !== "current")
+        };
+        try {
+            const sessions = await (scope === "current"
+                ? this.currentSessionsLoader(onProgress)
+                : this.allSessionsLoader(onProgress));
+            if (scope === "current") {
+                this.currentSessions = sessions;
+                this.currentLoading = false;
+            }
+            else {
+                this.allSessions = sessions;
+                this.allLoading = false;
+            }
+            if (scope !== this.scope)
+                return;
+            if (seq !== undefined && seq !== this.allLoadSeq)
                 return;
             this.header.setLoading(false);
-            this.sessionList.setSessions(sessions, false);
+            this.sessionList.setSessions(sessions, showCwd);
             this.requestRender();
-        })
-            .catch((error) => {
-            this.currentLoading = false;
-            const message = error instanceof Error ? error.message : String(error);
-            if (this.scope !== "current")
+            if (scope === "all" && sessions.length === 0 && (this.currentSessions?.length ?? 0) === 0) {
+                this.onCancel();
+            }
+        }
+        catch (err) {
+            if (scope === "current") {
+                this.currentLoading = false;
+            }
+            else {
+                this.allLoading = false;
+            }
+            if (scope !== this.scope)
                 return;
+            if (seq !== undefined && seq !== this.allLoadSeq)
+                return;
+            const message = err instanceof Error ? err.message : String(err);
             this.header.setLoading(false);
             this.header.setStatusMessage({ type: "error", message: `Failed to load sessions: ${message}` }, 4000);
-            this.sessionList.setSessions([], false);
+            if (reason === "initial") {
+                this.sessionList.setSessions([], showCwd);
+            }
             this.requestRender();
-        });
+        }
     }
     toggleSortMode() {
         this.sortMode = this.sortMode === "recent" ? "relevance" : "recent";
@@ -545,6 +689,9 @@ export class SessionSelectorComponent extends Container {
         this.sessionList.setSortMode(this.sortMode);
         this.requestRender();
     }
+    async refreshSessionsAfterMutation() {
+        await this.loadScope(this.scope, "refresh");
+    }
     toggleScope() {
         if (this.scope === "current") {
             this.scope = "all";
@@ -555,55 +702,16 @@ export class SessionSelectorComponent extends Container {
                 this.requestRender();
                 return;
             }
-            this.header.setLoading(true);
-            this.sessionList.setSessions([], true);
-            this.requestRender();
-            if (this.allLoading)
-                return;
-            this.allLoading = true;
-            const seq = ++this.allLoadSeq;
-            this.allSessionsLoader((loaded, total) => {
-                if (seq !== this.allLoadSeq)
-                    return;
-                if (this.scope !== "all")
-                    return;
-                this.header.setProgress(loaded, total);
-                this.requestRender();
-            })
-                .then((sessions) => {
-                this.allSessions = sessions;
-                this.allLoading = false;
-                if (seq !== this.allLoadSeq)
-                    return;
-                if (this.scope !== "all")
-                    return;
-                this.header.setLoading(false);
-                this.sessionList.setSessions(sessions, true);
-                this.requestRender();
-                if (sessions.length === 0 && (this.currentSessions?.length ?? 0) === 0) {
-                    this.onCancel();
-                }
-            })
-                .catch((error) => {
-                this.allLoading = false;
-                const message = error instanceof Error ? error.message : String(error);
-                if (seq !== this.allLoadSeq)
-                    return;
-                if (this.scope !== "all")
-                    return;
-                this.header.setLoading(false);
-                this.header.setStatusMessage({ type: "error", message: `Failed to load sessions: ${message}` }, 4000);
-                this.sessionList.setSessions([], true);
-                this.requestRender();
-            });
-        }
-        else {
-            this.scope = "current";
-            this.header.setScope(this.scope);
-            this.header.setLoading(this.currentLoading);
-            this.sessionList.setSessions(this.currentSessions ?? [], false);
-            this.requestRender();
+            if (!this.allLoading) {
+                void this.loadScope("all", "toggle");
+            }
+            return;
         }
+        this.scope = "current";
+        this.header.setScope(this.scope);
+        this.header.setLoading(this.currentLoading);
+        this.sessionList.setSessions(this.currentSessions ?? [], false);
+        this.requestRender();
     }
     getSessionList() {
         return this.sessionList;