pi-minimal 0.4.0 → 0.6.0

package/src/index.ts

@@ -1,199 +1,84 @@
-import { getAgentDir, type ExtensionAPI, type ExtensionContext } from "@earendil-works/pi-coding-agent"
-import { loadPiMinimalConfig } from "./config.js"
-import { installHeader } from "./header.js"
-import { installFooter } from "./footer.js"
-import { createFooterContributions } from "./footer-contributions.js"
-import { bindFooterContributionEvents } from "./footer-contribution-events.js"
-import { installCwd } from "./cwd.js"
-import { listSiblings, parseAgentList, parseTabList, type Sibling } from "./herdr.js"
-import { hideGauntletWidgets } from "./tracker.js"
-import { installToolRenderers, setEditDiffMode, stopLiveWatch } from "./tools.js"
-import { setSessionCwd } from "./tool-rows.js"
-import { applyReclaim, reclaimPolicy, type ReclaimReason } from "./reclaim.js"
-import { installWorkingStatus } from "./working-status.js"
-import { installTurnRule } from "./turn-rule.js"
-import { installTranscript } from "./transcript.js"
-import { createGitState } from "./git-state.js"
+import { Type } from "@earendil-works/pi-ai"
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent"
+import { showBackgroundOverlay } from "./background-overlay.js"
 import { installCodeBox } from "./code-box.js"
-import { setChromeMargin } from "./chrome.js"
-import { SettingsManager } from "@earendil-works/pi-coding-agent"
+import { isPrCreateCommand } from "./prs.js"
+import { parsePrFilter, prsToolResult, runPrsCommand, type PrFilter } from "./prs-command.js"
+import { createSession, type Session } from "./session.js"
+import { installToolRenderers, stopLiveWatch } from "./tools.js"
+import { installTranscript } from "./transcript.js"
+import { installTurnRule } from "./turn-rule.js"
+import { installWorkingStatus } from "./working-status.js"
 
