agent-sh 0.7.0 → 0.9.0

package/dist/extensions/agent-backend.js

@@ -0,0 +1,167 @@
+import { AgentLoop } from "../agent/agent-loop.js";
+import { LlmClient } from "../utils/llm-client.js";
+import { resolveProvider, getProviderNames, getSettings } from "../settings.js";
+export default function agentBackend(ctx) {
+    const { bus } = ctx;
+    // ── Resolve providers ──────────────────────────────────────
+    const config = ctx.call("config:get-shell-config") ?? {};
+    const settings = getSettings();
+    let activeProvider = null;
+    const providerRegistry = new Map();
+    for (const name of getProviderNames()) {
+        const p = resolveProvider(name);
+        if (p)
+            providerRegistry.set(name, p);
+    }
+    const providerName = config.provider ?? settings.defaultProvider;
+    if (providerName) {
+        activeProvider = providerRegistry.get(providerName) ?? null;
+    }
+    // ── Build modes ────────────────────────────────────────────
+    const buildModes = () => {
+        const allModes = [];
+        for (const [id, p] of providerRegistry) {
+            if (!p.apiKey)
+                continue;
+            for (const model of p.models) {
+                const mc = p.modelCapabilities?.get(model);
+                allModes.push({
+                    model,
+                    provider: id,
+                    providerConfig: { apiKey: p.apiKey, baseURL: p.baseURL },
+                    contextWindow: mc?.contextWindow ?? p.contextWindow,
+                    reasoning: mc?.reasoning,
+                    supportsReasoningEffort: p.supportsReasoningEffort,
+                });
+            }
+        }
+        return allModes;
+    };
+    const effectiveApiKey = config.apiKey ?? activeProvider?.apiKey;
+    const effectiveBaseURL = config.baseURL ?? activeProvider?.baseURL;
+    const effectiveModel = config.model ?? activeProvider?.defaultModel;
+    let modes = buildModes();
+    if (modes.length === 0 && effectiveApiKey && effectiveModel) {
+        modes = [{ model: effectiveModel }];
+    }
+    const initialModeIndex = Math.max(0, modes.findIndex((m) => m.model === effectiveModel && (!activeProvider || m.provider === activeProvider.id)));
+    // ── Create LLM client ─────────────────────────────────────
+    if (!effectiveApiKey)
+        return; // No LLM provider configured — skip
+    if (!effectiveModel) {
+        bus.emit("ui:error", { message: "No model specified. Use --model or configure a provider with defaultModel in ~/.agent-sh/settings.json" });
+        return;
+    }
+    const llmClient = new LlmClient({
+        apiKey: effectiveApiKey,
+        baseURL: effectiveBaseURL,
+        model: effectiveModel,
+    });
+    // Expose LLM client for other extensions (e.g. command-suggest)
+    ctx.define("llm:get-client", () => llmClient);
+    // ── Initial modes (queryable via pipe) ─────────────────────
+    bus.onPipe("config:get-initial-modes", () => ({
+        modes,
+        initialModeIndex,
+    }));
+    // ── Create agent loop ──────────────────────────────────────
+    const agentLoop = new AgentLoop({
+        bus,
+        contextManager: ctx.contextManager,
+        llmClient,
+        handlers: { define: ctx.define, advise: ctx.advise, call: ctx.call },
+        modes,
+        initialModeIndex,
+        compositor: ctx.compositor,
+    });
+    // Register as backend
+    bus.emit("agent:register-backend", {
+        name: "ash",
+        kill: () => agentLoop.kill(),
+        start: async () => {
+            agentLoop.wire();
+            bus.emit("agent:info", {
+                name: "ash",
+                version: "0.4",
+                model: llmClient.model,
+                provider: modes[initialModeIndex]?.provider,
+                contextWindow: modes[initialModeIndex]?.contextWindow,
+            });
+        },
+    });
+    // ── Runtime provider registration ──────────────────────────
+    bus.on("provider:register", (p) => {
+        const rawModels = p.models ?? (p.defaultModel ? [p.defaultModel] : []);
+        const modelIds = [];
+        const caps = new Map();
+        for (const m of rawModels) {
+            if (typeof m === "string") {
+                modelIds.push(m);
+            }
+            else {
+                modelIds.push(m.id);
+                caps.set(m.id, { reasoning: m.reasoning, contextWindow: m.contextWindow });
+            }
+        }
+        providerRegistry.set(p.id, {
+            id: p.id,
+            apiKey: p.apiKey,
+            baseURL: p.baseURL,
+            defaultModel: p.defaultModel,
+            models: modelIds,
+            supportsReasoningEffort: p.supportsReasoningEffort,
+            modelCapabilities: caps.size > 0 ? caps : undefined,
+        });
+        const addModes = modelIds.map((m) => {
+            const mc = caps.get(m);
+            return {
+                model: m,
+                provider: p.id,
+                providerConfig: { apiKey: p.apiKey ?? "", baseURL: p.baseURL },
+                contextWindow: mc?.contextWindow,
+                reasoning: mc?.reasoning,
+                supportsReasoningEffort: p.supportsReasoningEffort,
+            };
+        });
+        bus.emit("config:add-modes", { modes: addModes });
+    });
+    // ── Runtime provider switching ─────────────────────────────
+    bus.on("config:switch-provider", ({ provider: name }) => {
+        const p = providerRegistry.get(name);
+        if (!p) {
+            bus.emit("ui:error", { message: `Unknown provider: ${name}` });
+            return;
+        }
+        const newApiKey = p.apiKey;
+        if (!newApiKey) {
+            bus.emit("ui:error", { message: `Provider "${name}" has no API key configured` });
+            return;
+        }
+        const switchModel = p.defaultModel ?? p.models[0];
+        if (!switchModel) {
+            bus.emit("ui:error", { message: `Provider "${name}" has no models configured` });
+            return;
+        }
+        llmClient.reconfigure({
+            apiKey: newApiKey,
+            baseURL: p.baseURL,
+            model: switchModel,
+        });
+        const newModes = p.models.map((m) => {
+            const mc = p.modelCapabilities?.get(m);
+            return {
+                model: m,
+                provider: name,
+                providerConfig: { apiKey: newApiKey, baseURL: p.baseURL },
+                contextWindow: mc?.contextWindow ?? p.contextWindow,
+                reasoning: mc?.reasoning,
+                supportsReasoningEffort: p.supportsReasoningEffort,
+            };
+        });
+        bus.emit("config:set-modes", { modes: newModes });
+        activeProvider = p;
+        bus.emit("agent:info", { name: "ash", version: "0.4", model: switchModel, provider: name, contextWindow: p.contextWindow });
+        bus.emit("ui:info", { message: `Switched to ${name} (${switchModel})` });
+        bus.emit("config:changed", {});
+    });
+}

