@alumbwe/anvil 1.0.0

package/src/utils/__tests__/active-run.test.ts

@@ -0,0 +1,140 @@
+import { afterEach, describe, expect, it } from 'bun:test'
+
+import {
+  ACTIVE_RUN_QUEUE_POLICIES,
+  applyActiveRunQueuePolicy,
+  clearActiveRun,
+  registerActiveRun,
+  registerActiveRunStopHandler,
+  stopActiveRun,
+  type ActiveRunStopReason,
+} from '../active-run'
+
+const ALL_REASONS: ActiveRunStopReason[] = [
+  'user-interrupt',
+  'logout',
+  'new-chat',
+  'history-resume',
+  'session-transition',
+  'process-exit',
+]
+
+describe('active run ownership', () => {
+  afterEach(() => {
+    stopActiveRun('process-exit')
+  })
+
+  it.each(ALL_REASONS)('passes the %s reason to the run owner', (reason) => {
+    const reasons: ActiveRunStopReason[] = []
+    registerActiveRun('run-1', (receivedReason) => {
+      reasons.push(receivedReason)
+    })
+
+    expect(stopActiveRun(reason)).toBe(true)
+    expect(reasons).toEqual([reason])
+    expect(stopActiveRun(reason)).toBe(false)
+  })
+
+  it('does not let stale cleanup clear a newer run', () => {
+    const reasons: ActiveRunStopReason[] = []
+    registerActiveRun('run-new', (reason) => reasons.push(reason))
+
+    clearActiveRun('run-old')
+
+    expect(stopActiveRun('logout')).toBe(true)
+    expect(reasons).toEqual(['logout'])
+  })
+
+  it('stops a displaced owner without letting it clear the replacement', () => {
+    const oldReasons: ActiveRunStopReason[] = []
+    const newReasons: ActiveRunStopReason[] = []
+    registerActiveRun('run-old', (reason) => {
+      oldReasons.push(reason)
+      clearActiveRun('run-old')
+    })
+
+    registerActiveRun('run-new', (reason) => newReasons.push(reason))
+
+    expect(oldReasons).toEqual(['user-interrupt'])
+    expect(stopActiveRun('new-chat')).toBe(true)
+    expect(newReasons).toEqual(['new-chat'])
+  })
+
+  it('releases ownership before calling the stop handler', () => {
+    const nestedResults: boolean[] = []
+    registerActiveRun('run-1', () => {
+      nestedResults.push(stopActiveRun('process-exit'))
+    })
+
+    stopActiveRun('user-interrupt')
+
+    expect(nestedResults).toEqual([false])
+  })
+
+  it('still runs persistent cleanup when the run callback throws', () => {
+    const reasons: ActiveRunStopReason[] = []
+    const unregister = registerActiveRunStopHandler((reason) => {
+      reasons.push(reason)
+    })
+    registerActiveRun('broken-run', () => {
+      throw new Error('broken stop callback')
+    })
+
+    try {
+      expect(() => stopActiveRun('logout')).not.toThrow()
+      expect(reasons).toEqual(['logout'])
+    } finally {
+      unregister()
+    }
+  })
+
+  it.each(ALL_REASONS)(
+    'runs persistent runtime cleanup for %s even while idle',
+    (reason) => {
+      const reasons: ActiveRunStopReason[] = []
+      const unregister = registerActiveRunStopHandler((receivedReason) => {
+        reasons.push(receivedReason)
+      })
+
+      try {
+        expect(stopActiveRun(reason)).toBe(false)
+        expect(reasons).toEqual([reason])
+      } finally {
+        unregister()
+      }
+    },
+  )
+})
+
+describe('active run stop policies', () => {
+  const applyQueuePolicy = (reason: ActiveRunStopReason) => {
+    const calls: string[] = []
+    applyActiveRunQueuePolicy(reason, {
+      pauseQueueIfPending: () => calls.push('pause-if-pending'),
+      discardQueue: () => calls.push('discard'),
+      setCanProcessQueue: (canProcess) =>
+        calls.push(`can-process:${canProcess}`),
+    })
+    return calls
+  }
+
+  it('pauses pending work only for a manual interrupt', () => {
+    expect(ACTIVE_RUN_QUEUE_POLICIES['user-interrupt']).toBe('pause-if-pending')
+    expect(applyQueuePolicy('user-interrupt')).toEqual(['pause-if-pending'])
+  })
+
+  it.each([
+    'logout',
+    'new-chat',
+    'history-resume',
+    'session-transition',
+  ] as const)('clears and blocks the old queue for %s', (reason) => {
+    expect(ACTIVE_RUN_QUEUE_POLICIES[reason]).toBe('clear-and-block')
+    expect(applyQueuePolicy(reason)).toEqual(['discard'])
+  })
+
+  it('preserves and blocks the in-memory queue on exit', () => {
+    expect(ACTIVE_RUN_QUEUE_POLICIES['process-exit']).toBe('preserve-and-block')
+    expect(applyQueuePolicy('process-exit')).toEqual(['can-process:false'])
+  })
+})

