@raidou/pi-pm-subagents 0.1.1

package/src/utils/state.test.ts

@@ -0,0 +1,98 @@
+import type { UserMessage } from '@earendil-works/pi-ai'
+import type { SessionEntry } from '@earendil-works/pi-coding-agent'
+import { describe, expect, it } from 'vitest'
+
+import { getLastPmSubagentState } from './state.js'
+
+function user(text: string): UserMessage {
+  return {
+    role: 'user',
+    content: [{ type: 'text', text }],
+    timestamp: Date.now(),
+  }
+}
+
+describe('getLastPmSubagentState', () => {
+  it('returns undefined for empty entries array', () => {
+    const result = getLastPmSubagentState([])
+    expect(result).toBeUndefined()
+  })
+
+  it('returns undefined when entries contain no custom entries', () => {
+    const entries: SessionEntry[] = [
+      {
+        type: 'message',
+        id: '1',
+        parentId: null,
+        timestamp: new Date().toISOString(),
+        message: user('task'),
+      },
+    ]
+    const result = getLastPmSubagentState(entries)
+    expect(result).toBeUndefined()
+  })
+
+  it('returns undefined when custom entries have different type', () => {
+    const entries: SessionEntry[] = [
+      {
+        type: 'custom',
+        id: '1',
+        parentId: null,
+        timestamp: new Date().toISOString(),
+        customType: 'other-key',
+        data: {},
+      },
+    ]
+    const result = getLastPmSubagentState(entries)
+    expect(result).toBeUndefined()
+  })
+
+  it('returns pm-subagents state from the last matching custom entry', () => {
+    const entries: SessionEntry[] = [
+      {
+        type: 'custom',
+        id: '1',
+        parentId: null,
+        timestamp: new Date().toISOString(),
+        customType: 'pm-subagents',
+        data: {
+          mode: 'coordinator',
+        },
+      },
+      {
+        type: 'custom',
+        id: '2',
+        parentId: null,
+        timestamp: new Date().toISOString(),
+        customType: 'pm-subagents',
+        data: {
+          mode: 'coordinator',
+          modeDiffTools: { added: ['tool1'], removed: ['tool2'] },
+        },
+      },
+    ]
+    const result = getLastPmSubagentState(entries)
+    expect(result).toEqual({
+      mode: 'coordinator',
+      modeDiffTools: { added: ['tool1'], removed: ['tool2'] },
+    })
+  })
+
+  it('sanitizes stale mode to undefined', () => {
+    const entries: SessionEntry[] = [
+      {
+        type: 'custom',
+        id: '1',
+        parentId: null,
+        timestamp: new Date().toISOString(),
+        customType: 'pm-subagents',
+        data: {
+          mode: 'plan',
+          planMarkdown: 'stale plan',
+        },
+      },
+    ]
+    const result = getLastPmSubagentState(entries)
+    expect(result).toEqual({ mode: undefined })
+  })
+})

package/src/utils/state.ts

@@ -0,0 +1,45 @@
+import type {
+  ExtensionAPI,
+  SessionEntry,
+} from '@earendil-works/pi-coding-agent'
+
+import type { PmMode, PmSubagentState } from '../types.js'
+
+export const PLUGIN_KEY = 'pm-subagents'
+
+export function createState(): PmSubagentState {
+  return { mode: undefined }
+}
+
+export function persist(pi: ExtensionAPI, state: PmSubagentState): void {
+  pi.appendEntry(PLUGIN_KEY, {
+    mode: state.mode,
+    modeDiffTools: state.modeDiffTools,
+    previousModel: state.previousModel,
+    sessionSubagentModel: state.sessionSubagentModel,
+  })
+}
+
+export function getLastPmSubagentState(
+  entries: readonly SessionEntry[],
+): Partial<PmSubagentState> | undefined {
+  for (let i = entries.length - 1; i >= 0; i--) {
+    const entry = entries[i]
+    if (!entry || entry.type !== 'custom' || entry.customType !== PLUGIN_KEY)
+      continue
+    const data = entry.data as
+      (Partial<PmSubagentState> & { mode?: string }) | undefined
+    if (!data) return undefined
+    return {
+      mode: sanitizeMode(data.mode),
+      modeDiffTools: data.modeDiffTools,
+      previousModel: data.previousModel,
+      sessionSubagentModel: data.sessionSubagentModel,
+    }
+  }
+  return undefined
+}
+
+function sanitizeMode(mode: string | undefined): PmMode | undefined {
+  return mode === 'coordinator' ? 'coordinator' : undefined
+}

package/src/utils/tools.ts

@@ -0,0 +1,48 @@
+import type {
+  ExtensionAPI,
+  ToolDefinition,
+} from '@earendil-works/pi-coding-agent'
+import type { TSchema } from 'typebox'
+
+import type { PromptFrontmatter } from './markdown.js'
+
+export type ToolConfig = Pick<
+  PromptFrontmatter,
+  'tools' | 'extraTools' | 'removeTools'
+>
+
+export function registerOptionalTools(
+  pi: ExtensionAPI,
+  tools: ReadonlyArray<ToolDefinition<TSchema, unknown, unknown>>,
+  sessionStarted: boolean,
+): void {
+  const names = new Set(tools.map((t) => t.name))
+  for (const tool of tools) {
+    pi.registerTool(tool)
+  }
+
+  const filterIt = () => {
+    const activeTools = pi.getActiveTools()
+    const filtered = activeTools.filter((name) => !names.has(name))
+    if (filtered.length !== activeTools.length) {
+      pi.setActiveTools(filtered)
+    }
+  }
+
+  if (sessionStarted) filterIt()
+  else
+    pi.on('session_start', async () => {
+      filterIt()
+    })
+}
+
+export function composeTools(
+  baseTools: readonly string[],
+  config: ToolConfig,
+): string[] {
+  const tools = config.tools ?? [...baseTools]
+  const extra = config.extraTools ?? []
+  const merged = [...new Set([...tools, ...extra])]
+  const toRemove = config.removeTools ?? []
+  return merged.filter((t) => !toRemove.includes(t))
+}

