@tt-a1i/openpi 0.1.0

package/extensions/suggestions/src/predictor.ts

@@ -0,0 +1,147 @@
+import type { ModelRegistry } from "@earendil-works/pi-coding-agent";
+import { completeSimple } from "@earendil-works/pi-ai/compat";
+import { visibleWidth } from "@earendil-works/pi-tui";
+import { Data, Effect } from "effect";
+import { sanitizeTerminalText } from "../../shared/terminal-text.ts";
+import type { SuggestionConfig } from "./config.ts";
+import { buildSuggestionPrompt, SUGGESTION_SYSTEM_PROMPT } from "./prompt.ts";
+
+const SUGGESTION_MAX_CHARS = 200;
+
+class PredictionError extends Data.TaggedError("PredictionError")<{
+  readonly message: string;
+  readonly cause?: unknown;
+}> {}
+
+function cleanSuggestion(value: string) {
+  const oneLine = sanitizeTerminalText(value)
+    .normalize("NFC")
+    // Model output is untrusted editor input. Format controls can create an
+    // invisible or direction-spoofed suggestion, so never offer them.
+    .replace(/\p{Cf}/gu, "")
+    .replace(/\s+/g, " ")
+    .trim();
+  const bounded = [...oneLine].slice(0, SUGGESTION_MAX_CHARS).join("");
+  return visibleWidth(bounded) > 0 ? bounded : "";
+}
+
+function parseCandidate(candidate: string): string | undefined | null {
+  try {
+    const value: unknown = JSON.parse(candidate);
+    if (
+      typeof value !== "object" ||
+      value === null ||
+      Array.isArray(value) ||
+      Object.keys(value).join(",") !== "suggestion" ||
+      !("suggestion" in value)
+    ) {
+      return null;
+    }
+    if (value.suggestion === null) return undefined;
+    if (typeof value.suggestion !== "string") return null;
+    return cleanSuggestion(value.suggestion) || undefined;
+  } catch {
+    return null;
+  }
+}
+
+export function parseSuggestionResponse(text: string) {
+  const trimmed = text.trim();
+  const candidates = [trimmed];
+  for (const match of trimmed.matchAll(/```(?:json)?\s*([\s\S]*?)```/gi)) {
+    if (match[1]) candidates.push(match[1].trim());
+  }
+  const firstBrace = trimmed.indexOf("{");
+  const lastBrace = trimmed.lastIndexOf("}");
+  if (firstBrace !== -1 && lastBrace > firstBrace) {
+    candidates.push(trimmed.slice(firstBrace, lastBrace + 1));
+  }
+
+  for (const candidate of candidates) {
+    const parsed = parseCandidate(candidate);
+    if (parsed !== null) return parsed;
+  }
+  throw new PredictionError({
+    message: "The prediction model did not return valid suggestion JSON.",
+  });
+}
+
+export function reasoningOptions(reasoning: SuggestionConfig["reasoning"]) {
+  return reasoning === "off" ? {} : { reasoning };
+}
+
+function assistantText(
+  content: Awaited<ReturnType<typeof completeSimple>>["content"],
+) {
+  return content
+    .filter((block) => block.type === "text")
+    .map((block) => block.text)
+    .join("\n");
+}
+
+export function predictNextAction(options: {
+  readonly modelRegistry: ModelRegistry;
+  readonly config: SuggestionConfig;
+  readonly transcript: string;
+  readonly signal: AbortSignal;
+}) {
+  const completion = Effect.tryPromise({
+    try: async (effectSignal) => {
+      const model = options.modelRegistry.find(
+        options.config.provider,
+        options.config.model,
+      );
+      if (!model) {
+        throw new PredictionError({
+          message: `Suggestion model is unavailable: ${options.config.provider}/${options.config.model}`,
+        });
+      }
+
+      const auth = await options.modelRegistry.getApiKeyAndHeaders(model);
+      if (!auth.ok) throw new PredictionError({ message: auth.error });
+
+      const response = await completeSimple(
+        model,
+        {
+          systemPrompt: SUGGESTION_SYSTEM_PROMPT,
+          messages: [
+            {
+              role: "user",
+              content: buildSuggestionPrompt(options.transcript),
+              timestamp: Date.now(),
+            },
+          ],
+        },
+        {
+          apiKey: auth.apiKey,
+          env: auth.env,
+          headers: auth.headers,
+          maxTokens: 300,
+          maxRetries: 1,
+          signal: effectSignal,
+          timeoutMs: 20_000,
+          ...reasoningOptions(options.config.reasoning),
+        },
+      );
+
+      if (
+        response.stopReason === "error" ||
+        response.stopReason === "aborted"
+      ) {
+        throw new PredictionError({
+          message: response.errorMessage ?? "Suggestion model request failed.",
+        });
+      }
+      return parseSuggestionResponse(assistantText(response.content));
+    },
+    catch: (cause) =>
+      cause instanceof PredictionError
+        ? cause
+        : new PredictionError({
+            message: cause instanceof Error ? cause.message : String(cause),
+            cause,
+          }),
+  }).pipe(Effect.timeout("25 seconds"));
+
+  return Effect.runPromise(completion, { signal: options.signal });
+}

