prjct-cli 0.6.0 → 0.7.1

package/core/agentic/prompt-builder.js

@@ -0,0 +1,86 @@
+/**
+ * Prompt Builder
+ * Builds prompts for Claude based on templates and context
+ * Claude decides what to do - NO if/else logic here
+ */
+
+class PromptBuilder {
+  /**
+   * Build execution prompt for Claude
+   * @param {Object} template - Template from template-loader
+   * @param {Object} context - Context from context-builder
+   * @param {Object} state - Current state from context-builder
+   * @returns {string} Prompt for Claude
+   */
+  build(template, context, state) {
+    const parts = []
+
+    // 1. Command instructions from template
+    parts.push('# Command Instructions\n')
+    parts.push(template.content)
+    parts.push('\n')
+
+    // 2. Allowed tools
+    if (template.frontmatter['allowed-tools']) {
+      parts.push('## Allowed Tools\n')
+      parts.push(`You can use: ${template.frontmatter['allowed-tools'].join(', ')}\n\n`)
+    }
+
+    // 3. Project context
+    parts.push('## Project Context\n')
+    parts.push(`- Project ID: ${context.projectId}\n`)
+    parts.push(`- Timestamp: ${context.timestamp}\n`)
+    parts.push('\n')
+
+    // 4. Current state (only non-null files)
+    parts.push('## Current State\n')
+    for (const [key, content] of Object.entries(state)) {
+      if (content && content.trim()) {
+        parts.push(`### ${key}\n`)
+        parts.push('```\n')
+        parts.push(content)
+        parts.push('\n```\n\n')
+      }
+    }
+
+    // 5. Command parameters
+    if (Object.keys(context.params).length > 0) {
+      parts.push('## Parameters\n')
+      for (const [key, value] of Object.entries(context.params)) {
+        parts.push(`- ${key}: ${value}\n`)
+      }
+      parts.push('\n')
+    }
+
+    // 6. Final instruction
+    parts.push('## Execute\n')
+    parts.push('Based on the instructions above, execute the command.\n')
+    parts.push('Use ONLY the allowed tools.\n')
+    parts.push('Make decisions based on context - do not follow rigid if/else rules.\n')
+
+    return parts.join('')
+  }
+
+  /**
+   * Build analysis prompt
+   * Used for tasks that need Claude to analyze before acting
+   * @param {string} analysisType - Type of analysis
+   * @param {Object} context - Context
+   * @returns {string} Analysis prompt
+   */
+  buildAnalysis(analysisType, context) {
+    const parts = []
+
+    parts.push(`# Analyze: ${analysisType}\n\n`)
+    parts.push('Read the project context and provide your analysis.\n')
+    parts.push('No predetermined patterns - decide based on what you find.\n\n')
+
+    parts.push('## Project Context\n')
+    parts.push(`- Path: ${context.projectPath}\n`)
+    parts.push(`- ID: ${context.projectId}\n\n`)
+
+    return parts.join('')
+  }
+}
+
+module.exports = new PromptBuilder()

package/core/agentic/template-loader.js

