prjct-cli 0.63.0 → 0.64.1

package/CHANGELOG.md

@@ -1,5 +1,104 @@
 # Changelog
 
+## [0.64.1] - 2026-02-05
+
+### Bug Fixes
+
+- generate IDE context files with correct paths and formats (PRJ-122) (#107)
+
+
+## [0.64.1] - 2026-02-05
+
+### Bug Fixes
+
+- **IDE context file generation (PRJ-122)**: Fixed Cursor and Windsurf context file paths and formats
+
+### Implementation Details
+
+Fixed misalignment between `ai-provider.ts` (correct paths) and `ai-tools/registry.ts` (incorrect paths). Updated Cursor output to `.cursor/rules/prjct.mdc` with MDC format and `alwaysApply: true` frontmatter. Updated Windsurf output to `.windsurf/rules/prjct.md` with `trigger: always_on` frontmatter. Modified sync-service default behavior to auto-detect IDE tools when `.cursor/` or `.windsurf/` directories exist.
+
+### Learnings
+
+- Two separate implementations existed (ai-provider vs ai-tools) that needed synchronization
+- IDE formats differ: Cursor uses `alwaysApply: true`, Windsurf uses `trigger: always_on`
+- Auto-detection pattern: check for directory existence to enable optional features
+
+### Test Plan
+
+#### For QA
+1. Run `prjct sync` in project with `.cursor/` dir - verify `.cursor/rules/prjct.mdc` generated
+2. Run `prjct sync` in project with `.windsurf/` dir - verify `.windsurf/rules/prjct.md` generated
+3. Verify Cursor file has `alwaysApply: true` in frontmatter
+4. Verify Windsurf file has `trigger: always_on` in frontmatter
+5. Run `bun test` - all 405 tests pass
+
+#### For Users
+- `prjct sync` now auto-generates IDE context files when `.cursor/` or `.windsurf/` directories exist
+- No manual flags needed - detection is automatic
+- No breaking changes
+
+
+## [0.64.0] - 2026-02-05
+
+### Features
+
+- add input source tagging for context items (PRJ-102) (#106)
+
+
+## [0.63.2] - 2026-02-05
+
+### Added
+
+- **Input source tagging (PRJ-102)**: Context items now support origin tracking via `_source` metadata
+
+### Implementation Details
+
+Added `InputSource` type with 10 standardized source categories (user_explicit, user_file, system_detected, system_generated, system_inferred, learned, external, inherited, cached, unknown). Created `SourceMetadata` interface with capturedAt timestamp and optional confidence/sourcePath fields. Added `SourcedItem` base interface and `createSourceMetadata()` helper function. Extended key context interfaces (AgentInfo, FeatureInfo, PatternInfo, GatheredInfo, LoadedAgent) to support source tracking. Updated MemoryMetadata with inputSource field for consistency.
+
+### Learnings
+
+- Anthropic pattern: always track origin of all data for traceability and debugging
+- Using optional `_source` field allows backward-compatible adoption
+
+### Test Plan
+
+#### For QA
+1. Run `bun run typecheck` - passes with new types
+2. Run `bun test` - all 368 tests pass
+3. Verify `InputSource` type is exported from `core/types`
+
+#### For Users
+- Context items now support source tracking via `_source` metadata
+- Use `createSourceMetadata()` when creating context items
+- No breaking changes
+
+
+## [0.63.1] - 2026-02-05
+
+### Added
+
+- **Unit tests for smart-context.ts (PRJ-84)**: 57 tests covering domain detection, file filtering, and type mappings
+
+### Implementation Details
+
+Created comprehensive test suite for SmartContext class: `detectDomain()` tests for all 6 domains (frontend, backend, devops, docs, testing, general), `filterFiles()` tests for file pattern matching, `estimateSize()` tests for token estimation, and type mapping function tests.
+
+### Learnings
+
+- Keyword detection uses substring matching - "be" in "better" matches backend keyword
+- Frontend file pattern `/\.(tsx?|jsx?)$/` also matches plain `.ts` files (known behavior)
+- Confidence scoring caps at 0.95 regardless of keyword count
+
+### Test Plan
+
+#### For QA
+1. Run `bun test core/__tests__/agentic/smart-context.test.ts` - all 57 tests pass
+2. Run `bun test` - full suite passes (368 tests)
+
+#### For Users
+- No user-facing changes (test coverage improvement)
+
+
 ## [0.63.0] - 2026-02-05
 
 ### Features

package/core/__tests__/agentic/smart-context.test.ts

@@ -0,0 +1,372 @@
+/**
+ * Smart Context Tests
+ * PRJ-84: Unit tests for smart-context.ts
+ */
+
+import { describe, expect, it } from 'bun:test'
+import smartContext, { SmartContext } from '../../agentic/smart-context'
+import type { ContextDomain, TaskType } from '../../types'
+
+describe('SmartContext PRJ-84', () => {
+  describe('detectDomain', () => {
+    describe('frontend detection', () => {
+      it('should detect frontend from UI keywords', () => {
+        const result = smartContext.detectDomain('Add a new button component')
+        expect(result.primary).toBe('frontend')
+        expect(result.confidence).toBeGreaterThan(0.5)
+      })
+
+      it('should detect frontend from React keywords', () => {
+        const result = smartContext.detectDomain('Create React component for user profile')
+        expect(result.primary).toBe('frontend')
+      })
+
+      it('should detect frontend from styling keywords', () => {
+        const result = smartContext.detectDomain('Fix CSS layout for responsive design')
+        expect(result.primary).toBe('frontend')
+      })
+
+      it('should detect frontend from TSX/JSX keywords', () => {
+        const result = smartContext.detectDomain('Update tsx file for modal animation')
+        expect(result.primary).toBe('frontend')
+      })
+    })
+
+    describe('backend detection', () => {
+      it('should detect backend from API keywords', () => {
+        const result = smartContext.detectDomain('Create new API endpoint for users')
+        expect(result.primary).toBe('backend')
+        expect(result.confidence).toBeGreaterThan(0.5)
+      })
+
+      it('should detect backend from database keywords', () => {
+        const result = smartContext.detectDomain('Add database query for orders')
+        expect(result.primary).toBe('backend')
+      })
+
+      it('should detect backend from service keywords', () => {
+        const result = smartContext.detectDomain('Implement auth service handler')
+        expect(result.primary).toBe('backend')
+      })
+
+      it('should detect backend from GraphQL keywords', () => {
+        const result = smartContext.detectDomain('Add GraphQL resolver for products')
+        expect(result.primary).toBe('backend')
+      })
+    })
+
+    describe('devops detection', () => {
+      it('should detect devops from Docker keywords', () => {
+        const result = smartContext.detectDomain('Create Docker container for deployment')
+        expect(result.primary).toBe('devops')
+        expect(result.confidence).toBeGreaterThan(0.5)
+      })
+
+      it('should detect devops from Kubernetes keywords', () => {
+        const result = smartContext.detectDomain('Update k8s deployment configuration')
+        expect(result.primary).toBe('devops')
+      })
+
+      it('should detect devops from CI/CD keywords', () => {
+        const result = smartContext.detectDomain('Fix CI pipeline for build process')
+        expect(result.primary).toBe('devops')
+      })
+
+      it('should detect devops from infrastructure keywords', () => {
+        const result = smartContext.detectDomain('Configure AWS infrastructure with terraform')
+        expect(result.primary).toBe('devops')
+      })
+    })
+
+    describe('docs detection', () => {
+      it('should detect docs from documentation keywords', () => {
+        // Note: "documentation" alone triggers docs domain
+        const result = smartContext.detectDomain('Update documentation for users')
+        expect(result.primary).toBe('docs')
+        expect(result.confidence).toBeGreaterThan(0.5)
+      })
+
+      it('should detect docs from README keywords', () => {
+        const result = smartContext.detectDomain('Add readme section for installation')
+        expect(result.primary).toBe('docs')
+      })
+
+      it('should detect docs from changelog keywords', () => {
+        const result = smartContext.detectDomain('Update changelog for new release')
+        expect(result.primary).toBe('docs')
+      })
+
+      it('should detect docs from jsdoc keywords', () => {
+        const result = smartContext.detectDomain('Add jsdoc comments to functions')
+        expect(result.primary).toBe('docs')
+      })
+    })
+
+    describe('testing detection', () => {
+      it('should detect testing from test keywords', () => {
+        const result = smartContext.detectDomain('Add unit test for user service')
+        expect(result.primary).toBe('testing')
+        expect(result.confidence).toBeGreaterThan(0.5)
+      })
+
+      it('should detect testing from Jest keywords', () => {
+        const result = smartContext.detectDomain('Write jest spec for validation')
+        expect(result.primary).toBe('testing')
+      })
+
+      it('should detect testing from e2e keywords', () => {
+        const result = smartContext.detectDomain('Add e2e integration tests')
+        expect(result.primary).toBe('testing')
+      })
+
+      it('should detect testing from coverage keywords', () => {
+        const result = smartContext.detectDomain('Improve test coverage for auth module')
+        expect(result.primary).toBe('testing')
+      })
+
+      it('should detect testing from mock/fixture keywords', () => {
+        const result = smartContext.detectDomain('Create mock fixtures for API tests')
+        expect(result.primary).toBe('testing')
+      })
+    })
+
+    describe('general/fallback detection', () => {
+      it('should return general for ambiguous tasks', () => {
+        const result = smartContext.detectDomain('Refactor code')
+        expect(result.primary).toBe('general')
+        expect(result.confidence).toBe(0.5)
+      })
+
+      it('should return general for empty descriptions', () => {
+        const result = smartContext.detectDomain('')
+        expect(result.primary).toBe('general')
+      })
+
+      it('should return general for non-technical descriptions', () => {
+        // Note: "be" in "better" matches backend keyword, so use different text
+        const result = smartContext.detectDomain('Improve this somehow')
+        expect(result.primary).toBe('general')
+      })
+    })
+
+    describe('secondary domains', () => {
+      it('should detect secondary domains for mixed tasks', () => {
+        const result = smartContext.detectDomain('Add API endpoint with React frontend component')
+        expect(result.primary).toBeDefined()
+        expect(result.secondary.length).toBeGreaterThan(0)
+      })
+
+      it('should limit secondary domains to max 2', () => {
+        const result = smartContext.detectDomain(
+          'Add API endpoint with React component and Docker deploy with test coverage'
+        )
+        expect(result.secondary.length).toBeLessThanOrEqual(2)
+      })
+    })
+
+    describe('confidence scoring', () => {
+      it('should have higher confidence for strong domain signals', () => {
+        const strong = smartContext.detectDomain('Create React component with jsx tsx ui')
+        const weak = smartContext.detectDomain('Fix bug in component')
+        // Strong has multiple matching keywords, weak has fewer
+        expect(strong.confidence).toBeGreaterThanOrEqual(weak.confidence)
+      })
+
+      it('should cap confidence at 0.95', () => {
+        const result = smartContext.detectDomain(
+          'ui component react vue angular css style button form modal layout responsive animation dom html frontend jsx tsx'
+        )
+        expect(result.confidence).toBeLessThanOrEqual(0.95)
+      })
+    })
+  })
+
+  describe('filterFiles', () => {
+    const testFiles = [
+      'src/components/Button.tsx',
+      'src/components/Modal.jsx',
+      'src/api/users.ts',
+      'src/services/auth.ts',
+      'src/models/User.ts',
+      'docker/Dockerfile',
+      '.github/workflows/ci.yml',
+      'deploy/k8s/deployment.yaml',
+      'docs/README.md',
+      'docs/api.md',
+      'tests/unit/auth.test.ts',
+      '__tests__/components/Button.test.tsx',
+      'package.json',
+      'tsconfig.json',
+      'vite.config.ts',
+    ]
+
+    // Access private method via class instance
+    const smartContextInstance = new SmartContext()
+    const filterFiles = (files: string[], domain: ContextDomain) => {
+      // @ts-expect-error - accessing private method for testing
+      return smartContextInstance.filterFiles(files, domain)
+    }
+
+    describe('frontend filtering', () => {
+      it('should include component files', () => {
+        const result = filterFiles(testFiles, 'frontend')
+        expect(result).toContain('src/components/Button.tsx')
+        expect(result).toContain('src/components/Modal.jsx')
+      })
+
+      it('should include config files', () => {
+        const result = filterFiles(testFiles, 'frontend')
+        expect(result).toContain('package.json')
+        expect(result).toContain('tsconfig.json')
+      })
+
+      it('should exclude non-code files', () => {
+        const result = filterFiles(testFiles, 'frontend')
+        // Note: .ts files match frontend pattern /\.(tsx?|jsx?)$/ because tsx? = ts or tsx
+        // So backend .ts files are included - this is a known quirk
+        expect(result).not.toContain('docker/Dockerfile')
+        expect(result).not.toContain('docs/README.md')
+      })
+    })
+
+    describe('backend filtering', () => {
+      it('should include API and service files', () => {
+        const result = filterFiles(testFiles, 'backend')
+        expect(result).toContain('src/api/users.ts')
+        expect(result).toContain('src/services/auth.ts')
+        expect(result).toContain('src/models/User.ts')
+      })
+
+      it('should include config files', () => {
+        const result = filterFiles(testFiles, 'backend')
+        expect(result).toContain('package.json')
+      })
+    })
+
+    describe('devops filtering', () => {
+      it('should include Docker and CI files', () => {
+        const result = filterFiles(testFiles, 'devops')
+        expect(result).toContain('docker/Dockerfile')
+        expect(result).toContain('.github/workflows/ci.yml')
+        expect(result).toContain('deploy/k8s/deployment.yaml')
+      })
+    })
+
+    describe('docs filtering', () => {
+      it('should include markdown files', () => {
+        const result = filterFiles(testFiles, 'docs')
+        expect(result).toContain('docs/README.md')
+        expect(result).toContain('docs/api.md')
+      })
+    })
+
+    describe('testing filtering', () => {
+      it('should include test files', () => {
+        const result = filterFiles(testFiles, 'testing')
+        expect(result).toContain('tests/unit/auth.test.ts')
+        expect(result).toContain('__tests__/components/Button.test.tsx')
+      })
+    })
+
+    describe('general filtering', () => {
+      it('should return all files for general domain', () => {
+        const result = filterFiles(testFiles, 'general')
+        expect(result).toEqual(testFiles)
+      })
+    })
+  })
+
+  describe('estimateSize', () => {
+    // @ts-expect-error - accessing private method for testing
+    const estimateSize = smartContext.estimateSize.bind(smartContext)
+
+    it('should return minimum 100 for empty context', () => {
+      const result = estimateSize({})
+      expect(result).toBe(100)
+    })
+
+    it('should estimate agents at ~50 tokens each', () => {
+      const result = estimateSize({ agents: [{}, {}, {}] })
+      expect(result).toBe(150) // 3 * 50
+    })
+
+    it('should estimate roadmap items at ~50 tokens each', () => {
+      const result = estimateSize({ roadmap: [{}, {}] })
+      expect(result).toBe(100) // 2 * 50
+    })
+
+    it('should estimate patterns at ~30 tokens each', () => {
+      const result = estimateSize({ patterns: [{}, {}, {}, {}] })
+      expect(result).toBe(120) // 4 * 30
+    })
+
+    it('should estimate stack at 100 tokens', () => {
+      const result = estimateSize({ stack: {} })
+      expect(result).toBe(100)
+    })
+
+    it('should estimate files at ~10 tokens each', () => {
+      const result = estimateSize({ files: ['a', 'b', 'c', 'd', 'e'] })
+      expect(result).toBe(100) // 5 * 10 = 50, min 100
+    })
+
+    it('should estimate state at 200 tokens', () => {
+      const result = estimateSize({ state: {} })
+      expect(result).toBe(200)
+    })
+
+    it('should combine all estimates', () => {
+      const result = estimateSize({
+        agents: [{}, {}], // 100
+        roadmap: [{}], // 50
+        patterns: [{}], // 30
+        stack: {}, // 100
+        files: ['a'], // 10
+        state: {}, // 200
+      })
+      expect(result).toBe(490)
+    })
+  })
+
+  describe('taskTypeToContextDomain', () => {
+    const testCases: Array<{ input: TaskType; expected: ContextDomain }> = [
+      { input: 'frontend', expected: 'frontend' },
+      { input: 'backend', expected: 'backend' },
+      { input: 'devops', expected: 'devops' },
+      { input: 'database', expected: 'backend' },
+      { input: 'testing', expected: 'testing' },
+      { input: 'documentation', expected: 'docs' },
+      { input: 'refactoring', expected: 'general' },
+      { input: 'bugfix', expected: 'general' },
+      { input: 'feature', expected: 'general' },
+      { input: 'design', expected: 'frontend' },
+      { input: 'other', expected: 'general' },
+    ]
+
+    for (const { input, expected } of testCases) {
+      it(`should map ${input} to ${expected}`, () => {
+        expect(smartContext.taskTypeToContextDomain(input)).toBe(expected)
+      })
+    }
+  })
+
+  describe('contextDomainToTaskType (via getRecommendedContext)', () => {
+    // Test the private method indirectly through detectDomain verification
+    it('should have consistent bidirectional mapping for core domains', () => {
+      // Frontend maps to frontend
+      const frontendResult = smartContext.detectDomain('Create React component')
+      expect(frontendResult.primary).toBe('frontend')
+      expect(smartContext.taskTypeToContextDomain('frontend')).toBe('frontend')
+
+      // Backend maps to backend
+      const backendResult = smartContext.detectDomain('Add API endpoint')
+      expect(backendResult.primary).toBe('backend')
+      expect(smartContext.taskTypeToContextDomain('backend')).toBe('backend')
+
+      // Testing maps to testing
+      const testingResult = smartContext.detectDomain('Add unit test')
+      expect(testingResult.primary).toBe('testing')
+      expect(smartContext.taskTypeToContextDomain('testing')).toBe('testing')
+    })
+  })
+})