pi-minimalist 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Pinglei He
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,24 @@
+# pi-minimalist
+
+Make Pi's tool calls and optional thinking previews quieter: compact, one-line rows without losing access to the original tool output.
+
+## What does minimalist mode look like
+
+Before pi-minimalist:
+
+<img width="656" height="550" alt="before" src="https://github.com/user-attachments/assets/aa1602f7-5db1-49b8-a4d3-cbd1aef69ea0" />
+
+
+After pi-minimalist:
+
+<img width="699" height="50" alt="after" src="https://github.com/user-attachments/assets/c0e8bca4-afa7-42c1-9bf0-69f267d18d9f" />
+
+## Installation
+Install with npm:
+```bash
+ pi install npm:pi-minimalist
+```
+
+## Configuration
+
+You may configure different collapse options / verbosity levels with the slash command `/minimalist config`.

package/index.ts

@@ -0,0 +1,132 @@
+/**
+ * pi-minimalist — WIRING ONLY. All behavior lives in src/.
+ *
+ *   1. compact one-line tool rows, with Pi's own expanded output on Ctrl+O;
+ *   2. compact collapsed thinking previews;
+ *   3. optional folding of adjacent rows into one summary line.
+ *
+ * NOTHING ON DISK IS PATCHED. Pi's bundled CLI hands extensions its own live
+ * module namespaces (jiti `virtualModules`), so the component classes imported
+ * here are the exact objects the running TUI instantiates, and `core-patch.ts`
+ * wraps their prototypes at load time. See that file for the full rationale.
+ *
+ * This extension registers NO tools. Re-registering built-ins would change their
+ * source ownership and make pi-subagents drop them from child tool allowlists.
+ */
+
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import * as core from "@earendil-works/pi-coding-agent";
+import { getSettingsListTheme } from "@earendil-works/pi-coding-agent";
+// SettingsList lives in pi-tui; its Pi-styled theme comes from pi-coding-agent.
+// Using both means `/minimalist` is the same component, with the same
+// keybindings and colours, as Pi's own `/settings`.
+import { SettingsList } from "@earendil-works/pi-tui";
+import { installBridges, sharedState } from "./src/bridge.ts";
+import { BASIC_KEYS, DEFAULT_BASIC, type BasicKey, type BasicSettings, type Config } from "./src/config.ts";
+import { loadSettings, migratedQuiet, saveBasicSettings } from "./src/config-file.ts";
+import { argumentCompletions, createConfigScreen, summary } from "./src/config-ui.ts";
+import { patchCore } from "./src/core-patch.ts";
+import { refreshMcpTools } from "./src/tools.ts";
+
+export default function (pi: ExtensionAPI) {
+  // Adopted from the previous load when reloading: existing transcript rows close
+  // over these and resolve appearance at render time, so replacing them would
+  // strand every row on stale state.
+  const { config, grouping } = sharedState(loadSettings());
+
+  // One-time migration of the preference written by the removed `/quiet`
+  // command. A session override, so the per-turn re-read below cannot revert it
+  // before the user has saved anything.
+  const migrated = migratedQuiet();
+  if (migrated !== undefined) config.setSessionOverride("groupToolRuns", migrated);
+
+  installBridges({ config, grouping });
+  // Runtime replacement for editing Pi's compiled bundle. Idempotent, so a
+  // /reload only refreshes the bridge slots the wrappers read.
+  patchCore(core);
+
+  const refresh = () => {
+    // MCP tool names depend on adapter configuration, so they are discovered from
+    // public source metadata rather than a maintained whitelist.
+    refreshMcpTools(pi.getAllTools());
+    // Re-read settings.json so an external edit (or pi-env) applies without a
+    // restart. Session overrides are re-applied by Config.replace().
+    config.replace(loadSettings());
+  };
+  pi.on("session_start", refresh);
+  pi.on("turn_start", refresh);
+  pi.on("agent_start", () => grouping.agentStarted());
+  pi.on("agent_settled", () => grouping.agentSettled());
+
+  pi.registerCommand("minimalist", {
+    description: "Open pi-minimalist settings; `status` shows current state",
+    getArgumentCompletions: argumentCompletions,
+    handler: async (args, ctx) => {
+      const command = args.trim().toLowerCase();
+      if (command && command !== "config" && command !== "status") {
+        ctx.ui.notify("Usage: /minimalist [config|status]", "warning");
+        return;
+      }
+      if (command === "status") {
+        ctx.ui.notify(`pi-minimalist\n${summary(config.all())}`, "info");
+        return;
+      }
+      if (!ctx.hasUI || ctx.mode !== "tui") {
+        ctx.ui.notify("/minimalist needs the interactive TUI; use /minimalist status for current settings", "warning");
+        return;
+      }
+
+      await ctx.ui.custom<void>((_tui, _theme, _keybindings, done) =>
+        createConfigScreen({
+          SettingsList,
+          theme: getSettingsListTheme(),
+          config,
+          onChange: (key, value) => persist(ctx, config, key, value),
+          onReset: () => persistDefaults(ctx, config),
+          onClose: () => done(),
+        }),
+      );
+    },
+  });
+}
+
+type NotifyContext = { ui: { notify(message: string, type?: "info" | "warning" | "error"): void } };
+
+/**
+ * Write only the changed key to the global agent settings, and be honest when that is impossible.
+ *
+ * The live value has already changed, so a silent failure would leave the UI and
+ * the file disagreeing. Keeping it as a session override means the per-turn
+ * re-read cannot revert what the message says was applied.
+ */
+function persistDefaults(ctx: NotifyContext, config: Config): void {
+  const result = saveBasicSettings(DEFAULT_BASIC);
+  for (const key of BASIC_KEYS) {
+    if (result.ok) config.clearSessionOverride(key);
+    else config.setSessionOverride(key, config.get(key));
+  }
+  if (!result.ok) {
+    ctx.ui.notify(`Defaults applied for this session only; settings.json could not be written (${result.reason}).`, "warning");
+  }
+}
+
+function persist(
+  ctx: NotifyContext,
+  config: Config,
+  key: BasicKey,
+  value: BasicSettings[BasicKey],
+): void {
+  const result = saveBasicSettings({ [key]: value });
+  if (result.ok) {
+    // The file now agrees, so it becomes the source of truth again.
+    config.clearSessionOverride(key);
+    return;
+  }
+  config.setSessionOverride(key, value);
+  ctx.ui.notify(
+    result.reason === "comments"
+      ? `Applied for this session only. settings.json has comments, which JSON.stringify would delete — set "minimalist": { "${key}": ${JSON.stringify(value)} } by hand to persist.`
+      : `Applied for this session only; settings.json could not be written (${result.reason}).`,
+    "warning",
+  );
+}

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "pi-minimalist",
+  "version": "0.1.0",
+  "description": "Compact one-line tool and thinking rows for Pi's interactive transcript",
+  "keywords": ["pi-package"],
+  "license": "MIT",
+  "author": "Pinglei He",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/EviHex/pi-minimalist.git"
+  },
+  "type": "module",
+  "files": ["index.ts", "src/", "README.md", "LICENSE"],
+  "peerDependencies": {
+    "@earendil-works/pi-coding-agent": "*",
+    "@earendil-works/pi-tui": "*"
+  },
+  "pi": {
+    "extensions": ["./index.ts"]
+  }
+}

