@raidou/pi-notify 0.3.1 → 0.4.0

package/src/state-tracker.ts

@@ -0,0 +1,76 @@
+import type { ExtensionAPI } from '@earendil-works/pi-coding-agent'
+import Emittery from 'emittery'
+
+import type { JobTracker } from './jobs.js'
+import { Registrar } from './shared/registrar.js'
+
+const IDLE_TIMEOUT_MS = 10000
+
+export class StateTracker extends Registrar {
+  readonly events = new Emittery<{
+    running: never
+    idle: never
+  }>()
+
+  private readonly jobTracker: JobTracker
+  private idleTimer: NodeJS.Timeout | null = null
+  private running = false
+
+  constructor(pi: ExtensionAPI, jobTracker: JobTracker) {
+    super(pi)
+    this.jobTracker = jobTracker
+  }
+
+  private startIdleTimer(): void {
+    if (this.jobTracker.hasActiveJobs) return
+    this.clearIdleTimer()
+    this.idleTimer = setTimeout(() => {
+      this.idleTimer = null
+      this.running = false
+      void this.events.emit('idle')
+    }, IDLE_TIMEOUT_MS)
+  }
+
+  private clearIdleTimer(): void {
+    if (this.idleTimer) {
+      clearTimeout(this.idleTimer)
+      this.idleTimer = null
+    }
+  }
+
+  private markRunning(): void {
+    if (this.running) return
+    this.running = true
+    void this.events.emit('running')
+  }
+
+  protected override setup(): void {
+    this.pi.on('turn_start', () => {
+      this.markRunning()
+      this.clearIdleTimer()
+    })
+
+    this.pi.on('message_start', () => {
+      this.clearIdleTimer()
+    })
+
+    this.pi.on('agent_settled', () => {
+      this.startIdleTimer()
+    })
+
+    this.pi.on('tool_call', () => {
+      this.clearIdleTimer()
+    })
+
+    this.unsubscribes.push(
+      this.jobTracker.onEnd(() => {
+        this.startIdleTimer()
+      }),
+    )
+  }
+
+  override stop(): void {
+    super.stop()
+    this.clearIdleTimer()
+  }
+}

package/src/states.ts

@@ -1,9 +1,11 @@
 import type { ExtensionAPI } from '@earendil-works/pi-coding-agent'
 
 export class SessionState {
+  private readonly pi: ExtensionAPI
   public hasUI = false
 
-  constructor(private readonly pi: ExtensionAPI) {
+  constructor(pi: ExtensionAPI) {
+    this.pi = pi
     this.register()
   }
 

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/tool.ts

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

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
-  }
-}