@tt-a1i/openpi 0.4.0 → 0.6.0

package/extensions/subagents/src/ui/wait-result.ts

@@ -3,8 +3,12 @@ import {
   keyHint,
   type Theme,
 } from "@earendil-works/pi-coding-agent";
-import { Markdown, Text } from "@earendil-works/pi-tui";
-import { sanitizeText } from "./transcript.ts";
+import {
+  type Component,
+  Markdown,
+  truncateToWidth,
+} from "@earendil-works/pi-tui";
+import { sanitizeText } from "../../../shared/agent-transcript.ts";
 
 const MAX_STATUS_ROWS = 4;
 
@@ -12,40 +16,116 @@ export interface WaitResultItem {
   readonly id: string;
   readonly title?: string;
   readonly status?: string;
+  readonly outcome?: "completed" | "failed" | "interrupted";
+  readonly worktreeBranch?: string;
+  readonly elapsed?: string;
+  readonly artifactSaveFailed?: boolean;
+  readonly fullResultSaved?: boolean;
 }
 
 export interface WaitResultDetails {
   readonly results?: readonly WaitResultItem[];
 }
 
+function singleLine(value: string) {
+  return sanitizeText(value).replace(/\s+/gu, " ").trim();
+}
+
+function fixedRows(rows: readonly string[]): Component {
+  return {
+    render(width) {
+      return rows.map((row) => truncateToWidth(row, Math.max(1, width), "…"));
+    },
+    invalidate() {},
+  };
+}
+
+function selectStatusRows(results: readonly WaitResultItem[]) {
+  const visible = results.slice(0, MAX_STATUS_ROWS);
+  if (visible.some((result) => result.status === "error")) {
+    return visible;
+  }
+
+  const hiddenFailure = results
+    .slice(MAX_STATUS_ROWS)
+    .find((result) => result.status === "error");
+  return hiddenFailure ? [...visible.slice(0, -1), hiddenFailure] : visible;
+}
+
 export function buildWaitResultPreview(
   content: string,
   details: WaitResultDetails | undefined,
   theme: Theme,
 ) {
   const results = details?.results ?? [];
-  const failed = results.filter((result) => result.status === "error").length;
+  const uncertain = results.filter(
+    (result) => result.outcome === "interrupted",
+  ).length;
+  const failed = results.filter(
+    (result) => result.status === "error" && result.outcome !== "interrupted",
+  ).length;
+  const artifactFailures = results.filter(
+    (result) => result.artifactSaveFailed,
+  ).length;
+  const exceptions = [
+    failed > 0 ? theme.fg("error", `${failed} failed`) : "",
+    uncertain > 0 ? theme.fg("warning", `${uncertain} uncertain`) : "",
+  ].filter(Boolean);
   const header =
-    theme.fg(failed > 0 ? "warning" : "success", failed > 0 ? "!" : "✓") +
-    ` ${theme.fg("accent", theme.bold(`${results.length} subagent${results.length === 1 ? "" : "s"} settled`))}` +
-    (failed > 0 ? theme.fg("error", ` · ${failed} failed`) : "");
+    theme.fg(
+      failed > 0 || uncertain > 0 ? "warning" : "success",
+      failed > 0 || uncertain > 0 ? "!" : "✓",
+    ) +
+    ` ${exceptions.length > 0 ? `${exceptions.join(" · ")} · ` : ""}` +
+    theme.fg(
+      "accent",
+      theme.bold(
+        `${results.length} subagent${results.length === 1 ? "" : "s"} settled`,
+      ),
+    ) +
+    (artifactFailures > 0
+      ? theme.fg(
+          "warning",
+          ` · ${artifactFailures} artifact${artifactFailures === 1 ? "" : "s"} not saved`,
+        )
+      : "");
   const lines = [header];
+  const statusRows = selectStatusRows(results);
 
-  for (const result of results.slice(0, MAX_STATUS_ROWS)) {
-    const isFailure = result.status === "error";
+  for (const result of statusRows) {
+    const isUncertain = result.outcome === "interrupted";
+    const isFailure = result.status === "error" && !isUncertain;
     const icon = theme.fg(
-      isFailure ? "error" : "success",
-      isFailure ? "x" : "✓",
+      isFailure ? "error" : isUncertain ? "warning" : "success",
+      isFailure ? "x" : isUncertain ? "?" : "✓",
     );
+    const id = singleLine(result.id);
+    const title = result.title ? singleLine(result.title) : "";
+    const status = isUncertain
+      ? "uncertain"
+      : singleLine(result.status ?? "settled");
+    const elapsed = result.elapsed ? singleLine(result.elapsed) : "";
+    const notices = [
+      result.artifactSaveFailed ? "artifact not saved" : "",
+      result.worktreeBranch
+        ? `worktree handoff · ${singleLine(result.worktreeBranch)}`
+        : "",
+      result.fullResultSaved ? "full result saved" : "",
+    ].filter(Boolean);
+    const attention = notices.length
+      ? theme.fg("warning", `${notices.join(" · ")} · `)
+      : "";
     lines.push(
-      `  ${icon} ${theme.fg("accent", result.id)}${result.title ? theme.fg("muted", ` · ${result.title}`) : ""}${theme.fg("dim", ` · ${result.status ?? "settled"}`)}`,
+      `  ${icon} ${attention}${theme.fg("accent", id)}${title ? theme.fg("muted", ` · ${title}`) : ""}${theme.fg("dim", ` · ${status}${elapsed ? ` · ${elapsed}` : ""}`)}`,
     );
   }
-  if (results.length > MAX_STATUS_ROWS) {
-    lines.push(theme.fg("dim", `  … ${results.length - MAX_STATUS_ROWS} more`));
+  if (results.length > statusRows.length) {
+    lines.push(
+      theme.fg("dim", `  … ${results.length - statusRows.length} more`),
+    );
   }
 
-  if (content.trim()) {
+  if (sanitizeText(content).trim()) {
     lines.push(
       theme.fg(
         "dim",
@@ -56,6 +136,14 @@ export function buildWaitResultPreview(
   return lines.join("\n");
 }
 
+export function renderWaitResultPreview(
+  content: string,
+  details: WaitResultDetails | undefined,
+  theme: Theme,
+) {
+  return fixedRows(buildWaitResultPreview(content, details, theme).split("\n"));
+}
+
 export function renderWaitResult(
   content: string,
   details: WaitResultDetails | undefined,
@@ -63,7 +151,7 @@ export function renderWaitResult(
   theme: Theme,
 ) {
   if (!expanded) {
-    return new Text(buildWaitResultPreview(content, details, theme), 0, 0);
+    return renderWaitResultPreview(content, details, theme);
   }
 
   const markdown = new Markdown(

package/extensions/suggestions/src/ui.ts

@@ -13,6 +13,10 @@ import {
 } from "../../shared/below-editor-navigation.ts";
 
 const FAKE_CURSOR_PATTERN = /\u001b\[7m \u001b\[(?:0|27)m/;
+// Conservative idle-row band for terminal-owned CJK IME preedit. Pi's editor
+// contract exposes only committed input, never a composition event, so the
+// reservation cannot shrink to the frames that actually need it. A 1-cell
+// hardware-cursor pad lets long preedit cover or truncate the ghost.
 const IME_PREEDIT_MIN_COLUMNS = 12;
 const IME_PREEDIT_MAX_COLUMNS = 32;
 const GHOST_MIN_COLUMNS = 8;
@@ -96,10 +100,12 @@ function ghostGeometry(lines: readonly string[], width: number) {
     .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;
+  // Keep enough cells for a readable ghost and a conservative IME preedit
+  // band. At narrower widths, suppress the ghost rather than placing the
+  // hidden hardware cursor at the terminal's out-of-range column width.
+  if (remaining < GHOST_MIN_COLUMNS + IME_PREEDIT_MIN_COLUMNS) {
+    return undefined;
+  }
 
   const desiredPreedit = Math.min(
     IME_PREEDIT_MAX_COLUMNS,

package/extensions/tasks/index.ts

@@ -34,7 +34,6 @@ import {
   type TaskToolDetails,
 } from "./ui.ts";
 
-const TOOL_NAMES = ["tasks_add", "tasks_update", "tasks_list"] as const;
 const TASK_WIDGET_KEY = "session-tasks-panel";
 const CONFLICT_NAMES = new Set(["todo", "TodoWrite", "update_plan"]);
 const TOOL_PURPOSE =
@@ -542,8 +541,6 @@ export default function sessionTasks(pi: ExtensionAPI) {
   });
 }
 
-export { TOOL_NAMES as TASK_TOOL_NAMES };
-
 function mutationWillCloseBatch(
   snapshot: TaskSnapshot,
   id: number,

package/extensions/ui-customization/footer.ts

@@ -1,5 +1,5 @@
 import { homedir } from "node:os";
-import { relative } from "node:path";
+import { posix, win32 } from "node:path";
 import type { Theme } from "@earendil-works/pi-coding-agent";
 import {
   getCapabilities,
@@ -117,10 +117,21 @@ export function formatTokens(tokens: number) {
   return `${(tokens / 1_000_000).toFixed(1)}m`;
 }
 
-export function formatDirectory(cwd: string) {
-  const home = homedir();
-  if (cwd === home) return "~";
-  const display = cwd.startsWith(`${home}/`) ? `~/${relative(home, cwd)}` : cwd;
+export function formatDirectory(
+  cwd: string,
+  home = homedir(),
+  pathModule = process.platform === "win32" ? win32 : posix,
+) {
+  const relativePath = pathModule.relative(home, cwd);
+  const outsideHome =
+    relativePath === ".." ||
+    relativePath.startsWith(`..${pathModule.sep}`) ||
+    pathModule.isAbsolute(relativePath);
+  const display = outsideHome
+    ? cwd
+    : relativePath
+      ? `~/${relativePath.replaceAll(pathModule.sep, "/")}`
+      : "~";
   return sanitizeTerminalLabel(display);
 }
 
@@ -527,43 +538,3 @@ export function renderFooter(options: FooterRenderOptions) {
 
   return lines;
 }
-
-/** Legacy helper retained for tests that assert grouped content. */
-export function buildFooterContent(
-  modelInfo: ModelInfoState,
-  gitInfo: GitInfoState,
-  selectedItems: readonly FooterItem[],
-  formatPullRequest: (number: number, url: string) => string = (number) =>
-    `PR #${number}`,
-) {
-  const items = new Set(selectedItems);
-  const catalog = buildSegmentCatalog(
-    "",
-    modelInfo,
-    gitInfo,
-    formatPullRequest,
-  );
-  return {
-    showCwd: items.has("cwd"),
-    model: [
-      items.has("model") ? catalog.model.text : "",
-      items.has("thinking") ? catalog.thinking.text : "",
-    ]
-      .filter(Boolean)
-      .join(" · "),
-    usage: [
-      items.has("context") ? catalog.context.text : "",
-      items.has("cache") ? catalog.cache.text : "",
-      items.has("cost") ? catalog.cost.text : "",
-      items.has("throughput") ? catalog.throughput.text : "",
-    ]
-      .filter(Boolean)
-      .join(" · "),
-    git: [
-      items.has("git") ? catalog.git.text : "",
-      items.has("pr") ? catalog.pr.text : "",
-    ]
-      .filter(Boolean)
-      .join(" · "),
-  };
-}

package/extensions/ui-customization/index.ts

@@ -21,13 +21,9 @@ import {
   REFRESH_CHANNEL,
   isGitInfoState,
   isModelInfoState,
-  type GitInfoState,
-  type ModelInfoState,
 } from "../shared/dashboard-state.ts";
 import { formatDirectory, renderFooter } from "./footer.ts";
 
-export { buildFooterContent, formatDirectory, renderFooter } from "./footer.ts";
-
 type Rgb = [number, number, number];
 
 const RESET = "\x1b[0m";

package/extensions/user-input-fold/index.ts

@@ -40,8 +40,35 @@ type Segment =
   | { kind: "prose"; lines: string[] }
   | { kind: "code"; open: string; content: string[]; close: string };
 
-const FENCE_OPEN = /^ {0,3}`{3,}/;
-const FENCE_CLOSE = /^ {0,3}`{3,}[ \t]*$/;
+const FENCE_OPEN = /^ {0,3}(`{3,}|~{3,})/;
+
+/**
+ * Parse an opening code fence (CommonMark §4.5): which character it uses and
+ * how long it is. A backtick fence's info string may not contain backticks.
+ */
+function openFence(line: string) {
+  const match = FENCE_OPEN.exec(line);
+  if (!match) return undefined;
+  const fence = match[1];
+  if (fence[0] === "`" && line.slice(match[0].length).includes("`")) {
+    return undefined;
+  }
+  return { char: fence[0], length: fence.length };
+}
+
+/**
+ * A closing fence must use the same character as the opening fence and be at
+ * least as long: a ``` line does not close a ```` block, and backticks never
+ * close a tilde block.
+ */
+function isCloseFence(line: string, open: { char: string; length: number }) {
+  const match = /^ {0,3}(`{3,}|~{3,})[ \t]*\r?$/.exec(line);
+  return (
+    match !== null &&
+    match[1][0] === open.char &&
+    match[1].length >= open.length
+  );
+}
 
 function countLines(markdown: string) {
   const parts = markdown.split("\n");
@@ -60,7 +87,8 @@ function parseSegments(lines: string[]): Segment[] {
   let prose: string[] = [];
   let i = 0;
   while (i < lines.length) {
-    if (!FENCE_OPEN.test(lines[i])) {
+    const fence = openFence(lines[i]);
+    if (!fence) {
       prose.push(lines[i]);
       i += 1;
       continue;
@@ -74,13 +102,21 @@ function parseSegments(lines: string[]): Segment[] {
     let close: string | undefined;
     let j = i + 1;
     while (j < lines.length && close === undefined) {
-      if (FENCE_CLOSE.test(lines[j])) close = lines[j];
+      if (isCloseFence(lines[j], fence)) close = lines[j];
       else content.push(lines[j]);
       j += 1;
     }
     if (close === undefined) {
-      // Unterminated fence: fold the whole message conservatively as text.
-      return [{ kind: "prose", lines }];
+      // Unterminated fence: the block runs to the end of the message. Keep it
+      // as a code block with a synthesized closing fence so a folded preview
+      // never leaks an unclosed fence into the TUI.
+      segments.push({
+        kind: "code",
+        open,
+        content,
+        close: fence.char.repeat(fence.length),
+      });
+      return segments;
     }
     segments.push({ kind: "code", open, content, close });
     i = j;

package/extensions/web/index.ts

@@ -0,0 +1,257 @@
+import { spawn as nodeSpawn } from "node:child_process";
+import { dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import type {
+  ExtensionAPI,
+  ExtensionCommandContext,
+} from "@earendil-works/pi-coding-agent";
+import {
+  missingPiCodingAgentDiagnostic,
+  PI_CODING_AGENT_ENTRY_ENV,
+  resolvePiCodingAgentEntry,
+} from "../../web/host/pi-coding-agent-entry.ts";
+
+const DEFAULT_SHUTDOWN_TIMEOUT_MS = 5_000;
+
+export interface WebProcess {
+  readonly exitCode: number | null;
+  readonly signalCode: NodeJS.Signals | null;
+  once(event: "error", listener: (error: Error) => void): this;
+  once(
+    event: "close",
+    listener: (code: number | null, signal: NodeJS.Signals | null) => void,
+  ): this;
+  kill(signal?: NodeJS.Signals): boolean;
+}
+
+interface SpawnWebOptions {
+  cwd: string;
+  env: NodeJS.ProcessEnv;
+  shell: false;
+  stdio: "inherit";
+}
+
+function webProcessEnvironment(
+  cwd: string,
+  piCodingAgentEntry: string | undefined,
+) {
+  const environment: NodeJS.ProcessEnv = { ...process.env, PWD: cwd };
+  delete environment.OLDPWD;
+  delete environment.INIT_CWD;
+  delete environment.PI_SESSION_ID;
+  delete environment.PI_SESSION_FILE;
+  if (piCodingAgentEntry) {
+    environment[PI_CODING_AGENT_ENTRY_ENV] = piCodingAgentEntry;
+  } else {
+    delete environment[PI_CODING_AGENT_ENTRY_ENV];
+  }
+  return environment;
+}
+
+export interface WebCommandDependencies {
+  entrypoint: string;
+  spawn(command: string, args: string[], options: SpawnWebOptions): WebProcess;
+  clearTerminal(): void;
+  holdParentSigint(): () => void;
+  resolvePiCodingAgentEntry(): string | undefined;
+  shutdownTimeoutMs: number;
+}
+
+type WebExit =
+  | { kind: "close"; code: number | null; signal: NodeJS.Signals | null }
+  | { kind: "error"; error: Error };
+
+interface ActiveWebProcess {
+  child: WebProcess;
+  closed: Promise<void>;
+}
+
+const defaultDependencies: WebCommandDependencies = {
+  entrypoint: fileURLToPath(new URL("../../bin/openpi.js", import.meta.url)),
+  spawn(command, args, options) {
+    return nodeSpawn(command, args, options);
+  },
+  clearTerminal() {
+    process.stdout.write("\u001b[2J\u001b[H");
+  },
+  holdParentSigint() {
+    const keepPiAlive = () => {};
+    process.on("SIGINT", keepPiAlive);
+    return () => process.removeListener("SIGINT", keepPiAlive);
+  },
+  resolvePiCodingAgentEntry: () =>
+    resolvePiCodingAgentEntry({ source: "host" }),
+  shutdownTimeoutMs: DEFAULT_SHUTDOWN_TIMEOUT_MS,
+};
+
+function delay(milliseconds: number) {
+  return new Promise<void>((resolve) => {
+    const timer = setTimeout(resolve, milliseconds);
+    timer.unref();
+  });
+}
+
+async function stopWebProcess(active: ActiveWebProcess, timeoutMs: number) {
+  if (active.child.exitCode !== null || active.child.signalCode !== null)
+    return;
+  active.child.kill("SIGTERM");
+  const timedOut = await Promise.race([
+    active.closed.then(() => false),
+    delay(timeoutMs).then(() => true),
+  ]);
+  if (!timedOut) return;
+  if (active.child.exitCode === null && active.child.signalCode === null) {
+    active.child.kill("SIGKILL");
+    await Promise.race([active.closed, delay(timeoutMs)]);
+  }
+}
+
+function runWebInForeground(
+  ctx: ExtensionCommandContext,
+  dependencies: WebCommandDependencies,
+  setActive: (active: ActiveWebProcess | undefined) => void,
+  isShuttingDown: () => boolean,
+  piCodingAgentEntry: string,
+) {
+  return ctx.ui.custom<WebExit>((tui, _theme, _keybindings, done) => {
+    let finished = false;
+    let tuiStopped = false;
+    let resolveClosed = () => {};
+    const closed = new Promise<void>((resolve) => {
+      resolveClosed = resolve;
+    });
+    const releaseParentSigint = dependencies.holdParentSigint();
+
+    const finish = (result: WebExit) => {
+      if (finished) return;
+      finished = true;
+      releaseParentSigint();
+      setActive(undefined);
+      resolveClosed();
+      if (tuiStopped && !isShuttingDown()) {
+        tui.start();
+        tui.requestRender(true);
+      }
+      done(result);
+    };
+
+    try {
+      tui.stop();
+      tuiStopped = true;
+      dependencies.clearTerminal();
+      const childCwd = dirname(dependencies.entrypoint);
+      const child = dependencies.spawn(
+        process.execPath,
+        [dependencies.entrypoint, "web", "--no-workspace"],
+        {
+          cwd: childCwd,
+          env: webProcessEnvironment(childCwd, piCodingAgentEntry),
+          shell: false,
+          stdio: "inherit",
+        },
+      );
+      setActive({ child, closed });
+      child.once("error", (error) => finish({ kind: "error", error }));
+      child.once("close", (code, signal) =>
+        finish({ kind: "close", code, signal }),
+      );
+    } catch (error) {
+      finish({
+        kind: "error",
+        error: error instanceof Error ? error : new Error(String(error)),
+      });
+    }
+
+    return { render: () => [], invalidate: () => {} };
+  });
+}
+
+export default function web(
+  pi: ExtensionAPI,
+  dependencies: WebCommandDependencies = defaultDependencies,
+) {
+  let active: ActiveWebProcess | undefined;
+  let running = false;
+  let shuttingDown = false;
+
+  pi.on("session_start", () => {
+    shuttingDown = false;
+  });
+
+  pi.on("session_shutdown", async () => {
+    shuttingDown = true;
+    if (active) {
+      await stopWebProcess(active, dependencies.shutdownTimeoutMs);
+    }
+  });
+
+  pi.registerCommand("web", {
+    description:
+      "Open the separate OpenPI Web Workbench in this terminal until Ctrl+C",
+    handler: async (args, ctx) => {
+      if (args.trim()) {
+        ctx.ui.notify("Usage: /web", "warning");
+        return;
+      }
+      if (ctx.mode !== "tui") {
+        ctx.ui.notify("/web requires the interactive TUI.", "warning");
+        return;
+      }
+      if (!ctx.isIdle() || ctx.hasPendingMessages()) {
+        ctx.ui.notify(
+          "Wait until the current Pi Session is idle before starting /web.",
+          "warning",
+        );
+        return;
+      }
+      if (running) {
+        ctx.ui.notify("OpenPI Web Workbench is already running.", "warning");
+        return;
+      }
+      const piCodingAgentEntry = dependencies.resolvePiCodingAgentEntry();
+      if (!piCodingAgentEntry) {
+        ctx.ui.notify(missingPiCodingAgentDiagnostic(), "error");
+        return;
+      }
+
+      running = true;
+      try {
+        const result = await runWebInForeground(
+          ctx,
+          dependencies,
+          (next) => {
+            active = next;
+          },
+          () => shuttingDown,
+          piCodingAgentEntry,
+        );
+        if (shuttingDown) return;
+        if (result.kind === "error") {
+          ctx.ui.notify(
+            `Failed to start OpenPI Web Workbench: ${result.error.message}`,
+            "error",
+          );
+          return;
+        }
+        if (result.signal !== null) {
+          ctx.ui.notify(
+            `OpenPI Web Workbench was terminated by ${result.signal}.`,
+            "error",
+          );
+          return;
+        }
+        if (result.code !== 0) {
+          ctx.ui.notify(
+            `OpenPI Web Workbench exited with code ${result.code ?? "unknown"}.`,
+            "error",
+          );
+          return;
+        }
+        ctx.ui.notify("OpenPI Web Workbench stopped.", "info");
+      } finally {
+        active = undefined;
+        running = false;
+      }
+    },
+  });
+}