pi-orchestrator-config 4.1.5

package/extensions/orchestrator/git-helpers.ts

@@ -0,0 +1,420 @@
+/**
+ * Git utility functions for enforcement and status line.
+ */
+
+import { execFile, execSync } from "node:child_process";
+
+export function runGit(
+  args: string[],
+  cwd?: string,
+): { stdout: string; code: number } {
+  try {
+    const stdout = execSync(`git --no-optional-locks ${args.join(" ")}`, {
+      cwd,
+      timeout: 5000,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"],
+      env: {
+        ...process.env,
+        GIT_TERMINAL_PROMPT: "0",
+        GCM_INTERACTIVE: "Never",
+      },
+    });
+    return { stdout: stdout.trim(), code: 0 };
+  } catch (e: any) {
+    return { stdout: (e.stdout || "").trim(), code: e.status || 1 };
+  }
+}
+
+export function getCurrentBranch(cwd?: string): string | null {
+  const r = runGit(["rev-parse", "--abbrev-ref", "HEAD"], cwd);
+  if (r.code === 0 && r.stdout && r.stdout !== "HEAD") return r.stdout;
+  const s = runGit(["symbolic-ref", "HEAD"], cwd);
+  if (s.code === 0 && s.stdout.startsWith("refs/heads/"))
+    return s.stdout.slice("refs/heads/".length);
+  return null;
+}
+
+export function getMainBranch(cwd?: string): string | null {
+  for (const b of ["main", "master"])
+    if (
+      runGit(["rev-parse", "--verify", "--end-of-options", b], cwd).code === 0
+    )
+      return b;
+  return null;
+}
+
+export function isGitRepo(cwd?: string): boolean {
+  return runGit(["rev-parse", "--git-dir"], cwd).code === 0;
+}
+
+export function isGithubRepo(cwd?: string): boolean {
+  const r = runGit(["remote", "get-url", "origin"], cwd);
+  return r.code === 0 && r.stdout.toLowerCase().includes("github.com");
+}
+
+export function isBranchMerged(branch: string, main: string, cwd?: string): boolean {
+  const u = runGit(["rev-list", "--count", `${main}..${branch}`], cwd);
+  if (u.code !== 0) return false;
+  const n = parseInt(u.stdout, 10);
+  if (isNaN(n) || n === 0) return false;
+  return runGit(["merge-base", "--is-ancestor", branch, main], cwd).code === 0;
+}
+
+export function isBranchAhead(cwd?: string): boolean {
+  if (
+    runGit(["rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}"], cwd)
+      .code !== 0
+  )
+    return true;
+  const s = runGit(["status", "--short", "--branch"], cwd);
+  return s.code === 0 && s.stdout.includes("ahead");
+}
+
+export function getPrMergeStatus(
+  branch: string,
+  cwd?: string,
+): { merged: boolean | null; info: string | null } {
+  if (!isGithubRepo(cwd)) return { merged: false, info: null };
+  try {
+    const out = execSync(
+      `gh pr list --head "${branch}" --state merged --json number --limit 1`,
+      {
+        cwd,
+        timeout: 5000,
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"],
+      },
+    );
+    const data = JSON.parse(out);
+    if (Array.isArray(data) && data.length > 0)
+      return { merged: true, info: String(data[0].number || "") };
+    return { merged: false, info: null };
+  } catch {
+    return { merged: null, info: "Could not check PR status" };
+  }
+}
+
+export type OpenPr = { number: number; url: string };
+
+const OPEN_PR_TTL_MS = 30_000;
+const OPEN_PR_CACHE_MAX = 50;
+const SAFE_PR_URL = /^https:\/\/[^\x00-\x1f]+$/;
+
+type OpenPrCacheEntry = { at: number; pr: OpenPr | null };
+const openPrCache = new Map<string, OpenPrCacheEntry>();
+const openPrInFlight = new Map<string, Promise<OpenPr | null>>();
+/** Keys with an active scheduleOpenPrStatusRefresh .then subscription. */
+const openPrSchedulePending = new Set<string>();
+
+type GhPrViewRunner = (cwd?: string) => Promise<string>;
+
+const defaultGhPrView: GhPrViewRunner = (cwd) =>
+  new Promise((resolve, reject) => {
+    execFile(
+      "gh",
+      ["pr", "view", "--json", "number,url,state"],
+      { cwd, timeout: 5000, encoding: "utf-8", maxBuffer: 1024 * 1024 },
+      (err, stdout) => {
+        if (err) reject(err);
+        else resolve(typeof stdout === "string" ? stdout : String(stdout));
+      },
+    );
+  });
+
+let ghPrViewRunner: GhPrViewRunner = defaultGhPrView;
+
+/** Override `gh pr view` runner (tests). Pass null to restore default. */
+export function setGhPrViewRunner(runner: GhPrViewRunner | null): void {
+  ghPrViewRunner = runner ?? defaultGhPrView;
+}
+
+/** Parse `gh pr view --json number,url,state` output (OPEN only). */
+export function parseOpenPrJson(out: string): OpenPr | null {
+  try {
+    const data = JSON.parse(out);
+    if (
+      data &&
+      Number.isInteger(data.number) &&
+      data.number > 0 &&
+      typeof data.url === "string" &&
+      SAFE_PR_URL.test(data.url) &&
+      data.state === "OPEN"
+    ) {
+      return { number: data.number, url: data.url };
+    }
+  } catch {
+    // invalid JSON
+  }
+  return null;
+}
+
+/** Clear open-PR cache and in-flight lookups (tests). */
+export function clearOpenPrCache(): void {
+  openPrCache.clear();
+  openPrInFlight.clear();
+  openPrSchedulePending.clear();
+}
+
+/** Seed cache entry (tests) — use past `at` to exercise TTL / SWR. */
+export function seedOpenPrCacheForTests(
+  cwd: string,
+  branch: string,
+  entry: { at: number; pr: OpenPr | null },
+): void {
+  openPrCache.set(openPrCacheKey(cwd, branch), entry);
+}
+
+/** Evict oldest keys when over max size (LRU via touch-on-hit). */
+function enforceOpenPrCacheMax(): void {
+  while (openPrCache.size > OPEN_PR_CACHE_MAX) {
+    const oldest = openPrCache.keys().next().value;
+    if (oldest === undefined) break;
+    openPrCache.delete(oldest);
+  }
+}
+
+function openPrCacheKey(cwd: string | undefined, branch: string): string {
+  return `${cwd || process.cwd()}:${branch}`;
+}
+
+function touchOpenPrCache(key: string, entry: OpenPrCacheEntry): void {
+  openPrCache.delete(key);
+  openPrCache.set(key, entry);
+  enforceOpenPrCacheMax();
+}
+
+/**
+ * Cached open PR only — never calls `gh`.
+ * Returns stale entries past TTL (stale-while-revalidate); kick
+ * {@link refreshOpenPr} to refresh asynchronously.
+ * Pass `assumeGithub: true` when the caller already verified the remote.
+ */
+export function getOpenPr(
+  cwd?: string,
+  branch?: string | null,
+  opts?: { assumeGithub?: boolean },
+): OpenPr | null {
+  const b = branch ?? getCurrentBranch(cwd);
+  if (!b) return null;
+  if (!opts?.assumeGithub && !isGithubRepo(cwd)) return null;
+
+  const key = openPrCacheKey(cwd, b);
+  const cached = openPrCache.get(key);
+  if (!cached) return null;
+  // Touch for LRU even on stale hits so hot keys survive eviction.
+  touchOpenPrCache(key, cached);
+  return cached.pr;
+}
+
+/**
+ * Async `gh pr view` for the current (or given) branch.
+ * Coalesces in-flight lookups per cwd+branch; caches result for 30s.
+ * Status-line callers must use {@link getOpenPr} synchronously and only
+ * await this to refresh — never block the update path on `gh`.
+ * Pass `assumeGithub: true` when the caller already verified the remote.
+ */
+export function refreshOpenPr(
+  cwd?: string,
+  branch?: string | null,
+  opts?: { assumeGithub?: boolean },
+): Promise<OpenPr | null> {
+  const b = branch ?? getCurrentBranch(cwd);
+  if (!b) return Promise.resolve(null);
+  if (!opts?.assumeGithub && !isGithubRepo(cwd)) return Promise.resolve(null);
+
+  const now = Date.now();
+  const key = openPrCacheKey(cwd, b);
+  const cached = openPrCache.get(key);
+  if (cached && now - cached.at < OPEN_PR_TTL_MS) {
+    touchOpenPrCache(key, cached);
+    return Promise.resolve(cached.pr);
+  }
+
+  const inflight = openPrInFlight.get(key);
+  if (inflight) return inflight;
+
+  const pending = (async (): Promise<OpenPr | null> => {
+    let pr: OpenPr | null = null;
+    try {
+      const out = await ghPrViewRunner(cwd);
+      pr = parseOpenPrJson(out.trim());
+    } catch {
+      pr = null;
+    }
+    touchOpenPrCache(key, { at: Date.now(), pr });
+    return pr;
+  })().finally(() => {
+    openPrInFlight.delete(key);
+  });
+
+  openPrInFlight.set(key, pending);
+  return pending;
+}
+
+/** True when an async open-PR refresh still matches the active cwd/branch. */
+export function shouldApplyOpenPrRefresh(
+  lastCtx: { cwd?: string } | null,
+  lastBranch: string | null,
+  refreshKey: string,
+): boolean {
+  if (!lastCtx || lastBranch == null) return false;
+  return `${lastCtx.cwd || ""}:${lastBranch}` === refreshKey;
+}
+
+export type OpenPrRefreshDecision = "skip" | "rerender";
+
+/** Decide whether a finished refresh should re-run the status-line update. */
+export function decideOpenPrRefreshRerender(args: {
+  lastCtx: { cwd?: string } | null;
+  lastBranch: string | null;
+  refreshKey: string;
+  shownKey: string;
+  fresh: OpenPr | null;
+}): OpenPrRefreshDecision {
+  if (
+    !shouldApplyOpenPrRefresh(args.lastCtx, args.lastBranch, args.refreshKey)
+  ) {
+    return "skip";
+  }
+  const freshKey = args.fresh
+    ? `${args.fresh.number}\0${args.fresh.url}`
+    : "";
+  if (freshKey === args.shownKey) return "skip";
+  return "rerender";
+}
+
+/**
+ * Status-line open-PR refresh callback wiring (no TUI deps).
+ * Schedules refreshOpenPr and optionally re-renders when the result applies.
+ */
+export function scheduleOpenPrStatusRefresh(opts: {
+  cwd?: string;
+  branch: string;
+  shownPr: OpenPr | null;
+  getState: () => {
+    lastCtx: { cwd?: string } | null;
+    lastBranch: string | null;
+  };
+  onRerender: (ctx: { cwd?: string }) => void;
+  assumeGithub?: boolean;
+  refresh?: typeof refreshOpenPr;
+}): void {
+  const refreshKey = `${opts.cwd || ""}:${opts.branch}`;
+  // One .then per in-flight key — refreshOpenPr coalesces Promises but
+  // repeated schedule calls would otherwise all fire onRerender.
+  if (openPrSchedulePending.has(refreshKey)) return;
+  openPrSchedulePending.add(refreshKey);
+
+  const shownKey = opts.shownPr
+    ? `${opts.shownPr.number}\0${opts.shownPr.url}`
+    : "";
+  const refresh = opts.refresh ?? refreshOpenPr;
+  try {
+    void refresh(opts.cwd, opts.branch, {
+      assumeGithub: opts.assumeGithub,
+    })
+      .then((fresh) => {
+        const { lastCtx, lastBranch } = opts.getState();
+        if (
+          decideOpenPrRefreshRerender({
+            lastCtx,
+            lastBranch,
+            refreshKey,
+            shownKey,
+            fresh,
+          }) !== "rerender"
+        ) {
+          return;
+        }
+        if (!lastCtx) return;
+        try {
+          opts.onRerender(lastCtx);
+        } catch (e: any) {
+          console.debug(
+            "[status-line] open-PR refresh update failed:",
+            e?.message || e,
+          );
+        }
+      })
+      .finally(() => {
+        openPrSchedulePending.delete(refreshKey);
+      })
+      .catch((e: any) => {
+        console.debug(
+          "[status-line] open-PR refresh failed:",
+          refreshKey,
+          e?.message || e,
+        );
+      });
+  } catch {
+    openPrSchedulePending.delete(refreshKey);
+  }
+}
+
+// Cache protected branches per repo (fetched once per session)
+const protectedBranchesCache = new Map<string, Set<string>>();
+
+export function getProtectedBranches(cwd?: string): Set<string> {
+  const repoKey = cwd || process.cwd();
+  if (protectedBranchesCache.has(repoKey)) return protectedBranchesCache.get(repoKey)!;
+
+  const fallback = new Set(["main", "master"]);
+
+  if (!isGithubRepo(cwd)) {
+    protectedBranchesCache.set(repoKey, fallback);
+    return fallback;
+  }
+
+  // Get owner/repo from remote URL
+  const remote = runGit(["remote", "get-url", "origin"], cwd);
+  if (remote.code !== 0) {
+    protectedBranchesCache.set(repoKey, fallback);
+    return fallback;
+  }
+
+  const match = remote.stdout.match(/github\.com[:/]([^/]+\/[^/.]+)/);
+  if (!match) {
+    protectedBranchesCache.set(repoKey, fallback);
+    return fallback;
+  }
+
+  const repo = match[1];
+  try {
+    const out = execSync(
+      `gh api repos/${repo}/branches --paginate --jq '.[] | select(.protected==true) | .name'`,
+      { cwd, timeout: 10000, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] },
+    );
+    const branches = new Set(
+      out.split("\n").map((b) => b.trim()).filter(Boolean),
+    );
+    // Always include main/master as fallback
+    branches.add("main");
+    branches.add("master");
+    protectedBranchesCache.set(repoKey, branches);
+    return branches;
+  } catch {
+    protectedBranchesCache.set(repoKey, fallback);
+    return fallback;
+  }
+}
+
+export function hasGitSub(command: string, sub: string): boolean {
+  return new RegExp(
+    `\\bgit\\b(?:\\s+(?:-[a-zA-Z]\\s+\\S+|-\\S+))*\\s+${sub}\\b`,
+  ).test(command);
+}
+
+export const DANGEROUS = [
+  /\brm\s+(?:-[a-zA-Z]+\s+)*(-[a-zA-Z]*r[a-zA-Z]*|--recursive)/i,
+  /\bsudo\b/i,
+  /\b(chmod|chown)\b.*777/i,
+  /\bmkfs\b/i,
+  /\bdd\b.*\bof=\/dev\//i,
+  /\bgit\b[\s\S]*\breset\b[\s\S]*--hard\b/i,
+  /\bgit\b[\s\S]*\bclean\b[\s\S]*(?:--force|-\S*f)/i,
+  /\bfind\b[\s\S]*\s-delete\b/i,
+  /\bfind\b[\s\S]*-exec(?:dir)?\s+(?:\/\S+\/)?rm\b/i,
+  /\bxargs\s+(?:-\S+\s+)*(?:\/\S+\/)?rm\b/i,
+  /(?:^|[\s|])(ba|da|z|k|c|tc|fi)?sh\s*$/i,
+];

