prjct-cli 0.19.0 → 0.20.1

package/core/commands/command-data.ts

@@ -0,0 +1,346 @@
+/**
+ * Command Data - Static command definitions and categories
+ *
+ * Single source of truth for all command metadata.
+ * Used by registry for introspection and help display.
+ */
+
+import type { CommandMeta, CategoryInfo } from '../types'
+
+// Category definitions
+export const CATEGORIES: Record<string, CategoryInfo> = {
+  core: {
+    title: 'Core Workflow',
+    description: '13 essential commands for daily development workflow',
+    order: 1,
+  },
+  optional: {
+    title: 'Optional Commands',
+    description: 'Advanced features for specialized workflows',
+    order: 2,
+  },
+  setup: {
+    title: 'Setup',
+    description: 'Installation and configuration (not for daily use)',
+    order: 3,
+  },
+}
+
+// All command definitions
+export const COMMANDS: CommandMeta[] = [
+  // ===== CORE COMMANDS =====
+  {
+    name: 'init',
+    group: 'core',
+    description: 'Deep project analysis and initialization',
+    usage: { claude: '/p:init "[idea]"', terminal: 'prjct init "[idea]"' },
+    params: '[idea]',
+    implemented: true,
+    hasTemplate: true,
+    requiresProject: false,
+    features: ['Architect mode for blank projects', 'Auto tech stack recommendation', 'Analyzes existing codebases'],
+  },
+  {
+    name: 'idea',
+    group: 'core',
+    description: 'Transform ideas into complete technical architectures',
+    usage: { claude: '/p:idea "build a CRM"', terminal: 'prjct idea "build a CRM"' },
+    params: '<description>',
+    implemented: true,
+    hasTemplate: true,
+    requiresProject: true,
+    features: ['Simple ideas -> Quick capture', 'Complex ideas -> Full architecture'],
+  },
+  {
+    name: 'feature',
+    group: 'core',
+    description: 'Add feature with value analysis and task breakdown',
+    usage: { claude: '/p:feature "add testing"', terminal: 'prjct feature "add testing"' },
+    params: '<description>',
+    implemented: true,
+    hasTemplate: true,
+    requiresProject: true,
+    features: ['Value analysis', 'Auto roadmap generation', 'Task breakdown'],
+  },
+  {
+    name: 'spec',
+    group: 'core',
+    description: 'Create detailed specifications for complex features',
+    usage: { claude: '/p:spec "Dark Mode"', terminal: 'prjct spec "Dark Mode"' },
+    params: '[feature]',
+    implemented: true,
+    hasTemplate: true,
+    requiresProject: true,
+  },
+  {
+    name: 'now',
+    group: 'core',
+    description: 'Set or show current task with session tracking',
+    usage: { claude: '/p:now ["task"]', terminal: 'prjct now ["task"]' },
+    params: '[task] [estimate]',
+    implemented: true,
+    hasTemplate: true,
+    requiresProject: true,
+  },
+  {
+    name: 'work',
+    group: 'core',
+    description: 'Set or show current task (alias for now)',
+    usage: { claude: '/p:work ["task"]', terminal: 'prjct work ["task"]' },
+    params: '[task]',
+    implemented: true,
+    hasTemplate: true,
+    requiresProject: true,
+  },
+  {
+    name: 'pause',
+    group: 'core',
+    description: 'Pause active task to handle interruption',
+    usage: { claude: '/p:pause ["reason"]', terminal: 'prjct pause ["reason"]' },
+    params: '[reason]',
+    implemented: true,
+    hasTemplate: true,
+    requiresProject: true,
+    blockingRules: { check: 'Active task exists', message: 'No active task to pause' },
+  },
+  {
+    name: 'resume',
+    group: 'core',
+    description: 'Resume paused task or recover abandoned session',
+    usage: { claude: '/p:resume', terminal: 'prjct resume' },
+    params: '[task_id]',
+    implemented: true,
+    hasTemplate: true,
+    requiresProject: true,
+  },
+  {
+    name: 'next',
+    group: 'core',
+    description: 'Show priority queue or roadmap view',
+    usage: { claude: '/p:next', terminal: 'prjct next' },
+    params: '[roadmap]',
+    implemented: true,
+    hasTemplate: true,
+    requiresProject: true,
+  },
+  {
+    name: 'done',
+    group: 'core',
+    description: 'Mark current task as complete',
+    usage: { claude: '/p:done', terminal: 'prjct done' },
+    implemented: true,
+    hasTemplate: true,
+    requiresProject: true,
+  },
+  {
+    name: 'ship',
+    group: 'core',
+    description: 'Commit, push, and celebrate shipped feature',
+    usage: { claude: '/p:ship "feature"', terminal: 'prjct ship "feature"' },
+    params: '<feature>',
+    implemented: true,
+    hasTemplate: true,
+    requiresProject: true,
+  },
+  {
+    name: 'bug',
+    group: 'core',
+    description: 'Report and track bugs with priority',
+    usage: { claude: '/p:bug "description"', terminal: 'prjct bug "description"' },
+    params: '<description>',
+    implemented: true,
+    hasTemplate: true,
+    requiresProject: true,
+  },
+  {
+    name: 'dash',
+    group: 'core',
+    description: 'Unified dashboard - status, progress, and roadmap',
+    usage: { claude: '/p:dash [view]', terminal: 'prjct dash [view]' },
+    params: '[week|month|roadmap|compact]',
+    implemented: true,
+    hasTemplate: true,
+    requiresProject: true,
+  },
+  {
+    name: 'sync',
+    group: 'core',
+    description: 'Sync project state and update workflow agents',
+    usage: { claude: '/p:sync', terminal: 'prjct sync' },
+    implemented: true,
+    hasTemplate: true,
+    requiresProject: true,
+  },
+  {
+    name: 'suggest',
+    group: 'core',
+    description: 'Smart recommendations based on project state',
+    usage: { claude: '/p:suggest', terminal: 'prjct suggest' },
+    implemented: true,
+    hasTemplate: true,
+    requiresProject: true,
+  },
+  {
+    name: 'help',
+    group: 'core',
+    description: 'Contextual help and guidance',
+    usage: { claude: '/p:help [topic]', terminal: 'prjct help [topic]' },
+    params: '[topic]',
+    implemented: true,
+    hasTemplate: true,
+    requiresProject: false,
+  },
+
+  // ===== OPTIONAL COMMANDS =====
+  {
+    name: 'design',
+    group: 'optional',
+    description: 'Design system architecture, APIs, and components',
+    usage: { claude: '/p:design [target]', terminal: 'prjct design [target]' },
+    params: '[target] --type architecture|api|component',
+    implemented: true,
+    hasTemplate: true,
+    requiresProject: true,
+    isOptional: true,
+  },
+  {
+    name: 'cleanup',
+    group: 'optional',
+    description: 'Clean up temp files and old entries',
+    usage: { claude: '/p:cleanup', terminal: 'prjct cleanup' },
+    implemented: true,
+    hasTemplate: true,
+    requiresProject: true,
+    isOptional: true,
+  },
+  {
+    name: 'analyze',
+    group: 'optional',
+    description: 'Analyze repository and sync tasks',
+    usage: { claude: '/p:analyze', terminal: 'prjct analyze' },
+    implemented: true,
+    hasTemplate: true,
+    requiresProject: true,
+    isOptional: true,
+  },
+  {
+    name: 'undo',
+    group: 'optional',
+    description: 'Revert to previous snapshot',
+    usage: { claude: '/p:undo', terminal: 'prjct undo' },
+    implemented: true,
+    hasTemplate: true,
+    requiresProject: true,
+    isOptional: true,
+    features: ['Git-based snapshots', 'Preserves redo history'],
+  },
+  {
+    name: 'redo',
+    group: 'optional',
+    description: 'Redo previously undone changes',
+    usage: { claude: '/p:redo', terminal: 'prjct redo' },
+    implemented: true,
+    hasTemplate: true,
+    requiresProject: true,
+    isOptional: true,
+  },
+  {
+    name: 'history',
+    group: 'optional',
+    description: 'View snapshot history',
+    usage: { claude: '/p:history', terminal: 'prjct history' },
+    implemented: true,
+    hasTemplate: true,
+    requiresProject: true,
+    isOptional: true,
+  },
+  {
+    name: 'recover',
+    group: 'optional',
+    description: 'Recover abandoned session with context',
+    usage: { claude: '/p:recover', terminal: 'prjct recover' },
+    implemented: true,
+    hasTemplate: true,
+    requiresProject: true,
+    isOptional: true,
+  },
+  {
+    name: 'git',
+    group: 'optional',
+    description: 'Smart git operations with context',
+    usage: { claude: '/p:git [op]', terminal: 'prjct git [op]' },
+    params: '[operation]',
+    implemented: true,
+    hasTemplate: true,
+    requiresProject: true,
+    isOptional: true,
+  },
+  {
+    name: 'test',
+    group: 'optional',
+    description: 'Run tests with auto-fix',
+    usage: { claude: '/p:test', terminal: 'prjct test' },
+    implemented: true,
+    hasTemplate: true,
+    requiresProject: true,
+    isOptional: true,
+  },
+
+  // ===== SETUP COMMANDS =====
+  {
+    name: 'start',
+    group: 'setup',
+    description: 'First-time setup (install commands to editors)',
+    usage: { claude: null, terminal: 'prjct start' },
+    implemented: true,
+    hasTemplate: false,
+    requiresProject: false,
+  },
+  {
+    name: 'setup',
+    group: 'setup',
+    description: 'Reconfigure editor installations',
+    usage: { claude: '/p:setup', terminal: 'prjct setup' },
+    params: '[--force] [--editor <name>]',
+    implemented: true,
+    hasTemplate: true,
+    requiresProject: false,
+  },
+  {
+    name: 'migrate',
+    group: 'setup',
+    description: 'Migrate project to UUID format + sync',
+    usage: { claude: '/p:migrate', terminal: null },
+    implemented: true,
+    hasTemplate: true,
+    requiresProject: true,
+  },
+  {
+    name: 'migrate-all',
+    group: 'setup',
+    description: 'Migrate all legacy projects to UUID format',
+    usage: { claude: '/p:migrate-all', terminal: 'prjct migrate-all' },
+    params: '[--deep-scan] [--dry-run]',
+    implemented: true,
+    hasTemplate: true,
+    requiresProject: false,
+  },
+  {
+    name: 'auth',
+    group: 'setup',
+    description: 'Manage cloud authentication',
+    usage: { claude: '/p:auth [action]', terminal: 'prjct auth [action]' },
+    params: '[login|logout|status]',
+    implemented: true,
+    hasTemplate: true,
+    requiresProject: false,
+  },
+]
+
+// Legacy compatibility - category field mapping
+export function getCommandsWithCategory(): Array<CommandMeta & { category: string }> {
+  return COMMANDS.map(cmd => ({
+    ...cmd,
+    category: cmd.group, // Map group to category for backward compat
+  }))
+}

