agent-sh 0.12.26 → 0.12.27

package/dist/agent/agent-loop.js

@@ -1105,7 +1105,7 @@ export class AgentLoop {
                 // Compact deeply — shallow targets buy only 1–2 turns of runway on
                 // tool-heavy workloads.
                 const target = Math.floor(threshold * 0.25);
-                const result = this.compactWithHooks(target, 6);
+                const result = this.compactWithHooks(target, 1);
                 if (!result) {
                     // Auto-compact fired but nothing was evictable. This can happen
                     // in short conversations with heavy tool output where the pin
@@ -1488,7 +1488,7 @@ export class AgentLoop {
                 if (this.isContextOverflow(e)) {
                     const contextWindow = this.currentMode.contextWindow ?? DEFAULT_CONTEXT_WINDOW;
                     const target = Math.floor((contextWindow - RESPONSE_RESERVE) * 0.6);
-                    const stats = this.compactWithHooks(target, 6);
+                    const stats = this.compactWithHooks(target, 1);
                     // If compaction freed nothing, retrying will hit the same error.
                     // Surface the real failure instead of looping until exhaustion.
                     if (!stats || stats.after >= stats.before) {

package/dist/agent/conversation-state.js

@@ -29,6 +29,19 @@ function firstMatchExcerpt(text, regex) {
 function recencyWeight(idx, total) {
     return Math.max(0.1, 1 - idx / total);
 }
+// Head+tail because the start (command, opening lines) and end (final
+// result, exit code) are the informative parts of shell/file output.
+function slimToolContent(content, maxLen) {
+    const exitMatch = content.match(/exit code:?\s*(\d+)/i);
+    const exitSuffix = exitMatch ? ` (exit ${exitMatch[1]})` : "";
+    const lines = content.split("\n");
+    if (lines.length > 6) {
+        const head = lines.slice(0, 3).join("\n");
+        const tail = lines.slice(-2).join("\n");
+        return `${head}\n... [${lines.length - 5} lines trimmed by compact]\n${tail}${exitSuffix}`;
+    }
+    return `${content.slice(0, maxLen)}\n... [${content.length - maxLen} chars trimmed by compact]${exitSuffix}`;
+}
 /**
  * Conversation state with eager nucleation — shell-history shaped.
  *
@@ -611,6 +624,7 @@ export class ConversationState {
     // ── Internal: Two-tier pin for recent turns ────────────────────
     slimTurn(messages) {
         const MAX_RESULT_LEN = 1500;
+        const MAX_ASSISTANT_LEN = 1500;
         const result = [];
         const droppedToolIds = new Set();
         for (const msg of messages) {
@@ -642,13 +656,20 @@ export class ConversationState {
                     continue;
                 const content = typeof msg.content === "string" ? msg.content : "";
                 if (content.length > MAX_RESULT_LEN) {
-                    result.push({ ...msg, content: content.slice(0, MAX_RESULT_LEN) + "\n... [truncated by compact]" });
+                    result.push({ ...msg, content: slimToolContent(content, MAX_RESULT_LEN) });
                 }
                 else {
                     result.push(msg);
                 }
                 continue;
             }
+            if (msg.role === "assistant" && typeof msg.content === "string" && msg.content.length > MAX_ASSISTANT_LEN) {
+                const head = msg.content.slice(0, Math.floor(MAX_ASSISTANT_LEN * 0.6));
+                const tail = msg.content.slice(-Math.floor(MAX_ASSISTANT_LEN * 0.2));
+                const trimmed = msg.content.length - head.length - tail.length;
+                result.push({ ...msg, content: `${head}\n... [${trimmed} chars trimmed by compact]\n${tail}` });
+                continue;
+            }
             result.push(msg);
         }
         return result;

package/dist/install.js

@@ -69,11 +69,13 @@ function pickResolver(spec) {
             return r;
     return bundledResolver;
 }
-function maybeNpmInstall(target) {
+function readPackageJson(target) {
     const pkgJson = path.join(target, "package.json");
     if (!fs.existsSync(pkgJson))
-        return;
-    const pkg = JSON.parse(fs.readFileSync(pkgJson, "utf-8"));
+        return null;
+    return JSON.parse(fs.readFileSync(pkgJson, "utf-8"));
+}
+function maybeNpmInstall(target, pkg) {
     const deps = { ...(pkg.dependencies ?? {}), ...(pkg.peerDependencies ?? {}) };
     if (Object.keys(deps).length === 0)
         return;
@@ -88,6 +90,56 @@ function maybeNpmInstall(target) {
         throw new Error(`npm install failed in ${target}; run it manually.`);
     }
 }
+function normalizeBin(pkg) {
+    if (!pkg.bin)
+        return {};
+    if (typeof pkg.bin === "string") {
+        const name = pkg.name?.startsWith("@") ? pkg.name.split("/")[1] : pkg.name;
+        return name ? { [name]: pkg.bin } : {};
+    }
+    return pkg.bin;
+}
+function maybeNpmBuild(target, pkg) {
+    if (!pkg.scripts?.build)
+        return;
+    const binPaths = Object.values(normalizeBin(pkg)).map((p) => path.join(target, p));
+    if (binPaths.length === 0)
+        return;
+    if (binPaths.every((p) => fs.existsSync(p)))
+        return;
+    console.log(`Running npm run build in ${target}...`);
+    const result = spawnSync("npm", ["run", "build"], { cwd: target, stdio: "inherit" });
+    if (result.status !== 0) {
+        throw new Error(`npm run build failed in ${target}; run it manually.`);
+    }
+}
+function linkBins(target, pkg) {
+    const bins = normalizeBin(pkg);
+    if (Object.keys(bins).length === 0)
+        return [];
+    const binDir = path.join(CONFIG_DIR, "bin");
+    fs.mkdirSync(binDir, { recursive: true });
+    const linked = [];
+    for (const [name, relPath] of Object.entries(bins)) {
+        const src = path.resolve(target, relPath);
+        if (!fs.existsSync(src)) {
+            console.error(`agent-sh: skipping bin "${name}" — ${src} not found`);
+            continue;
+        }
+        try {
+            fs.chmodSync(src, 0o755);
+        }
+        catch { /* ignore */ }
+        const linkPath = path.join(binDir, name);
+        try {
+            fs.unlinkSync(linkPath);
+        }
+        catch { /* ignore */ }
+        fs.symlinkSync(src, linkPath);
+        linked.push(name);
+    }
+    return linked;
+}
 export async function runInstall(spec, opts = {}) {
     if (!spec) {
         console.error("Usage: agent-sh install <name|file:|npm:|github:> [--force]\n\n" +
@@ -114,10 +166,16 @@ export async function runInstall(spec, opts = {}) {
         }
         fs.rmSync(target, { recursive: true, force: true });
     }
+    let linkedBins = [];
     if (resolved.isDirectory) {
         fs.cpSync(resolved.sourcePath, target, { recursive: true });
         try {
-            maybeNpmInstall(target);
+            const pkg = readPackageJson(target);
+            if (pkg) {
+                maybeNpmInstall(target, pkg);
+                maybeNpmBuild(target, pkg);
+                linkedBins = linkBins(target, pkg);
+            }
         }
         catch (err) {
             console.error(`agent-sh: ${err instanceof Error ? err.message : String(err)}`);
@@ -128,6 +186,11 @@ export async function runInstall(spec, opts = {}) {
         fs.copyFileSync(resolved.sourcePath, target);
     }
     console.log(`Installed: ${resolved.name} -> ${target}`);
+    if (linkedBins.length > 0) {
+        const binDir = path.join(CONFIG_DIR, "bin");
+        console.log(`Linked bins: ${linkedBins.join(", ")} -> ${binDir}`);
+        console.log(`Add to PATH: export PATH="${binDir}:$PATH"`);
+    }
 }
 export async function runUninstall(name) {
     if (!name) {
@@ -146,6 +209,23 @@ export async function runUninstall(name) {
         console.error(`agent-sh: not installed: ${name}`);
         process.exit(1);
     }
+    const pkg = readPackageJson(target);
+    if (pkg) {
+        const binDir = path.join(CONFIG_DIR, "bin");
+        const targetPrefix = path.resolve(target) + path.sep;
+        for (const binName of Object.keys(normalizeBin(pkg))) {
+            const linkPath = path.join(binDir, binName);
+            try {
+                const stat = fs.lstatSync(linkPath, { throwIfNoEntry: false });
+                if (!stat?.isSymbolicLink())
+                    continue;
+                const dest = path.resolve(binDir, fs.readlinkSync(linkPath));
+                if (dest.startsWith(targetPrefix))
+                    fs.unlinkSync(linkPath);
+            }
+            catch { /* ignore */ }
+        }
+    }
     fs.rmSync(target, { recursive: true, force: true });
     console.log(`Uninstalled: ${name}`);
 }

package/dist/utils/floating-panel.d.ts

@@ -147,7 +147,8 @@ export declare class FloatingPanel {
      *   - `{prefix}:render-border-bottom(ctx: FrameContext) -> string`
      *   - `{prefix}:composite-row(content: string, bgLine: string|null, boxLeft: number, boxW: number, cols: number) -> string`
      *   - `{prefix}:submit(query: string) -> void`
-     *   - `{prefix}:dismiss() -> void`
+     *   - `{prefix}:hide() -> void`    (screen down; conversation state preserved)
+     *   - `{prefix}:reset() -> void`   (conversation state cleared)
      *   - `{prefix}:show() -> void`
      *   - `{prefix}:input(data: string) -> boolean`
      *   - `{prefix}:build-row(content: string, width: number) -> string`
@@ -177,6 +178,9 @@ export declare class FloatingPanel {
     private wrapCacheWidth;
     private passthroughTimer;
     private prevSerialized;
+    private autocompleteItems;
+    private autocompleteIndex;
+    private autocompleteActive;
     constructor(bus: EventBus, config: FloatingPanelConfig, handlers?: HandlerRegistry);
     private registerDefaultHandlers;
     private wireEvents;
@@ -196,8 +200,10 @@ export declare class FloatingPanel {
     hide(): void;
     /** Show the panel again after hide(), preserving conversation. */
     show(): void;
-    /** Fully destroy the panel, resetting all state. */
-    dismiss(): void;
+    /** End the conversation: screen down and all buffered state cleared. */
+    reset(): void;
+    /** Screen-only teardown; conversation state is left untouched. */
+    private teardownToHidden;
     /** Common screen enter logic shared by open() and show(). */
     private enterScreen;
     appendText(text: string): void;
@@ -213,8 +219,14 @@ export declare class FloatingPanel {
     scrollDown(lines?: number): void;
     getInput(): string;
     requestRender(): void;
+    private updateAutocomplete;
+    private applyAutocomplete;
+    private clearAutocomplete;
     private handleIntercept;
-    /** Handle scroll input. Returns true if consumed. */
+    /**
+     * Handle scroll input. Returns true if consumed.
+     * Pass `includeArrows=false` in input phase so arrows reach the editor.
+     */
     private handleScroll;
     private handleInputKey;
     /** Compute box geometry from config + current viewport. */