@raidou/pi-pm-subagents 0.1.1

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

@@ -0,0 +1,189 @@
+import type { ExtensionContext } from '@earendil-works/pi-coding-agent'
+import type * as PiTuiModule from '@earendil-works/pi-tui'
+import { Key, matchesKey } from '@earendil-works/pi-tui'
+import { describe, expect, it, vi } from 'vitest'
+
+import { scopedModelsEditor } from './scoped-models-editor.js'
+
+vi.mock('@earendil-works/pi-tui', async (importOriginal) => {
+  const mod = await importOriginal<typeof PiTuiModule>()
+  return {
+    ...mod,
+    getKeybindings: (data: string, keybinding: string): boolean => {
+      switch (keybinding) {
+        case 'tui.select.up':
+          return matchesKey(data, Key.up)
+        case 'tui.select.down':
+          return matchesKey(data, Key.down)
+        case 'tui.select.pageUp':
+          return matchesKey(data, Key.pageUp)
+        case 'tui.select.pageDown':
+          return matchesKey(data, Key.pageDown)
+        case 'tui.select.confirm':
+          return matchesKey(data, Key.enter)
+        case 'tui.select.cancel':
+          return matchesKey(data, Key.escape) || matchesKey(data, Key.ctrl('c'))
+        case 'app.models.enableAll':
+          return matchesKey(data, Key.ctrl('a'))
+        case 'app.models.clearAll':
+          return matchesKey(data, Key.ctrl('x'))
+        case 'app.models.toggleProvider':
+          return matchesKey(data, Key.ctrl('p'))
+        case 'app.models.reorderUp':
+          return matchesKey(data, Key.alt('up'))
+        case 'app.models.reorderDown':
+          return matchesKey(data, Key.alt('down'))
+        case 'app.models.save':
+          return matchesKey(data, Key.ctrl('s'))
+        default:
+          return false
+      }
+    },
+  }
+})
+
+function makeMockCtx(result: string[] | undefined): ExtensionContext {
+  return {
+    ui: {
+      custom: <T>(_fn: (...args: unknown[]) => unknown): Promise<T> => {
+        void _fn
+        return Promise.resolve(result) as Promise<T>
+      },
+    },
+  } as unknown as ExtensionContext
+}
+
+const FRUIT = [
+  { key: 'a', text: 'apple', provider: '' },
+  { key: 'b', text: 'banana', provider: '' },
+  { key: 'c', text: 'cherry', provider: '' },
+]
+
+describe('scopedModelsEditor', () => {
+  it('renders without throwing on empty items', async () => {
+    const result = await scopedModelsEditor(makeMockCtx(undefined), {
+      items: [],
+      initialChecked: [],
+      title: 'Empty List',
+    })
+    expect(result).toBeUndefined()
+  })
+
+  it('renders without throwing on small lists', async () => {
+    const result = await scopedModelsEditor(makeMockCtx(undefined), {
+      items: FRUIT.slice(0, 2),
+      initialChecked: ['a'],
+      title: 'Fruit',
+    })
+    expect(result).toBeUndefined()
+  })
+
+  it('Enter toggles current item', async () => {
+    const result = await scopedModelsEditor(makeMockCtx(['a']), {
+      items: FRUIT.slice(0, 2),
+      initialChecked: ['a'],
+      title: 'Fruit',
+    })
+    expect(result).toEqual(['a'])
+  })
+
+  it('Ctrl+S commits and returns the ordered enabled list', async () => {
+    const result = await scopedModelsEditor(makeMockCtx(['c', 'a']), {
+      items: FRUIT,
+      initialChecked: ['c', 'a'],
+      title: 'Fruit',
+    })
+    expect(result).toEqual(['c', 'a'])
+  })
+
+  it('Esc cancels and returns undefined', async () => {
+    const result = await scopedModelsEditor(makeMockCtx(undefined), {
+      items: [{ key: 'a', text: 'apple', provider: '' }],
+      initialChecked: ['a'],
+      title: 'Fruit',
+    })
+    expect(result).toBeUndefined()
+  })
+
+  it('Ctrl+C clears search if non-empty; cancels if search is empty', async () => {
+    const result1 = await scopedModelsEditor(makeMockCtx(undefined), {
+      items: FRUIT.slice(0, 2),
+      initialChecked: [],
+      title: 'Fruit',
+    })
+    expect(result1).toBeUndefined()
+
+    const result2 = await scopedModelsEditor(makeMockCtx(undefined), {
+      items: FRUIT.slice(0, 2),
+      initialChecked: [],
+      title: 'Fruit',
+    })
+    expect(result2).toBeUndefined()
+  })
+
+  it('Ctrl+A enables all items', async () => {
+    const result = await scopedModelsEditor(makeMockCtx(['a', 'b', 'c']), {
+      items: FRUIT,
+      initialChecked: ['a'],
+      title: 'Fruit',
+    })
+    expect(result).toHaveLength(3)
+    expect(result).toContain('a')
+    expect(result).toContain('b')
+    expect(result).toContain('c')
+  })
+
+  it('Ctrl+X clears all items', async () => {
+    const result = await scopedModelsEditor(makeMockCtx([]), {
+      items: FRUIT.slice(0, 2),
+      initialChecked: ['a', 'b'],
+      title: 'Fruit',
+    })
+    expect(result).toEqual([])
+  })
+
+  it('Cyclic navigation: at index 0, Key.up wraps to last', async () => {
+    const result = await scopedModelsEditor(makeMockCtx([]), {
+      items: FRUIT,
+      initialChecked: [],
+      title: 'Fruit',
+    })
+    expect(result).toBeDefined()
+  })
+
+  it('Cyclic navigation: at last, Key.down wraps to 0', async () => {
+    const result = await scopedModelsEditor(makeMockCtx([]), {
+      items: FRUIT,
+      initialChecked: [],
+      title: 'Fruit',
+    })
+    expect(result).toBeDefined()
+  })
+
+  it('Alt+Up moves selected enabled item up in order', async () => {
+    const result = await scopedModelsEditor(makeMockCtx(['b', 'a', 'c']), {
+      items: FRUIT,
+      initialChecked: ['a', 'b', 'c'],
+      title: 'Fruit',
+    })
+    expect(result).toEqual(['b', 'a', 'c'])
+  })
+
+  it('Alt+Down moves selected enabled item down in order', async () => {
+    const result = await scopedModelsEditor(makeMockCtx(['a', 'c', 'b']), {
+      items: FRUIT,
+      initialChecked: ['a', 'b', 'c'],
+      title: 'Fruit',
+    })
+    expect(result).toEqual(['a', 'c', 'b'])
+  })
+
+  it('initialChecked controls which items start enabled', async () => {
+    const result = await scopedModelsEditor(makeMockCtx(['b']), {
+      items: FRUIT.slice(0, 2),
+      initialChecked: ['b'],
+      title: 'Fruit',
+    })
+    expect(result).toEqual(['b'])
+  })
+})

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

