agent-sh 0.12.16 → 0.12.18

package/dist/agent/agent-loop.js

@@ -995,8 +995,7 @@ export class AgentLoop {
                 const absPath = path.resolve(process.cwd(), args.path);
                 this.fileReadCache.delete(absPath);
             }
-            // Compute result display: tool-provided → default (none)
-            const resultDisplay = tool.formatResult?.(args, result);
+            const resultDisplay = result.display ?? tool.formatResult?.(args, result);
             // Emit completion events (via transform pipe so extensions can override)
             this.bus.emitTransform("agent:tool-completed", {
                 toolCallId: id, exitCode: result.exitCode,

package/dist/agent/tools/edit-file.js

@@ -69,13 +69,7 @@ export function createEditFileTool(getCwd) {
             icon: "✎",
             locations: [{ path: args.path }],
         }),
-        formatResult: (_args, result) => {
-            if (result.isError)
-                return {};
-            const m = result.content.match(/\((\+\d+(?:\s-\d+)?)\)/);
-            return m ? { summary: m[1] } : {};
-        },
-        async execute(args, onChunk) {
+        async execute(args) {
             const filePath = expandHome(args.path);
             const oldText = args.old_text;
             const newText = args.new_text;
@@ -120,27 +114,16 @@ export function createEditFileTool(getCwd) {
                     ? newContent.replace(/\n/g, "\r\n")
                     : newContent;
                 await fs.writeFile(absPath, finalContent);
-                // Compute and stream diff for display (windowed — only diffs the edit region)
                 const diff = computeEditDiff(normalized, normalizedOld, normalizedNew, replaceAll);
-                if (onChunk && diff.hunks.length > 0) {
-                    for (const hunk of diff.hunks) {
-                        for (const line of hunk.lines) {
-                            if (line.type === "added")
-                                onChunk(`+${line.text}\n`);
-                            else if (line.type === "removed")
-                                onChunk(`-${line.text}\n`);
-                            else
-                                onChunk(` ${line.text}\n`);
-                        }
-                    }
-                }
-                const stats = diff.isNewFile
-                    ? `+${diff.added}`
-                    : `+${diff.added} -${diff.removed}`;
+                const stats = diff.isNewFile ? `+${diff.added}` : `+${diff.added} -${diff.removed}`;
                 return {
                     content: `Edited ${absPath} (${stats})`,
                     exitCode: 0,
                     isError: false,
+                    display: {
+                        summary: stats,
+                        body: { kind: "diff", diff, filePath: absPath },
+                    },
                 };
             }
             catch (err) {

package/dist/agent/tools/write-file.js

@@ -29,13 +29,7 @@ export function createWriteFileTool(getCwd) {
             icon: "✎",
             locations: [{ path: args.path }],
         }),
-        formatResult: (_args, result) => {
-            if (result.isError)
-                return {};
-            const m = result.content.match(/\((\+\d+(?:\s-\d+)?)\)/);
-            return m ? { summary: m[1] } : {};
-        },
-        async execute(args, onChunk) {
+        async execute(args) {
             const filePath = expandHome(args.path);
             const content = args.content;
             const absPath = path.resolve(getCwd(), filePath);
@@ -49,29 +43,18 @@ export function createWriteFileTool(getCwd) {
                 }
                 await fs.mkdir(path.dirname(absPath), { recursive: true });
                 await fs.writeFile(absPath, content);
-                // Compute and stream diff for display
                 const diff = computeDiff(oldContent, content);
-                if (onChunk && diff.hunks.length > 0) {
-                    for (const hunk of diff.hunks) {
-                        for (const line of hunk.lines) {
-                            if (line.type === "added")
-                                onChunk(`+${line.text}\n`);
-                            else if (line.type === "removed")
-                                onChunk(`-${line.text}\n`);
-                            else
-                                onChunk(` ${line.text}\n`);
-                        }
-                    }
-                }
-                const stats = diff.isNewFile
-                    ? `+${diff.added}`
-                    : `+${diff.added} -${diff.removed}`;
+                const stats = diff.isNewFile ? `+${diff.added}` : `+${diff.added} -${diff.removed}`;
                 return {
                     content: oldContent === null
                         ? `Created ${absPath} (${stats})`
                         : `Wrote ${absPath} (${stats})`,
                     exitCode: 0,
                     isError: false,
+                    display: {
+                        summary: stats,
+                        body: { kind: "diff", diff, filePath: absPath },
+                    },
                 };
             }
             catch (err) {

package/dist/agent/types.d.ts

@@ -19,6 +19,8 @@ export interface ToolResult {
     content: string;
     exitCode: number | null;
     isError: boolean;
+    /** When set, takes precedence over `tool.formatResult()`. */
+    display?: ToolResultDisplay;
 }
 /** Structured result display — returned by formatResult or computed by defaults. */
 export interface ToolResultDisplay {

package/dist/extensions/tui-renderer.js

@@ -652,22 +652,33 @@ export default function activate(ctx) {
     function renderDiffBody(diff, filePath, width) {
         if (diff.isIdentical)
             return [];
-        const boxW = Math.min(120, width - 2); // -2 for writeLine indent
+        const boxW = Math.min(120, width - 2);
         const contentW = boxW - 4;
-        const diffLines = renderDiff(diff, {
-            width: contentW,
-            filePath,
-            maxLines: getSettings().diffMaxLines,
-            trueColor: true,
-        });
-        const body = diffLines.length > 1 ? ["", ...diffLines.slice(1), ""] : diffLines;
-        const footer = undefined;
+        let body;
+        if (diff.isNewFile) {
+            const lines = diff.hunks.flatMap(h => h.lines.map(l => l.text));
+            const preview = getSettings().newFilePreviewLines;
+            const head = lines.slice(0, preview);
+            const truncated = head.map(l => l.length > contentW ? l.slice(0, contentW - 1) + "…" : l);
+            const more = lines.length > preview
+                ? [`${p.dim}… ${lines.length - preview} more lines${p.reset}`]
+                : [];
+            body = ["", ...truncated, ...more, ""];
+        }
+        else {
+            const diffLines = renderDiff(diff, {
+                width: contentW,
+                filePath,
+                maxLines: getSettings().diffMaxLines,
+                trueColor: true,
+            });
+            body = diffLines.length > 1 ? ["", ...diffLines.slice(1), ""] : diffLines;
+        }
         return renderBoxFrame(body, {
             width: boxW,
             style: "rounded",
             borderColor: p.dim,
             title: diffTitle(filePath, diff),
-            footer,
         });
     }
     /** Render output lines with truncation. */

package/dist/settings.d.ts

@@ -67,6 +67,8 @@ export interface Settings {
     readOutputMaxLines?: number;
     /** Max diff lines rendered in the TUI (Infinity = no limit). */
     diffMaxLines?: number;
+    /** Lines of head content shown when a brand-new file is created. */
+    newFilePreviewLines?: number;
     /** Tool protocol:
      *   "api" — all tools sent with full schema.
      *   "deferred" — extensions dispatched through `use_extension(name, args)` meta-tool.

package/dist/settings.js

@@ -30,6 +30,7 @@ const DEFAULTS = {
     maxCommandOutputLines: 3,
     readOutputMaxLines: 10,
     diffMaxLines: Infinity,
+    newFilePreviewLines: 5,
     skillPaths: [],
     diagnose: false,
     startupBanner: true,

package/dist/utils/line-editor.d.ts

@@ -54,6 +54,11 @@ export declare class LineEditor {
     setText(value: string): void;
     /** Process raw terminal input, return actions for the consumer. */
     feed(data: string): LineEditAction[];
+    /** Accumulate `data` into pasteAccum until PASTE_END appears.
+     *  Returns the marker index, or -1 if not yet seen (a partial-suffix
+     *  match is stashed in pendingSeq so the next feed() can complete it). */
+    private consumePasteChunk;
+    private commitPaste;
     /** Check if there's a pending incomplete escape sequence. */
     hasPendingEscape(): boolean;
     /** Flush a pending sequence — treat bare \x1b as cancel, discard incomplete CSI. */

package/dist/utils/line-editor.js

@@ -19,6 +19,7 @@ const KITTY_KEY_NAMES = {
 // ── Paste placeholder ───────────────────────────────────────────
 /** First Unicode Private Use Area codepoint, used as paste placeholder. */
 const PUA_BASE = 0xE000;
+const PASTE_END = "\x1b[201~";
 function isPUA(ch) {
     const code = ch.charCodeAt(0);
     return code >= PUA_BASE && code <= 0xF8FF;
@@ -115,7 +116,24 @@ export class LineEditor {
         }
         const actions = [];
         let i = 0;
+        // Heuristic for terminals that don't advertise bracketed paste (or where
+        // it's stripped by tmux/ssh): a multi-byte chunk with line breaks is a
+        // paste, since typed input arrives one keystroke per chunk in raw mode.
+        if (!this.inPaste && data.length > 1 && /[\r\n]/.test(data)
+            && data.indexOf("\x1b[200~") === -1) {
+            this.pasteAccum = data.replace(/\r\n?/g, "\n");
+            actions.push(...this.commitPaste());
+            return actions;
+        }
         while (i < data.length) {
+            if (this.inPaste) {
+                const endIdx = this.consumePasteChunk(data.slice(i));
+                if (endIdx === -1)
+                    return actions;
+                i += endIdx + PASTE_END.length;
+                actions.push(...this.commitPaste());
+                continue;
+            }
             const ch = data[i];
             // ── Escape sequences ────────────────────────────────
             if (ch === "\x1b") {
@@ -207,16 +225,6 @@ export class LineEditor {
                 // Other Alt+key — ignore
                 continue;
             }
-            // ── Bracket paste: accumulate into side buffer ─────
-            if (this.inPaste) {
-                if (ch === "\r") {
-                    i++;
-                    continue;
-                } // skip CR (CR+LF → just LF)
-                this.pasteAccum += ch;
-                i++;
-                continue;
-            }
             // ── Control characters ──────────────────────────────
             if (ch.charCodeAt(0) < 0x20 || ch === "\x7f") {
                 const action = this.handleControl(ch);
@@ -233,6 +241,47 @@ export class LineEditor {
         }
         return actions;
     }
+    /** Accumulate `data` into pasteAccum until PASTE_END appears.
+     *  Returns the marker index, or -1 if not yet seen (a partial-suffix
+     *  match is stashed in pendingSeq so the next feed() can complete it). */
+    consumePasteChunk(data) {
+        const endIdx = data.indexOf(PASTE_END);
+        if (endIdx !== -1) {
+            this.pasteAccum += data.slice(0, endIdx).replace(/\r/g, "");
+            return endIdx;
+        }
+        let suffixLen = 0;
+        for (let p = Math.min(PASTE_END.length - 1, data.length); p > 0; p--) {
+            if (data.endsWith(PASTE_END.slice(0, p))) {
+                suffixLen = p;
+                break;
+            }
+        }
+        const safeEnd = data.length - suffixLen;
+        this.pasteAccum += data.slice(0, safeEnd).replace(/\r/g, "");
+        if (suffixLen > 0)
+            this.pendingSeq = data.slice(safeEnd);
+        return -1;
+    }
+    commitPaste() {
+        this.inPaste = false;
+        const accum = this.pasteAccum;
+        this.pasteAccum = "";
+        if (!accum)
+            return [];
+        if (accum.indexOf("\n") === -1) {
+            this._buf = this._buf.slice(0, this.cursor) + accum + this._buf.slice(this.cursor);
+            this.cursor += accum.length;
+        }
+        else {
+            const id = this.pasteCounter++;
+            this.pastes.set(id, accum);
+            const placeholder = String.fromCharCode(PUA_BASE + id);
+            this._buf = this._buf.slice(0, this.cursor) + placeholder + this._buf.slice(this.cursor);
+            this.cursor++;
+        }
+        return [{ action: "changed" }];
+    }
     /** Check if there's a pending incomplete escape sequence. */
     hasPendingEscape() {
         return this.pendingSeq.length > 0;
@@ -517,27 +566,6 @@ export class LineEditor {
                     this.inPaste = true;
                     this.pasteAccum = "";
                 }
-                else if (params === "201") {
-                    this.inPaste = false;
-                    if (this.pasteAccum) {
-                        const lines = this.pasteAccum.split("\n");
-                        if (lines.length <= 1) {
-                            // Single-line paste — inline directly
-                            this._buf = this._buf.slice(0, this.cursor) + this.pasteAccum + this._buf.slice(this.cursor);
-                            this.cursor += this.pasteAccum.length;
-                        }
-                        else {
-                            // Multi-line paste — store and insert placeholder
-                            const id = this.pasteCounter++;
-                            this.pastes.set(id, this.pasteAccum);
-                            const placeholder = String.fromCharCode(PUA_BASE + id);
-                            this._buf = this._buf.slice(0, this.cursor) + placeholder + this._buf.slice(this.cursor);
-                            this.cursor++;
-                        }
-                        this.pasteAccum = "";
-                        actions.push({ action: "changed" });
-                    }
-                }
                 break;
             // All other CSI sequences — silently ignored
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-sh",
-  "version": "0.12.16",
+  "version": "0.12.18",
   "description": "A shell-first terminal where AI is one keystroke away",
   "type": "module",
   "main": "dist/core.js",