prjct-cli 0.11.5 → 0.12.0

package/core/agentic/think-blocks.ts

@@ -0,0 +1,202 @@
+/**
+ * Think Blocks
+ * Dynamic reasoning blocks for complex decisions
+ *
+ * @module agentic/think-blocks
+ * @version 1.0.0
+ */
+
+interface Context {
+  params: Record<string, unknown>
+  [key: string]: unknown
+}
+
+interface State {
+  now?: string | null
+  analysis?: string | null
+  codePatterns?: string | null
+  [key: string]: unknown
+}
+
+interface ThinkTrigger {
+  type: string
+  reason: string
+  priority: 'high' | 'medium' | 'low'
+}
+
+interface ThinkBlock {
+  trigger: ThinkTrigger
+  commandName: string
+  conclusions: string[]
+  plan: string[]
+  confidence: number
+  generatedAt: string
+}
+
+/**
+ * Detect if a think block is needed
+ */
+function detectTrigger(commandName: string, context: Context, state: State): ThinkTrigger | null {
+  // High-priority triggers (always think)
+  const highPriorityCommands = ['ship', 'cleanup', 'migrate']
+  if (highPriorityCommands.includes(commandName)) {
+    return {
+      type: 'critical_command',
+      reason: `${commandName} is a critical command requiring careful planning`,
+      priority: 'high',
+    }
+  }
+
+  // Check for complex task
+  const taskDescription = (context.params.task as string) || (context.params.description as string) || ''
+  if (taskDescription.length > 100) {
+    return {
+      type: 'complex_task',
+      reason: 'Task description is complex, requiring analysis',
+      priority: 'medium',
+    }
+  }
+
+  // Check for existing task (potential conflict)
+  if (state.now && !state.now.includes('No current task') && commandName === 'now') {
+    return {
+      type: 'task_conflict',
+      reason: 'Already has active task, need to decide how to handle',
+      priority: 'medium',
+    }
+  }
+
+  // Check if analysis exists (context-aware)
+  if (!state.analysis && ['feature', 'spec', 'design'].includes(commandName)) {
+    return {
+      type: 'missing_context',
+      reason: 'No project analysis available, may need /p:sync first',
+      priority: 'low',
+    }
+  }
+
+  // Check for code patterns
+  if (!state.codePatterns && ['now', 'build', 'fix'].includes(commandName)) {
+    return {
+      type: 'missing_patterns',
+      reason: 'No code patterns detected, may produce inconsistent code',
+      priority: 'low',
+    }
+  }
+
+  return null
+}
+
+/**
+ * Generate a think block
+ */
+async function generate(
+  trigger: ThinkTrigger,
+  commandName: string,
+  context: Context,
+  state: State
+): Promise<ThinkBlock> {
+  const conclusions: string[] = []
+  const plan: string[] = []
+  let confidence = 0.8
+
+  switch (trigger.type) {
+    case 'critical_command':
+      conclusions.push(`${commandName} requires careful execution`)
+      conclusions.push('Will verify state before proceeding')
+      plan.push('Check current state')
+      plan.push('Verify prerequisites')
+      plan.push('Execute with confirmation')
+      plan.push('Verify results')
+      confidence = 0.9
+      break
+
+    case 'complex_task':
+      conclusions.push('Task appears complex, breaking down')
+      conclusions.push('Will analyze dependencies first')
+      plan.push('Parse task requirements')
+      plan.push('Identify affected components')
+      plan.push('Create execution plan')
+      plan.push('Execute incrementally')
+      confidence = 0.7
+      break
+
+    case 'task_conflict':
+      conclusions.push('Existing task detected')
+      conclusions.push('Should complete or pause current task first')
+      plan.push('Check current task status')
+      plan.push('Decide: complete, pause, or replace')
+      plan.push('Update task state')
+      plan.push('Proceed with new task')
+      confidence = 0.6
+      break
+
+    case 'missing_context':
+      conclusions.push('Project analysis not available')
+      conclusions.push('May produce less optimal results')
+      plan.push('Proceed with available context')
+      plan.push('Note recommendation to run /p:sync')
+      confidence = 0.5
+      break
+
+    case 'missing_patterns':
+      conclusions.push('Code patterns not detected')
+      conclusions.push('Will use best-effort pattern matching')
+      plan.push('Read existing code for patterns')
+      plan.push('Match detected style')
+      plan.push('Generate consistent code')
+      confidence = 0.6
+      break
+
+    default:
+      conclusions.push('Standard execution path')
+      plan.push('Execute command as specified')
+      confidence = 0.8
+  }
+
+  return {
+    trigger,
+    commandName,
+    conclusions,
+    plan,
+    confidence,
+    generatedAt: new Date().toISOString(),
+  }
+}
+
+/**
+ * Format think block for display
+ */
+function format(thinkBlock: ThinkBlock | null, verbose: boolean = false): string {
+  if (!thinkBlock) {
+    return ''
+  }
+
+  const lines: string[] = []
+
+  if (verbose) {
+    lines.push(`🧠 Think Block: ${thinkBlock.commandName}`)
+    lines.push(`Trigger: ${thinkBlock.trigger.type} (${thinkBlock.trigger.priority})`)
+    lines.push(`Reason: ${thinkBlock.trigger.reason}`)
+    lines.push('')
+  }
+
+  lines.push('Conclusions:')
+  thinkBlock.conclusions.forEach((c) => {
+    lines.push(`  → ${c}`)
+  })
+
+  lines.push('')
+  lines.push('Plan:')
+  thinkBlock.plan.forEach((p, i) => {
+    lines.push(`  ${i + 1}. ${p}`)
+  })
+
+  lines.push('')
+  lines.push(`Confidence: ${Math.round(thinkBlock.confidence * 100)}%`)
+
+  return lines.join('\n')
+}
+
+export { detectTrigger, generate, format }
+export default { detectTrigger, generate, format }

