agent-sh 0.3.1 → 0.5.0

package/dist/extensions/slash-commands.js

@@ -2,90 +2,187 @@
  * Slash commands extension.
  *
  * Registers built-in slash commands on the event bus:
+ * - Listens for "command:register" to accept commands from extensions
  * - Responds to "autocomplete:request" pipe for /-prefixed completions
  * - Handles "command:execute" events and dispatches to matching handler
  * - Uses "ui:info"/"ui:error" for user feedback (no direct TUI dependency)
+ *
+ * Argument completion is composable: any extension can onPipe("autocomplete:request")
+ * and check payload.command / payload.commandArgs to add completions for any command.
  */
-import { execSync } from "node:child_process";
 import { palette as p } from "../utils/palette.js";
-export default function activate({ bus, getAcpClient, quit }) {
-    const commands = [
-        {
-            name: "/help",
-            description: "Show available commands",
-            handler: () => {
-                const lines = commands.map((c) => `  ${p.accent}${c.name.padEnd(12)}${p.reset} ${c.description}`);
-                bus.emit("ui:info", { message: "Available commands:\n" + lines.join("\n") });
-            },
-        },
-        {
-            name: "/clear",
-            description: "Start a new agent session",
-            handler: async () => {
-                try {
-                    await getAcpClient().resetSession();
-                    bus.emit("ui:info", { message: "Session cleared." });
-                }
-                catch (err) {
-                    bus.emit("ui:error", {
-                        message: `Failed to reset session: ${err instanceof Error ? err.message : String(err)}`,
-                    });
-                }
-            },
+import { discoverSkills, loadSkillContent } from "../agent/skills.js";
+export default function activate({ bus, contextManager }) {
+    const commands = new Map();
+    const register = (cmd) => {
+        const name = cmd.name.startsWith("/") ? cmd.name : `/${cmd.name}`;
+        commands.set(name, { ...cmd, name });
+    };
+    // ── Built-in commands ─────────────────────────────────────────
+    register({
+        name: "/help",
+        description: "Show available commands",
+        handler: () => {
+            const maxLen = Math.max(...[...commands.values()].map(c => c.name.length));
+            const pad = maxLen + 2;
+            const lines = [...commands.values()].map((c) => `  ${p.accent}${c.name.padEnd(pad)}${p.reset} ${c.description}`);
+            bus.emit("ui:info", { message: "Available commands:\n" + lines.join("\n") });
         },
-        {
-            name: "/copy",
-            description: "Copy last agent response to clipboard",
-            handler: () => {
-                const text = getAcpClient().getLastResponseText();
-                if (!text) {
-                    bus.emit("ui:info", { message: "No agent response to copy." });
-                    return;
-                }
-                try {
-                    if (process.platform === "darwin") {
-                        execSync("pbcopy", { input: text });
-                    }
-                    else {
-                        execSync("xclip -selection clipboard", { input: text });
-                    }
-                    bus.emit("ui:info", { message: "Copied to clipboard." });
-                }
-                catch {
-                    bus.emit("ui:error", { message: "Failed to copy to clipboard." });
-                }
-            },
+    });
+    register({
+        name: "/model",
+        description: "Cycle to next model, or switch to a specific one",
+        handler: (args) => {
+            const name = args.trim();
+            if (!name) {
+                const { models, active } = bus.emitPipe("config:get-models", { models: [], active: null });
+                const current = models.find((m) => m.model === active);
+                const label = current
+                    ? `${current.model}${current.provider ? ` [${current.provider}]` : ""}`
+                    : active ?? "none";
+                bus.emit("ui:info", { message: `Model: ${label}` });
+            }
+            else {
+                bus.emit("config:switch-model", { model: name });
+            }
         },
-        {
-            name: "/compact",
-            description: "Ask agent to summarize the conversation",
-            handler: async () => {
-                await getAcpClient().sendPrompt("Please provide a concise summary of our conversation so far and the current state of the work.");
-            },
+    });
+    register({
+        name: "/thinking",
+        description: "Set thinking/reasoning effort level",
+        handler: (args) => {
+            const level = args.trim();
+            if (!level) {
+                const { level: current, levels, supported } = bus.emitPipe("config:get-thinking", { level: "off", levels: [], supported: true });
+                const status = supported ? current : `${current} (not supported by current model)`;
+                bus.emit("ui:info", { message: `Thinking: ${status} (options: ${levels.join(", ")})` });
+            }
+            else {
+                bus.emit("config:set-thinking", { level });
+            }
         },
-        {
-            name: "/quit",
-            description: "Exit agent-sh",
-            handler: () => {
-                quit();
-            },
+    });
+    register({
+        name: "/backend",
+        description: "List or switch agent backend",
+        handler: (args) => {
+            const name = args.trim();
+            if (!name) {
+                bus.emit("config:list-backends", {});
+            }
+            else {
+                bus.emit("config:switch-backend", { name });
+            }
         },
-    ];
-    // Provide command completions for /-prefixed input
+    });
+    // ── Extension registration ────────────────────────────────────
+    bus.on("command:register", (cmd) => {
+        register(cmd);
+    });
+    // ── Skill commands (/skill:<name>) ────────────────────────────
+    const getSkills = () => {
+        const cwd = contextManager?.getCwd() ?? process.cwd();
+        return discoverSkills(cwd);
+    };
+    const handleSkillCommand = (skillName, args) => {
+        const skills = getSkills();
+        const skill = skills.find(s => s.name === skillName);
+        if (!skill) {
+            bus.emit("ui:error", { message: `Unknown skill: ${skillName}` });
+            return;
+        }
+        const content = loadSkillContent(skill);
+        if (!content) {
+            bus.emit("ui:error", { message: `Failed to load skill: ${skillName}` });
+            return;
+        }
+        const query = args.trim()
+            ? `${content}\n\n${args.trim()}`
+            : content;
+        bus.emit("agent:submit", { query });
+    };
+    // ── Autocomplete: command names ───────────────────────────────
     bus.onPipe("autocomplete:request", (payload) => {
         if (!payload.buffer.startsWith("/"))
             return payload;
+        // Argument completion is handled by separate pipe handlers below
+        if (payload.command)
+            return payload;
         const prefix = payload.buffer.toLowerCase();
-        const matching = commands
+        const matching = [...commands.values()]
             .filter((c) => c.name.toLowerCase().startsWith(prefix))
             .map((c) => ({ name: c.name, description: c.description }));
+        // Skill commands
+        if (prefix.startsWith("/skill:") || "/skill:".startsWith(prefix)) {
+            const skills = getSkills();
+            for (const skill of skills) {
+                const name = `/skill:${skill.name}`;
+                if (name.toLowerCase().startsWith(prefix)) {
+                    matching.push({ name, description: skill.description });
+                }
+            }
+        }
         if (matching.length === 0)
             return payload;
         return { ...payload, items: [...payload.items, ...matching] };
     });
-    // Handle command execution
+    // ── Autocomplete: /model arguments ─────────────────────────────
+    bus.onPipe("autocomplete:request", (payload) => {
+        if (payload.command !== "/model")
+            return payload;
+        const partial = (payload.commandArgs ?? "").toLowerCase();
+        const { models, active } = bus.emitPipe("config:get-models", { models: [], active: null });
+        const items = models
+            .filter((m) => m.model.toLowerCase().includes(partial))
+            .slice(0, 15)
+            .map((m) => ({
+            name: `/model ${m.model}`,
+            description: `${m.provider ? `[${m.provider}]` : ""}${m.model === active ? " (active)" : ""}`,
+        }));
+        if (items.length === 0)
+            return payload;
+        return { ...payload, items: [...payload.items, ...items] };
+    });
+    // ── Autocomplete: /thinking arguments ─────────────────────────
+    bus.onPipe("autocomplete:request", (payload) => {
+        if (payload.command !== "/thinking")
+            return payload;
+        const partial = (payload.commandArgs ?? "").toLowerCase();
+        const { level: current, levels } = bus.emitPipe("config:get-thinking", { level: "off", levels: [], supported: true });
+        const items = levels
+            .filter((l) => l.startsWith(partial))
+            .map((l) => ({
+            name: `/thinking ${l}`,
+            description: l === current ? "(active)" : "",
+        }));
+        if (items.length === 0)
+            return payload;
+        return { ...payload, items: [...payload.items, ...items] };
+    });
+    // ── Autocomplete: /backend arguments ──────────────────────────
+    bus.onPipe("autocomplete:request", (payload) => {
+        if (payload.command !== "/backend")
+            return payload;
+        const partial = (payload.commandArgs ?? "").toLowerCase();
+        const { names, active } = bus.emitPipe("config:get-backends", { names: [], active: null });
+        const items = names
+            .filter((n) => n.toLowerCase().startsWith(partial))
+            .map((n) => ({
+            name: `/backend ${n}`,
+            description: n === active ? "(active)" : "",
+        }));
+        if (items.length === 0)
+            return payload;
+        return { ...payload, items: [...payload.items, ...items] };
+    });
+    // ── Dispatch ──────────────────────────────────────────────────
     bus.on("command:execute", (e) => {
-        const cmd = commands.find((c) => c.name === e.name);
+        if (e.name.startsWith("/skill:")) {
+            const skillName = e.name.slice("/skill:".length);
+            handleSkillCommand(skillName, e.args);
+            return;
+        }
+        const cmd = commands.get(e.name);
         if (cmd) {
             const result = cmd.handler(e.args);
             if (result instanceof Promise) {

package/dist/extensions/tui-renderer.js

@@ -47,7 +47,6 @@ function createRenderState() {
         spinnerOpts: {},
         spinnerInterval: null,
         spinnerStartTime: 0,
-        lastCommand: "",
         toolLineOpen: false,
         currentToolKind: undefined,
         commandOutputBuffer: "",
@@ -60,9 +59,12 @@ function createRenderState() {
     };
 }
 export default function activate(ctx) {
-    const { bus, getAcpClient, define } = ctx;
+    const { bus, llmClient, define } = ctx;
     const writer = new StdoutWriter();
     const s = createRenderState();
+    // Track backend/model info for display on response border
+    let backendInfo = null;
+    bus.on("agent:info", (info) => { backendInfo = info; });
     // ── Register fenced block transform (code blocks → ContentBlock) ──
     // Nobody is special — tui-renderer uses the same primitive as any extension.
     const fencedTransform = createFencedBlockTransform(bus, {
@@ -75,7 +77,7 @@ export default function activate(ctx) {
     // ── Event subscriptions ─────────────────────────────────────
     bus.on("agent:query", (e) => {
         s.spinnerStartTime = 0;
-        showUserQuery(e.query);
+        showUserQuery(e.query, e.modeLabel);
         startAgentResponse();
         startThinkingSpinner();
     });
@@ -104,46 +106,54 @@ export default function activate(ctx) {
         }
     });
     bus.on("agent:response-chunk", (e) => {
-        if (e.blocks) {
-            // Inject spacing: append \n to text blocks that precede non-text blocks
-            const blocks = e.blocks;
-            for (let i = 0; i < blocks.length; i++) {
-                const block = blocks[i];
-                const next = blocks[i + 1];
-                if (block.type === "text" && next && next.type !== "text") {
-                    block.text += "\n";
-                }
-            }
-            for (const block of blocks) {
-                switch (block.type) {
-                    case "text":
-                        if (block.text)
-                            writeAgentText(block.text);
-                        break;
-                    case "code-block":
-                        writeCodeBlock(block.language, block.code);
-                        break;
-                    case "image":
-                        writeInlineImage(block.data);
-                        break;
-                    case "raw":
-                        flushForRaw();
-                        writer.write(block.escape);
-                        break;
-                }
+        const { blocks } = e;
+        // Inject spacing: append \n to text blocks that precede non-text blocks
+        for (let i = 0; i < blocks.length; i++) {
+            const block = blocks[i];
+            const next = blocks[i + 1];
+            if (block.type === "text" && next && next.type !== "text") {
+                block.text += "\n";
             }
         }
-        else {
-            writeAgentText(e.text);
+        for (const block of blocks) {
+            switch (block.type) {
+                case "text":
+                    if (block.text)
+                        writeAgentText(block.text);
+                    break;
+                case "code-block":
+                    writeCodeBlock(block.language, block.code);
+                    break;
+                case "image":
+                    writeInlineImage(block.data);
+                    break;
+                case "raw":
+                    flushForRaw();
+                    writer.write(block.escape);
+                    break;
+            }
         }
     });
+    // Track token usage for display
+    let pendingUsage = null;
+    bus.on("agent:usage", (e) => { pendingUsage = e; });
     bus.on("agent:response-done", () => {
         s.isThinking = false;
+        if (pendingUsage && s.renderer) {
+            const { prompt_tokens, completion_tokens } = pendingUsage;
+            const maxTokens = backendInfo?.contextWindow ?? 128_000;
+            // prompt_tokens of the latest call = current context usage
+            // (it includes the full conversation history)
+            const ctxK = (prompt_tokens / 1000).toFixed(1);
+            const maxK = (maxTokens / 1000).toFixed(0);
+            const pct = Math.min(100, (prompt_tokens / maxTokens) * 100).toFixed(0);
+            s.renderer.writeLine("");
+            s.renderer.writeLine(`${p.dim}⬆ ${prompt_tokens}  ⬇ ${completion_tokens}  ctx: ${ctxK}k/${maxK}k (${pct}%)${p.reset}`);
+            drain();
+            pendingUsage = null;
+        }
         endAgentResponse();
     });
-    bus.on("agent:tool-call", (e) => {
-        s.lastCommand = e.tool;
-    });
     bus.on("agent:tool-started", (e) => {
         fencedTransform.flush();
         stopCurrentSpinner();
@@ -159,9 +169,8 @@ export default function activate(ctx) {
             s.hadToolCalls = true;
         }
         else {
-            showToolCall(e.title, s.lastCommand, e);
+            showToolCall(e.title, "", e);
         }
-        s.lastCommand = "";
     });
     bus.on("agent:tool-completed", (e) => {
         showToolComplete(e.exitCode);
@@ -182,7 +191,15 @@ export default function activate(ctx) {
         stopCurrentSpinner();
         endAgentResponse();
     });
-    bus.on("agent:error", (e) => showError(e.message));
+    bus.on("agent:error", (e) => {
+        stopCurrentSpinner();
+        showCollapsedThinking();
+        if (!s.renderer)
+            startAgentResponse();
+        s.renderer.writeLine(`${p.error}Error: ${e.message}${p.reset}`);
+        s.renderer.writeLine("");
+        drain();
+    });
     bus.on("permission:request", (e) => {
         stopCurrentSpinner();
         flushCommandOutput();
@@ -191,11 +208,12 @@ export default function activate(ctx) {
             drain();
         }
         if (e.kind === "file-write" && e.metadata?.diff) {
+            showCollapsedThinking();
             showFileDiff(e.title, e.metadata.diff);
         }
-        else {
-            endAgentResponse();
-        }
+        // Don't endAgentResponse() here — permission requests that aren't
+        // file-write diffs are handled inline (auto-approved or by extensions).
+        // Closing the response prematurely causes double separator borders.
     });
     bus.on("input:keypress", (e) => {
         if (e.key === "\x0f")
@@ -203,8 +221,17 @@ export default function activate(ctx) {
         if (e.key === "\x14")
             toggleThinkingDisplay(); // Ctrl+T
     });
-    bus.on("ui:info", (e) => showInfo(e.message));
+    bus.on("ui:info", (e) => {
+        stopCurrentSpinner();
+        showInfo(e.message);
+        // Restart spinner if agent is still processing
+        if (s.renderer)
+            startThinkingSpinner();
+    });
     bus.on("ui:error", (e) => showError(e.message));
+    bus.on("ui:suggestion", (e) => {
+        writer.write(`${p.dim}💡 ${e.text}${p.reset}\n`);
+    });
     // ── Rendering functions ─────────────────────────────────────
     function drain() {
         if (!s.renderer)
@@ -224,6 +251,7 @@ export default function activate(ctx) {
             if (!s.renderer)
                 startAgentResponse();
             s.renderer.writeLine(`${p.muted}… thinking${p.reset}`);
+            s.renderer.writeLine("");
             s.thinkingPending = false;
         }
     }
@@ -234,11 +262,12 @@ export default function activate(ctx) {
             s.renderer.flush();
             s.renderer.printBottomBorder();
             drain();
+            writer.write("\n");
             s.renderer = null;
         }
     }
-    function showUserQuery(query) {
-        const boxW = Math.min(84, writer.columns);
+    function showUserQuery(query, modeLabel) {
+        const boxW = writer.columns;
         const contentW = boxW - 4;
         const lines = [];
         for (const raw of query.split("\n")) {
@@ -258,11 +287,31 @@ export default function activate(ctx) {
                     lines.push(`${p.accent}${remaining}${p.reset}`);
             }
         }
+        // Mode-specific border color and title
+        const isExecute = modeLabel === "Execute";
+        const borderColor = isExecute ? p.success : p.accent;
+        const title = modeLabel
+            ? `${borderColor}${p.bold} ${modeLabel} ${p.reset}`
+            : `${p.accent}${p.bold}❯${p.reset}`;
+        // Backend/model label on the right (backend/model, highlighted)
+        const model = backendInfo?.model ?? llmClient?.model;
+        const backend = backendInfo?.name;
+        let modelLabel;
+        if (backend && model) {
+            modelLabel = `${p.dim}${backend}/${p.reset}${p.bold}${model}${p.reset}`;
+        }
+        else if (model) {
+            modelLabel = `${p.bold}${model}${p.reset}`;
+        }
+        else if (backend) {
+            modelLabel = `${p.bold}${backend}${p.reset}`;
+        }
         const framed = renderBoxFrame(lines, {
             width: boxW,
             style: "rounded",
-            borderColor: p.accent,
-            title: `${p.accent}${p.bold}❯${p.reset}`,
+            borderColor,
+            title,
+            titleRight: modelLabel,
         });
         writer.write("\n");
         for (const line of framed) {
@@ -386,9 +435,10 @@ export default function activate(ctx) {
             drain();
         }
     }
+    // Thinking is always assumed available — the TUI renders thinking
+    // tokens whenever they arrive, regardless of backend.
     function hasThinkingMode() {
-        const mode = getAcpClient().getCurrentMode();
-        return !mode || mode.id !== "off";
+        return true;
     }
     function startThinkingSpinner() {
         if (!s.spinnerStartTime)
@@ -476,14 +526,13 @@ export default function activate(ctx) {
     function showFileDiff(filePath, diff) {
         if (diff.isIdentical)
             return;
-        const boxW = Math.min(84, writer.columns);
+        const boxW = Math.min(120, writer.columns);
         const contentW = boxW - 4;
         const diffLines = renderDiff(diff, {
             width: contentW,
             filePath,
             maxLines: getSettings().diffMaxLines,
             trueColor: true,
-            mode: "unified",
         });
         const lastLine = diffLines[diffLines.length - 1] ?? "";
         const isTruncated = lastLine.includes("… ");
@@ -546,14 +595,13 @@ export default function activate(ctx) {
     }
     function showFileDiffCached(entry) {
         const { filePath, diff } = entry;
-        const boxW = Math.min(84, writer.columns);
+        const boxW = Math.min(120, writer.columns);
         const contentW = boxW - 4;
         const diffLines = renderDiff(diff, {
             width: contentW,
             filePath,
             maxLines: getSettings().diffMaxLines,
             trueColor: true,
-            mode: "unified",
         });
         const body = diffLines.length > 1 ? ["", ...diffLines.slice(1), ""] : diffLines;
         const framed = renderBoxFrame(body, {
@@ -572,7 +620,17 @@ export default function activate(ctx) {
         s.showThinkingText = !s.showThinkingText;
         if (s.spinner) {
             stopCurrentSpinner();
-            startThinkingSpinner();
+            if (s.showThinkingText) {
+                // Expanding: replace spinner with thinking text header
+                if (!s.renderer)
+                    startAgentResponse();
+                s.renderer.writeLine(`${p.dim}Thinking (ctrl+t to collapse)${p.reset}`);
+                drain();
+            }
+            else {
+                // Collapsing: restart spinner with updated hint
+                startThinkingSpinner();
+            }
             return;
         }
         if (!s.isThinking)