agent-sh 0.10.2 → 0.10.3

package/dist/agent/agent-loop.js

@@ -97,7 +97,8 @@ export class AgentLoop {
         // Shell-history-shaped log. Default writes go through the advisable
         // `history:append` handler registered below; extensions swap the
         // backend without touching this wiring.
-        this.historyFile = new HistoryFile({ instanceId: this.instanceId });
+        const filePath = process.env.AGENT_SH_HISTORY_FILE || getSettings().historyFilePath;
+        this.historyFile = new HistoryFile({ instanceId: this.instanceId, filePath });
         this.conversation = new ConversationState(this.handlers, this.instanceId);
         // Fall back to a single-mode placeholder if the caller passed an
         // empty array (agent-backend does this pre-resolution).

package/dist/agent/history-file.d.ts

@@ -2,6 +2,7 @@ import { type NuclearEntry } from "./nuclear-form.js";
 export declare class HistoryFile {
     readonly instanceId: string;
     private filePath;
+    private lockPath;
     constructor(opts?: {
         filePath?: string;
         instanceId?: string;

package/dist/agent/history-file.js

@@ -12,14 +12,21 @@ import * as crypto from "node:crypto";
 import { CONFIG_DIR, getSettings } from "../settings.js";
 import { serializeEntry, deserializeEntry, formatNuclearLine, isReadOnly, } from "./nuclear-form.js";
 const HISTORY_PATH = path.join(CONFIG_DIR, "history");
-const LOCK_PATH = HISTORY_PATH + ".lock";
 const LOCK_STALE_MS = 10_000; // consider lock stale after 10s
 export class HistoryFile {
     instanceId;
     filePath;
+    lockPath;
     constructor(opts) {
         this.filePath = opts?.filePath ?? HISTORY_PATH;
+        this.lockPath = this.filePath + ".lock";
         this.instanceId = opts?.instanceId ?? crypto.randomBytes(2).toString("hex");
+        // Custom paths may target a dir that doesn't exist yet; create sync so
+        // the first append() can't race with the mkdir.
+        try {
+            fss.mkdirSync(path.dirname(this.filePath), { recursive: true });
+        }
+        catch { /* ignore */ }
     }
     /**
      * Append entries atomically. Uses O_APPEND for concurrency safety.
@@ -218,16 +225,16 @@ export class HistoryFile {
         try {
             // Check for stale lock
             try {
-                const stat = await fs.stat(LOCK_PATH);
+                const stat = await fs.stat(this.lockPath);
                 if (Date.now() - stat.mtimeMs > LOCK_STALE_MS) {
-                    await fs.unlink(LOCK_PATH).catch(() => { });
+                    await fs.unlink(this.lockPath).catch(() => { });
                 }
             }
             catch {
                 // Lock doesn't exist — good
             }
             // O_EXCL ensures atomicity
-            const fd = await fs.open(LOCK_PATH, fss.constants.O_CREAT | fss.constants.O_EXCL | fss.constants.O_WRONLY);
+            const fd = await fs.open(this.lockPath, fss.constants.O_CREAT | fss.constants.O_EXCL | fss.constants.O_WRONLY);
             await fd.close();
             return true;
         }
@@ -236,6 +243,6 @@ export class HistoryFile {
         }
     }
     async releaseLock() {
-        await fs.unlink(LOCK_PATH).catch(() => { });
+        await fs.unlink(this.lockPath).catch(() => { });
     }
 }

package/dist/settings.d.ts

@@ -42,6 +42,13 @@ export interface Settings {
     historyMaxBytes?: number;
     /** Number of prior history entries to load on startup (default: 50). */
     historyStartupEntries?: number;
+    /**
+     * Override the history file path. Defaults to `~/.agent-sh/history`.
+     * The `AGENT_SH_HISTORY_FILE` env var takes precedence over this setting.
+     * Use a per-project path to keep sessions isolated (e.g. embedding apps
+     * that boot agent-sh as a library against a specific working tree).
+     */
+    historyFilePath?: string;
     /** Auto-compact threshold as fraction of conversation budget (0-1, default 0.5). */
     autoCompactThreshold?: number;
     /** Max command output lines shown inline in TUI. */

package/dist/settings.js

@@ -21,6 +21,7 @@ const DEFAULTS = {
     shellTailLines: 10,
     historyMaxBytes: 104857600, // 100MB — history is only accessed via search/expand, never loaded wholesale
     historyStartupEntries: 100,
+    historyFilePath: undefined,
     autoCompactThreshold: 0.5,
     maxCommandOutputLines: 3,
     readOutputMaxLines: 10,

package/dist/utils/ansi.d.ts

@@ -7,20 +7,29 @@ export declare const GRAY = "\u001B[90m";
 export declare const BOLD = "\u001B[1m";
 export declare const RESET = "\u001B[0m";
 /**
- * Check if a Unicode code point is a wide character (CJK, fullwidth, emoji, etc.)
- * Returns 2 for wide chars, 1 for normal chars, 0 for combining chars.
+ * Width of a single Unicode code point in terminal columns.
  *
- * Based on East Asian Width and Unicode categories.
+ * For correct rendering of emoji clusters (ZWJ, flags, skin-tone, VS16)
+ * prefer `clusterWidth` or `visibleLen`, which segment graphemes first.
+ * This code-point-level primitive is kept for callers that iterate over
+ * chars for wrap-detection purposes (e.g. CJK line-break rules).
  */
 export declare function charWidth(codePoint: number): number;
+/**
+ * Width of one grapheme cluster in terminal columns. Handles ZWJ sequences,
+ * regional-indicator flags, skin-tone modifiers, and VS16 emoji presentation.
+ */
+export declare function clusterWidth(cluster: string): number;
 /**
  * Measure visible string length in terminal columns.
- * Excludes SGR (color/style) sequences and accounts for CJK double-width chars.
+ * Excludes SGR (color/style) sequences, and counts each grapheme cluster
+ * (emoji, CJK, combining marks) as one terminal-visible unit.
  */
 export declare function visibleLen(str: string): number;
 /**
  * Truncate a string to fit within `maxWidth` visible columns.
- * Accounts for CJK double-width characters. Appends `…` if truncated.
+ * Iterates by grapheme cluster so emoji sequences (ZWJ, flags, VS16) are
+ * kept intact rather than split mid-cluster. Appends `…` if truncated.
  */
 export declare function truncateToWidth(str: string, maxWidth: number): string;
 /** Truncate to visible width while preserving SGR sequences — use when
@@ -28,8 +37,10 @@ export declare function truncateToWidth(str: string, maxWidth: number): string;
 export declare function truncateAnsiToWidth(str: string, maxWidth: number): string;
 /**
  * Pad a string with spaces to fill `targetWidth` visible columns.
- * Accounts for CJK double-width characters.
  */
 export declare function padEndToWidth(str: string, targetWidth: number): string;
-/** Strip all ANSI escape sequences (SGR, OSC, CSI, private mode) and carriage returns. */
+/** Strip ANSI escape sequences and carriage returns.
+ *  Delegates escape handling to the `strip-ansi` package (covers SGR, OSC,
+ *  CSI, private-mode, 8-bit CSI, and newer variants). `\r` is not an escape
+ *  but callers rely on it being stripped alongside. */
 export declare function stripAnsi(str: string): string;

package/dist/utils/ansi.js

@@ -1,3 +1,5 @@
+import stringWidth from "string-width";
+import stripAnsiPkg from "strip-ansi";
 // ── ANSI escape code constants ────────────────────────────────
 export const CYAN = "\x1b[36m";
 export const DIM = "\x1b[2m";
@@ -8,160 +10,65 @@ export const GRAY = "\x1b[90m";
 export const BOLD = "\x1b[1m";
 export const RESET = "\x1b[0m";
 // ── ANSI utility functions ───────────────────────────────────
+// Reused across iterations. Segmenter construction is not free, and the API
+// is pure (no per-call state) so a module-level instance is safe.
+const GRAPHEME_SEGMENTER = new Intl.Segmenter(undefined, { granularity: "grapheme" });
 /**
- * Check if a Unicode code point is a wide character (CJK, fullwidth, emoji, etc.)
- * Returns 2 for wide chars, 1 for normal chars, 0 for combining chars.
+ * Width of a single Unicode code point in terminal columns.
  *
- * Based on East Asian Width and Unicode categories.
+ * For correct rendering of emoji clusters (ZWJ, flags, skin-tone, VS16)
+ * prefer `clusterWidth` or `visibleLen`, which segment graphemes first.
+ * This code-point-level primitive is kept for callers that iterate over
+ * chars for wrap-detection purposes (e.g. CJK line-break rules).
  */
 export function charWidth(codePoint) {
-    // Combining characters (zero width)
-    if (codePoint >= 0x0300 && codePoint <= 0x036f)
-        return 0; // Combining Diacritical Marks
-    if (codePoint >= 0x1ab0 && codePoint <= 0x1aff)
-        return 0; // Combining Diacritical Marks Extended
-    if (codePoint >= 0x1dc0 && codePoint <= 0x1dff)
-        return 0; // Combining Diacritical Marks Supplement
-    if (codePoint >= 0x20d0 && codePoint <= 0x20ff)
-        return 0; // Combining Diacritical Marks for Symbols
-    if (codePoint >= 0xfe20 && codePoint <= 0xfe2f)
-        return 0; // Combining Half Marks
-    if (codePoint >= 0xfe00 && codePoint <= 0xfe0f)
-        return 0; // Variation Selectors
-    if (codePoint >= 0xe0100 && codePoint <= 0xe01ef)
-        return 0; // Variation Selectors Supplement
-    // Emoji and symbols that render as wide (2 columns)
-    // Emoji presentation sequences and keycap
-    if (codePoint === 0x20e3)
-        return 2; // Combining Enclosing Keycap
-    // Emoji blocks
-    if (codePoint >= 0x1f600 && codePoint <= 0x1f64f)
-        return 2; // Emoticons
-    if (codePoint >= 0x1f300 && codePoint <= 0x1f5ff)
-        return 2; // Misc Symbols and Pictographs
-    if (codePoint >= 0x1f680 && codePoint <= 0x1f6ff)
-        return 2; // Transport and Map
-    if (codePoint >= 0x1f700 && codePoint <= 0x1f77f)
-        return 2; // Alchemical Symbols
-    if (codePoint >= 0x1f780 && codePoint <= 0x1f7ff)
-        return 2; // Geometric Shapes Extended
-    if (codePoint >= 0x1f800 && codePoint <= 0x1f8ff)
-        return 2; // Supplemental Arrows-C
-    if (codePoint >= 0x1f900 && codePoint <= 0x1f9ff)
-        return 2; // Supplemental Symbols and Pictographs
-    if (codePoint >= 0x1fa00 && codePoint <= 0x1faff)
-        return 2; // Chess Symbols, Symbols and Pictographs Extended-A
-    // NOTE: 0x2300-0x23ff (Misc Technical), 0x2600-0x26ff (Misc Symbols),
-    // and 0x2700-0x27bf (Dingbats) are mostly "Ambiguous" width — render as
-    // 1 column in non-CJK terminal locales (e.g. ❯, ⌘, ★, ♦). But a handful
-    // of dingbats have Emoji_Presentation=Yes and render as 2 cols everywhere.
-    if (codePoint === 0x2705 || // ✅ white heavy check mark
-        codePoint === 0x270a || // ✊ raised fist
-        codePoint === 0x270b || // ✋ raised hand
-        codePoint === 0x2728 || // ✨ sparkles
-        codePoint === 0x274c || // ❌ cross mark
-        codePoint === 0x274e || // ❎ negative squared cross mark
-        (codePoint >= 0x2753 && codePoint <= 0x2755) || // ❓❔❕
-        codePoint === 0x2757 || // ❗ heavy exclamation mark
-        (codePoint >= 0x2795 && codePoint <= 0x2797) || // ➕➖➗
-        codePoint === 0x27b0 || // ➰ curly loop
-        codePoint === 0x27bf // ➿ double curly loop
-    )
-        return 2;
-    // Regional indicator symbols (flag emoji components)
-    if (codePoint >= 0x1f1e6 && codePoint <= 0x1f1ff)
-        return 2;
-    // CJK Unified Ideographs
-    if (codePoint >= 0x4e00 && codePoint <= 0x9fff)
-        return 2;
-    // CJK Unified Ideographs Extension A
-    if (codePoint >= 0x3400 && codePoint <= 0x4dbf)
-        return 2;
-    // Hangul Syllables
-    if (codePoint >= 0xac00 && codePoint <= 0xd7af)
-        return 2;
-    // CJK Unified Ideographs Extension B-F and other CJK blocks
-    if (codePoint >= 0x20000 && codePoint <= 0x2ebef)
-        return 2;
-    // Fullwidth ASCII variants
-    if (codePoint >= 0xff01 && codePoint <= 0xff5e)
-        return 2;
-    // Fullwidth bracket forms
-    if (codePoint >= 0xff5f && codePoint <= 0xff60)
-        return 2;
-    // Fullwidth symbol variants
-    if (codePoint >= 0xffe0 && codePoint <= 0xffe6)
-        return 2;
-    // Japanese hiragana and katakana
-    if (codePoint >= 0x3040 && codePoint <= 0x309f)
-        return 2;
-    if (codePoint >= 0x30a0 && codePoint <= 0x30ff)
-        return 2;
-    // CJK symbols and punctuation
-    if (codePoint >= 0x3000 && codePoint <= 0x303f)
-        return 2;
-    // Enclosed CJK letters and months
-    if (codePoint >= 0x3200 && codePoint <= 0x32ff)
-        return 2;
-    // CJK compatibility
-    if (codePoint >= 0x3300 && codePoint <= 0x33ff)
-        return 2;
-    // Hangul Jamo
-    if (codePoint >= 0x1100 && codePoint <= 0x11ff)
-        return 2;
-    // Hangul compatibility Jamo
-    if (codePoint >= 0x3130 && codePoint <= 0x318f)
-        return 2;
-    return 1;
+    return stringWidth(String.fromCodePoint(codePoint));
+}
+/**
+ * Width of one grapheme cluster in terminal columns. Handles ZWJ sequences,
+ * regional-indicator flags, skin-tone modifiers, and VS16 emoji presentation.
+ */
+export function clusterWidth(cluster) {
+    return stringWidth(cluster);
+}
+/** Strip SGR (color/style) sequences from a string. */
+function stripSGR(str) {
+    return str.replace(/\x1b\[[^m]*m/g, "");
 }
 /**
  * Measure visible string length in terminal columns.
- * Excludes SGR (color/style) sequences and accounts for CJK double-width chars.
+ * Excludes SGR (color/style) sequences, and counts each grapheme cluster
+ * (emoji, CJK, combining marks) as one terminal-visible unit.
  */
 export function visibleLen(str) {
-    // First strip ANSI escape sequences
-    const cleanStr = str.replace(/\x1b\[[^m]*m/g, "");
-    let width = 0;
-    for (const char of cleanStr) {
-        width += charWidth(char.codePointAt(0) ?? 0);
-    }
-    return width;
+    return stringWidth(stripSGR(str));
 }
 /**
  * Truncate a string to fit within `maxWidth` visible columns.
- * Accounts for CJK double-width characters. Appends `…` if truncated.
+ * Iterates by grapheme cluster so emoji sequences (ZWJ, flags, VS16) are
+ * kept intact rather than split mid-cluster. Appends `…` if truncated.
  */
 export function truncateToWidth(str, maxWidth) {
-    const clean = str.replace(/\x1b\[[^m]*m/g, "");
+    const clean = stripSGR(str);
     if (maxWidth <= 0)
         return "";
-    // First check if the entire string fits
-    let fullWidth = 0;
-    for (const char of clean) {
-        fullWidth += charWidth(char.codePointAt(0) ?? 0);
-    }
-    if (fullWidth <= maxWidth)
+    if (visibleLen(clean) <= maxWidth)
         return clean;
-    // String doesn't fit — truncate with "…"
-    // At maxWidth=1 the ellipsis alone fills the budget.
     if (maxWidth === 1)
         return "…";
-    // Reserve 1 column for "…", so target content width is maxWidth - 1
     const target = maxWidth - 1;
     let width = 0;
-    let i = 0;
-    for (const char of clean) {
-        const cw = charWidth(char.codePointAt(0) ?? 0);
+    let out = "";
+    for (const { segment } of GRAPHEME_SEGMENTER.segment(clean)) {
+        const cw = clusterWidth(segment);
         if (width + cw > target)
             break;
         width += cw;
-        i += char.length;
+        out += segment;
     }
-    // If nothing fit (first char is wider than target), just show the ellipsis
-    // rather than emit a character that would overflow the budget.
-    if (i === 0)
+    if (out === "")
         return "…";
-    return clean.slice(0, i) + "…";
+    return out + "…";
 }
 /** Truncate to visible width while preserving SGR sequences — use when
  *  input carries color/bold codes. `truncateToWidth` strips them. */
@@ -173,43 +80,57 @@ export function truncateAnsiToWidth(str, maxWidth) {
     if (maxWidth === 1)
         return "…";
     const target = maxWidth - 1;
+    // Walk the string preserving SGR escapes in-place; buffer text between
+    // escapes and segment it into graphemes to count width correctly.
     let width = 0;
     let out = "";
+    let buf = "";
     let i = 0;
+    const flushBuf = () => {
+        if (!buf)
+            return false;
+        for (const { segment } of GRAPHEME_SEGMENTER.segment(buf)) {
+            const cw = clusterWidth(segment);
+            if (width + cw > target) {
+                buf = "";
+                return true; // budget exhausted
+            }
+            width += cw;
+            out += segment;
+        }
+        buf = "";
+        return false;
+    };
     while (i < str.length) {
         if (str[i] === "\x1b" && str[i + 1] === "[") {
             const end = str.indexOf("m", i);
             if (end !== -1) {
+                if (flushBuf())
+                    break;
                 out += str.slice(i, end + 1);
                 i = end + 1;
                 continue;
             }
         }
         const cp = str.codePointAt(i) ?? 0;
-        const cw = charWidth(cp);
-        if (width + cw > target)
-            break;
         const chLen = cp > 0xffff ? 2 : 1;
-        out += str.slice(i, i + chLen);
-        width += cw;
+        buf += str.slice(i, i + chLen);
         i += chLen;
     }
+    flushBuf();
     return out + "\x1b[0m…";
 }
 /**
  * Pad a string with spaces to fill `targetWidth` visible columns.
- * Accounts for CJK double-width characters.
  */
 export function padEndToWidth(str, targetWidth) {
     const gap = targetWidth - visibleLen(str);
     return gap > 0 ? str + " ".repeat(gap) : str;
 }
-/** Strip all ANSI escape sequences (SGR, OSC, CSI, private mode) and carriage returns. */
+/** Strip ANSI escape sequences and carriage returns.
+ *  Delegates escape handling to the `strip-ansi` package (covers SGR, OSC,
+ *  CSI, private-mode, 8-bit CSI, and newer variants). `\r` is not an escape
+ *  but callers rely on it being stripped alongside. */
 export function stripAnsi(str) {
-    return str
-        .replace(/\x1b\][^\x07]*\x07/g, "") // OSC sequences
-        .replace(/\x1b\[[^m]*m/g, "") // SGR (color) sequences
-        .replace(/\x1b\[\?[^a-zA-Z]*[a-zA-Z]/g, "") // private mode sequences
-        .replace(/\x1b\[[^a-zA-Z]*[a-zA-Z]/g, "") // CSI sequences
-        .replace(/\r/g, ""); // carriage returns
+    return stripAnsiPkg(str).replace(/\r/g, "");
 }

package/dist/utils/markdown.js

@@ -269,12 +269,20 @@ export class MarkdownRenderer {
         const separatorWidth = (numCols - 1) * 3;
         const tableWidth = Math.max(10, this.width - 2);
         const availableWidth = tableWidth - separatorWidth;
-        const totalWidth = colWidths.reduce((a, b) => a + b, 0);
-        if (totalWidth > availableWidth && availableWidth > numCols) {
-            const scale = availableWidth / totalWidth;
-            for (let c = 0; c < numCols; c++) {
-                colWidths[c] = Math.max(1, Math.floor(colWidths[c] * scale));
+        // Shrink the widest column one step at a time until the table fits.
+        // Preserves natural width on narrow columns — proportional scaling
+        // over-truncates when only one column is oversized.
+        let total = colWidths.reduce((a, b) => a + b, 0);
+        while (total > availableWidth && availableWidth > numCols) {
+            let maxIdx = 0;
+            for (let c = 1; c < numCols; c++) {
+                if (colWidths[c] > colWidths[maxIdx])
+                    maxIdx = c;
             }
+            if (colWidths[maxIdx] <= 1)
+                break;
+            colWidths[maxIdx]--;
+            total--;
         }
         // Render rows
         const hasHeader = sepIdx.includes(1) && dataRows.length > 1;
@@ -287,9 +295,13 @@ export class MarkdownRenderer {
             const cells = row.map((cell, c) => {
                 const w = colWidths[c];
                 const rendered = this.renderInline(cell);
-                const text = visibleLen(rendered) > w
+                // Truncation can yield width < w when a CJK double-width char
+                // won't fit the remaining budget — always re-pad to keep cells
+                // aligned with the border grid.
+                const clipped = visibleLen(rendered) > w
                     ? truncateAnsiToWidth(rendered, w)
-                    : padEndToWidth(rendered, w);
+                    : rendered;
+                const text = padEndToWidth(clipped, w);
                 return isHeader ? `${p.bold}${text}${p.reset}` : text;
             });
             this.writeLine(`${p.dim}│${p.reset} ${cells.join(` ${p.dim}│${p.reset} `)} ${p.dim}│${p.reset}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-sh",
-  "version": "0.10.2",
+  "version": "0.10.3",
   "description": "A shell-first terminal where AI is one keystroke away",
   "type": "module",
   "main": "dist/core.js",
@@ -34,6 +34,10 @@
       "types": "./dist/extensions/index.d.ts",
       "default": "./dist/extensions/index.js"
     },
+    "./shell": {
+      "types": "./dist/shell/shell.d.ts",
+      "default": "./dist/shell/shell.js"
+    },
     "./utils/stream-transform": {
       "types": "./dist/utils/stream-transform.d.ts",
       "default": "./dist/utils/stream-transform.js"
@@ -122,6 +126,8 @@
     "marked": "^17.0.6",
     "node-pty": "^1.2.0-beta.12",
     "openai": "^6.34.0",
+    "string-width": "^8.2.0",
+    "strip-ansi": "^7.2.0",
     "tsx": "^4.19.0"
   },
   "devDependencies": {