package/src/utils/__tests__/activity-tracker.test.ts

@@ -0,0 +1,440 @@
+import { describe, test, expect, beforeEach, afterEach, mock } from 'bun:test'
+
+import {
+  reportActivity,
+  getLastActivityTime,
+  isUserActive,
+  getIdleTime,
+  subscribeToActivity,
+  resetActivityTracker,
+} from '../activity-tracker'
+
+describe('activity-tracker', () => {
+  let originalDateNow: typeof Date.now
+  let mockNow: number
+
+  beforeEach(() => {
+    originalDateNow = Date.now
+    mockNow = 1000000
+    Date.now = () => mockNow
+    resetActivityTracker()
+  })
+
+  afterEach(() => {
+    Date.now = originalDateNow
+  })
+
+  describe('reportActivity', () => {
+    test('updates lastActivityTime to current time', () => {
+      mockNow = 2000000
+      reportActivity()
+      expect(getLastActivityTime()).toBe(2000000)
+    })
+
+    test('notifies all subscribers when activity is reported', () => {
+      const listener1 = mock(() => {})
+      const listener2 = mock(() => {})
+
+      subscribeToActivity(listener1)
+      subscribeToActivity(listener2)
+
+      mockNow = 3000000
+      reportActivity()
+
+      expect(listener1).toHaveBeenCalledTimes(1)
+      expect(listener1).toHaveBeenCalledWith(3000000)
+      expect(listener2).toHaveBeenCalledTimes(1)
+      expect(listener2).toHaveBeenCalledWith(3000000)
+    })
+
+    test('multiple calls update the timestamp each time', () => {
+      mockNow = 1000
+      reportActivity()
+      expect(getLastActivityTime()).toBe(1000)
+
+      mockNow = 2000
+      reportActivity()
+      expect(getLastActivityTime()).toBe(2000)
+
+      mockNow = 3000
+      reportActivity()
+      expect(getLastActivityTime()).toBe(3000)
+    })
+  })
+
+  describe('getLastActivityTime', () => {
+    test('returns the initial time after reset', () => {
+      // After reset, lastActivityTime is set to Date.now()
+      expect(getLastActivityTime()).toBe(mockNow)
+    })
+
+    test('returns the time of the last activity', () => {
+      mockNow = 5000000
+      reportActivity()
+      expect(getLastActivityTime()).toBe(5000000)
+    })
+  })
+
+  describe('isUserActive', () => {
+    test('returns true when user activity is within threshold', () => {
+      reportActivity()
+      mockNow += 10000 // 10 seconds later
+      expect(isUserActive(30000)).toBe(true)
+    })
+
+    test('returns false when user has been idle longer than threshold', () => {
+      reportActivity()
+      mockNow += 35000 // 35 seconds later
+      expect(isUserActive(30000)).toBe(false)
+    })
+
+    test('uses default threshold of 30 seconds', () => {
+      reportActivity()
+      mockNow += 29000 // 29 seconds later
+      expect(isUserActive()).toBe(true)
+
+      mockNow += 2000 // 31 seconds total
+      expect(isUserActive()).toBe(false)
+    })
+
+    test('returns true at exactly the threshold boundary', () => {
+      reportActivity()
+      mockNow += 29999 // Just under 30 seconds
+      expect(isUserActive(30000)).toBe(true)
+    })
+
+    test('returns false at exactly the threshold', () => {
+      reportActivity()
+      mockNow += 30000 // Exactly 30 seconds
+      expect(isUserActive(30000)).toBe(false)
+    })
+
+    test('works with custom thresholds', () => {
+      reportActivity()
+      mockNow += 5000
+      expect(isUserActive(10000)).toBe(true)
+      expect(isUserActive(3000)).toBe(false)
+    })
+  })
+
+  describe('getIdleTime', () => {
+    test('returns 0 immediately after activity', () => {
+      reportActivity()
+      expect(getIdleTime()).toBe(0)
+    })
+
+    test('returns correct idle time', () => {
+      reportActivity()
+      mockNow += 15000
+      expect(getIdleTime()).toBe(15000)
+    })
+
+    test('increases as time passes', () => {
+      reportActivity()
+
+      mockNow += 1000
+      expect(getIdleTime()).toBe(1000)
+
+      mockNow += 4000
+      expect(getIdleTime()).toBe(5000)
+
+      mockNow += 10000
+      expect(getIdleTime()).toBe(15000)
+    })
+
+    test('resets after new activity', () => {
+      reportActivity()
+      mockNow += 10000
+      expect(getIdleTime()).toBe(10000)
+
+      reportActivity()
+      expect(getIdleTime()).toBe(0)
+    })
+  })
+
+  describe('subscribeToActivity', () => {
+    test('returns an unsubscribe function', () => {
+      const listener = mock(() => {})
+      const unsubscribe = subscribeToActivity(listener)
+
+      expect(typeof unsubscribe).toBe('function')
+    })
+
+    test('unsubscribe stops notifications', () => {
+      const listener = mock(() => {})
+      const unsubscribe = subscribeToActivity(listener)
+
+      reportActivity()
+      expect(listener).toHaveBeenCalledTimes(1)
+
+      unsubscribe()
+
+      reportActivity()
+      expect(listener).toHaveBeenCalledTimes(1) // Still 1, not called again
+    })
+
+    test('multiple subscribers work independently', () => {
+      const listener1 = mock(() => {})
+      const listener2 = mock(() => {})
+      const listener3 = mock(() => {})
+
+      const unsub1 = subscribeToActivity(listener1)
+      subscribeToActivity(listener2)
+      subscribeToActivity(listener3)
+
+      reportActivity()
+      expect(listener1).toHaveBeenCalledTimes(1)
+      expect(listener2).toHaveBeenCalledTimes(1)
+      expect(listener3).toHaveBeenCalledTimes(1)
+
+      unsub1()
+
+      reportActivity()
+      expect(listener1).toHaveBeenCalledTimes(1) // Unsubscribed
+      expect(listener2).toHaveBeenCalledTimes(2)
+      expect(listener3).toHaveBeenCalledTimes(2)
+    })
+
+    test('same listener can be subscribed multiple times', () => {
+      const listener = mock(() => {})
+
+      subscribeToActivity(listener)
+      subscribeToActivity(listener)
+
+      reportActivity()
+      // Set only stores unique values, so it's called once
+      expect(listener).toHaveBeenCalledTimes(1)
+    })
+
+    test('unsubscribing non-existent listener does nothing', () => {
+      const listener1 = mock(() => {})
+      const listener2 = mock(() => {})
+
+      const unsub1 = subscribeToActivity(listener1)
+      unsub1()
+      unsub1() // Double unsubscribe should not throw
+
+      reportActivity()
+      expect(listener1).not.toHaveBeenCalled()
+    })
+  })
+
+  describe('resetActivityTracker', () => {
+    test('resets lastActivityTime to current time', () => {
+      reportActivity()
+      mockNow = 9999999
+      resetActivityTracker()
+      expect(getLastActivityTime()).toBe(9999999)
+    })
+
+    test('clears all listeners', () => {
+      const listener1 = mock(() => {})
+      const listener2 = mock(() => {})
+
+      subscribeToActivity(listener1)
+      subscribeToActivity(listener2)
+
+      resetActivityTracker()
+
+      reportActivity()
+      expect(listener1).not.toHaveBeenCalled()
+      expect(listener2).not.toHaveBeenCalled()
+    })
+  })
+})
+
+/**
+ * Tests for activity tracker integration with useActivityQuery.
+ * These verify the behavior that affects polling and refetching in hooks.
+ */
+describe('activity-tracker integration scenarios', () => {
+  let originalDateNow: typeof Date.now
+  let mockNow: number
+
+  beforeEach(() => {
+    originalDateNow = Date.now
+    mockNow = 1000000
+    Date.now = () => mockNow
+    resetActivityTracker()
+  })
+
+  afterEach(() => {
+    Date.now = originalDateNow
+  })
+
+  describe('pauseWhenIdle behavior', () => {
+    test('isUserActive returns true immediately after reportActivity', () => {
+      reportActivity()
+      expect(isUserActive(30000)).toBe(true)
+    })
+
+    test('isUserActive returns false after idle threshold passes', () => {
+      reportActivity()
+      mockNow += 35000 // 35 seconds
+      expect(isUserActive(30000)).toBe(false)
+    })
+
+    test('activity tracking prevents polling pause', () => {
+      // Simulate user typing every 10 seconds
+      reportActivity()
+      expect(isUserActive(30000)).toBe(true)
+
+      mockNow += 10000
+      reportActivity()
+      expect(isUserActive(30000)).toBe(true)
+
+      mockNow += 10000
+      reportActivity()
+      expect(isUserActive(30000)).toBe(true)
+
+      // User is continuously active - polling should continue
+    })
+
+    test('prolonged inactivity should trigger idle state', () => {
+      reportActivity()
+
+      // Simulate no activity for 60 seconds
+      mockNow += 60000
+
+      expect(isUserActive(30000)).toBe(false)
+      expect(getIdleTime()).toBe(60000)
+    })
+  })
+
+  describe('refetchOnActivity behavior', () => {
+    test('activity notification triggers listeners for refetch', () => {
+      const refetchCallback = mock(() => {})
+      subscribeToActivity(refetchCallback)
+
+      // User was idle
+      mockNow += 35000
+      expect(isUserActive(30000)).toBe(false)
+
+      // User becomes active - should notify listeners
+      reportActivity()
+
+      expect(refetchCallback).toHaveBeenCalledTimes(1)
+      expect(refetchCallback).toHaveBeenCalledWith(mockNow)
+    })
+
+    test('multiple listeners all receive activity notifications', () => {
+      const callback1 = mock(() => {})
+      const callback2 = mock(() => {})
+      const callback3 = mock(() => {})
+
+      subscribeToActivity(callback1)
+      subscribeToActivity(callback2)
+      subscribeToActivity(callback3)
+
+      reportActivity()
+
+      expect(callback1).toHaveBeenCalledTimes(1)
+      expect(callback2).toHaveBeenCalledTimes(1)
+      expect(callback3).toHaveBeenCalledTimes(1)
+    })
+
+    test('unsubscribed listeners do not receive notifications', () => {
+      const activeCallback = mock(() => {})
+      const unsubscribedCallback = mock(() => {})
+
+      subscribeToActivity(activeCallback)
+      const unsub = subscribeToActivity(unsubscribedCallback)
+
+      // Unsubscribe one listener
+      unsub()
+
+      reportActivity()
+
+      expect(activeCallback).toHaveBeenCalledTimes(1)
+      expect(unsubscribedCallback).not.toHaveBeenCalled()
+    })
+  })
+
+  describe('Claude quota polling scenarios', () => {
+    test('idle user should not trigger quota polling', () => {
+      const idleThreshold = 30000
+
+      // User was active
+      reportActivity()
+
+      // 60 seconds pass with no activity
+      mockNow += 60000
+
+      // User is idle
+      expect(isUserActive(idleThreshold)).toBe(false)
+
+      // When pauseWhenIdle is true, polling tick should skip refetch
+      // (tested in use-activity-query: if (pauseWhenIdle && !isUserActive(idleThreshold)) return)
+    })
+
+    test('returning user after idle should trigger stale data refetch', () => {
+      const idleThreshold = 30000
+      const wasIdleCallback = mock(() => {})
+
+      // Simulate wasIdleRef pattern from useActivityQuery
+      let wasIdle = false
+
+      subscribeToActivity(() => {
+        if (wasIdle) {
+          wasIdleCallback()
+          wasIdle = false
+        }
+      })
+
+      // User is initially active
+      reportActivity()
+
+      // User goes idle
+      mockNow += 35000
+      wasIdle = !isUserActive(idleThreshold)
+      expect(wasIdle).toBe(true)
+
+      // User returns
+      reportActivity()
+
+      // Should have triggered the "returning from idle" callback
+      expect(wasIdleCallback).toHaveBeenCalledTimes(1)
+    })
+
+    test('continuous activity should not set wasIdle flag', () => {
+      const idleThreshold = 30000
+
+      // User types every 10 seconds
+      for (let i = 0; i < 10; i++) {
+        reportActivity()
+        mockNow += 10000
+
+        // User never goes idle
+        expect(isUserActive(idleThreshold)).toBe(true)
+      }
+    })
+  })
+
+  describe('edge cases', () => {
+    test('very short idle threshold', () => {
+      reportActivity()
+      mockNow += 100 // 0.1 seconds
+      expect(isUserActive(100)).toBe(false)
+    })
+
+    test('very long idle threshold', () => {
+      reportActivity()
+      mockNow += 3600000 // 1 hour
+      expect(isUserActive(7200000)).toBe(true) // 2 hour threshold
+    })
+
+    test('activity reported multiple times in quick succession', () => {
+      const callback = mock(() => {})
+      subscribeToActivity(callback)
+
+      // Rapid activity reporting (e.g., typing fast)
+      for (let i = 0; i < 100; i++) {
+        mockNow += 10 // 10ms between keystrokes
+        reportActivity()
+      }
+
+      expect(callback).toHaveBeenCalledTimes(100)
+      expect(getLastActivityTime()).toBe(mockNow)
+    })
+  })
+})

