prjct-cli 0.4.1 → 0.4.3

package/CHANGELOG.md

@@ -7,6 +7,60 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Coming Soon
+- **Windows Compatibility** - Native Windows support
+  - PowerShell and CMD command execution
+  - Windows path handling (`%USERPROFILE%\.prjct-cli\`)
+  - Windows-specific installation scripts
+  - Cross-platform file operations
+  - Windows Terminal integration
+
+## [0.4.3] - 2025-10-02
+
+### Added
+- **Automatic Editor Command Updates** - Commands auto-update when npm package is updated
+  - New `core/editors-config.js` tracks which editors user has installed commands to
+  - Stores editor selections in `~/.prjct-cli/config/installed-editors.json`
+  - Post-install hook (`scripts/post-install.js`) auto-updates commands after `npm update -g prjct-cli`
+  - Ensures version consistency across all configured editors (Claude, Cursor, Windsurf, Codex)
+  - No manual reinstallation needed - updates happen automatically
+  - Respects user's original editor choices from initial setup
+
+- **GitHub Packages Support** - Dual registry publication for better reliability
+  - Package now published to both npm and GitHub Packages automatically
+  - GitHub Actions workflow updated to publish to both registries in parallel
+  - Added comprehensive GitHub Packages documentation (`docs/GITHUB_PACKAGES.md`)
+  - Includes `.npmrc.example` for easy local configuration
+  - Provides fallback option if npm registry is unavailable
+  - Free hosting for public repositories with automatic authentication
+
+### Changed
+- **Installation Documentation** - Updated README with dual installation options
+  - Primary: npm registry (recommended for most users)
+  - Alternative: GitHub Packages (for advanced users or npm fallback)
+  - Clear instructions for both installation methods
+
+### Technical Details
+- **Editor Tracking**: Configuration saved after successful command installation
+- **Post-Install Hook**: Runs only for global installations, skips for local/dev installs
+- **Version Detection**: Compares current version with last installed version
+- **Force Update**: Automatically updates commands when version changes
+- **Parallel Publication**: npm and GitHub Packages jobs run simultaneously for faster releases
+
+## [0.4.2] - 2025-10-02
+
+### Fixed
+- **Analyzer Compatibility** - Fixed ENOENT error when running `/p:init` in non-prjct projects
+  - Added validation to check if `bin/prjct` exists before reading
+  - Analyzer now works correctly in any project type (React, Vue, etc.)
+  - No longer throws "no such file or directory" error for normal projects
+  - Maintains full functionality for prjct-cli development projects
+
+- **Website Build Process** - Improved build script and component imports
+  - Fixed Badge component import casing (badge → Badge)
+  - Removed obsolete install.sh and setup.sh copying from build script
+  - Cleaner and faster website builds
+
 ## [0.4.1] - 2025-10-01
 
 ### Added

package/README.md

@@ -46,6 +46,8 @@ Each agent gets optimized output:
 
 ## ⚡ Installation
 
+### From npm (Recommended)
+
 Install prjct-cli globally using npm:
 
 ```bash
@@ -65,6 +67,16 @@ pnpm add -g prjct-cli
 bun install -g prjct-cli
 ```
 
+### From GitHub Packages
+
+You can also install from GitHub Packages:
+
+```bash
+npm install -g @jlopezlira/prjct-cli --registry=https://npm.pkg.github.com
+```
+
+For easier installation from GitHub Packages, see [GitHub Packages Setup](docs/GITHUB_PACKAGES.md).
+
 **Requirements**: Node.js 18 or higher
 
 > **Note**: The CLI automatically detects updates and notifies you when a new version is available. Simply run `npm update -g prjct-cli` to upgrade.

package/core/analyzer.js

@@ -48,11 +48,15 @@ class CodebaseAnalyzer {
 
     try {
       const binPath = path.join(this.projectPath, 'bin', 'prjct')
-      const content = await fs.readFile(binPath, 'utf-8')
 
-      const caseMatches = content.matchAll(/case\s+'([^']+)':/g)
-      for (const match of caseMatches) {
-        commands.push(match[1])
+      // Only try to read bin/prjct if it exists (for prjct-cli projects)
+      if (await this.fileExists(binPath)) {
+        const content = await fs.readFile(binPath, 'utf-8')
+
+        const caseMatches = content.matchAll(/case\s+'([^']+)':/g)
+        for (const match of caseMatches) {
+          commands.push(match[1])
+        }
       }
 
       const commandsPath = path.join(this.projectPath, 'core', 'commands.js')

package/core/command-installer.js

@@ -403,6 +403,7 @@ For detailed implementation, see prjct-cli documentation.
 
     const results = {}
     const installedTo = []
+    const successfulEditors = []
 
     for (const editorKey of selectedEditors) {
       const editor = this.editors[editorKey]
@@ -426,6 +427,7 @@ For detailed implementation, see prjct-cli documentation.
       results[editorKey] = await this.installToEditor(editorKey, forceUpdate)
       if (results[editorKey].success) {
         installedTo.push(editor.name)
+        successfulEditors.push(editorKey)
       }
     }
 
@@ -442,6 +444,11 @@ For detailed implementation, see prjct-cli documentation.
     const totalUpdated = Object.values(results)
       .reduce((sum, r) => sum + (r.updated || 0), 0)
 
+    // Save editor selections to config (only on successful new installations, not updates)
+    if (!forceUpdate && successfulEditors.length > 0) {
+      await this.saveEditorConfig(successfulEditors)
+    }
+
     return {
       success: true,
       editors: installedTo,
@@ -667,6 +674,36 @@ This command uses the global prjct architecture:
     return lines.join('\n')
   }
 
+  /**
+   * Save editor configuration to track installed editors
+   * @param {string[]} editors - Array of successfully installed editor keys
+   * @returns {Promise<void>}
+   */
+  async saveEditorConfig(editors) {
+    try {
+      const editorsConfig = require('./editors-config')
+      const packageJson = require('../package.json')
+
+      // Build paths object
+      const paths = {}
+      for (const editorKey of editors) {
+        const editor = this.editors[editorKey]
+        if (editor) {
+          paths[editorKey] = editor.commandsPath
+        }
+      }
+
+      await editorsConfig.saveConfig(
+        editors,
+        paths,
+        packageJson.version,
+      )
+    } catch (error) {
+      // Don't fail installation if config save fails
+      console.error('[command-installer] Error saving editor config:', error.message)
+    }
+  }
+
   /**
    * Install Context7 MCP configuration for all detected editors
    * @returns {Promise<Object>} Installation results

package/core/editors-config.js

@@ -0,0 +1,160 @@
+const fs = require('fs').promises
+const path = require('path')
+const os = require('os')
+
+/**
+ * EditorsConfig - Manages installed editors tracking configuration
+ *
+ * Tracks which AI editors user has installed prjct commands to,
+ * enabling automatic updates when npm package is updated.
+ *
+ * Config location: ~/.prjct-cli/config/installed-editors.json
+ *
+ * @version 0.4.2
+ */
+class EditorsConfig {
+  constructor() {
+    this.homeDir = os.homedir()
+    this.configDir = path.join(this.homeDir, '.prjct-cli', 'config')
+    this.configFile = path.join(this.configDir, 'installed-editors.json')
+  }
+
+  /**
+   * Ensure config directory exists
+   */
+  async ensureConfigDir() {
+    try {
+      await fs.mkdir(this.configDir, { recursive: true })
+    } catch (error) {
+      console.error('[editors-config] Error creating config directory:', error.message)
+    }
+  }
+
+  /**
+   * Load installed editors configuration
+   * @returns {Promise<Object|null>} Configuration object or null if not found
+   */
+  async loadConfig() {
+    try {
+      const content = await fs.readFile(this.configFile, 'utf-8')
+      return JSON.parse(content)
+    } catch (error) {
+      if (error.code === 'ENOENT') {
+        return null
+      }
+      console.error('[editors-config] Error loading config:', error.message)
+      return null
+    }
+  }
+
+  /**
+   * Save installed editors configuration
+   * @param {string[]} editors - Array of editor keys (e.g., ['claude', 'cursor'])
+   * @param {Object} paths - Object mapping editor keys to installation paths
+   * @param {string} version - Current prjct-cli version
+   * @returns {Promise<boolean>} Success status
+   */
+  async saveConfig(editors, paths, version) {
+    try {
+      await this.ensureConfigDir()
+
+      const config = {
+        version,
+        editors,
+        lastInstall: new Date().toISOString(),
+        paths,
+      }
+
+      await fs.writeFile(
+        this.configFile,
+        JSON.stringify(config, null, 2),
+        'utf-8',
+      )
+
+      return true
+    } catch (error) {
+      console.error('[editors-config] Error saving config:', error.message)
+      return false
+    }
+  }
+
+  /**
+   * Get tracked editors from configuration
+   * @returns {Promise<string[]>} Array of editor keys
+   */
+  async getTrackedEditors() {
+    const config = await this.loadConfig()
+    return config ? config.editors : []
+  }
+
+  /**
+   * Get editor paths from configuration
+   * @returns {Promise<Object>} Object mapping editor keys to paths
+   */
+  async getEditorPaths() {
+    const config = await this.loadConfig()
+    return config ? config.paths : {}
+  }
+
+  /**
+   * Get last installed version
+   * @returns {Promise<string|null>} Version string or null
+   */
+  async getLastVersion() {
+    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) {
+    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) {
+    try {
+      const config = await this.loadConfig()
+      if (!config) {
+        return false
+      }
+
+      config.version = version
+      config.lastInstall = new Date().toISOString()
+
+      await fs.writeFile(
+        this.configFile,
+        JSON.stringify(config, null, 2),
+        'utf-8',
+      )
+
+      return true
+    } catch (error) {
+      console.error('[editors-config] Error updating version:', error.message)
+      return false
+    }
+  }
+
+  /**
+   * Check if config file exists
+   * @returns {Promise<boolean>} True if config exists
+   */
+  async configExists() {
+    try {
+      await fs.access(this.configFile)
+      return true
+    } catch {
+      return false
+    }
+  }
+}
+
+module.exports = new EditorsConfig()

package/package.json

@@ -1,15 +1,17 @@
 {
   "name": "prjct-cli",
-  "version": "0.4.1",
+  "version": "0.4.3",
   "description": "AI-integrated project management for indie hackers - works with Claude Code, Cursor, and Warp",
   "main": "core/index.js",
   "bin": {
     "prjct": "./bin/prjct"
   },
   "publishConfig": {
-    "access": "public"
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
   },
   "scripts": {
+    "postinstall": "node scripts/post-install.js",
     "install-global": "./scripts/install.sh",
     "test": "echo 'No tests configured'",
     "lint": "eslint \"**/*.js\" --ignore-pattern \"node_modules/**\" --ignore-pattern \"website/**\"",
@@ -66,6 +68,7 @@
     "templates/",
     "scripts/install.sh",
     "scripts/verify-installation.sh",
+    "scripts/post-install.js",
     "LICENSE",
     "README.md",
     "CHANGELOG.md",

package/scripts/post-install.js

@@ -0,0 +1,118 @@
+#!/usr/bin/env node
+
+/**
+ * Post-Install Script
+ *
+ * Runs automatically after `npm install -g prjct-cli` or `npm update -g prjct-cli`.
+ * Auto-updates slash commands in all previously configured editors.
+ *
+ * Flow:
+ * 1. Check if running as global install
+ * 2. Read tracked editors from ~/.prjct-cli/config/installed-editors.json
+ * 3. If config exists and version changed, force-update commands in tracked editors
+ * 4. Update version in config
+ *
+ * @version 0.4.2
+ */
+
+const path = require('path')
+const chalk = require('chalk')
+const { execSync } = require('child_process')
+
+async function main() {
+  try {
+    // Check if this is a global installation
+    const isGlobal = await checkIfGlobalInstall()
+
+    if (!isGlobal) {
+      // Skip post-install for local/dev installations
+      return
+    }
+
+    // Load editors config
+    const editorsConfig = require('../core/editors-config')
+    const configExists = await editorsConfig.configExists()
+
+    if (!configExists) {
+      // First-time install, no editors tracked yet
+      // User will configure editors during `prjct init` or `prjct install`
+      return
+    }
+
+    // Get current package version
+    const packageJson = require('../package.json')
+    const currentVersion = packageJson.version
+
+    // Check if version has changed
+    const versionChanged = await editorsConfig.hasVersionChanged(currentVersion)
+
+    if (!versionChanged) {
+      // Same version, no update needed
+      return
+    }
+
+    // Get tracked editors and paths
+    const trackedEditors = await editorsConfig.getTrackedEditors()
+    const editorPaths = await editorsConfig.getEditorPaths()
+
+    if (trackedEditors.length === 0) {
+      // No editors tracked yet
+      return
+    }
+
+    console.log(chalk.cyan('\n🔄 Updating prjct commands in configured editors...\n'))
+
+    // Load command installer
+    const commandInstaller = require('../core/command-installer')
+
+    // Force-update commands in all tracked editors
+    const results = await commandInstaller.installToSelected(trackedEditors, true)
+
+    if (results.success) {
+      console.log(chalk.green(`✅ Updated commands in: ${results.editors.join(', ')}`))
+      console.log(chalk.gray(`   Commands updated: ${results.totalUpdated}`))
+    } else {
+      console.log(chalk.yellow('⚠️  Some editors could not be updated'))
+    }
+
+    // Update version in config
+    await editorsConfig.updateVersion(currentVersion)
+
+    console.log(chalk.cyan(`\n✨ prjct-cli ${currentVersion} is ready!\n`))
+
+  } catch (error) {
+    // Silently fail - don't block npm install
+    // Only log if explicitly debugging
+    if (process.env.DEBUG) {
+      console.error(chalk.red('[post-install] Error:'), error.message)
+    }
+  }
+}
+
+/**
+ * Check if package is being installed globally
+ * @returns {Promise<boolean>} True if global install
+ */
+async function checkIfGlobalInstall() {
+  try {
+    // Get npm global root directory
+    const globalRoot = execSync('npm root -g', { encoding: 'utf-8' }).trim()
+
+    // Get current package directory
+    const currentDir = path.resolve(__dirname, '..')
+
+    // Check if current directory is under global node_modules
+    return currentDir.startsWith(globalRoot)
+  } catch {
+    return false
+  }
+}
+
+// Run main function
+main().catch(error => {
+  // Silently fail - don't block npm install
+  if (process.env.DEBUG) {
+    console.error('[post-install] Fatal error:', error)
+  }
+  process.exit(0) // Exit with success to not block npm install
+})