prjct-cli 1.21.0 → 1.23.0

package/core/__tests__/storage/storage-manager.test.ts

@@ -1,383 +0,0 @@
-/**
- * Storage Manager Tests
- *
- * Tests for the base StorageManager class:
- * - Read/write JSON operations
- * - Missing file handling
- * - Directory creation
- * - Cache behavior
- * - State consistency
- */
-
-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 { prjctDb } from '../../storage/database'
-import { StorageManager } from '../../storage/storage-manager'
-
-// =============================================================================
-// Test Implementation
-// =============================================================================
-
-interface TestData {
-  value: string
-  count: number
-  items: string[]
-}
-
-/**
- * Concrete implementation for testing the abstract StorageManager
- */
-class TestStorageManager extends StorageManager<TestData> {
-  constructor() {
-    super('test-data.json')
-  }
-
-  protected getLayer(): string {
-    return 'context'
-  }
-
-  protected getDefault(): TestData {
-    return { value: '', count: 0, items: [] }
-  }
-
-  protected toMarkdown(data: TestData): string {
-    return `# Test Data\n\nValue: ${data.value}\nCount: ${data.count}\nItems: ${data.items.join(', ')}`
-  }
-
-  protected getMdFilename(): string {
-    return 'test-data.md'
-  }
-
-  protected getEventType(action: 'update' | 'create' | 'delete'): string {
-    return `test.${action}`
-  }
-}
-
-// =============================================================================
-// Test Setup
-// =============================================================================
-
-let tmpRoot: string | null = null
-let testProjectId: string
-let manager: TestStorageManager
-
-// Mock pathManager to use temp directory
-const originalGetGlobalProjectPath = pathManager.getGlobalProjectPath.bind(pathManager)
-const originalGetStoragePath = pathManager.getStoragePath.bind(pathManager)
-const originalGetFilePath = pathManager.getFilePath.bind(pathManager)
-
-describe('StorageManager', () => {
-  beforeEach(async () => {
-    // Create temp directory for test isolation
-    tmpRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'prjct-storage-test-'))
-    testProjectId = 'test-project-123'
-
-    // Mock pathManager to use temp directory
-    pathManager.getGlobalProjectPath = (projectId: string) => {
-      return path.join(tmpRoot!, projectId)
-    }
-
-    pathManager.getStoragePath = (projectId: string, filename: string) => {
-      return path.join(tmpRoot!, projectId, 'storage', filename)
-    }
-
-    pathManager.getFilePath = (projectId: string, layer: string, filename: string) => {
-      return path.join(tmpRoot!, projectId, layer, filename)
-    }
-
-    // Create fresh manager instance
-    manager = new TestStorageManager()
-  })
-
-  afterEach(async () => {
-    // Close SQLite connections before cleanup
-    prjctDb.close()
-
-    // Restore original pathManager methods
-    pathManager.getGlobalProjectPath = originalGetGlobalProjectPath
-    pathManager.getStoragePath = originalGetStoragePath
-    pathManager.getFilePath = originalGetFilePath
-
-    // Clean up temp directory
-    if (tmpRoot) {
-      await fs.rm(tmpRoot, { recursive: true, force: true })
-      tmpRoot = null
-    }
-  })
-
-  // ===========================================================================
-  // Read/Write Tests
-  // ===========================================================================
-
-  describe('read/write', () => {
-    it('should write and read JSON correctly', async () => {
-      const testData: TestData = {
-        value: 'hello',
-        count: 42,
-        items: ['a', 'b', 'c'],
-      }
-
-      await manager.write(testProjectId, testData)
-      const result = await manager.read(testProjectId)
-
-      expect(result).toEqual(testData)
-    })
-
-    it('should write to SQLite kv_store', async () => {
-      const testData: TestData = {
-        value: 'test',
-        count: 1,
-        items: ['item1'],
-      }
-
-      await manager.write(testProjectId, testData)
-
-      // Verify SQLite has the data
-      const doc = prjctDb.getDoc<TestData>(testProjectId, 'test-data')
-      expect(doc).toEqual(testData)
-    })
-
-    it('should not create JSON storage file', async () => {
-      const testData: TestData = {
-        value: 'test',
-        count: 1,
-        items: ['item1'],
-      }
-
-      await manager.write(testProjectId, testData)
-
-      // Verify JSON file does NOT exist
-      const storagePath = path.join(tmpRoot!, testProjectId, 'storage', 'test-data.json')
-      await expect(fs.access(storagePath)).rejects.toThrow()
-    })
-
-    it('should create context markdown file', async () => {
-      const testData: TestData = {
-        value: 'markdown-test',
-        count: 5,
-        items: ['x', 'y'],
-      }
-
-      await manager.write(testProjectId, testData)
-
-      // Verify markdown file exists
-      const contextPath = path.join(tmpRoot!, testProjectId, 'context', 'test-data.md')
-      const content = await fs.readFile(contextPath, 'utf-8')
-
-      expect(content).toContain('# Test Data')
-      expect(content).toContain('Value: markdown-test')
-      expect(content).toContain('Count: 5')
-      expect(content).toContain('Items: x, y')
-    })
-
-    it('should overwrite existing data', async () => {
-      const data1: TestData = { value: 'first', count: 1, items: [] }
-      const data2: TestData = { value: 'second', count: 2, items: ['new'] }
-
-      await manager.write(testProjectId, data1)
-      await manager.write(testProjectId, data2)
-
-      const result = await manager.read(testProjectId)
-      expect(result).toEqual(data2)
-    })
-  })
-
-  // ===========================================================================
-  // Missing File Handling
-  // ===========================================================================
-
-  describe('missing file handling', () => {
-    it('should return default when file does not exist', async () => {
-      const result = await manager.read('non-existent-project')
-
-      expect(result).toEqual({ value: '', count: 0, items: [] })
-    })
-
-    it('should report exists=false when no data', async () => {
-      const exists = await manager.exists('non-existent-project')
-      expect(exists).toBe(false)
-    })
-
-    it('should report exists=true after write', async () => {
-      await manager.write(testProjectId, { value: 'test', count: 1, items: [] })
-
-      const exists = await manager.exists(testProjectId)
-      expect(exists).toBe(true)
-    })
-  })
-
-  // ===========================================================================
-  // Directory Creation
-  // ===========================================================================
-
-  describe('directory creation', () => {
-    it('should create project directory for SQLite DB', async () => {
-      const testData: TestData = { value: 'dir-test', count: 1, items: [] }
-
-      // Project directory shouldn't exist yet
-      const projectDir = path.join(tmpRoot!, testProjectId)
-      await expect(fs.access(projectDir)).rejects.toThrow()
-
-      // Write should create it (SQLite DB creates its parent dir)
-      await manager.write(testProjectId, testData)
-
-      // Project dir should exist (created by SQLite)
-      const stat = await fs.stat(projectDir)
-      expect(stat.isDirectory()).toBe(true)
-    })
-
-    it('should create context directory if it does not exist', async () => {
-      const testData: TestData = { value: 'ctx-test', count: 1, items: [] }
-
-      // Directory shouldn't exist yet
-      const contextDir = path.join(tmpRoot!, testProjectId, 'context')
-      await expect(fs.access(contextDir)).rejects.toThrow()
-
-      // Write should create it
-      await manager.write(testProjectId, testData)
-
-      // Now it should exist
-      const stat = await fs.stat(contextDir)
-      expect(stat.isDirectory()).toBe(true)
-    })
-
-    it('should create nested directories', async () => {
-      const deepProjectId = 'deep/nested/project'
-      const testData: TestData = { value: 'nested', count: 1, items: [] }
-
-      await manager.write(deepProjectId, testData)
-
-      const result = await manager.read(deepProjectId)
-      expect(result).toEqual(testData)
-    })
-  })
-
-  // ===========================================================================
-  // Cache Behavior
-  // ===========================================================================
-
-  describe('cache behavior', () => {
-    it('should cache read results', async () => {
-      const testData: TestData = { value: 'cached', count: 1, items: [] }
-      await manager.write(testProjectId, testData)
-
-      // First read
-      const result1 = await manager.read(testProjectId)
-
-      // Modify SQLite directly (bypass manager)
-      prjctDb.setDoc(testProjectId, 'test-data', { value: 'modified', count: 2, items: [] })
-
-      // Second read should return cached value
-      const result2 = await manager.read(testProjectId)
-      expect(result2).toEqual(result1)
-    })
-
-    it('should clear cache for specific project', async () => {
-      const testData: TestData = { value: 'to-clear', count: 1, items: [] }
-      await manager.write(testProjectId, testData)
-
-      // Read to populate cache
-      await manager.read(testProjectId)
-
-      // Write new data through the manager (the proper API)
-      const newData: TestData = { value: 'updated', count: 99, items: ['new'] }
-      await manager.write(testProjectId, newData)
-
-      // Create a new manager instance (simulates fresh session without cache)
-      const freshManager = new TestStorageManager()
-
-      // Clear cache on original manager
-      manager.clearCache(testProjectId)
-
-      // Both should get the new data
-      const result = await manager.read(testProjectId)
-      expect(result).toEqual(newData)
-
-      const freshResult = await freshManager.read(testProjectId)
-      expect(freshResult).toEqual(newData)
-    })
-
-    it('should clear all cache', async () => {
-      // Write to multiple projects
-      await manager.write('project-a', { value: 'a', count: 1, items: [] })
-      await manager.write('project-b', { value: 'b', count: 2, items: [] })
-
-      // Read to populate cache
-      await manager.read('project-a')
-      await manager.read('project-b')
-
-      // Clear all cache
-      manager.clearCache()
-
-      // Verify cache stats
-      const stats = manager.getCacheStats()
-      expect(stats.size).toBe(0)
-    })
-
-    it('should return cache stats', async () => {
-      const stats = manager.getCacheStats()
-
-      expect(stats).toHaveProperty('size')
-      expect(stats).toHaveProperty('maxSize')
-      expect(stats).toHaveProperty('ttl')
-      expect(typeof stats.size).toBe('number')
-      expect(typeof stats.maxSize).toBe('number')
-      expect(typeof stats.ttl).toBe('number')
-    })
-  })
-
-  // ===========================================================================
-  // State Consistency (Update Operations)
-  // ===========================================================================
-
-  describe('state consistency', () => {
-    it('should update data atomically with updater function', async () => {
-      const initial: TestData = { value: 'initial', count: 0, items: [] }
-      await manager.write(testProjectId, initial)
-
-      const result = await manager.update(testProjectId, (current) => ({
-        ...current,
-        count: current.count + 1,
-        items: [...current.items, 'new-item'],
-      }))
-
-      expect(result.count).toBe(1)
-      expect(result.items).toEqual(['new-item'])
-
-      // Verify persisted
-      manager.clearCache(testProjectId)
-      const persisted = await manager.read(testProjectId)
-      expect(persisted).toEqual(result)
-    })
-
-    it('should handle multiple sequential updates', async () => {
-      await manager.write(testProjectId, { value: 'start', count: 0, items: [] })
-
-      // Multiple updates
-      for (let i = 0; i < 5; i++) {
-        await manager.update(testProjectId, (current) => ({
-          ...current,
-          count: current.count + 1,
-        }))
-      }
-
-      const result = await manager.read(testProjectId)
-      expect(result.count).toBe(5)
-    })
-
-    it('should maintain data integrity after failed read during update', async () => {
-      // Start with no file (will use default)
-      const result = await manager.update(testProjectId, (current) => ({
-        ...current,
-        value: 'from-default',
-        count: 100,
-      }))
-
-      expect(result.value).toBe('from-default')
-      expect(result.count).toBe(100)
-    })
-  })
-})