package/extensions/orchestrator/github-autocomplete.ts

@@ -0,0 +1,250 @@
+/**
+ * GitHub issue & PR autocomplete — type # to get suggestions from the current repo.
+ *
+ * Leverages pi 0.69.0's ctx.ui.addAutocompleteProvider() API.
+ * Lazy-loads on first # keystroke, caches for 5 minutes, includes both issues and PRs.
+ */
+
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import {
+  type AutocompleteItem,
+  type AutocompleteProvider,
+  type AutocompleteSuggestions,
+  fuzzyFilter,
+} from "@earendil-works/pi-tui";
+
+type GitHubItem = {
+  number: number;
+  title: string;
+  state: string;
+  kind: "issue" | "pr";
+  url: string;
+};
+
+const MAX_ITEMS = 200;
+const MAX_SUGGESTIONS = 20;
+const CACHE_TTL_MS = 5 * 60 * 1000; // 5 minutes
+
+function extractIssueToken(textBeforeCursor: string): string | undefined {
+  const match = textBeforeCursor.match(/(?:^|[ \t])#([^\s#]*)$/);
+  return match?.[1];
+}
+
+function parseGitHubRepo(remoteUrl: string): string | undefined {
+  const sshMatch = remoteUrl.match(
+    /^git@github\.com:([^/]+\/[^/]+?)(?:\.git)?$/,
+  );
+  if (sshMatch) return sshMatch[1];
+
+  const httpsMatch = remoteUrl.match(
+    /^https?:\/\/github\.com\/([^/]+\/[^/]+?)(?:\.git)?$/,
+  );
+  if (httpsMatch) return httpsMatch[1];
+
+  return undefined;
+}
+
+function formatItem(item: GitHubItem): AutocompleteItem {
+  const tag = item.kind === "pr" ? "pr" : "issue";
+  const stateIcon = item.state === "open" ? "🟢" : item.state === "merged" ? "🟣" : "🔴";
+  return {
+    value: `#${item.number} (${item.url})`,
+    label: `#${item.number}`,
+    description: `${stateIcon} [${tag}] ${item.title}`,
+  };
+}
+
+function filterItems(
+  items: GitHubItem[],
+  query: string,
+): AutocompleteItem[] {
+  if (!query.trim()) {
+    return items.slice(0, MAX_SUGGESTIONS).map(formatItem);
+  }
+
+  // Numeric prefix match first
+  if (/^\d+$/.test(query)) {
+    const numericMatches = items
+      .filter((item) => String(item.number).startsWith(query))
+      .slice(0, MAX_SUGGESTIONS)
+      .map(formatItem);
+    if (numericMatches.length > 0) return numericMatches;
+  }
+
+  // Fuzzy search on number + title
+  return fuzzyFilter(
+    items,
+    query,
+    (item) => `${item.number} ${item.title}`,
+  )
+    .slice(0, MAX_SUGGESTIONS)
+    .map(formatItem);
+}
+
+function createAutocompleteProvider(
+  current: AutocompleteProvider,
+  getItems: () => Promise<GitHubItem[] | undefined>,
+): AutocompleteProvider {
+  return {
+    async getSuggestions(
+      lines,
+      cursorLine,
+      cursorCol,
+      options,
+    ): Promise<AutocompleteSuggestions | null> {
+      const currentLine = lines[cursorLine] ?? "";
+      const textBeforeCursor = currentLine.slice(0, cursorCol);
+      const token = extractIssueToken(textBeforeCursor);
+
+      if (token === undefined) {
+        return current.getSuggestions(lines, cursorLine, cursorCol, options);
+      }
+
+      const items = await getItems();
+      if (options.signal.aborted || !items || items.length === 0) {
+        return current.getSuggestions(lines, cursorLine, cursorCol, options);
+      }
+
+      const suggestions = filterItems(items, token);
+      if (suggestions.length === 0) {
+        return current.getSuggestions(lines, cursorLine, cursorCol, options);
+      }
+
+      return { items: suggestions, prefix: `#${token}` };
+    },
+
+    applyCompletion(lines, cursorLine, cursorCol, item, prefix) {
+      return current.applyCompletion(
+        lines,
+        cursorLine,
+        cursorCol,
+        item,
+        prefix,
+      );
+    },
+
+    shouldTriggerFileCompletion(lines, cursorLine, cursorCol) {
+      return (
+        current.shouldTriggerFileCompletion?.(lines, cursorLine, cursorCol) ??
+        true
+      );
+    },
+  };
+}
+
+export function registerGithubAutocomplete(pi: ExtensionAPI): void {
+  // Skip in subagent children — they have no UI
+  if (process.env.PI_SUBAGENT_CHILD === "1") return;
+
+  pi.on("session_start", async (_event, ctx) => {
+    if (ctx.mode !== "tui") return;
+
+    // Resolve GitHub repo from git remote
+    const remoteResult = await pi.exec("git", ["remote", "-v"], {
+      cwd: ctx.cwd,
+      timeout: 5_000,
+    });
+    if (remoteResult.code !== 0) return; // Not a git repo
+
+    let repo: string | undefined;
+    for (const line of remoteResult.stdout.split("\n")) {
+      const columns = line.trim().split(/\s+/);
+      const remoteUrl = columns[1];
+      if (remoteUrl) {
+        repo = parseGitHubRepo(remoteUrl);
+        if (repo) break;
+      }
+    }
+    if (!repo) return; // Not a GitHub repo
+
+    // Cache state — lazy-loaded on first # keystroke, refreshed after TTL
+    let cachedItems: GitHubItem[] | undefined;
+    let cacheTimestamp = 0;
+    let fetchPromise: Promise<GitHubItem[] | undefined> | undefined;
+
+    async function fetchItems(): Promise<GitHubItem[] | undefined> {
+      // Fetch issues and PRs in parallel
+      const [issuesResult, prsResult] = await Promise.all([
+        pi.exec(
+          "gh",
+          [
+            "issue", "list",
+            "--repo", repo!,
+            "--state", "all",
+            "--limit", String(MAX_ITEMS),
+            "--json", "number,title,state,url",
+          ],
+          { cwd: ctx.cwd, timeout: 10_000 },
+        ),
+        pi.exec(
+          "gh",
+          [
+            "pr", "list",
+            "--repo", repo!,
+            "--state", "all",
+            "--limit", String(MAX_ITEMS),
+            "--json", "number,title,state,url",
+          ],
+          { cwd: ctx.cwd, timeout: 10_000 },
+        ),
+      ]);
+
+      const items: GitHubItem[] = [];
+
+      if (issuesResult.code === 0) {
+        try {
+          const issues = JSON.parse(issuesResult.stdout) as Array<{ number: number; title: string; state: string; url: string }>;
+          for (const issue of issues) {
+            items.push({ ...issue, state: issue.state.toLowerCase(), kind: "issue", url: issue.url || "" });
+          }
+        } catch (e: any) { console.debug("[github-autocomplete] issues JSON parse failed:", e?.message || e); }
+      }
+
+      if (prsResult.code === 0) {
+        try {
+          const prs = JSON.parse(prsResult.stdout) as Array<{ number: number; title: string; state: string; url: string }>;
+          for (const pr of prs) {
+            items.push({ ...pr, state: pr.state.toLowerCase(), kind: "pr", url: pr.url || "" });
+          }
+        } catch (e: any) { console.debug("[github-autocomplete] PRs JSON parse failed:", e?.message || e); }
+      }
+
+      if (items.length === 0) return undefined;
+
+      // Sort by number descending (newest first)
+      items.sort((a, b) => b.number - a.number);
+      return items;
+    }
+
+    const getItems = async (): Promise<GitHubItem[] | undefined> => {
+      const now = Date.now();
+
+      // Return cache if fresh
+      if (cachedItems && now - cacheTimestamp < CACHE_TTL_MS) {
+        return cachedItems;
+      }
+
+      // Deduplicate concurrent fetches
+      if (!fetchPromise) {
+        fetchPromise = fetchItems().then((result) => {
+          if (result) {
+            cachedItems = result;
+            cacheTimestamp = Date.now();
+          }
+          fetchPromise = undefined;
+          return cachedItems;
+        }).catch(() => {
+          fetchPromise = undefined;
+          return cachedItems;
+        });
+      }
+
+      return fetchPromise;
+    };
+
+    // Register autocomplete provider — fetches lazily on first # keystroke
+    ctx.ui.addAutocompleteProvider((current) =>
+      createAutocompleteProvider(current, getItems),
+    );
+  });
+}

package/extensions/orchestrator/icons.ts

@@ -0,0 +1,17 @@
+/**
+ * Nerd font icons — single place to change all icons used across the extension.
+ * Browse icons at: https://www.nerdfonts.com/cheat-sheet
+ */
+
+export const ICON_SEP = " ❱ ";
+export const ICON_CONTAINER = "󰡨";
+export const ICON_GIT_CLEAN = "";
+export const ICON_GIT_DIRTY = "";
+export const ICON_DIFF = "";
+export const ICON_DREAM = "󰖔";
+
+// Review loop status
+export const ICON_REVIEW_CLEAN = "✓";
+export const ICON_REVIEW_NEEDED = "";
+export const ICON_REVIEW_PROGRESS = "";
+export const ICON_REVIEW_FINDINGS = "";