prjct-cli 0.6.0 → 0.7.0

package/core/domain/agent-generator.js

@@ -0,0 +1,118 @@
+const fs = require('fs').promises
+const path = require('path')
+const os = require('os')
+
+/**
+ * AgentGenerator - Dynamic agent generation for prjct-cli
+ *
+ * 100% AGENTIC - Claude decides which agents to create based on project analysis.
+ * NO predetermined patterns, NO if/else logic, NO assumptions.
+ *
+ * @version 0.6.0 - Fully agentic refactor
+ */
+class AgentGenerator {
+  constructor(projectId = null) {
+    this.projectId = projectId
+
+    // Agents are stored in global project directory
+    if (projectId) {
+      this.outputDir = path.join(os.homedir(), '.prjct-cli', 'projects', projectId, 'agents')
+    } else {
+      // Fallback for backwards compatibility
+      this.outputDir = path.join(os.homedir(), '.prjct-cli', 'agents')
+    }
+  }
+
+  /**
+   * Generate a single agent dynamically
+   * Claude (the LLM) decides which agents to create based on project analysis
+   *
+   * @param {string} agentName - Descriptive name (e.g., 'go-backend', 'vuejs-frontend', 'elixir-api')
+   * @param {Object} config - Agent configuration
+   * @param {string} config.role - Agent's role description
+   * @param {string} config.expertise - Technologies and skills (specific versions, tools)
+   * @param {string} config.responsibilities - What the agent handles in THIS project
+   * @param {Object} config.projectContext - Project-specific context (optional)
+   * @returns {Promise<void>}
+   */
+  async generateDynamicAgent(agentName, config) {
+    console.log(`   🤖 Generating ${agentName} agent...`)
+
+    // Ensure output directory exists
+    await fs.mkdir(this.outputDir, { recursive: true })
+
+    // Create agent content
+    const content = `# ${config.role || agentName}
+
+## Role
+${config.role || 'Specialist for this project'}
+
+## Expertise
+${config.expertise || 'Technologies used in this project'}
+
+## Responsibilities
+${config.responsibilities || 'Handle specific aspects of development'}
+
+## Project Context
+${config.projectContext ? JSON.stringify(config.projectContext, null, 2) : 'No additional context'}
+
+## Guidelines
+- Focus on your area of expertise
+- Collaborate with other agents
+- Follow project conventions
+- Ask clarifying questions when needed
+`
+
+    // Write agent file
+    const outputPath = path.join(this.outputDir, `${agentName}.md`)
+    await fs.writeFile(outputPath, content, 'utf-8')
+
+    console.log(`   ✅ ${agentName} agent created`)
+  }
+
+  /**
+   * Remove agents that are no longer needed
+   * @param {Array} requiredAgents - List of agents that should exist
+   * @returns {Promise<Array>} List of removed agents
+   */
+  async cleanupObsoleteAgents(requiredAgents) {
+    const removed = []
+
+    try {
+      const files = await fs.readdir(this.outputDir)
+      const agentFiles = files.filter((f) => f.endsWith('.md') && !f.startsWith('.'))
+
+      for (const file of agentFiles) {
+        const type = file.replace('.md', '')
+
+        if (!requiredAgents.includes(type)) {
+          const filePath = path.join(this.outputDir, file)
+          await fs.unlink(filePath)
+          removed.push(type)
+          console.log(`   🗑️  ${type.toUpperCase()} agent removed (no longer needed)`)
+        }
+      }
+    } catch (error) {
+      console.error('Error during cleanup:', error.message)
+    }
+
+    return removed
+  }
+
+  /**
+   * List all existing agents
+   * @returns {Promise<Array>} List of agent names
+   */
+  async listAgents() {
+    try {
+      const files = await fs.readdir(this.outputDir)
+      return files
+        .filter((f) => f.endsWith('.md') && !f.startsWith('.'))
+        .map((f) => f.replace('.md', ''))
+    } catch {
+      return []
+    }
+  }
+}
+
+module.exports = AgentGenerator

package/core/domain/analyzer.js

@@ -0,0 +1,211 @@
+const fs = require('fs').promises
+const path = require('path')
+const { promisify } = require('util')
+const { exec: execCallback } = require('child_process')
+const exec = promisify(execCallback)
+
+/**
+ * CodebaseAnalyzer - Provides helpers for project analysis
+ *
+ * 100% AGENTIC - No predetermined patterns or regex detection.
+ * Claude reads the codebase and decides what's relevant.
+ *
+ * This class only provides I/O helpers. All analysis logic
+ * is driven by Claude reading templates/analysis/analyze.md
+ *
+ * @version 0.6.0 - Fully agentic refactor
+ */
+class CodebaseAnalyzer {
+  constructor() {
+    this.projectPath = null
+  }
+
+  /**
+   * Initialize analyzer for a project
+   * @param {string} projectPath - Project path
+   */
+  init(projectPath = process.cwd()) {
+    this.projectPath = projectPath
+  }
+
+  /**
+   * Read package.json if it exists
+   * @returns {Promise<Object|null>}
+   */
+  async readPackageJson() {
+    try {
+      const packagePath = path.join(this.projectPath, 'package.json')
+      const content = await fs.readFile(packagePath, 'utf-8')
+      return JSON.parse(content)
+    } catch {
+      return null
+    }
+  }
+
+  /**
+   * Read Cargo.toml if it exists
+   * @returns {Promise<string|null>}
+   */
+  async readCargoToml() {
+    try {
+      const cargoPath = path.join(this.projectPath, 'Cargo.toml')
+      return await fs.readFile(cargoPath, 'utf-8')
+    } catch {
+      return null
+    }
+  }
+
+  /**
+   * Read requirements.txt if it exists
+   * @returns {Promise<string|null>}
+   */
+  async readRequirements() {
+    try {
+      const reqPath = path.join(this.projectPath, 'requirements.txt')
+      return await fs.readFile(reqPath, 'utf-8')
+    } catch {
+      return null
+    }
+  }
+
+  /**
+   * Read go.mod if it exists
+   * @returns {Promise<string|null>}
+   */
+  async readGoMod() {
+    try {
+      const goModPath = path.join(this.projectPath, 'go.mod')
+      return await fs.readFile(goModPath, 'utf-8')
+    } catch {
+      return null
+    }
+  }
+
+  /**
+   * List all directories in project root
+   * @returns {Promise<string[]>}
+   */
+  async listDirectories() {
+    try {
+      const entries = await fs.readdir(this.projectPath, { withFileTypes: true })
+      return entries
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => entry.name)
+        .filter((name) => !name.startsWith('.') && name !== 'node_modules')
+    } catch {
+      return []
+    }
+  }
+
+  /**
+   * Get git log (last N commits)
+   * @param {number} limit - Number of commits
+   * @returns {Promise<string>}
+   */
+  async getGitLog(limit = 50) {
+    try {
+      const { stdout } = await exec(`git log -n ${limit} --pretty=format:"%h|%an|%ar|%s"`, {
+        cwd: this.projectPath,
+      })
+      return stdout
+    } catch {
+      return ''
+    }
+  }
+
+  /**
+   * Get git statistics
+   * @returns {Promise<Object>}
+   */
+  async getGitStats() {
+    try {
+      const { stdout: totalCommits } = await exec('git rev-list --count HEAD', {
+        cwd: this.projectPath,
+      })
+
+      const { stdout: contributors } = await exec('git log --format="%an" | sort -u | wc -l', {
+        cwd: this.projectPath,
+      })
+
+      const { stdout: firstCommit } = await exec(
+        'git log --reverse --pretty=format:"%ar" | head -1',
+        { cwd: this.projectPath }
+      )
+
+      return {
+        totalCommits: parseInt(totalCommits.trim()) || 0,
+        contributors: parseInt(contributors.trim()) || 0,
+        age: firstCommit.trim() || 'unknown',
+      }
+    } catch {
+      return {
+        totalCommits: 0,
+        contributors: 0,
+        age: 'unknown',
+      }
+    }
+  }
+
+  /**
+   * Count total files (excluding common ignore patterns)
+   * @returns {Promise<number>}
+   */
+  async countFiles() {
+    try {
+      const { stdout } = await exec(
+        'find . -type f ! -path "*/node_modules/*" ! -path "*/.git/*" ! -path "*/dist/*" | wc -l',
+        { cwd: this.projectPath }
+      )
+      return parseInt(stdout.trim()) || 0
+    } catch {
+      return 0
+    }
+  }
+
+  /**
+   * Check if file exists
+   * @param {string} filename - Filename to check
+   * @returns {Promise<boolean>}
+   */
+  async fileExists(filename) {
+    try {
+      await fs.access(path.join(this.projectPath, filename))
+      return true
+    } catch {
+      return false
+    }
+  }
+
+  /**
+   * Read any file in the project
+   * @param {string} relativePath - Path relative to project root
+   * @returns {Promise<string|null>}
+   */
+  async readFile(relativePath) {
+    try {
+      const fullPath = path.join(this.projectPath, relativePath)
+      return await fs.readFile(fullPath, 'utf-8')
+    } catch {
+      return null
+    }
+  }
+
+  /**
+   * Find files matching a pattern
+   * @param {string} pattern - Glob pattern
+   * @returns {Promise<string[]>}
+   */
+  async findFiles(pattern) {
+    try {
+      const { stdout } = await exec(
+        `find . -type f -name "${pattern}" ! -path "*/node_modules/*" ! -path "*/.git/*"`,
+        { cwd: this.projectPath }
+      )
+      return stdout.trim().split('\n').filter(Boolean)
+    } catch {
+      return []
+    }
+  }
+}
+
+module.exports = new CodebaseAnalyzer()

