prjct-cli 1.22.0 → 1.23.0

package/core/commands/uninstall.ts

@@ -1,542 +0,0 @@
-/**
- * Uninstall Command
- *
- * Complete system removal of prjct-cli.
- * Handles cleanup of all prjct files, configurations, and installations.
- *
- * @version 1.0.0
- */
-
-import { execSync } from 'node:child_process'
-import fs from 'node:fs/promises'
-import os from 'node:os'
-import path from 'node:path'
-import readline from 'node:readline'
-import chalk from 'chalk'
-import { getProviderPaths } from '../infrastructure/command-installer'
-import pathManager from '../infrastructure/path-manager'
-import type { CommandResult, UninstallOptions } from '../types'
-import { getErrorMessage } from '../types/fs'
-import { fileExists } from '../utils/fs-helpers'
-import { PrjctCommandsBase } from './base'
-
-// Markers for prjct section in CLAUDE.md
-const PRJCT_START_MARKER = '<!-- prjct:start - DO NOT REMOVE THIS MARKER -->'
-const PRJCT_END_MARKER = '<!-- prjct:end - DO NOT REMOVE THIS MARKER -->'
-
-interface UninstallItem {
-  path: string
-  type: 'directory' | 'file' | 'section'
-  description: string
-  size?: number
-  count?: number
-  exists: boolean
-}
-
-interface InstallationInfo {
-  homebrew: boolean
-  npm: boolean
-  homebrewFormula?: string
-}
-
-/**
- * Get directory size recursively
- */
-async function getDirectorySize(dirPath: string): Promise<number> {
-  let totalSize = 0
-
-  try {
-    const entries = await fs.readdir(dirPath, { withFileTypes: true })
-
-    for (const entry of entries) {
-      const entryPath = path.join(dirPath, entry.name)
-
-      if (entry.isDirectory()) {
-        totalSize += await getDirectorySize(entryPath)
-      } else {
-        try {
-          const stats = await fs.stat(entryPath)
-          totalSize += stats.size
-        } catch {
-          // Skip files we can't stat
-        }
-      }
-    }
-  } catch {
-    // Directory doesn't exist or can't be read
-  }
-
-  return totalSize
-}
-
-/**
- * Format bytes to human readable size
- */
-function formatSize(bytes: number): string {
-  if (bytes === 0) return '0 B'
-
-  const units = ['B', 'KB', 'MB', 'GB']
-  const i = Math.floor(Math.log(bytes) / Math.log(1024))
-  const size = bytes / 1024 ** i
-
-  return `${size.toFixed(1)} ${units[i]}`
-}
-
-/**
- * Count items in a directory
- */
-async function countDirectoryItems(dirPath: string): Promise<number> {
-  try {
-    const entries = await fs.readdir(dirPath, { withFileTypes: true })
-    return entries.filter((e) => e.isDirectory()).length
-  } catch {
-    return 0
-  }
-}
-
-/**
- * Detect installation method
- */
-function detectInstallation(): InstallationInfo {
-  const info: InstallationInfo = {
-    homebrew: false,
-    npm: false,
-  }
-
-  // Check Homebrew
-  try {
-    const result = execSync('brew list prjct-cli 2>/dev/null', { encoding: 'utf-8' })
-    if (result) {
-      info.homebrew = true
-      info.homebrewFormula = 'prjct-cli'
-    }
-  } catch {
-    // Not installed via Homebrew
-  }
-
-  // Check npm global
-  try {
-    const result = execSync('npm list -g prjct-cli --depth=0 2>/dev/null', { encoding: 'utf-8' })
-    if (result.includes('prjct-cli')) {
-      info.npm = true
-    }
-  } catch {
-    // Not installed via npm
-  }
-
-  return info
-}
-
-/**
- * Gather all items to uninstall
- */
-async function gatherUninstallItems(): Promise<UninstallItem[]> {
-  const items: UninstallItem[] = []
-  const providerPaths = getProviderPaths()
-
-  // 1. ~/.prjct-cli/ (main data directory)
-  const prjctCliPath = pathManager.getGlobalBasePath()
-  const prjctCliExists = await fileExists(prjctCliPath)
-  const projectCount = prjctCliExists
-    ? await countDirectoryItems(path.join(prjctCliPath, 'projects'))
-    : 0
-  const prjctCliSize = prjctCliExists ? await getDirectorySize(prjctCliPath) : 0
-
-  items.push({
-    path: prjctCliPath,
-    type: 'directory',
-    description: `All project data${projectCount > 0 ? `, ${projectCount} project${projectCount > 1 ? 's' : ''}` : ''}`,
-    size: prjctCliSize,
-    count: projectCount,
-    exists: prjctCliExists,
-  })
-
-  // 2. ~/.claude/CLAUDE.md (prjct section only)
-  const claudeMdPath = path.join(providerPaths.claude.config, 'CLAUDE.md')
-  const claudeMdExists = await fileExists(claudeMdPath)
-  let hasPrjctSection = false
-
-  if (claudeMdExists) {
-    try {
-      const content = await fs.readFile(claudeMdPath, 'utf-8')
-      hasPrjctSection = content.includes(PRJCT_START_MARKER) && content.includes(PRJCT_END_MARKER)
-    } catch {
-      // Can't read file
-    }
-  }
-
-  items.push({
-    path: claudeMdPath,
-    type: 'section',
-    description: 'prjct section in CLAUDE.md',
-    exists: claudeMdExists && hasPrjctSection,
-  })
-
-  // 3. ~/.claude/commands/p/ (prjct commands)
-  const claudeCommandsPath = providerPaths.claude.commands
-  const claudeCommandsExists = await fileExists(claudeCommandsPath)
-  const claudeCommandsSize = claudeCommandsExists ? await getDirectorySize(claudeCommandsPath) : 0
-
-  items.push({
-    path: claudeCommandsPath,
-    type: 'directory',
-    description: 'Claude commands',
-    size: claudeCommandsSize,
-    exists: claudeCommandsExists,
-  })
-
-  // 4. ~/.claude/commands/p.md (router)
-  const claudeRouterPath = providerPaths.claude.router
-  const claudeRouterExists = await fileExists(claudeRouterPath)
-
-  items.push({
-    path: claudeRouterPath,
-    type: 'file',
-    description: 'Claude router',
-    exists: claudeRouterExists,
-  })
-
-  // 5. ~/.claude/prjct-statusline.sh (status line script)
-  const statusLinePath = path.join(providerPaths.claude.config, 'prjct-statusline.sh')
-  const statusLineExists = await fileExists(statusLinePath)
-
-  items.push({
-    path: statusLinePath,
-    type: 'file',
-    description: 'Status line script',
-    exists: statusLineExists,
-  })
-
-  // 6. ~/.gemini/commands/p.toml (Gemini router, if exists)
-  const geminiRouterPath = providerPaths.gemini.router
-  const geminiRouterExists = await fileExists(geminiRouterPath)
-
-  items.push({
-    path: geminiRouterPath,
-    type: 'file',
-    description: 'Gemini router',
-    exists: geminiRouterExists,
-  })
-
-  // 7. ~/.gemini/GEMINI.md (prjct section only, if exists)
-  const geminiMdPath = path.join(providerPaths.gemini.config, 'GEMINI.md')
-  const geminiMdExists = await fileExists(geminiMdPath)
-  let hasGeminiPrjctSection = false
-
-  if (geminiMdExists) {
-    try {
-      const content = await fs.readFile(geminiMdPath, 'utf-8')
-      hasGeminiPrjctSection =
-        content.includes(PRJCT_START_MARKER) && content.includes(PRJCT_END_MARKER)
-    } catch {
-      // Can't read file
-    }
-  }
-
-  if (geminiMdExists && hasGeminiPrjctSection) {
-    items.push({
-      path: geminiMdPath,
-      type: 'section',
-      description: 'prjct section in GEMINI.md',
-      exists: true,
-    })
-  }
-
-  return items
-}
-
-/**
- * Remove prjct section from a markdown file
- */
-async function removePrjctSection(filePath: string): Promise<boolean> {
-  try {
-    const content = await fs.readFile(filePath, 'utf-8')
-
-    if (!content.includes(PRJCT_START_MARKER) || !content.includes(PRJCT_END_MARKER)) {
-      return false
-    }
-
-    const startIndex = content.indexOf(PRJCT_START_MARKER)
-    const endIndex = content.indexOf(PRJCT_END_MARKER) + PRJCT_END_MARKER.length
-
-    // Remove the section and any trailing newlines
-    let newContent = content.substring(0, startIndex) + content.substring(endIndex)
-    newContent = newContent.replace(/\n{3,}/g, '\n\n').trim()
-
-    // If the file is now empty or just whitespace, delete it
-    if (!newContent || newContent.trim().length === 0) {
-      await fs.unlink(filePath)
-    } else {
-      await fs.writeFile(filePath, `${newContent}\n`, 'utf-8')
-    }
-
-    return true
-  } catch {
-    return false
-  }
-}
-
-/**
- * Create backup of prjct data
- */
-async function createBackup(): Promise<string | null> {
-  const homeDir = os.homedir()
-  const timestamp = new Date().toISOString().replace(/[:.]/g, '-').substring(0, 19)
-  const backupDir = path.join(homeDir, `.prjct-backup-${timestamp}`)
-
-  try {
-    await fs.mkdir(backupDir, { recursive: true })
-
-    const prjctCliPath = pathManager.getGlobalBasePath()
-
-    if (await fileExists(prjctCliPath)) {
-      // Copy entire .prjct-cli directory
-      await copyDirectory(prjctCliPath, path.join(backupDir, '.prjct-cli'))
-    }
-
-    return backupDir
-  } catch {
-    return null
-  }
-}
-
-/**
- * Recursively copy a directory
- */
-async function copyDirectory(src: string, dest: string): Promise<void> {
-  await fs.mkdir(dest, { recursive: true })
-  const entries = await fs.readdir(src, { withFileTypes: true })
-
-  for (const entry of entries) {
-    const srcPath = path.join(src, entry.name)
-    const destPath = path.join(dest, entry.name)
-
-    if (entry.isDirectory()) {
-      await copyDirectory(srcPath, destPath)
-    } else {
-      await fs.copyFile(srcPath, destPath)
-    }
-  }
-}
-
-/**
- * Perform the actual uninstallation
- */
-async function performUninstall(
-  items: UninstallItem[],
-  installation: InstallationInfo,
-  options: UninstallOptions
-): Promise<{ deleted: string[]; errors: string[] }> {
-  const deleted: string[] = []
-  const errors: string[] = []
-
-  for (const item of items) {
-    if (!item.exists) continue
-
-    try {
-      if (item.type === 'section') {
-        // Remove prjct section from file
-        const success = await removePrjctSection(item.path)
-        if (success) {
-          deleted.push(item.path)
-        }
-      } else if (item.type === 'directory') {
-        await fs.rm(item.path, { recursive: true, force: true })
-        deleted.push(item.path)
-      } else if (item.type === 'file') {
-        await fs.unlink(item.path)
-        deleted.push(item.path)
-      }
-    } catch (error) {
-      errors.push(`${item.path}: ${getErrorMessage(error)}`)
-    }
-  }
-
-  // Uninstall package managers
-  if (!options.keepPackage) {
-    if (installation.homebrew && installation.homebrewFormula) {
-      try {
-        if (!options.dryRun) {
-          execSync(`brew uninstall ${installation.homebrewFormula}`, { stdio: 'pipe' })
-        }
-        deleted.push('Homebrew: prjct-cli')
-      } catch (error) {
-        errors.push(`Homebrew: ${getErrorMessage(error)}`)
-      }
-    }
-
-    if (installation.npm) {
-      try {
-        if (!options.dryRun) {
-          execSync('npm uninstall -g prjct-cli', { stdio: 'pipe' })
-        }
-        deleted.push('npm: prjct-cli')
-      } catch (error) {
-        errors.push(`npm: ${getErrorMessage(error)}`)
-      }
-    }
-  }
-
-  return { deleted, errors }
-}
-
-/**
- * Prompt user for confirmation
- */
-async function promptConfirmation(message: string): Promise<boolean> {
-  const rl = readline.createInterface({
-    input: process.stdin,
-    output: process.stdout,
-  })
-
-  return new Promise((resolve) => {
-    rl.question(message, (answer) => {
-      rl.close()
-      resolve(answer.toLowerCase() === 'uninstall')
-    })
-  })
-}
-
-/**
- * Main uninstall function
- */
-export async function uninstall(
-  options: UninstallOptions = {},
-  _projectPath: string = process.cwd()
-): Promise<CommandResult> {
-  const items = await gatherUninstallItems()
-  const installation = detectInstallation()
-  const existingItems = items.filter((i) => i.exists)
-
-  // Check if there's anything to uninstall
-  if (existingItems.length === 0 && !installation.homebrew && !installation.npm) {
-    console.log(chalk.yellow('\nNo prjct installation found.'))
-    return {
-      success: true,
-      message: 'Nothing to uninstall',
-    }
-  }
-
-  // Calculate total size
-  const totalSize = existingItems.reduce((sum, item) => sum + (item.size || 0), 0)
-
-  // Display warning and items
-  console.log('')
-  console.log(chalk.red.bold('  WARNING: This action is DANGEROUS and IRREVERSIBLE'))
-  console.log('')
-  console.log(chalk.white('The following will be permanently deleted:'))
-  console.log('')
-
-  for (const item of existingItems) {
-    const displayPath = pathManager.getDisplayPath(item.path)
-    let info = ''
-
-    if (item.type === 'section') {
-      info = chalk.dim('(section only)')
-    } else if (item.size) {
-      info = chalk.dim(`(${formatSize(item.size)})`)
-    }
-
-    console.log(`  ${chalk.cyan(displayPath.padEnd(35))} ${info}`)
-    console.log(`  ${chalk.dim(item.description)}`)
-    console.log('')
-  }
-
-  // Show package manager installations
-  if (installation.homebrew) {
-    console.log(`  ${chalk.cyan('Homebrew'.padEnd(35))} ${chalk.dim('prjct-cli formula')}`)
-    console.log('')
-  }
-
-  if (installation.npm) {
-    console.log(`  ${chalk.cyan('npm global'.padEnd(35))} ${chalk.dim('prjct-cli package')}`)
-    console.log('')
-  }
-
-  if (totalSize > 0) {
-    console.log(chalk.dim(`  Total size: ${formatSize(totalSize)}`))
-    console.log('')
-  }
-
-  // Handle dry run
-  if (options.dryRun) {
-    console.log(chalk.yellow('Dry run - no changes made'))
-    return {
-      success: true,
-      message: 'Dry run complete',
-      itemsFound: existingItems.length,
-    }
-  }
-
-  // Handle backup
-  if (options.backup) {
-    console.log(chalk.blue('Creating backup...'))
-    const backupPath = await createBackup()
-
-    if (backupPath) {
-      console.log(chalk.green(`Backup created: ${pathManager.getDisplayPath(backupPath)}`))
-      console.log('')
-    } else {
-      console.log(chalk.yellow('Failed to create backup, continuing...'))
-    }
-  }
-
-  // Require confirmation unless --force
-  if (!options.force) {
-    console.log(chalk.yellow('Type "uninstall" to confirm:'))
-    const confirmed = await promptConfirmation('> ')
-
-    if (!confirmed) {
-      console.log(chalk.yellow('\nUninstall cancelled.'))
-      return {
-        success: false,
-        message: 'Uninstall cancelled by user',
-      }
-    }
-  }
-
-  // Perform uninstallation
-  console.log('')
-  console.log(chalk.blue('Removing prjct...'))
-
-  const { deleted, errors } = await performUninstall(items, installation, options)
-
-  // Report results
-  console.log('')
-
-  if (deleted.length > 0) {
-    console.log(chalk.green(`Removed ${deleted.length} items`))
-  }
-
-  if (errors.length > 0) {
-    console.log(chalk.yellow(`\n${errors.length} errors:`))
-    for (const error of errors) {
-      console.log(chalk.red(`  - ${error}`))
-    }
-  }
-
-  console.log('')
-  console.log(chalk.green('prjct has been uninstalled.'))
-  console.log(chalk.dim('Thanks for using prjct! We hope to see you again.'))
-  console.log('')
-
-  return {
-    success: errors.length === 0,
-    message: `Removed ${deleted.length} items`,
-    deleted,
-    errors: errors.length > 0 ? errors : undefined,
-  }
-}
-
-/**
- * UninstallCommands class for integration with command system
- */
-export class UninstallCommands extends PrjctCommandsBase {
-  async uninstall(
-    options: UninstallOptions = {},
-    projectPath: string = process.cwd()
-  ): Promise<CommandResult> {
-    // Uninstall doesn't require project init
-    return uninstall(options, projectPath)
-  }
-}

