prjct-cli 1.21.0 → 1.23.0

package/core/__tests__/agentic/domain-classifier.test.ts

@@ -1,330 +0,0 @@
-/**
- * Domain Classifier Tests
- * PRJ-299: LLM-based domain classification with fallback chain
- */
-
-import { describe, expect, it } from 'bun:test'
-import {
-  classifyWithHeuristic,
-  hashDescription,
-  type ProjectContext,
-} from '../../agentic/domain-classifier'
-
-// Default project context for testing (all domains available)
-const fullContext: ProjectContext = {
-  domains: {
-    hasFrontend: true,
-    hasBackend: true,
-    hasDatabase: true,
-    hasTesting: true,
-    hasDocker: true,
-  },
-  agents: ['frontend', 'backend', 'database', 'testing', 'devops'],
-  stack: { language: 'TypeScript', framework: 'Hono' },
-}
-
-// Backend-only project context
-const backendOnlyContext: ProjectContext = {
-  domains: {
-    hasFrontend: false,
-    hasBackend: true,
-    hasDatabase: false,
-    hasTesting: false,
-    hasDocker: false,
-  },
-  agents: ['backend'],
-  stack: { language: 'TypeScript', framework: 'Hono' },
-}
-
-describe('DomainClassifier PRJ-299', () => {
-  describe('classifyWithHeuristic', () => {
-    // =================================================================
-    // Substring Trap Tests (the whole reason for PRJ-299)
-    // =================================================================
-    describe('substring traps (critical fixes)', () => {
-      it('should NOT match "author" to "auth" domain', () => {
-        const result = classifyWithHeuristic('Fix the author display on profile page', fullContext)
-        // "author" should NOT trigger backend (auth)
-        // "profile page" and "display" should trigger frontend
-        expect(result.primaryDomain).not.toBe('backend')
-        expect(result.primaryDomain).toBe('frontend')
-      })
-
-      it('should match standalone "auth" to backend', () => {
-        const result = classifyWithHeuristic(
-          'Fix the auth middleware for JWT validation',
-          fullContext
-        )
-        expect(result.primaryDomain).toBe('backend')
-      })
-
-      it('should NOT match "testament" to "test" domain', () => {
-        const result = classifyWithHeuristic(
-          'Update the testament of the old testament module',
-          fullContext
-        )
-        expect(result.primaryDomain).not.toBe('testing')
-      })
-
-      it('should NOT match "button" to "but" in other domains', () => {
-        const result = classifyWithHeuristic('Add a button component', fullContext)
-        expect(result.primaryDomain).toBe('frontend')
-      })
-
-      it('should NOT match "configure" to "config" in devops', () => {
-        // "configure" without a devops context word should not go to devops
-        const result = classifyWithHeuristic('Configure the React component props', fullContext)
-        expect(result.primaryDomain).toBe('frontend')
-      })
-    })
-
-    // =================================================================
-    // Correct Classification Tests
-    // =================================================================
-    describe('frontend detection', () => {
-      it('should detect "Build responsive dashboard" as frontend', () => {
-        const result = classifyWithHeuristic('Build responsive dashboard', fullContext)
-        expect(result.primaryDomain).toBe('frontend')
-      })
-
-      it('should detect React component tasks', () => {
-        const result = classifyWithHeuristic('Create a modal dialog for user settings', fullContext)
-        expect(result.primaryDomain).toBe('frontend')
-      })
-
-      it('should detect CSS/styling tasks', () => {
-        const result = classifyWithHeuristic(
-          'Fix the layout for mobile responsive view',
-          fullContext
-        )
-        expect(result.primaryDomain).toBe('frontend')
-      })
-
-      it('should detect page/navigation tasks', () => {
-        const result = classifyWithHeuristic(
-          'Add sidebar navigation with dropdown menus',
-          fullContext
-        )
-        expect(result.primaryDomain).toBe('frontend')
-      })
-    })
-
-    describe('backend detection', () => {
-      it('should detect API endpoint tasks', () => {
-        const result = classifyWithHeuristic(
-          'Create REST API endpoint for user management',
-          fullContext
-        )
-        expect(result.primaryDomain).toBe('backend')
-      })
-
-      it('should detect middleware tasks', () => {
-        const result = classifyWithHeuristic('Add rate limiting middleware', fullContext)
-        expect(result.primaryDomain).toBe('backend')
-      })
-
-      it('should detect authentication tasks', () => {
-        const result = classifyWithHeuristic('Implement JWT authentication flow', fullContext)
-        expect(result.primaryDomain).toBe('backend')
-      })
-    })
-
-    describe('database detection', () => {
-      it('should detect schema/migration tasks', () => {
-        const result = classifyWithHeuristic(
-          'Create database migration for users table',
-          fullContext
-        )
-        expect(result.primaryDomain).toBe('database')
-      })
-
-      it('should detect connection pooling as database (not schema)', () => {
-        const result = classifyWithHeuristic('Optimize database connection pooling', fullContext)
-        expect(result.primaryDomain).toBe('database')
-      })
-
-      it('should detect ORM/Prisma tasks', () => {
-        const result = classifyWithHeuristic('Update Prisma schema with new entity', fullContext)
-        expect(result.primaryDomain).toBe('database')
-      })
-    })
-
-    describe('devops detection', () => {
-      it('should detect Docker tasks', () => {
-        const result = classifyWithHeuristic(
-          'Create Docker container for production deployment',
-          fullContext
-        )
-        expect(result.primaryDomain).toBe('devops')
-      })
-
-      it('should detect CI/CD tasks', () => {
-        const result = classifyWithHeuristic(
-          'Fix the CI pipeline for automated deployment',
-          fullContext
-        )
-        expect(result.primaryDomain).toBe('devops')
-      })
-    })
-
-    describe('testing detection', () => {
-      it('should detect test writing tasks', () => {
-        const result = classifyWithHeuristic('Add unit tests for the payment service', fullContext)
-        expect(result.primaryDomain).toBe('testing')
-      })
-
-      it('should detect coverage improvement tasks', () => {
-        const result = classifyWithHeuristic('Improve test coverage for auth module', fullContext)
-        expect(result.primaryDomain).toBe('testing')
-      })
-    })
-
-    // =================================================================
-    // Multi-domain Tasks
-    // =================================================================
-    describe('multi-domain tasks', () => {
-      it('should detect secondary domains', () => {
-        const result = classifyWithHeuristic(
-          'Add API endpoint with React frontend component',
-          fullContext
-        )
-        expect(result.secondaryDomains.length).toBeGreaterThan(0)
-      })
-
-      it('should limit secondary domains to 2', () => {
-        const result = classifyWithHeuristic(
-          'Add API endpoint with React component and Docker deploy with test coverage and database migration',
-          fullContext
-        )
-        expect(result.secondaryDomains.length).toBeLessThanOrEqual(2)
-      })
-    })
-
-    // =================================================================
-    // Project Context Filtering
-    // =================================================================
-    describe('project context filtering', () => {
-      it('should not classify as frontend when project has no frontend', () => {
-        const result = classifyWithHeuristic(
-          'Add a button component with responsive layout',
-          backendOnlyContext
-        )
-        // Can't be frontend since project doesn't have it
-        // Falls through to general or docs (always available)
-        expect(result.primaryDomain).not.toBe('frontend')
-      })
-
-      it('should respect available agents', () => {
-        const result = classifyWithHeuristic('Create REST API endpoint', backendOnlyContext)
-        expect(result.primaryDomain).toBe('backend')
-      })
-    })
-
-    // =================================================================
-    // Confidence Scoring
-    // =================================================================
-    describe('confidence scoring', () => {
-      it('should have higher confidence for strong signals than multi-domain', () => {
-        // Single-domain (strong frontend signal) vs multi-domain (split between frontend and backend)
-        const strong = classifyWithHeuristic(
-          'Create React component with jsx tsx ui button form modal',
-          fullContext
-        )
-        const split = classifyWithHeuristic(
-          'Add API endpoint with React component and database query',
-          fullContext
-        )
-        expect(strong.confidence).toBeGreaterThanOrEqual(split.confidence)
-      })
-
-      it('should cap confidence at 0.85 for heuristic', () => {
-        const result = classifyWithHeuristic(
-          'ui component react vue angular css style button form modal layout responsive animation',
-          fullContext
-        )
-        expect(result.confidence).toBeLessThanOrEqual(0.85)
-      })
-
-      it('should return 0.3 confidence for unknown domains', () => {
-        const result = classifyWithHeuristic(
-          'Do something completely unrelated to any domain',
-          fullContext
-        )
-        expect(result.confidence).toBe(0.3)
-        expect(result.primaryDomain).toBe('general')
-      })
-    })
-
-    // =================================================================
-    // Edge Cases
-    // =================================================================
-    describe('edge cases', () => {
-      it('should handle empty description', () => {
-        const result = classifyWithHeuristic('', fullContext)
-        expect(result.primaryDomain).toBe('general')
-        expect(result.confidence).toBe(0.3)
-      })
-
-      it('should handle very long descriptions', () => {
-        const longDesc = 'Fix the bug in the component '.repeat(100)
-        const result = classifyWithHeuristic(longDesc, fullContext)
-        expect(result.primaryDomain).toBeDefined()
-      })
-
-      it('should be case-insensitive', () => {
-        const lower = classifyWithHeuristic('add react component', fullContext)
-        const upper = classifyWithHeuristic('ADD REACT COMPONENT', fullContext)
-        expect(lower.primaryDomain).toBe(upper.primaryDomain)
-      })
-    })
-  })
-
-  // =================================================================
-  // Hash Function
-  // =================================================================
-  describe('hashDescription', () => {
-    it('should produce consistent hashes', () => {
-      const hash1 = hashDescription('Fix the auth middleware')
-      const hash2 = hashDescription('Fix the auth middleware')
-      expect(hash1).toBe(hash2)
-    })
-
-    it('should be case-insensitive', () => {
-      const hash1 = hashDescription('Fix the Auth Middleware')
-      const hash2 = hashDescription('fix the auth middleware')
-      expect(hash1).toBe(hash2)
-    })
-
-    it('should trim whitespace', () => {
-      const hash1 = hashDescription('  Fix the auth middleware  ')
-      const hash2 = hashDescription('Fix the auth middleware')
-      expect(hash1).toBe(hash2)
-    })
-
-    it('should produce different hashes for different descriptions', () => {
-      const hash1 = hashDescription('Fix frontend component')
-      const hash2 = hashDescription('Fix backend service')
-      expect(hash1).not.toBe(hash2)
-    })
-
-    it('should return a 16-character hex string', () => {
-      const hash = hashDescription('Test description')
-      expect(hash).toMatch(/^[a-f0-9]{16}$/)
-    })
-  })
-
-  // =================================================================
-  // File Patterns
-  // =================================================================
-  describe('file patterns', () => {
-    it('should return frontend file patterns for frontend domain', () => {
-      const result = classifyWithHeuristic('Add React component', fullContext)
-      expect(result.filePatterns.length).toBeGreaterThan(0)
-    })
-
-    it('should return relevant agents', () => {
-      const result = classifyWithHeuristic('Create REST API endpoint', fullContext)
-      expect(result.relevantAgents).toContain('backend')
-    })
-  })
-})

