prjct-cli 0.4.7 → 0.4.9

package/CHANGELOG.md

@@ -15,6 +15,50 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   - Cross-platform file operations
   - Windows Terminal integration
 
+## [0.4.9] - 2025-10-02
+
+### Added
+- **Editor Uninstallation** - `prjct start` now allows removing editors
+  - Interactive checkbox selection shows currently installed editors
+  - Uncheck an editor to remove all prjct commands from it
+  - Automatically cleans up `~/.prjct-cli/config/installed-editors.json`
+  - User has full control over which editors have prjct commands
+
+### Changed
+- **`prjct start` Never Blocks** - Removed "already set up" error
+  - Can run `prjct start` anytime to reconfigure editors
+  - Shows beautiful ASCII art every time
+  - User decides which editors to keep/remove
+
+### Fixed
+- **Interactive Prompts** - Better UX for editor selection
+  - Pre-selects currently installed editors
+  - Clear message: "Select AI editors (uncheck to remove)"
+  - Allows selecting 0 editors (removes all)
+
+## [0.4.8] - 2025-10-02
+
+### Added
+- **Intelligent Project Initialization** - `prjct init` now works seamlessly in all scenarios
+  - Preserves existing project IDs when re-initializing
+  - Automatically merges local data with global structure
+  - Smart fusion of markdown files (now.md, next.md, shipped.md, ideas.md)
+  - Chronological merging of memory/context.jsonl entries
+  - Cleans up local `.prjct/` directory, keeping only `prjct.config.json`
+  - Multiple developers can initialize the same project without conflicts
+
+### Fixed
+- **Auto-Migration Removed** - Disabled intrusive automatic migration
+  - Migration no longer runs automatically during `prjct init` or any command
+  - Users can run `prjct migrate-all` manually if needed
+  - Removes blocking behavior that prevented normal usage
+  - Cleaner, non-intrusive installation and update experience
+
+### Changed
+- **`prjct init` Never Blocks** - Removed "already initialized" error
+  - Always allows re-initialization with intelligent data fusion
+  - Global architecture enables multi-developer workflows
+
 ## [0.4.7] - 2025-10-02
 
 ### Fixed

package/core/command-installer.js

@@ -480,24 +480,93 @@ For detailed implementation, see prjct-cli documentation.
     return await this.installToSelected(detectedEditors, forceUpdate)
   }
 
+  /**
+   * Uninstall commands from a specific editor
+   * @param {string} editorKey - Editor key (claude, cursor, windsurf, codex)
+   * @returns {Promise<Object>} Uninstall result
+   */
+  async uninstallFromEditor(editorKey) {
+    const chalk = require('chalk')
+    const editorsConfig = require('./editors-config')
+
+    const editor = this.editors[editorKey]
+    if (!editor) {
+      return {
+        success: false,
+        message: `Unknown editor: ${editorKey}`,
+      }
+    }
+
+    try {
+      // Delete commands from editor
+      const commandsPath = editor.path
+      const fs = require('fs').promises
+
+      // Get list of prjct commands
+      const commands = ['init', 'now', 'done', 'ship', 'next', 'idea', 'recap', 'progress', 'stuck', 'context',
+        'cleanup', 'design', 'task', 'git', 'test', 'roadmap', 'fix', 'analyze']
+
+      let deletedCount = 0
+
+      for (const command of commands) {
+        const commandFile = path.join(commandsPath, `p:${command}.md`)
+        try {
+          await fs.unlink(commandFile)
+          deletedCount++
+        } catch {
+          // Command file doesn't exist, skip
+        }
+      }
+
+      // Remove editor from tracked list
+      await editorsConfig.removeTrackedEditor(editorKey)
+
+      console.log(chalk.yellow(`🗑️  Removed ${deletedCount} commands from ${editor.name}`))
+
+      return {
+        success: true,
+        message: `Removed commands from ${editor.name}`,
+        deleted: deletedCount,
+      }
+    } catch (error) {
+      console.error(chalk.red(`❌ Error removing commands from ${editor.name}:`), error.message)
+      return {
+        success: false,
+        message: `Failed to remove commands: ${error.message}`,
+      }
+    }
+  }
+
   /**
    * Interactive installation with user selection using prompts
-   * @param {boolean} forceUpdate - Force update existing commands
+   * @param {boolean} allowUninstall - Allow uninstalling editors
    * @returns {Promise<Object>} Installation results
    */
