prjct-cli 0.11.5 → 0.12.0

package/core/infrastructure/{config-manager.js → config-manager.ts}

@@ -1,7 +1,3 @@
-const fs = require('fs').promises
-const pathManager = require('./path-manager')
-const { VERSION } = require('../utils/version')
-
 /**
  * ConfigManager - Manages prjct.config.json files
  *
@@ -13,14 +9,43 @@ const { VERSION } = require('../utils/version')
  *
  * @version 0.2.1
  */
+
+import fs from 'fs/promises'
+import path from 'path'
+import pathManager from './path-manager'
+import { VERSION } from '../utils/version'
+
+interface Author {
+  name: string
+  email: string
+  github: string
+  firstContribution?: string
+  lastActivity?: string
+}
+
+interface LocalConfig {
+  projectId: string
+  dataPath: string
+  authors?: Author[]
+  author?: Author
+  version?: string
+  created?: string
+  lastSync?: string
+}
+
+interface GlobalConfig {
+  projectId: string
+  authors: Author[]
+  version: string
+  created?: string
+  lastSync: string
+}
+
 class ConfigManager {
   /**
    * Read the project configuration file
-   *
-   * @param {string} projectPath - Path to the project
-   * @returns {Promise<Object|null>} - Configuration object or null if not found
    */
-  async readConfig(projectPath) {
+  async readConfig(projectPath: string): Promise<LocalConfig | null> {
     try {
       const configPath = pathManager.getLocalConfigPath(projectPath)
       const content = await fs.readFile(configPath, 'utf-8')
@@ -32,12 +57,8 @@ class ConfigManager {
 
   /**
    * Write the project configuration file
-   *
-   * @param {string} projectPath - Path to the project
-   * @param {Object} config - Configuration object
-   * @returns {Promise<void>}
    */
-  async writeConfig(projectPath, config) {
+  async writeConfig(projectPath: string, config: LocalConfig): Promise<void> {
     const configPath = pathManager.getLocalConfigPath(projectPath)
     const configDir = pathManager.getLegacyPrjctPath(projectPath)
 
@@ -50,11 +71,8 @@ class ConfigManager {
   /**
    * Read the global project configuration file
    * Contains authors array and other system data
-   *
-   * @param {string} projectId - Project identifier
-   * @returns {Promise<Object|null>} - Configuration object or null if not found
    */
-  async readGlobalConfig(projectId) {
+  async readGlobalConfig(projectId: string): Promise<GlobalConfig | null> {
     try {
       const configPath = pathManager.getGlobalProjectConfigPath(projectId)
       const content = await fs.readFile(configPath, 'utf-8')
@@ -66,12 +84,8 @@ class ConfigManager {
 
   /**
    * Write the global project configuration file
-   *
-   * @param {string} projectId - Project identifier
-   * @param {Object} config - Configuration object
-   * @returns {Promise<void>}
    */
-  async writeGlobalConfig(projectId, config) {
+  async writeGlobalConfig(projectId: string, config: GlobalConfig): Promise<void> {
     const configPath = pathManager.getGlobalProjectConfigPath(projectId)
     const configDir = pathManager.getGlobalProjectPath(projectId)
 
@@ -83,11 +97,8 @@ class ConfigManager {
 
   /**
    * Ensure global config exists, create if not
-   *
-   * @param {string} projectId - Project identifier
-   * @returns {Promise<Object>} - Global configuration
    */
-  async ensureGlobalConfig(projectId) {
+  async ensureGlobalConfig(projectId: string): Promise<GlobalConfig> {
     let globalConfig = await this.readGlobalConfig(projectId)
 
     if (!globalConfig) {
@@ -106,25 +117,24 @@ class ConfigManager {
 
   /**
    * Create a new project configuration
-   *
-   * @param {string} projectPath - Path to the project
-   * @param {Object} author - Author information {name, email, github}
-   * @returns {Promise<Object>} - Created configuration
    */
-  async createConfig(projectPath, author) {
+  async createConfig(
+    projectPath: string,
+    author: { name?: string; email?: string; github?: string }
+  ): Promise<LocalConfig> {
     const projectId = pathManager.generateProjectId(projectPath)
     const globalPath = pathManager.getGlobalProjectPath(projectId)
     const displayPath = pathManager.getDisplayPath(globalPath)
     const now = new Date().toISOString()
 
-    const localConfig = {
+    const localConfig: LocalConfig = {
       projectId,
       dataPath: displayPath,
     }
 
     await this.writeConfig(projectPath, localConfig)
 
-    const globalConfig = {
+    const globalConfig: GlobalConfig = {
       projectId,
       authors: [
         {
@@ -147,11 +157,8 @@ class ConfigManager {
 
   /**
    * Update the lastSync timestamp in global config
-   *
-   * @param {string} projectPath - Path to the project
-   * @returns {Promise<void>}
    */
-  async updateLastSync(projectPath) {
+  async updateLastSync(projectPath: string): Promise<void> {
     const projectId = await this.getProjectId(projectPath)
     const globalConfig = await this.readGlobalConfig(projectId)
     if (globalConfig) {
@@ -164,11 +171,8 @@ class ConfigManager {
    * Validate a local configuration object
    * Local config only contains project metadata (projectId, dataPath)
    * All system data (version, created, lastSync, authors) is in global config
-   *
-   * @param {Object} config - Configuration to validate
-   * @returns {boolean} - True if valid
    */
-  validateConfig(config) {
+  validateConfig(config: LocalConfig | null): boolean {
     if (!config) return false
     if (!config.projectId) return false
     if (!config.dataPath) return false
@@ -181,11 +185,8 @@ class ConfigManager {
    * Migration is needed if:
    * - Has legacy .prjct/ structure
    * - AND either no config exists OR files not yet in global location
-   *
-   * @param {string} projectPath - Path to the project
-   * @returns {Promise<boolean>} - True if migration needed
    */
-  async needsMigration(projectPath) {
+  async needsMigration(projectPath: string): Promise<boolean> {
     const hasLegacy = await pathManager.hasLegacyStructure(projectPath)
     if (!hasLegacy) return false
 
@@ -197,8 +198,6 @@ class ConfigManager {
     if (!config || !config.projectId) return true
 
     const globalPath = pathManager.getGlobalProjectPath(config.projectId)
-    const fs = require('fs').promises
-    const path = require('path')
 
     try {
       const coreFiles = await fs.readdir(path.join(globalPath, 'core'))
@@ -210,11 +209,8 @@ class ConfigManager {
 
   /**
    * Get the project ID from config, or generate it if config doesn't exist
-   *
-   * @param {string} projectPath - Path to the project
-   * @returns {Promise<string>} - Project ID
    */
-  async getProjectId(projectPath) {
+  async getProjectId(projectPath: string): Promise<string> {
     const config = await this.readConfig(projectPath)
     if (config && config.projectId) {
       return config.projectId
@@ -225,12 +221,8 @@ class ConfigManager {
   /**
    * Find an author in the authors array by github username
    * Reads from GLOBAL config
-   *
-   * @param {string} projectId - Project identifier
-   * @param {string} githubUsername - GitHub username to search for
-   * @returns {Promise<Object|null>} - Author object or null if not found
    */
-  async findAuthor(projectId, githubUsername) {
+  async findAuthor(projectId: string, githubUsername: string): Promise<Author | null> {
     const globalConfig = await this.readGlobalConfig(projectId)
     if (!globalConfig || !globalConfig.authors) return null
 
@@ -240,12 +232,11 @@ class ConfigManager {
   /**
    * Add a new author to the authors array
    * Writes to GLOBAL config
-   *
-   * @param {string} projectId - Project identifier
-   * @param {Object} author - Author information {name, email, github}
-   * @returns {Promise<void>}
    */
-  async addAuthor(projectId, author) {
+  async addAuthor(
+    projectId: string,
+    author: { name?: string; email?: string; github?: string }
+  ): Promise<void> {
     const globalConfig = await this.ensureGlobalConfig(projectId)
 
     const exists = globalConfig.authors.some((a) => a.github === author.github)
@@ -267,12 +258,8 @@ class ConfigManager {
   /**
    * Update author's last activity timestamp
    * Updates GLOBAL config
-   *
-   * @param {string} projectId - Project identifier
-   * @param {string} githubUsername - GitHub username
-   * @returns {Promise<void>}
    */
-  async updateAuthorActivity(projectId, githubUsername) {
+  async updateAuthorActivity(projectId: string, githubUsername: string): Promise<void> {
     const globalConfig = await this.readGlobalConfig(projectId)
     if (!globalConfig || !globalConfig.authors) return
 
@@ -286,12 +273,10 @@ class ConfigManager {
 
   /**
    * Get current author for session (detect or get from global config)
-   *
-   * @param {string} projectPath - Path to the project
-   * @returns {Promise<string>} - GitHub username of current author
    */
-  async getCurrentAuthor(projectPath) {
-    const authorDetector = require('./author-detector')
+  async getCurrentAuthor(projectPath: string): Promise<string> {
+    // Dynamic import to avoid circular dependency
+    const authorDetector = (await import('./author-detector')).default
     const author = await authorDetector.detect()
 
     const projectId = await this.getProjectId(projectPath)
@@ -302,11 +287,8 @@ class ConfigManager {
 
   /**
    * Check if config exists and is valid
-   *
-   * @param {string} projectPath - Path to the project
-   * @returns {Promise<boolean>} - True if valid config exists
    */
-  async isConfigured(projectPath) {
+  async isConfigured(projectPath: string): Promise<boolean> {
     const config = await this.readConfig(projectPath)
     return this.validateConfig(config)
   }
@@ -314,11 +296,8 @@ class ConfigManager {
   /**
    * Get configuration with defaults
    * Returns LOCAL config only (projectId, dataPath)
-   *
-   * @param {string} projectPath - Path to the project
-   * @returns {Promise<Object>} - Configuration with defaults
    */
-  async getConfigWithDefaults(projectPath) {
+  async getConfigWithDefaults(projectPath: string): Promise<LocalConfig> {
     const config = await this.readConfig(projectPath)
     if (config) {
       return config
@@ -332,4 +311,5 @@ class ConfigManager {
   }
 }
 
-module.exports = new ConfigManager()
+const configManager = new ConfigManager()
+export default configManager

package/core/infrastructure/{editors-config.js → editors-config.ts}

@@ -1,7 +1,3 @@
-const fs = require('fs').promises
-const path = require('path')
-const os = require('os')
-
 /**
  * EditorsConfig - Manages Claude installation tracking
  *
@@ -12,7 +8,23 @@ const os = require('os')
  *
  * @version 0.5.0
  */
+
+import fs from 'fs/promises'
+import path from 'path'
+import os from 'os'
+
+interface EditorConfig {
+  version: string
+  editor: string
+  lastInstall: string
+  path: string
+}
+
 class EditorsConfig {
+  homeDir: string
+  configDir: string
+  configFile: string
+
   constructor() {
     this.homeDir = os.homedir()
     this.configDir = path.join(this.homeDir, '.prjct-cli', 'config')
@@ -22,42 +34,38 @@ class EditorsConfig {
   /**
    * Ensure config directory exists
    */
-  async ensureConfigDir() {
+  async ensureConfigDir(): Promise<void> {
     try {
       await fs.mkdir(this.configDir, { recursive: true })
     } catch (error) {
-      console.error('[editors-config] Error creating config directory:', error.message)
+      console.error('[editors-config] Error creating config directory:', (error as Error).message)
     }
   }
 
   /**
    * Load installation configuration
-   * @returns {Promise<Object|null>} Configuration object or null if not found
    */
-  async loadConfig() {
+  async loadConfig(): Promise<EditorConfig | null> {
     try {
       const content = await fs.readFile(this.configFile, 'utf-8')
       return JSON.parse(content)
     } catch (error) {
-      if (error.code === 'ENOENT') {
+      if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
         return null
       }
-      console.error('[editors-config] Error loading config:', error.message)
+      console.error('[editors-config] Error loading config:', (error as Error).message)
       return null
     }
   }
 
   /**
    * Save installation configuration
-   * @param {string} version - Current prjct-cli version
-   * @param {string} claudePath - Path to Claude commands directory
-   * @returns {Promise<boolean>} Success status
    */
-  async saveConfig(version, claudePath) {
+  async saveConfig(version: string, claudePath: string): Promise<boolean> {
     try {
       await this.ensureConfigDir()
 
-      const config = {
+      const config: EditorConfig = {
         version,
         editor: 'claude',
         lastInstall: new Date().toISOString(),
@@ -68,36 +76,31 @@ class EditorsConfig {
 
       return true
     } catch (error) {
-      console.error('[editors-config] Error saving config:', error.message)
+      console.error('[editors-config] Error saving config:', (error as Error).message)
       return false
     }
   }
 
   /**
    * Get last installed version
-   * @returns {Promise<string|null>} Version string or null
    */
-  async getLastVersion() {
+  async getLastVersion(): Promise<string | null> {
     const config = await this.loadConfig()
     return config ? config.version : null
   }
 
   /**
    * Check if version has changed since last install
-   * @param {string} currentVersion - Current version to compare
-   * @returns {Promise<boolean>} True if version has changed
    */
-  async hasVersionChanged(currentVersion) {
+  async hasVersionChanged(currentVersion: string): Promise<boolean> {
     const lastVersion = await this.getLastVersion()
     return lastVersion !== null && lastVersion !== currentVersion
   }
 
   /**
    * Update version in configuration
-   * @param {string} version - New version to save
-   * @returns {Promise<boolean>} Success status
    */
-  async updateVersion(version) {
+  async updateVersion(version: string): Promise<boolean> {
     try {
       const config = await this.loadConfig()
       if (!config) {
@@ -111,16 +114,15 @@ class EditorsConfig {
 
       return true
     } catch (error) {
-      console.error('[editors-config] Error updating version:', error.message)
+      console.error('[editors-config] Error updating version:', (error as Error).message)
       return false
     }
   }
 
   /**
    * Check if config file exists
-   * @returns {Promise<boolean>} True if config exists
    */
-  async configExists() {
+  async configExists(): Promise<boolean> {
     try {
       await fs.access(this.configFile)
       return true
@@ -132,9 +134,8 @@ class EditorsConfig {
   /**
    * Delete configuration file
    * Used during uninstallation to clean up tracking data
-   * @returns {Promise<boolean>} Success status
    */
-  async deleteConfig() {
+  async deleteConfig(): Promise<boolean> {
     try {
       const exists = await this.configExists()
       if (exists) {
@@ -142,10 +143,11 @@ class EditorsConfig {
       }
       return true
     } catch (error) {
-      console.error('[editors-config] Error deleting config:', error.message)
+      console.error('[editors-config] Error deleting config:', (error as Error).message)
       return false
     }
   }
 }
 
-module.exports = new EditorsConfig()
+const editorsConfig = new EditorsConfig()
+export default editorsConfig

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

@@ -0,0 +1,216 @@
+/**
+ * Cleanup - Legacy Installation Cleanup
+ */
+
+import fs from 'fs/promises'
+import path from 'path'
+import os from 'os'
+import { legacyInstallDir, isWindows } from './detection'
+import type { CleanupResult } from './types'
+
+/**
+ * Get platform-specific shell config files
+ */
+export function getShellConfigFiles(): string[] {
+  if (isWindows) {
+    const profilePaths: string[] = []
+
+    if (process.env.USERPROFILE) {
+      profilePaths.push(
+        path.join(
+          process.env.USERPROFILE,
+          'Documents',
+          'PowerShell',
+          'Microsoft.PowerShell_profile.ps1'
+        ),
+        path.join(
+          process.env.USERPROFILE,
+          'Documents',
+          'WindowsPowerShell',
+          'Microsoft.PowerShell_profile.ps1'
+        )
+      )
+    }
+
+    return profilePaths
+  } else {
+    return [
+      path.join(os.homedir(), '.zshrc'),
+      path.join(os.homedir(), '.bashrc'),
+      path.join(os.homedir(), '.profile'),
+      path.join(os.homedir(), '.bash_profile'),
+    ]
+  }
+}
+
+/**
+ * Remove legacy installation files (keep projects data)
+ */
+export async function cleanupLegacyInstallation(): Promise<CleanupResult> {
+  const result: CleanupResult = {
+    success: false,
+    message: '',
+  }
+
+  try {
+    const dirsToRemove = [
+      'bin',
+      'core',
+      'templates',
+      'scripts',
+      'node_modules',
+      '.git',
+      '__tests__',
+      'website',
+      'docs',
+      '.github',
+    ]
+    const filesToRemove = [
+      'package.json',
+      'package-lock.json',
+      'README.md',
+      'LICENSE',
+      'CHANGELOG.md',
+      'CLAUDE.md',
+      'CONTRIBUTING.md',
+      'MIGRATION.md',
+      'TESTING.md',
+      '.gitignore',
+      '.eslintrc.js',
+      '.prettierrc',
+      'vitest.config.js',
+      'vitest.workspace.js',
+    ]
+
+    let removedItems = 0
+
+    for (const dir of dirsToRemove) {
+      const dirPath = path.join(legacyInstallDir, dir)
+      try {
+        await fs.rm(dirPath, { recursive: true, force: true })
+        removedItems++
+      } catch {
+        // Directory doesn't exist
+      }
+    }
+
+    for (const file of filesToRemove) {
+      const filePath = path.join(legacyInstallDir, file)
+      try {
+        await fs.unlink(filePath)
+        removedItems++
+      } catch {
+        // File doesn't exist
+      }
+    }
+
+    result.success = true
+    result.message = `Removed ${removedItems} legacy installation items`
+    return result
+  } catch (error) {
+    result.message = `Cleanup failed: ${(error as Error).message}`
+    return result
+  }
+}
+
+/**
+ * Clean up legacy PATH entries from shell config files
+ */
+export async function cleanupLegacyPATH(): Promise<CleanupResult> {
+  const result: CleanupResult = {
+    success: false,
+    message: '',
+    filesModified: 0,
+  }
+
+  try {
+    const shellConfigs = getShellConfigFiles()
+
+    for (const configFile of shellConfigs) {
+      try {
+        const content = await fs.readFile(configFile, 'utf8')
+
+        if (!content.includes('.prjct-cli/bin')) {
+          continue
+        }
+
+        const lines = content.split('\n')
+        const filteredLines = lines.filter((line) => {
+          return !line.includes('.prjct-cli/bin') && !line.includes('# prjct/cli')
+        })
+
+        const cleanedLines: string[] = []
+        for (let i = 0; i < filteredLines.length; i++) {
+          const line = filteredLines[i]
+          const prevLine = filteredLines[i - 1]
+
+          if (line.trim() === '' && prevLine && prevLine.trim() === '') {
+            continue
+          }
+
+          cleanedLines.push(line)
+        }
+
+        await fs.writeFile(configFile, cleanedLines.join('\n'), 'utf8')
+        result.filesModified!++
+      } catch {
+        // File doesn't exist or can't read
+      }
+    }
+
+    result.success = true
+    result.message =
+      result.filesModified! > 0
+        ? `Cleaned PATH from ${result.filesModified} shell config(s)`
+        : 'No legacy PATH entries found'
+
+    return result
+  } catch (error) {
+    result.message = `PATH cleanup failed: ${(error as Error).message}`
+    return result
+  }
+}
+
+/**
+ * Clean up legacy symlinks
+ */
+export async function cleanupLegacySymlinks(): Promise<CleanupResult> {
+  const result: CleanupResult = {
+    success: false,
+    message: '',
+  }
+
+  if (isWindows) {
+    result.success = true
+    result.message = 'No symlinks on Windows'
+    return result
+  }
+
+  try {
+    const symlinkPath = path.join(os.homedir(), '.local', 'bin', 'prjct')
+
+    try {
+      const stat = await fs.lstat(symlinkPath)
+
+      if (stat.isSymbolicLink()) {
+        const target = await fs.readlink(symlinkPath)
+
+        if (target.includes('.prjct-cli')) {
+          await fs.unlink(symlinkPath)
+          result.success = true
+          result.message = 'Removed legacy symlink'
+          return result
+        }
+      }
+    } catch {
+      // Symlink doesn't exist
+    }
+
+    result.success = true
+    result.message = 'No legacy symlinks found'
+    return result
+  } catch (error) {
+    result.message = `Symlink cleanup failed: ${(error as Error).message}`
+    return result
+  }
+}