agent-sh 0.9.0 → 0.10.1

package/dist/extensions/tui-renderer.js

@@ -12,6 +12,7 @@
  */
 import { highlight } from "cli-highlight";
 import { MarkdownRenderer, wrapLine, MAX_CONTENT_WIDTH } from "../utils/markdown.js";
+import { DEFAULT_CONTEXT_WINDOW } from "../agent/token-budget.js";
 import { createFencedBlockTransform } from "../utils/stream-transform.js";
 import { palette as p } from "../utils/palette.js";
 import { renderToolCall, createSpinner, formatElapsed, SPINNER_FRAMES, } from "../utils/tool-display.js";
@@ -63,16 +64,21 @@ function createRenderState() {
         isThinking: false,
         showThinkingText: false,
         thinkingPending: false,
-        lastTruncatedDiff: null,
     };
 }
 export default function activate(ctx) {
     const { bus, define, compositor } = ctx;
     const s = createRenderState();
+    /** Track the shell's cwd so path shortening is relative to where the user actually is. */
+    let shellCwd = process.cwd();
+    bus.on("shell:cwd-change", (e) => { shellCwd = e.cwd; });
     /** Shorthand — get the current agent surface. */
     function out() { return compositor.surface("agent"); }
-    /** Capped width for borders, tool lines, and content — keeps everything aligned. */
-    function cappedW() { return Math.min(MAX_CONTENT_WIDTH + 2, out().columns); }
+    /** Capped width for borders, tool lines, and content — keeps everything aligned.
+     *  MarkdownRenderer.writeLine prepends a 2-char indent ("  ") to every line,
+     *  so available width for actual content is columns - 2.  Subtract an additional
+     *  1 to prevent terminal auto-wrap when a line lands exactly at the right edge. */
+    function cappedW() { return Math.min(MAX_CONTENT_WIDTH + 2, out().columns) - 2 - 1; }
     // Gate: other extensions (e.g. overlay) can advise this to suppress
     // TUI rendering of agent output while they own the display.
     define("tui:should-render-agent", () => true);
@@ -226,7 +232,7 @@ export default function activate(ctx) {
         s.isThinking = false;
         if (pendingUsage && s.renderer) {
             const { prompt_tokens, completion_tokens } = pendingUsage;
-            const maxTokens = backendInfo?.contextWindow ?? 128_000;
+            const maxTokens = backendInfo?.contextWindow ?? DEFAULT_CONTEXT_WINDOW;
             s.renderer.writeLine("");
             s.renderer.writeLine(ctx.call("tui:render-usage", prompt_tokens, completion_tokens, maxTokens));
             drain();
@@ -379,17 +385,37 @@ export default function activate(ctx) {
             s.renderer.flush();
             drain();
         }
+        // Diff rendering is handled in the async pipe below so it can yield
+        // to the event loop between hunks (keeping the spinner responsive).
+    });
+    // Async pipe: render diffs via the tui:render-diff handler (extensions can
+    // advise to customize).  Runs after the sync `on` handler above (which
+    // flushes state) and before shell.ts's pipe (which pauses stdout).
+    bus.onPipeAsync("permission:request", async (e) => {
+        if (!shouldRender())
+            return e;
         if (e.kind === "file-write" && e.metadata?.diff) {
             showCollapsedThinking();
-            showFileDiff(e.title, e.metadata.diff);
+            const lines = ctx.call("tui:render-diff", e.title, e.metadata.diff, cappedW());
+            if (lines.length > 0) {
+                if (!s.renderer)
+                    startAgentResponse();
+                contentGap("diff");
+                for (const line of lines)
+                    s.renderer.writeLine(line);
+                drain();
+            }
+            // The diff box IS the visual representation of the upcoming tool call.
+            // Mark lastContentKind as "tool" so the tool call line that follows
+            // doesn't inject an extra gap between the diff box and the checkmark.
+            s.lastContentKind = "tool";
         }
         // 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.
+        return e;
     });
     bus.on("input:keypress", (e) => {
-        if (e.key === "\x0f")
-            expandLastDiff(); // Ctrl+O
         if (e.key === "\x14")
             toggleThinkingDisplay(); // Ctrl+T
     });
@@ -518,9 +544,23 @@ export default function activate(ctx) {
         }
         let highlighted;
         try {
-            highlighted = language
-                ? highlight(code, { language })
-                : highlight(code); // auto-detect
+            // highlight.js warns to console.error for unsupported languages (elisp, org, etc).
+            // Suppress so it doesn't leak into the terminal.
+            const origError = console.error;
+            console.error = (...args) => {
+                const msg = args.join(" ");
+                if (msg.includes("Could not find the language"))
+                    return;
+                origError.apply(console, args);
+            };
+            try {
+                highlighted = language
+                    ? highlight(code, { language })
+                    : highlight(code); // auto-detect
+            }
+            finally {
+                console.error = origError;
+            }
         }
         catch {
             highlighted = code;
@@ -574,6 +614,17 @@ export default function activate(ctx) {
         }
         return [];
     });