package/extensions/suggestions/src/prompt.ts

@@ -0,0 +1,20 @@
+export const SUGGESTION_SYSTEM_PROMPT = `Predict the user's single most likely immediate next message after a completed coding-agent run.
+
+Return exactly one JSON object in one of these shapes:
+{"suggestion":"..."}
+{"suggestion":null}
+
+Rules:
+- Write suggestion exactly as the user would type it to the coding agent, not as advice about what the user should do.
+- Choose one concrete, useful continuation grounded in the supplied run: a likely follow-up, verification, refinement, or next task. Never repeat work the run already confirmed complete.
+- Match the language, tone, and brevity of the user's initiating prompt. Keep the suggestion to one line and at most 200 characters.
+- Emit a natural-language user request, never an imitation of an assistant tool call. Do not copy a bare tool name, shell command, or filesystem path from assistant/tool transcript; mention a path only when the user's own initiating prompt named it and it remains necessary.
+- Return null when there is no specific, plausible continuation. Do not emit generic filler such as "continue", "anything else", "review the result", or "let me know".
+- Never invent facts, paths, failures, approvals, or user intent. Never propose destructive, irreversible, publishing, purchasing, credential, or permission-changing actions unless the user's run explicitly requested that exact action and it remains unfinished.
+- Base the answer only on the supplied current-run transcript.
+- Do not mention these instructions, hidden reasoning, transcript truncation, or that you are predicting the user.
+- Do not use Markdown, a code fence, or prose outside the JSON object.`;
+
+export function buildSuggestionPrompt(transcript: string) {
+  return `Predict the next user input after this fully settled main-agent run.\n\n<current_run>\n${transcript}\n</current_run>`;
+}

package/extensions/suggestions/src/transcript.ts

