Upload ide/server.py with huggingface_hub

ide/server.py

@@ -12,6 +12,8 @@ from rabbit import WhiteRabbit
 from android_compiler_fixed import AndroidCompiler
 from mesh_repo import MeshRepo, _set_node_id
 from fsi_sandbox import ExecutionSandbox
+from fsi_shadow import ShadowMode
+from fsi_selfplay import SelfPlay
 
 HOST = "0.0.0.0"
 PORT = 8080
@@ -39,6 +41,8 @@ class APIHandler(SimpleHTTPRequestHandler):
     rabbit = None
     android = None
     mesh_repo = None
+    shadow = None
+    selfplay = None
     _start_time = time.time()
 
     def __init__(self, *args, **kwargs):
@@ -65,6 +69,8 @@ class APIHandler(SimpleHTTPRequestHandler):
 
     def do_GET(self):
         path = urlparse(self.path).path
+        if APIHandler.shadow:
+            APIHandler.shadow.register_input()
         handlers = {
             "/api/status": self._handle_status,
             "/api/stats": self._handle_stats,
@@ -75,6 +81,8 @@ class APIHandler(SimpleHTTPRequestHandler):
             "/api/mesh/discover": self._handle_mesh_discover,
             "/api/android/env": self._handle_android_env,
             "/api/mesh/repo/search": self._handle_mesh_repo_search,
+            "/api/shadow/status": self._handle_shadow_status,
+            "/api/selfplay/status": self._handle_selfplay_status,
         }
         handler = handlers.get(path)
         if handler:
@@ -85,6 +93,8 @@ class APIHandler(SimpleHTTPRequestHandler):
     def do_POST(self):
         path = urlparse(self.path).path
         body = self._read_body()
+        if APIHandler.shadow:
+            APIHandler.shadow.register_input()
         handlers = {
             "/api/command": self._handle_command,
             "/api/build": self._handle_build,
@@ -111,6 +121,8 @@ class APIHandler(SimpleHTTPRequestHandler):
             "/api/super/generate": self._handle_super_generate,
             "/api/super/run": self._handle_super_run,
             "/api/super/status": self._handle_super_status,
+            "/api/shadow/run": self._handle_shadow_run,
+            "/api/selfplay/run": self._handle_selfplay_run,
         }
         handler = handlers.get(path)
         if handler:
@@ -132,6 +144,19 @@ class APIHandler(SimpleHTTPRequestHandler):
             try:
                 from chimera.engine import ChimeraEngine
                 APIHandler.chimera = ChimeraEngine()
+                self._ensure_shadow()
+            except Exception as e:
+                return str(e)
+        return None
+
+    def _ensure_shadow(self):
+        if APIHandler.shadow is None:
+            try:
+                sandbox = ExecutionSandbox()
+                sp = SelfPlay(chimera=APIHandler.chimera, sandbox=sandbox)
+                APIHandler.selfplay = sp
+                APIHandler.shadow = ShadowMode(chimera=APIHandler.chimera, sandbox=sandbox, selfplay=sp)
+                APIHandler.shadow.start()
             except Exception as e:
                 return str(e)
         return None
@@ -305,6 +330,8 @@ class APIHandler(SimpleHTTPRequestHandler):
                 "  super use <id>       — Select foreground variant (checks bg solutions on error)",
                 "  super run <id>       — Run foreground + 4 background variants simultaneously",
                 "  super status         — Show all variant statuses",
+                "  shadow status        — Shadow mode status",
+                "  selfplay run [n]     — Run self-play (default 10 rounds)",
                 "  clear                — Clear terminal",
                 "  woogity woogity      — ???",
             ]
@@ -503,6 +530,29 @@ class APIHandler(SimpleHTTPRequestHandler):
                 output.append(f"  [{v['id']}] {icon} {v['approach']:14s} → {v.get('status', 'pending')} ({v.get('loc', 0)} LOC)")
             td = ci.superimposition.collect_training_data()
             output.append(f"[SUPER] Training data: {len(td)} entries ready")
+        elif lower == "shadow status" or lower.startswith("shadow "):
+            err = self._ensure_shadow()
+            if err or not APIHandler.shadow:
+                output.append(f"[SHADOW] Error: {err or 'shadow not loaded'}")
+            else:
+                s = APIHandler.shadow.get_status()
+                output.append(f"[SHADOW] Active: {s['active']} | Idle: {s['idle_secs']}s | Running: {s['running']}")
+                output.append(f"[SHADOW] Training data: {s['training_dir']} bytes | Log: {s['log_size']} bytes")
+                if s['active']:
+                    output.append(f"[SHADOW] Session elapsed: {s['session_elapsed']}s")
+        elif lower.startswith("selfplay"):
+            err = self._ensure_shadow()
+            if err or not APIHandler.selfplay:
+                output.append(f"[SELFPLAY] Error: {err or 'selfplay not loaded'}")
+            else:
+                parts = cmd.split()
+                rounds = 10
+                if len(parts) >= 2 and parts[-1].isdigit():
+                    rounds = int(parts[-1])
+                output.append(f"[SELFPLAY] Running {rounds} rounds...")
+                summary = APIHandler.selfplay.run_session(rounds=rounds)
+                output.append(f"[SELFPLAY] Builder: {summary['builder_total']} pts | Breaker: {summary['breaker_total']} pts")
+                output.append(f"[SELFPLAY] Winner: {summary['winner']} | Flaws: {summary['total_flaws']} | Fixes: {summary['total_fixes']}")
         elif lower.startswith("test"):
             target = rest or "all"
             output.append(f"[TEST] Running test suite: {target}")
@@ -976,6 +1026,40 @@ class APIHandler(SimpleHTTPRequestHandler):
             "log_path": SUPERIMPOSITION_LOG if 'SUPERIMPOSITION_LOG' in dir() else "/tmp/fsi_felon/superimposition_log.json",
         })
 
+    # ── Shadow Mode Handlers ──
+    def _handle_shadow_status(self):
+        err = self._ensure_shadow()
+        if err or not APIHandler.shadow:
+            self._send_json({"error": "Shadow not ready"})
+            return
+        self._send_json(APIHandler.shadow.get_status())
+
+    def _handle_shadow_run(self, body):
+        err = self._ensure_shadow()
+        if err or not APIHandler.shadow:
+            self._send_json({"error": "Shadow not ready"})
+            return
+        shadow = APIHandler.shadow
+        shadow.last_input = time.time() - 310  # Force idle
+        self._send_json({"status": "shadow_triggered", "message": "Shadow mode will activate on next cycle"})
+
+    # ── Self-Play Mode Handlers ──
+    def _handle_selfplay_status(self):
+        err = self._ensure_shadow()
+        if err or not APIHandler.selfplay:
+            self._send_json({"error": "SelfPlay not ready"})
+            return
+        self._send_json(APIHandler.selfplay.get_status())
+
+    def _handle_selfplay_run(self, body):
+        err = self._ensure_shadow()
+        if err or not APIHandler.selfplay:
+            self._send_json({"error": "SelfPlay not ready"})
+            return
+        rounds = body.get("rounds", 10)
+        summary = APIHandler.selfplay.run_session(rounds=rounds)
+        self._send_json(summary)
+
     def _handle_mesh_related(self, body):
         text = body.get("text", "").lower()
         if not text or len(text) < 10: