agent-sh 0.14.2 → 0.14.3

package/dist/shell/events.d.ts

@@ -19,6 +19,8 @@ declare module "../core/event-bus.js" {
         };
         "shell:agent-exec-start": Record<string, never>;
         "shell:agent-exec-done": Record<string, never>;
+        /** Mark the next user-emitted shell command as excluded from <shell_events>. */
+        "shell:user-exec-exclude-next": Record<string, never>;
         "shell:pty-data": {
             raw: string;
         };

package/dist/shell/output-parser.d.ts

@@ -1,42 +1,31 @@
 import type { EventBus } from "../core/event-bus.js";
-/**
- * Parses PTY output to detect command boundaries, track cwd,
- * and emit shell events. Owns the command lifecycle state.
- */
+export interface OutputParserOpts {
+    /** Optional shell-specific cleanup applied to raw output before stripAnsi. */
+    cleanOutput?(raw: string): string;
+}
 export declare class OutputParser {
     private bus;
     private cwd;
     private ownTag;
+    private cleanOutput;
     private currentOutputCapture;
     private lastCommand;
     private foregroundBusy;
     private promptReady;
-    constructor(bus: EventBus, initialCwd: string, ownTag: string);
-    /** Process a chunk of PTY output data. */
+    constructor(bus: EventBus, initialCwd: string, ownTag: string, opts?: OutputParserOpts);
     processData(data: string): void;
-    /** Called when user presses Enter on a non-empty line. */
     onCommandEntered(command: string, cwd: string): void;
-    /** Whether the shell's prompt is fully rendered and ready for input. */
     isPromptReady(): boolean;
     isForegroundBusy(): boolean;
     getCwd(): string;
-    /**
-     * Detect preexec marker (OSC 9997) emitted by the shell's preexec hook.
-     * This carries the actual command text from the shell — more reliable than
-     * the InputHandler's lineBuffer which can't track history recall or tab
-     * completion. Returns data with the OSC stripped out.
-     */
+    /** Pulls the actual command from the shell's OSC 9997 preexec marker —
+     *  more reliable than the InputHandler's lineBuffer, which can't track
+     *  history recall or tab completion. Returns data with the OSC stripped. */
     private handlePreexec;
     private parseOSC7;
-    /**
-     * Detect our custom prompt marker (OSC 9999) in the PTY stream.
-     * Each time a prompt appears, we finalize the previous command's output.
-     */
+    /** OSC 9999 marker — each occurrence finalizes the previous command's output. */
     private parsePromptMarker;
-    /**
-     * Detect end-of-prompt marker (OSC 9998). The prompt is fully rendered
-     * and the shell is ready for input.
-     */
+    /** OSC 9998 — prompt is fully rendered and the shell is ready for input. */
     private parsePromptEnd;
     private removeEchoedCommand;
 }

package/dist/shell/output-parser.js

@@ -4,32 +4,27 @@ import { stripAnsi } from "../utils/ansi.js";
 const PROMPT_RE = /\x1b\]9999;(?:id=([a-f0-9]+);)?PROMPT\x07/;
 const PREEXEC_RE = /\x1b\]9997;(?:id=([a-f0-9]+);)?([^\x07]*)\x07/;
 const READY_RE = /\x1b\]9998;(?:id=([a-f0-9]+);)?READY\x07/;
