prjct-cli 1.7.5 → 1.9.0

package/core/__tests__/schemas/model.test.ts

@@ -0,0 +1,272 @@
+/**
+ * Model Schema Tests
+ *
+ * Tests for:
+ * - Provider model validation
+ * - Semver comparison
+ * - Minimum CLI version enforcement
+ * - Model mismatch detection
+ * - Default model resolution
+ * - Backwards compatibility (missing model field)
+ *
+ * @see PRJ-265
+ */
+
+import { describe, expect, it } from 'bun:test'
+import {
+  ClaudeProvider,
+  CursorProvider,
+  GeminiProvider,
+  validateCliVersion,
+} from '../../infrastructure/ai-provider'
+import {
+  checkModelMismatch,
+  compareSemver,
+  getDefaultModel,
+  getSupportedModels,
+  isValidModelForProvider,
+  type ModelMetadata,
+  meetsMinVersion,
+} from '../../schemas/model'
+
+// =============================================================================
+// Provider Model Configuration
+// =============================================================================
+
+describe('Provider model configuration', () => {
+  it('should have model fields on Claude provider', () => {
+    expect(ClaudeProvider.defaultModel).toBe('sonnet')
+    expect(ClaudeProvider.supportedModels).toEqual(['opus', 'sonnet', 'haiku'])
+    expect(ClaudeProvider.minCliVersion).toBe('1.0.0')
+  })
+
+  it('should have model fields on Gemini provider', () => {
+    expect(GeminiProvider.defaultModel).toBe('2.5-flash')
+    expect(GeminiProvider.supportedModels).toEqual(['2.5-pro', '2.5-flash', '2.0-flash'])
+    expect(GeminiProvider.minCliVersion).toBe('1.0.0')
+  })
+
+  it('should have null model fields on multi-model IDEs', () => {
+    expect(CursorProvider.defaultModel).toBeNull()
+    expect(CursorProvider.supportedModels).toEqual([])
+    expect(CursorProvider.minCliVersion).toBeNull()
+  })
+})
+
+// =============================================================================
+// Model Validation
+// =============================================================================
+
+describe('isValidModelForProvider', () => {
+  it('should accept valid Claude models', () => {
+    expect(isValidModelForProvider('claude', 'opus')).toBe(true)
+    expect(isValidModelForProvider('claude', 'sonnet')).toBe(true)
+    expect(isValidModelForProvider('claude', 'haiku')).toBe(true)
+  })
+
+  it('should reject invalid Claude models', () => {
+    expect(isValidModelForProvider('claude', 'gpt-4')).toBe(false)
+    expect(isValidModelForProvider('claude', 'unknown')).toBe(false)
+  })
+
+  it('should accept valid Gemini models', () => {
+    expect(isValidModelForProvider('gemini', '2.5-pro')).toBe(true)
+    expect(isValidModelForProvider('gemini', '2.5-flash')).toBe(true)
+    expect(isValidModelForProvider('gemini', '2.0-flash')).toBe(true)
+  })
+
+  it('should reject invalid Gemini models', () => {
+    expect(isValidModelForProvider('gemini', 'sonnet')).toBe(false)
+  })
+
+  it('should accept any model for multi-model IDEs (empty supportedModels)', () => {
+    expect(isValidModelForProvider('cursor', 'gpt-4')).toBe(true)
+    expect(isValidModelForProvider('cursor', 'anything')).toBe(true)
+    expect(isValidModelForProvider('windsurf', 'claude-sonnet')).toBe(true)
+  })
+
+  it('should accept any model for unknown providers', () => {
+    expect(isValidModelForProvider('future-provider', 'some-model')).toBe(true)
+  })
+})
+
+// =============================================================================
+// Default Model Resolution
+// =============================================================================
+
+describe('getDefaultModel', () => {
+  it('should return sonnet for Claude', () => {
+    expect(getDefaultModel('claude')).toBe('sonnet')
+  })
+
+  it('should return 2.5-flash for Gemini', () => {
+    expect(getDefaultModel('gemini')).toBe('2.5-flash')
+  })
+
+  it('should return null for providers without defaults', () => {
+    expect(getDefaultModel('cursor')).toBeNull()
+    expect(getDefaultModel('unknown')).toBeNull()
+  })
+})
+
+// =============================================================================
+// Supported Models
+// =============================================================================
+
+describe('getSupportedModels', () => {
+  it('should return Claude models', () => {
+    expect(getSupportedModels('claude')).toEqual(['opus', 'sonnet', 'haiku'])
+  })
+
+  it('should return empty for multi-model IDEs', () => {
+    expect(getSupportedModels('cursor')).toEqual([])
+  })
+
+  it('should return empty for unknown providers', () => {
+    expect(getSupportedModels('unknown')).toEqual([])
+  })
+})
+
+// =============================================================================
+// Semver Comparison
+// =============================================================================
+
+describe('compareSemver', () => {
+  it('should return 0 for equal versions', () => {
+    expect(compareSemver('1.0.0', '1.0.0')).toBe(0)
+    expect(compareSemver('2.3.4', '2.3.4')).toBe(0)
+  })
+
+  it('should return -1 when a < b', () => {
+    expect(compareSemver('1.0.0', '2.0.0')).toBe(-1)
+    expect(compareSemver('1.0.0', '1.1.0')).toBe(-1)
+    expect(compareSemver('1.0.0', '1.0.1')).toBe(-1)
+  })
+
+  it('should return 1 when a > b', () => {
+    expect(compareSemver('2.0.0', '1.0.0')).toBe(1)
+    expect(compareSemver('1.1.0', '1.0.0')).toBe(1)
+    expect(compareSemver('1.0.1', '1.0.0')).toBe(1)
+  })
+
+  it('should handle missing patch versions', () => {
+    expect(compareSemver('1.0', '1.0.0')).toBe(0)
+  })
+})
+
+// =============================================================================
+// Version Validation
+// =============================================================================
+
+describe('meetsMinVersion', () => {
+  it('should pass when version meets minimum', () => {
+    expect(meetsMinVersion('claude', '1.0.0')).toBe(true)
+    expect(meetsMinVersion('claude', '2.5.0')).toBe(true)
+  })
+
+  it('should fail when version is below minimum', () => {
+    expect(meetsMinVersion('claude', '0.9.0')).toBe(false)
+    expect(meetsMinVersion('claude', '0.0.1')).toBe(false)
+  })
+
+  it('should pass for providers without minimum', () => {
+    expect(meetsMinVersion('cursor', '0.1.0')).toBe(true)
+    expect(meetsMinVersion('unknown', '0.0.0')).toBe(true)
+  })
+})
+
+describe('validateCliVersion', () => {
+  it('should return null for valid versions', () => {
+    expect(validateCliVersion('claude', '1.0.0')).toBeNull()
+    expect(validateCliVersion('claude', '2.0.0')).toBeNull()
+  })
+
+  it('should return warning for versions below minimum', () => {
+    const warning = validateCliVersion('claude', '0.5.0')
+    expect(warning).toContain('below minimum')
+    expect(warning).toContain('Claude Code')
+  })
+
+  it('should return null for undefined version', () => {
+    expect(validateCliVersion('claude', undefined)).toBeNull()
+  })
+
+  it('should return null for providers without minCliVersion', () => {
+    expect(validateCliVersion('cursor', '0.1.0')).toBeNull()
+  })
+})
+
+// =============================================================================
+// Model Mismatch Detection
+// =============================================================================
+
+describe('checkModelMismatch', () => {
+  const claudeOpus: ModelMetadata = {
+    provider: 'claude',
+    model: 'opus',
+    cliVersion: '1.5.0',
+    recordedAt: '2026-02-07T00:00:00.000Z',
+  }
+
+  const claudeSonnet: ModelMetadata = {
+    provider: 'claude',
+    model: 'sonnet',
+    cliVersion: '1.5.0',
+    recordedAt: '2026-02-07T00:00:00.000Z',
+  }
+
+  const geminiPro: ModelMetadata = {
+    provider: 'gemini',
+    model: '2.5-pro',
+    cliVersion: '1.0.0',
+    recordedAt: '2026-02-07T00:00:00.000Z',
+  }
+
+  it('should return null when models match', () => {
+    expect(checkModelMismatch(claudeOpus, claudeOpus)).toBeNull()
+  })
+
+  it('should warn when models differ within same provider', () => {
+    const warning = checkModelMismatch(claudeOpus, claudeSonnet)
+    expect(warning).toContain('mismatch')
+    expect(warning).toContain('opus')
+    expect(warning).toContain('sonnet')
+  })
+
+  it('should warn when providers differ', () => {
+    const warning = checkModelMismatch(claudeOpus, geminiPro)
+    expect(warning).toContain('mismatch')
+    expect(warning).toContain('claude')
+    expect(warning).toContain('gemini')
+  })
+
+  it('should return null when either metadata is undefined', () => {
+    expect(checkModelMismatch(undefined, claudeOpus)).toBeNull()
+    expect(checkModelMismatch(claudeOpus, undefined)).toBeNull()
+    expect(checkModelMismatch(undefined, undefined)).toBeNull()
+  })
+})
+
+// =============================================================================
+// Backwards Compatibility
+// =============================================================================
+
+describe('backwards compatibility', () => {
+  it('should handle configs without model field gracefully', () => {
+    // Simulates loading an old config without model fields
+    const oldProviderConfig = {
+      name: 'claude' as const,
+      displayName: 'Claude Code',
+      cliCommand: 'claude',
+    }
+    // getDefaultModel should work even if provider config has no model field
+    expect(getDefaultModel(oldProviderConfig.name)).toBe('sonnet')
+  })
+
+  it('should resolve default model when preferredModel is not set', () => {
+    const preferredModel: string | undefined = undefined
+    const provider = 'claude'
+    const resolved = preferredModel ?? getDefaultModel(provider)
+    expect(resolved).toBe('sonnet')
+  })
+})

