@_xtribe/cli 2.2.7 → 2.2.9

package/enhanced-path-setup.js

@@ -0,0 +1,457 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { execSync } = require('child_process');
+const chalk = require('chalk');
+const ora = require('ora');
+
+const homeDir = os.homedir();
+const tribeDir = path.join(homeDir, '.tribe');
+const tribeBinDir = path.join(tribeDir, 'bin');
+const envScriptPath = path.join(tribeDir, 'tribe-env.sh');
+
+/**
+ * Enhanced PATH setup with comprehensive edge case handling
+ */
+class EnhancedPathSetup {
+    constructor() {
+        this.detectedShell = this.detectShell();
+        this.shellConfigs = this.getShellConfigs();
+        this.backupDir = path.join(tribeDir, 'backups');
+        this.installId = Date.now().toString();
+    }
+
+    /**
+     * Comprehensive shell detection
+     */
+    detectShell() {
+        const shell = process.env.SHELL || '';
+        const parentProcess = process.env._ || '';
+
+        // Check various indicators
+        if (shell.includes('zsh') || parentProcess.includes('zsh')) {
+            return 'zsh';
+        } else if (shell.includes('bash') || parentProcess.includes('bash')) {
+            return 'bash';
+        } else if (shell.includes('fish') || parentProcess.includes('fish')) {
+            return 'fish';
+        } else if (shell.includes('tcsh') || shell.includes('csh')) {
+            return 'csh';
+        } else if (process.platform === 'win32') {
+            return 'powershell';
+        }
+
+        // Fallback: try to detect from system
+        try {
+            const userShell = execSync('echo $0', { encoding: 'utf8', timeout: 1000 }).trim();
+            if (userShell.includes('zsh')) return 'zsh';
+            if (userShell.includes('bash')) return 'bash';
+            if (userShell.includes('fish')) return 'fish';
+        } catch (e) {
+            // Ignore detection failures
+        }
+
+        return 'bash'; // Safe fallback
+    }
+
+    /**
+     * Get shell configuration files in priority order
+     */
+    getShellConfigs() {
+        const configs = {
+            zsh: [
+                '.zshrc',
+                '.zprofile',
+                '.zshenv',
+                '.profile'
+            ],
+            bash: [
+                '.bashrc',
+                '.bash_profile',
+                '.profile',
+                '.bash_login'
+            ],
+            fish: [
+                '.config/fish/config.fish'
+            ],
+            csh: [
+                '.cshrc',
+                '.tcshrc'
+            ],
+            powershell: [
+                'Documents/PowerShell/Microsoft.PowerShell_profile.ps1',
+                'Documents/WindowsPowerShell/Microsoft.PowerShell_profile.ps1'
+            ]
+        };
+
+        return configs[this.detectedShell] || configs.bash;
+    }
+
+    /**
+     * Create enhanced environment script with better detection
+     */
+    createEnvScript() {
+        let envScript;
+
+        if (this.detectedShell === 'fish') {
+            envScript = `# TRIBE CLI Environment (Fish Shell)
+set -l tribe_bin_dir "$HOME/.tribe/bin"
+if test -d "$tribe_bin_dir"
+    if not contains "$tribe_bin_dir" $PATH
+        set -gx PATH "$tribe_bin_dir" $PATH
+    end
+end`;
+        } else if (this.detectedShell === 'csh') {
+            envScript = `# TRIBE CLI Environment (C Shell)
+set tribe_bin_dir = "$HOME/.tribe/bin"
+if ( -d "$tribe_bin_dir" ) then
+    echo ":$PATH:" | grep -q ":$tribe_bin_dir:" || setenv PATH "$tribe_bin_dir:$PATH"
+endif`;
+        } else if (this.detectedShell === 'powershell') {
+            envScript = `# TRIBE CLI Environment (PowerShell)
+$TribeBinDir = "$env:USERPROFILE\\.tribe\\bin"
+if (Test-Path $TribeBinDir) {
+    if (-not ($env:PATH -split ';' -contains $TribeBinDir)) {
+        $env:PATH = "$TribeBinDir;$env:PATH"
+    }
+}`;
+        } else {
+            // Bash/Zsh with enhanced detection
+            envScript = `#!/bin/bash
+# TRIBE CLI Environment
+# Generated on $(date) - Install ID: ${this.installId}
+
+TRIBE_BIN_DIR="$HOME/.tribe/bin"
+
+# Enhanced PATH detection - handles edge cases
+if [[ -d "$TRIBE_BIN_DIR" ]]; then
+    # Check if already in PATH using multiple methods
+    case ":$PATH:" in
+        *":$TRIBE_BIN_DIR:"*)
+            # Already in PATH, do nothing
+            ;;
+        *)
+            # Add to PATH
+            export PATH="$TRIBE_BIN_DIR:$PATH"
+            ;;
+    esac
+fi
+
+# Validate installation
+if command -v tribe >/dev/null 2>&1; then
+    # Optional: Set additional TRIBE environment variables
+    export TRIBE_HOME="$HOME/.tribe"
+    export TRIBE_VERSION="$(tribe version 2>/dev/null || echo 'unknown')"
+fi`;
+        }
+
+        fs.writeFileSync(envScriptPath, envScript);
+        if (this.detectedShell !== 'powershell') {
+            fs.chmodSync(envScriptPath, '755');
+        }
+    }
+
+    /**
+     * Backup existing shell config before modification
+     */
+    backupShellConfig(configPath) {
+        if (!fs.existsSync(this.backupDir)) {
+            fs.mkdirSync(this.backupDir, { recursive: true });
+        }
+
+        const configName = path.basename(configPath);
+        const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+        const backupPath = path.join(this.backupDir, `${configName}.backup.${timestamp}`);
+
+        try {
+            fs.copyFileSync(configPath, backupPath);
+            return backupPath;
+        } catch (error) {
+            console.warn(`Could not backup ${configPath}:`, error.message);
+            return null;
+        }
+    }
+
+    /**
+     * Smart shell config modification with duplicate detection
+     */
+    updateShellConfig() {
+        const indicators = [
+            'TRIBE CLI',
+            'tribe-env.sh',
+            '.tribe/bin',
+            'source ~/.tribe',
+            'TRIBE_BIN_DIR'
+        ];
+
+        for (const configFile of this.shellConfigs) {
+            const configPath = path.join(homeDir, configFile);
+
+            if (!fs.existsSync(configPath)) {
+                // Create config file if it doesn't exist (for primary configs only)
+                if (configFile === this.shellConfigs[0]) {
+                    try {
+                        // Create parent directory if needed
+                        const configDir = path.dirname(configPath);
+                        if (!fs.existsSync(configDir)) {
+                            fs.mkdirSync(configDir, { recursive: true });
+                        }
+                        fs.writeFileSync(configPath, '# Created by TRIBE installer\n');
+                    } catch (error) {
+                        continue; // Skip if can't create
+                    }
+                } else {
+                    continue; // Skip optional configs that don't exist
+                }
+            }
+
+            try {
+                const content = fs.readFileSync(configPath, 'utf8');
+
+                // Check for existing TRIBE configuration
+                const hasExisting = indicators.some(indicator =>
+                    content.includes(indicator)
+                );
+
+                if (hasExisting) {
+                    console.log(chalk.yellow(`⚠️  TRIBE already configured in ${configFile}`));
+
+                    // Check if it's working
+                    if (this.testPathSetup()) {
+                        console.log(chalk.green(`✅ Existing configuration is working`));
+                        return true;
+                    } else {
+                        console.log(chalk.yellow(`🔧 Existing configuration needs fixing`));
+                        this.cleanupOldEntries(configPath, content);
+                    }
+                }
+
+                // Backup before modification
+                this.backupShellConfig(configPath);
+
+                // Add new configuration
+                const sourceLine = this.getSourceLine();
+                const configBlock = `
+# TRIBE CLI - Added ${new Date().toISOString()}
+${sourceLine}`;
+
+                fs.appendFileSync(configPath, configBlock);
+                console.log(chalk.green(`✅ Updated ${configFile}`));
+                return true;
+
+            } catch (error) {
+                console.warn(chalk.yellow(`⚠️  Could not update ${configFile}: ${error.message}`));
+                continue;
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * Get appropriate source line for shell type
+     */
+    getSourceLine() {
+        if (this.detectedShell === 'fish') {
+            return 'source ~/.tribe/tribe-env.sh';
+        } else if (this.detectedShell === 'csh') {
+            return 'source ~/.tribe/tribe-env.sh';
+        } else if (this.detectedShell === 'powershell') {
+            return '. $env:USERPROFILE\\.tribe\\tribe-env.ps1';
+        } else {
+            return 'source ~/.tribe/tribe-env.sh';
+        }
+    }
+
+    /**
+     * Clean up duplicate or broken TRIBE entries
+     */
+    cleanupOldEntries(configPath, content) {
+        const lines = content.split('\n');
+        const cleanedLines = [];
+        let skipNext = false;
+        let removedCount = 0;
+
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+
+            if (skipNext) {
+                skipNext = false;
+                removedCount++;
+                continue;
+            }
+
+            // Skip old TRIBE entries
+            if (line.includes('TRIBE CLI') ||
+                line.includes('tribe-env.sh') ||
+                line.includes('export PATH=') && line.includes('.tribe/bin') ||
+                line.includes('TRIBE_BIN_DIR')) {
+
+                removedCount++;
+
+                // Check if next line is related
+                if (i + 1 < lines.length &&
+                    (lines[i + 1].includes('tribe') || lines[i + 1].trim() === '')) {
+                    skipNext = true;
+                }
+                continue;
+            }
+
+            cleanedLines.push(line);
+        }
+
+        if (removedCount > 0) {
+            fs.writeFileSync(configPath, cleanedLines.join('\n'));
+            console.log(chalk.blue(`🧹 Cleaned up ${removedCount} old TRIBE entries`));
+        }
+    }
+
+    /**
+     * Test if PATH setup is working
+     */
+    testPathSetup() {
+        try {
+            // Test if tribe command is accessible
+            const tribePath = path.join(tribeBinDir, 'tribe');
+            if (!fs.existsSync(tribePath)) {
+                return false;
+            }
+
+            // Test if it's in PATH
+            const whichResult = execSync('which tribe 2>/dev/null || echo ""', {
+                encoding: 'utf8',
+                timeout: 2000
+            }).trim();
+
+            return whichResult.includes('.tribe/bin/tribe');
+        } catch (error) {
+            return false;
+        }
+    }
+
+    /**
+     * Provide comprehensive installation summary
+     */
+    generateInstallSummary() {
+        const summary = {
+            shell: this.detectedShell,
+            pathWorking: this.testPathSetup(),
+            envScriptExists: fs.existsSync(envScriptPath),
+            tribeBinaryExists: fs.existsSync(path.join(tribeBinDir, 'tribe')),
+            configuredFiles: [],
+            instructions: []
+        };
+
+        // Check which configs were modified
+        for (const configFile of this.shellConfigs) {
+            const configPath = path.join(homeDir, configFile);
+            if (fs.existsSync(configPath)) {
+                const content = fs.readFileSync(configPath, 'utf8');
+                if (content.includes('tribe-env.sh')) {
+                    summary.configuredFiles.push(configFile);
+                }
+            }
+        }
+
+        // Generate specific instructions
+        if (!summary.pathWorking) {
+            summary.instructions.push(
+                `Restart your terminal or run: source ~/.tribe/tribe-env.sh`
+            );
+
+            if (summary.configuredFiles.length === 0) {
+                summary.instructions.push(
+                    `Manual setup required. Add to your shell config:\n  source ~/.tribe/tribe-env.sh`
+                );
+            }
+        }
+
+        return summary;
+    }
+
+    /**
+     * Main setup function
+     */
+    async setup() {
+        const spinner = ora('🔧 Setting up enhanced PATH configuration...').start();
+
+        try {
+            // 1. Create enhanced environment script
+            this.createEnvScript();
+            spinner.text = 'Environment script created...';
+
+            // 2. Update shell configuration
+            const configSuccess = this.updateShellConfig();
+            spinner.text = 'Shell configuration updated...';
+
+            // 3. Test setup
+            await new Promise(resolve => setTimeout(resolve, 500)); // Brief pause for file system
+            const pathWorking = this.testPathSetup();
+
+            // 4. Generate summary
+            const summary = this.generateInstallSummary();
+
+            if (pathWorking && configSuccess) {
+                spinner.succeed('PATH setup completed successfully');
+
+                console.log(chalk.green('\n✅ TRIBE CLI is ready to use!'));
+                console.log(chalk.blue(`   Shell: ${summary.shell}`));
+                console.log(chalk.blue(`   Configured: ${summary.configuredFiles.join(', ')}`));
+
+                if (summary.instructions.length > 0) {
+                    console.log(chalk.yellow('\n📝 Next steps:'));
+                    summary.instructions.forEach(instruction => {
+                        console.log(chalk.cyan(`   ${instruction}`));
+                    });
+                }
+            } else {
+                spinner.warn('PATH setup completed with warnings');
+
+                console.log(chalk.yellow('\n⚠️  Manual configuration may be needed'));
+                console.log(chalk.blue('   Try running: source ~/.tribe/tribe-env.sh'));
+                console.log(chalk.blue('   Or restart your terminal'));
+
+                if (summary.instructions.length > 0) {
+                    console.log(chalk.yellow('\n📝 Manual steps:'));
+                    summary.instructions.forEach(instruction => {
+                        console.log(chalk.cyan(`   ${instruction}`));
+                    });
+                }
+            }
+
+            // Always provide troubleshooting info
+            console.log(chalk.gray('\n🔍 Troubleshooting:'));
+            console.log(chalk.gray('   Config backups: ~/.tribe/backups/'));
+            console.log(chalk.gray('   Test command: which tribe'));
+            console.log(chalk.gray('   Manual setup: export PATH="$HOME/.tribe/bin:$PATH"'));
+
+            return { success: pathWorking && configSuccess, summary };
+
+        } catch (error) {
+            spinner.fail('PATH setup failed');
+            console.error(chalk.red(`Error: ${error.message}`));
+
+            // Provide fallback instructions
+            console.log(chalk.yellow('\n🚨 Fallback instructions:'));
+            console.log(chalk.cyan('   1. Add to your shell config (~/.zshrc or ~/.bashrc):'));
+            console.log(chalk.cyan('      export PATH="$HOME/.tribe/bin:$PATH"'));
+            console.log(chalk.cyan('   2. Restart your terminal'));
+            console.log(chalk.cyan('   3. Test with: tribe --version'));
+
+            return { success: false, error: error.message };
+        }
+    }
+}
+
+// Export for use in main installer
+module.exports = { EnhancedPathSetup };
+
+// Run if executed directly
+if (require.main === module) {
+    const setup = new EnhancedPathSetup();
+    setup.setup().then(result => {
+        process.exit(result.success ? 0 : 1);
+    });
+}

package/install-tribe.js

@@ -217,8 +217,25 @@ async function main() {
 
         spinner.succeed('Ready!');
 
-        // Show completion
-        console.log('Type ' + chalk.cyan.bold('tribe') + ' to get started');
+        // Test if tribe command works immediately
+        let commandWorks = false;
+        try {
+            execSync('which tribe', { stdio: 'ignore', timeout: 2000 });
+            commandWorks = true;
+        } catch (error) {
+            commandWorks = false;
+        }
+
+        // Show appropriate completion message
+        if (commandWorks) {
+            console.log(chalk.green('\n✅ TRIBE CLI is ready to use!'));
+            console.log('Type ' + chalk.cyan.bold('tribe') + ' to get started');
+        } else {
+            console.log(chalk.yellow('\n⚠️  TRIBE CLI installed successfully!'));
+            console.log(chalk.blue('To use the tribe command, please restart your terminal'));
+            console.log(chalk.gray('or run: ') + chalk.cyan.bold('source ~/.tribe/tribe-env.sh'));
+            console.log(chalk.gray('\nThen type: ') + chalk.cyan.bold('tribe') + chalk.gray(' to get started'));
+        }
 
     } catch (error) {
         spinner.fail('Installation failed');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@_xtribe/cli",
-  "version": "2.2.7",
+  "version": "2.2.9",
   "description": "TRIBE - Track, measure and optimize your AI coding agents to become 10x faster",
   "main": "install-tribe.js",
   "bin": {
@@ -43,6 +43,7 @@
     "install-tribe-minimal.js",
     "install-tribe-autolaunch.js",
     "setup-path.js",
+    "enhanced-path-setup.js",
     "install.sh",
     "tribe-deployment.yaml",
     "README.md",