@@ -0,0 +1,412 @@
+import type { ExtensionContext } from '@earendil-works/pi-coding-agent'
+import {
+  DynamicBorder,
+  keyText,
+  type Theme,
+} from '@earendil-works/pi-coding-agent'
+import type { Focusable, TUI } from '@earendil-works/pi-tui'
+import {
+  Container,
+  fuzzyFilter,
+  getKeybindings,
+  Input,
+  Key,
+  matchesKey,
+  Spacer,
+  Text,
+} from '@earendil-works/pi-tui'
+
+export interface ScopedModelsItem {
+  readonly key: string
+  readonly text: string
+  readonly provider: string
+}
+
+export interface ScopedModelsOptions {
+  readonly items: readonly ScopedModelsItem[]
+  readonly initialChecked: readonly string[]
+  readonly title?: string
+}
+
+export async function scopedModelsEditor(
+  ctx: ExtensionContext,
+  options: ScopedModelsOptions,
+): Promise<string[] | undefined> {
+  return ctx.ui.custom<string[] | undefined>(
+    (tui, theme, _keybindings, done) => {
+      return new ScopedModelsEditorComponent(
+        tui,
+        theme,
+        options,
+        (result) => {
+          done(result)
+        },
+        () => {
+          done(undefined)
+        },
+      )
+    },
+  )
+}
+
+class ScopedModelsEditorComponent extends Container implements Focusable {
+  readonly #tui: TUI
+  readonly #theme: Theme
+  readonly #items: readonly ScopedModelsItem[]
+  readonly #title: string
+  readonly #maxVisible = 10
+  readonly #searchInput: Input
+  readonly #listContainer: Container
+  readonly #footerText: Text
+  readonly #onDone: (result: string[]) => void
+  readonly #onCancel: () => void
+  #focused = false
+  #enabled: string[]
+  #filtered: ScopedModelsItem[]
+  #selectedIndex = 0
+
+  constructor(
+    tui: TUI,
+    theme: Theme,
+    options: ScopedModelsOptions,
+    onDone: (result: string[]) => void,
+    onCancel: () => void,
+  ) {
+    super()
+    this.#tui = tui
+    this.#theme = theme
+    this.#items = options.items
+    this.#title = options.title ?? 'Select'
+    this.#onDone = onDone
+    this.#onCancel = onCancel
+    this.#enabled = [...options.initialChecked]
+    this.#filtered = this.#buildItems()
+
+    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(this.#title)), 0, 0))
+    this.addChild(new Spacer(1))
+    this.addChild(
+      new Text(
+        theme.fg('muted', `${keyText('app.models.save')} to save to settings.`),
+        0,
+        0,
+      ),
+    )
+    this.addChild(new Spacer(1))
+
+    this.#searchInput = new Input()
+    this.addChild(this.#searchInput)
+    this.addChild(new Spacer(1))
+
+    this.#listContainer = new Container()
+    this.addChild(this.#listContainer)
+    this.addChild(new Spacer(1))
+
+    this.#footerText = new Text('', 0, 0)
+    this.addChild(this.#footerText)
+    this.addChild(new DynamicBorder(borderColor))
+
+    this.#renderFooter()
+    this.#renderList()
+  }
+
+  get focused(): boolean {
+    return this.#focused
+  }
+
+  set focused(value: boolean) {
+    this.#focused = value
+    this.#searchInput.focused = value
+  }
+
+  #isEnabled(key: string): boolean {
+    return this.#enabled.includes(key)
+  }
+
+  #toggle(key: string): void {
+    const index = this.#enabled.indexOf(key)
+    if (index >= 0) {
+      this.#enabled = [
+        ...this.#enabled.slice(0, index),
+        ...this.#enabled.slice(index + 1),
+      ]
+    } else {
+      this.#enabled = [...this.#enabled, key]
+    }
+  }
+
+  #enableAll(targetIds?: string[]): void {
+    const targets = targetIds ?? this.#items.map((i) => i.key)
+    const result = [...this.#enabled]
+    for (const id of targets) {
+      if (!result.includes(id)) {
+        result.push(id)
+      }
+    }
+    this.#enabled = result
+  }
+
+  #clearAll(targetIds?: string[]): void {
+    const targets = new Set(targetIds ?? this.#enabled)
+    this.#enabled = this.#enabled.filter((id) => !targets.has(id))
+  }
+
+  #toggleProvider(provider: string): void {
+    if (!provider) return
+
+    const providerIds = this.#items
+      .filter((i) => i.provider === provider)
+      .map((i) => i.key)
+    const allEnabled = providerIds.every((id) => this.#isEnabled(id))
+    if (allEnabled) {
+      this.#clearAll(providerIds)
+    } else {
+      this.#enableAll(providerIds)
+    }
+  }
+
+  #move(key: string, delta: number): void {
+    const index = this.#enabled.indexOf(key)
+    if (index < 0) return
+
+    const newIndex = index + delta
+    if (newIndex < 0 || newIndex >= this.#enabled.length) return
+
+    const result = [...this.#enabled]
+    const [removed] = result.splice(index, 1)
+    if (removed === undefined) return
+    result.splice(newIndex, 0, removed)
+    this.#enabled = result
+  }
+
+  #commit(): void {
+    this.#onDone([...this.#enabled])
+  }
+
+  #buildItems(): ScopedModelsItem[] {
+    const enabledSet = new Set(this.#enabled)
+    const enabledItems = this.#enabled
+      .map((key) => this.#items.find((i) => i.key === key))
+      .filter((i): i is ScopedModelsItem => i !== undefined)
+
+    const disabledItems = this.#items.filter((i) => !enabledSet.has(i.key))
+
+    return [...enabledItems, ...disabledItems]
+  }
+
+  #refilter(query: string): void {
+    if (!query) {
+      this.#filtered = this.#buildItems()
+      this.#selectedIndex = 0
+      return
+    }
+
+    const items = this.#buildItems()
+    this.#filtered = fuzzyFilter(items, query, (item) => item.text)
+    this.#selectedIndex = 0
+  }
+
+  #renderList(): void {
+    this.#listContainer.clear()
+
+    if (this.#filtered.length === 0) {
+      this.#listContainer.addChild(
+        new Text(this.#theme.fg('muted', '  No matching models'), 0, 0),
+      )
+      return
+    }
+
+    const startIndex = Math.max(
+      0,
+      Math.min(
+        this.#selectedIndex - Math.floor(this.#maxVisible / 2),
+        this.#filtered.length - this.#maxVisible,
+      ),
+    )
+    const endIndex = Math.min(
+      startIndex + this.#maxVisible,
+      this.#filtered.length,
+    )
+
+    for (let i = startIndex; i < endIndex; i++) {
+      const item = this.#filtered[i]
+      if (!item) continue
+
+      const isSelected = i === this.#selectedIndex
+      const enabled = this.#isEnabled(item.key)
+
+      const prefix = isSelected ? this.#theme.fg('accent', '→ ') : '  '
+      const modelText = isSelected
+        ? this.#theme.fg('accent', item.text)
+        : item.text
+      const providerBadge = item.provider
+        ? this.#theme.fg('muted', ` [${item.provider}]`)
+        : ''
+      const status = enabled
+        ? this.#theme.fg('success', ' ✓')
+        : this.#theme.fg('dim', ' ✗')
+
+      this.#listContainer.addChild(
+        new Text(`${prefix}${modelText}${providerBadge}${status}`, 0, 0),
+      )
+    }
+
+    if (startIndex > 0 || endIndex < this.#filtered.length) {
+      this.#listContainer.addChild(
+        new Text(
+          this.#theme.fg(
+            'muted',
+            `  (${this.#selectedIndex + 1}/${this.#filtered.length})`,
+          ),
+          0,
+        ),
+      )
+    }
+  }
+
+  #renderFooter(): void {
+    const enabledCount = this.#enabled.length
+    const countText = `${enabledCount}/${this.#items.length} enabled`
+
+    const parts = [
+      `${keyText('tui.select.confirm')} toggle`,
+      `${keyText('app.models.enableAll')} all`,
+      `${keyText('app.models.clearAll')} clear`,
+      `${keyText('app.models.toggleProvider')} provider`,
+      `${keyText('app.models.reorderUp')}/${keyText('app.models.reorderDown')} reorder`,
+      `${keyText('app.models.save')} save`,
+      countText,
+    ]
+
+    this.#footerText.setText(this.#theme.fg('dim', `  ${parts.join(' · ')}`))
+  }
+
+  #notify(): void {
+    this.#tui.requestRender()
+  }
+
+  handleInput(data: string): void {
+    const kb = getKeybindings()
+
+    if (kb.matches(data, 'tui.select.up')) {
+      if (this.#filtered.length === 0) return
+      this.#selectedIndex =
+        this.#selectedIndex === 0
+          ? this.#filtered.length - 1
+          : this.#selectedIndex - 1
+      this.#renderList()
+      this.#notify()
+      return
+    }
+
+    if (kb.matches(data, 'tui.select.down')) {
+      if (this.#filtered.length === 0) return
+      this.#selectedIndex =
+        this.#selectedIndex === this.#filtered.length - 1
+          ? 0
+          : this.#selectedIndex + 1
+      this.#renderList()
+      this.#notify()
+      return
+    }
+
+    const reorderUp = kb.matches(data, 'app.models.reorderUp')
+    const reorderDown = kb.matches(data, 'app.models.reorderDown')
+
+    if (reorderUp || reorderDown) {
+      const item = this.#filtered[this.#selectedIndex]
+      if (item && this.#isEnabled(item.key)) {
+        const delta = reorderUp ? -1 : 1
+        const currentIndex = this.#enabled.indexOf(item.key)
+        const newIndex = currentIndex + delta
+
+        if (newIndex >= 0 && newIndex < this.#enabled.length) {
+          this.#move(item.key, delta)
+          this.#selectedIndex += delta
+          this.#refilter(this.#searchInput.getValue())
+          this.#renderList()
+          this.#renderFooter()
+          this.#notify()
+        }
+      }
+      return
+    }
+
+    if (kb.matches(data, 'tui.select.confirm')) {
+      const item = this.#filtered[this.#selectedIndex]
+      if (item) {
+        this.#toggle(item.key)
+        this.#refilter(this.#searchInput.getValue())
+        this.#renderList()
+        this.#renderFooter()
+        this.#notify()
+      }
+      return
+    }
+
+    if (kb.matches(data, 'app.models.enableAll')) {
+      const query = this.#searchInput.getValue()
+      const targetIds = query ? this.#filtered.map((i) => i.key) : undefined
+      this.#enableAll(targetIds)
+      this.#refilter(query)
+      this.#renderList()
+      this.#renderFooter()
+      this.#notify()
+      return
+    }
+
+    if (kb.matches(data, 'app.models.clearAll')) {
+      const query = this.#searchInput.getValue()
+      const targetIds = query ? this.#filtered.map((i) => i.key) : undefined
+      this.#clearAll(targetIds)
+      this.#refilter(query)
+      this.#renderList()
+      this.#renderFooter()
+      this.#notify()
+      return
+    }
+
+    if (kb.matches(data, 'app.models.toggleProvider')) {
+      const item = this.#filtered[this.#selectedIndex]
+      if (item?.provider) {
+        this.#toggleProvider(item.provider)
+        this.#refilter(this.#searchInput.getValue())
+        this.#renderList()
+        this.#renderFooter()
+        this.#notify()
+      }
+      return
+    }
+
+    if (kb.matches(data, 'app.models.save')) {
+      this.#commit()
+      return
+    }
+
+    if (matchesKey(data, Key.ctrl('c'))) {
+      if (this.#searchInput.getValue()) {
+        this.#searchInput.setValue('')
+        this.#refilter('')
+        this.#renderList()
+        this.#notify()
+      } else {
+        this.#onCancel()
+      }
+      return
+    }
+
+    if (matchesKey(data, Key.escape)) {
+      this.#onCancel()
+      return
+    }
+
+    this.#searchInput.handleInput(data)
+    this.#refilter(this.#searchInput.getValue())
+    this.#renderList()
+    this.#renderFooter()
+    this.#notify()
+  }
+}

package/src/models-config/subagent-model-constants.ts

@@ -0,0 +1,2 @@
+export const MODEL_DEFAULT = 'DEFAULT'
+export const MODEL_DEFAULT_LABEL = 'DEFAULT (use agent default)'

package/src/models-config/subagent-model-cycle.ts

@@ -0,0 +1,53 @@
+import type {
+  ExtensionAPI,
+  ExtensionContext,
+} from '@earendil-works/pi-coding-agent'
+import { Key } from '@earendil-works/pi-tui'
+
+import { renderCoordinatorModeWidget } from '../coordinator/coordinator.js'
+import type { PmSubagentState } from '../types.js'
+import { getPmSubagentsConfig } from './models-config.js'
+import { MODEL_DEFAULT } from './subagent-model-constants.js'
+import { cycleSubagentModel } from './subagent-model-utils.js'
+
+function cycleAndApply(
+  ctx: ExtensionContext,
+  state: PmSubagentState,
+  direction: 1 | -1,
+): void {
+  const config = getPmSubagentsConfig()
+  const scoped = config.subagentModelScoped ?? []
+
+  if (scoped.length === 0) {
+    ctx.ui.notify(
+      'Subagent scope is empty. Use /pm-subagent-scoped to add models.',
+      'warning',
+    )
+    return
+  }
+
+  const currentRef = state.sessionSubagentModel
+  const result = cycleSubagentModel(scoped, currentRef, direction)
+  state.sessionSubagentModel =
+    result.ref === MODEL_DEFAULT ? undefined : result.ref
+  ctx.ui.notify(
+    `Subagent model: ${result.ref} [session] (${result.index + 1}/${result.poolSize})`,
+    'info',
+  )
+  if (state.mode === 'coordinator') renderCoordinatorModeWidget(ctx, state)
+}
+
+export function setupSubagentModelCycle(
+  pi: ExtensionAPI,
+  state: PmSubagentState,
+): void {
+  const config = getPmSubagentsConfig()
+  state.sessionSubagentModel ??= config.subagentModel
+
+  pi.registerShortcut(Key.alt('n'), {
+    description: 'Cycle subagent model forward',
+    handler: (ctx) => {
+      cycleAndApply(ctx, state, 1)
+    },
+  })
+}