prjct-cli 1.8.0 → 1.9.0

package/core/agentic/orchestrator-executor.ts

@@ -32,149 +32,11 @@ import type {
   RealCodebaseContext,
 } from '../types'
 import { getErrorMessage, isNotFoundError } from '../types/fs'
+import domainClassifier, { type ProjectContext } from './domain-classifier'
 import { parseFrontmatter } from './template-loader'
 
 const execAsync = promisify(execCallback)
 
-// =============================================================================
-// Domain Detection Keywords
-// =============================================================================
-
-/**
- * Keywords that indicate a domain is involved in the task
- * These are hints, not absolute rules - context matters
- */
-const DOMAIN_KEYWORDS: Record<string, string[]> = {
-  database: [
-    'database',
-    'db',
-    'sql',
-    'query',
-    'table',
-    'schema',
-    'migration',
-    'postgres',
-    'mysql',
-    'sqlite',
-    'mongo',
-    'redis',
-    'prisma',
-    'drizzle',
-    'orm',
-    'model',
-    'entity',
-    'repository',
-    'data layer',
-    'persist',
-  ],
-  backend: [
-    'api',
-    'endpoint',
-    'route',
-    'server',
-    'controller',
-    'service',
-    'middleware',
-    'auth',
-    'authentication',
-    'authorization',
-    'jwt',
-    'oauth',
-    'rest',
-    'graphql',
-    'trpc',
-    'express',
-    'fastify',
-    'hono',
-    'nest',
-    'validation',
-    'business logic',
-  ],
-  frontend: [
-    'ui',
-    'component',
-    'page',
-    'form',
-    'button',
-    'input',
-    'modal',
-    'dialog',
-    'react',
-    'vue',
-    'svelte',
-    'angular',
-    'next',
-    'nuxt',
-    'solid',
-    'css',
-    'style',
-    'tailwind',
-    'layout',
-    'responsive',
-    'animation',
-    'hook',
-    'state',
-    'context',
-    'redux',
-    'zustand',
-    'jotai',
-  ],
-  testing: [
-    'test',
-    'spec',
-    'unit',
-    'integration',
-    'e2e',
-    'jest',
-    'vitest',
-    'playwright',
-    'cypress',
-    'mocha',
-    'chai',
-    'mock',
-    'stub',
-    'fixture',
-    'coverage',
-    'assertion',
-  ],
-  devops: [
-    'docker',
-    'kubernetes',
-    'k8s',
-    'ci',
-    'cd',
-    'pipeline',
-    'deploy',
-    'github actions',
-    'vercel',
-    'aws',
-    'gcp',
-    'azure',
-    'terraform',
-    'nginx',
-    'caddy',
-    'env',
-    'environment',
-    'config',
-    'secret',
-  ],
-  uxui: [
-    'design',
-    'ux',
-    'user experience',
-    'accessibility',
-    'a11y',
-    'color',
-    'typography',
-    'spacing',
-    'prototype',
-    'wireframe',
-    'figma',
-    'user flow',
-    'interaction',
-  ],
-}
-
 /**
  * Domain dependency order - earlier domains should complete first
  */
