prjct-cli 1.21.0 → 1.23.0

package/core/__tests__/agentic/analysis-injection.test.ts

@@ -1,377 +0,0 @@
-/**
- * Analysis Injection Tests (PRJ-260)
- *
- * Tests for injecting sealed analysis data into task context:
- * - Prompt builder renders analysis in ground_truth section
- * - Anti-hallucination block enriched with analysis data
- * - Graceful degradation when no analysis available
- */
-
-import { beforeEach, describe, expect, it } from 'bun:test'
-import {
-  buildAntiHallucinationBlock,
-  type ProjectGroundTruth,
-} from '../../agentic/anti-hallucination'
-import promptBuilder from '../../agentic/prompt-builder'
-import type { OrchestratorContext, SealedAnalysisContext } from '../../types'
-
-// =============================================================================
-// Test Fixtures
-// =============================================================================
-
-const mockSealedAnalysis: SealedAnalysisContext = {
-  languages: ['TypeScript', 'JavaScript'],
-  frameworks: ['Hono', 'Zod'],
-  packageManager: 'bun',
-  sourceDir: 'core/',
-  testDir: 'core/__tests__/',
-  fileCount: 295,
-  patterns: [
-    {
-      name: 'StorageManager pattern',
-      description: 'All storage uses StorageManager base class with read/write/update',
-      location: 'core/storage/',
-    },
-    {
-      name: 'Zod schemas',
-      description: 'Runtime validation with Zod for all data structures',
-    },
-  ],
-  antiPatterns: [
-    {
-      issue: 'Direct fs.writeFile without StorageManager',
-      file: 'core/storage/legacy.ts',
-      suggestion: 'Use StorageManager.write() instead',
-    },
-  ],
-  status: 'sealed',
-  commitHash: 'abc123def456',
-}
-
-function makeOrchestratorContext(
-  sealedAnalysis: SealedAnalysisContext | null = mockSealedAnalysis
-): OrchestratorContext {
-  return {
-    detectedDomains: ['backend', 'testing'],
-    primaryDomain: 'backend',
-    agents: [],
-    skills: [],
-    requiresFragmentation: false,
-    subtasks: null,
-    project: {
-      id: 'test-project',
-      ecosystem: 'TypeScript',
-      conventions: ['Hono', 'Zod'],
-    },
-    sealedAnalysis,
-  }
-}
-
-// =============================================================================
-// Prompt Builder — Ground Truth Section
-// =============================================================================
-
-describe('Analysis Injection in Prompt Builder (PRJ-260)', () => {
-  beforeEach(() => {
-    promptBuilder.resetContext()
-  })
-
-  it('should render sealed analysis in ground truth section', async () => {
-    const template = {
-      frontmatter: { description: 'Test task' },
-      content: '## Instructions\nDo the work',
-    }
-    const context = { projectPath: '/test/project', files: ['a.ts'] }
-    const orcCtx = makeOrchestratorContext()
-
-    const prompt = await promptBuilder.build(
-      template,
-      context,
-      {},
-      null,
-      null,
-      null,
-      null,
-      null,
-      orcCtx
-    )
-
-    // Should contain analysis data
-    expect(prompt).toContain('Languages**: TypeScript, JavaScript')
-    expect(prompt).toContain('Frameworks**: Hono, Zod')
-    expect(prompt).toContain('Package Manager**: bun')
-    expect(prompt).toContain('Source Dir**: core/')
-    expect(prompt).toContain('Test Dir**: core/__tests__/')
-    expect(prompt).toContain('Files Analyzed**: 295')
-    expect(prompt).toContain('Analysis Status**: sealed')
-    expect(prompt).toContain('abc123de') // truncated commit hash
-  })
-
-  it('should render code patterns from sealed analysis', async () => {
-    const template = {
-      frontmatter: { description: 'Test' },
-      content: '## Do',
-    }
-    const context = { projectPath: '/test', files: [] }
-    const orcCtx = makeOrchestratorContext()
-
-    const prompt = await promptBuilder.build(
-      template,
-      context,
-      {},
-      null,
-      null,
-      null,
-      null,
-      null,
-      orcCtx
-    )
-
-    expect(prompt).toContain('Code Patterns (Follow These)')
-    expect(prompt).toContain('StorageManager pattern')
-    expect(prompt).toContain('All storage uses StorageManager base class')
-    expect(prompt).toContain('core/storage/')
-    expect(prompt).toContain('Zod schemas')
-  })
-
-  it('should render anti-patterns from sealed analysis', async () => {
-    const template = {
-      frontmatter: { description: 'Test' },
-      content: '## Do',
-    }
-    const context = { projectPath: '/test', files: [] }
-    const orcCtx = makeOrchestratorContext()
-
-    const prompt = await promptBuilder.build(
-      template,
-      context,
-      {},
-      null,
-      null,
-      null,
-      null,
-      null,
-      orcCtx
-    )
-
-    expect(prompt).toContain('Anti-Patterns (Avoid These)')
-    expect(prompt).toContain('Direct fs.writeFile without StorageManager')
-    expect(prompt).toContain('core/storage/legacy.ts')
-    expect(prompt).toContain('Use StorageManager.write() instead')
-  })
-
-  it('should gracefully handle null sealed analysis', async () => {
-    const template = {
-      frontmatter: { description: 'Test' },
-      content: '## Do',
-    }
-    const context = { projectPath: '/test', files: [] }
-    const orcCtx = makeOrchestratorContext(null)
-
-    const prompt = await promptBuilder.build(
-      template,
-      context,
-      {},
-      null,
-      null,
-      null,
-      null,
-      null,
-      orcCtx
-    )
-
-    // Should still have basic project analysis
-    expect(prompt).toContain('PROJECT ANALYSIS')
-    expect(prompt).toContain('Ecosystem**: TypeScript')
-    // Should NOT have analysis-specific fields
-    expect(prompt).not.toContain('Languages**:')
-    expect(prompt).not.toContain('Code Patterns (Follow These)')
-    expect(prompt).not.toContain('Anti-Patterns (Avoid These)')
-  })
-
-  it('should handle empty patterns and anti-patterns', async () => {
-    const template = {
-      frontmatter: { description: 'Test' },
-      content: '## Do',
-    }
-    const context = { projectPath: '/test', files: [] }
-    const emptyAnalysis: SealedAnalysisContext = {
-      ...mockSealedAnalysis,
-      patterns: [],
-      antiPatterns: [],
-    }
-    const orcCtx = makeOrchestratorContext(emptyAnalysis)
-
-    const prompt = await promptBuilder.build(
-      template,
-      context,
-      {},
-      null,
-      null,
-      null,
-      null,
-      null,
-      orcCtx
-    )
-
-    expect(prompt).toContain('Languages**: TypeScript, JavaScript')
-    expect(prompt).not.toContain('Code Patterns (Follow These)')
-    expect(prompt).not.toContain('Anti-Patterns (Avoid These)')
-  })
-
-  it('should handle no orchestrator context at all', async () => {
-    const template = {
-      frontmatter: { description: 'Test' },
-      content: '## Do',
-    }
-    const context = { projectPath: '/test', files: [] }
-
-    const prompt = await promptBuilder.build(
-      template,
-      context,
-      {},
-      null,
-      null,
-      null,
-      null,
-      null,
-      null
-    )
-
-    // Should not crash, should have fallback rules
-    expect(prompt).toContain('CONSTRAINTS')
-    expect(prompt).not.toContain('PROJECT ANALYSIS')
-  })
-})
-
-// =============================================================================
-// Anti-Hallucination Block — Analysis Enrichment
-// =============================================================================
-
-describe('Anti-Hallucination Block with Analysis (PRJ-260)', () => {
-  it('should include analysis languages in AVAILABLE list', () => {
-    const truth: ProjectGroundTruth = {
-      projectPath: '/test',
-      language: 'TypeScript',
-      techStack: ['Hono'],
-      analysisLanguages: ['TypeScript', 'JavaScript', 'Shell'],
-      analysisFrameworks: ['Hono', 'Vitest'],
-    }
-
-    const block = buildAntiHallucinationBlock(truth)
-
-    expect(block).toContain('AVAILABLE in this project:')
-    // TypeScript and Hono should not be duplicated
-    expect(block).toContain('JavaScript')
-    expect(block).toContain('Shell')
-    expect(block).toContain('Vitest')
-  })
-
-  it('should deduplicate analysis data with existing tech stack (case-insensitive)', () => {
-    const truth: ProjectGroundTruth = {
-      projectPath: '/test',
-      language: 'TypeScript',
-      framework: 'Hono',
-      techStack: ['Zod'],
-      analysisLanguages: ['typescript'], // lowercase duplicate
-      analysisFrameworks: ['hono', 'Zod'], // lowercase duplicates
-    }
-
-    const block = buildAntiHallucinationBlock(truth)
-
-    // Count occurrences — each should appear exactly once
-    const typescriptMatches = block.match(/typescript/gi)
-    expect(typescriptMatches?.length).toBe(1)
-
-    const honoMatches = block.match(/hono/gi)
-    expect(honoMatches?.length).toBe(1)
-  })
-
-  it('should show package manager from analysis', () => {
-    const truth: ProjectGroundTruth = {
-      projectPath: '/test',
-      analysisPackageManager: 'bun',
-    }
-
-    const block = buildAntiHallucinationBlock(truth)
-
-    expect(block).toContain('PACKAGE MANAGER: bun')
-  })
-
-  it('should work without any analysis data', () => {
-    const truth: ProjectGroundTruth = {
-      projectPath: '/test',
-      language: 'Python',
-    }
-
-    const block = buildAntiHallucinationBlock(truth)
-
-    expect(block).toContain('AVAILABLE in this project: Python')
-    expect(block).not.toContain('PACKAGE MANAGER:')
-  })
-
-  it('should handle empty analysis arrays gracefully', () => {
-    const truth: ProjectGroundTruth = {
-      projectPath: '/test',
-      analysisLanguages: [],
-      analysisFrameworks: [],
-    }
-
-    const block = buildAntiHallucinationBlock(truth)
-
-    // Should not contain AVAILABLE line (no tech to show)
-    expect(block).not.toContain('AVAILABLE in this project:')
-    expect(block).toContain('CONSTRAINTS')
-  })
-})
-
-// =============================================================================
-// SealedAnalysisContext Type
-// =============================================================================
-
-describe('SealedAnalysisContext type (PRJ-260)', () => {
-  it('should accept valid sealed analysis data', () => {
-    const analysis: SealedAnalysisContext = {
-      languages: ['TypeScript'],
-      frameworks: ['Hono'],
-      fileCount: 100,
-      patterns: [{ name: 'test', description: 'test pattern' }],
-      antiPatterns: [{ issue: 'test', file: 'test.ts', suggestion: 'fix it' }],
-      status: 'sealed',
-    }
-
-    expect(analysis.languages).toEqual(['TypeScript'])
-    expect(analysis.status).toBe('sealed')
-  })
-
-  it('should accept draft status', () => {
-    const analysis: SealedAnalysisContext = {
-      languages: [],
-      frameworks: [],
-      fileCount: 0,
-      patterns: [],
-      antiPatterns: [],
-      status: 'draft',
-    }
-
-    expect(analysis.status).toBe('draft')
-  })
-
-  it('should accept optional fields', () => {
-    const analysis: SealedAnalysisContext = {
-      languages: ['Python'],
-      frameworks: [],
-      fileCount: 50,
-      patterns: [],
-      antiPatterns: [],
-      status: 'sealed',
-      packageManager: 'pip',
-      sourceDir: 'src/',
-      testDir: 'tests/',
-      commitHash: 'abc123',
-    }
-
-    expect(analysis.packageManager).toBe('pip')
-    expect(analysis.commitHash).toBe('abc123')
-  })
-})

