prjct-cli 1.21.0 → 1.23.0

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

@@ -1,372 +0,0 @@
-/**
- * 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.3)
-      })
-
-      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.85', () => {
-        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.85)
-      })
-    })
-  })
-
-  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')
-    })
-  })
-})

package/core/__tests__/agentic/tech-normalizer.test.ts

@@ -1,136 +0,0 @@
-import { describe, expect, it } from 'bun:test'
-import {
-  deduplicateTechStack,
-  extractTechNames,
-  getFrameworkFamily,
-  matchesTech,
-  normalizeFrameworkName,
-} from '../../agentic/tech-normalizer'
-
-describe('tech-normalizer', () => {
-  describe('normalizeFrameworkName', () => {
-    it('should lowercase and trim', () => {
-      expect(normalizeFrameworkName('  TypeScript ')).toBe('typescript')
-      expect(normalizeFrameworkName('React')).toBe('react')
-    })
-
-    it('should resolve aliases', () => {
-      expect(normalizeFrameworkName('NodeJS')).toBe('node')
-      expect(normalizeFrameworkName('ts')).toBe('typescript')
-      expect(normalizeFrameworkName('js')).toBe('javascript')
-      expect(normalizeFrameworkName('pg')).toBe('postgres')
-      expect(normalizeFrameworkName('postgresql')).toBe('postgres')
-    })
-
-    it('should preserve dotted names', () => {
-      expect(normalizeFrameworkName('Next.js')).toBe('next.js')
-      expect(normalizeFrameworkName('Vue.js')).toBe('vue')
-    })
-
-    it('should handle nextjs alias', () => {
-      expect(normalizeFrameworkName('nextjs')).toBe('next.js')
-      expect(normalizeFrameworkName('nuxtjs')).toBe('nuxt.js')
-    })
-  })
-
-  describe('extractTechNames', () => {
-    it('should split on + separator', () => {
-      expect(extractTechNames('React + TypeScript')).toEqual(['react', 'typescript'])
-    })
-
-    it('should extract from parentheses', () => {
-      expect(extractTechNames('Next.js (React)')).toEqual(['next.js', 'react'])
-    })
-
-    it('should split on "with"', () => {
-      expect(extractTechNames('Hono with Zod')).toEqual(['hono', 'zod'])
-    })
-
-    it('should split on commas', () => {
-      expect(extractTechNames('React, Vue, Angular')).toEqual(['react', 'vue', 'angular'])
-    })
-
-    it('should handle single name', () => {
-      expect(extractTechNames('React')).toEqual(['react'])
-    })
-  })
-
-  describe('getFrameworkFamily', () => {
-    it('should resolve meta-frameworks to base', () => {
-      expect(getFrameworkFamily('next.js')).toBe('react')
-      expect(getFrameworkFamily('Next.js')).toBe('react')
-      expect(getFrameworkFamily('Remix')).toBe('react')
-      expect(getFrameworkFamily('Gatsby')).toBe('react')
-    })
-
-    it('should resolve Vue meta-frameworks', () => {
-      expect(getFrameworkFamily('nuxt')).toBe('vue')
-      expect(getFrameworkFamily('Nuxt.js')).toBe('vue')
-    })
-
-    it('should resolve Svelte meta-framework', () => {
-      expect(getFrameworkFamily('SvelteKit')).toBe('svelte')
-    })
-
-    it('should return name itself for base frameworks', () => {
-      expect(getFrameworkFamily('React')).toBe('react')
-      expect(getFrameworkFamily('Express')).toBe('express')
-      expect(getFrameworkFamily('Hono')).toBe('hono')
-    })
-  })
-
-  describe('matchesTech', () => {
-    it('should match exact names (case-insensitive)', () => {
-      expect(matchesTech('React', 'react')).toBe(true)
-      expect(matchesTech('react', 'React')).toBe(true)
-    })
-
-    it('should match via framework family', () => {
-      expect(matchesTech('Next.js', 'react')).toBe(true)
-      expect(matchesTech('Nuxt', 'vue')).toBe(true)
-      expect(matchesTech('SvelteKit', 'svelte')).toBe(true)
-    })
-
-    it('should match compound names', () => {
-      expect(matchesTech('React + TypeScript', 'react')).toBe(true)
-      expect(matchesTech('React + TypeScript', 'typescript')).toBe(true)
-    })
-
-    it('should match parenthesized names', () => {
-      expect(matchesTech('Next.js (React)', 'react')).toBe(true)
-      expect(matchesTech('Next.js (React)', 'next.js')).toBe(true)
-    })
-
-    it('should not match unrelated frameworks', () => {
-      expect(matchesTech('Vue', 'react')).toBe(false)
-      expect(matchesTech('Angular', 'react')).toBe(false)
-    })
-  })
-
-  describe('deduplicateTechStack', () => {
-    it('should remove case-insensitive duplicates', () => {
-      expect(deduplicateTechStack(['React', 'react', 'REACT'])).toEqual(['React'])
-    })
-
-    it('should remove alias duplicates', () => {
-      expect(deduplicateTechStack(['TypeScript', 'ts'])).toEqual(['TypeScript'])
-      expect(deduplicateTechStack(['Node.js', 'nodejs'])).toEqual(['Node.js'])
-    })
-
-    it('should preserve unique entries', () => {
-      expect(deduplicateTechStack(['React', 'Next.js', 'TypeScript'])).toEqual([
-        'React',
-        'Next.js',
-        'TypeScript',
-      ])
-    })
-
-    it('should preserve first occurrence casing', () => {
-      expect(deduplicateTechStack(['Next.js', 'nextjs', 'NEXT.JS'])).toEqual(['Next.js'])
-    })
-
-    it('should handle empty array', () => {
-      expect(deduplicateTechStack([])).toEqual([])
-    })
-  })
-})