+    /**
+     * Default renderer for standalone diffs (e.g. permission prompts).
+     * Extensions can advise this to customize diff rendering:
+     *
+     *   ctx.advise("tui:render-diff", (next, filePath, diff, width) => {
+     *     return myCustomDiffBox(filePath, diff, width);
+     *   });
+     */
+    define("tui:render-diff", (filePath, diff, width) => {
+        return renderDiffBody(diff, filePath, width);
+    });
     /** Render a diff as framed box lines (pure — no TUI state side effects). */
     function renderDiffBody(diff, filePath, width) {
         if (diff.isIdentical)
@@ -586,18 +637,8 @@ export default function activate(ctx) {
             maxLines: getSettings().diffMaxLines,
             trueColor: true,
         });
-        const lastLine = diffLines[diffLines.length - 1] ?? "";
-        const isTruncated = lastLine.includes("… ");
-        if (isTruncated) {
-            s.lastTruncatedDiff = { filePath, diff, expanded: false };
-        }
-        else {
-            s.lastTruncatedDiff = null;
-        }
         const body = diffLines.length > 1 ? ["", ...diffLines.slice(1), ""] : diffLines;
-        const footer = isTruncated
-            ? [`  ${p.dim}ctrl+o to expand${p.reset}`]
-            : undefined;
+        const footer = undefined;
         return renderBoxFrame(body, {
             width: boxW,
             style: "rounded",
@@ -625,11 +666,10 @@ export default function activate(ctx) {
     function extractDetail(extra) {
         if (extra.locations && extra.locations.length > 0) {
             const loc = extra.locations[0];
-            const cwd = process.cwd();
             const home = process.env.HOME;
             let fp = loc.path;
-            if (fp.startsWith(cwd + "/"))
-                fp = fp.slice(cwd.length + 1);
+            if (fp.startsWith(shellCwd + "/"))
+                fp = fp.slice(shellCwd.length + 1);
             else if (home && fp.startsWith(home + "/"))
                 fp = "~/" + fp.slice(home.length + 1);
             return loc.line ? `${fp}:${loc.line}` : fp;
@@ -642,11 +682,10 @@ export default function activate(ctx) {
         if (typeof raw.pattern === "string")
             return raw.pattern;
         if (typeof raw.path === "string") {
-            const cwd = process.cwd();
             const home = process.env.HOME;
             let fp = raw.path;
-            if (fp.startsWith(cwd + "/"))
-                fp = fp.slice(cwd.length + 1);
+            if (fp.startsWith(shellCwd + "/"))
+                fp = fp.slice(shellCwd.length + 1);
             else if (home && fp.startsWith(home + "/"))
                 fp = "~/" + fp.slice(home.length + 1);
             return fp;
@@ -674,7 +713,7 @@ export default function activate(ctx) {
             locations: extra?.locations,
             rawInput: extra?.rawInput,
             displayDetail: extra?.displayDetail,
-        }, cappedW());
+        }, cappedW(), shellCwd);
         if (extra?.groupContinuation && lines.length > 0) {
             // Swap the colored kind icon for a muted tree connector,
             // and strip the tool name prefix — show detail only.
@@ -879,58 +918,6 @@ export default function activate(ctx) {
             : `${p.success}+${diff.added}${p.reset} ${p.error}-${diff.removed}${p.reset}`;
         return `${p.dim}${filePath}${p.reset}  ${stats}`;
     }
-    function showFileDiff(filePath, diff) {
-        if (diff.isIdentical)
-            return;
-        contentGap("diff");
-        const lines = ctx.call("render:result-body", { kind: "diff", diff, filePath }, cappedW()) ?? [];
-        if (!s.renderer)
-            startAgentResponse();
-        for (const line of lines) {
-            s.renderer.writeLine(line);
-        }
-        drain();
-    }
-    function expandLastDiff() {
-        if (!s.lastTruncatedDiff)
-            return;
-        const entry = s.lastTruncatedDiff;
-        entry.expanded = !entry.expanded;
-        if (!entry.expanded) {
-            showFileDiffCached(entry);
-            return;
-        }
-        if (!entry.expandedLines) {
-            const { filePath, diff } = entry;
-            const boxW = Math.min(cappedW() - 2, out().columns - 2); // -2 for writeLine indent
-            const contentW = boxW - 4;
-            const diffLines = renderDiff(diff, {
-                width: contentW,
-                filePath,
-                maxLines: 500,
-                trueColor: true,
-            });
-            const body = diffLines.length > 1 ? ["", ...diffLines.slice(1), ""] : diffLines;
-            entry.expandedLines = renderBoxFrame(body, {
-                width: boxW,
-                style: "rounded",
-                borderColor: p.dim,
-                title: diffTitle(filePath, diff),
-                footer: [`  ${p.dim}ctrl+o to collapse${p.reset}`],
-            });
-        }
-        out().write("\n");
-        for (const line of entry.expandedLines) {
-            out().write(line + "\n");
-        }
-    }
-    function showFileDiffCached(entry) {
-        const lines = ctx.call("render:result-body", { kind: "diff", diff: entry.diff, filePath: entry.filePath }, cappedW()) ?? [];
-        out().write("\n");
-        for (const line of lines) {
-            out().write(line + "\n");
-        }
-    }
     function toggleThinkingDisplay() {
         s.showThinkingText = !s.showThinkingText;
         if (s.spinner) {

package/dist/index.js

@@ -15,6 +15,13 @@ import { discoverSkills } from "./agent/skills.js";
  */
 async function captureShellEnvAsync(shell) {
     return new Promise((resolve) => {
+        let settled = false;
+        const done = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            resolve(result);
+        };
         try {
             const shellName = path.basename(shell);
             const isZsh = shellName.includes("zsh");
@@ -30,8 +37,9 @@ async function captureShellEnvAsync(shell) {
                 output += data.toString("utf-8");
             });
             child.on("close", (code) => {
+                clearTimeout(timer);
                 if (code !== 0 || !output) {
-                    resolve({});
+                    done({});
                     return;
                 }
                 const env = {};
@@ -40,18 +48,19 @@ async function captureShellEnvAsync(shell) {
                     if (eq > 0)
                         env[entry.slice(0, eq)] = entry.slice(eq + 1);
                 }
-                resolve(env);
+                done(env);
             });
             child.on("error", () => {
-                resolve({});
+                clearTimeout(timer);
+                done({});
             });
-            setTimeout(() => {
+            const timer = setTimeout(() => {
                 child.kill("SIGTERM");
-                resolve({});
+                done({});
             }, 5000);
         }
         catch {
-            resolve({});
+            done({});
         }
     });
 }
@@ -245,6 +254,9 @@ async function main() {
     if (process.env.DEBUG) {
         console.error('[agent-sh] Extensions loaded');
     }
+    // Tell deferred-init listeners (agent-backend) that the provider
+    // registry is now complete.
+    core.bus.emit("core:extensions-loaded", {});
     // ── Discover skills ───────────────────────────────────────────
     const skills = discoverSkills(process.cwd());
     // ── Activate agent backend ────────────────────────────────────
@@ -281,6 +293,13 @@ async function main() {
                 sections += `\n    ${p.dim}${s.name}${p.reset}`;
             }
         }
+        const extSections = bus.emitPipe("banner:collect", { sections: [] }).sections;
+        for (const sec of extSections) {
+            sections += `\n\n  ${p.muted}${sec.label}:${p.reset}`;
+            for (const item of sec.items) {
+                sections += `\n    ${p.dim}${item}${p.reset}`;
+            }
+        }
         const hint = `${p.muted}Type ${p.warning}>${p.muted} to ask AI · ${p.warning}>/help${p.muted} for commands${p.reset}`;
         const borderLine = `${p.muted}${"─".repeat(bannerW)}${p.reset}`;
         process.stdout.write("\n" + borderLine + "\n" +

package/dist/settings.d.ts

@@ -32,44 +32,56 @@ export interface Settings {
     defaultProvider?: string;
     /** Preferred agent backend (extension name, e.g. "pi", "claude-code"). */
     defaultBackend?: string;
-    /** Recent exchanges included in agent context window. */
-    contextWindowSize?: number;
-    /** Context budget in bytes (~4 chars per token). */
-    contextBudget?: number;
-    /** Shell output lines before truncation kicks in. */
+    /** Shell output lines before spill-to-tempfile kicks in. */
     shellTruncateThreshold?: number;
-    /** Lines kept from start of truncated shell output. */
+    /** Lines kept from start of spilled shell output. */
     shellHeadLines?: number;
-    /** Lines kept from end of truncated shell output. */
+    /** Lines kept from end of spilled shell output. */
     shellTailLines?: number;
-    /** Max lines for recall expand before requiring line ranges. */
-    recallExpandMaxLines?: number;
-    /** Fraction of content budget allocated to shell context (0-1, default 0.35). */
-    shellContextRatio?: number;
     /** Max history file size in bytes (default: 102400 = 100KB). */
     historyMaxBytes?: number;
     /** Number of prior history entries to load on startup (default: 50). */
     historyStartupEntries?: number;
-    /** Max nuclear entries kept in-context before flushing to history file (default: 200). */
-    nuclearMaxEntries?: number;
     /** Auto-compact threshold as fraction of conversation budget (0-1, default 0.5). */
     autoCompactThreshold?: number;
     /** Max command output lines shown inline in TUI. */
     maxCommandOutputLines?: number;
     /** Max read tool output lines shown inline in TUI (0 = hide). */
     readOutputMaxLines?: number;
-    /** Max diff lines shown before "ctrl+o to expand". */
+    /** Max diff lines rendered in the TUI (Infinity = no limit). */
     diffMaxLines?: number;
-    /** Tool protocol: "api" (all tools), "deferred" (extensions via meta-tool), "inline" (text). */
-    toolMode?: "api" | "deferred" | "inline";
+    /** Tool protocol:
+     *   "api" — all tools sent with full schema.
+     *   "deferred" — extensions dispatched through `use_extension(name, args)` meta-tool.
+     *   "deferred-lookup" — extensions loaded on demand via `load_tool(names[])`; once loaded, callable as first-class tools.
+     *   "inline" — tools described as text.
+     */
+    toolMode?: "api" | "deferred" | "deferred-lookup" | "inline";
     /** Additional directories to scan for skills (supports ~ expansion). */
     skillPaths?: string[];
+    /**
+     * Enable the "diagnose" tool — lets the agent evaluate JavaScript
+     * expressions against its own runtime state. Powerful for introspection
+     * (e.g. this.conversation.turns.length) but grants arbitrary code
+     * execution within the agent process. Off by default because the
+     * agent already has unrestricted bash access — this is a convenience,
+     * not a new capability.
+     */
+    diagnose?: boolean;
     /** Show a startup banner when agent-sh launches. */
     startupBanner?: boolean;
     /** Show a subtle agent-sh indicator in the shell prompt. */
     promptIndicator?: boolean;
     /** Names of built-in extensions to disable (e.g. ["command-suggest"]). */
     disabledBuiltins?: string[];
+    /**
+     * Names of user extensions in ~/.agent-sh/extensions/ to skip when
+     * auto-discovering. Match by basename without extension for files
+     * (e.g. "peer-mesh" matches peer-mesh.ts), or by directory name for
+     * directory-style extensions (e.g. "superash" matches superash/index.ts).
+     * Beats having to rename files to .disabled every time.
+     */
+    disabledExtensions?: string[];
 }
 declare const DEFAULTS: Required<Settings>;
 /** Load settings from disk (cached after first call). */
@@ -87,6 +99,17 @@ export declare function getSettings(): Settings & typeof DEFAULTS;
 export declare function getExtensionSettings<T extends Record<string, unknown>>(namespace: string, defaults: T): T;
 /** Reset cached settings (for testing or after external edit). */
 export declare function reloadSettings(): void;
+/**
+ * Deep-merge a patch into ~/.agent-sh/settings.json on disk.
+ *
+ * Reads the raw file (preserving unknown keys), merges the patch, writes back
+ * with 2-space indentation, and clears the cache so subsequent getSettings()
+ * calls see the new values.
+ *
+ * Used by runtime controls (`/model`, `/backend`) that want their selection
+ * to persist as the default across restarts.
+ */
+export declare function updateSettings(patch: Record<string, unknown>): void;
 /**
  * Expand $ENV_VAR references in a string.
  * Supports $VAR and ${VAR} syntax.

package/dist/settings.js

@@ -16,24 +16,21 @@ const DEFAULTS = {
     defaultProvider: undefined,
     defaultBackend: "ash",
     toolMode: "api",
-    contextWindowSize: 20,
-    contextBudget: 16384,
-    shellTruncateThreshold: 10,
-    shellHeadLines: 5,
-    shellTailLines: 5,
-    recallExpandMaxLines: 100,
-    shellContextRatio: 0.35,
-    historyMaxBytes: 102400,
-    historyStartupEntries: 50,
-    nuclearMaxEntries: 200,
+    shellTruncateThreshold: 20,
+    shellHeadLines: 10,
+    shellTailLines: 10,
+    historyMaxBytes: 104857600, // 100MB — history is only accessed via search/expand, never loaded wholesale
+    historyStartupEntries: 100,
     autoCompactThreshold: 0.5,
     maxCommandOutputLines: 3,
     readOutputMaxLines: 10,
-    diffMaxLines: 20,
+    diffMaxLines: Infinity,
     skillPaths: [],
+    diagnose: false,
     startupBanner: true,
     promptIndicator: true,
     disabledBuiltins: [],
+    disabledExtensions: [],
 };
 let cached = null;
 /** Load settings from disk (cached after first call). */
@@ -74,6 +71,49 @@ export function getExtensionSettings(namespace, defaults) {
 export function reloadSettings() {
     cached = null;
 }
+/**
+ * Deep-merge a patch into ~/.agent-sh/settings.json on disk.
+ *
+ * Reads the raw file (preserving unknown keys), merges the patch, writes back
+ * with 2-space indentation, and clears the cache so subsequent getSettings()
+ * calls see the new values.
+ *
+ * Used by runtime controls (`/model`, `/backend`) that want their selection
+ * to persist as the default across restarts.
+ */
+export function updateSettings(patch) {
+    let existing = {};
+    try {
+        const raw = fs.readFileSync(SETTINGS_PATH, "utf-8");
+        existing = JSON.parse(raw);
+    }
+    catch {
+        // file missing or unreadable — start fresh
+    }
+    const merged = deepMerge(existing, patch);
+    try {
+        fs.mkdirSync(CONFIG_DIR, { recursive: true });
+        fs.writeFileSync(SETTINGS_PATH, JSON.stringify(merged, null, 2) + "\n", "utf-8");
+        cached = null;
+    }
+    catch (err) {
+        console.error(`[agent-sh] Warning: failed to update ${SETTINGS_PATH}: ${err.message}`);
+    }
+}
+function deepMerge(target, source) {
+    const out = { ...target };
+    for (const [key, val] of Object.entries(source)) {
+        const existing = out[key];
+        if (val !== null && typeof val === "object" && !Array.isArray(val) &&
+            existing !== null && typeof existing === "object" && !Array.isArray(existing)) {
+            out[key] = deepMerge(existing, val);
+        }
+        else {
+            out[key] = val;
+        }
+    }
+    return out;
+}
 /**
  * Expand $ENV_VAR references in a string.
  * Supports $VAR and ${VAR} syntax.

package/dist/shell/input-handler.d.ts

@@ -28,7 +28,8 @@ export declare class InputHandler {
     private history;
     private historyIndex;
     private savedBuffer;
-    private promptWrappedLines;
+    private cursorRowsBelow;
+    private cursorTermCol;
     private escapeTimer;
     private bus;
     private onShowAgentInfo;