package/core/__tests__/storage/subtask-handoff.test.ts

@@ -1,237 +0,0 @@
-/**
- * Subtask Handoff Tests (PRJ-262)
- *
- * Tests for mandatory subtask output and handoff:
- * - SubtaskCompletionDataSchema validation
- * - SubtaskSummarySchema required fields
- * - validateSubtaskCompletion helper
- * - Backward compatibility with old state.json
- */
-
-import { describe, expect, it } from 'bun:test'
-import {
-  SubtaskCompletionDataSchema,
-  SubtaskSchema,
-  SubtaskSummarySchema,
-  validateSubtaskCompletion,
-} from '../../schemas/state'
-
-// =============================================================================
-// SubtaskSummarySchema — outputForNextAgent is now required
-// =============================================================================
-
-describe('SubtaskSummarySchema', () => {
-  const validSummary = {
-    title: 'Implement auth middleware',
-    description: 'Added JWT verification to all protected routes',
-    filesChanged: [
-      { path: 'src/middleware/auth.ts', action: 'created' as const },
-      { path: 'src/routes/api.ts', action: 'modified' as const },
-    ],
-    whatWasDone: ['Created JWT middleware', 'Applied to API routes'],
-    outputForNextAgent:
-      'Auth middleware is in place. Next subtask should add role-based access control.',
-  }
-
-  it('should parse a valid summary with all required fields', () => {
-    const result = SubtaskSummarySchema.parse(validSummary)
-    expect(result.outputForNextAgent).toBe(validSummary.outputForNextAgent)
-    expect(result.whatWasDone).toHaveLength(2)
-  })
-
-  it('should reject missing outputForNextAgent', () => {
-    const { outputForNextAgent, ...withoutOutput } = validSummary
-    expect(() => SubtaskSummarySchema.parse(withoutOutput)).toThrow()
-  })
-
-  it('should reject empty outputForNextAgent', () => {
-    expect(() => SubtaskSummarySchema.parse({ ...validSummary, outputForNextAgent: '' })).toThrow()
-  })
-
-  it('should reject empty whatWasDone array', () => {
-    expect(() => SubtaskSummarySchema.parse({ ...validSummary, whatWasDone: [] })).toThrow()
-  })
-
-  it('should allow optional notes', () => {
-    const result = SubtaskSummarySchema.parse({ ...validSummary, notes: 'Watch for rate limits' })
-    expect(result.notes).toBe('Watch for rate limits')
-  })
-
-  it('should allow missing notes', () => {
-    const result = SubtaskSummarySchema.parse(validSummary)
-    expect(result.notes).toBeUndefined()
-  })
-})
-
-// =============================================================================
-// SubtaskCompletionDataSchema — validates completion requirements
-// =============================================================================
-
-describe('SubtaskCompletionDataSchema', () => {
-  const validCompletion = {
-    output: 'Implemented auth middleware with JWT verification',
-    summary: {
-      title: 'Auth middleware',
-      description: 'JWT verification for protected routes',
-      filesChanged: [{ path: 'src/auth.ts', action: 'created' as const }],
-      whatWasDone: ['Created JWT middleware'],
-      outputForNextAgent: 'Middleware ready, add RBAC next.',
-    },
-  }
-
-  it('should parse valid completion data', () => {
-    const result = SubtaskCompletionDataSchema.parse(validCompletion)
-    expect(result.output).toBe(validCompletion.output)
-    expect(result.summary.outputForNextAgent).toBe('Middleware ready, add RBAC next.')
-  })
-
-  it('should reject missing output', () => {
-    const { output, ...withoutOutput } = validCompletion
-    expect(() => SubtaskCompletionDataSchema.parse(withoutOutput)).toThrow()
-  })
-
-  it('should reject empty output', () => {
-    expect(() => SubtaskCompletionDataSchema.parse({ ...validCompletion, output: '' })).toThrow()
-  })
-
-  it('should reject missing summary', () => {
-    expect(() => SubtaskCompletionDataSchema.parse({ output: 'some output' })).toThrow()
-  })
-
-  it('should reject summary without outputForNextAgent', () => {
-    const badSummary = { ...validCompletion.summary }
-    // @ts-expect-error - intentionally testing invalid data
-    delete badSummary.outputForNextAgent
-    expect(() => SubtaskCompletionDataSchema.parse({ output: 'ok', summary: badSummary })).toThrow()
-  })
-})
-
-// =============================================================================
-// validateSubtaskCompletion helper
-// =============================================================================
-
-describe('validateSubtaskCompletion', () => {
-  const validData = {
-    output: 'Task done',
-    summary: {
-      title: 'Test',
-      description: 'Testing',
-      filesChanged: [],
-      whatWasDone: ['Did the thing'],
-      outputForNextAgent: 'Context for next.',
-    },
-  }
-
-  it('should return success for valid data', () => {
-    const result = validateSubtaskCompletion(validData)
-    expect(result.success).toBe(true)
-    if (result.success) {
-      expect(result.data.output).toBe('Task done')
-    }
-  })
-
-  it('should return errors for missing output', () => {
-    const result = validateSubtaskCompletion({ summary: validData.summary })
-    expect(result.success).toBe(false)
-    if (!result.success) {
-      expect(result.errors.length).toBeGreaterThan(0)
-      expect(result.errors.some((e) => e.includes('output'))).toBe(true)
-    }
-  })
-
-  it('should return errors for empty whatWasDone', () => {
-    const result = validateSubtaskCompletion({
-      output: 'ok',
-      summary: { ...validData.summary, whatWasDone: [] },
-    })
-    expect(result.success).toBe(false)
-    if (!result.success) {
-      expect(result.errors.some((e) => e.includes('whatWasDone'))).toBe(true)
-    }
-  })
-
-  it('should return errors for completely invalid data', () => {
-    const result = validateSubtaskCompletion({})
-    expect(result.success).toBe(false)
-    if (!result.success) {
-      expect(result.errors.length).toBeGreaterThan(0)
-    }
-  })
-})
-
-// =============================================================================
-// Backward Compatibility
-// =============================================================================
-
-describe('backward compatibility', () => {
-  it('should parse old SubtaskSchema without summary or output', () => {
-    const oldSubtask = {
-      id: 'subtask-1',
-      description: 'Old subtask without handoff',
-      domain: 'backend',
-      agent: 'backend.md',
-      status: 'completed' as const,
-      dependsOn: [],
-      startedAt: '2026-01-01T00:00:00.000Z',
-      completedAt: '2026-01-01T01:00:00.000Z',
-      // No output, no summary — old format
-    }
-    const result = SubtaskSchema.parse(oldSubtask)
-    expect(result.output).toBeUndefined()
-    expect(result.summary).toBeUndefined()
-    expect(result.status).toBe('completed')
-  })
-
-  it('should parse pending subtask without completion fields', () => {
-    const pending = {
-      id: 'subtask-2',
-      description: 'Pending subtask',
-      domain: 'frontend',
-      agent: 'frontend.md',
-      status: 'pending' as const,
-      dependsOn: ['subtask-1'],
-    }
-    const result = SubtaskSchema.parse(pending)
-    expect(result.status).toBe('pending')
-    expect(result.output).toBeUndefined()
-    expect(result.summary).toBeUndefined()
-  })
-
-  it('should parse subtask with output but no summary (transition format)', () => {
-    const transitional = {
-      id: 'subtask-1',
-      description: 'Transitional format',
-      domain: 'backend',
-      agent: 'backend.md',
-      status: 'completed' as const,
-      dependsOn: [],
-      output: 'Done with basic output',
-      // No summary yet
-    }
-    const result = SubtaskSchema.parse(transitional)
-    expect(result.output).toBe('Done with basic output')
-    expect(result.summary).toBeUndefined()
-  })
-
-  it('should parse subtask with full handoff data', () => {
-    const withHandoff = {
-      id: 'subtask-1',
-      description: 'Full handoff format',
-      domain: 'backend',
-      agent: 'backend.md',
-      status: 'completed' as const,
-      dependsOn: [],
-      output: 'Implemented the feature',
-      summary: {
-        title: 'Backend API',
-        description: 'Created REST endpoints',
-        filesChanged: [{ path: 'src/api.ts', action: 'created' as const }],
-        whatWasDone: ['Created endpoints', 'Added validation'],
-        outputForNextAgent: 'API is ready at /api/v1. Add auth next.',
-      },
-    }
-    const result = SubtaskSchema.parse(withHandoff)
-    expect(result.summary?.outputForNextAgent).toBe('API is ready at /api/v1. Add auth next.')
-    expect(result.summary?.whatWasDone).toHaveLength(2)
-  })
-})