@sagmans/dsh-tui 0.5.2 → 0.6.0

package/lib/index.js

@@ -8,6 +8,7 @@ import { createPromptHistory } from "./agent/prompt-history.js";
 import { createPresetRoster, parsePresetArgument } from "./agent/presets.js";
 import { createToolPresenter } from "./agent/present.js";
 import { forkPoint } from "./agent/fork.js";
+import { hiddenTail, NO_UNDO, redoStep, resetUndo, turnsOf, UNDO_TURN_SETTLE_MS, undoStep } from "./agent/undo.js";
 import { PROFILE_NAME, resumeHint } from "./identity.js";
 import { createStatusFacts } from "./agent/status.js";
 import { ModelSwitch, createModelCatalog, parseModelArgument, readModelRouteKey } from "./agent/model.js";
@@ -16,7 +17,8 @@ import { SubagentRoster, createSubagentControl, describeSubagents, parseSubagent
 import { describeMissingOptional, describeMissingRequired, probeComposition } from "./compat/probe.js";
 import { ApprovalGate, QuestionGate, toGateQuestions } from "./gates.js";
 import { cancelStep, quitStep } from "./input/cancel.js";
-import { createCompletionProvider } from "./input/completion.js";
+import { createAnswerCompletionProvider, createCompletionProvider } from "./input/completion.js";
+import { createFileIndex } from "./input/file-search.js";
 import { ghostSuffix } from "./input/ghost.js";
 import { LOCAL_COMMANDS, classifySubmission } from "./input/submission.js";
 import { createDeferredNotice } from "./settings-notice.js";
@@ -31,7 +33,7 @@ import { WarningSafeTui } from "./terminal/warning-screen.js";
 import { BELL, shouldRingBell } from "./terminal/bell.js";
 import { clipboardSequence } from "./terminal/clipboard.js";
 import { CLEAR_TITLE, windowTitle } from "./terminal/title.js";
-import { sessionStartReason } from "./herdr/state.js";
+import { driverReportFor, sessionStartReason } from "./herdr/state.js";
 import { createHerdrReporter } from "./herdr/reporter.js";
 import { defaultExportFile, transcriptToText } from "./export.js";
 import { createTheme, forwardEditorTheme, forwardMarkdownTheme } from "./theme.js";
@@ -47,6 +49,7 @@ import { SessionId } from '@deepseek-ai/dsh-session';
 import { formatTokens } from "./tokens.js";
 import { TranscriptModel } from "./transcript.js";
 import { WorkFold, describeTodos, planSelectedActive, planToggleLine, readPlanState } from "./work.js";
+import { cleanCopied } from "./ui/copy.js";
 import { WorkDock } from "./ui/dock.js";
 import { GateInputBar } from "./ui/gate-input.js";
 import { HistoryPicker } from "./ui/history-picker.js";
@@ -408,7 +411,7 @@ export function apply(ctx, config) {
     const markdown = new MarkdownRenderer(theme.markdown, createMermaidTransform({ theme, mode: () => mermaidMode }));
     const restore = createRestoreRegistry();
     const terminal = new ProcessTerminal();
-    const tui = new WarningSafeTui(terminal);
+    const tui = new WarningSafeTui(terminal, { copySelection });
     // A frame that cannot be drawn leaves the last good screen up, so the failure
     // has to reach the transcript: otherwise the surface looks frozen and nothing
     // on screen can say why.
@@ -431,6 +434,20 @@ export function apply(ctx, config) {
         if (!handedOver)
             terminal.write(text);
     };
+    /**
+     * Put a copied selection on the clipboard as the words it selected.
+     *
+     * A terminal copies the screen, so a drag across a message takes the box the
+     * message was drawn in along with it. The rows the last frame drew are the
+     * account of that frame, so the copy is read back through them: the shape the
+     * surface added comes off, and nothing the reader wrote does.
+     */
+    function copySelection(text) {
+        if (handedOver)
+            return Promise.resolve(false);
+        terminal.write(clipboardSequence(cleanCopied(text, view.copyRows())));
+        return Promise.resolve(true);
+    }
     /** The session this surface drives: commands, approvals, and the bell belong to it. */
     let activeSession = resolved.sessionId;
     /** The session the transcript is showing, which can be one of its children. */
@@ -462,6 +479,17 @@ export function apply(ctx, config) {
     });
     let agent;
     let turnOpen = false;
+    /**
+     * The staged undo cursor for the session this terminal drives.
+     *
+     * Prompts are never deleted: the cursor chooses how much of the live log the
+     * transcript shows. A cursor counts the turns of one log, so openAgent resets it.
+     */
+    let undoState = NO_UNDO;
+    /** Event index the transcript must not fold past while turns are hidden. */
+    let stagedCut;
+    /** Whether an undo is settling an interrupt, so a second press cannot race it. */
+    let undoPending = false;
     let turnStartedAt;
     let exited = false;
     /** Whether a session was really opened, which is what an exit hint can name. */
@@ -595,8 +623,9 @@ export function apply(ctx, config) {
         herdr.unblock();
         editor.disableSubmit = false;
         // The question is answered or skipped, so the reader gets their prompt back
-        // in the bar they left it in.
+        // in the bar they left it in, with the menu the prompt bar offered.
         promptBar.giveBack();
+        applyCompletion();
         tui.setFocus(editor);
         tui.requestRender();
     };
@@ -791,19 +820,42 @@ export function apply(ctx, config) {
         return undefined;
     }));
     const registry = () => ctx.get('commands');
