pi-code 0.1.0

package/extensions/output-styles.ts

@@ -0,0 +1,159 @@
+/**
+ * Output Styles Extension
+ *
+ * Bridges Claude Code's output styles into pi. It discovers `.claude/output-styles/*.md`
+ * (user then project), honors the active style recorded as `outputStyle` in
+ * `.claude/settings.json` (user, project, then settings.local.json, last wins),
+ * and appends that style's body to the system prompt so the agent adopts its
+ * tone and role. `/output-style` lists the styles and persists a choice to the
+ * project's settings.local.json.
+ *
+ * pi keeps its own base system prompt (tools, safety); the style is layered on
+ * top rather than replacing it wholesale.
+ *
+ * Docs: https://code.claude.com/docs/en/output-styles.md
+ */
+
+import * as fs from 'node:fs'
+import * as os from 'node:os'
+import * as path from 'node:path'
+import type { ExtensionAPI } from '@earendil-works/pi-coding-agent'
+
+export interface OutputStyle {
+  name: string
+  description: string
+  body: string
+}
+
+function field(frontmatter: string, key: string): string {
+  const match = new RegExp(`^\\s*${key}\\s*:\\s*(.+)$`, 'm').exec(frontmatter)
+  return match ? match[1].trim().replace(/^["']|["']$/g, '') : ''
+}
+
+/** Parse an output-style markdown file into its name, description, and body. */
+export function parseStyle(content: string, fallbackName: string): OutputStyle {
+  const match = /^---\r?\n([\s\S]*?)\r?\n---/.exec(content)
+  const frontmatter = match ? match[1] : ''
+  const body = match ? content.slice(match[0].length) : content
+  return { name: field(frontmatter, 'name') || fallbackName, description: field(frontmatter, 'description'), body: body.trim() }
+}
+
+function isDirectory(target: string): boolean {
+  try {
+    return fs.statSync(target).isDirectory()
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Existing `.claude/output-styles` directories, user first then project. The project
+ * directory is included only for trusted projects, since its style body is injected
+ * verbatim into the system prompt.
+ */
+export function styleDirs(cwd: string, home: string, trusted: boolean): string[] {
+  const dirs = [path.join(home, '.claude', 'output-styles')]
+  if (trusted) dirs.push(path.join(cwd, '.claude', 'output-styles'))
+  return dirs.filter((dir) => isDirectory(dir))
+}
+
+/** All output styles, project entries overriding user entries of the same name. */
+export function loadStyles(dirs: string[]): OutputStyle[] {
+  const byName = new Map<string, OutputStyle>()
+  for (const dir of dirs) {
+    let entries: string[]
+    try {
+      entries = fs.readdirSync(dir)
+    } catch {
+      continue
+    }
+    for (const entry of entries) {
+      if (!entry.endsWith('.md')) continue
+      const style = parseStyle(fs.readFileSync(path.join(dir, entry), 'utf-8'), entry.replace(/\.md$/, ''))
+      byName.set(style.name, style)
+    }
+  }
+  return [...byName.values()]
+}
+
+/** Settings files that carry `outputStyle`. Project settings apply only when trusted. */
+export function settingsFiles(cwd: string, home: string, trusted: boolean): string[] {
+  const files = [path.join(home, '.claude', 'settings.json')]
+  if (trusted) files.push(path.join(cwd, '.claude', 'settings.json'), path.join(cwd, '.claude', 'settings.local.json'))
+  return files
+}
+
+/** The `outputStyle` recorded in settings, last file winning. */
+export function readActiveStyleName(files: string[]): string | undefined {
+  let name: string | undefined
+  for (const file of files) {
+    try {
+      const settings = JSON.parse(fs.readFileSync(file, 'utf-8'))
+      if (typeof settings.outputStyle === 'string') name = settings.outputStyle
+    } catch {
+      // missing or invalid file: skip
+    }
+  }
+  return name
+}
+
+export function styleForName(styles: OutputStyle[], name: string | undefined): OutputStyle | undefined {
+  return name ? styles.find((style) => style.name === name) : undefined
+}
+
+function persistActiveStyle(file: string, name: string): void {
+  let config: Record<string, unknown> = {}
+  try {
+    config = JSON.parse(fs.readFileSync(file, 'utf-8'))
+  } catch {
+    // start from an empty config when the file is missing or invalid
+  }
+  config.outputStyle = name
+  fs.mkdirSync(path.dirname(file), { recursive: true })
+  fs.writeFileSync(file, `${JSON.stringify(config, null, 2)}\n`)
+}
+
+export default function outputStylesExtension(pi: ExtensionAPI) {
+  let styles: OutputStyle[] = []
+  let activeName: string | undefined
+  let localSettingsPath = ''
+
+  pi.on('session_start', async (_event, ctx) => {
+    const home = os.homedir()
+    // A project style body is injected verbatim into the system prompt, so only honor
+    // project styles / selection once the project is trusted.
+    const trusted = ctx.isProjectTrusted?.() ?? false
+    styles = loadStyles(styleDirs(ctx.cwd, home, trusted))
+    localSettingsPath = path.join(ctx.cwd, '.claude', 'settings.local.json')
+    activeName = readActiveStyleName(settingsFiles(ctx.cwd, home, trusted))
+    const active = styleForName(styles, activeName)
+    if (active) ctx.ui.notify(`Output style: ${active.name}`, 'info')
+  })
+
+  pi.on('before_agent_start', async (event) => {
+    const active = styleForName(styles, activeName)
+    if (!active || active.body.length === 0) return
+    return { systemPrompt: `${event.systemPrompt}\n\n## Output Style: ${active.name}\n\n${active.body}` }
+  })
+
+  pi.registerCommand('output-style', {
+    description: 'Choose the active Claude output style',
+    handler: async (_args, ctx) => {
+      if (!ctx.hasUI) {
+        ctx.ui.notify('/output-style requires interactive mode', 'error')
+        return
+      }
+      if (styles.length === 0) {
+        ctx.ui.notify('No output styles found in .claude/output-styles', 'info')
+        return
+      }
+      const labels = styles.map((style) => (style.description ? `${style.name} — ${style.description}` : style.name))
+      const choice = await ctx.ui.select('Output style:', labels)
+      if (!choice) return
+      const picked = styles[labels.indexOf(choice)]
+      activeName = picked.name
+      persistActiveStyle(localSettingsPath, picked.name)
+      ctx.ui.notify(`Output style set to ${picked.name} (applies next turn)`, 'info')
+    },
+  })
+}

package/extensions/plan-mode/README.md

@@ -0,0 +1,65 @@
+# Plan Mode Extension
+
+Read-only exploration mode for safe code analysis.
+
+## Features
+
+- **Read-only tools**: Restricts available tools to read, bash, grep, find, ls, question
+- **Bash allowlist**: Only read-only bash commands are allowed
+- **Plan extraction**: Extracts numbered steps from `Plan:` sections
+- **Progress tracking**: Widget shows completion status during execution
+- **[DONE:n] markers**: Explicit step completion tracking
+- **Session persistence**: State survives session resume
+
+## Commands
+
+- `/plan` - Toggle plan mode
+- `/todos` - Show current plan progress
+- `Ctrl+Alt+P` - Toggle plan mode (shortcut)
+
+## Usage
+
+1. Enable plan mode with `/plan` or `--plan` flag
+2. Ask the agent to analyze code and create a plan
+3. The agent should output a numbered plan under a `Plan:` header:
+
+```
+Plan:
+1. First step description
+2. Second step description
+3. Third step description
+```
+
+4. Choose "Execute the plan" when prompted
+5. During execution, the agent marks steps complete with `[DONE:n]` tags
+6. Progress widget shows completion status
+
+## How It Works
+
+### Plan Mode (Read-Only)
+- Only read-only tools available
+- Bash commands filtered through allowlist
+- Agent creates a plan without making changes
+
+### Execution Mode
+- Full tool access restored
+- Agent executes steps in order
+- `[DONE:n]` markers track completion
+- Widget shows progress
+
+### Command Allowlist
+
+Safe commands (allowed):
+- File inspection: `cat`, `head`, `tail`, `less`, `more`
+- Search: `grep`, `find`, `rg`, `fd`
+- Directory: `ls`, `pwd`, `tree`
+- Git read: `git status`, `git log`, `git diff`, `git branch`
+- Package info: `npm list`, `npm outdated`, `yarn info`
+- System info: `uname`, `whoami`, `date`, `uptime`
+
+Blocked commands:
+- File modification: `rm`, `mv`, `cp`, `mkdir`, `touch`
+- Git write: `git add`, `git commit`, `git push`
+- Package install: `npm install`, `yarn add`, `pip install`
+- System: `sudo`, `kill`, `reboot`
+- Editors: `vim`, `nano`, `code`

package/extensions/plan-mode/index.ts

@@ -0,0 +1,352 @@
+/**
+ * Plan Mode Extension
+ *
+ * Read-only exploration mode for safe code analysis.
+ * When enabled, only read-only tools are available.
+ *
+ * Features:
+ * - /plan command or Ctrl+Alt+P to toggle
+ * - Bash restricted to allowlisted read-only commands
+ * - Extracts numbered plan steps from "Plan:" sections
+ * - [DONE:n] markers to complete steps during execution
+ * - Progress tracking widget during execution
+ */
+
+import type { AgentMessage } from '@earendil-works/pi-agent-core'
+import type { AssistantMessage, TextContent } from '@earendil-works/pi-ai'
+import type { ExtensionAPI, ExtensionContext } from '@earendil-works/pi-coding-agent'
+import { Key } from '@earendil-works/pi-tui'
+import { Type } from 'typebox'
+import { extractTodoItems, isSafeCommand, markCompletedSteps, planToTodos, type TodoItem } from './utils.js'
+
+// Tools
+const PLAN_MODE_TOOLS = ['read', 'bash', 'grep', 'find', 'ls', 'question', 'plan_mode_complete']
+
+// Type guard for assistant messages
+function isAssistantMessage(m: AgentMessage): m is AssistantMessage {
+  return m.role === 'assistant' && Array.isArray(m.content)
+}
+
+// Extract text content from an assistant message
+function getTextContent(message: AssistantMessage): string {
+  return message.content
+    .filter((block): block is TextContent => block.type === 'text')
+    .map((block) => block.text)
+    .join('\n')
+}
+
+export default function planModeExtension(pi: ExtensionAPI): void {
+  let planModeEnabled = false
+  let executionMode = false
+  let todoItems: TodoItem[] = []
+  let planFromTool = false
+  let savedTools: string[] = []
+
+  function enterPlanTools(): void {
+    savedTools = pi.getActiveTools()
+    pi.setActiveTools(PLAN_MODE_TOOLS.filter((t) => savedTools.includes(t)))
+  }
+
+  function restoreTools(): void {
+    if (savedTools.length > 0) {
+      pi.setActiveTools(savedTools)
+    }
+  }
+
+  pi.registerFlag('plan', {
+    description: 'Start in plan mode (read-only exploration)',
+    type: 'boolean',
+    default: false,
+  })
+
+  function updateStatus(ctx: ExtensionContext): void {
+    // Footer status
+    if (executionMode && todoItems.length > 0) {
+      const completed = todoItems.filter((t) => t.completed).length
+      ctx.ui.setStatus('plan-mode', ctx.ui.theme.fg('accent', `📋 ${completed}/${todoItems.length}`))
+    } else if (planModeEnabled) {
+      ctx.ui.setStatus('plan-mode', ctx.ui.theme.fg('warning', '⏸ plan'))
+    } else {
+      ctx.ui.setStatus('plan-mode', undefined)
+    }
+
+    // Widget showing todo list
+    if (executionMode && todoItems.length > 0) {
+      const lines = todoItems.map((item) => {
+        if (item.completed) {
+          return ctx.ui.theme.fg('success', '☑ ') + ctx.ui.theme.fg('muted', ctx.ui.theme.strikethrough(item.text))
+        }
+        return `${ctx.ui.theme.fg('muted', '☐ ')}${item.text}`
+      })
+      ctx.ui.setWidget('plan-todos', lines)
+    } else {
+      ctx.ui.setWidget('plan-todos', undefined)
+    }
+  }
+
+  function togglePlanMode(ctx: ExtensionContext): void {
+    planModeEnabled = !planModeEnabled
+    executionMode = false
+    todoItems = []
+    planFromTool = false
+
+    if (planModeEnabled) {
+      enterPlanTools()
+      ctx.ui.notify(`Plan mode enabled. Tools: ${pi.getActiveTools().join(', ')}`)
+    } else {
+      restoreTools()
+      ctx.ui.notify('Plan mode disabled. Full access restored.')
+    }
+    updateStatus(ctx)
+  }
+
+  function persistState(): void {
+    pi.appendEntry('plan-mode', {
+      enabled: planModeEnabled,
+      todos: todoItems,
+      executing: executionMode,
+    })
+  }
+
+  pi.registerCommand('plan', {
+    description: 'Toggle plan mode (read-only exploration)',
+    handler: async (_args, ctx) => togglePlanMode(ctx),
+  })
+
+  pi.registerTool({
+    name: 'plan_mode_complete',
+    label: 'Plan complete',
+    description: 'Submit the finished plan for user review while in plan mode. Pass the full plan as numbered steps (1. ... 2. ...). Call this exactly once, when the plan is ready.',
+    parameters: Type.Object({ plan: Type.String({ description: 'The complete numbered plan' }) }),
+    async execute(_id, params) {
+      if (!planModeEnabled) {
+        return { content: [{ type: 'text', text: 'Not in plan mode; tool ignored.' }], details: {} }
+      }
+      todoItems = planToTodos(params.plan)
+      planFromTool = true
+      persistState()
+      return { content: [{ type: 'text', text: 'Plan submitted. The user will now review it.' }], details: {}, terminate: true }
+    },
+  })
+
+  pi.registerCommand('plan-todos', {
+    description: 'Show current plan todo list',
+    handler: async (_args, ctx) => {
+      if (todoItems.length === 0) {
+        ctx.ui.notify('No todos. Create a plan first with /plan', 'info')
+        return
+      }
+      const list = todoItems.map((item, i) => `${i + 1}. ${item.completed ? '✓' : '○'} ${item.text}`).join('\n')
+      ctx.ui.notify(`Plan Progress:\n${list}`, 'info')
+    },
+  })
+
+  pi.registerShortcut(Key.ctrlAlt('p'), {
+    description: 'Toggle plan mode',
+    handler: async (ctx) => togglePlanMode(ctx),
+  })
+
+  // Block destructive bash commands in plan mode
+  pi.on('tool_call', async (event) => {
+    if (!planModeEnabled || event.toolName !== 'bash') return
+
+    const command = event.input.command as string
+    if (!isSafeCommand(command)) {
+      return {
+        block: true,
+        reason: `Plan mode: command blocked (not allowlisted). Use /plan to disable plan mode first.\nCommand: ${command}`,
+      }
+    }
+  })
+
+  // Filter out stale plan mode context when not in plan mode
+  pi.on('context', async (event) => {
+    if (planModeEnabled) return
+
+    return {
+      messages: event.messages.filter((m) => {
+        const msg = m as AgentMessage & { customType?: string }
+        if (msg.customType === 'plan-mode-context') return false
+        if (msg.role !== 'user') return true
+
+        const content = msg.content
+        if (typeof content === 'string') {
+          return !content.includes('[PLAN MODE ACTIVE]')
+        }
+        if (Array.isArray(content)) {
+          return !content.some((c) => c.type === 'text' && (c as TextContent).text?.includes('[PLAN MODE ACTIVE]'))
+        }
+        return true
+      }),
+    }
+  })
+
+  // Inject plan/execution context before agent starts
+  pi.on('before_agent_start', async () => {
+    if (planModeEnabled) {
+      return {
+        message: {
+          customType: 'plan-mode-context',
+          content: `[PLAN MODE ACTIVE]
+You are in plan mode - a read-only exploration mode for safe code analysis.
+
+Restrictions:
+- You can only use: read, bash, grep, find, ls, question
+- You CANNOT use: edit, write (file modifications are disabled)
+- Bash is restricted to an allowlist of read-only commands
+
+Ask clarifying questions using the question tool.
+
+When your plan is ready, call the plan_mode_complete tool with the full plan as numbered steps:
+
+1. First step description
+2. Second step description
+...
+
+Do NOT attempt to make changes - just describe what you would do.`,
+          display: false,
+        },
+      }
+    }
+
+    if (executionMode && todoItems.length > 0) {
+      const remaining = todoItems.filter((t) => !t.completed)
+      const todoList = remaining.map((t) => `${t.step}. ${t.text}`).join('\n')
+      return {
+        message: {
+          customType: 'plan-execution-context',
+          content: `[EXECUTING PLAN - Full tool access enabled]
+
+Remaining steps:
+${todoList}
+
+Execute each step in order.
+After completing a step, include a [DONE:n] tag in your response.`,
+          display: false,
+        },
+      }
+    }
+  })
+
+  // Track progress after each turn
+  pi.on('turn_end', async (event, ctx) => {
+    if (!executionMode || todoItems.length === 0) return
+    if (!isAssistantMessage(event.message)) return
+
+    const text = getTextContent(event.message)
+    if (markCompletedSteps(text, todoItems) > 0) {
+      updateStatus(ctx)
+    }
+    persistState()
+  })
+
+  // Handle plan completion and plan mode UI
+  pi.on('agent_end', async (event, ctx) => {
+    // Check if execution is complete
+    if (executionMode && todoItems.length > 0) {
+      if (todoItems.every((t) => t.completed)) {
+        const completedList = todoItems.map((t) => `~~${t.text}~~`).join('\n')
+        pi.sendMessage({ customType: 'plan-complete', content: `**Plan Complete!** ✓\n\n${completedList}`, display: true }, { triggerTurn: false })
+        executionMode = false
+        todoItems = []
+        restoreTools()
+        updateStatus(ctx)
+        persistState() // Save cleared state so resume doesn't restore old execution mode
+      }
+      return
+    }
+
+    if (!planModeEnabled || !ctx.hasUI) return
+
+    // Prefer an explicitly submitted plan; fall back to extracting from prose
+    if (!planFromTool) {
+      const lastAssistant = [...event.messages].reverse().find(isAssistantMessage)
+      if (lastAssistant) {
+        const extracted = extractTodoItems(getTextContent(lastAssistant))
+        if (extracted.length > 0) {
+          todoItems = extracted
+        }
+      }
+    }
+
+    // Show plan steps and prompt for next action
+    if (todoItems.length > 0) {
+      const todoListText = todoItems.map((t, i) => `${i + 1}. ☐ ${t.text}`).join('\n')
+      pi.sendMessage(
+        {
+          customType: 'plan-todo-list',
+          content: `**Plan Steps (${todoItems.length}):**\n\n${todoListText}`,
+          display: true,
+        },
+        { triggerTurn: false },
+      )
+    }
+
+    const choice = await ctx.ui.select('Plan mode - what next?', [todoItems.length > 0 ? 'Execute the plan (track progress)' : 'Execute the plan', 'Stay in plan mode', 'Refine the plan'])
+
+    if (choice?.startsWith('Execute')) {
+      planModeEnabled = false
+      executionMode = todoItems.length > 0
+      planFromTool = false
+      restoreTools()
+      updateStatus(ctx)
+
+      const execMessage = todoItems.length > 0 ? `Execute the plan. Start with: ${todoItems[0].text}` : 'Execute the plan you just created.'
+      pi.sendMessage({ customType: 'plan-mode-execute', content: execMessage, display: true }, { triggerTurn: true })
+    } else if (choice === 'Refine the plan') {
+      const refinement = await ctx.ui.editor('Refine the plan:', '')
+      if (refinement?.trim()) {
+        pi.sendUserMessage(refinement.trim())
+      }
+    }
+  })
+
+  // Restore state on session start/resume
+  pi.on('session_start', async (_event, ctx) => {
+    if (pi.getFlag('plan') === true) {
+      planModeEnabled = true
+    }
+
+    const entries = ctx.sessionManager.getEntries()
+
+    // Restore persisted state
+    const planModeEntry = entries.filter((e: { type: string; customType?: string }) => e.type === 'custom' && e.customType === 'plan-mode').pop() as { data?: { enabled: boolean; todos?: TodoItem[]; executing?: boolean } } | undefined
+
+    if (planModeEntry?.data) {
+      planModeEnabled = planModeEntry.data.enabled ?? planModeEnabled
+      todoItems = planModeEntry.data.todos ?? todoItems
+      executionMode = planModeEntry.data.executing ?? executionMode
+    }
+
+    // On resume: re-scan messages to rebuild completion state
+    // Only scan messages AFTER the last "plan-mode-execute" to avoid picking up [DONE:n] from previous plans
+    const isResume = planModeEntry !== undefined
+    if (isResume && executionMode && todoItems.length > 0) {
+      // Find the index of the last plan-mode-execute entry (marks when current execution started)
+      let executeIndex = -1
+      for (let i = entries.length - 1; i >= 0; i--) {
+        const entry = entries[i] as { type: string; customType?: string }
+        if (entry.customType === 'plan-mode-execute') {
+          executeIndex = i
+          break
+        }
+      }
+
+      // Only scan messages after the execute marker
+      const messages: AssistantMessage[] = []
+      for (let i = executeIndex + 1; i < entries.length; i++) {
+        const entry = entries[i]
+        if (entry.type === 'message' && 'message' in entry && isAssistantMessage(entry.message as AgentMessage)) {
+          messages.push(entry.message as AssistantMessage)
+        }
+      }
+      const allText = messages.map(getTextContent).join('\n')
+      markCompletedSteps(allText, todoItems)
+    }
+
+    if (planModeEnabled) {
+      enterPlanTools()
+    }
+    updateStatus(ctx)
+  })
+}