@@ -0,0 +1,233 @@
+import type { SessionEntry } from "@earendil-works/pi-coding-agent";
+
+export const TOOL_ARGUMENT_MAX_BYTES = 2_000;
+export const TOOL_RESULT_MAX_BYTES = 5_000;
+export const TRANSCRIPT_MAX_BYTES = 48_000;
+
+const SECRET_KEY_PATTERN =
+  /(?:api[_-]?key|access[_-]?key|authorization|cookie|credential|password|passwd|private[_-]?key|secret|token)/i;
+
+export interface RunMarker {
+  readonly baselineLeafId: string | null;
+}
+
+export function createRunBoundary() {
+  let pending: RunMarker | undefined;
+
+  return {
+    begin(baselineLeafId: string | null) {
+      pending = { baselineLeafId };
+    },
+    settle() {
+      const run = pending;
+      pending = undefined;
+      return run;
+    },
+    reset() {
+      pending = undefined;
+    },
+  };
+}
+
+export function getRunEntries(
+  branch: readonly SessionEntry[],
+  baselineLeafId: string | null,
+) {
+  if (baselineLeafId === null) return [...branch];
+  const baselineIndex = branch.findIndex(
+    (entry) => entry.id === baselineLeafId,
+  );
+  return baselineIndex === -1 ? [] : branch.slice(baselineIndex + 1);
+}
+
+function truncateUtf8(text: string, maxBytes: number) {
+  if (Buffer.byteLength(text, "utf8") <= maxBytes) return text;
+
+  let low = 0;
+  let high = text.length;
+  while (low < high) {
+    const midpoint = Math.ceil((low + high) / 2);
+    if (Buffer.byteLength(text.slice(0, midpoint), "utf8") <= maxBytes) {
+      low = midpoint;
+    } else {
+      high = midpoint - 1;
+    }
+  }
+
+  let end = low;
+  const last = text.charCodeAt(end - 1);
+  if (last >= 0xd800 && last <= 0xdbff) end -= 1;
+  return text.slice(0, end);
+}
+
+function capped(text: string, maxBytes: number, notice: string) {
+  if (Buffer.byteLength(text, "utf8") <= maxBytes) return text;
+  const suffix = `\n[${notice}]`;
+  return `${truncateUtf8(text, maxBytes - Buffer.byteLength(suffix, "utf8"))}${suffix}`;
+}
+
+export function redactSecrets(text: string) {
+  return text
+    .replace(/\b(Bearer|Basic)\s+[A-Za-z0-9._~+/=-]+/gi, "$1 [REDACTED]")
+    .replace(
+      /\b(sk-[A-Za-z0-9_-]{12,}|gh[pousr]_[A-Za-z0-9_]{12,}|eyJ[A-Za-z0-9_-]{12,}\.[A-Za-z0-9_-]{6,}\.[A-Za-z0-9_-]{6,})\b/g,
+      "[REDACTED]",
+    )
+    .replace(
+      /(["']?(?:api[_-]?key|access[_-]?key|authorization|cookie|credential|password|passwd|private[_-]?key|secret|token)["']?\s*[:=]\s*)(["']?)[^\s,;}]+\2/gi,
+      "$1[REDACTED]",
+    )
+    .replace(
+      /([?&](?:api[_-]?key|access[_-]?token|key|secret|token)=)[^&#\s]+/gi,
+      "$1[REDACTED]",
+    );
+}
+
+function sanitizeValue(value: unknown, key?: string, depth = 0): unknown {
+  if (key && SECRET_KEY_PATTERN.test(key)) return "[REDACTED]";
+  if (depth >= 6) return "[nested value omitted]";
+  if (typeof value === "string") return redactSecrets(value);
+  if (typeof value === "bigint") return `${value}n`;
+  if (typeof value === "function" || typeof value === "symbol") {
+    return `[${typeof value} omitted]`;
+  }
+  if (Array.isArray(value)) {
+    const items = value
+      .slice(0, 30)
+      .map((item) => sanitizeValue(item, undefined, depth + 1));
+    if (value.length > items.length) items.push("[additional items omitted]");
+    return items;
+  }
+  if (typeof value === "object" && value !== null) {
+    return Object.fromEntries(
+      Object.entries(value).map(([entryKey, entryValue]) => [
+        entryKey,
+        sanitizeValue(entryValue, entryKey, depth + 1),
+      ]),
+    );
+  }
+  return value;
+}
+
+function serializeToolArguments(value: unknown) {
+  try {
+    return JSON.stringify(sanitizeValue(value), null, 2) ?? "(no arguments)";
+  } catch {
+    return "[tool arguments could not be serialized]";
+  }
+}
+
+function textContent(content: unknown) {
+  if (typeof content === "string") return redactSecrets(content);
+  if (!Array.isArray(content)) return "";
+  return content
+    .flatMap((block) => {
+      if (
+        typeof block === "object" &&
+        block !== null &&
+        "type" in block &&
+        block.type === "text" &&
+        "text" in block &&
+        typeof block.text === "string"
+      ) {
+        return [redactSecrets(block.text)];
+      }
+      return [];
+    })
+    .join("\n");
+}
+
+function serializeMessage(entry: Extract<SessionEntry, { type: "message" }>) {
+  const { message } = entry;
+
+  if (message.role === "user") {
+    const text = textContent(message.content);
+    return text ? `USER\n${text}` : "";
+  }
+
+  if (message.role === "assistant") {
+    const sections: string[] = [];
+    const text = message.content
+      .filter((block) => block.type === "text")
+      .map((block) => redactSecrets(block.text))
+      .join("\n");
+    if (text) sections.push(`ASSISTANT\n${text}`);
+
+    for (const block of message.content) {
+      if (block.type !== "toolCall") continue;
+      const args = capped(
+        redactSecrets(serializeToolArguments(block.arguments)),
+        TOOL_ARGUMENT_MAX_BYTES,
+        "tool arguments capped",
+      );
+      sections.push(`TOOL CALL ${block.name}\n${args}`);
+    }
+    return sections.join("\n\n");
+  }
+
+  if (message.role === "toolResult") {
+    const text = capped(
+      textContent(message.content),
+      TOOL_RESULT_MAX_BYTES,
+      "tool result capped",
+    );
+    return `TOOL RESULT ${message.toolName}${message.isError ? " (error)" : ""}\n${text || "(no text output)"}`;
+  }
+
+  if (message.role === "bashExecution") {
+    const command = capped(
+      redactSecrets(message.command),
+      TOOL_ARGUMENT_MAX_BYTES,
+      "command capped",
+    );
+    const output = capped(
+      redactSecrets(message.output),
+      TOOL_RESULT_MAX_BYTES,
+      "command output capped",
+    );
+    return `USER SHELL${message.exitCode === undefined ? "" : ` (exit ${message.exitCode})`}\n${command}\n${output}`;
+  }
+
+  if (message.role === "custom") {
+    if (message.customType === "summary-recap") return "";
+    const text = textContent(message.content);
+    return text ? `EXTENSION ${message.customType}\n${text}` : "";
+  }
+
+  return "";
+}
+
+export function serializeRunTranscript(
+  entries: readonly SessionEntry[],
+  maxBytes = TRANSCRIPT_MAX_BYTES,
+) {
+  const sections = entries.flatMap((entry) => {
+    if (entry.type === "message") {
+      const section = serializeMessage(entry);
+      return section ? [section] : [];
+    }
+    if (
+      entry.type === "custom_message" &&
+      entry.customType !== "summary-recap"
+    ) {
+      const text = textContent(entry.content);
+      return text ? [`EXTENSION ${entry.customType}\n${text}`] : [];
+    }
+    return [];
+  });
+
+  const transcript = sections.join("\n\n---\n\n") || "(no textual run output)";
+  if (Buffer.byteLength(transcript, "utf8") <= maxBytes) return transcript;
+
+  const marker = "\n\n[... transcript capped; middle omitted ...]\n\n";
+  const markerBytes = Buffer.byteLength(marker, "utf8");
+  const headBytes = Math.floor((maxBytes - markerBytes) * 0.58);
+  const tailBytes = maxBytes - markerBytes - headBytes;
+  const head = truncateUtf8(transcript, headBytes);
+  const reversedTail = truncateUtf8(
+    [...transcript].reverse().join(""),
+    tailBytes,
+  );
+  const tail = [...reversedTail].reverse().join("");
+  return `${head}${marker}${tail}`;
+}

