Put README.md

.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

.github/workflows/deploy.yml

@@ -1,119 +0,0 @@
-name: 🚀 Deploy GOD AGENT OS v11
-
-on:
-  push:
-    branches: [ master, main, genspark_ai_developer ]
-  workflow_dispatch:
-
-env:
-  HF_SPACE: PYAE1994/autonomous-coding-system
-  HF_USER: PYAE1994
-
-jobs:
-
-  # ── 1. Deploy Backend to HuggingFace Space ──────────────────────────────────
-  deploy-hf-backend:
-    name: 🤗 Deploy Backend to HF Space
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-
-      - name: 🐍 Setup Python
-        uses: actions/setup-python@v5
-        with:
-          python-version: '3.11'
-
-      - name: 📦 Install HF Hub
-        run: pip install huggingface_hub
-
-      - name: 🔐 Push HF Space Secrets
-        env:
-          HF_TOKEN: ${{ secrets.HF_TOKEN }}
-          GEMINI_KEY: ${{ secrets.GEMINI_KEY }}
-          SAMBANOVA_KEY: ${{ secrets.SAMBANOVA_KEY }}
-          GITHUB_KEY: ${{ secrets.GITHUB_KEY }}
-        run: |
-          python3 - <<'EOF'
-          import os
-          try:
-              from huggingface_hub import HfApi
-              token = os.environ.get("HF_TOKEN", "")
-              if not token:
-                  print("No HF_TOKEN — skipping secret push")
-                  exit(0)
-              api = HfApi(token=token)
-              repo_id = "PYAE1994/autonomous-coding-system"
-              secrets = {
-                  "GEMINI_KEY": os.environ.get("GEMINI_KEY", ""),
-                  "SAMBANOVA_KEY": os.environ.get("SAMBANOVA_KEY", ""),
-                  "GITHUB_KEY": os.environ.get("GITHUB_KEY", ""),
-                  "DB_PATH": "/data/god_agent_v11.db",
-                  "WORKSPACE_DIR": "/tmp/god_workspace",
-              }
-              for k, v in secrets.items():
-                  if v:
-                      try:
-                          api.add_space_secret(repo_id=repo_id, key=k, value=v)
-                          print(f"✓ Set secret: {k}")
-                      except Exception as e:
-                          print(f"⚠ Secret {k}: {e}")
-          except Exception as e:
-              print(f"HF secrets error: {e}")
-          EOF
-
-      - name: 🚀 Push Backend to HF Space
-        env:
-          HF_TOKEN: ${{ secrets.HF_TOKEN }}
-        run: |
-          git config --global user.email "ci@godagentos.ai"
-          git config --global user.name "God Agent OS CI"
-
-          # Clone HF space
-          git clone https://${{ env.HF_USER }}:${HF_TOKEN}@huggingface.co/spaces/${{ env.HF_SPACE }} /tmp/hf-space || true
-
-          # Copy backend files
-          rsync -av --exclude='.git' --exclude='__pycache__' --exclude='*.pyc' \
-            backend/ /tmp/hf-space/ 2>/dev/null || cp -rf backend/. /tmp/hf-space/ || true
-
-          cd /tmp/hf-space
-          git add -A
-          git diff --staged --quiet || git commit -m "🚀 Deploy God Agent OS v11 - $(date '+%Y-%m-%d %H:%M')"
-          git push https://${{ env.HF_USER }}:${HF_TOKEN}@huggingface.co/spaces/${{ env.HF_SPACE }} HEAD:main || true
-          echo "✅ HF Space deployment triggered"
-
-  # ── 2. Deploy Frontend to Vercel ────────────────────────────────────────────
-  deploy-vercel-frontend:
-    name: ▲ Deploy Frontend to Vercel
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: 🔧 Setup Node.js 20
-        uses: actions/setup-node@v4
-        with:
-          node-version: '20'
-
-      - name: 📦 Install Dependencies
-        run: |
-          cd frontend
-          npm ci --legacy-peer-deps
-
-      - name: 🏗️ Build Frontend
-        env:
-          NEXT_PUBLIC_API_URL: https://pyae1994-autonomous-coding-system.hf.space
-          NEXT_PUBLIC_WS_URL: wss://pyae1994-autonomous-coding-system.hf.space
-        run: |
-          cd frontend
-          npm run build
-
-      - name: 🚀 Deploy to Vercel
-        uses: amondnet/vercel-action@v25
-        with:
-          vercel-token: ${{ secrets.VERCEL_TOKEN }}
-          vercel-org-id: ${{ secrets.VERCEL_ORG_ID }}
-          vercel-project-id: ${{ secrets.VERCEL_PROJECT_ID }}
-          working-directory: ./frontend
-          vercel-args: '--prod'
-          github-comment: false

.gitignore

@@ -1,51 +0,0 @@
-# Dependencies
-node_modules/
-frontend/node_modules/
-__pycache__/
-*.pyc
-*.pyo
-*.pyd
-.Python
-
-# Build outputs
-frontend/.next/
-frontend/out/
-dist/
-build/
-*.egg-info/
-
-# Environment
-.env
-.env.local
-.env.production
-*.env
-
-# Logs
-*.log
-logs/
-
-# Database
-*.db
-*.sqlite
-
-# OS
-.DS_Store
-Thumbs.db
-
-# IDE
-.vscode/
-.idea/
-*.swp
-
-# Temporary
-tmp/
-temp/
-/tmp/
-
-# Python cache
-backend/__pycache__/
-backend/**/__pycache__/
-backend/ai_router/__pycache__/
-.env.keys
-backend/.env.keys
-.vercel

ARCHITECTURE.md

@@ -1,2 +0,0 @@
-# God Agent OS v9 — Space-Role Architecture
-Powered by Pyae Sone

CHANGELOG_V3.md

@@ -1,239 +0,0 @@
-# 🚀 GOD MODE+ v3.0 - Changelog
-
-## Release Date: May 14, 2026
-
-### 🎯 Major Features
-
-#### 1. Advanced AI Router with Reasoning Models ⚡
-- **New Reasoning Models Added:**
-  - DeepSeek R1 - Advanced multi-step reasoning (128K context)
-  - Qwen QwQ - Lightweight reasoning model (32K context)
-  - OpenAI o1-mini - OpenAI's reasoning model (128K context)
-  - Claude 3.5 Sonnet - Enhanced Claude reasoning (200K context)
-
-- **Smart Task-Based Routing:**
-  - Automatic task type detection (reasoning, coding, chat, analysis, creative, lightweight)
-  - Intelligent model selection based on task requirements
-  - Optimization modes: quality, speed, cost
-
-- **Enhanced Failover Chain:**
-  ```
-  Reasoning Tasks: DeepSeek R1 → Qwen QwQ → o1-mini → GPT-4o → Claude 3.5
-  Coding Tasks: GPT-4o → Claude 3.5 → DeepSeek R1 → Llama 3.3 → Mixtral
-  Chat Tasks: Llama 3.3 (FREE) → GPT-4o → Claude 3.5 → Mixtral
-  ```
-
-#### 2. New Agents (13 Total, +3 from v2)
-- **ReasoningAgent** 🧠 - Multi-step reasoning and problem decomposition
-- **OptimizationAgent** 📊 - Cost and latency optimization
-- **AnalyticsAgent** 📈 - Model performance tracking and analytics
-
-#### 3. Enhanced Backend Architecture
-- **New Dependencies:**
-  - LangChain & LangGraph for advanced orchestration
-  - Pinecone/Weaviate for vector embeddings
-  - OpenTelemetry for distributed tracing
-  - Prometheus for metrics collection
-
-- **Improved Memory System:**
-  - Vector database integration for semantic search
-  - Conversation summarization for long-term memory
-  - Efficient context retrieval
-
-- **Better Error Handling:**
-  - Circuit breaker pattern for API failures
-  - Exponential backoff with jitter
-  - Comprehensive error categorization
-
-#### 4. Frontend Modernization
-- **Upgraded to Next.js 15 & React 19**
-  - Better performance with React 19 features
-  - Improved server components
-  - Enhanced streaming capabilities
-
-- **New UI Components:**
-  - Model Performance Dashboard with real-time metrics
-  - Cost tracking visualization
-  - Agent performance analytics
-  - Prompt engineering UI builder
-
-- **Enhanced Burmese Support:**
-  - More comprehensive translations
-  - Better Burmese markdown rendering
-  - Improved keyboard shortcuts
-
-- **New Themes:**
-  - Cyberpunk theme (neon colors)
-  - Minimal theme (distraction-free)
-  - Improved theme persistence
-
-#### 5. New Connectors & Integrations
-- **LangChain Integration** - Advanced prompt management
-- **LangGraph Integration** - Workflow orchestration
-- **Together AI** - Access to open-source models
-- **Replicate** - Image generation and processing
-- **Enhanced GitHub** - PR review automation
-- **Enhanced Vercel** - Analytics integration
-
-#### 6. Performance & Observability
-- **OpenTelemetry Integration:**
-  - Distributed tracing across all services
-  - Custom metrics for agent performance
-  - Real-time system health dashboard
-
-- **Caching Strategy:**
-  - Redis caching for frequently used models
-  - Semantic caching for similar prompts
-  - Response caching for cost optimization
-
-- **Monitoring:**
-  - Real-time performance metrics
-  - Cost tracking per request
-  - Model success rate monitoring
-  - Latency analytics
-
-#### 7. Security Enhancements
-- **RBAC (Role-Based Access Control)**
-- **API Key Rotation**
-- **Audit Logging** for all operations
-- **Data Encryption** at rest
-- **GDPR Compliance** features
-
-### 📊 Performance Improvements
-
-| Metric | v2 | v3 | Improvement |
-|--------|-----|-----|-------------|
-| Response Time (p95) | 2-5s | <1s | 5-10x faster |
-| Model Options | 5 | 8+ | 60% more |
-| Agent Capabilities | 10 | 13 | 30% more |
-| Cost Optimization | Basic | Advanced | Smart routing |
-| Observability | Basic | Full | OpenTelemetry |
-| Security Score | 85/100 | 95+/100 | 10+ points |
-
-### 🔧 Technical Changes
-
-#### Backend (Python/FastAPI)
-```python
-# New AI Router v3
-from ai_router.router_v3 import AIRouterV3, TaskType
-
-router = AIRouterV3()
-task_type = router.detect_task_type("Explain quantum computing")
-model = router.select_model(task_type, optimize_for="quality")
-result = await router.route(message, context)
-```
-
-#### Frontend (React/Next.js)
-```tsx
-// New Model Performance Dashboard
-import ModelPerformanceDashboard from '@/components/dashboard/ModelPerformance';
-
-export default function Dashboard() {
-  return <ModelPerformanceDashboard />;
-}
-```
-
-### 📦 Dependency Updates
-
-**Backend:**
-- fastapi: 0.111.0 → 0.115.0
-- pydantic: 2.7.1 → 2.8.0
-- openai: 1.30.1 → 1.35.0
-- anthropic: 0.26.1 → 0.30.0
-- langchain: NEW (0.2.0)
-- langgraph: NEW (0.1.0)
-- opentelemetry: NEW (1.25.0)
-
-**Frontend:**
-- next: 14.2.3 → 15.0.0
-- react: 18.3.1 → 19.0.0
-- tailwindcss: 3.4.1 → 4.0.0
-- framer-motion: 11.1.9 → 12.0.0
-- recharts: NEW (2.12.0)
-
-### 🐛 Bug Fixes
-- Fixed WebSocket connection timeout issues
-- Improved error recovery in agent orchestration
-- Fixed memory leaks in long-running tasks
-- Better handling of concurrent requests
-
-### ⚠️ Breaking Changes
-- API v1 routes remain compatible
-- Model selection now automatic (can be overridden)
-- Some environment variables renamed for clarity
-
-### 🔄 Migration Guide
-
-**For Users:**
-1. No action required - automatic upgrade
-2. New reasoning models available via chat
-3. Cost tracking visible in dashboard
-4. Performance improvements automatic
-
-**For Developers:**
-1. Update dependencies: `pip install -r requirements_v3.txt`
-2. Use new AIRouterV3 for advanced routing
-3. Register new agents in orchestrator
-4. Update environment variables (see docs)
-
-### 📚 Documentation
-- [AI Router v3 Guide](./docs/ai-router-v3.md)
-- [New Agents Documentation](./docs/agents-v3.md)
-- [Performance Dashboard Guide](./docs/dashboard.md)
-- [Migration Guide](./docs/migration-v3.md)
-
-### 🎯 Next Steps (v4 Roadmap)
-- Multi-modal reasoning (vision + text)
-- Fine-tuning support for custom models
-- Advanced workflow automation
-- Mobile app support
-- Enterprise features (SSO, advanced RBAC)
-
-### 🙏 Credits
-- Built with ❤️ by the GOD MODE+ team
-- Powered by OpenAI, Anthropic, DeepSeek, Qwen, and community models
-- Special thanks to Vercel, HuggingFace, and Groq
-
----
-
-## Installation & Deployment
-
-### Local Development
-```bash
-# Backend
-cd backend
-pip install -r requirements_v3.txt
-export GROQ_API_KEY="your-key"
-uvicorn main:app --reload
-
-# Frontend
-cd frontend
-npm install
-npm run dev
-```
-
-### Production Deployment (Vercel)
-```bash
-# Push to GitHub
-git add .
-git commit -m "🚀 GOD MODE+ v3.0 upgrade"
-git push origin main
-
-# Vercel auto-deploys
-# Check: https://vercel.com/devin-agent-v2-ui
-```
-
-### Docker
-```bash
-# Build
-docker build -t god-mode-v3 .
-
-# Run
-docker run -p 8000:8000 -p 3000:3000 god-mode-v3
-```
-
----
-
-**Version:** 3.0.0  
-**Status:** 🟢 Production Ready  
-**Last Updated:** May 14, 2026

Dockerfile

