prjct-cli 1.22.0 → 1.24.0

package/core/agentic/command-context.ts

@@ -1,168 +0,0 @@
-/**
- * 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' }
-}

package/core/agentic/command-executor.ts

@@ -1,471 +0,0 @@
-/**
- * Command Executor
- * Orchestrates command execution with agentic delegation.
- *
- * @module agentic/command-executor
- * @version 3.4
- */
-
-import fs from 'node:fs/promises'
-import os from 'node:os'
-import path from 'node:path'
-import type {
-  ApprovalContext,
-  ExecutionResult,
-  ExecutionToolsFn,
-  OrchestratorContext,
-  PromptContext,
-  SimpleExecutionResult,
-} from '../types'
-import { getErrorMessage } from '../types/fs'
-import { agentStream } from '../utils/agent-stream'
-import { fileExists } from '../utils/fs-helpers'
-import { printSubtaskProgress, type SubtaskDisplay } from '../utils/subtask-table'
-import chainOfThought from './chain-of-thought'
-import contextBuilder from './context-builder'
-import groundTruth from './ground-truth'
-import loopDetector from './loop-detector'
-import memorySystem from './memory-system'
-import orchestratorExecutor from './orchestrator-executor'
-import planMode from './plan-mode'
-import promptBuilder from './prompt-builder'
-import templateExecutor from './template-executor'
-import templateLoader from './template-loader'
-import toolRegistry from './tool-registry'
-
-// =============================================================================
-// Status Signal
-// =============================================================================
-
-const RUNNING_FILE = path.join(os.homedir(), '.prjct-cli', '.running')
-
-/**
- * Signal that a command is running (for status line)
- */
-export async function signalStart(commandName: string): Promise<void> {
-  try {
-    const dir = path.dirname(RUNNING_FILE)
-    if (!(await fileExists(dir))) {
-      await fs.mkdir(dir, { recursive: true })
-    }
-    await fs.writeFile(RUNNING_FILE, `/p:${commandName}`)
-  } catch (_error) {
-    // Silently ignore - status line is optional
-  }
-}
-
-/**
- * Signal that command has finished (for status line)
- */
-export async function signalEnd(): Promise<void> {
-  try {
-    if (await fileExists(RUNNING_FILE)) {
-      await fs.unlink(RUNNING_FILE)
-    }
-  } catch (_error) {
-    // Silently ignore - status line is optional
-  }
-}
-
-// =============================================================================
-// Command Executor Class
-// =============================================================================
-
-export class CommandExecutor {
-  /**
-   * Signal that a command is running (for status line)
-   */
-  async signalStart(commandName: string): Promise<void> {
-    await signalStart(commandName)
-  }
-
-  /**
-   * Signal that command has finished (for status line)
-   */
-  async signalEnd(): Promise<void> {
-    await signalEnd()
-  }
-
-  /**
-   * Execute a prjct command with full agentic delegation
-   */
-  async execute(
-    commandName: string,
-    params: Record<string, unknown>,
-    projectPath: string
-  ): Promise<ExecutionResult> {
-    // Signal start for status line
-    await this.signalStart(commandName)
-
-    // Context for loop detection
-    const loopContext = (params.task as string) || (params.description as string) || ''
-
-    // Check if we're in a loop BEFORE attempting
-    if (loopDetector.shouldEscalate(commandName, loopContext)) {
-      const escalation = loopDetector.getEscalationInfo(commandName, loopContext)
-      await this.signalEnd()
-      return {
-        success: false,
-        error: escalation?.message,
-        escalation,
-        isLoopDetected: true,
-        suggestion: escalation?.suggestion,
-      }
-    }
-
-    try {
-      // 1. Load template
-      const template = await templateLoader.load(commandName)
-
-      // 2. Build METADATA context only (lazy loading - no file reads yet)
-      const metadataContext = await contextBuilder.build(projectPath, params)
-
-      // 2.55. P3.4 PLAN MODE: Check if command requires planning
-      const requiresPlanning = planMode.requiresPlanning(commandName)
-      const isDestructive = planMode.isDestructive(commandName)
-      const isInPlanningMode = planMode.isInPlanningMode(metadataContext.projectId!)
-
-      // Start planning mode if required and not already in it
-      let activePlan = null
-      if (requiresPlanning && !isInPlanningMode && !params.skipPlanning) {
-        activePlan = planMode.startPlanning(metadataContext.projectId!, commandName, params)
-      } else if (isInPlanningMode) {
-        activePlan = planMode.getActivePlan(metadataContext.projectId!)
-      }
-
-      // 2.6. GROUND TRUTH: Verify actual state before critical operations
-      let groundTruthResult = null
-      if (groundTruth.requiresVerification(commandName)) {
-        const preState = await contextBuilder.loadStateForCommand(metadataContext, commandName)
-        groundTruthResult = await groundTruth.verify(commandName, metadataContext, preState)
-
-        // Log warnings but don't block (user can override)
-        if (!groundTruthResult.verified && groundTruthResult.warnings.length > 0) {
-          console.log(groundTruth.formatWarnings(groundTruthResult))
-        }
-      }
-
-      // 2.8. CHAIN OF THOUGHT: Reasoning for critical commands
-      let reasoning = null
-      if (chainOfThought.requiresReasoning(commandName)) {
-        const reasoningState = await contextBuilder.loadStateForCommand(
-          metadataContext,
-          commandName
-        )
-        reasoning = await chainOfThought.reason(commandName, metadataContext, reasoningState)
-
-        // If reasoning shows critical issues, warn but continue
-        if (reasoning.reasoning && !reasoning.reasoning.allPassed) {
-          console.log('⚠️  Chain of Thought detected issues:')
-          console.log(chainOfThought.formatPlan(reasoning))
-        }
-      }
-
-      // 3. AGENTIC: Template-first execution
-      // Claude decides agent assignment via templates - no hardcoded routing
-      const taskDescription = (params.task as string) || (params.description as string) || ''
-      const agenticExecContext = await templateExecutor.buildContext(
-        commandName,
-        taskDescription,
-        projectPath
-      )
-      const agenticInfo = templateExecutor.buildAgenticPrompt(agenticExecContext)
-
-      // 3.5. ORCHESTRATOR: Execute orchestration for commands that require it
-      let orchestratorContext: OrchestratorContext | null = null
-      if (templateExecutor.requiresOrchestration(commandName) && taskDescription) {
-        try {
-          orchestratorContext = await orchestratorExecutor.execute(
-            commandName,
-            taskDescription,
-            projectPath
-          )
-
-          // Show orchestration with agent stream
-          if (orchestratorContext.detectedDomains.length > 0) {
-            agentStream.orchestrate(orchestratorContext.detectedDomains)
-          }
-
-          // Show each agent being activated
-          for (const agent of orchestratorContext.agents) {
-            const domain = agent.domain || agent.name.replace('.md', '')
-            agentStream.startAgent(agent.name, domain, `Loading ${domain} specialist...`)
-            agentStream.endAgent(true)
-          }
-
-          // Show subtasks if fragmented
-          if (orchestratorContext.requiresFragmentation && orchestratorContext.subtasks) {
-            const subtaskDisplay: SubtaskDisplay[] = orchestratorContext.subtasks.map((s) => ({
-              id: s.id,
-              domain: s.domain,
-              description: s.description,
-              status: s.status,
-            }))
-            printSubtaskProgress(subtaskDisplay)
-          }
-        } catch (error) {
-          // Orchestration failed - log warning but continue without it
-          console.warn(`⚠️  Orchestrator warning: ${getErrorMessage(error)}`)
-        }
-      }
-
-      // Build context with agent routing info for Claude delegation
-      const context: PromptContext = {
-        ...metadataContext,
-        agentsPath: agenticExecContext.paths.agentsDir,
-        agentRoutingPath: agenticExecContext.paths.agentRouting,
-        orchestratorPath: agenticExecContext.paths.orchestrator,
-        taskFragmentationPath: agenticExecContext.paths.taskFragmentation,
-        agenticDelegation: true,
-        agenticMode: true,
-      }
-
-      // 6. Load state with filtered context
-      const state = await contextBuilder.loadState(metadataContext)
-
-      // 7. MEMORY: Load learned patterns AND relevant memories for this command
-      let learnedPatterns = null
-      let relevantMemories = null
-      if (metadataContext.projectId) {
-        learnedPatterns = {
-          commit_footer: await memorySystem.getSmartDecision(
-            metadataContext.projectId,
-            'commit_footer'
-          ),
-          branch_naming: await memorySystem.getSmartDecision(
-            metadataContext.projectId,
-            'branch_naming'
-          ),
-          test_before_ship: await memorySystem.getSmartDecision(
-            metadataContext.projectId,
-            'test_before_ship'
-          ),
-          preferred_agent: await memorySystem.getSmartDecision(
-            metadataContext.projectId,
-            `preferred_agent_${commandName}`
-          ),
-        }
-
-        // P3.3: Get relevant memories for context
-        relevantMemories = await memorySystem.getRelevantMemories(
-          metadataContext.projectId,
-          { commandName, params },
-          5
-        )
-      }
-
-      // 9. Build prompt - NO agent assignment here, Claude decides via templates
-      const planInfo = {
-        isPlanning: requiresPlanning || isInPlanningMode,
-        requiresApproval: isDestructive && !params.approved,
-        active: activePlan,
-        allowedTools: planMode.getAllowedTools(
-          isInPlanningMode,
-          template.frontmatter['allowed-tools'] || []
-        ),
-      }
-      // Agent is null - Claude assigns via Task tool using agent-routing.md
-      // Pass orchestratorContext for domain/agent/subtask injection
-      const prompt = await promptBuilder.build(
-        template,
-        context,
-        state,
-        null,
-        learnedPatterns,
-        null,
-        relevantMemories,
-        planInfo,
-        orchestratorContext
-      )
-
-      // Log agentic mode
-      console.log(`🤖 Template-first execution: Claude reads templates and decides`)
-      if (agenticInfo.requiresOrchestration) {
-        console.log(`   → Orchestration: ${agenticExecContext.paths.orchestrator}`)
-      }
-
-      // Record successful attempt
-      loopDetector.recordSuccess(commandName, loopContext)
-
-      // Signal end for status line
-      await this.signalEnd()
-
-      return {
-        success: true,
-        template,
-        context,
-        state,
-        prompt,
-        agenticDelegation: true,
-        agenticMode: true,
-        agenticExecContext,
-        agenticPrompt: agenticInfo.prompt,
-        requiresOrchestration: agenticInfo.requiresOrchestration,
-        agentsPath: context.agentsPath as string,
-        agentRoutingPath: context.agentRoutingPath as string,
-        orchestratorPath: agenticExecContext.paths.orchestrator,
-        taskFragmentationPath: agenticExecContext.paths.taskFragmentation,
-        reasoning,
-        groundTruth: groundTruthResult,
-        learnedPatterns,
-        relevantMemories,
-        orchestratorContext,
-        memory: {
-          create: (memory: unknown) =>
-            memorySystem.createMemory(
-              metadataContext.projectId!,
-              memory as Parameters<typeof memorySystem.createMemory>[1]
-            ),
-          autoRemember: (type: string, value: string, ctx?: string) =>
-            memorySystem.autoRemember(metadataContext.projectId!, type, value, ctx),
-          search: (query: string) => memorySystem.searchMemories(metadataContext.projectId!, query),
-          findByTags: (tags: string[]) => memorySystem.findByTags(metadataContext.projectId!, tags),
-          getStats: () => memorySystem.getMemoryStats(metadataContext.projectId!),
-        },
-        plan: {
-          active: activePlan,
-          isPlanning: requiresPlanning || isInPlanningMode,
-          isDestructive,
-          requiresApproval: isDestructive && !params.approved,
-          recordInfo: (info: unknown) =>
-            planMode.recordGatheredInfo(
-              metadataContext.projectId!,
-              info as Parameters<typeof planMode.recordGatheredInfo>[1]
-            ),
-          setAnalysis: (analysis: unknown) =>
-            planMode.setAnalysis(
-              metadataContext.projectId!,
-              analysis as Parameters<typeof planMode.setAnalysis>[1]
-            ),
-          propose: (plan: unknown) =>
-            planMode.proposePlan(
-              metadataContext.projectId!,
-              plan as Parameters<typeof planMode.proposePlan>[1]
-            ),
-          approve: (feedback?: string | null) =>
-            planMode.approvePlan(metadataContext.projectId!, feedback),
-          reject: (reason?: string | null) =>
-            planMode.rejectPlan(metadataContext.projectId!, reason),
-          getApprovalPrompt: () =>
-            planMode.generateApprovalPrompt(commandName, {
-              // Reason: `context` here is the command execution context, not the plan-mode ApprovalContext.
-              // Provide required fields with safe defaults to avoid unsafe casting.
-              changedFiles: [],
-              filesToDelete: [],
-              operation: ((): ApprovalContext['operation'] => {
-                if (commandName === 'ship') return 'git_push'
-                if (commandName === 'cleanup') return 'delete_files'
-                return 'run_command'
-              })(),
-              warnings: [],
-            } satisfies ApprovalContext),
-          startExecution: () => planMode.startExecution(metadataContext.projectId!),
-          getNextStep: () => planMode.getNextStep(metadataContext.projectId!),
-          completeStep: (result?: unknown) =>
-            planMode.completeStep(
-              metadataContext.projectId!,
-              result as Parameters<typeof planMode.completeStep>[1]
-            ),
-          failStep: (error: string) => planMode.failStep(metadataContext.projectId!, error),
-          abort: (reason?: string) => planMode.abortPlan(metadataContext.projectId!, reason),
-          getStatus: () => planMode.formatStatus(metadataContext.projectId!),
-          getAllowedTools: () =>
-            planMode.getAllowedTools(isInPlanningMode, template.frontmatter['allowed-tools'] || []),
-        },
-      }
-    } catch (error) {
-      // Signal end for status line
-      await this.signalEnd()
-
-      // Record failed attempt for loop detection
-      const attemptInfo = loopDetector.recordAttempt(commandName, loopContext, {
-        success: false,
-        error: getErrorMessage(error),
-      })
-
-      // Check if we should escalate after this failure
-      if (attemptInfo.shouldEscalate) {
-        const escalation = loopDetector.getEscalationInfo(commandName, loopContext)
-        return {
-          success: false,
-          error: escalation?.message,
-          escalation,
-          isLoopDetected: true,
-          suggestion: escalation?.suggestion,
-        }
-      }
-
-      return {
-        success: false,
-        error: getErrorMessage(error),
-        attemptNumber: attemptInfo.attemptNumber,
-        isLooping: attemptInfo.isLooping,
-      }
-    }
-  }
-
-  /**
-   * Execute tool with permission check
-   */
-  async executeTool(toolName: string, args: unknown[], allowedTools: string[]): Promise<unknown> {
-    // Check if tool is allowed
-    if (!toolRegistry.isAllowed(toolName, allowedTools)) {
-      throw new Error(`Tool ${toolName} not allowed for this command`)
-    }
-
-    // Get tool function
-    const tool = toolRegistry.get(toolName)
-    if (!tool) {
-      throw new Error(`Tool ${toolName} not found`)
-    }
-
-    // Execute tool
-    return await tool(...args)
-  }
-
-  /**
-   * Simple execution for direct tool access (legacy migration helper)
-   */
-  async executeSimple(
-    commandName: string,
-    executionFn: ExecutionToolsFn,
-    projectPath: string
-  ): Promise<SimpleExecutionResult> {
-    try {
-      // Load template to get allowed tools
-      const template = await templateLoader.load(commandName)
-      const allowedTools = template.frontmatter['allowed-tools'] || []
-
-      // Build context
-      const context = await contextBuilder.build(projectPath)
-
-      // Create tools proxy that checks permissions
-      const tools = {
-        read: async (filePath: string) => this.executeTool('Read', [filePath], allowedTools),
-        write: async (filePath: string, content: string) =>
-          this.executeTool('Write', [filePath, content], allowedTools),
-        bash: async (command: string) => this.executeTool('Bash', [command], allowedTools),
-      }
-
-      // Execute user function with tools
-      const result = await executionFn(tools, context)
-
-      return {
-        success: true,
-        result,
-      }
-    } catch (error) {
-      return {
-        success: false,
-        error: getErrorMessage(error),
-      }
-    }
-  }
-}
-
-// =============================================================================
-// Default Export
-// =============================================================================
-
-const commandExecutor = new CommandExecutor()
-export default commandExecutor