@phren/agent 0.1.2 → 0.1.3

package/dist/tui.js

@@ -9,6 +9,8 @@ import { handleCommand } from "./commands.js";
 import { renderMarkdown } from "./multi/markdown.js";
 import { decodeDiffPayload, renderInlineDiff, DIFF_MARKER } from "./multi/diff-renderer.js";
 import * as os from "os";
+import * as fs from "node:fs";
+import * as path from "node:path";
 import { execSync } from "node:child_process";
 import { loadInputMode, saveInputMode, savePermissionMode } from "./settings.js";
 import { createRequire } from "node:module";
@@ -144,10 +146,12 @@ export async function startTui(config, spawner) {
     const session = createSession(contextLimit);
     const w = process.stdout;
     const isTTY = process.stdout.isTTY;
+    const startTime = Date.now();
     let inputMode = loadInputMode();
     let pendingInput = null;
     let running = false;
     let inputLine = "";
+    let cursorPos = 0;
     let costStr = "";
     // ── Dual-mode state ─────────────────────────────────────────────────────
     let tuiMode = "chat";
@@ -190,6 +194,7 @@ export async function startTui(config, spawner) {
         menuFilterActive = false;
         menuFilterBuf = "";
         w.write("\x1b[?1049l"); // leave alternate screen (restores chat)
+        setScrollRegion(); // re-establish scroll region after alt screen
         statusBar();
         prompt(true); // skip newline — alt screen restore already positioned cursor
     }
@@ -210,16 +215,65 @@ export async function startTui(config, spawner) {
         const icon = PERMISSION_ICONS[mode];
         const rows = process.stdout.rows || 24;
         const c = cols();
-        if (!skipNewline)
+        if (!skipNewline) {
+            // Newline within the scroll region so content scrolls up naturally
+            cursorToScrollEnd();
             w.write("\n");
-        const sepLine = s.dim("─".repeat(c));
+        }
+        // Draw the fixed bottom bar outside the scroll region.
+        // Temporarily reset DECSTBM so writes to rows (rows-4)..(rows) work.
+        w.write(`${ESC}r`); // reset scroll region temporarily
+        // Layout (bottom up): blank, permissions, separator, input, separator
+        const sep = s.dim("─".repeat(c));
         const permLine = `  ${color(`${icon} ${PERMISSION_LABELS[mode]} permissions`)} ${s.dim("(shift+tab to cycle)")}`;
-        w.write(`${ESC}${rows - 2};1H${ESC}2K${sepLine}`);
+        w.write(`${ESC}${rows - 4};1H${ESC}2K${sep}`);
+        w.write(`${ESC}${rows - 3};1H${ESC}2K${bashMode ? `${s.yellow("!")} ` : `${s.dim("▸")} `}`);
+        w.write(`${ESC}${rows - 2};1H${ESC}2K${sep}`);
         w.write(`${ESC}${rows - 1};1H${ESC}2K${permLine}`);
-        w.write(`${ESC}${rows};1H${ESC}2K${bashMode ? `${s.yellow("!")} ` : `${color(icon)} ${s.dim("▸")} `}`);
+        w.write(`${ESC}${rows};1H${ESC}2K`); // blank bottom row
+        // Re-establish scroll region and position cursor at the input line
+        setScrollRegion();
+        w.write(`${ESC}${rows - 3};${bashMode ? 3 : 4}H`);
+    }
+    // Redraw the input line and position the terminal cursor at cursorPos
+    function redrawInput() {
+        w.write(`${ESC}2K\r`);
+        prompt(true);
+        w.write(inputLine);
+        // Move terminal cursor back from end to cursorPos
+        const back = inputLine.length - cursorPos;
+        if (back > 0)
+            w.write(`${ESC}${back}D`);
+    }
+    // ── Scroll region management ─────────────────────────────────────────
+    // DECSTBM: rows 1..(rows-5) scroll; bottom 5 rows are fixed for the input bar.
+    function setScrollRegion() {
+        if (!isTTY)
+            return;
+        const rows = process.stdout.rows || 24;
+        const scrollBottom = Math.max(1, rows - 5);
+        w.write(`${ESC}1;${scrollBottom}r`);
+    }
+    // Move cursor to the bottom of the scroll region so new output scrolls naturally.
+    function cursorToScrollEnd() {
+        if (!isTTY)
+            return;
+        const rows = process.stdout.rows || 24;
+        const scrollBottom = Math.max(1, rows - 5);
+        w.write(`${ESC}${scrollBottom};1H`);
     }
+    // Periodic status bar refresh (every 30s) — keeps cost/turns current during long tool runs
+    const statusRefreshTimer = isTTY
+        ? setInterval(() => { if (tuiMode === "chat")
+            statusBar(); }, 30_000)
+        : null;
+    if (statusRefreshTimer)
+        statusRefreshTimer.unref(); // don't keep process alive
     // Terminal cleanup: restore state on exit
     function cleanupTerminal() {
+        if (statusRefreshTimer)
+            clearInterval(statusRefreshTimer);
+        w.write(`${ESC}r`); // reset scroll region
         w.write("\x1b[?1049l"); // leave alt screen if active
         if (process.stdin.isTTY) {
             try {
@@ -229,6 +283,15 @@ export async function startTui(config, spawner) {
         }
     }
     process.on("exit", cleanupTerminal);
+    // Re-establish scroll region on terminal resize.
+    // Node's "resize" event already fires on SIGWINCH — no separate signal handler needed.
+    process.stdout.on("resize", () => {
+        if (tuiMode === "chat") {
+            setScrollRegion();
+            statusBar();
+            prompt(true);
+        }
+    });
     // Setup: clear screen, status bar at top, content area clean
     if (isTTY) {
         w.write(`${ESC}2J${ESC}H`); // clear entire screen + home
@@ -266,6 +329,7 @@ export async function startTui(config, spawner) {
             w.write(`\n  ${info[0]}\n  ${info[1]}  ${info[2]}\n  ${info[4]}\n\n  ${info[6]}\n\n`);
         }
         w.write("\n");
+        setScrollRegion(); // establish scroll region after banner
     }
     // Raw stdin for steering
     if (process.stdin.isTTY) {
@@ -347,8 +411,83 @@ export async function startTui(config, spawner) {
             prompt(true);
             return;
         }
-        // Tab — toggle mode (not during agent run or filter)
-        if (key.name === "tab" && !menuFilterActive) {
+        // Tab — completion or toggle mode
+        if (key.name === "tab" && !key.shift && !menuFilterActive) {
+            // Slash command completion in chat mode
+            if (tuiMode === "chat" && inputLine.startsWith("/")) {
+                const SLASH_COMMANDS = [
+                    "/help", "/model", "/provider", "/turns", "/clear", "/cost",
+                    "/plan", "/undo", "/history", "/compact", "/context", "/mode",
+                    "/spawn", "/agents", "/diff", "/git", "/files", "/cwd",
+                    "/preset", "/exit",
+                ];
+                const matches = SLASH_COMMANDS.filter((c) => c.startsWith(inputLine));
+                if (matches.length === 1) {
+                    inputLine = matches[0];
+                    cursorPos = inputLine.length;
+                    redrawInput();
+                }
+                else if (matches.length > 1) {
+                    // Show matches in scroll area, then redraw prompt
+                    cursorToScrollEnd();
+                    w.write(`\n${s.dim("  " + matches.join("  "))}\n`);
+                    prompt(true);
+                    w.write(inputLine);
+                    const back = inputLine.length - cursorPos;
+                    if (back > 0)
+                        w.write(`${ESC}${back}D`);
+                }
+                return;
+            }
+            // File path completion in bash mode
+            if (tuiMode === "chat" && bashMode && inputLine.length > 0) {
+                // Complete the last whitespace-delimited token as a path
+                const lastSpace = inputLine.lastIndexOf(" ");
+                const prefix = lastSpace === -1 ? "" : inputLine.slice(0, lastSpace + 1);
+                const partial = lastSpace === -1 ? inputLine : inputLine.slice(lastSpace + 1);
+                const expandedPartial = partial.replace(/^~/, os.homedir());
+                const dir = path.dirname(expandedPartial);
+                const base = path.basename(expandedPartial);
+                try {
+                    const entries = fs.readdirSync(dir, { withFileTypes: true });
+                    const matches = entries.filter((e) => e.name.startsWith(base));
+                    if (matches.length === 1) {
+                        const completed = matches[0];
+                        const fullPath = partial.startsWith("~")
+                            ? "~/" + path.relative(os.homedir(), path.join(dir, completed.name))
+                            : path.join(dir, completed.name);
+                        inputLine = prefix + fullPath + (completed.isDirectory() ? "/" : "");
+                        cursorPos = inputLine.length;
+                        redrawInput();
+                    }
+                    else if (matches.length > 1) {
+                        const names = matches.map((e) => e.name + (e.isDirectory() ? "/" : ""));
+                        cursorToScrollEnd();
+                        w.write(`\n${s.dim("  " + names.join("  "))}\n`);
+                        // Find longest common prefix for partial completion
+                        let common = matches[0].name;
+                        for (const m of matches) {
+                            while (!m.name.startsWith(common))
+                                common = common.slice(0, -1);
+                        }
+                        if (common.length > base.length) {
+                            const fullPath = partial.startsWith("~")
+                                ? "~/" + path.relative(os.homedir(), path.join(dir, common))
+                                : path.join(dir, common);
+                            inputLine = prefix + fullPath;
+                            cursorPos = inputLine.length;
+                        }
+                        prompt(true);
+                        w.write(inputLine);
+                        const back = inputLine.length - cursorPos;
+                        if (back > 0)
+                            w.write(`${ESC}${back}D`);
+                    }
+                }
+                catch { /* dir doesn't exist or unreadable */ }
+                return;
+            }
+            // Default: toggle menu mode
             if (tuiMode === "chat" && !running) {
                 enterMenuMode();
             }
@@ -368,11 +507,13 @@ export async function startTui(config, spawner) {
             if (bashMode) {
                 bashMode = false;
                 inputLine = "";
+                cursorPos = 0;
                 prompt(true);
                 return;
             }
             if (inputLine) {
                 inputLine = "";
+                cursorPos = 0;
                 prompt(true);
                 return;
             }
@@ -389,6 +530,7 @@ export async function startTui(config, spawner) {
             if (bashMode) {
                 bashMode = false;
                 inputLine = "";
+                cursorPos = 0;
                 prompt(true);
                 ctrlCCount = 0;
                 return;
@@ -396,6 +538,7 @@ export async function startTui(config, spawner) {
             if (inputLine) {
                 // Clear input
                 inputLine = "";
+                cursorPos = 0;
                 prompt(true);
                 ctrlCCount = 0;
                 return;
@@ -410,8 +553,7 @@ export async function startTui(config, spawner) {
             }
             else {
                 // Actually quit
-                if (process.stdin.isTTY)
-                    process.stdin.setRawMode(false);
+                cleanupTerminal();
                 w.write(s.dim("\nSession ended.\n"));
                 resolve(session);
             }
@@ -420,7 +562,10 @@ export async function startTui(config, spawner) {
         // Enter — submit
         if (key.name === "return") {
             const line = inputLine.trim();
+            cursorPos = 0;
             inputLine = "";
+            // Move to the bottom of the scroll region so new output scrolls naturally
+            cursorToScrollEnd();
             w.write("\n");
             if (!line) {
                 prompt();
@@ -473,13 +618,19 @@ export async function startTui(config, spawner) {
                 prompt();
                 return;
             }
-            if (handleCommand(line, {
+            const cmdResult = handleCommand(line, {
                 session,
                 contextLimit,
                 undoStack: [],
                 providerName: config.provider.name,
                 currentModel: config.provider.model,
+                provider: config.provider,
+                systemPrompt: config.systemPrompt,
                 spawner,
+                sessionId: config.sessionId,
+                startTime,
+                phrenPath: config.phrenCtx?.phrenPath,
+                phrenCtx: config.phrenCtx,
                 onModelChange: (result) => {
                     // Live model switch — re-resolve provider with new model
                     try {
@@ -494,10 +645,15 @@ export async function startTui(config, spawner) {
                     }
                     catch { /* keep current provider on error */ }
                 },
-            })) {
+            });
+            if (cmdResult === true) {
                 prompt();
                 return;
             }
+            if (typeof cmdResult === "object" && cmdResult instanceof Promise) {
+                cmdResult.then(() => { prompt(); });
+                return;
+            }
             // If agent is running, buffer input
             if (running) {
                 pendingInput = line;
@@ -521,9 +677,8 @@ export async function startTui(config, spawner) {
                 historyIndex--;
             }
             inputLine = inputHistory[historyIndex];
-            w.write(`${ESC}2K\r`);
-            prompt(true);
-            w.write(inputLine);
+            cursorPos = inputLine.length;
+            redrawInput();
             return;
         }
         // Down arrow — next history or restore saved
@@ -538,20 +693,112 @@ export async function startTui(config, spawner) {
                 historyIndex = -1;
                 inputLine = savedInput;
             }
-            w.write(`${ESC}2K\r`);
-            prompt(true);
-            w.write(inputLine);
+            cursorPos = inputLine.length;
+            redrawInput();
             return;
         }
-        // Backspace
+        // Ctrl+A — move cursor to start of line
+        if (key.ctrl && key.name === "a") {
+            cursorPos = 0;
+            redrawInput();
+            return;
+        }
+        // Ctrl+E — move cursor to end of line
+        if (key.ctrl && key.name === "e") {
+            cursorPos = inputLine.length;
+            redrawInput();
+            return;
+        }
+        // Ctrl+U — kill entire line
+        if (key.ctrl && key.name === "u") {
+            inputLine = "";
+            cursorPos = 0;
+            redrawInput();
+            return;
+        }
+        // Ctrl+K — kill from cursor to end of line
+        if (key.ctrl && key.name === "k") {
+            inputLine = inputLine.slice(0, cursorPos);
+            redrawInput();
+            return;
+        }
+        // Left arrow — move cursor left one character
+        if (key.name === "left" && !key.meta && !key.ctrl) {
+            if (cursorPos > 0) {
+                cursorPos--;
+                w.write(`${ESC}D`);
+            }
+            return;
+        }
+        // Right arrow — move cursor right one character
+        if (key.name === "right" && !key.meta && !key.ctrl) {
+            if (cursorPos < inputLine.length) {
+                cursorPos++;
+                w.write(`${ESC}C`);
+            }
+            return;
+        }
+        // Alt+Left — move cursor left by one word
+        if (key.name === "left" && (key.meta || key.ctrl)) {
+            if (cursorPos > 0) {
+                // Skip spaces, then skip non-spaces
+                let p = cursorPos;
+                while (p > 0 && inputLine[p - 1] === " ")
+                    p--;
+                while (p > 0 && inputLine[p - 1] !== " ")
+                    p--;
+                cursorPos = p;
+                redrawInput();
+            }
+            return;
+        }
+        // Alt+Right — move cursor right by one word
+        if (key.name === "right" && (key.meta || key.ctrl)) {
+            if (cursorPos < inputLine.length) {
+                let p = cursorPos;
+                while (p < inputLine.length && inputLine[p] !== " ")
+                    p++;
+                while (p < inputLine.length && inputLine[p] === " ")
+                    p++;
+                cursorPos = p;
+                redrawInput();
+            }
+            return;
+        }
+        // Word-delete: Alt+Backspace, Ctrl+Backspace, Ctrl+W
+        if (((key.meta || key.ctrl) && key.name === "backspace") ||
+            (key.ctrl && key.name === "w")) {
+            if (cursorPos > 0) {
+                // Find word boundary before cursor
+                let p = cursorPos;
+                while (p > 0 && inputLine[p - 1] === " ")
+                    p--;
+                while (p > 0 && inputLine[p - 1] !== " ")
+                    p--;
+                inputLine = inputLine.slice(0, p) + inputLine.slice(cursorPos);
+                cursorPos = p;
+                redrawInput();
+            }
+            return;
+        }
+        // Backspace — delete character before cursor
         if (key.name === "backspace") {
-            if (inputLine.length > 0) {
-                inputLine = inputLine.slice(0, -1);
-                w.write("\b \b");
+            if (cursorPos > 0) {
+                inputLine = inputLine.slice(0, cursorPos - 1) + inputLine.slice(cursorPos);
+                cursorPos--;
+                redrawInput();
+            }
+            return;
+        }
+        // Delete — delete character at cursor
+        if (key.name === "delete") {
+            if (cursorPos < inputLine.length) {
+                inputLine = inputLine.slice(0, cursorPos) + inputLine.slice(cursorPos + 1);
+                redrawInput();
             }
             return;
         }
-        // Regular character
+        // Regular character — insert at cursor position
         if (key.sequence && !key.ctrl && !key.meta) {
             // ! at start of empty input toggles bash mode
             if (key.sequence === "!" && inputLine === "" && !bashMode) {
@@ -559,8 +806,9 @@ export async function startTui(config, spawner) {
                 prompt(true);
                 return;
             }
-            inputLine += key.sequence;
-            w.write(key.sequence);
+            inputLine = inputLine.slice(0, cursorPos) + key.sequence + inputLine.slice(cursorPos);
+            cursorPos += key.sequence.length;
+            redrawInput();
         }
     });
     // TUI hooks — render streaming text with markdown, compact tool output
@@ -578,11 +826,8 @@ export async function startTui(config, spawner) {
                 w.write(`${ESC}2K\r`); // clear thinking timer line
                 firstDelta = false;
             }
-            textBuffer += text;
-            // Flush on paragraph boundaries (double newline) or single newline for streaming feel
-            if (textBuffer.includes("\n\n") || textBuffer.endsWith("\n")) {
-                flushTextBuffer();
-            }
+            // Stream directly for real-time feel — write each delta immediately
+            w.write(text);
         },
         onTextDone: () => {
             flushTextBuffer();
@@ -621,14 +866,26 @@ export async function startTui(config, spawner) {
     async function runAgentTurn(userInput) {
         running = true;
         firstDelta = true;
+        cursorToScrollEnd(); // ensure all turn output stays within scroll region
         const thinkStart = Date.now();
+        // Phren thinking — subtle purple/cyan breath, no spinner gimmicks
+        let thinkFrame = 0;
         const thinkTimer = setInterval(() => {
-            const elapsed = ((Date.now() - thinkStart) / 1000).toFixed(1);
-            w.write(`${ESC}2K  ${s.dim(`◌ thinking... ${elapsed}s`)}\r`);
-        }, 100);
+            const elapsed = (Date.now() - thinkStart) / 1000;
+            // Gentle sine-wave interpolation between phren purple and cyan
+            const t = (Math.sin(thinkFrame * 0.08) + 1) / 2; // 0..1, slow oscillation
+            const r = Math.round(155 * (1 - t) + 40 * t);
+            const g = Math.round(140 * (1 - t) + 211 * t);
+            const b = Math.round(250 * (1 - t) + 242 * t);
+            const color = `${ESC}38;2;${r};${g};${b}m`;
+            w.write(`${ESC}2K  ${color}◆ thinking${ESC}0m ${s.dim(`${elapsed.toFixed(1)}s`)}\r`);
+            thinkFrame++;
+        }, 50);
         try {
             await runTurn(userInput, session, config, tuiHooks);
             clearInterval(thinkTimer);
+            const elapsed = ((Date.now() - thinkStart) / 1000).toFixed(1);
+            w.write(`${ESC}2K  ${s.dim(`◆ thought for ${elapsed}s`)}\n`);
             statusBar();
         }
         catch (err) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phren/agent",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "Coding agent with persistent memory — powered by phren",
   "type": "module",
   "bin": {
@@ -13,7 +13,7 @@
     "dist"
   ],
   "dependencies": {
-    "@phren/cli": "0.1.2"
+    "@phren/cli": "0.1.3"
   },
   "engines": {
     "node": ">=20.0.0"