prjct-cli 0.20.0 → 0.20.1

package/core/__tests__/agentic/prompt-builder.test.ts

@@ -13,12 +13,12 @@ describe('PromptBuilder', () => {
 
   beforeEach(() => {
     builder = promptBuilder
-    builder._currentContext = null
+    builder.resetContext()
   })
 
   describe('Critical Rules (Compressed)', () => {
     it('should include git safety rules', () => {
-      builder._currentContext = { files: [], filteredSize: 0 }
+      builder.setContext({ files: [], filteredSize: 0 })
       const rules = builder.buildCriticalRules()
 
       expect(rules).toContain('GIT SAFETY')
@@ -27,7 +27,7 @@ describe('PromptBuilder', () => {
     })
 
     it('should include read-first requirement', () => {
-      builder._currentContext = { files: [], filteredSize: 0 }
+      builder.setContext({ files: [], filteredSize: 0 })
       const rules = builder.buildCriticalRules()
 
       expect(rules).toContain('READ FIRST')
@@ -35,21 +35,21 @@ describe('PromptBuilder', () => {
     })
 
     it('should include pattern matching requirement', () => {
-      builder._currentContext = { files: [], filteredSize: 0 }
+      builder.setContext({ files: [], filteredSize: 0 })
       const rules = builder.buildCriticalRules()
 
       expect(rules).toContain('MATCH PATTERNS')
     })
 
     it('should include no-hallucination rules', () => {
-      builder._currentContext = { files: [], filteredSize: 0 }
+      builder.setContext({ files: [], filteredSize: 0 })
       const rules = builder.buildCriticalRules()
 
       expect(rules).toContain('NO HALLUCINATIONS')
     })
 
     it('should show file count in context', () => {
-      builder._currentContext = { files: ['a.js', 'b.js', 'c.js'] }
+      builder.setContext({ files: ['a.js', 'b.js', 'c.js'] })
       const rules = builder.buildCriticalRules()
 
       expect(rules).toContain('3 files available')

package/core/__tests__/utils/project-commands.test.ts

@@ -0,0 +1,72 @@
+/**
+ * Project command detection tests
+ * Ensures prjct-cli uses the repo's own test/lint tooling (not hardcoded).
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'bun:test'
+import fs from 'fs/promises'
+import path from 'path'
+
+import { detectProjectCommands } from '../../utils/project-commands'
+
+let tmpRoot: string | null = null
+
+async function writeJson(filePath: string, data: unknown): Promise<void> {
+  await fs.mkdir(path.dirname(filePath), { recursive: true })
+  await fs.writeFile(filePath, JSON.stringify(data, null, 2), 'utf-8')
+}
+
+async function writeText(filePath: string, content: string): Promise<void> {
+  await fs.mkdir(path.dirname(filePath), { recursive: true })
+  await fs.writeFile(filePath, content, 'utf-8')
+}
+
+describe('detectProjectCommands', () => {
+  beforeEach(async () => {
+    tmpRoot = await fs.mkdtemp(path.join(process.cwd(), '.tmp', 'detect-commands-'))
+  })
+
+  afterEach(async () => {
+    if (!tmpRoot) return
+    await fs.rm(tmpRoot, { recursive: true, force: true })
+    tmpRoot = null
+  })
+
+  it('detects JS project and respects declared pnpm packageManager', async () => {
+    await writeJson(path.join(tmpRoot!, 'package.json'), {
+      name: 'x',
+      packageManager: 'pnpm@9.0.0',
+      scripts: { test: 'vitest', lint: 'eslint .', typecheck: 'tsc -p tsconfig.json' },
+    })
+
+    const detected = await detectProjectCommands(tmpRoot!)
+    expect(detected.stack).toBe('js')
+    expect(detected.packageManager).toBe('pnpm')
+    expect(detected.test?.command).toBe('pnpm test')
+    expect(detected.lint?.command).toBe('pnpm run lint')
+    expect(detected.typecheck?.command).toBe('pnpm run typecheck')
+  })
+
+  it('detects Python pytest via pytest.ini', async () => {
+    await writeText(path.join(tmpRoot!, 'pytest.ini'), '[pytest]\n')
+    const detected = await detectProjectCommands(tmpRoot!)
+    expect(detected.stack).toBe('python')
+    expect(detected.test?.command).toBe('pytest')
+  })
+
+  it('detects Go via go.mod', async () => {
+    await writeText(path.join(tmpRoot!, 'go.mod'), 'module example.com/test\n')
+    const detected = await detectProjectCommands(tmpRoot!)
+    expect(detected.stack).toBe('go')
+    expect(detected.test?.command).toBe('go test ./...')
+  })
+
+  it('detects Rust via Cargo.toml', async () => {
+    await writeText(path.join(tmpRoot!, 'Cargo.toml'), '[package]\nname="x"\nversion="0.1.0"\n')
+    const detected = await detectProjectCommands(tmpRoot!)
+    expect(detected.stack).toBe('rust')
+    expect(detected.test?.command).toBe('cargo test')
+  })
+})
+
+

package/core/agentic/agent-router.ts

@@ -15,19 +15,10 @@ import fs from 'fs/promises'
 import path from 'path'
 import configManager from '../infrastructure/config-manager'
 import pathManager from '../infrastructure/path-manager'
+import type { Agent, AssignmentContext } from '../types'
 
-interface Agent {
-  name: string
-  content: string
-}
-
-interface AssignmentContext {
-  task: string
-  availableAgents: string[]
-  projectPath: string
-  projectId: string | null
-  _template: string
-}
+// Re-export types for convenience
+export type { Agent, AssignmentContext } from '../types'
 
 /**
  * Routes tasks to specialized agents based on Claude's decisions.

package/core/agentic/command-executor.ts

@@ -1,8 +1,377 @@
 /**
  * Command Executor
- * Re-exports from command-executor/index.ts for backwards compatibility.
+ * Orchestrates command execution with agentic delegation.
+ *
+ * @module agentic/command-executor
+ * @version 3.4
  */
 
-import commandExecutor from './command-executor/index'
-export * from './command-executor/index'
+import fs from 'fs'
+import path from 'path'
+import os from 'os'
+import templateLoader from './template-loader'
+import contextBuilder from './context-builder'
+import promptBuilder from './prompt-builder'
+import toolRegistry from './tool-registry'
+import loopDetector from './loop-detector'
+import chainOfThought from './chain-of-thought'
+import memorySystem from './memory-system'
+import groundTruth from './ground-truth'
+import planMode from './plan-mode'
+
+import type {
+  ExecutionResult,
+  SimpleExecutionResult,
+  ExecutionToolsFn,
+  ApprovalContext,
+} from '../types'
+
+// =============================================================================
+// Status Signal
+// =============================================================================
+
+const RUNNING_FILE = path.join(os.homedir(), '.prjct-cli', '.running')
+
+/**
+ * Signal that a command is running (for status line)
+ */
+export function signalStart(commandName: string): void {
+  try {
+    const dir = path.dirname(RUNNING_FILE)
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true })
+    }
+    fs.writeFileSync(RUNNING_FILE, `/p:${commandName}`)
+  } catch {
+    // Silently ignore - status line is optional
+  }
+}
+
+/**
+ * Signal that command has finished (for status line)
+ */
+export function signalEnd(): void {
+  try {
+    if (fs.existsSync(RUNNING_FILE)) {
+      fs.unlinkSync(RUNNING_FILE)
+    }
+  } catch {
+    // Silently ignore - status line is optional
+  }
+}
+
+// =============================================================================
+// Command Executor Class
+// =============================================================================
+
+export class CommandExecutor {
+  /**
+   * Signal that a command is running (for status line)
+   */
+  signalStart(commandName: string): void {
+    signalStart(commandName)
+  }
+
+  /**
+   * Signal that command has finished (for status line)
+   */
+  signalEnd(): void {
+    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
+    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)
+      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 as unknown as Parameters<typeof groundTruth.verify>[1],
+          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 as unknown as Parameters<typeof chainOfThought.reason>[1],
+          reasoningState as Parameters<typeof chainOfThought.reason>[2]
+        )
+
+        // 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: Claude decides agent assignment via templates
+      let context: Record<string, unknown> = metadataContext as unknown as Record<string, unknown>
+
+      // Provide agent info to context so Claude can delegate
+      context = {
+        ...context,
+        agentsPath: path.join(os.homedir(), '.prjct-cli', 'projects', metadataContext.projectId || '', 'agents'),
+        agentRoutingPath: path.join(__dirname, '..', '..', 'templates', 'agentic', 'agent-routing.md'),
+        agenticDelegation: 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
+      const prompt = promptBuilder.build(
+        template,
+        context as Parameters<typeof promptBuilder.build>[1],
+        state,
+        null,
+        learnedPatterns,
+        null,
+        relevantMemories,
+        planInfo
+      )
+
+      // Log agentic mode
+      console.log(`🤖 Agentic delegation enabled - Claude will assign agent via Task tool`)
+
+      // Record successful attempt
+      loopDetector.recordSuccess(commandName, loopContext)
+
+      // Signal end for status line
+      this.signalEnd()
+
+      return {
+        success: true,
+        template,
+        context,
+        state,
+        prompt,
+        agenticDelegation: true,
+        agentsPath: context.agentsPath as string,
+        agentRoutingPath: context.agentRoutingPath as string,
+        reasoning,
+        groundTruth: groundTruthResult,
+        learnedPatterns,
+        relevantMemories,
+        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
+      this.signalEnd()
+
+      // Record failed attempt for loop detection
+      const attemptInfo = loopDetector.recordAttempt(commandName, loopContext, {
+        success: false,
+        error: (error as Error).message,
+      })
+
+      // 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: (error as Error).message,
+        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: (error as Error).message,
+      }
+    }
+  }
+}
+
+// =============================================================================
+// Default Export
+// =============================================================================
+
+const commandExecutor = new CommandExecutor()
 export default commandExecutor

package/core/agentic/context-builder.ts

@@ -9,35 +9,15 @@
 import fs from 'fs/promises'
 import pathManager from '../infrastructure/path-manager'
 import configManager from '../infrastructure/config-manager'
+import type { ContextPaths, ProjectContext, ContextState } from '../types'
 
-interface Paths {
-  now: string
-  next: string
-  context: string
-  shipped: string
-  metrics: string
-  ideas: string
-  roadmap: string
-  specs: string
-  memory: string
-  patterns: string
-  analysis: string
-  codePatterns: string
-}
-
-interface Context {
-  projectId: string | null
-  projectPath: string
-  globalPath: string
-  paths: Paths
-  params: Record<string, unknown>
-  timestamp: string
-  date: string
-}
+// Re-export types for convenience
+export type { ContextPaths, ProjectContext, ContextState } from '../types'
 
-interface State {
-  [key: string]: string | null
-}
+// Local type aliases for backward compatibility
+type Paths = ContextPaths
+type Context = ProjectContext
+type State = ContextState
 
 /**
  * Builds and caches project context for Claude decisions.