prjct-cli 1.21.0 → 1.23.0

package/core/__tests__/utils/retry.test.ts

@@ -1,381 +0,0 @@
-/**
- * Retry Policy Tests
- * Tests for exponential backoff, error classification, and circuit breaker
- */
-
-import { afterEach, beforeEach, describe, expect, it } from 'bun:test'
-import {
-  defaultAgentRetryPolicy,
-  defaultToolRetryPolicy,
-  isPermanentError,
-  isTransientError,
-  RetryPolicy,
-} from '../../utils/retry'
-
-describe('RetryPolicy', () => {
-  let policy: RetryPolicy
-
-  beforeEach(() => {
-    policy = new RetryPolicy({
-      maxAttempts: 3,
-      baseDelayMs: 100, // Shorter delays for tests
-      maxDelayMs: 400,
-      circuitBreakerThreshold: 5,
-      circuitBreakerTimeoutMs: 1000,
-    })
-    // Reset all circuits before each test
-    policy.resetAllCircuits()
-  })
-
-  afterEach(() => {
-    policy.resetAllCircuits()
-  })
-
-  describe('Error Classification', () => {
-    it('should identify transient errors correctly', () => {
-      const transientErrors = [
-        { code: 'EBUSY' },
-        { code: 'EAGAIN' },
-        { code: 'ETIMEDOUT' },
-        { code: 'ECONNRESET' },
-        { code: 'ECONNREFUSED' },
-        { message: 'Operation timed out' },
-        { message: 'Request timeout' },
-      ]
-
-      for (const error of transientErrors) {
-        expect(isTransientError(error)).toBe(true)
-      }
-    })
-
-    it('should identify permanent errors correctly', () => {
-      const permanentErrors = [
-        { code: 'ENOENT' },
-        { code: 'EACCES' },
-        { code: 'EPERM' },
-        { code: 'EISDIR' },
-        { code: 'ENOTDIR' },
-        { code: 'EINVAL' },
-      ]
-
-      for (const error of permanentErrors) {
-        expect(isPermanentError(error)).toBe(true)
-        expect(isTransientError(error)).toBe(false)
-      }
-    })
-
-    it('should not classify unknown errors as transient', () => {
-      const unknownErrors = [
-        { code: 'UNKNOWN' },
-        { message: 'Unknown error' },
-        new Error('Generic error'),
-      ]
-
-      for (const error of unknownErrors) {
-        expect(isTransientError(error)).toBe(false)
-      }
-    })
-  })
-
-  describe('Successful Operations', () => {
-    it('should execute successful operation without retry', async () => {
-      let attempts = 0
-      const operation = async () => {
-        attempts++
-        return 'success'
-      }
-
-      const result = await policy.execute(operation, 'test-op')
-
-      expect(result).toBe('success')
-      expect(attempts).toBe(1)
-    })
-
-    it('should reset circuit breaker after success', async () => {
-      // Force some failures to increment circuit state
-      let failCount = 0
-      const failOperation = async () => {
-        failCount++
-        throw { code: 'EBUSY' }
-      }
-
-      try {
-        await policy.execute(failOperation, 'test-op')
-      } catch {
-        // Expected to fail
-      }
-
-      expect(failCount).toBe(3) // maxAttempts
-
-      // Now succeed - should reset circuit
-      const successOperation = async () => 'success'
-      await policy.execute(successOperation, 'test-op')
-
-      const circuitState = policy.getCircuitState('test-op')
-      expect(circuitState).toBeUndefined()
-    })
-  })
-
-  describe('Transient Error Retry', () => {
-    it('should retry transient errors and succeed', async () => {
-      let attempts = 0
-      const operation = async () => {
-        attempts++
-        if (attempts < 3) {
-          throw { code: 'EBUSY' } // Transient error
-        }
-        return 'success'
-      }
-
-      const result = await policy.execute(operation, 'test-op')
-
-      expect(result).toBe('success')
-      expect(attempts).toBe(3)
-    })
-
-    it('should apply exponential backoff between retries', async () => {
-      const timestamps: number[] = []
-      let attempts = 0
-
-      const operation = async () => {
-        timestamps.push(Date.now())
-        attempts++
-        if (attempts < 3) {
-          throw { code: 'ETIMEDOUT' }
-        }
-        return 'success'
-      }
-
-      await policy.execute(operation, 'test-op')
-
-      // Check delays: should be ~100ms, ~200ms (with some tolerance)
-      const delay1 = timestamps[1] - timestamps[0]
-      const delay2 = timestamps[2] - timestamps[1]
-
-      expect(delay1).toBeGreaterThanOrEqual(90) // 100ms with tolerance
-      expect(delay1).toBeLessThan(150)
-
-      expect(delay2).toBeGreaterThanOrEqual(180) // 200ms with tolerance
-      expect(delay2).toBeLessThan(250)
-    })
-
-    it('should respect maxDelayMs cap', async () => {
-      const policy = new RetryPolicy({
-        maxAttempts: 5,
-        baseDelayMs: 100,
-        maxDelayMs: 200,
-      })
-
-      const timestamps: number[] = []
-      let attempts = 0
-
-      const operation = async () => {
-        timestamps.push(Date.now())
-        attempts++
-        if (attempts < 5) {
-          throw { code: 'EBUSY' }
-        }
-        return 'success'
-      }
-
-      await policy.execute(operation, 'test-op')
-
-      // Last delay should not exceed maxDelayMs (check delay between attempt 3 and 4)
-      // Attempt 1: no delay
-      // Attempt 2: 100ms delay (baseDelayMs * 2^0)
-      // Attempt 3: 200ms delay (baseDelayMs * 2^1, capped at maxDelayMs)
-      // Attempt 4: 200ms delay (baseDelayMs * 2^2 = 400ms, capped at 200ms)
-      const delay3 = timestamps[3] - timestamps[2]
-      expect(delay3).toBeLessThanOrEqual(250) // 200ms + tolerance
-      expect(delay3).toBeGreaterThanOrEqual(180)
-    })
-
-    it('should throw if all retry attempts fail with transient error', async () => {
-      let attempts = 0
-      const operation = async () => {
-        attempts++
-        throw { code: 'EAGAIN' }
-      }
-
-      await expect(policy.execute(operation, 'test-op')).rejects.toMatchObject({
-        code: 'EAGAIN',
-      })
-
-      expect(attempts).toBe(3) // maxAttempts
-    })
-  })
-
-  describe('Permanent Error Handling', () => {
-    it('should fail fast on permanent errors without retry', async () => {
-      let attempts = 0
-      const operation = async () => {
-        attempts++
-        throw { code: 'ENOENT' } // Permanent error
-      }
-
-      await expect(policy.execute(operation, 'test-op')).rejects.toMatchObject({
-        code: 'ENOENT',
-      })
-
-      expect(attempts).toBe(1) // No retry
-    })
-
-    it('should fail fast on permission denied', async () => {
-      let attempts = 0
-      const operation = async () => {
-        attempts++
-        throw { code: 'EPERM' }
-      }
-
-      await expect(policy.execute(operation, 'test-op')).rejects.toMatchObject({
-        code: 'EPERM',
-      })
-
-      expect(attempts).toBe(1)
-    })
-
-    it('should record failure for permanent errors', async () => {
-      const operation = async () => {
-        throw { code: 'ENOENT' }
-      }
-
-      try {
-        await policy.execute(operation, 'perm-op')
-      } catch {
-        // Expected
-      }
-
-      const state = policy.getCircuitState('perm-op')
-      expect(state?.consecutiveFailures).toBe(1)
-    })
-  })
-
-  describe('Circuit Breaker', () => {
-    it('should open circuit after threshold failures', async () => {
-      const operation = async () => {
-        throw { code: 'EBUSY' }
-      }
-
-      // Execute 5 times to reach threshold (each attempt counts as 1 failure)
-      for (let i = 0; i < 5; i++) {
-        try {
-          await policy.execute(operation, 'circuit-op')
-        } catch {
-          // Expected
-        }
-      }
-
-      // Circuit should now be open
-      expect(policy.isCircuitOpen('circuit-op')).toBe(true)
-
-      // Next call should fail immediately with circuit breaker error
-      await expect(policy.execute(operation, 'circuit-op')).rejects.toThrow(
-        /Circuit breaker is open/
-      )
-    })
-
-    it('should close circuit after timeout', async () => {
-      const policy = new RetryPolicy({
-        maxAttempts: 3,
-        baseDelayMs: 10,
-        maxDelayMs: 50,
-        circuitBreakerThreshold: 3,
-        circuitBreakerTimeoutMs: 100, // Short timeout for test
-      })
-
-      const operation = async () => {
-        throw { code: 'ETIMEDOUT' }
-      }
-
-      // Trigger circuit breaker
-      for (let i = 0; i < 3; i++) {
-        try {
-          await policy.execute(operation, 'timeout-op')
-        } catch {
-          // Expected
-        }
-      }
-
-      expect(policy.isCircuitOpen('timeout-op')).toBe(true)
-
-      // Wait for timeout
-      await new Promise((resolve) => setTimeout(resolve, 150))
-
-      // Circuit should be closed now
-      expect(policy.isCircuitOpen('timeout-op')).toBe(false)
-    })
-
-    it('should track failures per operation independently', async () => {
-      const operation = async () => {
-        throw { code: 'EAGAIN' }
-      }
-
-      // Fail operation A multiple times
-      for (let i = 0; i < 3; i++) {
-        try {
-          await policy.execute(operation, 'op-a')
-        } catch {
-          // Expected
-        }
-      }
-
-      const stateA = policy.getCircuitState('op-a')
-      const stateB = policy.getCircuitState('op-b')
-
-      expect(stateA?.consecutiveFailures).toBe(3)
-      expect(stateB).toBeUndefined()
-    })
-  })
-
-  describe('Default Policies', () => {
-    it('should have agent retry policy with correct defaults', () => {
-      // Test that default agent policy is configured correctly
-      expect(defaultAgentRetryPolicy).toBeInstanceOf(RetryPolicy)
-      // We can't directly inspect options, but we can test behavior
-    })
-
-    it('should have tool retry policy with correct defaults', () => {
-      expect(defaultToolRetryPolicy).toBeInstanceOf(RetryPolicy)
-    })
-
-    it('should retry agent operations 3 times', async () => {
-      let attempts = 0
-      const operation = async () => {
-        attempts++
-        if (attempts < 3) {
-          throw { code: 'EBUSY' }
-        }
-        return 'success'
-      }
-
-      await defaultAgentRetryPolicy.execute(operation, 'agent-test')
-      expect(attempts).toBe(3)
-    })
-  })
-
-  describe('Edge Cases', () => {
-    it('should handle non-Error objects', async () => {
-      const operation = async () => {
-        throw 'string error'
-      }
-
-      await expect(policy.execute(operation, 'edge-op')).rejects.toBe('string error')
-    })
-
-    it('should handle null/undefined errors', async () => {
-      const operation = async () => {
-        throw null
-      }
-
-      await expect(policy.execute(operation, 'null-op')).rejects.toBeNull()
-    })
-
-    it('should handle errors without code property', async () => {
-      const operation = async () => {
-        throw new Error('Generic error')
-      }
-
-      await expect(policy.execute(operation, 'generic-op')).rejects.toThrow('Generic error')
-    })
-  })
-})