package/src/bridge.ts

@@ -0,0 +1,124 @@
+/**
+ * The boundary between this extension and Pi's core components.
+ *
+ * Nothing on disk is patched. `core-patch.ts` wraps Pi's real component
+ * prototypes at load time and READS the process-global slots below at CALL time,
+ * so `/reload` swaps behavior without re-wrapping anything, and an unloaded
+ * extension degrades to Pi's native rendering.
+ *
+ * SINGLE SOURCE OF TRUTH for the symbol names, shared by the wrappers, the state
+ * that must survive `/reload`, and the tests.
+ */
+
+import { Config } from "./config.ts";
+import { RunGrouping } from "./run-grouping.ts";
+import { Painter, type ThemeLike } from "./row.ts";
+import { createToolRenderer } from "./tool-renderer.ts";
+import { createThinkingPreview, singleHueThinkingTheme } from "./thinking.ts";
+import type { Timers } from "./components.ts";
+
+export const BRIDGE_SYMBOLS = {
+  /** `{ renderShell, handles, renderCall, renderResult }` for every tool row. */
+  toolRenderer: "pi.defaultToolRenderer",
+  /** `(text, theme, pad, streaming, owner, runIndex) => Component`. */
+  thinkingPreview: "pi.thinkingPreview",
+  /** `(markdownTheme, theme) => markdownTheme` for expanded thinking. */
+  thinkingMarkdownTheme: "pi.thinkingMarkdownTheme",
+
+  /** Live settings, retained across a /reload. */
+  config: "pi.minimalist.config",
+  /** Run-grouping state, retained across a /reload. */
+  grouping: "pi.minimalist.grouping",
+
+  /** Chronology hooks that keep thinking and prose in transcript order. */
+  observeThinking: "pi.minimalist.observeThinking",
+  observeProse: "pi.minimalist.observeProse",
+  /** `undefined` = native prose, `null` = hidden, Row = folded summary. */
+  proseView: "pi.minimalist.proseView",
+  /** `(toolCallId) => boolean`: omit core's separator before an activity summary. */
+  activitySummaryRow: "pi.minimalist.activitySummaryRow",
+  /** `(owner) => normal|hidden|summary`: normalize assistant host spacing. */
+  activityMessageView: "pi.minimalist.activityMessageView",
+  /**
+   * Spacer suppression for a fully hidden assistant message.
+   *
+   * There is deliberately NO tool-row equivalent: a compact row uses
+   * `renderShell: "self"`, and core's self-shell branch emits its separator
+   * inline and returns ZERO lines when the row renders nothing — spacer
+   * included. An earlier `quietSpacer` bridge was compensating for a problem core
+   * already handles.
+   */
+  messageSpacer: "pi.minimalist.messageSpacer",
+  /** `() => boolean`: keep a STREAMING thinking block expanded. */
+  keepActiveThinkingExpanded: "pi.minimalist.keepActiveThinkingExpanded",
+} as const;
+
+type Globals = Record<symbol, unknown>;
+
+function slot(key: keyof typeof BRIDGE_SYMBOLS): symbol {
+  return Symbol.for(BRIDGE_SYMBOLS[key]);
+}
+
+/**
+ * State that must survive `/reload`.
+ *
+ * Existing transcript rows close over these objects and resolve their appearance
+ * at render time, so replacing an instance would strand every row on stale state.
+ */
+export type SharedState = { config: Config; grouping: RunGrouping };
+
+/** Adopt the previous load's state, or start fresh. */
+export function sharedState(settings?: ConstructorParameters<typeof Config>[0]): SharedState {
+  const globals = globalThis as Globals;
+  const existingConfig = globals[slot("config")];
+  const existingGrouping = globals[slot("grouping")];
+  if (existingConfig instanceof Config && existingGrouping instanceof RunGrouping) {
+    return { config: existingConfig, grouping: existingGrouping };
+  }
+  const config = new Config(settings);
+  return { config, grouping: new RunGrouping(config) };
+}
+
+export type InstallOptions = SharedState & {
+  /** Injectable repaint scheduler; production uses Node's timers. */
+  timers?: Timers;
+};
+
+/**
+ * Install every bridge.
+ *
+ * Each `/reload` overwrites these slots with fresh instances. Do NOT clear them
+ * from `session_shutdown`: reload ordering can let an old shutdown hook erase the
+ * newly installed bridges. Process exit clears globalThis naturally.
+ */
+export function installBridges({ config, grouping, timers }: InstallOptions): void {
+  const globals = globalThis as Globals;
+
+  globals[slot("config")] = config;
+  globals[slot("grouping")] = grouping;
+  globals[slot("toolRenderer")] = createToolRenderer({ config, grouping, timers });
+  globals[slot("thinkingPreview")] = createThinkingPreview({ config, grouping, timers });
+  globals[slot("thinkingMarkdownTheme")] = (base: Record<string, unknown>, theme: never) =>
+    singleHueThinkingTheme(base, theme, config);
+
+  // Chronology: core walks message content in transcript order, and run folding
+  // depends on that order.
+  globals[slot("observeThinking")] = (owner: object, runIndex: number, streaming: boolean, hidden: boolean) => {
+    grouping.observeThinking(owner, runIndex, !streaming, !hidden);
+    return grouping.thinkingId(owner, runIndex);
+  };
+  globals[slot("observeProse")] = (
+    owner: object,
+    contentIndex: number,
+    signal: Parameters<RunGrouping["observeProse"]>[2],
+  ) => grouping.observeProse(owner, contentIndex, signal);
+  globals[slot("proseView")] = (id: string, theme: ThemeLike) =>
+    grouping.proseView(id, new Painter(theme, config));
+  globals[slot("activitySummaryRow")] = (id: string) => grouping.isActivitySummary(id);
+  globals[slot("activityMessageView")] = (owner: object) => grouping.activityMessageView(owner);
+  globals[slot("messageSpacer")] = (owner: object) => grouping.showsMessageSpacer(owner);
+
+  // A function, not a value: the prototype wrapper reads it on every call, so a
+  // toggle takes effect without reinstalling anything.
+  globals[slot("keepActiveThinkingExpanded")] = () => config.get("keepActiveThinkingExpanded");
+}