@@ -1,28 +0,0 @@
-# God Agent OS — Phase 1 backend (FastAPI + E2B + SSE)
-FROM python:3.11-slim
-
-WORKDIR /app
-
-# System deps (curl for healthcheck, git for any sandbox-side workflows)
-RUN apt-get update && apt-get install -y --no-install-recommends \
-    curl ca-certificates git \
- && rm -rf /var/lib/apt/lists/*
-
-# Python deps
-COPY requirements.txt /app/requirements.txt
-RUN pip install --no-cache-dir --upgrade pip \
- && pip install --no-cache-dir -r /app/requirements.txt
-
-# App code
-COPY . /app
-
-ENV PORT=7860 \
-    PYTHONUNBUFFERED=1 \
-    PYTHONPATH=/app
-
-EXPOSE 7860
-
-HEALTHCHECK --interval=30s --timeout=10s --start-period=20s --retries=3 \
-  CMD curl -fsS http://localhost:7860/health || exit 1
-
-CMD ["python", "-m", "uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860", "--workers", "1", "--log-level", "info", "--no-access-log"]

Dockerfile.hf

@@ -1,25 +0,0 @@
-# God Agent OS — Phase 1 backend for HuggingFace Spaces
-FROM python:3.11-slim
-
-WORKDIR /app
-
-RUN apt-get update && apt-get install -y --no-install-recommends \
-    curl ca-certificates git \
- && rm -rf /var/lib/apt/lists/*
-
-COPY requirements.txt /app/requirements.txt
-RUN pip install --no-cache-dir --upgrade pip \
- && pip install --no-cache-dir -r /app/requirements.txt
-
-COPY . /app
-
-ENV PORT=7860 \
-    PYTHONUNBUFFERED=1 \
-    PYTHONPATH=/app
-
-EXPOSE 7860
-
-HEALTHCHECK --interval=30s --timeout=10s --start-period=30s --retries=3 \
-  CMD curl -fsS http://localhost:7860/health || exit 1
-
-CMD ["python", "-m", "uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860", "--workers", "1", "--log-level", "info"]

README.md

@@ -1,4 +1,3 @@
----
 title: Autonomous Coding System
 emoji: 🤖
 colorFrom: purple
@@ -41,3 +40,5 @@ Set these in HF Space secrets:
 - `GITHUB_TOKEN` — GitHub token for Git operations
 - `HF_TOKEN` — HuggingFace token
 - `VERCEL_TOKEN` — Vercel deploy token
+
+Migrated from GitHub `sc8jd98v5k-lgtm/Autonomous-coding-system`.

V3_UPGRADE_PLAN.md

@@ -1,264 +0,0 @@
-# 🚀 GOD MODE+ v3 Upgrade Plan
-
-## Current Status
-- **Version**: v2.0 (Latest deployment on Vercel)
-- **Agents**: 10 specialized agents (Chat, Planner, Coding, Debug, Memory, Connector, Deploy, Workflow, Sandbox, UI)
-- **AI Providers**: 5 (OpenAI, Groq, Cerebras, OpenRouter, Anthropic)
-- **Connectors**: 13 (GitHub, HuggingFace, Vercel, n8n, Telegram, Discord, Slack, Cloudflare, etc.)
-- **UI**: Manus-style layout + 5 themes + Burmese language support
-
----
-
-## V3 Upgrade Roadmap
-
-### Phase 1: Advanced AI Router Enhancement ⚡
-**Goal**: Add reasoning models and improve model selection strategy
-
-#### 1.1 Add Reasoning Models
-- **DeepSeek R1** - Advanced reasoning capabilities
-- **Qwen QwQ** - Lightweight reasoning model
-- **OpenAI o1-mini** - OpenAI's reasoning model
-- **Claude 3.5 Sonnet** - Enhanced reasoning from Anthropic
-
-#### 1.2 Implement Smart Model Router
-```python
-# New routing logic:
-1. Detect task type (reasoning, coding, chat, etc.)
-2. Select optimal model based on:
-   - Task complexity
-   - Required latency
-   - Cost optimization
-   - Context length requirements
-3. Fallback chain with reasoning models first for complex tasks
-```
-
-#### 1.3 Update AI Router Priority Chain
-```
-For Reasoning Tasks:
-  DeepSeek R1 → OpenAI o1-mini → Claude 3.5 → Groq Llama
-
-For Coding Tasks:
-  OpenAI GPT-4o → Claude 3.5 → Groq Llama 3.3 70B
-
-For Chat Tasks:
-  Groq (FREE) → OpenAI → Claude 3.5 → Cerebras
-
-For Lightweight Tasks:
-  Groq → OpenRouter (Free) → Cerebras
-```
-
----
-
-### Phase 2: Backend Enhancements 🔧
-
-#### 2.1 Update Dependencies
-```
-# Key updates:
-- fastapi: 0.111.0 → 0.115.0+
-- pydantic: 2.7.1 → 2.8.0+
-- openai: 1.30.1 → 1.35.0+ (for o1 support)
-- anthropic: 0.26.1 → 0.30.0+ (for Claude 3.5)
-- langchain or similar: Add for better prompt engineering
-```
-
-#### 2.2 New Agent Capabilities
-- **ReasoningAgent**: Dedicated agent for complex reasoning tasks
-- **OptimizationAgent**: Cost and latency optimization
-- **AnalyticsAgent**: Track model performance and costs
-- **KnowledgeAgent**: Long-context document processing
-
-#### 2.3 Enhanced Memory System
-- Add vector database support (Pinecone, Weaviate, or local embeddings)
-- Implement semantic search for better context retrieval
-- Add conversation summarization for long-term memory
-
-#### 2.4 Improved Error Handling & Self-Healing
-- Implement exponential backoff with jitter
-- Add circuit breaker pattern for API failures
-- Better error categorization and recovery strategies
-
----
-
-### Phase 3: Frontend Modernization 🎨
-
-#### 3.1 Upgrade Dependencies
-```json
-{
-  "next": "14.2.3 → 15.0.0+",
-  "react": "18.3.1 → 19.0.0+",
-  "tailwindcss": "3.4.1 → 4.0.0+",
-  "framer-motion": "11.1.9 → 12.0.0+"
-}
-```
-
-#### 3.2 New UI Features
-- **Model Selection Dashboard**: Visual model performance metrics
-- **Real-time Cost Tracking**: Show API costs per request
-- **Advanced Analytics**: Agent performance, success rates, latency
-- **Prompt Engineering UI**: Visual prompt builder with templates
-- **Reasoning Visualization**: Show reasoning steps for complex tasks
-
-#### 3.3 Enhanced Burmese Support
-- Add more Burmese translations for new features
-- Improve Burmese markdown rendering
-- Add Burmese keyboard shortcuts
-
-#### 3.4 New Themes
-- Add "Cyberpunk" theme (requested by users)
-- Add "Minimal" theme for distraction-free mode
-- Improve theme switching with local persistence
-
----
-
-### Phase 4: Connector System Expansion 🔌
-
-#### 4.1 New Connectors
-- **LangChain Integration**: Better prompt management
-- **LangGraph Integration**: Advanced workflow orchestration
-- **Anthropic Models API**: Direct Claude integration
-- **Together AI**: Access to open-source models
-- **Replicate**: For image generation and processing
-
-#### 4.2 Enhanced Existing Connectors
-- **GitHub**: Add PR review automation, code analysis
-- **Vercel**: Add analytics integration, performance monitoring
-- **HuggingFace**: Add model fine-tuning capabilities
-- **n8n**: Add more workflow templates
-
----
-
-### Phase 5: Performance & Observability 📊
-
-#### 5.1 Monitoring & Logging
-- Add OpenTelemetry integration
-- Implement distributed tracing
-- Add custom metrics for agent performance
-- Real-time dashboard for system health
-
-#### 5.2 Caching Strategy
-- Implement Redis caching for frequently used models
-- Add semantic caching for similar prompts
-- Cache model responses for cost optimization
-
-#### 5.3 Load Testing & Optimization
-- Benchmark all agents under load
-- Optimize WebSocket message handling
-- Implement request batching for API calls
-
----
-
-### Phase 6: Security Hardening 🔒
-
-#### 6.1 Authentication & Authorization
-- Add role-based access control (RBAC)
-- Implement API key rotation
-- Add audit logging for all operations
-
-#### 6.2 Data Protection
-- Encrypt sensitive data at rest
-- Add data retention policies
-- Implement GDPR compliance
-
-#### 6.3 Rate Limiting & DDoS Protection
-- Enhance rate limiting per user/API key
-- Add IP-based rate limiting
-- Implement request validation
-
----
-
-### Phase 7: Deployment & DevOps 🚀
-
-#### 7.1 Docker Optimization
-- Multi-stage builds for smaller images
-- Add health checks and graceful shutdown
-- Implement zero-downtime deployments
-
-#### 7.2 Vercel Deployment
-- Add environment-specific configurations
-- Implement canary deployments
-- Add automated rollback on failures
-
-#### 7.3 CI/CD Pipeline
-- Add automated testing (unit, integration, e2e)
-- Implement code quality checks (SonarQube, CodeClimate)
-- Add performance benchmarking in CI
-
----
-
-## Implementation Timeline
-
-| Phase | Duration | Priority |
-|-------|----------|----------|
-| Phase 1: AI Router Enhancement | 2-3 days | 🔴 Critical |
-| Phase 2: Backend Enhancements | 3-4 days | 🔴 Critical |
-| Phase 3: Frontend Modernization | 2-3 days | 🟡 High |
-| Phase 4: Connector Expansion | 2-3 days | 🟡 High |
-| Phase 5: Performance & Observability | 2-3 days | 🟠 Medium |
-| Phase 6: Security Hardening | 2-3 days | 🟠 Medium |
-| Phase 7: Deployment & DevOps | 1-2 days | 🟡 High |
-
-**Total Estimated Time**: 14-21 days
-
----
-
-## Key Metrics for v3
-
-| Metric | v2 | v3 Target |
-|--------|-----|-----------|
-| Model Options | 5 AI providers | 8+ AI providers + reasoning models |
-| Agent Capabilities | 10 agents | 13+ agents (new: Reasoning, Optimization, Analytics, Knowledge) |
-| Response Time | ~2-5s | <1s (with caching) |
-| Cost Optimization | Basic | Advanced (smart model selection) |
-| Observability | Basic logging | Full OpenTelemetry integration |
-| Security Score | 85/100 | 95+/100 |
-
----
-
-## Testing Strategy
-
-### Unit Tests
-- Test each agent independently
-- Test AI router logic
-- Test connector integrations
-
-### Integration Tests
-- Test agent orchestration
-- Test WebSocket communication
-- Test end-to-end workflows
-
-### Performance Tests
-- Load test with 100+ concurrent users
-- Benchmark model response times
-- Test memory usage under stress
-
-### Security Tests
-- Penetration testing
-- API security audit
-- Data protection verification
-
----
-
-## Rollback Plan
-
-1. Keep v2 deployment running during v3 development
-2. Use canary deployments (5% → 25% → 50% → 100%)
-3. Monitor error rates and performance metrics
-4. Automatic rollback if error rate > 5%
-5. Manual rollback option always available
-
----
-
-## Success Criteria
-
-✅ All 13 agents operational and tested
-✅ 8+ AI providers integrated with reasoning models
-✅ Response time < 1s for 95% of requests
-✅ 99.9% uptime
-✅ Zero security vulnerabilities
-✅ Full test coverage > 80%
-✅ Improved user satisfaction (NPS > 50)
-
----
-
-*Last Updated: May 14, 2026*
-*Status: Planning Phase*

_legacy/main.py

@@ -1,310 +0,0 @@
-"""
-🚀 GOD AGENT OS — Autonomous AI Operating System v8
-Gemini + Sambanova + GitHub Models — Primary Provider Rotation
-Task-aware routing: research→Gemini, code→Sambanova, plan→GitHub
-"""
-
-# ─── Inject bundled API keys (env vars take precedence) ───────────────────────
-import os as _os
-
-def _inject_key(env_var: str, value: str):
-    """Set env var only if not already configured."""
-    if not _os.environ.get(env_var):
-        _os.environ[env_var] = value
-
-# Keys are loaded from HF Space Secrets / Docker env vars.
-# Set GEMINI_KEY, SAMBANOVA_KEY, GITHUB_KEY as comma-separated lists.
-# Fallback: read from .env.keys file if present (not committed to git).
-_keys_file = _os.path.join(_os.path.dirname(__file__), ".env.keys")
-if _os.path.exists(_keys_file):
-    with open(_keys_file) as _f:
-        for _line in _f:
-            _line = _line.strip()
-            if _line and "=" in _line and not _line.startswith("#"):
-                _k, _v = _line.split("=", 1)
-                _inject_key(_k.strip(), _v.strip())
-# ─────────────────────────────────────────────────────────────────────────────
-
-
-import asyncio
-import json
-import logging
-import os
-import time
-import uuid
-from contextlib import asynccontextmanager
-from typing import Optional
-
-import structlog
-from fastapi import FastAPI, WebSocket, WebSocketDisconnect, HTTPException, Request
-from fastapi.middleware.cors import CORSMiddleware
-from fastapi.middleware.gzip import GZipMiddleware
-from fastapi.responses import JSONResponse
-from slowapi import Limiter, _rate_limit_exceeded_handler
-from slowapi.util import get_remote_address
-from slowapi.errors import RateLimitExceeded
-
-from api.routes import tasks, chat, memory, github, health
-from api.routes import connectors, agents as agents_router
-from api.websocket_manager import WebSocketManager
-from core.task_engine import TaskEngine
-from memory.db import init_db
-
-# ─── God Mode Agents ───────────────────────────────────────────────────────────
-from ai_router.router import AIRouter
-from ai_router.router_v8 import GodModeRouter, get_router as get_god_router
-from agents.orchestrator import GodAgentOrchestrator
-from agents.chat_agent import ChatAgent
-from agents.planner_agent import PlannerAgent
-from agents.coding_agent import CodingAgent
-from agents.debug_agent import DebugAgent
-from agents.memory_agent import MemoryAgent
-from agents.connector_agent import ConnectorAgent
-from agents.deploy_agent import DeployAgent
-from agents.workflow_agent import WorkflowAgent
-from agents.sandbox_agent import SandboxAgent
-from agents.ui_agent import UIAgent
-from connectors.manager import ConnectorManager
-
-# ─── Structured Logging ────────────────────────────────────────────────────────
-structlog.configure(
-    processors=[
-        structlog.processors.TimeStamper(fmt="iso"),
-        structlog.stdlib.add_log_level,
-        structlog.processors.StackInfoRenderer(),
-        structlog.dev.ConsoleRenderer(),
-    ]
-)
-log = structlog.get_logger()
-
-# ─── Rate Limiter ──────────────────────────────────────────────────────────────
-limiter = Limiter(key_func=get_remote_address)
-
-# ─── Global Managers ──────────────────────────────────────────────────────────
-ws_manager = WebSocketManager()
-task_engine = TaskEngine(ws_manager)
-ai_router = AIRouter(ws_manager)
-god_router = get_god_router(ws_manager)   # v8 primary router
-connector_manager = ConnectorManager()
-
-# ─── Build God Agent Ecosystem ────────────────────────────────────────────────
-def build_orchestrator() -> GodAgentOrchestrator:
-    orchestrator = GodAgentOrchestrator(ws_manager=ws_manager, ai_router=ai_router)
-
-    # Register all specialized agents
-    orchestrator.register_agent("chat",      ChatAgent(ws_manager, ai_router))
-    orchestrator.register_agent("planner",   PlannerAgent(ws_manager, ai_router))
-    orchestrator.register_agent("coding",    CodingAgent(ws_manager, ai_router))
-    orchestrator.register_agent("debug",     DebugAgent(ws_manager, ai_router))
-    orchestrator.register_agent("memory",    MemoryAgent(ws_manager, ai_router))
-    orchestrator.register_agent("connector", ConnectorAgent(ws_manager, ai_router))
-    orchestrator.register_agent("deploy",    DeployAgent(ws_manager, ai_router))
-    orchestrator.register_agent("workflow",  WorkflowAgent(ws_manager, ai_router))
-    orchestrator.register_agent("sandbox",   SandboxAgent(ws_manager, ai_router))
-    orchestrator.register_agent("ui",        UIAgent(ws_manager, ai_router))
-
-    log.info("🤖 God Agent Ecosystem initialized", agents=10)
-    return orchestrator
-
-orchestrator = build_orchestrator()
-
-
-@asynccontextmanager
-async def lifespan(app: FastAPI):
-    """Startup + Shutdown lifecycle."""
-    log.info("🚀 Starting GOD MODE+ AI Operating System...")
-    await init_db()
-    await task_engine.start()
-    asyncio.create_task(ws_manager.heartbeat_loop())
-    log.info("✅ GOD MODE+ Platform ready — All agents online")
-    log.info("🤖 Agents: Chat, Planner, Coding, Debug, Memory, Connector, Deploy, Workflow, Sandbox, UI")
-    log.info("🌐 AI Router v8: Gemini → Sambanova → GitHub Models (task-aware rotation)")
-    yield
-    log.info("🛑 Shutting down...")
-    await task_engine.stop()
-    log.info("✅ Shutdown complete")
-
-
-# ─── FastAPI App ───────────────────────────────────────────────────────────────
-app = FastAPI(
-    title="🤖 GOD MODE+ AI Operating System",
-    description="Devin + Manus + Genspark Autonomous AI Engineering Platform",
-    version="3.0.0",
-    lifespan=lifespan,
-    docs_url="/api/docs",
-    redoc_url="/api/redoc",
-)
-
-app.state.limiter = limiter
-app.add_exception_handler(RateLimitExceeded, _rate_limit_exceeded_handler)
-
-# ─── Share state ───────────────────────────────────────────────────────────────
-app.state.ws_manager = ws_manager
-app.state.task_engine = task_engine
-app.state.ai_router = ai_router
-app.state.orchestrator = orchestrator
-app.state.connector_manager = connector_manager
-
-# ─── Middleware ────────────────────────────────────────────────────────────────
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-app.add_middleware(GZipMiddleware, minimum_size=1000)
-
-
-@app.middleware("http")
-async def log_requests(request: Request, call_next):
-    start = time.time()
-    response = await call_next(request)
-    duration = round((time.time() - start) * 1000, 2)
-    log.info("HTTP", method=request.method, path=request.url.path, status=response.status_code, ms=duration)
-    return response
-
-
-# ─── REST API Routers ──────────────────────────────────────────────────────────
-app.include_router(health.router,             prefix="/api/v1",              tags=["health"])
-app.include_router(tasks.router,              prefix="/api/v1/tasks",        tags=["tasks"])
-app.include_router(chat.router,               prefix="/api/v1",              tags=["chat"])
-app.include_router(memory.router,             prefix="/api/v1/memory",       tags=["memory"])
-app.include_router(github.router,             prefix="/api/v1/github",       tags=["github"])
-app.include_router(connectors.router,         prefix="/api/v1/connectors",   tags=["connectors"])
-app.include_router(agents_router.router,      prefix="/api/v1/agents",       tags=["agents"])
-
-
-# ─── WebSocket Endpoints ───────────────────────────────────────────────────────
-@app.websocket("/ws/tasks/{task_id}")
-async def ws_task(websocket: WebSocket, task_id: str):
-    await ws_manager.connect(websocket, room=f"task:{task_id}")
-    try:
-        while True:
-            data = await websocket.receive_text()
-            msg = json.loads(data)
-            if msg.get("type") == "ping":
-                await websocket.send_json({"type": "pong", "timestamp": time.time()})
-    except WebSocketDisconnect:
-        ws_manager.disconnect(websocket, room=f"task:{task_id}")
-
-
-@app.websocket("/ws/logs")
-async def ws_logs(websocket: WebSocket):
-    await ws_manager.connect(websocket, room="logs")
-    try:
-        while True:
-            data = await websocket.receive_text()
-            msg = json.loads(data)
-            if msg.get("type") == "ping":
-                await websocket.send_json({"type": "pong", "timestamp": time.time()})
-    except WebSocketDisconnect:
-        ws_manager.disconnect(websocket, room="logs")
-
-
-@app.websocket("/ws/chat/{session_id}")
-async def ws_chat(websocket: WebSocket, session_id: str):
-    await ws_manager.connect(websocket, room=f"chat:{session_id}")
-    try:
-        while True:
-            data = await websocket.receive_text()
-            msg = json.loads(data)
-            if msg.get("type") == "ping":
-                await websocket.send_json({"type": "pong", "timestamp": time.time()})
-            elif msg.get("type") == "chat_message":
-                # Route through God Agent Orchestrator
-                asyncio.create_task(
-                    orchestrator.orchestrate(
-                        user_message=msg.get("content", ""),
-                        session_id=session_id,
-                        context=msg.get("context", {}),
-                    )
-                )
-            elif msg.get("type") == "task_message":
-                # Create autonomous task via task engine
-                from core.models import TaskCreateRequest
-                req = TaskCreateRequest(
-                    goal=msg.get("content", ""),
-                    session_id=session_id,
-                )
-                asyncio.create_task(task_engine.submit(req))
-    except WebSocketDisconnect:
-        ws_manager.disconnect(websocket, room=f"chat:{session_id}")
-
-
-@app.websocket("/ws/agent/status")
-async def ws_agent_status(websocket: WebSocket):
-    await ws_manager.connect(websocket, room="agent_status")
-    try:
-        while True:
-            data = await websocket.receive_text()
-            msg = json.loads(data)
-            if msg.get("type") == "ping":
-                await websocket.send_json({"type": "pong", "timestamp": time.time()})
-            elif msg.get("type") == "get_status":
-                await websocket.send_json({
-                    "type": "agent_status",
-                    "data": orchestrator.get_status(),
-                })
-    except WebSocketDisconnect:
-        ws_manager.disconnect(websocket, room="agent_status")
-
-
-@app.websocket("/ws/sandbox/{session_id}")
-async def ws_sandbox(websocket: WebSocket, session_id: str):
-    """Live sandbox terminal stream."""
-    await ws_manager.connect(websocket, room=f"sandbox:{session_id}")
-    sandbox = orchestrator.get_agent("sandbox")
-    try:
-        while True:
-            data = await websocket.receive_text()
-            msg = json.loads(data)
-            if msg.get("type") == "ping":
-                await websocket.send_json({"type": "pong", "timestamp": time.time()})
-            elif msg.get("type") == "execute" and sandbox:
-                cmd = msg.get("command", "")
-                result = await sandbox.execute(cmd, session_id=session_id)
-                await websocket.send_json({
-                    "type": "terminal_output",
-                    "command": cmd,
-                    "output": result,
-                    "timestamp": time.time(),
-                })
-    except WebSocketDisconnect:
-        ws_manager.disconnect(websocket, room=f"sandbox:{session_id}")
-
-
-# ─── Root ──────────────────────────────────────────────────────────────────────
-@app.get("/")
-async def root():
-    cs = connector_manager.get_summary()
-    return {
-        "name": "🤖 GOD MODE+ AI Operating System",
-        "version": "3.0.0",
-        "status": "operational",
-        "mode": "god_mode_plus",
-        "agents": orchestrator.get_status()["agents"],
-        "connectors": {
-            "connected": cs["connected"],
-            "total": cs["total"],
-            "ai_ready": cs["ai_ready"],
-        },
-        "docs": "/api/docs",
-        "websockets": [
-            "/ws/tasks/{task_id}",
-            "/ws/logs",
-            "/ws/chat/{session_id}",
-            "/ws/agent/status",
-            "/ws/sandbox/{session_id}",
-        ],
-        "phases_complete": [
-            "Phase 1: God Agent Orchestrator",
-            "Phase 2: Sandbox Agent",
-            "Phase 3: Connector System",
-            "Phase 4: Autonomous Coding Engine",
-            "Phase 5: Memory System",
-            "Phase 6: Real-time Streaming",
-            "Phase 7: Workflow Factor OS",
-            "Phase 9: Multi-Model AI Router",
-        ],
-    }

_legacy/main_v11.py

@@ -1,442 +0,0 @@
-"""
-GOD AGENT OS v11 — Fixed & Production Ready
-Bugs fixed:
-- TaskEngine(ws_manager) only — removed ai_router arg
-- init_db() — no arguments
-- task_engine.start() — not run()
-- ws_manager.emit_chat() — not emit_task()
-- ConnectorManager() — sync init, no await needed
-"""
-
-import asyncio
-import json
-import os
-import time
-import uuid
-from contextlib import asynccontextmanager
-from typing import Dict, List
-
-import structlog
-from fastapi import FastAPI, WebSocket, WebSocketDisconnect, HTTPException, Request
-from fastapi.middleware.cors import CORSMiddleware
-from fastapi.middleware.gzip import GZipMiddleware
-from fastapi.responses import StreamingResponse
-from slowapi import Limiter, _rate_limit_exceeded_handler
-from slowapi.util import get_remote_address
-from slowapi.errors import RateLimitExceeded
-
-from api.websocket_manager import WebSocketManager
-from core.task_engine import TaskEngine
-from memory.db import init_db
-from ai_router.router_v10 import AIRouterV10
-from agents.orchestrator_v7 import GodAgentOrchestratorV7
-from agents.chat_agent import ChatAgent
-from agents.planner_agent import PlannerAgent
-from agents.coding_agent import CodingAgent
-from agents.debug_agent import DebugAgent
-from agents.memory_agent import MemoryAgent
-from agents.connector_agent import ConnectorAgent
-from agents.deploy_agent import DeployAgent
-from agents.workflow_agent import WorkflowAgent
-from agents.sandbox_agent import SandboxAgent
-from agents.ui_agent import UIAgent
-from agents.reasoning_agent import ReasoningAgent
-from agents.browser_agent import BrowserAgent
-from agents.file_agent import FileAgent
-from agents.git_agent import GitAgent
-from agents.test_agent import TestAgent
-from agents.vision_agent import VisionAgent
-from connectors.manager import ConnectorManager
-from api.routes import tasks, chat, memory, health, connectors, agents as agents_router
-from api.routes import github
-
-structlog.configure(
-    processors=[
-        structlog.processors.TimeStamper(fmt="iso"),
-        structlog.stdlib.add_log_level,
-        structlog.processors.StackInfoRenderer(),
-        structlog.dev.ConsoleRenderer(),
-    ]
-)
-log = structlog.get_logger()
-
-limiter = Limiter(key_func=get_remote_address)
-
-ws_manager: WebSocketManager = None
-task_engine: TaskEngine = None
-ai_router: AIRouterV10 = None
-orchestrator: GodAgentOrchestratorV7 = None
-connector_manager: ConnectorManager = None
-
-computer_use_sessions: Dict[str, List[Dict]] = {}
-
-
-def add_computer_use_step(session_id: str, step_type: str, data: Dict):
-    if session_id not in computer_use_sessions:
-        computer_use_sessions[session_id] = []
-    computer_use_sessions[session_id].append({
-        "id": uuid.uuid4().hex[:8],
-        "type": step_type,
-        "data": data,
-        "timestamp": time.time(),
-        "status": "running",
-    })
-    computer_use_sessions[session_id] = computer_use_sessions[session_id][-100:]
-
-
-@asynccontextmanager
-async def lifespan(app: FastAPI):
-    global ws_manager, task_engine, ai_router, orchestrator, connector_manager
-
-    log.info("GOD AGENT OS v11 starting...")
-
-    # FIX: init_db() takes no arguments
-    await init_db()
-
-    ai_router = AIRouterV10()
-    ws_manager = WebSocketManager()
-
-    # FIX: TaskEngine only takes ws_manager
-    task_engine = TaskEngine(ws_manager)
-
-    orchestrator = GodAgentOrchestratorV7(ws_manager, ai_router)
-    agents_map = {
-        "chat":      ChatAgent(ws_manager, ai_router),
-        "planner":   PlannerAgent(ws_manager, ai_router),
-        "coding":    CodingAgent(ws_manager, ai_router),
-        "debug":     DebugAgent(ws_manager, ai_router),
-        "memory":    MemoryAgent(ws_manager, ai_router),
-        "connector": ConnectorAgent(ws_manager, ai_router),
-        "deploy":    DeployAgent(ws_manager, ai_router),
-        "workflow":  WorkflowAgent(ws_manager, ai_router),
-        "sandbox":   SandboxAgent(ws_manager, ai_router),
-        "ui":        UIAgent(ws_manager, ai_router),
-        "reasoning": ReasoningAgent(ws_manager, ai_router),
-        "browser":   BrowserAgent(ws_manager, ai_router),
-        "file":      FileAgent(ws_manager, ai_router),
-        "git":       GitAgent(ws_manager, ai_router),
-        "test":      TestAgent(ws_manager, ai_router),
-        "vision":    VisionAgent(ws_manager, ai_router),
-    }
-    for name, agent in agents_map.items():
-        orchestrator.register_agent(name, agent)
-
-    # FIX: ConnectorManager is sync — no await initialize()
-    connector_manager = ConnectorManager()
-
-    app.state.ws_manager = ws_manager
-    app.state.task_engine = task_engine
-    app.state.ai_router = ai_router
-    app.state.orchestrator = orchestrator
-    app.state.connector_manager = connector_manager
-
-    # FIX: use start() not run()
-    asyncio.create_task(task_engine.start())
-
-    log.info("GOD AGENT OS v11 ready!", agents=len(agents_map))
-    yield
-
-    log.info("Shutting down...")
-    await task_engine.stop()
-
-
-app = FastAPI(
-    title="GOD AGENT OS v11",
-    description="Autonomous Engineering OS",
-    version="11.0.0",
-    docs_url="/api/docs",
-    redoc_url="/api/redoc",
-    lifespan=lifespan,
-)
-
-app.state_limiter = limiter
-app.add_exception_handler(RateLimitExceeded, _rate_limit_exceeded_handler)
-app.add_middleware(GZipMiddleware, minimum_size=1000)
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-
-app.include_router(health.router, prefix="/api/v1", tags=["health"])
-app.include_router(chat.router, prefix="/api/v1", tags=["chat"])
-app.include_router(tasks.router, prefix="/api/v1/tasks", tags=["tasks"])
-app.include_router(memory.router, prefix="/api/v1/memory", tags=["memory"])
-app.include_router(connectors.router, prefix="/api/v1/connectors", tags=["connectors"])
-app.include_router(agents_router.router, prefix="/api/v1/agents", tags=["agents"])
-app.include_router(github.router, prefix="/api/v1/github", tags=["github"])
-
-
-@app.websocket("/ws/{session_id}")
-async def websocket_endpoint(websocket: WebSocket, session_id: str):
-    # FIX: connect takes (websocket, room) — use chat: prefix
-    await ws_manager.connect(websocket, f"chat:{session_id}")
-    try:
-        while True:
-            data = await websocket.receive_json()
-            event_type = data.get("type", "")
-
-            if event_type == "ping":
-                await websocket.send_json({"type": "pong", "ts": time.time()})
-
-            elif event_type == "message":
-                message = data.get("message", "")
-                task_id = uuid.uuid4().hex[:12]
-                # FIX: use emit_chat() not emit_task()
-                await ws_manager.emit_chat(session_id, "task_start", {
-                    "task_id": task_id,
-                    "message": message[:100],
-                })
-                asyncio.create_task(_run_ws_task(message, task_id, session_id))
-
-            elif event_type == "stop":
-                task_id = data.get("task_id", "")
-                if task_id:
-                    await task_engine.cancel(task_id)
-
-    except WebSocketDisconnect:
-        ws_manager.disconnect(websocket, f"chat:{session_id}")
-
-
-async def _run_ws_task(message: str, task_id: str, session_id: str):
-    try:
-        result = await orchestrator.orchestrate(
-            user_message=message,
-            task_id=task_id,
-            session_id=session_id,
-        )
-        await ws_manager.emit_chat(session_id, "task_complete", {
-            "task_id": task_id,
-            "result": result[:2000] if result else "",
-        })
-    except Exception as e:
-        await ws_manager.emit_chat(session_id, "task_error", {
-            "task_id": task_id,
-            "error": str(e),
-        })
-
-
-@app.get("/api/v1/computer-use/{session_id}")
-async def get_computer_use_steps(session_id: str):
-    steps = computer_use_sessions.get(session_id, [])
-    return {"session_id": session_id, "steps": steps, "count": len(steps)}
-
-
-@app.websocket("/ws/computer-use/{session_id}")
-async def computer_use_ws(websocket: WebSocket, session_id: str):
-    await websocket.accept()
-    try:
-        last_idx = 0
-        while True:
-            steps = computer_use_sessions.get(session_id, [])
-            if len(steps) > last_idx:
-                for step in steps[last_idx:]:
-                    await websocket.send_json({"type": "computer_use_step", "step": step})
-                last_idx = len(steps)
-            await asyncio.sleep(0.5)
-    except WebSocketDisconnect:
-        pass
-
-
-@app.post("/api/v1/orchestrate")
-async def orchestrate_goal(request: Request):
-    body = await request.json()
-    message = body.get("message", "")
-    session_id = body.get("session_id", uuid.uuid4().hex[:12])
-
-    if not message:
-        raise HTTPException(status_code=400, detail="Message required")
-
-    task_id = uuid.uuid4().hex[:12]
-    add_computer_use_step(session_id, "thinking", {
-        "message": f"Processing: {message[:100]}",
-        "task_id": task_id,
-    })
-
-    if body.get("stream", False):
-        async def stream_gen():
-            try:
-                result = await orchestrator.orchestrate(
-                    user_message=message, task_id=task_id, session_id=session_id,
-                )
-                add_computer_use_step(session_id, "complete", {"result": result[:200] if result else ""})
-                yield f"data: {json.dumps({'type': 'complete', 'result': result, 'task_id': task_id, 'session_id': session_id})}\n\n"
-            except Exception as e:
-                yield f"data: {json.dumps({'type': 'error', 'error': str(e)})}\n\n"
-
-        return StreamingResponse(
-            stream_gen(),
-            media_type="text/event-stream",
-            headers={"Cache-Control": "no-cache", "X-Accel-Buffering": "no"},
-        )
-
-    try:
-        result = await orchestrator.orchestrate(user_message=message, task_id=task_id, session_id=session_id)
-        add_computer_use_step(session_id, "complete", {"result": result[:200] if result else ""})
-        return {"task_id": task_id, "session_id": session_id, "result": result, "status": "complete"}
-    except Exception as e:
-        log.error("Orchestration error", error=str(e))
-        raise HTTPException(status_code=500, detail=str(e))
-
-
-@app.post("/api/v1/agents/{agent_name}/run")
-async def run_agent(agent_name: str, request: Request):
-    body = await request.json()
-    task = body.get("task", "")
-    session_id = body.get("session_id", uuid.uuid4().hex[:12])
-    task_id = uuid.uuid4().hex[:12]
-
-    agent = orchestrator.get_agent(agent_name)
-    if not agent:
-        raise HTTPException(status_code=404, detail=f"Agent '{agent_name}' not found")
-
-    try:
-        result = await agent.run(
-            task=task,
-            context=body.get("context", {}),
-            task_id=task_id,
-            session_id=session_id,
-        )
-        return {"agent": agent_name, "task_id": task_id, "result": result, "status": "complete"}
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
-
-
-@app.get("/api/v1/agents")
-async def list_agents():
-    names = ["chat", "planner", "coding", "debug", "memory", "connector",
-             "deploy", "workflow", "sandbox", "ui", "reasoning",
-             "browser", "file", "git", "test", "vision"]
-    agents_list = []
-    for name in names:
-        agent = orchestrator.get_agent(name)
-        agents_list.append({
-            "name": name,
-            "available": agent is not None,
-            "class": type(agent).__name__ if agent else None,
-        })
-    return {"agents": agents_list, "total": len(agents_list)}
-
-
-SPACE_DEFS = [
-    {"id": "god-core",        "name": "God Core Space",      "role": "orchestration",   "agent": "orchestrator", "icon": "🧠"},
-    {"id": "coding",          "name": "Coding Worker",        "role": "code_generation", "agent": "coding",       "icon": "⚡"},
-    {"id": "sandbox",         "name": "Sandbox Worker",       "role": "execution",       "agent": "sandbox",      "icon": "🔧"},
-    {"id": "terminal",        "name": "Terminal Worker",      "role": "execution",       "agent": "sandbox",      "icon": "🖥️"},
-    {"id": "filesystem",      "name": "FileSystem Worker",    "role": "files",           "agent": "file",         "icon": "📁"},
-    {"id": "browser",         "name": "Browser Worker",       "role": "research",        "agent": "browser",      "icon": "🌐"},
-    {"id": "vision",          "name": "Vision Worker",        "role": "ui_gen",          "agent": "vision",       "icon": "👁️"},
-    {"id": "ui",              "name": "UI Worker",            "role": "ui",              "agent": "ui",           "icon": "🎨"},
-    {"id": "debug",           "name": "Debug Worker",         "role": "debugging",       "agent": "debug",        "icon": "🐛"},
-    {"id": "test",            "name": "Test Worker",          "role": "testing",         "agent": "test",         "icon": "🧪"},
-    {"id": "verification",    "name": "Verification Worker",  "role": "qa",              "agent": "test",         "icon": "✅"},
-    {"id": "git",             "name": "Git Worker",           "role": "git",             "agent": "git",          "icon": "🔀"},
-    {"id": "deploy",          "name": "Deploy Worker",        "role": "deployment",      "agent": "deploy",       "icon": "🚀"},
-    {"id": "connector",       "name": "Connector Worker",     "role": "integration",     "agent": "connector",    "icon": "🔌"},
-    {"id": "memory",          "name": "Memory Worker",        "role": "memory",          "agent": "memory",       "icon": "💾"},
-    {"id": "knowledge",       "name": "Knowledge Worker",     "role": "knowledge",       "agent": "memory",       "icon": "📚"},
-    {"id": "workflow",        "name": "Workflow Worker",       "role": "automation",      "agent": "workflow",     "icon": "⚙️"},
-    {"id": "eventbus",        "name": "Event Bus",            "role": "events",          "agent": None,           "icon": "📡"},
-    {"id": "model-router",    "name": "Model Router",         "role": "ai_routing",      "agent": None,           "icon": "🤖"},
-    {"id": "observability",   "name": "Observability",        "role": "monitoring",      "agent": None,           "icon": "📊"},
-    {"id": "session-runtime", "name": "Session Runtime",      "role": "sessions",        "agent": None,           "icon": "⏱️"},
-    {"id": "auth-gateway",    "name": "Auth Gateway",         "role": "auth",            "agent": None,           "icon": "🔐"},
-]
-
-
-@app.get("/api/v1/spaces")
-async def get_spaces():
-    spaces_status = []
-    for space in SPACE_DEFS:
-        agent_name = space.get("agent")
-        agent = orchestrator.get_agent(agent_name) if agent_name else None
-        spaces_status.append({
-            **space,
-            "status": "active" if (agent is not None or agent_name is None) else "inactive",
-            "online": True,
-            "backend": "god-agent-os-v11",
-            "tasks_completed": 0,
-        })
-    return {
-        "spaces": spaces_status,
-        "total": len(spaces_status),
-        "active": len([s for s in spaces_status if s["status"] == "active"]),
-        "backend_url": os.environ.get("SPACE_URL", "https://pyae1994-autonomous-coding-system.hf.space"),
-    }
-
-
-@app.get("/health")
-@app.get("/api/v1/health")
-async def health_check():
-    stats = ai_router.get_stats() if ai_router else {}
-    active_providers = [name for name, s in stats.items() if s.get("available")]
-    return {
-        "status": "healthy",
-        "version": "11.0.0",
-        "timestamp": time.time(),
-        "agents": 16,
-        "spaces": 22,
-        "ai_providers": active_providers,
-        "mode": "god_mode",
-    }
-
-
-@app.get("/api/v1/ai/stats")
-async def get_ai_stats():
-    return {"stats": ai_router.get_stats() if ai_router else {}}
-
-
-@app.get("/api/v1/ai/pool-status")
-async def get_pool_status():
-    return {"pools": ai_router.get_pool_status() if ai_router else {}}
-
-
-@app.get("/api/v1/system/status")
-async def system_status():
-    ai_stats = ai_router.get_stats() if ai_router else {}
-    cs = connector_manager.get_summary() if connector_manager else {"connected": 0, "total": 0}
-    return {
-        "system": "god_agent_os_v11",
-        "status": "operational",
-        "timestamp": time.time(),
-        "ai_router": {
-            "providers": ai_stats,
-            "active": len([v for v in ai_stats.values() if v.get("available")]),
-        },
-        "agents": {
-            "total": 16,
-            "online": 16,
-        },
-        "spaces": {"total": 22, "all_in_backend": True},
-        "connectors": cs,
-        "features": {
-            "god_mode": True,
-            "computer_use": True,
-            "streaming": True,
-            "websocket": True,
-            "multi_agent": True,
-            "burmese_language": True,
-        },
-    }
-
-
-@app.get("/")
-async def root():
-    return {
-        "name": "GOD AGENT OS v11",
-        "version": "11.0.0",
-        "status": "operational",
-        "mode": "GOD_MODE",
-        "docs": "/api/docs",
-        "health": "/health",
-        "agents": 16,
-        "spaces": 22,
-    }
-
-
-if __name__ == "__main__":
-    import uvicorn
-    port = int(os.environ.get("PORT", 7860))
-    uvicorn.run("main_v11:app", host="0.0.0.0", port=port, reload=False, workers=1)

_legacy/main_v7.py

@@ -1,363 +0,0 @@
-"""
-🚀 GOD AGENT OS v7 — Autonomous Engineering Operating System
-Manus + Genspark + Devin (OneHand) Combined
-Version: 7.0.0
-"""
-
-import asyncio
-import json
-import logging
-import os
-import time
-import uuid
-from contextlib import asynccontextmanager
-from typing import Optional
-
-import structlog
-from fastapi import FastAPI, WebSocket, WebSocketDisconnect, HTTPException, Request
-from fastapi.middleware.cors import CORSMiddleware
-from fastapi.middleware.gzip import GZipMiddleware
-from fastapi.responses import JSONResponse
-from slowapi import Limiter, _rate_limit_exceeded_handler
-from slowapi.util import get_remote_address
-from slowapi.errors import RateLimitExceeded
-
-from api.routes import tasks, chat, memory, github, health
-from api.routes import connectors, agents as agents_router
-from api.websocket_manager import WebSocketManager
-from core.task_engine import TaskEngine
-from memory.db import init_db
-
-# ─── v7 God Agent Ecosystem ────────────────────────────────────────────────────
-from ai_router.router import AIRouter
-from agents.orchestrator_v7 import GodAgentOrchestratorV7
-from agents.chat_agent import ChatAgent
-from agents.planner_agent import PlannerAgent
-from agents.coding_agent import CodingAgent
-from agents.debug_agent import DebugAgent
-from agents.memory_agent import MemoryAgent
-from agents.connector_agent import ConnectorAgent
-from agents.deploy_agent import DeployAgent
-from agents.workflow_agent import WorkflowAgent
-from agents.sandbox_agent import SandboxAgent
-from agents.ui_agent import UIAgent
-from agents.reasoning_agent import ReasoningAgent
-# v7 new agents
-from agents.browser_agent import BrowserAgent
-from agents.file_agent import FileAgent
-from agents.git_agent import GitAgent
-from agents.test_agent import TestAgent
-from agents.vision_agent import VisionAgent
-from connectors.manager import ConnectorManager
-
-# ─── Structured Logging ────────────────────────────────────────────────────────
-structlog.configure(
-    processors=[
-        structlog.processors.TimeStamper(fmt="iso"),
-        structlog.stdlib.add_log_level,
-        structlog.processors.StackInfoRenderer(),
-        structlog.dev.ConsoleRenderer(),
-    ]
-)
-log = structlog.get_logger()
-
-# ─── Rate Limiter ──────────────────────────────────────────────────────────────
-limiter = Limiter(key_func=get_remote_address)
-
-# ─── Global Managers ──────────────────────────────────────────────────────────
-ws_manager = WebSocketManager()
-task_engine = TaskEngine(ws_manager)
-ai_router = AIRouter(ws_manager)
-connector_manager = ConnectorManager()
-
-
-# ─── Build v7 God Agent Ecosystem ─────────────────────────────────────────────
-def build_orchestrator_v7() -> GodAgentOrchestratorV7:
-    orchestrator = GodAgentOrchestratorV7(ws_manager=ws_manager, ai_router=ai_router)
-
-    # ── Core agents (v3 retained) ──────────────────────────────────────────
-    orchestrator.register_agent("chat",       ChatAgent(ws_manager, ai_router))
-    orchestrator.register_agent("planner",    PlannerAgent(ws_manager, ai_router))
-    orchestrator.register_agent("coding",     CodingAgent(ws_manager, ai_router))
-    orchestrator.register_agent("debug",      DebugAgent(ws_manager, ai_router))
-    orchestrator.register_agent("memory",     MemoryAgent(ws_manager, ai_router))
-    orchestrator.register_agent("connector",  ConnectorAgent(ws_manager, ai_router))
-    orchestrator.register_agent("deploy",     DeployAgent(ws_manager, ai_router))
-    orchestrator.register_agent("workflow",   WorkflowAgent(ws_manager, ai_router))
-    orchestrator.register_agent("sandbox",    SandboxAgent(ws_manager, ai_router))
-    orchestrator.register_agent("ui",         UIAgent(ws_manager, ai_router))
-    orchestrator.register_agent("reasoning",  ReasoningAgent(ws_manager, ai_router))
-
-    # ── v7 NEW agents ──────────────────────────────────────────────────────
-    orchestrator.register_agent("browser",    BrowserAgent(ws_manager, ai_router))
-    orchestrator.register_agent("file",       FileAgent(ws_manager, ai_router))
-    orchestrator.register_agent("git",        GitAgent(ws_manager, ai_router))
-    orchestrator.register_agent("test",       TestAgent(ws_manager, ai_router))
-    orchestrator.register_agent("vision",     VisionAgent(ws_manager, ai_router))
-
-    log.info("🤖 GOD AGENT v7 Ecosystem initialized", agents=16)
-    return orchestrator
-
-
-orchestrator = build_orchestrator_v7()
-
-
-@asynccontextmanager
-async def lifespan(app: FastAPI):
-    log.info("🚀 Starting GOD AGENT OS v7 — Autonomous Engineering Platform...")
-    await init_db()
-    await task_engine.start()
-    asyncio.create_task(ws_manager.heartbeat_loop())
-    log.info("✅ GOD AGENT v7 — All 16 agents online")
-    log.info("🤖 Core: Chat, Planner, Coding, Debug, Memory, Connector, Deploy, Workflow, Sandbox, UI, Reasoning")
-    log.info("⚡ v7 New: Browser, File, Git, Test, Vision")
-    log.info("🌐 AI Router: OpenAI → Groq → Cerebras → OpenRouter → Anthropic (auto-failover)")
-    yield
-    log.info("🛑 Shutting down GOD AGENT v7...")
-    await task_engine.stop()
-    log.info("✅ Shutdown complete")
-
-
-# ─── FastAPI App ───────────────────────────────────────────────────────────────
-app = FastAPI(
-    title="🤖 GOD AGENT OS v7",
-    description="Autonomous Engineering OS — Manus + Genspark + Devin (OneHand) Combined",
-    version="7.0.0",
-    lifespan=lifespan,
-    docs_url="/api/docs",
-    redoc_url="/api/redoc",
-)
-
-app.state.limiter = limiter
-app.add_exception_handler(RateLimitExceeded, _rate_limit_exceeded_handler)
-
-# ─── Share state ───────────────────────────────────────────────────────────────
-app.state.ws_manager = ws_manager
-app.state.task_engine = task_engine
-app.state.ai_router = ai_router
-app.state.orchestrator = orchestrator
-app.state.connector_manager = connector_manager
-
-# ─── Middleware ────────────────────────────────────────────────────────────────
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-app.add_middleware(GZipMiddleware, minimum_size=1000)
-
-
-@app.middleware("http")
-async def log_requests(request: Request, call_next):
-    start = time.time()
-    response = await call_next(request)
-    duration = round((time.time() - start) * 1000, 2)
-    log.info("HTTP", method=request.method, path=request.url.path, status=response.status_code, ms=duration)
-    return response
-
-
-# ─── REST API Routers ──────────────────────────────────────────────────────────
-app.include_router(health.router,         prefix="/api/v1",            tags=["health"])
-app.include_router(tasks.router,          prefix="/api/v1/tasks",      tags=["tasks"])
-app.include_router(chat.router,           prefix="/api/v1",            tags=["chat"])
-app.include_router(memory.router,         prefix="/api/v1/memory",     tags=["memory"])
-app.include_router(github.router,         prefix="/api/v1/github",     tags=["github"])
-app.include_router(connectors.router,     prefix="/api/v1/connectors", tags=["connectors"])
-app.include_router(agents_router.router,  prefix="/api/v1/agents",     tags=["agents"])
-
-
-# ─── WebSocket Endpoints ───────────────────────────────────────────────────────
-@app.websocket("/ws/tasks/{task_id}")
-async def ws_task(websocket: WebSocket, task_id: str):
-    await ws_manager.connect(websocket, room=f"task:{task_id}")
-    try:
-        while True:
-            data = await websocket.receive_text()
-            msg = json.loads(data)
-            if msg.get("type") == "ping":
-                await websocket.send_json({"type": "pong", "timestamp": time.time()})
-    except WebSocketDisconnect:
-        ws_manager.disconnect(websocket, room=f"task:{task_id}")
-
-
-@app.websocket("/ws/logs")
-async def ws_logs(websocket: WebSocket):
-    await ws_manager.connect(websocket, room="logs")
-    try:
-        while True:
-            data = await websocket.receive_text()
-            msg = json.loads(data)
-            if msg.get("type") == "ping":
-                await websocket.send_json({"type": "pong", "timestamp": time.time()})
-    except WebSocketDisconnect:
-        ws_manager.disconnect(websocket, room="logs")
-
-
-@app.websocket("/ws/chat/{session_id}")
-async def ws_chat(websocket: WebSocket, session_id: str):
-    await ws_manager.connect(websocket, room=f"chat:{session_id}")
-    try:
-        while True:
-            data = await websocket.receive_text()
-            msg = json.loads(data)
-            if msg.get("type") == "ping":
-                await websocket.send_json({"type": "pong", "timestamp": time.time()})
-            elif msg.get("type") == "chat_message":
-                asyncio.create_task(
-                    orchestrator.orchestrate(
-                        user_message=msg.get("content", ""),
-                        session_id=session_id,
-                        context=msg.get("context", {}),
-                    )
-                )
-            elif msg.get("type") == "task_message":
-                from core.models import TaskCreateRequest
-                req = TaskCreateRequest(
-                    goal=msg.get("content", ""),
-                    session_id=session_id,
-                )
-                asyncio.create_task(task_engine.submit(req))
-    except WebSocketDisconnect:
-        ws_manager.disconnect(websocket, room=f"chat:{session_id}")
-
-
-@app.websocket("/ws/agent/status")
-async def ws_agent_status(websocket: WebSocket):
-    await ws_manager.connect(websocket, room="agent_status")
-    try:
-        while True:
-            data = await websocket.receive_text()
-            msg = json.loads(data)
-            if msg.get("type") == "ping":
-                await websocket.send_json({"type": "pong", "timestamp": time.time()})
-            elif msg.get("type") == "get_status":
-                await websocket.send_json({
-                    "type": "agent_status",
-                    "data": orchestrator.get_status(),
-                })
-    except WebSocketDisconnect:
-        ws_manager.disconnect(websocket, room="agent_status")
-
-
-@app.websocket("/ws/sandbox/{session_id}")
-async def ws_sandbox(websocket: WebSocket, session_id: str):
-    await ws_manager.connect(websocket, room=f"sandbox:{session_id}")
-    sandbox = orchestrator.get_agent("sandbox")
-    try:
-        while True:
-            data = await websocket.receive_text()
-            msg = json.loads(data)
-            if msg.get("type") == "ping":
-                await websocket.send_json({"type": "pong", "timestamp": time.time()})
-            elif msg.get("type") == "execute" and sandbox:
-                cmd = msg.get("command", "")
-                result = await sandbox.execute(cmd, session_id=session_id)
-                await websocket.send_json({
-                    "type": "terminal_output",
-                    "command": cmd,
-                    "output": result,
-                    "timestamp": time.time(),
-                })
-    except WebSocketDisconnect:
-        ws_manager.disconnect(websocket, room=f"sandbox:{session_id}")
-
-
-# ─── v7 New Endpoints ──────────────────────────────────────────────────────────
-@app.post("/api/v1/browser/research")
-async def browser_research(request: Request):
-    body = await request.json()
-    query = body.get("query", "")
-    session_id = body.get("session_id", "")
-    browser = orchestrator.get_agent("browser")
-    if not browser:
-        raise HTTPException(status_code=503, detail="BrowserAgent not available")
-    result = await browser.run(query, session_id=session_id)
-    return {"result": result}
-
-
-@app.get("/api/v1/files/workspace")
-async def list_workspace():
-    file_agent = orchestrator.get_agent("file")
-    if not file_agent:
-        return {"workspace": "/tmp/god_workspace", "files": [], "total": 0}
-    return file_agent.list_workspace()
-
-
-@app.post("/api/v1/git/pr")
-async def create_pr(request: Request):
-    body = await request.json()
-    git_agent = orchestrator.get_agent("git")
-    if not git_agent:
-        raise HTTPException(status_code=503, detail="GitAgent not available")
-    result = await git_agent.create_github_pr(
-        repo_owner=body.get("owner", ""),
-        repo_name=body.get("repo", ""),
-        title=body.get("title", ""),
-        body=body.get("body", ""),
-        head_branch=body.get("head_branch", "main"),
-        base_branch=body.get("base_branch", "main"),
-    )
-    return result
-
-
-@app.post("/api/v1/vision/generate")
-async def generate_ui(request: Request):
-    body = await request.json()
-    vision = orchestrator.get_agent("vision")
-    if not vision:
-        raise HTTPException(status_code=503, detail="VisionAgent not available")
-    result = await vision.run(
-        body.get("prompt", ""),
-        context=body.get("context", {}),
-        session_id=body.get("session_id", ""),
-    )
-    return {"result": result}
-
-
-# ─── Root ──────────────────────────────────────────────────────────────────────
-@app.get("/")
-async def root():
-    cs = connector_manager.get_summary()
-    status = orchestrator.get_status()
-    return {
-        "name": "🤖 GOD AGENT OS v7",
-        "version": "7.0.0",
-        "status": "operational",
-        "mode": "autonomous_engineering_os",
-        "description": "Manus + Genspark + Devin (OneHand) — Autonomous Engineering Platform",
-        "agents": status["agents"],
-        "total_agents": status["total_agents"],
-        "capabilities": status["capabilities"],
-        "connectors": {
-            "connected": cs["connected"],
-            "total": cs["total"],
-            "ai_ready": cs["ai_ready"],
-        },
-        "docs": "/api/docs",
-        "websockets": [
-            "/ws/tasks/{task_id}",
-            "/ws/logs",
-            "/ws/chat/{session_id}",
-            "/ws/agent/status",
-            "/ws/sandbox/{session_id}",
-        ],
-        "v7_new_features": [
-            "🌐 BrowserAgent — Web research & scraping",
-            "📁 FileAgent — Full file system control & project scaffolding",
-            "🔀 GitAgent — Autonomous Git & GitHub PR operations",
-            "🧪 TestAgent — Auto test generation & execution",
-            "🎨 VisionAgent — Design-to-code UI generation",
-            "⚡ 16-agent parallel orchestration",
-            "🔄 Advanced self-healing loop",
-            "🧠 Enhanced intent classification",
-            "📊 Real-time execution timeline",
-        ],
-    }
-
-
-if __name__ == "__main__":
-    import uvicorn
-    port = int(os.environ.get("PORT", 8000))
-    uvicorn.run("main_v7:app", host="0.0.0.0", port=port, reload=False, workers=1)

_legacy/main_v8.py

@@ -1,326 +0,0 @@
-"""
-🚀 GOD AGENT OS v8 — Autonomous Engineering Operating System
-Manus + Genspark + Devin (OneHand) Combined
-Version: 8.0.0 — KeyPool Multi-API Routing (Gemini + SambaNova Primary LLMs)
-"""
-
-import asyncio
-import json
-import os
-import time
-import uuid
-from contextlib import asynccontextmanager
-from typing import Optional
-
-import structlog
-from fastapi import FastAPI, WebSocket, WebSocketDisconnect, HTTPException, Request
-from fastapi.middleware.cors import CORSMiddleware
-from fastapi.middleware.gzip import GZipMiddleware
-from fastapi.responses import JSONResponse
-from slowapi import Limiter, _rate_limit_exceeded_handler
-from slowapi.util import get_remote_address
-from slowapi.errors import RateLimitExceeded
-
-from api.routes import tasks, chat, memory, github, health
-from api.routes import connectors, agents as agents_router
-from api.websocket_manager import WebSocketManager
-from core.task_engine import TaskEngine
-from memory.db import init_db
-
-# ─── v8 AI Router (KeyPool-based) ─────────────────────────────────────────────
-from ai_router.router_v8 import AIRouterV8
-
-# ─── Agent Ecosystem ──────────────────────────────────────────────────────────
-from agents.orchestrator_v7 import GodAgentOrchestratorV7
-from agents.chat_agent import ChatAgent
-from agents.planner_agent import PlannerAgent
-from agents.coding_agent import CodingAgent
-from agents.debug_agent import DebugAgent
-from agents.memory_agent import MemoryAgent
-from agents.connector_agent import ConnectorAgent
-from agents.deploy_agent import DeployAgent
-from agents.workflow_agent import WorkflowAgent
-from agents.sandbox_agent import SandboxAgent
-from agents.ui_agent import UIAgent
-from agents.reasoning_agent import ReasoningAgent
-from agents.browser_agent import BrowserAgent
-from agents.file_agent import FileAgent
-from agents.git_agent import GitAgent
-from agents.test_agent import TestAgent
-from agents.vision_agent import VisionAgent
-from connectors.manager import ConnectorManager
-
-# ─── Structured Logging ───────────────────────────────────────────────────────
-structlog.configure(
-    processors=[
-        structlog.processors.TimeStamper(fmt="iso"),
-        structlog.stdlib.add_log_level,
-        structlog.processors.StackInfoRenderer(),
-        structlog.dev.ConsoleRenderer(),
-    ]
-)
-log = structlog.get_logger()
-
-limiter = Limiter(key_func=get_remote_address)
-
-# ─── Global Managers ──────────────────────────────────────────────────────────
-ws_manager = WebSocketManager()
-task_engine = TaskEngine(ws_manager)
-ai_router = AIRouterV8(ws_manager)
-connector_manager = ConnectorManager()
-
-
-def build_orchestrator() -> GodAgentOrchestratorV7:
-    orchestrator = GodAgentOrchestratorV7(ws_manager=ws_manager, ai_router=ai_router)
-    orchestrator.register_agent("chat",       ChatAgent(ws_manager, ai_router))
-    orchestrator.register_agent("planner",    PlannerAgent(ws_manager, ai_router))
-    orchestrator.register_agent("coding",     CodingAgent(ws_manager, ai_router))
-    orchestrator.register_agent("debug",      DebugAgent(ws_manager, ai_router))
-    orchestrator.register_agent("memory",     MemoryAgent(ws_manager, ai_router))
-    orchestrator.register_agent("connector",  ConnectorAgent(ws_manager, ai_router))
-    orchestrator.register_agent("deploy",     DeployAgent(ws_manager, ai_router))
-    orchestrator.register_agent("workflow",   WorkflowAgent(ws_manager, ai_router))
-    orchestrator.register_agent("sandbox",    SandboxAgent(ws_manager, ai_router))
-    orchestrator.register_agent("ui",         UIAgent(ws_manager, ai_router))
-    orchestrator.register_agent("reasoning",  ReasoningAgent(ws_manager, ai_router))
-    orchestrator.register_agent("browser",    BrowserAgent(ws_manager, ai_router))
-    orchestrator.register_agent("file",       FileAgent(ws_manager, ai_router))
-    orchestrator.register_agent("git",        GitAgent(ws_manager, ai_router))
-    orchestrator.register_agent("test",       TestAgent(ws_manager, ai_router))
-    orchestrator.register_agent("vision",     VisionAgent(ws_manager, ai_router))
-    log.info("🤖 GOD AGENT v8 Ecosystem initialized", agents=16)
-    return orchestrator
-
-
-orchestrator = build_orchestrator()
-
-
-@asynccontextmanager
-async def lifespan(app: FastAPI):
-    log.info("🚀 Starting GOD AGENT OS v8 — KeyPool Multi-API Edition...")
-    await init_db()
-    await task_engine.start()
-    asyncio.create_task(ws_manager.heartbeat_loop())
-    # Print router status
-    stats = ai_router.get_stats()
-    active = [name for name, s in stats.items() if s["available"]]
-    log.info("✅ GOD AGENT v8 — 16 agents online")
-    log.info(f"🔑 Active AI providers: {active}")
-    log.info("🌐 AI Routing: SambaNova → Gemini → OpenAI → Groq → Cerebras → OpenRouter → Anthropic")
-    yield
-    log.info("🛑 Shutting down GOD AGENT v8...")
-    await task_engine.stop()
-
-
-app = FastAPI(
-    title="🤖 GOD AGENT OS v8",
-    description="Autonomous Engineering OS — Gemini + SambaNova KeyPool Multi-API Routing",
-    version="8.0.0",
-    lifespan=lifespan,
-    docs_url="/api/docs",
-    redoc_url="/api/redoc",
-)
-
-app.state.limiter = limiter
-app.add_exception_handler(RateLimitExceeded, _rate_limit_exceeded_handler)
-app.state.ws_manager = ws_manager
-app.state.task_engine = task_engine
-app.state.ai_router = ai_router
-app.state.orchestrator = orchestrator
-app.state.connector_manager = connector_manager
-
-app.add_middleware(CORSMiddleware, allow_origins=["*"], allow_credentials=True, allow_methods=["*"], allow_headers=["*"])
-app.add_middleware(GZipMiddleware, minimum_size=1000)
-
-
-@app.middleware("http")
-async def log_requests(request: Request, call_next):
-    start = time.time()
-    response = await call_next(request)
-    ms = round((time.time() - start) * 1000, 2)
-    log.info("HTTP", method=request.method, path=request.url.path, status=response.status_code, ms=ms)
-    return response
-
-
-# ─── REST Routers ─────────────────────────────────────────────────────────────
-app.include_router(health.router,        prefix="/api/v1",            tags=["health"])
-app.include_router(tasks.router,         prefix="/api/v1/tasks",      tags=["tasks"])
-app.include_router(chat.router,          prefix="/api/v1",            tags=["chat"])
-app.include_router(memory.router,        prefix="/api/v1/memory",     tags=["memory"])
-app.include_router(github.router,        prefix="/api/v1/github",     tags=["github"])
-app.include_router(connectors.router,    prefix="/api/v1/connectors", tags=["connectors"])
-app.include_router(agents_router.router, prefix="/api/v1/agents",     tags=["agents"])
-
-
-# ─── WebSocket Endpoints ──────────────────────────────────────────────────────
-@app.websocket("/ws/tasks/{task_id}")
-async def ws_task(websocket: WebSocket, task_id: str):
-    await ws_manager.connect(websocket, room=f"task:{task_id}")
-    try:
-        while True:
-            data = await websocket.receive_text()
-            msg = json.loads(data)
-            if msg.get("type") == "ping":
-                await websocket.send_json({"type": "pong", "timestamp": time.time()})
-    except WebSocketDisconnect:
-        ws_manager.disconnect(websocket, room=f"task:{task_id}")
-
-
-@app.websocket("/ws/logs")
-async def ws_logs(websocket: WebSocket):
-    await ws_manager.connect(websocket, room="logs")
-    try:
-        while True:
-            data = await websocket.receive_text()
-            msg = json.loads(data)
-            if msg.get("type") == "ping":
-                await websocket.send_json({"type": "pong", "timestamp": time.time()})
-    except WebSocketDisconnect:
-        ws_manager.disconnect(websocket, room="logs")
-
-
-@app.websocket("/ws/chat/{session_id}")
-async def ws_chat(websocket: WebSocket, session_id: str):
-    await ws_manager.connect(websocket, room=f"chat:{session_id}")
-    try:
-        while True:
-            data = await websocket.receive_text()
-            msg = json.loads(data)
-            if msg.get("type") == "ping":
-                await websocket.send_json({"type": "pong", "timestamp": time.time()})
-            elif msg.get("type") == "chat_message":
-                asyncio.create_task(orchestrator.orchestrate(
-                    user_message=msg.get("content", ""),
-                    session_id=session_id,
-                    context=msg.get("context", {}),
-                ))
-            elif msg.get("type") == "task_message":
-                from core.models import TaskCreateRequest
-                req = TaskCreateRequest(goal=msg.get("content", ""), session_id=session_id)
-                asyncio.create_task(task_engine.submit(req))
-    except WebSocketDisconnect:
-        ws_manager.disconnect(websocket, room=f"chat:{session_id}")
-
-
-@app.websocket("/ws/agent/status")
-async def ws_agent_status(websocket: WebSocket):
-    await ws_manager.connect(websocket, room="agent_status")
-    try:
-        while True:
-            data = await websocket.receive_text()
-            msg = json.loads(data)
-            if msg.get("type") == "ping":
-                await websocket.send_json({"type": "pong", "timestamp": time.time()})
-            elif msg.get("type") == "get_status":
-                await websocket.send_json({"type": "agent_status", "data": orchestrator.get_status()})
-    except WebSocketDisconnect:
-        ws_manager.disconnect(websocket, room="agent_status")
-
-
-@app.websocket("/ws/sandbox/{session_id}")
-async def ws_sandbox(websocket: WebSocket, session_id: str):
-    await ws_manager.connect(websocket, room=f"sandbox:{session_id}")
-    sandbox = orchestrator.get_agent("sandbox")
-    try:
-        while True:
-            data = await websocket.receive_text()
-            msg = json.loads(data)
-            if msg.get("type") == "ping":
-                await websocket.send_json({"type": "pong", "timestamp": time.time()})
-            elif msg.get("type") == "execute" and sandbox:
-                cmd = msg.get("command", "")
-                result = await sandbox.execute(cmd, session_id=session_id)
-                await websocket.send_json({"type": "terminal_output", "command": cmd, "output": result, "timestamp": time.time()})
-    except WebSocketDisconnect:
-        ws_manager.disconnect(websocket, room=f"sandbox:{session_id}")
-
-
-# ─── v8 Key Pool & AI Router Status Endpoints ─────────────────────────────────
-@app.get("/api/v1/ai/stats")
-async def get_ai_stats():
-    return {"stats": ai_router.get_stats()}
-
-
-@app.get("/api/v1/ai/pool-status")
-async def get_pool_status():
-    return {"pools": ai_router.get_pool_status()}
-
-
-@app.post("/api/v1/browser/research")
-async def browser_research(request: Request):
-    body = await request.json()
-    browser = orchestrator.get_agent("browser")
-    if not browser:
-        raise HTTPException(status_code=503, detail="BrowserAgent not available")
-    result = await browser.run(body.get("query", ""), session_id=body.get("session_id", ""))
-    return {"result": result}
-
-
-@app.get("/api/v1/files/workspace")
-async def list_workspace():
-    file_agent = orchestrator.get_agent("file")
-    if not file_agent:
-        return {"workspace": "/tmp/god_workspace", "files": [], "total": 0}
-    return file_agent.list_workspace()
-
-
-@app.post("/api/v1/git/pr")
-async def create_pr(request: Request):
-    body = await request.json()
-    git_agent = orchestrator.get_agent("git")
-    if not git_agent:
-        raise HTTPException(status_code=503, detail="GitAgent not available")
-    result = await git_agent.create_github_pr(
-        repo_owner=body.get("owner", ""),
-        repo_name=body.get("repo", ""),
-        title=body.get("title", ""),
-        body=body.get("body", ""),
-        head_branch=body.get("head_branch", "main"),
-        base_branch=body.get("base_branch", "main"),
-    )
-    return result
-
-
-@app.post("/api/v1/vision/generate")
-async def generate_ui(request: Request):
-    body = await request.json()
-    vision = orchestrator.get_agent("vision")
-    if not vision:
-        raise HTTPException(status_code=503, detail="VisionAgent not available")
-    result = await vision.run(body.get("prompt", ""), context=body.get("context", {}), session_id=body.get("session_id", ""))
-    return {"result": result}
-
-
-# ─── Root ─────────────────────────────────────────────────────────────────────
-@app.get("/")
-async def root():
-    cs = connector_manager.get_summary()
-    status = orchestrator.get_status()
-    stats = ai_router.get_stats()
-    active_providers = [name for name, s in stats.items() if s["available"]]
-    return {
-        "name": "🤖 GOD AGENT OS v8",
-        "version": "8.0.0",
-        "status": "operational",
-        "mode": "autonomous_engineering_os",
-        "description": "KeyPool Multi-API Routing — Gemini + SambaNova Primary LLMs",
-        "agents": status["agents"],
-        "total_agents": status["total_agents"],
-        "ai_providers": active_providers,
-        "connectors": {"connected": cs["connected"], "total": cs["total"]},
-        "docs": "/api/docs",
-        "v8_features": [
-            "🔑 KeyPool multi-key management (Gemini 6 keys + SambaNova 9 keys)",
-            "🔄 Automatic key failover with cooldown tracking",
-            "⚡ SambaNova → Gemini → OpenAI → Groq → Cerebras chain",
-            "📊 Per-key usage stats & health monitoring",
-            "🤖 16-agent autonomous fleet",
-            "🌐 Real-time streaming via WebSocket",
-        ],
-    }
-
-
-if __name__ == "__main__":
-    import uvicorn
-    port = int(os.environ.get("PORT", 8000))
-    uvicorn.run("main_v8:app", host="0.0.0.0", port=port, reload=False, workers=1)

_legacy/main_v9.py

@@ -1,417 +0,0 @@
-"""
-🚀 GOD AGENT OS v10 — Distributed 22-Space Agent OS
-Powered by Pyae Sone
-"""
-
-import asyncio
-import json
-import os
-import time
-import uuid
-from contextlib import asynccontextmanager
-from typing import Optional
-
-import structlog
-from fastapi import FastAPI, WebSocket, WebSocketDisconnect, HTTPException, Request
-from fastapi.middleware.cors import CORSMiddleware
-from fastapi.middleware.gzip import GZipMiddleware
-from fastapi.responses import JSONResponse
-from slowapi import Limiter, _rate_limit_exceeded_handler
-from slowapi.util import get_remote_address
-from slowapi.errors import RateLimitExceeded
-
-from api.routes import tasks, chat, memory, health
-from api.routes import connectors, agents as agents_router
-from api.websocket_manager import WebSocketManager
-from core.task_engine import TaskEngine
-from memory.db import init_db
-
-# ─── v10 AI Router (Gemini + SambaNova + GitHub KeyPool routing) ─────────────
-from ai_router.router_v10 import AIRouterV10 as AIRouterV8
-
-# ─── v9 Agent Kernel & Spaces ─────────────────────────────────────────────────
-from kernel.agent_kernel import AgentKernel
-from spaces import SPACE_CATALOG, build_all_spaces
-
-# ─── Legacy Agent Ecosystem (backward compatibility) ──────────────────────────
-from agents.orchestrator_v7 import GodAgentOrchestratorV7
-from agents.chat_agent import ChatAgent
-from agents.planner_agent import PlannerAgent
-from agents.coding_agent import CodingAgent
-from agents.debug_agent import DebugAgent
-from agents.memory_agent import MemoryAgent
-from agents.connector_agent import ConnectorAgent
-from agents.deploy_agent import DeployAgent
-from agents.workflow_agent import WorkflowAgent
-from agents.sandbox_agent import SandboxAgent
-from agents.ui_agent import UIAgent
-from agents.reasoning_agent import ReasoningAgent
-from agents.browser_agent import BrowserAgent
-from agents.file_agent import FileAgent
-from agents.git_agent import GitAgent
-from agents.test_agent import TestAgent
-from agents.vision_agent import VisionAgent
-from connectors.manager import ConnectorManager
-
-# ─── API Routes ───────────────────────────────────────────────────────────────
-from api.routes import github
-
-# ─── Structured Logging ───────────────────────────────────────────────────────
-structlog.configure(
-    processors=[
-        structlog.processors.TimeStamper(fmt="iso"),
-        structlog.stdlib.add_log_level,
-        structlog.processors.StackInfoRenderer(),
-        structlog.dev.ConsoleRenderer(),
-    ]
-)
-log = structlog.get_logger()
-
-limiter = Limiter(key_func=get_remote_address)
-
-# ─── Global Managers ──────────────────────────────────────────────────────────
-ws_manager = WebSocketManager()
-task_engine = TaskEngine(ws_manager)
-ai_router = AIRouterV8(ws_manager)
-connector_manager = ConnectorManager()
-
-
-def build_kernel() -> AgentKernel:
-    """Build and configure the distributed 22-space Agent Kernel."""
-    kernel = AgentKernel(ws_manager=ws_manager, ai_router=ai_router)
-    for space_name, space_instance in build_all_spaces(ws_manager=ws_manager, ai_router=ai_router).items():
-        kernel.register_space(space_name, space_instance)
-    log.info("🧠 GOD AGENT OS distributed kernel initialized", spaces=len(SPACE_CATALOG))
-    return kernel
-
-
-def build_legacy_orchestrator() -> GodAgentOrchestratorV7:
-    """Build legacy v7 orchestrator for backward compatibility."""
-    orchestrator = GodAgentOrchestratorV7(ws_manager=ws_manager, ai_router=ai_router)
-    orchestrator.register_agent("chat",       ChatAgent(ws_manager, ai_router))
-    orchestrator.register_agent("planner",    PlannerAgent(ws_manager, ai_router))
-    orchestrator.register_agent("coding",     CodingAgent(ws_manager, ai_router))
-    orchestrator.register_agent("debug",      DebugAgent(ws_manager, ai_router))
-    orchestrator.register_agent("memory",     MemoryAgent(ws_manager, ai_router))
-    orchestrator.register_agent("connector",  ConnectorAgent(ws_manager, ai_router))
-    orchestrator.register_agent("deploy",     DeployAgent(ws_manager, ai_router))
-    orchestrator.register_agent("workflow",   WorkflowAgent(ws_manager, ai_router))
-    orchestrator.register_agent("sandbox",    SandboxAgent(ws_manager, ai_router))
-    orchestrator.register_agent("ui",         UIAgent(ws_manager, ai_router))
-    orchestrator.register_agent("reasoning",  ReasoningAgent(ws_manager, ai_router))
-    orchestrator.register_agent("browser",    BrowserAgent(ws_manager, ai_router))
-    orchestrator.register_agent("file",       FileAgent(ws_manager, ai_router))
-    orchestrator.register_agent("git",        GitAgent(ws_manager, ai_router))
-    orchestrator.register_agent("test",       TestAgent(ws_manager, ai_router))
-    orchestrator.register_agent("vision",     VisionAgent(ws_manager, ai_router))
-    log.info("🤖 Legacy v7 Orchestrator initialized", agents=16)
-    return orchestrator
-
-
-# Initialize both kernel and legacy orchestrator
-kernel = build_kernel()
-orchestrator = build_legacy_orchestrator()
-
-
-@asynccontextmanager
-async def lifespan(app: FastAPI):
-    log.info("🚀 Starting GOD AGENT OS v10 — Distributed 22-Space Architecture...")
-    await init_db()
-    await task_engine.start()
-    asyncio.create_task(ws_manager.heartbeat_loop())
-    stats = ai_router.get_stats()
-    active = [name for name, s in stats.items() if s["available"]]
-    log.info("✅ GOD AGENT v10 — 22 Spaces + 16 Legacy Agents online")
-    log.info(f"🔑 Active AI providers: {active}")
-    log.info("🌐 Routing: SambaNova → Gemini → OpenAI → Groq → Cerebras")
-    log.info("📦 Spaces: distributed 22-space runtime online")
-    yield
-    log.info("🛑 Shutting down GOD AGENT OS v9...")
-    await task_engine.stop()
-
-
-app = FastAPI(
-    title="🤖 GOD AGENT OS v10",
-    description="Distributed 22-Space Autonomous Agent OS | Powered by Pyae Sone",
-    version="10.0.0",
-    lifespan=lifespan,
-    docs_url="/api/docs",
-    redoc_url="/api/redoc",
-)
-
-app.state.limiter = limiter
-app.add_exception_handler(RateLimitExceeded, _rate_limit_exceeded_handler)
-app.state.ws_manager = ws_manager
-app.state.task_engine = task_engine
-app.state.ai_router = ai_router
-app.state.kernel = kernel
-app.state.orchestrator = orchestrator
-app.state.connector_manager = connector_manager
-
-app.add_middleware(CORSMiddleware, allow_origins=["*"], allow_credentials=True, allow_methods=["*"], allow_headers=["*"])
-app.add_middleware(GZipMiddleware, minimum_size=1000)
-
-
-@app.middleware("http")
-async def log_requests(request: Request, call_next):
-    start = time.time()
-    response = await call_next(request)
-    ms = round((time.time() - start) * 1000, 2)
-    log.info("HTTP", method=request.method, path=request.url.path, status=response.status_code, ms=ms)
-    return response
-
-
-# ─── REST Routers ─────────────────────────────────────────────────────────────
-app.include_router(health.router,        prefix="/api/v1",            tags=["health"])
-app.include_router(tasks.router,         prefix="/api/v1/tasks",      tags=["tasks"])
-app.include_router(chat.router,          prefix="/api/v1",            tags=["chat"])
-app.include_router(memory.router,        prefix="/api/v1/memory",     tags=["memory"])
-app.include_router(github.router,        prefix="/api/v1/github",     tags=["github"])
-app.include_router(connectors.router,    prefix="/api/v1/connectors", tags=["connectors"])
-app.include_router(agents_router.router, prefix="/api/v1/agents",     tags=["agents"])
-
-
-# ─── WebSocket: Chat (v9 Kernel-powered) ──────────────────────────────────────
-@app.websocket("/ws/chat/{session_id}")
-async def ws_chat(websocket: WebSocket, session_id: str):
-    await ws_manager.connect(websocket, room=f"chat:{session_id}")
-    try:
-        while True:
-            data = await websocket.receive_text()
-            msg = json.loads(data)
-            
-            if msg.get("type") == "ping":
-                await websocket.send_json({"type": "pong", "timestamp": time.time()})
-            
-            elif msg.get("type") == "chat_message":
-                # Route through v9 Agent Kernel
-                asyncio.create_task(kernel.orchestrate(
-                    user_message=msg.get("content", ""),
-                    session_id=session_id,
-                    context=msg.get("context", {}),
-                ))
-            
-            elif msg.get("type") == "task_message":
-                from core.models import TaskCreateRequest
-                req = TaskCreateRequest(goal=msg.get("content", ""), session_id=session_id)
-                asyncio.create_task(task_engine.submit(req))
-    
-    except WebSocketDisconnect:
-        ws_manager.disconnect(websocket, room=f"chat:{session_id}")
-
-
-@app.websocket("/ws/tasks/{task_id}")
-async def ws_task(websocket: WebSocket, task_id: str):
-    await ws_manager.connect(websocket, room=f"task:{task_id}")
-    try:
-        while True:
-            data = await websocket.receive_text()
-            msg = json.loads(data)
-            if msg.get("type") == "ping":
-                await websocket.send_json({"type": "pong", "timestamp": time.time()})
-    except WebSocketDisconnect:
-        ws_manager.disconnect(websocket, room=f"task:{task_id}")
-
-
-@app.websocket("/ws/logs")
-async def ws_logs(websocket: WebSocket):
-    await ws_manager.connect(websocket, room="logs")
-    try:
-        while True:
-            data = await websocket.receive_text()
-            msg = json.loads(data)
-            if msg.get("type") == "ping":
-                await websocket.send_json({"type": "pong", "timestamp": time.time()})
-    except WebSocketDisconnect:
-        ws_manager.disconnect(websocket, room="logs")
-
-
-@app.websocket("/ws/agent/status")
-async def ws_agent_status(websocket: WebSocket):
-    await ws_manager.connect(websocket, room="agent_status")
-    try:
-        while True:
-            data = await websocket.receive_text()
-            msg = json.loads(data)
-            if msg.get("type") == "ping":
-                await websocket.send_json({"type": "pong", "timestamp": time.time()})
-            elif msg.get("type") == "get_status":
-                await websocket.send_json({
-                    "type": "agent_status",
-                    "data": kernel.get_status(),
-                    "legacy": orchestrator.get_status(),
-                })
-    except WebSocketDisconnect:
-        ws_manager.disconnect(websocket, room="agent_status")
-
-
-@app.websocket("/ws/sandbox/{session_id}")
-async def ws_sandbox(websocket: WebSocket, session_id: str):
-    await ws_manager.connect(websocket, room=f"sandbox:{session_id}")
-    sandbox_space = kernel.get_space("sandbox")
-    try:
-        while True:
-            data = await websocket.receive_text()
-            msg = json.loads(data)
-            if msg.get("type") == "ping":
-                await websocket.send_json({"type": "pong", "timestamp": time.time()})
-            elif msg.get("type") == "execute" and sandbox_space:
-                cmd = msg.get("command", "")
-                result = await sandbox_space._run_shell(cmd)
-                await websocket.send_json({
-                    "type": "terminal_output",
-                    "command": cmd,
-                    "output": result,
-                    "timestamp": time.time()
-                })
-    except WebSocketDisconnect:
-        ws_manager.disconnect(websocket, room=f"sandbox:{session_id}")
-
-
-# ─── v9 Space-Role API Endpoints ──────────────────────────────────────────────
-@app.get("/api/v1/kernel/status")
-async def kernel_status():
-    """Get Agent Kernel status."""
-    return {
-        "kernel": kernel.get_status(),
-        "ai_providers": ai_router.get_stats(),
-    }
-
-
-@app.get("/api/v1/spaces")
-async def list_spaces():
-    """List all available Spaces."""
-    spaces_info = {}
-    for name, space in kernel._spaces.items():
-        spaces_info[name] = space.get_info()
-    return {"spaces": spaces_info, "total": len(spaces_info)}
-
-
-@app.post("/api/v1/spaces/{space_name}/execute")
-async def execute_in_space(space_name: str, request: Request):
-    """Execute a task in a specific Space."""
-    body = await request.json()
-    task = body.get("task", "")
-    role = body.get("role", "cognition")
-    session_id = body.get("session_id", "api")
-    
-    space = kernel.get_space(space_name)
-    if not space:
-        raise HTTPException(status_code=404, detail=f"Space '{space_name}' not found")
-    
-    result = await space.execute(task=task, role=role, session_id=session_id, context=body.get("context", {}))
-    return {"space": space_name, "role": role, "result": result}
-
-
-@app.post("/api/v1/kernel/orchestrate")
-async def kernel_orchestrate(request: Request):
-    """Main orchestration endpoint."""
-    body = await request.json()
-    result = await kernel.orchestrate(
-        user_message=body.get("message", ""),
-        session_id=body.get("session_id", "api"),
-        context=body.get("context", {}),
-    )
-    return {"result": result}
-
-
-# ─── Legacy v8 Endpoints (backward compatibility) ─────────────────────────────
-@app.get("/api/v1/ai/stats")
-async def get_ai_stats():
-    return {"stats": ai_router.get_stats()}
-
-
-@app.get("/api/v1/ai/pool-status")
-async def get_pool_status():
-    return {"pools": ai_router.get_pool_status()}
-
-
-@app.post("/api/v1/browser/research")
-async def browser_research(request: Request):
-    body = await request.json()
-    browser_space = kernel.get_space("browser")
-    if not browser_space:
-        raise HTTPException(status_code=503, detail="Browser Space not available")
-    result = await browser_space.execute(
-        task=body.get("query", ""),
-        role="automation",
-        session_id=body.get("session_id", "api"),
-    )
-    return {"result": result}
-
-
-@app.get("/api/v1/files/workspace")
-async def list_workspace():
-    file_agent = orchestrator.get_agent("file")
-    if not file_agent:
-        return {"workspace": "/tmp/god_workspace", "files": [], "total": 0}
-    return file_agent.list_workspace()
-
-
-@app.post("/api/v1/git/pr")
-async def create_pr(request: Request):
-    body = await request.json()
-    git_agent = orchestrator.get_agent("git")
-    if not git_agent:
-        raise HTTPException(status_code=503, detail="GitAgent not available")
-    result = await git_agent.create_github_pr(
-        repo_owner=body.get("owner", ""),
-        repo_name=body.get("repo", ""),
-        title=body.get("title", ""),
-        body=body.get("body", ""),
-        head_branch=body.get("head_branch", "main"),
-        base_branch=body.get("base_branch", "main"),
-    )
-    return result
-
-
-@app.post("/api/v1/vision/generate")
-async def generate_ui(request: Request):
-    body = await request.json()
-    vision_space = kernel.get_space("vision")
-    if not vision_space:
-        raise HTTPException(status_code=503, detail="Vision Space not available")
-    result = await vision_space.execute(
-        task=body.get("prompt", ""),
-        role="visual_intelligence",
-        session_id=body.get("session_id", "api"),
-    )
-    return {"result": result}
-
-
-# ─── Root ─────────────────────────────────────────────────────────────────────
-@app.get("/")
-async def root():
-    cs = connector_manager.get_summary()
-    kernel_status_data = kernel.get_status()
-    stats = ai_router.get_stats()
-    active_providers = [name for name, s in stats.items() if s["available"]]
-    return {
-        "name": "🤖 GOD AGENT OS v10",
-        "version": "10.0.0",
-        "status": "operational",
-        "mode": "general_autonomous_agent_os",
-        "description": "Distributed 22-Space Architecture | Powered by Pyae Sone",
-        "architecture": "Distributed Worker Space Paradigm",
-        "spaces": kernel_status_data["spaces"],
-        "total_spaces": kernel_status_data["total_spaces"],
-        "ai_providers": active_providers,
-        "connectors": {"connected": cs["connected"], "total": cs["total"]},
-        "docs": "/api/docs",
-        "v9_features": [
-            "📦 22 distributed worker spaces across cognition, execution, verification, deployment, memory, coordination, monitoring, session, and infrastructure layers",
-            "🎭 5 Cognitive Roles: Cognition | Automation | Execution | Repair | Visual Intelligence",
-            "🧠 God Core Space orchestrates the worker fleet",
-            "🔑 KeyPool multi-key management (Gemini + SambaNova + GitHub)",
-            "🔄 Automatic worker-space routing based on intent",
-            "💾 Context Manager for session-scoped runtime state",
-            "⚡ Backward compatible with v8/v9 agent fleet",
-            "🌐 Real-time streaming via WebSocket",
-        ],
-    }
-
-
-if __name__ == "__main__":
-    import uvicorn
-    port = int(os.environ.get("PORT", 7860))
-    uvicorn.run("main_v9:app", host="0.0.0.0", port=port, reload=False, workers=1)

agents/__init__.py

@@ -1,24 +0,0 @@
-# God Agent Multi-Agent System
-from .orchestrator import GodAgentOrchestrator
-from .chat_agent import ChatAgent
-from .planner_agent import PlannerAgent
-from .coding_agent import CodingAgent
-from .debug_agent import DebugAgent
-from .memory_agent import MemoryAgent
-from .connector_agent import ConnectorAgent
-from .deploy_agent import DeployAgent
-from .workflow_agent import WorkflowAgent
-from .sandbox_agent import SandboxAgent
-
-__all__ = [
-    "GodAgentOrchestrator",
-    "ChatAgent",
-    "PlannerAgent",
-    "CodingAgent",
-    "DebugAgent",
-    "MemoryAgent",
-    "ConnectorAgent",
-    "DeployAgent",
-    "WorkflowAgent",
-    "SandboxAgent",
-]

agents/base_agent.py

@@ -1,54 +0,0 @@
-"""
-Base Agent — Abstract base for all God Mode agents
-"""
-from abc import ABC, abstractmethod
-from typing import Any, Dict, List, Optional
-import structlog
-
-log = structlog.get_logger()
-
-
-class BaseAgent(ABC):
-    """Abstract base class for all agents in the God Mode ecosystem."""
-
-    def __init__(self, name: str, ws_manager=None, ai_router=None):
-        self.name = name
-        self.ws = ws_manager
-        self.ai_router = ai_router
-        self.log = structlog.get_logger().bind(agent=name)
-
-    @abstractmethod
-    async def run(self, task: str, context: Dict = {}, **kwargs) -> str:
-        """Execute the agent's primary task."""
-        pass
-
-    async def emit(self, room: str, event: str, data: Dict, session_id: str = ""):
-        """Emit WebSocket event if manager available."""
-        if self.ws:
-            await self.ws.emit(room, event, data, session_id=session_id)
-
-    async def emit_chat(self, session_id: str, event: str, data: Dict):
-        """Emit chat WebSocket event."""
-        if self.ws:
-            await self.ws.emit_chat(session_id, event, data)
-
-    async def llm(
-        self,
-        messages: List[Dict],
-        task_id: str = "",
-        session_id: str = "",
-        temperature: float = 0.7,
-        max_tokens: int = 4096,
-        model: str = "",
-    ) -> str:
-        """Route LLM call through AI router."""
-        if self.ai_router:
-            return await self.ai_router.complete(
-                messages=messages,
-                task_id=task_id,
-                session_id=session_id,
-                temperature=temperature,
-                max_tokens=max_tokens,
-                preferred_model=model,
-            )
-        return f"[{self.name}] AI router not configured."

agents/browser_agent.py

@@ -1,147 +0,0 @@
-"""
-BrowserAgent v7 — Autonomous web browsing, scraping, research (Manus-style)
-Real browser control via Playwright/httpx for research, testing, web automation
-"""
-import asyncio
-import json
-import os
-import re
-from typing import Dict, List, Optional
-import structlog
-from .base_agent import BaseAgent
-
-log = structlog.get_logger()
-
-BROWSER_SYSTEM = """You are an elite autonomous web research and browser automation agent.
-You can:
-- Search the web and extract structured information
-- Navigate websites and fill forms
-- Take screenshots and analyze visual content
-- Scrape and parse complex web pages
-- Run web automation tasks
-
-Always provide structured, actionable results with source URLs.
-"""
-
-class BrowserAgent(BaseAgent):
-    def __init__(self, ws_manager=None, ai_router=None):
-        super().__init__("BrowserAgent", ws_manager, ai_router)
-        self._session_cache: Dict[str, str] = {}
-
-    async def run(self, task: str, context: Dict = {}, **kwargs) -> str:
-        session_id = kwargs.get("session_id", "")
-        task_id = kwargs.get("task_id", "")
-
-        await self.emit(task_id, "agent_start", {
-            "agent": "BrowserAgent",
-            "task": task[:80],
-        }, session_id)
-
-        await self.emit(task_id, "tool_called", {
-            "agent": "BrowserAgent",
-            "tool": "web_research",
-            "step": f"Researching: {task[:60]}",
-        }, session_id)
-
-        # Extract search query or URL from task
-        urls = re.findall(r'https?://[^\s]+', task)
-        
-        if urls:
-            result = await self._fetch_and_analyze(urls[0], task, task_id, session_id)
-        else:
-            result = await self._web_research(task, task_id, session_id)
-
-        await self.emit(task_id, "browser_result", {
-            "agent": "BrowserAgent",
-            "result_length": len(result),
-        }, session_id)
-
-        return result
-
-    async def _web_research(self, query: str, task_id: str, session_id: str) -> str:
-        """Perform web research using AI knowledge + httpx."""
-        import httpx
-        
-        # Use DuckDuckGo search API (no key needed)
-        search_url = f"https://api.duckduckgo.com/?q={query.replace(' ', '+')}&format=json&no_html=1"
-        
-        try:
-            async with httpx.AsyncClient(timeout=15, follow_redirects=True) as client:
-                resp = await client.get(search_url, headers={"User-Agent": "GodAgent/7.0"})
-                data = resp.json()
-                
-                results = []
-                if data.get("AbstractText"):
-                    results.append(f"**Summary:** {data['AbstractText']}")
-                if data.get("AbstractURL"):
-                    results.append(f"**Source:** {data['AbstractURL']}")
-                
-                related = data.get("RelatedTopics", [])[:5]
-                if related:
-                    results.append("\n**Related:**")
-                    for r in related:
-                        if isinstance(r, dict) and r.get("Text"):
-                            results.append(f"- {r['Text'][:200]}")
-                
-                if results:
-                    search_context = "\n".join(results)
-                else:
-                    search_context = f"Web search for: {query}"
-                    
-        except Exception as e:
-            search_context = f"Search context for: {query}"
-
-        # Use AI to synthesize research
-        messages = [
-            {"role": "system", "content": BROWSER_SYSTEM},
-            {"role": "user", "content": (
-                f"Research task: {query}\n\n"
-                f"Search context:\n{search_context}\n\n"
-                f"Provide a comprehensive, structured research report with key findings, "
-                f"actionable insights, and relevant sources. Format with headers and bullet points."
-            )},
-        ]
-        return await self.llm(messages, task_id=task_id, session_id=session_id, temperature=0.3, max_tokens=4096)
-
-    async def _fetch_and_analyze(self, url: str, task: str, task_id: str, session_id: str) -> str:
-        """Fetch a URL and analyze its content."""
-        import httpx
-        
-        try:
-            async with httpx.AsyncClient(timeout=20, follow_redirects=True) as client:
-                resp = await client.get(url, headers={
-                    "User-Agent": "Mozilla/5.0 GodAgent/7.0",
-                    "Accept": "text/html,application/json,*/*",
-                })
-                content_type = resp.headers.get("content-type", "")
-                
-                if "json" in content_type:
-                    page_content = json.dumps(resp.json(), indent=2)[:3000]
-                else:
-                    # Strip HTML tags
-                    html = resp.text
-                    text = re.sub(r'<[^>]+>', ' ', html)
-                    text = re.sub(r'\s+', ' ', text).strip()
-                    page_content = text[:3000]
-                    
-        except Exception as e:
-            page_content = f"Could not fetch {url}: {str(e)}"
-
-        messages = [
-            {"role": "system", "content": BROWSER_SYSTEM},
-            {"role": "user", "content": (
-                f"Analyze this web page content for the task: {task}\n\n"
-                f"URL: {url}\n\n"
-                f"Page Content:\n{page_content}\n\n"
-                f"Provide a structured analysis with key information extracted."
-            )},
-        ]
-        return await self.llm(messages, task_id=task_id, session_id=session_id, temperature=0.3, max_tokens=4096)
-
-    async def screenshot_analyze(self, url: str, task_id: str = "", session_id: str = "") -> str:
-        """Describe what a webpage looks like (AI-powered visual analysis)."""
-        messages = [
-            {"role": "system", "content": BROWSER_SYSTEM},
-            {"role": "user", "content": f"Describe the visual layout and UI elements you'd expect at: {url}. Provide a detailed visual analysis."},
-        ]
-        return await self.llm(messages, task_id=task_id, session_id=session_id, temperature=0.5)

