prjct-cli 1.22.0 → 1.23.0

package/core/__tests__/domain/change-propagator.test.ts

@@ -1,100 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-import { affectedDomains, propagateChanges } from '../../domain/change-propagator'
-import type { FileDiff } from '../../domain/file-hasher'
-
-describe('change-propagator', () => {
-  // =========================================================================
-  // propagateChanges
-  // =========================================================================
-
-  describe('propagateChanges', () => {
-    test('returns direct changes when no import graph exists', () => {
-      const diff: FileDiff = {
-        added: ['src/new.ts'],
-        modified: ['src/changed.ts'],
-        deleted: ['src/removed.ts'],
-        unchanged: ['src/same.ts'],
-      }
-
-      // Use a fake projectId that won't have a graph
-      const result = propagateChanges(diff, 'nonexistent-project')
-
-      expect(result.directlyChanged).toEqual(['src/new.ts', 'src/changed.ts'])
-      expect(result.affectedByImports).toEqual([])
-      expect(result.allAffected).toEqual(['src/new.ts', 'src/changed.ts'])
-      expect(result.deleted).toEqual(['src/removed.ts'])
-    })
-
-    test('empty diff returns empty propagation', () => {
-      const diff: FileDiff = {
-        added: [],
-        modified: [],
-        deleted: [],
-        unchanged: ['src/a.ts', 'src/b.ts'],
-      }
-
-      const result = propagateChanges(diff, 'nonexistent-project')
-
-      expect(result.directlyChanged).toEqual([])
-      expect(result.affectedByImports).toEqual([])
-      expect(result.allAffected).toEqual([])
-    })
-  })
-
-  // =========================================================================
-  // affectedDomains
-  // =========================================================================
-
-  describe('affectedDomains', () => {
-    test('detects frontend files', () => {
-      const domains = affectedDomains([
-        'src/components/Button.tsx',
-        'src/pages/Home.jsx',
-        'styles/main.css',
-      ])
-      expect(domains.has('frontend')).toBe(true)
-      expect(domains.has('uxui')).toBe(true)
-    })
-
-    test('detects backend files', () => {
-      const domains = affectedDomains(['core/services/auth.ts', 'core/domain/user.ts'])
-      expect(domains.has('backend')).toBe(true)
-    })
-
-    test('detects testing files', () => {
-      const domains = affectedDomains([
-        'core/__tests__/auth.test.ts',
-        'src/components/Button.spec.tsx',
-      ])
-      expect(domains.has('testing')).toBe(true)
-    })
-
-    test('detects devops files', () => {
-      const domains = affectedDomains(['Dockerfile', '.github/workflows/ci.yml'])
-      expect(domains.has('devops')).toBe(true)
-    })
-
-    test('detects database files', () => {
-      const domains = affectedDomains(['prisma/schema.prisma', 'db/migrations/001.sql'])
-      expect(domains.has('database')).toBe(true)
-    })
-
-    test('handles mixed domain files', () => {
-      const domains = affectedDomains([
-        'src/components/Form.tsx', // frontend + uxui
-        'core/services/api.ts', // backend
-        'Dockerfile', // devops
-        'core/__tests__/api.test.ts', // testing + backend
-      ])
-      expect(domains.has('frontend')).toBe(true)
-      expect(domains.has('backend')).toBe(true)
-      expect(domains.has('devops')).toBe(true)
-      expect(domains.has('testing')).toBe(true)
-    })
-
-    test('empty file list returns empty domains', () => {
-      const domains = affectedDomains([])
-      expect(domains.size).toBe(0)
-    })
-  })
-})

package/core/__tests__/domain/fibonacci.test.ts