package/src/components.ts

@@ -0,0 +1,173 @@
+/**
+ * TUI components. Purely presentational: they render painted rows (see row.ts)
+ * and know nothing about themes, tools, or run grouping.
+ *
+ * Kept free of Pi extension API imports so unit tests can exercise the real
+ * production components without loading an extension runtime.
+ */
+
+import { truncateToWidth } from "@earendil-works/pi-tui";
+import type { Component } from "@earendil-works/pi-tui";
+import { gutterWidth, type Row } from "./row.ts";
+
+/**
+ * Injectable timer pair. Production passes Node's globals; tests pass fakes so
+ * the elapsed timer can be advanced without sleeping and leaks are detectable.
+ */
+export type Timers = {
+  setInterval: (callback: () => void, ms: number) => unknown;
+  clearInterval: (handle: unknown) => void;
+};
+
+export const realTimers: Timers = {
+  setInterval: (callback, ms) => {
+    const handle = setInterval(callback, ms);
+    // A forgotten ticker must never hold the process open.
+    handle.unref?.();
+    return handle;
+  },
+  clearInterval: (handle) => clearInterval(handle as ReturnType<typeof setInterval>),
+};
+
+/**
+ * Resolve what to draw, at render time. `null` means draw NOTHING (zero lines),
+ * which is how run grouping hides a row. Resolved on every render, so a config
+ * toggle repaints existing transcript rows with no core rebuild.
+ *
+ * Receives the real terminal width, because detail truncation budgets depend on
+ * it and TUI only reveals the width during render(). Passing a fixed character
+ * count from the caller cannot adapt to the actual viewport.
+ */
+export type ResolveRow = (width: number) => Row | null;
+
+/**
+ * One physical terminal line with width-aware truncation and full-width color.
+ *
+ * Pi's Text component wraps long strings. That is correct for prose but made a
+ * long path spill onto a second line in a supposedly single-line renderer. TUI
+ * only supplies the real terminal width during render(), so truncating with a
+ * fixed character count in the caller cannot solve this reliably.
+ */
+export class CompactLine implements Component {
+  private resolve: ResolveRow = () => null;
+  private ticker: unknown;
+  private timers: Timers;
+
+  constructor(timers: Timers = realTimers) {
+    this.timers = timers;
+  }
+
+  /** Install the row resolver. Called on every updateDisplay with fresh state. */
+  setRow(resolve: ResolveRow): void {
+    this.resolve = resolve;
+  }
+
+  /**
+   * Repaint once per second while a tool runs, so the elapsed timer ticks even
+   * for silent commands that produce no streaming output (the only other
+   * repaint trigger). stopTicker() clears it at a final state.
+   */
+  startTicker(requestRender: () => void): void {
+    if (this.ticker !== undefined) return; // already ticking
+    this.ticker = this.timers.setInterval(requestRender, 1000);
+  }
+
+  stopTicker(): void {
+    if (this.ticker !== undefined) {
+      this.timers.clearInterval(this.ticker);
+      this.ticker = undefined;
+    }
+  }
+
+  /** Test/inspection helper: is a repaint interval currently registered? */
+  isTicking(): boolean {
+    return this.ticker !== undefined;
+  }
+
+  render(width: number): string[] {
+    const row = this.resolve(width);
+    if (row === null) return [];
+
+    // TUI pads each line to terminal width, so no manual trailing padding is
+    // needed. truncateToWidth understands ANSI codes and wide Unicode glyphs,
+    // so colored text truncates at VISIBLE columns. The gutter is a fixed-width
+    // prefix, so the content gets the remaining columns. Width comes from the
+    // row's OWN gutter text, so a disabled gutter reclaims those columns.
+    const line = truncateToWidth(row.text, Math.max(1, width - gutterWidth(row.gutter)), "…");
+    return [row.gutter + (row.highlight ? row.highlight(line) : line)];
+  }
+
+  // Component contract allows cached components to be invalidated. This class
+  // computes one cheap line every render, so no cache needs clearing.
+  invalidate(): void {}
+}
+
+/**
+ * Collapsed results must render ZERO lines, not one blank line.
+ *
+ * Pi's Text component returns [""] for empty strings (one blank row), which
+ * doubled the height of every collapsed tool call. This is the only safe way to
+ * say "no content at all" while still returning a Component, as the
+ * renderResult slot contract requires.
+ */
+export class FoldableProse implements Component {
+  private inner: Component;
+  private resolve: (width: number) => Row | null | undefined;
+
+  constructor(inner: Component, resolve: (width: number) => Row | null | undefined) {
+    this.inner = inner;
+    this.resolve = resolve;
+  }
+
+  render(width: number): string[] {
+    const row = this.resolve(width);
+    if (row === undefined) return this.inner.render(width);
+    const line = new CompactLine();
+    line.setRow(() => row);
+    return line.render(width);
+  }
+
+  invalidate(): void {
+    this.inner.invalidate?.();
+  }
+}
+
+export class EmptyComponent implements Component {
+  render(): string[] {
+    return [];
+  }
+
+  invalidate(): void {}
+}
+
+/**
+ * Wraps another component and prefixes EVERY line it renders with a gutter, so
+ * expanded output stays visually attached to the call row above it instead of
+ * blending into model prose.
+ *
+ * The inner component renders at a reduced width (the gutter occupies real
+ * columns), otherwise its own wrapping/truncation would overflow the row.
+ */
+export class GutteredComponent implements Component {
+  private inner: Component;
+  private gutterText: string;
+
+  constructor(inner: Component, gutterText: string) {
+    this.inner = inner;
+    this.gutterText = gutterText;
+  }
+
+  /** Swap in the newest inner component while keeping this wrapper stable. */
+  setInner(inner: Component): void {
+    this.inner = inner;
+  }
+
+  render(width: number): string[] {
+    const lines = this.inner.render(Math.max(1, width - gutterWidth(this.gutterText)));
+    return lines.map((line) => this.gutterText + line);
+  }
+
+  invalidate(): void {
+    this.inner.invalidate?.();
+  }
+}