package/core/agentic/tool-registry.ts

@@ -0,0 +1,119 @@
+/**
+ * Tool Registry
+ * Maps tool names to implementations for agentic execution.
+ *
+ * @module agentic/tool-registry
+ * @version 1.0.0
+ */
+
+import fs from 'fs/promises'
+import { exec } from 'child_process'
+import { promisify } from 'util'
+
+const execAsync = promisify(exec)
+
+type ToolFunction = (...args: unknown[]) => Promise<unknown>
+
+interface ToolRegistry {
+  tools: Map<string, ToolFunction>
+  register(name: string, fn: ToolFunction): void
+  get(name: string): ToolFunction | undefined
+  isAllowed(name: string, allowedTools: string[]): boolean
+  list(): string[]
+}
+
+const toolRegistry: ToolRegistry = {
+  tools: new Map(),
+
+  /**
+   * Register a tool
+   */
+  register(name: string, fn: ToolFunction): void {
+    this.tools.set(name, fn)
+  },
+
+  /**
+   * Get a tool by name
+   */
+  get(name: string): ToolFunction | undefined {
+    return this.tools.get(name)
+  },
+
+  /**
+   * Check if tool is allowed for command
+   */
+  isAllowed(name: string, allowedTools: string[]): boolean {
+    // If no restrictions, allow all
+    if (!allowedTools || allowedTools.length === 0) {
+      return true
+    }
+
+    // Check if tool name matches or starts with allowed pattern
+    return allowedTools.some((allowed) => {
+      if (allowed.endsWith('*')) {
+        return name.startsWith(allowed.slice(0, -1))
+      }
+      return name === allowed
+    })
+  },
+
+  /**
+   * List all registered tools
+   */
+  list(): string[] {
+    return Array.from(this.tools.keys())
+  },
+}
+
+// Register built-in tools
+
+// Read file
+toolRegistry.register('Read', async (filePath: unknown): Promise<string | null> => {
+  try {
+    return await fs.readFile(filePath as string, 'utf-8')
+  } catch {
+    return null
+  }
+})
+
+// Write file
+toolRegistry.register('Write', async (filePath: unknown, content: unknown): Promise<boolean> => {
+  try {
+    await fs.writeFile(filePath as string, content as string, 'utf-8')
+    return true
+  } catch {
+    return false
+  }
+})
+
+// Execute bash command
+toolRegistry.register('Bash', async (command: unknown): Promise<{ stdout: string; stderr: string }> => {
+  try {
+    const { stdout, stderr } = await execAsync(command as string)
+    return { stdout, stderr }
+  } catch (error) {
+    const err = error as { stdout?: string; stderr?: string; message?: string }
+    return {
+      stdout: err.stdout || '',
+      stderr: err.stderr || err.message || 'Command failed',
+    }
+  }
+})
+
+// Get current timestamp
+toolRegistry.register('GetTimestamp', async (): Promise<string> => {
+  return new Date().toISOString()
+})
+
+// Get current date
+toolRegistry.register('GetDate', async (): Promise<string> => {
+  return new Date().toISOString().split('T')[0]
+})
+
+// Get current datetime
+toolRegistry.register('GetDateTime', async (): Promise<string> => {
+  return new Date().toISOString()
+})
+
+export default toolRegistry
+export { toolRegistry }

