prjct-cli 0.11.4 → 0.12.0

package/core/command-registry/index.ts

@@ -0,0 +1,158 @@
+/**
+ * Command Registry - Single Source of Truth
+ *
+ * All prjct commands are defined here with metadata.
+ * This registry is used by:
+ * - bin/prjct (terminal CLI)
+ * - website/Commands.tsx (documentation site)
+ * - CLAUDE.md (AI assistant instructions)
+ * - scripts/validate-commands.js (validation)
+ *
+ * @version 0.9.0 - Simplified commands with pause/resume and intelligent idea development
+ */
+
+import type {
+  Command,
+  CategoryInfo,
+  Categories,
+  RegistryStats,
+  ValidationResult
+} from './types'
+export type { Command, CategoryInfo, Categories, RegistryStats, ValidationResult } from './types'
+import { COMMANDS } from './commands'
+import { CATEGORIES } from './categories'
+
+/**
+ * Registry helper functions
+ */
+const registry = {
+  /**
+   * Get all commands
+   */
+  getAll: (): Command[] => COMMANDS,
+
+  /**
+   * Get command by name
+   */
+  getByName: (name: string): Command | undefined => COMMANDS.find((c) => c.name === name),
+
+  /**
+   * Get commands by category
+   */
+  getByCategory: (category: string): Command[] => COMMANDS.filter((c) => c.category === category),
+
+  /**
+   * Get all implemented commands
+   */
+  getAllImplemented: (): Command[] => COMMANDS.filter((c) => c.implemented),
+
+  /**
+   * Get all commands with templates
+   */
+  getAllWithTemplates: (): Command[] => COMMANDS.filter((c) => c.hasTemplate),
+
+  /**
+   * Get commands available in Claude Code
+   */
+  getClaudeCommands: (): Command[] => COMMANDS.filter((c) => c.usage.claude !== null),
+
+  /**
+   * Get commands available in terminal
+   */
+  getTerminalCommands: (): Command[] => COMMANDS.filter((c) => c.usage.terminal !== null),
+
+  /**
+   * Get all categories
+   */
+  getCategories: (): Categories => CATEGORIES,
+
+  /**
+   * Get category metadata
+   */
+  getCategory: (category: string): CategoryInfo | undefined => CATEGORIES[category],
+
+  /**
+   * Validate command registry
+   */
+  validate: (): ValidationResult => {
+    const issues: string[] = []
+
+    // Check for duplicate names
+    const names = COMMANDS.map((c) => c.name)
+    const duplicates = names.filter((name, index) => names.indexOf(name) !== index)
+    if (duplicates.length > 0) {
+      issues.push(`Duplicate command names: ${duplicates.join(', ')}`)
+    }
+
+    // Check for commands with templates but not implemented
+    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(', ')}`
+      )
+    }
+
+    // Check for invalid categories
+    const validCategories = Object.keys(CATEGORIES)
+    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(', ')}`
+      )
+    }
+
+    return {
+      valid: issues.length === 0,
+      issues,
+    }
+  },
+
+  /**
+   * Get core commands only (13 essential)
+   */
+  getCoreCommands: (): Command[] => COMMANDS.filter((c) => c.category === 'core'),
+
+  /**
+   * Get optional commands
+   */
+  getOptionalCommands: (): Command[] => COMMANDS.filter((c) => c.category === 'optional'),
+
+  /**
+   * Get commands that require initialization
+   */
+  getRequiresInit: (): Command[] => COMMANDS.filter((c) => c.requiresInit),
+
+  /**
+   * Get commands with blocking rules
+   * NOTE: Blocking rules are now handled by Claude reading templates, not deterministic code
+   */
+  getWithBlockingRules: (): Command[] => COMMANDS.filter((c) => c.blockingRules !== null),
+
+  /**
+   * Get statistics
+   */
+  getStats: (): RegistryStats => ({
+    total: COMMANDS.length,
+    core: COMMANDS.filter((c) => c.category === 'core').length,
+    optional: COMMANDS.filter((c) => c.category === 'optional').length,
+    setup: COMMANDS.filter((c) => c.category === 'setup').length,
+    implemented: COMMANDS.filter((c) => c.implemented).length,
+    withTemplates: COMMANDS.filter((c) => c.hasTemplate).length,
+    claudeOnly: COMMANDS.filter((c) => c.usage.claude && !c.usage.terminal).length,
+    terminalOnly: COMMANDS.filter((c) => !c.usage.claude && c.usage.terminal).length,
+    both: COMMANDS.filter((c) => c.usage.claude && c.usage.terminal).length,
+    requiresInit: COMMANDS.filter((c) => c.requiresInit).length,
+    withBlockingRules: COMMANDS.filter((c) => c.blockingRules !== null).length,
+    byCategory: Object.keys(CATEGORIES).reduce(
+      (acc, cat) => ({
+        ...acc,
+        [cat]: COMMANDS.filter((c) => c.category === cat).length,
+      }),
+      {}
+    ),
+  }),
+}
+
+export default registry
+export { COMMANDS } from './commands'
+export { CATEGORIES } from './categories'