package/core/commands/commands.ts

@@ -0,0 +1,216 @@
+/**
+ * prjct CLI Commands Handler
+ *
+ * MD-First Architecture - All state in Markdown files.
+ *
+ * COMMANDS (22 total):
+ * - Workflow (5): work, done, next, pause, resume
+ * - Planning (5): init, feature, bug, idea, spec
+ * - Shipping (1): ship
+ * - Analytics (2): dash, help
+ * - Maintenance (5): cleanup, design, recover, undo, redo, history
+ * - Analysis (2): analyze, sync
+ * - Setup (3): start, setup, migrateAll
+ */
+
+import { WorkflowCommands } from './workflow'
+import { PlanningCommands } from './planning'
+import { ShippingCommands } from './shipping'
+import { AnalyticsCommands } from './analytics'
+import { MaintenanceCommands } from './maintenance'
+import { AnalysisCommands } from './analysis'
+import { SetupCommands } from './setup'
+
+import type {
+  CommandResult,
+  AgentInfo,
+  Author,
+  DesignOptions,
+  CleanupOptions,
+  SetupOptions,
+  MigrateOptions,
+  AnalyzeOptions
+} from '../types'
+
+/**
+ * PrjctCommands - Combined class with all commands
+ * Uses mixins pattern to combine all command groups
+ */
+class PrjctCommands {
+  // Instances of each command group
+  private workflow: WorkflowCommands
+  private planning: PlanningCommands
+  private shipping: ShippingCommands
+  private analytics: AnalyticsCommands
+  private maintenance: MaintenanceCommands
+  private analysis: AnalysisCommands
+  private setupCmds: SetupCommands
+
+  // Shared state
+  agent: unknown
+  agentInfo: AgentInfo | null
+  currentAuthor: Author | null
+  prjctDir: string
+
+  constructor() {
+    this.workflow = new WorkflowCommands()
+    this.planning = new PlanningCommands()
+    this.shipping = new ShippingCommands()
+    this.analytics = new AnalyticsCommands()
+    this.maintenance = new MaintenanceCommands()
+    this.analysis = new AnalysisCommands()
+    this.setupCmds = new SetupCommands()
+
+    this.agent = null
+    this.agentInfo = null
+    this.currentAuthor = null
+    this.prjctDir = '.prjct'
+  }
+
+  // ========== Workflow Commands ==========
+
+  async work(task: string | null = null, projectPath: string = process.cwd()): Promise<CommandResult> {
+    return this.workflow.now(task, projectPath)
+  }
+
+  async done(projectPath: string = process.cwd()): Promise<CommandResult> {
+    return this.workflow.done(projectPath)
+  }
+
+  async next(projectPath: string = process.cwd()): Promise<CommandResult> {
+    return this.workflow.next(projectPath)
+  }
+
+  async pause(reason: string = '', projectPath: string = process.cwd()): Promise<CommandResult> {
+    return this.workflow.pause(reason, projectPath)
+  }
+
+  async resume(taskId: string | null = null, projectPath: string = process.cwd()): Promise<CommandResult> {
+    return this.workflow.resume(taskId, projectPath)
+  }
+
+  // ========== Planning Commands ==========
+
+  async init(idea: string | null = null, projectPath: string = process.cwd()): Promise<CommandResult> {
+    return this.planning.init(idea, projectPath)
+  }
+
+  async feature(description: string, projectPath: string = process.cwd()): Promise<CommandResult> {
+    return this.planning.feature(description, projectPath)
+  }
+
+  async bug(description: string, projectPath: string = process.cwd()): Promise<CommandResult> {
+    return this.planning.bug(description, projectPath)
+  }
+
+  async idea(description: string, projectPath: string = process.cwd()): Promise<CommandResult> {
+    return this.planning.idea(description, projectPath)
+  }
+
+  async spec(featureName: string | null = null, projectPath: string = process.cwd()): Promise<CommandResult> {
+    return this.planning.spec(featureName, projectPath)
+  }
+
+  // ========== Shipping Commands ==========
+
+  async ship(feature: string | null, projectPath: string = process.cwd()): Promise<CommandResult> {
+    return this.shipping.ship(feature, projectPath)
+  }
+
+  // ========== Analytics Commands ==========
+
+  async dash(view: string = 'default', projectPath: string = process.cwd()): Promise<CommandResult> {
+    return this.analytics.dash(view, projectPath)
+  }
+
+  async help(topic: string = '', projectPath: string = process.cwd()): Promise<CommandResult> {
+    return this.analytics.help(topic, projectPath)
+  }
+
+  // ========== Maintenance Commands ==========
+
+  async cleanup(options: CleanupOptions = {}, projectPath: string = process.cwd()): Promise<CommandResult> {
+    return this.maintenance.cleanup(options, projectPath)
+  }
+
+  async design(target: string | null = null, options: DesignOptions = {}, projectPath: string = process.cwd()): Promise<CommandResult> {
+    return this.maintenance.design(target, options, projectPath)
+  }
+
+  async recover(projectPath: string = process.cwd()): Promise<CommandResult> {
+    return this.maintenance.recover(projectPath)
+  }
+
+  async undo(projectPath: string = process.cwd()): Promise<CommandResult> {
+    return this.maintenance.undo(projectPath)
+  }
+
+  async redo(projectPath: string = process.cwd()): Promise<CommandResult> {
+    return this.maintenance.redo(projectPath)
+  }
+
+  async history(projectPath: string = process.cwd()): Promise<CommandResult> {
+    return this.maintenance.history(projectPath)
+  }
+
+  // ========== Analysis Commands ==========
+
+  async analyze(options: AnalyzeOptions = {}, projectPath: string = process.cwd()): Promise<CommandResult> {
+    return this.analysis.analyze(options, projectPath)
+  }
+
+  async sync(projectPath: string = process.cwd()): Promise<CommandResult> {
+    return this.analysis.sync(projectPath)
+  }
+
+  // ========== Setup Commands ==========
+
+  async start(): Promise<CommandResult> {
+    return this.setupCmds.start()
+  }
+
+  async setup(options: SetupOptions = {}): Promise<CommandResult> {
+    return this.setupCmds.setup(options)
+  }
+
+  async migrateAll(options: MigrateOptions = {}): Promise<CommandResult> {
+    return this.setupCmds.migrateAll(options)
+  }
+
+  async installStatusLine(): Promise<{ success: boolean; error?: string }> {
+    return this.setupCmds.installStatusLine()
+  }
+
+  showAsciiArt(): void {
+    return this.setupCmds.showAsciiArt()
+  }
+
+  // ========== Delegated Base Methods ==========
+
+  async initializeAgent(): Promise<unknown> {
+    return this.workflow.initializeAgent()
+  }
+
+  async ensureProjectInit(projectPath: string): Promise<CommandResult> {
+    return this.workflow.ensureProjectInit(projectPath)
+  }
+
+  async ensureAuthor(): Promise<Author> {
+    return this.workflow.ensureAuthor()
+  }
+
+  async getGlobalProjectPath(projectPath: string): Promise<string> {
+    return this.workflow.getGlobalProjectPath(projectPath)
+  }
+
+  async logToMemory(projectPath: string, action: string, data: Record<string, unknown>): Promise<void> {
+    return this.workflow.logToMemory(projectPath, action, data)
+  }
+}
+
+// Export both class and singleton instance
+const instance = new PrjctCommands()
+
+export default instance
+export { PrjctCommands }
+

