@tt-a1i/openpi 0.3.1 → 0.5.0

package/extensions/capabilities/src/ui.ts

@@ -0,0 +1,93 @@
+import type { KeybindingsManager } from "@earendil-works/pi-coding-agent";
+import type { EditorComponent } from "@earendil-works/pi-tui";
+import {
+  BelowEditorNavigationEditor,
+  BelowEditorStripState,
+} from "../../shared/below-editor-navigation.ts";
+import { capabilitiesRequestedByPrompt } from "../../shared/capability-intent.ts";
+
+const DELEGATE_NAMES = /\bsubagents?\b|子代理/giu;
+const WORKFLOW_NAMES = /\bworkflows?\b|工作流/giu;
+const FOREGROUND_RESET = "\u001b[39m";
+
+interface CapabilityKeywordColorOptions {
+  readonly colorMode: "truecolor" | "256color";
+  readonly light: boolean;
+}
+
+export function isLightNamedTheme(name: string | undefined) {
+  return name !== undefined && /(?:^|[-_])light(?:$|[-_])/iu.test(name);
+}
+
+/**
+ * Claude-style lavender keyword color. The light variant preserves readable
+ * contrast instead of mechanically reusing the bright dark-terminal swatch.
+ */
+export function colorCapabilityKeyword(
+  text: string,
+  options: CapabilityKeywordColorOptions,
+) {
+  const start = options.light
+    ? options.colorMode === "truecolor"
+      ? "\u001b[38;2;130;80;223m"
+      : "\u001b[38;5;98m"
+    : options.colorMode === "truecolor"
+      ? "\u001b[38;2;210;168;255m"
+      : "\u001b[38;5;183m";
+  return `${start}${text}${FOREGROUND_RESET}`;
+}
+
+export function highlightCapabilityNames(
+  line: string,
+  capabilities: readonly string[],
+  highlight: (text: string) => string,
+) {
+  let result = line;
+  if (capabilities.includes("delegate")) {
+    result = result.replace(DELEGATE_NAMES, (match) => highlight(match));
+  }
+  if (capabilities.includes("workflow")) {
+    result = result.replace(WORKFLOW_NAMES, (match) => highlight(match));
+  }
+  return result;
+}
+
+/**
+ * Transparent, pre-submit feedback for capability intent. It colours only
+ * names whose capability the shared classifier would load after submission;
+ * it never changes editor text, Session history, or model context.
+ */
+export class CapabilityIntentHighlightEditor extends BelowEditorNavigationEditor {
+  private readonly highlight: (text: string) => string;
+
+  constructor(
+    base: EditorComponent,
+    keybindings: KeybindingsManager,
+    highlight: (text: string) => string,
+  ) {
+    super(
+      base,
+      keybindings,
+      new BelowEditorStripState(),
+      () => false,
+      () => undefined,
+      () => undefined,
+    );
+    this.highlight = highlight;
+  }
+
+  override render(width: number) {
+    const capabilities = capabilitiesRequestedByPrompt(this.getText());
+    if (
+      !capabilities.includes("delegate") &&
+      !capabilities.includes("workflow")
+    ) {
+      return super.render(width);
+    }
+    return super
+      .render(width)
+      .map((line) =>
+        highlightCapabilityNames(line, capabilities, this.highlight),
+      );
+  }
+}

package/extensions/clear-context/index.ts