package/core/command-registry/optional-commands.ts

@@ -0,0 +1,119 @@
+/**
+ * Optional Commands
+ * Advanced features for specialized workflows.
+ */
+
+import type { Command } from './types'
+
+export const OPTIONAL_COMMANDS: Command[] = [
+  {
+    name: 'design',
+    category: 'optional',
+    description: 'Design system architecture, APIs, and components',
+    usage: {
+      claude: '/p:design authentication --type architecture',
+      terminal: 'prjct design authentication --type architecture',
+    },
+    params: '[target] --type architecture|api|component|database|flow',
+    implemented: true,
+    hasTemplate: true,
+    requiresInit: true,
+    blockingRules: null,
+    isOptional: true,
+  },
+
+  {
+    name: 'cleanup',
+    category: 'optional',
+    description: 'Clean up temp files and old entries',
+    usage: {
+      claude: '/p:cleanup',
+      terminal: 'prjct cleanup',
+    },
+    params: null,
+    implemented: true,
+    hasTemplate: true,
+    requiresInit: true,
+    blockingRules: null,
+    isOptional: true,
+  },
+
+  {
+    name: 'analyze',
+    category: 'optional',
+    description: 'Analyze repository and sync tasks',
+    usage: {
+      claude: '/p:analyze',
+      terminal: 'prjct analyze',
+    },
+    params: null,
+    implemented: true,
+    hasTemplate: true,
+    requiresInit: true,
+    blockingRules: null,
+    isOptional: true,
+  },
+
+  {
+    name: 'undo',
+    category: 'optional',
+    description: 'Revert to previous snapshot',
+    usage: {
+      claude: '/p:undo',
+      terminal: 'prjct undo',
+    },
+    params: null,
+    implemented: true,
+    hasTemplate: true,
+    requiresInit: true,
+    blockingRules: null,
+    isOptional: true,
+    features: [
+      'Git-based snapshots',
+      'Preserves redo history',
+      'Non-destructive',
+    ],
+  },
+
+  {
+    name: 'redo',
+    category: 'optional',
+    description: 'Redo previously undone changes',
+    usage: {
+      claude: '/p:redo',
+      terminal: 'prjct redo',
+    },
+    params: null,
+    implemented: true,
+    hasTemplate: true,
+    requiresInit: true,
+    blockingRules: null,
+    isOptional: true,
+    features: [
+      'Only available after undo',
+      'Restores undone state',
+      'Clears on new snapshot',
+    ],
+  },
+
+  {
+    name: 'history',
+    category: 'optional',
+    description: 'View snapshot history',
+    usage: {
+      claude: '/p:history',
+      terminal: 'prjct history',
+    },
+    params: null,
+    implemented: true,
+    hasTemplate: true,
+    requiresInit: true,
+    blockingRules: null,
+    isOptional: true,
+    features: [
+      'Shows all snapshots',
+      'Current position indicator',
+      'Redo availability count',
+    ],
+  },
+]

package/core/command-registry/setup-commands.ts

@@ -0,0 +1,53 @@
+/**
+ * Setup Commands
+ * Installation and configuration (not for daily use).
+ */
+
+import type { Command } from './types'
+
+export const SETUP_COMMANDS: Command[] = [
+  {
+    name: 'start',
+    category: 'setup',
+    description: 'First-time setup (install commands to editors)',
+    usage: {
+      claude: null,
+      terminal: 'prjct start',
+    },
+    params: null,
+    implemented: true,
+    hasTemplate: false,
+    requiresInit: false,
+    blockingRules: null,
+  },
+
+  {
+    name: 'setup',
+    category: 'setup',
+    description: 'Reconfigure editor installations',
+    usage: {
+      claude: '/p:setup',
+      terminal: 'prjct setup [--force] [--editor <name>]',
+    },
+    params: '[--force] [--editor <name>]',
+    implemented: true,
+    hasTemplate: true,
+    requiresInit: false,
+    blockingRules: null,
+  },
+
+  {
+    name: 'migrate-all',
+    category: 'setup',
+    description: 'Migrate all legacy projects',
+    usage: {
+      claude: '/p:migrate-all',
+      terminal: 'prjct migrate-all [--deep-scan] [--remove-legacy] [--dry-run]',
+    },
+    params: '[--deep-scan] [--remove-legacy] [--dry-run]',
+    implemented: true,
+    hasTemplate: true,
+    requiresInit: false,
+    blockingRules: null,
+  },
+]