agents/chat_agent.py

@@ -1,44 +0,0 @@
-"""
-ChatAgent — Conversational interface with streaming, Burmese support
-"""
-from typing import Dict
-import structlog
-from .base_agent import BaseAgent
-
-log = structlog.get_logger()
-
-CHAT_SYSTEM = """You are God Agent — an elite autonomous AI operating system.
-You support both English and Burmese (မြန်မာဘာသာ) languages.
-Be helpful, precise, and autonomous. 
-When users write in Burmese, respond in Burmese.
-When discussing code, provide production-quality examples.
-"""
-
-
-class ChatAgent(BaseAgent):
-    def __init__(self, ws_manager=None, ai_router=None):
-        super().__init__("ChatAgent", ws_manager, ai_router)
-
-    async def run(self, task: str, context: Dict = {}, **kwargs) -> str:
-        session_id = kwargs.get("session_id", "")
-        task_id = kwargs.get("task_id", "")
-
-        history = context.get("history", [])
-        messages = [{"role": "system", "content": CHAT_SYSTEM}]
-
-        for h in history[-10:]:
-            messages.append({"role": h.get("role", "user"), "content": h.get("content", "")})
-
-        messages.append({"role": "user", "content": task})
-
-        await self.emit_chat(session_id, "stream_start", {"agent": "ChatAgent", "status": "generating"})
-
-        response = await self.llm(messages, task_id=task_id, session_id=session_id)
-
-        await self.emit_chat(session_id, "stream_end", {
-            "agent": "ChatAgent",
-            "full_response": response,
-            "status": "complete",
-        })
-
-        return response

agents/coding_agent.py

@@ -1,191 +0,0 @@
-"""
-CodingAgent — Autonomous code generation, editing, refactoring (Devin/Genspark style)
-"""
-import json
-import os
-import re
-from typing import Dict, List
-import structlog
-from .base_agent import BaseAgent
-
-log = structlog.get_logger()
-
-CODING_SYSTEM = """You are an elite autonomous software engineer — like Devin combined with Genspark.
-You write production-quality code that is:
-- Clean, readable, well-structured
-- Properly typed (TypeScript/Python type hints)
-- Error-handled and resilient
-- Documented with clear comments
-- Following best practices for the language/framework
-
-When generating code:
-1. Think about the full architecture first
-2. Write complete, runnable code (not snippets)
-3. Include proper imports
-4. Add error handling
-5. Include brief usage examples in comments
-
-Support: Python, TypeScript, JavaScript, Go, Rust, SQL, Shell, YAML, JSON
-"""
-
-
-class CodingAgent(BaseAgent):
-    def __init__(self, ws_manager=None, ai_router=None):
-        super().__init__("CodingAgent", ws_manager, ai_router)
-
-    async def run(self, task: str, context: Dict = {}, **kwargs) -> str:
-        session_id = kwargs.get("session_id", "")
-        task_id = kwargs.get("task_id", "")
-
-        await self.emit(task_id, "agent_start", {
-            "agent": "CodingAgent",
-            "task": task[:80],
-        }, session_id)
-
-        # Build context-aware messages
-        prev_results = context.get("previous_results", [])
-        project_ctx = context.get("project_context", "")
-        plan = context.get("plan", "")
-
-        system_content = CODING_SYSTEM
-        if project_ctx:
-            system_content += f"\n\nProject Context:\n{project_ctx[:1000]}"
-
-        user_content = f"Task: {task}"
-        if plan:
-            user_content += f"\n\nExecution Plan:\n{plan[:500]}"
-        if prev_results:
-            user_content += f"\n\nPrevious results:\n" + "\n".join(str(r)[:200] for r in prev_results[-3:])
-
-        messages = [
-            {"role": "system", "content": system_content},
-            {"role": "user", "content": user_content},
-        ]
-
-        await self.emit(task_id, "tool_called", {
-            "agent": "CodingAgent",
-            "tool": "code_generation",
-            "step": task[:60],
-        }, session_id)
-
-        result = await self.llm(
-            messages,
-            task_id=task_id,
-            session_id=session_id,
-            temperature=0.2,
-            max_tokens=8192,
-        )
-
-        # Extract code blocks for display
-        code_blocks = self._extract_code_blocks(result)
-        await self.emit(task_id, "code_generated", {
-            "agent": "CodingAgent",
-            "code_blocks": len(code_blocks),
-            "total_lines": sum(len(b.split("\n")) for b in code_blocks),
-            "languages": list(set(self._detect_language(b) for b in code_blocks)),
-        }, session_id)
-
-        return result
-
-    async def generate_file(
-        self,
-        filename: str,
-        description: str,
-        task_id: str = "",
-        session_id: str = "",
-        context: Dict = {},
-    ) -> str:
-        """Generate a complete file with proper structure."""
-        messages = [
-            {"role": "system", "content": CODING_SYSTEM},
-            {"role": "user", "content": (
-                f"Generate a complete, production-ready file.\n"
-                f"Filename: {filename}\n"
-                f"Description: {description}\n"
-                f"Context: {json.dumps(context)[:500]}\n\n"
-                f"Return ONLY the file content, no explanation."
-            )},
-        ]
-        content = await self.llm(messages, task_id=task_id, session_id=session_id, temperature=0.1, max_tokens=8192)
-
-        # Strip markdown code fences if present
-        content = self._strip_code_fences(content)
-
-        # Write to workspace
-        workspace = os.environ.get("WORKSPACE_DIR", "/tmp/god_workspace")
-        filepath = os.path.join(workspace, filename)
-        os.makedirs(os.path.dirname(filepath), exist_ok=True)
-        with open(filepath, "w") as f:
-            f.write(content)
-
-        await self.emit(task_id, "file_written", {
-            "filename": filename,
-            "size": len(content),
-            "lines": len(content.split("\n")),
-        }, session_id)
-
-        return content
-
-    async def refactor(
-        self,
-        code: str,
-        instructions: str,
-        task_id: str = "",
-        session_id: str = "",
-    ) -> str:
-        """Refactor existing code based on instructions."""
-        messages = [
-            {"role": "system", "content": CODING_SYSTEM},
-            {"role": "user", "content": (
-                f"Refactor this code based on these instructions:\n"
-                f"Instructions: {instructions}\n\n"
-                f"Original code:\n```\n{code}\n```\n\n"
-                f"Return ONLY the refactored code."
-            )},
-        ]
-        return await self.llm(messages, task_id=task_id, session_id=session_id, temperature=0.1, max_tokens=8192)
-
-    async def scan_repository(self, repo_path: str) -> Dict:
-        """Scan repository and build project intelligence graph."""
-        import subprocess
-        try:
-            result = subprocess.run(
-                ["find", repo_path, "-type", "f", "-name", "*.py", "-o",
-                 "-name", "*.ts", "-o", "-name", "*.js", "-o", "-name", "*.go"],
-                capture_output=True, text=True, timeout=10
-            )
-            files = result.stdout.strip().split("\n")[:50]
-
-            # Read key files
-            key_files = {}
-            for f in ["package.json", "requirements.txt", "tsconfig.json", "pyproject.toml", "go.mod"]:
-                path = os.path.join(repo_path, f)
-                if os.path.exists(path):
-                    with open(path) as fp:
-                        key_files[f] = fp.read()[:1000]
-
-            return {
-                "files": files,
-                "key_configs": key_files,
-                "total_files": len(files),
-            }
-        except Exception as e:
-            return {"error": str(e), "files": [], "key_configs": {}}
-
-    def _extract_code_blocks(self, text: str) -> List[str]:
-        pattern = r"```[\w]*\n(.*?)```"
-        return re.findall(pattern, text, re.DOTALL)
-
-    def _strip_code_fences(self, text: str) -> str:
-        text = re.sub(r"^```[\w]*\n", "", text.strip())
-        text = re.sub(r"\n```$", "", text)
-        return text
-
-    def _detect_language(self, code: str) -> str:
-        if "def " in code and "import " in code:
-            return "python"
-        if "function " in code or "const " in code or "interface " in code:
-            return "typescript"
-        if "package main" in code:
-            return "go"
-        return "unknown"

agents/connector_agent.py