+    /** One scan of the workspace, shared by both menus: the listing is read-only and cached. */
+    const fileIndex = createFileIndex(process.cwd());
+    /** The menu the prompt bar offers: the commands this session can run, and the workspace's files. */
+    let promptCompletion;
+    /** The menu an answer offers, which is the same menu without the commands. */
+    let answerCompletion;
+    /**
+     * Give the bar the menu its current role calls for.
+     *
+     * A question borrows the prompt bar's editor rather than drawing its own, so
+     * the provider has to follow the borrow: a slash command is a line this
+     * surface would run, and an answer is text the model reads, so the two roles
+     * must not share one menu.
+     */
+    const applyCompletion = () => {
+        const chosen = promptBar.isBorrowed() ? answerCompletion : promptCompletion;
+        if (chosen !== undefined)
+            editor.setAutocompleteProvider(chosen);
+    };
     /**
      * Offer completion for whatever this session can run right now.
      *
      * The registry is agent-scoped and still empty while the agent starts, so the
      * menu is rebuilt when the agent arrives and whenever a package registers
-     * another command.
+     * another command. Both providers are built here because the answer's is the
+     * prompt bar's own minus the commands, and a rebuild while a question is open
+     * must not leave the answer menu unreachable.
      */
     const installCompletion = () => {
         const current = agent?.agent;
         const commands = registry();
         if (current === undefined || commands === undefined)
             return;
-        editor.setAutocompleteProvider(createCompletionProvider(commands.list(current), process.cwd()));
+        answerCompletion = createAnswerCompletionProvider(process.cwd(), fileIndex);
+        promptCompletion = createCompletionProvider(commands.list(current), process.cwd(), fileIndex);
+        applyCompletion();
     };
     /**
      * Take the keyboard for a picker.
@@ -1093,12 +1145,19 @@ export function apply(ctx, config) {
      * what tells the two apart.
      */
     const foldCursor = new FoldCursor();
-    /** Feed one durable event to the model, unless a fold has already folded it. */
+    /**
+     * Fold one durable event into the view, unless a staged cursor hides it.
+     *
+     * Undo never deletes, so the log keeps the hidden suffix; this filter is the
+     * one place the transcript and the log disagree about where the session ends.
+     */
     const applyDurable = (session, event) => {
+        if (stagedCut !== undefined && session === activeSession && typeof event.seq === 'number' && event.seq >= stagedCut)
+            return;
         if (foldCursor.accept(session, event))
             applyEvent(event);
     };
