prjct-cli 0.5.1 → 0.7.0

package/core/agentic/command-executor.js

@@ -0,0 +1,113 @@
+/**
+ * Command Executor
+ * Executes commands using templates - Claude decides everything
+ * ZERO if/else business logic
+ */
+
+const templateLoader = require('./template-loader')
+const contextBuilder = require('./context-builder')
+const promptBuilder = require('./prompt-builder')
+const toolRegistry = require('./tool-registry')
+
+class CommandExecutor {
+  /**
+   * Execute a command agentically
+   * @param {string} commandName - Command name (e.g., 'now', 'done')
+   * @param {Object} params - Command parameters
+   * @param {string} projectPath - Project path
+   * @returns {Promise<Object>} Execution result
+   */
+  async execute(commandName, params, projectPath) {
+    try {
+      // 1. Load template
+      const template = await templateLoader.load(commandName)
+
+      // 2. Build context
+      const context = await contextBuilder.build(projectPath, params)
+
+      // 3. Load current state
+      const state = await contextBuilder.loadState(context)
+
+      // 4. Build prompt for Claude
+      const prompt = promptBuilder.build(template, context, state)
+
+      // 5. Execute (in real implementation, this would call Claude)
+      // For now, we return structured data that Claude can work with
+      return {
+        success: true,
+        template,
+        context,
+        state,
+        prompt,
+        // In production: result from Claude's execution
+      }
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message,
+      }
+    }
+  }
+
+  /**
+   * Execute tool with permission check
+   * @param {string} toolName - Tool name
+   * @param {Array} args - Tool arguments
+   * @param {string[]} allowedTools - Allowed tools for this command
+   * @returns {Promise<any>}
+   */
+  async executeTool(toolName, args, allowedTools) {
+    // 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)
+
+    // Execute tool
+    return await tool(...args)
+  }
+
+  /**
+   * Simple execution for direct tool access
+   * Used by legacy commands during migration
+   * @param {string} commandName - Command name
+   * @param {Function} executionFn - Function that uses tools
+   * @param {string} projectPath - Project path
+   * @returns {Promise<Object>}
+   */
+  async executeSimple(commandName, executionFn, projectPath) {
+    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) => this.executeTool('Read', [filePath], allowedTools),
+        write: async (filePath, content) =>
+          this.executeTool('Write', [filePath, content], allowedTools),
+        bash: async (command) => 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.message,
+      }
+    }
+  }
+}
+
+module.exports = new CommandExecutor()

package/core/agentic/context-builder.js

@@ -0,0 +1,85 @@
+/**
+ * Context Builder
+ * Builds project context for Claude to make decisions
+ * NO if/else logic - just data collection
+ */
+
+const fs = require('fs').promises
+const pathManager = require('../infrastructure/path-manager')
+const configManager = require('../infrastructure/config-manager')
+
+class ContextBuilder {
+  /**
+   * Build full project context for Claude
+   * @param {string} projectPath - Local project path
+   * @param {Object} commandParams - Command-specific parameters
+   * @returns {Promise<Object>} Context object
+   */
+  async build(projectPath, commandParams = {}) {
+    const projectId = await configManager.getProjectId(projectPath)
+    const globalPath = pathManager.getGlobalProjectPath(projectId)
+
+    return {
+      // Project identification
+      projectId,
+      projectPath,
+      globalPath,
+
+      // File paths
+      paths: {
+        now: pathManager.getFilePath(projectId, 'core', 'now.md'),
+        next: pathManager.getFilePath(projectId, 'core', 'next.md'),
+        context: pathManager.getFilePath(projectId, 'core', 'context.md'),
+        shipped: pathManager.getFilePath(projectId, 'progress', 'shipped.md'),
+        metrics: pathManager.getFilePath(projectId, 'progress', 'metrics.md'),
+        ideas: pathManager.getFilePath(projectId, 'planning', 'ideas.md'),
+        roadmap: pathManager.getFilePath(projectId, 'planning', 'roadmap.md'),
+        memory: pathManager.getFilePath(projectId, 'memory', 'context.jsonl'),
+        analysis: pathManager.getFilePath(projectId, 'analysis', 'repo-summary.md'),
+      },
+
+      // Command parameters
+      params: commandParams,
+
+      // Timestamps
+      timestamp: new Date().toISOString(),
+      date: new Date().toLocaleString(),
+    }
+  }
+
+  /**
+   * Load current project state
+   * @param {Object} context - Context from build()
+   * @returns {Promise<Object>} Current state
+   */
+  async loadState(context) {
+    const state = {}
+
+    // Read all core files
+    for (const [key, filePath] of Object.entries(context.paths)) {
+      try {
+        state[key] = await fs.readFile(filePath, 'utf-8')
+      } catch {
+        state[key] = null
+      }
+    }
+
+    return state
+  }
+
+  /**
+   * Check file existence
+   * @param {string} filePath - File path
+   * @returns {Promise<boolean>}
+   */
+  async fileExists(filePath) {
+    try {
+      await fs.access(filePath)
+      return true
+    } catch {
+      return false
+    }
+  }
+}
+
+module.exports = new ContextBuilder()

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()