@@ -1,186 +0,0 @@
-"""
-ConnectorAgent — GitHub, HuggingFace, Vercel, n8n, Telegram, Discord integrations
-"""
-import json
-import os
-from typing import Dict, List, Optional
-import httpx
-import structlog
-from .base_agent import BaseAgent
-
-log = structlog.get_logger()
-
-
-class ConnectorAgent(BaseAgent):
-    def __init__(self, ws_manager=None, ai_router=None):
-        super().__init__("ConnectorAgent", ws_manager, ai_router)
-
-    async def run(self, task: str, context: Dict = {}, **kwargs) -> str:
-        session_id = kwargs.get("session_id", "")
-        task_id = kwargs.get("task_id", "")
-
-        task_lower = task.lower()
-
-        if "github" in task_lower:
-            return await self.github_operation(task, task_id=task_id, session_id=session_id)
-        elif "huggingface" in task_lower or "hf" in task_lower:
-            return await self.hf_operation(task, task_id=task_id, session_id=session_id)
-        elif "vercel" in task_lower:
-            return await self.vercel_operation(task, task_id=task_id, session_id=session_id)
-        else:
-            return await self._generic_connector(task, task_id=task_id, session_id=session_id)
-
-    # ─── GitHub ───────────────────────────────────────────────────────────────
-
-    async def github_operation(self, task: str, task_id: str = "", session_id: str = "") -> str:
-        token = os.environ.get("GITHUB_TOKEN", "")
-        if not token:
-            return "⚠️ GITHUB_TOKEN not set. Please add it to environment variables."
-
-        headers = {
-            "Authorization": f"token {token}",
-            "Accept": "application/vnd.github.v3+json",
-        }
-
-        task_lower = task.lower()
-
-        try:
-            async with httpx.AsyncClient(timeout=30) as client:
-                if "create repo" in task_lower or "new repo" in task_lower:
-                    return await self._github_create_repo(client, headers, task, task_id, session_id)
-                elif "list repo" in task_lower:
-                    return await self._github_list_repos(client, headers, task_id, session_id)
-                elif "commit" in task_lower:
-                    return f"✅ GitHub commit operation noted. Use SandboxAgent for actual commits."
-                elif "issue" in task_lower:
-                    return await self._github_create_issue(client, headers, task, task_id, session_id)
-                else:
-                    return await self._github_user_info(client, headers, task_id, session_id)
-        except Exception as e:
-            return f"❌ GitHub error: {str(e)}"
-
-    async def _github_user_info(self, client, headers, task_id, session_id) -> str:
-        resp = await client.get("https://api.github.com/user", headers=headers)
-        if resp.status_code == 200:
-            data = resp.json()
-            await self.emit(task_id, "connector_result", {
-                "connector": "github",
-                "action": "user_info",
-                "user": data.get("login"),
-            }, session_id)
-            return f"✅ GitHub connected as **{data.get('login')}** ({data.get('public_repos')} repos)"
-        return f"❌ GitHub auth failed: {resp.status_code}"
-
-    async def _github_create_repo(self, client, headers, task, task_id, session_id) -> str:
-        # Extract repo name from task using simple heuristic
-        words = task.split()
-        name_candidates = [w for w in words if w.replace("-", "").replace("_", "").isalnum() and len(w) > 3]
-        repo_name = name_candidates[-1] if name_candidates else "god-agent-project"
-
-        payload = {
-            "name": repo_name,
-            "description": "Created by God Agent Platform",
-            "private": False,
-            "auto_init": True,
-        }
-        resp = await client.post("https://api.github.com/user/repos", headers=headers, json=payload)
-        if resp.status_code == 201:
-            data = resp.json()
-            await self.emit(task_id, "connector_result", {
-                "connector": "github",
-                "action": "repo_created",
-                "repo": data.get("full_name"),
-                "url": data.get("html_url"),
-            }, session_id)
-            return f"✅ GitHub repo created: [{data.get('full_name')}]({data.get('html_url')})"
-        return f"❌ Failed to create repo: {resp.status_code} — {resp.text[:200]}"
-
-    async def _github_list_repos(self, client, headers, task_id, session_id) -> str:
-        resp = await client.get("https://api.github.com/user/repos?per_page=10&sort=updated", headers=headers)
-        if resp.status_code == 200:
-            repos = resp.json()
-            lines = [f"- [{r['full_name']}]({r['html_url']}) ⭐{r['stargazers_count']}" for r in repos[:10]]
-            return "📦 **Your GitHub Repos:**\n\n" + "\n".join(lines)
-        return f"❌ Failed to list repos: {resp.status_code}"
-
-    async def _github_create_issue(self, client, headers, task, task_id, session_id) -> str:
-        return "✅ GitHub issue creation requires repo context. Specify: 'create issue in owner/repo: title'"
-
-    # ─── HuggingFace ──────────────────────────────────────────────────────────
-
-    async def hf_operation(self, task: str, task_id: str = "", session_id: str = "") -> str:
-        token = os.environ.get("HF_TOKEN", "")
-        if not token:
-            return "⚠️ HF_TOKEN not set. Add HuggingFace token to environment."
-
-        headers = {"Authorization": f"Bearer {token}"}
-        try:
-            async with httpx.AsyncClient(timeout=30) as client:
-                resp = await client.get("https://huggingface.co/api/whoami", headers=headers)
-                if resp.status_code == 200:
-                    data = resp.json()
-                    await self.emit(task_id, "connector_result", {
-                        "connector": "huggingface",
-                        "user": data.get("name"),
-                    }, session_id)
-                    return f"✅ HuggingFace connected as **{data.get('name')}**"
-                return f"❌ HF auth failed: {resp.status_code}"
-        except Exception as e:
-            return f"❌ HuggingFace error: {str(e)}"
-
-    # ─── Vercel ───────────────────────────────────────────────────────────────
-
-    async def vercel_operation(self, task: str, task_id: str = "", session_id: str = "") -> str:
-        token = os.environ.get("VERCEL_TOKEN", "")
-        if not token:
-            return "⚠️ VERCEL_TOKEN not set. Add Vercel token to environment."
-
-        headers = {"Authorization": f"Bearer {token}"}
-        try:
-            async with httpx.AsyncClient(timeout=30) as client:
-                resp = await client.get("https://api.vercel.com/v2/user", headers=headers)
-                if resp.status_code == 200:
-                    data = resp.json()
-                    user = data.get("user", {})
-                    await self.emit(task_id, "connector_result", {
-                        "connector": "vercel",
-                        "user": user.get("username"),
-                    }, session_id)
-                    return f"✅ Vercel connected as **{user.get('username')}** ({user.get('email')})"
-                return f"❌ Vercel auth failed: {resp.status_code}"
-        except Exception as e:
-            return f"❌ Vercel error: {str(e)}"
-
-    async def _generic_connector(self, task: str, task_id: str = "", session_id: str = "") -> str:
-        return (
-            "🔌 **Available Connectors:**\n\n"
-            "| Connector | Status | Env Var |\n"
-            "|-----------|--------|---------||\n"
-            f"| GitHub | {'✅' if os.environ.get('GITHUB_TOKEN') else '❌'} | GITHUB_TOKEN |\n"
-            f"| HuggingFace | {'✅' if os.environ.get('HF_TOKEN') else '❌'} | HF_TOKEN |\n"
-            f"| Vercel | {'✅' if os.environ.get('VERCEL_TOKEN') else '❌'} | VERCEL_TOKEN |\n"
-            f"| OpenAI | {'✅' if os.environ.get('OPENAI_API_KEY') else '❌'} | OPENAI_API_KEY |\n"
-            f"| Groq | {'✅' if os.environ.get('GROQ_API_KEY') else '❌'} | GROQ_API_KEY |\n"
-            f"| OpenRouter | {'✅' if os.environ.get('OPENROUTER_API_KEY') else '❌'} | OPENROUTER_API_KEY |\n"
-        )
-
-    def get_connector_status(self) -> Dict:
-        """Return status of all connectors."""
-        connectors = {
-            "github": bool(os.environ.get("GITHUB_TOKEN")),
-            "huggingface": bool(os.environ.get("HF_TOKEN")),
-            "vercel": bool(os.environ.get("VERCEL_TOKEN")),
-            "openai": bool(os.environ.get("OPENAI_API_KEY")),
-            "groq": bool(os.environ.get("GROQ_API_KEY")),
-            "cerebras": bool(os.environ.get("CEREBRAS_API_KEY")),
-            "openrouter": bool(os.environ.get("OPENROUTER_API_KEY")),
-            "anthropic": bool(os.environ.get("ANTHROPIC_API_KEY")),
-            "n8n": bool(os.environ.get("N8N_URL")),
-            "telegram": bool(os.environ.get("TELEGRAM_BOT_TOKEN")),
-            "discord": bool(os.environ.get("DISCORD_BOT_TOKEN")),
-        }
-        return {
-            "connectors": connectors,
-            "connected_count": sum(connectors.values()),
-            "total": len(connectors),
-        }

agents/debug_agent.py

@@ -1,158 +0,0 @@
-"""
-DebugAgent — Autonomous error detection, self-healing, retry loops
-"""
-import json
-import re
-from typing import Dict, List
-import structlog
-from .base_agent import BaseAgent
-
-log = structlog.get_logger()
-
-DEBUG_SYSTEM = """You are an expert debugging engineer with deep knowledge of:
-- Python, TypeScript, JavaScript, Go, Rust errors
-- Runtime exceptions, import errors, type errors
-- API errors, network failures, auth issues
-- Build failures, dependency conflicts
-- Database errors, query optimization
-
-When given an error:
-1. Identify the root cause precisely
-2. Provide the EXACT fix (code patch or config change)
-3. Explain WHY it failed
-4. Suggest prevention strategies
-
-Always return actionable fixes, not just explanations.
-"""
-
-
-class DebugAgent(BaseAgent):
-    def __init__(self, ws_manager=None, ai_router=None):
-        super().__init__("DebugAgent", ws_manager, ai_router)
-
-    async def run(self, task: str, context: Dict = {}, **kwargs) -> str:
-        session_id = kwargs.get("session_id", "")
-        task_id = kwargs.get("task_id", "")
-        attempt = context.get("attempt", 1)
-
-        await self.emit(task_id, "agent_start", {
-            "agent": "DebugAgent",
-            "attempt": attempt,
-            "error": task[:100],
-        }, session_id)
-
-        messages = [
-            {"role": "system", "content": DEBUG_SYSTEM},
-            {"role": "user", "content": (
-                "Debug and fix this issue (attempt " + str(attempt) + "):\n\n"
-                + task + "\n\n"
-                "Provide:\n"
-                "1. Root cause analysis\n"
-                "2. Exact fix (code/config)\n"
-                "3. Prevention strategy"
-            )},
-        ]
-
-        result = await self.llm(
-            messages,
-            task_id=task_id,
-            session_id=session_id,
-            temperature=0.1,
-            max_tokens=4096,
-        )
-
-        await self.emit(task_id, "debug_complete", {
-            "agent": "DebugAgent",
-            "has_fix": "```" in result or "fix" in result.lower(),
-            "attempt": attempt,
-        }, session_id)
-
-        return result
-
-    async def analyze_error(self, error_output: str, source_code: str = "", task_id: str = "", session_id: str = "") -> Dict:
-        """Deep error analysis with structured output."""
-        if source_code:
-            source_section = "Source Code:\n```\n" + source_code[:1000] + "\n```"
-        else:
-            source_section = ""
-
-        messages = [
-            {"role": "system", "content": DEBUG_SYSTEM},
-            {"role": "user", "content": (
-                "Analyze this error and provide structured diagnosis:\n\n"
-                "Error:\n" + error_output[:2000] + "\n\n"
-                + source_section + "\n\n"
-                "Respond with JSON:\n"
-                '{"error_type": "...", "root_cause": "...", "fix": "...", "prevention": "...", "severity": "low|medium|high|critical"}'
-            )},
-        ]
-        raw = await self.llm(messages, task_id=task_id, session_id=session_id, temperature=0.1, max_tokens=1000)
-        try:
-            start = raw.find("{")
-            end = raw.rfind("}") + 1
-            return json.loads(raw[start:end])
-        except Exception:
-            return {"error_type": "unknown", "root_cause": error_output[:200], "fix": raw[:500], "severity": "medium"}
-
-    async def self_heal_loop(
-        self,
-        code: str,
-        error: str,
-        max_retries: int = 3,
-        task_id: str = "",
-        session_id: str = "",
-    ) -> str:
-        """Self-healing loop — generate fix, validate, retry."""
-        current_code = code
-        current_error = error
-
-        for attempt in range(1, max_retries + 1):
-            await self.emit(task_id, "self_heal_attempt", {
-                "attempt": attempt,
-                "max_retries": max_retries,
-                "error_snippet": current_error[:100],
-            }, session_id)
-
-            messages = [
-                {"role": "system", "content": DEBUG_SYSTEM},
-                {"role": "user", "content": (
-                    "Fix attempt " + str(attempt) + "/" + str(max_retries) + ":\n\n"
-                    "Error: " + current_error + "\n\n"
-                    "Code:\n```\n" + current_code[:3000] + "\n```\n\n"
-                    "Return ONLY the fixed code."
-                )},
-            ]
-
-            fixed = await self.llm(messages, task_id=task_id, session_id=session_id, temperature=0.1, max_tokens=8192)
-            fixed = self._strip_fences(fixed)
-
-            # Validate syntax for Python
-            validation = await self._validate_python(fixed)
-            if validation["valid"]:
-                await self.emit(task_id, "self_heal_success", {
-                    "attempt": attempt,
-                    "code_lines": len(fixed.split("\n")),
-                }, session_id)
-                return fixed
-            else:
-                current_code = fixed
-                current_error = validation["error"]
-                log.warning("Self-heal attempt failed", attempt=attempt, error=current_error[:100])
-
-        await self.emit(task_id, "self_heal_failed", {"attempts": max_retries}, session_id)
-        return current_code  # Return best attempt
-
-    async def _validate_python(self, code: str) -> Dict:
-        """Quick Python syntax validation."""
-        try:
-            compile(code, "<string>", "exec")
-            return {"valid": True, "error": ""}
-        except SyntaxError as e:
-            return {"valid": False, "error": "SyntaxError: " + str(e)}
-        except Exception as e:
-            return {"valid": False, "error": str(e)}
-
-    def _strip_fences(self, text: str) -> str:
-        text = re.sub(r"^```[\w]*\n", "", text.strip())
-        text = re.sub(r"\n```$", "", text)
-        return text

agents/deploy_agent.py

@@ -1,101 +0,0 @@
-"""
-DeployAgent — Automated deployments to Vercel, HF Spaces, GitHub Pages
-"""
-import json
-import os
-from typing import Dict
-import httpx
-import structlog
-from .base_agent import BaseAgent
-
-log = structlog.get_logger()
-
-DEPLOY_SYSTEM = """You are a deployment engineer expert in:
-- Vercel deployments (Next.js, React, API routes)
-- HuggingFace Spaces (Docker, Gradio, Streamlit)
-- GitHub Pages (static sites)
-- Docker containerization
-- Environment variable management
-
-Generate precise deployment configs and commands.
-"""
-
-
-class DeployAgent(BaseAgent):
-    def __init__(self, ws_manager=None, ai_router=None):
-        super().__init__("DeployAgent", ws_manager, ai_router)
-
-    async def run(self, task: str, context: Dict = {}, **kwargs) -> str:
-        session_id = kwargs.get("session_id", "")
-        task_id = kwargs.get("task_id", "")
-
-        await self.emit(task_id, "agent_start", {"agent": "DeployAgent", "task": task[:80]}, session_id)
-
-        task_lower = task.lower()
-        if "vercel" in task_lower:
-            return await self._deploy_vercel_guide(task, task_id, session_id)
-        elif "huggingface" in task_lower or "hf" in task_lower or "space" in task_lower:
-            return await self._deploy_hf_guide(task, task_id, session_id)
-        elif "docker" in task_lower:
-            return await self._generate_dockerfile(task, task_id, session_id)
-        else:
-            return await self._deploy_general(task, task_id, session_id)
-
-    async def _deploy_vercel_guide(self, task: str, task_id: str, session_id: str) -> str:
-        messages = [
-            {"role": "system", "content": DEPLOY_SYSTEM},
-            {"role": "user", "content": (
-                f"Generate complete Vercel deployment guide for: {task}\n\n"
-                f"Include:\n1. vercel.json config\n2. Environment variables needed\n"
-                f"3. Build commands\n4. Step-by-step deployment instructions"
-            )},
-        ]
-        result = await self.llm(messages, task_id=task_id, session_id=session_id, temperature=0.2)
-        await self.emit(task_id, "deploy_plan_ready", {"platform": "vercel"}, session_id)
-        return result
-
-    async def _deploy_hf_guide(self, task: str, task_id: str, session_id: str) -> str:
-        messages = [
-            {"role": "system", "content": DEPLOY_SYSTEM},
-            {"role": "user", "content": (
-                f"Generate HuggingFace Space deployment for: {task}\n\n"
-                f"Include:\n1. Dockerfile\n2. README.md with YAML header\n"
-                f"3. Requirements/dependencies\n4. Space configuration"
-            )},
-        ]
-        result = await self.llm(messages, task_id=task_id, session_id=session_id, temperature=0.2)
-        await self.emit(task_id, "deploy_plan_ready", {"platform": "huggingface"}, session_id)
-        return result
-
-    async def _generate_dockerfile(self, task: str, task_id: str, session_id: str) -> str:
-        messages = [
-            {"role": "system", "content": DEPLOY_SYSTEM},
-            {"role": "user", "content": f"Generate production Dockerfile for: {task}\nInclude multi-stage build, security best practices, health check."},
-        ]
-        return await self.llm(messages, task_id=task_id, session_id=session_id, temperature=0.1)
-
-    async def _deploy_general(self, task: str, task_id: str, session_id: str) -> str:
-        messages = [
-            {"role": "system", "content": DEPLOY_SYSTEM},
-            {"role": "user", "content": f"Create deployment plan for: {task}\n\nInclude platform recommendation, config files, and step-by-step guide."},
-        ]
-        return await self.llm(messages, task_id=task_id, session_id=session_id)
-
-    async def check_vercel_deployments(self) -> str:
-        """Check recent Vercel deployments."""
-        token = os.environ.get("VERCEL_TOKEN", "")
-        if not token:
-            return "⚠️ VERCEL_TOKEN not set."
-        try:
-            async with httpx.AsyncClient(timeout=15) as client:
-                resp = await client.get(
-                    "https://api.vercel.com/v6/deployments?limit=5",
-                    headers={"Authorization": f"Bearer {token}"}
-                )
-                if resp.status_code == 200:
-                    deps = resp.json().get("deployments", [])
-                    lines = [f"- {d.get('name')} → {d.get('state')} ({d.get('url', '')})" for d in deps[:5]]
-                    return "🚀 **Recent Vercel Deployments:**\n\n" + "\n".join(lines)
-        except Exception as e:
-            return f"❌ Vercel error: {e}"
-        return "No deployments found."

agents/file_agent.py

@@ -1,227 +0,0 @@
-"""
-FileAgent v7 — Autonomous file system management, code editing, project scaffolding
-Like Devin's file browser + OneHand's file manipulation
-"""
-import asyncio
-import json
-import os
-import re
-import shutil
-from pathlib import Path
-from typing import Dict, List, Optional
-import structlog
-from .base_agent import BaseAgent
-
-log = structlog.get_logger()
-
-FILE_SYSTEM = """You are an elite file system and project management agent.
-You can:
-- Create, read, edit, delete files and directories
-- Scaffold complete project structures
-- Analyze codebases and suggest improvements
-- Generate file trees and project maps
-- Apply patches and diffs to code files
-- Manage project configuration files
-
-Always provide complete, runnable file content.
-"""
-
-WORKSPACE = os.environ.get("WORKSPACE_DIR", "/tmp/god_workspace")
-
-class FileAgent(BaseAgent):
-    def __init__(self, ws_manager=None, ai_router=None):
-        super().__init__("FileAgent", ws_manager, ai_router)
-        os.makedirs(WORKSPACE, exist_ok=True)
-
-    async def run(self, task: str, context: Dict = {}, **kwargs) -> str:
-        session_id = kwargs.get("session_id", "")
-        task_id = kwargs.get("task_id", "")
-
-        await self.emit(task_id, "agent_start", {"agent": "FileAgent", "task": task[:80]}, session_id)
-
-        task_lower = task.lower()
-        if any(k in task_lower for k in ["create", "scaffold", "generate", "new project", "init"]):
-            result = await self._scaffold_project(task, context, task_id, session_id)
-        elif any(k in task_lower for k in ["read", "show", "view", "list", "tree"]):
-            result = await self._read_or_list(task, task_id, session_id)
-        elif any(k in task_lower for k in ["edit", "modify", "update", "change", "fix", "patch"]):
-            result = await self._edit_file(task, context, task_id, session_id)
-        elif any(k in task_lower for k in ["delete", "remove", "clean"]):
-            result = await self._delete_files(task, task_id, session_id)
-        else:
-            result = await self._ai_file_task(task, context, task_id, session_id)
-
-        return result
-
-    async def _scaffold_project(self, task: str, context: Dict, task_id: str, session_id: str) -> str:
-        """Scaffold a complete project structure."""
-        await self.emit(task_id, "tool_called", {
-            "agent": "FileAgent", "tool": "scaffold_project", "step": "Generating project structure"
-        }, session_id)
-
-        messages = [
-            {"role": "system", "content": FILE_SYSTEM},
-            {"role": "user", "content": (
-                f"Task: {task}\n\n"
-                "Generate a complete project scaffold. Return a JSON object with this structure:\n"
-                "{\n"
-                '  "project_name": "name",\n'
-                '  "files": [\n'
-                '    {"path": "relative/path/file.ext", "content": "full file content here"}\n'
-                "  ],\n"
-                '  "description": "what was created",\n'
-                '  "run_commands": ["npm install", "npm run dev"]\n'
-                "}\n"
-                "Include all necessary files for a working project."
-            )},
-        ]
-        response = await self.llm(messages, task_id=task_id, session_id=session_id, temperature=0.2, max_tokens=8192)
-
-        # Parse JSON and create files
-        created_files = []
-        try:
-            start = response.find("{")
-            end = response.rfind("}") + 1
-            if start >= 0 and end > start:
-                data = json.loads(response[start:end])
-                project_name = data.get("project_name", "project")
-                project_path = os.path.join(WORKSPACE, project_name)
-                os.makedirs(project_path, exist_ok=True)
-
-                for f in data.get("files", []):
-                    filepath = os.path.join(project_path, f["path"])
-                    os.makedirs(os.path.dirname(filepath), exist_ok=True)
-                    with open(filepath, "w") as fp:
-                        fp.write(f["content"])
-                    created_files.append(f["path"])
-                    await self.emit(task_id, "file_written", {
-                        "path": f["path"], "size": len(f["content"])
-                    }, session_id)
-
-                result = (
-                    f"✅ **Project Scaffolded**: `{project_name}`\n\n"
-                    f"**Files Created** ({len(created_files)}):\n"
-                    + "\n".join(f"- `{f}`" for f in created_files)
-                    + f"\n\n**Description:** {data.get('description', '')}\n\n"
-                    + "**Run Commands:**\n"
-                    + "\n".join(f"```\n{cmd}\n```" for cmd in data.get("run_commands", []))
-                )
-                return result
-        except Exception as e:
-            log.warning("Failed to parse project scaffold JSON", error=str(e))
-
-        return response
-
-    async def _read_or_list(self, task: str, task_id: str, session_id: str) -> str:
-        """Read files or list directory structure."""
-        await self.emit(task_id, "tool_called", {
-            "agent": "FileAgent", "tool": "read_files", "step": "Reading file system"
-        }, session_id)
-
-        # Extract path from task
-        path_match = re.search(r'["\']([^"\']+)["\']|(\S+\.\w+)', task)
-        target_path = path_match.group(1) or path_match.group(2) if path_match else WORKSPACE
-
-        if not os.path.isabs(target_path):
-            target_path = os.path.join(WORKSPACE, target_path)
-
-        if os.path.isdir(target_path):
-            tree = self._get_tree(target_path)
-            return f"**Directory Tree:** `{target_path}`\n\n```\n{tree}\n```"
-        elif os.path.isfile(target_path):
-            with open(target_path) as f:
-                content = f.read()
-            return f"**File:** `{target_path}`\n\n```\n{content[:4000]}\n```"
-        else:
-            # List workspace
-            tree = self._get_tree(WORKSPACE, max_depth=3)
-            return f"**Workspace:** `{WORKSPACE}`\n\n```\n{tree}\n```"
-
-    async def _edit_file(self, task: str, context: Dict, task_id: str, session_id: str) -> str:
-        """Edit a file based on instructions."""
-        await self.emit(task_id, "tool_called", {
-            "agent": "FileAgent", "tool": "edit_file", "step": "Editing file"
-        }, session_id)
-
-        messages = [
-            {"role": "system", "content": FILE_SYSTEM},
-            {"role": "user", "content": (
-                f"Task: {task}\n\n"
-                f"Context: {json.dumps(context)[:500]}\n\n"
-                "Return a JSON with: {\"filepath\": \"path\", \"content\": \"full new file content\", \"explanation\": \"what changed\"}"
-            )},
-        ]
-        response = await self.llm(messages, task_id=task_id, session_id=session_id, temperature=0.1, max_tokens=8192)
-
-        try:
-            start = response.find("{")
-            end = response.rfind("}") + 1
-            if start >= 0 and end > start:
-                data = json.loads(response[start:end])
-                filepath = os.path.join(WORKSPACE, data.get("filepath", "output.txt"))
-                os.makedirs(os.path.dirname(filepath), exist_ok=True)
-                with open(filepath, "w") as f:
-                    f.write(data.get("content", ""))
-                await self.emit(task_id, "file_written", {"path": data.get("filepath"), "edited": True}, session_id)
-                return f"✅ **File Edited:** `{data.get('filepath')}`\n\n{data.get('explanation', '')}"
-        except Exception:
-            pass
-        return response
-
-    async def _delete_files(self, task: str, task_id: str, session_id: str) -> str:
-        """Delete files or directories safely."""
-        path_match = re.search(r'["\']([^"\']+)["\']', task)
-        if path_match:
-            target = os.path.join(WORKSPACE, path_match.group(1))
-            if os.path.exists(target) and WORKSPACE in target:
-                if os.path.isdir(target):
-                    shutil.rmtree(target)
-                else:
-                    os.remove(target)
-                await self.emit(task_id, "file_deleted", {"path": path_match.group(1)}, session_id)
-                return f"✅ Deleted: `{path_match.group(1)}`"
-        return "❌ Could not find file/directory to delete. Please specify the path in quotes."
-
-    async def _ai_file_task(self, task: str, context: Dict, task_id: str, session_id: str) -> str:
-        """Handle generic file tasks via AI."""
-        messages = [
-            {"role": "system", "content": FILE_SYSTEM},
-            {"role": "user", "content": f"Task: {task}\n\nWorkspace: {WORKSPACE}\n\nContext: {json.dumps(context)[:300]}"},
-        ]
-        return await self.llm(messages, task_id=task_id, session_id=session_id, temperature=0.3, max_tokens=4096)
-
-    def _get_tree(self, path: str, prefix: str = "", max_depth: int = 4, depth: int = 0) -> str:
-        """Generate a directory tree string."""
-        if depth > max_depth:
-            return ""
-        try:
-            entries = sorted(os.scandir(path), key=lambda e: (e.is_file(), e.name))
-        except PermissionError:
-            return ""
-        lines = []
-        for i, entry in enumerate(entries):
-            if entry.name.startswith(".") and entry.name not in [".env", ".gitignore"]:
-                continue
-            connector = "└── " if i == len(entries) - 1 else "├── "
-            lines.append(f"{prefix}{connector}{entry.name}")
-            if entry.is_dir() and depth < max_depth:
-                extension = "    " if i == len(entries) - 1 else "│   "
-                subtree = self._get_tree(entry.path, prefix + extension, max_depth, depth + 1)
-                if subtree:
-                    lines.append(subtree)
-        return "\n".join(lines)
-
-    def list_workspace(self) -> Dict:
-        """List all workspace files."""
-        files = []
-        for root, dirs, filenames in os.walk(WORKSPACE):
-            dirs[:] = [d for d in dirs if not d.startswith(".") and d != "node_modules"]
-            for f in filenames:
-                full_path = os.path.join(root, f)
-                rel_path = os.path.relpath(full_path, WORKSPACE)
-                try:
-                    size = os.path.getsize(full_path)
-                    files.append({"path": rel_path, "size": size})
-                except Exception:
-                    pass
-        return {"workspace": WORKSPACE, "files": files, "total": len(files)}

agents/git_agent.py

@@ -1,120 +0,0 @@
-"""
-GitAgent v7 — Autonomous Git operations, PR creation, code review
-Full GitHub integration like Manus/Genspark autonomous coding
-"""
-import asyncio
-import json
-import os
-import re
-from typing import Dict, List
-import structlog
-from .base_agent import BaseAgent
-
-log = structlog.get_logger()
-
-GIT_SYSTEM = """You are an elite autonomous Git and GitHub operations agent.
-You can clone, commit, push, pull, create branches, PRs, review code,
-generate commit messages, manage workflows, and handle merge conflicts.
-Always write clear, conventional commit messages (feat/fix/chore/docs/refactor).
-"""
-
-
-class GitAgent(BaseAgent):
-    def __init__(self, ws_manager=None, ai_router=None):
-        super().__init__("GitAgent", ws_manager, ai_router)
-        self.workspace = os.environ.get("WORKSPACE_DIR", "/tmp/god_workspace")
-
-    async def run(self, task: str, context: Dict = {}, **kwargs) -> str:
-        session_id = kwargs.get("session_id", "")
-        task_id = kwargs.get("task_id", "")
-        await self.emit(task_id, "agent_start", {"agent": "GitAgent", "task": task[:80]}, session_id)
-
-        t = task.lower()
-        if any(k in t for k in ["clone", "checkout"]):
-            return await self._clone_repo(task, context, task_id, session_id)
-        if any(k in t for k in ["commit", "push", "pull request", " pr "]):
-            return await self._commit_and_push(task, context, task_id, session_id)
-        if any(k in t for k in ["review", "analyze code", "audit"]):
-            return await self._code_review(task, context, task_id, session_id)
-        return await self._git_ai_task(task, context, task_id, session_id)
-
-    async def _clone_repo(self, task: str, context: Dict, task_id: str, session_id: str) -> str:
-        urls = re.findall(r'https?://github\.com/[^\s]+', task)
-        if not urls:
-            return "❌ No GitHub URL found in task."
-        url = urls[0]
-        repo_name = url.rstrip("/").split("/")[-1].replace(".git", "")
-        dest = os.path.join(self.workspace, repo_name)
-        await self.emit(task_id, "tool_called", {"agent": "GitAgent", "tool": "git_clone", "step": f"Cloning {repo_name}"}, session_id)
-        token = os.environ.get("GITHUB_TOKEN", "")
-        auth_url = url.replace("https://", f"https://{token}@") if token else url
-        r = await self._run_cmd(["git", "clone", auth_url, dest])
-        if r["returncode"] == 0:
-            await self.emit(task_id, "git_cloned", {"repo": repo_name, "path": dest}, session_id)
-            return f"✅ **Cloned** `{repo_name}` → `{dest}`\n```\n{r['stdout'][:500]}\n```"
-        return f"❌ Clone failed:\n```\n{r['stderr'][:500]}\n```"
-
-    async def _commit_and_push(self, task: str, context: Dict, task_id: str, session_id: str) -> str:
-        repo_path = context.get("repo_path", self.workspace)
-        await self.emit(task_id, "tool_called", {"agent": "GitAgent", "tool": "git_commit", "step": "Committing"}, session_id)
-        msgs = [
-            {"role": "system", "content": "Generate a conventional commit message. Return ONLY the one-line message."},
-            {"role": "user", "content": f"Task: {task}\nContext: {json.dumps(context)[:200]}"},
-        ]
-        commit_msg = (await self.llm(msgs, task_id=task_id, session_id=session_id, temperature=0.3, max_tokens=80)).strip().split("\n")[0][:100]
-        results = []
-        for cmd in [["git", "add", "-A"], ["git", "commit", "-m", commit_msg]]:
-            r = await self._run_cmd(cmd, cwd=repo_path)
-            results.append(f"$ {' '.join(cmd)}\n{r['stdout']}{r['stderr']}")
-        branch = context.get("branch", "main")
-        r = await self._run_cmd(["git", "push", "origin", branch], cwd=repo_path)
-        results.append(f"$ git push\n{r['stdout']}{r['stderr']}")
-        return f"✅ **Committed:** `{commit_msg}`\n\n```\n" + "\n".join(results) + "\n```"
-
-    async def _code_review(self, task: str, context: Dict, task_id: str, session_id: str) -> str:
-        repo_path = context.get("repo_path", self.workspace)
-        diff = await self._run_cmd(["git", "diff", "HEAD~1"], cwd=repo_path)
-        msgs = [
-            {"role": "system", "content": GIT_SYSTEM},
-            {"role": "user", "content": f"Task: {task}\n\nDiff:\n{diff['stdout'][:2500]}\n\nProvide code review: summary, issues, suggestions, score (1-10)."},
-        ]
-        return await self.llm(msgs, task_id=task_id, session_id=session_id, temperature=0.3, max_tokens=4096)
-
-    async def _git_ai_task(self, task: str, context: Dict, task_id: str, session_id: str) -> str:
-        msgs = [
-            {"role": "system", "content": GIT_SYSTEM},
-            {"role": "user", "content": f"Task: {task}\nWorkspace: {self.workspace}\nContext: {json.dumps(context)[:300]}"},
-        ]
-        return await self.llm(msgs, task_id=task_id, session_id=session_id, temperature=0.3, max_tokens=4096)
-
-    async def create_github_pr(self, repo_owner: str, repo_name: str, title: str, body: str,
-                                head_branch: str, base_branch: str = "main",
-                                task_id: str = "", session_id: str = "") -> Dict:
-        import httpx
-        token = os.environ.get("GITHUB_TOKEN", "")
-        if not token:
-            return {"error": "GITHUB_TOKEN not set"}
-        async with httpx.AsyncClient(timeout=30) as client:
-            resp = await client.post(
-                f"https://api.github.com/repos/{repo_owner}/{repo_name}/pulls",
-                headers={"Authorization": f"token {token}", "Accept": "application/vnd.github.v3+json"},
-                json={"title": title, "body": body, "head": head_branch, "base": base_branch},
-            )
-            data = resp.json()
-            if resp.status_code == 201:
-                await self.emit(task_id, "pr_created", {"url": data.get("html_url")}, session_id)
-                return {"success": True, "url": data.get("html_url")}
-            return {"error": data.get("message", "Failed"), "status": resp.status_code}
-
-    async def _run_cmd(self, cmd: List[str], cwd: str = None, timeout: int = 60) -> Dict:
-        try:
-            proc = await asyncio.create_subprocess_exec(
-                *cmd, cwd=cwd or self.workspace,
-                stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE,
-            )
-            stdout, stderr = await asyncio.wait_for(proc.communicate(), timeout=timeout)
-            return {"returncode": proc.returncode,
-                    "stdout": stdout.decode("utf-8", errors="replace"),
-                    "stderr": stderr.decode("utf-8", errors="replace")}
-        except Exception as e:
-            return {"returncode": -1, "stdout": "", "stderr": str(e)}

agents/memory_agent.py

@@ -1,130 +0,0 @@
-"""
-MemoryAgent — Persistent long-term memory system (Phase 5)
-SQLite-backed with semantic search simulation
-"""
-import json
-import time
-from typing import Dict, List, Optional
-import structlog
-from .base_agent import BaseAgent
-from memory.db import save_memory, search_memory, get_history, get_project_memory
-
-log = structlog.get_logger()
-
-
-class MemoryAgent(BaseAgent):
-    def __init__(self, ws_manager=None, ai_router=None):
-        super().__init__("MemoryAgent", ws_manager, ai_router)
-
-    async def run(self, task: str, context: Dict = {}, **kwargs) -> str:
-        session_id = kwargs.get("session_id", "")
-        task_id = kwargs.get("task_id", "")
-
-        # Determine if retrieve or save
-        task_lower = task.lower()
-        if any(k in task_lower for k in ["remember", "save", "store", "record"]):
-            content = context.get("content", task)
-            await self.save(content, session_id=session_id, memory_type="user_directive")
-            return f"✅ Saved to memory: {content[:100]}"
-        else:
-            results = await self.retrieve(task, session_id=session_id)
-            if results:
-                return "📚 **Memory Retrieved:**\n\n" + "\n".join(f"- {r['content'][:200]}" for r in results[:5])
-            return "No relevant memories found."
-
-    async def save(
-        self,
-        content: str,
-        session_id: str = "",
-        project_id: str = "",
-        memory_type: str = "general",
-        key: str = "",
-        metadata: Dict = {},
-    ):
-        """Save content to persistent memory."""
-        await save_memory(
-            content=content,
-            memory_type=memory_type,
-            session_id=session_id,
-            project_id=project_id,
-            key=key,
-            metadata=metadata,
-        )
-
-    async def retrieve(
-        self,
-        query: str,
-        session_id: str = "",
-        project_id: str = "",
-        limit: int = 10,
-    ) -> List[Dict]:
-        """Retrieve relevant memories."""
-        return await search_memory(query[:100], session_id=session_id, project_id=project_id, limit=limit)
-
-    async def get_conversation_history(self, session_id: str, limit: int = 20) -> List[Dict]:
-        """Get conversation history for a session."""
-        return await get_history(session_id, limit=limit)
-
-    async def save_interaction(
-        self,
-        user_message: str,
-        assistant_response: str,
-        session_id: str = "",
-        intent: Dict = {},
-    ):
-        """Save a full interaction to memory."""
-        await save_memory(
-            content=user_message,
-            memory_type="conversation",
-            session_id=session_id,
-            key="user_message",
-            metadata={"intent": intent.get("intent", ""), "timestamp": time.time()},
-        )
-        await save_memory(
-            content=assistant_response,
-            memory_type="conversation",
-            session_id=session_id,
-            key="assistant_response",
-            metadata={"agent": intent.get("primary_agent", "chat"), "timestamp": time.time()},
-        )
-
-    async def save_coding_style(self, style_notes: str, session_id: str = ""):
-        """Remember user's coding preferences."""
-        await save_memory(
-            content=style_notes,
-            memory_type="user_preference",
-            session_id=session_id,
-            key="coding_style",
-            metadata={"category": "coding_style"},
-        )
-
-    async def save_project_context(self, project_id: str, context: Dict):
-        """Save project-specific context."""
-        await save_memory(
-            content=json.dumps(context),
-            memory_type="project_context",
-            project_id=project_id,
-            key="project_context",
-            metadata={"timestamp": time.time()},
-        )
-
-    async def get_project_context(self, project_id: str) -> Optional[Dict]:
-        """Get project context."""
-        results = await get_project_memory(project_id, memory_type="project_context", limit=1)
-        if results:
-            try:
-                return json.loads(results[0]["content"])
-            except Exception:
-                return {"raw": results[0]["content"]}
-        return None
-
-    async def build_context_for_agent(self, session_id: str, query: str) -> Dict:
-        """Build rich context dict for agents from memory."""
-        history = await self.get_conversation_history(session_id, limit=10)
-        relevant = await self.retrieve(query, session_id=session_id, limit=5)
-
-        return {
-            "history": [{"role": "user" if i % 2 == 0 else "assistant", "content": h["content"]} for i, h in enumerate(reversed(history))],
-            "relevant_memories": [r["content"][:200] for r in relevant],
-            "session_id": session_id,
-        }

