prjct-cli 1.22.0 → 1.24.0

package/core/commands/analytics.ts

@@ -1,342 +0,0 @@
-/**
- * Analytics Commands: dash, help
- * Unified dashboard and contextual help - MD-First Architecture
- */
-
-import path from 'node:path'
-import { createStalenessChecker } from '../services'
-import { ideasStorage, queueStorage, shippedStorage, stateStorage } from '../storage'
-import type { CommandResult, ProjectContext } from '../types'
-import { getErrorMessage } from '../types/fs'
-import {
-  configManager,
-  contextBuilder,
-  dateHelper,
-  jsonlHelper,
-  out,
-  PrjctCommandsBase,
-  pathManager,
-  toolRegistry,
-} from './base'
-import { commandRegistry } from './registry'
-
-interface MemoryEntry {
-  timestamp: string
-  action: string
-  data?: Record<string, unknown>
-}
-
-export class AnalyticsCommands extends PrjctCommandsBase {
-  /**
-   * /p:dash - Unified dashboard
-   * Views: default, week, month, roadmap, compact
-   */
-  async dash(
-    view: string = 'default',
-    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.failWithHint('NO_PROJECT_ID')
-        return { success: false, error: 'No project ID found' }
-      }
-
-      const projectName = path.basename(projectPath)
-
-      // Get current task (from storage layer - JSON source of truth)
-      const currentTask = await stateStorage.getCurrentTask(projectId)
-
-      // Get queue
-      const queueTasks = await queueStorage.getActiveTasks(projectId)
-
-      // Get shipped (recent)
-      const shipped = await shippedStorage.getRecent(projectId, 5)
-
-      // Get ideas
-      const ideas = await ideasStorage.getPending(projectId)
-
-      if (view === 'compact') {
-        // One-liner status
-        const taskStatus = currentTask ? `🎯 ${currentTask.description.slice(0, 30)}` : '💤 idle'
-        const queueStatus = `📋 ${queueTasks.length}`
-        const shippedStatus = `🚀 ${shipped.length}`
-        out.done(`${taskStatus} | ${queueStatus} | ${shippedStatus}`)
-        return { success: true, view: 'compact' }
-      }
-
-      if (view === 'week' || view === 'month') {
-        // Period-based metrics
-        const days = view === 'week' ? 7 : 30
-        const startDate = dateHelper.getDaysAgo(days)
-
-        const memoryPath = pathManager.getFilePath(projectId, 'memory', 'context.jsonl')
-        let entries: MemoryEntry[] = []
-        try {
-          const allEntries = (await jsonlHelper.readJsonLines(memoryPath)) as MemoryEntry[]
-          entries = allEntries.filter((e) => new Date(e.timestamp) >= startDate)
-        } catch {
-          entries = []
-        }
-
-        const metrics = {
-          tasksCompleted: entries.filter((e) => e.action === 'task_completed').length,
-          featuresShipped: entries.filter((e) => e.action === 'feature_shipped').length,
-          totalActions: entries.length,
-        }
-
-        console.log(`\n📊 ${view.toUpperCase()} PROGRESS - ${projectName}\n`)
-        console.log('═'.repeat(50))
-        console.log(`  Tasks completed: ${metrics.tasksCompleted}`)
-        console.log(`  Features shipped: ${metrics.featuresShipped}`)
-        console.log(`  Total actions: ${metrics.totalActions}`)
-        console.log('═'.repeat(50))
-
-        // ASCII sparkline
-        const sparkline = this._generateSparkline(entries, days)
-        console.log(`\n  Activity: ${sparkline}\n`)
-
-        return { success: true, view, metrics }
-      }
-
-      if (view === 'roadmap') {
-        // Roadmap view
-        const context = (await contextBuilder.build(projectPath)) as ProjectContext
-        const roadmapContent = (await toolRegistry.get('Read')!(context.paths.roadmap)) as
-          | string
-          | null
-
-        console.log(`\n🗺️  ROADMAP - ${projectName}\n`)
-        console.log('═'.repeat(50))
-
-        if (!roadmapContent || roadmapContent.trim() === '# ROADMAP') {
-          console.log('  No features planned yet.')
-          console.log('  Use /p:feature to add features.\n')
-        } else {
-          // Parse and display roadmap
-          const features = roadmapContent
-            .split('##')
-            .filter((s) => s.trim() && !s.includes('ROADMAP'))
-          features.slice(0, 5).forEach((f, i) => {
-            const name = f.split('\n')[0].trim()
-            console.log(`  ${i + 1}. ${name}`)
-          })
-          if (features.length > 5) {
-            console.log(`  ... and ${features.length - 5} more`)
-          }
-        }
-        console.log(`${'═'.repeat(50)}\n`)
-
-        return { success: true, view: 'roadmap' }
-      }
-
-      // Default view - project overview
-      console.log(`\n📊 DASHBOARD - ${projectName}\n`)
-      console.log('═'.repeat(50))
-
-      // Check staleness (PRJ-120)
-      const checker = createStalenessChecker(projectPath)
-      const stalenessStatus = await checker.check(projectId)
-      const stalenessWarning = checker.getWarning(stalenessStatus)
-      if (stalenessWarning) {
-        console.log(`\n${stalenessWarning}`)
-      }
-
-      // Current task
-      console.log('\n🎯 CURRENT FOCUS')
-      if (currentTask) {
-        console.log(`   ${currentTask.description}`)
-        if (currentTask.startedAt) {
-          const elapsed = dateHelper.calculateDuration(new Date(currentTask.startedAt))
-          console.log(`   Started: ${elapsed} ago`)
-        }
-      } else {
-        console.log('   No active task. Use /p:work to start.')
-      }
-
-      // Queue
-      console.log('\n📋 QUEUE')
-      if (queueTasks.length === 0) {
-        console.log('   Queue is empty')
-      } else {
-        queueTasks.slice(0, 3).forEach((t, i) => {
-          const priority = t.priority ? `[${t.priority}]` : ''
-          console.log(`   ${i + 1}. ${t.description.slice(0, 40)} ${priority}`)
-        })
-        if (queueTasks.length > 3) {
-          console.log(`   ... and ${queueTasks.length - 3} more`)
-        }
-      }
-
-      // Recent ships
-      console.log('\n🚀 RECENT SHIPS')
-      if (shipped.length === 0) {
-        console.log('   Nothing shipped yet')
-      } else {
-        shipped.slice(0, 3).forEach((s) => {
-          const date = s.shippedAt ? new Date(s.shippedAt).toLocaleDateString() : ''
-          console.log(`   • ${s.name} ${date ? `(${date})` : ''}`)
-        })
-      }
-
-      // Ideas
-      console.log('\n💡 IDEAS')
-      console.log(`   ${ideas.length} pending ideas`)
-
-      console.log(`\n${'═'.repeat(50)}`)
-      console.log('💡 /p:work to start | /p:done to complete | /p:ship to ship\n')
-
-      await this.logToMemory(projectPath, 'dash_viewed', {
-        view,
-        timestamp: dateHelper.getTimestamp(),
-      })
-
-      return {
-        success: true,
-        view: 'default',
-        stats: {
-          currentTask: currentTask?.description || null,
-          queueCount: queueTasks.length,
-          shippedCount: shipped.length,
-          ideasCount: ideas.length,
-        },
-      }
-    } catch (error) {
-      out.fail(getErrorMessage(error))
-      return { success: false, error: getErrorMessage(error) }
-    }
-  }
-
-  /**
-   * /p:help - Contextual help and guidance
-   */
-  async help(topic: string = '', _projectPath: string = process.cwd()): Promise<CommandResult> {
-    try {
-      if (!topic) {
-        // Show command overview
-        console.log('\n PRJCT COMMANDS\n')
-        console.log('='.repeat(50))
-
-        const categories = commandRegistry.getAllCategories()
-        const commands = commandRegistry.getAll()
-
-        // Group by category
-        const byCategory: Record<string, typeof commands> = {}
-        commands.forEach((cmd) => {
-          if (cmd.deprecated) return
-          if (!byCategory[cmd.group]) byCategory[cmd.group] = []
-          byCategory[cmd.group].push(cmd)
-        })
-
-        Object.entries(byCategory).forEach(([cat, cmds]) => {
-          const catInfo = categories.get(cat)
-          console.log(`\n${catInfo?.title || cat}:`)
-          cmds.forEach((cmd) => {
-            const params = cmd.params ? ` ${cmd.params}` : ''
-            console.log(`  ${cmd.name}${params}`)
-            console.log(`    ${cmd.description}`)
-          })
-        })
-
-        console.log(`\n${'═'.repeat(50)}`)
-        console.log('💡 Use /p:help <command> for detailed help\n')
-
-        return { success: true, topic: 'overview' }
-      }
-
-      // Topic-specific help
-      const command = commandRegistry.getByName(topic)
-      if (command) {
-        console.log(`\n📚 HELP: /p:${command.name}\n`)
-        console.log('═'.repeat(50))
-        console.log(`Description: ${command.description}`)
-
-        if (command.params) {
-          console.log(`Parameters: ${command.params}`)
-        }
-
-        if (command.usage) {
-          console.log('\nUsage:')
-          if (command.usage.claude) console.log(`  Claude: ${command.usage.claude}`)
-          if (command.usage.terminal) console.log(`  Terminal: ${command.usage.terminal}`)
-        }
-
-        if (command.features) {
-          console.log('\nFeatures:')
-          for (const f of command.features) {
-            console.log(`  • ${f}`)
-          }
-        }
-
-        console.log(`\n${'═'.repeat(50)}\n`)
-        return { success: true, topic, command }
-      }
-
-      // Intent translation (like old /p:ask)
-      const intents: Record<string, { command: string; hint: string }> = {
-        start: { command: 'work', hint: 'Start working on a task' },
-        begin: { command: 'work', hint: 'Start working on a task' },
-        finish: { command: 'done', hint: 'Mark current task complete' },
-        complete: { command: 'done', hint: 'Mark current task complete' },
-        deploy: { command: 'ship', hint: 'Ship a feature' },
-        release: { command: 'ship', hint: 'Ship a feature' },
-        status: { command: 'dash', hint: 'View project dashboard' },
-        overview: { command: 'dash', hint: 'View project dashboard' },
-        queue: { command: 'next', hint: 'View task queue' },
-        tasks: { command: 'next', hint: 'View task queue' },
-        add: { command: 'feature', hint: 'Add a new feature' },
-        new: { command: 'feature', hint: 'Add a new feature' },
-        break: { command: 'pause', hint: 'Pause current task' },
-        stop: { command: 'pause', hint: 'Pause current task' },
-        continue: { command: 'resume', hint: 'Resume paused task' },
-        back: { command: 'resume', hint: 'Resume paused task' },
-      }
-
-      const lowerTopic = topic.toLowerCase()
-      for (const [intent, info] of Object.entries(intents)) {
-        if (lowerTopic.includes(intent)) {
-          console.log(`\n💡 Did you mean /p:${info.command}?`)
-          console.log(`   ${info.hint}\n`)
-          return { success: true, topic, suggestion: info.command }
-        }
-      }
-
-      console.log(`\n❓ Unknown topic: ${topic}`)
-      console.log('   Use /p:help to see all commands\n')
-      return { success: false, error: `Unknown topic: ${topic}` }
-    } catch (error) {
-      out.fail(getErrorMessage(error))
-      return { success: false, error: getErrorMessage(error) }
-    }
-  }
-
-  /**
-   * Generate ASCII sparkline for activity
-   */
-  private _generateSparkline(entries: MemoryEntry[], days: number): string {
-    const bars = ['▁', '▂', '▃', '▄', '▅', '▆', '▇', '█']
-    const now = new Date()
-    const counts: number[] = []
-
-    // Count entries per day
-    for (let i = days - 1; i >= 0; i--) {
-      const date = new Date(now)
-      date.setDate(date.getDate() - i)
-      const dayStart = new Date(date.setHours(0, 0, 0, 0))
-      const dayEnd = new Date(date.setHours(23, 59, 59, 999))
-
-      const count = entries.filter((e) => {
-        const ts = new Date(e.timestamp)
-        return ts >= dayStart && ts <= dayEnd
-      }).length
-
-      counts.push(count)
-    }
-
-    const max = Math.max(...counts, 1)
-    return counts.map((c) => bars[Math.floor((c / max) * (bars.length - 1))]).join('')
-  }
-}