package/core/__tests__/agentic/injection-validator.test.ts

@@ -1,255 +0,0 @@
-/**
- * Injection Validator Tests
- * Tests for safeInject, truncation, skill filtering, and budget tracking.
- */
-
-import { describe, expect, it } from 'bun:test'
-import { z } from 'zod'
-import {
-  DEFAULT_BUDGETS,
-  estimateTokens,
-  filterSkillsByDomains,
-  InjectionBudgetTracker,
-  safeInject,
-  safeInjectString,
-  truncateToTokenBudget,
-} from '../../agentic/injection-validator'
-
-// =============================================================================
-// safeInject
-// =============================================================================
-
-describe('safeInject', () => {
-  const schema = z.object({ name: z.string(), value: z.number() })
-  const fallback = { name: 'unknown', value: 0 }
-
-  it('returns validated data on valid input', () => {
-    const data = { name: 'test', value: 42 }
-    expect(safeInject(data, schema, fallback)).toEqual(data)
-  })
-
-  it('returns fallback on invalid input', () => {
-    const data = { name: 123, value: 'bad' }
-    expect(safeInject(data, schema, fallback)).toEqual(fallback)
-  })
-
-  it('returns fallback on null input', () => {
-    expect(safeInject(null, schema, fallback)).toEqual(fallback)
-  })
-
-  it('returns fallback on undefined input', () => {
-    expect(safeInject(undefined, schema, fallback)).toEqual(fallback)
-  })
-
-  it('strips extra fields via Zod', () => {
-    const data = { name: 'test', value: 42, extra: 'ignored' }
-    const result = safeInject(data, schema, fallback)
-    expect(result.name).toBe('test')
-    expect(result.value).toBe(42)
-  })
-})
-
-// =============================================================================
-// safeInjectString
-// =============================================================================
-
-describe('safeInjectString', () => {
-  const schema = z.object({ count: z.number() })
-  const formatter = (d: { count: number }) => `Items: ${d.count}`
-
-  it('returns formatted string on valid input', () => {
-    expect(safeInjectString({ count: 5 }, schema, formatter, 'N/A')).toBe('Items: 5')
-  })
-
-  it('returns fallback string on invalid input', () => {
-    expect(safeInjectString({ count: 'bad' }, schema, formatter, 'N/A')).toBe('N/A')
-  })
-
-  it('returns fallback string on null', () => {
-    expect(safeInjectString(null, schema, formatter, 'no data')).toBe('no data')
-  })
-})
-
-// =============================================================================
-// truncateToTokenBudget
-// =============================================================================
-
-describe('truncateToTokenBudget', () => {
-  it('returns text unchanged if within budget', () => {
-    const text = 'short text'
-    expect(truncateToTokenBudget(text, 100)).toBe(text)
-  })
-
-  it('truncates text that exceeds budget', () => {
-    const text = 'a'.repeat(500) // 500 chars = ~125 tokens
-    const result = truncateToTokenBudget(text, 50) // 50 tokens = 200 chars
-    expect(result.length).toBeLessThan(500)
-    expect(result).toContain('truncated')
-    expect(result).toContain('~50 tokens')
-  })
-
-  it('truncates to exact char limit', () => {
-    const text = 'a'.repeat(100)
-    const result = truncateToTokenBudget(text, 10) // 10 tokens = 40 chars
-    expect(result.startsWith('a'.repeat(40))).toBe(true)
-  })
-
-  it('handles empty string', () => {
-    expect(truncateToTokenBudget('', 100)).toBe('')
-  })
-
-  it('handles zero budget', () => {
-    const result = truncateToTokenBudget('some text', 0)
-    expect(result).toContain('truncated')
-  })
-})
-
-// =============================================================================
-// estimateTokens
-// =============================================================================
-
-describe('estimateTokens', () => {
-  it('estimates tokens at ~4 chars per token', () => {
-    expect(estimateTokens('a'.repeat(100))).toBe(25)
-  })
-
-  it('rounds up partial tokens', () => {
-    expect(estimateTokens('abc')).toBe(1) // 3/4 = 0.75, ceil = 1
-  })
-
-  it('handles empty string', () => {
-    expect(estimateTokens('')).toBe(0)
-  })
-})
-
-// =============================================================================
-// filterSkillsByDomains
-// =============================================================================
-
-describe('filterSkillsByDomains', () => {
-  const skills = [
-    { name: 'react-patterns', content: 'React component patterns and hooks' },
-    { name: 'api-design', content: 'RESTful API design and endpoint patterns' },
-    { name: 'jest-testing', content: 'Jest test patterns and assertions' },
-    { name: 'docker-deploy', content: 'Docker and Kubernetes deployment' },
-    { name: 'general-coding', content: 'General coding best practices' },
-  ]
-
-  it('returns all skills when no domains detected', () => {
-    expect(filterSkillsByDomains(skills, [])).toEqual(skills)
-  })
-
-  it('returns all skills when skills array is empty', () => {
-    expect(filterSkillsByDomains([], ['frontend'])).toEqual([])
-  })
-
-  it('filters to frontend-relevant skills', () => {
-    const result = filterSkillsByDomains(skills, ['frontend'])
-    expect(result.some((s) => s.name === 'react-patterns')).toBe(true)
-    expect(result.some((s) => s.name === 'docker-deploy')).toBe(false)
-  })
-
-  it('filters to backend-relevant skills', () => {
-    const result = filterSkillsByDomains(skills, ['backend'])
-    expect(result.some((s) => s.name === 'api-design')).toBe(true)
-    expect(result.some((s) => s.name === 'react-patterns')).toBe(false)
-  })
-
-  it('filters to testing-relevant skills', () => {
-    const result = filterSkillsByDomains(skills, ['testing'])
-    expect(result.some((s) => s.name === 'jest-testing')).toBe(true)
-  })
-
-  it('supports multiple domains', () => {
-    const result = filterSkillsByDomains(skills, ['frontend', 'testing'])
-    expect(result.some((s) => s.name === 'react-patterns')).toBe(true)
-    expect(result.some((s) => s.name === 'jest-testing')).toBe(true)
-    expect(result.some((s) => s.name === 'docker-deploy')).toBe(false)
-  })
-
-  it('matches domain name itself as keyword', () => {
-    const customSkills = [{ name: 'devops-helper', content: 'general devops tools' }]
-    const result = filterSkillsByDomains(customSkills, ['devops'])
-    expect(result).toHaveLength(1)
-  })
-
-  it('is case insensitive', () => {
-    const result = filterSkillsByDomains(skills, ['Frontend'])
-    expect(result.some((s) => s.name === 'react-patterns')).toBe(true)
-  })
-})
-
-// =============================================================================
-// InjectionBudgetTracker
-// =============================================================================
-
-describe('InjectionBudgetTracker', () => {
-  it('tracks cumulative token usage', () => {
-    const tracker = new InjectionBudgetTracker({ totalPrompt: 100 })
-    tracker.addSection('a'.repeat(200), 100) // 200 chars = 50 tokens
-    expect(tracker.totalUsed).toBe(50)
-    expect(tracker.remaining).toBe(50)
-  })
-
-  it('truncates sections to per-section budget', () => {
-    const tracker = new InjectionBudgetTracker({ totalPrompt: 1000 })
-    const result = tracker.addSection('a'.repeat(500), 50) // budget: 50 tokens = 200 chars
-    expect(result.length).toBeLessThan(500)
-  })
-
-  it('returns empty string when total budget exhausted', () => {
-    const tracker = new InjectionBudgetTracker({ totalPrompt: 10 })
-    tracker.addSection('a'.repeat(100), 50) // uses all 10 tokens of total budget
-    const result = tracker.addSection('more content', 50)
-    expect(result).toBe('')
-  })
-
-  it('fits content to remaining total budget', () => {
-    const tracker = new InjectionBudgetTracker({ totalPrompt: 30 })
-    tracker.addSection('a'.repeat(80), 30) // 80 chars = 20 tokens
-    // Remaining: 10 tokens
-    const result = tracker.addSection('b'.repeat(200), 100) // wants 100 tokens, only 10 left
-    expect(result.length).toBeLessThan(200)
-    expect(tracker.remaining).toBe(0)
-  })
-
-  it('uses default budgets when none provided', () => {
-    const tracker = new InjectionBudgetTracker()
-    expect(tracker.config.totalPrompt).toBe(DEFAULT_BUDGETS.totalPrompt)
-    expect(tracker.config.autoContext).toBe(DEFAULT_BUDGETS.autoContext)
-  })
-
-  it('allows partial budget overrides', () => {
-    const tracker = new InjectionBudgetTracker({ totalPrompt: 5000 })
-    expect(tracker.config.totalPrompt).toBe(5000)
-    expect(tracker.config.autoContext).toBe(DEFAULT_BUDGETS.autoContext) // unchanged
-  })
-
-  it('remaining never goes negative', () => {
-    const tracker = new InjectionBudgetTracker({ totalPrompt: 5 })
-    tracker.addSection('a'.repeat(1000), 500)
-    expect(tracker.remaining).toBe(0)
-  })
-})
-
-// =============================================================================
-// DEFAULT_BUDGETS
-// =============================================================================
-
-describe('DEFAULT_BUDGETS', () => {
-  it('has all required fields', () => {
-    expect(DEFAULT_BUDGETS.autoContext).toBeGreaterThan(0)
-    expect(DEFAULT_BUDGETS.agentContent).toBeGreaterThan(0)
-    expect(DEFAULT_BUDGETS.skillContent).toBeGreaterThan(0)
-    expect(DEFAULT_BUDGETS.stateData).toBeGreaterThan(0)
-    expect(DEFAULT_BUDGETS.memories).toBeGreaterThan(0)
-    expect(DEFAULT_BUDGETS.totalPrompt).toBeGreaterThan(0)
-  })
-
-  it('totalPrompt is larger than individual budgets', () => {
-    expect(DEFAULT_BUDGETS.totalPrompt).toBeGreaterThan(DEFAULT_BUDGETS.autoContext)
-    expect(DEFAULT_BUDGETS.totalPrompt).toBeGreaterThan(DEFAULT_BUDGETS.agentContent)
-    expect(DEFAULT_BUDGETS.totalPrompt).toBeGreaterThan(DEFAULT_BUDGETS.skillContent)
-    expect(DEFAULT_BUDGETS.totalPrompt).toBeGreaterThan(DEFAULT_BUDGETS.stateData)
-  })
-})