agent-sh 0.12.26 → 0.13.0

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

@@ -0,0 +1,136 @@
+import type { Component } from "@earendil-works/pi-tui";
+import type { ExtensionContext } from "agent-sh/types";
+import {
+  AssistantMessage,
+  ThinkingBlock,
+  ToolResultBody,
+  UserMessage,
+} from "./components.js";
+import { entryFor, loadToolDisplayConfig, type ToolResultMode } from "./display-config.js";
+
+export interface RenderState {
+  state: Record<string, unknown>;
+  invalidate: () => void;
+}
+
+export interface UserMessageArgs extends RenderState { text: string }
+
+export interface AssistantArgs extends RenderState { text: string }
+
+export interface ThinkingArgs extends RenderState { text: string; hidden: boolean }
+
+export interface ToolCallArgs extends RenderState {
+  toolCallId: string;
+  name: string;
+  title: string;
+  kind?: string;
+  displayDetail?: string;
+  rawInput?: unknown;
+}
+
+export interface ToolResultArgs extends RenderState {
+  toolCallId: string;
+  name: string;
+  kind?: string;
+  rawInput?: unknown;
+  /** Resolved from ashi.display.{name} (or .default) in settings.json. */
+  mode: ToolResultMode;
+  previewLines: number;
+}
+
+/** Mutated by ashi when the tool completes. Renderers may ignore setStatus
+ *  if they encode status differently (e.g. a sigil in the call line). */
+export interface ToolCallView extends Component {
+  setStatus(opts: { exitCode: number | null; elapsedMs: number; summary?: string }): void;
+}
+
+/** Mutated by ashi as output streams in and when the tool completes.
+ *  setDiff is optional behavior — renderers may no-op if they don't show diffs.
+ *  toggleExpanded flips the view's internal expansion state (Ctrl+O). */
+export interface ToolResultView extends Component {
+  appendChunk(chunk: string): void;
+  setDiff(lines: string[]): void;
+  finalize(opts: { exitCode: number | null; summary?: string }): void;
+  toggleExpanded(): void;
+}
+
+const CALL_PREFIX = "ashi:render-tool-call:";
+const RESULT_PREFIX = "ashi:render-tool-result:";
+
+/** Register the default render-* handlers. Per-tool overrides are advised by
+ *  name (e.g. `ashi:render-tool-call:bash`); unknown tools fall back to
+ *  `:default`. */
+export function registerRenderDefaults(ctx: ExtensionContext): void {
+  ctx.define("ashi:render-user-message", (args: UserMessageArgs): Component => {
+    return new UserMessage(args.text);
+  });
+
+  ctx.define("ashi:render-assistant", (args: AssistantArgs): Component => {
+    const msg = new AssistantMessage();
+    if (args.text) {
+      msg.appendText(args.text);
+      msg.finalize();
+    }
+    return msg;
+  });
+
+  ctx.define("ashi:render-thinking", (args: ThinkingArgs): Component => {
+    const tb = new ThinkingBlock();
+    if (args.text) {
+      tb.appendText(args.text);
+      tb.finalize();
+    }
+    tb.setHidden(args.hidden);
+    return tb;
+  });
+
+  ctx.define(`${RESULT_PREFIX}default`, (args: ToolResultArgs): ToolResultView => {
+    return new ToolResultBody(args.mode, args.previewLines);
+  });
+}
+
+export interface ToolHookResolver {
+  call: (args: Omit<ToolCallArgs, "state" | "invalidate"> & Partial<RenderState>) => ToolCallView;
+  result: (args: Omit<ToolResultArgs, "mode" | "previewLines" | "state" | "invalidate"> & Partial<RenderState>) => ToolResultView;
+  modeFor: (name: string) => { mode: ToolResultMode; previewLines: number };
+}
+
+/** Resolves :{name} → :default for tool render hooks and looks up each tool's
+ *  display mode from ashi.display. Cache the registered-handler set; callers
+ *  can `refresh()` after extensions register new tool-specific renderers. */
+export function createToolHookResolver(
+  ctx: ExtensionContext,
+  renderState: () => RenderState,
+): ToolHookResolver & { refresh: () => void } {
+  const config = loadToolDisplayConfig();
+  let registered = new Set(ctx.list());
+
+  const pick = (prefix: string, name: string): string => {
+    const specific = `${prefix}${name}`;
+    return registered.has(specific) ? specific : `${prefix}default`;
+  };
+
+  return {
+    refresh(): void {
+      registered = new Set(ctx.list());
+    },
+    modeFor(name: string) {
+      const e = entryFor(config, name);
+      return { mode: e.result, previewLines: e.previewLines };
+    },
+    call(args) {
+      const handler = pick(CALL_PREFIX, args.name);
+      return ctx.call(handler, { ...renderState(), ...args }) as ToolCallView;
+    },
+    result(args) {
+      const { mode, previewLines } = this.modeFor(args.name);
+      const handler = pick(RESULT_PREFIX, args.name);
+      return ctx.call(handler, {
+        ...renderState(),
+        ...args,
+        mode,
+        previewLines,
+      }) as ToolResultView;
+    },
+  };
+}

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