@@ -0,0 +1,83 @@
+import {
+  type ExtensionAPI,
+  type ExtensionContext,
+  type KeybindingsManager,
+} from "@earendil-works/pi-coding-agent";
+import { Key, matchesKey, type EditorComponent } from "@earendil-works/pi-tui";
+import {
+  BelowEditorNavigationEditor,
+  BelowEditorStripState,
+} from "../shared/below-editor-navigation.ts";
+import {
+  registerEditorLayer,
+  removeEditorLayer,
+} from "../shared/editor-layers.ts";
+
+export function shouldClearContext(
+  data: string,
+  editorText: string,
+  isIdle: boolean,
+) {
+  return isIdle && editorText.length === 0 && matchesKey(data, Key.ctrl("c"));
+}
+
+export class ClearContextEditor extends BelowEditorNavigationEditor {
+  private readonly isIdle: () => boolean;
+
+  constructor(
+    base: EditorComponent,
+    keybindings: KeybindingsManager,
+    isIdle: () => boolean,
+  ) {
+    super(
+      base,
+      keybindings,
+      new BelowEditorStripState(),
+      () => false,
+      () => undefined,
+      () => undefined,
+    );
+    this.isIdle = isIdle;
+  }
+
+  override handleInput(data: string) {
+    if (shouldClearContext(data, this.getText(), this.isIdle())) {
+      // Route through Pi's built-in /new command so session replacement keeps
+      // Pi's persistence, cleanup, and transcript lifecycle as the source of truth.
+      this.setText("/new");
+      this.onSubmit?.("/new");
+      return;
+    }
+
+    super.handleInput(data);
+  }
+}
+
+function installClearContextShortcut(pi: ExtensionAPI, ctx: ExtensionContext) {
+  if (ctx.mode !== "tui") return () => {};
+
+  registerEditorLayer(pi, ctx, {
+    id: "clear-context",
+    order: 100,
+    wrap: (base, _tui, _theme, keybindings) =>
+      new ClearContextEditor(base, keybindings, () => ctx.isIdle()),
+  });
+
+  return () => removeEditorLayer(pi, "clear-context");
+}
+
+export default function clearContext(pi: ExtensionAPI) {
+  let removeShortcut = () => {};
+
+  pi.on("session_start", (_event, ctx) => {
+    removeShortcut();
+    removeShortcut = installClearContextShortcut(pi, ctx);
+  });
+
+  pi.on("session_shutdown", () => {
+    removeShortcut();
+    removeShortcut = () => {};
+  });
+}
+
+export { installClearContextShortcut };

package/extensions/context-pivot/index.ts

@@ -11,6 +11,9 @@ import {
 
 export const MIN_CONTEXT_PIVOT_TOKENS = 30_000;
 const STATUS_KEY = "context-pivot";
+const NOTHING_TO_COMPACT_ERROR = "Nothing to compact (session too small)";
+const NO_DISCARDABLE_HISTORY_MESSAGE =
+  "Context pivot could not run: this session has no discardable history to compact. Continue in the current session, or use /sessions to choose another session; to begin cleanly, start a new Session in Pi.";
 
 interface PendingPivot {
   brief: string;
@@ -57,6 +60,13 @@ export function buildPivotSummary(brief: string): string {
   ].join("\n");
 }
 
+function formatContextPivotError(error: unknown): string {
+  const message = error instanceof Error ? error.message : String(error);
+  return message === NOTHING_TO_COMPACT_ERROR
+    ? NO_DISCARDABLE_HISTORY_MESSAGE
+    : `Context pivot failed: ${message}`;
+}
+
 function impossibleKeptId(entries: readonly SessionEntry[]) {
   return `${entries.at(-1)?.id ?? "context-pivot"}-context-pivot-cut`;
 }
@@ -73,7 +83,7 @@ function validateBrief(brief: string, ctx: ExtensionContext) {
   }
   if (tokens < MIN_CONTEXT_PIVOT_TOKENS) {
     throw new Error(
-      `Context is only ${Math.round(tokens).toLocaleString()} tokens; use context_pivot once context reaches at least ${MIN_CONTEXT_PIVOT_TOKENS.toLocaleString()} tokens, or /handoff for a genuinely new session.`,
+      `Context is only ${Math.round(tokens).toLocaleString()} tokens; use context_pivot once context reaches at least ${MIN_CONTEXT_PIVOT_TOKENS.toLocaleString()} tokens, or use /sessions to browse or switch an existing session; start a new Session in Pi when a clean session is needed.`,
     );
   }
 }
