feat: GOD MODE+ v4.0 - main.py

main.py

@@ -1,7 +1,7 @@
 """
-🚀 GOD MODE+ Autonomous AI Operating System
-Devin + Manus + Genspark Style — Production-Grade Backend
-Version: 4.0.0 — Real Execution Engine + Mission Control UI
+🚀 GOD MODE+ Autonomous AI Operating System v4.0
+REAL Execution-First Architecture — Devin + Manus + Genspark Style
+Phase 4: Terminal Engine + FileSystem + GitHub + DAG + Self-Repair
 """
 
 import asyncio
@@ -42,9 +42,14 @@ 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.autonomous_agent import AutonomousAgent
 from connectors.manager import ConnectorManager
 
+# ─── New Execution Tools ───────────────────────────────────────────────────────
+from tools.terminal_engine import TerminalEngine
+from tools.filesystem import FileSystemTool
+from tools.github_tool import GitHubTool
+from tools.task_dag import DAGEngine
+
 # ─── Structured Logging ────────────────────────────────────────────────────────
 structlog.configure(
     processors=[
@@ -65,11 +70,16 @@ task_engine = TaskEngine(ws_manager)
 ai_router = AIRouter(ws_manager)
 connector_manager = ConnectorManager()
 
+# ─── Execution Tools ───────────────────────────────────────────────────────────
+terminal_engine = TerminalEngine(ws_manager)
+fs_tool = FileSystemTool()
+github_tool = GitHubTool()
+dag_engine = DAGEngine(ws_manager)
+
+
 # ─── 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))
@@ -80,35 +90,40 @@ def build_orchestrator() -> GodAgentOrchestrator:
     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("autonomous", AutonomousAgent(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...")
+    log.info("🚀 Starting GOD MODE+ v4.0 AI Operating System...")
+    log.info("⚡ REAL Execution Engine: Terminal + FileSystem + GitHub + DAG")
     await init_db()
     await task_engine.start()
     asyncio.create_task(ws_manager.heartbeat_loop())
-    log.info("✅ GOD MODE+ Platform ready — All agents online")
+
+    # Ensure workspace exists
+    ws_dir = os.environ.get("WORKSPACE_DIR", "/tmp/god_workspace")
+    os.makedirs(ws_dir, exist_ok=True)
+
+    log.info("✅ GOD MODE+ v4.0 Platform ready")
     log.info("🤖 Agents: Chat, Planner, Coding, Debug, Memory, Connector, Deploy, Workflow, Sandbox, UI")
+    log.info("🔧 Tools: TerminalEngine, FileSystem, GitHub, DAG Engine, SelfRepair")
     log.info("🌐 AI Router: OpenAI → Groq → Cerebras → OpenRouter → Anthropic")
     yield
-    log.info("🛑 Shutting down...")
+    log.info("🛑 Shutting down GOD MODE+ v4.0...")
     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",
+    title="🤖 GOD MODE+ AI Operating System v4.0",
+    description="REAL Execution-First Autonomous AI Engineering Platform — Devin + Manus + Genspark",
+    version="4.0.0",
     lifespan=lifespan,
     docs_url="/api/docs",
     redoc_url="/api/redoc",
@@ -123,6 +138,10 @@ app.state.task_engine = task_engine
 app.state.ai_router = ai_router
 app.state.orchestrator = orchestrator
 app.state.connector_manager = connector_manager
+app.state.terminal_engine = terminal_engine
+app.state.fs_tool = fs_tool
+app.state.github_tool = github_tool
+app.state.dag_engine = dag_engine
 
 # ─── Middleware ────────────────────────────────────────────────────────────────
 app.add_middleware(
@@ -154,34 +173,8 @@ app.include_router(connectors.router,         prefix="/api/v1/connectors",   tag
 app.include_router(agents_router.router,      prefix="/api/v1/agents",       tags=["agents"])
 app.include_router(execution_router.router,   prefix="/api/v1/exec",         tags=["execution"])
 
-# ─── WebSocket: autonomous execution stream ────────────────────────────────
-@app.websocket("/ws/exec/{session_id}")
-async def ws_exec(websocket: WebSocket, session_id: str):
-    """Live execution streaming for autonomous tasks."""
-    await ws_manager.connect(websocket, room=f"exec:{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") == "run":
-                from agents.autonomous_agent import AutonomousAgent
-                agent = AutonomousAgent(ws_manager=ws_manager, ai_router=ai_router)
-                asyncio.create_task(
-                    agent.run(
-                        msg.get("goal", ""),
-                        context=msg.get("context", {}),
-                        session_id=session_id,
-                        task_id=session_id,
-                        max_steps=msg.get("max_steps", 20),
-                    )
-                )
-    except WebSocketDisconnect:
-        ws_manager.disconnect(websocket, room=f"exec:{session_id}")
-
 
-# ─── WebSocket Endpoints ───────────────────────────────────────────────────────
+# ─── WebSocket: Task Stream ────────────────────────────────────────────────────
 @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}")
@@ -195,6 +188,7 @@ async def ws_task(websocket: WebSocket, task_id: str):
         ws_manager.disconnect(websocket, room=f"task:{task_id}")
 
 
+# ─── WebSocket: Logs ──────────────────────────────────────────────────────────
 @app.websocket("/ws/logs")
 async def ws_logs(websocket: WebSocket):
     await ws_manager.connect(websocket, room="logs")
@@ -208,6 +202,7 @@ async def ws_logs(websocket: WebSocket):
         ws_manager.disconnect(websocket, room="logs")
 
 
+# ─── WebSocket: Chat ──────────────────────────────────────────────────────────
 @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}")
@@ -218,7 +213,6 @@ async def ws_chat(websocket: WebSocket, session_id: str):
             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", ""),
@@ -227,7 +221,6 @@ async def ws_chat(websocket: WebSocket, session_id: str):
                     )
                 )
             elif msg.get("type") == "task_message":
-                # Create autonomous task via task engine
                 from core.models import TaskCreateRequest
                 req = TaskCreateRequest(
                     goal=msg.get("content", ""),
@@ -238,6 +231,7 @@ async def ws_chat(websocket: WebSocket, session_id: str):
         ws_manager.disconnect(websocket, room=f"chat:{session_id}")
 
 
+# ─── WebSocket: Agent Status ──────────────────────────────────────────────────
 @app.websocket("/ws/agent/status")
 async def ws_agent_status(websocket: WebSocket):
     await ws_manager.connect(websocket, room="agent_status")
@@ -256,40 +250,112 @@ async def ws_agent_status(websocket: WebSocket):
         ws_manager.disconnect(websocket, room="agent_status")
 
 
+# ─── WebSocket: Sandbox Terminal ──────────────────────────────────────────────
 @app.websocket("/ws/sandbox/{session_id}")
 async def ws_sandbox(websocket: WebSocket, session_id: str):
-    """Live sandbox terminal stream."""
+    """Live streaming sandbox terminal."""
     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:
+
+            elif msg.get("type") == "execute":
                 cmd = msg.get("command", "")
-                result = await sandbox.execute(cmd, session_id=session_id)
+                task_id = msg.get("task_id", "")
+
+                async def stream_line(line: str):
+                    try:
+                        await websocket.send_json({
+                            "type": "terminal_output",
+                            "line": line,
+                            "timestamp": time.time(),
+                        })
+                    except Exception:
+                        pass
+
+                result = await terminal_engine.execute(
+                    cmd,
+                    session_id=session_id,
+                    task_id=task_id,
+                    stream_callback=stream_line,
+                )
                 await websocket.send_json({
-                    "type": "terminal_output",
+                    "type": "terminal_result",
                     "command": cmd,
-                    "output": result,
+                    "output": result.get("output", ""),
+                    "exit_code": result.get("exit_code", 0),
+                    "success": result.get("success", False),
+                    "duration": result.get("duration", 0),
                     "timestamp": time.time(),
                 })
+
+            elif msg.get("type") == "kill":
+                result = await terminal_engine.kill(session_id)
+                await websocket.send_json({"type": "kill_result", **result})
+
+            elif msg.get("type") == "write_file":
+                filename = msg.get("filename", "")
+                content = msg.get("content", "")
+                result = await fs_tool.write_file(filename, content)
+                await websocket.send_json({"type": "file_result", **result})
+
+            elif msg.get("type") == "read_file":
+                filename = msg.get("filename", "")
+                result = await fs_tool.read_file(filename)
+                await websocket.send_json({"type": "file_result", **result})
+
+            elif msg.get("type") == "list_files":
+                result = await fs_tool.list_dir(msg.get("path", ""))
+                await websocket.send_json({"type": "file_list", **result})
+
+            elif msg.get("type") == "tree":
+                result = await fs_tool.tree(msg.get("path", ""))
+                await websocket.send_json({"type": "tree_result", **result})
+
     except WebSocketDisconnect:
         ws_manager.disconnect(websocket, room=f"sandbox:{session_id}")
 
 
+# ─── WebSocket: DAG Progress ──────────────────────────────────────────────────
+@app.websocket("/ws/dag/{dag_id}")
+async def ws_dag(websocket: WebSocket, dag_id: str):
+    """Real-time DAG execution progress."""
+    await ws_manager.connect(websocket, room=f"dag:{dag_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") == "get_dag":
+                dag = dag_engine.get_dag(dag_id)
+                if dag:
+                    await websocket.send_json({"type": "dag_state", "dag": dag.to_dict()})
+    except WebSocketDisconnect:
+        ws_manager.disconnect(websocket, room=f"dag:{dag_id}")
+
+
 # ─── Root ──────────────────────────────────────────────────────────────────────
 @app.get("/")
 async def root():
     cs = connector_manager.get_summary()
     return {
         "name": "🤖 GOD MODE+ AI Operating System",
-        "version": "3.0.0",
+        "version": "4.0.0",
         "status": "operational",
-        "mode": "god_mode_plus",
+        "mode": "god_mode_plus_v4",
+        "execution_engine": "REAL",
         "agents": orchestrator.get_status()["agents"],
+        "tools": {
+            "terminal": "TerminalEngine (streaming, self-repair)",
+            "filesystem": "FileSystemTool (read/write/patch/search/tree)",
+            "github": "GitHubTool (clone/commit/push/pr/issues)",
+            "dag": "DAGEngine (parallel, dependency-aware)",
+        },
         "connectors": {
             "connected": cs["connected"],
             "total": cs["total"],
@@ -302,6 +368,7 @@ async def root():
             "/ws/chat/{session_id}",
             "/ws/agent/status",
             "/ws/sandbox/{session_id}",
+            "/ws/dag/{dag_id}",
         ],
         "phases_complete": [
             "Phase 1: God Agent Orchestrator",
@@ -310,7 +377,12 @@ async def root():
             "Phase 4: Autonomous Coding Engine",
             "Phase 5: Memory System",
             "Phase 6: Real-time Streaming",
-            "Phase 7: Workflow Factor OS",
+            "Phase 7: Workflow Factory OS",
+            "Phase 8: Terminal Execution Engine",
             "Phase 9: Multi-Model AI Router",
+            "Phase 10: FileSystem Control",
+            "Phase 11: GitHub Autonomy",
+            "Phase 12: Task DAG Engine",
+            "Phase 13: Self-Repair Loop",
         ],
     }