agent-sh 0.14.10 → 0.15.0

package/examples/extensions/ash-scheme/package.json

@@ -5,7 +5,7 @@
   "type": "module",
   "main": "index.ts",
   "dependencies": {
-    "@jcubic/lips": "^0.20.3",
+    "@jcubic/lips": "1.0.0-beta.20",
     "agent-sh": "^0.14.0"
   }
 }

package/examples/extensions/ashi/EXTENDING.md

@@ -0,0 +1,118 @@
+# Extending ashi
+
+Other extensions can customize how chat entries and tool results render — and even swap the whole TUI renderer — without forking ashi. For non-render concerns (commands, settings, tools, providers) use the standard `agent-sh` extension API; see the [agent-sh extension docs](https://github.com/guanyilun/agent-sh/blob/main/docs/extensions.md).
+
+To **drive** the UI from an extension — post a notice, add a status segment, pin a dock widget, or open a select/confirm/input dialog — use the UI-surface protocol (bus events + named handlers, no `ctx.ui` object); see [`docs/ui-surface-protocol.md`](docs/ui-surface-protocol.md) and the worked example `examples/extensions/ashi-ui-demo.ts`.
+
+## Chat hooks
+
+These return a renderer-agnostic chat-entry view built from the active renderer's
+node factories (`args.nodes`), so an override never imports a concrete TUI library:
+
+| Hook | Args | Returns |
+|---|---|---|
+| `ashi:render-user-message` | `{ text, nodes, state, invalidate }` | `{ node }` |
+| `ashi:render-assistant` | `{ text, nodes, state, invalidate }` | `{ node, appendText, appendCodeBlock, finalize, hasContent }` |
+| `ashi:render-thinking` | `{ text, hidden, nodes, state, invalidate }` | `{ node, appendText, finalize, setHidden }` |
+
+`nodes` is a `RenderNodes` (`text` / `markdown` / `image` / `container` / `spacer`); `src/chat/` holds the default controllers.
+
+## Tool hooks — declarative render schema
+
+Tool rendering uses a declarative schema so extensions don't import pi-tui or touch ashi internals. Register a `RenderModel` under `ashi:render-tool:{name}` (with `:default` as the fallback):
+
+```ts
+import type { RenderModel, ToolDisplay } from "@guanyilun/ashi/render";
+
+const myModel: RenderModel<{ command: string }> = {
+  initial: ({ rawInput }) => ({ command: JSON.parse(String(rawInput)).command ?? "" }),
+  view: (s): ToolDisplay => ({
+    title: [
+      { text: "$ ", style: { bold: true, color: "toolTitle" } },
+      { text: s.command, highlight: "bash" },
+    ],
+    status: s.status,
+    body: { kind: "stream", text: s.output },
+    expandable: true,
+  }),
+};
+
+export default function activate(ctx) {
+  ctx.define("ashi:render-tool:bash", () => myModel);
+}
+```
+
+`view(state, env)` is a pure function returning a `ToolDisplay`. Ashi owns the mapping to the active renderer, theming, streaming buffer policy (preview / summary / hidden modes from `ashi.display`), diff width memoization, and the Ctrl+O expand toggle. The framework auto-tracks `state.status`, `state.output` (streaming chunks), and `state.hasDiff` (for edit/write) — renderers read these without wiring their own reducers.
+
+`ToolDisplay` body kinds: `text`, `code` (with syntax highlighting via `lang`), `stream` (preview/summary/hidden policy applied by ashi), `diff` (closure pushed by the frontend orchestrator), `lines`, `compound`. Custom state transitions can be declared via an optional `reducers` map.
+
+To ship a default display policy with your renderer (e.g. "this tool's output is large, default to `summary`"), set `display` on the model. User `settings.json` still wins:
+
+```ts
+const myModel: RenderModel<...> = {
+  initial, view,
+  display: { result: "summary", previewLines: 3 },
+};
+```
+
+## Renderers
+
+The whole TUI is swappable. ashi (the substrate) depends only on the `Renderer`
+contract from [`@guanyilun/ashi/renderer`](src/renderer.ts) — the schema, theme,
+chat controllers, and frontend never import a concrete TUI library. The built-in
+renderer is pi-tui (`src/renderers/pi-tui`).
+
+A renderer is just an extension that registers `ashi:renderer:<name>`:
+
+```ts
+import type { Renderer } from "@guanyilun/ashi/renderer";
+
+function createMyRenderer(): Renderer { /* … */ }
+
+export default function activate(ctx) {
+  ctx.define("ashi:renderer:my-tui", () => createMyRenderer());
+}
+```
+
+**Loading vs. selecting are separate.** A renderer must be *loaded* (so its
+`ashi:renderer:<name>` is registered) and then *selected* by name:
+
+- **Load** — `ashi install my-tui-renderer` (installed extensions auto-load every
+  launch), or `-e my-tui-renderer` to load from source during development.
+- **Select** — `--renderer my-tui` (flag) **>** `ASHI_RENDERER=my-tui` (env) **>**
+  `ashi.renderer` in `settings.json` (persistent preference) **>** `pi-tui`
+  (default). An unknown name errors rather than silently falling back.
+
+So a persistent setup is `ashi install my-tui-renderer` once + `"ashi": { "renderer":
+"my-tui" }` in settings — no per-command flags. The contract has two halves —
+content-node factories (`text` / `markdown` / `image` / `container` / `spacer`) and
+an app shell (`mount()` → scrollback / footer / queue / input / `belowInput` / status,
+plus select lists, loader, and key events) — together with `mountToolCall` / `mountToolResult`
+and a `capabilities` list so a renderer can declare gaps and the substrate degrades
+rather than crashes. This is how you build a different TUI frontend (Ink, a
+remote/web bridge…) without forking ashi.
+
+Tool calls follow the same rule: the renderer owns the look. Same-kind runs of
+`read`/`search` are collapsed by a substrate `ToolGroup` controller that owns only
+the *state* (tail-merge, eviction, expand) and hands the renderer a neutral
+`ToolGroupModel` to draw via the optional `mountToolGroup()`. The substrate ships
+a default rendering — `renderToolGroupLines(model)`, the `├`/`└` tree — that a
+renderer can mount as-is (both pi-tui and Ink do) or ignore and draw the model
+however it likes. Grouping is a presentation policy, not a mandate: a renderer
+that omits `mountToolGroup` opts out entirely, and the substrate renders those
+calls individually through the schema mount.
+
+Autocomplete works the same way: the substrate owns the popup and mounts the
+suggestion list in the `belowInput` slot; the renderer only draws it, so the
+slash-command / `@`-file popup behaves identically in every renderer.
+
+The substrate also owns terminal setup so renderers don't each rediscover it.
+agent-sh's shell clears OPOST on boot (pi-tui emits its own `\r`); ashi reads
+`capabilities.rawOutput` and restores OPOST for renderers that emit lone `\n`
+(Ink and most libraries — the default), so they don't staircase. A new renderer
+gets the conventional terminal for free; only a raw driver like pi-tui sets
+`rawOutput: true`.
+
+See [`examples/extensions/ashi-ink`](../ashi-ink) for a worked example — a **working**
+Ink (React) renderer (`ASHI_RENDERER=ink ashi -e ashi-ink`), verified with
+`ink-testing-library`.

package/examples/extensions/ashi/README.md

@@ -7,6 +7,14 @@
 
 Same backend, tools, slash commands, providers, and skills as `agent-sh`, mounted in a chat-style interface with session history, branching, and LLM-driven compaction.
 
+Rendering is **decoupled** — even *how* ashi draws tool calls and results is a swappable render extension. Same agent, same conversation; load a different render extension and the whole TUI restyles, no code changes:
+
+| pi-style rendering | claude-code-style rendering |
+|---|---|
+| ![ashi rendering tool calls pi-style](https://raw.githubusercontent.com/guanyilun/agent-sh/main/assets/ashi-pi-style.png) | ![ashi rendering tool calls claude-code-style](https://raw.githubusercontent.com/guanyilun/agent-sh/main/assets/ashi-claude-code-style.png) |
+
+The claude-code-style renderer is [ashi-ink](../ashi-ink), a working Ink (React) renderer; see [Extending ashi](#extending-ashi) for the contract.
+
 ## Install
 
 ```bash
@@ -73,6 +81,8 @@ Ctrl+O       Expand/collapse all tool calls and results in chat
 
 The current thinking level is shown in the footer as `[level]` next to the model name.
 
+Typing `/` (commands) or `@` (files) opens a suggestion popup: ↑/↓ to move, Tab or Enter to accept, Esc to dismiss.
+
 ## Sessions
 
 Many sessions per cwd, fresh by default:
@@ -122,7 +132,7 @@ Per-tool compactness lives under `ashi.display` in `~/.agent-sh/settings.json`:
 {
   "ashi": {
     "display": {
-      "default": { "result": "preview", "previewLines": 5 },
+      "default": { "result": "preview", "previewLines": 5, "expandedLines": 200 },
       "read":    { "result": "hidden" },
       "ls":      { "result": "hidden" },
       "grep":    { "result": "summary" },
@@ -142,63 +152,17 @@ Per-tool compactness lives under `ashi.display` in `~/.agent-sh/settings.json`:
 
 For `edit_file` / `write_file`, the diff frame is treated as the output and follows the same gating: shown for `preview`, hidden for `hidden`/`summary` (the call line already carries `+12 -3` stats). The line-count hint is suppressed for diff-producing tools so edits stay quiet.
 
-Hit `Ctrl+O` to toggle expansion across all tool entries in chat — result bodies show their full output regardless of mode, and call lines with truncated labels (e.g. long `bash` commands) reveal their full text. Press again to collapse.
+Hit `Ctrl+O` to toggle expansion across all tool entries in chat — result bodies show their output regardless of mode, and call lines with truncated labels (e.g. long `bash` commands) reveal their full text. Press again to collapse. Expanded output is still tail-capped to `expandedLines` (default 200) so `Ctrl+O` on a huge result can't flood the scrollback — the rest shows as a `… (N earlier lines hidden)` note. The agent always receives the full output; only the on-screen display is bounded.
 
 Each tool inherits from `default` and is overridden by its own block. Unknown tool names fall through to `default`.
 
-## Extension surface
-
-Other extensions can customize how chat entries and tool results render without forking ashi.
-
-### Chat hooks
-
-These return [`@earendil-works/pi-tui`](https://www.npmjs.com/package/@earendil-works/pi-tui) components directly:
+## Extending ashi
 
-| Hook | Args | Returns |
-|---|---|---|
-| `ashi:render-user-message` | `{ text, state, invalidate }` | `Component` |
-| `ashi:render-assistant` | `{ text, state, invalidate }` | `Component` |
-| `ashi:render-thinking` | `{ text, hidden, state, invalidate }` | `Component` |
-
-### Tool hooks — declarative render schema
-
-Tool rendering uses a declarative schema so extensions don't import pi-tui or touch ashi internals. Register a `RenderModel` under `ashi:render-tool:{name}` (with `:default` as the fallback):
-
-```ts
-import type { RenderModel, ToolDisplay } from "@guanyilun/ashi/render";
-
-const myModel: RenderModel<{ command: string }> = {
-  initial: ({ rawInput }) => ({ command: JSON.parse(String(rawInput)).command ?? "" }),
-  view: (s): ToolDisplay => ({
-    title: [
-      { text: "$ ", style: { bold: true, color: "toolTitle" } },
-      { text: s.command, highlight: "bash" },
-    ],
-    status: s.status,
-    body: { kind: "stream", text: s.output },
-    expandable: true,
-  }),
-};
-
-export default function activate(ctx) {
-  ctx.define("ashi:render-tool:bash", () => myModel);
-}
-```
-
-`view(state, env)` is a pure function returning a `ToolDisplay`. Ashi owns the pi-tui mapping, theming, streaming buffer policy (preview / summary / hidden modes from `ashi.display`), diff width memoization, and the Ctrl+O expand toggle. The framework auto-tracks `state.status`, `state.output` (streaming chunks), and `state.hasDiff` (for edit/write) — renderers read these without wiring their own reducers.
-
-`ToolDisplay` body kinds: `text`, `code` (with syntax highlighting via `lang`), `stream` (preview/summary/hidden policy applied by ashi), `diff` (closure pushed by the frontend orchestrator), `lines`, `compound`. Custom state transitions can be declared via an optional `reducers` map.
-
-To ship a default display policy with your renderer (e.g. "this tool's output is large, default to `summary`"), set `display` on the model. User `settings.json` still wins:
-
-```ts
-const myModel: RenderModel<...> = {
-  initial, view,
-  display: { result: "summary", previewLines: 3 },
-};
-```
-
-For non-render concerns (commands, settings, tools, providers) use the standard `agent-sh` extension API. See the [agent-sh extension docs](https://github.com/guanyilun/agent-sh/blob/main/docs/extensions.md).
+Other extensions can customize chat and tool-result rendering — and even swap the whole
+TUI renderer (pi-tui, [Ink](../ashi-ink), …) — without forking ashi. See **[EXTENDING.md](EXTENDING.md)**
+for the chat/tool render hooks, the declarative tool render schema, and the renderer
+contract. For non-render concerns (commands, settings, tools, providers), use the
+standard [agent-sh extension API](https://github.com/guanyilun/agent-sh/blob/main/docs/extensions.md).
 
 ## Install from source
 
@@ -211,6 +175,14 @@ export PATH="$HOME/.agent-sh/bin:$PATH"
 
 `agent-sh install` runs `npm install` and `npm run build` in the copied directory and symlinks the built bin into `~/.agent-sh/bin/`.
 
+By default the copy pulls the **published** `agent-sh` from npm. When ashi's source depends on an unreleased core — a kernel change you haven't published yet — add `--dev` so the install links against the checkout you're running instead:
+
+```bash
+agent-sh install ashi --dev --force
+```
+
+`--dev` repoints the copied package's `agent-sh` dependency at the running host's checkout (the one the global `agent-sh` is linked to). The build then sees the local types, and a later `npm run build` at the repo root flows through without reinstalling — the kernel rebuild rule from [Development](#development) applies. Re-run the install to refresh ashi's own dist after frontend changes.
+
 ## Development
 
 `@guanyilun/ashi` depends on the published `agent-sh` package. To iterate against a local checkout, use `npm link`:

package/examples/extensions/ashi/docs/ui-surface-protocol.md

@@ -0,0 +1,163 @@
+# ashi UI surfaces
+
+How an extension drives ashi's terminal UI — post a notice, add a status-bar segment, pin a
+widget above the input, or ask the user a question.
+
+ashi doesn't hand extensions a `ui` object. Instead it answers a small set of **bus events**
+and **named handlers**, so the same extension degrades gracefully under a frontend that doesn't
+implement a given surface (and under headless/RPC use). There are three shapes:
+
+- **Notices** are fire-and-forget bus events (`ctx.bus.emit`).
+- **Status segments and docks** are *pull* pipes (`ctx.bus.onPipe`): ashi asks for contributions
+  while it repaints and you append yours — ashi owns the layout.
+- **Dialogs** are request/response calls (`await ctx.call(...)`) that resolve when the user answers.
+
+## Setup
+
+For typed events, import the augmentation once (types only — no runtime cost):
+
+```ts
+import "@guanyilun/ashi/events";
+```
+
+`ui:*` names are meant to work under any ashi-compatible frontend; `ashi:*` names are specific to
+ashi's terminal UI. Before a `ctx.call(...)` that must return a value, feature-detect:
+
+```ts
+if (ctx.list().includes("ui:select")) { /* … */ }
+```
+
+Bus emits (`ui:notify`, the `*:invalidate` nudges) need no detection — they're no-ops when nothing
+is listening.
+
+## Timing
+
+Extensions load before ashi mounts, so the surfaces aren't all live at `activate()` time:
+
+- **Pull contributors (`status`, `dock`, any `onPipe`) can be registered any time** — ashi reads them
+  on its next repaint, so registering during `activate()` is fine; the first paint picks them up.
+- **Imperative surfaces (notify, dialogs, editor) are ready once ashi has mounted.** From a command
+  or key handler they're always ready. To use one at startup, wait for the `ashi:ready` event:
+
+  ```ts
+  ctx.bus.on("ashi:ready", () => createUi(ctx).notify("loaded"));
+  ```
+
+The helper degrades (`select`/`input` → `undefined`, `confirm` → `false`) if called before a frontend
+answers, so a premature call can't throw; a premature `notify` is simply dropped.
+
+## Post a notice
+
+```ts
+ctx.bus.emit("ui:notify", { message: "Saved.", level: "success" });
+// level: "info" (default) | "warn" | "error" | "success"
+```
+
+Appends a themed line to the transcript.
+
+## Add a status-bar segment
+
+Contribute to the footer; ashi appends your segment and owns placement:
+
+```ts
+ctx.bus.onPipe("ui:status", (p) => ({
+  segments: [...p.segments, { id: "build", text: "✓ build ok", color: "success" }],
+}));
+```
+
+A segment is `{ id: string; text: string; color?: ThemeColor }`, where `ThemeColor` is a theme name
+such as `"accent"`, `"success"`, `"warning"`, `"error"`, or `"muted"`. When your data changes
+outside a repaint, ask ashi to re-pull:
+
+```ts
+ctx.bus.emit("ui:status:invalidate", {});
+```
+
+## Pin a widget above the input
+
+Same pull model, but you build the view from the renderer's node factory (so you never import a
+TUI library):
+
+```ts
+ctx.bus.onPipe("ashi:dock:above-input", (p) => {
+  const line = p.nodes.text({ paddingX: 1 });
+  line.setText("📌 2 todos remaining");
+  return { ...p, views: [...p.views, line.node] };
+});
+
+// after a change:
+ctx.bus.emit("ashi:dock:invalidate", {});
+```
+
+`p.nodes` offers `text`, `markdown`, `container`, `spacer`, and `image`. Return the payload
+unchanged to contribute nothing — the dock takes zero space when empty.
+
+## Ask the user
+
+```ts
+const fruit = await ctx.call("ui:select", {
+  title: "Pick a fruit",
+  items: [
+    { value: "apple", label: "Apple", description: "crisp" },
+    { value: "banana", label: "Banana" },
+  ],
+});                      // → the chosen value, or undefined if cancelled
+
+const ok = await ctx.call("ui:confirm", { title: "Delete it?" });   // → boolean
+
+const name = await ctx.call("ui:input", {
+  title: "Name?",        // hint shown above the input
+  prefill: "untitled",   // optional starting text
+});                      // → the text, or undefined if cancelled (Esc)
+```
+
+Only one dialog (or built-in picker) is open at a time; a call made while one is open resolves
+`undefined`.
+
+## Read or seed the input
+
+```ts
+const draft = ctx.call("ui:editor:get-text") as string;
+ctx.call("ui:editor:set-text", "/commit ");
+```
+
+## Typed helper
+
+If you're willing to depend on `@guanyilun/ashi`, `createUi(ctx)` wraps everything above with
+full types and no magic strings. Request/response surfaces also degrade on their own — `select`
+and `input` resolve `undefined`, `confirm` resolves `false` — when no frontend answers:
+
+```ts
+import { createUi } from "@guanyilun/ashi/ui";
+
+const ui = createUi(ctx);
+ui.notify("Saved.", "success");
+const fruit = await ui.select({ title: "Pick", items: [{ value: "a", label: "Apple" }] });
+const seg = ui.status(() => ({ id: "build", text: "✓ ok", color: "success" })); // seg.refresh() / seg.remove()
+const widget = ui.dock((nodes) => {
+  const t = nodes.text({ paddingX: 1 });
+  t.setText("📌 note");
+  return t.node;
+});
+```
+
+The raw events and calls above carry no build-time dependency on ashi — reach for them if you
+want a dependency-free extension. The helper is the same protocol with types and degradation
+bolted on.
+
+## Not yet available
+
+Floating/overlay panels and fully custom interactive components aren't exposed — the renderer
+contract has no free-placement layer yet. Use the dock, dialogs, and notices above.
+
+## Working example
+
+[`ashi-ui-demo.ts`](../../ashi-ui-demo.ts) exercises every surface through the typed helper. Load
+it and try the commands:
+
+```
+ashi -e ashi-ui-demo
+/ui-demo        # select → confirm → input, then a notice
+/ui-demo-bump   # update the status segment
+/ui-demo-dock   # toggle the pinned widget
+```

package/examples/extensions/ashi/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@guanyilun/ashi",
-  "version": "0.1.8",
+  "version": "0.2.0",
   "description": "Ash in an interactive TUI — agent-sh's built-in agent without the shell underneath",
   "type": "module",
   "main": "dist/cli.js",
@@ -12,6 +12,18 @@
     "./render": {
       "types": "./dist/schema.d.ts",
       "import": "./dist/schema.js"
+    },
+    "./renderer": {
+      "types": "./dist/renderer.d.ts",
+      "import": "./dist/renderer.js"
+    },
+    "./events": {
+      "types": "./dist/events.d.ts",
+      "import": "./dist/events.js"
+    },
+    "./ui": {
+      "types": "./dist/ui.d.ts",
+      "import": "./dist/ui.js"
     }
   },
   "files": [
@@ -56,7 +68,7 @@
   },
   "dependencies": {
     "@earendil-works/pi-tui": "^0.74.0",
-    "agent-sh": "^0.14.8",
+    "agent-sh": "^0.14.11",
     "chalk": "^5.5.0",
     "cli-highlight": "^2.1.11"
   },

package/examples/extensions/ashi/src/autocomplete-controller.ts

@@ -0,0 +1,95 @@
+import type {
+  App,
+  AutocompleteItem,
+  AutocompleteProvider,
+  InputView,
+  KeyEvent,
+  SelectView,
+} from "./renderer.js";
+
+export interface AutocompleteController {
+  /** Re-query suggestions for the current input. Call from the input's onChange. */
+  refresh(): void;
+}
+
+const VISIBLE_ROWS = 8;
+
+/**
+ * Substrate-owned autocomplete: the renderer only draws a SelectView in `belowInput`, so
+ * the popup behaves identically in any renderer instead of living inside one editor.
+ */
+export function createAutocompleteController(opts: {
+  app: App;
+  input: InputView;
+  provider: AutocompleteProvider;
+  suppressed: () => boolean;
+}): AutocompleteController {
+  const { app, input, provider, suppressed } = opts;
+  let view: SelectView | null = null;
+  let items: AutocompleteItem[] = [];
+  let prefix = "";
+  let index = 0;
+  let reqSeq = 0;
+  let applying = false;
+
+  const clear = (): void => {
+    if (!view) return;
+    app.belowInput.clear();
+    view = null;
+    items = [];
+  };
+
+  const refresh = (): void => {
+    if (applying) return;
+    if (suppressed()) { clear(); app.requestRender(); return; }
+    const lines = input.getText().split("\n");
+    const { line, col } = input.getCursor();
+    const seq = ++reqSeq;
+    void Promise.resolve(provider.getSuggestions(lines, line, col)).then((result) => {
+      if (seq !== reqSeq || applying) return;
+      if (!result || result.items.length === 0) { clear(); app.requestRender(); return; }
+      items = result.items;
+      prefix = result.prefix;
+      index = Math.max(0, Math.min(index, items.length - 1));
+      app.belowInput.clear();
+      view = app.createSelectList(
+        items.map((it) => ({ value: it.value, label: it.label, description: it.description })),
+        { visibleRows: VISIBLE_ROWS },
+      );
+      view.setSelectedIndex(index);
+      app.belowInput.addChild(view.node);
+      app.requestRender();
+    });
+  };
+
+  // Enter applies and closes. Tab applies and, for `@`/path completions, re-queries so
+  // you can keep completing deeper — slash commands close (else an exact command would
+  // re-match itself and the list would never dismiss). `applying` swallows the onChange
+  // that replaceBeforeCursor fires mid-apply.
+  const apply = (allowReopen: boolean): void => {
+    const chosen = items[index];
+    if (!chosen) return;
+    const slash = prefix.startsWith("/");
+    applying = true;
+    input.replaceBeforeCursor(prefix.length, chosen.value);
+    clear();
+    applying = false;
+    if (allowReopen && !slash) refresh();
+    app.requestRender();
+  };
+
+  app.onKey((key: KeyEvent): { consume: boolean } | void => {
+    if (key.isRelease() || key.isRepeat()) return;
+    if (!view || items.length === 0) {
+      if (key.matches("tab")) { refresh(); return { consume: true }; }
+      return;
+    }
+    if (key.matches("up")) { index = (index - 1 + items.length) % items.length; view.setSelectedIndex(index); app.requestRender(); return { consume: true }; }
+    if (key.matches("down")) { index = (index + 1) % items.length; view.setSelectedIndex(index); app.requestRender(); return { consume: true }; }
+    if (key.matches("return")) { apply(false); return { consume: true }; }
+    if (key.matches("tab")) { apply(true); return { consume: true }; }
+    if (key.matches("escape")) { clear(); app.requestRender(); return { consume: true }; }
+  });
+
+  return { refresh };
+}

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

@@ -2,7 +2,7 @@ import type {
   AutocompleteItem,
   AutocompleteProvider,
   AutocompleteSuggestions,
-} from "@earendil-works/pi-tui";
+} from "./renderer.js";
 import type { EventBus } from "agent-sh/event-bus";
 
 /** Adapt pi-tui's AutocompleteProvider to agent-sh's autocomplete:request pipe.
@@ -54,28 +54,6 @@ export class BusAutocompleteProvider implements AutocompleteProvider {
     }));
     return { items, prefix: before };
   }
-
-  applyCompletion(
-    lines: string[],
-    cursorLine: number,
-    cursorCol: number,
-    item: AutocompleteItem,
-    prefix: string,
-  ): { lines: string[]; cursorLine: number; cursorCol: number } {
-    const line = lines[cursorLine] ?? "";
-    // Replace the prefix span (the leading slash-word + args we sent) with
-    // the completion value. Anything after the cursor is preserved.
-    const head = line.slice(0, cursorCol - prefix.length);
-    const tail = line.slice(cursorCol);
-    const newLine = `${head}${item.value}${tail}`;
-    const out = lines.slice();
-    out[cursorLine] = newLine;
-    return {
-      lines: out,
-      cursorLine,
-      cursorCol: (head + item.value).length,
-    };
-  }
 }
 
 /** Locate an active `@` file-trigger in the text preceding the cursor.