@@ -127,7 +137,7 @@ export default function contextPivot(pi: ExtensionAPI) {
     name: "context_pivot",
     label: "Context Pivot",
     description:
-      "Deliberately replace a long, noisy active context with a concise brief for the next phase while staying in the same Pi session. Use once context is at least 30k tokens and the work is moving between phases such as research → implementation or implementation → review; below 30k it is rejected. Use /handoff instead for a genuinely new session.",
+      "Deliberately replace a long, noisy active context with a concise brief for the next phase while staying in the same Pi session. Use once context is at least 30k tokens and the work is moving between phases such as research → implementation or implementation → review; below 30k it is rejected. Use /sessions to browse or switch an existing session; start a new Session in Pi when a genuinely new session is needed.",
     promptSnippet:
       "Compress a long current session into a clean brief before changing phase",
     promptGuidelines: [
@@ -176,11 +186,11 @@ export default function contextPivot(pi: ExtensionAPI) {
           onError: (error) => {
             if (pivotGeneration === generation) pending = undefined;
             clear();
+            const message = formatContextPivotError(error);
             if (ctx.hasUI) {
-              ctx.ui.notify(
-                `Context pivot failed: ${error instanceof Error ? error.message : String(error)}`,
-                "error",
-              );
+              ctx.ui.notify(message, "error");
+            } else {
+              console.error(message);
             }
           },
         });

package/extensions/cron/schedule.ts

@@ -81,8 +81,14 @@ export function parseCronCommand(raw: string): ParsedCronCommand {
       error: `Minimum interval is ${MIN_INTERVAL_MS / 1000}s (the scheduler polls about that often).`,
     };
   }
-  const prompt = schedule[3].trim().slice(0, CRON_PROMPT_MAX_CHARS);
+  const prompt = schedule[3].trim();
   if (!prompt) return { action: "help", error: "Provide a prompt to run." };
