prjct-cli 1.8.0 → 1.10.0

package/core/agentic/response-validator.ts

@@ -0,0 +1,98 @@
+/**
+ * Response Validator
+ *
+ * Validates LLM responses against Zod schemas.
+ * Provides structured error handling with re-prompt support.
+ *
+ * Flow:
+ * 1. Parse raw text as JSON
+ * 2. Validate against Zod schema
+ * 3. On success: return typed data
+ * 4. On failure: return validation errors for re-prompt or fallback
+ *
+ * @see PRJ-264
+ */
+
+import type { z } from 'zod'
+
+// =============================================================================
+// Types
+// =============================================================================
+
+export interface ValidationSuccess<T> {
+  success: true
+  data: T
+}
+
+export interface ValidationFailure {
+  success: false
+  error: string
+  /** Raw parsed JSON (may be partial) */
+  rawParsed: unknown
+  /** Zod validation issues */
+  issues: string[]
+}
+
+export type ValidationResult<T> = ValidationSuccess<T> | ValidationFailure
+
+// =============================================================================
+// Core Validation
+// =============================================================================
+
+/**
+ * Validate a raw LLM response string against a Zod schema.
+ *
+ * Handles:
+ * - JSON parse errors (LLM returned non-JSON)
+ * - Markdown-wrapped JSON (```json ... ```)
+ * - Schema validation errors (wrong fields, types)
+ */
+export function validateLLMResponse<T>(raw: string, schema: z.ZodType<T>): ValidationResult<T> {
+  // Strip markdown code fences if present
+  let jsonText = raw.trim()
+  const fenceMatch = jsonText.match(/^```(?:json)?\s*\n?([\s\S]*?)\n?\s*```$/)
+  if (fenceMatch) {
+    jsonText = fenceMatch[1].trim()
+  }
+
+  // Attempt JSON parse
+  let parsed: unknown
+  try {
+    parsed = JSON.parse(jsonText)
+  } catch {
+    return {
+      success: false,
+      error: 'Response is not valid JSON',
+      rawParsed: null,
+      issues: [`JSON parse error: expected JSON, got: ${jsonText.slice(0, 100)}...`],
+    }
+  }
+
+  // Validate against schema
+  const result = schema.safeParse(parsed)
+  if (result.success) {
+    return { success: true, data: result.data }
+  }
+
+  // Extract readable error messages
+  const issues = result.error.issues.map((issue) => `${issue.path.join('.')}: ${issue.message}`)
+
+  return {
+    success: false,
+    error: `Schema validation failed: ${issues.join('; ')}`,
+    rawParsed: parsed,
+    issues,
+  }
+}
+
+/**
+ * Build a re-prompt message when validation fails.
+ * Includes the original error so the LLM can fix its response.
+ */
+export function buildReprompt(failure: ValidationFailure, schemaExample: string): string {
+  return `Your previous response was not valid. Errors:
+${failure.issues.map((i) => `- ${i}`).join('\n')}
+
+Return ONLY valid JSON matching this exact format (no markdown, no explanation):
+${schemaExample}`
+}

package/core/agentic/smart-context.ts

@@ -4,8 +4,10 @@
  * Intelligently filters context based on task type.
  * Reduces prompt size by 40-70% while maintaining relevance.
  *
+ * Uses LLM-based domain classification (PRJ-299) instead of keyword matching.
+ *
  * @module agentic/smart-context
- * @version 1.0
+ * @version 2.0
  */
 
 import { agentPerformanceTracker } from '../agents'
@@ -19,6 +21,7 @@ import type {
   StackInfo,
   TaskType,
 } from '../types'
