prjct-cli 0.19.0 → 0.20.1

package/core/commands/maintenance.ts

@@ -1,495 +1,74 @@
 /**
- * Maintenance Commands: cleanup, design, recover, undo, redo, history
- * Git-based snapshots for undo/redo functionality
+ * Maintenance Commands
+ *
+ * Composed from individual modules:
+ * - cleanup: Memory and project file cleanup
+ * - design: System architecture and component design
+ * - snapshots: Git-based undo/redo and session recovery
  */
 
-import path from 'path'
+import type { CommandResult, CleanupOptions, DesignOptions } from '../types'
+import { PrjctCommandsBase } from './base'
 
-import type { CommandResult, CleanupOptions, DesignOptions } from './types'
-import {
-  PrjctCommandsBase,
-  pathManager,
-  configManager,
-  fileHelper,
-  jsonlHelper,
-  dateHelper,
-  out
-} from './base'
-import { mdIdeasManager, mdQueueManager } from '../data'
+// Import individual command functions
+import { cleanup, cleanupMemory, cleanupMemoryInternal } from './cleanup'
+import { design } from './design'
+import { recover, undo, redo, history } from './snapshots'
 
+/**
+ * MaintenanceCommands - Facade class for maintenance operations
+ *
+ * Delegates to individual modules for implementation.
+ */
 export class MaintenanceCommands extends PrjctCommandsBase {
-  /**
-   * Memory cleanup helper
-   */
-  async _cleanupMemory(projectPath: string): Promise<{ success: boolean; results: { rotated: string[]; totalSize: number; freedSpace: number } }> {
-    const projectId = await configManager.getProjectId(projectPath)
-
-    const results = { rotated: [] as string[], totalSize: 0, freedSpace: 0 }
-    const jsonlFiles = [
-      pathManager.getFilePath(projectId!, 'memory', 'context.jsonl'),
-      pathManager.getFilePath(projectId!, 'progress', 'shipped.md'),
-      pathManager.getFilePath(projectId!, 'planning', 'ideas.md'),
-    ]
-
-    for (const filePath of jsonlFiles) {
-      try {
-        const sizeMB = await jsonlHelper.getFileSizeMB(filePath)
-        if (sizeMB > 0) {
-          results.totalSize += sizeMB
-          const rotated = await jsonlHelper.rotateJsonLinesIfNeeded(filePath, 10)
-          if (rotated) {
-            results.rotated.push(path.basename(filePath))
-            results.freedSpace += sizeMB
-          }
-        }
-      } catch {
-        // skip
-      }
-    }
-
-    return { success: true, results }
+  // Cleanup operations
+  _cleanupMemory = cleanupMemory
+  _cleanupMemoryInternal = cleanupMemoryInternal
+
+  async cleanup(options: CleanupOptions = {}, projectPath: string = process.cwd()): Promise<CommandResult> {
+    const initResult = await this.ensureProjectInit(projectPath)
+    if (!initResult.success) return initResult
+    return cleanup(options, projectPath)
   }
 
-  /**
-   * Internal cleanup helper for memory during normal cleanup
-   */
-  async _cleanupMemoryInternal(projectPath: string): Promise<void> {
-    const projectId = await configManager.getProjectId(projectPath)
-    const memoryPath = pathManager.getFilePath(projectId!, 'memory', 'context.jsonl')
-    await jsonlHelper.rotateJsonLinesIfNeeded(memoryPath, 10)
-  }
-
-  /**
-   * /p:cleanup - Clean temp files and old entries
-   */
-  async cleanup(_options: CleanupOptions = {}, projectPath: string = process.cwd()): Promise<CommandResult> {
-    try {
-      const initResult = await this.ensureProjectInit(projectPath)
-      if (!initResult.success) return initResult
-
-      const isMemoryMode = _options.memory === true || _options.type === 'memory'
-
-      if (isMemoryMode) {
-        out.spin('cleaning memory...')
-        const result = await this._cleanupMemory(projectPath)
-        out.done('memory cleaned')
-        return result
-      }
-
-      out.spin('cleaning up...')
-
-      const projectId = await configManager.getProjectId(projectPath)
-      if (!projectId) {
-        out.fail('no project ID')
-        return { success: false, error: 'No project ID found' }
-      }
-
-      const cleaned: string[] = []
-
-      // Clean memory (keep last 100 entries)
-      const memoryPath = pathManager.getFilePath(projectId, 'memory', 'context.jsonl')
-      try {
-        const entries = await jsonlHelper.readJsonLines(memoryPath)
-
-        if (entries.length > 100) {
-          const kept = entries.slice(-100)
-          await jsonlHelper.writeJsonLines(memoryPath, kept)
-          cleaned.push(`Memory: ${entries.length - 100} old entries removed`)
-        } else {
-          cleaned.push('Memory: No cleanup needed')
-        }
-      } catch {
-        cleaned.push('Memory: No file found')
-      }
-
-      // Clean ideas using mdIdeasManager
-      try {
-        const result = await mdIdeasManager.cleanup(projectId)
-        if (result.removed > 0) {
-          cleaned.push(`Ideas: ${result.removed} old archived ideas removed`)
-        } else {
-          cleaned.push('Ideas: No cleanup needed')
-        }
-      } catch {
-        cleaned.push('Ideas: No file found')
-      }
-
-      // Check queue for completed tasks using mdQueueManager
-      try {
-        const tasks = await mdQueueManager.getActiveTasks(projectId)
-        const completedTasks = tasks.filter(t => t.completed).length
-
-        if (completedTasks > 0) {
-          cleaned.push(
-            `Queue: ${completedTasks} completed tasks found (not removed - use /p:done to clear)`
-          )
-        } else {
-          cleaned.push('Queue: No completed tasks')
-        }
-      } catch {
-        cleaned.push('Queue: No file found')
-      }
-
-      await this._cleanupMemoryInternal(projectPath)
-
-      await this.logToMemory(projectPath, 'cleanup_performed', {
-        items: cleaned.length,
-        timestamp: dateHelper.getTimestamp(),
-      })
-
-      out.done(`${cleaned.length} items cleaned`)
-      return { success: true, cleaned }
-    } catch (error) {
-      out.fail((error as Error).message)
-      return { success: false, error: (error as Error).message }
-    }
+  // Design operations
+  async design(
+    target: string | null = null,
+    options: DesignOptions = {},
+    projectPath: string = process.cwd()
+  ): Promise<CommandResult> {
+    const initResult = await this.ensureProjectInit(projectPath)
+    if (!initResult.success) return initResult
+    return design(target, options, projectPath)
   }
 
-  /**
-   * /p:design - Design system architecture, APIs, and components
-   */
-  async design(target: string | null = null, options: DesignOptions = {}, projectPath: string = process.cwd()): Promise<CommandResult> {
-    try {
-      const initResult = await this.ensureProjectInit(projectPath)
-      if (!initResult.success) return initResult
-
-      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 this.logToMemory(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 }
-    }
-  }
-
-  /**
-   * /p:recover - Recover abandoned session with context restoration
-   */
+  // Snapshot operations
   async recover(projectPath: string = process.cwd()): Promise<CommandResult> {
-    try {
-      const initResult = await this.ensureProjectInit(projectPath)
-      if (!initResult.success) return initResult
-
-      const projectId = await configManager.getProjectId(projectPath)
-      if (!projectId) {
-        out.fail('no project ID')
-        return { success: false, error: 'No project ID found' }
-      }
-
-      out.spin('checking for abandoned sessions...')
-
-      // Check for current session file
-      const sessionPath = pathManager.getFilePath(projectId, 'progress', 'sessions/current.json')
-
-      let sessionData: { task?: string; startedAt?: string; context?: string } | null = null
-      try {
-        const content = await fileHelper.readFile(sessionPath)
-        sessionData = JSON.parse(content)
-      } catch {
-        sessionData = null
-      }
-
-      if (!sessionData || !sessionData.task) {
-        out.warn('no abandoned session found')
-        return { success: true, message: 'No abandoned session found' }
-      }
-
-      console.log('\n🔍 Found abandoned session:\n')
-      console.log(`   Task: ${sessionData.task}`)
-      if (sessionData.startedAt) {
-        const elapsed = dateHelper.calculateDuration(new Date(sessionData.startedAt))
-        console.log(`   Started: ${elapsed} ago`)
-      }
-      if (sessionData.context) {
-        console.log(`   Context: ${sessionData.context.slice(0, 100)}...`)
-      }
-
-      console.log('\n💡 Options:')
-      console.log('   1. Use /p:work to resume working')
-      console.log('   2. Use /p:done to mark as complete')
-      console.log('   3. Delete session file to discard\n')
-
-      return { success: true, session: sessionData }
-    } catch (error) {
-      out.fail((error as Error).message)
-      return { success: false, error: (error as Error).message }
-    }
+    const initResult = await this.ensureProjectInit(projectPath)
+    if (!initResult.success) return initResult
+    return recover(projectPath)
   }
 
-  /**
-   * /p:undo - Git-based undo (stash current changes)
-   */
   async undo(projectPath: string = process.cwd()): Promise<CommandResult> {
-    try {
-      const initResult = await this.ensureProjectInit(projectPath)
-      if (!initResult.success) return initResult
-
-      out.spin('creating undo point...')
-
-      const projectId = await configManager.getProjectId(projectPath)
-      if (!projectId) {
-        out.fail('no project ID')
-        return { success: false, error: 'No project ID found' }
-      }
-
-      // Create snapshots directory
-      const snapshotsPath = path.join(
-        pathManager.getGlobalProjectPath(projectId),
-        'snapshots'
-      )
-      await fileHelper.ensureDir(snapshotsPath)
-
-      // Check git status
-      const { execSync } = await import('child_process')
-
-      try {
-        const status = execSync('git status --porcelain', {
-          cwd: projectPath,
-          encoding: 'utf-8'
-        }).trim()
-
-        if (!status) {
-          out.warn('nothing to undo (no changes)')
-          return { success: true, message: 'No changes to undo' }
-        }
-
-        // Create stash with timestamp
-        const timestamp = new Date().toISOString().replace(/[:.]/g, '-')
-        const stashMessage = `prjct-undo-${timestamp}`
-
-        execSync(`git stash push -m "${stashMessage}"`, {
-          cwd: projectPath,
-          encoding: 'utf-8'
-        })
-
-        // Save snapshot metadata
-        const snapshotFile = path.join(snapshotsPath, 'history.json')
-        let history: { snapshots: { id: string; timestamp: string; message: string }[]; current: number } = { snapshots: [], current: -1 }
-
-        try {
-          const content = await fileHelper.readFile(snapshotFile)
-          history = JSON.parse(content)
-        } catch {
-          // New history
-        }
-
-        history.snapshots.push({
-          id: stashMessage,
-          timestamp: new Date().toISOString(),
-          message: stashMessage
-        })
-        history.current = history.snapshots.length - 1
-
-        await fileHelper.writeFile(snapshotFile, JSON.stringify(history, null, 2))
-
-        await this.logToMemory(projectPath, 'undo_performed', {
-          snapshotId: stashMessage,
-          timestamp: dateHelper.getTimestamp(),
-        })
-
-        out.done('changes stashed (use /p:redo to restore)')
-        return { success: true, snapshotId: stashMessage }
-      } catch (gitError) {
-        out.fail('git operation failed')
-        return { success: false, error: (gitError as Error).message }
-      }
-    } catch (error) {
-      out.fail((error as Error).message)
-      return { success: false, error: (error as Error).message }
-    }
+    const initResult = await this.ensureProjectInit(projectPath)
+    if (!initResult.success) return initResult
+    return undo(projectPath)
   }
 
-  /**
-   * /p:redo - Restore previously undone changes
-   */
   async redo(projectPath: string = process.cwd()): Promise<CommandResult> {
-    try {
-      const initResult = await this.ensureProjectInit(projectPath)
-      if (!initResult.success) return initResult
-
-      out.spin('restoring changes...')
-
-      const projectId = await configManager.getProjectId(projectPath)
-      if (!projectId) {
-        out.fail('no project ID')
-        return { success: false, error: 'No project ID found' }
-      }
-
-      const snapshotsPath = path.join(
-        pathManager.getGlobalProjectPath(projectId),
-        'snapshots'
-      )
-      const snapshotFile = path.join(snapshotsPath, 'history.json')
-
-      let history: { snapshots: { id: string; timestamp: string; message: string }[]; current: number }
-
-      try {
-        const content = await fileHelper.readFile(snapshotFile)
-        history = JSON.parse(content)
-      } catch {
-        out.warn('no undo history found')
-        return { success: false, message: 'No undo history found' }
-      }
-
-      if (history.snapshots.length === 0) {
-        out.warn('nothing to redo')
-        return { success: false, message: 'Nothing to redo' }
-      }
-
-      const { execSync } = await import('child_process')
-
-      try {
-        // Get latest stash
-        const stashList = execSync('git stash list', {
-          cwd: projectPath,
-          encoding: 'utf-8'
-        }).trim()
-
-        if (!stashList) {
-          out.warn('no stashed changes')
-          return { success: false, message: 'No stashed changes found' }
-        }
-
-        // Find prjct stash
-        const prjctStash = stashList.split('\n').find(line => line.includes('prjct-undo-'))
-
-        if (!prjctStash) {
-          out.warn('no prjct undo point found')
-          return { success: false, message: 'No prjct undo point found' }
-        }
-
-        // Pop the stash
-        execSync('git stash pop', {
-          cwd: projectPath,
-          encoding: 'utf-8'
-        })
-
-        // Remove from history
-        history.snapshots.pop()
-        history.current = Math.max(0, history.current - 1)
-
-        await fileHelper.writeFile(snapshotFile, JSON.stringify(history, null, 2))
-
-        await this.logToMemory(projectPath, 'redo_performed', {
-          timestamp: dateHelper.getTimestamp(),
-        })
-
-        out.done('changes restored')
-        return { success: true }
-      } catch (gitError) {
-        out.fail('git operation failed')
-        return { success: false, error: (gitError as Error).message }
-      }
-    } catch (error) {
-      out.fail((error as Error).message)
-      return { success: false, error: (error as Error).message }
-    }
+    const initResult = await this.ensureProjectInit(projectPath)
+    if (!initResult.success) return initResult
+    return redo(projectPath)
   }
 
-  /**
-   * /p:history - Show snapshot history for undo/redo
-   */
   async history(projectPath: string = process.cwd()): Promise<CommandResult> {
-    try {
-      const initResult = await this.ensureProjectInit(projectPath)
-      if (!initResult.success) return initResult
-
-      const projectId = await configManager.getProjectId(projectPath)
-      if (!projectId) {
-        out.fail('no project ID')
-        return { success: false, error: 'No project ID found' }
-      }
-
-      const snapshotsPath = path.join(
-        pathManager.getGlobalProjectPath(projectId),
-        'snapshots'
-      )
-      const snapshotFile = path.join(snapshotsPath, 'history.json')
-
-      let history: { snapshots: { id: string; timestamp: string; message: string }[]; current: number }
-
-      try {
-        const content = await fileHelper.readFile(snapshotFile)
-        history = JSON.parse(content)
-      } catch {
-        console.log('\n📜 SNAPSHOT HISTORY\n')
-        console.log('═'.repeat(50))
-        console.log('  No snapshots yet.')
-        console.log('  Use /p:undo to create a snapshot.\n')
-        return { success: true, snapshots: [] }
-      }
-
-      console.log('\n📜 SNAPSHOT HISTORY\n')
-      console.log('═'.repeat(50))
-
-      if (history.snapshots.length === 0) {
-        console.log('  No snapshots yet.')
-        console.log('  Use /p:undo to create a snapshot.\n')
-      } else {
-        history.snapshots.forEach((snap, i) => {
-          const marker = i === history.current ? '→' : ' '
-          const date = new Date(snap.timestamp).toLocaleString()
-          console.log(`  ${marker} ${i + 1}. ${date}`)
-        })
-        console.log('')
-        console.log(`  ${history.snapshots.length} snapshot(s) available`)
-        console.log('  Use /p:redo to restore the latest\n')
-      }
-
-      console.log('═'.repeat(50) + '\n')
-
-      return { success: true, snapshots: history.snapshots, current: history.current }
-    } catch (error) {
-      out.fail((error as Error).message)
-      return { success: false, error: (error as Error).message }
-    }
+    const initResult = await this.ensureProjectInit(projectPath)
+    if (!initResult.success) return initResult
+    return history(projectPath)
   }
 }
+
+// Re-export individual functions for direct use
+export { cleanup, cleanupMemory, cleanupMemoryInternal } from './cleanup'
+export { design } from './design'
+export { recover, undo, redo, history } from './snapshots'

package/core/commands/planning.ts

@@ -5,7 +5,7 @@
 
 import path from 'path'
 
-import type { CommandResult, AnalyzeOptions, Context } from './types'
+import type { CommandResult, ProjectContext } from '../types'
 import { generateUUID } from '../schemas'
 import type { Priority, TaskType, TaskSection } from '../schemas/state'
 import {
@@ -151,7 +151,7 @@ export class PlanningCommands extends PrjctCommandsBase {
 
       out.spin(`planning ${description}...`)
 
-      const context = await contextBuilder.build(projectPath, { description }) as Context
+      const context = await contextBuilder.build(projectPath, { description }) as ProjectContext
       const tasks = this._breakdownFeatureTasks(description)
       const featureId = generateUUID()
 
@@ -217,7 +217,7 @@ export class PlanningCommands extends PrjctCommandsBase {
 
       out.spin('tracking bug...')
 
-      const context = await contextBuilder.build(projectPath, { description }) as Context
+      const context = await contextBuilder.build(projectPath, { description }) as ProjectContext
       const severity = this._detectBugSeverity(description)
 
       const agentResult = await this._assignAgentForTask(`fix bug: ${description}`, projectPath, context)

package/core/commands/register.ts

@@ -0,0 +1,104 @@
+/**
+ * Command Registration - Bridges existing command groups to the registry
+ *
+ * This module registers all commands from the existing command groups
+ * into the central CommandRegistry. This enables:
+ * - Uniform command execution via registry.execute()
+ * - Command introspection and metadata
+ * - Future migration to pure handler pattern
+ */
+
+import { commandRegistry } from './registry'
+import { COMMANDS, CATEGORIES } from './command-data'
+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'
+
+// Singleton instances of command groups
+const workflow = new WorkflowCommands()
+const planning = new PlanningCommands()
+const shipping = new ShippingCommands()
+const analytics = new AnalyticsCommands()
+const maintenance = new MaintenanceCommands()
+const analysis = new AnalysisCommands()
+const setup = new SetupCommands()
+
+/**
+ * Register categories
+ */
+function registerCategories(): void {
+  for (const [name, info] of Object.entries(CATEGORIES)) {
+    commandRegistry.registerCategory(name, info)
+  }
+}
+
+/**
+ * Register all commands from existing command groups
+ */
+export function registerAllCommands(): void {
+  // Skip if already registered
+  if (commandRegistry.has('work')) return
+
+  // Register categories first
+  registerCategories()
+
+  // Helper to get metadata from COMMANDS
+  const getMeta = (name: string) => COMMANDS.find(c => c.name === name)
+
+  // Workflow commands
+  commandRegistry.registerMethod('work', workflow, 'now', getMeta('work'))
+  commandRegistry.registerMethod('now', workflow, 'now', getMeta('now'))
+  commandRegistry.registerMethod('done', workflow, 'done', getMeta('done'))
+  commandRegistry.registerMethod('next', workflow, 'next', getMeta('next'))
+  commandRegistry.registerMethod('pause', workflow, 'pause', getMeta('pause'))
+  commandRegistry.registerMethod('resume', workflow, 'resume', getMeta('resume'))
+
+  // Planning commands
+  commandRegistry.registerMethod('init', planning, 'init', getMeta('init'))
+  commandRegistry.registerMethod('feature', planning, 'feature', getMeta('feature'))
+  commandRegistry.registerMethod('bug', planning, 'bug', getMeta('bug'))
+  commandRegistry.registerMethod('idea', planning, 'idea', getMeta('idea'))
+  commandRegistry.registerMethod('spec', planning, 'spec', getMeta('spec'))
+
+  // Shipping commands
+  commandRegistry.registerMethod('ship', shipping, 'ship', getMeta('ship'))
+
+  // Analytics commands
+  commandRegistry.registerMethod('dash', analytics, 'dash', getMeta('dash'))
+  commandRegistry.registerMethod('help', analytics, 'help', getMeta('help'))
+
+  // Maintenance commands
+  commandRegistry.registerMethod('cleanup', maintenance, 'cleanup', getMeta('cleanup'))
+  commandRegistry.registerMethod('design', maintenance, 'design', getMeta('design'))
+  commandRegistry.registerMethod('recover', maintenance, 'recover', getMeta('recover'))
+  commandRegistry.registerMethod('undo', maintenance, 'undo', getMeta('undo'))
+  commandRegistry.registerMethod('redo', maintenance, 'redo', getMeta('redo'))
+  commandRegistry.registerMethod('history', maintenance, 'history', getMeta('history'))
+
+  // Analysis commands
+  commandRegistry.registerMethod('analyze', analysis, 'analyze', getMeta('analyze'))
+  commandRegistry.registerMethod('sync', analysis, 'sync', getMeta('sync'))
+
+  // Setup commands
+  commandRegistry.registerMethod('start', setup, 'start', getMeta('start'))
+  commandRegistry.registerMethod('setup', setup, 'setup', getMeta('setup'))
+  commandRegistry.registerMethod('migrateAll', setup, 'migrateAll', getMeta('migrate-all'))
+}
+
+// Auto-register on import
+registerAllCommands()
+
+// Export command group instances for direct access (legacy support)
+export {
+  workflow,
+  planning,
+  shipping,
+  analytics,
+  maintenance,
+  analysis,
+  setup
+}