package/core/domain/architect-session.js

@@ -0,0 +1,300 @@
+/**
+ * Architect Session Manager
+ * Handles conversational state for ARCHITECT MODE (Agent-based, not deterministic)
+ */
+
+const fs = require('fs').promises
+const path = require('path')
+
+class ArchitectSession {
+  /**
+   * Initialize new architect session
+   * @param {string} idea - Project idea
+   * @param {string} projectType - Type of project (web, api, mobile, cli, data)
+   * @param {string} globalPath - Global project path
+   * @returns {Promise<Object>} Session object
+   */
+  async init(idea, projectType, globalPath) {
+    const session = {
+      idea,
+      projectType,
+      active: true,
+      startedAt: new Date().toISOString(),
+      conversation: [], // Free-form Q&A logging
+      answers: {}, // Key insights for plan generation
+    }
+
+    await this.save(session, globalPath)
+    return session
+  }
+
+  /**
+   * Load active session
+   */
+  async load(globalPath) {
+    try {
+      const sessionPath = path.join(globalPath, 'planning', 'architect-session.json')
+      const content = await fs.readFile(sessionPath, 'utf-8')
+      return JSON.parse(content)
+    } catch {
+      return null
+    }
+  }
+
+  /**
+   * Save session to disk
+   */
+  async save(session, globalPath) {
+    const planningDir = path.join(globalPath, 'planning')
+    await fs.mkdir(planningDir, { recursive: true })
+
+    const sessionPath = path.join(planningDir, 'architect-session.json')
+    await fs.writeFile(sessionPath, JSON.stringify(session, null, 2))
+  }
+
+  /**
+   * Log a Q&A pair to the conversation
+   * @param {string} question - The question asked by Claude
+   * @param {string} answer - User's answer
+   * @param {string} globalPath - Global project path
+   */
+  async logQA(question, answer, globalPath) {
+    const session = await this.load(globalPath)
+
+    if (!session || !session.active) {
+      throw new Error('No active architect session')
+    }
+
+    session.conversation.push({
+      question,
+      answer,
+      timestamp: new Date().toISOString(),
+    })
+
+    await this.save(session, globalPath)
+  }
+
+  /**
+   * Save key insight for plan generation
+   * @param {string} key - Insight key (e.g., 'language', 'framework', 'database')
+   * @param {string} value - Insight value
+   * @param {string} globalPath - Global project path
+   */
+  async saveInsight(key, value, globalPath) {
+    const session = await this.load(globalPath)
+
+    if (!session || !session.active) {
+      throw new Error('No active architect session')
+    }
+
+    session.answers[key] = value
+    await this.save(session, globalPath)
+  }
+
+  /**
+   * Complete session and generate plan
+   * @param {string} globalPath - Global project path
+   * @returns {Promise<Object>} Summary object
+   */
+  async complete(globalPath) {
+    const session = await this.load(globalPath)
+
+    if (!session || !session.active) {
+      throw new Error('No active architect session')
+    }
+
+    // Generate plan MD
+    await this.generatePlan(session, globalPath)
+
+    // Mark session as complete
+    session.active = false
+    session.completedAt = new Date().toISOString()
+    await this.save(session, globalPath)
+
+    return this.buildSummary(session)
+  }
+
+  /**
+   * Generate architect plan MD file
+   */
+  async generatePlan(session, globalPath) {
+    const plan = this.buildPlanMarkdown(session)
+
+    const planPath = path.join(globalPath, 'planning', 'architect-session.md')
+    await fs.writeFile(planPath, plan)
+  }
+
+  /**
+   * Build plan markdown content
+   */
+  buildPlanMarkdown(session) {
+    const { projectType, idea, conversation, answers } = session
+
+    // Build conversation log
+    const conversationLog = conversation
+      .map((qa, i) => `### Q${i + 1}: ${qa.question}\n**A**: ${qa.answer}\n\n_${qa.timestamp}_`)
+      .join('\n\n')
+
+    // Build stack summary from answers
+    const stackSummary = this.buildStackSummary(answers)
+
+    // Build Context7 queries
+    const context7Queries = this.buildContext7Queries(answers)
+
+    // Build implementation steps
+    const steps = this.buildImplementationSteps(session)
+
+    return `# ARCHITECT SESSION: ${idea}
+
+## Project Idea
+${idea}
+
+## Project Type
+${projectType}
+
+## Discovery Conversation
+
+${conversationLog}
+
+## Architecture Summary
+
+**Stack:**
+${stackSummary}
+
+## Implementation Plan
+
+**Context7 Queries:**
+${context7Queries.map((q) => `- "${q}"`).join('\n')}
+
+**Implementation Steps:**
+${steps.map((step, i) => `${i + 1}. ${step}`).join('\n')}
+
+## Execution
+
+This plan is ready to be executed.
+
+**To generate code:**
+\`\`\`
+/p:architect execute
+\`\`\`
+
+The agent will:
+1. Read this architectural plan
+2. Use Context7 to fetch official documentation
+3. Generate project structure following best practices
+4. Create starter files with boilerplate code
+
+---
+Generated: ${new Date().toISOString()}
+`
+  }
+
+  /**
+   * Build stack summary from answers
+   */
+  buildStackSummary(answers) {
+    const parts = []
+
+    for (const [key, value] of Object.entries(answers)) {
+      if (value && value !== 'Ninguna' && value !== 'None' && value !== 'Otro') {
+        parts.push(`- **${key}**: ${value}`)
+      }
+    }
+
+    return parts.length > 0 ? parts.join('\n') : '- To be determined during implementation'
+  }
+
+  /**
+   * Build Context7 queries from answers
+   */
+  buildContext7Queries(answers) {
+    const queries = []
+
+    if (answers.framework) {
+      queries.push(`${answers.framework} getting started`)
+      queries.push(`${answers.framework} project structure`)
+    }
+
+    if (answers.language && answers.framework) {
+      queries.push(`${answers.language} ${answers.framework} best practices`)
+    }
+
+    if (answers.database && answers.language) {
+      queries.push(`${answers.database} ${answers.language} integration`)
+    }
+
+    if (answers.auth) {
+      queries.push(`${answers.auth} implementation ${answers.language || ''}`.trim())
+    }
+
+    // Always include general queries if specific ones not available
+    if (queries.length === 0 && answers.language) {
+      queries.push(`${answers.language} project structure`)
+      queries.push(`${answers.language} best practices`)
+    }
+
+    return queries
+  }
+
+  /**
+   * Build implementation steps from session
+   */
+  buildImplementationSteps(session) {
+    const { answers } = session
+    const steps = []
+
+    // Generic steps - Claude will refine during execution
+    if (answers.language) {
+      steps.push(`Initialize ${answers.language} project`)
+    }
+
+    if (answers.framework) {
+      steps.push(`Setup ${answers.framework}`)
+    }
+
+    if (answers.database) {
+      steps.push(`Configure ${answers.database}`)
+    }
+
+    if (answers.auth) {
+      steps.push(`Implement ${answers.auth}`)
+    }
+
+    steps.push('Create project structure')
+    steps.push('Generate starter files')
+
+    if (answers.deployment) {
+      steps.push(`Setup ${answers.deployment} configuration`)
+    }
+
+    return steps
+  }
+
+  /**
+   * Build summary of session
+   */
+  buildSummary(session) {
+    return {
+      idea: session.idea,
+      projectType: session.projectType,
+      conversationLength: session.conversation.length,
+      insights: Object.keys(session.answers).length,
+      startedAt: session.startedAt,
+      completedAt: session.completedAt || new Date().toISOString(),
+    }
+  }
+
+  /**
+   * Clear architect session
+   */
+  async clear(globalPath) {
+    try {
+      const sessionPath = path.join(globalPath, 'planning', 'architect-session.json')
+      await fs.unlink(sessionPath)
+    } catch {
+      // Ignore if doesn't exist
+    }
+  }
+}
+
+module.exports = new ArchitectSession()