+import domainClassifier, { classifyWithHeuristic, type ProjectContext } from './domain-classifier'
 
 // Re-export types for convenience
 export type {
@@ -35,163 +38,76 @@ export type {
 // Type alias exported for backward compatibility (used by external consumers)
 export type ProjectState = SmartContextProjectState
 
+// Map ClassificationDomain → ContextDomain
+function toContextDomain(domain: string): ContextDomain {
+  const mapping: Record<string, ContextDomain> = {
+    frontend: 'frontend',
+    backend: 'backend',
+    database: 'backend', // database maps to backend context domain
+    devops: 'devops',
+    testing: 'testing',
+    docs: 'docs',
+    uxui: 'frontend', // uxui maps to frontend context domain
+    general: 'general',
+  }
+  return mapping[domain] || 'general'
+}
+
 /**
  * SmartContext - Intelligent context filtering.
  */
 class SmartContext {
   /**
    * Detect the domain of a task from its description.
+   *
+   * Synchronous version using the improved heuristic (word-boundary matching).
+   * For full LLM-based classification, use classifyDomain().
    */
   detectDomain(taskDescription: string): DomainAnalysis {
-    const lower = taskDescription.toLowerCase()
-
-    // Frontend indicators
-    const frontendKeywords = [
-      'ui',
-      'component',
-      'react',
-      'vue',
-      'angular',
-      'css',
-      'style',
-      'button',
-      'form',
-      'modal',
-      'layout',
-      'responsive',
-      'animation',
-      'dom',
-      'html',
-      'frontend',
-      'fe',
-      'client',
-      'browser',
-      'jsx',
-      'tsx',
-    ]
-
-    // Backend indicators
-    const backendKeywords = [
-      'api',
-      'server',
-      'database',
-      'db',
-      'endpoint',
-      'route',
-      'handler',
-      'controller',
-      'service',
-      'repository',
-      'model',
-      'query',
-      'backend',
-      'be',
-      'rest',
-      'graphql',
-      'prisma',
-      'sql',
-      'redis',
-      'auth',
-    ]
-
-    // DevOps indicators
-    const devopsKeywords = [
-      'deploy',
-      'docker',
-      'kubernetes',
-      'k8s',
-      'ci',
-      'cd',
-      'pipeline',
-      'terraform',
-      'ansible',
-      'aws',
-      'gcp',
-      'azure',
-      'config',
-      'nginx',
-      'devops',
-      'infrastructure',
-      'monitoring',
-      'logging',
-      'build',
-    ]
-
-    // Docs indicators
-    const docsKeywords = [
-      'document',
-      'docs',
-      'readme',
-      'changelog',
-      'comment',
-      'jsdoc',
-      'tutorial',
-      'guide',
-      'explain',
-      'describe',
-      'markdown',
-    ]
-
-    // Testing indicators
-    const testingKeywords = [
-      'test',
-      'spec',
-      // JS/TS
-      'bun',
-      'bun test',
-      'jest',
-      'mocha',
-      'cypress',
-      'playwright',
-      // Python
-      'pytest',
-      'unittest',
-      // Go
-      'go test',
-      // Rust
-      'cargo test',
-      // .NET
-      'dotnet test',
-      // Java
-      'mvn test',
-      'gradle test',
-      'gradlew test',
-      'e2e',
-      'unit',
-      'integration',
-      'coverage',
-      'mock',
-      'fixture',
-    ]
-
-    // Count matches
-    const scores: Record<ContextDomain, number> = {
-      frontend: frontendKeywords.filter((k) => lower.includes(k)).length,
-      backend: backendKeywords.filter((k) => lower.includes(k)).length,
-      devops: devopsKeywords.filter((k) => lower.includes(k)).length,
-      docs: docsKeywords.filter((k) => lower.includes(k)).length,
-      testing: testingKeywords.filter((k) => lower.includes(k)).length,
-      general: 0,
+    // Default context when no project info is available
+    const defaultContext: ProjectContext = {
+      domains: {
+        hasFrontend: true,
+        hasBackend: true,
+        hasDatabase: true,
+        hasTesting: true,
+        hasDocker: true,
+      },
+      agents: [],
     }
 
-    // Find primary and secondary domains
-    const sorted = Object.entries(scores)
-      .filter(([_, score]) => score > 0)
-      .sort((a, b) => b[1] - a[1])
+    const result = classifyWithHeuristic(taskDescription, defaultContext)
 
-    if (sorted.length === 0) {
-      return { primary: 'general', secondary: [], confidence: 0.5 }
+    return {
+      primary: toContextDomain(result.primaryDomain),
+      secondary: result.secondaryDomains.map(toContextDomain),
+      confidence: result.confidence,
     }
+  }
 
-    const primary = sorted[0][0] as ContextDomain
-    const primaryScore = sorted[0][1]
-    const secondary = sorted.slice(1, 3).map(([domain]) => domain as ContextDomain)
-
-    // Calculate confidence based on score gap
-    const totalScore = sorted.reduce((sum, [_, score]) => sum + score, 0)
-    const confidence = totalScore > 0 ? Math.min(0.95, primaryScore / totalScore + 0.3) : 0.5
+  /**
+   * Classify domain using the full fallback chain (cache → history → LLM → heuristic).
+   * Async version that leverages project context and LLM classification.
+   */
+  async classifyDomain(
+    taskDescription: string,
+    projectId: string,
+    globalPath: string,
+    context: ProjectContext
+  ): Promise<DomainAnalysis & { source: string }> {
+    const { classification, source } = await domainClassifier.classify(
+      taskDescription,
+      projectId,
+      globalPath,
+      context
+    )
 
-    return { primary, secondary, confidence }
+    return {
+      primary: toContextDomain(classification.primaryDomain),
+      secondary: classification.secondaryDomains.map(toContextDomain),
+      confidence: classification.confidence,
+      source,
+    }
   }
 
   /**

package/core/agentic/token-budget.ts

@@ -0,0 +1,226 @@
+/**
+ * Token Budget Coordinator
+ *
+ * Centrally manages the global token budget across all context-loading components.
+ * Ensures the combined prompt stays within the model's context window
+ * and reserves space for the output.
+ *
+ * Budget formula: inputBudget = modelContextWindow * 0.65
+ * Priority: state (P1) > injection context (P2) > file content (P3)
+ *
+ * @see PRJ-266
+ */
+
+// =============================================================================
+// Model Context Windows
+// =============================================================================
+
+/** Context window sizes by model identifier (in tokens) */
+export const MODEL_CONTEXT_WINDOWS: Record<string, number> = {
+  // Claude models (short names from model.ts)
+  opus: 200_000,
+  sonnet: 200_000,
+  haiku: 200_000,
+  // Gemini models
+  '2.5-pro': 1_000_000,
+  '2.5-flash': 1_000_000,
+  '2.0-flash': 1_000_000,
+  // Full model IDs (for direct API usage)
+  'claude-opus-4.5': 200_000,
+  'claude-sonnet-4.5': 200_000,
+  'claude-haiku-4.5': 200_000,
+  'claude-opus-4-6': 200_000,
+  // Default fallback
+  default: 200_000,
+}
+
+/** Ratio of context window reserved for input (rest for output) */
+export const INPUT_RATIO = 0.65
+
+// =============================================================================
+// Budget Categories
+// =============================================================================
+
+/** Budget category identifiers ordered by priority */
+export type BudgetCategory = 'state' | 'injection' | 'files'
+
+/** Budget allocation result for each category */
+export interface BudgetAllocation {
+  state: number
+  injection: number
+  files: number
+  inputBudget: number
+  outputReserve: number
+  contextWindow: number
+}
+
+/** Usage tracking per category */
+export interface BudgetUsage {
+  category: BudgetCategory
+  allocated: number
+  used: number
+  remaining: number
+}
+
+// =============================================================================
+// Default Allocation Ratios (within input budget)
+// =============================================================================
+
+interface AllocationConfig {
+  ratio: number
+  minimum: number
+}
+
+const ALLOCATION_CONFIG: Record<BudgetCategory, AllocationConfig> = {
+  /** P1: State — current task, queue, patterns (highest priority) */
+  state: { ratio: 0.02, minimum: 1_500 },
+  /** P2: Injection — agents, skills, modules, checklists */
+  injection: { ratio: 0.08, minimum: 8_000 },
+  /** P3: Files — codebase file content (lowest priority, gets remainder) */
+  files: { ratio: 0.9, minimum: 20_000 },
+}
+
+/** Priority order for budget distribution */
+const PRIORITY_ORDER: BudgetCategory[] = ['state', 'injection', 'files']
+
+// =============================================================================
+// TokenBudgetCoordinator
+// =============================================================================
+
+export class TokenBudgetCoordinator {
+  private readonly _contextWindow: number
+  private readonly _inputBudget: number
+  private readonly _outputReserve: number
+  private readonly _allocations: Map<BudgetCategory, number> = new Map()
+  private readonly _used: Map<BudgetCategory, number> = new Map()
+
+  constructor(model?: string) {
+    this._contextWindow = getContextWindow(model)
+    this._inputBudget = Math.floor(this._contextWindow * INPUT_RATIO)
+    this._outputReserve = this._contextWindow - this._inputBudget
+    this.distributeBudget()
+  }
+
+  /** Distribute input budget across categories by priority */
+  private distributeBudget(): void {
+    let remaining = this._inputBudget
+
+    for (const category of PRIORITY_ORDER) {
+      const config = ALLOCATION_CONFIG[category]
+
+      if (category === 'files') {
+        // Lowest priority gets whatever remains
+        this._allocations.set(category, Math.max(remaining, 0))
+      } else {
+        const allocation = Math.max(config.minimum, Math.floor(this._inputBudget * config.ratio))
+        const granted = Math.min(allocation, remaining)
+        this._allocations.set(category, granted)
+        remaining -= granted
+      }
+
+      this._used.set(category, 0)
+    }
+  }
+
+  /** Get the full budget allocation */
+  getAllocation(): BudgetAllocation {
+    return {
+      state: this._allocations.get('state') ?? 0,
+      injection: this._allocations.get('injection') ?? 0,
+      files: this._allocations.get('files') ?? 0,
+      inputBudget: this._inputBudget,
+      outputReserve: this._outputReserve,
+      contextWindow: this._contextWindow,
+    }
+  }
+
+  /**
+   * Request tokens from a category.
+   * Returns actual tokens granted (may be less than requested if budget is exhausted).
+   */
+  request(category: BudgetCategory, requestedTokens: number): number {
+    const allocated = this._allocations.get(category) ?? 0
+    const currentUsed = this._used.get(category) ?? 0
+    const available = Math.max(0, allocated - currentUsed)
+    const granted = Math.min(requestedTokens, available)
+    this._used.set(category, currentUsed + granted)
+    return granted
+  }
+
+  /** Record token usage for a category */
+  record(category: BudgetCategory, tokensUsed: number): void {
+    const current = this._used.get(category) ?? 0
+    this._used.set(category, current + tokensUsed)
+  }
+
+  /** Get usage details for a category */
+  getUsage(category: BudgetCategory): BudgetUsage {
+    const allocated = this._allocations.get(category) ?? 0
+    const used = this._used.get(category) ?? 0
+    return {
+      category,
+      allocated,
+      used,
+      remaining: Math.max(0, allocated - used),
+    }
+  }
+
+  /** Get allocation for a specific category */
+  getAllocationFor(category: BudgetCategory): number {
+    return this._allocations.get(category) ?? 0
+  }
+
+  /** Get total remaining input budget across all categories */
+  get totalRemaining(): number {
+    let totalUsed = 0
+    for (const v of this._used.values()) {
+      totalUsed += v
+    }
+    return Math.max(0, this._inputBudget - totalUsed)
+  }
+
+  /** Check if total usage exceeds input budget */
+  get isOverBudget(): boolean {
+    let totalUsed = 0
+    for (const v of this._used.values()) {
+      totalUsed += v
+    }
+    return totalUsed > this._inputBudget
+  }
+
+  /** Context window size */
+  get contextWindow(): number {
+    return this._contextWindow
+  }
+
+  /** Total input budget */
+  get inputBudget(): number {
+    return this._inputBudget
+  }
+
+  /** Output token reserve */
+  get outputReserve(): number {
+    return this._outputReserve
+  }
+}
+
+// =============================================================================
+// Helpers
+// =============================================================================
+
+/** Get context window size for a model identifier */
+export function getContextWindow(model?: string): number {
+  if (!model) return MODEL_CONTEXT_WINDOWS.default
+  return MODEL_CONTEXT_WINDOWS[model] ?? MODEL_CONTEXT_WINDOWS.default
+}
+
+/** Calculate input budget for a model */
+export function calculateInputBudget(model?: string): number {
+  return Math.floor(getContextWindow(model) * INPUT_RATIO)
+}
+
+/** Calculate output reserve for a model */
+export function calculateOutputReserve(model?: string): number {
+  const contextWindow = getContextWindow(model)
+  return contextWindow - Math.floor(contextWindow * INPUT_RATIO)
+}

package/core/infrastructure/ai-provider.ts

@@ -21,6 +21,7 @@ import { exec } from 'node:child_process'
 import os from 'node:os'
 import path from 'node:path'
 import { promisify } from 'node:util'
+import { compareSemver } from '../schemas/model'
 import { fileExists } from '../utils/fs-helpers'
 import { readProviderCache, writeProviderCache } from '../utils/provider-cache'
 
@@ -58,6 +59,9 @@ export const ClaudeProvider: AIProviderConfig = {
   ignoreFile: '.claudeignore',
   websiteUrl: 'https://www.anthropic.com/claude',
   docsUrl: 'https://docs.anthropic.com/claude-code',
+  defaultModel: 'sonnet',
+  supportedModels: ['opus', 'sonnet', 'haiku'],
+  minCliVersion: '1.0.0',
 }
 
 /**
@@ -77,6 +81,9 @@ export const GeminiProvider: AIProviderConfig = {
   ignoreFile: '.geminiignore',
   websiteUrl: 'https://geminicli.com',
   docsUrl: 'https://geminicli.com/docs',
+  defaultModel: '2.5-flash',
+  supportedModels: ['2.5-pro', '2.5-flash', '2.0-flash'],
+  minCliVersion: '1.0.0',
 }
 
 /**
@@ -100,6 +107,9 @@ export const AntigravityProvider: AIProviderConfig = {
   ignoreFile: '.agentignore', // Assumed
   websiteUrl: 'https://gemini.google.com/app/antigravity',
   docsUrl: 'https://gemini.google.com/app/antigravity',
+  defaultModel: null, // Platform-managed
+  supportedModels: [],
+  minCliVersion: null,
 }
 
 /**
@@ -129,6 +139,9 @@ export const CursorProvider: AIProviderConfig = {
   isProjectLevel: true, // Config is project-level only
   websiteUrl: 'https://cursor.com',
   docsUrl: 'https://cursor.com/docs',
+  defaultModel: null, // Multi-model IDE, user selects
+  supportedModels: [],
+  minCliVersion: null,
 }
 
 /**
@@ -159,6 +172,9 @@ export const WindsurfProvider: AIProviderConfig = {
   isProjectLevel: true, // Config is project-level only
   websiteUrl: 'https://windsurf.com',
   docsUrl: 'https://docs.windsurf.com',
+  defaultModel: null, // Multi-model IDE, user selects
+  supportedModels: [],
+  minCliVersion: null,
 }
 
 /**
@@ -221,14 +237,33 @@ export async function detectProvider(provider: AIProviderName): Promise<Provider
   }
 
   const version = await getCliVersion(config.cliCommand)
+  const versionWarning = validateCliVersion(provider, version || undefined)
 
   return {
     installed: true,
     version: version || undefined,
     path: cliPath,
+    versionWarning: versionWarning || undefined,
   }
 }
 
+/**
+ * Validate that a detected CLI version meets the provider's minimum requirement.
+ * Returns a warning message if the version is below minimum, or null if OK.
+ */
+export function validateCliVersion(
+  provider: AIProviderName,
+  version: string | undefined
+): string | null {
+  const config = Providers[provider]
+  if (!config.minCliVersion || !version) return null
+
+  if (compareSemver(version, config.minCliVersion) < 0) {
+    return `⚠️ ${config.displayName} v${version} is below minimum v${config.minCliVersion}. Some features may not work correctly.`
+  }
+  return null
+}
+
 /**
  * Detect all available CLI-based providers
  * Results are cached to disk with a 10-minute TTL to avoid redundant shell spawns.

package/core/schemas/analysis.ts

@@ -4,6 +4,8 @@
  * Defines the structure for analysis.json - repository analysis.
  */
 
+import type { ModelMetadata } from './model'
+
 export interface CodePattern {
   name: string
   description: string
@@ -28,6 +30,8 @@ export interface AnalysisSchema {
   patterns: CodePattern[]
   antiPatterns: AntiPattern[]
   analyzedAt: string // ISO8601
+  /** Which AI model was used for this analysis (PRJ-265) */
+  modelMetadata?: ModelMetadata
 }
 
 export const DEFAULT_ANALYSIS: Omit<AnalysisSchema, 'projectId'> = {