-/**
- * Parses PTY output to detect command boundaries, track cwd,
- * and emit shell events. Owns the command lifecycle state.
- */
 export class OutputParser {
     bus;
     cwd;
     ownTag;
+    cleanOutput;
     currentOutputCapture = "";
     lastCommand = "";
     foregroundBusy = false;
     promptReady = false;
-    constructor(bus, initialCwd, ownTag) {
+    constructor(bus, initialCwd, ownTag, opts = {}) {
         this.bus = bus;
         this.cwd = initialCwd;
-        // Strip the "id=" prefix; we compare the value alone.
         this.ownTag = ownTag.startsWith("id=") ? ownTag.slice(3) : ownTag;
+        this.cleanOutput = opts.cleanOutput ?? ((raw) => raw);
     }
-    /** Process a chunk of PTY output data. */
     processData(data) {
         this.parseOSC7(data);
         data = this.handlePreexec(data);
         this.parsePromptMarker(data);
         this.parsePromptEnd(data);
     }
-    /** Called when user presses Enter on a non-empty line. */
     onCommandEntered(command, cwd) {
         this.lastCommand = command;
         this.currentOutputCapture = "";
@@ -39,7 +34,6 @@ export class OutputParser {
             this.bus.emit("shell:foreground-busy", { busy: true });
         }
     }
-    /** Whether the shell's prompt is fully rendered and ready for input. */
     isPromptReady() {
         return this.promptReady;
     }
@@ -49,13 +43,9 @@ export class OutputParser {
     getCwd() {
         return this.cwd;
     }
-    // ── Parsing ─────────────────────────────────────────────────
-    /**
-     * Detect preexec marker (OSC 9997) emitted by the shell's preexec hook.
-     * This carries the actual command text from the shell — more reliable than
-     * the InputHandler's lineBuffer which can't track history recall or tab
-     * completion. Returns data with the OSC stripped out.
-     */
+    /** Pulls the actual command from the shell's OSC 9997 preexec marker —
+     *  more reliable than the InputHandler's lineBuffer, which can't track
+     *  history recall or tab completion. Returns data with the OSC stripped. */
     handlePreexec(data) {
         const match = PREEXEC_RE.exec(data);
         if (!match)
@@ -66,7 +56,8 @@ export class OutputParser {
         }
         const command = match[2];
         this.lastCommand = command;
-        this.currentOutputCapture = ""; // discard echo accumulated before preexec
+        // Discard echo accumulated before preexec.
+        this.currentOutputCapture = "";
         if (!this.foregroundBusy) {
             this.foregroundBusy = true;
             this.bus.emit("shell:foreground-busy", { busy: true });
@@ -84,21 +75,16 @@ export class OutputParser {
             }
         }
     }
-    /**
-     * Detect our custom prompt marker (OSC 9999) in the PTY stream.
-     * Each time a prompt appears, we finalize the previous command's output.
-     */
+    /** OSC 9999 marker — each occurrence finalizes the previous command's output. */
     parsePromptMarker(data) {
         const match = PROMPT_RE.exec(data);
         if (match) {
             if (match[1] !== this.ownTag) {
-                // Nested instance or untagged foreign emission — treat as opaque
-                // foreground output, do not finalize our own command.
+                // Nested or untagged emission: keep as opaque foreground output.
                 this.currentOutputCapture += data;
                 return;
             }
             const markerIdx = match.index;
-            // Capture any output that arrived in the same chunk before the marker
             if (markerIdx > 0) {
                 this.currentOutputCapture += data.slice(0, markerIdx);
             }
@@ -108,7 +94,8 @@ export class OutputParser {
                 this.bus.emit("shell:foreground-busy", { busy: false });
             }
             if (this.lastCommand) {
-                const output = stripAnsi(this.currentOutputCapture).trim();
+                const raw = this.cleanOutput(this.currentOutputCapture);
+                const output = stripAnsi(raw).trim();
                 const cleaned = this.removeEchoedCommand(output, this.lastCommand);
                 this.bus.emit("shell:command-done", {
                     command: this.lastCommand,
@@ -121,21 +108,16 @@ export class OutputParser {
             this.currentOutputCapture = "";
         }
         else {
-            // Cap capture buffer to avoid unbounded growth when a foreground
-            // program (tmux, vim, etc.) produces output without prompt markers.
-            // Keep only the tail — the final output is what matters for
-            // command-done context.
-            const MAX_CAPTURE = 128 * 1024; // 128 KB
+            // Cap to the tail so a long-running foreground program (tmux, vim)
+            // emitting output without prompt markers can't grow this unboundedly.
+            const MAX_CAPTURE = 128 * 1024;
             this.currentOutputCapture += data;
             if (this.currentOutputCapture.length > MAX_CAPTURE) {
                 this.currentOutputCapture = this.currentOutputCapture.slice(-MAX_CAPTURE);
             }
         }
     }
-    /**
-     * Detect end-of-prompt marker (OSC 9998). The prompt is fully rendered
-     * and the shell is ready for input.
-     */
+    /** OSC 9998 — prompt is fully rendered and the shell is ready for input. */
     parsePromptEnd(data) {
         const match = READY_RE.exec(data);
         if (!match)

package/dist/shell/shell-context.d.ts

@@ -1,8 +1,5 @@
-/**
- * Tracks PTY commands and cwd, spills long outputs, contributes the
- * per-query `<cwd>` (always) and `<shell_events>` (when there are fresh
- * user-shell exchanges) signals. Frontends without a PTY skip this
- * built-in and the agent runs cwd-aware via core's process.cwd() default.
- */
+/** Tracks PTY commands and cwd, spills long outputs, contributes per-query
+ *  `<cwd>` (always) and `<shell_events>` (fresh user exchanges). Frontends
+ *  without a PTY skip this and fall back to core's process.cwd() default. */
 import type { ExtensionContext } from "./host-types.js";
 export default function activate(ctx: ExtensionContext): void;

package/dist/shell/shell-context.js

@@ -6,12 +6,13 @@ export default function activate(ctx) {
     let nextId = 1;
     let currentCwd = process.cwd();
     let agentShellActive = false;
+    let nextUserExcluded = false;
     let lastSeq = 0;
     bus.on("shell:command-done", (e) => {
         const lines = e.output.split("\n");
         const s = getSettings();
-        // Long outputs spill to a tempfile so the agent can `read_file` them
-        // on demand instead of carrying the full text in LLM context.
+        // Long outputs spill to a tempfile the agent can `read_file` instead of
+        // carrying the full text in LLM context.
         let output = e.output;
         let spillPath;
         if (lines.length > s.shellTruncateThreshold) {
@@ -25,6 +26,13 @@ export default function activate(ctx) {
                 spillPath = undefined;
             }
         }
+        const source = agentShellActive
+            ? "agent"
+            : nextUserExcluded
+                ? "user-excluded"
+                : "user";
+        if (nextUserExcluded)
+            nextUserExcluded = false;
         exchanges.push({
             id: nextId++,
             timestamp: Date.now(),
@@ -34,22 +42,22 @@ export default function activate(ctx) {
             exitCode: e.exitCode,
             outputLines: lines.length,
             outputBytes: e.output.length,
-            source: agentShellActive ? "agent" : "user",
+            source,
             spillPath,
         });
     });
     bus.on("shell:cwd-change", (e) => { currentCwd = e.cwd; });
     bus.on("shell:agent-exec-start", () => { agentShellActive = true; });
     bus.on("shell:agent-exec-done", () => { agentShellActive = false; });
-    // Override core's process.cwd() default with the PTY-tracked value.
+    bus.on("shell:user-exec-exclude-next", () => { nextUserExcluded = true; });
     ctx.advise("cwd", () => currentCwd);
-    // Advises the core handler directly: shell-context loads before the
-    // agent host attaches `ctx.agent`, so the sugar isn't available yet.
+    // Advise the core handler directly: this loads before the agent host
+    // attaches `ctx.agent`, so the sugar isn't available yet.
     ctx.advise("query-context:build", (next) => {
         const base = next();
         const part = (() => {
             const cwdTag = `<cwd>${currentCwd}</cwd>`;
-            const fresh = exchanges.filter((ex) => ex.id > lastSeq && ex.source !== "agent");
+            const fresh = exchanges.filter((ex) => ex.id > lastSeq && ex.source === "user");
             if (fresh.length === 0)
                 return cwdTag;
             lastSeq = exchanges[exchanges.length - 1].id;

package/dist/shell/shell.js

@@ -77,7 +77,9 @@ export class Shell {
         clearOpost();
         this.bus = opts.bus;
         this.handlers = opts.handlers;
-        this.outputParser = new OutputParser(opts.bus, opts.cwd, instanceTag);
+        this.outputParser = new OutputParser(opts.bus, opts.cwd, instanceTag, {
+            cleanOutput: this.strategy.cleanOutput?.bind(this.strategy),
+        });
         // Ensure temp dir cleanup on abnormal exit (SIGKILL won't fire this,
         // but it covers uncaught exceptions and normal process.exit paths)
         if (this.tmpDir) {

package/dist/shell/strategies/types.d.ts

@@ -47,4 +47,10 @@ export interface ShellStrategy {
      * Returns null if the shell can't redraw — caller falls back to freshPrompt.
      */
     redrawEscape(): string | null;
+    /**
+     * Strip shell-specific artifacts from raw PTY output before stripAnsi
+     * collapses SGR codes (e.g. zsh's PROMPT_SP inverse-video `%`). Default
+     * is identity — most shells need no cleanup.
+     */
+    cleanOutput?(raw: string): string;
 }

package/dist/shell/strategies/zsh.js

@@ -69,4 +69,11 @@ export const zshStrategy = {
     redrawEscape() {
         return "\x1b[9999~";
     },
+    cleanOutput(raw) {
+        return raw.replace(PROMPT_SP_RE, "");
+    },
 };
+/** PROMPT_SP marker (inverse-video PROMPT_EOL_MARK, default `%`) zsh prints
+ *  before a prompt when prior output didn't end at column 0. Matching the
+ *  inverse-video wrapper preserves legitimate trailing `%`. */
+const PROMPT_SP_RE = /\x1b\[7m.\x1b\[(?:0|27)m/g;

package/examples/extensions/ashi/src/cli.ts

@@ -7,8 +7,22 @@ import { loadBuiltinExtensions } from "agent-sh/extensions";
 import { loadExtensions } from "agent-sh/extension-loader";
 import { activateAgent } from "agent-sh/agent";
 import { getSettings } from "agent-sh/settings";
+import { Shell } from "agent-sh/shell";
+import type { Terminal } from "agent-sh/shell/terminal";
+import activateShellContext from "agent-sh/shell/context";
 import type { AppConfig } from "agent-sh/types";
 
+/** No-op: ashi renders via pi-tui, the PTY only needs to exist. */
+function headlessTerminal(): Terminal {
+  return {
+    write() {},
+    onInput: () => () => {},
+    onResize: () => () => {},
+    cols: () => 100,
+    rows: () => 30,
+  };
+}
+
 import { mountAshi } from "./frontend.js";
 import { MultiSessionStore } from "./multi-session-store.js";
 import { registerForkCommands, applyBranchMessages } from "./commands.js";
@@ -104,7 +118,6 @@ async function main(): Promise<void> {
     process.exit(1);
   }
 
-  // ── Pi-tui frontend
   const config = parseArgs(rawArgs);
 
   if (!process.stdin.isTTY) {
@@ -125,11 +138,13 @@ async function main(): Promise<void> {
 
   let stopFrontend: (() => void) | null = null;
 
+  let shellRef: { kill(): void } | null = null;
   const cleanup = (): void => {
-    try { stopFrontend?.(); } catch { /* ignore */ }
-    try { core.kill(); } catch { /* ignore */ }
+    try { stopFrontend?.(); } catch {}
+    try { shellRef?.kill(); } catch {}
+    try { core.kill(); } catch {}
     if (process.stdin.isTTY) {
-      try { process.stdin.setRawMode(false); } catch { /* ignore */ }
+      try { process.stdin.setRawMode(false); } catch {}
     }
     process.exit(0);
   };
@@ -137,8 +152,21 @@ async function main(): Promise<void> {
   const ctx = core.extensionContext({ quit: cleanup });
 
   activateAgent(ctx);
+  activateShellContext(ctx);
   await loadBuiltinExtensions(ctx);
 
+  const shell = new Shell({
+    bus: core.bus,
+    handlers: { define: ctx.define, call: ctx.call },
+    cols: 100,
+    rows: 30,
+    shell: process.env.SHELL ?? "/bin/bash",
+    cwd: process.cwd(),
+    instanceId: ctx.instanceId,
+    terminal: headlessTerminal(),
+  });
+  shellRef = shell;
+
   const loaded = await loadExtensions(ctx, config.extensions);
   core.bus.emit("core:extensions-loaded", { names: loaded });
 

package/examples/extensions/ashi/src/commands.ts

@@ -1,6 +1,5 @@
 import type { ExtensionContext } from "agent-sh/types";
 import type { MultiSessionStore } from "./multi-session-store.js";
-import type { AgentMessage } from "./session-store.js";
 import type { Capture } from "./capture.js";
 
 export function registerForkCommands(
@@ -12,14 +11,13 @@ export function registerForkCommands(
 ): void {
   const { bus } = ctx;
 
-  ctx.registerCommand("fork", "Rewind and branch: /fork (interactive picker) or /fork <id-prefix>", async (args) => {
+  ctx.registerCommand("fork", "Pick a past user message to edit, or a branch tip to switch to", async (args) => {
     const arg = args.trim();
     if (arg === "") {
       await openTreePicker();
       return;
     }
-    const branch = getStore().current().getBranch();
-    const matches = branch.filter((e) => e.id.startsWith(arg));
+    const matches = getStore().current().getAllEntries().filter((e) => e.id.startsWith(arg));
     if (matches.length === 0) {
       bus.emit("ui:error", { message: `fork: no entry matches "${arg}"` });
       return;
@@ -34,22 +32,6 @@ export function registerForkCommands(
     bus.emit("ui:info", { message: `fork: rewound to ${target.id}` });
     await rebuildChat();
   });
-
-  ctx.registerCommand("branch", "Show the active branch (root → leaf)", async () => {
-    const branch = getStore().current().getBranch();
-    if (branch.length === 0) {
-      bus.emit("ui:info", { message: "branch: empty" });
-      return;
-    }
-    const lines = branch.map((e) => {
-      if (e.type === "session") return `[${e.id}] session start (${e.cwd})`;
-      if (e.type === "compaction") return `[${e.id}] compaction (firstKept=${e.firstKeptId})`;
-      const msg = (e as { message: AgentMessage }).message;
-      const text = typeof msg.content === "string" ? msg.content : "";
-      return `[${e.id}] ${msg.role}: ${text.slice(0, 60)}`;
-    });
-    bus.emit("ui:info", { message: `branch (${branch.length} entries):\n${lines.join("\n")}` });
-  });
 }
 
 export function applyBranchMessages(

package/examples/extensions/ashi/src/default-schema-renderers.ts

@@ -1,10 +1,8 @@
-// Default schema-style renderers shipped with ashi. Each model below could
-// equally well live in an external extension — they use only the public
-// "@guanyilun/ashi/render" surface, proving the schema covers ashi's own
-// variety.
+// Default schema-style renderers shipped with ashi. Each uses only the public
+// "@guanyilun/ashi/render" surface — they could equally well live externally.
 
 import type { ExtensionContext } from "agent-sh/types";
-import type { RenderModel, Segment, ToolDisplay, TitleIcon } from "./schema.js";
+import type { RenderModel, Segment, ToolDisplay, TitleIcon, Color } from "./schema.js";
 
 function parseRaw(raw: unknown): Record<string, unknown> {
   if (typeof raw === "string") {
@@ -37,9 +35,6 @@ const accentSeg = (text: string): Segment => ({ text, style: { color: "accent" }
 const mutedSeg = (text: string): Segment => ({ text, style: { color: "muted" } });
 const warnSeg = (text: string): Segment => ({ text, style: { color: "warning" } });
 
-// ---------------------------------------------------------------------------
-// bash — full command toggle on Ctrl+O, syntax-highlighted, streaming output.
-
 interface BashInit { command: string; timeout?: number }
 
 const bashModel: RenderModel<BashInit> = {
@@ -62,8 +57,27 @@ const bashModel: RenderModel<BashInit> = {
   },
 };
 
-// ---------------------------------------------------------------------------
-// read — file path + optional offset:limit range.
+/** User-typed `!` shell commands. `▸` mirrors the status-footer glyph; the
+ *  right-aligned tag disambiguates private vs public on scrollback. */
+function makeUserBashModel(opts: { private: boolean }): RenderModel<BashInit> {
+  const color: Color = opts.private ? "bashModePrivate" : "bashMode";
+  const prefixSeg: Segment = { text: "▸ ", style: { bold: true, color } };
+  const tagText = opts.private ? "shell · private" : "shell";
+  const tagSeg: Segment = { text: tagText, style: { color, dim: true } };
+  return {
+    initial: ({ rawInput }) => {
+      const r = parseRaw(rawInput);
+      return { command: str(r.command) ?? "…", timeout: num(r.timeout) };
+    },
+    view: (s, env): ToolDisplay => ({
+      title: [prefixSeg, { text: env.expanded ? s.command : compact(s.command), highlight: "bash" }],
+      titleRight: [tagSeg],
+      status: s.status,
+      body: { kind: "stream", text: s.output },
+      expandable: true,
+    }),
+  };
+}
 
 interface ReadInit { path: string; range?: string }
 
@@ -94,9 +108,6 @@ const readModel: RenderModel<ReadInit> = {
   }),
 };
 
-// ---------------------------------------------------------------------------
-// grep / glob / ls — pattern + scope.
-
 interface GrepInit { pattern: string; scope: string; extras: string }
 
 const grepModel: RenderModel<GrepInit> = {
@@ -159,11 +170,6 @@ const lsModel: RenderModel<LsInit> = {
   }),
 };
 
-// ---------------------------------------------------------------------------
-// edit_file / write_file — path + framework-supplied diff body. The "Edited
-// /path (+N -M)" streaming text is suppressed because the diff body already
-// shows that information; per-line output reappears via expand on Ctrl+O.
-
 interface EditInit { path: string; verb: string }
 
 function editLikeModel(verb: string): RenderModel<EditInit> {
@@ -177,8 +183,8 @@ function editLikeModel(verb: string): RenderModel<EditInit> {
       titleIcon: "edit",
       title: [nameSeg(`${s.verb} `), accentSeg(s.path)],
       status: s.status,
-      // Collapsed-with-diff: diff only (the "Edited /path (+N -M)" stream line
-      // restates the call line). Expanded-with-diff: diff + stream output.
+      // Collapsed shows just the diff (the "Edited /path (+N -M)" stream
+      // line would only restate the call); expand adds the stream output.
       body: s.hasDiff
         ? (env.expanded
             ? { kind: "compound", parts: [{ kind: "diff" }, { kind: "stream", text: s.output }] }
@@ -189,9 +195,6 @@ function editLikeModel(verb: string): RenderModel<EditInit> {
   };
 }
 
-// ---------------------------------------------------------------------------
-// default — fallback for any tool without a specific renderer.
-
 interface DefaultInit { title: string; detail?: string; icon: TitleIcon }
 
 const defaultModel: RenderModel<DefaultInit> = {
@@ -212,10 +215,10 @@ const defaultModel: RenderModel<DefaultInit> = {
   }),
 };
 
-// ---------------------------------------------------------------------------
-
 export function registerDefaultSchemaRenderers(ctx: ExtensionContext): void {
   ctx.define("ashi:render-tool:bash", () => bashModel);
+  ctx.define("ashi:render-tool:user_bash", () => makeUserBashModel({ private: false }));
+  ctx.define("ashi:render-tool:user_bash_private", () => makeUserBashModel({ private: true }));
   ctx.define("ashi:render-tool:read_file", () => readModel);
   ctx.define("ashi:render-tool:read", () => readModel);
   ctx.define("ashi:render-tool:grep", () => grepModel);