@@ -1,113 +0,0 @@
-/**
- * Fibonacci Estimation Module Tests
- */
-
-import { describe, expect, it } from 'bun:test'
-import {
-  FIBONACCI_POINTS,
-  findClosestPoint,
-  formatMinutes,
-  isValidPoint,
-  pointsToMinutes,
-  pointsToTimeRange,
-} from '../../domain/fibonacci'
-
-describe('Fibonacci Estimation', () => {
-  describe('FIBONACCI_POINTS', () => {
-    it('should contain the standard Fibonacci sequence', () => {
-      expect(FIBONACCI_POINTS).toEqual([1, 2, 3, 5, 8, 13, 21])
-    })
-  })
-
-  describe('isValidPoint', () => {
-    it('should accept valid Fibonacci points', () => {
-      for (const p of FIBONACCI_POINTS) {
-        expect(isValidPoint(p)).toBe(true)
-      }
-    })
-
-    it('should reject non-Fibonacci numbers', () => {
-      expect(isValidPoint(0)).toBe(false)
-      expect(isValidPoint(4)).toBe(false)
-      expect(isValidPoint(6)).toBe(false)
-      expect(isValidPoint(10)).toBe(false)
-      expect(isValidPoint(22)).toBe(false)
-    })
-  })
-
-  describe('pointsToMinutes', () => {
-    it('should return min/max/typical for each point', () => {
-      const result = pointsToMinutes(1)
-      expect(result).toEqual({ min: 5, max: 15, typical: 10 })
-    })
-
-    it('should scale up with larger points', () => {
-      const small = pointsToMinutes(1)
-      const large = pointsToMinutes(21)
-      expect(large.typical).toBeGreaterThan(small.typical)
-    })
-
-    it('should have increasing typical times across the scale', () => {
-      let prev = 0
-      for (const p of FIBONACCI_POINTS) {
-        const { typical } = pointsToMinutes(p)
-        expect(typical).toBeGreaterThan(prev)
-        prev = typical
-      }
-    })
-  })
-
-  describe('formatMinutes', () => {
-    it('should format sub-hour durations', () => {
-      expect(formatMinutes(30)).toBe('30m')
-      expect(formatMinutes(5)).toBe('5m')
-    })
-
-    it('should format exact hours', () => {
-      expect(formatMinutes(60)).toBe('1h')
-      expect(formatMinutes(120)).toBe('2h')
-    })
-
-    it('should format hours and minutes', () => {
-      expect(formatMinutes(90)).toBe('1h 30m')
-      expect(formatMinutes(150)).toBe('2h 30m')
-    })
-  })
-
-  describe('pointsToTimeRange', () => {
-    it('should return formatted range string', () => {
-      expect(pointsToTimeRange(1)).toBe('5m–15m')
-      expect(pointsToTimeRange(5)).toBe('1h–2h')
-    })
-  })
-
-  describe('findClosestPoint', () => {
-    it('should find exact matches for typical times', () => {
-      expect(findClosestPoint(10)).toBe(1)
-      expect(findClosestPoint(20)).toBe(2)
-      expect(findClosestPoint(45)).toBe(3)
-      expect(findClosestPoint(90)).toBe(5)
-      expect(findClosestPoint(180)).toBe(8)
-      expect(findClosestPoint(360)).toBe(13)
-      expect(findClosestPoint(720)).toBe(21)
-    })
-
-    it('should find closest point for in-between values', () => {
-      // 15 minutes is equidistant between 1 (10m) and 2 (20m) — picks first match
-      expect(findClosestPoint(15)).toBe(1)
-      // 16 minutes is closer to 2 (20m) than 1 (10m)
-      expect(findClosestPoint(16)).toBe(2)
-      // 35 minutes is closer to 3 (45m) than 2 (20m)
-      expect(findClosestPoint(35)).toBe(3)
-    })
-
-    it('should return 1 for very small durations', () => {
-      expect(findClosestPoint(1)).toBe(1)
-      expect(findClosestPoint(0)).toBe(1)
-    })
-
-    it('should return 21 for very large durations', () => {
-      expect(findClosestPoint(1000)).toBe(21)
-    })
-  })
-})

package/core/__tests__/domain/file-hasher.test.ts