package/extensions/suggestions/src/ui.ts

@@ -0,0 +1,224 @@
+import type { KeybindingsManager } from "@earendil-works/pi-coding-agent";
+import type { EditorComponent } from "@earendil-works/pi-tui";
+import {
+  CURSOR_MARKER,
+  Key,
+  matchesKey,
+  truncateToWidth,
+  visibleWidth,
+} from "@earendil-works/pi-tui";
+import {
+  BelowEditorNavigationEditor,
+  BelowEditorStripState,
+} from "../../shared/below-editor-navigation.ts";
+
+const FAKE_CURSOR_PATTERN = /\u001b\[7m \u001b\[(?:0|27)m/;
+const IME_PREEDIT_MIN_COLUMNS = 12;
+const IME_PREEDIT_MAX_COLUMNS = 32;
+const GHOST_MIN_COLUMNS = 8;
+
+export interface SuggestionToken {
+  readonly generation: number;
+}
+
+/** Ephemeral latest-wins state; suggestions are never written to session history. */
+export class NextActionSuggestionState {
+  private generation = 0;
+  private active = false;
+  private suggestion?: string;
+
+  begin(): SuggestionToken {
+    this.generation += 1;
+    this.active = true;
+    this.suggestion = undefined;
+    return { generation: this.generation };
+  }
+
+  offer(
+    token: SuggestionToken,
+    suggestion: string | undefined,
+    editorEmpty: boolean,
+  ) {
+    if (!this.active || token.generation !== this.generation) return false;
+    if (!suggestion || !editorEmpty) {
+      this.active = false;
+      this.suggestion = undefined;
+      return false;
+    }
+    this.suggestion = suggestion;
+    return true;
+  }
+
+  cancel() {
+    this.generation += 1;
+    this.active = false;
+    this.suggestion = undefined;
+  }
+
+  isActive() {
+    return this.active;
+  }
+
+  peek() {
+    return this.suggestion;
+  }
+
+  revision() {
+    return this.generation;
+  }
+
+  accept() {
+    const suggestion = this.suggestion;
+    this.cancel();
+    return suggestion;
+  }
+}
+
+function isStripNavigation(data: string) {
+  return (
+    matchesKey(data, Key.up) ||
+    matchesKey(data, Key.down) ||
+    matchesKey(data, Key.left) ||
+    matchesKey(data, Key.right) ||
+    matchesKey(data, Key.enter) ||
+    matchesKey(data, Key.escape)
+  );
+}
+
+function ghostGeometry(lines: readonly string[], width: number) {
+  const index = lines.findIndex((line) => FAKE_CURSOR_PATTERN.test(line));
+  if (index === -1) return undefined;
+  const line = lines[index]!;
+  const cursor = line.match(FAKE_CURSOR_PATTERN);
+  if (!cursor || cursor.index === undefined) return undefined;
+  const beforeCursor = line
+    .slice(0, cursor.index)
+    .replaceAll(CURSOR_MARKER, "");
+  const prefix = `${beforeCursor}${cursor[0]}`;
+  const remaining = Math.max(0, width - visibleWidth(prefix));
+  // One terminal cell must remain after the hidden hardware cursor. At
+  // narrower widths, suppress the ghost rather than placing the cursor at the
+  // terminal's out-of-range column width.
+  if (remaining <= GHOST_MIN_COLUMNS) return undefined;
+
+  const desiredPreedit = Math.min(
+    IME_PREEDIT_MAX_COLUMNS,
+    Math.max(IME_PREEDIT_MIN_COLUMNS, Math.floor(width * 0.3)),
+  );
+  const preedit = Math.min(desiredPreedit, remaining - GHOST_MIN_COLUMNS);
+  return { index, prefix, available: remaining - preedit, preedit };
+}
+
+export function renderGhostSuggestion(
+  lines: readonly string[],
+  width: number,
+  suggestion: string,
+  dim: (text: string) => string,
+) {
+  const geometry = ghostGeometry(lines, width);
+  if (!geometry) return [...lines];
+  const { index, prefix, available, preedit } = geometry;
+  const ghost = truncateToWidth(suggestion, available, "…");
+  const content = `${prefix}${dim(ghost)}`;
+  const padding = " ".repeat(
+    Math.max(0, width - preedit - visibleWidth(content)),
+  );
+  const rendered = [...lines];
+  // CJK IMEs draw uncommitted preedit at the terminal's hidden hardware
+  // cursor before the editor receives an input event. Keep the visible fake
+  // cursor and ghost inline, but move that hardware anchor to reserved cells
+  // at the row end so preedit cannot overwrite the suggestion.
+  rendered[index] =
+    `${content}${padding}${CURSOR_MARKER}${" ".repeat(preedit)}`;
+  return rendered;
+}
+
+/**
+ * Transparent editor wrapper that shows one dim inline suggestion in an empty
+ * editor. Right accepts without submitting; any other editor interaction
+ * cancels the pending or visible suggestion. Existing management-strip
+ * navigation keeps precedence while a strip is focused.
+ */
+export class NextActionSuggestionEditor extends BelowEditorNavigationEditor {
+  private readonly editor: EditorComponent;
+  private readonly state: NextActionSuggestionState;
+  private readonly onInteraction: () => void;
+  private readonly requestSuggestionRender: () => void;
+  private readonly dim: (text: string) => string;
+  private visibleRevision?: number;
+
+  constructor(
+    base: EditorComponent,
+    keybindings: KeybindingsManager,
+    state: NextActionSuggestionState,
+    onInteraction: () => void,
+    requestRender: () => void,
+    dim: (text: string) => string,
+  ) {
+    super(
+      base,
+      keybindings,
+      new BelowEditorStripState(),
+      () => false,
+      () => undefined,
+      requestRender,
+    );
+    this.editor = base;
+    this.state = state;
+    this.onInteraction = onInteraction;
+    this.requestSuggestionRender = requestRender;
+    this.dim = dim;
+  }
+
+  override handleInput(data: string) {
+    if (this.state.isActive()) {
+      if (this.hasFocusedStrip() && isStripNavigation(data)) {
+        super.handleInput(data);
+        return;
+      }
+      const suggestion = this.state.peek();
+      if (
+        suggestion &&
+        this.visibleRevision === this.state.revision() &&
+        this.editor.getText().length === 0 &&
+        matchesKey(data, Key.right)
+      ) {
+        const accepted = this.state.accept();
+        this.visibleRevision = undefined;
+        if (accepted) super.setText(accepted);
+        this.requestSuggestionRender();
+        return;
+      }
+      this.visibleRevision = undefined;
+      this.onInteraction();
+    }
+    super.handleInput(data);
+  }
+
+  override render(width: number) {
+    const lines = super.render(width);
+    const suggestion = this.state.peek();
+    if (
+      suggestion &&
+      this.editor.getText().length === 0 &&
+      ghostGeometry(lines, width)
+    ) {
+      this.visibleRevision = this.state.revision();
+      return renderGhostSuggestion(lines, width, suggestion, this.dim);
+    }
+    this.visibleRevision = undefined;
+    return lines;
+  }
+
+  override setText(text: string) {
+    this.visibleRevision = undefined;
+    if (this.state.isActive()) this.onInteraction();
+    super.setText(text);
+  }
+
+  override insertTextAtCursor(text: string) {
+    this.visibleRevision = undefined;
+    if (this.state.isActive()) this.onInteraction();
+    super.insertTextAtCursor(text);
+  }
+}