package/dist/extensions/command-suggest.d.ts

@@ -1,10 +1,10 @@
 /**
  * Command suggestion extension (fast-path LLM feature).
  *
- * After a shell command fails (non-zero exit), uses llmClient.complete()
+ * After a shell command fails (non-zero exit), uses LlmClient.complete()
  * to suggest a fix. Shows the suggestion below the prompt.
  *
- * Only active when llmClient is available (internal agent mode).
+ * Only active when an LLM client is available (registered by agent-backend).
  */
 import type { ExtensionContext } from "../types.js";
-export default function activate({ bus, llmClient }: ExtensionContext): void;
+export default function activate({ bus, call }: ExtensionContext): void;

package/dist/extensions/command-suggest.js

@@ -1,6 +1,4 @@
-export default function activate({ bus, llmClient }) {
-    if (!llmClient)
-        return;
+export default function activate({ bus, call }) {
     let suggesting = false;
     bus.on("shell:command-done", ({ command, output, exitCode, cwd }) => {
         if (exitCode === null || exitCode === 0)
@@ -9,6 +7,9 @@ export default function activate({ bus, llmClient }) {
             return;
         if (suggesting)
             return; // don't stack suggestions
+        const llmClient = call("llm:get-client");
+        if (!llmClient)
+            return;
         suggesting = true;
         // Truncate output to avoid blowing up the prompt
         const truncated = output.length > 1000

package/dist/extensions/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Built-in extension manifest.
+ *
+ * These extensions ship with agent-sh and load before user extensions.
+ * They receive unscoped contexts (not reloadable) and can be individually
+ * disabled via the `disabledBuiltins` setting in ~/.agent-sh/settings.json.
+ */
+import type { ExtensionContext } from "../types.js";
+type ActivateFn = (ctx: ExtensionContext) => void;
+export declare const BUILTIN_EXTENSIONS: Array<{
+    name: string;
+    load: () => Promise<ActivateFn>;
+}>;
+/**
+ * Load built-in extensions sequentially, skipping any in the disabled list.
+ * Returns the names of extensions that were loaded.
+ */
+export declare function loadBuiltinExtensions(ctx: ExtensionContext, disabled?: string[]): Promise<string[]>;
+export {};

package/dist/extensions/index.js

@@ -0,0 +1,25 @@
+export const BUILTIN_EXTENSIONS = [
+    { name: "agent-backend", load: () => import("./agent-backend.js").then(m => m.default) },
+    { name: "tui-renderer", load: () => import("./tui-renderer.js").then(m => m.default) },
+    { name: "slash-commands", load: () => import("./slash-commands.js").then(m => m.default) },
+    { name: "file-autocomplete", load: () => import("./file-autocomplete.js").then(m => m.default) },
+    { name: "shell-recall", load: () => import("./shell-recall.js").then(m => m.default) },
+    { name: "command-suggest", load: () => import("./command-suggest.js").then(m => m.default) },
+    { name: "terminal-buffer", load: () => import("./terminal-buffer.js").then(m => m.default) },
+];
+/**
+ * Load built-in extensions sequentially, skipping any in the disabled list.
+ * Returns the names of extensions that were loaded.
+ */
+export async function loadBuiltinExtensions(ctx, disabled = []) {
+    const disabledSet = new Set(disabled);
+    const loaded = [];
+    for (const ext of BUILTIN_EXTENSIONS) {
+        if (disabledSet.has(ext.name))
+            continue;
+        const activate = await ext.load();
+        activate(ctx);
+        loaded.push(ext.name);
+    }
+    return loaded;
+}

package/dist/extensions/slash-commands.d.ts

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

package/dist/extensions/slash-commands.js

@@ -12,7 +12,9 @@
  */
 import { palette as p } from "../utils/palette.js";
 import { discoverSkills, loadSkillContent } from "../agent/skills.js";
-export default function activate({ bus, contextManager }) {
+import { reloadExtensions } from "../extension-loader.js";
+export default function activate(ctx) {
+    const { bus, contextManager } = ctx;
     const commands = new Map();
     const register = (cmd) => {
         const name = cmd.name.startsWith("/") ? cmd.name : `/${cmd.name}`;
@@ -75,6 +77,47 @@ export default function activate({ bus, contextManager }) {
             }
         },
     });
+    register({
+        name: "/compact",
+        description: "Compact conversation (move full content to nuclear summaries)",
+        handler: () => {
+            bus.emit("agent:compact-request", {});
+        },
+    });
+    register({
+        name: "/context",
+        description: "Show context budget usage",
+        handler: () => {
+            const stats = bus.emitPipe("context:get-stats", {
+                activeTokens: 0,
+                nuclearEntries: 0,
+                recallArchiveSize: 0,
+                budgetTokens: 0,
+            });
+            const pct = stats.budgetTokens > 0
+                ? Math.round((stats.activeTokens / stats.budgetTokens) * 100)
+                : 0;
+            const lines = [
+                `Active context: ~${stats.activeTokens.toLocaleString()} tokens / ${stats.budgetTokens.toLocaleString()} budget (${pct}%)`,
+                `Nuclear entries: ${stats.nuclearEntries} in-context`,
+                `Recall archive: ${stats.recallArchiveSize} entries`,
+            ];
+            bus.emit("ui:info", { message: lines.join("\n") });
+        },
+    });
+    register({
+        name: "/reload",
+        description: "Reload user extensions from ~/.agent-sh/extensions/",
+        handler: async () => {
+            const names = await reloadExtensions(ctx);
+            if (names.length > 0) {
+                bus.emit("ui:info", { message: `Reloaded: ${names.join(", ")}` });
+            }
+            else {
+                bus.emit("ui:info", { message: "No extensions to reload." });
+            }
+        },
+    });
     // ── Extension registration ────────────────────────────────────
     bus.on("command:register", (cmd) => {
         register(cmd);

package/dist/extensions/terminal-buffer.d.ts

@@ -11,4 +11,4 @@
  * Requires: npm install @xterm/headless@5.5.0 @xterm/addon-serialize@0.13.0
  */
 import type { ExtensionContext } from "../types.js";
-export default function activate({ bus, terminalBuffer: tb, registerTool }: ExtensionContext): void;
+export default function activate(ctx: ExtensionContext): void;

package/dist/extensions/terminal-buffer.js

@@ -19,17 +19,26 @@ function interpretEscapes(str) {
 function settle(ms = 100) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
-export default function activate({ bus, terminalBuffer: tb, registerTool }) {
+export default function activate(ctx) {
+    const { bus, terminalBuffer: tb, registerTool, registerInstruction } = ctx;
     if (!tb)
         return; // @xterm/headless not installed
     registerTool({
         name: "terminal_read",
-        description: "Read the current terminal screen contents. Returns clean text (ANSI stripped) " +
+        description: "Read what is currently visible on the user's terminal screen. Returns clean text (ANSI stripped) " +
             "with cursor position and whether an alternate-screen program (vim, htop, less) is active. " +
-            "Use this to see what the user sees before sending keystrokes with terminal_keys.",
+            "Use this to observe what the user sees — helpful for answering questions about terminal output, " +
+            "diagnosing errors on screen, or checking state before/after sending keystrokes with terminal_keys.",
         input_schema: {
             type: "object",
-            properties: {},
+            properties: {
+                include_scrollback: {
+                    type: "boolean",
+                    description: "If true, include scrollback buffer (content that scrolled off screen) " +
+                        "in addition to the visible viewport. Useful for capturing output from " +
+                        "long-running or streaming commands. Default: false.",
+                },
+            },
         },
         showOutput: true,
         getDisplayInfo: () => ({
@@ -37,8 +46,9 @@ export default function activate({ bus, terminalBuffer: tb, registerTool }) {
             icon: "⊞",
             locations: [],
         }),
-        async execute() {
-            const { text, altScreen, cursorX, cursorY } = tb.readScreen();
+        async execute(args) {
+            const includeScrollback = args.include_scrollback ?? false;
+            const { text, altScreen, cursorX, cursorY } = tb.readScreen({ includeScrollback });
             const info = [
                 altScreen ? "mode: alternate screen" : "mode: normal",
                 `cursor: row=${cursorY} col=${cursorX}`,
@@ -52,8 +62,11 @@ export default function activate({ bus, terminalBuffer: tb, registerTool }) {
     });
     registerTool({
         name: "terminal_keys",
-        description: "Send keystrokes to the user's live terminal. The keys are written directly to the PTY " +
-            "as if the user typed them. Use escape sequences for special keys:\n" +
+        description: "Send keystrokes directly into the user's live terminal PTY, as if the user typed them. " +
+            "Use this to interact with programs already running in the terminal (vim, htop, less, ssh, REPLs, etc.) " +
+            "or to type commands at the shell prompt. Do NOT use user_shell for this — user_shell runs a new " +
+            "command in a subshell, while terminal_keys types into whatever is currently on screen.\n\n" +
+            "Escape sequences for special keys:\n" +
             "  - Escape: \\x1b\n" +
             "  - Enter/Return: \\r\n" +
             "  - Tab: \\t\n" +
@@ -105,6 +118,7 @@ export default function activate({ bus, terminalBuffer: tb, registerTool }) {
             process.stdout.write("\n");
             bus.emit("shell:pty-write", { data: keys });
             await settle(settleMs);
+            bus.emit("shell:stdout-hide", {});
             const { text, altScreen, cursorX, cursorY } = tb.readScreen();
             const info = [
                 altScreen ? "mode: alternate screen" : "mode: normal",