prjct-cli 0.11.5 → 0.12.0

package/core/agentic/tool-registry.js

@@ -1,184 +0,0 @@
-/**
- * Tool Registry
- * Maps allowed-tools from templates to actual functions
- * Simple I/O operations - NO business logic, NO if/else
- *
- * P3.2: Added parallelization hints for multi-tool execution
- */
-
-const fs = require('fs').promises
-const path = require('path')
-const { promisify } = require('util')
-const { exec: execCallback } = require('child_process')
-const exec = promisify(execCallback)
-const dateHelper = require('../utils/date-helper')
-
-class ToolRegistry {
-  constructor() {
-    this.tools = {
-      Read: this.read.bind(this),
-      Write: this.write.bind(this),
-      Bash: this.bash.bind(this),
-      Exec: this.bash.bind(this), // Alias
-      GetTimestamp: this.getTimestamp.bind(this),
-      GetDate: this.getDate.bind(this),
-      GetDateTime: this.getDateTime.bind(this),
-    }
-
-    // P3.2: Parallelization hints
-    // Used by parallel-tools.js to optimize execution
-    this.parallelHints = {
-      Read: { parallel: true, category: 'read' },
-      Write: { parallel: false, category: 'write' },
-      Bash: { parallel: false, category: 'execute' },
-      Exec: { parallel: false, category: 'execute' },
-      GetTimestamp: { parallel: true, category: 'read' },
-      GetDate: { parallel: true, category: 'read' },
-      GetDateTime: { parallel: true, category: 'read' },
-    }
-  }
-
-  /**
-   * P3.2: Check if tool can be parallelized
-   * @param {string} toolName
-   * @returns {boolean}
-   */
-  canParallelize(toolName) {
-    return this.parallelHints[toolName]?.parallel ?? false
-  }
-
-  /**
-   * P3.2: Get tool category (read/write/execute)
-   * @param {string} toolName
-   * @returns {string}
-   */
-  getCategory(toolName) {
-    return this.parallelHints[toolName]?.category ?? 'unknown'
-  }
-
-  /**
-   * Get tool function by name
-   * @param {string} toolName - Tool name (e.g., 'Read', 'Write')
-   * @returns {Function}
-   */
-  get(toolName) {
-    const tool = this.tools[toolName]
-    if (!tool) {
-      throw new Error(`Unknown tool: ${toolName}`)
-    }
-    return tool
-  }
-
-  /**
-   * Check if tool is allowed
-   * @param {string} toolName - Tool name
-   * @param {string[]} allowedTools - List of allowed tools
-   * @returns {boolean}
-   */
-  isAllowed(toolName, allowedTools) {
-    return allowedTools.includes(toolName)
-  }
-
-  /**
-   * Read file
-   * @param {string} filePath - File path
-   * @returns {Promise<string>}
-   */
-  async read(filePath) {
-    try {
-      return await fs.readFile(filePath, 'utf-8')
-    } catch (error) {
-      return null
-    }
-  }
-
-  /**
-   * Write file
-   * @param {string} filePath - File path
-   * @param {string} content - Content to write
-   * @returns {Promise<void>}
-   */
-  async write(filePath, content) {
-    // Ensure directory exists
-    await fs.mkdir(path.dirname(filePath), { recursive: true })
-    await fs.writeFile(filePath, content, 'utf-8')
-  }
-
-  /**
-   * Execute bash command
-   * @param {string} command - Command to execute
-   * @returns {Promise<{stdout: string, stderr: string}>}
-   */
-  async bash(command) {
-    try {
-      const { stdout, stderr } = await exec(command)
-      return { stdout, stderr }
-    } catch (error) {
-      return {
-        stdout: '',
-        stderr: error.message,
-        error: true,
-      }
-    }
-  }
-
-  /**
-   * Check if file exists
-   * @param {string} filePath - File path
-   * @returns {Promise<boolean>}
-   */
-  async exists(filePath) {
-    try {
-      await fs.access(filePath)
-      return true
-    } catch {
-      return false
-    }
-  }
-
-  /**
-   * List directory
-   * @param {string} dirPath - Directory path
-   * @returns {Promise<string[]>}
-   */
-  async list(dirPath) {
-    try {
-      return await fs.readdir(dirPath)
-    } catch {
-      return []
-    }
-  }
-
-  /**
-   * Get current system timestamp (ISO format)
-   * LLM MUST use this instead of generating timestamps
-   * @returns {Promise<string>} ISO timestamp (e.g., "2025-10-07T14:30:00.000Z")
-   */
-  async getTimestamp() {
-    return dateHelper.getTimestamp()
-  }
-
-  /**
-   * Get current system date (YYYY-MM-DD)
-   * LLM MUST use this instead of generating dates
-   * @returns {Promise<string>} Date string (e.g., "2025-10-07")
-   */
-  async getDate() {
-    return dateHelper.getTodayKey()
-  }
-
-  /**
-   * Get current system date/time components
-   * @returns {Promise<Object>} Date components {timestamp, date, year, month, day}
-   */
-  async getDateTime() {
-    const now = new Date()
-    return {
-      timestamp: dateHelper.getTimestamp(),
-      date: dateHelper.getTodayKey(),
-      ...dateHelper.getYearMonthDay(now),
-    }
-  }
-}
-
-module.exports = new ToolRegistry()