agents/orchestrator.py

@@ -1,248 +0,0 @@
-"""
-God Agent Orchestrator — Central Brain (Manus-style)
-Routes user intent → correct agent → merges results
-"""
-
-import asyncio
-import json
-import time
-import uuid
-from typing import Any, Dict, List, Optional
-
-import structlog
-
-log = structlog.get_logger()
-
-SYSTEM_PROMPT = """You are GOD AGENT — an elite autonomous AI operating system combining:
-- Manus-style orchestration and planning
-- Devin-style autonomous coding and debugging
-- Genspark-style repo engineering
-
-You coordinate multiple specialized agents:
-- ChatAgent: Conversation and clarification
-- PlannerAgent: Break goals into executable task graphs
-- CodingAgent: Generate, edit, refactor, fix code
-- DebugAgent: Detect and auto-fix errors (self-healing)
-- MemoryAgent: Persistent long-term memory
-- ConnectorAgent: GitHub/HF/Vercel/n8n integrations
-- DeployAgent: Automated deployments
-- WorkflowAgent: n8n workflow generation
-- SandboxAgent: VS Code sandbox execution
-
-You respond in Burmese or English based on user preference.
-Always think step-by-step. Be autonomous, decisive, and thorough.
-"""
-
-
-class GodAgentOrchestrator:
-    """
-    Central orchestrator — routes tasks to specialized agents,
-    merges results, manages agent collaboration.
-    """
-
-    def __init__(self, ws_manager=None, ai_router=None):
-        self.ws = ws_manager
-        self.ai_router = ai_router
-        self._agents: Dict[str, Any] = {}
-        self._active_tasks: Dict[str, Dict] = {}
-
-    def register_agent(self, name: str, agent):
-        self._agents[name] = agent
-        log.info("Agent registered", agent=name)
-
-    def get_agent(self, name: str):
-        return self._agents.get(name)
-
-    # ─── Intent Classification ────────────────────────────────────────────────
-
-    async def classify_intent(self, user_message: str) -> Dict:
-        """Classify user intent to route to correct agent(s)."""
-        classify_prompt = f"""Classify this user request and identify which agents are needed.
-
-User message: "{user_message}"
-
-Respond ONLY with JSON:
-{{
-  "primary_agent": "chat|planner|coding|debug|connector|deploy|workflow|sandbox|memory",
-  "secondary_agents": [],
-  "intent": "brief description",
-  "requires_planning": true/false,
-  "is_code_task": true/false,
-  "is_deployment": true/false,
-  "is_workflow": true/false,
-  "language": "en|my",
-  "complexity": "simple|moderate|complex"
-}}"""
-
-        if self.ai_router:
-            messages = [
-                {"role": "system", "content": "You are an intent classifier. Return only valid JSON."},
-                {"role": "user", "content": classify_prompt},
-            ]
-            raw = await self.ai_router.complete(messages, temperature=0.1, max_tokens=300)
-            try:
-                start = raw.find("{")
-                end = raw.rfind("}") + 1
-                if start >= 0 and end > start:
-                    return json.loads(raw[start:end])
-            except Exception:
-                pass
-
-        # Fallback heuristic classification
-        msg_lower = user_message.lower()
-        is_code = any(k in msg_lower for k in ["code", "build", "create", "write", "fix", "debug", "api", "function", "class", "script", "app"])
-        is_deploy = any(k in msg_lower for k in ["deploy", "vercel", "github", "push", "publish", "release"])
-        is_workflow = any(k in msg_lower for k in ["workflow", "n8n", "automate", "trigger", "pipeline", "schedule"])
-        is_memory = any(k in msg_lower for k in ["remember", "recall", "memory", "history", "previous"])
-
-        primary = "coding" if is_code else ("deploy" if is_deploy else ("workflow" if is_workflow else ("memory" if is_memory else "chat")))
-
-        return {
-            "primary_agent": primary,
-            "secondary_agents": [],
-            "intent": user_message[:80],
-            "requires_planning": is_code or is_deploy,
-            "is_code_task": is_code,
-            "is_deployment": is_deploy,
-            "is_workflow": is_workflow,
-            "language": "my" if any(c > "\u1000" for c in user_message) else "en",
-            "complexity": "complex" if len(user_message) > 200 else "moderate",
-        }
-
-    # ─── Main Orchestration ───────────────────────────────────────────────────
-
-    async def orchestrate(
-        self,
-        user_message: str,
-        session_id: str = "",
-        task_id: str = "",
-        context: Dict = {},
-    ) -> str:
-        """Main orchestration — classify → route → execute → merge."""
-        exec_id = task_id or f"orch_{uuid.uuid4().hex[:8]}"
-
-        await self._emit(session_id, task_id, "orchestrator_start", {
-            "message": user_message[:100],
-            "session_id": session_id,
-        })
-
-        # 1. Classify intent
-        intent = await self.classify_intent(user_message)
-        log.info("Intent classified", **intent)
-
-        await self._emit(session_id, task_id, "intent_classified", {
-            "primary_agent": intent["primary_agent"],
-            "complexity": intent["complexity"],
-            "language": intent["language"],
-        })
-
-        # 2. Build execution plan for complex tasks
-        if intent.get("requires_planning") and intent.get("complexity") == "complex":
-            planner = self._agents.get("planner")
-            if planner:
-                await self._emit(session_id, task_id, "agent_called", {"agent": "PlannerAgent"})
-                plan = await planner.run(user_message, context=context, session_id=session_id, task_id=exec_id)
-                context["plan"] = plan
-
-        # 3. Route to primary agent
-        primary_name = intent["primary_agent"]
-        primary_agent = self._agents.get(primary_name) or self._agents.get("chat")
-
-        if not primary_agent:
-            return f"Agent '{primary_name}' not available."
-
-        await self._emit(session_id, task_id, "agent_called", {
-            "agent": primary_name,
-            "intent": intent["intent"],
-        })
-
-        # 4. Execute primary agent
-        result = await primary_agent.run(
-            user_message,
-            context={**context, "intent": intent},
-            session_id=session_id,
-            task_id=exec_id,
-        )
-
-        # 5. Run secondary agents in parallel if needed
-        secondary_results = []
-        if intent.get("secondary_agents"):
-            tasks = []
-            for agent_name in intent["secondary_agents"]:
-                agent = self._agents.get(agent_name)
-                if agent:
-                    tasks.append(agent.run(user_message, context=context, session_id=session_id, task_id=exec_id))
-            if tasks:
-                secondary_results = await asyncio.gather(*tasks, return_exceptions=True)
-
-        # 6. Save to memory
-        memory_agent = self._agents.get("memory")
-        if memory_agent:
-            asyncio.create_task(memory_agent.save_interaction(
-                user_message=user_message,
-                assistant_response=result,
-                session_id=session_id,
-                intent=intent,
-            ))
-
-        await self._emit(session_id, task_id, "orchestrator_complete", {
-            "primary_agent": primary_name,
-            "result_length": len(result),
-        })
-
-        return result
-
-    # ─── Self-Healing Loop ────────────────────────────────────────────────────
-
-    async def self_heal(
-        self,
-        error: str,
-        original_task: str,
-        task_id: str = "",
-        session_id: str = "",
-        max_retries: int = 3,
-    ) -> str:
-        """Self-healing retry loop — automatically fix errors."""
-        debug_agent = self._agents.get("debug")
-        if not debug_agent:
-            return f"Cannot self-heal: DebugAgent not available. Error: {error}"
-
-        for attempt in range(1, max_retries + 1):
-            await self._emit(session_id, task_id, "self_heal_attempt", {
-                "attempt": attempt,
-                "max": max_retries,
-                "error": error[:200],
-            })
-            fix = await debug_agent.run(
-                f"Fix this error: {error}\n\nOriginal task: {original_task}",
-                context={"attempt": attempt},
-                session_id=session_id,
-                task_id=task_id,
-            )
-            if fix and "❌" not in fix[:10]:
-                await self._emit(session_id, task_id, "self_heal_success", {
-                    "attempt": attempt,
-                    "fix": fix[:200],
-                })
-                return fix
-
-        return f"❌ Self-healing failed after {max_retries} attempts. Last error: {error}"
-
-    # ─── Emit Helper ─────────────────────────────────────────────────────────
-
-    async def _emit(self, session_id: str, task_id: str, event: str, data: Dict):
-        if not self.ws:
-            return
-        if task_id:
-            await self.ws.emit(task_id, event, data, session_id=session_id)
-        if session_id:
-            await self.ws.emit_chat(session_id, event, data)
-
-    # ─── Agent Status ────────────────────────────────────────────────────────
-
-    def get_status(self) -> Dict:
-        return {
-            "agents": list(self._agents.keys()),
-            "active_tasks": len(self._active_tasks),
-            "total_agents": len(self._agents),
-        }

agents/orchestrator_v7.py

@@ -1,338 +0,0 @@
-"""
-God Agent Orchestrator v7 — True Autonomous Engineering OS
-Manus + Genspark + Devin (OneHand) style multi-agent coordination
-"""
-import asyncio
-import json
-import time
-import uuid
-from typing import Any, Dict, List, Optional
-import structlog
-
-log = structlog.get_logger()
-
-SYSTEM_PROMPT_V7 = """You are GOD AGENT v7 — the world's most advanced autonomous AI engineering operating system.
-
-You combine the best of:
-- 🧠 **Manus** — Deep reasoning, multi-step planning, autonomous decision making
-- ⚡ **Genspark** — Repository engineering, code generation at scale, multi-model AI routing  
-- 🤖 **Devin/OneHand** — Self-healing code execution, real browser control, file system mastery
-
-Your specialized agent fleet (15 agents):
-- **OrchestratorAgent** — Central brain, routes & coordinates all agents
-- **PlannerAgent** — Breaks complex goals into executable task graphs
-- **CodingAgent** — Generates production-quality code in any language
-- **DebugAgent** — Autonomous error detection and self-healing
-- **TestAgent** — Generates & runs comprehensive test suites
-- **FileAgent** — Full file system control, project scaffolding
-- **GitAgent** — Git operations, PR creation, code review
-- **BrowserAgent** — Web research, scraping, web automation
-- **VisionAgent** — UI/UX generation, design-to-code
-- **SandboxAgent** — Code execution in isolated environments
-- **DeployAgent** — Auto-deploy to Vercel, HF, Docker, AWS
-- **ConnectorAgent** — External integrations (GitHub, Slack, Notion, etc.)
-- **MemoryAgent** — Long-term memory and context management
-- **WorkflowAgent** — n8n/automation workflow generation
-- **UIAgent** — Real-time UI state updates
-
-Operating principles:
-1. PLAN before executing — always create a step-by-step plan for complex tasks
-2. EXECUTE autonomously — don't ask for confirmation on obvious steps
-3. SELF-HEAL — when errors occur, automatically retry with corrections
-4. PARALLELIZE — run independent tasks simultaneously
-5. REMEMBER — store and recall relevant context from memory
-
-Respond in Burmese or English based on user language.
-Be decisive, thorough, and production-focused.
-"""
-
-
-class GodAgentOrchestratorV7:
-    """
-    v7 Central Orchestrator — 15-agent autonomous engineering OS.
-    Routes tasks, coordinates parallel execution, self-heals failures.
-    """
-
-    def __init__(self, ws_manager=None, ai_router=None):
-        self.ws = ws_manager
-        self.ai_router = ai_router
-        self._agents: Dict[str, Any] = {}
-        self._active_tasks: Dict[str, Dict] = {}
-        self._task_history: List[Dict] = []
-
-    def register_agent(self, name: str, agent):
-        self._agents[name] = agent
-        log.info("v7 Agent registered", agent=name)
-
-    def get_agent(self, name: str):
-        return self._agents.get(name)
-
-    # ── Intent Classification ───────────────────────────────────────────────
-
-    async def classify_intent_v7(self, user_message: str) -> Dict:
-        """Advanced intent classification for 15-agent routing."""
-        classify_prompt = f"""Classify this user request for our 15-agent autonomous engineering OS.
-
-User message: "{user_message}"
-
-Available agents: orchestrator, planner, coding, debug, test, file, git, browser, vision, sandbox, deploy, connector, memory, workflow, ui
-
-Respond ONLY with valid JSON:
-{{
-  "primary_agent": "agent_name",
-  "secondary_agents": ["agent1", "agent2"],
-  "parallel_tasks": [],
-  "intent": "brief description",
-  "requires_planning": true/false,
-  "is_code_task": true/false,
-  "is_deployment": true/false,
-  "is_research": true/false,
-  "is_ui_task": true/false,
-  "is_git_task": true/false,
-  "is_test_task": true/false,
-  "language": "en|my",
-  "complexity": "simple|moderate|complex|ultra_complex",
-  "estimated_steps": 3
-}}"""
-
-        if self.ai_router:
-            messages = [
-                {"role": "system", "content": "You are an intent classifier. Return only valid JSON."},
-                {"role": "user", "content": classify_prompt},
-            ]
-            raw = await self.ai_router.complete(messages, temperature=0.1, max_tokens=400)
-            try:
-                start = raw.find("{")
-                end = raw.rfind("}") + 1
-                if start >= 0 and end > start:
-                    return json.loads(raw[start:end])
-            except Exception:
-                pass
-
-        # Heuristic fallback
-        msg = user_message.lower()
-        is_code = any(k in msg for k in ["code", "build", "create", "write", "fix", "debug", "api", "function", "class", "script", "app", "backend", "frontend"])
-        is_deploy = any(k in msg for k in ["deploy", "vercel", "github", "push", "publish", "release", "hf", "hugging"])
-        is_research = any(k in msg for k in ["research", "search", "find", "browse", "web", "scrape", "analyze"])
-        is_ui = any(k in msg for k in ["ui", "ux", "design", "component", "dashboard", "landing", "page", "frontend"])
-        is_git = any(k in msg for k in ["git", "commit", "pr", "pull request", "branch", "merge", "clone"])
-        is_test = any(k in msg for k in ["test", "testing", "pytest", "jest", "coverage", "qa"])
-        is_file = any(k in msg for k in ["file", "folder", "directory", "scaffold", "project structure"])
-        is_workflow = any(k in msg for k in ["workflow", "n8n", "automate", "trigger", "pipeline"])
-        is_memory = any(k in msg for k in ["remember", "recall", "memory", "history", "previous"])
-
-        primary = (
-            "vision" if is_ui else
-            "git" if is_git else
-            "test" if is_test else
-            "browser" if is_research else
-            "file" if is_file else
-            "coding" if is_code else
-            "deploy" if is_deploy else
-            "workflow" if is_workflow else
-            "memory" if is_memory else
-            "chat"
-        )
-
-        secondary = []
-        if is_code and is_deploy:
-            secondary.append("deploy")
-        if is_code and is_test:
-            secondary.append("test")
-        if is_code and is_git:
-            secondary.append("git")
-
-        return {
-            "primary_agent": primary,
-            "secondary_agents": secondary,
-            "parallel_tasks": [],
-            "intent": user_message[:80],
-            "requires_planning": is_code or is_deploy or len(user_message) > 150,
-            "is_code_task": is_code,
-            "is_deployment": is_deploy,
-            "is_research": is_research,
-            "is_ui_task": is_ui,
-            "is_git_task": is_git,
-            "is_test_task": is_test,
-            "language": "my" if any(c > "\u1000" for c in user_message) else "en",
-            "complexity": "ultra_complex" if len(user_message) > 500 else ("complex" if len(user_message) > 200 else "moderate"),
-            "estimated_steps": 5 if is_code else 3,
-        }
-
-    # ── Main Orchestration ─────────────────────────────────────────────────
-
-    async def orchestrate(
-        self,
-        user_message: str,
-        session_id: str = "",
-        task_id: str = "",
-        context: Dict = {},
-    ) -> str:
-        exec_id = task_id or f"v7_{uuid.uuid4().hex[:8]}"
-
-        await self._emit(session_id, task_id, "orchestrator_start", {
-            "message": user_message[:100],
-            "version": "v7",
-            "agents_available": len(self._agents),
-        })
-
-        # 1. Classify intent
-        intent = await self.classify_intent_v7(user_message)
-        log.info("v7 Intent classified", **{k: v for k, v in intent.items() if k != "parallel_tasks"})
-
-        await self._emit(session_id, task_id, "intent_classified", {
-            "primary_agent": intent["primary_agent"],
-            "secondary_agents": intent["secondary_agents"],
-            "complexity": intent["complexity"],
-            "language": intent["language"],
-        })
-
-        # 2. Planning phase for complex tasks
-        plan_context = {}
-        if intent.get("requires_planning") and intent.get("complexity") in ("complex", "ultra_complex"):
-            planner = self._agents.get("planner")
-            if planner:
-                await self._emit(session_id, task_id, "agent_called", {
-                    "agent": "PlannerAgent", "phase": "planning"
-                })
-                try:
-                    plan = await asyncio.wait_for(
-                        planner.run(user_message, context={**context, "intent": intent},
-                                    session_id=session_id, task_id=exec_id),
-                        timeout=60
-                    )
-                    plan_context["plan"] = plan
-                    await self._emit(session_id, task_id, "plan_ready", {"plan_length": len(plan)})
-                except asyncio.TimeoutError:
-                    log.warning("PlannerAgent timed out")
-
-        # 3. Route to primary agent
-        primary_name = intent["primary_agent"]
-        primary_agent = self._agents.get(primary_name) or self._agents.get("chat")
-
-        if not primary_agent:
-            return f"Agent '{primary_name}' not available."
-
-        await self._emit(session_id, task_id, "agent_called", {
-            "agent": primary_name,
-            "intent": intent["intent"],
-        })
-
-        full_context = {**context, **plan_context, "intent": intent}
-
-        # 4. Execute primary agent
-        try:
-            result = await asyncio.wait_for(
-                primary_agent.run(user_message, context=full_context, session_id=session_id, task_id=exec_id),
-                timeout=300
-            )
-        except asyncio.TimeoutError:
-            result = f"⚠️ Primary agent ({primary_name}) timed out. Please try a more specific request."
-        except Exception as e:
-            log.error("Primary agent error", agent=primary_name, error=str(e))
-            result = await self.self_heal(str(e), user_message, exec_id, session_id)
-
-        # 5. Run secondary agents in parallel
-        if intent.get("secondary_agents"):
-            secondary_tasks = []
-            for agent_name in intent["secondary_agents"]:
-                agent = self._agents.get(agent_name)
-                if agent:
-                    secondary_tasks.append(
-                        asyncio.wait_for(
-                            agent.run(user_message, context={**full_context, "primary_result": result},
-                                      session_id=session_id, task_id=exec_id),
-                            timeout=120
-                        )
-                    )
-            if secondary_tasks:
-                secondary_results = await asyncio.gather(*secondary_tasks, return_exceptions=True)
-                valid_results = [r for r in secondary_results if isinstance(r, str) and len(r) > 10]
-                if valid_results:
-                    result += "\n\n---\n\n" + "\n\n".join(valid_results)
-
-        # 6. Save to memory asynchronously
-        memory_agent = self._agents.get("memory")
-        if memory_agent:
-            asyncio.create_task(memory_agent.save_interaction(
-                user_message=user_message,
-                assistant_response=result,
-                session_id=session_id,
-                intent=intent,
-            ))
-
-        # 7. Record in task history
-        self._task_history.append({
-            "id": exec_id,
-            "message": user_message[:200],
-            "primary_agent": primary_name,
-            "result_length": len(result),
-            "timestamp": time.time(),
-        })
-        if len(self._task_history) > 100:
-            self._task_history = self._task_history[-100:]
-
-        await self._emit(session_id, task_id, "orchestrator_complete", {
-            "primary_agent": primary_name,
-            "result_length": len(result),
-            "version": "v7",
-        })
-
-        return result
-
-    # ── Self-Healing ───────────────────────────────────────────────────────
-
-    async def self_heal(self, error: str, original_task: str, task_id: str = "",
-                        session_id: str = "", max_retries: int = 3) -> str:
-        debug_agent = self._agents.get("debug")
-        if not debug_agent:
-            return f"❌ Self-heal unavailable. Error: {error}"
-
-        for attempt in range(1, max_retries + 1):
-            await self._emit(session_id, task_id, "self_heal_attempt", {
-                "attempt": attempt, "max": max_retries, "error": error[:200]
-            })
-            try:
-                fix = await asyncio.wait_for(
-                    debug_agent.run(
-                        f"Fix this error: {error}\n\nOriginal task: {original_task}",
-                        context={"attempt": attempt, "error": error},
-                        session_id=session_id, task_id=task_id,
-                    ),
-                    timeout=60
-                )
-                if fix and "❌" not in fix[:10]:
-                    await self._emit(session_id, task_id, "self_heal_success", {"attempt": attempt})
-                    return fix
-            except Exception as e:
-                log.warning("Self-heal attempt failed", attempt=attempt, error=str(e))
-
-        return f"❌ Self-healing failed after {max_retries} attempts. Error: {error}"
-
-    # ── Helpers ────────────────────────────────────────────────────────────
-
-    async def _emit(self, session_id: str, task_id: str, event: str, data: Dict):
-        if not self.ws:
-            return
-        try:
-            if task_id:
-                await self.ws.emit(task_id, event, data, session_id=session_id)
-            if session_id:
-                await self.ws.emit_chat(session_id, event, data)
-        except Exception:
-            pass
-
-    def get_status(self) -> Dict:
-        return {
-            "version": "7.0.0",
-            "agents": list(self._agents.keys()),
-            "total_agents": len(self._agents),
-            "active_tasks": len(self._active_tasks),
-            "tasks_completed": len(self._task_history),
-            "capabilities": [
-                "autonomous_planning", "multi_agent_parallel",
-                "self_healing", "web_browsing", "file_management",
-                "git_operations", "ui_generation", "test_generation",
-                "deployment", "memory", "workflow_automation"
-            ],
-        }

agents/planner_agent.py

@@ -1,127 +0,0 @@
-"""
-PlannerAgent — Breaks goals into executable task graphs (Manus-style)
-"""
-import json
-from typing import Dict, List
-import structlog
-from .base_agent import BaseAgent
-
-log = structlog.get_logger()
-
-PLANNER_SYSTEM = """You are an elite software architect and project planner.
-Break down user goals into detailed, executable task graphs.
-Think like Devin/Manus — autonomous, thorough, production-minded.
-
-Always respond with valid JSON task plans.
-"""
-
-PLANNER_PROMPT = """Break this goal into a detailed execution plan.
-
-Goal: {goal}
-Context: {context}
-
-Respond ONLY with valid JSON:
-{{
-  "title": "Plan title",
-  "steps": [
-    {{
-      "id": "step_1",
-      "name": "Step name",
-      "description": "Detailed description",
-      "agent": "coding|debug|connector|deploy|workflow|sandbox|memory",
-      "tool": "code|shell|file|github|memory|search|test|none",
-      "depends_on": [],
-      "estimated_seconds": 15,
-      "can_parallel": false
-    }}
-  ],
-  "estimated_duration": 120,
-  "tools_needed": ["code", "shell"],
-  "agents_needed": ["coding", "debug"],
-  "complexity": "simple|moderate|complex"
-}}"""
-
-
-class PlannerAgent(BaseAgent):
-    def __init__(self, ws_manager=None, ai_router=None):
-        super().__init__("PlannerAgent", ws_manager, ai_router)
-
-    async def run(self, task: str, context: Dict = {}, **kwargs) -> str:
-        session_id = kwargs.get("session_id", "")
-        task_id = kwargs.get("task_id", "")
-
-        await self.emit(task_id, "agent_start", {"agent": "PlannerAgent", "goal": task[:80]}, session_id)
-
-        ctx_str = json.dumps(context.get("memory", []))[:300] if context.get("memory") else "No prior context"
-        prompt = PLANNER_PROMPT.format(goal=task, context=ctx_str)
-
-        messages = [
-            {"role": "system", "content": PLANNER_SYSTEM},
-            {"role": "user", "content": prompt},
-        ]
-
-        raw = await self.llm(messages, task_id=task_id, session_id=session_id, temperature=0.2, max_tokens=2000)
-
-        try:
-            start = raw.find("{")
-            end = raw.rfind("}") + 1
-            if start >= 0 and end > start:
-                plan = json.loads(raw[start:end])
-            else:
-                plan = json.loads(raw)
-
-            await self.emit(task_id, "plan_ready", {
-                "title": plan.get("title", "Execution Plan"),
-                "steps": len(plan.get("steps", [])),
-                "estimated_duration": plan.get("estimated_duration", 60),
-                "agents_needed": plan.get("agents_needed", []),
-            }, session_id)
-
-            return json.dumps(plan)
-
-        except Exception as e:
-            log.warning("Plan parse failed", error=str(e))
-            fallback = self._fallback_plan(task)
-            await self.emit(task_id, "plan_ready", {"title": "Fallback Plan", "steps": len(fallback["steps"])}, session_id)
-            return json.dumps(fallback)
-
-    def _fallback_plan(self, goal: str) -> Dict:
-        return {
-            "title": f"Plan: {goal[:50]}",
-            "steps": [
-                {"id": "step_1", "name": "Analyze Requirements", "description": f"Analyze: {goal[:60]}", "agent": "coding", "tool": "none", "depends_on": [], "estimated_seconds": 10, "can_parallel": False},
-                {"id": "step_2", "name": "Design Solution", "description": "Design the architecture", "agent": "coding", "tool": "code", "depends_on": ["step_1"], "estimated_seconds": 20, "can_parallel": False},
-                {"id": "step_3", "name": "Implement", "description": "Write implementation code", "agent": "coding", "tool": "code", "depends_on": ["step_2"], "estimated_seconds": 30, "can_parallel": False},
-                {"id": "step_4", "name": "Test & Debug", "description": "Test and fix errors", "agent": "debug", "tool": "test", "depends_on": ["step_3"], "estimated_seconds": 20, "can_parallel": False},
-                {"id": "step_5", "name": "Document", "description": "Write documentation", "agent": "coding", "tool": "file", "depends_on": ["step_4"], "estimated_seconds": 10, "can_parallel": True},
-            ],
-            "estimated_duration": 90,
-            "tools_needed": ["code", "test"],
-            "agents_needed": ["coding", "debug"],
-            "complexity": "moderate",
-        }
-
-    async def build_task_graph(self, plan_json: str) -> List[Dict]:
-        """Build execution order respecting dependencies."""
-        try:
-            plan = json.loads(plan_json)
-            steps = plan.get("steps", [])
-            # Topological sort by dependencies
-            ordered = []
-            visited = set()
-            
-            def visit(step_id):
-                if step_id in visited:
-                    return
-                visited.add(step_id)
-                step = next((s for s in steps if s["id"] == step_id), None)
-                if step:
-                    for dep in step.get("depends_on", []):
-                        visit(dep)
-                    ordered.append(step)
-            
-            for step in steps:
-                visit(step["id"])
-            return ordered
-        except Exception:
-            return []

agents/reasoning_agent.py

@@ -1,173 +0,0 @@
-"""
-ReasoningAgent v7 — Complex reasoning, analysis, and multi-step problem solving
-GOD AGENT OS — Using DeepSeek R1, Qwen QwQ, o1-mini style reasoning
-"""
-
-import asyncio
-import json
-from typing import Dict, Any, List, Optional
-
-import structlog
-
-from .base_agent import BaseAgent
-
-log = structlog.get_logger()
-
-REASONING_SYSTEM = """You are an elite autonomous reasoning and analysis agent.
-You excel at:
-- Multi-step reasoning with chain-of-thought
-- Complex problem decomposition and analysis
-- Mathematical and logical reasoning
-- Strategic planning and decision making
-- Root cause analysis
-
-Always think step by step, show your reasoning, and provide confident conclusions.
-"""
-
-
-class ReasoningAgent(BaseAgent):
-    """
-    Specialized agent for complex reasoning, analysis, and problem-solving tasks.
-
-    Capabilities:
-    - Multi-step reasoning with chain-of-thought
-    - Complex problem decomposition
-    - Mathematical reasoning
-    - Logical analysis
-    - Strategic planning
-    """
-
-    def __init__(self, ws_manager=None, ai_router=None):
-        super().__init__("ReasoningAgent", ws_manager, ai_router)
-        self.reasoning_depth = 3
-        self.max_reasoning_tokens = 16000
-
-    async def run(self, task: str, context: Dict = {}, **kwargs) -> str:
-        """Execute reasoning task."""
-        session_id = kwargs.get("session_id", "")
-        task_id = kwargs.get("task_id", "")
-
-        await self.emit(task_id, "agent_start", {
-            "agent": "ReasoningAgent",
-            "task": task[:80],
-        }, session_id)
-
-        try:
-            # Step 1: Analyze the problem
-            analysis = await self._analyze_problem(task, context, task_id, session_id)
-
-            # Step 2: Decompose if complex
-            if len(task.split()) > 30:
-                sub_problems = await self._decompose_problem(task, analysis, task_id, session_id)
-                solutions = []
-                for sub in sub_problems[:3]:
-                    sol = await self._solve_sub_problem(sub, context, task_id, session_id)
-                    solutions.append(sol)
-                result = await self._synthesize_answer(task, analysis, sub_problems, solutions, task_id, session_id)
-            else:
-                result = analysis
-
-            await self.emit(task_id, "reasoning_complete", {
-                "agent": "ReasoningAgent",
-                "reasoning_depth": self.reasoning_depth,
-            }, session_id)
-
-            return result
-
-        except Exception as e:
-            log.error("ReasoningAgent failed", error=str(e))
-            return "Reasoning agent encountered an error: " + str(e)
-
-    async def _analyze_problem(self, problem: str, context: Dict, task_id: str, session_id: str) -> str:
-        """Analyze the problem using reasoning model."""
-        messages = [
-            {"role": "system", "content": REASONING_SYSTEM},
-            {"role": "user", "content": (
-                "Analyze this problem step by step:\n\n"
-                + problem + "\n\n"
-                "Provide:\n"
-                "1. Problem type and complexity\n"
-                "2. Key constraints and requirements\n"
-                "3. Step-by-step solution\n"
-                "4. Final answer/recommendation"
-            )},
-        ]
-        return await self.llm(
-            messages,
-            task_id=task_id,
-            session_id=session_id,
-            temperature=0.2,
-            max_tokens=self.max_reasoning_tokens,
-        )
-
-    async def _decompose_problem(self, problem: str, analysis: str, task_id: str, session_id: str) -> List[str]:
-        """Break down complex problem into sub-problems."""
-        messages = [
-            {"role": "system", "content": REASONING_SYSTEM},
-            {"role": "user", "content": (
-                "Break this complex problem into 3 specific sub-problems:\n\n"
-                + problem + "\n\n"
-                "Initial analysis: " + analysis[:500] + "\n\n"
-                "List each sub-problem on a new line starting with '1.', '2.', '3.'"
-            )},
-        ]
-        raw = await self.llm(messages, task_id=task_id, session_id=session_id, temperature=0.3, max_tokens=2000)
-        # Parse numbered sub-problems
-        lines = raw.split("\n")
-        sub_problems = []
-        for line in lines:
-            line = line.strip()
-            if line and any(line.startswith(str(i) + ".") for i in range(1, 10)):
-                sub_problems.append(line)
-        return sub_problems if sub_problems else [problem]
-
-    async def _solve_sub_problem(self, sub_problem: str, context: Dict, task_id: str, session_id: str) -> str:
-        """Solve individual sub-problem."""
-        messages = [
-            {"role": "system", "content": REASONING_SYSTEM},
-            {"role": "user", "content": "Solve this specific problem:\n\n" + sub_problem},
-        ]
-        return await self.llm(messages, task_id=task_id, session_id=session_id, temperature=0.2, max_tokens=4096)
-
-    async def _synthesize_answer(
-        self,
-        original: str,
-        analysis: str,
-        sub_problems: List[str],
-        solutions: List[str],
-        task_id: str,
-        session_id: str,
-    ) -> str:
-        """Synthesize final answer from all reasoning steps."""
-        solutions_text = "\n".join(
-            "Sub-problem " + str(i + 1) + ": " + sol[:300]
-            for i, sol in enumerate(solutions)
-        )
-        messages = [
-            {"role": "system", "content": REASONING_SYSTEM},
-            {"role": "user", "content": (
-                "Original problem: " + original + "\n\n"
-                "Analysis: " + analysis[:800] + "\n\n"
-                "Solutions to sub-problems:\n" + solutions_text + "\n\n"
-                "Provide a comprehensive final answer that integrates all insights."
-            )},
-        ]
-        return await self.llm(messages, task_id=task_id, session_id=session_id, temperature=0.3, max_tokens=8192)
-
-    def get_status(self) -> Dict[str, Any]:
-        """Get agent status."""
-        return {
-            "name": self.name,
-            "status": "ready",
-            "capabilities": [
-                "Multi-step reasoning",
-                "Problem decomposition",
-                "Mathematical reasoning",
-                "Logical analysis",
-                "Strategic planning",
-            ],
-            "reasoning_depth": self.reasoning_depth,
-        }
-
-
-__all__ = ["ReasoningAgent"]

agents/sandbox_agent.py

@@ -1,249 +0,0 @@
-"""
-SandboxAgent — Persistent VS Code sandbox execution (Devin-style)
-Controls file system, terminal, git operations in workspace
-"""
-import asyncio
-import json
-import os
-import subprocess
-import tempfile
-from typing import Dict, List, Optional
-import structlog
-from .base_agent import BaseAgent
-
-log = structlog.get_logger()
-
-WORKSPACE = os.environ.get("WORKSPACE_DIR", "/tmp/god_workspace")
-
-
-class SandboxAgent(BaseAgent):
-    def __init__(self, ws_manager=None, ai_router=None):
-        super().__init__("SandboxAgent", ws_manager, ai_router)
-        os.makedirs(WORKSPACE, exist_ok=True)
-
-    async def run(self, task: str, context: Dict = {}, **kwargs) -> str:
-        session_id = kwargs.get("session_id", "")
-        task_id = kwargs.get("task_id", "")
-
-        task_lower = task.lower()
-
-        if "execute" in task_lower or "run" in task_lower or "terminal" in task_lower:
-            cmd = context.get("command", task)
-            return await self.execute(cmd, task_id=task_id, session_id=session_id)
-        elif "write file" in task_lower or "create file" in task_lower:
-            filename = context.get("filename", "output.txt")
-            content = context.get("content", "")
-            return await self.write_file(filename, content, task_id=task_id, session_id=session_id)
-        elif "read file" in task_lower:
-            filename = context.get("filename", "")
-            return await self.read_file(filename, task_id=task_id, session_id=session_id)
-        elif "git" in task_lower:
-            return await self.git_operation(task, task_id=task_id, session_id=session_id)
-        else:
-            return await self.execute(task, task_id=task_id, session_id=session_id)
-
-    # ─── Terminal Execution ───────────────────────────────────────────────────
-
-    async def execute(
-        self,
-        command: str,
-        cwd: str = "",
-        timeout: int = 30,
-        task_id: str = "",
-        session_id: str = "",
-    ) -> str:
-        """Execute shell command in sandbox workspace."""
-        work_dir = cwd or WORKSPACE
-
-        # Safety: block dangerous commands
-        blocked = ["rm -rf /", ":(){ :|:& };:", "mkfs", "shutdown", "reboot", "halt", "dd if=/dev/"]
-        for b in blocked:
-            if b in command:
-                return f"❌ Blocked dangerous command: {command[:50]}"
-
-        await self.emit(task_id, "sandbox_exec", {
-            "command": command[:200],
-            "cwd": work_dir,
-        }, session_id)
-
-        try:
-            proc = await asyncio.create_subprocess_shell(
-                command,
-                stdout=asyncio.subprocess.PIPE,
-                stderr=asyncio.subprocess.PIPE,
-                cwd=work_dir,
-            )
-            stdout, stderr = await asyncio.wait_for(proc.communicate(), timeout=timeout)
-            output = stdout.decode("utf-8", errors="replace")
-            err = stderr.decode("utf-8", errors="replace")
-
-            result = output[:3000]
-            if err and proc.returncode != 0:
-                result += f"\n⚠️ stderr:\n{err[:500]}"
-
-            await self.emit(task_id, "sandbox_result", {
-                "command": command[:100],
-                "exit_code": proc.returncode,
-                "output_length": len(output),
-                "success": proc.returncode == 0,
-            }, session_id)
-
-            return result or f"Command executed (exit code: {proc.returncode})"
-        except asyncio.TimeoutError:
-            return f"⚠️ Command timed out after {timeout}s"
-        except Exception as e:
-            return f"❌ Execution error: {str(e)}"
-
-    # ─── File Operations ──────────────────────────────────────────────────────
-
-    async def write_file(
-        self,
-        filename: str,
-        content: str,
-        task_id: str = "",
-        session_id: str = "",
-    ) -> str:
-        """Write file to workspace."""
-        filepath = os.path.join(WORKSPACE, filename)
-        os.makedirs(os.path.dirname(filepath), exist_ok=True)
-        try:
-            with open(filepath, "w", encoding="utf-8") as f:
-                f.write(content)
-            await self.emit(task_id, "file_written", {
-                "filename": filename,
-                "size": len(content),
-                "lines": len(content.split("\n")),
-                "path": filepath,
-            }, session_id)
-            return f"✅ File written: `{filename}` ({len(content)} chars, {len(content.split(chr(10)))} lines)"
-        except Exception as e:
-            return f"❌ Write failed: {str(e)}"
-
-    async def read_file(
-        self,
-        filename: str,
-        task_id: str = "",
-        session_id: str = "",
-    ) -> str:
-        """Read file from workspace."""
-        filepath = os.path.join(WORKSPACE, filename)
-        try:
-            with open(filepath, "r", encoding="utf-8") as f:
-                content = f.read()
-            await self.emit(task_id, "file_read", {
-                "filename": filename,
-                "size": len(content),
-            }, session_id)
-            return content[:5000]
-        except FileNotFoundError:
-            return f"❌ File not found: {filename}"
-        except Exception as e:
-            return f"❌ Read failed: {str(e)}"
-
-    async def list_files(self, path: str = "") -> List[str]:
-        """List files in workspace."""
-        target = os.path.join(WORKSPACE, path) if path else WORKSPACE
-        try:
-            result = []
-            for root, dirs, files in os.walk(target):
-                # Skip hidden and cache dirs
-                dirs[:] = [d for d in dirs if not d.startswith(".") and d != "__pycache__" and d != "node_modules"]
-                for f in files:
-                    rel = os.path.relpath(os.path.join(root, f), WORKSPACE)
-                    result.append(rel)
-                if len(result) > 100:
-                    break
-            return result
-        except Exception:
-            return []
-
-    # ─── Git Operations ───────────────────────────────────────────────────────
-
-    async def git_operation(
-        self,
-        task: str,
-        repo_path: str = "",
-        task_id: str = "",
-        session_id: str = "",
-    ) -> str:
-        """Perform git operations in workspace."""
-        work_dir = repo_path or WORKSPACE
-        task_lower = task.lower()
-
-        if "clone" in task_lower:
-            # Extract URL
-            words = task.split()
-            urls = [w for w in words if "github.com" in w or "gitlab.com" in w or ".git" in w]
-            if urls:
-                url = urls[0]
-                return await self.execute(f"git clone {url}", cwd=WORKSPACE, task_id=task_id, session_id=session_id)
-            return "❌ No git URL found in task."
-
-        elif "commit" in task_lower:
-            msg = task.replace("commit", "").strip() or "God Agent automated commit"
-            cmds = [
-                "git add -A",
-                f'git commit -m "{msg}"',
-            ]
-            results = []
-            for cmd in cmds:
-                r = await self.execute(cmd, cwd=work_dir, task_id=task_id, session_id=session_id)
-                results.append(r)
-            return "\n".join(results)
-
-        elif "push" in task_lower:
-            return await self.execute("git push", cwd=work_dir, task_id=task_id, session_id=session_id)
-
-        elif "status" in task_lower:
-            return await self.execute("git status", cwd=work_dir, task_id=task_id, session_id=session_id)
-
-        elif "log" in task_lower:
-            return await self.execute("git log --oneline -10", cwd=work_dir, task_id=task_id, session_id=session_id)
-
-        elif "init" in task_lower:
-            return await self.execute("git init && git add -A", cwd=work_dir, task_id=task_id, session_id=session_id)
-
-        else:
-            return await self.execute(task, cwd=work_dir, task_id=task_id, session_id=session_id)
-
-    # ─── Package Management ───────────────────────────────────────────────────
-
-    async def install_packages(
-        self,
-        packages: List[str],
-        manager: str = "pip",
-        task_id: str = "",
-        session_id: str = "",
-    ) -> str:
-        """Install packages in workspace."""
-        pkg_str = " ".join(packages)
-        if manager == "pip":
-            cmd = f"pip install {pkg_str}"
-        elif manager == "npm":
-            cmd = f"npm install {pkg_str}"
-        elif manager == "pnpm":
-            cmd = f"pnpm add {pkg_str}"
-        else:
-            cmd = f"{manager} install {pkg_str}"
-
-        await self.emit(task_id, "installing_packages", {
-            "manager": manager,
-            "packages": packages,
-        }, session_id)
-        return await self.execute(cmd, task_id=task_id, session_id=session_id)
-
-    # ─── Workspace Info ───────────────────────────────────────────────────────
-
-    async def get_workspace_info(self) -> Dict:
-        """Get workspace status."""
-        files = await self.list_files()
-        try:
-            disk = await self.execute("df -h /tmp | tail -1")
-        except Exception:
-            disk = "N/A"
-        return {
-            "path": WORKSPACE,
-            "file_count": len(files),
-            "files": files[:20],
-            "disk_usage": disk,
-        }