@@ -1,146 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-import path from 'node:path'
-import { computeHashes, diffHashes, type FileHash } from '../../domain/file-hasher'
-
-describe('file-hasher', () => {
-  // =========================================================================
-  // diffHashes
-  // =========================================================================
-
-  describe('diffHashes', () => {
-    const makeHash = (filePath: string, hash: string): FileHash => ({
-      path: filePath,
-      hash,
-      size: 100,
-      mtime: '2026-01-01T00:00:00.000Z',
-    })
-
-    test('detects added files', () => {
-      const current = new Map<string, FileHash>([
-        ['src/new-file.ts', makeHash('src/new-file.ts', 'xxh64:abc')],
-        ['src/existing.ts', makeHash('src/existing.ts', 'xxh64:def')],
-      ])
-      const stored = new Map<string, FileHash>([
-        ['src/existing.ts', makeHash('src/existing.ts', 'xxh64:def')],
-      ])
-
-      const diff = diffHashes(current, stored)
-      expect(diff.added).toEqual(['src/new-file.ts'])
-      expect(diff.modified).toEqual([])
-      expect(diff.unchanged).toEqual(['src/existing.ts'])
-      expect(diff.deleted).toEqual([])
-    })
-
-    test('detects modified files', () => {
-      const current = new Map<string, FileHash>([
-        ['src/changed.ts', makeHash('src/changed.ts', 'xxh64:new-hash')],
-      ])
-      const stored = new Map<string, FileHash>([
-        ['src/changed.ts', makeHash('src/changed.ts', 'xxh64:old-hash')],
-      ])
-
-      const diff = diffHashes(current, stored)
-      expect(diff.added).toEqual([])
-      expect(diff.modified).toEqual(['src/changed.ts'])
-      expect(diff.unchanged).toEqual([])
-      expect(diff.deleted).toEqual([])
-    })
-
-    test('detects deleted files', () => {
-      const current = new Map<string, FileHash>()
-      const stored = new Map<string, FileHash>([
-        ['src/removed.ts', makeHash('src/removed.ts', 'xxh64:abc')],
-      ])
-
-      const diff = diffHashes(current, stored)
-      expect(diff.added).toEqual([])
-      expect(diff.modified).toEqual([])
-      expect(diff.unchanged).toEqual([])
-      expect(diff.deleted).toEqual(['src/removed.ts'])
-    })
-
-    test('handles empty maps', () => {
-      const diff = diffHashes(new Map(), new Map())
-      expect(diff.added).toEqual([])
-      expect(diff.modified).toEqual([])
-      expect(diff.unchanged).toEqual([])
-      expect(diff.deleted).toEqual([])
-    })
-
-    test('handles first sync (no stored hashes)', () => {
-      const current = new Map<string, FileHash>([
-        ['src/a.ts', makeHash('src/a.ts', 'xxh64:1')],
-        ['src/b.ts', makeHash('src/b.ts', 'xxh64:2')],
-        ['src/c.ts', makeHash('src/c.ts', 'xxh64:3')],
-      ])
-      const stored = new Map<string, FileHash>()
-
-      const diff = diffHashes(current, stored)
-      expect(diff.added).toHaveLength(3)
-      expect(diff.modified).toEqual([])
-      expect(diff.unchanged).toEqual([])
-      expect(diff.deleted).toEqual([])
-    })
-
-    test('mixed changes: added + modified + deleted + unchanged', () => {
-      const current = new Map<string, FileHash>([
-        ['src/new.ts', makeHash('src/new.ts', 'xxh64:new')],
-        ['src/changed.ts', makeHash('src/changed.ts', 'xxh64:v2')],
-        ['src/same.ts', makeHash('src/same.ts', 'xxh64:same')],
-      ])
-      const stored = new Map<string, FileHash>([
-        ['src/changed.ts', makeHash('src/changed.ts', 'xxh64:v1')],
-        ['src/same.ts', makeHash('src/same.ts', 'xxh64:same')],
-        ['src/gone.ts', makeHash('src/gone.ts', 'xxh64:gone')],
-      ])
-
-      const diff = diffHashes(current, stored)
-      expect(diff.added).toEqual(['src/new.ts'])
-      expect(diff.modified).toEqual(['src/changed.ts'])
-      expect(diff.unchanged).toEqual(['src/same.ts'])
-      expect(diff.deleted).toEqual(['src/gone.ts'])
-    })
-  })
-
-  // =========================================================================
-  // computeHashes (integration — reads actual files)
-  // =========================================================================
-
-  describe('computeHashes', () => {
-    test('computes hashes for project files', async () => {
-      // Hash the prjct-cli project itself (small subset)
-      const projectPath = path.resolve(__dirname, '..', '..', '..')
-      const hashes = await computeHashes(projectPath)
-
-      // Should find many files
-      expect(hashes.size).toBeGreaterThan(50)
-
-      // Check a known file exists
-      const packageJson = hashes.get('package.json')
-      expect(packageJson).toBeDefined()
-      expect(packageJson!.hash).toMatch(/^(xxh64|fnv1a):/)
-      expect(packageJson!.size).toBeGreaterThan(0)
-    })
-
-    test('excludes node_modules and .git', async () => {
-      const projectPath = path.resolve(__dirname, '..', '..', '..')
-      const hashes = await computeHashes(projectPath)
-
-      for (const [filePath] of hashes) {
-        expect(filePath).not.toContain('node_modules')
-        expect(filePath).not.toContain('.git/')
-      }
-    })
-
-    test('hash is deterministic', async () => {
-      const projectPath = path.resolve(__dirname, '..', '..', '..')
-      const hashes1 = await computeHashes(projectPath)
-      const hashes2 = await computeHashes(projectPath)
-
-      // Same file should produce same hash
-      const pkg1 = hashes1.get('package.json')
-      const pkg2 = hashes2.get('package.json')
-      expect(pkg1?.hash).toBe(pkg2?.hash)
-    })
-  })
-})