-    const foldHistory = async (id) => {
+    const foldHistory = async (id, through) => {
         // Resolved before the fold so every card reads its tool through the scope
         // that actually registered it; a stored session nobody runs has none.
         presentScope = ctx.agents?.get(id);
@@ -1107,10 +1166,13 @@ export function apply(ctx, config) {
         foldCursor.reset();
         const inMemory = liveSession(id)?.snapshotEvents?.();
         if (inMemory !== undefined) {
-            for (const event of inMemory)
+            const events = through === undefined ? inMemory : inMemory.slice(0, through);
+            for (const event of events)
                 applyDurable(id, event);
-            return inMemory.length;
+            return events.length;
         }
+        // Only a live session can be staged: undo acts on the agent this terminal
+        // drives, and a stored log has no cursor to hide a suffix from.
         const history = createSessionHistory(ctx);
         if (history === undefined)
             return 0;
@@ -1167,6 +1229,192 @@ export function apply(ctx, config) {
         const history = createSessionHistory(ctx);
         return history === undefined ? [] : history.read(id);
     };
+    /** The closed turns of the session this terminal drives, newest last. */
+    const currentTurns = async () => turnsOf(await sessionEvents(activeSession));
+    /** Fold the transcript through the staged cut, or the whole log at the tip. */
+    const redrawStaged = async () => {
+        model.reset();
+        work.reset();
+        await foldHistory(activeSession, stagedCut);
+    };
+    /** Park queued prompts one per stash entry, newest first so popping replays queue order. */
+    const parkQueued = async (queued) => {
+        for (const text of [...queued].reverse())
+            await stash?.stashEditor(text);
+    };
+    /** Resolver for the turn/end an undo is waiting on, set only while waiting. */
+    let turnSettled;
+    /** Wait for the interrupted turn to close, bounded so undo can give up honestly. */
+    const waitForTurnEnd = (timeoutMs) => new Promise(resolve => {
+        const timer = setTimeout(() => {
+            turnSettled = undefined;
+            resolve(false);
+        }, timeoutMs);
+        turnSettled = () => {
+            clearTimeout(timer);
+            turnSettled = undefined;
+            resolve(true);
+        };
+    });
+    /**
+     * Stop the running turn and empty the inbox so the cut lands on a closed
+     * turn/end; queued prompts are parked first because cancelling drops them.
+     *
+     * Returns undefined when the reader's words cannot be kept: a queue with no
+     * stash to park it in, or a turn that will not close. Both leave the cursor
+     * untouched, so the transcript keeps showing what the model actually saw; a
+     * number is how many queued prompts were parked before the turn was stopped.
+     */
+    const settleForUndo = async () => {
+        const queued = queuedPrompts();
+        if (!turnOpen && queued.length === 0)
+            return 0;
+        if (queued.length > 0 && stash === undefined) {
+            model.notice('queued prompts have no stash to park in; undo cancelled');
+            tui.requestRender();
+            return undefined;
+        }
+        agent?.interrupt();
+        if (queued.length > 0)
+            await parkQueued(queued);
+        if (turnOpen && !(await waitForTurnEnd(UNDO_TURN_SETTLE_MS))) {
+            model.notice('could not stop the turn; undo cancelled');
+            tui.requestRender();
+            return undefined;
+        }
+        return queued.length;
+    };
+    const runUndoCommand = () => {
+        if (undoPending)
+            return;
+        undoPending = true;
+        void (async () => {
+            if (viewedSession !== activeSession) {
+                model.notice('undo works on the session this terminal drives · ctrl+b comes back');
+                tui.requestRender();
+                return;
+            }
+            const turns = await currentTurns();
+            if (undoState.hidden >= turns.length && !turnOpen) {
+                model.notice('nothing to undo');
+                tui.requestRender();
+                return;
+            }
+            const draft = editor.getExpandedText();
+            // Text this state itself restored is not the reader's draft, so undoing
+            // again must not park it and end up with two copies.
+            const holdsDraft = draft !== '' && draft !== undoState.lastRestored;
+            if (holdsDraft && stash === undefined) {
+                model.notice('the bar holds a draft and there is no stash to park it in; undo cancelled');
+                tui.requestRender();
+                return;
+            }
+            const parked = await settleForUndo();
+            if (parked === undefined)
+                return;
+            const settled = await currentTurns();
+            const next = undoStep(undoState, settled);
+            if (next === undefined) {
+                model.notice('nothing to undo');
+                tui.requestRender();
+                return;
+            }
+            if (holdsDraft) {
+                await stash?.stashEditor(draft);
+                model.notice('the draft in the bar was parked in the stash');
+            }
+            undoState = next;
+            stagedCut = hiddenTail(next, settled)?.seedCount;
+            await redrawStaged();
+            editor.setText(next.lastRestored);
+            // The parking count rides the undo notice: a notice of its own would be
+            // replaced before the frame could show it.
+            const parkedNote = parked === 0 ? '' : ` · ${parked} queued prompt${parked === 1 ? '' : 's'} parked in the stash`;
+            model.notice(`undo · ${next.hidden} prompt${next.hidden === 1 ? '' : 's'} hidden${parkedNote} · prefix r redo`);
+            tui.requestRender();
+        })()
+            .catch((error) => {
+            model.notice(`undo failed: ${error instanceof Error ? error.message : String(error)}`);
+            tui.requestRender();
+        })
+            .finally(() => {
+            undoPending = false;
+        });
+    };
+    const runRedoCommand = () => {
+        void (async () => {
+            if (viewedSession !== activeSession) {
+                model.notice('redo works on the session this terminal drives · ctrl+b comes back');
+                tui.requestRender();
+                return;
+            }
+            const turns = await currentTurns();
+            const before = editor.getExpandedText();
+            const restored = undoState.lastRestored;
+            const next = redoStep(undoState, turns);
+            if (next === undefined) {
+                model.notice('nothing to redo');
+                tui.requestRender();
+                return;
+            }
+            undoState = next;
+            stagedCut = hiddenTail(next, turns)?.seedCount;
+            await redrawStaged();
+            // A composer the reader edited is theirs; only text this state wrote is replaced.
+            if (before === restored)
+                editor.setText(next.lastRestored);
+            model.notice(next.hidden === 0
+                ? 'redo · back at the newest prompt'
+                : `redo · ${next.hidden} prompt${next.hidden === 1 ? '' : 's'} hidden`);
+            tui.requestRender();
+        })().catch((error) => {
+            model.notice(`redo failed: ${error instanceof Error ? error.message : String(error)}`);
+            tui.requestRender();
+        });
+    };
+    /**
+     * Send the reader's prompt, branching first when the transcript is staged.
+     *
+     * Context is derived from the log, so a send while turns are hidden has to
+     * continue in a child seeded with the visible prefix; submitting in place would
+     * show the model the prompts the reader undid. Every send passes through here so
+     * the branch has one commit point, not one per caller.
+     */
+    const commitStagedSend = async (text) => {
+        try {
+            const previous = agent;
+            if (previous === undefined) {
+                model.notice('the agent is still starting; try again in a moment');
+                tui.requestRender();
+                return;
+            }
+            if (undoState.hidden === 0) {
+                previous.submit(text);
+                return;
+            }
+            const source = activeSession;
+            const events = await sessionEvents(source);
+            const turns = turnsOf(events);
+            const tail = hiddenTail(undoState, turns);
+            const seed = tail === undefined ? [] : events.slice(0, tail.seedCount);
+            const childId = SessionId(`tui-session-${randomUUID()}`);
+            agent = undefined;
+            turnOpen = false;
+            turnStartedAt = undefined;
+            presentScope = undefined;
+            model.reset();
+            work.reset();
+            roster.reset();
+            await previous.dispose();
+            const opened = await openAgent(childId, false, seed.length === 0 ? undefined : { from: source, events: seed });
+            model.notice(`continuing in a new branch · ${source} keeps the undone turns`);
+            opened.submit(text);
+        }
+        catch (error) {
+            model.notice(`could not send: ${error instanceof Error ? error.message : String(error)}`);
+            tui.requestRender();
+        }
+    };
     /**
      * The mode one agent joins.
      *
@@ -1232,9 +1480,19 @@ export function apply(ctx, config) {
         activeSession = id;
         viewedSession = id;
         agent = handle;
+        // A cursor counts the turns of one log; the session just opened has its own.
+        undoState = resetUndo(id);
+        stagedCut = undefined;
         // The bank follows the session, so the footer stops counting the drafts of
         // the session just left and the next command reads this session's file.
         void stash?.open();
+        // agent/status is emitted on transitions only, so a driver that was
+        // already running when this surface attached — a resume that wakes
+        // straight away — would otherwise stay unreported until it stops. The
+        // status is read once here and settled before the session identity, so the
+        // report that carries the new session id states the driver's real phase
+        // rather than the one the previous session left behind.
+        herdr.driver(handle.agent.status);
         // The agent's own id is reported rather than the requested one: a resume can
         // be answered by the session the log actually holds.
         herdr.session({
@@ -1262,6 +1520,9 @@ export function apply(ctx, config) {
         installCompletion();
         model.notice(`session ${handle.sessionId}${resume ? ' (resumed)' : ''}`);
         tui.requestRender();
+        // Returned so a caller that replaced the handle can send through the new
+        // one without a fresh read of state TypeScript can no longer widen.
+        return handle;
     };
     /** Move the surface to another stored session without leaving the terminal. */
     const switchSession = async (id) => {
@@ -1271,6 +1532,9 @@ export function apply(ctx, config) {
         // during the transition can read a torn-down world.
         presentScope = undefined;
         turnOpen = false;
+        // The outgoing turn's clock dies with its agent; leaving it set would time
+        // the session being joined by work it never ran.
+        turnStartedAt = undefined;
         model.reset();
         work.reset();
         roster.reset();
@@ -1431,6 +1695,48 @@ export function apply(ctx, config) {
             tui.requestRender();
         });
     };
+    /**
+     * Compose this session's agent again without leaving the conversation.
+     *
+     * A preset's standing mount only re-reads its composition file for an agent
+     * that joins after the file changed, so an edited preset, skill, or prompt
+     * file reaches a running session only by joining anew. The durable log is
+     * replayed afterwards, so the reader keeps the conversation they were reading.
+     */
+    const runReloadCommand = () => {
+        // A failed reload leaves no agent behind, so the command has to be usable
+        // again: the retry is what makes a broken composition file recoverable,
+        // while a surface that has opened no session yet is still starting.
+        if (agent === undefined && !sessionOpened) {
+            model.notice('the agent is still starting; try again in a moment');
+            tui.requestRender();
+            return;
+        }
+        const queued = queuedPrompts();
+        // Work the reader would lose is a decision, and the interrupt key already
+        // owns that decision: it stops the turn and hands queued words back to the
+        // bar. Reopening the session drops the inbox, so a reload that would take
+        // those words asks for the key instead of asking a question of its own.
+        if (turnOpen || queued.length > 0) {
+            model.notice(queued.length > 0
+                ? `${queued.length} queued ${queued.length === 1 ? 'prompt' : 'prompts'} would be dropped — ctrl+c hands them back to the bar, then /reload`
+                : 'a turn is running — ctrl+c interrupts it first (delivered text is kept), then /reload');
+            tui.requestRender();
+            return;
+        }
+        const id = activeSession;
+        void (async () => {
+            // The same transition a session switch takes, aimed at the session
+            // already open: dispose, then join its preset generation anew.
+            await switchSession(id);
+            model.notice("reloaded this session's composition; the transcript was replayed");
+            tui.requestRender();
+        })().catch((error) => {
+            const reason = error instanceof Error ? error.message : String(error);
+            model.notice(`could not reload: ${reason} — fix the composition and /reload again`);
+            tui.requestRender();
+        });
+    };
     /** Show the todo list the agent has been keeping. */
     const runTodoCommand = () => {
         model.notice(describeTodos(work.state().todos));
@@ -1941,6 +2247,9 @@ export function apply(ctx, config) {
             case 'new':
                 runNewCommand(submission.title);
                 return;
+            case 'reload':
+                runReloadCommand();
+                return;
             case 'todo':
                 runTodoCommand();
                 return;
@@ -2084,6 +2393,12 @@ export function apply(ctx, config) {
                 work.reset();
                 tui.requestRender();
                 return;
+            case 'undo':
+                runUndoCommand();
+                return;
+            case 'redo':
+                runRedoCommand();
+                return;
             case 'help':
                 model.notice(helpText());
                 tui.requestRender();
@@ -2113,7 +2428,7 @@ export function apply(ctx, config) {
                     agent.steer(submission.text);
                 else {
                     adoptDefaultRoute();
-                    agent.submit(submission.text);
+                    void commitStagedSend(submission.text);
                 }
         }
     };
@@ -2136,14 +2451,14 @@ export function apply(ctx, config) {
                 turnOpen = true;
                 turnStartedAt = Date.now();
                 writeTerminal(windowTitle(process.cwd(), 'working'));
-                herdr.working();
             }
             if (event.type === 'turn/end') {
                 const ranFor = turnStartedAt === undefined ? 0 : Date.now() - turnStartedAt;
                 turnOpen = false;
                 turnStartedAt = undefined;
+                // An undo may be parked waiting for exactly this boundary.
+                turnSettled?.();
                 writeTerminal(windowTitle(process.cwd(), 'ready'));
-                herdr.idle();
                 if (shouldRingBell({ bell: resolved.bell, ranForMs: ranFor, exiting: exited }))
                     writeTerminal(BELL);
                 // A job the turn started may have settled while the reader was watching
@@ -2168,6 +2483,20 @@ export function apply(ctx, config) {
      * harness cannot break compilation of this surface.
      */
     const listenFor = (name, handler) => ctx.on(name, handler);
+    // Herdr hears the driver rather than each turn: a run that chains turns
+    // through a pending inbox is one stretch of work, and a turn boundary inside
+    // it would read as done between two turns of an agent that is still working.
+    // The turn listeners above keep the title and the bell, which are about the
+    // reader's own conversation.
+    disposers.push(listenFor('agent/status', payload => {
+        // Read against the driven session at delivery time: the reader can switch
+        // sessions between two transitions, and the row must follow the one this
+        // terminal now drives.
+        const status = driverReportFor(payload, activeSession);
+        if (status === undefined)
+            return;
+        herdr.driver(status);
+    }));
     disposers.push(listenFor('subagent/start', info => {
         roster.start(info);
         const record = asRecord(info);
@@ -2209,7 +2538,13 @@ export function apply(ctx, config) {
         if (questions.length === 0)
             return next();
         return new Promise(resolve => {
-            const gate = promptBar.borrow(() => new QuestionGate(questions, editor, () => keymap));
+            const gate = promptBar.borrow(() => {
+                // The bar is an answer's for as long as the gate holds it, so the menu
+                // it once offered commands through is replaced before a key can reach it.
+                const built = new QuestionGate(questions, editor, () => keymap);
+                applyCompletion();
+                return built;
+            });
             // The seam takes mutable selection arrays and an optional custom field, so
             // the read-only gate answer is copied into that exact shape here.
             const settle = (answers) => {