prjct-cli 1.22.0 → 1.23.0

package/core/__tests__/infrastructure/performance-tracker.test.ts

@@ -1,328 +0,0 @@
-/**
- * PerformanceTracker Tests
- *
- * Tests for:
- * - Timing marks (start/end)
- * - Memory snapshots
- * - Metric recording to JSONL
- * - Context correctness recording
- * - Subtask handoff recording
- * - Report generation
- * - JSONL rotation
- *
- * @see PRJ-297
- */
-
-import { afterEach, beforeEach, describe, expect, it } from 'bun:test'
-import fs from 'node:fs/promises'
-import os from 'node:os'
-import path from 'node:path'
-import pathManager from '../../infrastructure/path-manager'
-import { performanceTracker } from '../../infrastructure/performance-tracker'
-import type { PerformanceEntry, PerformanceMetric } from '../../schemas/performance'
-import * as jsonlHelper from '../../utils/jsonl-helper'
-
-// =============================================================================
-// Test Setup
-// =============================================================================
-
-let tmpRoot: string | null = null
-let testProjectId: string
-
-const originalGetStoragePath = pathManager.getStoragePath.bind(pathManager)
-const originalGetGlobalProjectPath = pathManager.getGlobalProjectPath.bind(pathManager)
-
-describe('PerformanceTracker', () => {
-  beforeEach(async () => {
-    tmpRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'prjct-perf-test-'))
-    testProjectId = 'test-project-perf'
-
-    pathManager.getStoragePath = (projectId: string, filename: string) => {
-      return path.join(tmpRoot!, projectId, 'storage', filename)
-    }
-
-    pathManager.getGlobalProjectPath = (projectId: string) => {
-      return path.join(tmpRoot!, projectId)
-    }
-  })
-
-  afterEach(async () => {
-    pathManager.getStoragePath = originalGetStoragePath
-    pathManager.getGlobalProjectPath = originalGetGlobalProjectPath
-
-    if (tmpRoot) {
-      await fs.rm(tmpRoot, { recursive: true, force: true })
-      tmpRoot = null
-    }
-  })
-
-  // ===========================================================================
-  // Timing Tests
-  // ===========================================================================
-
-  describe('timing marks', () => {
-    it('should measure elapsed time between start and end', async () => {
-      performanceTracker.markStart('test-op')
-
-      // Simulate some work
-      await new Promise((resolve) => setTimeout(resolve, 10))
-
-      const durationMs = performanceTracker.markEnd('test-op')
-      expect(durationMs).not.toBeNull()
-      expect(durationMs!).toBeGreaterThan(0)
-      expect(durationMs!).toBeLessThan(1000) // Shouldn't take more than 1s
-    })
-
-    it('should return null for non-existent mark', () => {
-      const result = performanceTracker.markEnd('nonexistent')
-      expect(result).toBeNull()
-    })
-
-    it('should clean up marks after end', () => {
-      performanceTracker.markStart('cleanup-test')
-      performanceTracker.markEnd('cleanup-test')
-
-      // Second call should return null
-      const result = performanceTracker.markEnd('cleanup-test')
-      expect(result).toBeNull()
-    })
-  })
-
-  // ===========================================================================
-  // Memory Tests
-  // ===========================================================================
-
-  describe('memory snapshots', () => {
-    it('should return valid memory snapshot', () => {
-      const snapshot = performanceTracker.snapshotMemory()
-
-      expect(snapshot.heapUsed).toBeGreaterThan(0)
-      expect(snapshot.heapTotal).toBeGreaterThan(0)
-      expect(snapshot.rss).toBeGreaterThan(0)
-      expect(snapshot.external).toBeGreaterThanOrEqual(0)
-      // heapUsed can momentarily exceed heapTotal during GC, so just
-      // verify both are positive numbers in a reasonable range
-      expect(snapshot.heapTotal).toBeGreaterThan(1024 * 1024) // > 1MB
-    })
-
-    it('should record memory to JSONL', async () => {
-      const snapshot = await performanceTracker.recordMemory(testProjectId)
-
-      expect(snapshot.heapUsed).toBeGreaterThan(0)
-
-      // Verify JSONL file was created
-      const filePath = pathManager.getStoragePath(testProjectId, 'performance.jsonl')
-      const entries = await jsonlHelper.readJsonLines<PerformanceMetric>(filePath)
-
-      // Should have 4 entries (heap_used, heap_total, rss, external_memory)
-      expect(entries.length).toBe(4)
-      expect(entries.map((e) => e.metric)).toEqual([
-        'heap_used',
-        'heap_total',
-        'rss',
-        'external_memory',
-      ])
-    })
-  })
-
-  // ===========================================================================
-  // Recording Tests
-  // ===========================================================================
-
-  describe('metric recording', () => {
-    it('should record timing metric to JSONL', async () => {
-      await performanceTracker.recordTiming(testProjectId, 'startup_time', 350.5)
-
-      const filePath = pathManager.getStoragePath(testProjectId, 'performance.jsonl')
-      const entries = await jsonlHelper.readJsonLines<PerformanceMetric>(filePath)
-
-      expect(entries.length).toBe(1)
-      expect(entries[0].metric).toBe('startup_time')
-      expect(entries[0].value).toBe(350.5)
-      expect(entries[0].unit).toBe('ms')
-      expect(entries[0].timestamp).toBeTruthy()
-    })
-
-    it('should record timing with context', async () => {
-      await performanceTracker.recordTiming(testProjectId, 'command_duration', 120, {
-        command: 'sync',
-      })
-
-      const filePath = pathManager.getStoragePath(testProjectId, 'performance.jsonl')
-      const entries = await jsonlHelper.readJsonLines<PerformanceMetric>(filePath)
-
-      expect(entries[0].context).toEqual({ command: 'sync' })
-    })
-
-    it('should append multiple metrics', async () => {
-      await performanceTracker.recordTiming(testProjectId, 'startup_time', 300)
-      await performanceTracker.recordTiming(testProjectId, 'startup_time', 250)
-      await performanceTracker.recordTiming(testProjectId, 'command_duration', 50)
-
-      const filePath = pathManager.getStoragePath(testProjectId, 'performance.jsonl')
-      const entries = await jsonlHelper.readJsonLines<PerformanceMetric>(filePath)
-
-      expect(entries.length).toBe(3)
-    })
-  })
-
-  // ===========================================================================
-  // Context Correctness Tests
-  // ===========================================================================
-
-  describe('context correctness', () => {
-    it('should record context correctness entry', async () => {
-      await performanceTracker.recordContextCorrectness(testProjectId, {
-        taskId: 'task_123',
-        receivedSync: true,
-        syncFieldsInjected: ['analysis', 'patterns'],
-      })
-
-      const filePath = pathManager.getStoragePath(testProjectId, 'performance.jsonl')
-      const entries = await jsonlHelper.readJsonLines<PerformanceEntry>(filePath)
-
-      expect(entries.length).toBe(1)
-      const entry = entries[0] as Record<string, unknown>
-      expect(entry.metric).toBe('context_correctness')
-      expect(entry.taskId).toBe('task_123')
-      expect(entry.receivedSync).toBe(true)
-    })
-  })
-
-  // ===========================================================================
-  // Subtask Handoff Tests
-  // ===========================================================================
-
-  describe('subtask handoff', () => {
-    it('should record handoff entry', async () => {
-      await performanceTracker.recordSubtaskHandoff(testProjectId, {
-        taskId: 'task_456',
-        subtaskId: 'subtask-001',
-        outputPopulated: true,
-      })
-
-      const filePath = pathManager.getStoragePath(testProjectId, 'performance.jsonl')
-      const entries = await jsonlHelper.readJsonLines<PerformanceEntry>(filePath)
-
-      expect(entries.length).toBe(1)
-      const entry = entries[0] as Record<string, unknown>
-      expect(entry.metric).toBe('subtask_handoff')
-      expect(entry.outputPopulated).toBe(true)
-    })
-  })
-
-  // ===========================================================================
-  // Report Generation Tests
-  // ===========================================================================
-
-  describe('report generation', () => {
-    it('should return empty report when no data', async () => {
-      const report = await performanceTracker.getReport(testProjectId)
-
-      expect(report.period).toBe('7d')
-      expect(report.startup).toBeUndefined()
-      expect(report.memory).toBeUndefined()
-      expect(report.contextCorrectness).toBeUndefined()
-      expect(report.subtaskHandoff).toBeUndefined()
-    })
-
-    it('should aggregate startup time metrics', async () => {
-      await performanceTracker.recordTiming(testProjectId, 'startup_time', 300)
-      await performanceTracker.recordTiming(testProjectId, 'startup_time', 400)
-      await performanceTracker.recordTiming(testProjectId, 'startup_time', 500)
-
-      const report = await performanceTracker.getReport(testProjectId)
-
-      expect(report.startup).toBeDefined()
-      expect(report.startup!.avg).toBe(400)
-      expect(report.startup!.min).toBe(300)
-      expect(report.startup!.max).toBe(500)
-      expect(report.startup!.count).toBe(3)
-    })
-
-    it('should aggregate memory metrics', async () => {
-      await performanceTracker.recordMemory(testProjectId)
-
-      const report = await performanceTracker.getReport(testProjectId)
-
-      expect(report.memory).toBeDefined()
-      expect(report.memory!.avgHeapMB).toBeGreaterThan(0)
-      expect(report.memory!.peakHeapMB).toBeGreaterThan(0)
-    })
-
-    it('should aggregate context correctness', async () => {
-      await performanceTracker.recordContextCorrectness(testProjectId, {
-        taskId: 't1',
-        receivedSync: true,
-      })
-      await performanceTracker.recordContextCorrectness(testProjectId, {
-        taskId: 't2',
-        receivedSync: false,
-      })
-
-      const report = await performanceTracker.getReport(testProjectId)
-
-      expect(report.contextCorrectness).toBeDefined()
-      expect(report.contextCorrectness!.total).toBe(2)
-      expect(report.contextCorrectness!.receivedSync).toBe(1)
-      expect(report.contextCorrectness!.rate).toBe(50)
-    })
-
-    it('should aggregate subtask handoff', async () => {
-      await performanceTracker.recordSubtaskHandoff(testProjectId, {
-        taskId: 't1',
-        subtaskId: 's1',
-        outputPopulated: true,
-      })
-      await performanceTracker.recordSubtaskHandoff(testProjectId, {
-        taskId: 't1',
-        subtaskId: 's2',
-        outputPopulated: true,
-      })
-      await performanceTracker.recordSubtaskHandoff(testProjectId, {
-        taskId: 't1',
-        subtaskId: 's3',
-        outputPopulated: false,
-      })
-
-      const report = await performanceTracker.getReport(testProjectId)
-
-      expect(report.subtaskHandoff).toBeDefined()
-      expect(report.subtaskHandoff!.total).toBe(3)
-      expect(report.subtaskHandoff!.outputPopulated).toBe(2)
-      expect(report.subtaskHandoff!.rate).toBe(67)
-    })
-
-    it('should aggregate command durations', async () => {
-      await performanceTracker.recordTiming(testProjectId, 'command_duration', 100, {
-        command: 'sync',
-      })
-      await performanceTracker.recordTiming(testProjectId, 'command_duration', 200, {
-        command: 'sync',
-      })
-      await performanceTracker.recordTiming(testProjectId, 'command_duration', 50, {
-        command: 'status',
-      })
-
-      const report = await performanceTracker.getReport(testProjectId)
-
-      expect(report.commandDurations).toBeDefined()
-      expect(report.commandDurations!.sync).toBeDefined()
-      expect(report.commandDurations!.sync.avg).toBe(150)
-      expect(report.commandDurations!.sync.count).toBe(2)
-      expect(report.commandDurations!.status).toBeDefined()
-      expect(report.commandDurations!.status.avg).toBe(50)
-    })
-
-    it('should filter by date range', async () => {
-      // Record some metrics
-      await performanceTracker.recordTiming(testProjectId, 'startup_time', 300)
-
-      // Report for 0 days (should find nothing before today)
-      const report = await performanceTracker.getReport(testProjectId, 0)
-      // With 0 days, sinceDate = today, so entries from "now" should still match
-      // because the filter is >= sinceIso (same day)
-      expect(report.startup).toBeDefined()
-    })
-  })
-})