package/core/commands/velocity.ts

@@ -1,149 +0,0 @@
-/**
- * Velocity Commands: velocity
- * Sprint-based velocity dashboard
- *
- * @see PRJ-296
- */
-
-import chalk from 'chalk'
-import { calculateVelocity, projectCompletion } from '../domain/velocity'
-import outcomeRecorder from '../outcomes/recorder'
-import type { VelocityConfig } from '../schemas/velocity'
-import { DEFAULT_VELOCITY_CONFIG } from '../schemas/velocity'
-import { velocityStorage } from '../storage/velocity-storage'
-import type { CommandResult } from '../types'
-import { getErrorMessage } from '../types/fs'
-import { configManager, out, PrjctCommandsBase } from './base'
-
-export class VelocityCommands extends PrjctCommandsBase {
-  /**
-   * prjct velocity - Velocity dashboard
-   */
-  async velocity(
-    backlogPoints: string = '0',
-    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' }
-      }
-
-      // Load velocity config from project config (or defaults)
-      const config = await this.loadVelocityConfig(projectPath)
-
-      // Load all outcomes
-      const outcomes = await outcomeRecorder.getAll(projectId)
-
-      if (outcomes.length === 0) {
-        console.log(`\n${chalk.dim('No velocity data yet.')}`)
-        console.log(`${chalk.dim('Complete tasks with estimates to build velocity history.')}\n`)
-        return { success: true, message: 'No data' }
-      }
-
-      // Calculate velocity metrics
-      const metrics = calculateVelocity(outcomes, config)
-
-      // Save for context injection
-      await velocityStorage.saveMetrics(projectId, metrics)
-
-      // Render dashboard
-      console.log(
-        `\n${chalk.cyan('Sprint Velocity')} ${chalk.dim(`(last ${config.windowSize ?? 6} sprints)`)}`
-      )
-      console.log('═'.repeat(60))
-
-      // Sprint table
-      const recentSprints = metrics.sprints.slice(-(config.windowSize ?? 6))
-      for (const sprint of recentSprints) {
-        const accuracyColor =
-          sprint.estimationAccuracy >= 80
-            ? chalk.green
-            : sprint.estimationAccuracy >= 60
-              ? chalk.yellow
-              : chalk.red
-        console.log(
-          `  Sprint ${String(sprint.sprintNumber).padStart(2)}: ${chalk.bold(`${sprint.pointsCompleted} pts`)} | ${sprint.tasksCompleted} tasks | accuracy: ${accuracyColor(`${sprint.estimationAccuracy}%`)}`
-        )
-      }
-
-      console.log('')
-      const trendIcon =
-        metrics.velocityTrend === 'improving'
-          ? chalk.green('↑')
-          : metrics.velocityTrend === 'declining'
-            ? chalk.red('↓')
-            : chalk.dim('→')
-      console.log(
-        `  Average: ${chalk.bold(`${metrics.averageVelocity} pts/sprint`)} | Trend: ${trendIcon} ${metrics.velocityTrend}`
-      )
-      console.log(
-        `  Estimation accuracy: ${chalk.bold(`${metrics.estimationAccuracy}%`)} ${chalk.dim(`(±${config.accuracyTolerance ?? 20}% tolerance)`)}`
-      )
-
-      // Patterns
-      if (metrics.underEstimated.length > 0 || metrics.overEstimated.length > 0) {
-        console.log(`\n  ${chalk.dim('Patterns:')}`)
-        for (const p of metrics.underEstimated) {
-          console.log(
-            `    ${chalk.yellow('⚠')} ${p.category} tasks underestimated by avg ${chalk.bold(`${p.avgVariance}%`)}`
-          )
-        }
-        for (const p of metrics.overEstimated) {
-          console.log(
-            `    ${chalk.green('✓')} ${p.category} tasks estimated within ${chalk.bold(`${p.avgVariance}%`)}`
-          )
-        }
-      }
-
-      // Projection (if backlog points provided)
-      const points = parseInt(backlogPoints, 10)
-      if (points > 0 && metrics.averageVelocity > 0) {
-        const projection = projectCompletion(points, metrics.averageVelocity, config)
-        const dateStr = projection.estimatedDate
-          ? new Date(projection.estimatedDate).toLocaleDateString('en-US', {
-              month: 'short',
-              day: 'numeric',
-              year: 'numeric',
-            })
-          : 'unknown'
-        console.log(`\n  ${chalk.dim('Projection:')}`)
-        console.log(`    Backlog: ${chalk.bold(`${points} pts`)} remaining`)
-        console.log(
-          `    At current velocity: ~${projection.sprints} sprints (${projection.sprints * (config.sprintLengthDays ?? 7)} days)`
-        )
-        console.log(`    Estimated completion: ${chalk.bold(dateStr)}`)
-      }
-
-      console.log('═'.repeat(60))
-      console.log('')
-
-      return { success: true }
-    } catch (error) {
-      out.fail(getErrorMessage(error))
-      return { success: false, error: getErrorMessage(error) }
-    }
-  }
-
-  /**
-   * Load velocity config from project or use defaults.
-   * Velocity config can be added to prjct.config.json as { velocity: { sprintLengthDays, ... } }
-   */
-  private async loadVelocityConfig(projectPath: string): Promise<VelocityConfig> {
-    try {
-      const config = await configManager.readConfig(projectPath)
-      // Read velocity config from extended config (not typed in LocalConfig yet)
-      const raw = config as Record<string, unknown> | null
-      if (raw?.velocity && typeof raw.velocity === 'object') {
-        return { ...DEFAULT_VELOCITY_CONFIG, ...(raw.velocity as Partial<VelocityConfig>) }
-      }
-    } catch {
-      // Use defaults
-    }
-    return DEFAULT_VELOCITY_CONFIG
-  }
-}