package/core/__tests__/domain/file-ranker.test.ts

@@ -1,169 +0,0 @@
-/**
- * Tests for Combined File Ranker
- */
-
-import { afterEach, beforeEach, describe, expect, it } from 'bun:test'
-import { exec as execCallback } from 'node:child_process'
-import fs from 'node:fs/promises'
-import os from 'node:os'
-import path from 'node:path'
-import { promisify } from 'node:util'
-import { indexProject } from '../../domain/bm25'
-import { hasIndexes, rankFiles } from '../../domain/file-ranker'
-import { indexCoChanges } from '../../domain/git-cochange'
-import { indexImports } from '../../domain/import-graph'
-import pathManager from '../../infrastructure/path-manager'
-import prjctDb from '../../storage/database'
-
-const exec = promisify(execCallback)
-
-describe('FileRanker', () => {
-  let testDir: string
-  let testProjectId: string
-  const originalGetGlobalProjectPath = pathManager.getGlobalProjectPath.bind(pathManager)
-
-  beforeEach(async () => {
-    testDir = path.join(os.tmpdir(), `prjct-ranker-test-${Date.now()}`)
-    testProjectId = `test-ranker-${Date.now()}`
-    await fs.mkdir(testDir, { recursive: true })
-
-    // Mock path manager to use temp dir
-    pathManager.getGlobalProjectPath = () => testDir
-
-    // Initialize git repo
-    await exec('git init', { cwd: testDir })
-    await exec('git config user.email "test@test.com"', { cwd: testDir })
-    await exec('git config user.name "Test"', { cwd: testDir })
-  })
-
-  afterEach(async () => {
-    pathManager.getGlobalProjectPath = originalGetGlobalProjectPath
-    prjctDb.close()
-    try {
-      await fs.rm(testDir, { recursive: true, force: true })
-    } catch {
-      // Ignore
-    }
-  })
-
-  describe('hasIndexes', () => {
-    it('should return false when no indexes exist', () => {
-      const result = hasIndexes(testProjectId)
-      expect(result.bm25).toBe(false)
-      expect(result.imports).toBe(false)
-      expect(result.cochange).toBe(false)
-    })
-
-    it('should return true after building indexes', async () => {
-      // Create a test file
-      await fs.writeFile(path.join(testDir, 'app.ts'), 'export function main() {}')
-      await exec('git add -A && git commit -m "init"', { cwd: testDir })
-
-      await indexProject(testDir, testProjectId)
-      await indexImports(testDir, testProjectId)
-      await indexCoChanges(testDir, testProjectId)
-
-      const result = hasIndexes(testProjectId)
-      expect(result.bm25).toBe(true)
-      expect(result.imports).toBe(true)
-      expect(result.cochange).toBe(true)
-    })
-  })
-
-  describe('rankFiles', () => {
-    it('should return empty array when no indexes exist', () => {
-      const result = rankFiles(testProjectId, 'anything')
-      expect(result).toEqual([])
-    })
-
-    it('should rank relevant files higher', async () => {
-      // Create auth-related files
-      await fs.writeFile(
-        path.join(testDir, 'auth.ts'),
-        `// Authentication service for JWT handling\nexport class AuthService {\n  validateJwt(token: string) { return true }\n}`
-      )
-      await fs.writeFile(
-        path.join(testDir, 'middleware.ts'),
-        `import { AuthService } from './auth'\n// Auth middleware\nexport function authMiddleware() {}`
-      )
-      await fs.writeFile(
-        path.join(testDir, 'session.ts'),
-        `import { AuthService } from './auth'\n// Session management\nexport function refreshSession() {}`
-      )
-      // Create unrelated file
-      await fs.writeFile(
-        path.join(testDir, 'button.tsx'),
-        `// UI button component\nexport function Button() { return null }`
-      )
-
-      // Create git history with co-changes
-      await exec('git add -A && git commit -m "init"', { cwd: testDir })
-      await fs.writeFile(path.join(testDir, 'auth.ts'), `export class AuthService { v2() {} }`)
-      await fs.writeFile(
-        path.join(testDir, 'middleware.ts'),
-        `export function authMiddleware() { v2 }`
-      )
-      await exec('git add -A && git commit -m "update auth"', { cwd: testDir })
-
-      // Build all indexes
-      await indexProject(testDir, testProjectId)
-      await indexImports(testDir, testProjectId)
-      await indexCoChanges(testDir, testProjectId)
-
-      const results = rankFiles(testProjectId, 'Fix auth middleware for JWT validation')
-
-      expect(results.length).toBeGreaterThan(0)
-
-      // Auth and middleware should be in results
-      const authResult = results.find((r) => r.path === 'auth.ts')
-      const middlewareResult = results.find((r) => r.path === 'middleware.ts')
-
-      expect(authResult).toBeDefined()
-      expect(middlewareResult).toBeDefined()
-
-      // Auth should rank higher than button
-      const buttonResult = results.find((r) => r.path === 'button.tsx')
-      if (authResult && buttonResult) {
-        expect(authResult.finalScore).toBeGreaterThan(buttonResult.finalScore)
-      }
-    })
-
-    it('should include signal breakdown', async () => {
-      await fs.writeFile(
-        path.join(testDir, 'auth.ts'),
-        `// Authentication\nexport class AuthService {}`
-      )
-      await exec('git add -A && git commit -m "init"', { cwd: testDir })
-
-      await indexProject(testDir, testProjectId)
-      await indexImports(testDir, testProjectId)
-      await indexCoChanges(testDir, testProjectId)
-
-      const results = rankFiles(testProjectId, 'authentication')
-
-      if (results.length > 0) {
-        const first = results[0]
-        expect(first.signals).toBeDefined()
-        expect(typeof first.signals.bm25).toBe('number')
-        expect(typeof first.signals.imports).toBe('number')
-        expect(typeof first.signals.cochange).toBe('number')
-      }
-    })
-
-    it('should respect topN config', async () => {
-      // Create many files
-      for (let i = 0; i < 20; i++) {
-        await fs.writeFile(
-          path.join(testDir, `service-${i}.ts`),
-          `// Service module ${i}\nexport function service${i}() {}`
-        )
-      }
-      await exec('git add -A && git commit -m "init"', { cwd: testDir })
-
-      await indexProject(testDir, testProjectId)
-
-      const results = rankFiles(testProjectId, 'service module', { topN: 5 })
-      expect(results.length).toBeLessThanOrEqual(5)
-    })
-  })
-})

