@_xtribe/cli 2.0.0 → 2.0.3

package/README.md

@@ -0,0 +1,207 @@
+# TRIBE: Multi-Agent AI Development System
+
+> **Transform natural language into production-ready code with a team of autonomous AI agents working in parallel**
+
+[![npm version](https://img.shields.io/npm/v/@_xtribe/cli.svg)](https://www.npmjs.com/package/@_xtribe/cli)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## 🚀 Get Started in 30 Seconds
+
+```bash
+npx @_xtribe/cli@latest
+```
+
+That's it! This single command sets up your entire AI development environment.
+
+## 💡 Why TRIBE?
+
+**The Problem:** Writing code takes time. Even with AI assistants, you're still copy-pasting, context-switching, and managing everything manually.
+
+**The Solution:** TRIBE deploys a team of AI agents that work like real developers. They understand your requirements, write code, create pull requests, and even handle code reviews—all running securely on your local machine.
+
+## 🎯 What Can TRIBE Do?
+
+### Real Examples, Real Results
+
+```bash
+# Create a complete REST API
+tribe submit-prompt "Build a user management API with JWT auth, password reset, and email verification"
+
+# Add features to existing code
+tribe submit-prompt "Add rate limiting and request logging to all API endpoints"
+
+# Fix bugs with context
+tribe submit-prompt "Debug why user sessions expire after 5 minutes instead of 24 hours"
+
+# Refactor legacy code
+tribe submit-prompt "Refactor the payment processing module to use async/await instead of callbacks"
+```
+
+**TRIBE agents will:**
+- ✅ Break down your request into logical tasks
+- ✅ Assign specialized agents to each task
+- ✅ Write code in parallel across multiple feature branches
+- ✅ Create pull requests with detailed descriptions
+- ✅ Implement features with best practices
+
+## 🏗️ How It Works
+
+1. **Natural Language Input** → You describe what you want in plain English
+2. **Intelligent Task Breakdown** → TRIBE analyzes and creates an execution plan
+3. **Parallel Agent Execution** → Multiple AI agents work simultaneously
+4. **Code Implementation** → Agents write clean, tested code
+5. **Pull Request Ready** → Review and merge when you're satisfied
+
+## 🛠️ Quick Start Guide
+
+### Prerequisites
+- **Claude Code CLI**: Install with `npm install -g @anthropic-ai/claude-code` and authenticate
+- **Docker** or **Colima**: For running the local Kubernetes cluster
+- **Node.js 16+**: Required for the CLI
+
+### Installation
+
+```bash
+# 1. Install TRIBE CLI
+npx @_xtribe/cli@latest
+
+# 2. Install and authenticate Claude Code CLI (if not already done)
+npm install -g @anthropic-ai/claude-code
+claude auth login
+
+# 3. Start TRIBE
+tribe start
+```
+
+### Your First Project
+
+```bash
+# Interactive mode (recommended for beginners)
+tribe
+
+# Or use direct commands
+tribe submit-prompt "Create a TODO app with React, TypeScript, and local storage"
+```
+
+Watch as your agents:
+- Create a new repository
+- Set up the project structure
+- Implement all features
+- Write tests
+- Create documentation
+
+### Monitor Progress
+
+```bash
+# See what your agents are doing (multiple ways)
+tribe tasks                    # Object-oriented syntax
+tribe list-tasks              # Traditional syntax
+
+# Check specific task details
+tribe tasks task_abc123       # Object-oriented syntax
+tribe show-task task_abc123   # Traditional syntax
+
+# View worker activity
+tribe workers                 # Object-oriented syntax
+tribe worker-status          # Traditional syntax
+```
+
+### Export and Review
+
+```bash
+# Export all branches locally
+tribe export-branches
+
+# Review the code
+git diff main...tribe/feature-todo-app
+
+# Merge via the Gitea UI
+open http://localhost:3000
+```
+
+## 🎨 Key Features
+
+### 🤖 Autonomous Multi-Agent System
+- **Specialized Agents**: Different agents for frontend, backend, testing, and documentation
+- **Parallel Execution**: Multiple agents work simultaneously on different tasks
+- **Smart Coordination**: Agents understand dependencies and work in the right order
+
+### 🔒 Security & Privacy First
+- **100% Local**: Your code never leaves your machine
+- **Isolated Environment**: Runs in Kubernetes with proper resource limits
+- **Full Control**: Review every line before merging
+
+### 🛠️ Developer-Friendly
+- **Git-Native**: Each task creates a proper feature branch
+- **Standard PRs**: Review changes like any other pull request
+- **IDE Compatible**: Work with your favorite editor while agents code
+
+### 📊 Real-Time Monitoring
+- **Live Progress**: See what each agent is working on
+- **Task Tracking**: Monitor completion status
+- **Performance Metrics**: Understand how your agents are performing
+
+## 📈 Use Cases
+
+### Startups & MVPs
+Build your MVP faster by describing features in plain English and letting TRIBE handle the implementation.
+
+### Enterprise Development
+Automate routine feature development, bug fixes, and refactoring tasks while your team focuses on architecture.
+
+### Learning & Experimentation
+See how experienced developers would implement your ideas by reviewing the code TRIBE generates.
+
+## 🔧 Commands Reference
+
+TRIBE supports both traditional and object-oriented command syntax:
+
+```bash
+# Cluster Management
+tribe start                        # Start TRIBE cluster
+tribe stop                         # Stop TRIBE cluster
+tribe status                       # Check system status
+
+# Task Management (two ways)
+tribe submit-prompt "description"  # Create new project from prompt
+tribe tasks                        # List all tasks (object-oriented)
+tribe list-tasks                   # List all tasks (traditional)
+tribe tasks <id>                   # Show task details (object-oriented)
+tribe show-task <id>              # Show task details (traditional)
+
+# Project Management
+tribe projects                     # List all projects (object-oriented)
+tribe list-projects               # List all projects (traditional)
+
+# Worker Management
+tribe workers                      # List workers (object-oriented)
+tribe worker-status               # Show worker status (traditional)
+tribe scale-workers <count>       # Scale agent count
+
+# Advanced Object-Oriented Examples
+tribe pods                        # List all pods
+tribe pods <name> logs           # View pod logs
+tribe services <name> restart    # Restart a service
+
+# Code Management
+tribe export-branches            # Export all branches locally
+tribe export-branch <name>       # Export specific branch
+```
+
+## 🤝 Community & Support
+
+- **GitHub**: [github.com/TRIBE-INC/0zen](https://github.com/TRIBE-INC/0zen)
+- **Issues**: [github.com/TRIBE-INC/0zen/issues](https://github.com/TRIBE-INC/0zen/issues)
+- **Documentation**: [Full documentation in repository](https://github.com/TRIBE-INC/0zen/blob/main/README.md)
+
+## 📄 License
+
+MIT License - see [LICENSE](https://github.com/TRIBE-INC/0zen/blob/main/LICENSE) for details.
+
+---
+
+<div align="center">
+  <h3>🚀 Ready to 10x your development speed?</h3>
+  <h2><code>npx @_xtribe/cli@latest</code></h2>
+  <p><em>Start building faster with TRIBE today</em></p>
+</div> 

package/install-tribe.js

@@ -639,29 +639,13 @@ async function installTribeCLI() {
         // Multiple sources for reliability
         // For testing, use a direct URL to our releases folder
         const isTestEnv = process.env.TRIBE_TEST_BINARY_URL;
-        const testBinary = process.env.TRIBE_TEST_BINARY;
         const githubRepo = process.env.TRIBE_INSTALLER_REPO || 'TRIBE-INC/releases';
         
-        // If we have a test binary file, use it directly
-        if (testBinary && fs.existsSync(testBinary)) {
-            spinner.text = 'Using test binary...';
-            fs.copyFileSync(testBinary, tribeDest);
-            fs.chmodSync(tribeDest, '755');
-            spinner.succeed('✓ TRIBE CLI installed from test binary');
-            return true;
-        }
-        
         let downloadUrl = '';
 
         try {
             spinner.text = 'Fetching latest release information from GitHub...';
-            const response = await fetch(`https://api.github.com/repos/${githubRepo}/releases`, {
-                headers: {
-                    'User-Agent': 'TRIBE-Installer',
-                    // Add token if available in environment
-                    ...(process.env.GITHUB_TOKEN ? { 'Authorization': `token ${process.env.GITHUB_TOKEN}` } : {})
-                }
-            });
+            const response = await fetch(`https://api.github.com/repos/${githubRepo}/releases`);
             if (!response.ok) {
                 throw new Error(`GitHub API returned ${response.status}`);
             }
@@ -669,47 +653,19 @@ async function installTribeCLI() {
             if (!releases || releases.length === 0) {
                 throw new Error('No releases found');
             }
-            
-            // Find a release with the binary we need
-            let foundRelease = null;
+            const latestRelease = releases[0];
             const assetName = `tribe-${platform}-${arch}`;
-            
-            for (const release of releases) {
-                if (release.draft) continue;
-                const asset = release.assets?.find(a => a.name === assetName || a.name === `${assetName}.exe`);
-                if (asset) {
-                    foundRelease = release;
-                    downloadUrl = asset.browser_download_url;
-                    spinner.text = `Found binary in release: ${release.tag_name}`;
-                    break;
-                }
-            }
-            
-            if (!foundRelease) {
-                // No release has the binary, try constructing URL from latest release
-                const latestRelease = releases[0];
-                downloadUrl = `https://github.com/${githubRepo}/releases/download/${latestRelease.tag_name}/tribe-${platform}-${arch}`;
-                spinner.text = `Trying release: ${latestRelease.tag_name}`;
+            const asset = latestRelease.assets.find(a => a.name === assetName);
+
+            if (!asset) {
+                throw new Error(`No binary found for ${platform}-${arch} in release ${latestRelease.tag_name}`);
             }
+
+            downloadUrl = asset.browser_download_url;
+            spinner.text = `Found latest release: ${latestRelease.tag_name}`;
         } catch (error) {
-            log.warning(`Failed to get release info: ${error.message}`);
-            // Try to get the latest release tag directly
-            try {
-                const tagResponse = await fetch(`https://api.github.com/repos/${githubRepo}/releases`, {
-                    headers: { 'User-Agent': 'TRIBE-Installer' }
-                });
-                if (tagResponse.ok) {
-                    const releases = await tagResponse.json();
-                    if (releases && releases.length > 0) {
-                        const tag = releases[0].tag_name;
-                        // Construct direct download URL
-                        downloadUrl = `https://github.com/${githubRepo}/releases/download/${tag}/tribe-${platform}-${arch}`;
-                        spinner.text = `Using direct download for release: ${tag}`;
-                    }
-                }
-            } catch (e) {
-                // Ignore and use fallback URLs
-            }
+            spinner.fail(`Failed to get release info: ${error.message}`);
+            // Fallback to other methods if the API fails
         }
 
         // Check if there's a local build available
@@ -1037,9 +993,6 @@ async function verifyInstallation() {
         results[tool] = await checkCommand(tool);
     }
     
-    // Store results globally for later use
-    global.installationChecks = results;
-    
     // Special check for container runtime
     let containerWorking = false;
     if (platform === 'darwin') {
@@ -1570,17 +1523,6 @@ async function forceCleanInstallation() {
         log.info('npm cache clean attempted (may have failed, which is okay)');
     }
     
-    // Remove first-install marker to allow auto-launch
-    const firstInstallMarker = path.join(tribeDir, '.first-install-complete');
-    if (fs.existsSync(firstInstallMarker)) {
-        try {
-            fs.unlinkSync(firstInstallMarker);
-            log.success('Removed first-install marker');
-        } catch (error) {
-            log.warning(`Could not remove first-install marker: ${error.message}`);
-        }
-    }
-    
     // Platform-specific cleanup
     if (platform === 'darwin') {
         // Check if Colima is running and stop it
@@ -1612,12 +1554,29 @@ async function forceCleanInstallation() {
 }
 
 async function main() {
-    console.log(chalk.bold.blue('\n🚀 TRIBE CLI Installer\n'));
+    // Fire-themed ASCII art with modern Unicode design
+    console.log('');
+    console.log(chalk.red(`     ░▒▓█▓▒░      ░▒▓█▓▒░`) + chalk.yellow(`      ░▒▓`) + chalk.red(`      `)              + chalk.yellow(`     ▓▒░         `) + chalk.red(`░▒▓█▓▒░`));
+    console.log(chalk.red(`   ░▒▓█████▓▒░  ░▒▓█████▓▒░`) + chalk.yellow(`  ░▒▓██`) + chalk.red(`    `)            + chalk.yellow(` ▓██▓▒░       `) + chalk.red(`░▒▓█████▓▒░`));
+    console.log(chalk.red(`     ░▒▓█▓▒░    ░▒▓█▓▒░▒▓█▓▒░`) + chalk.yellow(`░▒▓██`) + chalk.red(`  `)          + chalk.yellow(`▓██▓▒░      `) + chalk.red(`░▒▓█▓▒░░▒▓█▓▒░`));
+    console.log(chalk.red(`     ░▒▓█▓▒░    ░▒▓█▓▒░░▒▓█▓▒░`) + chalk.yellow(` ░▒▓██`) + chalk.red(``)        + chalk.yellow(`▓██▓▒░     `) + chalk.red(`░▒▓█▓▒░  ░▒▓█▓▒░`));
+    console.log(chalk.red(`     ░▒▓█▓▒░    ░▒▓█▓▒░ ░▒▓█▓▒░`) + chalk.yellow(`  ░▒▓██`) + chalk.red(``)      + chalk.yellow(`██▓▒░    `) + chalk.red(`░▒▓█▓▒░    ░▒▓█▓▒░`));
+    console.log(chalk.red(`     ░▒▓█▓▒░    ░▒▓█▓▒░  ░▒▓█▓▒░`) + chalk.yellow(`   ░▒▓`) + chalk.red(`██`)  + chalk.yellow(`▓▒░   `) + chalk.red(`░▒▓█▓▒░      ░▒▓█▓▒░`));
+    console.log(chalk.red(`     ░▒▓█▓▒░    ░▒▓█▓▒░   ░▒▓█▓▒░`) + chalk.yellow(`    ░▒`) + chalk.red(`▓`) + chalk.yellow(`▒░  `) + chalk.red(`░▒▓█▓▒░░▒▓█▓▒░░▒▓█▓▒░`));
+    console.log(chalk.red(`     ░▒▓█▓▒░    ░▒▓█▓▒░    ░▒▓█▓▒░`) + chalk.yellow(`     `) + chalk.red(`░`) + chalk.yellow(` `) + chalk.red(`░▒▓█▓▒░  ░▒▓█████▓▒░`));
+    console.log(chalk.red(`     ░▒▓█▓▒░    ░▒▓█▓▒░     ░▒▓█▓▒░`) + chalk.yellow(`    `) + chalk.red(`░▒▓█▓▒░    ░▒▓█▓▒░`));
+    console.log(chalk.red(`     ░▒▓█▓▒░    ░▒▓█▓▒░      ░▒▓█▓▒░`) + chalk.yellow(` `) + chalk.red(`░▒▓█▓▒░      ░▒▓█▓▒░`));
+    console.log(chalk.red(`     ░▒▓█▓▒░    ░▒▓█▓▒░       ░▒▓█▓▒`) + chalk.red(`▓█▓▒░        ░▒▓█▓▒░`));
+    console.log('');
+    console.log(chalk.yellow(`            ╔═══════════════════════════════════╗`));
+    console.log(chalk.yellow(`            ║ `) + chalk.white.bold(`Multi-Agent Orchestration System`) + chalk.yellow(` ║`));
+    console.log(chalk.yellow(`            ╚═══════════════════════════════════╝`));
+    console.log('');
     
     // Detect and display platform info
     const displayArch = process.arch === 'x64' ? 'amd64' : process.arch;
-    console.log(chalk.gray(`Platform: ${platform} (${displayArch})`));
-    console.log(chalk.gray(`Node: ${process.version}`));
+    console.log(chalk.cyan(`Platform: ${platform} (${displayArch})`));
+    console.log(chalk.cyan(`Node: ${process.version}`));
     console.log('');
     
     // Check for unsupported platforms early
@@ -1719,16 +1678,6 @@ async function main() {
     // Verify everything first
     const verified = await verifyInstallation();
     
-    // If critical components failed (especially TRIBE CLI), exit with error
-    if (!allSuccess) {
-        // Check specifically if TRIBE CLI installation failed
-        const tribeBinaryExists = fs.existsSync(path.join(tribeBinDir, 'tribe'));
-        if (!tribeBinaryExists) {
-            console.error(chalk.red('\n❌ Installation failed: TRIBE CLI could not be installed'));
-            process.exit(1);
-        }
-    }
-    
     // Try to start container runtime (after showing results)
     const runtimeStarted = await startContainerRuntime();
     
@@ -1875,22 +1824,6 @@ async function main() {
         log.info('Then run: tribe start');
     }
     
-    // Auto-launch handling (only for successful installations)
-    const checks = global.installationChecks || {};
-    if (checks.kubectl && checks.tribe) {
-        try {
-            const autoLaunch = require('./install-tribe-autolaunch.js');
-            if (autoLaunch.shouldAutoLaunch()) {
-                console.log(''); // Spacing before auto-launch
-                await autoLaunch.handleAutoLaunch();
-                // If auto-launch takes over, we won't reach here
-            }
-        } catch (error) {
-            // Silently ignore auto-launch errors to not break the installer
-            // Auto-launch is a nice-to-have feature, not critical
-        }
-    }
-    
     // Exit cleanly
     process.exit(0);
 }
@@ -1911,7 +1844,6 @@ if (require.main === module) {
         console.log('  --verify       Only verify existing installation');
         console.log('  --dry-run      Show what would be installed');
         console.log('  --skip-cluster Skip cluster deployment (for testing)');
-        console.log('  --no-start     Alias for --skip-cluster (for CI environments)');
         console.log('  --force        Force clean installation (removes existing installations)');
         console.log('\nThis installer sets up the complete TRIBE development environment:');
         
@@ -1952,8 +1884,8 @@ if (require.main === module) {
         process.exit(0);
     }
     
-    // Store skip-cluster flag (--no-start is an alias)
-    global.skipCluster = args.includes('--skip-cluster') || args.includes('--no-start');
+    // Store skip-cluster flag
+    global.skipCluster = args.includes('--skip-cluster');
     
     // Check for force flag
     if (args.includes('--force')) {

package/package.json

@@ -1,27 +1,35 @@
 {
   "name": "@_xtribe/cli",
-  "version": "2.0.0",
-  "description": "TRIBE multi-agent development system - Zero to productive with one command",
+  "version": "2.0.3",
+  "description": "Deploy a team of AI agents that write production-ready code. Transform natural language into working software with autonomous Claude-powered developers.",
   "main": "install-tribe.js",
   "bin": {
-    "cli": "./index.js",
-    "install-tribe": "./install-tribe.js",
-    "setup-path": "./setup-path.js"
+    "tribe": "install-tribe.js"
   },
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"
   },
   "keywords": [
+    "ai",
+    "claude",
+    "anthropic",
+    "code-generation",
+    "ai-agents",
+    "multi-agent",
+    "autonomous-development",
+    "ai-developer",
+    "code-assistant",
+    "llm",
     "tribe",
     "cli",
     "kubernetes",
     "docker",
     "colima",
-    "multi-agent",
-    "ai",
     "development",
-    "autonomous",
-    "agents"
+    "automation",
+    "devtools",
+    "productivity",
+    "natural-language-programming"
   ],
   "engines": {
     "node": ">=16.0.0"
@@ -36,33 +44,25 @@
     "registry": "https://registry.npmjs.org/"
   },
   "files": [
-    "index.js",
     "install-tribe.js",
-    "install-tribe-minimal.js",
-    "install-tribe-autolaunch.js",
-    "setup-path.js",
-    "install.sh",
-    "tribe-deployment.yaml",
     "README.md",
-    "AUTOLAUNCH_IMPLEMENTATION.md",
     "package.json"
   ],
   "dependencies": {
-    "adm-zip": "^0.5.9",
     "chalk": "^4.1.2",
-    "node-fetch": "^2.6.7",
     "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/TRIBE-INC/0zen.git"
+    "url": "git+https://github.com/0zen/0zen.git"
   },
-  "author": "TRIBE-INC",
+  "author": "0zen",
   "license": "MIT",
-  "homepage": "https://github.com/TRIBE-INC/0zen",
+  "homepage": "https://github.com/0zen/0zen",
   "bugs": {
-    "url": "https://github.com/TRIBE-INC/0zen/issues"
+    "url": "https://github.com/0zen/0zen/issues"
   }
 }

package/index.js

@@ -1,20 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Default entry point for npx @_xtribe/cli
- * This runs the full installation process
- */
-
-// Execute the installer in a way that preserves require.main
-const { spawn } = require('child_process');
-const path = require('path');
-
-const installerPath = path.join(__dirname, 'install-tribe.js');
-const child = spawn(process.execPath, [installerPath, ...process.argv.slice(2)], {
-    stdio: 'inherit',
-    env: process.env
-});
-
-child.on('exit', (code) => {
-    process.exit(code || 0);
-});