@_xtribe/cli 1.0.0-beta.10

package/README.md

@@ -0,0 +1,123 @@
+# TRIBE CLI - Zero to Productive in One Command
+
+TRIBE is an AI-powered multi-agent development system that manages your entire development workflow. From project creation to task implementation and PR reviews, TRIBE's AI agents handle it all.
+
+## 🚀 One-Command Installation
+
+```bash
+npx @_xtribe/cli
+```
+
+That's it! This single command will:
+- ✅ Install all required tools (Docker, Kubernetes, kubectl)
+- ✅ Set up Colima container runtime (macOS)
+- ✅ Deploy the complete TRIBE cluster
+- ✅ Configure everything automatically
+- ✅ Guide you through creating your first project
+
+## 🎯 What is TRIBE?
+
+TRIBE is a complete development ecosystem where AI agents:
+- 📝 Implement features based on your descriptions
+- 🔧 Fix bugs autonomously
+- 🔀 Create pull requests
+- 👀 Handle code reviews
+- 🚀 Manage the entire development lifecycle
+
+## 💡 Quick Start
+
+After installation, just run:
+
+```bash
+tribe
+```
+
+The interactive CLI will:
+1. **First time?** Guide you through creating your first project
+2. **Returning?** Show your projects, tasks, and agent activity
+
+### Creating Tasks
+
+```bash
+tribe create-task
+# Select project, describe what you want built
+# An AI agent picks it up and implements it!
+```
+
+### Reviewing PRs
+
+```bash
+tribe review-task
+# See PRs created by agents
+# Review diffs, add comments, merge
+```
+
+## 🛠️ System Requirements
+
+- **macOS** or **Linux**
+- **4GB RAM** minimum (8GB recommended)
+- **20GB disk space**
+- **Node.js 16+**
+
+## 📚 Common Commands
+
+```bash
+tribe                    # Interactive mode
+tribe status            # Check system status
+tribe create-task       # Create a new task
+tribe review-task       # Review agent PRs
+tribe list-projects     # Show all projects
+tribe list-agents       # Show agent status
+```
+
+## 🔧 Architecture
+
+TRIBE runs a local Kubernetes cluster with:
+- **Bridge** - API gateway and orchestrator
+- **TaskMaster** - Task queue and agent coordinator
+- **Claude Agents** - AI workers powered by Claude
+- **Gitea** - Local Git server for repositories
+- **PostgreSQL** - Database for state management
+
+## 🤝 Contributing
+
+TRIBE is open source! Visit our [GitHub repository](https://github.com/0zen/0zen) to contribute.
+
+## 📖 Documentation
+
+For detailed documentation, visit the [TRIBE Flow Guide](https://github.com/0zen/0zen/blob/main/TRIBE-SYSTEM-FLOW-GUIDE.md).
+
+## 🆘 Troubleshooting
+
+### Cluster not starting?
+```bash
+# Check if Colima is running
+colima status
+
+# Start manually if needed
+colima start --kubernetes
+tribe start
+```
+
+### Port conflicts?
+```bash
+# Check what's using ports
+lsof -i :30080
+lsof -i :3456
+```
+
+### Reset everything?
+```bash
+# Stop cluster
+colima stop
+
+# Remove TRIBE namespace
+kubectl delete namespace tribe-system
+
+# Start fresh
+tribe start
+```
+
+## 📄 License
+
+MIT License - see [LICENSE](https://github.com/0zen/0zen/blob/main/LICENSE) for details. 

package/install-tribe.js

@@ -0,0 +1,671 @@
+#!/usr/bin/env node
+
+const os = require('os');
+const fs = require('fs');
+const path = require('path');
+const https = require('https');
+const { execSync, spawn } = require('child_process');
+const chalk = require('chalk');
+const ora = require('ora');
+const which = require('which');
+
+const platform = os.platform();
+const arch = os.arch();
+const homeDir = os.homedir();
+const binDir = path.join(homeDir, 'bin');
+const tribeDir = path.join(homeDir, '.tribe');
+
+// Ensure local bin directory exists
+if (!fs.existsSync(binDir)) {
+    fs.mkdirSync(binDir, { recursive: true });
+}
+
+// Ensure TRIBE config directory exists
+if (!fs.existsSync(tribeDir)) {
+    fs.mkdirSync(tribeDir, { recursive: true });
+}
+
+const log = {
+    success: (msg) => console.log(chalk.green('✓'), msg),
+    error: (msg) => console.log(chalk.red('✗'), msg),
+    warning: (msg) => console.log(chalk.yellow('⚠'), msg),
+    info: (msg) => console.log(chalk.blue('ℹ'), msg),
+    step: (msg) => console.log(chalk.cyan('→'), msg)
+};
+
+async function checkCommand(cmd) {
+    try {
+        await which(cmd);
+        return true;
+    } catch {
+        return false;
+    }
+}
+
+async function findCommand(cmd) {
+    // Try to find command in various locations
+    const possiblePaths = [
+        path.join(binDir, cmd),                    // Our install location
+        path.join('/opt/homebrew/bin', cmd),       // Homebrew on M1 Macs
+        path.join('/usr/local/bin', cmd),          // Homebrew on Intel Macs
+        cmd                                         // In PATH
+    ];
+    
+    // First try 'which' command
+    try {
+        const cmdPath = await which(cmd);
+        return cmdPath;
+    } catch {
+        // If not in PATH, check known locations
+        for (const cmdPath of possiblePaths) {
+            try {
+                await fs.promises.access(cmdPath, fs.constants.X_OK);
+                return cmdPath;
+            } catch {
+                // Continue searching
+            }
+        }
+    }
+    
+    return null;
+}
+
+async function downloadFile(url, dest) {
+    return new Promise((resolve, reject) => {
+        const file = fs.createWriteStream(dest);
+        https.get(url, (response) => {
+            if (response.statusCode === 302 || response.statusCode === 301) {
+                // Handle redirects
+                return downloadFile(response.headers.location, dest).then(resolve, reject);
+            }
+            if (response.statusCode !== 200) {
+                reject(new Error(`HTTP ${response.statusCode}: ${response.statusMessage}`));
+                return;
+            }
+            response.pipe(file);
+            file.on('finish', () => {
+                file.close();
+                resolve();
+            });
+        }).on('error', reject);
+    });
+}
+
+// Docker installation removed - Colima provides Docker runtime
+
+async function installColima() {
+    if (platform !== 'darwin') {
+        log.info('Colima is only needed on macOS - skipping');
+        return true;
+    }
+
+    const existingColima = await findCommand('colima');
+    if (existingColima) {
+        log.success(`Colima already installed at: ${existingColima}`);
+        return true;
+    }
+
+    const spinner = ora('Installing Colima...').start();
+    
+    try {
+        // Strategy 1: Try Homebrew if available (better signing)
+        try {
+            execSync('brew --version', { stdio: 'ignore' });
+            spinner.text = 'Installing Colima via Homebrew...';
+            execSync('brew install colima', { stdio: 'ignore' });
+            spinner.succeed('Colima installed via Homebrew');
+            return true;
+        } catch (brewError) {
+            // Homebrew not available, continue with direct download
+            spinner.text = 'Installing Colima (direct download)...';
+        }
+        
+        // Strategy 2: Direct download with Gatekeeper approval
+        const colimaUrl = `https://github.com/abiosoft/colima/releases/latest/download/colima-${platform}-${arch}`;
+        const colimaDest = path.join(binDir, 'colima');
+        
+        await downloadFile(colimaUrl, colimaDest);
+        fs.chmodSync(colimaDest, '755');
+        
+        // Try to remove quarantine attribute (macOS Sequoia workaround)
+        try {
+            execSync(`xattr -d com.apple.quarantine ${colimaDest}`, { stdio: 'ignore' });
+            log.info('Removed quarantine attribute from Colima');
+        } catch (error) {
+            // Quarantine attribute may not exist, which is fine
+            log.info('Colima installed (quarantine handling not needed)');
+        }
+        
+        spinner.succeed('Colima installed');
+        return true;
+    } catch (error) {
+        spinner.fail(`Colima installation failed: ${error.message}`);
+        return false;
+    }
+}
+
+// Lima installation removed - Colima handles virtualization
+
+// KIND installation removed - using Colima's built-in Kubernetes
+
+async function installKubectl() {
+    if (await checkCommand('kubectl')) {
+        log.success('kubectl already installed');
+        return true;
+    }
+
+    const spinner = ora('Installing kubectl...').start();
+    
+    try {
+        // Get latest stable version
+        const versionResponse = await fetch('https://dl.k8s.io/release/stable.txt');
+        const version = await versionResponse.text();
+        const kubectlUrl = `https://dl.k8s.io/release/${version.trim()}/bin/${platform}/${arch}/kubectl`;
+        const kubectlDest = path.join(binDir, 'kubectl');
+        
+        await downloadFile(kubectlUrl, kubectlDest);
+        fs.chmodSync(kubectlDest, '755');
+        
+        spinner.succeed('kubectl installed');
+        return true;
+    } catch (error) {
+        spinner.fail(`kubectl installation failed: ${error.message}`);
+        return false;
+    }
+}
+
+async function installTribeCli() {
+    const spinner = ora('Installing TRIBE CLI...').start();
+    
+    try {
+        const tribeDest = path.join(binDir, 'tribe');
+        
+        // First check if we have a bundled binary
+        const bundledBinary = path.join(__dirname, 'tribe');
+        if (fs.existsSync(bundledBinary)) {
+            fs.copyFileSync(bundledBinary, tribeDest);
+            fs.chmodSync(tribeDest, '755');
+            spinner.succeed('TRIBE CLI installed from bundled binary');
+            return true;
+        }
+        
+        // Check if we have local source
+        const sourceFile = path.join(__dirname, 'cluster-cli.go');
+        if (fs.existsSync(sourceFile)) {
+            // Build from source
+            try {
+                execSync('go version', { stdio: 'ignore' });
+                execSync(`cd ${__dirname} && go build -o tribe cluster-cli.go client.go`);
+                fs.copyFileSync(path.join(__dirname, 'tribe'), tribeDest);
+                fs.chmodSync(tribeDest, '755');
+                spinner.succeed('TRIBE CLI built from source');
+                return true;
+            } catch {
+                spinner.warn('Go not available, trying pre-built binary...');
+            }
+        }
+        
+        // Try pre-built binary from GitHub
+        const tribeUrl = `https://github.com/0zen/0zen/releases/latest/download/tribe-${platform}-${arch}`;
+        
+        try {
+            await downloadFile(tribeUrl, tribeDest);
+            fs.chmodSync(tribeDest, '755');
+            spinner.succeed('TRIBE CLI installed');
+            return true;
+        } catch {
+            // Fallback: look for any existing tribe binary
+            const possiblePaths = [
+                path.join(__dirname, '..', 'tribe-cli'),
+                path.join(__dirname, '..', 'tribe'),
+                './tribe-cli',
+                './tribe'
+            ];
+            
+            for (const possiblePath of possiblePaths) {
+                if (fs.existsSync(possiblePath)) {
+                    fs.copyFileSync(possiblePath, tribeDest);
+                    fs.chmodSync(tribeDest, '755');
+                    spinner.succeed('TRIBE CLI installed from local binary');
+                    return true;
+                }
+            }
+            
+            throw new Error('No TRIBE CLI binary available');
+        }
+    } catch (error) {
+        spinner.fail(`TRIBE CLI installation failed: ${error.message}`);
+        return false;
+    }
+}
+
+async function startContainerRuntime() {
+    if (platform !== 'darwin') {
+        return true; // Linux uses Docker daemon directly
+    }
+
+    // Check if container runtime is already working
+    try {
+        execSync('docker info', { stdio: 'ignore' });
+        log.success('Container runtime is already working');
+        return true;
+    } catch {
+        // Try to start Colima with different approaches
+        if (await checkCommand('colima')) {
+            const spinner = ora('Starting Colima container runtime...').start();
+            
+            try {
+                // Strategy 1: Quick start with minimal resources and Kubernetes
+                spinner.text = 'Starting Colima with Kubernetes...';
+                const colimaPath = await findCommand('colima') || path.join(binDir, 'colima');
+                execSync(`${colimaPath} start --cpu 2 --memory 4 --disk 10 --kubernetes --vm-type=vz`, { 
+                    stdio: 'pipe',
+                    timeout: 60000 // 60 second timeout for K8s
+                });
+                
+                // Test if it worked
+                execSync('docker info', { stdio: 'ignore' });
+                spinner.succeed('Colima started successfully');
+                return true;
+                
+            } catch (error) {
+                // Strategy 2: Start in background with Kubernetes
+                try {
+                    spinner.text = 'Starting Colima with Kubernetes in background...';
+                    const colimaPath = await findCommand('colima') || path.join(binDir, 'colima');
+                    const child = spawn(colimaPath, ['start', '--cpu', '2', '--memory', '4', '--disk', '10', '--kubernetes'], {
+                        detached: true,
+                        stdio: 'ignore',
+                        env: { ...process.env, PATH: `${binDir}:${process.env.PATH}` }
+                    });
+                    child.unref(); // Don't wait for completion
+                    
+                    spinner.succeed('Colima startup initiated (background)');
+                    log.info('Colima is starting in the background');
+                    log.info('Run "colima status" to check progress');
+                    log.info('Run "docker info" to test when ready');
+                    return true;
+                    
+                } catch (bgError) {
+                    spinner.fail('Failed to start Colima');
+                    log.warning('Container runtime startup failed (likely due to macOS system restrictions)');
+                    log.info('Options to fix:');
+                    log.info('');
+                    log.info('Option 1 - Manual Colima start:');
+                    log.info('  colima start --cpu 2 --memory 4  # Start container runtime');
+                    log.info('  # This downloads a 344MB disk image (may take time)');
+                    log.info('');
+                    log.info('Option 2 - Use Docker Desktop (easier):');
+                    log.info('  Download from: https://docs.docker.com/desktop/install/mac-install/');
+                    log.info('  # Docker Desktop handles all container runtime setup');
+                    log.info('');
+                    log.info('Option 3 - Use Homebrew (recommended):');
+                    log.info('  brew install colima docker');
+                    log.info('  colima start');
+                    log.info('');
+                    return false;
+                }
+            }
+        }
+    }
+    return false;
+}
+
+async function updatePath() {
+    const shell = process.env.SHELL || '/bin/zsh';
+    const rcFile = shell.includes('zsh') ? '.zshrc' : '.bashrc';
+    const rcPath = path.join(homeDir, rcFile);
+    
+    const pathExport = `export PATH="${binDir}:$PATH"`;
+    
+    try {
+        const rcContent = fs.existsSync(rcPath) ? fs.readFileSync(rcPath, 'utf8') : '';
+        if (!rcContent.includes(pathExport)) {
+            fs.appendFileSync(rcPath, `\n# Added by TRIBE CLI installer\n${pathExport}\n`);
+            log.success(`Updated ${rcFile} with PATH`);
+        }
+    } catch (error) {
+        log.warning(`Failed to update ${rcFile}: ${error.message}`);
+    }
+    
+    // Update current process PATH
+    process.env.PATH = `${binDir}:${process.env.PATH}`;
+}
+
+async function verifyInstallation() {
+    const spinner = ora('Verifying installation...').start();
+    
+    const tools = ['docker', 'kubectl', 'tribe', 'colima'];
+    const results = {};
+    
+    for (const tool of tools) {
+        results[tool] = await checkCommand(tool);
+    }
+    
+    // Special check for container runtime
+    let containerWorking = false;
+    try {
+        execSync('docker info', { stdio: 'ignore' });
+        containerWorking = true;
+    } catch (error) {
+        containerWorking = false;
+    }
+    
+    spinner.stop();
+    
+    console.log('\n' + chalk.bold('Installation Summary:'));
+    tools.forEach(tool => {
+        const status = results[tool] ? chalk.green('✓') : chalk.red('✗');
+        console.log(`${status} ${tool}`);
+    });
+    
+    const extraStatus = containerWorking ? chalk.green('✓') : chalk.yellow('⚠');
+    console.log(`${extraStatus} Container runtime`);
+    
+    if (platform === 'darwin') {
+        const colimaInstalled = await checkCommand('colima');
+        const limaInstalled = await checkCommand('limactl');
+        console.log(`${colimaInstalled ? chalk.green('✓') : chalk.yellow('⚠')} Colima`);
+        console.log(`${limaInstalled ? chalk.green('✓') : chalk.yellow('⚠')} Lima`);
+    }
+    
+    return Object.values(results).every(r => r) && containerWorking;
+}
+
+async function checkClusterExists() {
+    try {
+        // Check if TRIBE namespace exists in any context
+        execSync('kubectl get namespace tribe-system', { stdio: 'ignore' });
+        return true;
+    } catch {
+        return false;
+    }
+}
+
+async function checkColimaRunning() {
+    try {
+        const colimaPath = await findCommand('colima') || path.join(binDir, 'colima');
+        execSync(`${colimaPath} status`, { stdio: 'ignore' });
+        return true;
+    } catch {
+        return false;
+    }
+}
+
+async function startColimaWithKubernetes() {
+    const spinner = ora('Starting Colima with Kubernetes...').start();
+    
+    try {
+        // Check if already running
+        if (await checkColimaRunning()) {
+            spinner.succeed('Colima is already running');
+            return true;
+        }
+        
+        // Start Colima with Kubernetes enabled
+        spinner.text = 'Starting Colima (this may take a few minutes on first run)...';
+        const colimaPath = await findCommand('colima') || path.join(binDir, 'colima');
+        execSync(`${colimaPath} start --kubernetes --cpu 4 --memory 8 --disk 20`, {
+            stdio: 'pipe',
+            env: { ...process.env, PATH: `${binDir}:${process.env.PATH}` }
+        });
+        
+        // Verify it's working
+        const kubectlPath = await findCommand('kubectl') || 'kubectl';
+        execSync(`${kubectlPath} version --client`, { stdio: 'ignore' });
+        spinner.succeed('Colima started with Kubernetes');
+        return true;
+    } catch (error) {
+        spinner.fail('Failed to start Colima with Kubernetes');
+        log.error(error.message);
+        return false;
+    }
+}
+
+async function deployTribeCluster() {
+    const spinner = ora('Deploying TRIBE cluster...').start();
+    
+    try {
+        // Create a marker file to indicate first-run deployment
+        const deploymentMarker = path.join(tribeDir, '.cluster-deployed');
+        
+        // Check if we've already deployed
+        if (fs.existsSync(deploymentMarker)) {
+            // Check if cluster actually exists
+            if (await checkClusterExists()) {
+                spinner.succeed('TRIBE cluster already deployed');
+                return true;
+            }
+            // Marker exists but cluster doesn't - remove marker and redeploy
+            fs.unlinkSync(deploymentMarker);
+        }
+        
+        // Copy deployment YAML to .tribe directory
+        const sourceYaml = path.join(__dirname, 'tribe-deployment.yaml');
+        const destYaml = path.join(tribeDir, 'tribe-deployment.yaml');
+        
+        if (fs.existsSync(sourceYaml)) {
+            fs.copyFileSync(sourceYaml, destYaml);
+            log.info('Copied deployment configuration');
+        }
+        
+        // Run tribe start command with deployment YAML path
+        spinner.text = 'Running TRIBE cluster deployment...';
+        const tribePath = path.join(binDir, 'tribe');
+        
+        // Set environment variable for the deployment YAML location
+        const env = {
+            ...process.env,
+            PATH: `${binDir}:${process.env.PATH}`,
+            TRIBE_DEPLOYMENT_YAML: destYaml
+        };
+        
+        // Execute tribe start without validation (services need time to start)
+        execSync(`${tribePath} start --validate=false`, {
+            stdio: 'pipe',
+            env: env
+        });
+        
+        // Create marker file
+        fs.writeFileSync(deploymentMarker, new Date().toISOString());
+        
+        spinner.succeed('TRIBE cluster deployed successfully');
+        log.info('Services are starting up. Check status with: tribe status');
+        return true;
+    } catch (error) {
+        spinner.fail('Failed to deploy TRIBE cluster');
+        log.error(error.message);
+        log.info('You can manually deploy later with: tribe start');
+        return false;
+    }
+}
+
+async function promptForClusterSetup() {
+    // Simple prompt without external dependencies
+    return new Promise((resolve) => {
+        console.log('\n' + chalk.bold('🚀 TRIBE Cluster Setup'));
+        console.log('\nWould you like to set up the TRIBE cluster now?');
+        console.log('This will:');
+        console.log('  • Start Colima with Kubernetes');
+        console.log('  • Deploy all TRIBE services');
+        console.log('  • Set up port forwarding');
+        console.log('\n' + chalk.yellow('Note: This requires ~2GB disk space and may take a few minutes'));
+        
+        process.stdout.write('\nSet up now? [Y/n]: ');
+        
+        process.stdin.resume();
+        process.stdin.setEncoding('utf8');
+        process.stdin.once('data', (data) => {
+            process.stdin.pause();
+            const answer = data.toString().trim().toLowerCase();
+            resolve(answer === '' || answer === 'y' || answer === 'yes');
+        });
+    });
+}
+
+async function main() {
+    console.log(chalk.bold.blue('\n🚀 TRIBE CLI Complete Installer\n'));
+    
+    log.info(`Detected: ${platform} (${arch})`);
+    log.info(`Installing to: ${binDir}`);
+    
+    // Update PATH first
+    await updatePath();
+    
+    const tasks = [
+        { name: 'Colima', fn: installColima },
+        { name: 'kubectl', fn: installKubectl },
+        { name: 'TRIBE CLI', fn: installTribeCli }
+    ];
+    
+    let allSuccess = true;
+    
+    for (const task of tasks) {
+        log.step(`Installing ${task.name}...`);
+        const success = await task.fn();
+        if (!success) allSuccess = false;
+    }
+    
+    // Try to start container runtime
+    await startContainerRuntime();
+    
+    // Verify everything
+    const verified = await verifyInstallation();
+    
+    if (verified) {
+        // Check if cluster already exists
+        const clusterExists = await checkClusterExists();
+        
+        if (!clusterExists) {
+            // Prompt for cluster setup
+            const shouldSetup = await promptForClusterSetup();
+            
+            if (shouldSetup) {
+                console.log('');
+                
+                // Start Colima with Kubernetes if on macOS
+                if (platform === 'darwin') {
+                    const colimaStarted = await startColimaWithKubernetes();
+                    if (!colimaStarted) {
+                        log.error('Failed to start Colima. Please run manually:');
+                        console.log('  colima start --kubernetes');
+                        console.log('  tribe start');
+                        process.exit(1);
+                    }
+                }
+                
+                // Deploy TRIBE cluster
+                const deployed = await deployTribeCluster();
+                
+                if (deployed) {
+                    console.log('\n' + chalk.bold.green('✨ TRIBE is ready!'));
+                    console.log('');
+                    
+                    // Check if PATH needs updating
+                    const needsPathUpdate = !process.env.PATH.includes(binDir);
+                    if (needsPathUpdate) {
+                        log.warning('PATH update required for current shell:');
+                        console.log(chalk.yellow(`  source ~/.${process.env.SHELL?.includes('zsh') ? 'zshrc' : 'bashrc'}`));
+                        console.log('  ' + chalk.gray('or restart your terminal'));
+                        console.log('');
+                    }
+                    
+                    log.info('Quick start:');
+                    console.log('  tribe              # Launch interactive CLI');
+                    console.log('  tribe status       # Check cluster status');
+                    console.log('  tribe create-task  # Create a new task');
+                    console.log('');
+                    log.info('First time? The CLI will guide you through creating your first project!');
+                } else {
+                    log.warning('Cluster deployment failed, but you can try manually:');
+                    console.log('  tribe start');
+                }
+            } else {
+                console.log('\n' + chalk.bold('Setup Complete!'));
+                log.info('You can set up the cluster later with:');
+                console.log('  tribe start');
+            }
+        } else {
+            console.log('\n' + chalk.bold.green('✨ TRIBE is ready!'));
+            log.success('Cluster is already running');
+            console.log('');
+            log.info('Commands:');
+            console.log('  tribe              # Launch interactive CLI');
+            console.log('  tribe status       # Check status');
+            console.log('  tribe create-task  # Create a new task');
+        }
+    } else {
+        console.log('\n' + chalk.bold('Next Steps:'));
+        log.warning('Some components need attention:');
+        console.log('');
+        // Check container runtime for guidance
+        let runtimeWorking = false;
+        try {
+            execSync('docker info', { stdio: 'ignore' });
+            runtimeWorking = true;
+        } catch {
+            runtimeWorking = false;
+        }
+        
+        if (!runtimeWorking) {
+            log.info('Start container runtime:');
+            console.log('  colima start             # macOS');
+            console.log('  sudo systemctl start docker  # Linux');
+        }
+        console.log('');
+        log.info('Restart your shell or run: source ~/.zshrc');
+        log.info('Then run: tribe start');
+    }
+}
+
+// Handle fetch polyfill for older Node versions
+if (!global.fetch) {
+    global.fetch = require('node-fetch');
+}
+
+if (require.main === module) {
+    const args = process.argv.slice(2);
+    
+    if (args.includes('--help') || args.includes('-h')) {
+        console.log(chalk.bold.blue('TRIBE CLI Installer\n'));
+        console.log('Usage: npx tribe-cli-local [options]\n');
+        console.log('Options:');
+        console.log('  --help, -h     Show this help message');
+        console.log('  --verify       Only verify existing installation');
+        console.log('  --dry-run      Show what would be installed');
+                console.log('\nThis installer sets up the complete TRIBE development environment:');
+        console.log('• Colima (Container runtime with Kubernetes)');
+        console.log('• kubectl (Kubernetes CLI)');
+        console.log('• TRIBE CLI (Multi-agent orchestration)');
+        console.log('\nAfter installation:');
+        console.log('  tribe start    # Start TRIBE cluster');
+        console.log('  tribe status   # Check cluster status');
+        process.exit(0);
+    }
+    
+    if (args.includes('--verify')) {
+        console.log(chalk.bold.blue('🔍 Verifying TRIBE Installation\n'));
+        verifyInstallation().then(success => {
+            process.exit(success ? 0 : 1);
+        });
+        return;
+    }
+    
+    if (args.includes('--dry-run')) {
+        console.log(chalk.bold.blue('🔍 TRIBE CLI Installation Preview\n'));
+        log.info(`Platform: ${platform} (${arch})`);
+        log.info(`Install directory: ${binDir}`);
+        console.log('\nWould install:');
+        console.log('• Colima - Container runtime with Kubernetes (macOS only)');
+        console.log('• kubectl - Kubernetes CLI');
+        console.log('• TRIBE CLI - Multi-agent system');
+        process.exit(0);
+    }
+    
+    main().catch(error => {
+        console.error(chalk.red('Installation failed:'), error.message);
+        process.exit(1);
+    });
+}
+
+module.exports = { main };

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@_xtribe/cli",
+  "version": "1.0.0-beta.10",
+  "description": "TRIBE multi-agent development system - Zero to productive with one command",
+  "main": "install-tribe.js",
+  "bin": {
+    "tribe": "install-tribe.js"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "tribe",
+    "cli",
+    "kubernetes",
+    "docker",
+    "colima",
+    "multi-agent",
+    "ai",
+    "development",
+    "autonomous",
+    "agents"
+  ],
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "os": [
+    "darwin",
+    "linux"
+  ],
+  "preferGlobal": true,
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "files": [
+    "install-tribe.js",
+    "lima-guestagent.Linux-aarch64.gz",
+    "tribe-deployment.yaml",
+    "tribe",
+    "README.md",
+    "package.json"
+  ],
+  "dependencies": {
+    "chalk": "^4.1.2",
+    "ora": "^5.4.1",
+    "node-fetch": "^2.6.7",
+    "tar": "^6.1.15",
+    "which": "^2.0.2"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/0zen/0zen.git"
+  },
+  "author": "0zen",
+  "license": "MIT",
+  "homepage": "https://github.com/0zen/0zen",
+  "bugs": {
+    "url": "https://github.com/0zen/0zen/issues"
+  }
+}

package/tribe-deployment.yaml

@@ -0,0 +1,448 @@
+---
+# TRIBE Complete Deployment - Bundled with NPM Package
+# This file is automatically deployed by 'npx @_xtribe/cli'
+---
+apiVersion: v1
+kind: Namespace
+metadata:
+  name: tribe-system
+---
+# ServiceAccount for Bridge
+apiVersion: v1
+kind: ServiceAccount
+metadata:
+  name: bridge
+  namespace: tribe-system
+---
+# Role for Bridge
+apiVersion: rbac.authorization.k8s.io/v1
+kind: Role
+metadata:
+  name: bridge-role
+  namespace: tribe-system
+rules:
+  - apiGroups: [""]
+    resources: ["pods", "services", "pods/exec", "pods/log", "configmaps", "secrets", "namespaces"]
+    verbs: ["get", "list", "watch", "create", "update", "patch", "delete"]
+  - apiGroups: ["apps"]
+    resources: ["deployments", "replicasets"]
+    verbs: ["get", "list", "watch", "create", "update", "patch", "delete"]
+  - apiGroups: ["batch"]
+    resources: ["jobs"]
+    verbs: ["get", "list", "watch", "create", "update", "patch", "delete"]
+---
+# RoleBinding for Bridge
+apiVersion: rbac.authorization.k8s.io/v1
+kind: RoleBinding
+metadata:
+  name: bridge-rolebinding
+  namespace: tribe-system
+subjects:
+  - kind: ServiceAccount
+    name: bridge
+    namespace: tribe-system
+roleRef:
+  kind: Role
+  name: bridge-role
+  apiGroup: rbac.authorization.k8s.io
+---
+# PostgreSQL
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: postgres
+  namespace: tribe-system
+spec:
+  replicas: 1
+  selector:
+    matchLabels:
+      app: postgres
+  template:
+    metadata:
+      labels:
+        app: postgres
+    spec:
+      containers:
+      - name: postgres
+        image: postgres:15
+        env:
+        - name: POSTGRES_DB
+          value: gitea
+        - name: POSTGRES_USER
+          value: gitea
+        - name: POSTGRES_PASSWORD
+          value: gitea
+        ports:
+        - containerPort: 5432
+        readinessProbe:
+          exec:
+            command:
+            - pg_isready
+            - -U
+            - gitea
+          initialDelaySeconds: 5
+          periodSeconds: 5
+---
+apiVersion: v1
+kind: Service
+metadata:
+  name: postgres
+  namespace: tribe-system
+spec:
+  selector:
+    app: postgres
+  ports:
+  - port: 5432
+---
+# Gitea
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: gitea
+  namespace: tribe-system
+spec:
+  replicas: 1
+  selector:
+    matchLabels:
+      app: gitea
+  template:
+    metadata:
+      labels:
+        app: gitea
+    spec:
+      initContainers:
+      - name: wait-for-db
+        image: busybox:1.35
+        command: ['sh', '-c', 'until nc -z postgres 5432; do echo waiting for db; sleep 2; done']
+      - name: init-gitea
+        image: gitea/gitea:1.20.5
+        command: ['/bin/bash', '-c']
+        args:
+        - |
+          # Create app.ini
+          mkdir -p /data/gitea/conf
+          cat > /data/gitea/conf/app.ini << 'EOF'
+          APP_NAME = Gitea
+          RUN_MODE = prod
+          
+          [database]
+          DB_TYPE = postgres
+          HOST = postgres:5432
+          NAME = gitea
+          USER = gitea
+          PASSWD = gitea
+          
+          [server]
+          DOMAIN = gitea
+          ROOT_URL = http://gitea:3000/
+          HTTP_PORT = 3000
+          
+          [service]
+          DISABLE_REGISTRATION = true
+          
+          [security]
+          INSTALL_LOCK = true
+          SECRET_KEY = changeme
+          EOF
+          
+          # Run migrations
+          gitea migrate
+          
+          # Create admin user
+          gitea admin user create --admin --username gitea_admin --password admin123 --email admin@example.com || true
+        env:
+        - name: GITEA_WORK_DIR
+          value: /data
+        - name: GITEA_CUSTOM
+          value: /data/gitea
+        volumeMounts:
+        - name: gitea-data
+          mountPath: /data
+      containers:
+      - name: gitea
+        image: gitea/gitea:1.20.5
+        ports:
+        - containerPort: 3000
+        env:
+        - name: GITEA_WORK_DIR
+          value: /data
+        - name: GITEA_CUSTOM
+          value: /data/gitea
+        volumeMounts:
+        - name: gitea-data
+          mountPath: /data
+        readinessProbe:
+          httpGet:
+            path: /
+            port: 3000
+          initialDelaySeconds: 30
+          periodSeconds: 10
+      volumes:
+      - name: gitea-data
+        emptyDir: {}
+---
+apiVersion: v1
+kind: Service
+metadata:
+  name: gitea
+  namespace: tribe-system
+spec:
+  selector:
+    app: gitea
+  ports:
+  - port: 3000
+---
+# TaskMaster
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: taskmaster
+  namespace: tribe-system
+spec:
+  replicas: 1
+  selector:
+    matchLabels:
+      app: taskmaster
+  template:
+    metadata:
+      labels:
+        app: taskmaster
+    spec:
+      initContainers:
+      - name: wait-for-db
+        image: busybox:1.35
+        command: ['sh', '-c', 'until nc -z postgres 5432; do echo waiting for db; sleep 2; done']
+      containers:
+      - name: taskmaster
+        image: taskmaster:latest
+        imagePullPolicy: IfNotPresent
+        ports:
+        - containerPort: 5000
+        env:
+        - name: FLASK_ENV
+          value: development
+        - name: DATABASE_URL
+          value: postgresql://gitea:gitea@postgres:5432/gitea
+        - name: GITEA_URL
+          value: http://gitea:3000
+        - name: GITEA_TOKEN
+          value: will-be-set-by-init-job
+        readinessProbe:
+          httpGet:
+            path: /
+            port: 5000
+          initialDelaySeconds: 10
+          periodSeconds: 5
+---
+apiVersion: v1
+kind: Service
+metadata:
+  name: taskmaster
+  namespace: tribe-system
+spec:
+  selector:
+    app: taskmaster
+  ports:
+  - port: 5000
+---
+# Bridge
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: bridge
+  namespace: tribe-system
+spec:
+  replicas: 1
+  selector:
+    matchLabels:
+      app: bridge
+  template:
+    metadata:
+      labels:
+        app: bridge
+    spec:
+      serviceAccountName: bridge
+      initContainers:
+      - name: wait-for-services
+        image: busybox:1.35
+        command: ['sh', '-c']
+        args:
+        - |
+          echo "Waiting for services..."
+          until nc -z taskmaster 5000; do echo waiting for taskmaster; sleep 2; done
+          until nc -z gitea 3000; do echo waiting for gitea; sleep 2; done
+          echo "All services ready!"
+      containers:
+      - name: bridge
+        image: bridge:latest
+        imagePullPolicy: IfNotPresent
+        ports:
+        - containerPort: 8080
+        - containerPort: 3456
+        env:
+        - name: TASKMASTER_URL
+          value: http://taskmaster:5000
+        - name: GITEA_URL
+          value: http://gitea:3000
+        - name: GITEA_ADMIN_USER
+          value: gitea_admin
+        - name: GITEA_ADMIN_PASSWORD
+          value: admin123
+        - name: NAMESPACE
+          value: tribe-system
+        readinessProbe:
+          httpGet:
+            path: /health
+            port: 8080
+          initialDelaySeconds: 10
+          periodSeconds: 5
+---
+apiVersion: v1
+kind: Service
+metadata:
+  name: bridge
+  namespace: tribe-system
+spec:
+  selector:
+    app: bridge
+  ports:
+  - name: http
+    port: 8080
+  - name: websocket
+    port: 3456
+---
+# Claude Worker Deployment (starts with 0 replicas)
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: claude-worker-deployment
+  namespace: tribe-system
+spec:
+  replicas: 0
+  selector:
+    matchLabels:
+      app: claude-worker
+  template:
+    metadata:
+      labels:
+        app: claude-worker
+    spec:
+      containers:
+      - name: claude-agent
+        image: claude-agent:latest
+        imagePullPolicy: IfNotPresent
+        env:
+        - name: ROLE
+          value: worker
+        - name: TASKMASTER_URL
+          value: http://taskmaster:5000
+        - name: GITEA_URL
+          value: http://gitea:3000
+        - name: NAMESPACE
+          value: tribe-system
+        - name: ANTHROPIC_API_KEY
+          valueFrom:
+            secretKeyRef:
+              name: claude-api-key
+              key: api-key
+              optional: true
+        volumeMounts:
+        - name: workspace
+          mountPath: /workspace
+        - name: config
+          mountPath: /app/minimal-config
+        readinessProbe:
+          exec:
+            command:
+            - /bin/sh
+            - -c
+            - test -f /tmp/worker-ready
+          initialDelaySeconds: 30
+          periodSeconds: 10
+      volumes:
+      - name: workspace
+        emptyDir: {}
+      - name: config
+        configMap:
+          name: claude-config
+          optional: true
+---
+# NodePort service for easy access
+apiVersion: v1
+kind: Service
+metadata:
+  name: bridge-nodeport
+  namespace: tribe-system
+spec:
+  type: NodePort
+  selector:
+    app: bridge
+  ports:
+  - name: http
+    port: 8080
+    nodePort: 30080
+  - name: websocket
+    port: 3456
+    nodePort: 30456
+---
+# ConfigMap for Claude agent configuration
+apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: claude-config
+  namespace: tribe-system
+data:
+  config.yaml: |
+    mcp_servers:
+      filesystem:
+        command: npx
+        args: ["-y", "@modelcontextprotocol/server-filesystem", "/workspace"]
+      git:
+        command: npx
+        args: ["-y", "@modelcontextprotocol/server-git"]
+        env:
+          PATH: /usr/local/bin:/usr/bin:/bin
+---
+# Initialization Job
+apiVersion: batch/v1
+kind: Job
+metadata:
+  name: tribe-init
+  namespace: tribe-system
+spec:
+  template:
+    spec:
+      restartPolicy: OnFailure
+      containers:
+      - name: init
+        image: curlimages/curl:8.4.0
+        command: ['/bin/sh', '-c']
+        args:
+        - |
+          echo "Waiting for Gitea to be ready..."
+          until curl -s http://gitea:3000 > /dev/null; do
+            echo "Waiting for Gitea..."
+            sleep 5
+          done
+          
+          echo "Creating Gitea access token..."
+          TOKEN=$(curl -s -X POST http://gitea:3000/api/v1/users/gitea_admin/tokens \
+            -u gitea_admin:admin123 \
+            -H "Content-Type: application/json" \
+            -d '{"name":"taskmaster-'$(date +%s)'","scopes":["write:repository","write:user","write:issue","write:organization","read:repository"]}' \
+            | grep -o '"sha1":"[^"]*' | cut -d'"' -f4)
+          
+          if [ -z "$TOKEN" ]; then
+            echo "Failed to create token!"
+            exit 1
+          fi
+          
+          echo "Token created successfully"
+          
+          # Update TaskMaster with the token
+          echo "Updating TaskMaster configuration..."
+          curl -X POST http://taskmaster:5000/api/config \
+            -H "Content-Type: application/json" \
+            -d "{\"gitea_token\":\"$TOKEN\"}"
+          
+          echo "Initialization complete!"