package/core/{agents → infrastructure/agents}/claude-agent.js

@@ -39,9 +39,7 @@ class ClaudeAgent {
       if (global.mcp && global.mcp.filesystem) {
         return await global.mcp.filesystem.read(filePath)
       }
-    } catch (e) {
-
-    }
+    } catch (e) {}
 
     return await fs.readFile(filePath, 'utf8')
   }
@@ -54,9 +52,7 @@ class ClaudeAgent {
       if (global.mcp && global.mcp.filesystem) {
         return await global.mcp.filesystem.write(filePath, content)
       }
-    } catch (e) {
-
-    }
+    } catch (e) {}
 
     await fs.writeFile(filePath, content, 'utf8')
   }
@@ -69,9 +65,7 @@ class ClaudeAgent {
       if (global.mcp && global.mcp.filesystem) {
         return await global.mcp.filesystem.list(dirPath)
       }
-    } catch (e) {
-
-    }
+    } catch (e) {}
 
     return await fs.readdir(dirPath)
   }
@@ -131,7 +125,11 @@ ${data.recentActivity ? '\n' + data.recentActivity : ''}`
    */
   formatProgress(data) {
     const trend =
-      data.velocity > data.previousVelocity ? '📈' : data.velocity < data.previousVelocity ? '📉' : '➡️'
+      data.velocity > data.previousVelocity
+        ? '📈'
+        : data.velocity < data.previousVelocity
+          ? '📉'
+          : '➡️'
 
     return `📊 ${data.period}
 
