shariq-pi-extensions 0.1.0

package/extensions/subagents/src/ui/transcript.ts

@@ -0,0 +1,182 @@
+/**
+ * Transcript rendering for the takeover view: turns a SubagentSnapshot's
+ * normalized transcript + live state into plain wrapped lines. Ported from
+ * v1, with the session-poking replaced by snapshot reads.
+ */
+
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import {
+  truncateToWidth,
+  visibleWidth,
+  wrapTextWithAnsi,
+} from "@earendil-works/pi-tui";
+import type { SubagentSnapshot, TranscriptItem } from "../domain.ts";
+
+const ANSI_PATTERN =
+  // eslint-disable-next-line no-control-regex
+  /[\u001B\u009B][[\]()#;?]*(?:(?:(?:[a-zA-Z\d]*(?:;[a-zA-Z\d]*)*)?\u0007)|(?:(?:\d{1,4}(?:;\d{0,4})*)?[\dA-PR-TZcf-nq-uy=><~]))/g;
+
+/**
+ * Strip raw ANSI codes, expand tabs, and drop control chars. Terminal-expanded
+ * tabs (and stray escapes) make lines wider than the width we declare to the
+ * TUI, which desyncs the renderer and smears the overlay.
+ */
+export function sanitizeText(text: string): string {
+  return text
+    .replace(ANSI_PATTERN, "")
+    .replaceAll("\t", "  ")
+    .replace(/[\u0000-\u0008\u000b-\u001f\u007f]/g, "");
+}
+
+function renderUserText(
+  theme: Theme,
+  text: string,
+  width: number,
+  out: string[],
+) {
+  const clean = sanitizeText(text).trim();
+  if (!clean) return;
+  const wrapped = wrapTextWithAnsi(clean, Math.max(10, width - 2));
+  for (let i = 0; i < wrapped.length; i++) {
+    const prefix = i === 0 ? theme.fg("accent", "> ") : "  ";
+    out.push(
+      truncateToWidth(prefix + theme.fg("userMessageText", wrapped[i]), width),
+    );
+  }
+}
+
+function renderThinking(
+  theme: Theme,
+  text: string,
+  width: number,
+  out: string[],
+) {
+  const reasoning = sanitizeText(text).trim();
+  if (!reasoning) return;
+  const prefix = theme.fg("dim", "~ ");
+  const wrapped = wrapTextWithAnsi(reasoning, Math.max(10, width - 2));
+  for (let i = 0; i < wrapped.length; i++) {
+    out.push(
+      truncateToWidth(
+        (i === 0 ? prefix : "  ") + theme.fg("muted", theme.italic(wrapped[i])),
+        width,
+      ),
+    );
+  }
+}
+
+function renderAssistantItem(
+  theme: Theme,
+  item: Extract<TranscriptItem, { kind: "assistant" }>,
+  width: number,
+  out: string[],
+) {
+  for (const part of item.parts) {
+    if (part.type === "text") {
+      const text = sanitizeText(part.text).trim();
+      if (!text) continue;
+      out.push(...wrapTextWithAnsi(text, width));
+    } else if (part.type === "thinking") {
+      renderThinking(
+        theme,
+        part.redacted ? "[redacted reasoning]" : part.text,
+        width,
+        out,
+      );
+    } else if (part.type === "toolCall") {
+      const preview = part.argsPreview ? sanitizeText(part.argsPreview) : "";
+      const line =
+        theme.fg("muted", "→ ") +
+        theme.fg("toolTitle", part.name) +
+        (preview && preview !== "{}" ? theme.fg("dim", ` ${preview}`) : "");
+      out.push(truncateToWidth(line, width));
+    }
+  }
+}
+
+function renderToolResultItem(
+  theme: Theme,
+  item: Extract<TranscriptItem, { kind: "toolResult" }>,
+  width: number,
+  out: string[],
+) {
+  const firstLine =
+    sanitizeText(item.outputPreview ?? "")
+      .split("\n")
+      .find((line) => line.trim()) ?? "";
+  const label = item.isError
+    ? theme.fg("error", "  error: ")
+    : theme.fg("dim", "  output: ");
+  out.push(
+    truncateToWidth(label + theme.fg("dim", firstLine || "(no output)"), width),
+  );
+}
+
+/** Render a subagent's conversation as plain lines, wrapped to `width`. */
+export function buildTranscriptLines(
+  snap: SubagentSnapshot,
+  width: number,
+  theme: Theme,
+): string[] {
+  const out: string[] = [];
+
+  for (const item of snap.transcript) {
+    const before = out.length;
+    if (item.kind === "user") {
+      renderUserText(theme, item.text, width, out);
+    } else if (item.kind === "assistant") {
+      renderAssistantItem(theme, item, width, out);
+    } else {
+      renderToolResultItem(theme, item, width, out);
+    }
+    if (out.length > before) out.push("");
+  }
+  while (out.length > 0 && out[out.length - 1] === "") out.pop();
+
+  // Live streaming assistant buffers (cleared when the finalized message lands).
+  if (snap.liveAssistant) {
+    const { thinking, text } = snap.liveAssistant;
+    const before = out.length;
+    if (out.length > 0) out.push("");
+    if (thinking.trim()) renderThinking(theme, thinking, width, out);
+    if (text.trim())
+      out.push(...wrapTextWithAnsi(sanitizeText(text).trim(), width));
+    if (out.length === before + 1) out.pop();
+  }
+
+  // Live tool executions (present until the ToolEnd lands in the transcript).
+  for (const tool of snap.liveTools) {
+    if (out.length > 0) out.push("");
+    const marker = tool.done
+      ? tool.isError
+        ? theme.fg("error", "error")
+        : theme.fg("success", "done")
+      : theme.fg("warning", "running");
+    let line = `${theme.fg("toolTitle", tool.name)} · ${marker}`;
+    const preview = tool.outputPreview && sanitizeText(tool.outputPreview);
+    if (preview) line += theme.fg("dim", ` · ${preview}`);
+    out.push(truncateToWidth(line, width));
+  }
+
+  // Queued steering/follow-up messages: show them immediately so Enter
+  // visibly acknowledges the user's input instead of appearing to do nothing.
+  for (const message of snap.queued) {
+    if (out.length > 0) out.push("");
+    const prefix = theme.fg("warning", `> [queued ${message.kind}] `);
+    const wrapped = wrapTextWithAnsi(
+      sanitizeText(message.text),
+      Math.max(10, width - visibleWidth(prefix)),
+    );
+    for (let i = 0; i < wrapped.length; i++) {
+      out.push(
+        truncateToWidth(
+          (i === 0 ? prefix : " ".repeat(visibleWidth(prefix))) +
+            theme.fg("muted", wrapped[i]),
+          width,
+        ),
+      );
+    }
+  }
+
+  return out;
+}

package/extensions/subagents/src/worktree.ts

@@ -0,0 +1,175 @@
+import { createHash, randomUUID } from "node:crypto";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
+
+export interface WorktreeInfo {
+  baseCwd: string;
+  repoRoot: string;
+  path: string;
+  branch: string;
+  /** Commit from which the isolated branch was created. Optional for v1 records. */
+  baseCommit?: string;
+}
+
+export const WORKTREE_ACTIONS = ["inspect", "patch", "cherry-pick", "merge", "discard"] as const;
+export type WorktreeAction = (typeof WORKTREE_ACTIONS)[number];
+
+type Exec = ExtensionAPI["exec"];
+
+function commandError(command: string, result: { code: number | null; stderr: string; stdout: string }) {
+  const detail = (result.stderr || result.stdout).trim();
+  return new Error(`${command} failed${detail ? `: ${detail}` : ""}`);
+}
+
+async function checked(exec: Exec, command: string, args: string[]) {
+  const result = await exec(command, args);
+  if (result.code !== 0) throw commandError(`${command} ${args.join(" ")}`, result);
+  return result.stdout.trim();
+}
+
+export async function createAgentWorktree(exec: Exec, cwd: string, label: string): Promise<WorktreeInfo> {
+  const repoRoot = await checked(exec, "git", ["-C", cwd, "rev-parse", "--show-toplevel"]);
+  const sourceStatus = await checked(exec, "git", ["-C", repoRoot, "status", "--porcelain", "--untracked-files=all"]);
+  if (sourceStatus) {
+    throw new Error(
+      "Worktree isolation requires a clean source checkout because isolated branches start from HEAD and cannot safely inherit uncommitted changes. Commit or stash the changes, or use the shared workspace.",
+    );
+  }
+  const baseCommit = await checked(exec, "git", ["-C", cwd, "rev-parse", "HEAD"]);
+  const repoHash = createHash("sha256").update(repoRoot).digest("hex").slice(0, 12);
+  const slug = label.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 40) || "agent";
+  const suffix = randomUUID().slice(0, 8);
+  const worktreePath = path.join(getAgentDir(), "subagent-worktrees", repoHash, `${slug}-${suffix}`);
+  const branch = `pi-subagent/${slug}-${suffix}`;
+  fs.mkdirSync(path.dirname(worktreePath), { recursive: true });
+  const result = await exec("git", ["-C", repoRoot, "worktree", "add", "-b", branch, worktreePath, baseCommit]);
+  if (result.code !== 0) throw commandError("git worktree add", result);
+  return { baseCwd: cwd, repoRoot, path: worktreePath, branch, baseCommit };
+}
+
+export async function discardAgentWorktree(exec: Exec, info: WorktreeInfo) {
+  const remove = await exec("git", ["-C", info.repoRoot, "worktree", "remove", "--force", info.path]);
+  if (remove.code !== 0) throw commandError("git worktree remove", remove);
+  const branch = await exec("git", ["-C", info.repoRoot, "branch", "-D", info.branch]);
+  if (branch.code !== 0) throw commandError("git branch -D", branch);
+}
+
+export async function inspectAgentWorktree(exec: Exec, info: WorktreeInfo) {
+  const baseCommit = info.baseCommit ?? await checked(exec, "git", ["-C", info.repoRoot, "merge-base", "HEAD", info.branch]);
+  const status = await checked(exec, "git", ["-C", info.path, "status", "--porcelain"]);
+  const names = await checked(exec, "git", ["-C", info.path, "diff", "--name-only", baseCommit]);
+  const untracked = status.split(/\r?\n/).filter((line) => line.startsWith("?? ")).map((line) => line.slice(3));
+  const commitsText = await checked(exec, "git", ["-C", info.repoRoot, "rev-list", "--reverse", `${baseCommit}..${info.branch}`]);
+  return {
+    baseCommit,
+    dirty: !!status,
+    files: [...new Set([...names.split(/\r?\n/).filter(Boolean), ...untracked])],
+    commits: commitsText.split(/\r?\n/).filter(Boolean),
+  };
+}
+
+export async function applyAgentWorktreeTo(
+  exec: Exec,
+  info: WorktreeInfo,
+  targetCwd: string,
+) {
+  const mark = await exec("git", ["-C", info.path, "add", "-N", "--", "."]);
+  if (mark.code !== 0) throw commandError("git add -N", mark);
+  const baseCommit = info.baseCommit ?? await checked(exec, "git", ["-C", info.repoRoot, "merge-base", "HEAD", info.branch]);
+  const diff = await exec("git", ["-C", info.path, "diff", "--binary", baseCommit]);
+  if (diff.code !== 0) throw commandError("git diff", diff);
+  if (!diff.stdout.trim()) return { action: "patch" as const, changed: false, files: [] as string[] };
+
+  const names = await checked(exec, "git", ["-C", info.path, "diff", "--name-only", baseCommit]);
+  const patchPath = path.join(getAgentDir(), "subagent-worktrees", `.apply-${randomUUID()}.patch`);
+  fs.writeFileSync(patchPath, diff.stdout, { mode: 0o600 });
+  try {
+    const check = await exec("git", ["-C", targetCwd, "apply", "--check", "--whitespace=nowarn", patchPath]);
+    if (check.code !== 0) throw commandError("git apply --check", check);
+    const apply = await exec("git", ["-C", targetCwd, "apply", "--whitespace=nowarn", patchPath]);
+    if (apply.code !== 0) throw commandError("git apply", apply);
+  } finally {
+    fs.rmSync(patchPath, { force: true });
+  }
+  return { action: "patch" as const, changed: true, files: names.split(/\r?\n/).filter(Boolean) };
+}
+
+export function applyAgentWorktree(exec: Exec, info: WorktreeInfo) {
+  return applyAgentWorktreeTo(exec, info, info.repoRoot);
+}
+
+async function commitDirtyWorktree(exec: Exec, info: WorktreeInfo, label: string) {
+  const status = await checked(exec, "git", ["-C", info.path, "status", "--porcelain"]);
+  if (!status) return;
+  await checked(exec, "git", ["-C", info.path, "add", "-A", "--", "."]);
+  await checked(exec, "git", [
+    "-C", info.path,
+    "-c", "user.name=Pi Subagent",
+    "-c", "user.email=pi-subagent@localhost",
+    "commit", "-m", `Apply ${label} subagent changes`,
+  ]);
+}
+
+async function ensureCleanSource(exec: Exec, info: WorktreeInfo) {
+  const status = await checked(exec, "git", ["-C", info.repoRoot, "status", "--porcelain"]);
+  if (status) {
+    throw new Error("The source repository must be clean for cherry-pick or merge. Use action=patch to preserve unrelated working-tree changes.");
+  }
+}
+
+async function integrationArgs(
+  exec: Exec,
+  info: WorktreeInfo,
+  action: "cherry-pick" | "merge",
+) {
+  const inspected = await inspectAgentWorktree(exec, info);
+  if (inspected.commits.length === 0) return { inspected, args: [] as string[] };
+  if (action === "merge") return { inspected, args: ["merge", "--no-ff", "--no-edit", info.branch] };
+  return { inspected, args: ["cherry-pick", ...inspected.commits] };
+}
+
+/** Preflight commit-aware integration in a temporary worktree before touching the source checkout. */
+export async function integrateAgentWorktree(
+  exec: Exec,
+  info: WorktreeInfo,
+  action: "cherry-pick" | "merge",
+  label: string,
+) {
+  await ensureCleanSource(exec, info);
+  await commitDirtyWorktree(exec, info, label);
+  const { inspected, args } = await integrationArgs(exec, info, action);
+  if (args.length === 0) {
+    return { action, changed: false, files: inspected.files, commits: [] as string[] };
+  }
+
+  const preflightPath = path.join(getAgentDir(), "subagent-worktrees", `.preflight-${randomUUID()}`);
+  fs.mkdirSync(path.dirname(preflightPath), { recursive: true });
+  await checked(exec, "git", ["-C", info.repoRoot, "worktree", "add", "--detach", preflightPath, "HEAD"]);
+  try {
+    const preflight = await exec("git", [
+      "-C", preflightPath,
+      "-c", "user.name=Pi Subagent",
+      "-c", "user.email=pi-subagent@localhost",
+      ...args,
+    ]);
+    if (preflight.code !== 0) {
+      throw new Error(`Preflight found ${action} conflicts; the source repository was not changed. ${(preflight.stderr || preflight.stdout).trim()}`);
+    }
+  } finally {
+    await exec("git", ["-C", info.repoRoot, "worktree", "remove", "--force", preflightPath]);
+  }
+
+  const applied = await exec("git", [
+    "-C", info.repoRoot,
+    "-c", "user.name=Pi Subagent",
+    "-c", "user.email=pi-subagent@localhost",
+    ...args,
+  ]);
+  if (applied.code !== 0) {
+    await exec("git", ["-C", info.repoRoot, action === "merge" ? "merge" : "cherry-pick", "--abort"]);
+    throw commandError(`git ${action}`, applied);
+  }
+  return { action, changed: true, files: inspected.files, commits: inspected.commits };
+}

package/extensions/web-fetch/README.md

@@ -0,0 +1,13 @@
+# Web Fetch
+
+Pi local extension that registers `web_fetch`, a read-only exact-URL retrieval tool.
+
+Use `web_search` for discovery and `web_fetch` for retrieval from a specific URL.
+
+Parameters:
+
+- `url` — required `http://` or `https://` URL
+- `format` — `markdown` (default), `text`, or `html`
+- `timeoutSeconds` — default 30, max 120
+- `maxBytes` — default 5 MiB, max 25 MiB
+- `userAgent` — optional override