package/core/__tests__/workflow/state-machine.test.ts

@@ -1,216 +0,0 @@
-/**
- * State Machine Tests
- *
- * Tests for workflow state machine transitions:
- * - All valid transitions work
- * - Invalid transitions are rejected
- * - New transitions: completed→paused, paused→shipped, completed→reopen
- * - getCurrentState detects paused tasks from pausedTasks array
- */
-
-import { describe, expect, it } from 'bun:test'
-import type { WorkflowCommand, WorkflowState } from '../../workflow/state-machine'
-import { WorkflowStateMachine } from '../../workflow/state-machine'
-
-const sm = new WorkflowStateMachine()
-
-// =============================================================================
-// getCurrentState
-// =============================================================================
-
-describe('getCurrentState', () => {
-  it('returns idle when no task and no paused tasks', () => {
-    expect(sm.getCurrentState({ currentTask: null })).toBe('idle')
-    expect(sm.getCurrentState({})).toBe('idle')
-  })
-
-  it('returns working for in_progress status', () => {
-    expect(sm.getCurrentState({ currentTask: { status: 'in_progress' } })).toBe('working')
-    expect(sm.getCurrentState({ currentTask: { status: 'working' } })).toBe('working')
-  })
-
-  it('returns completed for completed/done status', () => {
-    expect(sm.getCurrentState({ currentTask: { status: 'completed' } })).toBe('completed')
-    expect(sm.getCurrentState({ currentTask: { status: 'done' } })).toBe('completed')
-  })
-
-  it('returns shipped for shipped status', () => {
-    expect(sm.getCurrentState({ currentTask: { status: 'shipped' } })).toBe('shipped')
-  })
-
-  it('returns paused when currentTask has paused status', () => {
-    expect(sm.getCurrentState({ currentTask: { status: 'paused' } })).toBe('paused')
-  })
-
-  it('returns paused when no currentTask but pausedTasks array has entries', () => {
-    expect(sm.getCurrentState({ currentTask: null, pausedTasks: [{ id: '1' }] })).toBe('paused')
-  })
-
-  it('returns paused when no currentTask but legacy previousTask is paused', () => {
-    expect(sm.getCurrentState({ currentTask: null, previousTask: { status: 'paused' } })).toBe(
-      'paused'
-    )
-  })
-
-  it('returns idle when no currentTask and empty pausedTasks', () => {
-    expect(sm.getCurrentState({ currentTask: null, pausedTasks: [] })).toBe('idle')
-  })
-
-  it('returns working for unknown status when task exists', () => {
-    expect(sm.getCurrentState({ currentTask: { status: 'active' } })).toBe('working')
-    expect(sm.getCurrentState({ currentTask: {} })).toBe('working')
-  })
-})
-
-// =============================================================================
-// canTransition - valid transitions
-// =============================================================================
-
-describe('canTransition - valid', () => {
-  const validTransitions: [WorkflowState, WorkflowCommand][] = [
-    // idle
-    ['idle', 'task'],
-    ['idle', 'next'],
-    // working
-    ['working', 'done'],
-    ['working', 'pause'],
-    // paused
-    ['paused', 'resume'],
-    ['paused', 'task'],
-    ['paused', 'ship'], // NEW: fast-track ship
-    // completed
-    ['completed', 'ship'],
-    ['completed', 'task'],
-    ['completed', 'next'],
-    ['completed', 'pause'], // NEW: reopen for review
-    ['completed', 'reopen'], // NEW: reopen for rework
-    // shipped
-    ['shipped', 'task'],
-    ['shipped', 'next'],
-  ]
-
-  for (const [state, command] of validTransitions) {
-    it(`${state} → ${command} is valid`, () => {
-      const result = sm.canTransition(state, command)
-      expect(result.valid).toBe(true)
-      expect(result.error).toBeUndefined()
-    })
-  }
-})
-
-// =============================================================================
-// canTransition - invalid transitions
-// =============================================================================
-
-describe('canTransition - invalid', () => {
-  const invalidTransitions: [WorkflowState, WorkflowCommand][] = [
-    ['idle', 'done'],
-    ['idle', 'pause'],
-    ['idle', 'resume'],
-    ['idle', 'ship'],
-    ['idle', 'reopen'],
-    ['working', 'task'],
-    ['working', 'ship'],
-    ['working', 'resume'],
-    ['working', 'next'],
-    ['working', 'reopen'],
-    ['paused', 'done'],
-    ['paused', 'pause'],
-    ['paused', 'reopen'],
-    ['shipped', 'done'],
-    ['shipped', 'pause'],
-    ['shipped', 'resume'],
-    ['shipped', 'ship'],
-    ['shipped', 'reopen'],
-  ]
-
-  for (const [state, command] of invalidTransitions) {
-    it(`${state} → ${command} is invalid`, () => {
-      const result = sm.canTransition(state, command)
-      expect(result.valid).toBe(false)
-      expect(result.error).toBeDefined()
-      expect(result.suggestion).toBeDefined()
-    })
-  }
-})
-
-// =============================================================================
-// getNextState
-// =============================================================================
-
-describe('getNextState', () => {
-  it('task → working', () => {
-    expect(sm.getNextState('idle', 'task')).toBe('working')
-    expect(sm.getNextState('paused', 'task')).toBe('working')
-    expect(sm.getNextState('completed', 'task')).toBe('working')
-  })
-
-  it('done → completed', () => {
-    expect(sm.getNextState('working', 'done')).toBe('completed')
-  })
-
-  it('pause → paused', () => {
-    expect(sm.getNextState('working', 'pause')).toBe('paused')
-    expect(sm.getNextState('completed', 'pause')).toBe('paused')
-  })
-
-  it('resume → working', () => {
-    expect(sm.getNextState('paused', 'resume')).toBe('working')
-  })
-
-  it('ship → shipped', () => {
-    expect(sm.getNextState('completed', 'ship')).toBe('shipped')
-    expect(sm.getNextState('paused', 'ship')).toBe('shipped')
-  })
-
-  it('reopen → working', () => {
-    expect(sm.getNextState('completed', 'reopen')).toBe('working')
-  })
-
-  it('next preserves current state', () => {
-    expect(sm.getNextState('idle', 'next')).toBe('idle')
-    expect(sm.getNextState('completed', 'next')).toBe('completed')
-  })
-})
-
-// =============================================================================
-// getValidCommands
-// =============================================================================
-
-describe('getValidCommands', () => {
-  it('idle allows task, next', () => {
-    expect(sm.getValidCommands('idle')).toEqual(['task', 'next'])
-  })
-
-  it('working allows done, pause', () => {
-    expect(sm.getValidCommands('working')).toEqual(['done', 'pause'])
-  })
-
-  it('paused allows resume, task, ship', () => {
-    expect(sm.getValidCommands('paused')).toEqual(['resume', 'task', 'ship'])
-  })
-
-  it('completed allows ship, task, next, pause, reopen', () => {
-    expect(sm.getValidCommands('completed')).toEqual(['ship', 'task', 'next', 'pause', 'reopen'])
-  })
-
-  it('shipped allows task, next', () => {
-    expect(sm.getValidCommands('shipped')).toEqual(['task', 'next'])
-  })
-})
-
-// =============================================================================
-// formatNextSteps
-// =============================================================================
-
-describe('formatNextSteps', () => {
-  it('includes reopen in completed state steps', () => {
-    const steps = sm.formatNextSteps('completed')
-    expect(steps.some((s) => s.includes('reopen'))).toBe(true)
-  })
-
-  it('includes ship in paused state steps', () => {
-    const steps = sm.formatNextSteps('paused')
-    expect(steps.some((s) => s.includes('ship'))).toBe(true)
-  })
-})