package/core/commands/design.ts

@@ -0,0 +1,83 @@
+/**
+ * Design Commands
+ *
+ * System architecture, API, and component design operations.
+ */
+
+import path from 'path'
+
+import type { CommandResult, DesignOptions } from '../types'
+import {
+  pathManager,
+  configManager,
+  fileHelper,
+  dateHelper,
+  out
+} from './base'
+import { memoryService } from '../services'
+
+/**
+ * /p:design - Design system architecture, APIs, and components
+ */
+export async function design(
+  target: string | null = null,
+  options: DesignOptions = {},
+  projectPath: string = process.cwd()
+): Promise<CommandResult> {
+  try {
+    const designType = options.type || 'architecture'
+    const validTypes = ['architecture', 'api', 'component', 'database', 'flow']
+
+    if (!validTypes.includes(designType)) {
+      out.fail(`invalid type: ${designType}`)
+      return { success: false, error: 'Invalid design type' }
+    }
+
+    const designTarget = target || 'system'
+    out.spin(`designing ${designType}...`)
+
+    const projectId = await configManager.getProjectId(projectPath)
+    const designsPath = path.join(
+      pathManager.getGlobalProjectPath(projectId!),
+      'planning',
+      'designs'
+    )
+    await fileHelper.ensureDir(designsPath)
+
+    let designContent = ''
+
+    switch (designType) {
+      case 'architecture':
+        designContent = `# Architecture Design: ${designTarget}\n\n*Use templates/design/architecture.md for full design*\n`
+        break
+      case 'api':
+        designContent = `# API Design: ${designTarget}\n\n*Use templates/design/api.md for full design*\n`
+        break
+      case 'component':
+        designContent = `# Component Design: ${designTarget}\n\n*Use templates/design/component.md for full design*\n`
+        break
+      case 'database':
+        designContent = `# Database Design: ${designTarget}\n\n*Use templates/design/database.md for full design*\n`
+        break
+      case 'flow':
+        designContent = `# Flow Design: ${designTarget}\n\n*Use templates/design/flow.md for full design*\n`
+        break
+    }
+
+    const designFileName = `${designType}-${designTarget.toLowerCase().replace(/\s+/g, '-')}.md`
+    const designFilePath = path.join(designsPath, designFileName)
+    await fileHelper.writeFile(designFilePath, designContent)
+
+    await memoryService.log(projectPath, 'design_created', {
+      type: designType,
+      target: designTarget,
+      timestamp: dateHelper.getTimestamp(),
+    })
+
+    out.done(`${designType} design created`)
+    return { success: true, designPath: designFilePath, type: designType, target: designTarget }
+  } catch (error) {
+    out.fail((error as Error).message)
+    return { success: false, error: (error as Error).message }
+  }
+}