prjct-cli 1.16.0 → 1.18.0

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

@@ -0,0 +1,169 @@
+/**
+ * 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

@@ -0,0 +1,121 @@
+/**
+ * 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()
+    })
+  })
+})

package/core/__tests__/domain/import-graph.test.ts

@@ -0,0 +1,156 @@
+/**
+ * Tests for Import Graph Builder
+ */
+
+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 { buildGraph, scoreFromSeeds } from '../../domain/import-graph'
+
+describe('ImportGraph', () => {
+  let testDir: string
+
+  beforeEach(async () => {
+    testDir = path.join(os.tmpdir(), `prjct-import-graph-test-${Date.now()}`)
+    await fs.mkdir(testDir, { recursive: true })
+  })
+
+  afterEach(async () => {
+    try {
+      await fs.rm(testDir, { recursive: true, force: true })
+    } catch {
+      // Ignore cleanup errors
+    }
+  })
+
+  describe('buildGraph', () => {
+    it('should build forward and reverse edges', async () => {
+      await fs.writeFile(
+        path.join(testDir, 'auth.ts'),
+        `import { validate } from './validator'\nexport class Auth {}`
+      )
+      await fs.writeFile(path.join(testDir, 'validator.ts'), `export function validate() {}`)
+      await fs.writeFile(
+        path.join(testDir, 'middleware.ts'),
+        `import { Auth } from './auth'\nexport function middleware() {}`
+      )
+
+      const graph = await buildGraph(testDir)
+
+      // Forward: auth imports validator
+      expect(graph.forward['auth.ts']).toContain('validator.ts')
+      // Forward: middleware imports auth
+      expect(graph.forward['middleware.ts']).toContain('auth.ts')
+
+      // Reverse: validator is imported by auth
+      expect(graph.reverse['validator.ts']).toContain('auth.ts')
+      // Reverse: auth is imported by middleware
+      expect(graph.reverse['auth.ts']).toContain('middleware.ts')
+    })
+
+    it('should count files and edges', async () => {
+      await fs.writeFile(
+        path.join(testDir, 'a.ts'),
+        `import { b } from './b'\nimport { c } from './c'`
+      )
+      await fs.writeFile(path.join(testDir, 'b.ts'), `export const b = 1`)
+      await fs.writeFile(path.join(testDir, 'c.ts'), `export const c = 2`)
+
+      const graph = await buildGraph(testDir)
+      expect(graph.fileCount).toBe(3)
+      expect(graph.edgeCount).toBe(2)
+    })
+
+    it('should skip external imports', async () => {
+      await fs.writeFile(
+        path.join(testDir, 'app.ts'),
+        `import express from 'express'\nimport { helper } from './helper'`
+      )
+      await fs.writeFile(path.join(testDir, 'helper.ts'), `export function helper() {}`)
+
+      const graph = await buildGraph(testDir)
+      expect(graph.forward['app.ts']).toEqual(['helper.ts'])
+      // express should not appear
+      expect(graph.forward['app.ts']).not.toContain('express')
+    })
+
+    it('should skip node_modules', async () => {
+      await fs.mkdir(path.join(testDir, 'node_modules'), { recursive: true })
+      await fs.writeFile(path.join(testDir, 'node_modules', 'pkg.ts'), `export default {}`)
+      await fs.writeFile(path.join(testDir, 'main.ts'), `export function main() {}`)
+
+      const graph = await buildGraph(testDir)
+      expect(graph.fileCount).toBe(1)
+    })
+  })
+
+  describe('scoreFromSeeds', () => {
+    it('should score direct imports at 0.5', async () => {
+      await fs.writeFile(
+        path.join(testDir, 'auth.ts'),
+        `import { middleware } from './middleware'\nexport class Auth {}`
+      )
+      await fs.writeFile(path.join(testDir, 'middleware.ts'), `export function middleware() {}`)
+      await fs.writeFile(path.join(testDir, 'unrelated.ts'), `export function unrelated() {}`)
+
+      const graph = await buildGraph(testDir)
+      const scores = scoreFromSeeds(['auth.ts'], graph)
+
+      const middlewareScore = scores.find((s) => s.path === 'middleware.ts')
+      expect(middlewareScore).toBeDefined()
+      expect(middlewareScore!.score).toBe(0.5) // 1 / (1 + 1) = 0.5
+      expect(middlewareScore!.depth).toBe(1)
+
+      // unrelated.ts should not appear
+      const unrelatedScore = scores.find((s) => s.path === 'unrelated.ts')
+      expect(unrelatedScore).toBeUndefined()
+    })
+
+    it('should score 2nd-level imports at 0.33', async () => {
+      await fs.writeFile(path.join(testDir, 'auth.ts'), `import { session } from './session'`)
+      await fs.writeFile(
+        path.join(testDir, 'session.ts'),
+        `import { db } from './db'\nexport function session() {}`
+      )
+      await fs.writeFile(path.join(testDir, 'db.ts'), `export function db() {}`)
+
+      const graph = await buildGraph(testDir)
+      const scores = scoreFromSeeds(['auth.ts'], graph, 2)
+
+      const sessionScore = scores.find((s) => s.path === 'session.ts')
+      expect(sessionScore).toBeDefined()
+      expect(sessionScore!.depth).toBe(1)
+
+      const dbScore = scores.find((s) => s.path === 'db.ts')
+      expect(dbScore).toBeDefined()
+      expect(dbScore!.depth).toBe(2)
+      expect(dbScore!.score).toBeCloseTo(1 / 3, 2)
+    })
+
+    it('should follow reverse edges (imported-by)', async () => {
+      await fs.writeFile(path.join(testDir, 'auth.ts'), `export function auth() {}`)
+      await fs.writeFile(
+        path.join(testDir, 'middleware.ts'),
+        `import { auth } from './auth'\nexport function middleware() {}`
+      )
+
+      const graph = await buildGraph(testDir)
+      // Seed is auth.ts, middleware imports auth → should appear via reverse edge
+      const scores = scoreFromSeeds(['auth.ts'], graph)
+
+      const middlewareScore = scores.find((s) => s.path === 'middleware.ts')
+      expect(middlewareScore).toBeDefined()
+    })
+
+    it('should not include seed files in results', async () => {
+      await fs.writeFile(path.join(testDir, 'a.ts'), `import { b } from './b'`)
+      await fs.writeFile(path.join(testDir, 'b.ts'), `export const b = 1`)
+
+      const graph = await buildGraph(testDir)
+      const scores = scoreFromSeeds(['a.ts'], graph)
+
+      expect(scores.find((s) => s.path === 'a.ts')).toBeUndefined()
+    })
+  })
+})

