pi-code 1.0.10 → 1.0.11

package/extensions/hooks.ts

@@ -3,7 +3,14 @@
  *
  * Runs Claude Code's `.claude/settings.json` hooks on pi's lifecycle events, so
  * a project's existing hooks work under pi:
- * - PreToolUse      -> pi `tool_call` (can block the tool or rewrite its input)
+ * - PreToolUse      -> pi `tool_call` (can block the tool or rewrite its input), plus
+ *                      pi `user_bash` for a `!`/`!!` command the user runs directly (the
+ *                      model never issues these, so a deny-list guard would otherwise miss
+ *                      them). No pi tool call exists there, so the payload reports the
+ *                      Claude name "Bash"; a deny hands pi a synthetic failed result so
+ *                      the command never runs. UserBashEvent carries no execution result
+ *                      and fires only before the command runs, so it has no PostToolUse
+ *                      counterpart (pi never delivers the output to observe).
  * - PostToolUse     -> pi `tool_result` (block reasons and additionalContext are
  *                      appended next to the tool result, as Claude documents)
  * - SessionStart    -> pi `session_start` (stdout/additionalContext is injected as
@@ -1021,6 +1028,31 @@ export default function hooksExtension(pi: ExtensionAPI) {
     return { content: [...event.content, ...feedback.map((text) => ({ type: 'text' as const, text }))] }
   })
 
