@raidou/pi-notify 0.4.0 → 0.5.0

package/src/state-tracker.test.ts

@@ -1,19 +1,27 @@
 import type { ExtensionAPI } from '@earendil-works/pi-coding-agent'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 
+import type { ResolvedNotifyConfig } from './config.js'
 import type { JobTracker } from './jobs.js'
-import { StateTracker } from './state-tracker.js'
+import { PI_NOTIFY_EVENT, StateTracker } from './state-tracker.js'
+
+type EventsListener = (payload?: unknown) => void
 
 interface FakePi {
-  listeners: Map<string, Set<() => void>>
-  on(event: string, listener: () => void): void
-  emit(event: string): void
+  listeners: Map<string, Set<(payload?: unknown) => void>>
+  eventListeners: Map<string, Set<EventsListener>>
+  on(event: string, listener: (payload?: unknown) => void): void
+  events: { on(event: string, listener: EventsListener): () => void }
+  emit(event: string, payload?: unknown): void
+  emitEvent(event: string, payload?: unknown): void
 }
 
 function makeFakePi(): FakePi {
-  const listeners = new Map<string, Set<() => void>>()
+  const listeners = new Map<string, Set<(payload?: unknown) => void>>()
+  const eventListeners = new Map<string, Set<EventsListener>>()
   return {
     listeners,
+    eventListeners,
     on(event, listener) {
       let set = listeners.get(event)
       if (!set) {
@@ -22,10 +30,28 @@ function makeFakePi(): FakePi {
       }
       set.add(listener)
     },
-    emit(event) {
+    events: {
+      on(event, listener) {
+        let set = eventListeners.get(event)
+        if (!set) {
+          set = new Set()
+          eventListeners.set(event, set)
+        }
+        set.add(listener)
+        return () => {
+          set.delete(listener)
+        }
+      },
+    },
+    emit(event, payload) {
       const set = listeners.get(event)
       if (!set) return
-      for (const listener of [...set]) listener()
+      for (const listener of [...set]) listener(payload)
+    },
+    emitEvent(event, payload) {
+      const set = eventListeners.get(event)
+      if (!set) return
+      for (const listener of [...set]) listener(payload)
     },
   }
 }
@@ -41,23 +67,42 @@ async function flush(): Promise<void> {
   for (let i = 0; i < 5; i++) await Promise.resolve()
 }
 
-function makeTracker(pi: FakePi): {
+const BASE_CONFIG: ResolvedNotifyConfig = {
+  enabled: true,
+  notifyTools: new Set(['bash', 'read']),
+  events: {
+    'permissions:ui_prompt': 'msg',
+    'disabled:channel': false,
+  },
+  finished: true,
+  onlyNotifyWhenUnfocused: true,
+  unfocusedActivityThresholdMs: 0,
+  tmuxSymbol: '',
+} as unknown as ResolvedNotifyConfig
+
+function makeTracker(
+  pi: FakePi,
+  config: ResolvedNotifyConfig = BASE_CONFIG,
+): {
   tracker: StateTracker
   states: string[]
+  bodies: string[]
 } {
   const states: string[] = []
+  const bodies: string[] = []
   const tracker = new StateTracker(
     pi as unknown as ExtensionAPI,
     makeFakeJobTracker(),
+    config,
   )
-  tracker.register(() => {})
+  tracker.register((body) => bodies.push(body))
   tracker.events.on('running', () => {
     states.push('running')
   })
   tracker.events.on('idle', () => {
     states.push('idle')
   })
-  return { tracker, states }
+  return { tracker, states, bodies }
 }
 
 describe('StateTracker', () => {
@@ -99,7 +144,11 @@ describe('StateTracker', () => {
 
     pi.emit('turn_start')
     pi.emit('message_start')
-    pi.emit('tool_call')
+    pi.emit('tool_call', {
+      type: 'tool_call',
+      toolCallId: 't1',
+      toolName: 'read',
+    })
     pi.emit('turn_start')
 
     await flush()
@@ -107,6 +156,62 @@ describe('StateTracker', () => {
     expect(states).toEqual(['running'])
   })
 
+  it('emits tool only for tools in notifyTools', async () => {
+    const pi = makeFakePi()
+    const { tracker } = makeTracker(pi)
+    const tools: string[] = []
+    tracker.events.on('tool', (event) => {
+      tools.push(event.data)
+    })
+
+    pi.emit('tool_call', {
+      type: 'tool_call',
+      toolCallId: 't1',
+      toolName: 'bash',
+    })
+    pi.emit('tool_call', {
+      type: 'tool_call',
+      toolCallId: 't2',
+      toolName: 'grep',
+    })
+
+    await flush()
+
+    expect(tools).toEqual(['bash'])
+  })
+
+  it('emits event for configured channels and not for disabled ones', async () => {
+    const pi = makeFakePi()
+    const { tracker } = makeTracker(pi)
+    const events: string[] = []
+    tracker.events.on('event', (event) => {
+      events.push(event.data)
+    })
+
+    pi.emitEvent('permissions:ui_prompt', {})
+    pi.emitEvent('disabled:channel', {})
+
+    await flush()
+
+    expect(events).toEqual(['permissions:ui_prompt'])
+  })
+
+  it('unsubscribes from channel events on stop', async () => {
+    const pi = makeFakePi()
+    const { tracker } = makeTracker(pi)
+    const events: string[] = []
+    tracker.events.on('event', (event) => {
+      events.push(event.data)
+    })
+
+    tracker.stop()
+    pi.emitEvent('permissions:ui_prompt', {})
+
+    await flush()
+
+    expect(events).toEqual([])
+  })
+
   it('emits running again after becoming idle', async () => {
     const pi = makeFakePi()
     const { states } = makeTracker(pi)
@@ -121,6 +226,112 @@ describe('StateTracker', () => {
     expect(states).toEqual(['running', 'idle', 'running'])
   })
 
+  it('notifies with the configured message when a custom event fires', () => {
+    const pi = makeFakePi()
+    const { bodies } = makeTracker(pi)
+
+    pi.emitEvent('permissions:ui_prompt', {})
+
+    expect(bodies).toEqual(['msg'])
+  })
+
+  it('does not notify for events disabled with false', () => {
+    const pi = makeFakePi()
+    const { bodies } = makeTracker(pi)
+
+    pi.emitEvent('disabled:channel', {})
+
+    expect(bodies).toEqual([])
+  })
+
+  it('does not notify for events disabled with an empty string', () => {
+    const pi = makeFakePi()
+    const { bodies } = makeTracker(pi, {
+      ...BASE_CONFIG,
+      events: { 'my:custom:event': '' },
+    })
+
+    pi.emitEvent('my:custom:event', {})
+
+    expect(bodies).toEqual([])
+  })
+
+  it('notifies from the custom channel', () => {
+    const pi = makeFakePi()
+    const { bodies } = makeTracker(pi)
+
+    pi.emitEvent(PI_NOTIFY_EVENT, 'custom payload')
+
+    expect(bodies).toEqual(['custom payload'])
+  })
+
+  it('notifies for tools in notifyTools', () => {
+    const pi = makeFakePi()
+    const { bodies } = makeTracker(pi)
+
+    pi.emit('tool_call', {
+      type: 'tool_call',
+      toolCallId: 't1',
+      toolName: 'read',
+    })
+
+    expect(bodies).toEqual(['Tool call: read'])
+  })
+
+  it('does not notify for tools not in notifyTools', () => {
+    const pi = makeFakePi()
+    const { bodies } = makeTracker(pi)
+
+    pi.emit('tool_call', {
+      type: 'tool_call',
+      toolCallId: 't1',
+      toolName: 'grep',
+    })
+
+    expect(bodies).toEqual([])
+  })
+
+  it('notifies Idle on idle when there was activity', async () => {
+    const pi = makeFakePi()
+    const { bodies } = makeTracker(pi)
+
+    pi.emit('turn_start')
+    pi.emit('agent_settled')
+    vi.advanceTimersByTime(10000)
+
+    await flush()
+
+    expect(bodies).toEqual(['Idle'])
+  })
+
+  it('does not notify Idle on idle without activity', async () => {
+    const pi = makeFakePi()
+    const { bodies } = makeTracker(pi)
+
+    pi.emit('agent_settled')
+    vi.advanceTimersByTime(10000)
+
+    await flush()
+
+    expect(bodies).toEqual([])
+  })
+
+  it('does not notify Idle when finished is disabled', async () => {
+    const pi = makeFakePi()
+    const { bodies } = makeTracker(pi, {
+      ...BASE_CONFIG,
+      finished: false,
+    })
+
+    pi.emit('turn_start')
+    pi.emit('agent_settled')
+    vi.advanceTimersByTime(10000)
+
+    await flush()
+
+    expect(bodies).toEqual([])
+  })
+
   it('resets the idle timer on activity', async () => {
     const pi = makeFakePi()
     const { states } = makeTracker(pi)
@@ -128,7 +339,11 @@ describe('StateTracker', () => {
     pi.emit('turn_start')
     pi.emit('agent_settled')
     vi.advanceTimersByTime(9000)
-    pi.emit('tool_call')
+    pi.emit('tool_call', {
+      type: 'tool_call',
+      toolCallId: 't2',
+      toolName: 'bash',
+    })
     vi.advanceTimersByTime(9000)
 
     await flush()

package/src/state-tracker.ts

@@ -1,8 +1,12 @@
 import type { ExtensionAPI } from '@earendil-works/pi-coding-agent'
 import Emittery from 'emittery'
 
+import type { ResolvedNotifyConfig } from './config.js'
 import type { JobTracker } from './jobs.js'
 import { Registrar } from './shared/registrar.js'
+import type { NotifyAction } from './shared/types.js'
+
+export const PI_NOTIFY_EVENT = 'pi-notify:notify'
 
 const IDLE_TIMEOUT_MS = 10000
 
@@ -10,15 +14,25 @@ export class StateTracker extends Registrar {
   readonly events = new Emittery<{
     running: never
     idle: never
+    tool: string
+    event: string
   }>()
 
   private readonly jobTracker: JobTracker
+  private readonly config: ResolvedNotifyConfig
   private idleTimer: NodeJS.Timeout | null = null
   private running = false
+  private hasActivity = false
+  private notify: NotifyAction = () => {}
 
-  constructor(pi: ExtensionAPI, jobTracker: JobTracker) {
+  constructor(
+    pi: ExtensionAPI,
+    jobTracker: JobTracker,
+    config: ResolvedNotifyConfig,
+  ) {
     super(pi)
     this.jobTracker = jobTracker
+    this.config = config
   }
 
   private startIdleTimer(): void {
@@ -28,6 +42,9 @@ export class StateTracker extends Registrar {
       this.idleTimer = null
       this.running = false
       void this.events.emit('idle')
+      if (this.hasActivity && this.config.finished) {
+        this.notify('Idle')
+      }
     }, IDLE_TIMEOUT_MS)
   }
 
@@ -44,8 +61,41 @@ export class StateTracker extends Registrar {
     void this.events.emit('running')
   }
 
-  protected override setup(): void {
+  private setupPiEvents() {
+    for (const [channel, message] of Object.entries(this.config.events)) {
+      if (typeof message !== 'string' || message === '') continue
+      const unsubscribe = this.pi.events.on(channel, () => {
+        this.notify(message)
+        void this.events.emit('event', channel)
+      })
+      this.unsubscribes.push(unsubscribe)
+    }
+
+    const customEventUnsub = this.pi.events.on(PI_NOTIFY_EVENT, (payload) => {
+      this.notify(String(payload))
+      void this.events.emit('event', PI_NOTIFY_EVENT)
+    })
+    this.unsubscribes.push(customEventUnsub)
+  }
+
+  private setupToolCall() {
+    this.pi.on('tool_call', (event) => {
+      if (this.config.notifyTools.has(event.toolName)) {
+        this.notify(`Tool call: ${event.toolName}`)
+        void this.events.emit('tool', event.toolName)
+      }
+      this.clearIdleTimer()
+    })
+  }
+
+  protected override setup(notify: NotifyAction): void {
+    this.notify = notify
+
+    this.setupPiEvents()
+    this.setupToolCall()
+
     this.pi.on('turn_start', () => {
+      this.hasActivity = true
       this.markRunning()
       this.clearIdleTimer()
     })
@@ -58,10 +108,6 @@ export class StateTracker extends Registrar {
       this.startIdleTimer()
     })
 
-    this.pi.on('tool_call', () => {
-      this.clearIdleTimer()
-    })
-
     this.unsubscribes.push(
       this.jobTracker.onEnd(() => {
         this.startIdleTimer()
@@ -72,5 +118,6 @@ export class StateTracker extends Registrar {
   override stop(): void {
     super.stop()
     this.clearIdleTimer()
+    this.hasActivity = false
   }
 }

package/src/dashboard/ui.ts

@@ -1,193 +0,0 @@
-import type { Theme } from '@earendil-works/pi-coding-agent'
-import { DynamicBorder } from '@earendil-works/pi-coding-agent'
-import {
-  Container,
-  Key,
-  matchesKey,
-  Spacer,
-  Text,
-  truncateToWidth,
-} from '@earendil-works/pi-tui'
-
-import type { SessionRecord } from './state-store.js'
-
-const COLUMNS = [
-  { name: 'SESSION_ID', width: 8 },
-  { name: 'PID', width: 8 },
-  { name: 'STATE', width: 8 },
-  { name: 'PROJECT', width: 15 },
-  { name: 'UPTIME', width: 10 },
-] as const
-
-const [SESSION_ID_COL, PID_COL, STATE_COL, PROJECT_COL, UPTIME_COL] = COLUMNS
-
-const MAX_ROWS = Math.max(1, (process.stdout.rows || 20) - 6)
-
-export interface DashboardProps {
-  tui: { requestRender: () => void }
-  theme: Theme
-  initialSessions: SessionRecord[]
-  onRefresh: () => Promise<SessionRecord[]>
-  onClose: () => void
-  onDispose?: () => void
-}
-
-function formatUptime(startedAt: number): string {
-  const elapsed = Date.now() - startedAt
-  const seconds = Math.floor(elapsed / 1000)
-  const minutes = Math.floor(seconds / 60)
-  const hours = Math.floor(minutes / 60)
-
-  if (hours > 0) {
-    const mins = minutes % 60
-    return `${hours}h ${mins}m`
-  }
-  if (minutes > 0) {
-    const secs = seconds % 60
-    return `${minutes}m ${secs}s`
-  }
-  return `${seconds}s`
-}
-
-export function createDashboard(props: DashboardProps) {
-  let sessions = [...props.initialSessions]
-  let scrollOffset = 0
-  let cachedWidth: number | null = null
-  let cachedLines: string[] = []
-  let disposed = false
-
-  const dashboardContainer = new Container()
-
-  function refresh(): void {
-    props
-      .onRefresh()
-      .then((newSessions) => {
-        sessions = [...newSessions]
-        scrollOffset = 0
-        cachedWidth = null
-        props.tui.requestRender()
-      })
-      .catch(() => {})
-  }
-
-  const timer = setInterval(() => {
-    if (!disposed) refresh()
-  }, 1000)
-
-  function updateChildren(): void {
-    const { theme } = props
-
-    const stats = sessions.reduce(
-      (acc, s) => {
-        acc[s.state]++
-        return acc
-      },
-      { running: 0, idle: 0 },
-    )
-
-    const headerLine = COLUMNS.map((col) => col.name.padEnd(col.width)).join(
-      '  ',
-    )
-
-    dashboardContainer.clear()
-    dashboardContainer.addChild(
-      new Text(
-        `${theme.fg('accent', theme.bold('pi sessions dashboard'))} ${theme.fg(
-          'dim',
-          `total=${sessions.length} running=${stats.running} idle=${stats.idle}`,
-        )}`,
-        0,
-        0,
-      ),
-    )
-    dashboardContainer.addChild(new Spacer(1))
-    dashboardContainer.addChild(
-      new Text(theme.fg('borderAccent', headerLine), 0, 0),
-    )
-    dashboardContainer.addChild(
-      new DynamicBorder((str) => theme.fg('borderAccent', str)),
-    )
-
-    for (const session of sessions.slice(
-      scrollOffset,
-      scrollOffset + MAX_ROWS,
-    )) {
-      const stateColor = session.state === 'running' ? 'success' : 'muted'
-      const line = [
-        theme.fg(
-          'dim',
-          session.sessionId.slice(-6).padEnd(SESSION_ID_COL.width),
-        ),
-        theme.fg('dim', String(session.pid).padEnd(PID_COL.width)),
-        theme.fg(stateColor, session.state.padEnd(STATE_COL.width)),
-        theme.fg(
-          'text',
-          truncateToWidth(session.projectName, PROJECT_COL.width, '…', true),
-        ),
-        theme.fg(
-          'dim',
-          formatUptime(session.startedAt).padEnd(UPTIME_COL.width),
-        ),
-      ].join('  ')
-      dashboardContainer.addChild(new Text(line, 0, 0))
-    }
-
-    dashboardContainer.addChild(new Spacer(1))
-    dashboardContainer.addChild(
-      new Text(theme.fg('dim', '↑↓ scroll • r refresh • q or esc close'), 0, 0),
-    )
-  }
-
-  const component = {
-    render(width: number): string[] {
-      if (cachedWidth !== width) {
-        updateChildren()
-        cachedLines = dashboardContainer.render(width)
-        cachedWidth = width
-      }
-      return cachedLines
-    },
-
-    handleInput(data: string): void {
-      if (matchesKey(data, 'r')) {
-        refresh()
-        return
-      }
-
-      if (matchesKey(data, 'q') || matchesKey(data, Key.escape)) {
-        props.onClose()
-        return
-      }
-
-      if (matchesKey(data, Key.up) || matchesKey(data, 'k')) {
-        if (scrollOffset > 0) {
-          scrollOffset--
-          cachedWidth = null
-          props.tui.requestRender()
-        }
-        return
-      }
-
-      if (matchesKey(data, Key.down) || matchesKey(data, 'j')) {
-        if (scrollOffset + MAX_ROWS < sessions.length) {
-          scrollOffset++
-          cachedWidth = null
-          props.tui.requestRender()
-        }
-      }
-    },
-
-    invalidate(): void {
-      cachedWidth = null
-      dashboardContainer.invalidate()
-    },
-
-    dispose(): void {
-      disposed = true
-      clearInterval(timer)
-      props.onDispose?.()
-    },
-  }
-
-  return component
-}