prjct-cli 0.11.5 → 0.12.1

package/core/commands/planning.ts

@@ -0,0 +1,311 @@
+/**
+ * Planning Commands: init, feature, bug, architect
+ */
+
+import path from 'path'
+
+import type { CommandResult, AnalyzeOptions, Context } from './types'
+import {
+  PrjctCommandsBase,
+  contextBuilder,
+  toolRegistry,
+  pathManager,
+  configManager,
+  fileHelper,
+  dateHelper,
+  out
+} from './base'
+import authorDetector from '../infrastructure/author-detector'
+
+export class PlanningCommands extends PrjctCommandsBase {
+  /**
+   * /p:init - Initialize prjct project
+   */
+  async init(idea: string | null = null, projectPath: string = process.cwd()): Promise<CommandResult> {
+    try {
+      await this.initializeAgent()
+
+      const isConfigured = await configManager.isConfigured(projectPath)
+
+      if (isConfigured) {
+        out.warn('already initialized')
+        return { success: false, message: 'Already initialized' }
+      }
+
+      out.spin('initializing...')
+
+      const detectedAuthor = await authorDetector.detect()
+      // Convert null to undefined for createConfig
+      const author = {
+        name: detectedAuthor.name || undefined,
+        email: detectedAuthor.email || undefined,
+        github: detectedAuthor.github || undefined
+      }
+      const config = await configManager.createConfig(projectPath, author)
+      const projectId = config.projectId
+
+      out.spin('creating structure...')
+
+      await pathManager.ensureProjectStructure(projectId)
+      const globalPath = pathManager.getGlobalProjectPath(projectId)
+
+      const baseFiles: Record<string, string> = {
+        'core/now.md': '# NOW\n\nNo current task. Use `/p:now` to set focus.\n',
+        'core/next.md': '# NEXT\n\n## Priority Queue\n\n',
+        'core/context.md': '# CONTEXT\n\n',
+        'progress/shipped.md': '# SHIPPED 🚀\n\n',
+        'progress/metrics.md': '# METRICS\n\n',
+        'planning/ideas.md': '# IDEAS 💡\n\n## Brain Dump\n\n',
+        'planning/roadmap.md': '# ROADMAP\n\n',
+        'planning/specs/.gitkeep': '# Specs directory - created by /p:spec\n',
+        'memory/context.jsonl': '',
+        'memory/patterns.json': JSON.stringify({
+          version: 1,
+          decisions: {},
+          preferences: {},
+          workflows: {},
+          counters: {}
+        }, null, 2),
+      }
+
+      for (const [filePath, content] of Object.entries(baseFiles)) {
+        await toolRegistry.get('Write')!(path.join(globalPath, filePath), content)
+      }
+
+      const isEmpty = await this._detectEmptyDirectory(projectPath)
+      const hasCode = await this._detectExistingCode(projectPath)
+
+      if (hasCode || !isEmpty) {
+        out.spin('analyzing project...')
+        const analysisResult = await (this as unknown as { analyze: (options: AnalyzeOptions, projectPath: string) => Promise<CommandResult> }).analyze({}, projectPath)
+
+        if (analysisResult.success) {
+          out.spin('generating agents...')
+          await (this as unknown as { sync: (projectPath: string) => Promise<CommandResult> }).sync(projectPath)
+          out.done('initialized')
+          return { success: true, mode: 'existing', projectId }
+        }
+      }
+
+      if (isEmpty && !hasCode) {
+        if (!idea) {
+          out.done('blank project - provide idea for architect mode')
+          return { success: true, mode: 'blank_no_idea', projectId }
+        }
+
+        out.spin('architect mode...')
+        const sessionPath = path.join(globalPath, 'planning', 'architect-session.md')
+        const sessionContent = `# Architect Session\n\n## Idea\n${idea}\n\n## Status\nInitialized - awaiting stack recommendation\n\nGenerated: ${new Date().toLocaleString()}\n`
+        await toolRegistry.get('Write')!(sessionPath, sessionContent)
+
+        const commandInstaller = require('../infrastructure/command-installer')
+        await commandInstaller.installGlobalConfig()
+
+        out.done('architect mode ready')
+        return { success: true, mode: 'architect', projectId, idea }
+      }
+
+      const commandInstaller = require('../infrastructure/command-installer')
+      await commandInstaller.installGlobalConfig()
+
+      out.done('initialized')
+      return { success: true, projectId }
+    } catch (error) {
+      out.fail((error as Error).message)
+      return { success: false, error: (error as Error).message }
+    }
+  }
+
+  /**
+   * /p:feature - Add feature with value analysis, roadmap, and task breakdown
+   */
+  async feature(description: string, projectPath: string = process.cwd()): Promise<CommandResult> {
+    try {
+      const initResult = await this.ensureProjectInit(projectPath)
+      if (!initResult.success) return initResult
+
+      if (!description) {
+        out.fail('description required')
+        return { success: false, error: 'Description required' }
+      }
+
+      out.spin(`planning ${description}...`)
+
+      const context = await contextBuilder.build(projectPath, { description }) as Context
+      const tasks = this._breakdownFeatureTasks(description)
+
+      const tasksWithAgents: { task: string; agent: string }[] = []
+      for (const taskDesc of tasks) {
+        const agentResult = await this._assignAgentForTask(taskDesc, projectPath, context)
+        const agent = agentResult.agent?.name || 'generalist'
+        tasksWithAgents.push({ task: taskDesc, agent })
+      }
+
+      const nextContent =
+        (await toolRegistry.get('Read')!(context.paths.next) as string) || '# NEXT\n\n## Priority Queue\n\n'
+      const taskSection =
+        `\n## Feature: ${description}\n\n` +
+        tasksWithAgents.map((t, i) => `${i + 1}. [${t.agent}] [ ] ${t.task}`).join('\n') +
+        `\n\nEstimated: ${tasks.length * 2}h\n`
+
+      await toolRegistry.get('Write')!(context.paths.next, nextContent + taskSection)
+
+      await this.logToMemory(projectPath, 'feature_planned', {
+        feature: description,
+        tasks: tasksWithAgents.length,
+        assignments: tasksWithAgents.map(t => ({ task: t.task, agent: t.agent })),
+        timestamp: dateHelper.getTimestamp(),
+      })
+
+      const agentCounts = tasksWithAgents.reduce((acc: Record<string, number>, t) => {
+        acc[t.agent] = (acc[t.agent] || 0) + 1
+        return acc
+      }, {})
+      const agentSummary = Object.entries(agentCounts).map(([a, c]) => `${a}:${c}`).join(' ')
+
+      out.done(`${tasks.length} tasks [${agentSummary}]`)
+
+      return { success: true, feature: description, tasks: tasksWithAgents }
+    } catch (error) {
+      out.fail((error as Error).message)
+      return { success: false, error: (error as Error).message }
+    }
+  }
+
+  /**
+   * /p:bug - Report and track bugs with auto-prioritization
+   */
+  async bug(description: string, projectPath: string = process.cwd()): Promise<CommandResult> {
+    try {
+      const initResult = await this.ensureProjectInit(projectPath)
+      if (!initResult.success) return initResult
+
+      if (!description) {
+        out.fail('bug description required')
+        return { success: false, error: 'Description required' }
+      }
+
+      out.spin('tracking bug...')
+
+      const context = await contextBuilder.build(projectPath, { description }) as Context
+      const severity = this._detectBugSeverity(description)
+
+      const agentResult = await this._assignAgentForTask(`fix bug: ${description}`, projectPath, context)
+      const agent = agentResult.agent?.name || 'generalist'
+
+      const nextContent =
+        (await toolRegistry.get('Read')!(context.paths.next) as string) || '# NEXT\n\n## Priority Queue\n\n'
+      const bugEntry = `\n## 🐛 BUG [${severity.toUpperCase()}] [${agent}]: ${description}\n\nReported: ${new Date().toLocaleString()}\nPriority: ${severity === 'critical' ? '⚠️ URGENT' : severity === 'high' ? '🔴 High' : '🟡 Normal'}\nAssigned: ${agent}\n`
+
+      const updatedContent =
+        severity === 'critical' || severity === 'high'
+          ? nextContent.replace('## Priority Queue\n\n', `## Priority Queue\n\n${bugEntry}\n`)
+          : nextContent + bugEntry
+
+      await toolRegistry.get('Write')!(context.paths.next, updatedContent)
+
+      await this.logToMemory(projectPath, 'bug_reported', {
+        bug: description,
+        severity,
+        agent,
+        timestamp: dateHelper.getTimestamp(),
+      })
+
+      out.done(`bug [${severity}] → ${agent}`)
+
+      return { success: true, bug: description, severity, agent }
+    } catch (error) {
+      out.fail((error as Error).message)
+      return { success: false, error: (error as Error).message }
+    }
+  }
+
+  /**
+   * /p:architect - Execute architect plan and generate code
+   */
+  async architect(action: string = 'execute', projectPath: string = process.cwd()): Promise<CommandResult> {
+    if (action !== 'execute') {
+      return {
+        success: false,
+        message: '❌ Invalid action. Use: /p:architect execute',
+      }
+    }
+
+    try {
+      const initResult = await this.ensureProjectInit(projectPath)
+      if (!initResult.success) return initResult
+
+      console.log('🏗️  Architect Mode - Code Generation\n')
+
+      const globalPath = await this.getGlobalProjectPath(projectPath)
+      const planPath = path.join(globalPath, 'planning', 'architect-session.md')
+
+      let planContent: string
+      try {
+        planContent = await fileHelper.readFile(planPath)
+      } catch {
+        return {
+          success: false,
+          message:
+            '❌ No architect plan found.\n\n' +
+            'Create a plan first:\n' +
+            '  1. Run /p:init in an empty directory\n' +
+            '  2. Answer the discovery questions\n' +
+            '  3. Plan will be auto-generated\n' +
+            '  4. Then run /p:architect execute',
+        }
+      }
+
+      if (!planContent || planContent.trim() === '') {
+        return {
+          success: false,
+          message: '❌ Architect plan is empty',
+        }
+      }
+
+      console.log('📋 Reading architect plan...\n')
+
+      const ideaMatch = planContent.match(/## Project Idea\n(.+)/s)
+      const stackMatch = planContent.match(/\*\*Stack:\*\*\n([\s\S]+?)\n\n/)
+      const stepsMatch = planContent.match(/\*\*Implementation Steps:\*\*\n([\s\S]+?)\n\n/)
+
+      const idea = ideaMatch ? ideaMatch[1].split('\n')[0].trim() : 'Unknown project'
+      const stack = stackMatch ? stackMatch[1] : 'Not specified'
+      const steps = stepsMatch ? stepsMatch[1] : 'Not specified'
+
+      console.log(`📝 Project: ${idea}`)
+      console.log(`\n🔧 Stack:\n${stack}`)
+      console.log(`\n📋 Implementation Steps:\n${steps}`)
+
+      console.log('\n' + '='.repeat(60))
+      console.log('🤖 READY TO GENERATE CODE')
+      console.log('='.repeat(60))
+
+      console.log(
+        '\nThe architect plan is ready. Claude will now:\n' +
+          '  1. Read the architectural plan\n' +
+          '  2. Use Context7 for official documentation\n' +
+          '  3. Generate project structure\n' +
+          '  4. Create starter files with boilerplate\n'
+      )
+
+      console.log('\n💡 This command shows the plan.')
+      console.log('   For code generation, Claude Code will read this plan')
+      console.log('   and generate the structure automatically.\n')
+
+      await this.logToMemory(projectPath, 'architect_executed', {
+        timestamp: dateHelper.getTimestamp(),
+        idea,
+      })
+
+      return {
+        success: true,
+        plan: planContent,
+        idea,
+      }
+    } catch (error) {
+      console.error('❌ Error:', (error as Error).message)
+      return { success: false, error: (error as Error).message }
+    }
+  }
+}

package/core/commands/setup.ts

@@ -0,0 +1,309 @@
+/**
+ * Setup Commands: start, setup, migrateAll, installStatusLine, showAsciiArt
+ */
+
+import path from 'path'
+import fs from 'fs'
+import os from 'os'
+
+import migrator from '../infrastructure/migrator'
+import type { CommandResult, SetupOptions, MigrateOptions, GlobalConfig, MigrationResult } from './types'
+import {
+  PrjctCommandsBase,
+  configManager,
+  dateHelper
+} from './base'
+import { VERSION } from '../utils/version'
+
+export class SetupCommands extends PrjctCommandsBase {
+  /**
+   * First-time setup - Install commands to editors
+   */
+  async start(): Promise<CommandResult> {
+    const commandInstaller = require('../infrastructure/command-installer')
+
+    console.log('🚀 Setting up prjct for Claude...\n')
+
+    const status = await commandInstaller.checkInstallation()
+
+    if (!status.claudeDetected) {
+      return {
+        success: false,
+        message:
+          '❌ Claude not detected.\n\nPlease install Claude Code or Claude Desktop first:\n' +
+          '  - Claude Code: https://claude.com/code\n' +
+          '  - Claude Desktop: https://claude.com/desktop',
+      }
+    }
+
+    console.log('📦 Installing /p:* commands...')
+    const result = await commandInstaller.installCommands()
+
+    if (!result.success) {
+      return {
+        success: false,
+        message: `❌ Installation failed: ${result.error}`,
+      }
+    }
+
+    console.log(`\n✅ Installed ${result.installed.length} commands to:\n   ${result.path}`)
+
+    if (result.errors.length > 0) {
+      console.log(`\n⚠️  ${result.errors.length} errors:`)
+      result.errors.forEach((e: { file: string; error: string }) => console.log(`   - ${e.file}: ${e.error}`))
+    }
+
+    console.log('\n🎉 Setup complete!')
+    console.log('\nNext steps:')
+    console.log('  1. Open Claude Code or Claude Desktop')
+    console.log('  2. Navigate to your project')
+    console.log('  3. Run: /p:init')
+
+    return {
+      success: true,
+      message: '',
+    }
+  }
+
+  /**
+   * Reconfigure editor installations
+   */
+  async setup(options: SetupOptions = {}): Promise<CommandResult> {
+    const commandInstaller = require('../infrastructure/command-installer')
+
+    console.log('🔧 Reconfiguring prjct...\n')
+
+    if (options.force) {
+      console.log('🗑️  Removing existing installation...')
+      await commandInstaller.uninstallCommands()
+    }
+
+    console.log('📦 Installing /p:* commands...')
+    const result = await commandInstaller.updateCommands()
+
+    if (!result.success) {
+      return {
+        success: false,
+        message: `❌ Setup failed: ${result.error}`,
+      }
+    }
+
+    console.log(`\n✅ Installed ${result.installed.length} commands`)
+
+    if (result.errors.length > 0) {
+      console.log(`\n⚠️  ${result.errors.length} errors:`)
+      result.errors.forEach((e: { file: string; error: string }) => console.log(`   - ${e.file}: ${e.error}`))
+    }
+
+    console.log('\n📝 Installing global configuration...')
+    const configResult = await commandInstaller.installGlobalConfig()
+
+    if (configResult.success) {
+      if (configResult.action === 'created') {
+        console.log('✅ Created ~/.claude/CLAUDE.md')
+      } else if (configResult.action === 'updated') {
+        console.log('✅ Updated ~/.claude/CLAUDE.md')
+      } else if (configResult.action === 'appended') {
+        console.log('✅ Added prjct config to ~/.claude/CLAUDE.md')
+      }
+    } else {
+      console.log(`⚠️  ${configResult.error}`)
+    }
+
+    console.log('\n⚡ Installing status line...')
+    const statusLineResult = await this.installStatusLine()
+    if (statusLineResult.success) {
+      console.log('✅ Status line configured')
+    } else {
+      console.log(`⚠️  ${statusLineResult.error}`)
+    }
+
+    console.log('\n🎉 Setup complete!\n')
+
+    this.showAsciiArt()
+
+    return {
+      success: true,
+      message: '',
+    }
+  }
+
+  /**
+   * Install status line script and configure settings.json
+   */
+  async installStatusLine(): Promise<{ success: boolean; error?: string }> {
+    try {
+      const claudeDir = path.join(os.homedir(), '.claude')
+      const settingsPath = path.join(claudeDir, 'settings.json')
+      const statusLinePath = path.join(claudeDir, 'prjct-statusline.sh')
+
+      const scriptContent = `#!/bin/bash
+# prjct Status Line for Claude Code
+# Shows ⚡ prjct with animated spinner when command is running
+
+# Read JSON context from stdin (provided by Claude Code)
+read -r json
+
+# Spinner frames
+frames=('⠋' '⠙' '⠹' '⠸' '⠼' '⠴' '⠦' '⠧' '⠇' '⠏')
+
+# Calculate frame based on time (changes every 80ms)
+frame=$(($(date +%s%N 2>/dev/null || echo 0) / 80000000 % 10))
+
+# Check if prjct command is running
+running_file="$HOME/.prjct-cli/.running"
+
+if [ -f "$running_file" ]; then
+  task=$(cat "$running_file" 2>/dev/null || echo "working")
+  echo "⚡ prjct \${frames[$frame]} $task"
+else
+  echo "⚡ prjct"
+fi
+`
+      fs.writeFileSync(statusLinePath, scriptContent, { mode: 0o755 })
+
+      let settings: Record<string, unknown> = {}
+      if (fs.existsSync(settingsPath)) {
+        try {
+          settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'))
+        } catch {
+          // Invalid JSON, start fresh
+        }
+      }
+
+      settings.statusLine = {
+        type: 'command',
+        command: statusLinePath
+      }
+
+      fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2))
+
+      return { success: true }
+    } catch (error) {
+      return { success: false, error: (error as Error).message }
+    }
+  }
+
+  /**
+   * Show beautiful ASCII art with quick start
+   */
+  showAsciiArt(): void {
+    const chalk = require('chalk')
+
+    console.log(chalk.cyan('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'))
+    console.log('')
+    console.log(chalk.bold.cyan('   ██████╗ ██████╗      ██╗ ██████╗████████╗'))
+    console.log(chalk.bold.cyan('   ██╔══██╗██╔══██╗     ██║██╔════╝╚══██╔══╝'))
+    console.log(chalk.bold.cyan('   ██████╔╝██████╔╝     ██║██║        ██║'))
+    console.log(chalk.bold.cyan('   ██╔═══╝ ██╔══██╗██   ██║██║        ██║'))
+    console.log(chalk.bold.cyan('   ██║     ██║  ██║╚█████╔╝╚██████╗   ██║'))
+    console.log(chalk.bold.cyan('   ╚═╝     ╚═╝  ╚═╝ ╚════╝  ╚═════╝   ╚═╝'))
+    console.log('')
+    console.log(`   ${chalk.bold.cyan('prjct')}${chalk.magenta('/')}${chalk.green('cli')}  ${chalk.dim.white('v' + VERSION + ' installed')}`)
+    console.log('')
+    console.log(`   ${chalk.yellow('⚡')} Ship faster with zero friction`)
+    console.log(`   ${chalk.green('📝')} From idea to technical tasks in minutes`)
+    console.log(`   ${chalk.cyan('🤖')} Perfect context for AI agents`)
+    console.log('')
+    console.log(chalk.cyan('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'))
+    console.log('')
+    console.log(chalk.bold.cyan('🚀 Quick Start'))
+    console.log(chalk.dim('─────────────────────────────────────────────────'))
+    console.log('')
+    console.log(`  ${chalk.bold('1.')} Initialize your project:`)
+    console.log(`     ${chalk.green('cd your-project && prjct init')}`)
+    console.log('')
+    console.log(`  ${chalk.bold('2.')} Set your current focus:`)
+    console.log(`     ${chalk.green('prjct now "build auth"')}`)
+    console.log('')
+    console.log(`  ${chalk.bold('3.')} Ship & celebrate:`)
+    console.log(`     ${chalk.green('prjct ship "user login"')}`)
+    console.log('')
+    console.log(chalk.dim('─────────────────────────────────────────────────'))
+    console.log('')
+    console.log(`  ${chalk.dim('Documentation:')} ${chalk.cyan('https://prjct.app')}`)
+    console.log(`  ${chalk.dim('Report issues:')} ${chalk.cyan('https://github.com/jlopezlira/prjct-cli/issues')}`)
+    console.log('')
+    console.log(chalk.bold.magenta('Happy shipping! 🚀'))
+    console.log('')
+  }
+
+  /**
+   * Migrate all legacy projects
+   */
+  async migrateAll(options: MigrateOptions = {}): Promise<CommandResult> {
+    const fsPromises = require('fs').promises
+
+    console.log('🔄 Scanning for legacy prjct projects...\n')
+
+    const homeDir = os.homedir()
+    const globalRoot = path.join(homeDir, '.prjct-cli', 'projects')
+
+    let projectIds: string[] = []
+    try {
+      const dirs = await fsPromises.readdir(globalRoot)
+      projectIds = dirs.filter((d: string) => !d.startsWith('.'))
+    } catch {
+      return {
+        success: false,
+        message: '❌ No prjct projects found',
+      }
+    }
+
+    console.log(`📁 Found ${projectIds.length} projects in global storage\n`)
+
+    const migrated: { projectId: string; path: string }[] = []
+    const failed: { projectId: string; path: string; error: string }[] = []
+    const skipped: { projectId: string; reason: string }[] = []
+
+    for (const projectId of projectIds) {
+      const globalConfig = await configManager.readGlobalConfig(projectId) as GlobalConfig | null
+      if (!globalConfig || !globalConfig.projectPath) {
+        skipped.push({ projectId, reason: 'No project path in config' })
+        continue
+      }
+
+      const projectPath = globalConfig.projectPath!
+
+      if (!(await migrator.needsMigration(projectPath))) {
+        skipped.push({ projectId, reason: 'Already migrated' })
+        continue
+      }
+
+      console.log(`🔄 Migrating: ${projectPath}`)
+
+      try {
+        const result = await migrator.migrate(projectPath, options) as MigrationResult
+
+        if (result.success) {
+          migrated.push({ projectId, path: projectPath })
+          console.log(`   ✅ Migrated successfully`)
+        } else {
+          const issues = result.issues?.join(', ') || 'Unknown error'
+          failed.push({ projectId, path: projectPath, error: issues })
+          console.log(`   ❌ ${issues}`)
+        }
+      } catch (error) {
+        failed.push({ projectId, path: projectPath, error: (error as Error).message })
+        console.log(`   ❌ ${(error as Error).message}`)
+      }
+
+      console.log('')
+    }
+
+    console.log('\n📊 Migration Summary:')
+    console.log(`   ✅ Migrated: ${migrated.length}`)
+    console.log(`   ⏭️  Skipped: ${skipped.length}`)
+    console.log(`   ❌ Failed: ${failed.length}`)
+
+    if (failed.length > 0) {
+      console.log('\n❌ Failed migrations:')
+      failed.forEach((f) => console.log(`   - ${f.path}: ${f.error}`))
+    }
+
+    return {
+      success: failed.length === 0,
+      message: '',
+    }
+  }
+}