agents/test_agent.py

@@ -1,103 +0,0 @@
-"""
-TestAgent v7 — Autonomous test generation, execution, and quality assurance
-Like Devin's self-testing loop + Genspark's QA automation
-"""
-import asyncio
-import json
-import os
-import re
-from typing import Dict, List
-import structlog
-from .base_agent import BaseAgent
-
-log = structlog.get_logger()
-
-TEST_SYSTEM = """You are an elite autonomous test engineer.
-You generate comprehensive tests: unit, integration, e2e, performance.
-You analyze code for bugs, edge cases, and security vulnerabilities.
-You write pytest (Python) and Jest/Vitest (TypeScript) tests.
-Always aim for 80%+ test coverage and meaningful assertions.
-"""
-
-
-class TestAgent(BaseAgent):
-    def __init__(self, ws_manager=None, ai_router=None):
-        super().__init__("TestAgent", ws_manager, ai_router)
-        self.workspace = os.environ.get("WORKSPACE_DIR", "/tmp/god_workspace")
-
-    async def run(self, task: str, context: Dict = {}, **kwargs) -> str:
-        session_id = kwargs.get("session_id", "")
-        task_id = kwargs.get("task_id", "")
-        await self.emit(task_id, "agent_start", {"agent": "TestAgent", "task": task[:80]}, session_id)
-
-        t = task.lower()
-        if any(k in t for k in ["generate test", "write test", "create test"]):
-            return await self._generate_tests(task, context, task_id, session_id)
-        if any(k in t for k in ["run test", "execute test", "pytest", "jest"]):
-            return await self._run_tests(task, context, task_id, session_id)
-        if any(k in t for k in ["coverage", "quality", "audit"]):
-            return await self._quality_audit(task, context, task_id, session_id)
-        return await self._generate_tests(task, context, task_id, session_id)
-
-    async def _generate_tests(self, task: str, context: Dict, task_id: str, session_id: str) -> str:
-        code = context.get("code", "")
-        language = context.get("language", "python")
-        await self.emit(task_id, "tool_called", {
-            "agent": "TestAgent", "tool": "generate_tests", "step": "Generating tests"
-        }, session_id)
-        msgs = [
-            {"role": "system", "content": TEST_SYSTEM},
-            {"role": "user", "content": (
-                f"Task: {task}\nLanguage: {language}\n\n"
-                f"Code to test:\n{code[:3000] if code else 'Generate tests for: ' + task}\n\n"
-                "Generate comprehensive tests with:\n"
-                "1. Happy path tests\n2. Edge case tests\n3. Error handling tests\n"
-                "4. Mocks for external dependencies\n5. Clear test descriptions"
-            )},
-        ]
-        result = await self.llm(msgs, task_id=task_id, session_id=session_id, temperature=0.2, max_tokens=8192)
-        # Save test file to workspace
-        test_filename = f"test_{re.sub(r'[^a-z0-9]', '_', task.lower()[:30])}.py"
-        test_path = os.path.join(self.workspace, "tests", test_filename)
-        os.makedirs(os.path.dirname(test_path), exist_ok=True)
-        code_blocks = re.findall(r'```(?:python|py)?\n(.*?)```', result, re.DOTALL)
-        if code_blocks:
-            with open(test_path, "w") as f:
-                f.write(code_blocks[0])
-            await self.emit(task_id, "file_written", {"path": test_path}, session_id)
-        return result
-
-    async def _run_tests(self, task: str, context: Dict, task_id: str, session_id: str) -> str:
-        repo_path = context.get("repo_path", self.workspace)
-        await self.emit(task_id, "tool_called", {
-            "agent": "TestAgent", "tool": "run_tests", "step": "Executing tests"
-        }, session_id)
-        # Detect test runner
-        if os.path.exists(os.path.join(repo_path, "package.json")):
-            cmd = ["npm", "test", "--", "--watchAll=false"]
-        else:
-            cmd = ["python", "-m", "pytest", "-v", "--tb=short"]
-        try:
-            proc = await asyncio.create_subprocess_exec(
-                *cmd, cwd=repo_path,
-                stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE,
-            )
-            stdout, stderr = await asyncio.wait_for(proc.communicate(), timeout=120)
-            output = stdout.decode() + stderr.decode()
-            passed = len(re.findall(r'PASSED|✓|pass', output, re.I))
-            failed = len(re.findall(r'FAILED|✗|fail', output, re.I))
-            await self.emit(task_id, "tests_complete", {"passed": passed, "failed": failed}, session_id)
-            return f"**Test Results:** ✅ {passed} passed | ❌ {failed} failed\n\n```\n{output[:3000]}\n```"
-        except Exception as e:
-            return f"❌ Test run error: {str(e)}"
-
-    async def _quality_audit(self, task: str, context: Dict, task_id: str, session_id: str) -> str:
-        code = context.get("code", "")
-        msgs = [
-            {"role": "system", "content": TEST_SYSTEM},
-            {"role": "user", "content": (
-                f"Task: {task}\n\nCode:\n{code[:3000]}\n\n"
-                "Provide quality audit: coverage estimate, complexity score, bugs found, security issues, and recommendations."
-            )},
-        ]
-        return await self.llm(msgs, task_id=task_id, session_id=session_id, temperature=0.3, max_tokens=4096)

agents/ui_agent.py

@@ -1,45 +0,0 @@
-"""
-UIAgent — UI component generation (React/Next.js/Tailwind)
-"""
-from typing import Dict
-import structlog
-from .base_agent import BaseAgent
-
-log = structlog.get_logger()
-
-UI_SYSTEM = """You are an expert React/Next.js/Tailwind CSS UI engineer.
-You generate beautiful, responsive, production-ready UI components.
-Always use:
-- TypeScript with proper types
-- Tailwind CSS for styling
-- shadcn/ui components when appropriate
-- Framer Motion for animations
-- Lucide React for icons
-- Dark mode support
-- Mobile-first responsive design
-- Accessibility (aria labels, semantic HTML)
-"""
-
-
-class UIAgent(BaseAgent):
-    def __init__(self, ws_manager=None, ai_router=None):
-        super().__init__("UIAgent", ws_manager, ai_router)
-
-    async def run(self, task: str, context: Dict = {}, **kwargs) -> str:
-        session_id = kwargs.get("session_id", "")
-        task_id = kwargs.get("task_id", "")
-
-        await self.emit(task_id, "agent_start", {"agent": "UIAgent", "task": task[:80]}, session_id)
-
-        messages = [
-            {"role": "system", "content": UI_SYSTEM},
-            {"role": "user", "content": (
-                f"Generate a complete, production-ready UI component for: {task}\n\n"
-                f"Requirements:\n"
-                f"- TypeScript\n- Tailwind CSS\n- Dark mode\n- Mobile responsive\n"
-                f"- Include all imports\n- Export as default"
-            )},
-        ]
-        result = await self.llm(messages, task_id=task_id, session_id=session_id, temperature=0.3, max_tokens=6000)
-        await self.emit(task_id, "ui_generated", {"agent": "UIAgent"}, session_id)
-        return result

agents/vision_agent.py

@@ -1,109 +0,0 @@
-"""
-VisionAgent v7 — UI/UX generation, design-to-code, screenshot analysis
-Converts designs, wireframes, and visual specs into real code
-"""
-import json
-import os
-from typing import Dict
-import structlog
-from .base_agent import BaseAgent
-
-log = structlog.get_logger()
-
-VISION_SYSTEM = """You are an elite UI/UX engineer and design-to-code specialist.
-You can:
-- Convert design mockups and wireframes into pixel-perfect React/Next.js components
-- Generate beautiful, responsive UI components with Tailwind CSS
-- Create complete page layouts with animations (Framer Motion)
-- Analyze screenshots and reproduce UI components
-- Generate design systems, color palettes, and typography scales
-- Build dashboards, landing pages, admin panels, mobile-first UIs
-
-Always produce production-ready code with:
-- Responsive design (mobile-first)
-- Accessibility (ARIA labels, semantic HTML)
-- Dark/light mode support
-- Smooth animations and transitions
-- TypeScript types
-"""
-
-
-class VisionAgent(BaseAgent):
-    def __init__(self, ws_manager=None, ai_router=None):
-        super().__init__("VisionAgent", ws_manager, ai_router)
-        self.workspace = os.environ.get("WORKSPACE_DIR", "/tmp/god_workspace")
-
-    async def run(self, task: str, context: Dict = {}, **kwargs) -> str:
-        session_id = kwargs.get("session_id", "")
-        task_id = kwargs.get("task_id", "")
-        await self.emit(task_id, "agent_start", {"agent": "VisionAgent", "task": task[:80]}, session_id)
-
-        t = task.lower()
-        if any(k in t for k in ["dashboard", "admin", "panel"]):
-            return await self._generate_dashboard(task, context, task_id, session_id)
-        if any(k in t for k in ["landing", "homepage", "hero"]):
-            return await self._generate_landing_page(task, context, task_id, session_id)
-        if any(k in t for k in ["component", "button", "card", "form", "modal", "nav"]):
-            return await self._generate_component(task, context, task_id, session_id)
-        return await self._generate_ui(task, context, task_id, session_id)
-
-    async def _generate_dashboard(self, task: str, context: Dict, task_id: str, session_id: str) -> str:
-        await self.emit(task_id, "tool_called", {
-            "agent": "VisionAgent", "tool": "generate_dashboard", "step": "Generating dashboard UI"
-        }, session_id)
-        msgs = [
-            {"role": "system", "content": VISION_SYSTEM},
-            {"role": "user", "content": (
-                f"Build a complete dashboard UI: {task}\n\n"
-                "Requirements:\n"
-                "- Dark theme with glass morphism effects\n"
-                "- Sidebar navigation with icons\n"
-                "- Header with user menu\n"
-                "- Stats cards with trends\n"
-                "- Data tables with sorting\n"
-                "- Charts/graphs area\n"
-                "- React + TypeScript + Tailwind CSS\n"
-                "Generate the complete component code."
-            )},
-        ]
-        return await self.llm(msgs, task_id=task_id, session_id=session_id, temperature=0.4, max_tokens=8192)
-
-    async def _generate_landing_page(self, task: str, context: Dict, task_id: str, session_id: str) -> str:
-        await self.emit(task_id, "tool_called", {
-            "agent": "VisionAgent", "tool": "generate_landing", "step": "Generating landing page"
-        }, session_id)
-        msgs = [
-            {"role": "system", "content": VISION_SYSTEM},
-            {"role": "user", "content": (
-                f"Create a stunning landing page: {task}\n\n"
-                "Include: Hero section, Features grid, Pricing table, Testimonials, CTA, Footer\n"
-                "Style: Modern, gradient backgrounds, glassmorphism, smooth animations\n"
-                "Tech: Next.js + TypeScript + Tailwind + Framer Motion"
-            )},
-        ]
-        return await self.llm(msgs, task_id=task_id, session_id=session_id, temperature=0.5, max_tokens=8192)
-
-    async def _generate_component(self, task: str, context: Dict, task_id: str, session_id: str) -> str:
-        await self.emit(task_id, "tool_called", {
-            "agent": "VisionAgent", "tool": "generate_component", "step": "Generating UI component"
-        }, session_id)
-        msgs = [
-            {"role": "system", "content": VISION_SYSTEM},
-            {"role": "user", "content": (
-                f"Create a polished UI component: {task}\n\n"
-                "Requirements:\n"
-                "- Fully typed with TypeScript\n"
-                "- Responsive and accessible\n"
-                "- Dark/light mode support\n"
-                "- Smooth hover/focus animations\n"
-                "- Props with sensible defaults"
-            )},
-        ]
-        return await self.llm(msgs, task_id=task_id, session_id=session_id, temperature=0.4, max_tokens=8192)
-
-    async def _generate_ui(self, task: str, context: Dict, task_id: str, session_id: str) -> str:
-        msgs = [
-            {"role": "system", "content": VISION_SYSTEM},
-            {"role": "user", "content": f"Generate UI for: {task}\n\nContext: {json.dumps(context)[:300]}"},
-        ]
-        return await self.llm(msgs, task_id=task_id, session_id=session_id, temperature=0.5, max_tokens=8192)

agents/workflow_agent.py

@@ -1,163 +0,0 @@
-"""
-WorkflowAgent — n8n workflow generation, validation, deployment (Phase 7)
-Workflow Factor OS merged into God Agent ecosystem
-"""
-import json
-from typing import Dict, List
-import structlog
-from .base_agent import BaseAgent
-
-log = structlog.get_logger()
-
-WORKFLOW_SYSTEM = """You are an expert n8n workflow architect and automation engineer.
-You design production-grade automation workflows for:
-- Telegram/Discord bots with AI responses
-- Data pipelines and ETL processes
-- API integrations and webhooks
-- Scheduled tasks and cron jobs
-- Email/Slack/notification systems
-- GitHub CI/CD triggers
-- AI-powered automation chains
-
-Generate valid n8n workflow JSON that can be directly imported.
-Think about error handling, retry logic, and edge cases.
-"""
-
-
-class WorkflowAgent(BaseAgent):
-    def __init__(self, ws_manager=None, ai_router=None):
-        super().__init__("WorkflowAgent", ws_manager, ai_router)
-
-    async def run(self, task: str, context: Dict = {}, **kwargs) -> str:
-        session_id = kwargs.get("session_id", "")
-        task_id = kwargs.get("task_id", "")
-
-        await self.emit(task_id, "agent_start", {
-            "agent": "WorkflowAgent",
-            "task": task[:80],
-        }, session_id)
-
-        task_lower = task.lower()
-
-        if "telegram" in task_lower:
-            return await self._telegram_workflow(task, task_id, session_id)
-        elif "discord" in task_lower:
-            return await self._discord_workflow(task, task_id, session_id)
-        elif "schedule" in task_lower or "cron" in task_lower:
-            return await self._scheduled_workflow(task, task_id, session_id)
-        elif "github" in task_lower and ("webhook" in task_lower or "trigger" in task_lower):
-            return await self._github_workflow(task, task_id, session_id)
-        else:
-            return await self._generic_workflow(task, task_id, session_id)
-
-    async def _telegram_workflow(self, task: str, task_id: str, session_id: str) -> str:
-        messages = [
-            {"role": "system", "content": WORKFLOW_SYSTEM},
-            {"role": "user", "content": (
-                f"Create a complete n8n workflow for: {task}\n\n"
-                f"Include:\n"
-                f"1. Telegram Trigger node (webhook)\n"
-                f"2. AI processing node (HTTP Request to API)\n"
-                f"3. Telegram Send Message node\n"
-                f"4. Error handling branch\n\n"
-                f"Also provide:\n"
-                f"- Setup instructions\n"
-                f"- Required environment variables\n"
-                f"- Testing steps\n"
-                f"- The n8n workflow JSON"
-            )},
-        ]
-        result = await self.llm(messages, task_id=task_id, session_id=session_id, temperature=0.2, max_tokens=6000)
-        await self.emit(task_id, "workflow_generated", {
-            "type": "telegram_bot",
-            "agent": "WorkflowAgent",
-        }, session_id)
-        return result
-
-    async def _discord_workflow(self, task: str, task_id: str, session_id: str) -> str:
-        messages = [
-            {"role": "system", "content": WORKFLOW_SYSTEM},
-            {"role": "user", "content": (
-                f"Create a complete n8n workflow for Discord automation: {task}\n\n"
-                f"Include Discord webhook integration, message processing, and response handling."
-            )},
-        ]
-        result = await self.llm(messages, task_id=task_id, session_id=session_id, temperature=0.2, max_tokens=5000)
-        await self.emit(task_id, "workflow_generated", {"type": "discord", "agent": "WorkflowAgent"}, session_id)
-        return result
-
-    async def _scheduled_workflow(self, task: str, task_id: str, session_id: str) -> str:
-        messages = [
-            {"role": "system", "content": WORKFLOW_SYSTEM},
-            {"role": "user", "content": (
-                f"Create a scheduled n8n workflow for: {task}\n\n"
-                f"Include cron trigger configuration, processing steps, and notification on completion/failure."
-            )},
-        ]
-        result = await self.llm(messages, task_id=task_id, session_id=session_id, temperature=0.2)
-        await self.emit(task_id, "workflow_generated", {"type": "scheduled", "agent": "WorkflowAgent"}, session_id)
-        return result
-
-    async def _github_workflow(self, task: str, task_id: str, session_id: str) -> str:
-        messages = [
-            {"role": "system", "content": WORKFLOW_SYSTEM},
-            {"role": "user", "content": (
-                f"Create a GitHub webhook n8n workflow for: {task}\n\n"
-                f"Include GitHub webhook trigger, event processing, and automated responses/actions."
-            )},
-        ]
-        result = await self.llm(messages, task_id=task_id, session_id=session_id, temperature=0.2)
-        await self.emit(task_id, "workflow_generated", {"type": "github_webhook", "agent": "WorkflowAgent"}, session_id)
-        return result
-
-    async def _generic_workflow(self, task: str, task_id: str, session_id: str) -> str:
-        messages = [
-            {"role": "system", "content": WORKFLOW_SYSTEM},
-            {"role": "user", "content": (
-                f"Design a complete automation workflow for: {task}\n\n"
-                f"Provide:\n"
-                f"1. Workflow architecture diagram (text)\n"
-                f"2. n8n node configuration\n"
-                f"3. Step-by-step setup guide\n"
-                f"4. Import-ready n8n JSON\n"
-                f"5. Testing checklist"
-            )},
-        ]
-        result = await self.llm(messages, task_id=task_id, session_id=session_id, temperature=0.3, max_tokens=6000)
-        await self.emit(task_id, "workflow_generated", {"type": "custom", "agent": "WorkflowAgent"}, session_id)
-        return result
-
-    async def validate_workflow(self, workflow_json: str) -> Dict:
-        """Validate n8n workflow JSON structure."""
-        try:
-            workflow = json.loads(workflow_json)
-            nodes = workflow.get("nodes", [])
-            connections = workflow.get("connections", {})
-            has_trigger = any(
-                n.get("type", "").startswith("n8n-nodes-base.") and
-                ("Trigger" in n.get("type", "") or n.get("type", "").endswith("trigger"))
-                for n in nodes
-            )
-            return {
-                "valid": True,
-                "node_count": len(nodes),
-                "has_trigger": has_trigger,
-                "connection_count": len(connections),
-            }
-        except json.JSONDecodeError as e:
-            return {"valid": False, "error": f"Invalid JSON: {e}"}
-        except Exception as e:
-            return {"valid": False, "error": str(e)}
-
-    async def simulate_workflow(self, workflow_json: str, test_data: Dict = {}) -> str:
-        """Simulate workflow execution with test data."""
-        messages = [
-            {"role": "system", "content": WORKFLOW_SYSTEM},
-            {"role": "user", "content": (
-                f"Simulate this n8n workflow execution with test data:\n\n"
-                f"Workflow: {workflow_json[:1000]}\n\n"
-                f"Test data: {json.dumps(test_data)}\n\n"
-                f"Walk through each node's execution and expected output."
-            )},
-        ]
-        return await self.llm(messages, temperature=0.3)

ai_router/__init__.py

@@ -1,6 +0,0 @@
-# Multi-Model AI Router — GOD AGENT OS v8
-# Primary: Gemini → Sambanova → GitHub Models (task-aware rotation)
-from .router import AIRouter
-from .router_v8 import GodModeRouter, get_router, classify_task, get_provider_order
-
-__all__ = ["AIRouter", "GodModeRouter", "get_router", "classify_task", "get_provider_order"]

ai_router/key_pool.py

@@ -1,131 +0,0 @@
-"""
-KeyPool — Multi-API Key Manager with Failover & Cooldown
-God Agent OS v8 — Supports Gemini, SambaNova, GitHub, OpenAI, Groq, etc.
-Each provider can have multiple comma-separated keys.
-"""
-
-import asyncio
-import time
-from collections import defaultdict
-from typing import Dict, List, Optional
-import structlog
-
-log = structlog.get_logger()
-
-COOLDOWN_SECONDS = 60   # Key cooling time after max failures
-MAX_FAILURES = 3        # Max fails before cooldown
-
-
-class KeyEntry:
-    def __init__(self, key: str):
-        self.key = key
-        self.failures = 0
-        self.cooldown_until = 0.0
-        self.calls = 0
-        self.last_used = 0.0
-
-    def is_available(self) -> bool:
-        if self.cooldown_until > time.time():
-            return False
-        return True
-
-    def mark_fail(self):
-        self.failures += 1
-        if self.failures >= MAX_FAILURES:
-            self.cooldown_until = time.time() + COOLDOWN_SECONDS
-            log.warning("Key cooldown activated", failures=self.failures)
-
-    def mark_success(self):
-        self.failures = max(0, self.failures - 1)
-        self.cooldown_until = 0.0
-        self.calls += 1
-        self.last_used = time.time()
-
-    def status(self) -> dict:
-        remaining = max(0, self.cooldown_until - time.time())
-        return {
-            "key_preview": self.key[:8] + "..." + self.key[-4:] if len(self.key) > 12 else "***",
-            "available": self.is_available(),
-            "failures": self.failures,
-            "calls": self.calls,
-            "cooldown_remaining_s": round(remaining, 1),
-        }
-
-
-class KeyPool:
-    """
-    Pool of API keys for a single provider.
-    Round-robins through available keys with failure tracking.
-    """
-
-    def __init__(self, provider: str, keys: List[str]):
-        self.provider = provider
-        self._keys: List[KeyEntry] = [KeyEntry(k.strip()) for k in keys if k.strip()]
-        self._index = 0
-
-    def __len__(self) -> int:
-        return len(self._keys)
-
-    def pick(self) -> Optional[str]:
-        """Pick the next available key (round-robin, skip cooling down keys)."""
-        if not self._keys:
-            return None
-        n = len(self._keys)
-        for _ in range(n):
-            entry = self._keys[self._index % n]
-            self._index = (self._index + 1) % n
-            if entry.is_available():
-                return entry.key
-        # All keys in cooldown — try the one with shortest cooldown
-        soonest = min(self._keys, key=lambda e: e.cooldown_until)
-        log.warning(
-            "All keys in cooldown, using soonest",
-            provider=self.provider,
-            cooldown_remaining=round(soonest.cooldown_until - time.time(), 1),
-        )
-        return soonest.key
-
-    def mark_fail(self, key: str):
-        for e in self._keys:
-            if e.key == key:
-                e.mark_fail()
-                return
-
-    def mark_success(self, key: str):
-        for e in self._keys:
-            if e.key == key:
-                e.mark_success()
-                return
-
-    def available_count(self) -> int:
-        return sum(1 for e in self._keys if e.is_available())
-
-    def status(self) -> dict:
-        return {
-            "provider": self.provider,
-            "total_keys": len(self._keys),
-            "available_keys": self.available_count(),
-            "keys": [e.status() for e in self._keys],
-        }
-
-
-# ─── Global Key Pool Registry ─────────────────────────────────────────────────
-
-class KeyPoolRegistry:
-    """Central registry for all provider key pools."""
-
-    def __init__(self):
-        self._pools: Dict[str, KeyPool] = {}
-
-    def register(self, provider: str, keys_csv: str):
-        """Register comma-separated keys for a provider."""
-        keys = [k.strip() for k in keys_csv.split(",") if k.strip()]
-        if keys:
-            self._pools[provider] = KeyPool(provider, keys)
-            log.info("KeyPool registered", provider=provider, count=len(keys))
-
-    def get(self, provider: str) -> Optional[KeyPool]:
-        return self._pools.get(provider)
-
-    def all_status(self) -> dict:
-        return {name: pool.status() for name, pool in self._pools.items()}

ai_router/router.py

@@ -1,264 +0,0 @@
-"""
-Multi-Model AI Router — Phase 9
-Supports: OpenAI, Groq, Cerebras, OpenRouter, HuggingFace
-Automatic failover chain: OpenAI → Groq → Cerebras → OpenRouter → HF
-"""
-
-import asyncio
-import json
-import os
-import time
-from typing import Any, Dict, List, Optional
-
-import httpx
-import structlog
-
-log = structlog.get_logger()
-
-# ─── Provider Config ──────────────────────────────────────────────────────────
-PROVIDERS = [
-    {
-        "name": "openai",
-        "key_env": "OPENAI_API_KEY",
-        "base_url": os.environ.get("OPENAI_BASE_URL", "https://api.openai.com/v1"),
-        "default_model": os.environ.get("DEFAULT_MODEL", "gpt-4o"),
-        "headers_fn": lambda k: {"Authorization": f"Bearer {k}", "Content-Type": "application/json"},
-    },
-    {
-        "name": "groq",
-        "key_env": "GROQ_API_KEY",
-        "base_url": "https://api.groq.com/openai/v1",
-        "default_model": "llama-3.3-70b-versatile",
-        "headers_fn": lambda k: {"Authorization": f"Bearer {k}", "Content-Type": "application/json"},
-    },
-    {
-        "name": "cerebras",
-        "key_env": "CEREBRAS_API_KEY",
-        "base_url": "https://api.cerebras.ai/v1",
-        "default_model": "llama3.1-70b",
-        "headers_fn": lambda k: {"Authorization": f"Bearer {k}", "Content-Type": "application/json"},
-    },
-    {
-        "name": "openrouter",
-        "key_env": "OPENROUTER_API_KEY",
-        "base_url": "https://openrouter.ai/api/v1",
-        "default_model": "meta-llama/llama-3.3-70b-instruct:free",
-        "headers_fn": lambda k: {
-            "Authorization": f"Bearer {k}",
-            "Content-Type": "application/json",
-            "HTTP-Referer": "https://god-agent.ai",
-            "X-Title": "God Agent Platform",
-        },
-    },
-    {
-        "name": "anthropic",
-        "key_env": "ANTHROPIC_API_KEY",
-        "base_url": "https://api.anthropic.com/v1",
-        "default_model": "claude-3-5-sonnet-20241022",
-        "headers_fn": lambda k: {
-            "x-api-key": k,
-            "anthropic-version": "2023-06-01",
-            "Content-Type": "application/json",
-        },
-    },
-]
-
-
-class AIRouter:
-    """
-    God Mode AI Router — automatically routes and fails over across providers.
-    Supports streaming token output via WebSocket.
-    """
-
-    def __init__(self, ws_manager=None):
-        self.ws = ws_manager
-        self._stats: Dict[str, Dict] = {p["name"]: {"calls": 0, "errors": 0, "latency": []} for p in PROVIDERS}
-
-    def _get_provider(self, name: str) -> Optional[Dict]:
-        return next((p for p in PROVIDERS if p["name"] == name), None)
-
-    def _available_providers(self) -> List[Dict]:
-        """Return providers with valid API keys, in priority order."""
-        return [p for p in PROVIDERS if os.environ.get(p["key_env"], "")]
-
-    # ─── Main Entry Point ─────────────────────────────────────────────────────
-
-    async def complete(
-        self,
-        messages: List[Dict],
-        task_id: str = "",
-        session_id: str = "",
-        temperature: float = 0.7,
-        max_tokens: int = 4096,
-        preferred_model: str = "",
-        stream: bool = True,
-    ) -> str:
-        """Route completion through available providers with failover."""
-        providers = self._available_providers()
-
-        if not providers:
-            return await self._demo_stream(messages, task_id, session_id)
-
-        last_error = None
-        for provider in providers:
-            try:
-                start = time.time()
-                if provider["name"] == "anthropic":
-                    result = await self._anthropic_stream(
-                        provider, messages, task_id, session_id, temperature, max_tokens
-                    )
-                else:
-                    result = await self._openai_compat_stream(
-                        provider, messages, task_id, session_id, temperature, max_tokens, preferred_model
-                    )
-                elapsed = time.time() - start
-                self._stats[provider["name"]]["calls"] += 1
-                self._stats[provider["name"]]["latency"].append(elapsed)
-                log.info("AI Router success", provider=provider["name"], ms=round(elapsed * 1000))
-                return result
-            except Exception as e:
-                last_error = e
-                self._stats[provider["name"]]["errors"] += 1
-                log.warning("AI Router failover", provider=provider["name"], error=str(e))
-                continue
-
-        log.error("All AI providers failed", last_error=str(last_error))
-        return await self._demo_stream(messages, task_id, session_id)
-
-    # ─── OpenAI-compatible Stream (OpenAI, Groq, Cerebras, OpenRouter) ────────
-
-    async def _openai_compat_stream(
-        self, provider, messages, task_id, session_id, temperature, max_tokens, preferred_model
-    ) -> str:
-        key = os.environ.get(provider["key_env"], "")
-        model = preferred_model or provider["default_model"]
-        headers = provider["headers_fn"](key)
-        payload = {
-            "model": model,
-            "messages": messages,
-            "stream": True,
-            "temperature": temperature,
-            "max_tokens": max_tokens,
-        }
-        full_text = ""
-        async with httpx.AsyncClient(timeout=120) as client:
-            async with client.stream(
-                "POST", f"{provider['base_url']}/chat/completions",
-                headers=headers, json=payload
-            ) as resp:
-                resp.raise_for_status()
-                async for line in resp.aiter_lines():
-                    if not line.startswith("data:"):
-                        continue
-                    chunk = line[6:].strip()
-                    if chunk == "[DONE]":
-                        break
-                    try:
-                        data = json.loads(chunk)
-                        delta = data["choices"][0]["delta"].get("content", "")
-                        if delta:
-                            full_text += delta
-                            await self._emit_chunk(delta, task_id, session_id)
-                    except Exception:
-                        pass
-        return full_text
-
-    # ─── Anthropic Stream ─────────────────────────────────────────────────────
-
-    async def _anthropic_stream(
-        self, provider, messages, task_id, session_id, temperature, max_tokens
-    ) -> str:
-        key = os.environ.get(provider["key_env"], "")
-        headers = provider["headers_fn"](key)
-        system = ""
-        filtered = []
-        for m in messages:
-            if m["role"] == "system":
-                system = m["content"]
-            else:
-                filtered.append(m)
-        payload = {
-            "model": provider["default_model"],
-            "max_tokens": max_tokens,
-            "messages": filtered,
-            "stream": True,
-        }
-        if system:
-            payload["system"] = system
-        full_text = ""
-        async with httpx.AsyncClient(timeout=120) as client:
-            async with client.stream(
-                "POST", f"{provider['base_url']}/messages",
-                headers=headers, json=payload
-            ) as resp:
-                resp.raise_for_status()
-                async for line in resp.aiter_lines():
-                    if not line.startswith("data:"):
-                        continue
-                    try:
-                        data = json.loads(line[5:].strip())
-                        if data.get("type") == "content_block_delta":
-                            delta = data["delta"].get("text", "")
-                            if delta:
-                                full_text += delta
-                                await self._emit_chunk(delta, task_id, session_id)
-                    except Exception:
-                        pass
-        return full_text
-
-    # ─── Demo Stream ──────────────────────────────────────────────────────────
-
-    async def _demo_stream(self, messages, task_id, session_id) -> str:
-        last_user = next(
-            (m["content"] for m in reversed(messages) if m["role"] == "user"), "Hello"
-        )
-        response = (
-            f"🤖 **God Agent** (Demo Mode)\n\n"
-            f"Received: *{last_user[:100]}*\n\n"
-            f"To enable real AI, set one of these env vars:\n"
-            f"- `OPENAI_API_KEY` (GPT-4o)\n"
-            f"- `GROQ_API_KEY` (Llama 3.3 70B — Free)\n"
-            f"- `OPENROUTER_API_KEY` (Multi-model)\n"
-            f"- `ANTHROPIC_API_KEY` (Claude 3.5)\n\n"
-            f"**God Mode+ Capabilities Active:**\n"
-            f"- ⚡ Multi-agent orchestration\n"
-            f"- 🔧 Autonomous coding & debugging\n"
-            f"- 🧠 Persistent memory system\n"
-            f"- 🔌 Connector ecosystem\n"
-            f"- 📡 Real-time streaming\n"
-            f"- 🌐 Multi-model failover\n"
-        )
-        full_text = ""
-        for word in response.split():
-            chunk = word + " "
-            full_text += chunk
-            await asyncio.sleep(0.02)
-            await self._emit_chunk(chunk, task_id, session_id, demo=True)
-        return full_text
-
-    # ─── Emit Helper ──────────────────────────────────────────────────────────
-
-    async def _emit_chunk(self, chunk: str, task_id: str, session_id: str, demo: bool = False):
-        if not self.ws:
-            return
-        payload = {"chunk": chunk, "demo": demo}
-        if task_id:
-            await self.ws.emit(task_id, "llm_chunk", payload, session_id=session_id)
-        if session_id and not task_id:
-            await self.ws.emit_chat(session_id, "llm_chunk", payload)
-
-    # ─── Stats ────────────────────────────────────────────────────────────────
-
-    def get_stats(self) -> Dict:
-        stats = {}
-        for name, s in self._stats.items():
-            avg_lat = round(sum(s["latency"][-20:]) / max(len(s["latency"][-20:]), 1) * 1000, 1)
-            stats[name] = {
-                "calls": s["calls"],
-                "errors": s["errors"],
-                "avg_latency_ms": avg_lat,
-                "available": bool(os.environ.get(
-                    next((p["key_env"] for p in PROVIDERS if p["name"] == name), ""), ""
-                )),
-            }
-        return stats

ai_router/router_v10.py