package/core/agentic/command-classifier.ts

@@ -0,0 +1,141 @@
+/**
+ * Command Classifier
+ *
+ * Classifies unknown commands by analyzing template metadata.
+ * When a command isn't in command-context.config.json, this module
+ * determines what context sections it needs based on template content.
+ *
+ * Classification chain:
+ * 1. Config lookup (instant) — handled by command-context.ts
+ * 2. Template heuristic (instant) — this module
+ * 3. Wildcard fallback — handled by command-context.ts
+ *
+ * @see PRJ-298
+ */
+
+import type { CommandContextEntry } from '../schemas/command-context'
+import type { Template } from '../types'
+
+// Keywords that indicate code-modifying commands
+const CODE_KEYWORDS = [
+  'build',
+  'create',
+  'add',
+  'implement',
+  'fix',
+  'refactor',
+  'update',
+  'modify',
+  'change',
+  'write',
+  'generate',
+  'scaffold',
+  'migrate',
+  'optimize',
+  'improve',
+  'enhance',
+  'redesign',
+  'rewrite',
+]
+
+// Keywords that indicate read-only / info commands
+const INFO_KEYWORDS = [
+  'list',
+  'show',
+  'get',
+  'status',
+  'info',
+  'check',
+  'view',
+  'display',
+  'describe',
+  'explain',
+  'analyze',
+  'report',
+  'dashboard',
+]
+
+// Keywords that indicate quality/verification commands
+const QUALITY_KEYWORDS = [
+  'test',
+  'verify',
+  'validate',
+  'review',
+  'audit',
+  'check',
+  'lint',
+  'ship',
+  'deploy',
+  'release',
+  'complete',
+  'done',
+  'finish',
+]
+
+// Tools that indicate code modification
+const CODE_TOOLS = ['Write', 'Edit', 'Bash']
+
+/**
+ * Count keyword matches using word boundaries to avoid substring false positives.
+ */
+function countMatches(text: string, keywords: string[]): number {
+  return keywords.filter((k) => new RegExp(`\\b${k}\\b`).test(text)).length
+}
+
+/**
+ * Classify a command based on its template metadata.
+ * Analyzes the command name, description, allowed tools, and content
+ * to determine what context sections are relevant.
+ *
+ * Priority: code-modifying > quality/verification > info/read-only > default
+ */
+export function classifyCommand(commandName: string, template: Template): CommandContextEntry {
+  const description = (template.frontmatter?.description || '').toLowerCase()
+  const content = template.content.toLowerCase()
+  const allowedTools = template.frontmatter?.['allowed-tools'] || []
+  const combined = `${commandName} ${description} ${content}`
+
+  const codeScore = countMatches(combined, CODE_KEYWORDS)
+  const infoScore = countMatches(combined, INFO_KEYWORDS)
+  const qualityScore = countMatches(combined, QUALITY_KEYWORDS)
+  const hasCodeTools = allowedTools.some((t: string) => CODE_TOOLS.includes(t))
+
+  // Code-modifying command: needs agents + patterns + checklists
+  if (hasCodeTools && codeScore > 0) {
+    return {
+      agents: true,
+      patterns: true,
+      checklist: qualityScore > 0,
+      modules: [],
+    }
+  }
+
+  // Quality/verification command: needs patterns + checklists
+  // Quality takes priority over info when quality score is higher
+  if (qualityScore > 0 && qualityScore >= infoScore) {
+    return {
+      agents: false,
+      patterns: true,
+      checklist: true,
+      modules: [],
+    }
+  }
+
+  // Info/read-only command: needs nothing
+  if (infoScore > 0 && codeScore === 0) {
+    return {
+      agents: false,
+      patterns: false,
+      checklist: false,
+      modules: [],
+    }
+  }
+
+  // Default for unknown: agents + patterns (sensible default)
+  return {
+    agents: true,
+    patterns: true,
+    checklist: false,
+    modules: [],
+  }
+}

