prjct-cli 1.7.5 → 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

@@ -12,6 +12,7 @@
 import fs from 'node:fs/promises'
 import path from 'node:path'
 import { outcomeAnalyzer } from '../outcomes'
+import type { CommandContextEntry } from '../schemas/command-context'
 import { queueStorage, stateStorage } from '../storage'
 import type {
   LearnedPatterns,
@@ -28,6 +29,7 @@ import type {
 import { getErrorMessage, isNotFoundError } from '../types/fs'
 import { fileExists } from '../utils/fs-helpers'
 import { PACKAGE_ROOT } from '../utils/version'
+import { loadCommandContextConfig, resolveCommandContextFull } from './command-context'
 import {
   DEFAULT_BUDGETS,
   filterSkillsByDomains,
@@ -144,18 +146,14 @@ class PromptBuilder {
 
   /**
    * Get additional modules needed for SMART commands (PRJ-94)
-   * Returns array of module names that should be injected
+   * Now config-driven via command-context.config.json (PRJ-298)
    */
-  getModulesForCommand(commandName: string): string[] {
-    const smartCommands: Record<string, string[]> = {
-      task: ['CLAUDE-intelligence.md', 'CLAUDE-storage.md'],
-      ship: ['CLAUDE-intelligence.md', 'CLAUDE-storage.md'],
-      bug: ['CLAUDE-intelligence.md'],
-      done: ['CLAUDE-storage.md'],
-      work: ['CLAUDE-intelligence.md', 'CLAUDE-storage.md'],
-      spec: ['CLAUDE-intelligence.md'],
-    }
-    return smartCommands[commandName] || []
+  getModulesForCommand(_commandName: string, commandContext?: CommandContextEntry): string[] {
+    if (commandContext) {
+      return commandContext.modules
+    }
+    // Fallback if called without config (shouldn't happen after PRJ-298)
+    return []
   }
 
   /**
@@ -411,21 +409,20 @@ class PromptBuilder {
     // Store context for use in helper methods
     this._currentContext = context
 
-    // Agent assignment (CONDITIONAL - only for code-modifying commands)
+    // PRJ-298: Config-driven command context (replaces 4 hardcoded lists)
     const commandName = template.frontmatter?.name?.replace('p:', '') || ''
-    const agentCommands = [
-      'now',
-      'build',
-      'feature',
-      'design',
-      'fix',
-      'bug',
-      'test',
-      'work',
-      'cleanup',
-      'spec',
-    ]
-    const needsAgent = agentCommands.includes(commandName)
+    let commandContext: CommandContextEntry
+    try {
+      const config = await loadCommandContextConfig()
+      const resolved = resolveCommandContextFull(config, commandName, template)
+      commandContext = resolved.entry
+    } catch {
+      // Fallback: sensible defaults if config fails to load
+      commandContext = { agents: true, patterns: true, checklist: false, modules: [] }
+    }
+
+    // Agent assignment (config-driven)
+    const needsAgent = commandContext.agents
 
     if (agent && needsAgent) {
       parts.push(`# AGENT: ${agent.name}\n`)
@@ -591,21 +588,8 @@ class PromptBuilder {
       )
     }
 
-    // OPTIMIZED: Only include patterns for code-modifying commands
-    const codeCommands = [
-      'now',
-      'build',
-      'feature',
-      'design',
-      'cleanup',
-      'fix',
-      'bug',
-      'test',
-      'init',
-      'spec',
-      'work',
-    ]
-    const needsPatterns = codeCommands.includes(commandName)
+    // OPTIMIZED: Only include patterns for code-modifying commands (config-driven, PRJ-298)
+    const needsPatterns = commandContext.patterns
 
     // Include code patterns analysis for code-modifying commands
     const codePatternsContent = state?.codePatterns || ''
@@ -636,8 +620,8 @@ class PromptBuilder {
     // CRITICAL: Compressed rules
     parts.push(this.buildCriticalRules())
 
-    // PRJ-94: Inject additional modules for SMART commands
-    const additionalModules = this.getModulesForCommand(commandName)
+    // PRJ-94/PRJ-298: Inject additional modules for SMART commands (config-driven)
+    const additionalModules = this.getModulesForCommand(commandName, commandContext)
     if (additionalModules.length > 0) {
       for (const moduleName of additionalModules) {
         const moduleContent = await this.loadModule(moduleName)
@@ -698,19 +682,8 @@ class PromptBuilder {
       )
     }
 
-    // P4.1: Quality Checklists
-    const checklistCommands = [
-      'now',
-      'build',
-      'feature',
-      'design',
-      'fix',
-      'bug',
-      'cleanup',
-      'spec',
-      'work',
-    ]
-    if (checklistCommands.includes(commandName)) {
+    // P4.1: Quality Checklists (config-driven, PRJ-298)
+    if (commandContext.checklist) {
       const routing = await this.loadChecklistRouting()
       const checklists = await this.loadChecklists()
 
@@ -725,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')
 
@@ -802,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}`
+}