+  if (prompt.length > CRON_PROMPT_MAX_CHARS) {
+    return {
+      action: "help",
+      error: `Prompt is too long. Maximum is ${CRON_PROMPT_MAX_CHARS} characters.`,
+    };
+  }
   return {
     action: "add",
     intervalMs,

package/extensions/file-mutation-display/index.ts

@@ -1,88 +1,28 @@
 import {
   createBashToolDefinition,
   createEditToolDefinition,
+  createFindToolDefinition,
+  createGrepToolDefinition,
+  createLsToolDefinition,
+  createReadToolDefinition,
   createWriteToolDefinition,
   type ExtensionAPI,
   type ToolDefinition,
 } from "@earendil-works/pi-coding-agent";
+import type { TSchema } from "typebox";
 import { loadSetupConfig } from "../shared/setup-config.ts";
-import {
-  compactBashRenderedComponent,
-  compactRenderedComponent,
-  singleLineRenderedComponent,
-} from "./render.ts";
-
-function withCompactCallRenderer(
-  definition: ToolDefinition<any, any, any>,
-): ToolDefinition<any, any, any> {
-  const renderCall = definition.renderCall;
-  if (!renderCall) return definition;
-  return {
-    ...definition,
-    renderCall(args, theme, context) {
-      const component = renderCall(args, theme, context);
-      if (
-        context.expanded ||
-        loadSetupConfig().ui.fileMutationDisplay === "full"
-      ) {
-        return component;
-      }
-      // While the model is still streaming a large Write/Edit payload, a
-      // syntax-highlighted preview changes on nearly every token and makes the
-      // entire tool block flash. Keep that phase to a stable one-line header;
-      // reveal the bounded preview once arguments are complete.
-      if (!context.argsComplete) {
-        return singleLineRenderedComponent(component, theme);
-      }
-      const background = context.isPartial
-        ? (text: string) => theme.bg("toolPendingBg", text)
-        : context.isError
-          ? (text: string) => theme.bg("toolErrorBg", text)
-          : (text: string) => theme.bg("toolSuccessBg", text);
-      return compactRenderedComponent(component, theme, undefined, background);
-    },
-  };
-}
+import { withActivityRenderer } from "./render.ts";
 
-function withCompactBashRenderer(
-  definition: ToolDefinition<any, any, any>,
-): ToolDefinition<any, any, any> {
-  const renderCall = definition.renderCall;
-  const renderResult = definition.renderResult;
-  if (!renderCall || !renderResult) return definition;
-  return {
-    ...definition,
-    renderCall(args, theme, context) {
-      // A compact wrapper is not the native Text component expected through
-      // lastComponent, so rebuild the cheap call renderer on each update.
-      const component = renderCall(args, theme, {
-        ...context,
-        lastComponent: undefined,
-      });
-      if (context.expanded || loadSetupConfig().ui.bashToolDisplay === "full") {
-        return component;
-      }
-      return singleLineRenderedComponent(component, theme);
-    },
-    renderResult(result, options, theme, context) {
-      // Bash streams partial results. Never hand our wrapper back to Pi's
-      // native BashResultRenderComponent updater.
-      const component = renderResult(result, options, theme, {
-        ...context,
-        lastComponent: undefined,
-      });
-      if (options.expanded || loadSetupConfig().ui.bashToolDisplay === "full") {
-        return component;
-      }
-      return compactBashRenderedComponent(component, theme);
-    },
-  };
+function compact<TParams extends TSchema, TDetails, TState>(
+  definition: ToolDefinition<TParams, TDetails, TState>,
+  enabled: boolean,
+) {
+  return enabled ? withActivityRenderer(definition) : definition;
 }
 
 /**
- * Override only the TUI renderers. The wrapped definitions are Pi's native
- * Bash/Write/Edit tools, so schemas, execution, mutation queues, diffs, and
- * errors stay on the upstream implementation.
+ * Override only Pi's TUI projection. Every wrapped definition retains its
+ * native schema, prompt metadata, execute function, result, and details.
  */
 export default function fileMutationDisplay(pi: ExtensionAPI) {
   pi.on("session_start", (_event, ctx) => {
@@ -96,10 +36,28 @@ export default function fileMutationDisplay(pi: ExtensionAPI) {
           display.fileMutationDisplay === "full",
       );
     }
-    pi.registerTool(withCompactBashRenderer(createBashToolDefinition(ctx.cwd)));
+
+    pi.registerTool(
+      compact(
+        createBashToolDefinition(ctx.cwd),
+        display.bashToolDisplay !== "full",
+      ),
+    );
+    pi.registerTool(
+      compact(
+        createWriteToolDefinition(ctx.cwd),
+        display.fileMutationDisplay !== "full",
+      ),
+    );
     pi.registerTool(
-      withCompactCallRenderer(createWriteToolDefinition(ctx.cwd)),
+      compact(
+        createEditToolDefinition(ctx.cwd),
+        display.fileMutationDisplay !== "full",
+      ),
     );
-    pi.registerTool(withCompactCallRenderer(createEditToolDefinition(ctx.cwd)));
+    pi.registerTool(withActivityRenderer(createReadToolDefinition(ctx.cwd)));
+    pi.registerTool(withActivityRenderer(createGrepToolDefinition(ctx.cwd)));
+    pi.registerTool(withActivityRenderer(createFindToolDefinition(ctx.cwd)));
+    pi.registerTool(withActivityRenderer(createLsToolDefinition(ctx.cwd)));
   });
 }

package/extensions/file-mutation-display/render.ts

@@ -1,107 +1,166 @@
-import { stripVTControlCharacters } from "node:util";
-import { keyHint, type Theme } from "@earendil-works/pi-coding-agent";
-import {
-  truncateToWidth,
-  visibleWidth,
-  type Component,
-} from "@earendil-works/pi-tui";
+import type {
+  AgentToolResult,
+  Theme,
+  ToolDefinition,
+} from "@earendil-works/pi-coding-agent";
+import type { Component } from "@earendil-works/pi-tui";
+import type { TSchema } from "typebox";
+import { renderPaddedToolActivityLine } from "../shared/tool-activity.ts";
 
-// Native Write/Edit renderings include their title and context rows. Three
-// visible rows keep the operation identifiable while making repeated file
-// mutations substantially quieter than Claude Code's default preview.
-export const FILE_MUTATION_PREVIEW_LINES = 3;
-export const BASH_OUTPUT_PREVIEW_LINES = 1;
+type ActivityStatus = "pending" | "success" | "error";
 
-function expandHint(hidden: number) {
-  return `… ${hidden} more line${hidden === 1 ? "" : "s"} · ${keyHint("app.tools.expand", "to expand")}`;
+type ActivityRenderState<TDetails> = {
+  openpiActivity?: {
+    result?: AgentToolResult<TDetails>;
+    status: ActivityStatus;
+    startedAt?: number;
+    endedAt?: number;
+    interval?: NodeJS.Timeout;
+    nativeCallComponent?: Component;
+    nativeResultComponent?: Component;
+  };
+};
+
+const emptyComponent: Component = {
+  render: () => [],
+  invalidate() {},
+};
+
+function textOutput(result: AgentToolResult<unknown> | undefined) {
+  return (
+    result?.content
+      .filter((item) => item.type === "text")
+      .map((item) => item.text)
+      .join("\n") ?? ""
+  );
 }
 
-/** Keep a long command identifiable without allowing it to wrap for many rows. */
-export function singleLineRenderedComponent(
-  component: Component,
+function activityComponent(
+  name: string,
+  args: unknown,
+  state: NonNullable<ActivityRenderState<unknown>["openpiActivity"]>,
   theme: Theme,
+  cwd: string,
 ): Component {
   return {
     render(width) {
-      const lines = component.render(width);
-      if (lines.length <= 1) return lines;
-      if (width <= 2) return [truncateToWidth(lines[0] ?? "", width, "")];
-      return [
-        truncateToWidth(lines[0] ?? "", width - 2, "") + theme.fg("dim", " …"),
-      ];
-    },
-    invalidate() {
-      component.invalidate();
+      const line = renderPaddedToolActivityLine(
+        {
+          name,
+          args,
+          output: textOutput(state.result),
+          details: state.result?.details,
+          status: state.status,
+          cwd,
+          startedAt: state.startedAt,
+          endedAt: state.endedAt,
+        },
+        theme,
+        width,
+      );
+      return line ? [line] : [];
     },
+    invalidate() {},
   };
 }
 
-/** Preserve one output row, warnings, and final timing in compact Bash mode. */
-export function compactBashRenderedComponent(
-  component: Component,
-  theme: Theme,
-  maximum = BASH_OUTPUT_PREVIEW_LINES,
-): Component {
+/**
+ * Preserve Pi's complete tool definition and execution semantics while
+ * replacing only the collapsed operator-facing projection.
+ */
+export function withActivityRenderer<TParams extends TSchema, TDetails, TState>(
+  definition: ToolDefinition<TParams, TDetails, TState>,
+): ToolDefinition<TParams, TDetails, TState & ActivityRenderState<TDetails>> {
+  const nativeRenderCall = definition.renderCall;
+  const nativeRenderResult = definition.renderResult;
   return {
-    render(width) {
-      const rendered = component.render(width);
-      const visible = rendered.filter(
-        (line) => stripVTControlCharacters(line).trim().length > 0,
+    ...definition,
+    renderShell: "self",
+    renderCall(args, theme, context) {
+      const state = context.state as TState & ActivityRenderState<TDetails>;
+      state.openpiActivity ??= { status: "pending" };
+      const activity = state.openpiActivity;
+      if (context.executionStarted && activity.startedAt === undefined) {
+        activity.startedAt = Date.now();
+      }
+      if (
+        context.executionStarted &&
+        definition.name === "bash" &&
+        activity.status === "pending" &&
+        !context.expanded &&
+        activity.interval === undefined
+      ) {
+        activity.interval = setInterval(() => context.invalidate(), 1000);
+        activity.interval.unref();
+      }
+      if (context.expanded && activity.interval) {
+        clearInterval(activity.interval);
+        activity.interval = undefined;
+      }
+      if (context.expanded && nativeRenderCall) {
+        const nativeContext: Parameters<typeof nativeRenderCall>[2] = {
+          ...context,
+          state,
+          lastComponent: activity.nativeCallComponent,
+        };
+        const component = nativeRenderCall(args, theme, nativeContext);
+        activity.nativeCallComponent = component;
+        return component;
+      }
+      return activityComponent(
+        definition.name,
+        args,
+        activity as NonNullable<ActivityRenderState<unknown>["openpiActivity"]>,
+        theme,
+        context.cwd,
       );
-      let nativeHidden = 0;
-      const content: string[] = [];
-      const metadata: string[] = [];
-      let status: string | undefined;
-      for (const line of visible) {
-        const plain = stripVTControlCharacters(line).trim();
-        const hiddenMatch = plain.match(/\(?([0-9]+) earlier lines,/);
-        if (hiddenMatch) {
-          nativeHidden += Number(hiddenMatch[1]);
-        } else if (/^(Took|Elapsed)\s/.test(plain)) {
-          status = line;
-        } else if (/^\[(Full output|Truncated):/.test(plain)) {
-          metadata.push(line);
-        } else {
-          content.push(line);
+    },
+    renderResult(result, options, theme, context) {
+      const state = context.state as TState & ActivityRenderState<TDetails>;
+      state.openpiActivity ??= { status: "pending" };
+      const activity = state.openpiActivity;
+      activity.result = result;
+      activity.status = options.isPartial
+        ? "pending"
+        : context.isError
+          ? "error"
+          : "success";
+      if (
+        options.isPartial &&
+        definition.name === "bash" &&
+        !options.expanded &&
+        activity.interval === undefined
+      ) {
+        activity.interval = setInterval(() => context.invalidate(), 1000);
+        activity.interval.unref();
+      }
+      if (!options.isPartial || context.isError || options.expanded) {
+        activity.endedAt ??= Date.now();
+        if (activity.interval) {
+          clearInterval(activity.interval);
+          activity.interval = undefined;
         }
       }
-      const preview = content.slice(0, maximum);
-      const hidden =
-        nativeHidden + Math.max(0, content.length - preview.length);
-      return [
-        ...preview,
-        ...(hidden > 0 ? [theme.fg("dim", expandHint(hidden))] : []),
-        ...metadata,
-        ...(status ? [status] : []),
-      ];
-    },
-    invalidate() {
-      component.invalidate();
-    },
-  };
-}
+      if (options.isPartial && options.expanded) {
+        activity.endedAt = undefined;
+      }
 
-export function compactRenderedComponent(
-  component: Component,
-  theme: Theme,
-  maximum = FILE_MUTATION_PREVIEW_LINES,
-  background?: (text: string) => string,
-): Component {
-  return {
-    render(width) {
-      const lines = component.render(width);
-      if (lines.length <= maximum) return lines;
-      const hidden = lines.length - maximum;
-      const hint = theme.fg("dim", expandHint(hidden));
-      const paddedHint =
-        hint + " ".repeat(Math.max(0, width - visibleWidth(hint)));
-      return [
-        ...lines.slice(0, maximum),
-        background ? background(paddedHint) : hint,
-      ];
-    },
-    invalidate() {
-      component.invalidate();
+      if (options.expanded && nativeRenderResult) {
+        const nativeContext: Parameters<typeof nativeRenderResult>[3] = {
+          ...context,
+          state,
+          lastComponent: activity.nativeResultComponent,
+        };
+        const component = nativeRenderResult(
+          result,
+          options,
+          theme,
+          nativeContext,
+        );
+        activity.nativeResultComponent = component;
+        return component;
+      }
+      return emptyComponent;
     },
   };
 }