pi-spark 0.1.1 → 0.2.0

package/README.md

@@ -6,10 +6,10 @@ A small, opinionated collection of [pi](https://pi.dev/) extensions.
 
 ## Extensions
 
-- **Editor**: replaces the default editor with a compact working indicator and current model info.
+- **Editor**: replaces the default editor with a compact working indicator (inspired by [Amp](https://ampcode.com/)) and current model info.
 - **Footer**: shows the session info, cost, and context usage in one line, followed by extension statuses.
 - **Fullscreen**: clears the screen and scrollback on session start and pins the editor and footer to the bottom for a full-screen session.
-- **Presets**: switches named model presets with `/preset` and quick cycle shortcuts.
+- **Presets**: switches named model presets with `/preset`, `--preset`, and quick cycle shortcuts.
 - **Recap**: generates a short idle-session recap and exposes a `/recap` command for manual generation, inspired by [Claude Code's session recap](https://code.claude.com/docs/en/interactive-mode#session-recap).
 
 ![Screenshot](./assets/screenshot.png)
@@ -64,8 +64,9 @@ Example:
 Notes:
 
 - Set an extension key to `false` to disable it.
-- The `editor.spinner` value can be `lights` or `dots`.
+- The `editor.spinner` value can be `dots`, `lights`, or `tildes`.
 - Presets can be selected with `/preset` or `/preset <key>`.
+- Start pi with a preset using `pi --preset <key>`.
 - Cycle presets with `ctrl+super+p` and `ctrl+shift+super+p` (`super` is `command` on macOS).
 - The `recap.idle` value is in milliseconds and must be at least `5000`.
 

package/extensions/editor/index.ts

@@ -14,6 +14,7 @@ class Editor extends CustomEditor {
   private ctx: ExtensionContext;
 
   private spinner: Spinner;
+  private workingMessage: string | undefined;
   private slots: { modelBefore: string | undefined };
 
   constructor(pi: ExtensionAPI, ctx: ExtensionContext, tui: TUI, theme: EditorTheme, keybindings: KeybindingsManager, spinner: Spinner = new Spinner()) {
@@ -24,10 +25,16 @@ class Editor extends CustomEditor {
 
     this.spinner = spinner;
     this.spinner.setTUI(tui);
+    this.workingMessage = undefined;
     this.slots = { modelBefore: undefined };
   }
 
-  setSlot(slot: keyof typeof this.slots, value: string | undefined): void {
+  setWorkingMessage(message?: string | undefined): void {
+    this.workingMessage = message;
+    this.tui.requestRender();
+  }
+
+  setSlot(slot: keyof typeof this.slots, value?: string | undefined): void {
     this.slots[slot] = value;
     this.tui.requestRender();
   }
@@ -58,7 +65,10 @@ class Editor extends CustomEditor {
   private getLeft(): string {
     const theme = this.ctx.ui.theme;
 
-    return theme.fg("accent", this.spinner.getFrame());
+    const spinner = this.spinner.getFrame();
+    const workingMessage = this.workingMessage;
+
+    return [theme.fg("accent", spinner), workingMessage ? theme.fg("dim", workingMessage) : undefined].filter(Boolean).join(" ");
   }
 
   private getRight(): string {
@@ -73,7 +83,10 @@ class Editor extends CustomEditor {
 
 export default function (pi: ExtensionAPI) {
   const events = autoCollectEvents(pi);
+
+  let editor: Editor | undefined = undefined;
   let spinner: Spinner | undefined = undefined;
+  let runningToolCallIds = new Set<string>();
 
   pi.on("session_start", (_event, ctx) => {
     if (!ctx.hasUI) return;
@@ -85,11 +98,11 @@ export default function (pi: ExtensionAPI) {
 
     ctx.ui.setWorkingVisible(false);
     ctx.ui.setEditorComponent((tui, theme, keybindings) => {
-      const editor = new Editor(pi, ctx, tui, theme, keybindings, spinner);
+      editor = new Editor(pi, ctx, tui, theme, keybindings, spinner);
 
       events.on(PRESET_CHANGE, (data) => {
         const payload = parsePresetChange(data);
-        editor.setSlot("modelBefore", payload ? `preset:${payload}` : undefined);
+        editor?.setSlot("modelBefore", payload ? `preset:${payload}` : undefined);
       });
 
       return editor;
@@ -97,14 +110,60 @@ export default function (pi: ExtensionAPI) {
   });
 
   pi.on("agent_start", () => {
+    runningToolCallIds.clear();
+    editor?.setWorkingMessage();
     spinner?.start();
   });
 
+  pi.on("message_update", (event) => {
+    if (runningToolCallIds.size > 0) return;
+
+    switch (event.assistantMessageEvent.type) {
+      case "thinking_start":
+      case "thinking_delta":
+      case "thinking_end":
+        editor?.setWorkingMessage("Thinking");
+        break;
+      case "text_start":
+      case "text_delta":
+      case "text_end":
+        editor?.setWorkingMessage("Streaming");
+        break;
+      case "toolcall_start":
+      case "toolcall_delta":
+      case "toolcall_end":
+        editor?.setWorkingMessage("Running tools");
+        break;
+      default:
+        editor?.setWorkingMessage();
+        break;
+    }
+  });
+
+  pi.on("tool_execution_start", (event) => {
+    runningToolCallIds.add(event.toolCallId);
+    editor?.setWorkingMessage("Running tools");
+  });
+
+  pi.on("tool_call", (event) => {
+    runningToolCallIds.add(event.toolCallId);
+    editor?.setWorkingMessage("Running tools");
+  });
+
+  pi.on("tool_execution_end", (event) => {
+    runningToolCallIds.delete(event.toolCallId);
+    editor?.setWorkingMessage(runningToolCallIds.size > 0 ? "Running tools" : undefined);
+  });
+
   pi.on("agent_end", () => {
+    runningToolCallIds.clear();
+    editor?.setWorkingMessage();
     spinner?.stop();
   });
 
   pi.on("session_shutdown", () => {
+    runningToolCallIds.clear();
+    editor = undefined;
     spinner?.dispose();
     spinner = undefined;
   });

package/extensions/editor/spinner.ts

@@ -2,7 +2,7 @@ import * as z from "zod";
 
 import type { TUI } from "@earendil-works/pi-tui";
 
-export const spinnerPresetSchema = z.enum(["lights", "dots"]);
+export const spinnerPresetSchema = z.enum(["dots", "lights", "tildes"]);
 
 type SpinnerPreset = z.infer<typeof spinnerPresetSchema>;
 
@@ -13,19 +13,24 @@ interface SpinnerParams {
 }
 
 const SPINNER_PRESETS: Record<SpinnerPreset, SpinnerParams> = {
+  dots: {
+    frames: ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"],
+    interval: 80,
+    random: false,
+  },
   lights: {
-    frames: ["○○○○", "●○○○", "○●○○", "○○●○", "○○○●", "●●○○", "●○●○", "●○○●", "○●●○", "○●○●", "○○●●", "●●●○", "●●○●", "●○●●", "○●●●", "●●●●"],
+    frames: ["○", "●"],
     interval: { min: 120, max: 240 },
     random: true,
   },
-  dots: {
-    frames: ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"],
-    interval: 80,
+  tildes: {
+    frames: ["∼", "≈", "≋", "≈", "∼"],
+    interval: 200,
     random: false,
   },
 };
 
-const DEFAULT_SPINNER_PRESET = "lights";
+const DEFAULT_SPINNER_PRESET = "tildes";
 
 export class Spinner {
   private tui: TUI | undefined;

package/extensions/footer/index.ts

@@ -1,5 +1,4 @@
 import { isAbsolute, relative, resolve, sep } from "node:path";
-import { truncateToWidth } from "@earendil-works/pi-tui";
 
 import { SplitLine } from "../shared/components/split-line";
 import { loadConfig } from "../shared/config";
@@ -25,16 +24,10 @@ class FooterComponent implements Component {
   }
 
   render(width: number): string[] {
-    return [this.renderMainLine(width), this.renderStatusLine(width)].filter(Boolean);
-  }
-
-  private renderMainLine(width: number): string {
     const left = this.getLeft();
     const right = this.getRight();
-    return new SplitLine(left, right, {
-      primarySide: "right",
-      ellipsis: this.theme.fg("dim", "…"),
-    }).render(width)[0];
+
+    return new SplitLine(left, right, { primarySide: "right", ellipsis: this.theme.fg("dim", "…") }).render(width);
   }
 
   private getLeft(): string {
@@ -50,10 +43,22 @@ class FooterComponent implements Component {
   }
 
   private getRight(): string {
+    const statusesText = this.getStatusesText();
     const styledCostText = this.getStyledCostText();
     const styledContextUsageText = this.getStyledContextUsageText();
 
-    return `${styledCostText}${this.theme.fg("dim", " • ")}${styledContextUsageText}`;
+    return [statusesText, styledCostText, styledContextUsageText].filter(Boolean).join(this.theme.fg("dim", " • "));
+  }
+
+  /** Get extension statuses, sorted by key alphabetically. */
+  private getStatusesText(): string {
+    const extensionStatuses = this.footerData.getExtensionStatuses();
+    if (extensionStatuses.size === 0) return "";
+
+    return Array.from(extensionStatuses.entries())
+      .sort(([a], [b]) => a.localeCompare(b))
+      .map(([, text]) => sanitizeText(text))
+      .join(this.theme.fg("dim", " • "));
   }
 
   private getStyledCostText(): string {
@@ -64,8 +69,8 @@ class FooterComponent implements Component {
     }, { subscription: 0, paid: 0 });
 
     const isSubscription = this.ctx.model ? this.ctx.modelRegistry.isUsingOAuth(this.ctx.model) : false;
-    const subscriptionCostText = isSubscription || cost.subscription > 0 ? formatCost(cost.subscription, true) : undefined;
-    const paidCostText = !isSubscription || cost.paid > 0 ? formatCost(cost.paid, false) : undefined;
+    const subscriptionCostText = isSubscription || cost.subscription >= 0.005 ? formatCost(cost.subscription, true) : undefined;
+    const paidCostText = !isSubscription || cost.paid >= 0.005 ? formatCost(cost.paid, false) : undefined;
     const costText = [subscriptionCostText, paidCostText].filter(Boolean).join(" + ");
 
     const totalCost = cost.subscription + cost.paid;
@@ -83,19 +88,6 @@ class FooterComponent implements Component {
     if (percent && percent > 70) return this.theme.fg("warning", contextUsageText);
     return this.theme.fg("dim", contextUsageText);
   }
-
-  /** Add extension statues on a single line, sorted by key alphabetically. */
-  private renderStatusLine(width: number): string {
-    const extensionStatuses = this.footerData.getExtensionStatuses();
-    if (extensionStatuses.size === 0) return "";
-
-    const statusLine = Array.from(extensionStatuses.entries())
-      .sort(([a], [b]) => a.localeCompare(b))
-      .map(([, text]) => sanitizeText(text))
-      .join(this.theme.fg("dim", " • "));
-
-    return truncateToWidth(statusLine, width, this.theme.fg("dim", "..."));
-  }
 }
 
 function formatCwd(cwd: string, home?: string): string {

package/extensions/presets/index.ts

@@ -9,9 +9,19 @@ import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 export default function (pi: ExtensionAPI) {
   let presetManager: PresetManager | undefined = undefined;
 
-  pi.on("session_start", (_event, ctx) => {
+  pi.registerFlag("preset", {
+    description: "Model preset to use",
+    type: "string",
+  });
+
+  pi.on("session_start", async (event, ctx) => {
+    const presetFlag = pi.getFlag("preset");
+
     const config = loadConfig(ctx, "presets");
-    if (!config || Object.keys(config).length === 0) return;
+    if (!config || Object.keys(config).length === 0) {
+      if (presetFlag) ctx.ui.notify("No presets defined in spark.json", "warning");
+      return;
+    }
 
     presetManager = new PresetManager(pi, config);
     presetManager.sync(ctx);
@@ -42,6 +52,10 @@ export default function (pi: ExtensionAPI) {
         }
       },
     });
+
+    if (presetFlag && typeof presetFlag === "string") {
+      await presetManager.apply(presetFlag, ctx);
+    }
   });
 
   pi.on("model_select", (_event, ctx) => {

package/extensions/presets/manager.ts

@@ -35,7 +35,7 @@ export class PresetManager {
   async apply(key: string, ctx: ExtensionContext): Promise<boolean> {
     const preset = this.presets[key];
     if (!preset) {
-      ctx.ui.notify(`Unknown preset ${key}`, "error");
+      ctx.ui.notify(`Unknown preset ${key} (${this.keys.length ? `available: ${this.keys.join(", ")}` : "none defined"})`, "error");
       return false;
     }
 

package/extensions/recap/manager.ts

@@ -1,7 +1,7 @@
 import { completeSimple } from "@earendil-works/pi-ai";
 import { convertToLlm, serializeConversation } from "@earendil-works/pi-coding-agent";
 
-import { resolveRecapModel } from "./model";
+import { resolveRecapModelSettings } from "./model";
 import { clearRecapWidget, setRecapLoadingWidget, setRecapTextWidget } from "./widget";
 import { sanitizeText } from "../shared/format";
 
@@ -10,14 +10,15 @@ import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-a
 import type { RecapConfig } from "./config";
 
 const SYSTEM_PROMPT = [
-  "You write concise recaps for an idle terminal coding agent session.",
-  "Summarize only what is supported by the transcript; do not invent progress, intent, files, or next steps.",
-  "Focus on the user's goal, completed work, current state, and likely next step.",
-  "Prefer recent context when the session changed direction.",
-  "Output one short paragraph of 1-2 sentences. No heading, markdown, bullets, or quotes.",
+  "You write concise idle-session recaps for a terminal coding agent.",
+  "Use only transcript-supported facts; do not invent progress, intent, files, or next steps.",
+  "Prefer the latest active task if the session changed direction.",
+  "Summarize the user's goal, what was done, current state, and any clearly supported next step.",
+  "Respond in the conversation's primary language.",
+  "Output 1-2 plain-text sentences under 80 words. No heading, markdown, bullets, or quotes.",
 ].join("\n");
 
-const MAX_TOKENS = 120;
+const MAX_TOKENS = 100;
 const MAX_CONVERSATION_CHARS = 8_000;
 
 export class RecapManager {
@@ -39,25 +40,27 @@ export class RecapManager {
     this.inflight = controller;
 
     try {
-      const recapModel = await resolveRecapModel(this.pi, ctx, this.config);
-      if (controller.signal.aborted || this.inflight !== controller || !recapModel) return;
+      const recapModelSettings = await resolveRecapModelSettings(this.pi, ctx, this.config);
+      if (controller.signal.aborted || this.inflight !== controller || !recapModelSettings) return;
 
-      setRecapLoadingWidget(ctx, recapModel.warning);
+      const { model, thinkingLevel, warning } = recapModelSettings;
+
+      setRecapLoadingWidget(ctx, warning);
       this.active = false;
 
-      const result = await this.generate(ctx, recapModel.model, recapModel.thinkingLevel, controller.signal);
+      const result = await this.generate(ctx, model, thinkingLevel, controller.signal);
       if (controller.signal.aborted || this.inflight !== controller) return;
       if (!result.content) {
         clearRecapWidget(ctx);
         return;
       }
 
-      setRecapTextWidget(ctx, result.content, recapModel.warning);
+      setRecapTextWidget(ctx, result.content, warning);
       this.active = true;
 
       this.pi.appendEntry("recap", {
-        provider: recapModel.model.provider,
-        model: recapModel.model.id,
+        provider: model.provider,
+        model: model.id,
         usage: result.usage,
         content: result.content,
       });
@@ -111,8 +114,8 @@ export class RecapManager {
     const conversation = text.length > MAX_CONVERSATION_CHARS ? text.slice(-MAX_CONVERSATION_CHARS) : text;
 
     return [
-      "Create a short recap of this coding agent session for the user to see while the agent is idle.",
-      "The transcript may be truncated from the beginning and may start mid-message; account for that uncertainty.",
+      "Create a short recap from this transcript, ordered oldest to newest.",
+      "It may be truncated from the beginning; focus on the latest coherent task.",
       "",
       "<conversation>",
       conversation,

package/extensions/recap/model.ts

@@ -1,61 +1,95 @@
 import { clampThinkingLevel } from "@earendil-works/pi-ai";
 
+import { formatModel } from "../shared/format";
+
 import type { Api, Model, ModelThinkingLevel } from "@earendil-works/pi-ai";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import type { OptionalModelConfig } from "../shared/config/model";
 
 const DEFAULT_THINKING_LEVEL: ModelThinkingLevel = "off";
 
-type RecapModel = {
+type RecapModelSettings = {
   model: Model<Api>;
   thinkingLevel: ModelThinkingLevel;
   warning: string | undefined;
 };
 
-export async function resolveRecapModel(pi: ExtensionAPI, ctx: ExtensionContext, config: OptionalModelConfig): Promise<RecapModel | undefined> {
+type ModelSelection = {
+  model: Model<Api>;
+  warning: string | undefined;
+};
+
+type ThinkingLevelSelection = {
+  thinkingLevel: ModelThinkingLevel;
+  warning: string | undefined;
+};
+
+export async function resolveRecapModelSettings(pi: ExtensionAPI, ctx: ExtensionContext, config: OptionalModelConfig): Promise<RecapModelSettings | undefined> {
   const fallbackModel = ctx.model;
   if (!fallbackModel) {
     ctx.ui.notify("No model selected for recap", "warning");
     return;
   }
 
-  let model = fallbackModel;
-  let warning: string | undefined;
-
-  if (config.provider || config.model) {
-    if (!config.provider || !config.model) {
-      warning = "Both recap.provider and recap.model are required; using the current model.";
-    } else {
-      const configuredModel = ctx.modelRegistry.find(config.provider, config.model);
-      if (configuredModel) {
-        const auth = await ctx.modelRegistry.getApiKeyAndHeaders(configuredModel);
-        if (auth.ok) {
-          model = configuredModel;
-        } else {
-          warning = `Model ${config.provider}/${config.model} unavailable: ${auth.error}; using the current model.`;
-        }
-      } else {
-        warning = `Model ${config.provider}/${config.model} not found; using the current model.`;
-      }
-    }
-  }
-
+  const { model, warning: modelWarning } = await resolveModelSelection(ctx, config, fallbackModel);
   const { thinkingLevel, warning: thinkingLevelWarning } = resolveThinkingLevel(model, config.thinkingLevel ?? pi.getThinkingLevel());
 
   return {
     model,
     thinkingLevel,
-    warning: [warning, thinkingLevelWarning].filter(Boolean).join(" ") || undefined,
+    warning: [modelWarning, thinkingLevelWarning].filter(Boolean).join(" ") || undefined,
   };
 }
 
-function resolveThinkingLevel(model: Model<Api>, requested: ModelThinkingLevel): { thinkingLevel: ModelThinkingLevel; warning?: string } {
+async function resolveModelSelection(ctx: ExtensionContext, config: OptionalModelConfig, fallbackModel: Model<Api>): Promise<ModelSelection> {
+  if (!config.provider && !config.model) {
+    return {
+      model: fallbackModel,
+      warning: undefined,
+    };
+  }
+
+  if (!config.provider || !config.model) {
+    return {
+      model: fallbackModel,
+      warning: "Both recap.provider and recap.model are required; using the current model.",
+    };
+  }
+
+  const model = ctx.modelRegistry.find(config.provider, config.model);
+  if (!model) {
+    return {
+      model: fallbackModel,
+      warning: `Model ${formatModel(config.provider, config.model)} not found; using the current model.`,
+    };
+  }
+
+  const auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
+  if (!auth.ok) {
+    return {
+      model: fallbackModel,
+      warning: `Model ${formatModel(config.provider, config.model)} unavailable: ${auth.error}; using the current model.`,
+    };
+  }
+
+  return {
+    model,
+    warning: undefined,
+  };
+}
+
+function resolveThinkingLevel(model: Model<Api>, requested: ModelThinkingLevel): ThinkingLevelSelection {
   const thinkingLevel = clampThinkingLevel(model, requested);
-  if (thinkingLevel === requested) return { thinkingLevel };
+  if (thinkingLevel === requested) {
+    return {
+      thinkingLevel,
+      warning: undefined,
+    };
+  }
 
   const fallback = clampThinkingLevel(model, DEFAULT_THINKING_LEVEL);
   return {
     thinkingLevel: fallback,
-    warning: `Thinking level ${requested} is not supported by ${model.provider}/${model.id}; using ${fallback}.`,
+    warning: `Thinking level ${requested} is not supported by ${formatModel(model.provider, model.id)}; using ${fallback}.`,
   };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-spark",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "A small, opinionated collection of pi extensions",
   "keywords": [
     "pi-coding-agent",
@@ -19,7 +19,9 @@
     "LICENSE"
   ],
   "pi": {
-    "extensions": ["./extensions"],
+    "extensions": [
+      "./extensions"
+    ],
     "image": "https://raw.githubusercontent.com/zlliang/pi-spark/main/assets/cover.png"
   },
   "scripts": {