@@ -0,0 +1,146 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as crypto from "node:crypto";
+import { SessionStore, type AgentMessage } from "./session-store.js";
+
+export interface SessionInfo {
+  id: string;
+  filePath: string;
+  createdAt: number;
+  name?: string;
+  preview: string;
+  entryCount: number;
+}
+
+/** Many sessions per cwd. Each is one .jsonl file under `dir/`. Constructor
+ *  always opens a fresh session; /resume callers can `openSession(id)` to
+ *  swap the current store to a past session file. */
+export class MultiSessionStore {
+  private dir: string;
+  private cwd: string;
+  private currentStore: SessionStore;
+
+  constructor(dir: string, cwd: string) {
+    this.dir = dir;
+    this.cwd = cwd;
+    fs.mkdirSync(dir, { recursive: true });
+    this.migrateLegacy();
+    this.currentStore = this.createFreshSession();
+  }
+
+  /** One-time import from the previous storage format (sessions stored as
+   *  directories with tree.jsonl + snapshots/). Each old session is replayed
+   *  from its most recent snapshot into a new flat `.jsonl` file, then the
+   *  source directory is renamed `.migrated-<id>/` so the import is idempotent. */
+  private migrateLegacy(): void {
+    let names: string[];
+    try { names = fs.readdirSync(this.dir); } catch { return; }
+    for (const name of names) {
+      if (name.startsWith(".migrated-")) continue;
+      const full = path.join(this.dir, name);
+      let stat: fs.Stats;
+      try { stat = fs.statSync(full); } catch { continue; }
+      if (!stat.isDirectory()) continue;
+      const snapshotsDir = path.join(full, "snapshots");
+      const leafFile = path.join(full, "active-leaf");
+      let leaf: string;
+      try { leaf = fs.readFileSync(leafFile, "utf-8").trim(); } catch { continue; }
+      let messages: AgentMessage[];
+      try {
+        const raw = fs.readFileSync(path.join(snapshotsDir, `${leaf}.json`), "utf-8");
+        const parsed = JSON.parse(raw);
+        if (!Array.isArray(parsed)) continue;
+        messages = parsed as AgentMessage[];
+      } catch { continue; }
+      let createdAt = 0;
+      let displayName: string | undefined;
+      try {
+        const m = JSON.parse(fs.readFileSync(path.join(full, "meta.json"), "utf-8"));
+        if (typeof m?.createdAt === "number") createdAt = m.createdAt;
+        if (typeof m?.name === "string") displayName = m.name;
+      } catch { /* no meta */ }
+      const newFile = path.join(this.dir, `${name}.jsonl`);
+      try {
+        writeImportedSession(newFile, name, this.cwd, messages, createdAt, displayName);
+        fs.renameSync(full, path.join(this.dir, `.migrated-${name}`));
+      } catch { /* leave the original directory alone if anything failed */ }
+    }
+  }
+
+  current(): SessionStore { return this.currentStore; }
+
+  newSession(): SessionStore {
+    this.currentStore = this.createFreshSession();
+    return this.currentStore;
+  }
+
+  openSession(id: string): SessionStore {
+    const filePath = this.sessionFile(id);
+    if (!fs.existsSync(filePath)) throw new Error(`session not found: ${id}`);
+    this.currentStore = new SessionStore(filePath);
+    return this.currentStore;
+  }
+
+  listSessions(): SessionInfo[] {
+    let names: string[];
+    try { names = fs.readdirSync(this.dir); } catch { return []; }
+    const result: SessionInfo[] = [];
+    for (const name of names) {
+      if (!name.endsWith(".jsonl")) continue;
+      const id = name.slice(0, -".jsonl".length);
+      const filePath = path.join(this.dir, name);
+      try {
+        const store = new SessionStore(filePath);
+        const meta = store.getMeta();
+        result.push({
+          id,
+          filePath,
+          createdAt: meta.createdAt,
+          name: meta.name,
+          preview: store.getPreview(),
+          entryCount: store.getAllEntries().length,
+        });
+      } catch { /* skip unreadable */ }
+    }
+    result.sort((a, b) => b.createdAt - a.createdAt);
+    return result;
+  }
+
+  private createFreshSession(): SessionStore {
+    const id = newSessionFileId();
+    const filePath = this.sessionFile(id);
+    return new SessionStore(filePath, { create: { cwd: this.cwd, sessionId: id } });
+  }
+
+  private sessionFile(id: string): string {
+    return path.join(this.dir, `${id}.jsonl`);
+  }
+}
+
+function newSessionFileId(): string {
+  const ts = new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19);
+  const suffix = crypto.randomBytes(3).toString("hex");
+  return `${ts}_${suffix}`;
+}
+
+function writeImportedSession(
+  newFile: string,
+  id: string,
+  cwd: string,
+  messages: AgentMessage[],
+  createdAt: number,
+  name?: string,
+): void {
+  const ts = createdAt || Date.now();
+  const header = { type: "session", id, parentId: null, timestamp: ts, cwd, version: 1 };
+  const lines: string[] = [JSON.stringify(header)];
+  let parent: string = id;
+  for (const m of messages) {
+    const entryId = crypto.randomBytes(4).toString("hex");
+    lines.push(JSON.stringify({ type: "message", id: entryId, parentId: parent, timestamp: ts, message: m }));
+    parent = entryId;
+  }
+  fs.writeFileSync(newFile, lines.join("\n") + "\n");
+  fs.writeFileSync(newFile + ".leaf", parent);
+  fs.writeFileSync(newFile + ".meta", JSON.stringify({ createdAt: ts, ...(name ? { name } : {}) }));
+}

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