package/core/agentic/smart-context.ts

@@ -11,6 +11,7 @@
  */
 
 import { agentPerformanceTracker } from '../agents'
+import { hasIndexes, rankFiles } from '../domain/file-ranker'
 import { outcomeAnalyzer } from '../outcomes'
 import type {
   ContextDomain,
@@ -177,8 +178,13 @@ class SmartContext {
       filteredStack.testing = fullContext.stack.testing
     }
 
-    // Filter files by domain patterns
-    const filteredFiles = this.filterFiles(fullContext.files, taskDomain)
+    // Filter files: use BM25 ranker if indexes exist, else fall back to domain patterns
+    const filteredFiles = this.rankOrFilterFiles(
+      fullContext.files,
+      taskDescription,
+      projectId,
+      taskDomain
+    )
 
     // Calculate metrics
     const originalSize = this.estimateSize(fullContext)
@@ -205,6 +211,31 @@ class SmartContext {
     }
   }
 
+  /**
+   * Use BM25 + import graph + co-change ranking if indexes exist,
+   * otherwise fall back to regex-based domain filtering.
+   */
+  private rankOrFilterFiles(
+    files: string[],
+    taskDescription: string,
+    projectId: string,
+    domain: ContextDomain
+  ): string[] {
+    try {
+      const indexes = hasIndexes(projectId)
+      if (indexes.bm25) {
+        const ranked = rankFiles(projectId, taskDescription, { topN: 15 })
+        if (ranked.length > 0) {
+          return ranked.map((r) => r.path)
+        }
+      }
+    } catch {
+      // Index not available — fall through to regex filter
+    }
+
+    return this.filterFiles(files, domain)
+  }
+
   /**
    * Filter files by domain.
    */

package/core/commands/analysis.ts

@@ -235,6 +235,7 @@ export class AnalysisCommands extends PrjctCommandsBase {
       yes?: boolean
       json?: boolean
       package?: string
+      full?: boolean
     } = {}
   ): Promise<CommandResult> {
     try {
@@ -308,7 +309,10 @@ export class AnalysisCommands extends PrjctCommandsBase {
         }
 
         // Do a dry-run sync to see what would change
-        const result = await syncService.sync(projectPath, { aiTools: options.aiTools })
+        const result = await syncService.sync(projectPath, {
+          aiTools: options.aiTools,
+          full: options.full,
+        })
 
         if (!result.success) {
           if (isNonInteractive) {
@@ -453,7 +457,10 @@ export class AnalysisCommands extends PrjctCommandsBase {
       out.spin('Syncing project...')
 
       // Use syncService to do EVERYTHING in one call
-      const result = await syncService.sync(projectPath, { aiTools: options.aiTools })
+      const result = await syncService.sync(projectPath, {
+        aiTools: options.aiTools,
+        full: options.full,
+      })
 
       if (!result.success) {
         out.fail(result.error || 'Sync failed')

package/core/commands/command-data.ts

@@ -166,11 +166,13 @@ export const COMMANDS: CommandMeta[] = [
     name: 'sync',
     group: 'core',
     description: 'Sync project state and update workflow agents',
-    usage: { claude: '/p:sync', terminal: 'prjct sync [--package=<name>]' },
+    usage: { claude: '/p:sync', terminal: 'prjct sync [--package=<name>] [--full]' },
     implemented: true,
     hasTemplate: true,
     requiresProject: true,
     features: [
+      'Incremental sync: only re-analyzes changed files (default)',
+      'Force full sync: --full bypasses incremental cache',
       'Monorepo support: --package=<name> for single package sync',
       'Nested PRJCT.md inheritance',
       'Per-package CLAUDE.md generation',

package/core/commands/commands.ts

@@ -211,6 +211,7 @@ class PrjctCommands {
       yes?: boolean
       json?: boolean
       package?: string
+      full?: boolean
     } = {}
   ): Promise<CommandResult> {
     return this.analysis.sync(projectPath, options)