package/core/commands/base.ts

@@ -1,118 +0,0 @@
-/**
- * Base class and helpers for PrjctCommands
- *
- * Delegates to service modules for business logic.
- * This class maintains backward compatibility while services handle implementation.
- */
-
-import commandExecutor from '../agentic/command-executor'
-import contextBuilder from '../agentic/context-builder'
-import toolRegistry from '../agentic/tool-registry'
-import configManager from '../infrastructure/config-manager'
-import pathManager from '../infrastructure/path-manager'
-import UpdateChecker from '../infrastructure/update-checker'
-// Services
-import { agentService, breakdownService, memoryService, projectService } from '../services'
-import type {
-  AgentAssignmentResult,
-  AgentInfo,
-  Author,
-  CommandResult,
-  ProjectContext,
-} from '../types'
-import * as dateHelper from '../utils/date-helper'
-import * as fileHelper from '../utils/file-helper'
-import * as jsonlHelper from '../utils/jsonl-helper'
-import out from '../utils/output'
-
-/**
- * Base class with shared state and utilities
- * Delegates to service modules for implementation
- */
-export class PrjctCommandsBase {
-  prjctDir: string
-  updateChecker: UpdateChecker
-  updateNotificationShown: boolean
-  commandExecutor: typeof commandExecutor
-
-  constructor() {
-    this.prjctDir = '.prjct'
-    this.updateChecker = new UpdateChecker()
-    this.updateNotificationShown = false
-    this.commandExecutor = commandExecutor
-  }
-
-  // Agent accessors (delegate to agentService)
-  get agent(): unknown {
-    return agentService.getAgent()
-  }
-
-  get agentInfo(): AgentInfo | null {
-    return agentService.getInfo()
-  }
-
-  get currentAuthor(): Author | null {
-    return projectService.getCurrentAuthor()
-  }
-
-  async initializeAgent(): Promise<unknown> {
-    return agentService.initialize()
-  }
-
-  async ensureProjectInit(projectPath: string): Promise<CommandResult> {
-    return projectService.ensureInit(projectPath)
-  }
-
-  async ensureAuthor(): Promise<Author> {
-    return projectService.ensureAuthor()
-  }
-
-  async getGlobalProjectPath(projectPath: string): Promise<string> {
-    return projectService.getGlobalPath(projectPath)
-  }
-
-  async logToMemory(
-    projectPath: string,
-    action: string,
-    data: Record<string, unknown>
-  ): Promise<void> {
-    const author = await this.ensureAuthor()
-    return memoryService.log(projectPath, action, data, author.name)
-  }
-
-  async _detectEmptyDirectory(projectPath: string): Promise<boolean> {
-    return projectService.isEmptyDirectory(projectPath)
-  }
-
-  async _detectExistingCode(projectPath: string): Promise<boolean> {
-    return projectService.hasExistingCode(projectPath)
-  }
-
-  _breakdownFeatureTasks(description: string): string[] {
-    return breakdownService.breakdownFeature(description)
-  }
-
-  _detectBugSeverity(description: string): string {
-    return breakdownService.detectBugSeverity(description)
-  }
-
-  async _assignAgentForTask(
-    task: string,
-    projectPath: string,
-    context: ProjectContext
-  ): Promise<AgentAssignmentResult> {
-    return agentService.assignForTask(task, projectPath, context)
-  }
-}
-
-// Re-export dependencies for use by other modules
-export {
-  contextBuilder,
-  toolRegistry,
-  pathManager,
-  configManager,
-  fileHelper,
-  jsonlHelper,
-  dateHelper,
-  out,
-}