package/core/command-registry/types.ts

@@ -0,0 +1,59 @@
+/**
+ * Command Registry Types
+ */
+
+export interface CommandUsage {
+  claude: string | null
+  terminal: string | null
+}
+
+export interface BlockingRules {
+  check: string
+  message: string
+}
+
+export interface Command {
+  name: string
+  category: string
+  description: string
+  usage: CommandUsage
+  params: string | null
+  implemented: boolean
+  hasTemplate: boolean
+  requiresInit: boolean
+  blockingRules: BlockingRules | null
+  features?: string[]
+  isOptional?: boolean
+  deprecated?: boolean
+  replacedBy?: string
+}
+
+export interface CategoryInfo {
+  title: string
+  description: string
+  order: number
+}
+
+export interface Categories {
+  [key: string]: CategoryInfo
+}
+
+export interface RegistryStats {
+  total: number
+  core: number
+  optional: number
+  setup: number
+  implemented: number
+  withTemplates: number
+  claudeOnly: number
+  terminalOnly: number
+  both: number
+  requiresInit: number
+  withBlockingRules: number
+  byCategory: Record<string, number>
+}
+
+export interface ValidationResult {
+  valid: boolean
+  issues: string[]
+}

package/core/command-registry.ts

@@ -0,0 +1,9 @@
+/**
+ * Command Registry
+ * Re-exports from command-registry/index.ts for backwards compatibility.
+ */
+
+import registry from './command-registry/index'
+export default registry
+export type { Command, CategoryInfo, Categories, RegistryStats, ValidationResult } from './command-registry/index'
+export { COMMANDS, CATEGORIES } from './command-registry/index'

package/core/commands/analysis.ts