+/**
+ * Process-wide hooks are installed once at load (renderers, transformers, the code-box patch);
+ * everything else lives on a `Session` created at session_start and disposed at session_shutdown
+ * or when the next session starts.
+ */
 export default function piMinimalExtension(pi: ExtensionAPI): void {
   const stopWorkingStatus = installWorkingStatus(pi)
   const stopTurnRule = installTurnRule(pi)
   installToolRenderers(pi)
   installTranscript(pi)
   installCodeBox()
-  const contributions = createFooterContributions()
-  let stopFooter = () => {}
-  let stopContributionEvents = () => {}
-  let sessionActive = false
-  let fastTimer: ReturnType<typeof setInterval> | undefined
-  let slowTimer: ReturnType<typeof setInterval> | undefined
-  let stealTimer: ReturnType<typeof setInterval> | undefined
-  let inFlight: AbortController | undefined
-  let siblings: Sibling[] | undefined
-  let generation = 0
-  let hideWidgets = true
-  let busy = false
-  let currentCwd = process.cwd()
-  const gitState = createGitState(pi, () => currentCwd)
-  const stopTimers = () => {
-    if (fastTimer) clearInterval(fastTimer)
-    if (slowTimer) clearInterval(slowTimer)
-    if (stealTimer) clearInterval(stealTimer)
-    fastTimer = undefined
-    slowTimer = undefined
-    stealTimer = undefined
-    inFlight?.abort()
-    inFlight = undefined
-  }
-
-  const scheduleFast = (ctx: ExtensionContext) => {
-    if (fastTimer) return
-    if (slowTimer) clearInterval(slowTimer)
-    slowTimer = undefined
-    fastTimer = setInterval(() => {
-      void probe(ctx)
-    }, 2000)
-  }
-
-  const scheduleSlow = (ctx: ExtensionContext) => {
-    if (slowTimer) return
-    if (fastTimer) clearInterval(fastTimer)
-    fastTimer = undefined
-    slowTimer = setInterval(() => {
-      void probe(ctx)
-    }, 10000)
-  }
-
-  const probe = async (ctx: ExtensionContext) => {
-    if (process.env.HERDR_ENV !== "1") return
-    if (inFlight) return
-    const ac = new AbortController()
-    const gen = generation
-    inFlight = ac
-    try {
-      const agentRun = await pi.exec("herdr", ["agent", "list"], {
-        timeout: 3000,
-        signal: ac.signal,
-      })
-      if (generation !== gen) return
-      const tabRun = await pi.exec("herdr", ["tab", "list"], {
-        timeout: 3000,
-        signal: ac.signal,
-      })
-      if (generation !== gen) return
-      if (agentRun.code !== 0 || tabRun.code !== 0 || agentRun.killed || tabRun.killed) {
-        siblings = undefined
-        scheduleSlow(ctx)
-        return
-      }
-      siblings = listSiblings(
-        parseAgentList(agentRun.stdout),
-        parseTabList(tabRun.stdout),
-        process.env.HERDR_PANE_ID,
-        process.env.HERDR_TAB_ID,
-      )
-      if (siblings) scheduleFast(ctx)
-      else scheduleSlow(ctx)
-    } catch {
-      if (generation !== gen) return
-      siblings = undefined
-      scheduleSlow(ctx)
-    } finally {
-      if (inFlight === ac) inFlight = undefined
-    }
-  }
 
-  const hideForeignChrome = (ctx: ExtensionContext, reason: ReclaimReason) => {
-    if (ctx.mode !== "tui") return
-    applyReclaim(
-      reason,
-      ctx.ui,
-      {
-        widgets: () => {
-          if (hideWidgets) hideGauntletWidgets(ctx)
-        },
-        chrome: () => {
-          installHeader(ctx)
-          installChromeFooter(ctx)
-        },
-      },
-    )
-  }
-
-  const contextPct = (ctx: ExtensionContext): number | undefined => {
-    const usage = ctx.getContextUsage?.()
-    const window = usage?.contextWindow || ctx.model?.contextWindow
-    if (typeof usage?.tokens !== "number" || !window) return undefined
-    return Math.max(0, Math.min(100, Math.round((usage.tokens / window) * 100)))
-  }
+  let active: Session | undefined
+  let busy = false
 
-  const installChromeFooter = (ctx: ExtensionContext) => {
-    stopFooter()
-    stopFooter = installFooter(ctx, {
-      busy: () => busy,
-      editorText: () => (typeof ctx.ui.getEditorText === "function" ? ctx.ui.getEditorText() : ""),
-      contextPct: () => contextPct(ctx),
-    }, contributions)
+  // Background processes: `/bg` and a shortcut (default ctrl+b, see `backgroundShortcut`). The
+  // shortcut is registered once per key at load, since pi has no unregister; it reads the active
+  // session's config when pressed.
+  const openBackground = async (ctx: ExtensionContext) => {
+    if (!active?.background) return
+    await showBackgroundOverlay(ctx, active.background, active.backgroundShortcut ?? undefined)
   }
-
-  const installStatusLine = (ctx: ExtensionContext) => {
-    installCwd(ctx, {
-      gitState: gitState.get,
-      siblings: () => siblings,
-      onGitChange: gitState.onChange,
+  pi.registerCommand("bg", { description: "Show processes left running by bash tool calls", handler: (_args, ctx) => openBackground(ctx) })
+  // Open PRs for the repo in cwd: `/prs [mine|review|all]` and the `list_open_prs` tool.
+  pi.registerCommand("prs", {
+    description: "Open PRs in this repo that I authored or that need my review",
+    handler: (args, ctx) => runPrsCommand(args, ctx, pi, active?.prs),
+  })
+  pi.registerTool({
+    name: "list_open_prs",
+    label: "List Open PRs",
+    description: "List open pull requests in the current repository that the user authored or has been asked to review (via the gh CLI).",
+    parameters: Type.Object({
+      filter: Type.Optional(Type.Union([Type.Literal("all"), Type.Literal("mine"), Type.Literal("review")], { description: "all (default), mine, or review (waiting on my review)" })),
+    }),
+    async execute(_toolCallId, params) {
+      await active?.prs?.refresh()
+      const result = prsToolResult(active?.prs, (params.filter as PrFilter | undefined) ?? parsePrFilter(""))
+      const text = result.prs.length === 0
+        ? `No open PRs${result.repo ? ` in ${result.repo}` : ""}${result.error ? ` (${result.error})` : ""}.`
+        : result.prs.map((pr) => `#${pr.number} [${pr.kind}${pr.isDraft ? ", draft" : ""}${pr.ciFailing ? ", CI failing" : ""}] ${pr.title} — ${pr.url}`).join("\n")
+      return { content: [{ type: "text", text }], details: result }
+    },
+  })
+  const registeredShortcuts = new Set<string>()
+  const ensureShortcut = () => {
+    const key = active?.backgroundShortcut
+    if (!key || registeredShortcuts.has(key) || typeof pi.registerShortcut !== "function") return
+    registeredShortcuts.add(key)
+    pi.registerShortcut(key as Parameters<ExtensionAPI["registerShortcut"]>[0], {
+      description: "Show background processes",
+      handler: (ctx) => (active?.backgroundShortcut === key ? openBackground(ctx) : undefined),
     })
   }
 
-  const pinChrome = (ctx: ExtensionContext, reason: ReclaimReason) => {
-    hideForeignChrome(ctx, reason)
-    if (ctx.mode !== "tui" || !reclaimPolicy(reason).reinstallChrome) return
-    ctx.ui.setWidget("tw-cwd", undefined)
-    installStatusLine(ctx)
-  }
+  pi.on("session_start", (_event, ctx) => {
+    active?.dispose()
+    active = createSession(pi, ctx, { busy: () => busy })
+    ensureShortcut()
+  })
 
-  pi.on("session_start", async (_event, ctx) => {
-    stopFooter()
-    stopContributionEvents()
-    sessionActive = true
-    generation += 1
-    stopContributionEvents = bindFooterContributionEvents(pi.events, contributions, ctx.sessionManager.getSessionId(), ctx.mode)
-    if (ctx.mode !== "tui") return
-    const config = loadPiMinimalConfig({
-      agentDir: getAgentDir(),
-      cwd: ctx.cwd,
-      projectTrusted: ctx.isProjectTrusted(),
-    })
-    hideWidgets = config.hideGauntletWidgets
-    setEditDiffMode(config.editDiff)
-    currentCwd = ctx.cwd
-    setSessionCwd(ctx.cwd)
-    try {
-      const settings = SettingsManager.create(ctx.cwd, undefined, { projectTrusted: ctx.isProjectTrusted() })
-      setChromeMargin(settings.getOutputPad())
-    } catch {
-      // Keep the default margin when settings are unavailable.
-    }
-    installHeader(ctx)
-    installChromeFooter(ctx)
-    installStatusLine(ctx)
-    void gitState.refresh(true)
-    pinChrome(ctx, "session_start")
-    ctx.ui.setHiddenThinkingLabel("◆ Thought")
-    ctx.ui.setWorkingIndicator()
-    const sessionGeneration = generation
-    const settle = () => {
-      if (sessionActive && generation === sessionGeneration) pinChrome(ctx, "session_settle")
-    }
-    setTimeout(settle, 0)
-    setTimeout(settle, 50)
-    if (!stealTimer) {
-      stealTimer = setInterval(() => hideForeignChrome(ctx, "interval"), 200)
-    }
-    if (process.env.HERDR_ENV === "1") {
-      await probe(ctx)
+  // Commands that create a PR: remember the URL they print so the chips follow the session
+  // even when cwd is another repo (worktrees) or no repo at all.
+  const prCreateCalls = new Map<string, true>()
+  pi.on("tool_execution_start", (event) => {
+    active?.background?.toolStart(event.toolCallId, event.toolName)
+    const command = (event.args as { command?: unknown } | undefined)?.command
+    if ((event.toolName === "bash" || event.toolName === "powershell") && typeof command === "string" && isPrCreateCommand(command)) {
+      prCreateCalls.set(event.toolCallId, true)
     }
   })
 
@@ -202,27 +87,28 @@ export default function piMinimalExtension(pi: ExtensionAPI): void {
   })
   pi.on("agent_end", () => {
     busy = false
-    void gitState.refresh()
+    active?.refreshGit()
   })
-  pi.on("turn_end", (_event, ctx) => {
-    pinChrome(ctx, "turn_end")
-    void gitState.refresh()
+  pi.on("turn_end", () => {
+    active?.pin("turn_end")
+    active?.refreshGit()
   })
-  pi.on("tool_execution_end", (_event, ctx) => {
-    pinChrome(ctx, "tool_execution_end")
-    void gitState.refresh()
+  pi.on("tool_execution_end", (event) => {
+    active?.background?.toolEnd(event.toolCallId, event.toolName)
+    if (prCreateCalls.delete(event.toolCallId) && !event.isError) {
+      const content = (event.result as { content?: Array<{ type?: string; text?: string }> } | undefined)?.content ?? []
+      active?.notePrUrls(content.map((part) => (part.type === "text" && typeof part.text === "string" ? part.text : "")).join("\n"))
+    }
+    active?.pin("tool_execution_end")
+    active?.refreshGit()
   })
 
-  pi.on("session_shutdown", async () => {
-    sessionActive = false
-    stopFooter()
-    stopContributionEvents()
+  pi.on("session_shutdown", () => {
+    active?.dispose()
+    active = undefined
     busy = false
-    stopTimers()
     stopWorkingStatus()
     stopTurnRule()
     stopLiveWatch()
-    generation += 1
-    siblings = undefined
   })
 }

package/src/listeners.ts

@@ -0,0 +1,22 @@
+/** A tiny change-notification set shared by the git and sibling sources. */
+export function createListeners() {
+  const listeners = new Set<() => void>()
+  return {
+    notify() {
+      for (const listener of listeners) {
+        try {
+          listener()
+        } catch {
+          // One listener's failure must not starve the others.
+        }
+      }
+    },
+    add(listener: () => void) {
+      listeners.add(listener)
+      return () => listeners.delete(listener)
+    },
+    clear() {
+      listeners.clear()
+    },
+  }
+}

package/src/prs-command.ts

@@ -0,0 +1,81 @@
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent"
+import { describePr, PR_LEGEND, type PrSource, type PullRequest } from "./prs.js"
+
+/**
+ * `/prs [mine|review|all]` lists the current repo's open PRs that involve me and offers actions on
+ * the chosen one. The `list_open_prs` tool gives the model the same list.
+ */
+
+export type PrFilter = "all" | "mine" | "review"
+
+export function parsePrFilter(args: string): PrFilter {
+  const word = args.trim().split(/\s+/)[0]?.toLowerCase() ?? ""
+  if (["mine", "author", "authored", "my"].includes(word)) return "mine"
+  if (["review", "reviews", "review-requested", "requested"].includes(word)) return "review"
+  return "all"
+}
+
+export function filterPrs(prs: PullRequest[], filter: PrFilter): PullRequest[] {
+  if (filter === "all") return prs
+  return prs.filter((pr) => pr.kind === filter)
+}
+
+const ACTIONS = ["Open in browser", "Paste URL into editor", "Checkout branch", "Cancel"] as const
+
+export async function runPrsCommand(args: string, ctx: ExtensionContext, pi: ExtensionAPI, source: PrSource | undefined): Promise<void> {
+  if (!source) {
+    ctx.ui.notify("PRs are only tracked in interactive sessions.", "info")
+    return
+  }
+  await source.refresh(true)
+  const snap = source.get()
+  if (!snap.repo && snap.prs.length === 0) {
+    ctx.ui.notify(snap.error ? `No GitHub repo here: ${snap.error}` : "No GitHub repo here.", "warning")
+    return
+  }
+  const filter = parsePrFilter(args)
+  const prs = filterPrs(snap.prs, filter)
+  const title = `${snap.repo?.nameWithOwner ?? "this session"}: ${prs.length} open PR${prs.length === 1 ? "" : "s"}${filter === "all" ? "" : ` (${filter})`}${snap.error ? ` · stale: ${snap.error}` : ""}`
+  if (prs.length === 0) {
+    ctx.ui.notify(title, "info")
+    return
+  }
+  if (ctx.mode !== "tui") {
+    ctx.ui.notify(`${title}\n${prs.map((pr) => `${describePr(pr, snap.repo ? `${snap.repo.host}/${snap.repo.nameWithOwner}` : undefined)}\n  ${pr.url}`).join("\n")}`, "info")
+    return
+  }
+  const cwdRepo = snap.repo ? `${snap.repo.host}/${snap.repo.nameWithOwner}` : undefined
+  const labels = prs.map((pr) => describePr(pr, cwdRepo))
+  const chosen = await ctx.ui.select(`${title}\n${PR_LEGEND}`, labels)
+  if (chosen === undefined) return
+  const pr = prs[labels.indexOf(chosen)]
+  if (!pr) return
+  const action = await ctx.ui.select(`#${pr.number} ${pr.title}`, [...ACTIONS])
+  if (action === "Open in browser") {
+    const open = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open"
+    const run = await pi.exec(open, [pr.url])
+    if (run.code !== 0) ctx.ui.notify(`Could not open browser: ${run.stderr.trim()}`, "error")
+  } else if (action === "Paste URL into editor") {
+    ctx.ui.pasteToEditor(pr.url)
+  } else if (action === "Checkout branch") {
+    const run = await pi.exec("gh", ["pr", "checkout", String(pr.number), "-R", pr.repo], { cwd: ctx.cwd, timeout: 60_000 })
+    ctx.ui.notify(run.code === 0 ? `Checked out #${pr.number}` : `Checkout failed: ${run.stderr.trim()}`, run.code === 0 ? "info" : "error")
+  }
+}
+
+export function prsToolResult(source: PrSource | undefined, filter: PrFilter) {
+  const snap = source?.get()
+  const prs = filterPrs(snap?.prs ?? [], filter).map((pr) => ({
+    number: pr.number,
+    title: pr.title,
+    url: pr.url,
+    repo: pr.repo,
+    author: pr.author,
+    isDraft: pr.isDraft,
+    kind: pr.kind,
+    reviewDecision: pr.reviewDecision,
+    ciFailing: pr.ciFailing,
+    updatedAt: pr.updatedAt,
+  }))
+  return { repo: snap?.repo?.nameWithOwner, host: snap?.repo?.host, fetchedAt: snap?.fetchedAt, error: snap?.error, prs }
+}