pi-minimal 0.3.1 → 0.5.0

package/src/index.ts

@@ -1,199 +1,29 @@
-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 type { ExtensionAPI } from "@earendil-works/pi-coding-agent"
+import { installCodeBox } from "./code-box.js"
+import { createSession, type Session } from "./session.js"
 import { installToolRenderers, 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 { installCodeBox } from "./code-box.js"
-import { setChromeMargin } from "./chrome.js"
-import { SettingsManager } from "@earendil-works/pi-coding-agent"
+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)))
-  }
-
-  const installChromeFooter = (ctx: ExtensionContext) => {
-    stopFooter()
-    stopFooter = installFooter(ctx, {
-      busy: () => busy,
-      editorText: () => (typeof ctx.ui.getEditorText === "function" ? ctx.ui.getEditorText() : ""),
-      contextPct: () => contextPct(ctx),
-    }, contributions)
-  }
-
-  const installStatusLine = (ctx: ExtensionContext) => {
-    installCwd(ctx, {
-      gitState: gitState.get,
-      siblings: () => siblings,
-      onGitChange: gitState.onChange,
-    })
-  }
-
-  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)
-  }
+  let active: Session | undefined
+  let busy = false
 
-  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
-    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)
-    }
+  pi.on("session_start", (_event, ctx) => {
+    active?.dispose()
+    active = createSession(pi, ctx, { busy: () => busy })
   })
 
   pi.on("agent_start", () => {
@@ -201,27 +31,23 @@ 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", () => {
+    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/reclaim.ts

@@ -1,7 +1,6 @@
 export type ReclaimReason =
   | "session_start"
   | "session_settle"
-  | "interval"
   | "turn_end"
   | "tool_execution_end"
 
@@ -14,9 +13,6 @@ export function reclaimPolicy(reason: ReclaimReason): ReclaimPolicy {
   if (reason === "session_start") {
     return { resetEditor: true, reinstallChrome: true }
   }
-  if (reason === "interval") {
-    return { resetEditor: false, reinstallChrome: false }
-  }
   // session_settle / turn_end / tool_execution_end: restore chrome, keep editor
   return { resetEditor: false, reinstallChrome: true }
 }

package/src/session.ts

@@ -0,0 +1,159 @@
+import { getAgentDir, SettingsManager, type ExtensionAPI, type ExtensionContext } from "@earendil-works/pi-coding-agent"
+import { setChromeMargin } from "./chrome.js"
+import { loadPiMinimalConfig } from "./config.js"
+import { installCwd } from "./cwd.js"
+import { installFooter } from "./footer.js"
+import { bindFooterContributionEvents } from "./footer-contribution-events.js"
+import { createFooterContributions } from "./footer-contributions.js"
+import { createGitState } from "./git-state.js"
+import { installHeader } from "./header.js"
+import { listSiblings, parseAgentList, parseTabList, type Sibling } from "./herdr.js"
+import { applyReclaim, reclaimPolicy, type ReclaimReason } from "./reclaim.js"
+import { setSessionCwd } from "./tool-rows.js"
+import { setEditDiffMode } from "./tools.js"
+import { hideGauntletWidgets } from "./tracker.js"
+
+export type SessionDeps = {
+  /** Whether an agent run is in progress; owned by the extension because agent events are not session-scoped. */
+  busy: () => boolean
+}
+
+export type Session = {
+  readonly id: string
+  /** Re-asserts chrome after an event that may have let another extension draw over it. */
+  pin(reason: ReclaimReason): void
+  refreshGit(force?: boolean): void
+  dispose(): void
+}
+
+const HERDR_FAST_MS = 2000
+const HERDR_SLOW_MS = 10000
+const HERDR_EXEC_TIMEOUT_MS = 3000
+
+/**
+ * Everything pi-minimal owns for one session: config, cwd, the contribution registry, the git and
+ * Herdr pollers, and the header/footer/status-line chrome. Disposal stops every timer and makes
+ * late async results inert, so two sessions in one process never share or overwrite each other's
+ * state. Non-TUI sessions get a session too, but it only binds the contribution protocol (which
+ * replies `not-tui`) and installs no chrome.
+ */
+export function createSession(pi: ExtensionAPI, ctx: ExtensionContext, deps: SessionDeps): Session {
+  const id = ctx.sessionManager.getSessionId()
+  let alive = true
+  const contributions = createFooterContributions()
+  const stopContributionEvents = bindFooterContributionEvents(pi.events, contributions, id, ctx.mode)
+  if (ctx.mode !== "tui") {
+    return { id, pin() {}, refreshGit() {}, dispose() { if (!alive) return; alive = false; stopContributionEvents() } }
+  }
+
+  const config = loadPiMinimalConfig({ agentDir: getAgentDir(), cwd: ctx.cwd, projectTrusted: ctx.isProjectTrusted() })
+  setSessionCwd(ctx.cwd)
+  setEditDiffMode(config.editDiff)
+  try {
+    const settings = SettingsManager.create(ctx.cwd, undefined, { projectTrusted: ctx.isProjectTrusted() })
+    setChromeMargin(settings.getOutputPad())
+  } catch {
+    // Keep the current margin when settings are unavailable.
+  }
+
+  const gitState = createGitState(pi, () => ctx.cwd)
+  let stopFooter = () => {}
+  let siblings: Sibling[] | undefined
+  let herdrTimer: ReturnType<typeof setInterval> | undefined
+  let herdrPeriod = 0
+  let herdrInFlight: AbortController | undefined
+  const settleTimers: ReturnType<typeof setTimeout>[] = []
+
+  const contextPct = (): 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)))
+  }
+
+  const installChromeFooter = () => {
+    stopFooter()
+    stopFooter = installFooter(ctx, {
+      busy: deps.busy,
+      editorText: () => (typeof ctx.ui.getEditorText === "function" ? ctx.ui.getEditorText() : ""),
+      contextPct,
+    }, contributions)
+  }
+
+  const installStatusLine = () => {
+    installCwd(ctx, { gitState: gitState.get, siblings: () => siblings, onGitChange: gitState.onChange })
+  }
+
+  const pin = (reason: ReclaimReason) => {
+    if (!alive) return
+    applyReclaim(reason, ctx.ui, {
+      widgets: () => { if (config.hideGauntletWidgets) hideGauntletWidgets(ctx) },
+      chrome: () => { installHeader(ctx); installChromeFooter() },
+    })
+    if (!reclaimPolicy(reason).reinstallChrome) return
+    ctx.ui.setWidget("tw-cwd", undefined)
+    installStatusLine()
+  }
+
+  const scheduleHerdr = (periodMs: number) => {
+    if (!alive || herdrPeriod === periodMs) return
+    if (herdrTimer) clearInterval(herdrTimer)
+    herdrPeriod = periodMs
+    herdrTimer = setInterval(() => { void probeHerdr() }, periodMs)
+  }
+
+  const probeHerdr = async () => {
+    if (!alive || herdrInFlight) return
+    const ac = new AbortController()
+    herdrInFlight = ac
+    try {
+      const agentRun = await pi.exec("herdr", ["agent", "list"], { timeout: HERDR_EXEC_TIMEOUT_MS, signal: ac.signal })
+      if (!alive) return
+      const tabRun = await pi.exec("herdr", ["tab", "list"], { timeout: HERDR_EXEC_TIMEOUT_MS, signal: ac.signal })
+      if (!alive) return
+      if (agentRun.code !== 0 || tabRun.code !== 0 || agentRun.killed || tabRun.killed) {
+        siblings = undefined
+        scheduleHerdr(HERDR_SLOW_MS)
+        return
+      }
+      siblings = listSiblings(parseAgentList(agentRun.stdout), parseTabList(tabRun.stdout), process.env.HERDR_PANE_ID, process.env.HERDR_TAB_ID)
+      scheduleHerdr(siblings ? HERDR_FAST_MS : HERDR_SLOW_MS)
+    } catch {
+      if (!alive) return
+      siblings = undefined
+      scheduleHerdr(HERDR_SLOW_MS)
+    } finally {
+      if (herdrInFlight === ac) herdrInFlight = undefined
+    }
+  }
+
+  // Install once, then re-assert shortly after: other extensions' session_start handlers may draw after ours.
+  installHeader(ctx)
+  installChromeFooter()
+  installStatusLine()
+  void gitState.refresh(true)
+  pin("session_start")
+  ctx.ui.setHiddenThinkingLabel("◆ Thought")
+  ctx.ui.setWorkingIndicator()
+  for (const delay of [0, 50]) settleTimers.push(setTimeout(() => pin("session_settle"), delay))
+  if (process.env.HERDR_ENV === "1") void probeHerdr()
+
+  return {
+    id,
+    pin,
+    refreshGit(force) { if (alive) void gitState.refresh(force) },
+    dispose() {
+      if (!alive) return
+      alive = false
+      for (const timer of settleTimers.splice(0)) clearTimeout(timer)
+      if (herdrTimer) clearInterval(herdrTimer)
+      herdrTimer = undefined
+      herdrInFlight?.abort()
+      herdrInFlight = undefined
+      siblings = undefined
+      gitState.dispose()
+      stopFooter()
+      stopContributionEvents()
+    },
+  }
+}