package/core/agentic/command-context.ts

@@ -0,0 +1,168 @@
+/**
+ * Command Context Resolver
+ *
+ * Replaces 4 hardcoded command lists in prompt-builder with config-driven lookups.
+ * Falls back to LLM classification for unknown commands (Phase 2).
+ * Auto-learns after repeated classifications (Phase 3).
+ *
+ * @see PRJ-298
+ */
+
+import fs from 'node:fs/promises'
+import path from 'node:path'
+import {
+  type CommandContextConfig,
+  CommandContextConfigSchema,
+  type CommandContextEntry,
+} from '../schemas/command-context'
+import type { Template } from '../types'
+import { PACKAGE_ROOT } from '../utils/version'
+import { classifyCommand } from './command-classifier'
+
+const CONFIG_PATH = path.join(PACKAGE_ROOT, 'core/config/command-context.config.json')
+
+let cachedConfig: CommandContextConfig | null = null
+
+/**
+ * Load and validate the command context config.
+ * Cached after first load for the process lifetime.
+ */
+export async function loadCommandContextConfig(): Promise<CommandContextConfig> {
+  if (cachedConfig) return cachedConfig
+
+  const raw = await fs.readFile(CONFIG_PATH, 'utf-8')
+  const parsed = JSON.parse(raw)
+  cachedConfig = CommandContextConfigSchema.parse(parsed)
+  return cachedConfig
+}
+
+/**
+ * Get context config for a command.
+ * Returns the command's config if explicitly defined, otherwise falls back to wildcard '*'.
+ */
+export function resolveCommandContext(
+  config: CommandContextConfig,
+  commandName: string
+): CommandContextEntry {
+  return config.commands[commandName] ?? config.commands['*']
+}
+
+// =============================================================================
+// LLM Classification Cache (Phase 2)
+// =============================================================================
+
+const classificationCache = new Map<string, CommandContextEntry>()
+
+/**
+ * Get a cached LLM classification result for a command.
+ */
+export function getCachedClassification(commandName: string): CommandContextEntry | undefined {
+  return classificationCache.get(commandName)
+}
+
+/**
+ * Cache an LLM classification result for a command.
+ */
+export function cacheClassification(commandName: string, entry: CommandContextEntry): void {
+  classificationCache.set(commandName, entry)
+}
+
+// =============================================================================
+// Auto-Learn Tracking (Phase 3)
+// =============================================================================
+
+const classificationHistory = new Map<string, { entry: CommandContextEntry; count: number }>()
+
+const AUTO_LEARN_THRESHOLD = 3
+
+/**
+ * Track a classification result. Returns true if the threshold is reached
+ * and the classification should be persisted to config.
+ */
+export function trackClassification(commandName: string, entry: CommandContextEntry): boolean {
+  const key = commandName
+  const existing = classificationHistory.get(key)
+
+  if (existing && isSameEntry(existing.entry, entry)) {
+    existing.count++
+    return existing.count >= AUTO_LEARN_THRESHOLD
+  }
+
+  classificationHistory.set(key, { entry, count: 1 })
+  return false
+}
+
+/**
+ * Persist a learned classification to the config file.
+ */
+export async function persistClassification(
+  commandName: string,
+  entry: CommandContextEntry
+): Promise<void> {
+  const raw = await fs.readFile(CONFIG_PATH, 'utf-8')
+  const config = JSON.parse(raw) as CommandContextConfig
+
+  config.commands[commandName] = entry
+  await fs.writeFile(CONFIG_PATH, `${JSON.stringify(config, null, 2)}\n`, 'utf-8')
+
+  // Invalidate cache so next load picks up the change
+  cachedConfig = null
+}
+
+function isSameEntry(a: CommandContextEntry, b: CommandContextEntry): boolean {
+  return (
+    a.agents === b.agents &&
+    a.patterns === b.patterns &&
+    a.checklist === b.checklist &&
+    a.modules.length === b.modules.length &&
+    a.modules.every((m, i) => m === b.modules[i])
+  )
+}
+
+// =============================================================================
+// Convenience: resolve with all fallbacks
+// =============================================================================
+
+/**
+ * Resolve command context with full fallback chain:
+ * 1. Config lookup (instant)
+ * 2. Classification cache (instant)
+ * 3. Template heuristic classification (instant) — caches result + tracks for auto-learn
+ * 4. Wildcard default (instant)
+ *
+ * Returns { entry, source } where source indicates how it was resolved.
+ */
+export function resolveCommandContextFull(
+  config: CommandContextConfig,
+  commandName: string,
+  template?: Template
+): { entry: CommandContextEntry; source: 'config' | 'classified' | 'cache' | 'wildcard' } {
+  // 1. Explicit config match
+  if (commandName in config.commands && commandName !== '*') {
+    return { entry: config.commands[commandName], source: 'config' }
+  }
+
+  // 2. Classification cache
+  const cached = getCachedClassification(commandName)
+  if (cached) {
+    return { entry: cached, source: 'cache' }
+  }
+
+  // 3. Template heuristic classification
+  if (template) {
+    const classified = classifyCommand(commandName, template)
+    cacheClassification(commandName, classified)
+
+    // Track for auto-learn (Phase 3)
+    const shouldPersist = trackClassification(commandName, classified)
+    if (shouldPersist) {
+      // Fire-and-forget persist — don't block prompt building
+      persistClassification(commandName, classified).catch(() => {})
+    }
+
+    return { entry: classified, source: 'classified' }
+  }
+
+  // 4. Wildcard default
+  return { entry: config.commands['*'], source: 'wildcard' }
+}