package/core/commands/cleanup.ts

@@ -1,157 +0,0 @@
-/**
- * Cleanup Commands
- *
- * Memory and project file cleanup operations.
- */
-
-import path from 'node:path'
-import { memoryService } from '../services'
-import { ideasStorage, queueStorage } from '../storage'
-import type { CleanupOptions, CommandResult } from '../types'
-import { getErrorMessage, isNotFoundError } from '../types/fs'
-import { configManager, dateHelper, jsonlHelper, out, pathManager } from './base'
-
-/**
- * Memory cleanup helper
- */
-export async function 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 (error) {
-      // Skip file if not found, otherwise log unexpected errors
-      if (!isNotFoundError(error)) {
-        console.error(`Cleanup warning for ${filePath}: ${getErrorMessage(error)}`)
-      }
-    }
-  }
-
-  return { success: true, results }
-}
-
-/**
- * Internal cleanup helper for memory during normal cleanup
- */
-export async function 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
- */
-export async function cleanup(
-  options: CleanupOptions = {},
-  projectPath: string = process.cwd()
-): Promise<CommandResult> {
-  try {
-    const isMemoryMode = options.memory === true || options.type === 'memory'
-
-    if (isMemoryMode) {
-      out.spin('cleaning memory...')
-      const result = await cleanupMemory(projectPath)
-      out.done('memory cleaned')
-      return result
-    }
-
-    out.spin('cleaning up...')
-
-    const projectId = await configManager.getProjectId(projectPath)
-    if (!projectId) {
-      out.failWithHint('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 (error) {
-      if (isNotFoundError(error)) {
-        cleaned.push('Memory: No file found')
-      } else {
-        cleaned.push(`Memory: Error - ${getErrorMessage(error)}`)
-      }
-    }
-
-    // Clean ideas using ideasStorage
-    try {
-      const result = await ideasStorage.cleanup(projectId)
-      if (result.removed > 0) {
-        cleaned.push(`Ideas: ${result.removed} old archived ideas removed`)
-      } else {
-        cleaned.push('Ideas: No cleanup needed')
-      }
-    } catch (error) {
-      if (isNotFoundError(error)) {
-        cleaned.push('Ideas: No file found')
-      } else {
-        cleaned.push(`Ideas: Error - ${getErrorMessage(error)}`)
-      }
-    }
-
-    // Check queue for completed tasks using queueStorage
-    try {
-      const tasks = await queueStorage.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 (error) {
-      if (isNotFoundError(error)) {
-        cleaned.push('Queue: No file found')
-      } else {
-        cleaned.push(`Queue: Error - ${getErrorMessage(error)}`)
-      }
-    }
-
-    await cleanupMemoryInternal(projectPath)
-
-    await memoryService.log(projectPath, 'cleanup_performed', {
-      items: cleaned.length,
-      timestamp: dateHelper.getTimestamp(),
-    })
-
-    out.done(`${cleaned.length} items cleaned`)
-    return { success: true, cleaned }
-  } catch (error) {
-    out.fail(getErrorMessage(error))
-    return { success: false, error: getErrorMessage(error) }
-  }
-}