prjct-cli 0.44.1 → 0.45.3

package/core/agentic/command-executor.ts

@@ -6,30 +6,29 @@
  * @version 3.4
  */
 
-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 templateExecutor from './template-executor'
-import orchestratorExecutor from './orchestrator-executor'
-import { agentStream } from '../utils/agent-stream'
-
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
 import type {
-  OrchestratorContext,
+  ApprovalContext,
   ExecutionResult,
-  SimpleExecutionResult,
   ExecutionToolsFn,
-  ApprovalContext,
+  OrchestratorContext,
   PromptContext,
+  SimpleExecutionResult,
 } from '../types'
+import { agentStream } from '../utils/agent-stream'
+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
@@ -135,11 +134,7 @@ export class CommandExecutor {
       let groundTruthResult = null
       if (groundTruth.requiresVerification(commandName)) {
         const preState = await contextBuilder.loadStateForCommand(metadataContext, commandName)
-        groundTruthResult = await groundTruth.verify(
-          commandName,
-          metadataContext,
-          preState
-        )
+        groundTruthResult = await groundTruth.verify(commandName, metadataContext, preState)
 
         // Log warnings but don't block (user can override)
         if (!groundTruthResult.verified && groundTruthResult.warnings.length > 0) {
@@ -150,12 +145,11 @@ export class CommandExecutor {
       // 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,
+        const reasoningState = await contextBuilder.loadStateForCommand(
           metadataContext,
-          reasoningState
+          commandName
         )
+        reasoning = await chainOfThought.reason(commandName, metadataContext, reasoningState)
 
         // If reasoning shows critical issues, warn but continue
         if (reasoning.reasoning && !reasoning.reasoning.allPassed) {
@@ -225,9 +219,18 @@ export class CommandExecutor {
       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'),
+          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}`
@@ -247,7 +250,10 @@ export class CommandExecutor {
         isPlanning: requiresPlanning || isInPlanningMode,
         requiresApproval: isDestructive && !params.approved,
         active: activePlan,
-        allowedTools: planMode.getAllowedTools(isInPlanningMode, template.frontmatter['allowed-tools'] || []),
+        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
@@ -297,7 +303,10 @@ export class CommandExecutor {
         orchestratorContext,
         memory: {
           create: (memory: unknown) =>
-            memorySystem.createMemory(metadataContext.projectId!, memory as Parameters<typeof memorySystem.createMemory>[1]),
+            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),
@@ -310,12 +319,24 @@ export class CommandExecutor {
           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]),
+            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),
+            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.
@@ -331,7 +352,11 @@ export class CommandExecutor {
             } 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]),
+          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!),
@@ -408,7 +433,8 @@ export class CommandExecutor {
       // 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),
+        write: async (filePath: string, content: string) =>
+          this.executeTool('Write', [filePath, content], allowedTools),
         bash: async (command: string) => this.executeTool('Bash', [command], allowedTools),
       }
 

package/core/agentic/context-builder.ts

@@ -6,14 +6,14 @@
  * @version 0.1
  */
 
-import fs from 'fs/promises'
-import pathManager from '../infrastructure/path-manager'
+import fs from 'node:fs/promises'
 import configManager from '../infrastructure/config-manager'
+import pathManager from '../infrastructure/path-manager'
+import type { ContextPaths, ContextState, ProjectContext } from '../types'
 import { isNotFoundError } from '../types/fs'
-import type { ContextPaths, ProjectContext, ContextState } from '../types'
 
 // Re-export types for convenience
-export type { ContextPaths, ProjectContext, ContextState } from '../types'
+export type { ContextPaths, ContextState, ProjectContext } from '../types'
 
 // Local type aliases for backward compatibility
 type Paths = ContextPaths
@@ -140,7 +140,10 @@ class ContextBuilder {
     if (uncachedEntries.length > 0) {
       const readPromises = uncachedEntries.map(async ([key, filePath]) => {
         try {
-          const [content, stat] = await Promise.all([fs.readFile(filePath, 'utf-8'), fs.stat(filePath)])
+          const [content, stat] = await Promise.all([
+            fs.readFile(filePath, 'utf-8'),
+            fs.stat(filePath),
+          ])
           return { key, filePath, content, mtime: stat.mtimeMs }
         } catch (error) {
           if (isNotFoundError(error)) {

package/core/agentic/ground-truth.ts

@@ -11,10 +11,10 @@
  * Source: Devin, Cursor, Augment Code patterns
  */
 
-import fs from 'fs/promises'
-import path from 'path'
-import os from 'os'
-import { execSync } from 'child_process'
+import { execSync } from 'node:child_process'
+import fs from 'node:fs/promises'
+import os from 'node:os'
+import path from 'node:path'
 
 import type { GroundTruthContext, VerificationResult, Verifier } from '../types'
 import { isNotFoundError } from '../types/fs'
@@ -99,7 +99,7 @@ export async function verifyDone(context: GroundTruthContext): Promise<Verificat
       actual.startedAt = startedMatch[1]
       // Calculate duration
       const startTime = new Date(startedMatch[1])
-      if (!isNaN(startTime.getTime())) {
+      if (!Number.isNaN(startTime.getTime())) {
         actual.durationMs = Date.now() - startTime.getTime()
         actual.durationFormatted = formatDuration(actual.durationMs as number)
       }
@@ -174,7 +174,7 @@ export async function verifyShip(context: GroundTruthContext): Promise<Verificat
       warnings.push(`${actual.uncommittedFiles} uncommitted file(s)`)
       recommendations.push('Commit changes before shipping')
     }
-  } catch (error) {
+  } catch (_error) {
     // Git errors (not a repo, git not installed) are not blockers
     actual.gitAvailable = false
   }
@@ -341,7 +341,9 @@ export async function verifyNow(context: GroundTruthContext): Promise<Verificati
     actual.nowContent = nowContent.trim()
 
     const hasRealTask =
-      nowContent.trim().length > 0 && !nowContent.includes('No current task') && !nowContent.match(/^#\s*NOW\s*$/m)
+      nowContent.trim().length > 0 &&
+      !nowContent.includes('No current task') &&
+      !nowContent.match(/^#\s*NOW\s*$/m)
 
     actual.hasActiveTask = hasRealTask
 
@@ -426,7 +428,7 @@ export async function verifyInit(context: GroundTruthContext): Promise<Verificat
         await fs.mkdir(globalPath, { recursive: true })
         actual.globalPathWritable = true
         actual.globalPathCreated = true
-      } catch (mkdirError) {
+      } catch (_mkdirError) {
         actual.globalPathWritable = false
         warnings.push('Cannot write to ~/.prjct-cli')
         recommendations.push('Check directory permissions')
@@ -657,7 +659,11 @@ export async function verify(
  * Prepare command by verifying ground truth
  * Returns enhanced context with verification results
  */
-export async function prepareCommand(commandName: string, context: GroundTruthContext, state: unknown) {
+export async function prepareCommand(
+  commandName: string,
+  context: GroundTruthContext,
+  state: unknown
+) {
   const verification = await verify(commandName, context, state)
 
   return {

package/core/agentic/index.ts

@@ -10,178 +10,171 @@
  * - Tools: Tool registry, template loader
  */
 
-// ============ Memory ============
-// Pattern learning, semantic memories, session history
-export {
-  default as memorySystem,
-  MemorySystem,
-  CachedStore,
-  PatternStore,
-  SemanticMemories,
-  HistoryStore,
-  SessionStore,
-  MEMORY_TAGS,
-} from './memory-system'
-
-// ============ Planning ============
-// Plan mode for complex tasks
-export {
-  default as planMode,
-  PlanMode,
-  generateApprovalPrompt,
-  PLAN_STATUS,
-  PLAN_REQUIRED_COMMANDS,
-  DESTRUCTIVE_COMMANDS,
-  PLANNING_TOOLS,
-} from './plan-mode'
-
+// ============ Types ============
+// All types re-exported from ../types (canonical source)
+export type {
+  // Agent router types
+  Agent,
+  AgentInfo,
+  ApprovalContext,
+  ApprovalOperation,
+  ApprovalOption,
+  ApprovalPrompt,
+  AssignmentContext,
+  AttemptInfo,
+  AttemptRecord,
+  AttemptResult,
+  // Chain of Thought types
+  ChainOfThoughtContext,
+  ChainOfThoughtResult,
+  ChainOfThoughtState,
+  ChangedFile,
+  // Smart context types
+  ContextDomain,
+  // Context builder types
+  ContextPaths,
+  ContextState,
+  Decision,
+  DomainAnalysis,
+  // Loop Detector types
+  ErrorEntry,
+  ErrorPattern,
+  EscalationInfo,
+  // Execution types
+  ExecutionResult,
+  ExecutionToolsFn,
+  FeatureInfo,
+  FilteredContext,
+  FilterMetrics,
+  // Prompt builder types
+  Frontmatter,
+  FullContext,
+  GatheredAnalysisData,
+  GatheredFileData,
+  GatheredInfo,
+  GatheredInfoType,
+  // Ground Truth types
+  GroundTruthContext,
+  HallucinationPattern,
+  HallucinationResult,
+  HistoryEntry,
+  HistoryEventType,
+  LearnedPatterns,
+  LoadedAgent,
+  LoadedSkill,
+  // Memory types
+  Memory,
+  MemoryContext,
+  MemoryContextParams,
+  MemoryDatabase,
+  MemoryTag,
+  // Orchestrator types
+  OrchestratorContext,
+  OrchestratorSubtask,
+  OutputAnalysis,
+  PatternInfo,
+  Patterns,
+  Plan,
+  PlanAnalysis,
+  PlanInfo,
+  // Plan Mode types
+  PlanParams,
+  PlanStatus,
+  PlanStep,
+  PlanStepDefinition,
+  PlanStepResult,
+  Preference,
+  ProjectContext,
+  ProposedPlan,
+  ReasoningResult,
+  ReasoningStep,
+  SimpleExecutionResult,
+  StackInfo,
+  Template,
+  ThinkBlock,
+  // Tool registry types
+  ToolFunction,
+  ToolRegistryInterface,
+  VerificationResult,
+  Verifier,
+  Workflow,
+} from '../types'
+// ============ Routing ============
+// Agent routing and ground truth verification
+export { default as AgentRouter } from './agent-router'
+// ============ Utilities ============
+// Chain of thought, services
+export { default as chainOfThought } from './chain-of-thought'
 // ============ Execution ============
 // Command execution, loop detection
 export {
-  default as commandExecutor,
   CommandExecutor,
-  signalStart,
+  default as commandExecutor,
   signalEnd,
+  signalStart,
 } from './command-executor'
 
-export {
-  default as loopDetector,
-  LoopDetector,
-  HALLUCINATION_PATTERNS,
-  detectHallucination,
-  getHallucinationSuggestion,
-  isSimilarError,
-  analyzeErrorPattern,
-  generateEscalationMessage,
-  generateSuggestion,
-} from './loop-detector'
-
 // ============ Context ============
 // Context building and prompt generation
 export { default as contextBuilder } from './context-builder'
-export { default as smartContext } from './smart-context'
-export { default as promptBuilder } from './prompt-builder'
-
-// ============ Routing ============
-// Agent routing and ground truth verification
-export { default as AgentRouter } from './agent-router'
 export {
   default as groundTruth,
-  verify,
+  escapeRegex,
+  formatDuration,
+  formatWarnings,
   prepareCommand,
   requiresVerification,
   verifiers,
+  verify,
+  verifyAnalyze,
   verifyDone,
-  verifyShip,
   verifyFeature,
-  verifyNow,
   verifyInit,
-  verifySync,
-  verifyAnalyze,
+  verifyNow,
+  verifyShip,
   verifySpec,
-  formatDuration,
-  escapeRegex,
-  formatWarnings,
+  verifySync,
 } from './ground-truth'
-
+export {
+  analyzeErrorPattern,
+  default as loopDetector,
+  detectHallucination,
+  generateEscalationMessage,
+  generateSuggestion,
+  getHallucinationSuggestion,
+  HALLUCINATION_PATTERNS,
+  isSimilarError,
+  LoopDetector,
+} from './loop-detector'
+// ============ Memory ============
+// Pattern learning, semantic memories, session history
+export {
+  CachedStore,
+  default as memorySystem,
+  HistoryStore,
+  MEMORY_TAGS,
+  MemorySystem,
+  PatternStore,
+  SemanticMemories,
+  SessionStore,
+} from './memory-system'
+export { default as orchestratorExecutor, OrchestratorExecutor } from './orchestrator-executor'
+// ============ Planning ============
+// Plan mode for complex tasks
+export {
+  DESTRUCTIVE_COMMANDS,
+  default as planMode,
+  generateApprovalPrompt,
+  PLAN_REQUIRED_COMMANDS,
+  PLAN_STATUS,
+  PLANNING_TOOLS,
+  PlanMode,
+} from './plan-mode'
+export { default as promptBuilder } from './prompt-builder'
+export { default as services } from './services'
+export { default as smartContext } from './smart-context'
+export { default as templateExecutor, TemplateExecutor } from './template-executor'
+export { default as templateLoader } from './template-loader'
 // ============ Tools ============
 // Tool and template management
 export { default as toolRegistry } from './tool-registry'
-export { default as templateLoader } from './template-loader'
-export { default as templateExecutor, TemplateExecutor } from './template-executor'
-export { default as orchestratorExecutor, OrchestratorExecutor } from './orchestrator-executor'
-
-// ============ Utilities ============
-// Chain of thought, services
-export { default as chainOfThought } from './chain-of-thought'
-export { default as services } from './services'
-
-// ============ Types ============
-// All types re-exported from ../types (canonical source)
-export type {
-  // Memory types
-  Memory,
-  MemoryTag,
-  MemoryDatabase,
-  HistoryEntry,
-  HistoryEventType,
-  Decision,
-  Workflow,
-  Preference,
-  Patterns,
-  MemoryContext,
-  MemoryContextParams,
-  // Plan Mode types
-  PlanParams,
-  GatheredInfo,
-  GatheredInfoType,
-  GatheredFileData,
-  GatheredAnalysisData,
-  ProposedPlan,
-  PlanStepDefinition,
-  PlanStep,
-  PlanStepResult,
-  PlanStatus,
-  Plan,
-  PlanAnalysis,
-  ApprovalPrompt,
-  ApprovalOption,
-  ApprovalContext,
-  ChangedFile,
-  ApprovalOperation,
-  // Execution types
-  ExecutionResult,
-  SimpleExecutionResult,
-  ExecutionToolsFn,
-  // Loop Detector types
-  ErrorEntry,
-  AttemptRecord,
-  ErrorPattern,
-  EscalationInfo,
-  AttemptResult,
-  AttemptInfo,
-  HallucinationPattern,
-  HallucinationResult,
-  OutputAnalysis,
-  // Ground Truth types
-  GroundTruthContext,
-  VerificationResult,
-  Verifier,
-  // Tool registry types
-  ToolFunction,
-  ToolRegistryInterface,
-  // Agent router types
-  Agent,
-  AssignmentContext,
-  // Context builder types
-  ContextPaths,
-  ProjectContext,
-  ContextState,
-  // Smart context types
-  ContextDomain,
-  FullContext,
-  FilteredContext,
-  AgentInfo,
-  FeatureInfo,
-  PatternInfo,
-  StackInfo,
-  FilterMetrics,
-  DomainAnalysis,
-  // Prompt builder types
-  Frontmatter,
-  Template,
-  LearnedPatterns,
-  ThinkBlock,
-  PlanInfo,
-  // Chain of Thought types
-  ChainOfThoughtContext,
-  ChainOfThoughtState,
-  ReasoningStep,
-  ReasoningResult,
-  ChainOfThoughtResult,
-  // Orchestrator types
-  OrchestratorContext,
-  LoadedAgent,
-  LoadedSkill,
-  OrchestratorSubtask,
-} from '../types'

package/core/agentic/loop-detector.ts

@@ -17,12 +17,12 @@
  */
 
 import type {
-  ErrorEntry,
+  AttemptInfo,
   AttemptRecord,
+  AttemptResult,
+  ErrorEntry,
   ErrorPattern,
   EscalationInfo,
-  AttemptResult,
-  AttemptInfo,
   HallucinationPattern,
   HallucinationResult,
   OutputAnalysis,
@@ -38,9 +38,21 @@ import type {
  */
 export const HALLUCINATION_PATTERNS: HallucinationPattern[] = [
   // Contradictory file operations
-  { pattern: /file.*not found.*created/i, type: 'contradiction', description: 'Claims file created but also not found' },
-  { pattern: /created.*but.*error/i, type: 'contradiction', description: 'Claims success but also error' },
-  { pattern: /successfully.*failed/i, type: 'contradiction', description: 'Contradictory success/failure' },
+  {
+    pattern: /file.*not found.*created/i,
+    type: 'contradiction',
+    description: 'Claims file created but also not found',
+  },
+  {
+    pattern: /created.*but.*error/i,
+    type: 'contradiction',
+    description: 'Claims success but also error',
+  },
+  {
+    pattern: /successfully.*failed/i,
+    type: 'contradiction',
+    description: 'Contradictory success/failure',
+  },
 
   // Impossible task states
   {
@@ -48,8 +60,16 @@ export const HALLUCINATION_PATTERNS: HallucinationPattern[] = [
     type: 'state',
     description: 'Completing already-completed task',
   },
-  { pattern: /no task.*marking complete/i, type: 'state', description: 'Completing non-existent task' },
-  { pattern: /no.*active.*done with/i, type: 'state', description: 'Finishing task that doesnt exist' },
+  {
+    pattern: /no task.*marking complete/i,
+    type: 'state',
+    description: 'Completing non-existent task',
+  },
+  {
+    pattern: /no.*active.*done with/i,
+    type: 'state',
+    description: 'Finishing task that doesnt exist',
+  },
 
   // Invented data
   {
@@ -57,7 +77,11 @@ export const HALLUCINATION_PATTERNS: HallucinationPattern[] = [
     type: 'invented',
     description: 'Version update without package.json',
   },
-  { pattern: /committed.*nothing to commit/i, type: 'invented', description: 'Commit without changes' },
+  {
+    pattern: /committed.*nothing to commit/i,
+    type: 'invented',
+    description: 'Commit without changes',
+  },
   { pattern: /pushed.*no remote/i, type: 'invented', description: 'Push without remote' },
 ]
 
@@ -70,7 +94,8 @@ export const HALLUCINATION_PATTERNS: HallucinationPattern[] = [
  */
 export function getHallucinationSuggestion(type: string): string {
   const suggestions: Record<string, string> = {
-    contradiction: 'Verify file/resource state before reporting. Use Read tool to check actual state.',
+    contradiction:
+      'Verify file/resource state before reporting. Use Read tool to check actual state.',
     state: 'Check current task state from now.md before assuming completion.',
     invented: 'Verify prerequisites exist (package.json, git remote) before claiming actions.',
   }
@@ -163,7 +188,11 @@ export function analyzeErrorPattern(errors: ErrorEntry[]): ErrorPattern {
 /**
  * Generate user-friendly escalation message
  */
-export function generateEscalationMessage(command: string, errorPattern: ErrorPattern, maxAttempts: number): string {
+export function generateEscalationMessage(
+  command: string,
+  errorPattern: ErrorPattern,
+  maxAttempts: number
+): string {
   const messages: Record<string, string> = {
     permission: `I've tried ${command} ${maxAttempts} times but keep hitting permission issues.`,
     not_found: `After ${maxAttempts} attempts, I still can't find the required file or resource.`,