@@ -0,0 +1,104 @@
+/**
+ * Template Loader
+ * Loads command templates with frontmatter parsing
+ * Templates define what Claude should do - NO if/else logic
+ */
+
+const fs = require('fs').promises
+const path = require('path')
+
+class TemplateLoader {
+  constructor() {
+    this.templatesDir = path.join(__dirname, '..', '..', 'templates', 'commands')
+    this.cache = new Map()
+  }
+
+  /**
+   * Load template with frontmatter
+   * @param {string} commandName - Command name (e.g., 'now', 'done', 'ship')
+   * @returns {Promise<{frontmatter: Object, content: string}>}
+   */
+  async load(commandName) {
+    // Check cache first
+    if (this.cache.has(commandName)) {
+      return this.cache.get(commandName)
+    }
+
+    const templatePath = path.join(this.templatesDir, `${commandName}.md`)
+
+    try {
+      const rawContent = await fs.readFile(templatePath, 'utf-8')
+      const parsed = this.parseFrontmatter(rawContent)
+
+      // Cache result
+      this.cache.set(commandName, parsed)
+
+      return parsed
+    } catch (error) {
+      throw new Error(`Template not found: ${commandName}.md`)
+    }
+  }
+
+  /**
+   * Parse frontmatter from markdown
+   * @param {string} content - Raw markdown content
+   * @returns {Object} Parsed template with frontmatter and content
+   */
+  parseFrontmatter(content) {
+    const frontmatterRegex = /^---\n([\s\S]+?)\n---\n([\s\S]*)$/
+    const match = content.match(frontmatterRegex)
+
+    if (!match) {
+      return {
+        frontmatter: {},
+        content: content.trim(),
+      }
+    }
+
+    const [, frontmatterText, mainContent] = match
+    const frontmatter = {}
+
+    // Parse frontmatter lines
+    frontmatterText.split('\n').forEach((line) => {
+      const [key, ...valueParts] = line.split(':')
+      if (key && valueParts.length > 0) {
+        const value = valueParts.join(':').trim()
+
+        // Parse arrays
+        if (value.startsWith('[') && value.endsWith(']')) {
+          frontmatter[key.trim()] = value
+            .slice(1, -1)
+            .split(',')
+            .map((v) => v.trim())
+        } else {
+          // Remove quotes if present
+          frontmatter[key.trim()] = value.replace(/^["']|["']$/g, '')
+        }
+      }
+    })
+
+    return {
+      frontmatter,
+      content: mainContent.trim(),
+    }
+  }
+
+  /**
+   * Get allowed tools for a command
+   * @param {string} commandName - Command name
+   * @returns {Promise<string[]>}
+   */
+  async getAllowedTools(commandName) {
+    const template = await this.load(commandName)
+    return template.frontmatter['allowed-tools'] || []
+  }
+
+  /**
+   * Clear cache (useful for testing)
+   */
+  clearCache() {
+    this.cache.clear()
+  }
+}
+
+module.exports = new TemplateLoader()

package/core/agentic/tool-registry.js

@@ -0,0 +1,117 @@
+/**
+ * Tool Registry
+ * Maps allowed-tools from templates to actual functions
+ * Simple I/O operations - NO business logic, NO if/else
+ */
+
+const fs = require('fs').promises
+const path = require('path')
+const { promisify } = require('util')
+const { exec: execCallback } = require('child_process')
+const exec = promisify(execCallback)
+
+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
+    }
+  }
+
+  /**
+   * 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 []
+    }
+  }
+}
+
+module.exports = new ToolRegistry()

package/core/command-registry.js

@@ -20,48 +20,67 @@ const COMMANDS = [
     category: 'core',
     description: 'Deep project analysis and initialization',
     usage: {
-      claude: '/p:init',
-      terminal: 'prjct init',
+      claude: '/p:init "[idea]"',
+      terminal: 'prjct init "[idea]"',
     },
-    params: null,
+    params: '[idea]',
     implemented: true,
     hasTemplate: true,
     icon: 'Zap',
     requiresInit: false,
     blockingRules: null,
     features: [
-      'Analyzes codebase structure',
-      'Reviews docs and GitHub',
-      'Generates project summary',
-      'Creates initial roadmap',
+      'Architect mode for blank projects',
+      'Auto tech stack recommendation',
+      'Project structure generation',
+      'Initial roadmap creation',
+      'Analyzes existing codebases',
     ],
   },
 
-  // 2. Agentic Idea Evaluation
+  // 2. Feature with Roadmap (NEW - replaces idea)
   {
-    name: 'idea',
+    name: 'feature',
     category: 'core',
-    description: 'AI-powered idea evaluation with risk assessment',
+    description: 'Add feature with value analysis, roadmap, and task breakdown',
     usage: {
-      claude: '/p:idea "add dark mode"',
-      terminal: 'prjct idea "add dark mode"',
+      claude: '/p:feature "add unit testing"',
+      terminal: 'prjct feature "add unit testing"',
     },
-    params: '<text>',
-    implemented: false, // Needs agentic enhancement
+    params: '<description>',
+    implemented: true,
     hasTemplate: true,
-    icon: 'Lightbulb',
+    icon: 'Package',
     requiresInit: true,
     blockingRules: null,
     features: [
-      'Risk assessment (low/medium/high)',
-      'Time estimation',
+      'Value analysis (impact/effort/timing)',
+      'Auto roadmap generation',
       'Task breakdown',
-      'Optimal timing recommendation',
-      'ASCII decision tree',
-      'Interactive keep/discard',
+      'Auto-start first task',
+      'Timing recommendations',
     ],
   },
 
+  // DEPRECATED: Use /p:feature instead
+  {
+    name: 'idea',
+    category: 'deprecated',
+    description: '[DEPRECATED] Use /p:feature instead',
+    usage: {
+      claude: null,
+      terminal: null,
+    },
+    params: '<text>',
+    implemented: false,
+    hasTemplate: true,
+    icon: 'Lightbulb',
+    requiresInit: true,
+    blockingRules: null,
+    deprecated: true,
+    replacedBy: 'feature',
+  },
+
   // 3. Strategic Roadmap
   {
     name: 'roadmap',
@@ -72,7 +91,7 @@ const COMMANDS = [
       terminal: 'prjct roadmap',
     },
     params: null,
-    implemented: false,
+    implemented: true,
     hasTemplate: true,
     icon: 'Map',
     requiresInit: true,
@@ -95,7 +114,7 @@ const COMMANDS = [
       terminal: 'prjct status',
     },
     params: null,
-    implemented: false,
+    implemented: true,
     hasTemplate: true,
     icon: 'BarChart3',
     requiresInit: true,
@@ -136,7 +155,7 @@ const COMMANDS = [
       terminal: 'prjct build "implement auth"',
     },
     params: '<task> | [1-5]',
-    implemented: false,
+    implemented: true,
     hasTemplate: true,
     icon: 'Play',
     requiresInit: true,
@@ -209,36 +228,87 @@ const COMMANDS = [
       terminal: 'prjct ship "user authentication"',
     },
     params: '<feature>',
-    implemented: false, // Needs Git integration
+    implemented: true, // Complete automated workflow
     hasTemplate: true,
     icon: 'Rocket',
     requiresInit: true,
     blockingRules: null,
     features: [
-      'Auto-generates commit message',
-      'Adds "Generated-by: prjct/cli" footer',
-      'Interactive push confirmation',
-      'Moves to shipped.md',
-      'Completion metadata tracking',
+      'Lint checks (non-blocking)',
+      'Run tests (non-blocking)',
+      'Update docs',
+      'Update version',
+      'Update CHANGELOG',
+      'Git commit + push',
+      'Recommend compact',
+    ],
+  },
+
+  // 10. Bug Tracking
+  {
+    name: 'bug',
+    category: 'core',
+    description: 'Report and track bugs with priority',
+    usage: {
+      claude: '/p:bug "login button not working"',
+      terminal: 'prjct bug "login button not working"',
+    },
+    params: '<description>',
+    implemented: true,
+    hasTemplate: true,
+    icon: 'Bug',
+    requiresInit: true,
+    blockingRules: null,
+    features: [
+      'Auto-detect severity (critical/high/medium/low)',
+      'Priority placement in next.md',
+      'Bug tracking in memory',
+      'Quick bug resolution workflow',
+    ],
+  },
+
+  // 11. Architect Execute
+  {
+    name: 'architect',
+    category: 'core',
+    description: 'Execute architect plan and generate code',
+    usage: {
+      claude: '/p:architect execute',
+      terminal: 'prjct architect execute',
+    },
+    params: 'execute',
+    implemented: true,
+    hasTemplate: false,
+    icon: 'Hammer',
+    requiresInit: true,
+    blockingRules: null,
+    features: [
+      'Reads architect-session.md plan',
+      'Generates code structure',
+      'Uses Context7 for documentation',
+      'Language-agnostic implementation',
     ],
   },
 
   // ===== OPTIONAL COMMANDS (Advanced features) =====
+
+  // DEPRECATED: Workflow is now automatic in /p:ship
   {
     name: 'workflow',
-    category: 'optional',
-    description: 'Cascading agentic workflow for complex tasks',
+    category: 'deprecated',
+    description: '[DEPRECATED] Workflow is now automatic in /p:ship',
     usage: {
-      claude: '/p:workflow',
-      terminal: 'prjct workflow',
+      claude: null,
+      terminal: null,
     },
     params: null,
-    implemented: true,
+    implemented: false,
     hasTemplate: true,
     icon: 'GitBranch',
     requiresInit: true,
     blockingRules: null,
-    isOptional: true,
+    deprecated: true,
+    replacedBy: 'ship',
   },
   {
     name: 'design',
@@ -459,7 +529,7 @@ const registry = {
     const notImplemented = COMMANDS.filter((c) => c.hasTemplate && !c.implemented)
     if (notImplemented.length > 0) {
       issues.push(
-        `Commands with templates but not implemented: ${notImplemented.map((c) => c.name).join(', ')}`,
+        `Commands with templates but not implemented: ${notImplemented.map((c) => c.name).join(', ')}`
       )
     }
 
@@ -468,7 +538,7 @@ const registry = {
     const invalidCategories = COMMANDS.filter((c) => !validCategories.includes(c.category))
     if (invalidCategories.length > 0) {
       issues.push(
-        `Invalid categories: ${invalidCategories.map((c) => `${c.name}:${c.category}`).join(', ')}`,
+        `Invalid categories: ${invalidCategories.map((c) => `${c.name}:${c.category}`).join(', ')}`
       )
     }
 
@@ -495,36 +565,10 @@ const registry = {
 
   /**
    * Get commands with blocking rules
+   * NOTE: Blocking rules are now handled by Claude reading templates, not deterministic code
    */
   getWithBlockingRules: () => COMMANDS.filter((c) => c.blockingRules !== null),
 
-  /**
-   * Check if command can execute based on blocking rules
-   */
-  canExecute: (commandName, context = {}) => {
-    const command = COMMANDS.find((c) => c.name === commandName)
-    if (!command) return { allowed: false, message: 'Command not found' }
-    if (!command.blockingRules) return { allowed: true }
-
-    // Example context checks - should be implemented per command
-    const { hasActiveTask, hasContent } = context
-
-    if (commandName === 'build' && hasActiveTask) {
-      return { allowed: false, message: command.blockingRules.message }
-    }
-    if (commandName === 'done' && !hasContent) {
-      return { allowed: false, message: command.blockingRules.message }
-    }
-    if (commandName === 'next' && hasActiveTask) {
-      return {
-        allowed: true,
-        warning: 'You have an active task. Complete it with /p:done first.',
-      }
-    }
-
-    return { allowed: true }
-  },
-
   /**
    * Get statistics
    */
@@ -545,7 +589,7 @@ const registry = {
         ...acc,
         [cat]: COMMANDS.filter((c) => c.category === cat).length,
       }),
-      {},
+      {}
     ),
   }),
 }