@_xtribe/cli 1.0.0-beta.5 → 1.0.0-beta.7

package/README.md

@@ -1,177 +1,123 @@
-# @_xtribe/cli
+# TRIBE CLI - Zero to Productive in One Command
 
-Complete TRIBE multi-agent development environment installer.
+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.
 
-## Quick Start
+## 🚀 One-Command Installation
 
 ```bash
 npx @_xtribe/cli
 ```
 
-This single command installs:
-- ✅ Docker CLI
-- ✅ Colima (lightweight container runtime for macOS)
-- ✅ Lima (virtualization layer) 
-- ✅ KIND (Kubernetes in Docker)
-- ✅ kubectl (Kubernetes CLI)
-- ✅ TRIBE CLI (multi-agent orchestration)
+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
 
-## After Installation
+## 🎯 What is TRIBE?
 
-Start the container runtime:
+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
 
-```bash
-# Option 1: Use installed Colima
-colima start --cpu 2 --memory 4
-
-# Option 2: Use Docker Desktop
-# Download from: https://docs.docker.com/desktop/install/mac-install/
+## 💡 Quick Start
 
-# Option 3: Use Homebrew (recommended)
-brew install colima docker
-colima start
-```
-
-Then start your TRIBE development environment:
+After installation, just run:
 
 ```bash
-tribe start
-tribe status
-tribe deploy-task --prompt "Create REST API" --repo "https://github.com/your/repo"
+tribe
 ```
 
-## What is TRIBE?
-
-TRIBE (Task-Review-Iterate-Branch-Execute) is a multi-agent AI development system that automates software development workflows using multiple Claude AI agents working in parallel.
-
-## System Requirements
-
-- macOS or Linux
-- Node.js 16+
-- Internet connection for downloads
-
-## Support
+The interactive CLI will:
+1. **First time?** Guide you through creating your first project
+2. **Returning?** Show your projects, tasks, and agent activity
 
-- Issues: https://github.com/0zen/0zen/issues
-- Documentation: https://github.com/0zen/0zen
-
-## License
-
-MIT
-
-## Overview
-
-The TRIBE CLI GUI provides both interactive and non-interactive modes for:
-- Listing and viewing tasks
-- Managing projects
-- Monitoring agents
-- Creating new tasks (interactive mode)
-
-## Installation
+### Creating Tasks
 
 ```bash
-cd sdk/cmd/cli-gui
-go build -o cli-gui .
+tribe create-task
+# Select project, describe what you want built
+# An AI agent picks it up and implements it!
 ```
 
-## Usage
-
-### Interactive Mode
-
-Simply run the CLI without arguments:
+### Reviewing PRs
 
 ```bash
-./cli-gui
+tribe review-task
+# See PRs created by agents
+# Review diffs, add comments, merge
 ```
 
-This will present a menu-driven interface where you can:
-1. List all tasks
-2. List all projects
-3. List all agents
-4. Create a new task
-5. View task details
+## 🛠️ System Requirements
 
-### Non-Interactive Mode
+- **macOS** or **Linux**
+- **4GB RAM** minimum (8GB recommended)
+- **20GB disk space**
+- **Node.js 16+**
 
-Perfect for scripting and automation:
+## 📚 Common Commands
 
 ```bash
-# List all tasks
-./cli-gui --non-interactive --cmd list-tasks
-
-# List all projects
-./cli-gui --non-interactive --cmd list-projects
-
-# List all agents
-./cli-gui --non-interactive --cmd list-agents
-
-# View task details
-./cli-gui --non-interactive --cmd task-details --task-id task-8e4999d6
-
-# Get JSON output
-./cli-gui --non-interactive --cmd list-tasks --format json
+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
 ```
 
-### Environment Variables
+## 🔧 Architecture
 
-Configure API endpoints using environment variables:
+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
 
-```bash
-export TASKMASTER_URL=http://localhost:8080
-export BRIDGE_URL=http://localhost:3456
-export GITEA_URL=http://localhost:3000
-```
+## 🤝 Contributing
 
