agent-sh 0.14.2 → 0.14.3

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

@@ -1,14 +1,7 @@
-// Declarative render schema for tool-call hooks.
-//
-// External renderers register one hook per tool:
-//   ctx.define("ashi:render-tool:scheme", () => ({ initial, reducers, view }))
-//
-// The view function is pure: `view(state, env)` returns a ToolDisplay describing
-// title + status + body. Ashi owns the pi-tui mapping, theming, streaming
-// buffer policy, diff reflow on resize, expand/collapse — everything that used
-// to leak into renderer subclasses.
-
-import { Container, Spacer, Text } from "@earendil-works/pi-tui";
+// Declarative render schema for tool-call hooks. External renderers register
+// `ctx.define("ashi:render-tool:<name>", () => ({ initial, reducers, view }))`.
+
+import { Container, Spacer, Text, visibleWidth } from "@earendil-works/pi-tui";
 import type { Component } from "@earendil-works/pi-tui";
 import type { ThemeColor } from "./theme.js";
 import type { ToolEntryConfig } from "./display-config.js";
@@ -29,9 +22,8 @@ export type Segment = string | { text: string; style?: StyleHint; highlight?: st
 export type Body =
   | { kind: "text"; segments: Segment[] }
   | { kind: "code"; lang?: string; text: string }
-  /** Diff body — framework supplies the width-aware renderer via setDiffRenderer
-   *  (called from frontend.ts when the edit/write tool finalizes). Renderers
-   *  opt in by returning { kind: "diff" } and reading hasDiff from state. */
+  /** Width-aware renderer is supplied via setDiffRenderer; view() opts in by
+   *  returning { kind: "diff" } and gating on hasDiff in state. */
   | { kind: "diff" }
   | { kind: "stream"; text: string }
   | { kind: "lines"; lines: Segment[][] }
@@ -43,22 +35,22 @@ export interface DisplayStatus {
   summary?: string;
 }
 
-/** Built-in icon set ashi knows how to theme. Renderers pick a category;
- *  ashi picks the glyph. Falls back to the generic gear if absent. */
+/** Renderers pick a category; ashi picks the glyph. Falls back to generic. */
 export type TitleIcon = "read" | "search" | "edit" | "shell" | "generic" | "scheme";
 
 export interface ToolDisplay {
   titleIcon?: TitleIcon;
   title: Segment[];
+  /** Right-aligned on the title line; framework handles padding and reserves
+   *  space for the status suffix so renderers don't compute widths. */
+  titleRight?: Segment[];
   status?: DisplayStatus;
   body?: Body;
   expandable?: boolean;
   defaultExpanded?: boolean;
 }
 
-/** What the host tells the view about the rendering environment. Pure:
- *  changes here trigger a re-invocation of view(). `mode` and `previewLines`
- *  come from ashi.display.{name} — see display-config.ts. */
+/** `mode` and `previewLines` come from ashi.display.{name} (display-config.ts). */
 export interface Env {
   width: number;
   expanded: boolean;
@@ -69,9 +61,8 @@ export interface Env {
 
 export type Reducer<S, P = unknown> = (state: S, payload: P) => S;
 
-/** State as seen by view() — the user's S plus framework-tracked output/status.
- *  Renderers never need to wire `chunk` / `status` / `diff` reducers themselves.
- *  hasDiff is true once setDiffRenderer has been called (edit/write tools). */
+/** Framework tracks `output`, `status`, `hasDiff` — renderers don't wire
+ *  `chunk` / `status` / `diff` reducers themselves. */
 export type ViewState<S> = S & {
   output: string;
   status?: DisplayStatus;
@@ -88,8 +79,7 @@ export interface RenderInitArgs {
 
 export interface RenderModel<S = Record<string, never>> {
   initial: (args: RenderInitArgs) => S;
-  /** Optional. `status` and `chunk` are tracked by the framework — declare
-   *  reducers here only for tool-specific state transitions. */
+  /** Only for tool-specific state transitions; `status`/`chunk` are framework-tracked. */
   reducers?: Record<string, Reducer<ViewState<S>, never>>;
   view: (state: ViewState<S>, env: Env) => ToolDisplay;
   display?: Partial<ToolEntryConfig>;
@@ -101,12 +91,8 @@ export function isRenderModel(v: unknown): v is RenderModel<unknown> {
   return typeof o.initial === "function" && typeof o.view === "function";
 }
 
-// ---------------------------------------------------------------------------
-// Adapter: model → paired Components for call-side and result-side hooks.
-//
-// Both Components share a single state cell so that a `chunk` dispatch from
-// the result side repaints the call line too (e.g. for renderers that show
-// progress in the title).
+// Call-side and result-side components share one state cell, so chunks from
+// the result side can repaint the call line (e.g. for in-title progress).
 
 import { theme } from "./theme.js";
 
@@ -131,10 +117,7 @@ interface RenderHandle<S> {
   dispatch: (action: string, payload?: unknown) => void;
 }
 
-/** Per-toolCallId handle registry — sole purpose is letting the result-side
- *  mount find the call-side cell so they can share state. Once the result
- *  component is mounted, both views hold their own handle reference and the
- *  map entry is dead weight; cleared on finalize. */
+/** Lets the result-side mount find the call-side cell. Cleared on finalize. */
 const HANDLES = new Map<string, RenderHandle<unknown>>();
 
 export interface MountArgs {
@@ -191,9 +174,7 @@ function handleFor<S>(
   return handle as unknown as RenderHandle<S>;
 }
 
-// ---------------------------------------------------------------------------
-// Segment / Body → ANSI string rendering. Lives here so it's the only place
-// that knows about theme colors + highlighting; renderers stay pure-data.
+// Sole place that knows about theme colors + highlighting; renderers stay pure-data.
 
 import { highlight, supportsLanguage } from "cli-highlight";
 
@@ -271,9 +252,7 @@ function renderBody(body: Body, env: Env, diff: DiffSlot, exitCode?: number | nu
   }
 }
 
-// Lifted from ToolResultBody.repaint() in components.ts — preview/summary/hidden
-// policy is host-wide display config, not per-tool, so it lives here once and
-// every schema renderer with a kind:"stream" body inherits it for free.
+// Host-wide preview/summary/hidden policy inherited by every kind:"stream" body.
 function renderStream(buffer: string, env: Env, exitCode: number | null | undefined): string {
   const display = buffer.replace(/\n+$/, "");
   if (env.expanded) return theme.fg("toolOutput", display);
@@ -306,10 +285,7 @@ function lineCountHint(buffer: string, exitCode: number | null | undefined): str
   return `${arrow}${theme.fg("muted", label)}`;
 }
 
-// ---------------------------------------------------------------------------
-// Pi-tui Components produced by the adapter. Implement the existing
-// ToolCallView / ToolResultView contracts so the ashi resolver doesn't care
-// whether a renderer is legacy or schema-style.
+// Components that satisfy the legacy ToolCallView / ToolResultView contracts.
 
 class SchemaCallComponent extends Container {
   private line: Text;
@@ -330,7 +306,16 @@ class SchemaCallComponent extends Container {
     const display = this.handle.model.view(this.handle.cell.state as ViewState<unknown>, this.handle.cell.env);
     const icon = iconString(display.titleIcon);
     const title = segmentsToString(display.title);
-    this.line.setText(`${icon}${title}${statusSuffix(display.status)}`);
+    const status = statusSuffix(display.status);
+    if (display.titleRight && display.titleRight.length > 0) {
+      const right = segmentsToString(display.titleRight);
+      // env.width − 2 accounts for Text's paddingX=1 on each side.
+      const used = visibleWidth(icon) + visibleWidth(title) + visibleWidth(status) + visibleWidth(right);
+      const pad = " ".repeat(Math.max(2, this.handle.cell.env.width - 2 - used));
+      this.line.setText(`${icon}${title}${status}${pad}${right}`);
+    } else {
+      this.line.setText(`${icon}${title}${status}`);
+    }
   }
 }
 
@@ -369,9 +354,8 @@ class SchemaResultComponent extends Container {
     const env = this.handle.cell.env;
     const display = this.handle.model.view(this.handle.cell.state as ViewState<unknown>, env);
     if (!display.body) { this.body.setText(""); return; }
-    // kind:"stream" embeds preview/summary/hidden policy.
-    // kind:"diff" shows in preview mode or when expanded.
-    // Other kinds show iff expanded or the view requested defaultExpanded.
+    // stream embeds the preview/summary/hidden policy; diff shows in preview
+    // or when expanded; other kinds show only when expanded/defaultExpanded.
     if (display.body.kind === "diff" && !env.expanded && env.mode !== "preview") {
       this.body.setText("");
       return;
@@ -385,11 +369,6 @@ class SchemaResultComponent extends Container {
   }
 }
 
-// ---------------------------------------------------------------------------
-// Public mount functions used by hooks.ts when resolving a schema-style
-// renderer. Each returns a Component that satisfies the legacy view contract,
-// so the rest of ashi doesn't need to know schema renderers exist.
-
 export interface MountEnv {
   width: number;
   mode: Env["mode"];

package/examples/extensions/ashi/src/session-store.ts

@@ -44,7 +44,25 @@ export interface CompactionEntry {
   tokensBefore: number;
 }
 
-export type SessionEntry = SessionHeaderEntry | MessageEntry | CompactionEntry;
+/** Omitted from buildMessages — the agent already saw it via <shell_events>
+ *  (or didn't, if private). The frontend replays it for scrollback fidelity. */
+export interface ShellExchangeEntry {
+  type: "shell-exchange";
+  id: string;
+  parentId: string;
+  timestamp: number;
+  command: string;
+  output: string;
+  exitCode: number | null;
+  cwd?: string;
+  private?: boolean;
+}
+
+export type SessionEntry =
+  | SessionHeaderEntry
+  | MessageEntry
+  | CompactionEntry
+  | ShellExchangeEntry;
 
 export interface SessionMeta {
   name?: string;
@@ -96,13 +114,22 @@ export function summarizeMessage(m: AgentMessage): string {
   return `${role}: ${snippet(extractText(m.content), 500)}`;
 }
 
+/** For displayed user text. Loops because both wrappers can stack at the head. */
+export function stripContextWrappers(content: string): string {
+  let out = content;
+  for (;;) {
+    const next = out.replace(/^\s*<(query_context|dynamic_context)>[\s\S]*?<\/\1>\s*/, "");
+    if (next === out) return out;
+    out = next;
+  }
+}
+
 export function renderEvictedSummary(evicted: AgentMessage[]): string {
   const lines = evicted.map((m) => `- ${summarizeMessage(m)}`);
   return `${lines.length} message(s) elided\n${lines.join("\n")}`;
 }
 
-/** One session = one JSONL file (entries) + sidecar files for leaf & meta.
- *  Tree is implicit via parentId pointers; entries kept in memory after load. */
+/** Tree is implicit via parentId pointers; entries are kept in memory after load. */
 export class SessionStore {
   private entriesPath: string;
   private leafPath: string;
@@ -170,9 +197,6 @@ export class SessionStore {
     this.persistMeta();
   }
 
-  /** Append messages as a chain of MessageEntry, each parented at the
-   *  previously appended id (starting from current leaf). Returns the new
-   *  entry ids in order. */
   async appendMessages(messages: AgentMessage[]): Promise<string[]> {
     if (messages.length === 0) return [];
     this.flushHeader();
@@ -198,6 +222,32 @@ export class SessionStore {
     return newIds;
   }
 
+  async appendShellExchange(e: {
+    command: string;
+    output: string;
+    exitCode: number | null;
+    cwd?: string;
+    private?: boolean;
+  }): Promise<string> {
+    this.flushHeader();
+    const entry: ShellExchangeEntry = {
+      type: "shell-exchange",
+      id: newEntryId(),
+      parentId: this.activeLeaf,
+      timestamp: Date.now(),
+      command: e.command,
+      output: e.output,
+      exitCode: e.exitCode,
+      ...(e.cwd !== undefined ? { cwd: e.cwd } : {}),
+      ...(e.private ? { private: true } : {}),
+    };
+    this.entries.set(entry.id, entry);
+    this.activeLeaf = entry.id;
+    await fsp.appendFile(this.entriesPath, JSON.stringify(entry) + "\n");
+    this.persistLeaf();
+    return entry.id;
+  }
+
   async appendCompaction(firstKeptId: string, tokensBefore: number, summary?: string): Promise<string> {
     if (!this.entries.has(firstKeptId)) throw new Error(`firstKeptId unknown: ${firstKeptId}`);
     this.flushHeader();
@@ -217,7 +267,7 @@ export class SessionStore {
     return e.id;
   }
 
-  /** Walk parent pointers from a leaf back to the root. Returns oldest-first. */
+  /** Oldest-first walk from leaf to root. */
   getBranch(leafId: string = this.activeLeaf): SessionEntry[] {
     const out: SessionEntry[] = [];
     const seen = new Set<string>();
@@ -232,9 +282,7 @@ export class SessionStore {
     return out.reverse();
   }
 
-  /** Reconstruct the live message array for the active leaf, honoring the
-   *  latest compaction on the branch (summary + kept tail). Mirrors pi's
-   *  buildSessionContext. */
+  /** Honors the latest compaction on the branch (summary + kept tail). */
   buildMessages(leafId: string = this.activeLeaf): AgentMessage[] {
     const branch = this.getBranch(leafId);
     let compactionIdx = -1;
@@ -265,12 +313,11 @@ export class SessionStore {
     return out;
   }
 
-  /** A short, human-friendly preview for picker rows. Uses the first user
-   *  message's text when available, else the session id. */
   getPreview(): string {
     for (const e of this.entries.values()) {
       if (e.type === "message" && e.message.role === "user") {
-        const txt = typeof e.message.content === "string" ? e.message.content : "";
+        const raw = typeof e.message.content === "string" ? e.message.content : "";
+        const txt = stripContextWrappers(raw);
         if (txt) return txt.slice(0, 80);
       }
     }

package/examples/extensions/ashi/src/shell-mode.ts

@@ -0,0 +1,52 @@
+export interface ChangeHandlerResult {
+  mode: boolean;
+  /** When set, caller must `editor.setText(replaceText)` to strip the `!`. */
+  replaceText?: string;
+  /** Whether the next submit (if in shell mode) is marked private. */
+  pendingPrivate: boolean;
+}
+
+/** Strips `!` (entry), `!!` (entry + private), in-mode `!` (upgrade to private).
+ *  Shell mode is sticky — exit only via the Backspace-on-empty intercept;
+ *  auto-exit on empty text would fire during pi-tui's pre-emptive onChange("")
+ *  inside Editor.submitValue() and misroute the submit. pendingPrivate is
+ *  sticky for the same reason. */
+export function deriveChangeHandlerResult(
+  mode: boolean,
+  pendingPrivate: boolean,
+  text: string,
+): ChangeHandlerResult {
+  if (!mode && text.startsWith("!!")) {
+    return { mode: true, replaceText: text.slice(2), pendingPrivate: true };
+  }
+  if (!mode && text.startsWith("!")) {
+    return { mode: true, replaceText: text.slice(1), pendingPrivate: false };
+  }
+  if (mode && text.startsWith("!")) {
+    return { mode: true, replaceText: text.slice(1), pendingPrivate: true };
+  }
+  return { mode, pendingPrivate: pendingPrivate && mode };
+}
+
+export type SubmitAction =
+  | { kind: "noop" }
+  | { kind: "shell"; line: string; private: boolean }
+  | { kind: "command"; name: string; args: string }
+  | { kind: "agent"; query: string };
+
+export function classifySubmit(
+  text: string,
+  shellMode: boolean,
+  pendingPrivate: boolean,
+): SubmitAction {
+  const query = text.trim();
+  if (!query) return { kind: "noop" };
+  if (shellMode) return { kind: "shell", line: query, private: pendingPrivate };
+  if (query.startsWith("/")) {
+    const sp = query.indexOf(" ");
+    const name = sp === -1 ? query : query.slice(0, sp);
+    const args = sp === -1 ? "" : query.slice(sp + 1).trim();
+    return { kind: "command", name, args };
+  }
+  return { kind: "agent", query };
+}

package/examples/extensions/ashi/src/status-footer.ts

@@ -12,6 +12,7 @@ interface StatusFields {
   tokens?: number;
   compactions?: number;
   thinking?: string;
+  shellMode?: "off" | "on" | "private";
 }
 
 export class StatusFooter extends Container {
@@ -40,12 +41,25 @@ export class StatusFooter extends Container {
 
   private repaint(width: number): void {
     const contentWidth = width > 0 ? Math.max(1, width - 2) : 0;
+    const right = this.buildRight();
+    const rightWidth = visibleWidth(right);
+    const join = (left: string): string => {
+      if (!right) return left;
+      const leftWidth = visibleWidth(left);
+      const gap = Math.max(1, contentWidth - leftWidth - rightWidth);
+      return `${left}${" ".repeat(gap)}${right}`;
+    };
     const full = this.buildLine("full");
-    if (contentWidth === 0 || visibleWidth(full) <= contentWidth) {
-      this.text.setText(full);
-      return;
-    }
-    this.text.setText(this.buildLine("basename"));
+    const fullFits = contentWidth === 0
+      || visibleWidth(full) + (right ? rightWidth + 1 : 0) <= contentWidth;
+    this.text.setText(fullFits ? join(full) : join(this.buildLine("basename")));
+  }
+
+  private buildRight(): string {
+    const mode = this.fields.shellMode;
+    if (mode === "on") return theme.fg("bashMode", "▸ shell");
+    if (mode === "private") return theme.fg("bashModePrivate", "▸ shell · private");
+    return "";
   }
 
   private buildLine(cwdMode: "full" | "basename"): string {

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

@@ -53,7 +53,8 @@ const RAW = {
   toolDiffAdded: "green",
   toolDiffRemoved: "red",
   toolDiffContext: "gray",
-  bashMode: "green",
+  bashMode: "yellow",
+  bashModePrivate: "green",
 } as const;
 
 export type ThemeColor = keyof typeof RAW;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-sh",
-  "version": "0.14.2",
+  "version": "0.14.3",
   "description": "A shell-first terminal where AI is one keystroke away",
   "type": "module",
   "workspaces": [
@@ -49,6 +49,10 @@
       "types": "./dist/shell/terminal.d.ts",
       "default": "./dist/shell/terminal.js"
     },
+    "./shell/context": {
+      "types": "./dist/shell/shell-context.d.ts",
+      "default": "./dist/shell/shell-context.js"
+    },
     "./utils/stream-transform": {
       "types": "./dist/utils/stream-transform.d.ts",
       "default": "./dist/utils/stream-transform.js"