package/src/utils/truncate.test.ts

@@ -0,0 +1,41 @@
+import { describe, expect, it } from 'vitest'
+
+import { truncateText } from './truncate.js'
+
+describe('truncateText', () => {
+  it('returns plain ASCII unchanged when it fits', () => {
+    expect(truncateText('hello', 10)).toBe('hello')
+    expect(truncateText('hello', 5)).toBe('hello')
+  })
+
+  it('truncates plain ASCII with ellipsis when too wide', () => {
+    expect(truncateText('hello world', 8)).toBe('hello...')
+  })
+
+  it('preserves ANSI codes when truncating colored text', () => {
+    const colored = '\x1b[31mhello world\x1b[0m'
+    const result = truncateText(colored, 8)
+    expect(result).toBe('\x1b[31mhello\x1b[0m...')
+    expect(result).toContain('\x1b[31m')
+  })
+
+  it('pads to exactly maxWidth when pad is true', () => {
+    expect(truncateText('hi', 5, '...', true)).toBe('hi   ')
+    expect(truncateText('hello world', 8, '...', true)).toBe('hello...')
+  })
+
+  it('counts emoji as width 2', () => {
+    expect(truncateText('👍👍', 4)).toBe('👍👍')
+    expect(truncateText('👍👍👍', 5)).toBe('👍...')
+  })
+
+  it('pads empty text with spaces when pad is true', () => {
+    expect(truncateText('', 4, '...', true)).toBe('    ')
+    expect(truncateText('', 4)).toBe('')
+  })
+
+  it('returns empty string when maxWidth <= 0', () => {
+    expect(truncateText('hello', 0)).toBe('')
+    expect(truncateText('hello', -1)).toBe('')
+  })
+})

package/src/utils/truncate.ts

@@ -0,0 +1,59 @@
+import { visibleWidth } from '@earendil-works/pi-tui'
+
+const ANSI_RE = new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*m`, 'g')
+const segmenter = new Intl.Segmenter()
+
+export function truncateText(
+  text: string,
+  maxWidth: number,
+  ellipsis = '...',
+  pad = false,
+): string {
+  if (maxWidth <= 0) return ''
+
+  const totalWidth = visibleWidth(text)
+  if (totalWidth <= maxWidth) {
+    return pad ? text + ' '.repeat(maxWidth - totalWidth) : text
+  }
+
+  const ellipsisWidth = visibleWidth(ellipsis)
+  const useEllipsis = ellipsisWidth < maxWidth
+  const targetWidth = useEllipsis ? maxWidth - ellipsisWidth : maxWidth
+
+  const appendFitting = (chunk: string): boolean => {
+    for (const { segment } of segmenter.segment(chunk)) {
+      const segmentWidth = visibleWidth(segment)
+      if (width + segmentWidth > targetWidth) return false
+      result += segment
+      width += segmentWidth
+    }
+    return true
+  }
+
+  let result = ''
+  let width = 0
+  let cursor = 0
+  let truncated = false
+  for (const match of text.matchAll(ANSI_RE)) {
+    if (!appendFitting(text.slice(cursor, match.index))) {
+      truncated = true
+      break
+    }
+    result += match[0]
+    cursor = match.index + match[0].length
+  }
+  if (truncated) {
+    result += [...text.slice(cursor).matchAll(ANSI_RE)]
+      .map((m) => m[0])
+      .join('')
+  } else {
+    appendFitting(text.slice(cursor))
+  }
+
+  if (useEllipsis) result += ellipsis
+  if (pad)
+    result += ' '.repeat(
+      Math.max(0, maxWidth - width - (useEllipsis ? ellipsisWidth : 0)),
+    )
+  return result
+}

package/tsconfig.json

@@ -0,0 +1,24 @@
+{
+  "compilerOptions": {
+    "outDir": "dist",
+    "jsx": "react-jsx",
+    "declaration": false,
+    "allowJs": true,
+    "lib": ["DOM", "ES2022"],
+    "target": "ES2022",
+    "module": "nodenext",
+    "stripInternal": true,
+    "resolveJsonModule": true,
+    "moduleResolution": "nodenext",
+    "esModuleInterop": true,
+    "sourceMap": true,
+    "strict": true,
+    "allowImportingTsExtensions": true,
+    "rewriteRelativeImportExtensions": true,
+    "forceConsistentCasingInFileNames": true,
+    "noUncheckedIndexedAccess": true,
+    "verbatimModuleSyntax": true,
+    "skipLibCheck": true
+  },
+  "include": ["src", "*.ts", "*.tsx", "*.js", "*.jsx", "*.mjs"]
+}

package/vitest.config.ts

@@ -0,0 +1,8 @@
+import { defineConfig } from 'vitest/config'
+
+export default defineConfig({
+  test: {
+    globals: false,
+    include: ['src/**/*.test.ts'],
+  },
+})