prjct-cli 0.4.7 → 0.4.8

package/CHANGELOG.md

@@ -15,6 +15,29 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   - Cross-platform file operations
   - Windows Terminal integration
 
+## [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/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
    *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prjct-cli",
-  "version": "0.4.7",
+  "version": "0.4.8",
   "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) {