agent-sh 0.2.0 → 0.3.0

package/dist/extensions/shell-exec.js

@@ -22,25 +22,30 @@ import * as net from "node:net";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { fileURLToPath } from "node:url";
+import { getSettings } from "../settings.js";
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 export default function activate({ bus, contextManager }, opts) {
     const { socketPath } = opts;
-    // Register MCP server so ACP agents discover the user_shell tool
-    bus.onPipe("session:configure", (payload) => {
-        return {
-            ...payload,
-            mcpServers: [
-                ...payload.mcpServers,
-                {
-                    name: "agent-sh",
-                    command: process.execPath,
-                    args: [path.join(__dirname, "..", "mcp-server.js")],
-                    env: [{ name: "AGENT_SH_SOCKET", value: socketPath }],
-                },
-            ],
-        };
-    });
-    // Also set AGENT_SH_SOCKET for pi extensions that connect directly
+    // Register MCP server so ACP agents discover the bridge tools.
+    // Agents that don't support MCP (e.g. pi-acp) simply ignore it.
+    // Can be disabled via settings.json if not needed.
+    if (getSettings().enableMcp) {
+        bus.onPipe("session:configure", (payload) => {
+            return {
+                ...payload,
+                mcpServers: [
+                    ...payload.mcpServers,
+                    {
+                        name: "agent-sh",
+                        command: process.execPath,
+                        args: [path.join(__dirname, "..", "mcp-server.js")],
+                        env: [{ name: "AGENT_SH_SOCKET", value: socketPath }],
+                    },
+                ],
+            };
+        });
+    }
+    // Set AGENT_SH_SOCKET for agent extensions that connect directly
     process.env.AGENT_SH_SOCKET = socketPath;
     // Serialize shell/exec requests — only one PTY command at a time
     let execPending = Promise.resolve();
@@ -56,21 +61,19 @@ export default function activate({ bus, contextManager }, opts) {
                 return new Promise((resolve, reject) => {
                     execPending = execPending.then(async () => {
                         try {
+                            bus.emit("shell:agent-exec-start", {});
                             const result = await bus.emitPipeAsync("shell:exec-request", {
                                 command,
                                 output: "",
                                 cwd: "",
                                 done: false,
                             });
-                            // Show the command output in the TUI
-                            if (result.output) {
-                                bus.emit("agent:tool-output-chunk", { chunk: result.output });
-                            }
+                            bus.emit("shell:agent-exec-done", {});
                             resolve({ output: result.output, cwd: result.cwd });
                         }
                         catch (err) {
+                            bus.emit("shell:agent-exec-done", {});
                             const message = err instanceof Error ? err.message : String(err);
-                            bus.emit("agent:tool-output-chunk", { chunk: `Error: ${message}` });
                             reject(rpcError(-32000, message));
                         }
                     });
@@ -98,7 +101,9 @@ export default function activate({ bus, contextManager }, opts) {
                         if (!Array.isArray(ids) || ids.length === 0) {
                             throw rpcError(-32602, "Missing required parameter: ids (array of numbers)");
                         }
-                        return { result: contextManager.expand(ids.map(Number)) };
+                        const start = typeof params?.start === "number" ? params.start : undefined;
+                        const end = typeof params?.end === "number" ? params.end : undefined;
+                        return { result: contextManager.expand(ids.map(Number), start, end) };
                     }
                     case "browse":
                         return { result: contextManager.getRecentSummary() };

package/dist/extensions/tui-renderer.d.ts

@@ -1,2 +1,2 @@
 import type { ExtensionContext } from "../types.js";
-export default function activate({ bus }: ExtensionContext): void;
+export default function activate({ bus, getAcpClient }: ExtensionContext): void;

package/dist/extensions/tui-renderer.js

@@ -12,22 +12,27 @@
  */
 import { MarkdownRenderer } from "../utils/markdown.js";
 import { palette as p } from "../utils/palette.js";
-import { renderToolCall, renderToolResult, startSpinner, stopSpinner as stopToolSpinner, } from "../utils/tool-display.js";
+import { renderToolCall, startSpinner, stopSpinner as stopToolSpinner, } from "../utils/tool-display.js";
 import { renderDiff } from "../utils/diff-renderer.js";
 import { renderBoxFrame } from "../utils/box-frame.js";
-const MAX_COMMAND_OUTPUT_LINES = 30;
-export default function activate({ bus }) {
+import { getSettings } from "../settings.js";
+export default function activate({ bus, getAcpClient }) {
     let spinner = null;
     let renderer = null;
     let commandOutputBuffer = "";
     let commandOutputLineCount = 0;
     let commandOutputOverflow = 0;
     let lastCommand = "";
+    let toolLineOpen = false; // true when tool header was written without \n
+    let hadToolCalls = false; // true after any tool call in current response
+    let currentToolKind; // kind of the currently executing tool
     let isThinking = false;
     let showThinkingText = false;
+    let spinnerStartTime = 0; // preserved across spinner restarts
     let lastTruncatedDiff = null;
     // ── Event subscriptions ─────────────────────────────────────
     bus.on("agent:query", (e) => {
+        spinnerStartTime = 0;
         showUserQuery(e.query);
         startAgentResponse();
         startThinkingSpinner();
@@ -35,14 +40,15 @@ export default function activate({ bus }) {
     bus.on("agent:thinking-chunk", (e) => {
         if (!isThinking) {
             isThinking = true;
-            stopCurrentSpinner();
             if (showThinkingText) {
+                stopCurrentSpinner();
                 if (!renderer)
                     startAgentResponse();
-                renderer.writeLine(`${p.dim}${p.bold}💭 Thinking${p.reset}`);
+                renderer.writeLine(`${p.dim}Thinking (ctrl+t to collapse)${p.reset}`);
             }
             else {
-                startThinkingSpinner("Thinking");
+                // Restart spinner with ctrl+t hint now that we know thinking is available
+                startThinkingSpinner();
             }
         }
         if (showThinkingText && e.text) {
@@ -62,10 +68,28 @@ export default function activate({ bus }) {
     });
     bus.on("agent:tool-started", (e) => {
         stopCurrentSpinner();
-        showToolCall(e.title, lastCommand, e);
+        currentToolKind = e.kind;
+        if (e.title === "user_shell") {
+            // Minimal annotation — PTY echo will show the output
+            closeToolLine();
+            if (!renderer)
+                startAgentResponse();
+            renderer.flush();
+            const cmd = e.rawInput?.command || "";
+            renderer.writeLine(`${p.dim}▶ user_shell: ${cmd}${p.reset}`);
+            hadToolCalls = true;
+        }
+        else {
+            showToolCall(e.title, lastCommand, e);
+        }
         lastCommand = "";
     });
-    bus.on("agent:tool-completed", (e) => showToolComplete(e.exitCode));
+    bus.on("agent:tool-completed", (e) => {
+        showToolComplete(e.exitCode);
+        currentToolKind = undefined;
+        spinnerStartTime = 0;
+        startThinkingSpinner();
+    });
     bus.on("agent:tool-output-chunk", (e) => writeCommandOutput(e.chunk));
     bus.on("agent:tool-output", () => flushCommandOutput());
     bus.on("agent:cancelled", () => {
@@ -74,6 +98,11 @@ export default function activate({ bus }) {
         showInfo("(cancelled)");
         endAgentResponse();
     });
+    bus.on("agent:processing-done", () => {
+        isThinking = false;
+        stopCurrentSpinner();
+        endAgentResponse();
+    });
     bus.on("agent:error", (e) => showError(e.message));
     // Flush rendering state and show inline diff for file writes
     bus.on("permission:request", (e) => {
@@ -108,10 +137,11 @@ export default function activate({ bus }) {
     }
     function startAgentResponse() {
         renderer = new MarkdownRenderer();
-        process.stdout.write("\n");
+        hadToolCalls = false;
         renderer.printTopBorder();
     }
     function endAgentResponse() {
+        closeToolLine();
         if (renderer) {
             renderer.flush();
             renderer.printBottomBorder();
@@ -154,6 +184,9 @@ export default function activate({ bus }) {
         }
     }
     function writeAgentText(text) {
+        closeToolLine();
+        const needsGap = hadToolCalls;
+        hadToolCalls = false;
         if (isThinking) {
             isThinking = false;
             if (showThinkingText && renderer) {
@@ -166,10 +199,13 @@ export default function activate({ bus }) {
         stopCurrentSpinner();
         if (!renderer)
             startAgentResponse();
+        if (needsGap)
+            process.stdout.write("\n");
         renderer.push(text);
         flushOutput();
     }
     function showToolCall(title, command, extra) {
+        closeToolLine();
         stopCurrentSpinner();
         if (!renderer)
             startAgentResponse();
@@ -182,9 +218,15 @@ export default function activate({ bus }) {
             locations: extra?.locations,
             rawInput: extra?.rawInput,
         }, termW);
-        for (const line of lines) {
-            renderer.writeLine(line);
+        // Write all lines except the last normally, write last without \n
+        for (let i = 0; i < lines.length - 1; i++) {
+            renderer.writeLine(lines[i]);
         }
+        if (lines.length > 0) {
+            process.stdout.write(`  ${lines[lines.length - 1]}`);
+            toolLineOpen = true;
+        }
+        hadToolCalls = true;
         // Reset output tracking for the new tool
         commandOutputLineCount = 0;
         commandOutputOverflow = 0;
@@ -192,15 +234,37 @@ export default function activate({ bus }) {
     function showToolComplete(exitCode) {
         if (!renderer)
             return;
-        const termW = process.stdout.columns || 80;
-        const lines = renderToolResult({ exitCode }, termW);
-        for (const line of lines) {
-            renderer.writeLine(line);
+        const mark = exitCode === null
+            ? `${p.muted}(timed out)${p.reset}`
+            : exitCode === 0
+                ? `${p.success}✓${p.reset}`
+                : `${p.error}✗ exit ${exitCode}${p.reset}`;
+        if (toolLineOpen && commandOutputLineCount === 0) {
+            // No output written — append mark on same line as tool header
+            process.stdout.write(` ${mark}\n`);
+            toolLineOpen = false;
+        }
+        else {
+            closeToolLine();
+            flushCommandOutput();
+            renderer.writeLine(`  ${mark}`);
         }
     }
-    function startThinkingSpinner(label = "Thinking") {
+    function hasThinkingMode() {
+        const mode = getAcpClient().getCurrentMode();
+        return !mode || mode.id !== "off";
+    }
+    function startThinkingSpinner() {
+        // Preserve start time if restarting (e.g. toggle), otherwise reset
+        if (!spinnerStartTime)
+            spinnerStartTime = Date.now();
         stopCurrentSpinner();
-        spinner = startSpinner(label);
+        const thinking = hasThinkingMode();
+        const label = thinking ? "Thinking" : "Working";
+        const hint = thinking
+            ? (showThinkingText ? "(ctrl+t to collapse)" : "(ctrl+t to expand)")
+            : "";
+        spinner = startSpinner(label, { hint: hint || undefined, startTime: spinnerStartTime });
     }
     function stopCurrentSpinner() {
         if (spinner) {
@@ -208,14 +272,24 @@ export default function activate({ bus }) {
             spinner = null;
         }
     }
+    function closeToolLine() {
+        if (toolLineOpen) {
+            process.stdout.write("\n");
+            toolLineOpen = false;
+        }
+    }
     function writeCommandOutput(chunk) {
         if (!renderer)
             return;
+        closeToolLine();
+        const maxLines = currentToolKind === "read"
+            ? getSettings().readOutputMaxLines
+            : getSettings().maxCommandOutputLines;
         commandOutputBuffer += chunk;
         const lines = commandOutputBuffer.split("\n");
         commandOutputBuffer = lines.pop();
         for (const line of lines) {
-            if (commandOutputLineCount < MAX_COMMAND_OUTPUT_LINES) {
+            if (commandOutputLineCount < maxLines) {
                 renderer.writeLine(`${p.dim}  ${line}${p.reset}`);
                 commandOutputLineCount++;
             }
@@ -227,8 +301,11 @@ export default function activate({ bus }) {
     function flushCommandOutput() {
         if (!renderer)
             return;
+        const maxLines = currentToolKind === "read"
+            ? getSettings().readOutputMaxLines
+            : getSettings().maxCommandOutputLines;
         if (commandOutputBuffer) {
-            if (commandOutputLineCount < MAX_COMMAND_OUTPUT_LINES) {
+            if (commandOutputLineCount < maxLines) {
                 renderer.writeLine(`${p.dim}  ${commandOutputBuffer}${p.reset}`);
                 commandOutputLineCount++;
             }
@@ -237,12 +314,11 @@ export default function activate({ bus }) {
             }
             commandOutputBuffer = "";
         }
-        if (commandOutputOverflow > 0) {
+        if (commandOutputOverflow > 0 && maxLines > 0) {
             renderer.writeLine(`${p.dim}  … ${commandOutputOverflow} more lines${p.reset}`);
-            commandOutputOverflow = 0;
         }
+        commandOutputOverflow = 0;
     }
-    const DIFF_MAX_LINES = 20;
     function diffTitle(filePath, diff) {
         const stats = diff.isNewFile
             ? `${p.success}+${diff.added}${p.reset}`
@@ -258,7 +334,7 @@ export default function activate({ bus }) {
         const diffLines = renderDiff(diff, {
             width: contentW,
             filePath,
-            maxLines: DIFF_MAX_LINES,
+            maxLines: getSettings().diffMaxLines,
             trueColor: true,
             mode: "unified",
         });
@@ -329,7 +405,7 @@ export default function activate({ bus }) {
         const diffLines = renderDiff(diff, {
             width: contentW,
             filePath,
-            maxLines: DIFF_MAX_LINES,
+            maxLines: getSettings().diffMaxLines,
             trueColor: true,
             mode: "unified",
         });
@@ -348,8 +424,31 @@ export default function activate({ bus }) {
     }
     function toggleThinkingDisplay() {
         showThinkingText = !showThinkingText;
-        const state = showThinkingText ? "on" : "off";
-        process.stdout.write(`\n${p.dim}Thinking display: ${state}${p.reset}\n`);
+        // Update spinner hint to reflect new state, even if not actively thinking
+        if (spinner) {
+            stopCurrentSpinner();
+            startThinkingSpinner();
+            return;
+        }
+        if (!isThinking)
+            return;
+        if (showThinkingText) {
+            // Switch from spinner to streaming text
+            stopCurrentSpinner();
+            if (!renderer)
+                startAgentResponse();
+            renderer.writeLine(`${p.dim}Thinking (ctrl+t to collapse)${p.reset}`);
+        }
+        else {
+            // Switch from streaming text to spinner
+            if (renderer) {
+                renderer.flush();
+                const termW = process.stdout.columns || 80;
+                const w = Math.min(80, termW);
+                renderer.writeLine(`${p.dim}${"─".repeat(w)}${p.reset}`);
+            }
+            startThinkingSpinner();
+        }
     }
     function showError(message) {
         process.stdout.write(`\n${p.error}Error: ${message}${p.reset}\n`);