@_xtribe/cli 2.0.3 → 2.0.5

package/README.md

@@ -1,207 +1,84 @@
-# TRIBE: Multi-Agent AI Development System
+# TRIBE CLI Installer
 
-> **Transform natural language into production-ready code with a team of autonomous AI agents working in parallel**
+Automate your TRIBE development environment with a single command. This npm package delivers the latest TRIBE CLI binary, bootstraps required dependencies (Colima, kubectl, container runtime), and wires the CLI into your shell `PATH` so you can start managing telemetry and authentication immediately.
 
-[![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)
+## Requirements
 
-## 🚀 Get Started in 30 Seconds
+- **Operating systems:** macOS (Intel/Apple Silicon) or Linux
+- **Node.js:** v16 or newer (the installer runs via `npx`)
+- **Docker alternative:** The installer provisions Colima automatically; you can skip it with `--skip-cluster` if you already have a configured runtime.
 
-```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
+## Installation
 
 ```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"
+npx @_xtribe/cli@latest --version
 ```
 
-**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
+Running the installer will:
 
-## 🏗️ How It Works
+1. Detect your platform and download the matching TRIBE CLI binary.
+2. Install or verify Colima, kubectl, and supporting services.
+3. Place the CLI at `~/.tribe/bin/tribe` and configure your shell `PATH` via `~/.tribe/tribe-env.sh`.
+4. Start the local container runtime (unless it is already running).
 
-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
+> **Tip:** Source `~/.tribe/tribe-env.sh` to use the CLI immediately in the current shell.
 
-## 🛠️ Quick Start Guide
+## Usage
 
-### 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
+Launch the CLI with:
 
 ```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
+tribe --help
 ```
 
-### Your First Project
-
-```bash
-# Interactive mode (recommended for beginners)
-tribe
+### Telemetry Commands
 
-# Or use direct commands
-tribe submit-prompt "Create a TODO app with React, TypeScript, and local storage"
-```
+| Command        | Description                                   |
+| -------------- | --------------------------------------------- |
+| `tribe enable` | Start the tutor telemetry collector daemon.   |
+| `tribe disable`| Stop the collector and disable auto-start.    |
+| `tribe status` | Display OAuth status, collector health, and recent event counts. |
+| `tribe logs`   | Tail the telemetry collector log file.        |
 
-Watch as your agents:
-- Create a new repository
-- Set up the project structure
-- Implement all features
-- Write tests
-- Create documentation
+### Authentication Commands
 
-### Monitor Progress
+| Command         | Description                                                        |
+| --------------- | ------------------------------------------------------------------ |
+| `tribe login`   | Launches the TRIBE OAuth flow (opens browser, handles callback, stores tokens in `~/.tribe/tutor/auth.json`). |
+| `tribe logout`  | Removes stored credentials and stops authenticated telemetry.      |
 
-```bash
-# See what your agents are doing (multiple ways)
-tribe tasks                    # Object-oriented syntax
-tribe list-tasks              # Traditional syntax
+### Flags
 
-# Check specific task details
-tribe tasks task_abc123       # Object-oriented syntax
-tribe show-task task_abc123   # Traditional syntax
+- `-localhost` — Force localhost mode (auto-starts local tutor services instead of production).
+- `-verbose` — Emit verbose installer or runtime logs for debugging.
+- `-beta` — Enable advanced/beta commands when available.
 
-# View worker activity
-tribe workers                 # Object-oriented syntax
-tribe worker-status          # Traditional syntax
-```
+Combine flags with commands, for example `tribe -verbose status`.
 
-### Export and Review
+## Typical Workflow
 
 ```bash
-# Export all branches locally
-tribe export-branches
+# Install (or upgrade) the CLI
+npx @_xtribe/cli@latest --version
 
-# Review the code
-git diff main...tribe/feature-todo-app
+# Authenticate and start telemetry
+tribe login
+tribe status
 
-# Merge via the Gitea UI
-open http://localhost:3000
+# Review logs when troubleshooting
+tribe logs
 ```
 
-## 🎨 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)
+Successful authentication writes fresh tokens and the collector begins pushing events to `https://tutor.tribecode.ai`. Run `tribe status` any time to confirm the collector PID, uptime, and recent event totals.
 
-## 📄 License
+## Troubleshooting
 
-MIT License - see [LICENSE](https://github.com/TRIBE-INC/0zen/blob/main/LICENSE) for details.
+- **OAuth callback shows a blank page:** This is expected once the CLI captures the code. Check the terminal for `✅ Authorization received` and rerun `tribe status` to confirm.
+- **Collector reports `TOKEN_VALIDATION_FAILED`:** Refresh credentials with `tribe login` and ensure the collector restarts (`tribe disable && tribe enable`).
+- **PATH not updated:** Source `~/.tribe/tribe-env.sh` or add `export PATH="$HOME/.tribe/bin:$PATH"` to your shell profile.
 
----
+## Additional Resources
 
-<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> 
+- [TRIBE CLI & Platform Docs](https://github.com/TRIBE-INC/0zen) — architecture overviews, local setup, and troubleshooting guides.
+- [TRIBE API Reference](https://github.com/TRIBE-INC/tribe-api) — REST endpoints for retrieving telemetry, session insights, and system metadata.
+- [TRIBE Documentation Portal](https://docs.tribecode.ai/) — centralized guides, onboarding flows, and deep dives into telemetry processing.

package/index.js

@@ -0,0 +1,20 @@
+#!/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);
+});

package/install-tribe-autolaunch.js

@@ -0,0 +1,272 @@
+#!/usr/bin/env node
+
+const os = require('os');
+const fs = require('fs');
+const path = require('path');
+const { spawn, execSync } = require('child_process');
+
+// Import the existing installer
+const originalInstaller = require('./install-tribe.js');
+
+// Auto-launch specific functionality
+const platform = os.platform();
+const homeDir = os.homedir();
+const tribeDir = path.join(homeDir, '.tribe');
+const firstTimeMarker = path.join(tribeDir, '.first-install-complete');
+
+// Color codes for output
+const colors = {
+    reset: '\x1b[0m',
+    bright: '\x1b[1m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    blue: '\x1b[34m',
+    cyan: '\x1b[36m'
+};
+
+function log(message, color = '') {
+    console.log(color + message + colors.reset);
+}
+
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+/**
+ * Check if we should auto-launch the interactive UI
+ */
+function shouldAutoLaunch() {
+    // Check for command line flags
+    const args = process.argv.slice(2);
+    const noLaunchFlag = args.includes('--no-launch') || args.includes('--no-auto');
+    const launchFlag = args.includes('--launch') || args.includes('--auto');
+    const simpleFlag = args.includes('--simple');
+    
+    if (noLaunchFlag || simpleFlag) {
+        return false;
+    }
+    
+    if (launchFlag) {
+        return true;
+    }
+    
+    // Auto-launch conditions:
+    // 1. Interactive terminal (TTY)
+    const isTTY = process.stdout.isTTY && process.stdin.isTTY;
+    if (!isTTY) {
+        return false;
+    }
+    
+    // 2. Not in CI environment
+    const isCI = process.env.CI === 'true' || 
+                 process.env.CONTINUOUS_INTEGRATION === 'true' ||
+                 process.env.GITHUB_ACTIONS === 'true';
+    if (isCI) {
+        return false;
+    }
+    
+    // 3. First time install (no marker file exists)
+    const isFirstTime = !fs.existsSync(firstTimeMarker);
+    
+    return isFirstTime;
+}
+
+/**
+ * Get the path to the tribe binary
+ */
+function getTribeBinaryPath() {
+    const tribeBinDir = path.join(homeDir, '.tribe', 'bin');
+    const tribePath = path.join(tribeBinDir, 'tribe');
+    
+    if (fs.existsSync(tribePath)) {
+        return tribePath;
+    }
+    
+    // Try global install
+    try {
+        return execSync('which tribe', { encoding: 'utf8' }).trim();
+    } catch {
+        throw new Error('Tribe binary not found');
+    }
+}
+
+/**
+ * Check if the Tribe cluster is running
+ */
+async function isClusterRunning() {
+    try {
+        const tribePath = getTribeBinaryPath();
+        const result = execSync(`${tribePath} --simple status`, { encoding: 'utf8' });
+        return result.includes('Cluster is running');
+    } catch {
+        return false;
+    }
+}
+
+/**
+ * Start the Tribe cluster
+ */
+async function startCluster() {
+    const tribePath = getTribeBinaryPath();
+    log('\nStarting Tribe cluster...', colors.cyan);
+    
+    try {
+        execSync(`${tribePath} --simple start`, { stdio: 'inherit' });
+        
+        // Wait for cluster to be ready
+        log('Waiting for services to be ready...', colors.yellow);
+        let attempts = 0;
+        while (attempts < 30) {
+            await sleep(2000);
+            if (await isClusterRunning()) {
+                log('✅ Cluster is ready!', colors.green);
+                return true;
+            }
+            attempts++;
+        }
+        
+        throw new Error('Cluster failed to start in time');
+    } catch (error) {
+        log('Failed to start cluster: ' + error.message, colors.reset);
+        return false;
+    }
+}
+
+/**
+ * Display the first-time welcome experience
+ */
+async function showFirstTimeWelcome() {
+    console.log('\n' + colors.bright + colors.cyan + '🎉 Welcome to TRIBE!' + colors.reset);
+    console.log('\nYour AI development team is ready to help you build amazing software!\n');
+    
+    console.log('Meet your AI agents:');
+    console.log('  🎨 ' + colors.bright + 'Pixel' + colors.reset + ' - Creative Design & UI/UX');
+    console.log('  ⚡ ' + colors.bright + 'Spark' + colors.reset + ' - Implementation & Performance');
+    console.log('  🌟 ' + colors.bright + 'Nova' + colors.reset + ' - Architecture & Strategy');
+    console.log('  🧘 ' + colors.bright + 'Zen' + colors.reset + ' - Testing & Quality');
+    console.log('  🔥 ' + colors.bright + 'Blaze' + colors.reset + ' - DevOps & Infrastructure');
+    console.log('  🌌 ' + colors.bright + 'Cosmos' + colors.reset + ' - Data & Analytics');
+    console.log('  🔊 ' + colors.bright + 'Echo' + colors.reset + ' - API & Integration');
+    console.log('  ⚛️ ' + colors.bright + 'Quantum' + colors.reset + ' - Security & Cryptography');
+    
+    console.log('\n' + colors.yellow + 'Launching interactive mode...' + colors.reset);
+    await sleep(2000);
+}
+
+/**
+ * Launch the Tribe interactive UI
+ */
+async function launchTribeInteractive() {
+    const tribePath = getTribeBinaryPath();
+    
+    // Clear the screen for a clean start
+    if (platform !== 'win32') {
+        process.stdout.write('\x1Bc');
+    }
+    
+    // Launch tribe in interactive mode (default when no args)
+    const child = spawn(tribePath, [], {
+        stdio: 'inherit',
+        env: { 
+            ...process.env,
+            TERM: process.env.TERM || 'xterm-256color'
+        }
+    });
+    
+    // Handle child process exit
+    child.on('exit', (code) => {
+        if (code !== 0) {
+            console.error(`\nTribe exited with code ${code}`);
+        }
+        process.exit(code || 0);
+    });
+    
+    // Handle errors
+    child.on('error', (err) => {
+        console.error('Failed to launch Tribe:', err.message);
+        showManualInstructions();
+        process.exit(1);
+    });
+}
+
+/**
+ * Show manual launch instructions
+ */
+function showManualInstructions() {
+    console.log('\n' + colors.yellow + 'To start Tribe manually:' + colors.reset);
+    console.log('  ' + colors.green + 'tribe' + colors.reset + '              # Interactive mode');
+    console.log('  ' + colors.green + 'tribe --simple' + colors.reset + '     # Simple CLI mode');
+    console.log('  ' + colors.green + 'tribe --help' + colors.reset + '       # Show all options\n');
+}
+
+/**
+ * Mark first install as complete
+ */
+function markFirstInstallComplete() {
+    if (!fs.existsSync(tribeDir)) {
+        fs.mkdirSync(tribeDir, { recursive: true });
+    }
+    fs.writeFileSync(firstTimeMarker, new Date().toISOString());
+}
+
+/**
+ * Main auto-launch handler
+ */
+async function handleAutoLaunch() {
+    // Only proceed if we should auto-launch
+    if (!shouldAutoLaunch()) {
+        showManualInstructions();
+        return;
+    }
+    
+    try {
+        // Check if this is first time
+        const isFirstTime = !fs.existsSync(firstTimeMarker);
+        
+        // Show welcome for first-time users
+        if (isFirstTime) {
+            await showFirstTimeWelcome();
+        } else {
+            log('\nLaunching TRIBE interactive mode...', colors.cyan);
+            await sleep(1000);
+        }
+        
+        // Check and start cluster if needed (skip if --no-start was used)
+        const args = process.argv.slice(2);
+        const skipCluster = args.includes('--skip-cluster') || args.includes('--no-start');
+        
+        if (!skipCluster && !await isClusterRunning()) {
+            const started = await startCluster();
+            if (!started) {
+                showManualInstructions();
+                return;
+            }
+        }
+        
+        // Mark first install complete before launching
+        if (isFirstTime) {
+            markFirstInstallComplete();
+        }
+        
+        // Launch the interactive UI
+        await launchTribeInteractive();
+        
+    } catch (error) {
+        console.error('\n' + colors.reset + 'Could not launch Tribe automatically.');
+        console.error('Error:', error.message);
+        showManualInstructions();
+    }
+}
+
+// Export for use in main installer
+module.exports = {
+    shouldAutoLaunch,
+    handleAutoLaunch,
+    showManualInstructions,
+    markFirstInstallComplete
+};
+
+// If run directly (for testing)
+if (require.main === module) {
+    handleAutoLaunch();
+}