package/core/agentic/validation-rules.js

@@ -1,380 +0,0 @@
-/**
- * Validation Rules
- * Explicit pre-flight checks for each command
- * Returns SPECIFIC error messages, never generic failures
- *
- * OPTIMIZATION (P0.2): Anti-Hallucination Pattern
- * - Ground truth verification before actions
- * - Specific error messages for each failure mode
- * - Actionable suggestions in every error
- *
- * Source: Claude Code, Devin, Augment Code patterns
- */
-
-const contextBuilder = require('./context-builder')
-
-/**
- * Validation result structure
- * @typedef {Object} ValidationResult
- * @property {boolean} valid - Whether validation passed
- * @property {string|null} error - Specific error message if invalid
- * @property {string|null} suggestion - Actionable next step
- * @property {Object} state - Pre-loaded state for command execution
- */
-
-/**
- * Command-specific validation rules
- * Each rule returns { valid, error, suggestion, state }
- */
-const validationRules = {
-  /**
-   * /p:done - Complete current task
-   */
-  async done(context) {
-    const state = await contextBuilder.loadStateForCommand(context, 'done')
-
-    // Check 1: now.md exists and has content
-    if (!state.now || state.now.trim() === '') {
-      return {
-        valid: false,
-        error: 'No active task to complete',
-        suggestion: 'Start a task first with /p:now "task description"',
-        state
-      }
-    }
-
-    // Check 2: Task is not a placeholder/comment
-    const content = state.now.trim()
-    if (content.startsWith('#') && content.split('\n').length === 1) {
-      return {
-        valid: false,
-        error: 'now.md contains only a header, no task description',
-        suggestion: 'Add task details or start fresh with /p:now "task"',
-        state
-      }
-    }
-
-    // Check 3: Task is not blocked
-    if (content.toLowerCase().includes('blocked') ||
-        content.toLowerCase().includes('waiting for')) {
-      return {
-        valid: false,
-        error: 'Task appears to be blocked',
-        suggestion: 'Resolve the blocker first or use /p:pause to save progress',
-        state
-      }
-    }
-
-    return { valid: true, error: null, suggestion: null, state }
-  },
-
-  /**
-   * /p:ship - Ship a feature
-   */
-  async ship(context) {
-    const state = await contextBuilder.loadStateForCommand(context, 'ship')
-
-    // Check 1: Has something to ship (now.md or recent shipped items)
-    const hasCurrentTask = state.now && state.now.trim() !== ''
-    const hasRecentShips = state.shipped && state.shipped.trim() !== ''
-
-    if (!hasCurrentTask && !hasRecentShips) {
-      return {
-        valid: false,
-        error: 'Nothing to ship yet',
-        suggestion: 'Build something first with /p:now "feature name"',
-        state
-      }
-    }
-
-    // Check 2: Feature name provided (from params)
-    if (!context.params.feature && !context.params.description) {
-      // Try to extract from now.md
-      if (hasCurrentTask) {
-        // Auto-extract feature name - this is OK
-        return { valid: true, error: null, suggestion: null, state }
-      }
-      return {
-        valid: false,
-        error: 'No feature name specified',
-        suggestion: 'Specify what to ship: /p:ship "feature name"',
-        state
-      }
-    }
-
-    return { valid: true, error: null, suggestion: null, state }
-  },
-
-  /**
-   * /p:now - Set or show current task
-   */
-  async now(context) {
-    const state = await contextBuilder.loadStateForCommand(context, 'now')
-
-    // If no task param, this is a "show" request - always valid
-    if (!context.params.task && !context.params.description) {
-      return { valid: true, error: null, suggestion: null, state }
-    }
-
-    // Check: If setting new task, warn if one exists
-    if (state.now && state.now.trim() !== '') {
-      return {
-        valid: true, // Still valid, but with warning
-        error: null,
-        suggestion: `Note: Replacing current task. Use /p:done first to track completion.`,
-        state
-      }
-    }
-
-    return { valid: true, error: null, suggestion: null, state }
-  },
-
-  /**
-   * /p:next - Show priority queue
-   */
-  async next(context) {
-    const state = await contextBuilder.loadStateForCommand(context, 'next')
-
-    if (!state.next || state.next.trim() === '' ||
-        !state.next.includes('- [')) {
-      return {
-        valid: true, // Valid but empty
-        error: null,
-        suggestion: 'Queue is empty. Add tasks with /p:feature or /p:idea',
-        state
-      }
-    }
-
-    return { valid: true, error: null, suggestion: null, state }
-  },
-
-  /**
-   * /p:idea - Capture an idea
-   */
-  async idea(context) {
-    const state = await contextBuilder.loadStateForCommand(context, 'idea')
-
-    // Check: Idea text provided
-    if (!context.params.text && !context.params.description) {
-      return {
-        valid: false,
-        error: 'No idea text provided',
-        suggestion: 'Provide your idea: /p:idea "your idea here"',
-        state
-      }
-    }
-
-    return { valid: true, error: null, suggestion: null, state }
-  },
-
-  /**
-   * /p:feature - Add a new feature
-   */
-  async feature(context) {
-    const state = await contextBuilder.loadStateForCommand(context, 'feature')
-
-    // If no description, show interactive template - valid
-    if (!context.params.description && !context.params.feature) {
-      return { valid: true, error: null, suggestion: null, state }
-    }
-
-    return { valid: true, error: null, suggestion: null, state }
-  },
-
-  /**
-   * /p:pause - Pause current task
-   */
-  async pause(context) {
-    const state = await contextBuilder.loadStateForCommand(context, 'now')
-
-    if (!state.now || state.now.trim() === '') {
-      return {
-        valid: false,
-        error: 'No active task to pause',
-        suggestion: 'Start a task first with /p:now "task"',
-        state
-      }
-    }
-
-    return { valid: true, error: null, suggestion: null, state }
-  },
-
-  /**
-   * /p:resume - Resume paused task
-   */
-  async resume(context) {
-    const state = await contextBuilder.loadState(context, ['now'])
-
-    // Check if there's a paused state to resume
-    // This would need to check a paused.md or similar
-    return { valid: true, error: null, suggestion: null, state }
-  },
-
-  /**
-   * /p:recap - Show project overview
-   */
-  async recap(context) {
-    const state = await contextBuilder.loadStateForCommand(context, 'recap')
-    return { valid: true, error: null, suggestion: null, state }
-  },
-
-  /**
-   * /p:progress - Show progress metrics
-   */
-  async progress(context) {
-    const state = await contextBuilder.loadStateForCommand(context, 'progress')
-    return { valid: true, error: null, suggestion: null, state }
-  },
-
-  /**
-   * /p:analyze - Analyze repository
-   */
-  async analyze(context) {
-    const state = await contextBuilder.loadStateForCommand(context, 'analyze')
-    return { valid: true, error: null, suggestion: null, state }
-  },
-
-  /**
-   * /p:sync - Sync project state
-   */
-  async sync(context) {
-    const state = await contextBuilder.loadStateForCommand(context, 'sync')
-    return { valid: true, error: null, suggestion: null, state }
-  },
-
-  /**
-   * /p:bug - Report a bug
-   */
-  async bug(context) {
-    const state = await contextBuilder.loadState(context, ['next'])
-
-    if (!context.params.description && !context.params.bug) {
-      return {
-        valid: false,
-        error: 'No bug description provided',
-        suggestion: 'Describe the bug: /p:bug "description of the issue"',
-        state
-      }
-    }
-
-    return { valid: true, error: null, suggestion: null, state }
-  },
-
-  /**
-   * /p:help - Show help
-   */
-  async help(context) {
-    const state = await contextBuilder.loadStateForCommand(context, 'now')
-    return { valid: true, error: null, suggestion: null, state }
-  },
-
-  /**
-   * /p:ask - Intent translator
-   */
-  async ask(context) {
-    if (!context.params.query && !context.params.question) {
-      return {
-        valid: false,
-        error: 'No question provided',
-        suggestion: 'Ask what you want to do: /p:ask "how do I..."',
-        state: {}
-      }
-    }
-
-    return { valid: true, error: null, suggestion: null, state: {} }
-  },
-
-  /**
-   * /p:suggest - Smart suggestions
-   */
-  async suggest(context) {
-    const state = await contextBuilder.loadState(context, ['now', 'next', 'shipped', 'metrics'])
-    return { valid: true, error: null, suggestion: null, state }
-  },
-
-  /**
-   * /p:spec - Spec-driven development
-   */
-  async spec(context) {
-    const state = await contextBuilder.loadState(context, ['roadmap', 'next'])
-
-    // If no feature name, this is a "show template" request - always valid
-    if (!context.params.feature && !context.params.name && !context.params.description) {
-      return {
-        valid: true,
-        error: null,
-        suggestion: 'Provide a feature name to create a spec',
-        state
-      }
-    }
-
-    // Check queue capacity for new tasks
-    const queueContent = state.next || ''
-    const taskCount = (queueContent.match(/- \[[ x]\]/g) || []).length
-    if (taskCount >= 95) {
-      return {
-        valid: false,
-        error: 'Queue almost full (95+ tasks)',
-        suggestion: 'Complete some tasks before creating a new spec. Use /p:done',
-        state
-      }
-    }
-
-    return { valid: true, error: null, suggestion: null, state }
-  }
-}
-
-/**
- * Validate command before execution
- *
- * @param {string} commandName - Command to validate
- * @param {Object} context - Built context from contextBuilder
- * @returns {Promise<ValidationResult>}
- */
-async function validate(commandName, context) {
-  const validator = validationRules[commandName]
-
-  if (!validator) {
-    // No specific validation - default to valid
-    return {
-      valid: true,
-      error: null,
-      suggestion: null,
-      state: await contextBuilder.loadState(context)
-    }
-  }
-
-  try {
-    return await validator(context)
-  } catch (error) {
-    return {
-      valid: false,
-      error: `Validation error: ${error.message}`,
-      suggestion: 'Check file permissions and project configuration',
-      state: {}
-    }
-  }
-}
-
-/**
- * Format validation error for display
- * Minimal, actionable output
- *
- * @param {ValidationResult} result - Validation result
- * @returns {string} Formatted error message
- */
-function formatError(result) {
-  if (result.valid) return null
-
-  let output = `❌ ${result.error}`
-  if (result.suggestion) {
-    output += `\n→ ${result.suggestion}`
-  }
-  return output
-}
-
-module.exports = {
-  validate,
-  formatError,
-  validationRules
-}