+  // Claude's PreToolUse for Bash, extended to a command the user runs directly with the
+  // `!`/`!!` prefix. pi fires user_bash before executing it, and the model never sees it,
+  // so without this a guard that blocks `git push -f` from the model would not stop the
+  // same command typed by hand. There is no pi tool call, so the matcher sees both pi's
+  // "bash" and the Claude name "Bash" (exactly as an MCP alias is bridged) and the payload
+  // reports "Bash", the tool_name a Claude-written PreToolUse Bash hook expects. The
+  // payload carries no tool_use_id (no model tool call produced it). UserBashEventResult
+  // exposes no block flag: a deny is enforced through `result` ("extension handled
+  // execution, use this result"), a synthetic failed BashResult that stands in for the
+  // command so it never runs and its deny reason shows as the output. The event delivers
+  // no execution result and fires only before the command runs, so there is deliberately
+  // no PostToolUse for it.
+  pi.on('user_bash', async (event, ctx) => {
+    const decision = await runPreToolUse(config, 'bash', { command: event.command }, boundRunner(ctx), 'Bash', (message) => ctx.ui.notify(message, 'warning'))
+    if (!decision.block) return undefined
+    // Claude's "ask": prompt before running and let the command through on approval; with
+    // no UI (headless) the block stands, the same safe default as the tool_call path.
+    if (decision.ask && ctx.hasUI) {
+      const approved = await ctx.ui.confirm('Allow this command?', decision.reason ?? 'A hook asks you to confirm this command.')
+      if (approved) return undefined
+    }
+    const reason = decision.reason ?? 'Command blocked by hook'
+    return { result: { output: `Blocked by hook: ${reason}`, exitCode: 1, cancelled: false, truncated: false } }
+  })
+
   pi.on('input', async (event, ctx) => {
     // Only genuine user input; extension-injected messages (plan-mode, subagent) are not
     // prompts the user submitted.

package/extensions/output-styles.ts

@@ -200,6 +200,13 @@ export default function outputStylesExtension(pi: ExtensionAPI) {
 
   pi.registerCommand('output-style', {
     description: 'Choose the active Claude output style (or /output-style <name>)',
+    // /output-style <name> takes a style name, so complete the discovered names by the
+    // typed prefix (case-insensitive, like the handler's own name lookup). An empty
+    // prefix offers every style.
+    getArgumentCompletions: (argumentPrefix) => {
+      const prefix = argumentPrefix.trim().toLowerCase()
+      return styles.filter((style) => style.name.toLowerCase().startsWith(prefix)).map((style) => ({ value: style.name, label: style.name, ...(style.description ? { description: style.description } : {}) }))
+    },
     handler: async (args, ctx) => {
       const requested = args.trim()
       if (requested) {

package/extensions/session-title.ts

@@ -0,0 +1,126 @@
+/**
+ * Session Auto-Title Extension
+ *
+ * Claude auto-names a new conversation from its first message; this does the same for
+ * pi. After the first run of an unnamed session settles, it asks the current model for
+ * a short title based on the first user message and applies it two ways: setSessionName
+ * (the name shown in the session selector) and the terminal window/tab title.
+ *
+ * It runs in every mode, not just the TUI: naming a session is cheap and harmless, and a
+ * headless run that persists its session still benefits from a readable name later. The
+ * window-title update is the only terminal-specific part, so it is optional-called rather
+ * than gated on hasUI. Titling is best-effort throughout: a session that already has a
+ * name, a run with no user text (a slash-command-only turn), a headless run with no model,
+ * or any provider error leaves the session untitled and never throws.
+ *
+ * Cost: one model call per session at most. The guard is claimed before the completion so
+ * repeated settles cannot each fire a call, and a failed attempt is not retried until a
+ * new session resets the guard.
+ */
+
+import type { ExtensionAPI, ExtensionContext } from '@earendil-works/pi-coding-agent'
+
+import { completeText } from './internal/model-complete.js'
+
+const TITLE_SYSTEM = 'You name a coding session from its first user message. Reply with a terse 3 to 6 word title in Title Case that captures the task. No quotes, no surrounding punctuation, no trailing period. Output the title only, nothing else.'
+/** A title is a few words; a tight cap keeps the extra call cheap and stops a runaway reply. */
+const TITLE_MAX_TOKENS = 24
+/** The first message can be huge; only its opening is needed to name the session, and a
+ * bounded prompt keeps the input cost of the extra call small. */
+const MAX_PROMPT_CHARS = 1000
+
+/** Join the text of a message's content, mirroring git-checkpoint's extraction: content is
+ * either a plain string or an array of parts, of which only text parts carry a title's worth. */
+function extractText(content: unknown): string {
+  if (typeof content === 'string') return content
+  if (!Array.isArray(content)) return ''
+  return content
+    .filter((part) => part?.type === 'text' && typeof part.text === 'string')
+    .map((part) => part.text)
+    .join(' ')
+}
+
+/** Text of the first user message in the branch, or empty when the run carried no user text
+ * (for example a slash-command-only turn), in which case there is nothing to title from. */
+export function firstUserText(ctx: ExtensionContext): string {
+  for (const entry of ctx.sessionManager.getBranch()) {
+    if (entry?.type === 'message' && entry.message.role === 'user') {
+      return extractText(entry.message.content).trim()
+    }
+  }
+  return ''
+}
+
+/** Wrapping quotes (straight, smart, and backtick) and trailing sentence punctuation that
+ * cleanTitle peels, held as plain strings so the trims below can test membership by index
+ * rather than with an anchored regex. */
+const WRAPPING_QUOTES = '"\'`“”‘’'
+const TRAILING_PUNCTUATION = '.,;:!?'
+
+/** Strip runs of `chars` from both ends of `value` in linear time. The equivalent
+ * /^[chars]+|[chars]+$/g backtracks super-linearly on a long run (S8786). */
+function trimBothEnds(value: string, chars: string): string {
+  let start = 0
+  let end = value.length
+  while (start < end && chars.includes(value[start])) start++
+  while (end > start && chars.includes(value[end - 1])) end--
+  return value.slice(start, end)
+}
+
+/** Strip a trailing run of `chars` from `value` in linear time. The equivalent
+ * /[chars]+$/g backtracks super-linearly on a long trailing run (S8786). */
+function trimTrailing(value: string, chars: string): string {
+  let end = value.length
+  while (end > 0 && chars.includes(value[end - 1])) end--
+  return value.slice(0, end)
+}
+
+/** Trim the model's reply to a bare title: collapse whitespace, then peel wrapping quotes
+ * and trailing punctuation until stable, so `"Fix The Parser."` and `Fix The Parser.` both
+ * land on the plain phrase. */
+export function cleanTitle(raw: string): string {
+  let title = raw.trim().replace(/\s+/g, ' ')
+  let prev: string
+  do {
+    prev = title
+    title = trimTrailing(trimBothEnds(title, WRAPPING_QUOTES), TRAILING_PUNCTUATION).trim()
+  } while (title !== prev)
+  return title
+}
+
+export default function sessionTitleExtension(pi: ExtensionAPI) {
+  // One title per session, reset when a new session takes over so a resumed or forked
+  // session can still earn its own name.
+  let titled = false
+
+  pi.on('session_start', () => {
+    titled = false
+  })
+
+  pi.on('agent_settled', async (_event, ctx) => {
+    if (titled) return
+    // Never clobber an existing name: a user-chosen or resumed name wins.
+    if (pi.getSessionName?.()) return
+    const model = ctx.model
+    if (!model) return // headless with no model: nothing to name with, and the guard is left unspent
+    const prompt = firstUserText(ctx)
+    if (!prompt) return // no user text this run: leave the guard unspent for a later real message
+
+    // Claim the single attempt before the await, so overlapping or repeated settles cannot
+    // each fire a model call; a failed attempt below is not retried within this session.
+    titled = true
+    let title: string
+    try {
+      const { text } = await completeText(model, `First user message of a new coding session:\n\n${prompt.slice(0, MAX_PROMPT_CHARS)}`, {
+        system: TITLE_SYSTEM,
+        maxTokens: TITLE_MAX_TOKENS,
+      })
+      title = cleanTitle(text)
+    } catch {
+      return // no model, provider error: leave the session untitled (best-effort)
+    }
+    if (!title) return
+    pi.setSessionName(title)
+    ctx.ui.setTitle?.(title)
+  })
+}

package/extensions/status-line.ts

@@ -64,6 +64,66 @@ function formatCost(cost: number): string {
   return cost >= 0.01 ? `$${cost.toFixed(2)}` : `$${cost.toFixed(4)}`
 }
 
+interface RateLimitWindow {
+  used_percentage: number
+  resets_at?: string
+}
+interface RateLimitSnapshot {
+  five_hour?: RateLimitWindow
+  seven_day?: RateLimitWindow
+}
+
+/** Lowercase every header name (HTTP names are case-insensitive) and drop null
+ * values, so a single lookup shape works regardless of how the provider cased
+ * them. ProviderHeaders values are string | null. */
+function normalizeHeaders(raw: Record<string, string | null> | undefined): Record<string, string> {
+  const out: Record<string, string> = {}
+  for (const [key, value] of Object.entries(raw ?? {})) {
+    if (typeof value === 'string') out[key.toLowerCase()] = value
+  }
+  return out
+}
+
+function toNumber(value: string | undefined): number | undefined {
+  if (value === undefined || value.trim() === '') return undefined
+  const parsed = Number(value)
+  return Number.isFinite(parsed) ? parsed : undefined
+}
+
+/** One rate-limit window from the `anthropic-ratelimit-<prefix>-*` header family,
+ * taking a direct `-utilization` percentage when present, else computing it from
+ * `-limit` and `-remaining`. resets_at comes from `-reset` when the header is set.
+ * Header names vary, so only what is present is read and a bare number is enough. */
+function readRateLimitWindow(headers: Record<string, string>, prefix: string): RateLimitWindow | undefined {
+  const base = `anthropic-ratelimit-${prefix}`
+  let usedPercentage = toNumber(headers[`${base}-utilization`])
+  if (usedPercentage === undefined) {
+    const limit = toNumber(headers[`${base}-limit`])
+    const remaining = toNumber(headers[`${base}-remaining`])
+    if (limit !== undefined && limit > 0 && remaining !== undefined) {
+      usedPercentage = ((limit - remaining) / limit) * 100
+    }
+  }
+  if (usedPercentage === undefined) return undefined
+  const window: RateLimitWindow = { used_percentage: usedPercentage }
+  const resetsAt = headers[`${base}-reset`] ?? headers[`${base}-resets-at`]
+  if (resetsAt) window.resets_at = resetsAt
+  return window
+}
+
+/** The five-hour and seven-day utilization windows Claude's statusline reports,
+ * from the unified rate-limit response headers. Undefined when neither is present
+ * so a response without them never clobbers an earlier snapshot. */
+function parseRateLimits(headers: Record<string, string>): RateLimitSnapshot | undefined {
+  const fiveHour = readRateLimitWindow(headers, 'unified-5h')
+  const sevenDay = readRateLimitWindow(headers, 'unified-7d')
+  if (!fiveHour && !sevenDay) return undefined
+  const snapshot: RateLimitSnapshot = {}
+  if (fiveHour) snapshot.five_hour = fiveHour
+  if (sevenDay) snapshot.seven_day = sevenDay
+  return snapshot
+}
+
 export interface StatusLineConfig {
   command: string
   padding: number
@@ -120,6 +180,10 @@ export default function statusLine(pi: ExtensionAPI) {
   let apiDurationMs = 0
   let requestStartMs: number | undefined
   let lastUsage: { input: number; output: number; cacheRead: number; cacheWrite: number; totalTokens: number } | undefined
+  // The most recent rate-limit snapshot parsed from provider response headers, and
+  // a once-per-session guard so a 429 warns the user only the first time it lands.
+  let rateLimits: RateLimitSnapshot | undefined
+  let rateLimitWarned = false
   let refreshTimer: ReturnType<typeof setInterval> | undefined
   let debounceTimer: ReturnType<typeof setTimeout> | undefined
   let running = false
@@ -193,6 +257,9 @@ export default function statusLine(pi: ExtensionAPI) {
       payload.thinking = { enabled: ctx.thinkingLevel !== 'off' }
     }
     if (styleName) payload.output_style = { name: styleName }
+    // The current utilization of the account's rate-limit windows, when the
+    // provider reported them; omitted entirely until a response has carried them.
+    if (rateLimits) payload.rate_limits = rateLimits
     return payload
   }
 
@@ -260,9 +327,24 @@ export default function statusLine(pi: ExtensionAPI) {
   pi.on('before_provider_request', async () => {
     requestStartMs = Date.now()
   })
-  pi.on('after_provider_response', async () => {
+  pi.on('after_provider_response', async (event, ctx) => {
     if (requestStartMs !== undefined) apiDurationMs += Date.now() - requestStartMs
     requestStartMs = undefined
+    // Rate-limit windows and 429 handling ride on the same response event. Header
+    // names and presence vary, so parse only what is there and never throw.
+    const headers = normalizeHeaders(event.headers)
+    const snapshot = parseRateLimits(headers)
+    if (snapshot) rateLimits = snapshot
+    if (event.status === 429 && !rateLimitWarned) {
+      rateLimitWarned = true
+      const retryAfter = headers['retry-after']
+      const detail = retryAfter ? `; retry after ${retryAfter}s` : ''
+      try {
+        ctx.ui.notify(`Provider rate limit reached (429)${detail}`, 'warning')
+      } catch {
+        // The session may be gone by the time a late response lands; nothing to warn.
+      }
+    }
   })
   // The last message's token usage, for the breakdown getContextUsage() omits,
   // and the running cost total, so renders never re-walk the branch.
@@ -284,6 +366,8 @@ export default function statusLine(pi: ExtensionAPI) {
     apiDurationMs = 0
     requestStartMs = undefined
     lastUsage = undefined
+    rateLimits = undefined
+    rateLimitWarned = false
     clearInterval(refreshTimer)
     // Seed the running cost from the branch: a resumed or forked session starts
     // with history, and message_end only accumulates from here on.
@@ -327,6 +411,15 @@ export default function statusLine(pi: ExtensionAPI) {
     scheduleRefresh()
   })
 
+  // The model and effort segments of the payload go stale between turns; a switch
+  // fires these events, so refresh at once instead of waiting for the next tick.
+  pi.on('model_select', async () => {
+    scheduleRefresh()
+  })
+  pi.on('thinking_level_select', async () => {
+    scheduleRefresh()
+  })
+
   pi.on('session_compact', async (_event, ctx) => {
     // Compaction replaces the branch entries; reseed the total from what remains.
     costTotal = sessionCost(ctx)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-code",
-  "version": "1.0.10",
+  "version": "1.0.11",
   "description": "Claude Code experience for the pi coding agent: reads your .claude config (rules, commands, skills, hooks, output styles, MCP servers, agents) and adds todo, checkpoints, memory, web, and subagents",
   "keywords": [
     "pi",