@@ -1,493 +0,0 @@
-"""
-GOD AGENT OS — Multi-Provider AI Router v10
-Primary: Gemini (6 keys) → SambaNova (9 keys) → GitHub Models (9 keys)
-Fallback: Groq → OpenAI → Demo
-Auto-failover, round-robin KeyPool, task-type routing.
-"""
-
-from __future__ import annotations
-
-import os
-import time
-from typing import Any, Dict, List, Optional, Tuple
-
-import httpx
-import structlog
-
-log = structlog.get_logger()
-
-# ─── Provider Definitions ─────────────────────────────────────────────────────
-PROVIDERS: Dict[str, Dict[str, Any]] = {
-    "gemini": {
-        "name": "gemini",
-        "type": "gemini",
-        "base_url": "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent",
-        "key_env": "GEMINI_KEY",
-        "default_model": "gemini-2.0-flash",
-        "max_tokens": 8192,
-        "priority_tasks": ["language", "research", "content", "general", "analysis"],
-    },
-    "sambanova": {
-        "name": "sambanova",
-        "type": "openai",
-        "base_url": "https://api.sambanova.ai/v1",
-        "key_env": "SAMBANOVA_KEY",
-        "default_model": "Meta-Llama-3.3-70B-Instruct",
-        "max_tokens": 8192,
-        "priority_tasks": ["reasoning", "engineering", "planning", "analysis"],
-    },
-    "github": {
-        "name": "github",
-        "type": "openai",
-        "base_url": "https://models.inference.ai.azure.com",
-        "key_env": "GITHUB_KEY",
-        "default_model": "gpt-4o",
-        "max_tokens": 4096,
-        "priority_tasks": ["planning", "engineering", "general"],
-    },
-    "groq": {
-        "name": "groq",
-        "type": "openai",
-        "base_url": "https://api.groq.com/openai/v1",
-        "key_env": "GROQ_API_KEY",
-        "default_model": "llama-3.3-70b-versatile",
-        "max_tokens": 8192,
-        "priority_tasks": ["general"],
-    },
-    "openai": {
-        "name": "openai",
-        "type": "openai",
-        "base_url": "https://api.openai.com/v1",
-        "key_env": "OPENAI_API_KEY",
-        "default_model": "gpt-4o",
-        "max_tokens": 4096,
-        "priority_tasks": ["general"],
-    },
-}
-
-PRIMARY_ORDER = ["gemini", "sambanova", "github"]
-FALLBACK_ORDER = ["groq", "openai"]
-KEY_COOLDOWN_SECONDS = 300
-KEY_MAX_FAILS = 3
-MAX_RETRIES_PER_KEY = 2
-
-
-# ─── KeyPool ──────────────────────────────────────────────────────────────────
-
-class KeyPool:
-    """Round-robin key pool with failure tracking and cooldown."""
-
-    def __init__(self, provider: str, raw_keys: str):
-        self.provider = provider
-        self._keys: List[Dict[str, Any]] = []
-        for key in raw_keys.split(","):
-            key = key.strip()
-            if key:
-                self._keys.append({
-                    "key": key,
-                    "fails": 0,
-                    "cooldown_until": 0.0,
-                    "calls": 0,
-                })
-        log.info("key_pool_init", provider=provider, keys=len(self._keys))
-
-    def pick(self) -> Optional[Dict[str, Any]]:
-        now = time.time()
-        available = [item for item in self._keys if item["cooldown_until"] < now]
-        if not available:
-            # All in cooldown — return soonest
-            if self._keys:
-                soonest = min(self._keys, key=lambda x: x["cooldown_until"])
-                log.warning("all_keys_cooldown", provider=self.provider,
-                           wait_s=round(soonest["cooldown_until"] - now, 1))
-                return soonest
-            return None
-        available.sort(key=lambda item: item["fails"])
-        return available[0]
-
-    def mark_fail(self, key_obj: Dict[str, Any]):
-        key_obj["fails"] += 1
-        if key_obj["fails"] >= KEY_MAX_FAILS:
-            key_obj["cooldown_until"] = time.time() + KEY_COOLDOWN_SECONDS
-            log.warning("key_cooled_down", provider=self.provider,
-                       key_prefix=key_obj["key"][:8])
-
-    def mark_success(self, key_obj: Dict[str, Any]):
-        key_obj["fails"] = 0
-        key_obj["cooldown_until"] = 0.0
-        key_obj["calls"] += 1
-
-    def has_keys(self) -> bool:
-        return bool(self._keys)
-
-    def count(self) -> int:
-        return len(self._keys)
-
-    def available_count(self) -> int:
-        now = time.time()
-        return sum(1 for k in self._keys if k["cooldown_until"] < now)
-
-    def status(self) -> Dict[str, Any]:
-        now = time.time()
-        return {
-            "provider": self.provider,
-            "total_keys": len(self._keys),
-            "available_keys": self.available_count(),
-            "keys": [
-                {
-                    "key_prefix": k["key"][:8] + "...",
-                    "fails": k["fails"],
-                    "calls": k["calls"],
-                    "available": k["cooldown_until"] < now,
-                    "cooldown_s": max(0, round(k["cooldown_until"] - now, 1)),
-                }
-                for k in self._keys
-            ],
-        }
-
-
-# ─── Task Classifier ──────────────────────────────────────────────────────────
-
-def classify_task(prompt: str = "") -> str:
-    p = (prompt or "").lower()
-    if any(w in p for w in ["code", "function", "implement", "build", "develop", "api", "class", "debug", "script", "program"]):
-        return "engineering"
-    if any(w in p for w in ["plan", "strategy", "workflow", "json", "automate", "pipeline", "step", "task"]):
-        return "planning"
-    if any(w in p for w in ["analyze", "reasoning", "why", "explain", "evaluate", "compare", "think"]):
-        return "reasoning"
-    if any(w in p for w in ["research", "find", "search", "discover", "investigate", "browse", "web"]):
-        return "research"
-    if any(w in p for w in ["write", "content", "blog", "article", "copy", "generate text", "summarize", "essay"]):
-        return "content"
-    if any(w in p for w in ["translate", "language", "convert", "myanmar", "burmese"]):
-        return "language"
-    if any(w in p for w in ["data", "csv", "metrics", "report", "insight", "chart", "graph"]):
-        return "analysis"
-    return "general"
-
-
-def get_provider_order(task_type: str, preferred: str = "") -> List[str]:
-    ordered = sorted(
-        PRIMARY_ORDER,
-        key=lambda p: 0 if task_type in PROVIDERS[p]["priority_tasks"] else 1
-    )
-    result = ordered + [p for p in FALLBACK_ORDER if os.environ.get(PROVIDERS[p]["key_env"], "")]
-    if preferred and preferred in PROVIDERS and preferred in result:
-        result = [preferred] + [p for p in result if p != preferred]
-    return result
-
-
-# ─── API Calls ────────────────────────────────────────────────────────────────
-
-async def call_gemini(
-    base_url: str, key: str,
-    messages: List[Dict[str, str]], max_tokens: int
-) -> Tuple[bool, str]:
-    url = f"{base_url}?key={key}"
-    # Build contents from messages
-    contents = []
-    system_text = ""
-    for msg in messages:
-        role = msg.get("role", "user")
-        content = msg.get("content", "")
-        if role == "system":
-            system_text = content
-        elif role == "user":
-            contents.append({"role": "user", "parts": [{"text": content}]})
-        elif role == "assistant":
-            contents.append({"role": "model", "parts": [{"text": content}]})
-
-    if not contents:
-        contents = [{"role": "user", "parts": [{"text": "Hello"}]}]
-
-    body: Dict[str, Any] = {
-        "contents": contents,
-        "generationConfig": {
-            "maxOutputTokens": min(max_tokens, 8192),
-            "temperature": 0.7,
-        },
-    }
-    if system_text:
-        body["systemInstruction"] = {"parts": [{"text": system_text}]}
-
-    try:
-        async with httpx.AsyncClient(timeout=60.0) as client:
-            resp = await client.post(url, json=body)
-            if resp.status_code == 200:
-                data = resp.json()
-                candidates = data.get("candidates", [])
-                if candidates:
-                    text = candidates[0].get("content", {}).get("parts", [{}])[0].get("text", "")
-                    if text:
-                        return True, text
-                return False, f"Empty response: {str(data)[:200]}"
-            return False, f"HTTP {resp.status_code}: {resp.text[:300]}"
-    except Exception as exc:
-        return False, str(exc)
-
-
-async def call_openai_compat(
-    base_url: str, key: str, model: str,
-    messages: List[Dict[str, str]], max_tokens: int
-) -> Tuple[bool, str]:
-    url = f"{base_url}/chat/completions"
-    headers = {
-        "Authorization": f"Bearer {key}",
-        "Content-Type": "application/json",
-    }
-    body = {
-        "model": model,
-        "messages": messages,
-        "max_tokens": max_tokens,
-        "temperature": 0.7,
-    }
-    try:
-        async with httpx.AsyncClient(timeout=60.0) as client:
-            resp = await client.post(url, json=body, headers=headers)
-            if resp.status_code == 200:
-                data = resp.json()
-                choices = data.get("choices", [])
-                if choices:
-                    content = choices[0].get("message", {}).get("content", "")
-                    if content:
-                        return True, content
-                return False, f"Empty choices: {str(data)[:200]}"
-            return False, f"HTTP {resp.status_code}: {resp.text[:300]}"
-    except Exception as exc:
-        return False, str(exc)
-
-
-# ─── Main Router ──────────────────────────────────────────────────────────────
-
-class AIRouterV10:
-    """
-    God Agent OS AI Router v10.
-    Multi-provider routing: Gemini (6 keys) → SambaNova (9 keys) → GitHub (9 keys) → fallback.
-    """
-
-    VERSION = "10.0"
-
-    def __init__(self, ws_manager=None):
-        self.ws = ws_manager
-        self._pools: Dict[str, KeyPool] = {}
-        self._stats: Dict[str, Dict[str, Any]] = {
-            name: {"calls": 0, "errors": 0, "latency_ms": [], "last_used": 0.0}
-            for name in PROVIDERS
-        }
-        self._load_pools()
-
-    def _load_pools(self):
-        """Load key pools from environment variables."""
-        for name, cfg in PROVIDERS.items():
-            raw = os.environ.get(cfg["key_env"], "").strip()
-            if raw:
-                self._pools[name] = KeyPool(name, raw)
-        loaded = list(self._pools.keys())
-        log.info("router_v10_loaded", providers=loaded, total=len(loaded))
-
-    def reload_pools(self):
-        """Hot-reload pools (e.g., after env var update)."""
-        self._pools.clear()
-        self._load_pools()
-
-    def get_stats(self) -> Dict[str, Any]:
-        return {
-            name: {
-                "available": name in self._pools and self._pools[name].has_keys(),
-                "keys": self._pools[name].count() if name in self._pools else 0,
-                "calls": self._stats[name]["calls"],
-                "errors": self._stats[name]["errors"],
-                "avg_latency_ms": (
-                    round(
-                        sum(self._stats[name]["latency_ms"][-20:]) /
-                        max(len(self._stats[name]["latency_ms"][-20:]), 1),
-                        1,
-                    )
-                    if self._stats[name]["latency_ms"] else 0
-                ),
-            }
-            for name in PROVIDERS
-        }
-
-    def get_pool_status(self) -> Dict[str, Any]:
-        return {
-            name: (
-                self._pools[name].status()
-                if name in self._pools
-                else {"provider": name, "total_keys": 0, "available_keys": 0, "keys": []}
-            )
-            for name in PROVIDERS
-        }
-
-    def get_status(self) -> Dict[str, Any]:
-        return {
-            "version": self.VERSION,
-            "providers": self.get_stats(),
-            "primary_order": PRIMARY_ORDER,
-            "fallback_order": FALLBACK_ORDER,
-            "active_providers": [n for n in self._pools if self._pools[n].has_keys()],
-        }
-
-    def _normalize_messages(
-        self,
-        messages: Optional[List[Dict[str, str]]] = None,
-        prompt: str = "",
-        system: str = "",
-    ) -> Tuple[List[Dict[str, str]], bool]:
-        if messages:
-            return messages, False
-        normalized: List[Dict[str, str]] = []
-        if system:
-            normalized.append({"role": "system", "content": system})
-        normalized.append({"role": "user", "content": prompt or "Hello"})
-        return normalized, True
-
-    async def complete(
-        self,
-        messages: Optional[List[Dict[str, str]]] = None,
-        task_id: str = "",
-        session_id: str = "",
-        temperature: float = 0.7,
-        max_tokens: int = 4096,
-        preferred_provider: str = "",
-        preferred_model: str = "",
-        stream: bool = False,
-        prompt: str = "",
-        system: str = "",
-        **_: Any,
-    ) -> Any:
-        normalized_messages, return_dict = self._normalize_messages(
-            messages=messages, prompt=prompt, system=system
-        )
-        user_msg = next(
-            (msg.get("content", "") for msg in reversed(normalized_messages) if msg.get("role") == "user"),
-            "",
-        )
-        task_type = classify_task(user_msg)
-        order = get_provider_order(task_type, preferred=preferred_provider)
-
-        log.info("routing", task_type=task_type, order=order[:3], session=session_id[:8] if session_id else "")
-        last_error = "No providers available — set GEMINI_KEY, SAMBANOVA_KEY, or GITHUB_KEY"
-
-        for provider_name in order:
-            if provider_name not in self._pools:
-                continue
-
-            pool = self._pools[provider_name]
-            cfg = PROVIDERS[provider_name]
-            model = preferred_model or cfg["default_model"]
-
-            for _attempt in range(MAX_RETRIES_PER_KEY):
-                key_obj = pool.pick()
-                if key_obj is None:
-                    break
-
-                t0 = time.time()
-                try:
-                    if cfg["type"] == "gemini":
-                        ok, text = await call_gemini(
-                            cfg["base_url"], key_obj["key"],
-                            normalized_messages, min(max_tokens, cfg["max_tokens"])
-                        )
-                    else:
-                        ok, text = await call_openai_compat(
-                            cfg["base_url"], key_obj["key"], model,
-                            normalized_messages, min(max_tokens, cfg["max_tokens"])
-                        )
-
-                    elapsed = int((time.time() - t0) * 1000)
-
-                    if ok and text.strip():
-                        pool.mark_success(key_obj)
-                        self._stats[provider_name]["calls"] += 1
-                        self._stats[provider_name]["latency_ms"].append(elapsed)
-                        self._stats[provider_name]["last_used"] = time.time()
-                        log.info("llm_success", provider=provider_name, ms=elapsed, task_type=task_type)
-
-                        if self.ws and (task_id or session_id):
-                            await self._emit_response(text, task_id, session_id)
-
-                        payload = {
-                            "content": text,
-                            "provider": provider_name,
-                            "task_type": task_type,
-                            "latency_ms": elapsed,
-                            "model": model,
-                        }
-                        return payload if return_dict else text
-
-                    pool.mark_fail(key_obj)
-                    last_error = text
-                    self._stats[provider_name]["errors"] += 1
-                    log.warning("llm_fail", provider=provider_name, error=text[:150])
-
-                except Exception as exc:
-                    pool.mark_fail(key_obj)
-                    self._stats[provider_name]["errors"] += 1
-                    last_error = str(exc)
-                    log.error("llm_exception", provider=provider_name, error=str(exc)[:200])
-
-        # All failed — return demo
-        demo = await self._demo_response(normalized_messages, task_type)
-        log.warning("all_providers_failed", last_error=last_error[:200])
-        payload = {
-            "content": demo,
-            "provider": "demo",
-            "task_type": task_type,
-            "error": last_error,
-        }
-        return payload if return_dict else demo
-
-    async def _emit_response(self, text: str, task_id: str, session_id: str):
-        """Emit response through WebSocket if available."""
-        try:
-            if task_id and hasattr(self.ws, "emit"):
-                await self.ws.emit(task_id, "llm_response", {"content": text}, session_id=session_id)
-            elif session_id and hasattr(self.ws, "emit_chat"):
-                await self.ws.emit_chat(session_id, "llm_response", {"content": text})
-        except Exception:
-            pass
-
-    async def _demo_response(self, messages: List[Dict[str, str]], task_type: str) -> str:
-        user_msg = next(
-            (msg.get("content", "") for msg in reversed(messages) if msg.get("role") == "user"),
-            "Hello"
-        )
-        active = list(self._pools.keys())
-        return (
-            "🤖 **GOD AGENT OS v10 — Demo Mode**\n\n"
-            f"Task type detected: `{task_type}`\n"
-            f"Your request: *{user_msg[:200]}*\n\n"
-            f"**Active providers:** {active or 'none'}\n\n"
-            "**To enable real AI, set environment variables:**\n"
-            "```\n"
-            "GEMINI_KEY=AIza...,AIza...  (comma-separated, 6 keys)\n"
-            "SAMBANOVA_KEY=uuid,...      (comma-separated, 9 keys)\n"
-            "GITHUB_KEY=ghp_...,ghp_... (comma-separated, 9 keys)\n"
-            "```\n\n"
-            "**God Agent OS v10 Features:**\n"
-            "- 🔑 Multi-key pool routing with auto-failover\n"
-            "- 🧠 22 distributed worker spaces\n"
-            "- 🤖 16 autonomous agents\n"
-            "- 💬 Persistent chat history\n"
-            "- ⚡ Real-time WebSocket streaming\n"
-            "- 🌐 Manus-like UI experience\n"
-        )
-
-
-# ─── Singleton ────────────────────────────────────────────────────────────────
-
-_router_instance: Optional[AIRouterV10] = None
-
-
-def get_router_v10(ws_manager=None) -> AIRouterV10:
-    global _router_instance
-    if _router_instance is None:
-        _router_instance = AIRouterV10(ws_manager)
-    return _router_instance
-
-
-# Alias for compatibility
-AIRouterV8 = AIRouterV10
-GodModeRouter = AIRouterV10

ai_router/router_v3.py

@@ -1,382 +0,0 @@
-"""
-🚀 GOD MODE+ v3 - Advanced AI Router with Reasoning Models
-Intelligent model selection based on task type and requirements
-Version: 3.0.0
-"""
-
-import asyncio
-import logging
-from enum import Enum
-from typing import Optional, Dict, List, Any
-from dataclasses import dataclass
-from datetime import datetime
-
-import structlog
-from openai import AsyncOpenAI, RateLimitError, APIError
-from anthropic import AsyncAnthropic
-
-log = structlog.get_logger()
-
-
-class TaskType(str, Enum):
-    """Task classification for optimal model selection."""
-    REASONING = "reasoning"
-    CODING = "coding"
-    CHAT = "chat"
-    ANALYSIS = "analysis"
-    CREATIVE = "creative"
-    LIGHTWEIGHT = "lightweight"
-
-
-class ModelProvider(str, Enum):
-    """Supported AI model providers."""
-    OPENAI = "openai"
-    ANTHROPIC = "anthropic"
-    GROQ = "groq"
-    DEEPSEEK = "deepseek"
-    TOGETHER = "together"
-    OPENROUTER = "openrouter"
-    CEREBRAS = "cerebras"
-    QWEN = "qwen"
-
-
-@dataclass
-class ModelConfig:
-    """Configuration for each model."""
-    provider: ModelProvider
-    model_id: str
-    name: str
-    max_tokens: int
-    cost_per_1k_input: float
-    cost_per_1k_output: float
-    latency_ms: int
-    reasoning_capable: bool
-    coding_capable: bool
-    context_length: int
-    is_free: bool = False
-
-
-class AIRouterV3:
-    """
-    Advanced AI Router with:
-    - Reasoning model support (DeepSeek R1, Qwen QwQ, o1-mini)
-    - Smart task-based model selection
-    - Cost optimization
-    - Latency optimization
-    - Automatic failover with exponential backoff
-    """
-
-    # Model Registry
-    MODELS: Dict[str, ModelConfig] = {
-        # Reasoning Models (v3 NEW)
-        "deepseek-r1": ModelConfig(
-            provider=ModelProvider.DEEPSEEK,
-            model_id="deepseek-r1",
-            name="DeepSeek R1",
-            max_tokens=8000,
-            cost_per_1k_input=0.55,
-            cost_per_1k_output=2.19,
-            latency_ms=3000,
-            reasoning_capable=True,
-            coding_capable=True,
-            context_length=128000,
-        ),
-        "qwen-qwq": ModelConfig(
-            provider=ModelProvider.QWEN,
-            model_id="qwen-qwq-32b",
-            name="Qwen QwQ",
-            max_tokens=32000,
-            cost_per_1k_input=0.20,
-            cost_per_1k_output=0.60,
-            latency_ms=2500,
-            reasoning_capable=True,
-            coding_capable=True,
-            context_length=32768,
-        ),
-        "o1-mini": ModelConfig(
-            provider=ModelProvider.OPENAI,
-            model_id="o1-mini",
-            name="OpenAI o1-mini",
-            max_tokens=65536,
-            cost_per_1k_input=3.00,
-            cost_per_1k_output=12.00,
-            latency_ms=5000,
-            reasoning_capable=True,
-            coding_capable=True,
-            context_length=128000,
-        ),
-        # Standard Models
-        "gpt-4o": ModelConfig(
-            provider=ModelProvider.OPENAI,
-            model_id="gpt-4o",
-            name="GPT-4o",
-            max_tokens=4096,
-            cost_per_1k_input=5.00,
-            cost_per_1k_output=15.00,
-            latency_ms=1500,
-            reasoning_capable=False,
-            coding_capable=True,
-            context_length=128000,
-        ),
-        "claude-3.5-sonnet": ModelConfig(
-            provider=ModelProvider.ANTHROPIC,
-            model_id="claude-3-5-sonnet-20241022",
-            name="Claude 3.5 Sonnet",
-            max_tokens=4096,
-            cost_per_1k_input=3.00,
-            cost_per_1k_output=15.00,
-            latency_ms=1200,
-            reasoning_capable=False,
-            coding_capable=True,
-            context_length=200000,
-        ),
-        "llama-3.3-70b": ModelConfig(
-            provider=ModelProvider.GROQ,
-            model_id="llama-3.3-70b-versatile",
-            name="Llama 3.3 70B (Groq)",
-            max_tokens=8192,
-            cost_per_1k_input=0.00,
-            cost_per_1k_output=0.00,
-            latency_ms=800,
-            reasoning_capable=False,
-            coding_capable=True,
-            context_length=8192,
-            is_free=True,
-        ),
-        "mixtral-8x7b": ModelConfig(
-            provider=ModelProvider.TOGETHER,
-            model_id="mistralai/Mixtral-8x7B-Instruct-v0.1",
-            name="Mixtral 8x7B",
-            max_tokens=4096,
-            cost_per_1k_input=0.60,
-            cost_per_1k_output=0.60,
-            latency_ms=1000,
-            reasoning_capable=False,
-            coding_capable=True,
-            context_length=32768,
-        ),
-    }
-
-    # Routing Chains for Different Task Types
-    ROUTING_CHAINS = {
-        TaskType.REASONING: [
-            "deepseek-r1",
-            "qwen-qwq",
-            "o1-mini",
-            "gpt-4o",
-            "claude-3.5-sonnet",
-        ],
-        TaskType.CODING: [
-            "gpt-4o",
-            "claude-3.5-sonnet",
-            "deepseek-r1",
-            "llama-3.3-70b",
-            "mixtral-8x7b",
-        ],
-        TaskType.CHAT: [
-            "llama-3.3-70b",  # Free first
-            "gpt-4o",
-            "claude-3.5-sonnet",
-            "mixtral-8x7b",
-        ],
-        TaskType.ANALYSIS: [
-            "gpt-4o",
-            "claude-3.5-sonnet",
-            "deepseek-r1",
-            "llama-3.3-70b",
-        ],
-        TaskType.CREATIVE: [
-            "gpt-4o",
-            "claude-3.5-sonnet",
-            "mixtral-8x7b",
-            "llama-3.3-70b",
-        ],
-        TaskType.LIGHTWEIGHT: [
-            "llama-3.3-70b",
-            "mixtral-8x7b",
-            "gpt-4o",
-        ],
-    }
-
-    def __init__(self, ws_manager=None):
-        """Initialize AI Router v3."""
-        self.ws_manager = ws_manager
-        self.clients = {}
-        self.model_stats = {}
-        self.retry_config = {
-            "max_retries": 3,
-            "initial_delay": 1,
-            "max_delay": 30,
-            "exponential_base": 2,
-        }
-        log.info("🤖 AI Router v3 initialized with reasoning models")
-
-    def detect_task_type(self, message: str, context: Dict[str, Any] = None) -> TaskType:
-        """
-        Detect task type from message content.
-        Uses heuristics and optional context hints.
-        """
-        message_lower = message.lower()
-        context = context or {}
-
-        # Check explicit task type hint
-        if context.get("task_type"):
-            try:
-                return TaskType(context["task_type"])
-            except ValueError:
-                pass
-
-        # Heuristic detection
-        if any(word in message_lower for word in ["think", "reason", "why", "explain", "analyze"]):
-            return TaskType.REASONING
-
-        if any(word in message_lower for word in ["code", "function", "debug", "fix", "implement"]):
-            return TaskType.CODING
-
-        if any(word in message_lower for word in ["analyze", "compare", "evaluate", "assess"]):
-            return TaskType.ANALYSIS
-
-        if any(word in message_lower for word in ["write", "create", "story", "poem", "imagine"]):
-            return TaskType.CREATIVE
-
-        # Default to chat for general conversation
-        return TaskType.CHAT
-
-    def select_model(
-        self,
-        task_type: TaskType,
-        optimize_for: str = "quality",  # "quality", "speed", "cost"
-        context_length_needed: int = 4096,
-    ) -> str:
-        """
-        Select optimal model based on task type and optimization preference.
-        """
-        chain = self.ROUTING_CHAINS.get(task_type, self.ROUTING_CHAINS[TaskType.CHAT])
-
-        if optimize_for == "cost":
-            # Prefer free models first
-            for model_id in chain:
-                if self.MODELS[model_id].is_free:
-                    return model_id
-            return chain[0]
-
-        elif optimize_for == "speed":
-            # Sort by latency
-            sorted_chain = sorted(
-                chain,
-                key=lambda m: self.MODELS[m].latency_ms
-            )
-            return sorted_chain[0]
-
-        else:  # quality (default)
-            # Prefer models with better reasoning/coding capabilities
-            if task_type == TaskType.REASONING:
-                reasoning_models = [m for m in chain if self.MODELS[m].reasoning_capable]
-                return reasoning_models[0] if reasoning_models else chain[0]
-            elif task_type == TaskType.CODING:
-                coding_models = [m for m in chain if self.MODELS[m].coding_capable]
-                return coding_models[0] if coding_models else chain[0]
-
-        return chain[0]
-
-    async def route(
-        self,
-        message: str,
-        context: Dict[str, Any] = None,
-        optimize_for: str = "quality",
-    ) -> Dict[str, Any]:
-        """
-        Main routing function: detect task type → select model → execute with failover.
-        """
-        context = context or {}
-        task_type = self.detect_task_type(message, context)
-        model_id = self.select_model(task_type, optimize_for)
-
-        log.info(
-            "🎯 Routing decision",
-            task_type=task_type,
-            selected_model=model_id,
-            optimize_for=optimize_for,
-        )
-
-        # Try selected model with failover chain
-        chain = self.ROUTING_CHAINS.get(task_type, self.ROUTING_CHAINS[TaskType.CHAT])
-        
-        for attempt, fallback_model in enumerate(chain):
-            try:
-                result = await self._call_model(fallback_model, message, context)
-                
-                # Track success
-                if fallback_model not in self.model_stats:
-                    self.model_stats[fallback_model] = {"success": 0, "failures": 0}
-                self.model_stats[fallback_model]["success"] += 1
-
-                return {
-                    "success": True,
-                    "model": fallback_model,
-                    "task_type": task_type,
-                    "response": result,
-                    "attempts": attempt + 1,
-                }
-
-            except (RateLimitError, APIError) as e:
-                log.warning(
-                    "⚠️ Model failed, trying next in chain",
-                    model=fallback_model,
-                    error=str(e),
-                    attempt=attempt + 1,
-                )
-                if fallback_model not in self.model_stats:
-                    self.model_stats[fallback_model] = {"success": 0, "failures": 0}
-                self.model_stats[fallback_model]["failures"] += 1
-
-                if attempt < len(chain) - 1:
-                    await asyncio.sleep(self.retry_config["initial_delay"] ** attempt)
-                continue
-
-        return {
-            "success": False,
-            "error": "All models in chain failed",
-            "task_type": task_type,
-            "attempts": len(chain),
-        }
-
-    async def _call_model(self, model_id: str, message: str, context: Dict[str, Any]) -> str:
-        """Call specific model with appropriate client."""
-        config = self.MODELS[model_id]
-
-        if config.provider == ModelProvider.OPENAI:
-            return await self._call_openai(model_id, message, context)
-        elif config.provider == ModelProvider.ANTHROPIC:
-            return await self._call_anthropic(model_id, message, context)
-        elif config.provider == ModelProvider.GROQ:
-            return await self._call_groq(model_id, message, context)
-        else:
-            raise ValueError(f"Provider {config.provider} not yet implemented")
-
-    async def _call_openai(self, model_id: str, message: str, context: Dict[str, Any]) -> str:
-        """Call OpenAI models (GPT-4o, o1-mini)."""
-        # Implementation would go here
-        return f"[{model_id}] Response placeholder"
-
-    async def _call_anthropic(self, model_id: str, message: str, context: Dict[str, Any]) -> str:
-        """Call Anthropic Claude models."""
-        # Implementation would go here
-        return f"[{model_id}] Response placeholder"
-
-    async def _call_groq(self, model_id: str, message: str, context: Dict[str, Any]) -> str:
-        """Call Groq models (Llama 3.3 70B)."""
-        # Implementation would go here
-        return f"[{model_id}] Response placeholder"
-
-    def get_stats(self) -> Dict[str, Any]:
-        """Get router statistics."""
-        return {
-            "models": len(self.MODELS),
-            "model_stats": self.model_stats,
-            "timestamp": datetime.now().isoformat(),
-        }
-
-
-# Export for use in main.py
-__all__ = ["AIRouterV3", "TaskType", "ModelProvider"]

ai_router/router_v8.py

@@ -1,321 +0,0 @@
-"""
-GOD AGENT OS — Multi-Provider AI Router v8/v10 compatibility layer.
-Primary providers: Gemini -> SambaNova -> GitHub Models.
-Supports both legacy `messages=[...]` calls and newer `prompt/system` style calls.
-"""
-
-from __future__ import annotations
-
-import os
-import time
-from typing import Any, Dict, List, Optional, Tuple
-
-import httpx
-import structlog
-
-log = structlog.get_logger()
-
-PROVIDERS = {
-    "gemini": {
-        "name": "gemini",
-        "type": "gemini",
-        "base_url": "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent",
-        "key_env": "GEMINI_KEY",
-        "default_model": "gemini-2.0-flash",
-        "max_tokens": 8192,
-        "priority_tasks": ["language", "research", "content", "general"],
-    },
-    "sambanova": {
-        "name": "sambanova",
-        "type": "openai",
-        "base_url": "https://api.sambanova.ai/v1",
-        "key_env": "SAMBANOVA_KEY",
-        "default_model": "Meta-Llama-3.3-70B-Instruct",
-        "max_tokens": 8192,
-        "priority_tasks": ["reasoning", "engineering", "planning", "analysis"],
-    },
-    "github": {
-        "name": "github",
-        "type": "openai",
-        "base_url": "https://models.inference.ai.azure.com",
-        "key_env": "GITHUB_KEY",
-        "default_model": "gpt-4o",
-        "max_tokens": 4096,
-        "priority_tasks": ["planning", "engineering", "general"],
-    },
-    "groq": {
-        "name": "groq",
-        "type": "openai",
-        "base_url": "https://api.groq.com/openai/v1",
-        "key_env": "GROQ_API_KEY",
-        "default_model": "llama-3.3-70b-versatile",
-        "max_tokens": 8192,
-        "priority_tasks": ["general"],
-    },
-    "openai": {
-        "name": "openai",
-        "type": "openai",
-        "base_url": "https://api.openai.com/v1",
-        "key_env": "OPENAI_API_KEY",
-        "default_model": "gpt-4o",
-        "max_tokens": 4096,
-        "priority_tasks": ["general"],
-    },
-}
-
-PRIMARY_ORDER = ["gemini", "sambanova", "github"]
-FALLBACK_ORDER = ["groq", "openai"]
-MAX_RETRIES_PER_KEY = 2
-KEY_COOLDOWN_SECONDS = 300
-KEY_MAX_FAILS = 3
-
-
-class KeyPool:
-    def __init__(self, raw_keys: str):
-        self._keys: List[Dict[str, Any]] = []
-        for key in raw_keys.split(","):
-            key = key.strip()
-            if key:
-                self._keys.append({"key": key, "fails": 0, "cooldown_until": 0.0})
-
-    def pick(self) -> Optional[Dict[str, Any]]:
-        now = time.time()
-        available = [item for item in self._keys if item["cooldown_until"] < now]
-        if not available:
-            return None
-        available.sort(key=lambda item: item["fails"])
-        return available[0]
-
-    def mark_fail(self, key_obj: Dict[str, Any]):
-        key_obj["fails"] += 1
-        if key_obj["fails"] >= KEY_MAX_FAILS:
-            key_obj["cooldown_until"] = time.time() + KEY_COOLDOWN_SECONDS
-            log.warning("key_cooled_down", key_prefix=key_obj["key"][:8])
-
-    def mark_success(self, key_obj: Dict[str, Any]):
-        key_obj["fails"] = 0
-        key_obj["cooldown_until"] = 0.0
-
-    def has_keys(self) -> bool:
-        return bool(self._keys)
-
-    def count(self) -> int:
-        return len(self._keys)
-
-    def status(self) -> List[Dict[str, Any]]:
-        now = time.time()
-        result = []
-        for item in self._keys:
-            result.append({
-                "key_prefix": item["key"][:8],
-                "fails": item["fails"],
-                "cooldown_seconds": max(0, int(item["cooldown_until"] - now)),
-                "available": item["cooldown_until"] < now,
-            })
-        return result
-
-
-def classify_task(prompt: str = "") -> str:
-    p = (prompt or "").lower()
-    if any(word in p for word in ["code", "function", "implement", "build", "develop", "api", "class", "debug"]):
-        return "engineering"
-    if any(word in p for word in ["plan", "strategy", "workflow", "json", "automate", "pipeline"]):
-        return "planning"
-    if any(word in p for word in ["analyze", "reasoning", "why", "explain", "evaluate", "compare"]):
-        return "reasoning"
-    if any(word in p for word in ["research", "find", "search", "discover", "investigate"]):
-        return "research"
-    if any(word in p for word in ["write", "content", "blog", "article", "copy", "generate text", "summarize"]):
-        return "content"
-    if any(word in p for word in ["translate", "language", "convert"]):
-        return "language"
-    if any(word in p for word in ["data", "csv", "metrics", "report", "insight"]):
-        return "analysis"
-    return "general"
-
-
-def get_provider_order(task_type: str) -> List[str]:
-    ordered = sorted(PRIMARY_ORDER, key=lambda provider: 0 if task_type in PROVIDERS[provider]["priority_tasks"] else 1)
-    return ordered + [provider for provider in FALLBACK_ORDER if os.environ.get(PROVIDERS[provider]["key_env"], "")]
-
-
-async def call_gemini(base_url: str, key: str, messages: List[Dict[str, str]], max_tokens: int) -> Tuple[bool, str]:
-    url = f"{base_url}?key={key}"
-    parts = [{"text": message.get("content", "")} for message in messages if message.get("content")]
-    body = {
-        "contents": [{"parts": parts or [{"text": "Hello"}]}],
-        "generationConfig": {"maxOutputTokens": max_tokens, "temperature": 0.7},
-    }
-    try:
-        async with httpx.AsyncClient(timeout=60.0) as client:
-            resp = await client.post(url, json=body)
-            if resp.status_code == 200:
-                data = resp.json()
-                text = data.get("candidates", [{}])[0].get("content", {}).get("parts", [{}])[0].get("text", "")
-                return True, text
-            return False, f"HTTP {resp.status_code}: {resp.text[:200]}"
-    except Exception as exc:
-        return False, str(exc)
-
-
-async def call_openai_compat(base_url: str, key: str, model: str, messages: List[Dict[str, str]], max_tokens: int) -> Tuple[bool, str]:
-    url = f"{base_url}/chat/completions"
-    headers = {"Authorization": f"Bearer {key}", "Content-Type": "application/json"}
-    body = {"model": model, "messages": messages, "max_tokens": max_tokens, "temperature": 0.7}
-    try:
-        async with httpx.AsyncClient(timeout=60.0) as client:
-            resp = await client.post(url, json=body, headers=headers)
-            if resp.status_code == 200:
-                data = resp.json()
-                return True, data["choices"][0]["message"]["content"]
-            return False, f"HTTP {resp.status_code}: {resp.text[:200]}"
-    except Exception as exc:
-        return False, str(exc)
-
-
-class GodModeRouter:
-    def __init__(self, ws_manager=None):
-        self.ws = ws_manager
-        self._pools: Dict[str, KeyPool] = {}
-        self._stats: Dict[str, Dict[str, Any]] = {
-            name: {"calls": 0, "errors": 0, "latency_ms": []} for name in PROVIDERS
-        }
-        self._load_pools()
-
-    def _load_pools(self):
-        for name, cfg in PROVIDERS.items():
-            raw = os.environ.get(cfg["key_env"], "")
-            if raw:
-                self._pools[name] = KeyPool(raw)
-                log.info("key_pool_loaded", provider=name, key_count=self._pools[name].count())
-
-    def reload_pools(self):
-        self._pools.clear()
-        self._load_pools()
-
-    def get_status(self) -> Dict[str, Any]:
-        return {
-            "providers": {
-                name: {
-                    "available": name in self._pools and self._pools[name].has_keys(),
-                    "keys": self._pools[name].count() if name in self._pools else 0,
-                    "stats": self._stats.get(name, {}),
-                }
-                for name in PROVIDERS
-            },
-            "primary_order": PRIMARY_ORDER,
-        }
-
-    def get_stats(self) -> Dict[str, Any]:
-        return {
-            name: {"available": name in self._pools, "calls": self._stats[name]["calls"]}
-            for name in PROVIDERS
-        }
-
-    def get_pool_status(self) -> Dict[str, Any]:
-        return {
-            name: {
-                "available": name in self._pools and self._pools[name].has_keys(),
-                "keys": self._pools[name].count() if name in self._pools else 0,
-                "entries": self._pools[name].status() if name in self._pools else [],
-            }
-            for name in PROVIDERS
-        }
-
-    def _normalize_messages(self, messages=None, prompt: str = "", system: str = "") -> Tuple[List[Dict[str, str]], bool]:
-        if messages:
-            return messages, False
-        normalized: List[Dict[str, str]] = []
-        if system:
-            normalized.append({"role": "system", "content": system})
-        normalized.append({"role": "user", "content": prompt or "Hello"})
-        return normalized, True
-
-    async def complete(
-        self,
-        messages: Optional[List[Dict[str, str]]] = None,
-        task_id: str = "",
-        session_id: str = "",
-        temperature: float = 0.7,
-        max_tokens: int = 4096,
-        preferred_provider: str = "",
-        stream: bool = False,
-        prompt: str = "",
-        system: str = "",
-        preferred_model: str = "",
-        **_: Any,
-    ) -> Any:
-        normalized_messages, return_dict = self._normalize_messages(messages=messages, prompt=prompt, system=system)
-        user_msg = next((msg.get("content", "") for msg in reversed(normalized_messages) if msg.get("role") == "user"), "")
-        task_type = classify_task(user_msg)
-
-        if preferred_provider and preferred_provider in PROVIDERS:
-            order = [preferred_provider] + [provider for provider in get_provider_order(task_type) if provider != preferred_provider]
-        else:
-            order = get_provider_order(task_type)
-
-        log.info("routing_request", task_type=task_type, order=order[:3], task_id=task_id, session_id=session_id)
-        last_error = "No providers available"
-
-        for provider_name in order:
-            if provider_name not in self._pools:
-                continue
-
-            pool = self._pools[provider_name]
-            cfg = PROVIDERS[provider_name]
-            model = preferred_model or cfg["default_model"]
-
-            for _attempt in range(MAX_RETRIES_PER_KEY):
-                key_obj = pool.pick()
-                if key_obj is None:
-                    break
-
-                t0 = time.time()
-                try:
-                    if cfg["type"] == "gemini":
-                        ok, text = await call_gemini(cfg["base_url"], key_obj["key"], normalized_messages, min(max_tokens, cfg["max_tokens"]))
-                    else:
-                        ok, text = await call_openai_compat(cfg["base_url"], key_obj["key"], model, normalized_messages, min(max_tokens, cfg["max_tokens"]))
-                    elapsed = int((time.time() - t0) * 1000)
-
-                    if ok and text.strip():
-                        pool.mark_success(key_obj)
-                        self._stats[provider_name]["calls"] += 1
-                        self._stats[provider_name]["latency_ms"].append(elapsed)
-                        payload = {"content": text, "provider": provider_name, "task_type": task_type, "latency_ms": elapsed}
-                        return payload if return_dict else text
-
-                    pool.mark_fail(key_obj)
-                    last_error = text
-                    self._stats[provider_name]["errors"] += 1
-                    log.warning("llm_fail", provider=provider_name, error=text[:120])
-                except Exception as exc:
-                    pool.mark_fail(key_obj)
-                    self._stats[provider_name]["errors"] += 1
-                    last_error = str(exc)
-                    log.error("llm_exception", provider=provider_name, error=str(exc)[:160])
-
-        demo = await self._demo_response(normalized_messages, task_type)
-        return {"content": demo, "provider": "demo", "task_type": task_type, "error": last_error} if return_dict else demo
-
-    async def _demo_response(self, messages: List[Dict[str, str]], task_type: str) -> str:
-        user_msg = next((msg.get("content", "") for msg in reversed(messages) if msg.get("role") == "user"), "Hello")
-        return (
-            "[GOD AGENT OS — Demo Mode]\n\n"
-            f"Task type detected: {task_type}\n"
-            f"Your request: '{user_msg[:160]}'\n\n"
-            "Configure API keys in environment: GEMINI_KEY, SAMBANOVA_KEY, GITHUB_KEY"
-        )
-
-
-_router_instance: Optional[GodModeRouter] = None
-
-
-def get_router(ws_manager=None) -> GodModeRouter:
-    global _router_instance
-    if _router_instance is None:
-        _router_instance = GodModeRouter(ws_manager)
-    return _router_instance
-
-
-AIRouterV8 = GodModeRouter