@@ -0,0 +1,298 @@
+/**
+ * Analysis Commands: analyze, sync, and related helpers
+ */
+
+import path from 'path'
+
+import type { CommandResult, AnalyzeOptions, Context } from './types'
+import {
+  PrjctCommandsBase,
+  contextBuilder,
+  toolRegistry,
+  pathManager,
+  configManager,
+  dateHelper
+} from './base'
+
+export class AnalysisCommands extends PrjctCommandsBase {
+  /**
+   * /p:analyze - Analyze repository and generate summary
+   */
+  async analyze(options: AnalyzeOptions = {}, projectPath: string = process.cwd()): Promise<CommandResult> {
+    try {
+      await this.initializeAgent()
+
+      console.log('🔍 Analyzing repository...\n')
+
+      const analyzer = require('../domain/analyzer')
+      analyzer.init(projectPath)
+
+      const context = await contextBuilder.build(projectPath, options) as Context
+
+      const analysisData = {
+        packageJson: await analyzer.readPackageJson(),
+        cargoToml: await analyzer.readCargoToml(),
+        goMod: await analyzer.readGoMod(),
+        requirements: await analyzer.readRequirements(),
+        directories: await analyzer.listDirectories(),
+        fileCount: await analyzer.countFiles(),
+        gitStats: await analyzer.getGitStats(),
+        gitLog: await analyzer.getGitLog(20),
+        hasDockerfile: await analyzer.fileExists('Dockerfile'),
+        hasDockerCompose: await analyzer.fileExists('docker-compose.yml'),
+        hasReadme: await analyzer.fileExists('README.md'),
+        hasTsconfig: await analyzer.fileExists('tsconfig.json'),
+        hasViteConfig:
+          (await analyzer.fileExists('vite.config.ts')) ||
+          (await analyzer.fileExists('vite.config.js')),
+        hasNextConfig:
+          (await analyzer.fileExists('next.config.js')) ||
+          (await analyzer.fileExists('next.config.mjs')),
+      }
+
+      const summary = this._generateAnalysisSummary(analysisData, projectPath)
+
+      const projectId = await configManager.getProjectId(projectPath)
+      const summaryPath =
+        context.paths.analysis ||
+        pathManager.getFilePath(
+          projectId!,
+          'analysis',
+          'repo-summary.md'
+        )
+
+      await toolRegistry.get('Write')!(summaryPath, summary)
+
+      await this.logToMemory(projectPath, 'repository_analyzed', {
+        timestamp: dateHelper.getTimestamp(),
+        fileCount: analysisData.fileCount,
+        gitCommits: analysisData.gitStats.totalCommits,
+      })
+
+      const contextSync = require('../context-sync')
+      await contextSync.generateLocalContext(projectPath, projectId)
+
+      const commandInstaller = require('../infrastructure/command-installer')
+      const globalConfigResult = await commandInstaller.installGlobalConfig()
+      if (globalConfigResult.success) {
+        console.log('📝 Updated ~/.claude/CLAUDE.md')
+      }
+
+      console.log('✅ Analysis complete!\n')
+      console.log('📄 Full report: analysis/repo-summary.md')
+      console.log('📝 Context: ~/.prjct-cli/projects/' + projectId + '/CLAUDE.md\n')
+      console.log('Next steps:')
+      console.log('• /p:sync → Generate agents based on stack')
+      console.log('• /p:feature → Add a new feature')
+
+      return {
+        success: true,
+        summaryPath,
+        data: analysisData,
+      }
+    } catch (error) {
+      console.error('❌ Error:', (error as Error).message)
+      return { success: false, error: (error as Error).message }
+    }
+  }
+
+  /**
+   * Generate analysis summary from collected data
+   */
+  _generateAnalysisSummary(data: Record<string, unknown>, projectPath: string): string {
+    const lines: string[] = []
+
+    lines.push('# Repository Analysis\n')
+    lines.push(`Generated: ${new Date().toLocaleString()}\n`)
+
+    const projectName = path.basename(projectPath)
+    lines.push(`## Project: ${projectName}\n`)
+
+    lines.push('## Stack Detected\n')
+
+    if (data.packageJson) {
+      const pkg = data.packageJson as { dependencies?: Record<string, string> }
+      lines.push('### JavaScript/TypeScript\n')
+      lines.push('- **Package Manager**: npm/yarn/pnpm')
+      if (pkg.dependencies) {
+        const deps = Object.keys(pkg.dependencies)
+        if (deps.length > 0) {
+          lines.push(
+            `- **Dependencies**: ${deps.slice(0, 10).join(', ')}${deps.length > 10 ? ` (+${deps.length - 10} more)` : ''}`
+          )
+        }
+      }
+      if (data.hasNextConfig) lines.push('- **Framework**: Next.js detected')
+      if (data.hasViteConfig) lines.push('- **Build Tool**: Vite detected')
+      if (data.hasTsconfig) lines.push('- **Language**: TypeScript')
+      lines.push('')
+    }
+
+    if (data.cargoToml) {
+      lines.push('### Rust\n')
+      lines.push('- **Package Manager**: Cargo')
+      lines.push('- **Language**: Rust\n')
+    }
+
+    if (data.goMod) {
+      lines.push('### Go\n')
+      lines.push('- **Package Manager**: Go modules')
+      lines.push('- **Language**: Go\n')
+    }
+
+    if (data.requirements) {
+      lines.push('### Python\n')
+      lines.push('- **Package Manager**: pip')
+      lines.push('- **Language**: Python\n')
+    }
+
+    const directories = data.directories as string[] | undefined
+    lines.push('## Structure\n')
+    lines.push(`- **Total Files**: ${data.fileCount}`)
+    lines.push(
+      `- **Directories**: ${directories?.slice(0, 15).join(', ') || 'none'}${(directories?.length || 0) > 15 ? ` (+${(directories?.length || 0) - 15} more)` : ''}`
+    )
+
+    if (data.hasDockerfile) lines.push('- **Docker**: Detected')
+    if (data.hasDockerCompose) lines.push('- **Docker Compose**: Detected')
+    if (data.hasReadme) lines.push('- **Documentation**: README.md found')
+    lines.push('')
+
+    const gitStats = data.gitStats as { totalCommits?: number; contributors?: number; age?: string } | undefined
+    lines.push('## Git Statistics\n')
+    lines.push(`- **Total Commits**: ${gitStats?.totalCommits || 0}`)
+    lines.push(`- **Contributors**: ${gitStats?.contributors || 0}`)
+    lines.push(`- **Age**: ${gitStats?.age || 'unknown'}`)
+    lines.push('')
+
+    if (data.gitLog) {
+      lines.push('## Recent Activity\n')
+      const logLines = (data.gitLog as string).split('\n').slice(0, 5)
+      logLines.forEach((line) => {
+        if (line.trim()) {
+          const [hash, , time, msg] = line.split('|')
+          lines.push(`- \`${hash}\` ${msg} (${time})`)
+        }
+      })
+      lines.push('')
+    }
+
+    lines.push('## Recommendations\n')
+    lines.push('Based on detected stack, consider generating specialized agents using `/p:sync`.\n')
+
+    lines.push('---\n')
+    lines.push(
+      '*This analysis was generated automatically. For updated information, run `/p:analyze` again.*\n'
+    )
+
+    return lines.join('\n')
+  }
+
+  /**
+   * /p:sync - Sync project state and generate dynamic agents
+   */
+  async sync(projectPath: string = process.cwd()): Promise<CommandResult> {
+    try {
+      const initResult = await this.ensureProjectInit(projectPath)
+      if (!initResult.success) return initResult
+
+      await this.initializeAgent()
+
+      console.log('🔄 Syncing project state...\n')
+
+      const context = await contextBuilder.build(projectPath) as Context
+
+      console.log('📊 Running analysis...')
+      const analysisResult = await this.analyze({}, projectPath)
+
+      if (!analysisResult.success) {
+        console.error('❌ Analysis failed')
+        return analysisResult
+      }
+
+      const summaryContent = (await toolRegistry.get('Read')!(context.paths.analysis)) as string | null
+
+      if (!summaryContent) {
+        console.error('❌ No analysis found. Run /p:analyze first.')
+        return { success: false, error: 'No analysis found' }
+      }
+
+      console.log('✅ Analysis loaded\n')
+
+      console.log('🤖 Generating specialized agents...\n')
+
+      const projectId = await configManager.getProjectId(projectPath)
+      const AgentGenerator = require('../domain/agent-generator')
+      const generator = new AgentGenerator(projectId)
+
+      const generatedAgents = await this._generateAgentsFromAnalysis(summaryContent, generator, projectPath)
+
+      await this.logToMemory(projectPath, 'agents_generated', {
+        timestamp: dateHelper.getTimestamp(),
+        agents: generatedAgents,
+        count: generatedAgents.length,
+      })
+
+      const contextSync = require('../context-sync')
+      await contextSync.generateLocalContext(projectPath, projectId)
+
+      const commandInstaller = require('../infrastructure/command-installer')
+      const globalConfigResult = await commandInstaller.installGlobalConfig()
+      if (globalConfigResult.success) {
+        console.log('📝 Updated ~/.claude/CLAUDE.md')
+      }
+
+      console.log('\n✅ Sync complete!\n')
+      console.log(`🤖 Agents Generated: ${generatedAgents.length}`)
+      generatedAgents.forEach((agent) => {
+        console.log(`   • ${agent}`)
+      })
+      console.log('📝 Context: ~/.prjct-cli/projects/' + projectId + '/CLAUDE.md')
+      console.log('\n📋 Based on: analysis/repo-summary.md')
+      console.log('💡 See templates/agents/AGENTS.md for reference\n')
+      console.log('Next steps:')
+      console.log('• /p:context → View project state')
+      console.log('• /p:feature → Add a feature')
+
+      return {
+        success: true,
+        agents: generatedAgents,
+      }
+    } catch (error) {
+      console.error('❌ Error:', (error as Error).message)
+      return { success: false, error: (error as Error).message }
+    }
+  }
+
+  /**
+   * Generate agents dynamically from analysis summary
+   */
+  async _generateAgentsFromAnalysis(summaryContent: string, generator: unknown, projectPath: string): Promise<string[]> {
+    const agents: string[] = []
+
+    const analyzer = require('../domain/analyzer')
+    analyzer.init(projectPath)
+
+    const projectData = {
+      packageJson: await analyzer.readPackageJson(),
+      extensions: await analyzer.getFileExtensions(),
+      directories: await analyzer.listDirectories(),
+      configFiles: await analyzer.listConfigFiles(),
+      analysisSummary: summaryContent,
+      projectPath
+    }
+
+    const gen = generator as { generateAgentsFromTech: (data: unknown) => Promise<Array<{ name?: string } | string>> }
+    const generatedAgents = await gen.generateAgentsFromTech(projectData)
+
+    generatedAgents.forEach(agent => {
+      if (typeof agent === 'string') {
+        agents.push(agent)
+      } else if (agent.name) {
+        agents.push(agent.name)
+      }
+    })
+
+    return agents
+  }
+}