agent-sh 0.8.0 → 0.10.0

package/dist/extensions/agent-backend.js

@@ -0,0 +1,188 @@
+import { AgentLoop } from "../agent/agent-loop.js";
+import { LlmClient } from "../utils/llm-client.js";
+import { resolveProvider, getProviderNames, getSettings } from "../settings.js";
+/** Read the user's persisted defaultModel for a provider, if any. */
+function persistedModelFor(providerName) {
+    if (!providerName)
+        return undefined;
+    return getSettings().providers?.[providerName]?.defaultModel;
+}
+export default function agentBackend(ctx) {
+    const { bus } = ctx;
+    const config = ctx.call("config:get-shell-config") ?? {};
+    // Seed from settings.json; runtime provider:register events add more.
+    const providerRegistry = new Map();
+    for (const name of getProviderNames()) {
+        const p = resolveProvider(name);
+        if (p)
+            providerRegistry.set(name, p);
+    }
+    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;
+    };
+    // Placeholder client — reconfigured at core:extensions-loaded. Any
+    // stream() call before then fails from the OpenAI SDK; start() won't
+    // wire the loop until we've resolved, so users never hit that path.
+    const llmClient = new LlmClient({ apiKey: "not-configured", model: "not-configured" });
+    ctx.define("llm:get-client", () => llmClient);
+    let modes = [];
+    let initialModeIndex = 0;
+    let resolved = false;
+    bus.onPipe("config:get-initial-modes", () => ({ modes, initialModeIndex }));
+    // AgentLoop must be constructed *before* user extensions activate,
+    // because its ctor defines handlers (history:append, etc.) that
+    // extensions like superash call synchronously during their own
+    // activate. Advise-before-define works for advisers, but plain calls
+    // would hit a no-op stub.
+    const agentLoop = new AgentLoop({
+        bus,
+        contextManager: ctx.contextManager,
+        llmClient,
+        handlers: { define: ctx.define, advise: ctx.advise, call: ctx.call, list: ctx.list },
+        modes,
+        initialModeIndex,
+        compositor: ctx.compositor,
+        instanceId: ctx.instanceId,
+    });
+    bus.emit("agent:register-backend", {
+        name: "ash",
+        kill: () => agentLoop.kill(),
+        start: async () => {
+            if (!resolved) {
+                bus.emit("ui:error", { message: "Agent backend not started — no LLM provider available. See earlier messages." });
+                return;
+            }
+            agentLoop.wire();
+            bus.emit("agent:info", {
+                name: "ash",
+                version: "0.4",
+                model: llmClient.model,
+                provider: modes[initialModeIndex]?.provider,
+                contextWindow: modes[initialModeIndex]?.contextWindow,
+            });
+        },
+    });
+    bus.on("core:extensions-loaded", () => {
+        const settings = getSettings();
+        const providerName = config.provider ?? settings.defaultProvider;
+        const activeProvider = providerName ? providerRegistry.get(providerName) ?? null : null;
+        // User's persisted defaultModel wins over the provider's declared
+        // default. Dynamic providers (openrouter) re-register with their
+        // hardcoded DEFAULT_MODELS[0] each startup, which would otherwise
+        // clobber the user's /model selection.
+        const effectiveApiKey = config.apiKey ?? activeProvider?.apiKey;
+        const effectiveBaseURL = config.baseURL ?? activeProvider?.baseURL;
+        const effectiveModel = config.model ?? persistedModelFor(providerName) ?? activeProvider?.defaultModel;
+        if (!effectiveApiKey) {
+            bus.emit("ui:error", { message: "No LLM provider configured. Set --api-key, configure a provider in ~/.agent-sh/settings.json, or load a provider extension (e.g. openrouter) that sets OPENROUTER_API_KEY." });
+            return;
+        }
+        if (!effectiveModel) {
+            bus.emit("ui:error", { message: "No model specified. Use --model or configure a provider with defaultModel in ~/.agent-sh/settings.json" });
+            return;
+        }
+        modes = buildModes();
+        if (modes.length === 0)
+            modes = [{ model: effectiveModel }];
+        initialModeIndex = Math.max(0, modes.findIndex((m) => m.model === effectiveModel && (!activeProvider || m.provider === activeProvider.id)));
+        llmClient.reconfigure({ apiKey: effectiveApiKey, baseURL: effectiveBaseURL, model: effectiveModel });
+        bus.emit("config:set-modes", { modes, activeIndex: initialModeIndex });
+        resolved = true;
+        // start() emits agent:info after wiring.
+    });
+    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 });
+        // Late-registration reconcile: if this completes the user's persisted
+        // default (openrouter's async fetch delivers the full catalog after
+        // we've already fallen back to mode 0), quietly switch to it.
+        if (!resolved)
+            return;
+        const pendingProvider = getSettings().defaultProvider;
+        if (pendingProvider !== p.id)
+            return;
+        const pendingModel = persistedModelFor(pendingProvider);
+        if (pendingModel && modelIds.includes(pendingModel) && llmClient.model !== pendingModel) {
+            bus.emit("config:switch-model", { model: pendingModel });
+        }
+    });
+    bus.on("config:switch-provider", ({ provider: name }) => {
+        const p = providerRegistry.get(name);
+        if (!p) {
+            bus.emit("ui:error", { message: `Unknown provider: ${name}` });
+            return;
+        }
+        if (!p.apiKey) {
+            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: p.apiKey, baseURL: p.baseURL, model: switchModel });
+        const newModes = p.models.map((m) => {
+            const mc = p.modelCapabilities?.get(m);
+            return {
+                model: m,
+                provider: name,
+                providerConfig: { apiKey: p.apiKey, baseURL: p.baseURL },
+                contextWindow: mc?.contextWindow ?? p.contextWindow,
+                reasoning: mc?.reasoning,
+                supportsReasoningEffort: p.supportsReasoningEffort,
+            };
+        });
+        bus.emit("config:set-modes", { modes: newModes });
+        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,24 @@
+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) },
+];
+/**
+ * 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}`;
@@ -77,7 +79,7 @@ export default function activate({ bus, contextManager }) {
     });
     register({
         name: "/compact",
-        description: "Compact conversation (move full content to nuclear summaries)",
+        description: "Compact conversation via the active compaction strategy",
         handler: () => {
             bus.emit("agent:compact-request", {});
         },
@@ -88,25 +90,43 @@ export default function activate({ bus, contextManager }) {
         handler: () => {
             const stats = bus.emitPipe("context:get-stats", {
                 activeTokens: 0,
-                nuclearEntries: 0,
-                recallArchiveSize: 0,
+                totalTokens: 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") });
+            bus.emit("ui:info", {
+                message: `Active context: ~${stats.activeTokens.toLocaleString()} tokens / ${stats.budgetTokens.toLocaleString()} budget (${pct}%)`,
+            });
+        },
+    });
+    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." });
+            }
         },
     });
+    // Handler form so extensions can trigger reload programmatically
+    // (e.g. an ash-callable reload_extensions tool in superash).
+    ctx.define("extensions:reload", async () => {
+        return await reloadExtensions(ctx);
+    });
     // ── Extension registration ────────────────────────────────────
     bus.on("command:register", (cmd) => {
         register(cmd);
     });
+    bus.on("command:unregister", ({ name }) => {
+        const key = name.startsWith("/") ? name : `/${name}`;
+        commands.delete(key);
+    });
     // ── Skill commands (/skill:<name>) ────────────────────────────
     const getSkills = () => {
         const cwd = contextManager?.getCwd() ?? process.cwd();