package/core/__tests__/schemas/model.test.ts

@@ -1,272 +0,0 @@
-/**
- * Model Schema Tests
- *
- * Tests for:
- * - Provider model validation
- * - Semver comparison
- * - Minimum CLI version enforcement
- * - Model mismatch detection
- * - Default model resolution
- * - Backwards compatibility (missing model field)
- *
- * @see PRJ-265
- */
-
-import { describe, expect, it } from 'bun:test'
-import {
-  ClaudeProvider,
-  CursorProvider,
-  GeminiProvider,
-  validateCliVersion,
-} from '../../infrastructure/ai-provider'
-import {
-  checkModelMismatch,
-  compareSemver,
-  getDefaultModel,
-  getSupportedModels,
-  isValidModelForProvider,
-  type ModelMetadata,
-  meetsMinVersion,
-} from '../../schemas/model'
-
-// =============================================================================
-// Provider Model Configuration
-// =============================================================================
-
-describe('Provider model configuration', () => {
-  it('should have model fields on Claude provider', () => {
-    expect(ClaudeProvider.defaultModel).toBe('sonnet')
-    expect(ClaudeProvider.supportedModels).toEqual(['opus', 'sonnet', 'haiku'])
-    expect(ClaudeProvider.minCliVersion).toBe('1.0.0')
-  })
-
-  it('should have model fields on Gemini provider', () => {
-    expect(GeminiProvider.defaultModel).toBe('2.5-flash')
-    expect(GeminiProvider.supportedModels).toEqual(['2.5-pro', '2.5-flash', '2.0-flash'])
-    expect(GeminiProvider.minCliVersion).toBe('1.0.0')
-  })
-
-  it('should have null model fields on multi-model IDEs', () => {
-    expect(CursorProvider.defaultModel).toBeNull()
-    expect(CursorProvider.supportedModels).toEqual([])
-    expect(CursorProvider.minCliVersion).toBeNull()
-  })
-})
-
-// =============================================================================
-// Model Validation
-// =============================================================================
-
-describe('isValidModelForProvider', () => {
-  it('should accept valid Claude models', () => {
-    expect(isValidModelForProvider('claude', 'opus')).toBe(true)
-    expect(isValidModelForProvider('claude', 'sonnet')).toBe(true)
-    expect(isValidModelForProvider('claude', 'haiku')).toBe(true)
-  })
-
-  it('should reject invalid Claude models', () => {
-    expect(isValidModelForProvider('claude', 'gpt-4')).toBe(false)
-    expect(isValidModelForProvider('claude', 'unknown')).toBe(false)
-  })
-
-  it('should accept valid Gemini models', () => {
-    expect(isValidModelForProvider('gemini', '2.5-pro')).toBe(true)
-    expect(isValidModelForProvider('gemini', '2.5-flash')).toBe(true)
-    expect(isValidModelForProvider('gemini', '2.0-flash')).toBe(true)
-  })
-
-  it('should reject invalid Gemini models', () => {
-    expect(isValidModelForProvider('gemini', 'sonnet')).toBe(false)
-  })
-
-  it('should accept any model for multi-model IDEs (empty supportedModels)', () => {
-    expect(isValidModelForProvider('cursor', 'gpt-4')).toBe(true)
-    expect(isValidModelForProvider('cursor', 'anything')).toBe(true)
-    expect(isValidModelForProvider('windsurf', 'claude-sonnet')).toBe(true)
-  })
-
-  it('should accept any model for unknown providers', () => {
-    expect(isValidModelForProvider('future-provider', 'some-model')).toBe(true)
-  })
-})
-
-// =============================================================================
-// Default Model Resolution
-// =============================================================================
-
-describe('getDefaultModel', () => {
-  it('should return sonnet for Claude', () => {
-    expect(getDefaultModel('claude')).toBe('sonnet')
-  })
-
-  it('should return 2.5-flash for Gemini', () => {
-    expect(getDefaultModel('gemini')).toBe('2.5-flash')
-  })
-
-  it('should return null for providers without defaults', () => {
-    expect(getDefaultModel('cursor')).toBeNull()
-    expect(getDefaultModel('unknown')).toBeNull()
-  })
-})
-
-// =============================================================================
-// Supported Models
-// =============================================================================
-
-describe('getSupportedModels', () => {
-  it('should return Claude models', () => {
-    expect(getSupportedModels('claude')).toEqual(['opus', 'sonnet', 'haiku'])
-  })
-
-  it('should return empty for multi-model IDEs', () => {
-    expect(getSupportedModels('cursor')).toEqual([])
-  })
-
-  it('should return empty for unknown providers', () => {
-    expect(getSupportedModels('unknown')).toEqual([])
-  })
-})
-
-// =============================================================================
-// Semver Comparison
-// =============================================================================
-
-describe('compareSemver', () => {
-  it('should return 0 for equal versions', () => {
-    expect(compareSemver('1.0.0', '1.0.0')).toBe(0)
-    expect(compareSemver('2.3.4', '2.3.4')).toBe(0)
-  })
-
-  it('should return -1 when a < b', () => {
-    expect(compareSemver('1.0.0', '2.0.0')).toBe(-1)
-    expect(compareSemver('1.0.0', '1.1.0')).toBe(-1)
-    expect(compareSemver('1.0.0', '1.0.1')).toBe(-1)
-  })
-
-  it('should return 1 when a > b', () => {
-    expect(compareSemver('2.0.0', '1.0.0')).toBe(1)
-    expect(compareSemver('1.1.0', '1.0.0')).toBe(1)
-    expect(compareSemver('1.0.1', '1.0.0')).toBe(1)
-  })
-
-  it('should handle missing patch versions', () => {
-    expect(compareSemver('1.0', '1.0.0')).toBe(0)
-  })
-})
-
-// =============================================================================
-// Version Validation
-// =============================================================================
-
-describe('meetsMinVersion', () => {
-  it('should pass when version meets minimum', () => {
-    expect(meetsMinVersion('claude', '1.0.0')).toBe(true)
-    expect(meetsMinVersion('claude', '2.5.0')).toBe(true)
-  })
-
-  it('should fail when version is below minimum', () => {
-    expect(meetsMinVersion('claude', '0.9.0')).toBe(false)
-    expect(meetsMinVersion('claude', '0.0.1')).toBe(false)
-  })
-
-  it('should pass for providers without minimum', () => {
-    expect(meetsMinVersion('cursor', '0.1.0')).toBe(true)
-    expect(meetsMinVersion('unknown', '0.0.0')).toBe(true)
-  })
-})
-
-describe('validateCliVersion', () => {
-  it('should return null for valid versions', () => {
-    expect(validateCliVersion('claude', '1.0.0')).toBeNull()
-    expect(validateCliVersion('claude', '2.0.0')).toBeNull()
-  })
-
-  it('should return warning for versions below minimum', () => {
-    const warning = validateCliVersion('claude', '0.5.0')
-    expect(warning).toContain('below minimum')
-    expect(warning).toContain('Claude Code')
-  })
-
-  it('should return null for undefined version', () => {
-    expect(validateCliVersion('claude', undefined)).toBeNull()
-  })
-
-  it('should return null for providers without minCliVersion', () => {
-    expect(validateCliVersion('cursor', '0.1.0')).toBeNull()
-  })
-})
-
-// =============================================================================
-// Model Mismatch Detection
-// =============================================================================
-
-describe('checkModelMismatch', () => {
-  const claudeOpus: ModelMetadata = {
-    provider: 'claude',
-    model: 'opus',
-    cliVersion: '1.5.0',
-    recordedAt: '2026-02-07T00:00:00.000Z',
-  }
-
-  const claudeSonnet: ModelMetadata = {
-    provider: 'claude',
-    model: 'sonnet',
-    cliVersion: '1.5.0',
-    recordedAt: '2026-02-07T00:00:00.000Z',
-  }
-
-  const geminiPro: ModelMetadata = {
-    provider: 'gemini',
-    model: '2.5-pro',
-    cliVersion: '1.0.0',
-    recordedAt: '2026-02-07T00:00:00.000Z',
-  }
-
-  it('should return null when models match', () => {
-    expect(checkModelMismatch(claudeOpus, claudeOpus)).toBeNull()
-  })
-
-  it('should warn when models differ within same provider', () => {
-    const warning = checkModelMismatch(claudeOpus, claudeSonnet)
-    expect(warning).toContain('mismatch')
-    expect(warning).toContain('opus')
-    expect(warning).toContain('sonnet')
-  })
-
-  it('should warn when providers differ', () => {
-    const warning = checkModelMismatch(claudeOpus, geminiPro)
-    expect(warning).toContain('mismatch')
-    expect(warning).toContain('claude')
-    expect(warning).toContain('gemini')
-  })
-
-  it('should return null when either metadata is undefined', () => {
-    expect(checkModelMismatch(undefined, claudeOpus)).toBeNull()
-    expect(checkModelMismatch(claudeOpus, undefined)).toBeNull()
-    expect(checkModelMismatch(undefined, undefined)).toBeNull()
-  })
-})
-
-// =============================================================================
-// Backwards Compatibility
-// =============================================================================
-
-describe('backwards compatibility', () => {
-  it('should handle configs without model field gracefully', () => {
-    // Simulates loading an old config without model fields
-    const oldProviderConfig = {
-      name: 'claude' as const,
-      displayName: 'Claude Code',
-      cliCommand: 'claude',
-    }
-    // getDefaultModel should work even if provider config has no model field
-    expect(getDefaultModel(oldProviderConfig.name)).toBe('sonnet')
-  })
-
-  it('should resolve default model when preferredModel is not set', () => {
-    const preferredModel: string | undefined = undefined
-    const provider = 'claude'
-    const resolved = preferredModel ?? getDefaultModel(provider)
-    expect(resolved).toBe('sonnet')
-  })
-})