prjct-cli 0.44.1 → 0.45.3

package/core/__tests__/agentic/prompt-builder.test.ts

@@ -5,7 +5,7 @@
  * OPTIMIZED: Tests updated to match compressed prompt structure
  */
 
-import { describe, it, expect, beforeEach } from 'bun:test'
+import { beforeEach, describe, expect, it } from 'bun:test'
 import promptBuilder from '../../agentic/prompt-builder'
 
 describe('PromptBuilder', () => {
@@ -63,7 +63,7 @@ describe('PromptBuilder', () => {
         next: '# NEXT\n\n## Priority Queue\n\n1. Task 1',
         context: 'Project context information',
         analysis: 'Stack: Node.js\nPatterns: ES6 modules',
-        metrics: 'Some metrics data'
+        metrics: 'Some metrics data',
       }
 
       const filtered = builder.filterRelevantState(state)
@@ -79,7 +79,7 @@ describe('PromptBuilder', () => {
       const largeContent = 'x'.repeat(2000)
       const state = {
         now: '# NOW\n\n**Task**',
-        largeFile: largeContent
+        largeFile: largeContent,
       }
 
       const filtered = builder.filterRelevantState(state)
@@ -99,7 +99,7 @@ describe('PromptBuilder', () => {
     it('should include patterns for code commands', () => {
       const template = {
         frontmatter: { description: 'Build feature', name: 'p:build' },
-        content: '## Flow\nBuild something'
+        content: '## Flow\nBuild something',
       }
 
       const context = { projectPath: '/test', files: ['file1.js'] }
@@ -114,7 +114,7 @@ describe('PromptBuilder', () => {
     it('should NOT include patterns for non-code commands', () => {
       const template = {
         frontmatter: { description: 'Show current task', name: 'p:now' },
-        content: '## Flow\nShow task'
+        content: '## Flow\nShow task',
       }
 
       const context = { projectPath: '/test', files: ['file1.js'] }
@@ -130,12 +130,12 @@ describe('PromptBuilder', () => {
     it('should list available files when context has files', () => {
       const template = {
         frontmatter: { description: 'Test command' },
-        content: '## Flow\nDo something'
+        content: '## Flow\nDo something',
       }
 
       const context = {
         projectPath: '/test',
-        files: ['src/file1.js', 'src/file2.js', 'tests/test1.js']
+        files: ['src/file1.js', 'src/file2.js', 'tests/test1.js'],
       }
 
       const state = {}
@@ -151,7 +151,7 @@ describe('PromptBuilder', () => {
     it('should show project path when no files listed', () => {
       const template = {
         frontmatter: { description: 'Test command' },
-        content: '## Flow\nDo something'
+        content: '## Flow\nDo something',
       }
 
       const context = { projectPath: '/test/project' }
@@ -169,15 +169,15 @@ describe('PromptBuilder', () => {
       const template = {
         frontmatter: {
           description: 'Test command',
-          'allowed-tools': ['Read', 'Write']
+          'allowed-tools': ['Read', 'Write'],
         },
-        content: '## Flow\n1. Do step 1\n2. Do step 2'
+        content: '## Flow\n1. Do step 1\n2. Do step 2',
       }
 
       const context = {
         projectPath: '/test',
         params: { task: 'test task' },
-        files: ['file1.js']
+        files: ['file1.js'],
       }
 
       const state = { now: '# NOW\n\n**Current task**' }
@@ -194,7 +194,7 @@ describe('PromptBuilder', () => {
     it('should be concise (under 2000 chars for simple prompt)', () => {
       const template = {
         frontmatter: { description: 'Test', 'allowed-tools': ['Read'] },
-        content: '## Flow\n1. Test'
+        content: '## Flow\n1. Test',
       }
 
       const context = { projectPath: '/test', files: ['a.js'] }
@@ -210,7 +210,7 @@ describe('PromptBuilder', () => {
     it('should include compact plan mode instructions', () => {
       const template = {
         frontmatter: { description: 'Test' },
-        content: '## Flow\nTest'
+        content: '## Flow\nTest',
       }
 
       const context = { projectPath: '/test' }
@@ -227,7 +227,7 @@ describe('PromptBuilder', () => {
     it('should include approval required section', () => {
       const template = {
         frontmatter: { description: 'Test' },
-        content: '## Flow\nTest'
+        content: '## Flow\nTest',
       }
 
       const context = { projectPath: '/test' }

package/core/__tests__/services/project-index.test.ts

@@ -0,0 +1,353 @@
+/**
+ * ProjectIndex Tests
+ *
+ * Tests for the persistent project scanner with scoring
+ */
+
+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 { FileScorer } from '../../services/file-scorer'
+import { createProjectIndexer, RELEVANCE_THRESHOLD } from '../../services/project-index'
+import { getDefaultIndex, indexStorage } from '../../storage/index-storage'
+
+describe('FileScorer', () => {
+  describe('scoreFile', () => {
+    it('should give higher scores to recently modified files', () => {
+      const scorer = new FileScorer()
+
+      const recentFile = {
+        path: 'src/recent.ts',
+        size: 1000,
+        mtime: new Date(), // today
+      }
+
+      const oldFile = {
+        path: 'src/old.ts',
+        size: 1000,
+        mtime: new Date(Date.now() - 365 * 24 * 60 * 60 * 1000), // 1 year ago
+      }
+
+      const context = {
+        allFiles: new Map([
+          ['src/recent.ts', recentFile],
+          ['src/old.ts', oldFile],
+        ]),
+        configFiles: new Set<string>(),
+        maxFileSize: 1000,
+        maxRecentCommits: 0,
+        now: new Date(),
+      }
+
+      const recentScore = scorer.scoreFile(recentFile, context)
+      const oldScore = scorer.scoreFile(oldFile, context)
+
+      expect(recentScore.factors.recency).toBeGreaterThan(oldScore.factors.recency)
+    })
+
+    it('should give higher scores to config files', () => {
+      const scorer = new FileScorer()
+
+      const configFile = {
+        path: 'package.json',
+        size: 500,
+        mtime: new Date(),
+      }
+
+      const sourceFile = {
+        path: 'src/utils.ts',
+        size: 500,
+        mtime: new Date(),
+      }
+
+      const context = {
+        allFiles: new Map([
+          ['package.json', configFile],
+          ['src/utils.ts', sourceFile],
+        ]),
+        configFiles: new Set(['package.json']),
+        maxFileSize: 500,
+        maxRecentCommits: 0,
+        now: new Date(),
+      }
+
+      const configScore = scorer.scoreFile(configFile, context)
+      const sourceScore = scorer.scoreFile(sourceFile, context)
+
+      expect(configScore.factors.configRelevance).toBe(20)
+      expect(sourceScore.factors.configRelevance).toBe(0)
+    })
+
+    it('should give higher scores to index/main files', () => {
+      const scorer = new FileScorer()
+
+      const indexFile = {
+        path: 'src/index.ts',
+        size: 500,
+        mtime: new Date(),
+      }
+
+      const helperFile = {
+        path: 'src/random-helper.ts',
+        size: 500,
+        mtime: new Date(),
+      }
+
+      const context = {
+        allFiles: new Map([
+          ['src/index.ts', indexFile],
+          ['src/random-helper.ts', helperFile],
+        ]),
+        configFiles: new Set<string>(),
+        maxFileSize: 500,
+        maxRecentCommits: 0,
+        now: new Date(),
+      }
+
+      const indexScore = scorer.scoreFile(indexFile, context)
+      const helperScore = scorer.scoreFile(helperFile, context)
+
+      expect(indexScore.factors.nameRelevance).toBe(15)
+      expect(helperScore.factors.nameRelevance).toBe(0)
+    })
+
+    it('should penalize very large files', () => {
+      const scorer = new FileScorer()
+
+      const normalFile = {
+        path: 'src/normal.ts',
+        size: 5000, // 5KB - optimal
+        mtime: new Date(),
+      }
+
+      const hugeFile = {
+        path: 'src/huge.ts',
+        size: 500000, // 500KB - too large
+        mtime: new Date(),
+      }
+
+      const context = {
+        allFiles: new Map([
+          ['src/normal.ts', normalFile],
+          ['src/huge.ts', hugeFile],
+        ]),
+        configFiles: new Set<string>(),
+        maxFileSize: 500000,
+        maxRecentCommits: 0,
+        now: new Date(),
+      }
+
+      const normalScore = scorer.scoreFile(normalFile, context)
+      const hugeScore = scorer.scoreFile(hugeFile, context)
+
+      expect(normalScore.factors.sizeOptimal).toBeGreaterThan(hugeScore.factors.sizeOptimal)
+    })
+  })
+
+  describe('getRelevantFiles', () => {
+    it('should filter files below threshold', () => {
+      const scorer = new FileScorer()
+
+      // Config file should be relevant
+      const configFile = {
+        path: 'package.json',
+        size: 500,
+        mtime: new Date(),
+      }
+
+      // Random old file should not be relevant
+      const randomFile = {
+        path: 'src/old-unused.ts',
+        size: 50, // very small
+        mtime: new Date(Date.now() - 365 * 24 * 60 * 60 * 1000), // old
+      }
+
+      const context = {
+        allFiles: new Map([
+          ['package.json', configFile],
+          ['src/old-unused.ts', randomFile],
+        ]),
+        configFiles: new Set(['package.json']),
+        maxFileSize: 500,
+        maxRecentCommits: 0,
+        now: new Date(),
+      }
+
+      const relevant = scorer.getRelevantFiles(context, RELEVANCE_THRESHOLD)
+
+      expect(relevant.length).toBeGreaterThanOrEqual(1)
+      expect(relevant[0].path).toBe('package.json')
+    })
+  })
+})
+
+describe('IndexStorage', () => {
+  const testProjectId = `test-project-${Date.now()}`
+
+  beforeEach(async () => {
+    // Set up test directory
+    const testDir = path.join(os.tmpdir(), `prjct-test-${Date.now()}`)
+    pathManager.setGlobalBaseDir(testDir)
+  })
+
+  afterEach(async () => {
+    // Cleanup is handled by temp directory
+  })
+
+  describe('readIndex/writeIndex', () => {
+    it('should return null for non-existent index', async () => {
+      const index = await indexStorage.readIndex(testProjectId)
+      expect(index).toBeNull()
+    })
+
+    it('should persist and retrieve index', async () => {
+      const testIndex = getDefaultIndex('/test/project')
+      testIndex.lastFullScan = new Date().toISOString()
+      testIndex.totalFiles = 100
+
+      await indexStorage.writeIndex(testProjectId, testIndex)
+      const retrieved = await indexStorage.readIndex(testProjectId)
+
+      expect(retrieved).not.toBeNull()
+      expect(retrieved!.totalFiles).toBe(100)
+      expect(retrieved!.lastFullScan).toBe(testIndex.lastFullScan)
+    })
+  })
+
+  describe('hasValidIndex', () => {
+    it('should return false for non-existent index', async () => {
+      const valid = await indexStorage.hasValidIndex(testProjectId)
+      expect(valid).toBe(false)
+    })
+
+    it('should return true for index with lastFullScan', async () => {
+      const testIndex = getDefaultIndex('/test/project')
+      testIndex.lastFullScan = new Date().toISOString()
+
+      await indexStorage.writeIndex(testProjectId, testIndex)
+      const valid = await indexStorage.hasValidIndex(testProjectId)
+
+      expect(valid).toBe(true)
+    })
+  })
+})
+
+describe('ProjectIndexer', () => {
+  const testProjectId = `test-indexer-${Date.now()}`
+  let testProjectPath: string
+
+  beforeEach(async () => {
+    // Create a temp project directory
+    testProjectPath = path.join(os.tmpdir(), `prjct-indexer-test-${Date.now()}`)
+    await fs.mkdir(testProjectPath, { recursive: true })
+
+    // Create some test files
+    await fs.mkdir(path.join(testProjectPath, 'src'), { recursive: true })
+    await fs.writeFile(
+      path.join(testProjectPath, 'src', 'index.ts'),
+      'export const main = () => {}'
+    )
+    await fs.writeFile(
+      path.join(testProjectPath, 'src', 'utils.ts'),
+      'export const helper = () => {}'
+    )
+    await fs.writeFile(
+      path.join(testProjectPath, 'package.json'),
+      JSON.stringify(
+        {
+          name: 'test-project',
+          version: '1.0.0',
+          dependencies: { express: '^4.0.0' },
+          devDependencies: { typescript: '^5.0.0' },
+        },
+        null,
+        2
+      )
+    )
+
+    // Set up test storage directory
+    const testStorageDir = path.join(os.tmpdir(), `prjct-storage-${Date.now()}`)
+    pathManager.setGlobalBaseDir(testStorageDir)
+  })
+
+  afterEach(async () => {
+    // Cleanup
+    try {
+      await fs.rm(testProjectPath, { recursive: true })
+    } catch {
+      // Ignore cleanup errors
+    }
+  })
+
+  describe('fullScan', () => {
+    it('should scan project and create index', async () => {
+      const indexer = createProjectIndexer(testProjectPath, testProjectId)
+      const result = await indexer.fullScan()
+
+      expect(result.fromCache).toBe(false)
+      expect(result.index.totalFiles).toBeGreaterThanOrEqual(2)
+      expect(result.index.lastFullScan).not.toBe('')
+    })
+
+    it('should detect TypeScript from config files', async () => {
+      // Add tsconfig.json
+      await fs.writeFile(
+        path.join(testProjectPath, 'tsconfig.json'),
+        JSON.stringify({
+          compilerOptions: { target: 'ES2020' },
+        })
+      )
+
+      const indexer = createProjectIndexer(testProjectPath, testProjectId)
+      const result = await indexer.fullScan()
+
+      expect(result.index.configFiles.some((cf) => cf.type === 'tsconfig.json')).toBe(true)
+    })
+
+    it('should detect Express backend', async () => {
+      const indexer = createProjectIndexer(testProjectPath, testProjectId)
+      const result = await indexer.fullScan()
+
+      expect(result.index.detectedStack.frameworks).toContain('Express')
+    })
+  })
+
+  describe('loadOrScan', () => {
+    it('should use cached index if valid', async () => {
+      const indexer = createProjectIndexer(testProjectPath, testProjectId)
+
+      // First scan
+      const firstResult = await indexer.fullScan()
+      expect(firstResult.fromCache).toBe(false)
+
+      // Second load should use cache
+      const secondResult = await indexer.loadOrScan()
+      expect(secondResult.fromCache).toBe(true)
+    })
+
+    it('should rescan if forceFullScan is true', async () => {
+      const indexer = createProjectIndexer(testProjectPath, testProjectId)
+
+      // First scan
+      await indexer.fullScan()
+
+      // Force rescan
+      const result = await indexer.loadOrScan({ forceFullScan: true })
+      expect(result.fromCache).toBe(false)
+    })
+  })
+
+  describe('getRelevantContext', () => {
+    it('should return files within token limit', async () => {
+      const indexer = createProjectIndexer(testProjectPath, testProjectId)
+      await indexer.fullScan()
+
+      const context = await indexer.getRelevantContext(10000)
+
+      expect(context.estimatedTokens).toBeLessThanOrEqual(10000)
+      expect(context.compressionRate).toBeGreaterThanOrEqual(0)
+    })
+  })
+})

package/core/__tests__/types/fs.test.ts

@@ -3,13 +3,13 @@
  * Tests for file system error utilities
  */
 
-import { describe, it, expect } from 'bun:test'
+import { describe, expect, it } from 'bun:test'
 import {
-  isNotFoundError,
-  isPermissionError,
   isDirNotEmptyError,
   isFileExistsError,
   isNodeError,
+  isNotFoundError,
+  isPermissionError,
 } from '../../types/fs'
 
 describe('FS Error Utilities', () => {

package/core/__tests__/utils/date-helper.test.ts

@@ -3,24 +3,24 @@
  * Tests for centralized date operations and formatting
  */
 
-import { describe, it, expect, beforeEach, afterEach, setSystemTime } from 'bun:test'
+import { afterEach, beforeEach, describe, expect, it, setSystemTime } from 'bun:test'
 import {
+  calculateDuration,
   formatDate,
+  formatDuration,
   formatMonth,
-  getTodayKey,
   getDateKey,
-  getYearMonthDay,
-  parseDate,
-  getTimestamp,
+  getDateRange,
   getDaysAgo,
   getDaysFromNow,
-  getDateRange,
+  getEndOfDay,
+  getStartOfDay,
+  getTimestamp,
+  getTodayKey,
+  getYearMonthDay,
   isToday,
   isWithinLastDays,
-  formatDuration,
-  calculateDuration,
-  getStartOfDay,
-  getEndOfDay,
+  parseDate,
 } from '../../utils/date-helper'
 
 describe('DateHelper', () => {

package/core/__tests__/utils/output.test.ts

@@ -3,21 +3,24 @@
  * Minimal output system for prjct-cli
  */
 
-import { describe, it, expect, beforeEach, afterEach, spyOn } from 'bun:test'
+import { afterEach, beforeEach, describe, expect, it, spyOn } from 'bun:test'
 import out from '../../utils/output'
 
 describe('Output Module', () => {
   let consoleLogSpy: ReturnType<typeof spyOn>
+  let consoleErrorSpy: ReturnType<typeof spyOn>
   let stdoutWriteSpy: ReturnType<typeof spyOn>
 
   beforeEach(() => {
     consoleLogSpy = spyOn(console, 'log').mockImplementation(() => {})
+    consoleErrorSpy = spyOn(console, 'error').mockImplementation(() => {})
     stdoutWriteSpy = spyOn(process.stdout, 'write').mockImplementation(() => true)
     out.stop()
   })
 
   afterEach(() => {
     consoleLogSpy.mockRestore()
+    consoleErrorSpy.mockRestore()
     stdoutWriteSpy.mockRestore()
     out.stop()
   })
@@ -50,8 +53,8 @@ describe('Output Module', () => {
     it('should output error message with X mark', () => {
       out.fail('something failed')
 
-      expect(consoleLogSpy).toHaveBeenCalledTimes(1)
-      const output = consoleLogSpy.mock.calls[0][0]
+      expect(consoleErrorSpy).toHaveBeenCalledTimes(1)
+      const output = consoleErrorSpy.mock.calls[0][0]
       expect(output).toContain('✗')
       expect(output).toContain('something failed')
     })
@@ -60,7 +63,7 @@ describe('Output Module', () => {
       const longMessage = 'error '.repeat(50)
       out.fail(longMessage)
 
-      const output = consoleLogSpy.mock.calls[0][0]
+      const output = consoleErrorSpy.mock.calls[0][0]
       expect(output.length).toBeLessThan(80)
     })
 
@@ -90,7 +93,7 @@ describe('Output Module', () => {
     it('should start spinner with message', async () => {
       out.spin('loading')
 
-      await new Promise(resolve => setTimeout(resolve, 150))
+      await new Promise((resolve) => setTimeout(resolve, 150))
 
       expect(stdoutWriteSpy).toHaveBeenCalled()
       const output = stdoutWriteSpy.mock.calls[0][0]
@@ -109,7 +112,7 @@ describe('Output Module', () => {
   describe('stop()', () => {
     it('should stop spinner and clear line', async () => {
       out.spin('loading')
-      await new Promise(resolve => setTimeout(resolve, 150))
+      await new Promise((resolve) => setTimeout(resolve, 150))
 
       stdoutWriteSpy.mockClear()
       out.stop()

package/core/__tests__/utils/project-commands.test.ts

@@ -3,9 +3,10 @@
  * Ensures prjct-cli uses the repo's own test/lint tooling (not hardcoded).
  */
 
-import { describe, it, expect, beforeEach, afterEach } from 'bun:test'
-import fs from 'fs/promises'
-import path from 'path'
+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 { detectProjectCommands } from '../../utils/project-commands'
 
@@ -23,7 +24,7 @@ async function writeText(filePath: string, content: string): Promise<void> {
 
 describe('detectProjectCommands', () => {
   beforeEach(async () => {
-    tmpRoot = await fs.mkdtemp(path.join(process.cwd(), '.tmp', 'detect-commands-'))
+    tmpRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'prjct-detect-commands-'))
   })
 
   afterEach(async () => {
@@ -68,5 +69,3 @@ describe('detectProjectCommands', () => {
     expect(detected.test?.command).toBe('cargo test')
   })
 })
-
-

package/core/agentic/agent-router.ts

@@ -11,12 +11,12 @@
  * @version 4.0.0
  */
 
-import fs from 'fs/promises'
-import path from 'path'
+import fs from 'node:fs/promises'
+import path from 'node:path'
 import configManager from '../infrastructure/config-manager'
 import pathManager from '../infrastructure/path-manager'
-import { isNotFoundError } from '../types/fs'
 import type { Agent, AssignmentContext } from '../types'
+import { isNotFoundError } from '../types/fs'
 
 // Re-export types for convenience
 export type { Agent, AssignmentContext } from '../types'
@@ -130,13 +130,12 @@ class AgentRouter {
         'agent-usage.jsonl'
       )
 
-      const entry =
-        JSON.stringify({
-          timestamp: new Date().toISOString(),
-          task: typeof task === 'string' ? task : task.description,
-          agent: typeof agent === 'string' ? agent : agent.name,
-          projectId: this.projectId,
-        }) + '\n'
+      const entry = `${JSON.stringify({
+        timestamp: new Date().toISOString(),
+        task: typeof task === 'string' ? task : task.description,
+        agent: typeof agent === 'string' ? agent : agent.name,
+        projectId: this.projectId,
+      })}\n`
 
       await fs.appendFile(logPath, entry)
     } catch (error) {

package/core/agentic/chain-of-thought.ts

@@ -6,7 +6,7 @@
  * @version 1.0.0
  */
 
-import type { ProjectContext, ContextState } from '../types'
+import type { ContextState, ProjectContext } from '../types'
 
 // Type aliases for compatibility with ProjectContext from contextBuilder.build()
 type Context = Pick<ProjectContext, 'projectId' | 'projectPath' | 'params'>
@@ -44,7 +44,11 @@ function requiresReasoning(commandName: string): boolean {
 /**
  * Reason through a command before execution
  */
-async function reason(commandName: string, context: Context, state: State): Promise<ReasoningResult> {
+async function reason(
+  commandName: string,
+  context: Context,
+  state: State
+): Promise<ReasoningResult> {
   const steps: ReasoningStep[] = []
   const plan: string[] = []
   const criticalIssues: string[] = []
@@ -63,7 +67,11 @@ async function reason(commandName: string, context: Context, state: State): Prom
       if (state.shipped) {
         steps.push({ step: 'Shipped log accessible', passed: true })
       } else {
-        steps.push({ step: 'Shipped log accessible', passed: false, details: 'shipped.md not found' })
+        steps.push({
+          step: 'Shipped log accessible',
+          passed: false,
+          details: 'shipped.md not found',
+        })
       }
 
       // Plan
@@ -79,7 +87,11 @@ async function reason(commandName: string, context: Context, state: State): Prom
       if (context.params.description || context.params.feature) {
         steps.push({ step: 'Has feature description', passed: true })
       } else {
-        steps.push({ step: 'Has feature description', passed: false, details: 'No description provided' })
+        steps.push({
+          step: 'Has feature description',
+          passed: false,
+          details: 'No description provided',
+        })
         criticalIssues.push('Missing feature description')
       }