@@ -145,14 +143,16 @@ ${data.recentFeatures || ''}`
    */
   getHelpContent(issue) {
     const helps = {
-      debugging: '🔍 1. Isolate code causing error\n2. Add logs at key points\n3. Search exact error message',
+      debugging:
+        '🔍 1. Isolate code causing error\n2. Add logs at key points\n3. Search exact error message',
       design: '🎨 1. Define problem clearly\n2. Start with simplest solution\n3. Ship MVP, iterate',
       performance:
         '⚡ 1. Profile/measure first\n2. Optimize slowest parts\n3. Cache expensive operations',
       default: '💡 1. Break into smaller tasks\n2. Start with simplest part\n3. Ship it',
     }
 
-    const helpType = Object.keys(helps).find((key) => issue.toLowerCase().includes(key)) || 'default'
+    const helpType =
+      Object.keys(helps).find((key) => issue.toLowerCase().includes(key)) || 'default'
     return helps[helpType]
   }
 
@@ -194,9 +194,12 @@ Or type /p:help to see all options`,
 Or: /p:now | /p:task | /p:idea`,
     }
 
-    return suggestions[context] || `What would you like to do?
+    return (
+      suggestions[context] ||
+      `What would you like to do?
 
 Type /p:help to see all options`
+    )
   }
 
   /**

package/core/{author-detector.js → infrastructure/author-detector.js}

@@ -175,7 +175,9 @@ class AuthorDetector {
     const recommendations = []
 
     if (!hasGitHub && !author.github) {
-      recommendations.push('Install GitHub CLI (gh) for better collaboration support: https://cli.github.com/')
+      recommendations.push(
+        'Install GitHub CLI (gh) for better collaboration support: https://cli.github.com/'
+      )
     }
 
     if (!hasGit) {