-## Command-Line Options
+TRIBE is open source! Visit our [GitHub repository](https://github.com/0zen/0zen) to contribute.
 
-- `--non-interactive`: Run in non-interactive mode
-- `--cmd <command>`: Command to execute (required in non-interactive mode)
-  - `list-tasks`: List all tasks
-  - `list-projects`: List all projects
-  - `list-agents`: List all agents
-  - `task-details`: View details of a specific task
-- `--task-id <id>`: Task ID (required for task-details command)
-- `--format <format>`: Output format (text or json, default: text)
+## 📖 Documentation
 
-## Examples
+For detailed documentation, visit the [TRIBE Flow Guide](https://github.com/0zen/0zen/blob/main/TRIBE-SYSTEM-FLOW-GUIDE.md).
 
-### List tasks in JSON format
-```bash
-./cli-gui --non-interactive --cmd list-tasks --format json
-```
+## 🆘 Troubleshooting
 
-### View specific task details
+### Cluster not starting?
 ```bash
-./cli-gui --non-interactive --cmd task-details --task-id task-123456
+# Check if Colima is running
+colima status
+
+# Start manually if needed
+colima start --kubernetes
+tribe start
 ```
 
-### Use with custom API endpoints
+### Port conflicts?
 ```bash
-TASKMASTER_URL=http://api.example.com:8080 ./cli-gui --non-interactive --cmd list-tasks
+# Check what's using ports
+lsof -i :30080
+lsof -i :3456
 ```
 
-## Testing with Mock Data
-
-To test without a running TRIBE cluster, you can use mock endpoints or run against a local instance.
-
-## Development
-
-### Adding New Commands
-
-1. Add the command to the switch statement in `runNonInteractive()`
-2. Implement the corresponding function
-3. Add any necessary API methods to `api.go`
-4. Update this README with the new command
+### Reset everything?
+```bash
+# Stop cluster
+colima stop
 
-### Building for Different Platforms
+# Remove TRIBE namespace
+kubectl delete namespace tribe-system
 
-```bash
-# Linux
-GOOS=linux GOARCH=amd64 go build -o cli-gui-linux .
+# Start fresh
+tribe start
+```
 
-# macOS
-GOOS=darwin GOARCH=amd64 go build -o cli-gui-macos .
+## 📄 License
 
-# Windows
-GOOS=windows GOARCH=amd64 go build -o cli-gui.exe .
-``` 
+MIT License - see [LICENSE](https://github.com/0zen/0zen/blob/main/LICENSE) for details. 

package/install-tribe.js

@@ -13,12 +13,18 @@ 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),
@@ -391,6 +397,17 @@ 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)) {
@@ -398,7 +415,6 @@ async function installTribeCli() {
             try {
                 execSync('go version', { stdio: 'ignore' });
                 execSync(`cd ${__dirname} && go build -o tribe cluster-cli.go client.go`);
-                const tribeDest = path.join(binDir, 'tribe');
                 fs.copyFileSync(path.join(__dirname, 'tribe'), tribeDest);
                 fs.chmodSync(tribeDest, '755');
                 spinner.succeed('TRIBE CLI built from source');
@@ -408,9 +424,8 @@ async function installTribeCli() {
             }
         }
         
-        // Try pre-built binary
+        // Try pre-built binary from GitHub
         const tribeUrl = `https://github.com/0zen/0zen/releases/latest/download/tribe-${platform}-${arch}`;
-        const tribeDest = path.join(binDir, 'tribe');
         
         try {
             await downloadFile(tribeUrl, tribeDest);
@@ -418,14 +433,23 @@ async function installTribeCli() {
             spinner.succeed('TRIBE CLI installed');
             return true;
         } catch {
-            // Fallback: copy local binary if it exists
-            const localBinary = path.join(__dirname, 'tribe');
-            if (fs.existsSync(localBinary)) {
-                fs.copyFileSync(localBinary, tribeDest);
-                fs.chmodSync(tribeDest, '755');
-                spinner.succeed('TRIBE CLI installed from local binary');
-                return true;
+            // 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) {
@@ -450,11 +474,11 @@ async function startContainerRuntime() {
             const spinner = ora('Starting Colima container runtime...').start();
             
             try {
-                // Strategy 1: Quick start with minimal resources
-                spinner.text = 'Starting Colima (minimal setup)...';
-                execSync('colima start --cpu 1 --memory 2 --disk 5 --vm-type=vz', { 
+                // Strategy 1: Quick start with minimal resources and Kubernetes
+                spinner.text = 'Starting Colima with Kubernetes...';
+                execSync('colima start --cpu 2 --memory 4 --disk 10 --kubernetes --vm-type=vz', { 
                     stdio: 'pipe',
-                    timeout: 30000 // 30 second timeout
+                    timeout: 60000 // 60 second timeout for K8s
                 });
                 
                 // Test if it worked
@@ -463,10 +487,10 @@ async function startContainerRuntime() {
                 return true;
                 
             } catch (error) {
-                // Strategy 2: Start in background and don't wait
+                // Strategy 2: Start in background with Kubernetes
                 try {
-                    spinner.text = 'Starting Colima in background...';
-                    const child = spawn(path.join(binDir, 'colima'), ['start', '--cpu', '2', '--memory', '4'], {
+                    spinner.text = 'Starting Colima with Kubernetes in background...';
+                    const child = spawn(path.join(binDir, 'colima'), ['start', '--cpu', '2', '--memory', '4', '--disk', '10', '--kubernetes'], {
                         detached: true,
                         stdio: 'ignore',
                         env: { ...process.env, PATH: `${binDir}:${process.env.PATH}` }
@@ -528,7 +552,7 @@ async function updatePath() {
 async function verifyInstallation() {
     const spinner = ora('Verifying installation...').start();
     
-    const tools = ['docker', 'kind', 'kubectl', 'tribe'];
+    const tools = ['docker', 'kubectl', 'tribe', 'colima'];
     const results = {};
     
     for (const tool of tools) {
@@ -565,6 +589,133 @@ async function verifyInstallation() {
     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 {
+        execSync('colima 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)...';
+        execSync('colima start --kubernetes --cpu 4 --memory 8 --disk 20', {
+            stdio: 'pipe',
+            env: { ...process.env, PATH: `${binDir}:${process.env.PATH}` }
+        });
+        
+        // Verify it's working
+        execSync('kubectl 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
+        execSync(`${tribePath} start`, {
+            stdio: 'pipe',
+            env: env
+        });
+        
+        // Create marker file
+        fs.writeFileSync(deploymentMarker, new Date().toISOString());
+        
+        spinner.succeed('TRIBE cluster deployed successfully');
+        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'));
     
@@ -575,10 +726,7 @@ async function main() {
     await updatePath();
     
     const tasks = [
-        { name: 'Docker CLI', fn: installDocker },
         { name: 'Colima', fn: installColima },
-        { name: 'Lima', fn: installLima },
-        { name: 'KIND', fn: installKind },
         { name: 'kubectl', fn: installKubectl },
         { name: 'TRIBE CLI', fn: installTribeCli }
     ];
@@ -597,17 +745,60 @@ async function main() {
     // Verify everything
     const verified = await verifyInstallation();
     
-    console.log('\n' + chalk.bold('Next Steps:'));
     if (verified) {
-        log.success('All components installed successfully! 🎉');
-        console.log('');
-        log.info('Quick start:');
-        console.log('  tribe start              # Start TRIBE cluster');
-        console.log('  tribe status             # Check cluster status');
-        console.log('  tribe deploy-task        # Deploy tasks to agents');
-        console.log('');
-        log.info('For help: tribe --help');
+        // 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('');
+                    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
@@ -626,6 +817,7 @@ async function main() {
         }
         console.log('');
         log.info('Restart your shell or run: source ~/.zshrc');
+        log.info('Then run: tribe start');
     }
 }
 
@@ -644,9 +836,8 @@ if (require.main === module) {
         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('• Docker CLI + Colima (macOS container runtime)');
-        console.log('• KIND (Kubernetes in Docker)'); 
+                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:');
@@ -671,7 +862,7 @@ if (require.main === module) {
         console.log('• Docker CLI (if not present)');
         console.log('• Colima container runtime (macOS only)');
         console.log('• Lima virtualization (macOS only)');
-        console.log('• KIND - Kubernetes in Docker');
+                    console.log('• Colima - Container runtime with Kubernetes');
         console.log('• kubectl - Kubernetes CLI');
         console.log('• TRIBE CLI - Multi-agent system');
         process.exit(0);

package/package.json

@@ -1,9 +1,11 @@
 {
   "name": "@_xtribe/cli",
-  "version": "1.0.0-beta.5",
-  "description": "TRIBE multi-agent development system CLI installer",
+  "version": "1.0.0-beta.7",
+  "description": "TRIBE multi-agent development system - Zero to productive with one command",
   "main": "install-tribe.js",
-  "bin": "./install-tribe.js",
+  "bin": {
+    "tribe": "install-tribe.js"
+  },
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"
   },
@@ -15,7 +17,9 @@
     "colima",
     "multi-agent",
     "ai",
-    "development"
+    "development",
+    "autonomous",
+    "agents"
   ],
   "engines": {
     "node": ">=16.0.0"
@@ -32,6 +36,7 @@
   "files": [
     "install-tribe.js",
     "lima-guestagent.Linux-aarch64.gz",
+    "tribe-deployment.yaml",
     "tribe",
     "README.md",
     "package.json"
@@ -45,7 +50,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/0zen/0zen.git"
+    "url": "git+https://github.com/0zen/0zen.git"
   },
   "author": "0zen",
   "license": "MIT",
@@ -53,4 +58,4 @@
   "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!"