@raidou/pi-pm-subagents 0.1.1

package/src/custom-select.ts

@@ -0,0 +1,209 @@
+import type { ExtensionContext, Theme } from '@earendil-works/pi-coding-agent'
+import { DynamicBorder } from '@earendil-works/pi-coding-agent'
+import type { Focusable, TUI } from '@earendil-works/pi-tui'
+import {
+  Container,
+  fuzzyFilter,
+  Input,
+  Key,
+  matchesKey,
+  Spacer,
+  Text,
+} from '@earendil-works/pi-tui'
+
+export interface CustomSelectItem {
+  readonly key: string
+  readonly text: string
+}
+
+export interface CustomSelectOptions {
+  readonly items: readonly CustomSelectItem[]
+  readonly title?: string
+  readonly placeholder?: string
+  readonly maxVisible?: number
+}
+
+/** Open a searchable, height-limited selector over `{ key, text }` items. */
+export async function customSelect(
+  ctx: ExtensionContext,
+  options: CustomSelectOptions,
+): Promise<string | undefined> {
+  return ctx.ui.custom<string | undefined>((tui, theme, _keybindings, done) => {
+    return new CustomSelectComponent(
+      tui,
+      theme,
+      options,
+      (key) => {
+        done(key)
+      },
+      () => {
+        done(undefined)
+      },
+    )
+  })
+}
+
+/**
+ * Searchable, height-limited selector over a list of `{ key, text }` items.
+ * Returns the picked item's `key` (or undefined on cancel).
+ */
+export class CustomSelectComponent extends Container implements Focusable {
+  readonly #tui: TUI
+  readonly #theme: Theme
+  readonly #items: readonly CustomSelectItem[]
+  readonly #placeholder: string
+  readonly #maxVisible: number
+  readonly #searchInput: Input
+  readonly #listContainer: Container
+  readonly #onSelect: (key: string) => void
+  readonly #onCancel: () => void
+  #focused = false
+  #filtered: CustomSelectItem[]
+  #selectedIndex = 0
+
+  constructor(
+    tui: TUI,
+    theme: Theme,
+    options: CustomSelectOptions,
+    onSelect: (key: string) => void,
+    onCancel: () => void,
+  ) {
+    super()
+    this.#tui = tui
+    this.#theme = theme
+    this.#items = options.items
+    this.#placeholder = options.placeholder ?? 'filter'
+    this.#maxVisible = options.maxVisible ?? 10
+    this.#onSelect = onSelect
+    this.#onCancel = onCancel
+    this.#filtered = [...this.#items]
+
+    const borderColor = (s: string) => theme.fg('borderMuted', s)
+
+    this.addChild(new DynamicBorder(borderColor))
+    this.addChild(new Spacer(1))
+    this.addChild(
+      new Text(theme.fg('accent', theme.bold(options.title ?? 'Select')), 1, 0),
+    )
+    this.addChild(new Spacer(1))
+    this.addChild(new Text(theme.fg('muted', this.#placeholder), 1, 0))
+
+    this.#searchInput = new Input()
+    this.#searchInput.onSubmit = () => {
+      this.#confirm()
+    }
+    this.addChild(this.#searchInput)
+    this.addChild(new Spacer(1))
+
+    this.#listContainer = new Container()
+    this.addChild(this.#listContainer)
+    this.addChild(new Spacer(1))
+    this.addChild(new DynamicBorder(borderColor))
+
+    this.#renderList()
+  }
+
+  get focused(): boolean {
+    return this.#focused
+  }
+
+  set focused(value: boolean) {
+    this.#focused = value
+    this.#searchInput.focused = value
+  }
+
+  handleInput(keyData: string): void {
+    if (matchesKey(keyData, Key.up) || matchesKey(keyData, Key.ctrl('p'))) {
+      this.#move(-1)
+    } else if (
+      matchesKey(keyData, Key.down) ||
+      matchesKey(keyData, Key.ctrl('n'))
+    ) {
+      this.#move(1)
+    } else if (
+      matchesKey(keyData, Key.pageUp) ||
+      matchesKey(keyData, Key.ctrl('u'))
+    ) {
+      this.#move(-this.#maxVisible)
+    } else if (
+      matchesKey(keyData, Key.pageDown) ||
+      matchesKey(keyData, Key.ctrl('d'))
+    ) {
+      this.#move(this.#maxVisible)
+    } else if (matchesKey(keyData, Key.enter)) {
+      this.#confirm()
+    } else if (
+      matchesKey(keyData, Key.escape) ||
+      matchesKey(keyData, Key.ctrl('c'))
+    ) {
+      this.#onCancel()
+    } else {
+      this.#searchInput.handleInput(keyData)
+      this.#refilter(this.#searchInput.getValue())
+    }
+  }
+
+  #move(delta: number): void {
+    if (this.#filtered.length === 0) return
+    const last = this.#filtered.length - 1
+    this.#selectedIndex =
+      delta > 0
+        ? Math.min(last, this.#selectedIndex + delta)
+        : Math.max(0, this.#selectedIndex + delta)
+    this.#renderList()
+    this.#tui.requestRender()
+  }
+
+  #confirm(): void {
+    const picked = this.#filtered[this.#selectedIndex]
+    if (picked) this.#onSelect(picked.key)
+  }
+
+  #refilter(query: string): void {
+    const needle = query.trim().toLowerCase()
+    const source: CustomSelectItem[] = [...this.#items]
+    this.#filtered = needle
+      ? fuzzyFilter(source, needle, (item) => item.text)
+      : source
+    this.#selectedIndex = 0
+    this.#renderList()
+    this.#tui.requestRender()
+  }
+
+  #renderList(): void {
+    this.#listContainer.clear()
+    const total = this.#filtered.length
+    const visible = Math.min(this.#maxVisible, total)
+    const start = Math.max(
+      0,
+      Math.min(
+        this.#selectedIndex - Math.floor(this.#maxVisible / 2),
+        total - visible,
+      ),
+    )
+    const end = start + visible
+    for (let i = start; i < end; i++) {
+      const item = this.#filtered[i]
+      if (!item) continue
+      const prefix = i === this.#selectedIndex ? '→ ' : '  '
+      const text =
+        i === this.#selectedIndex
+          ? this.#theme.fg('accent', item.text)
+          : item.text
+      this.#listContainer.addChild(new Text(`${prefix}${text}`, 1, 0))
+    }
+    if (total > visible) {
+      this.#listContainer.addChild(
+        new Text(
+          this.#theme.fg('muted', `  (${this.#selectedIndex + 1}/${total})`),
+          1,
+          0,
+        ),
+      )
+    } else if (total === 0) {
+      this.#listContainer.addChild(
+        new Text(this.#theme.fg('muted', '  No matches'), 1, 0),
+      )
+    }
+  }
+}

package/src/index.ts

@@ -0,0 +1,87 @@
+import type { ExtensionAPI } from '@earendil-works/pi-coding-agent'
+
+import { setupBashReadonlyTool } from './bash-readonly.js'
+import {
+  applyCoordinatorMode,
+  enterCoordinatorMode,
+  setupCoordinator,
+} from './coordinator/coordinator.js'
+import {
+  getPmSubagentsConfig,
+  loadPmSubagentsConfig,
+  setupPmSubagentsConfig,
+} from './models-config/models-config.js'
+import { setupSubagentModelCycle } from './models-config/subagent-model-cycle.js'
+import { readModePrompt } from './prompts/mode.js'
+import { isSubagentSpawnContext } from './subagent/identity.js'
+import type { PmSubagentState } from './types.js'
+import { createState, getLastPmSubagentState } from './utils/state.js'
+
+let pendingPmSubagentState: Partial<PmSubagentState> | undefined
+
+export default async function pmSubagentsExtension(
+  pi: ExtensionAPI,
+): Promise<void> {
+  setupBashReadonlyTool(pi)
+  if (isSubagentSpawnContext()) {
+    return
+  }
+
+  const state = createState()
+  await loadPmSubagentsConfig()
+
+  const coordinatorDefinition = await readModePrompt('coordinator')
+
+  const demoEnabled = process.env.PI_DEMO === '1'
+
+  await setupCoordinator(pi, state, {
+    demoEnabled,
+    coordinatorDefinition,
+  })
+  setupPmSubagentsConfig(pi, state, coordinatorDefinition)
+  setupSubagentModelCycle(pi, state)
+
+  pi.on('session_before_switch', (_event, ctx) => {
+    pendingPmSubagentState = getLastPmSubagentState(
+      ctx.sessionManager.getEntries(),
+    )
+  })
+
+  pi.on('session_before_fork', (_event, ctx) => {
+    pendingPmSubagentState = getLastPmSubagentState(
+      ctx.sessionManager.getEntries(),
+    )
+  })
+
+  pi.on('session_start', async (_event, ctx) => {
+    let data = getLastPmSubagentState(ctx.sessionManager.getEntries())
+
+    if (!data && pendingPmSubagentState) {
+      data = pendingPmSubagentState
+      pendingPmSubagentState = undefined
+    }
+
+    if (data) {
+      state.mode = data.mode
+      state.modeDiffTools = data.modeDiffTools
+      state.previousModel = data.previousModel
+      state.sessionSubagentModel = data.sessionSubagentModel
+
+      if (state.mode === 'coordinator') {
+        await applyCoordinatorMode(pi, state, ctx, coordinatorDefinition)
+      }
+
+      return
+    }
+
+    if (getPmSubagentsConfig().defaultMode === 'coordinator') {
+      await enterCoordinatorMode(
+        pi,
+        state,
+        undefined,
+        ctx,
+        coordinatorDefinition,
+      )
+    }
+  })
+}

package/src/models-config/models-config.test.ts

@@ -0,0 +1,88 @@
+import { describe, expect, it } from 'vitest'
+
+import type { PmSubagentsConfig } from './models-config.js'
+import { sanitizeConfig } from './models-config.js'
+import { MODEL_DEFAULT } from './subagent-model-constants.js'
+
+describe('PmSubagentsConfig schema', () => {
+  it('has subagentModelScope field', () => {
+    const config: PmSubagentsConfig = {
+      subagentModelScoped: [MODEL_DEFAULT, 'provider/model'],
+    }
+    expect(config.subagentModelScoped).toBeDefined()
+    expect(config.subagentModelScoped?.length).toBe(2)
+  })
+
+  it('has subagentModel field', () => {
+    const config: PmSubagentsConfig = {
+      subagentModel: 'anthropic/claude-sonnet-4-5',
+    }
+    expect(config.subagentModel).toBe('anthropic/claude-sonnet-4-5')
+  })
+})
+
+describe('sanitizeConfig', () => {
+  it('keeps defaultMode when it is coordinator', () => {
+    expect(sanitizeConfig({ defaultMode: 'coordinator' })).toEqual({
+      defaultMode: 'coordinator',
+    })
+  })
+
+  it('clears invalid defaultMode', () => {
+    expect(sanitizeConfig({ defaultMode: 'bogus' })).toEqual({})
+  })
+
+  it('keeps valid subagentModel and scope', () => {
+    const config = sanitizeConfig({
+      subagentModel: 'provider/model',
+      subagentModelScoped: ['provider/model', MODEL_DEFAULT],
+    })
+    expect(config.subagentModel).toBe('provider/model')
+    expect(config.subagentModelScoped).toEqual([
+      'provider/model',
+      MODEL_DEFAULT,
+    ])
+  })
+
+  it('clears invalid subagentModel and empty scope', () => {
+    const config = sanitizeConfig({
+      subagentModel: 'no-slash',
+      subagentModelScoped: ['also-bad'],
+    })
+    expect(config.subagentModel).toBeUndefined()
+    expect(config.subagentModelScoped).toBeUndefined()
+  })
+
+  it('keeps valid skipPluginAgents', () => {
+    expect(sanitizeConfig({ skipPluginAgents: true })).toEqual({
+      skipPluginAgents: true,
+    })
+  })
+
+  it('clears invalid skipPluginAgents', () => {
+    expect(
+      sanitizeConfig({ skipPluginAgents: 'yes' as unknown as boolean }),
+    ).toEqual({})
+  })
+
+  it('clears invalid defaultMode without affecting a valid subagentModel', () => {
+    expect(
+      sanitizeConfig({
+        subagentModel: 'provider/model',
+        defaultMode: 'bogus',
+      }),
+    ).toEqual({ subagentModel: 'provider/model' })
+  })
+
+  it('does not mutate the input record', () => {
+    const record: PmSubagentsConfig = {
+      subagentModel: 'no-slash',
+      defaultMode: 'bogus',
+    }
+    sanitizeConfig(record)
+    expect(record).toEqual({
+      subagentModel: 'no-slash',
+      defaultMode: 'bogus',
+    })
+  })
+})

package/src/models-config/models-config.ts

@@ -0,0 +1,205 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises'
+import { dirname, join } from 'node:path'
+
+import type {
+  ExtensionAPI,
+  ExtensionContext,
+} from '@earendil-works/pi-coding-agent'
+import { getAgentDir } from '@earendil-works/pi-coding-agent'
+import type { Static } from 'typebox'
+import { Type } from 'typebox'
+import { Parse } from 'typebox/value'
+
+import {
+  enterCoordinatorMode,
+  renderCoordinatorModeWidget,
+} from '../coordinator/coordinator.js'
+import { customSelect } from '../custom-select.js'
+import type { PmSubagentState } from '../types.js'
+import type { PromptDefinition } from '../utils/markdown.js'
+import {
+  modelOptionOf,
+  parseModelRef,
+  resolveModelRef,
+} from '../utils/model-ref.js'
+import { scopedModelsEditor } from './scoped-models-editor.js'
+import {
+  MODEL_DEFAULT,
+  MODEL_DEFAULT_LABEL,
+} from './subagent-model-constants.js'
+
+const PmSubagentsConfigSchema = Type.Object({
+  subagentModel: Type.Optional(Type.String()),
+  subagentModelScoped: Type.Optional(Type.Array(Type.String())),
+  defaultMode: Type.Optional(Type.String()),
+  skipPluginAgents: Type.Optional(Type.Boolean()),
+})
+
+export function sanitizeConfig(record: PmSubagentsConfig): PmSubagentsConfig {
+  const model = record.subagentModel
+  const subagentModel = model && !parseModelRef(model) ? undefined : model
+
+  let subagentModelScoped = record.subagentModelScoped
+  if (subagentModelScoped) {
+    const filtered = subagentModelScoped.filter(
+      (ref) => ref === MODEL_DEFAULT || parseModelRef(ref) !== undefined,
+    )
+    subagentModelScoped = filtered.length > 0 ? filtered : undefined
+  }
+
+  const defaultMode =
+    record.defaultMode === 'coordinator' ? 'coordinator' : undefined
+
+  const skipPluginAgents =
+    typeof record.skipPluginAgents === 'boolean'
+      ? record.skipPluginAgents
+      : undefined
+
+  return {
+    subagentModel,
+    subagentModelScoped,
+    defaultMode,
+    skipPluginAgents,
+  }
+}
+
+export type PmSubagentsConfig = Static<typeof PmSubagentsConfigSchema>
+
+let pmSubagentsConfig: PmSubagentsConfig = {}
+
+function configPath(): string {
+  return join(getAgentDir(), 'pi-pm-subagents.json')
+}
+
+export async function loadPmSubagentsConfig(): Promise<void> {
+  try {
+    const raw: unknown = JSON.parse(await readFile(configPath(), 'utf8'))
+    pmSubagentsConfig = sanitizeConfig(Parse(PmSubagentsConfigSchema, raw))
+  } catch {
+    pmSubagentsConfig = {}
+  }
+}
+
+export function getPmSubagentsConfig(): PmSubagentsConfig {
+  return pmSubagentsConfig
+}
+
+export async function setSubagentModelScoped(scope: string[]): Promise<void> {
+  pmSubagentsConfig.subagentModelScoped = scope
+  await savePmSubagentsConfig()
+}
+
+export async function setSubagentModel(
+  model: string | undefined,
+): Promise<void> {
+  pmSubagentsConfig.subagentModel = model
+  await savePmSubagentsConfig()
+}
+
+export async function setDefaultMode(
+  mode: 'coordinator' | undefined,
+): Promise<void> {
+  pmSubagentsConfig.defaultMode = mode
+  await savePmSubagentsConfig()
+}
+
+async function savePmSubagentsConfig(): Promise<void> {
+  await mkdir(dirname(configPath()), { recursive: true })
+  await writeFile(
+    configPath(),
+    `${JSON.stringify(pmSubagentsConfig, null, 2)}\n`,
+    'utf8',
+  )
+}
+
+async function pickModel(ctx: ExtensionContext): Promise<string | undefined> {
+  const items: Array<{ key: string; text: string }> = [
+    { key: MODEL_DEFAULT, text: MODEL_DEFAULT_LABEL },
+    ...ctx.modelRegistry.getAvailable().map(modelOptionOf),
+  ]
+  return customSelect(ctx, {
+    items,
+    title: 'Choose model',
+    placeholder: 'filter (provider/id substring)',
+  })
+}
+
+export function setupPmSubagentsConfig(
+  pi: ExtensionAPI,
+  state: PmSubagentState,
+  coordinatorDefinition: PromptDefinition,
+): void {
+  pi.registerCommand('pm-subagent-model', {
+    description: 'Configure the subagent model',
+    handler: async (_args, ctx) => {
+      const model = await pickModel(ctx)
+      if (!model) {
+        ctx.ui.notify('No model selected', 'warning')
+        return
+      }
+
+      const isDefaultModel = model === MODEL_DEFAULT
+      if (!isDefaultModel && !resolveModelRef(ctx, [model])) {
+        ctx.ui.notify(`Unknown model "${model}"`, 'warning')
+        return
+      }
+
+      await setSubagentModel(isDefaultModel ? undefined : model)
+      state.sessionSubagentModel = isDefaultModel ? undefined : model
+
+      const current = pmSubagentsConfig.subagentModel ?? MODEL_DEFAULT
+      ctx.ui.notify(`Subagent model: ${current}`, 'info')
+      if (state.mode === 'coordinator') renderCoordinatorModeWidget(ctx, state)
+    },
+  })
+
+  pi.registerCommand('pm-subagent-scoped', {
+    description: 'Manage subagent model scope (cycle pool)',
+    handler: async (_args, ctx) => {
+      const currentDefault = pmSubagentsConfig.subagentModel
+      const currentScope =
+        pmSubagentsConfig.subagentModelScoped ??
+        (currentDefault ? [currentDefault] : [])
+      const result = await scopedModelsEditor(ctx, {
+        items: [
+          { key: MODEL_DEFAULT, text: MODEL_DEFAULT_LABEL, provider: '' },
+          ...ctx.modelRegistry.getAvailable().map(modelOptionOf),
+        ],
+        initialChecked: currentScope,
+        title: 'Subagent Model Scope',
+      })
+      if (result === undefined) {
+        ctx.ui.notify('Scope unchanged.', 'info')
+        return
+      }
+      await setSubagentModelScoped(result)
+      ctx.ui.notify(`Subagent scope saved (${result.length} items).`, 'info')
+      if (state.mode === 'coordinator') renderCoordinatorModeWidget(ctx, state)
+    },
+  })
+
+  const runPmDefaultCommand = async (_args: string, ctx: ExtensionContext) => {
+    const enabled = pmSubagentsConfig.defaultMode !== 'coordinator'
+    await setDefaultMode(enabled ? 'coordinator' : undefined)
+    ctx.ui.notify(`pm mode on startup: ${enabled ? 'on' : 'off'}`, 'info')
+    if (enabled && state.mode !== 'coordinator') {
+      await enterCoordinatorMode(
+        pi,
+        state,
+        undefined,
+        ctx,
+        coordinatorDefinition,
+      )
+    }
+  }
+
+  pi.registerCommand('coordinator-default', {
+    description: 'Toggle pm (coordinator) mode enabled by default on startup',
+    handler: runPmDefaultCommand,
+  })
+
+  pi.registerCommand('pm-default', {
+    description: 'Toggle pm (coordinator) mode enabled by default on startup',
+    handler: runPmDefaultCommand,
+  })
+}