agent-sh 0.15.5 → 0.15.7

package/src/utils/executor.ts

@@ -1,5 +1,6 @@
 import { spawn, spawnSync, type ChildProcess } from "node:child_process";
 import { existsSync } from "node:fs";
+import { StringDecoder } from "node:string_decoder";
 import { stripAnsi } from "./ansi.js";
 
 // Node reports a missing cwd as `spawn <binary> ENOENT` — disambiguate.
@@ -106,25 +107,23 @@ export function executeCommand(opts: {
 
   session.process = child;
 
-  const handleData = (data: Buffer) => {
-    const raw = data.toString("utf-8");
+  const handleText = (raw: string) => {
+    if (!raw) return;
     const clean = stripAnsi(raw);
-
-    // Accumulate cleaned output for the agent
     session.output += clean;
-
-    // Enforce output cap — truncate from beginning, keep tail
     if (session.output.length > maxOutput) {
       session.output = session.output.slice(-maxOutput);
       session.truncated = true;
     }
-
-    // Real-time streaming callback
     opts.onOutput?.(raw);
   };
 
-  child.stdout?.on("data", handleData);
-  child.stderr?.on("data", handleData);
+  const outDecoder = new StringDecoder("utf-8");
+  const errDecoder = new StringDecoder("utf-8");
+  child.stdout?.on("data", (d: Buffer) => handleText(outDecoder.write(d)));
+  child.stderr?.on("data", (d: Buffer) => handleText(errDecoder.write(d)));
+  child.stdout?.on("end", () => handleText(outDecoder.end()));
+  child.stderr?.on("end", () => handleText(errDecoder.end()));
 
   let cancelKill: (() => void) | undefined;
   const timer = setTimeout(() => {
@@ -218,8 +217,8 @@ export function executeArgv(opts: {
 
   session.process = child;
 
-  const handleData = (data: Buffer) => {
-    const raw = data.toString("utf-8");
+  const handleText = (raw: string) => {
+    if (!raw) return;
     const clean = stripAnsi(raw);
     session.output += clean;
     if (session.output.length > maxOutput) {
@@ -229,8 +228,12 @@ export function executeArgv(opts: {
     opts.onOutput?.(raw);
   };
 
-  child.stdout?.on("data", handleData);
-  child.stderr?.on("data", handleData);
+  const outDecoder = new StringDecoder("utf-8");
+  const errDecoder = new StringDecoder("utf-8");
+  child.stdout?.on("data", (d: Buffer) => handleText(outDecoder.write(d)));
+  child.stderr?.on("data", (d: Buffer) => handleText(errDecoder.write(d)));
+  child.stdout?.on("end", () => handleText(outDecoder.end()));
+  child.stderr?.on("end", () => handleText(errDecoder.end()));
 
   const timer = setTimeout(() => {
     if (!session.done && session.process) {

package/src/utils/floating-panel.ts

@@ -823,6 +823,13 @@ export class FloatingPanel {
     this.autocompleteIndex = 0;
   }
 
+  private moveAutocomplete(delta: number): void {
+    const n = this.autocompleteItems.length;
+    if (n === 0) return;
+    this.autocompleteIndex = (this.autocompleteIndex + delta + n) % n;
+    this.render();
+  }
+
   // ── Input handling ──────────────────────────────────────────
 
   private handleIntercept(payload: { data: string; consumed: boolean }): { data: string; consumed: boolean } {
@@ -913,6 +920,16 @@ export class FloatingPanel {
 
     if (this.handleScroll(data, false)) return;
 
+    if (data === "\x10" || data === "\x0e") {
+      const forward = data === "\x0e";
+      if (this.autocompleteActive) {
+        this.moveAutocomplete(forward ? 1 : -1);
+      } else if (forward ? this.editor.historyForward() : this.editor.historyBack()) {
+        this.render();
+      }
+      return;
+    }
+
     const actions = this.editor.feed(data);
     for (const action of actions) {
       switch (action.action) {
@@ -924,6 +941,7 @@ export class FloatingPanel {
           this.editor.pushHistory(query);
           this.editor.clear();
           this.clearAutocomplete();
+          this.userScrolled = false;
           // Phase change is the submit handler's call — sync slash commands
           // (e.g. /model, /help) keep the user in input mode.
           this.handlers.call(`${this.prefix}:submit`, query);
@@ -945,30 +963,14 @@ export class FloatingPanel {
         case "shift+tab":
           this.render();
           break;
-        case "arrow-up": {
-          if (this.autocompleteActive) {
-            this.autocompleteIndex = this.autocompleteIndex === 0
-              ? this.autocompleteItems.length - 1
-              : this.autocompleteIndex - 1;
-            this.render();
-          } else {
-            const hist = this.editor.historyBack();
-            if (hist) this.render();
-          }
+        case "arrow-up":
+          if (this.autocompleteActive) this.moveAutocomplete(-1);
+          else this.scrollUp(1);
           break;
-        }
-        case "arrow-down": {
-          if (this.autocompleteActive) {
-            this.autocompleteIndex = this.autocompleteIndex === this.autocompleteItems.length - 1
-              ? 0
-              : this.autocompleteIndex + 1;
-            this.render();
-          } else {
-            const hist = this.editor.historyForward();
-            if (hist) this.render();
-          }
+        case "arrow-down":
+          if (this.autocompleteActive) this.moveAutocomplete(1);
+          else this.scrollDown(1);
           break;
-        }
         case "changed":
         case "delete-empty":
           this.updateAutocomplete();

package/src/utils/markdown.ts

@@ -79,6 +79,30 @@ export function wrapLine(text: string, maxWidth: number): string[] {
     lastVisibleIdx = -1;
   };
 
+  const hardBreak = (token: string): void => {
+    let remaining = token;
+    while (remaining.length > 0) {
+      let fitLen = 0, fitWidth = 0;
+      for (const ch of remaining) {
+        const cw = charWidth(ch.codePointAt(0) ?? 0);
+        if (fitWidth + cw > maxWidth - lineWidth) break;
+        fitWidth += cw;
+        fitLen += ch.length;
+      }
+      if (fitLen === 0) {
+        // Force one char on an empty line so an over-wide char can't loop forever.
+        if (lineWidth > 0) { commit(); continue; }
+        fitLen = remaining[0]?.length ?? 1;
+      }
+      const chunk = remaining.slice(0, fitLen);
+      remaining = remaining.slice(fitLen);
+      lineTokens.push(chunk);
+      lineWidth += visibleLen(chunk);
+      lastVisibleIdx = lineTokens.length - 1;
+      if (remaining.length > 0) commit();
+    }
+  };
+
   for (const seg of segments) {
     if (seg.startsWith("\x1b[")) {
       lineTokens.push(seg);
@@ -103,23 +127,7 @@ export function wrapLine(text: string, maxWidth: number): string[] {
 
       if (lineWidth === 0) {
         // Token longer than the entire line — hard-break by char width.
-        let remaining = token;
-        while (remaining.length > 0) {
-          let fitLen = 0, fitWidth = 0;
-          for (const ch of remaining) {
-            const cw = charWidth(ch.codePointAt(0) ?? 0);
-            if (fitWidth + cw > maxWidth) break;
-            fitWidth += cw;
-            fitLen += ch.length;
-          }
-          if (fitLen === 0) fitLen = remaining[0]?.length ?? 1;
-          const chunk = remaining.slice(0, fitLen);
-          remaining = remaining.slice(fitLen);
-          lineTokens.push(chunk);
-          lineWidth += visibleLen(chunk);
-          lastVisibleIdx = lineTokens.length - 1;
-          if (remaining.length > 0) commit();
-        }
+        hardBreak(token);
         continue;
       }
 
@@ -147,9 +155,13 @@ export function wrapLine(text: string, maxWidth: number): string[] {
         lineTokens.push(t);
         lineWidth += visibleLen(t);
       }
-      lineTokens.push(token);
-      lineWidth += tokenWidth;
-      lastVisibleIdx = lineTokens.length - 1;
+      if (lineWidth + tokenWidth <= maxWidth) {
+        lineTokens.push(token);
+        lineWidth += tokenWidth;
+        lastVisibleIdx = lineTokens.length - 1;
+      } else {
+        hardBreak(token);
+      }
     }
   }
 
@@ -340,27 +352,24 @@ export class MarkdownRenderer {
   private renderLine(line: string): string {
     if (line.trim() === "") return "";
 
-    // Headings
-    const h1 = line.match(/^# (.+)/);
-    if (h1) return `${p.bold}${p.warning}${h1[1]}${p.reset}`;
-
-    const h2 = line.match(/^## (.+)/);
-    if (h2) return `${p.bold}${p.accent}${h2[1]}${p.reset}`;
-
-    const h3 = line.match(/^### (.+)/);
-    if (h3) return `${p.bold}${h3[1]}${p.reset}`;
-
-    const h4 = line.match(/^#{4,} (.+)/);
-    if (h4) return `${p.bold}${h4[1]}${p.reset}`;
+    // Headings — H3+ keep the `###` marker; H1/H2 don't
+    const heading = line.match(/^(#{1,6}) (.+)/);
+    if (heading) {
+      const level = heading[1]!.length;
+      const text = heading[2]!;
+      if (level === 1) return `${p.bold}${p.underline}${p.mdHeading}${text}${p.reset}`;
+      if (level === 2) return `${p.bold}${p.mdHeading}${text}${p.reset}`;
+      return `${p.bold}${p.mdHeading}${"#".repeat(level)} ${text}${p.reset}`;
+    }
 
-    // Horizontal rule — subtle short separator, not full-width
+    // Horizontal rule
     if (/^(-{3,}|_{3,}|\*{3,})\s*$/.test(line)) {
-      return "";
+      return `${p.mdHr}${"─".repeat(Math.min(this.contentWidth, 80))}${p.reset}`;
     }
 
     // Blockquote
     const bq = line.match(/^>\s?(.*)/);
-    if (bq) return `${p.muted}│${p.reset} ${p.dim}${p.italic}${this.renderInline(bq[1] || "")}${p.reset}`;
+    if (bq) return `${p.mdQuoteBorder}│${p.reset} ${p.mdQuote}${p.italic}${this.renderInline(bq[1] || "")}${p.reset}`;
 
     // Task list (checkbox items) — must come before generic unordered list
     const task = line.match(/^(\s*)[*\-+]\s+\[([ xX])\]\s+(.*)/);
@@ -377,14 +386,14 @@ export class MarkdownRenderer {
     const ul = line.match(/^(\s*)[*\-+]\s+(.*)/);
     if (ul) {
       const indent = ul[1] || "";
-      return `${indent}  ${p.accent}*${p.reset} ${this.renderInline(ul[2] || "")}`;
+      return `${indent}  ${p.mdListBullet}-${p.reset} ${this.renderInline(ul[2] || "")}`;
     }
 
     // Ordered list
     const ol = line.match(/^(\s*)(\d+)[.)]\s+(.*)/);
     if (ol) {
       const indent = ol[1] || "";
-      return `${indent}  ${p.accent}${ol[2]}.${p.reset} ${this.renderInline(ol[3] || "")}`;
+      return `${indent}  ${p.mdListBullet}${ol[2]}.${p.reset} ${this.renderInline(ol[3] || "")}`;
     }
 
     return this.renderInline(line);
@@ -394,10 +403,10 @@ export class MarkdownRenderer {
     // Links first — later subs inject `\x1b[…m` whose `[` would be eaten here.
     text = text.replace(
       /\[([^\]]+)\]\(([^)]+)\)/g,
-      `$1 ${p.muted}${p.underline}($2)${p.reset}`
+      `${p.mdLink}${p.underline}$1${p.reset} ${p.mdLinkUrl}($2)${p.reset}`
     );
     // Inline code
-    text = text.replace(/`([^`]+)`/g, `${p.accent}$1${p.reset}`);
+    text = text.replace(/`([^`]+)`/g, `${p.mdCode}$1${p.reset}`);
     // Bold + italic
     text = text.replace(/\*\*\*(.+?)\*\*\*/g, `${p.bold}${p.italic}$1${p.reset}`);
     // Bold
@@ -407,7 +416,7 @@ export class MarkdownRenderer {
     text = text.replace(/\*(.+?)\*/g, `${p.italic}$1${p.reset}`);
     text = text.replace(/(?<!\w)_(.+?)_(?!\w)/g, `${p.italic}$1${p.reset}`);
     // Strikethrough
-    text = text.replace(/~~(.+?)~~/g, `${p.dim}$1${p.reset}`);
+    text = text.replace(/~~(.+?)~~/g, `${p.strikethrough}$1${p.reset}`);
     return text;
   }
 

package/src/utils/palette.ts

@@ -29,7 +29,20 @@ export interface ColorPalette {
   dim: string;
   italic: string;
   underline: string;
+  strikethrough: string;
   reset: string;
+
+  // ── Markdown element colors ───────────────────────────────
+  mdHeading: string;       // headings (all levels)
+  mdLink: string;          // link text
+  mdLinkUrl: string;       // link URL
+  mdCode: string;          // inline code span
+  mdCodeBlock: string;     // fenced code fallback (no highlight)
+  mdCodeBlockBorder: string; // code fence / language label
+  mdQuote: string;         // blockquote text
+  mdQuoteBorder: string;   // blockquote left bar
+  mdHr: string;            // horizontal rule
+  mdListBullet: string;    // list bullet / ordinal
 }
 
 const defaultPalette: ColorPalette = {
@@ -45,11 +58,23 @@ const defaultPalette: ColorPalette = {
   errorBgEmph:   "\x1b[48;2;124;50;64m",
   diffText:      "\x1b[97m",   // bright white — readable on the red/green tints
 
-  bold:      "\x1b[1m",
-  dim:       "\x1b[2m",
-  italic:    "\x1b[3m",
-  underline: "\x1b[4m",
-  reset:     "\x1b[0m",
+  bold:          "\x1b[1m",
+  dim:           "\x1b[2m",
+  italic:        "\x1b[3m",
+  underline:     "\x1b[4m",
+  strikethrough: "\x1b[9m",
+  reset:         "\x1b[0m",
+
+  mdHeading:         "\x1b[38;2;240;198;116m", // #f0c674 gold
+  mdLink:            "\x1b[38;2;129;162;190m", // #81a2be blue
+  mdLinkUrl:         "\x1b[38;2;102;102;102m", // #666666 dim gray
+  mdCode:            "\x1b[38;2;138;190;183m", // #8abeb7 teal
+  mdCodeBlock:       "\x1b[38;2;181;189;104m", // #b5bd68 green
+  mdCodeBlockBorder: "\x1b[38;2;128;128;128m", // #808080 gray
+  mdQuote:           "\x1b[38;2;128;128;128m", // #808080 gray
+  mdQuoteBorder:     "\x1b[38;2;128;128;128m", // #808080 gray
+  mdHr:              "\x1b[38;2;128;128;128m", // #808080 gray
+  mdListBullet:      "\x1b[38;2;138;190;183m", // #8abeb7 teal
 };
 
 /** Active palette — import and use directly in components. */