@raidou/pi-notify 0.3.1 → 0.5.0

package/src/tmux-title.ts

@@ -4,6 +4,8 @@ import { readlinkSync } from 'node:fs'
 import type { ExtensionAPI } from '@earendil-works/pi-coding-agent'
 
 import type { ResolvedNotifyConfig } from './config.js'
+import { Registrar } from './shared/registrar.js'
+import type { NotifyAction } from './shared/types.js'
 
 const WINDOW_ID_FORMAT = '#{window_id}'
 const WINDOW_NAME_FORMAT = '#{window_name}'
@@ -11,22 +13,24 @@ const LIST_FORMAT = '#{pane_tty}\t#{window_id}'
 const NEWLINE = '\n'
 const TAB = '\t'
 
-export class TmuxTitleTracker {
+export class TmuxTitleTracker extends Registrar {
+  private readonly config: ResolvedNotifyConfig
   private windowId: string | undefined
   private originalTitle: string | undefined
   private autoRename: boolean | undefined
   private modified = false
 
-  constructor(
-    private readonly pi: ExtensionAPI,
-    private readonly config: ResolvedNotifyConfig,
-  ) {}
+  constructor(pi: ExtensionAPI, config: ResolvedNotifyConfig) {
+    super(pi)
+    this.config = config
+  }
 
   get enabled(): boolean {
     return this.config.tmuxSymbol.length > 0
   }
 
-  register(): void {
+  protected override setup(notify: NotifyAction): void {
+    void notify
     this.pi.on('session_start', (_event, ctx) => {
       if (ctx.mode !== 'tui' || !this.enabled) return
       this.restore()
@@ -36,9 +40,6 @@ export class TmuxTitleTracker {
       this.originalTitle = this.queryWindowName(id)
       this.autoRename = this.queryAutomaticRename(id)
     })
-    this.pi.on('session_shutdown', () => {
-      this.stop()
-    })
   }
 
   mark(): void {
@@ -72,7 +73,8 @@ export class TmuxTitleTracker {
     this.modified = false
   }
 
-  stop(): void {
+  override stop(): void {
+    super.stop()
     this.restore()
     this.windowId = undefined
     this.originalTitle = undefined

package/src/dashboard/state-tracker.ts

@@ -1,174 +0,0 @@
-import { basename } from 'node:path'
-
-import type { ExtensionAPI } from '@earendil-works/pi-coding-agent'
-
-import { type SessionRecord, updateState } from './state-store.js'
-
-const IDLE_TIMEOUT_MS = 10000
-const HEARTBEAT_INTERVAL_MS = 5000
-
-export class StateTracker {
-  private registered = false
-  private heartbeatTimer: NodeJS.Timeout | null = null
-  private idleTimer: NodeJS.Timeout | null = null
-  private sessionId: string | undefined = undefined
-  private cwd: string | undefined = undefined
-  private projectName: string | undefined = undefined
-  private model: string | undefined = undefined
-
-  private get cwdOrCwd(): string {
-    return this.cwd ?? process.cwd()
-  }
-
-  private get projectNameOrCwd(): string {
-    return this.projectName ?? basename(process.cwd())
-  }
-
-  constructor(private readonly pi: ExtensionAPI) {}
-
-  private updateSessionRecord(updates: Partial<SessionRecord>): void {
-    if (!this.sessionId) return
-    const now = Date.now()
-    const id = this.sessionId
-
-    void updateState((state) => {
-      const existing = state.sessions[id]
-      const stateChanged =
-        updates.state !== undefined && updates.state !== existing?.state
-
-      const record: SessionRecord = {
-        pid: process.pid,
-        cwd: this.cwdOrCwd,
-        projectName: this.projectNameOrCwd,
-        lastHeartbeatAt: now,
-        startedAt: existing?.startedAt ?? now,
-        state: updates.state ?? existing?.state ?? 'running',
-        stateChangedAt: stateChanged ? now : (existing?.stateChangedAt ?? now),
-        model: this.model ?? existing?.model,
-        lastEvent: updates.lastEvent ?? existing?.lastEvent,
-      }
-
-      return {
-        ...state,
-        sessions: { ...state.sessions, [id]: record },
-      }
-    })
-  }
-
-  private removeSession(): void {
-    if (!this.sessionId) return
-    const id = this.sessionId
-
-    void updateState((state) => {
-      const sessions: Record<string, SessionRecord | undefined> = {}
-      for (const [key, value] of Object.entries(state.sessions)) {
-        if (key !== id) sessions[key] = value
-      }
-      return { ...state, sessions }
-    })
-  }
-
-  private clearIdleTimer(): void {
-    if (this.idleTimer) {
-      clearTimeout(this.idleTimer)
-      this.idleTimer = null
-    }
-  }
-
-  private startIdleTimer(): void {
-    this.clearIdleTimer()
-    this.idleTimer = setTimeout(() => {
-      this.clearIdleTimer()
-      this.updateSessionRecord({
-        state: 'idle',
-        lastEvent: { type: 'idle', summary: 'idle', at: Date.now() },
-      })
-    }, IDLE_TIMEOUT_MS)
-  }
-
-  register(): void {
-    if (this.registered) return
-    this.registered = true
-
-    this.pi.on('session_start', (_event, ctx) => {
-      this.sessionId = ctx.sessionManager.getSessionId()
-      this.cwd = ctx.cwd
-      this.projectName = basename(ctx.cwd)
-      this.model = ctx.model?.id
-
-      this.updateSessionRecord({
-        lastEvent: {
-          type: 'session_start',
-          summary: 'started',
-          at: Date.now(),
-        },
-      })
-
-      this.heartbeatTimer = setInterval(() => {
-        if (!this.sessionId) return
-        const id = this.sessionId
-
-        void updateState((state) => {
-          const existing = state.sessions[id]
-          if (!existing) return state
-
-          return {
-            ...state,
-            sessions: {
-              ...state.sessions,
-              [id]: {
-                ...existing,
-                lastHeartbeatAt: Date.now(),
-              },
-            },
-          }
-        })
-      }, HEARTBEAT_INTERVAL_MS)
-    })
-
-    this.pi.on('turn_start', () => {
-      this.clearIdleTimer()
-      this.updateSessionRecord({
-        state: 'running',
-        lastEvent: { type: 'turn_start', summary: 'running', at: Date.now() },
-      })
-    })
-
-    this.pi.on('agent_start', () => {
-      this.clearIdleTimer()
-      this.updateSessionRecord({
-        state: 'running',
-        lastEvent: { type: 'agent_start', summary: 'running', at: Date.now() },
-      })
-    })
-
-    this.pi.on('agent_settled', () => {
-      this.startIdleTimer()
-    })
-
-    this.pi.on('tool_call', (event) => {
-      this.updateSessionRecord({
-        state: 'running',
-        lastEvent: {
-          type: 'tool_call',
-          summary: `tool:${event.toolName}`,
-          at: Date.now(),
-        },
-      })
-    })
-
-    this.pi.on('session_shutdown', () => {
-      this.stop()
-      this.removeSession()
-    })
-  }
-
-  stop(): void {
-    this.clearIdleTimer()
-    if (this.heartbeatTimer) {
-      clearInterval(this.heartbeatTimer)
-      this.heartbeatTimer = null
-    }
-    this.registered = false
-  }
-}

package/src/dashboard/ui.ts

@@ -1,198 +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: 'PID', width: 8 },
-  { name: 'STATE', width: 8 },
-  { name: 'PROJECT', width: 15 },
-  { name: 'UPTIME', width: 10 },
-  { name: 'MODEL', width: 20 },
-  { name: 'LAST EVENT', width: undefined },
-] as const
-
-const [PID_COL, STATE_COL, PROJECT_COL, UPTIME_COL, MODEL_COL] = COLUMNS
-
-const FIXED_COLUMNS_WIDTH =
-  PID_COL.width +
-  STATE_COL.width +
-  PROJECT_COL.width +
-  UPTIME_COL.width +
-  MODEL_COL.width
-const GAPS_WIDTH = (COLUMNS.length - 1) * 2
-
-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
-}
-
-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[] = []
-
-  const dashboardContainer = new Container()
-
-  function updateChildren(width: number): void {
-    const remainingWidth = Math.max(1, width - FIXED_COLUMNS_WIDTH - GAPS_WIDTH)
-    const { theme } = props
-
-    const stats = sessions.reduce(
-      (acc, s) => {
-        acc[s.state]++
-        return acc
-      },
-      { running: 0, idle: 0 },
-    )
-
-    const headerLine = COLUMNS.map((col) =>
-      col.width === undefined ? col.name : 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', 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),
-        ),
-        theme.fg(
-          'muted',
-          session.model
-            ? truncateToWidth(session.model, MODEL_COL.width, '…', true)
-            : '',
-        ),
-        theme.fg(
-          'dim',
-          session.lastEvent
-            ? truncateToWidth(
-                `${session.lastEvent.type}:${session.lastEvent.summary}`,
-                remainingWidth,
-              )
-            : '',
-        ),
-      ].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(width)
-        cachedLines = dashboardContainer.render(width)
-        cachedWidth = width
-      }
-      return cachedLines
-    },
-
-    handleInput(data: string): void {
-      if (matchesKey(data, 'r')) {
-        props
-          .onRefresh()
-          .then((newSessions) => {
-            sessions = [...newSessions]
-            scrollOffset = 0
-            cachedWidth = null
-            props.tui.requestRender()
-          })
-          .catch(() => {})
-        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()
-    },
-  }
-
-  return component
-}

package/src/events.ts

@@ -1,46 +0,0 @@
-import type { ExtensionAPI } from '@earendil-works/pi-coding-agent'
-
-import type { ResolvedNotifyConfig } from './config.js'
-import type { NotifyAction, Unsubscribe } from './types.js'
-
-export const PI_NOTIFY_EVENT = 'pi-notify:notify'
-
-export class EventsNotifier {
-  private unsubscribes: Unsubscribe[] = []
-  private registered = false
-
-  constructor(
-    private readonly pi: ExtensionAPI,
-    private readonly config: ResolvedNotifyConfig,
-  ) {}
-
-  register(notify: NotifyAction): void {
-    if (this.registered) return
-    this.registered = true
-
-    for (const [channel, message] of Object.entries(this.config.events)) {
-      if (!message) continue
-      const unsubscribe = this.pi.events.on(channel, () => {
-        notify(message)
-      })
-      this.unsubscribes.push(unsubscribe)
-    }
-
-    const customEventUnsub = this.pi.events.on(PI_NOTIFY_EVENT, (payload) => {
-      notify(String(payload))
-    })
-    this.unsubscribes.push(customEventUnsub)
-
-    this.pi.on('session_shutdown', () => {
-      this.stop()
-    })
-  }
-
-  stop(): void {
-    this.unsubscribes.forEach((unsub) => {
-      unsub()
-    })
-    this.unsubscribes = []
-    this.registered = false
-  }
-}

package/src/idle.ts

@@ -1,52 +0,0 @@
-import type { ExtensionAPI } from '@earendil-works/pi-coding-agent'
-
-import type { ResolvedNotifyConfig } from './config.js'
-import type { JobTracker } from './jobs.js'
-import type { NotifyAction } from './types.js'
-
-const IDLE_TIMEOUT_MS = 10000
-
-export class IdleNotifier {
-  private timer: NodeJS.Timeout | null = null
-
-  constructor(
-    private readonly pi: ExtensionAPI,
-    private readonly config: ResolvedNotifyConfig,
-    private readonly jobTracker: JobTracker,
-  ) {}
-
-  clearIdleTimer(): void {
-    if (this.timer) {
-      clearTimeout(this.timer)
-      this.timer = null
-    }
-  }
-  startIdleTimer(notify: NotifyAction): void {
-    this.clearIdleTimer()
-    this.timer = setTimeout(() => {
-      this.clearIdleTimer()
-      notify('Idle')
-    }, IDLE_TIMEOUT_MS)
-  }
-
-  register(notify: NotifyAction): void {
-    if (!this.config.finished) return
-
-    this.pi.on('turn_start', () => {
-      this.clearIdleTimer()
-    })
-
-    this.pi.on('message_start', () => {
-      this.clearIdleTimer()
-    })
-
-    this.pi.on('agent_settled', () => {
-      if (this.jobTracker.hasActiveJobs) return
-      this.startIdleTimer(notify)
-    })
-
-    this.jobTracker.onEnd(() => {
-      this.startIdleTimer(notify)
-    })
-  }
-}

package/src/tool.ts

@@ -1,18 +0,0 @@
-import type { ExtensionAPI } from '@earendil-works/pi-coding-agent'
-
-import type { ResolvedNotifyConfig } from './config.js'
-import type { NotifyAction } from './types.js'
-
-export class ToolCallNotifier {
-  constructor(
-    private readonly pi: ExtensionAPI,
-    private readonly config: ResolvedNotifyConfig,
-  ) {}
-
-  register(notify: NotifyAction): void {
-    this.pi.on('tool_call', (event) => {
-      if (!this.config.notifyTools.has(event.toolName)) return
-      notify(`Tool call: ${event.toolName}`)
-    })
-  }
-}