-  async interactiveInstall(forceUpdate = false) {
+  async interactiveInstall(allowUninstall = false) {
     const prompts = require('prompts')
+    const editorsConfig = require('./editors-config')
 
     // Detect all editors
     const detected = await this.detectEditors(this.projectPath)
 
+    // Get currently installed editors if allowUninstall
+    let installedEditors = []
+    if (allowUninstall) {
+      try {
+        installedEditors = await editorsConfig.getTrackedEditors()
+      } catch {
+        // No editors installed yet
+      }
+    }
+
     // Create choices for prompts
     const availableEditors = Object.entries(detected)
       .filter(([_, info]) => info.detected)
       .map(([key, info]) => ({
         title: `${this.editors[key].name} (${info.path})`,
         value: key,
-        selected: true, // Pre-select all detected editors
+        // Pre-select if allowUninstall and already installed, otherwise select all
+        selected: allowUninstall ? installedEditors.includes(key) : true,
       }))
 
     if (availableEditors.length === 0) {
@@ -513,15 +582,15 @@ For detailed implementation, see prjct-cli documentation.
     const response = await prompts({
       type: 'multiselect',
       name: 'selectedEditors',
-      message: 'Select AI editors to install commands to:',
+      message: allowUninstall ? 'Select AI editors (uncheck to remove):' : 'Select AI editors to install commands to:',
       choices: availableEditors,
-      min: 1,
+      min: allowUninstall ? 0 : 1, // Allow 0 selections if uninstalling
       hint: '- Space to select. Return to submit',
       instructions: false,
     })
 
     // Check if user cancelled
-    if (!response.selectedEditors || response.selectedEditors.length === 0) {
+    if (response.selectedEditors === undefined) {
       return {
         success: false,
         message: 'Installation cancelled by user',
@@ -530,8 +599,28 @@ For detailed implementation, see prjct-cli documentation.
       }
     }
 
-    // Install to selected editors
-    return await this.installToSelected(response.selectedEditors, forceUpdate)
+    const selectedEditors = response.selectedEditors || []
+
+    // If allowUninstall, handle editors that were deselected
+    if (allowUninstall) {
+      const deselectedEditors = installedEditors.filter(e => !selectedEditors.includes(e))
+
+      for (const editorKey of deselectedEditors) {
+        await this.uninstallFromEditor(editorKey)
+      }
+    }
+
+    // Install to selected editors (or return success if none selected)
+    if (selectedEditors.length === 0) {
+      return {
+        success: true,
+        message: 'All editors removed',
+        editors: [],
+        results: {},
+      }
+    }
+
+    return await this.installToSelected(selectedEditors, true) // Force update
   }
 
   /**

package/core/commands.js

@@ -192,8 +192,6 @@ class PrjctCommands {
 
     this.agent = new Agent()
 
-    await this.checkAndRunAutoMigration()
-
     // Check for updates in background (non-blocking)
     this.checkAndNotifyUpdates().catch(() => {
       // Fail silently - don't interrupt workflow
@@ -316,41 +314,46 @@ class PrjctCommands {
   async init(projectPath = process.cwd()) {
     try {
       await this.initializeAgent()
-
-      if (await configManager.isConfigured(projectPath)) {
-        return {
-          success: false,
-          message: this.agent.formatResponse('Project already initialized!', 'warning'),
-        }
-      }
-
       const author = await authorDetector.detect()
 
-      const hasLegacy = await pathManager.hasLegacyStructure(projectPath)
-      let migrationPerformed = false
+      // Check if local config exists
+      const isConfigured = await configManager.isConfigured(projectPath)
+      let projectId
+      let existingLocalData = null
+      let fusionPerformed = false
 
-      if (hasLegacy) {
-        const config = await configManager.createConfig(projectPath, author)
-        const projectId = config.projectId
-        await pathManager.ensureProjectStructure(projectId)
+      if (isConfigured) {
+        // Use existing ID from local config
+        const existingConfig = await configManager.readConfig(projectPath)
+        projectId = existingConfig.projectId
+        console.log(`🔄 Using existing project ID: ${projectId}`)
 
+        // Check if there's local data to merge
+        const localPrjctPath = path.join(projectPath, '.prjct')
         try {
-          const migrationResult = await migrator.migrate(projectPath, {
-            removeLegacy: false,
-            cleanupLegacy: true,
-            dryRun: false,
-          })
-          migrationPerformed = migrationResult.success
+          const localFiles = await fs.readdir(localPrjctPath)
+          if (localFiles.length > 1) { // More than just prjct.config.json
+            existingLocalData = await this.collectLocalData(localPrjctPath)
+          }
         } catch (error) {
-          console.error('[prjct] Migration warning:', error.message)
+          // No local data to merge
         }
+      } else {
+        // Generate new ID based on path hash
+        const config = await configManager.createConfig(projectPath, author)
+        projectId = config.projectId
+        console.log(`✨ Created new project ID: ${projectId}`)
       }
 
-      if (!migrationPerformed) {
-        const config = await configManager.createConfig(projectPath, author)
-        const projectId = config.projectId
-        await pathManager.ensureProjectStructure(projectId)
+      // Ensure global structure exists
+      await pathManager.ensureProjectStructure(projectId)
+      const globalPath = pathManager.getGlobalProjectPath(projectId)
+
+      // Check if global data exists
+      const globalExists = await this.checkGlobalDataExists(globalPath)
 
+      if (!globalExists) {
+        // Create fresh global structure
         const files = {
           'core/now.md': '# NOW\n\nNo current task. Use `/p:now` to set focus.\n',
           'core/next.md': '# NEXT\n\n## Priority Queue\n\n',
@@ -362,22 +365,25 @@ class PrjctCommands {
           'memory/context.jsonl': '',
         }
 
-        const globalPath = pathManager.getGlobalProjectPath(projectId)
         for (const [filePath, content] of Object.entries(files)) {
           await this.agent.writeFile(path.join(globalPath, filePath), content)
         }
+        console.log('✅ Created global structure')
+      } else {
+        console.log('✅ Using existing global data')
       }
 
-      const config = await configManager.readConfig(projectPath)
-      const projectId = config.projectId
-      const globalPath = pathManager.getGlobalProjectPath(projectId)
+      // Merge local data if exists
+      if (existingLocalData) {
+        console.log('🔄 Merging local data with global...')
+        await this.mergeProjectData(existingLocalData, globalPath)
+        fusionPerformed = true
+      }
 
-      const projectInfo = await this.detectProjectType(projectPath)
+      // Clean up local data (keep only prjct.config.json)
+      await this.cleanupLocalData(projectPath)
 
-      const installResult = await this.install({ force: false, interactive: true })
-      const editorsInstalled = installResult.success
-        ? `\n🤖 Commands installed to: ${installResult.message.split('Editors: ')[1]?.split('\n')[0] || 'selected editors'}`
-        : ''
+      const projectInfo = await this.detectProjectType(projectPath)
 
       let analysisMessage = ''
       const hasExistingCode = await this.detectExistingCode(projectPath)
@@ -403,13 +409,14 @@ class PrjctCommands {
       }
 
       const displayPath = pathManager.getDisplayPath(globalPath)
+      const fusionMessage = fusionPerformed ? '\n🔄 Merged local data with global' : ''
       const message =
         `Initializing prjct v${VERSION} for ${this.agentInfo.name}...\n` +
-        `✅ Created global structure at ${displayPath}\n` +
-        '✅ Created prjct.config.json\n' +
+        `✅ Project ID: ${projectId}\n` +
+        `✅ Global data: ${displayPath}\n` +
         `👤 Author: ${authorDetector.formatAuthor(author)}\n` +
         `📋 Project: ${projectInfo}` +
-        editorsInstalled +
+        fusionMessage +
         analysisMessage +
         `\n\nReady! Start with ${this.agentInfo.config.commandPrefix}now "your first task"`
 
@@ -426,6 +433,270 @@ class PrjctCommands {
     }
   }
 
+  /**
+   * Check if global data exists for a project
+   *
+   * @param {string} globalPath - Global project path
+   * @returns {Promise<boolean>} True if global data exists
+   * @private
+   */
+  async checkGlobalDataExists(globalPath) {
+    try {
+      const nowFile = path.join(globalPath, 'core', 'now.md')
+      await fs.access(nowFile)
+      return true
+    } catch {
+      return false
+    }
+  }
+
+  /**
+   * Collect all data from local .prjct directory
+   *
+   * @param {string} localPrjctPath - Path to local .prjct directory
+   * @returns {Promise<Object>} Object with local data organized by category
+   * @private
+   */
+  async collectLocalData(localPrjctPath) {
+    const data = {
+      core: {},
+      progress: {},
+      planning: {},
+      memory: {},
+    }
+
+    try {
+      // Collect core files
+      const coreFiles = ['now.md', 'next.md', 'context.md']
+      for (const file of coreFiles) {
+        try {
+          const filePath = path.join(localPrjctPath, file)
+          data.core[file] = await this.agent.readFile(filePath)
+        } catch {
+          // File doesn't exist locally
+        }
+      }
+
+      // Collect progress files
+      const progressFiles = ['shipped.md', 'metrics.md']
+      for (const file of progressFiles) {
+        try {
+          const filePath = path.join(localPrjctPath, file)
+          data.progress[file] = await this.agent.readFile(filePath)
+        } catch {
+          // File doesn't exist locally
+        }
+      }
+
+      // Collect planning files
+      const planningFiles = ['ideas.md', 'roadmap.md']
+      for (const file of planningFiles) {
+        try {
+          const filePath = path.join(localPrjctPath, file)
+          data.planning[file] = await this.agent.readFile(filePath)
+        } catch {
+          // File doesn't exist locally
+        }
+      }
+
+      // Collect memory
+      try {
+        const memoryPath = path.join(localPrjctPath, 'memory.jsonl')
+        data.memory['context.jsonl'] = await this.agent.readFile(memoryPath)
+      } catch {
+        // Memory doesn't exist locally
+      }
+    } catch (error) {
+      console.error('[prjct] Error collecting local data:', error.message)
+    }
+
+    return data
+  }
+
+  /**
+   * Merge local project data with global data
+   *
+   * @param {Object} localData - Local data collected from .prjct
+   * @param {string} globalPath - Global project path
+   * @returns {Promise<void>}
+   * @private
+   */
+  async mergeProjectData(localData, globalPath) {
+    try {
+      // Merge core files
+      for (const [filename, localContent] of Object.entries(localData.core)) {
+        if (!localContent) continue
+
+        const globalFilePath = path.join(globalPath, 'core', filename)
+        let globalContent = ''
+        try {
+          globalContent = await this.agent.readFile(globalFilePath)
+        } catch {
+          // Global file doesn't exist yet
+        }
+
+        const merged = this.intelligentMerge(localContent, globalContent, filename)
+        await this.agent.writeFile(globalFilePath, merged)
+      }
+
+      // Merge progress files
+      for (const [filename, localContent] of Object.entries(localData.progress)) {
+        if (!localContent) continue
+
+        const globalFilePath = path.join(globalPath, 'progress', filename)
+        let globalContent = ''
+        try {
+          globalContent = await this.agent.readFile(globalFilePath)
+        } catch {
+          // Global file doesn't exist yet
+        }
+
+        const merged = this.intelligentMerge(localContent, globalContent, filename)
+        await this.agent.writeFile(globalFilePath, merged)
+      }
+
+      // Merge planning files
+      for (const [filename, localContent] of Object.entries(localData.planning)) {
+        if (!localContent) continue
+
+        const globalFilePath = path.join(globalPath, 'planning', filename)
+        let globalContent = ''
+        try {
+          globalContent = await this.agent.readFile(globalFilePath)
+        } catch {
+          // Global file doesn't exist yet
+        }
+
+        const merged = this.intelligentMerge(localContent, globalContent, filename)
+        await this.agent.writeFile(globalFilePath, merged)
+      }
+
+      // Merge memory (chronologically)
+      if (localData.memory['context.jsonl']) {
+        const globalMemoryPath = path.join(globalPath, 'memory', 'context.jsonl')
+        let globalMemory = ''
+        try {
+          globalMemory = await this.agent.readFile(globalMemoryPath)
+        } catch {
+          // Global memory doesn't exist yet
+        }
+
+        const merged = this.mergeMemory(localData.memory['context.jsonl'], globalMemory)
+        await this.agent.writeFile(globalMemoryPath, merged)
+      }
+    } catch (error) {
+      console.error('[prjct] Error merging data:', error.message)
+    }
+  }
+
+  /**
+   * Intelligent merge of markdown content
+   *
+   * @param {string} localContent - Content from local file
+   * @param {string} globalContent - Content from global file
+   * @param {string} filename - Name of the file being merged
+   * @returns {string} Merged content
+   * @private
+   */
+  intelligentMerge(localContent, globalContent, filename) {
+    // If global is empty, use local
+    if (!globalContent || globalContent.trim() === '' || globalContent.includes('No current task')) {
+      return localContent
+    }
+
+    // If local is empty, use global
+    if (!localContent || localContent.trim() === '') {
+      return globalContent
+    }
+
+    // For now.md, prefer local (most recent)
+    if (filename === 'now.md') {
+      return localContent
+    }
+
+    // For shipped.md, next.md, ideas.md, roadmap.md - combine unique entries
+    const localLines = localContent.split('\n').filter((l) => l.trim())
+    const globalLines = globalContent.split('\n').filter((l) => l.trim())
+
+    // Keep header from global
+    const header = globalLines[0] || localLines[0]
+
+    // Combine unique content (skip headers and empty lines)
+    const allLines = [...globalLines.slice(1), ...localLines.slice(1)]
+    const uniqueLines = [...new Set(allLines)]
+
+    return [header, '', ...uniqueLines].join('\n')
+  }
+
+  /**
+   * Merge memory.jsonl files chronologically
+   *
+   * @param {string} localMemory - Local memory content
+   * @param {string} globalMemory - Global memory content
+   * @returns {string} Merged memory sorted by timestamp
+   * @private
+   */
+  mergeMemory(localMemory, globalMemory) {
+    if (!globalMemory) return localMemory
+    if (!localMemory) return globalMemory
+
+    const localEntries = localMemory.split('\n').filter((l) => l.trim())
+    const globalEntries = globalMemory.split('\n').filter((l) => l.trim())
+
+    const allEntries = [...globalEntries, ...localEntries].map((entry) => {
+      try {
+        return JSON.parse(entry)
+      } catch {
+        return null
+      }
+    }).filter(Boolean)
+
+    // Sort by timestamp
+    allEntries.sort((a, b) => new Date(a.timestamp) - new Date(b.timestamp))
+
+    // Remove duplicates
+    const unique = []
+    const seen = new Set()
+    for (const entry of allEntries) {
+      const key = `${entry.timestamp}-${entry.action}`
+      if (!seen.has(key)) {
+        seen.add(key)
+        unique.push(entry)
+      }
+    }
+
+    return unique.map((e) => JSON.stringify(e)).join('\n')
+  }
+
+  /**
+   * Clean up local .prjct directory, keeping only prjct.config.json
+   *
+   * @param {string} projectPath - Project path
+   * @returns {Promise<void>}
+   * @private
+   */
+  async cleanupLocalData(projectPath) {
+    try {
+      const localPrjctPath = path.join(projectPath, '.prjct')
+      const files = await fs.readdir(localPrjctPath, { withFileTypes: true })
+
+      for (const file of files) {
+        if (file.name === 'prjct.config.json') continue
+
+        const filePath = path.join(localPrjctPath, file.name)
+        if (file.isDirectory()) {
+          await fs.rm(filePath, { recursive: true, force: true })
+        } else {
+          await fs.unlink(filePath)
+        }
+      }
+
+      console.log('🧹 Cleaned up local data - only prjct.config.json remains')
+    } catch (error) {
+      console.error('[prjct] Warning: Could not clean up local data:', error.message)
+    }
+  }
+
   /**
    * Set or view current task
    *
@@ -1949,20 +2220,6 @@ ${diagram}
     try {
       await this.initializeAgent()
 
-      // Check if already configured
-      const editorsConfig = require('./editors-config')
-      const configExists = await editorsConfig.configExists()
-
-      if (configExists) {
-        return {
-          success: false,
-          message: this.agent.formatResponse(
-            'prjct is already set up!\n\nTo reconfigure editors: prjct setup',
-            'warning'
-          ),
-        }
-      }
-
       // ASCII Art
       const chalk = require('chalk')
       console.log('')
@@ -2006,8 +2263,8 @@ ${diagram}
       })
       console.log('')
 
-      // Interactive selection
-      const installResult = await commandInstaller.interactiveInstall(false)
+      // Interactive selection (allow uninstall = true)
+      const installResult = await commandInstaller.interactiveInstall(true)
 
       if (!installResult.success) {
         return {

package/core/editors-config.js

@@ -87,6 +87,35 @@ class EditorsConfig {
     return config ? config.editors : []
   }
 
+  /**
+   * Remove an editor from tracked list
+   * @param {string} editorKey - Editor key to remove
+   * @returns {Promise<boolean>} Success status
+   */
+  async removeTrackedEditor(editorKey) {
+    try {
+      const config = await this.loadConfig()
+      if (!config) return false
+
+      // Remove from editors array
+      config.editors = config.editors.filter(e => e !== editorKey)
+
+      // Remove from paths object
+      if (config.paths && config.paths[editorKey]) {
+        delete config.paths[editorKey]
+      }
+
+      // Save updated config
+      await fs.mkdir(this.configDir, { recursive: true })
+      await fs.writeFile(this.configPath, JSON.stringify(config, null, 2), 'utf-8')
+
+      return true
+    } catch (error) {
+      console.error('[editors-config] Error removing tracked editor:', error.message)
+      return false
+    }
+  }
+
   /**
    * Get editor paths from configuration
    * @returns {Promise<Object>} Object mapping editor keys to paths

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prjct-cli",
-  "version": "0.4.7",
+  "version": "0.4.9",
   "description": "AI-integrated project management for indie hackers - works with Claude Code, Cursor, and Warp",
   "main": "core/index.js",
   "bin": {

package/scripts/post-install.js

@@ -81,34 +81,6 @@ async function main() {
     // Update version in config
     await editorsConfig.updateVersion(currentVersion)
 
-    // Auto-migrate legacy projects (v0.1.0 → v0.4.4)
-    try {
-      console.log(chalk.cyan('\n🔍 Checking for legacy projects to migrate...\n'))
-
-      const migrator = require('../core/migrator')
-
-      // Quick scan of common directories (not entire home directory)
-      const summary = await migrator.migrateAll({
-        deepScan: false,        // Only scan common dirs (fast)
-        removeLegacy: false,    // Keep legacy dirs for safety
-        cleanupLegacy: true,    // Remove old dirs but keep config
-        dryRun: false,          // Actually perform migration
-        interactive: false      // No user prompts during npm install
-      })
-
-      if (summary.successfullyMigrated > 0) {
-        console.log(chalk.green(`✅ Migrated ${summary.successfullyMigrated} legacy project(s) to new structure`))
-        console.log(chalk.gray(`   Data location: ~/.prjct-cli/projects/`))
-      } else if (summary.totalFound > 0 && summary.alreadyMigrated === summary.totalFound) {
-        console.log(chalk.gray('ℹ️  All projects already using new structure'))
-      }
-    } catch (migrationError) {
-      // Don't block install if migration fails
-      if (process.env.DEBUG) {
-        console.error(chalk.yellow('[post-install] Migration warning:'), migrationError.message)
-      }
-    }
-
     console.log(chalk.cyan(`\n✨ prjct-cli ${currentVersion} is ready!\n`))
 
   } catch (error) {