package/core/agentic/validation-rules.ts

@@ -0,0 +1,313 @@
+/**
+ * Validation Rules
+ * Pre-flight validation for commands before execution
+ *
+ * @module agentic/validation-rules
+ * @version 1.0.0
+ */
+
+import fs from 'fs/promises'
+import path from 'path'
+import os from 'os'
+
+interface Context {
+  projectPath: string
+  projectId?: string | null
+  paths: Record<string, string>
+  params: Record<string, unknown>
+}
+
+interface ValidationResult {
+  valid: boolean
+  errors: string[]
+  warnings: string[]
+  suggestions: string[]
+}
+
+type Validator = (context: Context) => Promise<ValidationResult>
+
+/**
+ * Command-specific validators
+ */
+const validators: Record<string, Validator> = {
+  /**
+   * Validate /p:done can execute
+   */
+  async done(context): Promise<ValidationResult> {
+    const errors: string[] = []
+    const warnings: string[] = []
+    const suggestions: string[] = []
+
+    // Check if now.md exists and has content
+    try {
+      const nowContent = await fs.readFile(context.paths.now, 'utf-8')
+      if (!nowContent.trim() || nowContent.includes('No current task')) {
+        errors.push('No active task to complete')
+        suggestions.push('Start a task with /p:now "task description"')
+      }
+    } catch {
+      errors.push('now.md does not exist')
+      suggestions.push('Initialize project with /p:init')
+    }
+
+    return {
+      valid: errors.length === 0,
+      errors,
+      warnings,
+      suggestions,
+    }
+  },
+
+  /**
+   * Validate /p:ship can execute
+   */
+  async ship(context): Promise<ValidationResult> {
+    const errors: string[] = []
+    const warnings: string[] = []
+    const suggestions: string[] = []
+
+    // Check if now.md has content to ship
+    try {
+      const nowContent = await fs.readFile(context.paths.now, 'utf-8')
+      if (!nowContent.trim() || nowContent.includes('No current task')) {
+        warnings.push('No active task to ship')
+      }
+    } catch {
+      warnings.push('now.md does not exist')
+    }
+
+    // Check if shipped.md exists
+    try {
+      await fs.access(path.dirname(context.paths.shipped))
+    } catch {
+      warnings.push('shipped.md directory does not exist')
+      suggestions.push('Run /p:init to initialize project structure')
+    }
+
+    return {
+      valid: errors.length === 0,
+      errors,
+      warnings,
+      suggestions,
+    }
+  },
+
+  /**
+   * Validate /p:now can execute
+   */
+  async now(context): Promise<ValidationResult> {
+    const errors: string[] = []
+    const warnings: string[] = []
+    const suggestions: string[] = []
+
+    // Check if project is initialized
+    const configPath = path.join(context.projectPath, '.prjct/prjct.config.json')
+    try {
+      await fs.access(configPath)
+    } catch {
+      errors.push('Project not initialized')
+      suggestions.push('Run /p:init to initialize')
+    }
+
+    // Check if already has a task
+    try {
+      const nowContent = await fs.readFile(context.paths.now, 'utf-8')
+      if (nowContent.trim() && !nowContent.includes('No current task')) {
+        warnings.push('Already has an active task')
+        suggestions.push('Complete it first with /p:done')
+      }
+    } catch {
+      // now.md doesn't exist - that's ok for /p:now
+    }
+
+    return {
+      valid: errors.length === 0,
+      errors,
+      warnings,
+      suggestions,
+    }
+  },
+
+  /**
+   * Validate /p:init can execute
+   */
+  async init(context): Promise<ValidationResult> {
+    const errors: string[] = []
+    const warnings: string[] = []
+    const suggestions: string[] = []
+
+    // Check if already initialized
+    const configPath = path.join(context.projectPath, '.prjct/prjct.config.json')
+    try {
+      await fs.access(configPath)
+      warnings.push('Project already initialized')
+      suggestions.push('Use /p:sync to refresh or delete .prjct/ to reinitialize')
+    } catch {
+      // Not initialized - good
+    }
+
+    // Check if global storage is writable
+    const globalPath = path.join(os.homedir(), '.prjct-cli')
+    try {
+      await fs.mkdir(globalPath, { recursive: true })
+    } catch {
+      errors.push('Cannot create ~/.prjct-cli directory')
+      suggestions.push('Check filesystem permissions')
+    }
+
+    return {
+      valid: errors.length === 0,
+      errors,
+      warnings,
+      suggestions,
+    }
+  },
+
+  /**
+   * Validate /p:sync can execute
+   */
+  async sync(context): Promise<ValidationResult> {
+    const errors: string[] = []
+    const warnings: string[] = []
+    const suggestions: string[] = []
+
+    // Check if project is initialized
+    const configPath = path.join(context.projectPath, '.prjct/prjct.config.json')
+    try {
+      await fs.access(configPath)
+    } catch {
+      errors.push('Project not initialized')
+      suggestions.push('Run /p:init first')
+    }
+
+    return {
+      valid: errors.length === 0,
+      errors,
+      warnings,
+      suggestions,
+    }
+  },
+
+  /**
+   * Validate /p:feature can execute
+   */
+  async feature(context): Promise<ValidationResult> {
+    const errors: string[] = []
+    const warnings: string[] = []
+    const suggestions: string[] = []
+
+    // Check if project is initialized
+    const configPath = path.join(context.projectPath, '.prjct/prjct.config.json')
+    try {
+      await fs.access(configPath)
+    } catch {
+      errors.push('Project not initialized')
+      suggestions.push('Run /p:init first')
+    }
+
+    // Check if description provided
+    if (!context.params.description && !context.params.feature) {
+      warnings.push('No feature description provided')
+      suggestions.push('Provide a feature description')
+    }
+
+    return {
+      valid: errors.length === 0,
+      errors,
+      warnings,
+      suggestions,
+    }
+  },
+
+  /**
+   * Validate /p:idea can execute
+   */
+  async idea(context): Promise<ValidationResult> {
+    const errors: string[] = []
+    const warnings: string[] = []
+    const suggestions: string[] = []
+
+    // Check if project is initialized
+    const configPath = path.join(context.projectPath, '.prjct/prjct.config.json')
+    try {
+      await fs.access(configPath)
+    } catch {
+      errors.push('Project not initialized')
+      suggestions.push('Run /p:init first')
+    }
+
+    // Check if idea text provided
+    if (!context.params.idea && !context.params.text) {
+      warnings.push('No idea text provided')
+      suggestions.push('Provide idea text')
+    }
+
+    return {
+      valid: errors.length === 0,
+      errors,
+      warnings,
+      suggestions,
+    }
+  },
+}
+
+/**
+ * Validate a command before execution
+ */
+async function validate(commandName: string, context: Context): Promise<ValidationResult> {
+  const validator = validators[commandName]
+
+  if (!validator) {
+    // No specific validation needed
+    return {
+      valid: true,
+      errors: [],
+      warnings: [],
+      suggestions: [],
+    }
+  }
+
+  try {
+    return await validator(context)
+  } catch (error) {
+    return {
+      valid: false,
+      errors: [`Validation error: ${(error as Error).message}`],
+      warnings: [],
+      suggestions: ['Check file permissions and project configuration'],
+    }
+  }
+}
+
+/**
+ * Format validation errors for display
+ */
+function formatError(result: ValidationResult): string {
+  let output = ''
+
+  if (result.errors.length > 0) {
+    output += '❌ Validation Failed:\n'
+    result.errors.forEach((e) => {
+      output += `  • ${e}\n`
+    })
+  }
+
+  if (result.warnings.length > 0) {
+    output += '\n⚠️  Warnings:\n'
+    result.warnings.forEach((w) => {
+      output += `  • ${w}\n`
+    })
+  }
+
+  if (result.suggestions.length > 0) {
+    output += '\n💡 Suggestions:\n'
+    result.suggestions.forEach((s) => {
+      output += `  → ${s}\n`
+    })
+  }
+
+  return output
+}
+
+export { validate, formatError, validators }
+export default { validate, formatError, validators }

package/core/agents/index.ts

@@ -0,0 +1,28 @@
+/**
+ * Agents Module
+ *
+ * Agent performance tracking and intelligent routing.
+ *
+ * @example
+ * ```typescript
+ * import { agentPerformanceTracker } from './agents'
+ *
+ * // Record task completion
+ * await agentPerformanceTracker.recordTask(projectId, {
+ *   agentName: 'fe',
+ *   taskType: 'frontend',
+ *   success: true,
+ *   estimatedDuration: '2h',
+ *   actualDuration: '1h 45m',
+ *   qualityScore: 4,
+ *   completedAt: new Date().toISOString()
+ * })
+ *
+ * // Get agent suggestion
+ * const suggestion = await agentPerformanceTracker.suggestAgent(projectId, 'frontend')
+ * // { agentName: 'fe', confidence: 0.9, reason: 'Best success rate...' }
+ * ```
+ */
+
+export { AgentPerformanceTracker, default as agentPerformanceTracker } from './performance'
+export * from './types'