prjct-cli 0.11.5 → 0.12.1

package/core/infrastructure/legacy-installer-detector/detection.ts

@@ -0,0 +1,95 @@
+/**
+ * Detection - Legacy Installation Detection
+ */
+
+import fs from 'fs/promises'
+import path from 'path'
+import os from 'os'
+import { execSync } from 'child_process'
+
+export const legacyInstallDir = path.join(os.homedir(), '.prjct-cli')
+export const npmGlobalProjectsDir = path.join(os.homedir(), '.prjct-cli', 'projects')
+export const isWindows = process.platform === 'win32'
+
+/**
+ * Check if legacy curl installation exists
+ */
+export async function hasLegacyInstallation(): Promise<boolean> {
+  try {
+    const stat = await fs.stat(legacyInstallDir)
+    if (!stat.isDirectory()) return false
+
+    // Check for .git directory (indicates curl install)
+    try {
+      await fs.access(path.join(legacyInstallDir, '.git'))
+      return true
+    } catch {
+      // No .git, check for other legacy indicators
+      const entries = await fs.readdir(legacyInstallDir)
+
+      // Legacy has: bin/, core/, templates/, scripts/, package.json
+      const legacyFiles = ['bin', 'core', 'templates', 'scripts', 'package.json']
+      const hasLegacyFiles = legacyFiles.every((file) => entries.includes(file))
+
+      if (hasLegacyFiles) {
+        return true
+      }
+
+      // Only has projects/ and config/ = already migrated
+      const onlyDataDirs = entries.every((entry) => ['projects', 'config'].includes(entry))
+      return !onlyDataDirs
+    }
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Get npm global installation path
+ */
+export function getNpmGlobalPath(): string {
+  try {
+    const npmRoot = execSync('npm root -g', { encoding: 'utf8' }).trim()
+    return path.join(npmRoot, 'prjct-cli')
+  } catch {
+    // Fallback to common locations
+    const nodePath = process.execPath
+    const nodeDir = path.dirname(path.dirname(nodePath))
+    return path.join(nodeDir, 'lib', 'node_modules', 'prjct-cli')
+  }
+}
+
+/**
+ * Check if user has npm global installation
+ */
+export async function hasNpmInstallation(): Promise<boolean> {
+  try {
+    execSync('npm list -g prjct-cli', { stdio: 'ignore' })
+    return true
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Get version of legacy installation
+ */
+export async function getLegacyVersion(): Promise<string | null> {
+  try {
+    const packageJsonPath = path.join(legacyInstallDir, 'package.json')
+    const content = await fs.readFile(packageJsonPath, 'utf8')
+    const pkg = JSON.parse(content)
+    return pkg.version || 'unknown'
+  } catch {
+    return null
+  }
+}
+
+/**
+ * Quick check - silent, returns true if cleanup needed
+ */
+export async function needsCleanup(): Promise<boolean> {
+  const hasLegacy = await hasLegacyInstallation()
+  const hasNpm = await hasNpmInstallation()
+  return hasLegacy && hasNpm
+}

package/core/infrastructure/legacy-installer-detector/index.ts

@@ -0,0 +1,171 @@
+/**
+ * Legacy Installer Detector
+ *
+ * Detects and cleans up legacy curl-based installations from ~/.prjct-cli/
+ *
+ * @version 0.8.8
+ */
+
+import {
+  legacyInstallDir,
+  npmGlobalProjectsDir,
+  isWindows,
+  hasLegacyInstallation,
+  getNpmGlobalPath,
+  hasNpmInstallation,
+  getLegacyVersion,
+  needsCleanup,
+} from './detection'
+
+import { migrateProjectsData } from './migration'
+
+import {
+  cleanupLegacyInstallation,
+  cleanupLegacyPATH,
+  cleanupLegacySymlinks,
+  getShellConfigFiles,
+} from './cleanup'
+
+import type { CleanupReport, CleanupOptions } from './types'
+import { CYAN, GREEN, YELLOW, RED, DIM, NC } from './types'
+
+class LegacyInstallerDetector {
+  legacyInstallDir = legacyInstallDir
+  npmGlobalProjectsDir = npmGlobalProjectsDir
+  isWindows = isWindows
+
+  hasLegacyInstallation = hasLegacyInstallation
+  getNpmGlobalPath = getNpmGlobalPath
+  hasNpmInstallation = hasNpmInstallation
+  getLegacyVersion = getLegacyVersion
+  needsCleanup = needsCleanup
+  migrateProjectsData = migrateProjectsData
+  cleanupLegacyInstallation = cleanupLegacyInstallation
+  cleanupLegacyPATH = cleanupLegacyPATH
+  cleanupLegacySymlinks = cleanupLegacySymlinks
+  getShellConfigFiles = getShellConfigFiles
+
+  /**
+   * Perform complete legacy cleanup
+   */
+  async performCleanup(options: CleanupOptions = {}): Promise<CleanupReport> {
+    const { verbose = true } = options
+
+    const report: CleanupReport = {
+      success: false,
+      legacyVersion: null,
+      hasNpm: false,
+      steps: {
+        projectsMigrated: 0,
+        installationCleaned: false,
+        pathCleaned: false,
+        symlinksCleaned: false,
+      },
+      messages: [],
+    }
+
+    try {
+      const hasLegacy = await hasLegacyInstallation()
+
+      if (!hasLegacy) {
+        report.success = true
+        report.messages.push('No legacy installation found')
+        return report
+      }
+
+      report.legacyVersion = await getLegacyVersion()
+      report.hasNpm = await hasNpmInstallation()
+
+      if (verbose) {
+        console.log('')
+        console.log(`${YELLOW}----------------------------------------${NC}`)
+        console.log(`${YELLOW}Legacy curl installation detected${NC}`)
+        console.log(`${YELLOW}----------------------------------------${NC}`)
+        console.log('')
+        console.log(`   ${DIM}Version: ${report.legacyVersion || 'unknown'}${NC}`)
+        console.log(`   ${DIM}Location: ~/.prjct-cli/${NC}`)
+        console.log('')
+
+        if (!report.hasNpm) {
+          console.log(`${RED}npm global installation not found${NC}`)
+          console.log('')
+          console.log(`${CYAN}Install prjct-cli via npm first:${NC}`)
+          console.log(`   ${GREEN}npm install -g prjct-cli${NC}`)
+          console.log('')
+          return report
+        }
+
+        console.log(`${CYAN}Migrating to npm installation...${NC}`)
+        console.log('')
+      }
+
+      // Step 1: Migrate projects data
+      if (verbose) console.log(`   ${DIM}Migrating projects data...${NC}`)
+      const projectsMigration = await migrateProjectsData()
+      report.steps.projectsMigrated = projectsMigration.projectsMigrated
+      report.messages.push(projectsMigration.message)
+      if (verbose) {
+        const icon = projectsMigration.success ? `${GREEN}✓${NC}` : `${RED}✗${NC}`
+        console.log(`   ${icon} ${projectsMigration.message}`)
+      }
+
+      // Step 2: Clean legacy installation
+      if (verbose) console.log(`   ${DIM}Removing legacy files...${NC}`)
+      const installCleanup = await cleanupLegacyInstallation()
+      report.steps.installationCleaned = installCleanup.success
+      report.messages.push(installCleanup.message)
+      if (verbose) {
+        const icon = installCleanup.success ? `${GREEN}✓${NC}` : `${RED}✗${NC}`
+        console.log(`   ${icon} ${installCleanup.message}`)
+      }
+
+      // Step 3: Clean PATH entries
+      if (verbose) console.log(`   ${DIM}Cleaning shell PATH...${NC}`)
+      const pathCleanup = await cleanupLegacyPATH()
+      report.steps.pathCleaned = pathCleanup.success
+      report.messages.push(pathCleanup.message)
+      if (verbose) {
+        const icon = pathCleanup.success ? `${GREEN}✓${NC}` : `${RED}✗${NC}`
+        console.log(`   ${icon} ${pathCleanup.message}`)
+      }
+
+      // Step 4: Clean symlinks
+      if (verbose) console.log(`   ${DIM}Cleaning symlinks...${NC}`)
+      const symlinkCleanup = await cleanupLegacySymlinks()
+      report.steps.symlinksCleaned = symlinkCleanup.success
+      report.messages.push(symlinkCleanup.message)
+      if (verbose) {
+        const icon = symlinkCleanup.success ? `${GREEN}✓${NC}` : `${RED}✗${NC}`
+        console.log(`   ${icon} ${symlinkCleanup.message}`)
+      }
+
+      if (verbose) {
+        console.log('')
+        console.log(`${GREEN}Migration complete!${NC}`)
+        console.log('')
+        console.log(`${DIM}Next steps:${NC}`)
+        if (pathCleanup.filesModified && pathCleanup.filesModified > 0) {
+          console.log(`   ${CYAN}1. Reload your shell:${NC}`)
+          console.log(`      source ~/.zshrc  ${DIM}(or ~/.bashrc)${NC}`)
+          console.log('')
+        }
+        const stepNum = pathCleanup.filesModified && pathCleanup.filesModified > 0 ? '2' : '1'
+        console.log(`   ${CYAN}${stepNum}. Verify installation:${NC}`)
+        console.log(`      which prjct  ${DIM}(should show npm path)${NC}`)
+        console.log(`      prjct --version`)
+        console.log('')
+        console.log(`${YELLOW}----------------------------------------${NC}`)
+        console.log('')
+      }
+
+      report.success = true
+      return report
+    } catch (error) {
+      report.messages.push(`Cleanup failed: ${(error as Error).message}`)
+      return report
+    }
+  }
+}
+
+const legacyInstallerDetector = new LegacyInstallerDetector()
+export default legacyInstallerDetector

package/core/infrastructure/legacy-installer-detector/migration.ts

@@ -0,0 +1,87 @@
+/**
+ * Migration - Project Data Migration
+ */
+
+import fs from 'fs/promises'
+import path from 'path'
+import { legacyInstallDir, npmGlobalProjectsDir } from './detection'
+import type { MigrationResult } from './types'
+
+/**
+ * Copy directory recursively
+ */
+async function copyDirectory(source: string, destination: string): Promise<void> {
+  await fs.mkdir(destination, { recursive: true })
+
+  const entries = await fs.readdir(source, { withFileTypes: true })
+
+  for (const entry of entries) {
+    const sourcePath = path.join(source, entry.name)
+    const destPath = path.join(destination, entry.name)
+
+    if (entry.isDirectory()) {
+      await copyDirectory(sourcePath, destPath)
+    } else {
+      await fs.copyFile(sourcePath, destPath)
+    }
+  }
+}
+
+/**
+ * Migrate projects data from legacy location to npm location
+ */
+export async function migrateProjectsData(): Promise<MigrationResult> {
+  const result: MigrationResult = {
+    success: false,
+    projectsMigrated: 0,
+    message: '',
+  }
+
+  try {
+    const legacyProjectsDir = path.join(legacyInstallDir, 'projects')
+
+    // Check if legacy projects directory exists
+    try {
+      await fs.access(legacyProjectsDir)
+    } catch {
+      result.success = true
+      result.message = 'No projects data to migrate'
+      return result
+    }
+
+    // Ensure npm global projects directory exists
+    await fs.mkdir(npmGlobalProjectsDir, { recursive: true })
+
+    // Read all project directories
+    const projectDirs = await fs.readdir(legacyProjectsDir, { withFileTypes: true })
+
+    for (const entry of projectDirs) {
+      if (!entry.isDirectory()) continue
+
+      const legacyProjectPath = path.join(legacyProjectsDir, entry.name)
+      const npmProjectPath = path.join(npmGlobalProjectsDir, entry.name)
+
+      // Check if project already exists in npm location
+      try {
+        await fs.access(npmProjectPath)
+        // Already exists, skip
+        continue
+      } catch {
+        // Doesn't exist, copy it
+        await copyDirectory(legacyProjectPath, npmProjectPath)
+        result.projectsMigrated++
+      }
+    }
+
+    result.success = true
+    result.message =
+      result.projectsMigrated > 0
+        ? `Migrated ${result.projectsMigrated} project(s) to npm global location`
+        : 'All projects already in npm location'
+
+    return result
+  } catch (error) {
+    result.message = `Migration failed: ${(error as Error).message}`
+    return result
+  }
+}

package/core/infrastructure/legacy-installer-detector/types.ts

@@ -0,0 +1,42 @@
+/**
+ * Legacy Installer Detector Types
+ */
+
+// Colors
+export const CYAN = '\x1b[36m'
+export const GREEN = '\x1b[32m'
+export const YELLOW = '\x1b[33m'
+export const RED = '\x1b[31m'
+export const DIM = '\x1b[2m'
+export const NC = '\x1b[0m'
+
+export interface CleanupSteps {
+  projectsMigrated: number
+  installationCleaned: boolean
+  pathCleaned: boolean
+  symlinksCleaned: boolean
+}
+
+export interface CleanupReport {
+  success: boolean
+  legacyVersion: string | null
+  hasNpm: boolean
+  steps: CleanupSteps
+  messages: string[]
+}
+
+export interface MigrationResult {
+  success: boolean
+  projectsMigrated: number
+  message: string
+}
+
+export interface CleanupResult {
+  success: boolean
+  message: string
+  filesModified?: number
+}
+
+export interface CleanupOptions {
+  verbose?: boolean
+}

package/core/infrastructure/legacy-installer-detector.ts

@@ -0,0 +1,7 @@
+/**
+ * Legacy Installer Detector
+ * Re-exports from legacy-installer-detector/index.ts for backwards compatibility.
+ */
+
+import legacyInstallerDetector from './legacy-installer-detector/index'
+export default legacyInstallerDetector

package/core/infrastructure/migrator/file-operations.ts

@@ -0,0 +1,125 @@
+/**
+ * File Operations
+ * Handles file copying and mapping for migrations.
+ */
+
+import fs from 'fs/promises'
+import path from 'path'
+import type { FileMapping, MigrationStats, LayerCounts } from './types'
+
+/**
+ * Copy a directory recursively
+ */
+export async function copyDirectory(source: string, destination: string): Promise<number> {
+  let fileCount = 0
+
+  await fs.mkdir(destination, { recursive: true })
+
+  const entries = await fs.readdir(source, { withFileTypes: true })
+
+  for (const entry of entries) {
+    const sourcePath = path.join(source, entry.name)
+    const destPath = path.join(destination, entry.name)
+
+    if (entry.isDirectory()) {
+      fileCount += await copyDirectory(sourcePath, destPath)
+    } else {
+      await fs.copyFile(sourcePath, destPath)
+      fileCount++
+    }
+  }
+
+  return fileCount
+}
+
+/**
+ * Map legacy flat structure to new layered structure
+ */
+export function mapLegacyFile(filename: string): FileMapping {
+  if (filename === 'now.md' || filename === 'next.md' || filename === 'context.md') {
+    return { layer: 'core', filename }
+  }
+
+  if (filename === 'shipped.md' || filename === 'metrics.md') {
+    return { layer: 'progress', filename }
+  }
+
+  if (filename === 'ideas.md' || filename === 'roadmap.md') {
+    return { layer: 'planning', filename }
+  }
+
+  if (
+    filename === 'memory.jsonl' ||
+    filename === 'context.jsonl' ||
+    filename === 'decisions.jsonl'
+  ) {
+    return { layer: 'memory', filename }
+  }
+
+  if (filename === 'repo-summary.md') {
+    return { layer: 'analysis', filename }
+  }
+
+  return { layer: '.', filename }
+}
+
+/**
+ * Migrate files from legacy structure to new layered structure
+ */
+export async function migrateFiles(legacyPath: string, globalPath: string): Promise<MigrationStats> {
+  let fileCount = 0
+  const layerCounts: LayerCounts = {
+    core: 0,
+    progress: 0,
+    planning: 0,
+    analysis: 0,
+    memory: 0,
+    other: 0,
+  }
+
+  const validLayers = ['core', 'progress', 'planning', 'analysis', 'memory', 'sessions']
+  const entries = await fs.readdir(legacyPath, { withFileTypes: true })
+
+  for (const entry of entries) {
+    const sourcePath = path.join(legacyPath, entry.name)
+
+    if (entry.name === 'prjct.config.json' || entry.name.endsWith('.old')) {
+      continue
+    }
+
+    if (entry.isDirectory()) {
+      if (validLayers.includes(entry.name)) {
+        const destPath = path.join(globalPath, entry.name)
+        const count = await copyDirectory(sourcePath, destPath)
+        fileCount += count
+        if (Object.prototype.hasOwnProperty.call(layerCounts, entry.name)) {
+          layerCounts[entry.name as keyof LayerCounts] += count
+        } else {
+          layerCounts.other += count
+        }
+      } else {
+        const destPath = path.join(globalPath, 'planning', entry.name)
+        const count = await copyDirectory(sourcePath, destPath)
+        fileCount += count
+        layerCounts.planning += count
+      }
+    } else {
+      const mapping = mapLegacyFile(entry.name)
+      const destPath = path.join(globalPath, mapping.layer, mapping.filename)
+
+      await fs.mkdir(path.dirname(destPath), { recursive: true })
+
+      await fs.copyFile(sourcePath, destPath)
+      fileCount++
+
+      if (mapping.layer === '.') {
+        layerCounts.other++
+      } else {
+        layerCounts[mapping.layer as keyof LayerCounts] =
+          (layerCounts[mapping.layer as keyof LayerCounts] || 0) + 1
+      }
+    }
+  }
+
+  return { fileCount, layerCounts }
+}