@@ -353,84 +215,66 @@ export class OrchestratorExecutor {
   }
 
   /**
-   * Detect which domains are relevant for this task
+   * Detect which domains are relevant for this task.
    *
-   * Uses keyword matching + project context to determine domains.
-   * More intelligent than simple string matching - considers:
-   * - Task description keywords
-   * - Project technology stack
-   * - Available agents
+   * Uses LLM-based classification with fallback chain (PRJ-299):
+   * cache → confirmed patterns → LLM → heuristic
    */
   async detectDomains(
     taskDescription: string,
     projectId: string,
     repoAnalysis: { ecosystem: string; technologies?: string[] } | null
   ): Promise<{ domains: string[]; primary: string }> {
-    const taskLower = taskDescription.toLowerCase()
-    const detectedDomains: Map<string, number> = new Map()
-
-    // Score each domain based on keyword matches
-    for (const [domain, keywords] of Object.entries(DOMAIN_KEYWORDS)) {
-      let score = 0
-      for (const keyword of keywords) {
-        if (taskLower.includes(keyword.toLowerCase())) {
-          // Weight multi-word matches higher
-          score += keyword.includes(' ') ? 3 : 1
-        }
-      }
-      if (score > 0) {
-        detectedDomains.set(domain, score)
+    const globalPath = pathManager.getGlobalProjectPath(projectId)
+    const availableAgents = await this.getAvailableAgentNames(globalPath)
+
+    // Load state.json for project domain info
+    let projectDomains = {
+      hasFrontend: false,
+      hasBackend: true,
+      hasDatabase: false,
+      hasTesting: false,
+      hasDocker: false,
+    }
+    try {
+      const statePath = path.join(globalPath, 'storage', 'state.json')
+      const stateContent = await fs.readFile(statePath, 'utf-8')
+      const state = JSON.parse(stateContent)
+      if (state.domains) {
+        projectDomains = state.domains
       }
+    } catch {
+      // Use defaults
     }
 
-    // Boost scores for domains that match project technologies
-    if (repoAnalysis?.technologies) {
-      const techStr = repoAnalysis.technologies.join(' ').toLowerCase()
-
-      // If project has React/Vue/etc, boost frontend
-      if (/react|vue|svelte|angular|next|nuxt/.test(techStr)) {
-        const current = detectedDomains.get('frontend') || 0
-        if (current > 0) detectedDomains.set('frontend', current + 2)
-      }
+    const context: ProjectContext = {
+      domains: projectDomains,
+      agents: availableAgents,
+      stack: repoAnalysis ? { language: repoAnalysis.ecosystem } : undefined,
+    }
 
-      // If project has Express/Fastify/etc, boost backend
-      if (/express|fastify|hono|nest|koa/.test(techStr)) {
-        const current = detectedDomains.get('backend') || 0
-        if (current > 0) detectedDomains.set('backend', current + 2)
-      }
+    const { classification } = await domainClassifier.classify(
+      taskDescription,
+      projectId,
+      globalPath,
+      context
+    )
 
-      // If project has Prisma/Drizzle/etc, boost database
-      if (/prisma|drizzle|mongoose|typeorm|sequelize/.test(techStr)) {
-        const current = detectedDomains.get('database') || 0
-        if (current > 0) detectedDomains.set('database', current + 2)
-      }
-    }
+    const domains = [classification.primaryDomain, ...classification.secondaryDomains]
 
-    // Get available agents to filter domains
-    const globalPath = pathManager.getGlobalProjectPath(projectId)
-    const availableAgents = await this.getAvailableAgentNames(globalPath)
+    // Filter to domains that have corresponding agents
+    const validDomains = domains.filter((domain) =>
+      availableAgents.some(
+        (agent) =>
+          agent === domain || agent.includes(domain) || domain.includes(agent.replace('.md', ''))
+      )
+    )
 
-    // Only include domains that have corresponding agents
-    const validDomains = Array.from(detectedDomains.entries())
-      .filter(([domain]) => {
-        // Check if agent exists for this domain
-        return availableAgents.some(
-          (agent) =>
-            agent === domain || agent.includes(domain) || domain.includes(agent.replace('.md', ''))
-        )
-      })
-      .sort((a, b) => b[1] - a[1]) // Sort by score descending
-      .map(([domain]) => domain)
-
-    // If no domains detected, default to 'general'
     if (validDomains.length === 0) {
       return { domains: ['general'], primary: 'general' }
     }
 
-    // Primary is the highest scoring domain
-    const primary = validDomains[0]
-
-    return { domains: validDomains, primary }
+    return { domains: validDomains, primary: validDomains[0] }
   }
 
   /**

package/core/agentic/prompt-builder.ts

@@ -698,6 +698,16 @@ class PromptBuilder {
       }
     }
 
+    // PRJ-264: Output schema injection for structured responses
+    const schemaType = this.getSchemaTypeForCommand(commandName)
+    if (schemaType) {
+      const { renderSchemaForPrompt } = await import('../schemas/llm-output')
+      const schemaBlock = renderSchemaForPrompt(schemaType)
+      if (schemaBlock) {
+        parts.push(`\n${schemaBlock}\n`)
+      }
+    }
+
     // Simple execution directive
     parts.push('\nEXECUTE: Follow flow. Use tools. Decide.\n')
 
@@ -775,6 +785,18 @@ class PromptBuilder {
     return result || null
   }
 
+  /**
+   * Map command names to their expected output schema type.
+   * Returns null for commands that don't need structured output.
+   */
+  private getSchemaTypeForCommand(commandName: string): string | null {
+    const schemaMap: Record<string, string> = {
+      task: 'subtaskBreakdown',
+      bug: 'classification',
+    }
+    return schemaMap[commandName] ?? null
+  }
+
   /**
    * Build critical anti-hallucination rules section
    */

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,
+    }
   }
 
   /**