package/src/utils/__tests__/agent-display.test.ts

@@ -0,0 +1,139 @@
+import { describe, expect, test } from 'bun:test'
+
+import {
+  getAgentDisplayPrompt,
+  getBasherFinishedOutputPreview,
+  truncateToSingleLinePreview,
+} from '../agent-display'
+
+import type { AgentContentBlock } from '../../types/chat'
+
+const createAgentBlock = (
+  overrides: Partial<AgentContentBlock>,
+): AgentContentBlock => ({
+  type: 'agent',
+  agentId: 'agent-1',
+  agentName: 'Basher',
+  agentType: 'basher',
+  content: '',
+  status: 'running',
+  blocks: [],
+  initialPrompt: '',
+  ...overrides,
+})
+
+describe('getAgentDisplayPrompt', () => {
+  test('uses initial prompt when present', () => {
+    const block = createAgentBlock({
+      initialPrompt: 'Run tests',
+      params: {
+        what_to_summarize: 'Summarize failures',
+      },
+    })
+
+    expect(getAgentDisplayPrompt(block)).toBe('Run tests')
+  })
+
+  test('uses basher what_to_summarize when prompt is omitted', () => {
+    const block = createAgentBlock({
+      params: {
+        command: 'bun test',
+        what_to_summarize: 'Summarize failing tests only',
+      },
+    })
+
+    expect(getAgentDisplayPrompt(block)).toBe('Summarize failing tests only')
+  })
+
+  test('normalizes scoped and versioned basher agent ids', () => {
+    const block = createAgentBlock({
+      agentType: 'anvil/basher@1.0.0',
+      params: {
+        what_to_summarize: 'Summarize command output',
+      },
+    })
+
+    expect(getAgentDisplayPrompt(block)).toBe('Summarize command output')
+  })
+
+  test('ignores non-basher what_to_summarize params', () => {
+    const block = createAgentBlock({
+      agentName: 'code-searcher',
+      agentType: 'code-searcher',
+      params: {
+        what_to_summarize: 'This is not a basher prompt',
+      },
+    })
+
+    expect(getAgentDisplayPrompt(block)).toBeUndefined()
+  })
+})
+
+describe('getBasherFinishedOutputPreview', () => {
+  test('returns undefined while basher is still running', () => {
+    const block = createAgentBlock({
+      status: 'running',
+      params: {
+        what_to_summarize: 'Report the test result',
+      },
+      blocks: [{ type: 'text', content: 'Tests passed' }],
+    })
+
+    expect(getBasherFinishedOutputPreview(block)).toBeUndefined()
+  })
+
+  test('uses finished basher text output before what_to_summarize', () => {
+    const block = createAgentBlock({
+      status: 'complete',
+      params: {
+        what_to_summarize: 'Report the test result',
+      },
+      blocks: [
+        {
+          type: 'text',
+          content: 'Tests passed\n42 assertions completed',
+          textType: 'text',
+        },
+      ],
+    })
+
+    expect(getBasherFinishedOutputPreview(block)).toBe(
+      'Tests passed 42 assertions completed',
+    )
+  })
+
+  test('falls back to command output when no text block exists', () => {
+    const block = createAgentBlock({
+      status: 'complete',
+      blocks: [
+        {
+          type: 'tool',
+          toolCallId: 'tool-1',
+          toolName: 'run_terminal_command',
+          input: { command: 'git status --short' },
+          output: ' M cli/src/app.tsx\n',
+        },
+      ],
+    })
+
+    expect(getBasherFinishedOutputPreview(block)).toBe('M cli/src/app.tsx')
+  })
+
+  test('ignores non-basher output', () => {
+    const block = createAgentBlock({
+      agentType: 'code-searcher',
+      status: 'complete',
+      blocks: [{ type: 'text', content: 'Search results' }],
+    })
+
+    expect(getBasherFinishedOutputPreview(block)).toBeUndefined()
+  })
+})
+
+describe('truncateToSingleLinePreview', () => {
+  test('collapses whitespace and truncates to the requested length', () => {
+    expect(truncateToSingleLinePreview('one\ntwo   three four', 13)).toBe(
+      'one two th...',
+    )
+  })
+})