@tt-a1i/openpi 0.1.0

package/extensions/background-terminals/src/ui/tool-result.ts

@@ -0,0 +1,146 @@
+import { keyHint, type Theme } from "@earendil-works/pi-coding-agent";
+import { Text, truncateToWidth, type Component } from "@earendil-works/pi-tui";
+import { sanitizeText } from "./output-view.ts";
+
+const STREAM_PREVIEW_LINES = 2;
+
+interface ParsedTerminalResult {
+  summary: string;
+  metadata: string[];
+  streams: Array<{
+    name: "stdout" | "stderr";
+    lines: string[];
+    truncated: boolean;
+  }>;
+}
+
+export interface CompactTerminalPreview {
+  summary: string;
+  metadata: string[];
+  streams: Array<{
+    name: "stdout" | "stderr";
+    lines: string[];
+  }>;
+  hiddenLines: number;
+  unknownEarlierOutput: boolean;
+}
+
+function parseTerminalResult(content: string): ParsedTerminalResult {
+  const lines = sanitizeText(content).split("\n");
+  const summary = lines.shift()?.trim() || "Background terminal result";
+  const metadata: string[] = [];
+  const streams: ParsedTerminalResult["streams"] = [];
+  let current: ParsedTerminalResult["streams"][number] | undefined;
+
+  for (const rawLine of lines) {
+    const line = rawLine.replace(/\s+$/, "");
+    const streamHeader = /^(stdout|stderr):(.*)$/.exec(line);
+    if (streamHeader) {
+      current = {
+        name: streamHeader[1] === "stdout" ? "stdout" : "stderr",
+        lines: [],
+        truncated: false,
+      };
+      streams.push(current);
+      const inline = streamHeader[2]?.trim();
+      if (inline && inline !== "(empty)") current.lines.push(inline);
+      continue;
+    }
+    if (!current) {
+      if (line.trim()) metadata.push(line.trim());
+      continue;
+    }
+    if (/^\[(stdout|stderr) truncated:/.test(line)) {
+      current.truncated = true;
+      continue;
+    }
+    if (!line || line === "(empty)") continue;
+    current.lines.push(line);
+  }
+
+  for (const stream of streams) {
+    while (stream.lines.at(-1) === "") stream.lines.pop();
+  }
+  return { summary, metadata, streams };
+}
+
+/** Build a bounded, tail-first preview without changing model-facing output. */
+export function buildCompactTerminalPreview(
+  content: string,
+  maximumPerStream = STREAM_PREVIEW_LINES,
+): CompactTerminalPreview {
+  const parsed = parseTerminalResult(content);
+  let hiddenLines = 0;
+  let unknownEarlierOutput = false;
+  const streams = parsed.streams
+    .filter((stream) => stream.lines.length > 0)
+    .map((stream) => {
+      const maximum = Math.max(0, maximumPerStream);
+      hiddenLines += Math.max(0, stream.lines.length - maximum);
+      unknownEarlierOutput ||= stream.truncated;
+      return {
+        name: stream.name,
+        lines: maximum === 0 ? [] : stream.lines.slice(-maximum),
+      };
+    });
+
+  return {
+    summary: parsed.summary,
+    metadata: parsed.metadata,
+    streams,
+    hiddenLines,
+    unknownEarlierOutput,
+  };
+}
+
+function fixedRows(rows: string[]): Component {
+  return {
+    render(width) {
+      return rows.map((row) => truncateToWidth(row, width, "…"));
+    },
+    invalidate() {},
+  };
+}
+
+/** Render terminal results compactly by default; expanded mode preserves all text. */
+export function renderTerminalResult(
+  content: string,
+  expanded: boolean,
+  theme: Theme,
+  summaryOverride?: string,
+): Component {
+  const sanitized = sanitizeText(content);
+  if (expanded) {
+    if (!summaryOverride) return new Text(sanitized, 0, 0);
+    return new Text(
+      [summaryOverride, ...sanitized.split("\n").slice(1)].join("\n"),
+      0,
+      0,
+    );
+  }
+
+  const preview = buildCompactTerminalPreview(sanitized);
+  const rows = [
+    summaryOverride ?? theme.fg("muted", preview.summary),
+    ...preview.metadata.map((line) => theme.fg("error", line)),
+  ];
+  for (const stream of preview.streams) {
+    for (const line of stream.lines) {
+      rows.push(
+        theme.fg("dim", `${stream.name} · `) + theme.fg("toolOutput", line),
+      );
+    }
+  }
+  if (preview.hiddenLines > 0 || preview.unknownEarlierOutput) {
+    const amount = preview.unknownEarlierOutput
+      ? "earlier log output"
+      : `${preview.hiddenLines} earlier line${preview.hiddenLines === 1 ? "" : "s"}`;
+    rows.push(
+      theme.fg(
+        "dim",
+        `… ${amount} hidden · ${keyHint("app.tools.expand", "to expand")}`,
+      ),
+    );
+  }
+  return fixedRows(rows);
+}

package/extensions/background-terminals/src/watch.ts

@@ -0,0 +1,192 @@
+/**
+ * Pure matcher for `bg_watch`: scans a background terminal's streamed output
+ * for a pattern, keeping a bounded carry so a match that straddles two chunks
+ * is still found. Kept free of process/IO concerns so it can be tested
+ * directly — the streaming path around it is the part that is hard to test.
+ */
+
+import {
+  hasTerminalControls,
+  sanitizeTerminalText,
+} from "../../shared/terminal-text.ts";
+
+/** Bound on retained tail. A match spanning more than this is not detected. */
+export const WATCH_CARRY_MAX_BYTES = 4 * 1024;
+
+export interface WatchMatch {
+  /** The line (or bounded slice) containing the match. */
+  line: string;
+  /** Which stream produced it. */
+  stream: "stdout" | "stderr";
+}
+
+export interface ChunkMatcher {
+  /** Feed a chunk; returns the first match in it, or undefined. */
+  push(chunk: string, stream: "stdout" | "stderr"): WatchMatch | undefined;
+}
+
+interface CapturedOutput {
+  text: string;
+  truncatedBytes: number;
+}
+
+/** Refuse a watch when prior eviction made terminal parse state unknowable. */
+export function assertWatchableOutput(
+  stdout: CapturedOutput,
+  stderr: CapturedOutput,
+) {
+  if (stdout.truncatedBytes === 0 && stderr.truncatedBytes === 0) return;
+  throw new Error(
+    "Cannot safely arm a watch after older terminal output was dropped; inspect /ps or start a fresh terminal before watching for a signature.",
+  );
+}
+
+/** Check retained output only when its control-string parse state is intact. */
+export function matchCapturedOutput(
+  matcher: ChunkMatcher,
+  stdout: CapturedOutput,
+  stderr: CapturedOutput,
+) {
+  // A head-truncated buffer can begin inside an OSC/DCS payload after its
+  // opener was evicted. There is no safe way to infer that missing state, so
+  // skip historical matching for that stream and watch future chunks instead.
+  const stdoutHit =
+    stdout.truncatedBytes === 0
+      ? matcher.push(stdout.text, "stdout")
+      : undefined;
+  return (
+    stdoutHit ??
+    (stderr.truncatedBytes === 0
+      ? matcher.push(stderr.text, "stderr")
+      : undefined)
+  );
+}
+
+const CONTROL_STRING_STARTS = [
+  "\u001b]",
+  "\u001bP",
+  "\u001bX",
+  "\u001b^",
+  "\u001b_",
+  "\u0090",
+  "\u0098",
+  "\u009d",
+  "\u009e",
+  "\u009f",
+];
+const OSC_END = /\u0007|\u001b\\|\u009c/;
+const ST_STRING_END = /\u001b\\|\u009c/;
+
+/** Keep an opener when a long split control string crosses the carry bound. */
+function boundedRawCarry(text: string) {
+  if (text.length <= WATCH_CARRY_MAX_BYTES) return text;
+  let lastStart = -1;
+  let opener = "";
+  for (const candidate of CONTROL_STRING_STARTS) {
+    const index = text.lastIndexOf(candidate);
+    if (index > lastStart) {
+      lastStart = index;
+      opener = candidate;
+    }
+  }
+  const terminator =
+    opener === "\u001b]" || opener === "\u009d" ? OSC_END : ST_STRING_END;
+  const open =
+    lastStart >= 0 && !terminator.test(text.slice(lastStart + opener.length));
+  return `${open ? opener : ""}${text.slice(-WATCH_CARRY_MAX_BYTES)}`;
+}
+
+/**
+ * Build a one-shot matcher from the safe RegExp produced by
+ * `compileWatchPattern`. It has no stateful flags, so each test is independent.
+ * Returns undefined-forever after the first match: callers
+ * disarm the watch, and this makes double-fire impossible even if they don't.
+ */
+export function createChunkMatcher(pattern: RegExp): ChunkMatcher {
+  // One carry PER STREAM. A shared buffer would splice interleaved stdout and
+  // stderr together, both missing real straddling matches and fabricating
+  // matches from text that never appeared on either stream.
+  const carries: Record<"stdout" | "stderr", string> = {
+    stdout: "",
+    stderr: "",
+  };
+  let done = false;
+  return {
+    push(chunk, stream) {
+      if (done || !chunk) return undefined;
+      const rawText = carries[stream] + chunk;
+      // Match only text that could actually be shown to the user. A readiness
+      // word hidden inside an OSC clipboard payload must not wake the agent.
+      const text = sanitizeTerminalText(rawText);
+      const match = pattern.exec(text);
+      if (!match) {
+        // Retain raw text so a control string split across chunks can still be
+        // removed as one unit before matching. Preserve its opener if its
+        // payload itself is longer than the carry bound.
+        carries[stream] = boundedRawCarry(rawText);
+        return undefined;
+      }
+      done = true;
+      carries.stdout = "";
+      carries.stderr = "";
+      // Report the containing line, not the whole buffer: the model wants the
+      // log line that matched, not every byte since the watch started. Bound
+      // it too — a process with no newlines (progress bars) would otherwise
+      // smear kilobytes into the transcript.
+      const start = text.lastIndexOf("\n", match.index) + 1;
+      const endIndex = text.indexOf("\n", match.index);
+      const end = endIndex === -1 ? text.length : endIndex;
+      return {
+        line: sanitizeLine(text.slice(start, end)),
+        stream,
+      };
+    },
+  };
+}
+
+/** Cap on the reported match line, so a newline-free stream cannot smear. */
+export const WATCH_LINE_MAX_CHARS = 500;
+
+/**
+ * Strip ANSI/control bytes and bound the length. The matched line is injected
+ * into the transcript, and the sibling terminal-result path already sanitizes;
+ * passing raw escape sequences through would desync the renderer.
+ */
+function sanitizeLine(raw: string) {
+  const stripped = sanitizeTerminalText(raw).trim();
+  return stripped.length > WATCH_LINE_MAX_CHARS
+    ? `${stripped.slice(0, WATCH_LINE_MAX_CHARS)}\u2026`
+    : stripped;
+}
+
+/** Cap on a signature list; watches are match hints, not a regex engine. */
+export const WATCH_PATTERN_MAX_CHARS = 200;
+
+function escapeRegExp(text: string) {
+  return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+/**
+ * Compile pipe-separated literal signatures. JavaScript regex executes
+ * synchronously on the process-output hot path and has no timeout, so no
+ * blacklist can make arbitrary regex safe from catastrophic backtracking.
+ * Literal alternatives preserve the useful `Ready|ERROR|FAILED` contract and
+ * make matching time linear in the bounded input.
+ */
+export function compileWatchPattern(pattern: string): RegExp {
+  if (pattern.length > WATCH_PATTERN_MAX_CHARS) {
+    throw new Error(
+      `Watch pattern is too long (max ${WATCH_PATTERN_MAX_CHARS} chars); use short signatures like "Ready in|Traceback|ERROR".`,
+    );
+  }
+  if (hasTerminalControls(pattern)) {
+    throw new Error("Watch signatures cannot contain control characters.");
+  }
+  const alternatives = pattern.split("|");
+  if (alternatives.some((alternative) => alternative.length === 0)) {
+    throw new Error(
+      'Watch signatures cannot be empty; use literals like "Ready in|Traceback|ERROR".',
+    );
+  }
+  return new RegExp(alternatives.map(escapeRegExp).join("|"));
+}

package/extensions/context-pivot/index.ts

@@ -0,0 +1,222 @@
+import type {
+  ExtensionAPI,
+  ExtensionContext,
+  SessionEntry,
+} from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+
+export const MIN_CONTEXT_PIVOT_TOKENS = 30_000;
+const STATUS_KEY = "context-pivot";
+
+interface PendingPivot {
+  brief: string;
+  generation: number;
+}
+
+interface ContextUsage {
+  tokens?: number | null;
+  percent?: number | null;
+  contextWindow?: number | null;
+}
+
+export function estimateContextTokens(
+  usage: ContextUsage | null | undefined,
+): number | null {
+  if (!usage) return null;
+  if (typeof usage.tokens === "number") {
+    return Number.isFinite(usage.tokens) && usage.tokens >= 0
+      ? usage.tokens
+      : null;
+  }
+  if (
+    typeof usage.percent !== "number" ||
+    !Number.isFinite(usage.percent) ||
+    usage.percent < 0 ||
+    typeof usage.contextWindow !== "number" ||
+    !Number.isFinite(usage.contextWindow) ||
+    usage.contextWindow <= 0
+  ) {
+    return null;
+  }
+  return (usage.contextWindow * usage.percent) / 100;
+}
+
+export function buildPivotSummary(brief: string): string {
+  return [
+    "## Context Pivot — Continue in a Clean Context",
+    "",
+    "The previous phase was deliberately compressed. Continue from this brief instead of reconstructing discarded mechanics.",
+    "",
+    "## Next Phase",
+    "",
+    brief.trim(),
+  ].join("\n");
+}
+
+function impossibleKeptId(entries: readonly SessionEntry[]) {
+  return `${entries.at(-1)?.id ?? "context-pivot"}-context-pivot-cut`;
+}
+
+function validateBrief(brief: string, ctx: ExtensionContext) {
+  if (!brief.trim())
+    throw new Error("context_pivot requires a non-empty brief.");
+
+  const tokens = estimateContextTokens(ctx.getContextUsage());
+  if (tokens === null) {
+    throw new Error(
+      "Context usage is unavailable; context pivot was not started.",
+    );
+  }
+  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.`,
+    );
+  }
+}
+
+export default function contextPivot(pi: ExtensionAPI) {
+  let generation = 0;
+  let pending: PendingPivot | undefined;
+  let compacting = false;
+
+  pi.on("session_before_compact", (event) => {
+    const pivot = pending;
+    if (!pivot || pivot.generation !== generation) return;
+
+    pending = undefined;
+    const summary = buildPivotSummary(pivot.brief);
+    return {
+      compaction: {
+        summary,
+        firstKeptEntryId: impossibleKeptId(event.branchEntries),
+        tokensBefore: event.preparation.tokensBefore,
+        details: { contextPivot: true },
+      },
+    };
+  });
+
+  pi.on("session_shutdown", (_event, ctx) => {
+    generation += 1;
+    pending = undefined;
+    compacting = false;
+    if (ctx.hasUI) ctx.ui.setStatus(STATUS_KEY, undefined);
+  });
+
+  pi.registerTool({
+    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.",
+    promptSnippet:
+      "Compress a long current session into a clean brief before changing phase",
+    promptGuidelines: [
+      "Use context_pivot only when the current context is at least 30k tokens and the work is changing phase. Put the current state, decisions, blockers, failed paths worth avoiding, relevant artifact paths, and exact next steps in its brief.",
+    ],
+    parameters: Type.Object({
+      brief: Type.String({
+        description:
+          "Self-contained next-phase brief: goal, current state, decisions and constraints, blockers, failed paths, artifact paths, and immediate next steps.",
+      }),
+    }),
+    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+      if (compacting)
+        throw new Error("A context pivot is already in progress.");
+      validateBrief(params.brief, ctx);
+
+      const pivotGeneration = ++generation;
+      pending = { brief: params.brief.trim(), generation: pivotGeneration };
+      compacting = true;
+      if (ctx.hasUI) {
+        ctx.ui.setStatus(
+          STATUS_KEY,
+          ctx.ui.theme.fg("accent", "↻ pivoting context…"),
+        );
+      }
+
+      const clear = () => {
+        if (pivotGeneration !== generation) return;
+        compacting = false;
+        if (ctx.hasUI) ctx.ui.setStatus(STATUS_KEY, undefined);
+      };
+
+      try {
+        ctx.compact({
+          onComplete: () => {
+            clear();
+            if (pivotGeneration !== generation) return;
+            if (ctx.hasUI) {
+              ctx.ui.notify(
+                "Context pivot complete. Continuing from the next-phase brief.",
+                "info",
+              );
+            }
+            pi.sendUserMessage("Continue with the next phase now.");
+          },
+          onError: (error) => {
+            if (pivotGeneration === generation) pending = undefined;
+            clear();
+            if (ctx.hasUI) {
+              ctx.ui.notify(
+                `Context pivot failed: ${error instanceof Error ? error.message : String(error)}`,
+                "error",
+              );
+            }
+          },
+        });
+      } catch (error) {
+        pending = undefined;
+        clear();
+        throw error;
+      }
+
+      return {
+        content: [{ type: "text", text: "Context pivot started." }],
+        details: { contextPivot: true },
+        terminate: true,
+      };
+    },
+  });
+
+  pi.registerCommand("context-pivot", {
+    description:
+      "Ask the agent to compact this long session into a clean next-phase brief",
+    handler: async (args, ctx) => {
+      const direction = args.trim();
+      if (!direction) {
+        if (ctx.hasUI) {
+          ctx.ui.notify("Usage: /context-pivot <next phase>", "error");
+        }
+        return;
+      }
+
+      const tokens = estimateContextTokens(ctx.getContextUsage());
+      if (tokens === null || tokens < MIN_CONTEXT_PIVOT_TOKENS) {
+        if (ctx.hasUI) {
+          ctx.ui.notify(
+            tokens === null
+              ? "Context usage is unavailable; context pivot was not started."
+              : `Context is only ${Math.round(tokens).toLocaleString()} tokens; a pivot is not useful yet.`,
+            "warning",
+          );
+        }
+        return;
+      }
+
+      pi.sendUserMessage(
+        [
+          `Context pivot direction: ${direction}`,
+          "",
+          "Prepare a concise, self-contained next-phase brief containing:",
+          "- the exact next goal and current state",
+          "- decisions and constraints that still matter",
+          "- blockers, unresolved questions, and failed paths worth avoiding",
+          "- relevant artifact, file, issue, or commit references",
+          "- immediate executable next steps",
+          "",
+          "Then call context_pivot with that brief. Do not continue normal work first.",
+        ].join("\n"),
+        ctx.isIdle() ? undefined : { deliverAs: "followUp" },
+      );
+    },
+  });
+}

package/extensions/copy-all/index.ts

@@ -0,0 +1,65 @@
+import {
+  copyToClipboard,
+  type ExtensionAPI,
+} from "@earendil-works/pi-coding-agent";
+
+function textFromContent(content: unknown) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+
+  return content
+    .map((block) => {
+      if (!block || typeof block !== "object") return "";
+      if (!("type" in block)) return "";
+
+      if (
+        block.type === "text" &&
+        "text" in block &&
+        typeof block.text === "string"
+      ) {
+        return block.text;
+      }
+
+      if (block.type === "image") return "[image]";
+
+      return "";
+    })
+    .filter(Boolean)
+    .join("\n");
+}
+
+export default function (pi: ExtensionAPI) {
+  pi.registerCommand("copy-all", {
+    description:
+      "Copy the current branch's visible user and assistant conversation to the clipboard",
+    handler: async (_args, ctx) => {
+      await ctx.waitForIdle();
+
+      const sections = ctx.sessionManager
+        .getBranch()
+        .filter((entry) => entry.type === "message")
+        .map((entry) => entry.message)
+        .filter(
+          (message) => message.role === "user" || message.role === "assistant",
+        )
+        .map((message) => ({
+          role: message.role,
+          content: textFromContent(message.content).trim(),
+        }))
+        .filter(({ content }) => content)
+        .map(({ role, content }) => `${role.toUpperCase()}:\n${content}`);
+
+      if (sections.length === 0) {
+        ctx.ui.notify("No user or assistant messages to copy", "info");
+        return;
+      }
+
+      const conversation = sections.join("\n\n---\n\n");
+      await copyToClipboard(conversation);
+      ctx.ui.notify(
+        `Copied ${sections.length} visible messages (${conversation.length.toLocaleString()} characters) from the current branch`,
+        "info",
+      );
+    },
+  });
+}