api/routes/agents.py

@@ -1,98 +0,0 @@
-"""
-God Agent Orchestrator API Routes
-"""
-from fastapi import APIRouter, Request, HTTPException
-from pydantic import BaseModel
-from typing import Optional, Dict, Any
-
-router = APIRouter()
-
-
-class OrchestrateRequest(BaseModel):
-    message: str
-    session_id: str = ""
-    task_id: str = ""
-    context: Dict[str, Any] = {}
-
-
-class SandboxExecRequest(BaseModel):
-    command: str
-    cwd: str = ""
-    timeout: int = 30
-
-
-class FileWriteRequest(BaseModel):
-    filename: str
-    content: str
-
-
-@router.post("/orchestrate")
-async def orchestrate(req: OrchestrateRequest, request: Request):
-    """Route message through God Agent Orchestrator."""
-    orchestrator = getattr(request.app.state, "orchestrator", None)
-    if not orchestrator:
-        raise HTTPException(500, "Orchestrator not initialized")
-    result = await orchestrator.orchestrate(
-        user_message=req.message,
-        session_id=req.session_id,
-        task_id=req.task_id,
-        context=req.context,
-    )
-    return {"result": result, "session_id": req.session_id}
-
-
-@router.get("/status")
-async def agent_status(request: Request):
-    """Get all agent statuses."""
-    orchestrator = getattr(request.app.state, "orchestrator", None)
-    if not orchestrator:
-        return {"status": "not_initialized"}
-    return orchestrator.get_status()
-
-
-@router.post("/sandbox/execute")
-async def sandbox_execute(req: SandboxExecRequest, request: Request):
-    """Execute command in sandbox."""
-    orchestrator = getattr(request.app.state, "orchestrator", None)
-    if not orchestrator:
-        raise HTTPException(500, "Orchestrator not initialized")
-    sandbox = orchestrator.get_agent("sandbox")
-    if not sandbox:
-        raise HTTPException(503, "SandboxAgent not available")
-    result = await sandbox.execute(req.command, cwd=req.cwd, timeout=req.timeout)
-    return {"result": result, "command": req.command}
-
-
-@router.post("/sandbox/file")
-async def sandbox_write_file(req: FileWriteRequest, request: Request):
-    """Write file to sandbox workspace."""
-    orchestrator = getattr(request.app.state, "orchestrator", None)
-    if not orchestrator:
-        raise HTTPException(500, "Orchestrator not initialized")
-    sandbox = orchestrator.get_agent("sandbox")
-    if not sandbox:
-        raise HTTPException(503, "SandboxAgent not available")
-    result = await sandbox.write_file(req.filename, req.content)
-    return {"result": result, "filename": req.filename}
-
-
-@router.get("/sandbox/workspace")
-async def sandbox_workspace(request: Request):
-    """Get workspace info."""
-    orchestrator = getattr(request.app.state, "orchestrator", None)
-    if not orchestrator:
-        raise HTTPException(500, "Orchestrator not initialized")
-    sandbox = orchestrator.get_agent("sandbox")
-    if not sandbox:
-        raise HTTPException(503, "SandboxAgent not available")
-    info = await sandbox.get_workspace_info()
-    return info
-
-
-@router.get("/ai-router/stats")
-async def ai_router_stats(request: Request):
-    """Get AI router statistics."""
-    ai_router = getattr(request.app.state, "ai_router", None)
-    if not ai_router:
-        return {"stats": {}}
-    return {"stats": ai_router.get_stats()}

api/routes/chat.py

@@ -1,214 +0,0 @@
-"""
-Chat + Goal API Routes — Real-time streaming responses
-"""
-
-import asyncio
-import json
-import time
-import uuid
-
-from fastapi import APIRouter, HTTPException, Request
-from fastapi.responses import StreamingResponse
-
-from core.models import ChatRequest, GoalRequest, TaskCreateRequest
-from memory.db import save_memory, get_history
-
-router = APIRouter()
-
-
-def get_engine(request: Request):
-    return request.app.state.task_engine
-
-
-def get_ws(request: Request):
-    return request.app.state.ws_manager
-
-
-# ─── Chat (REST + SSE streaming) ───────────────────────────────────────────────
-
-@router.post("/chat", summary="Chat with the agent")
-async def chat(req: ChatRequest, request: Request):
-    from core.agent import AgentCore
-    ws = get_ws(request)
-    agent = AgentCore(ws)
-
-    messages = [{"role": m.role, "content": m.content} for m in req.messages]
-
-    if req.stream:
-        async def stream_gen():
-            async def _run():
-                result = await agent.llm_stream(
-                    messages=messages,
-                    session_id=req.session_id,
-                    model=req.model,
-                    temperature=req.temperature,
-                    max_tokens=req.max_tokens,
-                )
-                await save_memory(
-                    content=result,
-                    memory_type="conversation",
-                    session_id=req.session_id,
-                    project_id=req.project_id,
-                    key="assistant",
-                )
-                # Save user message too
-                user_msg = next((m["content"] for m in reversed(messages) if m["role"] == "user"), "")
-                await save_memory(
-                    content=user_msg,
-                    memory_type="conversation",
-                    session_id=req.session_id,
-                    project_id=req.project_id,
-                    key="user",
-                )
-                return result
-
-            room_buffer = []
-            original_emit_chat = ws.emit_chat
-            async def capture_emit(sid, etype, data):
-                if etype == "llm_chunk":
-                    chunk = data.get("chunk", "")
-                    room_buffer.append(chunk)
-                    yield_data = json.dumps({"type": etype, "data": data, "session_id": sid})
-                    return yield_data
-                return None
-
-            # Stream tokens directly
-            full = ""
-            from core.agent import AgentCore as _A
-            import httpx
-            import os
-            OPENAI_API_KEY = os.environ.get("OPENAI_API_KEY", "")
-            ANTHROPIC_API_KEY = os.environ.get("ANTHROPIC_API_KEY", "")
-
-            if OPENAI_API_KEY:
-                headers = {
-                    "Authorization": f"Bearer {OPENAI_API_KEY}",
-                    "Content-Type": "application/json",
-                }
-                payload = {
-                    "model": req.model,
-                    "messages": messages,
-                    "stream": True,
-                    "temperature": req.temperature,
-                    "max_tokens": req.max_tokens,
-                }
-                from core.agent import OPENAI_BASE_URL
-                async with httpx.AsyncClient(timeout=120) as client:
-                    async with client.stream("POST", f"{OPENAI_BASE_URL}/chat/completions",
-                                             headers=headers, json=payload) as resp:
-                        async for line in resp.aiter_lines():
-                            if not line.startswith("data:"):
-                                continue
-                            chunk_str = line[6:].strip()
-                            if chunk_str == "[DONE]":
-                                break
-                            try:
-                                data = json.loads(chunk_str)
-                                delta = data["choices"][0]["delta"].get("content", "")
-                                if delta:
-                                    full += delta
-                                    yield f"data: {json.dumps({'type': 'llm_chunk', 'data': {'chunk': delta}, 'session_id': req.session_id})}\n\n"
-                            except Exception:
-                                pass
-            else:
-                # Demo streaming
-                demo = (
-                    f"Hello! I'm your Devin-style AI Agent. I received: '{req.messages[-1].content[:80]}'. "
-                    f"Set OPENAI_API_KEY or ANTHROPIC_API_KEY for real AI responses. "
-                    f"I support real-time streaming, task planning, GitHub automation, and more!"
-                )
-                for word in demo.split():
-                    chunk = word + " "
-                    full += chunk
-                    await asyncio.sleep(0.04)
-                    yield f"data: {json.dumps({'type': 'llm_chunk', 'data': {'chunk': chunk}, 'session_id': req.session_id})}\n\n"
-
-            yield f"data: {json.dumps({'type': 'stream_end', 'data': {'full_response': full}, 'session_id': req.session_id})}\n\n"
-
-        return StreamingResponse(
-            stream_gen(),
-            media_type="text/event-stream",
-            headers={"Cache-Control": "no-cache", "X-Accel-Buffering": "no"},
-        )
-    else:
-        # Non-streaming
-        agent = AgentCore(get_ws(request))
-        result = await agent.llm_stream(messages, session_id=req.session_id)
-        return {
-            "response": result,
-            "session_id": req.session_id,
-            "model": req.model,
-            "timestamp": time.time(),
-        }
-
-
-@router.post("/chat/stream", summary="Explicit streaming chat endpoint")
-async def chat_stream(req: ChatRequest, request: Request):
-    req.stream = True
-    return await chat(req, request)
-
-
-# ─── Goal API (create task from goal) ─────────────────────────────────────────
-
-@router.post("/goal", summary="Submit a high-level goal to the agent")
-async def submit_goal(req: GoalRequest, request: Request):
-    engine = get_engine(request)
-    task_req = TaskCreateRequest(
-        goal=req.goal,
-        session_id=req.session_id,
-        project_id=req.project_id,
-        stream=req.stream,
-        metadata={"source": "goal_api", "github_repo": req.github_repo},
-    )
-    task_id = await engine.submit(task_req)
-    return {
-        "task_id": task_id,
-        "goal": req.goal,
-        "status": "queued",
-        "session_id": req.session_id,
-        "ws_url": f"/ws/tasks/{task_id}",
-        "stream_url": f"/api/v1/tasks/{task_id}/stream",
-    }
-
-
-@router.post("/goal/stream", summary="Submit goal with SSE streaming response")
-async def submit_goal_stream(req: GoalRequest, request: Request):
-    req.stream = True
-    return await submit_goal(req, request)
-
-
-# ─── Execute (direct tool execution) ──────────────────────────────────────────
-
-@router.post("/execute", summary="Execute a tool directly")
-async def execute(
-    tool: str,
-    task: str,
-    request: Request,
-    session_id: str = "",
-):
-    from tools.executor import ToolExecutor
-    ws = get_ws(request)
-    executor = ToolExecutor(ws)
-    result = await executor.run(
-        tool=tool,
-        task=task,
-        session_id=session_id,
-    )
-    return {"tool": tool, "task": task, "result": result, "session_id": session_id}
-
-
-# ─── Plan (generate plan without executing) ───────────────────────────────────
-
-@router.post("/plan", summary="Generate execution plan for a goal")
-async def generate_plan(req: GoalRequest, request: Request):
-    from core.agent import AgentCore
-    ws = get_ws(request)
-    agent = AgentCore(ws)
-    task_id = f"plan_{uuid.uuid4().hex[:8]}"
-    plan = await agent.plan(goal=req.goal, task_id=task_id, session_id=req.session_id)
-    return {
-        "goal": req.goal,
-        "plan": plan.model_dump(),
-        "session_id": req.session_id,
-        "task_id": task_id,
-    }

api/routes/connectors.py

@@ -1,49 +0,0 @@
-"""
-Connectors API — Manus-style connector management
-"""
-from fastapi import APIRouter, Request, HTTPException
-from pydantic import BaseModel
-from typing import Optional
-from connectors.manager import ConnectorManager
-
-router = APIRouter()
-connector_manager = ConnectorManager()
-
-
-class SetTokenRequest(BaseModel):
-    connector_id: str
-    token: str
-
-
-@router.get("/")
-async def get_all_connectors():
-    return {"connectors": connector_manager.get_all()}
-
-
-@router.get("/connected")
-async def get_connected():
-    return {"connectors": connector_manager.get_connected()}
-
-
-@router.get("/summary")
-async def get_summary():
-    return connector_manager.get_summary()
-
-
-@router.get("/category/{category}")
-async def get_by_category(category: str):
-    return {"connectors": connector_manager.get_by_category(category)}
-
-
-@router.post("/set-token")
-async def set_token(req: SetTokenRequest):
-    connector_manager.set_token(req.connector_id, req.token)
-    return {"status": "ok", "connector": req.connector_id, "connected": True}
-
-
-@router.get("/{connector_id}/status")
-async def get_status(connector_id: str):
-    return {
-        "connector_id": connector_id,
-        "connected": connector_manager.is_connected(connector_id),
-    }

api/routes/github.py

@@ -1,336 +0,0 @@
-"""
-GitHub Autonomous Engineering API Routes
-Clone, commit, push, PR, issues — all autonomous
-"""
-
-import os
-import time
-import asyncio
-import tempfile
-import shutil
-from typing import Optional
-
-import httpx
-from fastapi import APIRouter, HTTPException, Request
-
-from core.models import (
-    GitHubCloneRequest, GitHubCreateRepoRequest,
-    GitHubCommitRequest, GitHubPRRequest, GitHubIssueRequest,
-)
-from memory.db import save_memory
-
-router = APIRouter()
-
-GITHUB_TOKEN = os.environ.get("GITHUB_TOKEN", "")
-GITHUB_OWNER = os.environ.get("GITHUB_OWNER", "")
-GITHUB_API = "https://api.github.com"
-
-
-def gh_headers():
-    if not GITHUB_TOKEN:
-        raise HTTPException(status_code=400, detail="GITHUB_TOKEN not configured")
-    return {
-        "Authorization": f"Bearer {GITHUB_TOKEN}",
-        "Accept": "application/vnd.github+json",
-        "X-GitHub-Api-Version": "2022-11-28",
-    }
-
-
-async def gh_get(path: str) -> dict:
-    async with httpx.AsyncClient(timeout=30) as client:
-        r = await client.get(f"{GITHUB_API}{path}", headers=gh_headers())
-        r.raise_for_status()
-        return r.json()
-
-
-async def gh_post(path: str, data: dict) -> dict:
-    async with httpx.AsyncClient(timeout=30) as client:
-        r = await client.post(f"{GITHUB_API}{path}", headers=gh_headers(), json=data)
-        r.raise_for_status()
-        return r.json()
-
-
-async def gh_put(path: str, data: dict) -> dict:
-    async with httpx.AsyncClient(timeout=30) as client:
-        r = await client.put(f"{GITHUB_API}{path}", headers=gh_headers(), json=data)
-        r.raise_for_status()
-        return r.json()
-
-
-async def gh_patch(path: str, data: dict) -> dict:
-    async with httpx.AsyncClient(timeout=30) as client:
-        r = await client.patch(f"{GITHUB_API}{path}", headers=gh_headers(), json=data)
-        r.raise_for_status()
-        return r.json()
-
-
-# ─── Clone ────────────────────────────────────────────────────────────────────
-
-@router.post("/clone", summary="Clone a GitHub repository")
-async def clone_repo(req: GitHubCloneRequest):
-    try:
-        import git
-    except ImportError:
-        raise HTTPException(status_code=500, detail="gitpython not installed")
-
-    local_path = req.local_path or f"/tmp/repos/{req.repo_url.split('/')[-1].replace('.git', '')}"
-    os.makedirs(local_path, exist_ok=True)
-
-    if GITHUB_TOKEN:
-        url = req.repo_url.replace("https://", f"https://{GITHUB_TOKEN}@")
-    else:
-        url = req.repo_url
-
-    try:
-        if os.path.exists(os.path.join(local_path, ".git")):
-            repo = git.Repo(local_path)
-            repo.remotes.origin.pull()
-            action = "pulled"
-        else:
-            repo = git.Repo.clone_from(url, local_path, branch=req.branch, depth=1)
-            action = "cloned"
-
-        files = []
-        for root, dirs, fnames in os.walk(local_path):
-            dirs[:] = [d for d in dirs if d not in [".git", "node_modules", "__pycache__"]]
-            for f in fnames[:50]:
-                files.append(os.path.relpath(os.path.join(root, f), local_path))
-
-        # Save to memory
-        await save_memory(
-            content=f"Repo {req.repo_url} cloned to {local_path}. Files: {', '.join(files[:20])}",
-            memory_type="repo",
-            key=req.repo_url,
-        )
-
-        return {
-            "action": action,
-            "repo_url": req.repo_url,
-            "local_path": local_path,
-            "branch": req.branch,
-            "files_count": len(files),
-            "files": files[:30],
-        }
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Clone failed: {str(e)}")
-
-
-# ─── Create Repo ──────────────────────────────────────────────────────────────
-
-@router.post("/create_repo", summary="Create a new GitHub repository")
-async def create_repo(req: GitHubCreateRepoRequest):
-    data = {
-        "name": req.name,
-        "description": req.description,
-        "private": req.private,
-        "auto_init": req.auto_init,
-    }
-    try:
-        result = await gh_post("/user/repos", data)
-        return {
-            "repo": result["full_name"],
-            "url": result["html_url"],
-            "clone_url": result["clone_url"],
-            "default_branch": result.get("default_branch", "main"),
-            "private": result["private"],
-        }
-    except httpx.HTTPStatusError as e:
-        raise HTTPException(status_code=e.response.status_code, detail=e.response.text)
-
-
-# ─── Commit Files ─────────────────────────────────────────────────────────────
-
-@router.post("/commit", summary="Commit files to a repository")
-async def commit_files(req: GitHubCommitRequest):
-    import base64
-
-    owner_repo = req.repo if "/" in req.repo else f"{GITHUB_OWNER}/{req.repo}"
-    results = []
-
-    for file_path, content in req.files.items():
-        encoded = base64.b64encode(content.encode()).decode()
-
-        # Get current SHA if file exists
-        sha = None
-        try:
-            existing = await gh_get(f"/repos/{owner_repo}/contents/{file_path}?ref={req.branch}")
-            sha = existing.get("sha")
-        except Exception:
-            pass
-
-        payload = {
-            "message": req.message,
-            "content": encoded,
-            "branch": req.branch,
-        }
-        if sha:
-            payload["sha"] = sha
-
-        try:
-            result = await gh_put(f"/repos/{owner_repo}/contents/{file_path}", payload)
-            results.append({"file": file_path, "status": "committed", "sha": result["content"]["sha"]})
-        except Exception as e:
-            results.append({"file": file_path, "status": "error", "error": str(e)})
-
-    return {
-        "repo": owner_repo,
-        "branch": req.branch,
-        "message": req.message,
-        "files": results,
-        "committed": sum(1 for r in results if r["status"] == "committed"),
-    }
-
-
-# ─── Push ─────────────────────────────────────────────────────────────────────
-
-@router.post("/push", summary="Push local changes to remote")
-async def push_changes(
-    repo_path: str,
-    branch: str = "main",
-    message: str = "Auto-commit by Devin Agent",
-):
-    try:
-        import git
-        repo = git.Repo(repo_path)
-        repo.git.add(A=True)
-        if repo.index.diff("HEAD") or repo.untracked_files:
-            repo.index.commit(message)
-        origin = repo.remote("origin")
-        origin.push(refspec=f"HEAD:{branch}")
-        return {"status": "pushed", "branch": branch, "message": message}
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Push failed: {str(e)}")
-
-
-# ─── Create PR ────────────────────────────────────────────────────────────────
-
-@router.post("/pr/create", summary="Create a Pull Request")
-async def create_pr(req: GitHubPRRequest):
-    owner_repo = req.repo if "/" in req.repo else f"{GITHUB_OWNER}/{req.repo}"
-    data = {
-        "title": req.title,
-        "body": req.body,
-        "head": req.head,
-        "base": req.base,
-        "draft": req.draft,
-    }
-    try:
-        result = await gh_post(f"/repos/{owner_repo}/pulls", data)
-        return {
-            "pr_number": result["number"],
-            "title": result["title"],
-            "url": result["html_url"],
-            "state": result["state"],
-            "head": req.head,
-            "base": req.base,
-        }
-    except httpx.HTTPStatusError as e:
-        raise HTTPException(status_code=e.response.status_code, detail=e.response.text)
-
-
-# ─── Create Issue ─────────────────────────────────────────────────────────────
-
-@router.post("/issues/create", summary="Create a GitHub Issue")
-async def create_issue(req: GitHubIssueRequest):
-    owner_repo = req.repo if "/" in req.repo else f"{GITHUB_OWNER}/{req.repo}"
-    data = {"title": req.title, "body": req.body, "labels": req.labels}
-    try:
-        result = await gh_post(f"/repos/{owner_repo}/issues", data)
-        return {
-            "issue_number": result["number"],
-            "title": result["title"],
-            "url": result["html_url"],
-            "state": result["state"],
-        }
-    except httpx.HTTPStatusError as e:
-        raise HTTPException(status_code=e.response.status_code, detail=e.response.text)
-
-
-# ─── Code Review ──────────────────────────────────────────────────────────────
-
-@router.post("/review", summary="AI code review for a PR")
-async def review_pr(repo: str, pr_number: int, request: Request):
-    owner_repo = repo if "/" in repo else f"{GITHUB_OWNER}/{repo}"
-    try:
-        pr = await gh_get(f"/repos/{owner_repo}/pulls/{pr_number}")
-        files = await gh_get(f"/repos/{owner_repo}/pulls/{pr_number}/files")
-
-        file_changes = []
-        for f in files[:10]:
-            file_changes.append(f"{f['filename']}: +{f.get('additions',0)}/-{f.get('deletions',0)}")
-
-        ws = request.app.state.ws_manager
-        from core.agent import AgentCore
-        agent = AgentCore(ws)
-
-        review_prompt = (
-            f"Review this Pull Request:\n"
-            f"Title: {pr['title']}\n"
-            f"Description: {pr.get('body', 'No description')}\n"
-            f"Files changed: {chr(10).join(file_changes)}\n\n"
-            f"Provide a constructive code review with: summary, potential issues, suggestions, and verdict."
-        )
-        messages = [
-            {"role": "system", "content": "You are a senior software engineer doing code review. Be constructive, specific, and helpful."},
-            {"role": "user", "content": review_prompt},
-        ]
-        review = await agent.llm_stream(messages)
-
-        # Post review comment
-        if GITHUB_TOKEN:
-            await gh_post(f"/repos/{owner_repo}/issues/{pr_number}/comments", {"body": f"🤖 **Devin Agent Code Review**\n\n{review}"})
-
-        return {
-            "pr_number": pr_number,
-            "title": pr["title"],
-            "review": review,
-            "files_reviewed": len(files),
-            "posted_to_github": bool(GITHUB_TOKEN),
-        }
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
-
-
-# ─── Repo Info ────────────────────────────────────────────────────────────────
-
-@router.get("/repo/{owner}/{repo}", summary="Get repository info")
-async def get_repo_info(owner: str, repo: str):
-    try:
-        info = await gh_get(f"/repos/{owner}/{repo}")
-        return {
-            "name": info["name"],
-            "full_name": info["full_name"],
-            "description": info.get("description"),
-            "url": info["html_url"],
-            "default_branch": info["default_branch"],
-            "language": info.get("language"),
-            "stars": info["stargazers_count"],
-            "forks": info["forks_count"],
-            "open_issues": info["open_issues_count"],
-            "private": info["private"],
-        }
-    except httpx.HTTPStatusError as e:
-        raise HTTPException(status_code=e.response.status_code, detail=e.response.text)
-
-
-# ─── Status check ─────────────────────────────────────────────────────────────
-
-@router.get("/status", summary="GitHub integration status")
-async def github_status():
-    configured = bool(GITHUB_TOKEN)
-    user = None
-    if configured:
-        try:
-            user_info = await gh_get("/user")
-            user = user_info.get("login")
-        except Exception:
-            configured = False
-    return {
-        "configured": configured,
-        "user": user,
-        "owner": GITHUB_OWNER or user,
-        "capabilities": [
-            "clone", "create_repo", "commit", "push",
-            "pr/create", "issues/create", "review"
-        ],
-    }

api/routes/health.py

@@ -1,89 +0,0 @@
-"""
-Health + Status Routes — GOD AGENT OS v11
-"""
-
-import time
-import os
-import psutil
-from fastapi import APIRouter, Request
-
-router = APIRouter()
-
-
-@router.get("/health", summary="Health check")
-async def health(request: Request):
-    ws = getattr(request.app.state, "ws_manager", None)
-    engine = getattr(request.app.state, "task_engine", None)
-    orchestrator = getattr(request.app.state, "orchestrator", None)
-    ai_router = getattr(request.app.state, "ai_router", None)
-    connector_manager = getattr(request.app.state, "connector_manager", None)
-
-    ws_stats = ws.get_stats() if ws else {"total_connections": 0, "rooms": {}}
-    cs = connector_manager.get_summary() if connector_manager else {"connected": 0, "total": 0}
-    ai_stats = ai_router.get_stats() if ai_router else {}
-
-    orch_status = orchestrator.get_status() if orchestrator else {"agents": [], "total_agents": 0}
-
-    return {
-        "status": "healthy",
-        "name": "GOD AGENT OS v11 — Autonomous Engineering OS",
-        "version": "11.0.0",
-        "powered_by": "Pyae Sone",
-        "architecture": "Multi-Agent Orchestrator + Worker Spaces",
-        "timestamp": time.time(),
-        "platform": {
-            "mode": "god_mode",
-            "agents": orch_status.get("agents", []),
-            "agent_count": orch_status.get("total_agents", 0),
-        },
-        "ai_router": {
-            "providers": {k: v.get("available", False) for k, v in ai_stats.items()},
-            "ai_ready": any(v.get("available", False) for v in ai_stats.values()),
-        },
-        "connectors": {
-            "connected": cs.get("connected", 0),
-            "total": cs.get("total", 0),
-            "ai_ready": cs.get("ai_ready", False),
-        },
-        "task_engine": {
-            "queue_size": engine._queue.qsize() if engine else 0,
-            "active_tasks": len(engine._active) if engine else 0,
-        },
-        "websocket": {
-            "connections": ws_stats.get("total_connections", 0),
-            "rooms": list(ws_stats.get("rooms", {}).keys()),
-        },
-        "phases": [
-            "Phase 1: God Agent Orchestrator ✅",
-            "Phase 2: Sandbox Agent ✅",
-            "Phase 3: Connector System ✅",
-            "Phase 4: Autonomous Coding Engine ✅",
-            "Phase 5: Memory System ✅",
-            "Phase 6: Real-time Streaming ✅",
-            "Phase 7: Workflow Factor OS ✅",
-            "Phase 8: Modern UI Rebuild ✅",
-            "Phase 9: Multi-Model AI Router v10 ✅",
-            "Phase 10: v11 Production Hardening ✅",
-        ],
-    }
-
-
-@router.get("/metrics", summary="System metrics")
-async def metrics():
-    cpu = psutil.cpu_percent(interval=0.1)
-    mem = psutil.virtual_memory()
-    disk = psutil.disk_usage("/")
-    return {
-        "cpu_percent": cpu,
-        "memory": {
-            "total_mb": round(mem.total / 1024 / 1024),
-            "used_mb": round(mem.used / 1024 / 1024),
-            "percent": mem.percent,
-        },
-        "disk": {
-            "total_gb": round(disk.total / 1024 / 1024 / 1024, 1),
-            "used_gb": round(disk.used / 1024 / 1024 / 1024, 1),
-            "percent": disk.percent,
-        },
-        "timestamp": time.time(),
-    }

api/routes/memory.py

@@ -1,50 +0,0 @@
-"""
-Memory API Routes — Persistent agent memory
-"""
-
-import time
-from fastapi import APIRouter, HTTPException, Query
-from core.models import MemorySaveRequest, MemorySearchRequest
-from memory.db import save_memory, search_memory, get_project_memory, get_history
-
-router = APIRouter()
-
-
-@router.post("/", summary="Save memory")
-async def save(req: MemorySaveRequest):
-    await save_memory(
-        content=req.content,
-        memory_type=req.memory_type.value,
-        session_id=req.session_id,
-        project_id=req.project_id,
-        key=req.key,
-        metadata=req.metadata,
-    )
-    return {"status": "saved", "memory_type": req.memory_type, "timestamp": time.time()}
-
-
-@router.post("/search", summary="Search memory")
-async def search(req: MemorySearchRequest):
-    results = await search_memory(
-        query=req.query,
-        session_id=req.session_id,
-        project_id=req.project_id,
-        limit=req.limit,
-    )
-    return {"results": results, "total": len(results), "query": req.query}
-
-
-@router.get("/project/{project_id}", summary="Get project memory")
-async def project_memory(
-    project_id: str,
-    memory_type: str = Query(default=""),
-    limit: int = Query(default=100, le=500),
-):
-    results = await get_project_memory(project_id, memory_type=memory_type, limit=limit)
-    return {"project_id": project_id, "memories": results, "total": len(results)}
-
-
-@router.get("/history/{session_id}", summary="Get conversation history")
-async def history(session_id: str, limit: int = Query(default=50, le=200)):
-    results = await get_history(session_id, limit=limit)
-    return {"session_id": session_id, "history": results, "total": len(results)}

api/routes/tasks.py

@@ -1,167 +0,0 @@
-"""
-Task API Routes — CRUD + Streaming + WebSocket
-"""
-
-import asyncio
-import json
-import time
-from typing import Optional
-
-from fastapi import APIRouter, HTTPException, Request, Query
-from fastapi.responses import StreamingResponse
-
-from core.models import (
-    TaskCreateRequest, TaskCancelRequest, TaskRetryRequest, TaskResponse, TaskStatus
-)
-from memory.db import get_task, list_tasks, get_task_events, update_task_status
-
-router = APIRouter()
-
-
-def get_engine(request: Request):
-    return request.app.state.task_engine
-
-
-def get_ws(request: Request):
-    return request.app.state.ws_manager
-
-
-# ─── Create Task ───────────────────────────────────────────────────────────────
-
-@router.post("/create", summary="Create & queue a new agent task")
-async def create_task(req: TaskCreateRequest, request: Request):
-    engine = get_engine(request)
-    task_id = await engine.submit(req)
-    task = await get_task(task_id)
-    return {
-        "task_id": task_id,
-        "status": "queued",
-        "goal": req.goal,
-        "session_id": req.session_id,
-        "stream_url": f"/api/v1/tasks/{task_id}/stream",
-        "ws_url": f"/ws/tasks/{task_id}",
-        "created_at": task["created_at"] if task else time.time(),
-    }
-
-
-# ─── Get Task ──────────────────────────────────────────────────────────────────
-
-@router.get("/{task_id}", summary="Get task details")
-async def get_task_detail(task_id: str):
-    task = await get_task(task_id)
-    if not task:
-        raise HTTPException(status_code=404, detail=f"Task {task_id} not found")
-    return task
-
-
-# ─── Get Task Status ───────────────────────────────────────────────────────────
-
-@router.get("/{task_id}/status", summary="Get task status only")
-async def get_task_status(task_id: str):
-    task = await get_task(task_id)
-    if not task:
-        raise HTTPException(status_code=404, detail=f"Task {task_id} not found")
-    return {
-        "task_id": task_id,
-        "status": task["status"],
-        "retry_count": task.get("retry_count", 0),
-        "created_at": task.get("created_at"),
-        "started_at": task.get("started_at"),
-        "completed_at": task.get("completed_at"),
-    }
-
-
-# ─── Cancel Task ───────────────────────────────────────────────────────────────
-
-@router.post("/{task_id}/cancel", summary="Cancel a running task")
-async def cancel_task(task_id: str, req: TaskCancelRequest, request: Request):
-    task = await get_task(task_id)
-    if not task:
-        raise HTTPException(status_code=404, detail=f"Task {task_id} not found")
-    if task["status"] in ("completed", "failed", "cancelled"):
-        raise HTTPException(status_code=400, detail=f"Task already {task['status']}")
-    engine = get_engine(request)
-    await engine.cancel(task_id, req.reason)
-    return {"task_id": task_id, "status": "cancelled", "reason": req.reason}
-
-
-# ─── Retry Task ────────────────────────────────────────────────────────────────
-
-@router.post("/{task_id}/retry", summary="Retry a failed task")
-async def retry_task(task_id: str, request: Request):
-    task = await get_task(task_id)
-    if not task:
-        raise HTTPException(status_code=404, detail=f"Task {task_id} not found")
-    if task["status"] not in ("failed", "cancelled"):
-        raise HTTPException(status_code=400, detail="Only failed/cancelled tasks can be retried")
-    engine = get_engine(request)
-    await engine.retry(task_id)
-    return {"task_id": task_id, "status": "queued", "message": "Task requeued for retry"}
-
-
-# ─── Stream Task Events (SSE) ──────────────────────────────────────────────────
-
-@router.get("/{task_id}/stream", summary="Stream task events via SSE")
-async def stream_task(task_id: str, request: Request):
-    task = await get_task(task_id)
-    if not task:
-        raise HTTPException(status_code=404, detail=f"Task {task_id} not found")
-
-    async def event_generator():
-        # First, replay all stored events
-        events = await get_task_events(task_id)
-        for ev in events:
-            data = json.dumps({
-                "type": ev["event_type"],
-                "task_id": task_id,
-                "timestamp": ev["timestamp"],
-                "data": json.loads(ev["data"]) if ev.get("data") else {},
-            })
-            yield f"data: {data}\n\n"
-
-        # Then stream live events via WS manager buffer
-        ws = get_ws(request)
-        room = f"task:{task_id}"
-        last_count = len(events)
-        
-        # Poll for new events (for SSE fallback)
-        for _ in range(600):  # max 5 minutes
-            await asyncio.sleep(0.5)
-            current_task = await get_task(task_id)
-            if current_task and current_task["status"] in ("completed", "failed", "cancelled"):
-                yield f"data: {json.dumps({'type': 'stream_end', 'task_id': task_id, 'status': current_task['status']})}\n\n"
-                break
-            # heartbeat
-            yield f"data: {json.dumps({'type': 'heartbeat', 'timestamp': time.time()})}\n\n"
-
-    return StreamingResponse(
-        event_generator(),
-        media_type="text/event-stream",
-        headers={
-            "Cache-Control": "no-cache",
-            "X-Accel-Buffering": "no",
-            "Connection": "keep-alive",
-        },
-    )
-
-
-# ─── List Tasks ────────────────────────────────────────────────────────────────
-
-@router.get("/", summary="List tasks")
-async def list_all_tasks(
-    session_id: str = Query(default=""),
-    limit: int = Query(default=50, le=200),
-):
-    tasks = await list_tasks(session_id=session_id, limit=limit)
-    return {"tasks": tasks, "total": len(tasks)}
-
-
-# ─── Task Events History ───────────────────────────────────────────────────────
-
-@router.get("/{task_id}/events", summary="Get all events for a task")
-async def task_events(task_id: str):
-    task = await get_task(task_id)
-    if not task:
-        raise HTTPException(status_code=404, detail=f"Task {task_id} not found")
-    events = await get_task_events(task_id)
-    return {"task_id": task_id, "events": events, "total": len(events)}

api/websocket_manager.py

@@ -1,134 +0,0 @@
-"""
-WebSocket Connection Manager — Production Grade
-Handles rooms, heartbeats, event buffering, reconnect support
-"""
-
-import asyncio
-import json
-import time
-import uuid
-from collections import defaultdict
-from typing import Dict, List, Optional, Set
-import structlog
-
-log = structlog.get_logger()
-
-
-class WebSocketManager:
-    def __init__(self):
-        # room → set of websockets
-        self._rooms: Dict[str, Set] = defaultdict(set)
-        # ws → list of rooms
-        self._ws_rooms: Dict[object, Set[str]] = defaultdict(set)
-        # Event buffer per room (for replay on reconnect)
-        self._event_buffer: Dict[str, List] = defaultdict(list)
-        self._buffer_max = 100
-        # Active connection count
-        self._connection_count = 0
-
-    async def connect(self, websocket, room: str):
-        await websocket.accept()
-        self._rooms[room].add(websocket)
-        self._ws_rooms[websocket].add(room)
-        self._connection_count += 1
-        log.info("WS connected", room=room, total=self._connection_count)
-
-        # Replay buffered events for this room
-        buffered = self._event_buffer.get(room, [])[-20:]
-        for event in buffered:
-            try:
-                await websocket.send_json(event)
-            except Exception:
-                pass
-
-        await websocket.send_json({
-            "type": "connected",
-            "room": room,
-            "timestamp": time.time(),
-            "buffered_events": len(buffered),
-        })
-
-    def disconnect(self, websocket, room: Optional[str] = None):
-        if room:
-            self._rooms[room].discard(websocket)
-            self._ws_rooms[websocket].discard(room)
-        else:
-            for r in list(self._ws_rooms.get(websocket, [])):
-                self._rooms[r].discard(websocket)
-            self._ws_rooms.pop(websocket, None)
-        self._connection_count = max(0, self._connection_count - 1)
-        log.info("WS disconnected", room=room, total=self._connection_count)
-
-    async def broadcast(self, room: str, event: dict):
-        """Broadcast event to all sockets in a room."""
-        if "timestamp" not in event:
-            event["timestamp"] = time.time()
-        if "id" not in event:
-            event["id"] = str(uuid.uuid4())[:8]
-
-        # Buffer event
-        self._event_buffer[room].append(event)
-        if len(self._event_buffer[room]) > self._buffer_max:
-            self._event_buffer[room].pop(0)
-
-        dead = set()
-        for ws in list(self._rooms.get(room, [])):
-            try:
-                await ws.send_json(event)
-            except Exception:
-                dead.add(ws)
-
-        for ws in dead:
-            self.disconnect(ws, room)
-
-    async def broadcast_global(self, event: dict):
-        """Broadcast to ALL connected websockets."""
-        for room in list(self._rooms.keys()):
-            await self.broadcast(room, event)
-
-    async def emit(self, task_id: str, event_type: str, data: dict, session_id: str = ""):
-        """Emit a structured event to a task room + logs room."""
-        event = {
-            "type": event_type,
-            "task_id": task_id,
-            "session_id": session_id,
-            "timestamp": time.time(),
-            "data": data,
-        }
-        await self.broadcast(f"task:{task_id}", event)
-        await self.broadcast("logs", event)
-        await self.broadcast("agent_status", {
-            "type": "agent_event",
-            "task_id": task_id,
-            "event_type": event_type,
-            "timestamp": time.time(),
-        })
-
-    async def emit_chat(self, session_id: str, event_type: str, data: dict):
-        """Emit event to a chat session room."""
-        event = {
-            "type": event_type,
-            "session_id": session_id,
-            "timestamp": time.time(),
-            "data": data,
-        }
-        await self.broadcast(f"chat:{session_id}", event)
-
-    async def heartbeat_loop(self):
-        """Send heartbeat to all connections every 15s."""
-        while True:
-            await asyncio.sleep(15)
-            heartbeat = {
-                "type": "heartbeat",
-                "timestamp": time.time(),
-                "connections": self._connection_count,
-            }
-            for room in list(self._rooms.keys()):
-                await self.broadcast(room, heartbeat)
-
-    def get_stats(self) -> dict:
-        return {
-            "total_connections": self._connection_count,
-            "rooms": {r: len(ws) for r, ws in self._rooms.items()},
-            "buffered_events": {r: len(e) for r, e in self._event_buffer.items()},
-        }