package/core/__tests__/agentic/cache-eviction.test.ts

@@ -1,294 +0,0 @@
-/**
- * Cache Eviction Policy Tests (PRJ-288)
- * Verifies TTLCache integration, context caps, and archival.
- */
-
-import { afterAll, beforeAll, beforeEach, describe, expect, it } from 'bun:test'
-import fs from 'node:fs/promises'
-import path from 'node:path'
-import { ContextBuilder } from '../../agentic/context-builder'
-import { MemorySystem, PatternStore } from '../../agentic/memory-system'
-import pathManager from '../../infrastructure/path-manager'
-import { SessionLogManager } from '../../session/session-log-manager'
-import { TTLCache } from '../../utils/cache'
-
-const TEST_GLOBAL_BASE_DIR = path.join(process.cwd(), '.tmp', 'prjct-cli-cache-tests')
-let testCounter = 0
-const getTestProjectId = () => `test-cache-${Date.now()}-${++testCounter}`
-
-describe('Cache Eviction Policies (PRJ-288)', () => {
-  beforeAll(async () => {
-    pathManager.setGlobalBaseDir(TEST_GLOBAL_BASE_DIR)
-    await fs.mkdir(TEST_GLOBAL_BASE_DIR, { recursive: true })
-  })
-
-  afterAll(async () => {
-    await fs.rm(TEST_GLOBAL_BASE_DIR, { recursive: true, force: true })
-  })
-
-  // ===========================================================================
-  // TTLCache unit tests
-  // ===========================================================================
-
-  describe('TTLCache', () => {
-    it('should evict oldest entries when maxSize exceeded', () => {
-      const cache = new TTLCache<string>({ maxSize: 3, ttl: 60_000 })
-
-      cache.set('a', 'val-a')
-      cache.set('b', 'val-b')
-      cache.set('c', 'val-c')
-      expect(cache.size).toBe(3)
-
-      cache.set('d', 'val-d')
-      expect(cache.size).toBe(3)
-      // 'a' was oldest, should be evicted
-      expect(cache.get('a')).toBeNull()
-      expect(cache.get('d')).toBe('val-d')
-    })
-
-    it('should expire entries after TTL', async () => {
-      const cache = new TTLCache<string>({ maxSize: 10, ttl: 50 })
-
-      cache.set('key', 'value')
-      expect(cache.get('key')).toBe('value')
-
-      await new Promise((r) => setTimeout(r, 80))
-      expect(cache.get('key')).toBeNull()
-    })
-
-    it('should prune expired entries', async () => {
-      const cache = new TTLCache<string>({ maxSize: 10, ttl: 50 })
-
-      cache.set('a', '1')
-      cache.set('b', '2')
-      await new Promise((r) => setTimeout(r, 80))
-
-      cache.set('c', '3') // fresh
-      const pruned = cache.prune()
-      expect(pruned).toBe(2)
-      expect(cache.size).toBe(1)
-      expect(cache.get('c')).toBe('3')
-    })
-  })
-
-  // ===========================================================================
-  // SessionLogManager
-  // ===========================================================================
-
-  describe('SessionLogManager', () => {
-    it('should use TTLCache with LRU eviction at 50 entries', () => {
-      const manager = new SessionLogManager()
-      // Verify clearCache works (exercises TTLCache.clear())
-      manager.clearCache()
-    })
-  })
-
-  // ===========================================================================
-  // ContextBuilder
-  // ===========================================================================
-
-  describe('ContextBuilder', () => {
-    it('should report stats from TTLCache', () => {
-      const builder = new ContextBuilder()
-      const stats = builder.getCacheStats()
-      expect(stats).toHaveProperty('size')
-      expect(stats).toHaveProperty('maxSize')
-      expect(stats).toHaveProperty('ttl')
-      expect(stats.maxSize).toBe(200)
-      expect(stats.ttl).toBe(5000)
-    })
-
-    it('should clear cache and reset projectId', () => {
-      const builder = new ContextBuilder()
-      builder.clearCache()
-      const stats = builder.getCacheStats()
-      expect(stats.size).toBe(0)
-    })
-
-    it('should invalidate specific cache entries', async () => {
-      const builder = new ContextBuilder()
-
-      // Write a temp file, batchRead to populate cache, then invalidate
-      const tmpDir = path.join(TEST_GLOBAL_BASE_DIR, 'ctx-test')
-      await fs.mkdir(tmpDir, { recursive: true })
-      const tmpFile = path.join(tmpDir, 'test.txt')
-      await fs.writeFile(tmpFile, 'hello')
-
-      const result = await builder.batchRead([tmpFile])
-      expect(result.get(tmpFile)).toBe('hello')
-
-      // Invalidate and verify
-      builder.invalidateCache(tmpFile)
-      // After invalidation, a fresh batchRead should re-read from disk
-      await fs.writeFile(tmpFile, 'updated')
-      const result2 = await builder.batchRead([tmpFile])
-      expect(result2.get(tmpFile)).toBe('updated')
-    })
-  })
-
-  // ===========================================================================
-  // PatternStore - contexts cap
-  // ===========================================================================
-
-  describe('PatternStore contexts cap', () => {
-    let TEST_PROJECT_ID: string
-
-    beforeEach(() => {
-      TEST_PROJECT_ID = getTestProjectId()
-    })
-
-    it('should cap decision contexts at 20 (FIFO)', async () => {
-      const store = new PatternStore()
-
-      // Record a decision with many unique contexts
-      for (let i = 0; i < 25; i++) {
-        await store.recordDecision(TEST_PROJECT_ID, 'test-key', 'test-value', `context-${i}`)
-      }
-
-      const patterns = await store.load(TEST_PROJECT_ID)
-      const decision = patterns.decisions['test-key']
-      expect(decision.contexts.length).toBeLessThanOrEqual(20)
-      // Should keep the latest contexts
-      expect(decision.contexts).toContain('context-24')
-      expect(decision.contexts).toContain('context-5')
-      // Oldest should be evicted
-      expect(decision.contexts).not.toContain('context-0')
-    })
-
-    it('should truncate oversized contexts on afterLoad', async () => {
-      const store = new PatternStore()
-      const projectId = getTestProjectId()
-
-      // Manually write a patterns file with oversized contexts
-      const filePath = path.join(
-        pathManager.getGlobalProjectPath(projectId),
-        'memory',
-        'patterns.json'
-      )
-      await fs.mkdir(path.dirname(filePath), { recursive: true })
-
-      const oversizedPatterns = {
-        version: 1,
-        decisions: {
-          'big-key': {
-            value: 'v',
-            count: 30,
-            firstSeen: '2025-01-01T00:00:00.000Z',
-            lastSeen: '2025-06-01T00:00:00.000Z',
-            confidence: 'high',
-            contexts: Array.from({ length: 50 }, (_, i) => `ctx-${i}`),
-            userConfirmed: true,
-          },
-        },
-        preferences: {},
-        workflows: {},
-        counters: {},
-      }
-      await fs.writeFile(filePath, JSON.stringify(oversizedPatterns, null, 2), 'utf-8')
-
-      // Load triggers afterLoad which should truncate
-      const patterns = await store.load(projectId)
-      expect(patterns.decisions['big-key'].contexts.length).toBe(20)
-      // Should keep the latest 20 (indices 30-49)
-      expect(patterns.decisions['big-key'].contexts[19]).toBe('ctx-49')
-    })
-  })
-
-  // ===========================================================================
-  // PatternStore - archival
-  // ===========================================================================
-
-  describe('PatternStore archival', () => {
-    it('should archive decisions older than 90 days', async () => {
-      const store = new PatternStore()
-      const projectId = getTestProjectId()
-
-      // Write patterns with a stale and an active decision
-      const filePath = path.join(
-        pathManager.getGlobalProjectPath(projectId),
-        'memory',
-        'patterns.json'
-      )
-      await fs.mkdir(path.dirname(filePath), { recursive: true })
-
-      const now = new Date()
-      const staleDate = new Date(now.getTime() - 100 * 24 * 60 * 60 * 1000) // 100 days ago
-      const recentDate = new Date(now.getTime() - 5 * 24 * 60 * 60 * 1000) // 5 days ago
-
-      const patterns = {
-        version: 1,
-        decisions: {
-          'stale-key': {
-            value: 'old',
-            count: 3,
-            firstSeen: staleDate.toISOString(),
-            lastSeen: staleDate.toISOString(),
-            confidence: 'medium',
-            contexts: ['ctx1'],
-            userConfirmed: false,
-          },
-          'active-key': {
-            value: 'new',
-            count: 5,
-            firstSeen: recentDate.toISOString(),
-            lastSeen: recentDate.toISOString(),
-            confidence: 'high',
-            contexts: ['ctx2'],
-            userConfirmed: true,
-          },
-        },
-        preferences: {},
-        workflows: {},
-        counters: {},
-      }
-      await fs.writeFile(filePath, JSON.stringify(patterns, null, 2), 'utf-8')
-
-      // Reset store cache to force disk read
-      store.reset()
-      const archived = await store.archiveStaleDecisions(projectId)
-      expect(archived).toBe(1)
-
-      // Verify active decision remains
-      const updated = await store.load(projectId)
-      expect(updated.decisions['active-key']).toBeDefined()
-      expect(updated.decisions['stale-key']).toBeUndefined()
-
-      // Verify archive file was created
-      const archivePath = path.join(
-        pathManager.getGlobalProjectPath(projectId),
-        'memory',
-        'patterns-archive.json'
-      )
-      const archiveContent = JSON.parse(await fs.readFile(archivePath, 'utf-8'))
-      expect(archiveContent['stale-key']).toBeDefined()
-      expect(archiveContent['stale-key'].value).toBe('old')
-    })
-
-    it('should return 0 when no stale decisions exist', async () => {
-      const store = new PatternStore()
-      const projectId = getTestProjectId()
-
-      // Record a fresh decision
-      await store.recordDecision(projectId, 'fresh-key', 'fresh-val', 'ctx')
-      const archived = await store.archiveStaleDecisions(projectId)
-      expect(archived).toBe(0)
-    })
-  })
-
-  // ===========================================================================
-  // MemorySystem delegation
-  // ===========================================================================
-
-  describe('MemorySystem.archiveStaleDecisions', () => {
-    it('should delegate to PatternStore', async () => {
-      const ms = new MemorySystem()
-      const projectId = getTestProjectId()
-
-      // Just verify no crash - no stale data to archive
-      ms.resetState()
-      await ms.recordDecision(projectId, 'key', 'val', 'ctx')
-      const count = await ms.archiveStaleDecisions(projectId)
-      expect(count).toBe(0)
-    })
-  })
-})