package/core/__tests__/domain/git-cochange.test.ts

@@ -1,121 +0,0 @@
-/**
- * Tests for Git Co-Change Analyzer
- */
-
-import { afterEach, beforeEach, describe, expect, it } from 'bun:test'
-import { exec as execCallback } from 'node:child_process'
-import fs from 'node:fs/promises'
-import os from 'node:os'
-import path from 'node:path'
-import { promisify } from 'node:util'
-import { buildMatrix, scoreFromSeeds } from '../../domain/git-cochange'
-
-const exec = promisify(execCallback)
-
-describe('GitCoChange', () => {
-  let testDir: string
-
-  beforeEach(async () => {
-    testDir = path.join(os.tmpdir(), `prjct-cochange-test-${Date.now()}`)
-    await fs.mkdir(testDir, { recursive: true })
-
-    // Initialize a git repo
-    await exec('git init', { cwd: testDir })
-    await exec('git config user.email "test@test.com"', { cwd: testDir })
-    await exec('git config user.name "Test"', { cwd: testDir })
-  })
-
-  afterEach(async () => {
-    try {
-      await fs.rm(testDir, { recursive: true, force: true })
-    } catch {
-      // Ignore cleanup errors
-    }
-  })
-
-  describe('buildMatrix', () => {
-    it('should detect co-changed files', async () => {
-      // Create files that change together
-      for (let i = 0; i < 5; i++) {
-        await fs.writeFile(path.join(testDir, 'auth.ts'), `export const v${i} = ${i}`)
-        await fs.writeFile(path.join(testDir, 'middleware.ts'), `export const v${i} = ${i}`)
-        await exec('git add -A', { cwd: testDir })
-        await exec(`git commit -m "commit ${i}"`, { cwd: testDir })
-      }
-
-      // Create a file that changes independently
-      await fs.writeFile(path.join(testDir, 'unrelated.ts'), 'export const x = 1')
-      await exec('git add -A', { cwd: testDir })
-      await exec('git commit -m "unrelated"', { cwd: testDir })
-
-      const index = await buildMatrix(testDir, 100)
-
-      expect(index.commitsAnalyzed).toBeGreaterThan(0)
-      expect(index.matrix['auth.ts']).toBeDefined()
-      expect(index.matrix['auth.ts']['middleware.ts']).toBeGreaterThan(0)
-
-      // Auth and middleware should have high co-change
-      const similarity = index.matrix['auth.ts']['middleware.ts']
-      expect(similarity).toBeGreaterThan(0.5)
-    })
-
-    it('should be symmetric', async () => {
-      for (let i = 0; i < 3; i++) {
-        await fs.writeFile(path.join(testDir, 'a.ts'), `const v${i} = ${i}`)
-        await fs.writeFile(path.join(testDir, 'b.ts'), `const v${i} = ${i}`)
-        await exec('git add -A', { cwd: testDir })
-        await exec(`git commit -m "commit ${i}"`, { cwd: testDir })
-      }
-
-      const index = await buildMatrix(testDir, 100)
-
-      if (index.matrix['a.ts'] && index.matrix['b.ts']) {
-        expect(index.matrix['a.ts']['b.ts']).toBe(index.matrix['b.ts']['a.ts'])
-      }
-    })
-
-    it('should handle no git history', async () => {
-      const emptyDir = path.join(os.tmpdir(), `prjct-cochange-empty-${Date.now()}`)
-      await fs.mkdir(emptyDir, { recursive: true })
-
-      const index = await buildMatrix(emptyDir, 100)
-      expect(index.commitsAnalyzed).toBe(0)
-      expect(Object.keys(index.matrix)).toHaveLength(0)
-
-      await fs.rm(emptyDir, { recursive: true, force: true })
-    })
-  })
-
-  describe('scoreFromSeeds', () => {
-    it('should score co-changed files', async () => {
-      // Create co-change history
-      for (let i = 0; i < 5; i++) {
-        await fs.writeFile(path.join(testDir, 'auth.ts'), `v${i}`)
-        await fs.writeFile(path.join(testDir, 'session.ts'), `v${i}`)
-        await exec('git add -A', { cwd: testDir })
-        await exec(`git commit -m "commit ${i}"`, { cwd: testDir })
-      }
-
-      const index = await buildMatrix(testDir, 100)
-      const scores = scoreFromSeeds(['auth.ts'], index)
-
-      const sessionScore = scores.find((s) => s.path === 'session.ts')
-      expect(sessionScore).toBeDefined()
-      expect(sessionScore!.score).toBeGreaterThan(0)
-    })
-
-    it('should not include seed files in results', async () => {
-      for (let i = 0; i < 3; i++) {
-        await fs.writeFile(path.join(testDir, 'a.ts'), `v${i}`)
-        await fs.writeFile(path.join(testDir, 'b.ts'), `v${i}`)
-        await exec('git add -A', { cwd: testDir })
-        await exec(`git commit -m "commit ${i}"`, { cwd: testDir })
-      }
-
-      const index = await buildMatrix(testDir, 100)
-      const scores = scoreFromSeeds(['a.ts'], index)
-
-      expect(scores.find((s) => s.path === 'a.ts')).toBeUndefined()
-    })
-  })
-})