@@ -0,0 +1,76 @@
+import type { ExtensionContext } from "agent-sh/types";
+import type { MultiSessionStore, SessionInfo } from "./multi-session-store.js";
+import type { Capture } from "./capture.js";
+import { applyBranchMessages } from "./commands.js";
+
+export interface SessionCommandsDeps {
+  openSessionPicker: () => Promise<void>;
+  rebuildChat: () => Promise<void>;
+}
+
+export function registerSessionCommands(
+  ctx: ExtensionContext,
+  getStore: () => MultiSessionStore,
+  capture: Capture,
+  deps: SessionCommandsDeps,
+): void {
+  const { bus } = ctx;
+
+  ctx.registerCommand("resume", "Browse and resume a past session in this cwd", async () => {
+    await deps.openSessionPicker();
+  });
+
+  ctx.registerCommand("new", "Start a fresh session (discards in-memory context)", async () => {
+    const s = getStore().newSession();
+    ctx.call("conversation:reset-for-session", 1);
+    ctx.call("conversation:replace-messages", []);
+    capture.resetTo([]);
+    await deps.rebuildChat();
+    bus.emit("ui:info", { message: `new session: ${s.id}` });
+  });
+
+  ctx.registerCommand("name", "Set the current session display name: /name <text>", async (args) => {
+    const name = args.trim();
+    if (!name) {
+      bus.emit("ui:error", { message: "name: expected a name" });
+      return;
+    }
+    getStore().current().setName(name);
+    bus.emit("ui:info", { message: `session named: ${name}` });
+  });
+
+  ctx.registerCommand("sessions", "List past sessions in this cwd (text dump)", async () => {
+    const list = getStore().listSessions();
+    if (list.length === 0) {
+      bus.emit("ui:info", { message: "sessions: none" });
+      return;
+    }
+    const currentId = getStore().current().id;
+    const lines = list.map((s) => formatSessionRow(s, s.id === currentId));
+    bus.emit("ui:info", { message: `sessions (${list.length}):\n${lines.join("\n")}` });
+  });
+}
+
+function formatLocal(ts: number): string {
+  const d = new Date(ts);
+  const pad = (n: number): string => n.toString().padStart(2, "0");
+  return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ${pad(d.getHours())}:${pad(d.getMinutes())}`;
+}
+
+export function formatSessionRow(s: SessionInfo, isCurrent: boolean): string {
+  const marker = isCurrent ? "●" : " ";
+  const when = s.createdAt ? formatLocal(s.createdAt) : "?";
+  const label = s.name ?? s.preview;
+  return `${marker} ${when}  ${label}  (${s.entryCount})`;
+}
+
+export function resumeSession(
+  ctx: ExtensionContext,
+  getStore: () => MultiSessionStore,
+  capture: Capture,
+  id: string,
+): void {
+  getStore().openSession(id);
+  ctx.call("conversation:reset-for-session", 1);
+  applyBranchMessages(ctx, getStore, capture);
+}

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

@@ -0,0 +1,264 @@
+import * as fs from "node:fs";
+import * as fsp from "node:fs/promises";
+import * as path from "node:path";
+import * as crypto from "node:crypto";
+
+export interface ToolCall {
+  id?: string;
+  function?: { name: string; arguments?: string };
+}
+
+export interface AgentMessage {
+  role: "system" | "user" | "assistant" | "tool";
+  content?: unknown;
+  tool_calls?: ToolCall[];
+  tool_call_id?: string;
+  name?: string;
+}
+
+export interface SessionHeaderEntry {
+  type: "session";
+  id: string;
+  parentId: null;
+  timestamp: number;
+  cwd: string;
+  version: 1;
+}
+
+export interface MessageEntry {
+  type: "message";
+  id: string;
+  parentId: string;
+  timestamp: number;
+  message: AgentMessage;
+}
+
+export interface CompactionEntry {
+  type: "compaction";
+  id: string;
+  parentId: string;
+  timestamp: number;
+  summary: string;
+  firstKeptId: string;
+  tokensBefore: number;
+}
+
+export type SessionEntry = SessionHeaderEntry | MessageEntry | CompactionEntry;
+
+export interface SessionMeta {
+  name?: string;
+  createdAt: number;
+}
+
+export function newEntryId(): string {
+  return crypto.randomBytes(4).toString("hex");
+}
+
+/** One session = one JSONL file (entries) + sidecar files for leaf & meta.
+ *  Tree is implicit via parentId pointers; entries kept in memory after load. */
+export class SessionStore {
+  private entriesPath: string;
+  private leafPath: string;
+  private metaPath: string;
+  private entries = new Map<string, SessionEntry>();
+  private rootId = "";
+  private activeLeaf = "";
+  private meta: SessionMeta;
+  private pendingHeader: SessionHeaderEntry | null = null;
+  readonly id: string;
+
+  constructor(filePath: string, opts?: { create?: { cwd: string; sessionId: string } }) {
+    this.entriesPath = filePath;
+    this.leafPath = filePath + ".leaf";
+    this.metaPath = filePath + ".meta";
+    this.meta = { createdAt: 0 };
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+
+    if (opts?.create) {
+      this.id = opts.create.sessionId;
+      const header: SessionHeaderEntry = {
+        type: "session",
+        id: opts.create.sessionId,
+        parentId: null,
+        timestamp: Date.now(),
+        cwd: opts.create.cwd,
+        version: 1,
+      };
+      this.entries.set(header.id, header);
+      this.rootId = header.id;
+      this.activeLeaf = header.id;
+      this.meta = { createdAt: header.timestamp };
+      this.pendingHeader = header;
+    } else {
+      this.id = "";
+      this.load();
+      if (!this.rootId) throw new Error(`session file lacks a session header: ${filePath}`);
+      this.id = this.rootId;
+    }
+  }
+
+  private flushHeader(): void {
+    if (!this.pendingHeader) return;
+    const headerLine = JSON.stringify(this.pendingHeader) + "\n";
+    this.pendingHeader = null;
+    fs.writeFileSync(this.entriesPath, headerLine);
+    this.persistMeta();
+    this.persistLeaf();
+  }
+
+  getActiveLeaf(): string { return this.activeLeaf; }
+  setActiveLeaf(id: string): void {
+    if (!this.entries.has(id)) throw new Error(`unknown entry: ${id}`);
+    this.activeLeaf = id;
+    this.persistLeaf();
+  }
+  getRootId(): string { return this.rootId; }
+  getEntry(id: string): SessionEntry | undefined { return this.entries.get(id); }
+  getAllEntries(): SessionEntry[] {
+    return [...this.entries.values()];
+  }
+  getMeta(): SessionMeta { return { ...this.meta }; }
+  setName(name: string): void {
+    this.meta.name = name;
+    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();
+    let parent = this.activeLeaf;
+    const lines: string[] = [];
+    const newIds: string[] = [];
+    for (const m of messages) {
+      const e: MessageEntry = {
+        type: "message",
+        id: newEntryId(),
+        parentId: parent,
+        timestamp: Date.now(),
+        message: m,
+      };
+      this.entries.set(e.id, e);
+      lines.push(JSON.stringify(e));
+      newIds.push(e.id);
+      parent = e.id;
+    }
+    this.activeLeaf = parent;
+    await fsp.appendFile(this.entriesPath, lines.join("\n") + "\n");
+    this.persistLeaf();
+    return newIds;
+  }
+
+  async appendCompaction(summary: string, firstKeptId: string, tokensBefore: number): Promise<string> {
+    if (!this.entries.has(firstKeptId)) throw new Error(`firstKeptId unknown: ${firstKeptId}`);
+    this.flushHeader();
+    const e: CompactionEntry = {
+      type: "compaction",
+      id: newEntryId(),
+      parentId: this.activeLeaf,
+      timestamp: Date.now(),
+      summary,
+      firstKeptId,
+      tokensBefore,
+    };
+    this.entries.set(e.id, e);
+    this.activeLeaf = e.id;
+    await fsp.appendFile(this.entriesPath, JSON.stringify(e) + "\n");
+    this.persistLeaf();
+    return e.id;
+  }
+
+  /** Walk parent pointers from a leaf back to the root. Returns oldest-first. */
+  getBranch(leafId: string = this.activeLeaf): SessionEntry[] {
+    const out: SessionEntry[] = [];
+    const seen = new Set<string>();
+    let cur: string | null = leafId;
+    while (cur && !seen.has(cur)) {
+      seen.add(cur);
+      const e = this.entries.get(cur);
+      if (!e) break;
+      out.push(e);
+      cur = e.parentId;
+    }
+    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. */
+  buildMessages(leafId: string = this.activeLeaf): AgentMessage[] {
+    const branch = this.getBranch(leafId);
+    let compactionIdx = -1;
+    for (let i = branch.length - 1; i >= 0; i--) {
+      if (branch[i]!.type === "compaction") { compactionIdx = i; break; }
+    }
+    if (compactionIdx < 0) {
+      return branch
+        .filter((e): e is MessageEntry => e.type === "message")
+        .map((e) => e.message);
+    }
+    const c = branch[compactionIdx] as CompactionEntry;
+    const firstKeptIdx = branch.findIndex((e) => e.id === c.firstKeptId);
+    const keepFrom = firstKeptIdx >= 0 ? firstKeptIdx : 0;
+    const out: AgentMessage[] = [{
+      role: "user",
+      content: `[Compacted conversation summary]\n${c.summary}`,
+    }];
+    for (let i = keepFrom; i < branch.length; i++) {
+      const e = branch[i]!;
+      if (e.type === "message") out.push(e.message);
+    }
+    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 : "";
+        if (txt) return txt.slice(0, 80);
+      }
+    }
+    return "(empty)";
+  }
+
+  private load(): void {
+    try {
+      this.meta = JSON.parse(fs.readFileSync(this.metaPath, "utf-8")) as SessionMeta;
+    } catch { this.meta = { createdAt: 0 }; }
+    let raw: string;
+    try { raw = fs.readFileSync(this.entriesPath, "utf-8"); }
+    catch { return; }
+    for (const line of raw.split("\n")) {
+      if (!line) continue;
+      try {
+        const e = JSON.parse(line) as SessionEntry;
+        if (!e.id) continue;
+        this.entries.set(e.id, e);
+        if (e.type === "session") this.rootId = e.id;
+      } catch { /* skip malformed */ }
+    }
+    try {
+      this.activeLeaf = fs.readFileSync(this.leafPath, "utf-8").trim();
+      if (!this.entries.has(this.activeLeaf)) this.activeLeaf = this.rootId;
+    } catch { this.activeLeaf = this.lastEntryId(); }
+  }
+
+  private lastEntryId(): string {
+    let lastId = this.rootId;
+    for (const e of this.entries.values()) lastId = e.id;
+    return lastId;
+  }
+
+  private persistLeaf(): void {
+    if (this.pendingHeader) return;
+    fs.writeFileSync(this.leafPath, this.activeLeaf);
+  }
+  private persistMeta(): void {
+    if (this.pendingHeader) return;
+    fs.writeFileSync(this.metaPath, JSON.stringify(this.meta));
+  }
+}

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

@@ -0,0 +1,66 @@
+import { Container, Text } from "@earendil-works/pi-tui";
+import { theme } from "./theme.js";
+
+interface StatusFields {
+  model?: string;
+  provider?: string;
+  contextWindow?: number;
+  cwd?: string;
+  branch?: string;
+  leaf?: number;
+  tokens?: number;
+  compactions?: number;
+  thinking?: string;
+}
+
+export class StatusFooter extends Container {
+  private text: Text;
+  private fields: StatusFields = {};
+
+  constructor() {
+    super();
+    this.text = new Text("", 1, 0);
+    this.addChild(this.text);
+  }
+
+  update(patch: Partial<StatusFields>): void {
+    this.fields = { ...this.fields, ...patch };
+    this.repaint();
+  }
+
+  private repaint(): void {
+    const { model, provider, contextWindow, cwd, branch, leaf, tokens, compactions, thinking } = this.fields;
+    const sep = theme.fg("dim", " | ");
+    const parts: string[] = [];
+    if (model) {
+      const tail = provider ? theme.fg("muted", `@${provider}`) : "";
+      const think = thinking ? theme.fg("muted", ` [${thinking}]`) : "";
+      parts.push(`${theme.fg("accent", model)}${tail ? " " + tail : ""}${think}`);
+    } else if (provider) {
+      parts.push(theme.fg("muted", `@${provider}`));
+    }
+    if (cwd) parts.push(theme.fg("muted", shortenCwd(cwd)));
+    if (branch) parts.push(theme.fg("muted", `⎇ ${branch}`));
+    if (leaf != null && leaf > 0) parts.push(theme.fg("muted", `#${leaf}`));
+    if (tokens != null) {
+      const tokStr = contextWindow ? `${fmtTokens(tokens)}/${fmtTokens(contextWindow)}` : fmtTokens(tokens);
+      const pct = contextWindow ? ` ${theme.fg("dim", `${Math.round((tokens / contextWindow) * 100)}%`)}` : "";
+      parts.push(`${theme.fg("muted", tokStr)}${pct}`);
+    }
+    if (compactions && compactions > 0) parts.push(theme.fg("muted", `⊟ ${compactions}`));
+    this.text.setText(parts.length === 0 ? "" : parts.join(sep));
+  }
+}
+
+function shortenCwd(cwd: string): string {
+  const home = process.env.HOME;
+  if (home && cwd.startsWith(`${home}/`)) return `~/${cwd.slice(home.length + 1)}`;
+  if (home && cwd === home) return "~";
+  return cwd;
+}
+
+function fmtTokens(n: number): string {
+  if (n < 1000) return String(n);
+  if (n < 100_000) return `${(n / 1000).toFixed(1)}k`;
+  return `${Math.round(n / 1000)}k`;
+}