gemcode 0.4.6__tar.gz → 0.4.9__tar.gz

{gemcode-0.4.6/src/gemcode.egg-info → gemcode-0.4.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gemcode
-Version: 0.4.6
+Version: 0.4.9
 Summary: Local-first coding agent on Google Gemini + ADK
 Author: GemCode Contributors
 License:                                  Apache License

{gemcode-0.4.6 → gemcode-0.4.9}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "gemcode"
-version = "0.4.6"
+version = "0.4.9"
 description = "Local-first coding agent on Google Gemini + ADK"
 readme = "README.md"
 requires-python = ">=3.11"

{gemcode-0.4.6 → gemcode-0.4.9}/src/gemcode/agent_mesh.py

@@ -66,7 +66,11 @@ class AgentMesh:
     self._running: dict[str, asyncio.Task] = {}
     self._completed: list[AgentJob] = []
     self._scheduler_task: asyncio.Task | None = None
-    self._stop = asyncio.Event()
+    self._stop: asyncio.Event | None = None  # Created in background loop
+    self._bg_thread: "threading.Thread | None" = None
+    self._bg_loop: asyncio.AbstractEventLoop | None = None
+    # _stop is created lazily in the background loop
+    self._stop_flag = False
 
     # Subscribe to org.assign messages on the bus
     self._bus.subscribe(
@@ -112,25 +116,69 @@ class AgentMesh:
     return self._bus
 
   def start(self) -> None:
-    """Start the background scheduler loop and trigger engine."""
-    if self._scheduler_task is None or self._scheduler_task.done():
-      self._scheduler_task = asyncio.create_task(self._scheduler_loop())
-    # Start self-triggering agents
+    """Start the mesh in a dedicated background thread with its own event loop.
+
+    This is critical: the TUI's event loop is blocked on user input most of the
+    time. If we run mesh jobs on the same loop, they can only execute during the
+    brief moments prompt_toolkit yields control — not enough for a full agent turn.
+
+    By running in a separate thread, mesh jobs execute independently. Results are
+    written to fleet_reports.jsonl and picked up on the next user turn, or printed
+    to the terminal via the notification callback.
+    """
+    if self._bg_thread is not None and self._bg_thread.is_alive():
+      return  # Already running
+
+    import threading
+
+    def _run_bg_loop():
+      """Background thread entry: create a new event loop and run the scheduler."""
+      self._bg_loop = asyncio.new_event_loop()
+      asyncio.set_event_loop(self._bg_loop)
+      try:
+        self._bg_loop.run_until_complete(self._bg_main())
+      except Exception:
+        pass
+      finally:
+        try:
+          self._bg_loop.close()
+        except Exception:
+          pass
+
+    self._bg_thread = threading.Thread(target=_run_bg_loop, daemon=True, name="gemcode-mesh")
+    self._bg_thread.start()
+
+  async def _bg_main(self) -> None:
+    """Main coroutine for the background event loop."""
+    self._stop = asyncio.Event()  # Create in the correct loop
+
+    # Start all sub-systems in this loop
+    self._scheduler_task = asyncio.create_task(self._scheduler_loop())
+
     if self._trigger_engine is not None:
       self._trigger_engine.start()
-    # Start habit scheduler (cron/interval recurring tasks)
     if self._habit_scheduler is not None:
       self._habit_scheduler.start()
 
+    # Wait until stopped
+    await self._stop.wait()
+
   def stop(self) -> None:
     """Stop the scheduler and trigger engine."""
-    self._stop.set()
+    if self._stop is not None:
+      self._stop.set()
     if self._scheduler_task and not self._scheduler_task.done():
       self._scheduler_task.cancel()
     if self._trigger_engine is not None:
       self._trigger_engine.stop()
     if self._habit_scheduler is not None:
       self._habit_scheduler.stop()
+    # Signal the background loop to exit
+    if self._bg_loop is not None:
+      try:
+        self._bg_loop.call_soon_threadsafe(self._bg_loop.stop)
+      except Exception:
+        pass
 
   def enqueue(
     self,
@@ -141,7 +189,7 @@ class AgentMesh:
     member_name: str = "",
     meta: dict[str, Any] | None = None,
   ) -> str:
-    """Enqueue a job and return its job_id."""
+    """Enqueue a job and return its job_id. Thread-safe."""
     job_id = f"mesh_{uuid.uuid4().hex[:10]}"
     self._seq += 1
     job = AgentJob(
@@ -163,13 +211,9 @@ class AgentMesh:
       payload={"job_id": job_id, "member": member_name, "priority": priority},
     ))
 
-    # Auto-start scheduler if not running
-    try:
-      loop = asyncio.get_running_loop()
-      if self._scheduler_task is None or self._scheduler_task.done():
-        self._scheduler_task = loop.create_task(self._scheduler_loop())
-    except RuntimeError:
-      pass
+    # Auto-start the background thread if not running
+    if self._bg_thread is None or not self._bg_thread.is_alive():
+      self.start()
 
     return job_id
 
@@ -267,7 +311,7 @@ class AgentMesh:
 
   async def _scheduler_loop(self) -> None:
     """Continuously dequeue and run jobs."""
-    while not self._stop.is_set():
+    while self._stop is None or not self._stop.is_set():
       try:
         await self._sem.acquire()
         try:
@@ -590,11 +634,47 @@ class AgentMesh:
       )
       return {"ok": True, "job_id": job_id}
 
+    async def agent_dm(to: str, message: str) -> dict:
+      """Send a direct message to another agent via the event bus."""
+      from_name = job.member_name or 'anonymous'
+      await mesh._bus.publish(BusMessage(
+        topic='agent.dm', from_addr=from_name, to_addr=to,
+        payload={'from': from_name, 'to': to, 'message': message},
+      ))
+      try:
+        from gemcode.fleet_reports import append_fleet_report
+        fleet_root = resolve_fleet_root(mesh.cfg.project_root)
+        append_fleet_report(fleet_root, topic='agent.dm', payload={
+          'from': from_name, 'to': to, 'message': message[:4000],
+        })
+      except Exception:
+        pass
+      return {'ok': True, 'sent_to': to}
+
+    async def agent_broadcast(message: str) -> dict:
+      """Broadcast a message to all agents and the manager."""
+      from_name = job.member_name or 'anonymous'
+      await mesh._bus.publish(BusMessage(
+        topic='agent.broadcast', from_addr=from_name, to_addr='',
+        payload={'from': from_name, 'message': message},
+      ))
+      try:
+        from gemcode.fleet_reports import append_fleet_report
+        fleet_root = resolve_fleet_root(mesh.cfg.project_root)
+        append_fleet_report(fleet_root, topic='agent.broadcast', payload={
+          'from': from_name, 'message': message[:4000],
+        })
+      except Exception:
+        pass
+      return {'ok': True, 'broadcast_from': from_name}
+
     mesh_delegate.__name__ = "mesh_delegate"
     mesh_report.__name__ = "mesh_report"
     mesh_enqueue.__name__ = "mesh_enqueue"
+    agent_dm.__name__ = "agent_dm"
+    agent_broadcast.__name__ = "agent_broadcast"
 
-    return [mesh_delegate, mesh_report, mesh_enqueue]
+    return [mesh_delegate, mesh_report, mesh_enqueue, agent_dm, agent_broadcast]
 
   # ── Status / Introspection ──────────────────────────────────────────────
 

{gemcode-0.4.6 → gemcode-0.4.9}/src/gemcode/fleet_reports.py

@@ -273,6 +273,17 @@ def _format_record(rec: dict[str, Any]) -> str:
     elif isinstance(res, str) and res.strip():
       lines.append(f"  result: {res[:8000]}")
 
+  elif topic == "agent.dm":
+    from_name = str(payload.get("from") or "")
+    to_name = str(payload.get("to") or "")
+    msg = str(payload.get("message") or "").strip()
+    lines.append(f"[agent.dm] {from_name} → {to_name}: {msg[:4000]}")
+
+  elif topic == "agent.broadcast":
+    from_name = str(payload.get("from") or "")
+    msg = str(payload.get("message") or "").strip()
+    lines.append(f"[agent.broadcast] {from_name}: {msg[:4000]}")
+
   return "\n".join(lines)
 
 

{gemcode-0.4.6 → gemcode-0.4.9}/src/gemcode/invoke.py

@@ -111,10 +111,7 @@ async def run_turn(
     try:
       from gemcode.agent_mesh import ensure_mesh
       mesh = ensure_mesh(cfg)
-      try:
-        mesh.start()
-      except Exception:
-        pass
+      mesh.start()  # Starts background thread if not already running
     except Exception:
       pass
 

{gemcode-0.4.6 → gemcode-0.4.9}/src/gemcode/tools/org_tools.py

@@ -152,34 +152,7 @@ def make_org_tools(cfg: GemCodeConfig) -> list:
       pass
 
     # ── Also try IPC if daemon is running (bonus, not required) ───────────
-    if not _bus_enabled():
-      return
-
-    from gemcode.kaira_ipc import fleet_manager_ipc_path
-
-    sock = str(fleet_manager_ipc_path(fleet_root))
-    try:
-      if not Path(sock).exists():
-        return  # No daemon, but that's fine — bus + fleet reports already handled it
-    except Exception:
-      return
-
-    try:
-      from gemcode.kaira_client import KairaIpcClient
-
-      c = await KairaIpcClient.connect(socket_path=str(sock))
-      try:
-        for to_addr in chain:
-          await c.publish(
-            topic="org.report",
-            to=str(to_addr or "manager"),
-            from_addr=from_addr,
-            payload=payload,
-          )
-      finally:
-        await c.close()
-    except Exception:
-      pass
+    # Removed: Kaira IPC is no longer needed. The bus + fleet reports handle everything.
 
   def org_list() -> dict:
     """List available org members (workers)."""
@@ -219,7 +192,7 @@ def make_org_tools(cfg: GemCodeConfig) -> list:
     return {"ok": True, "tree": org_tree(root)}
 
   async def org_delegate(member: str, task: str, context: str = "") -> dict:
-    """Delegate a task to an org member (Kaira worker or subagent)."""
+    """Delegate a task to an org member. Uses the mesh — no daemon required."""
     m = find_member(root, member)
     if m is None:
       return {"ok": False, "error": f"unknown member: {member}"}
@@ -229,109 +202,40 @@ def make_org_tools(cfg: GemCodeConfig) -> list:
     if not task:
       return {"ok": False, "error": "missing task"}
 
-    # ── Strategy 1: In-process Agent Mesh (always available) ──────────────
-    # The mesh runs real ADK agents in-process with their own sessions.
-    # This is the PRIMARY path — no daemon required.
+    # Primary path: Agent Mesh (always available, runs in background thread)
     mesh = _get_mesh(cfg)
     if mesh is not None:
       try:
-        # For kaira_workers, run async (non-blocking) by default
-        # For subagents, run sync (blocking) to return result immediately
         wait = (m.kind != "kaira_worker")
         result = await mesh.delegate_to_member(
-          member=m,
-          task=task,
-          context=ctx,
-          priority=0,
-          wait=wait,
+          member=m, task=task, context=ctx, priority=0, wait=wait,
         )
         if result.get("ok"):
           return {"ok": True, "delegated_to": m.to_dict(), **result}
-        # If mesh delegation failed, fall through to other strategies
       except Exception:
         pass
 
-    # ── Strategy 2: Kaira Daemon IPC (if running) ─────────────────────────
-    if m.kind == "kaira_worker":
-      try:
-        from gemcode.kaira_client import KairaIpcClient
-        fleet_root = resolve_fleet_root(getattr(cfg, "project_root", Path.cwd()))
-        from gemcode.kaira_ipc import fleet_manager_ipc_path
-
-        sock_s = str(fleet_manager_ipc_path(fleet_root))
-        if Path(sock_s).exists():
-          client = await KairaIpcClient.connect(socket_path=sock_s)
-          try:
-            session_id = str(getattr(cfg, "_active_session_id", "") or "")
-            notify_chain = _ancestor_addresses_for(m)
-            header = (
-              f"You are {m.name} ({m.title}).\n"
-              f"Role description: {m.description or '(none)'}\n\n"
-              "Do the assigned task. Keep outputs concise and actionable.\n"
-            )
-            prompt = header + "\nTask:\n" + task
-            if ctx:
-              prompt += "\n\nContext:\n" + ctx
-            meta = {
-              "org": {
-                "member": (m.to_dict() if hasattr(m, "to_dict") else {}),
-                "capabilities": {
-                  "kind": getattr(m, "kind", ""),
-                  "address": getattr(m, "address", "") or getattr(m, "name", ""),
-                  "workspace_rel": getattr(m, "workspace_rel", "") or "",
-                  "reports_to": getattr(m, "reports_to", "") or "",
-                },
-                "task": task,
-                "context": ctx,
-                "notify_chain": notify_chain,
-              }
-            }
-            res = await client.request(
-              action="enqueue",
-              prompt=prompt,
-              priority=0,
-              session_id=session_id,
-              meta=meta,
-            )
-            if res.get("ok"):
-              job_id = str(res.get("job_id") or "")
-              await _publish_org_report(
-                m=m, status="delegated", task=task, context=ctx, job_id=job_id,
-                result={"kind": "kaira_worker", "job_id": job_id},
-              )
-              return {"ok": True, "delegated_to": m.to_dict(), "job_id": job_id}
-          finally:
-            await client.close()
-      except Exception:
-        pass
-
-    # ── Strategy 3: In-process subtask fallback ───────────────────────────
-    header = (
-      f"You are {m.name} ({m.title}).\n"
-      f"Role description: {m.description or '(none)'}\n\n"
-      "Before acting, load and follow your role skill if available.\n"
-      f"- If a GemSkill exists: call load_skill(\"{m.skill_name or 'member-' + m.name.lower()}\")\n\n"
-      "Do the assigned task. Keep outputs concise and actionable.\n"
-    )
-    prompt = header + "\nTask:\n" + task
-    if ctx:
-      prompt += "\n\nContext:\n" + ctx
-
+    # Fallback: in-process subtask (blocking but guaranteed to work)
     try:
       from gemcode.tools.subtask import make_run_subtask_tool
 
+      header = (
+        f"You are {m.name} ({m.title}).\n"
+        f"Role: {m.description or '(none)'}\n\n"
+        "Do the assigned task. Keep outputs concise and actionable.\n"
+      )
+      prompt = header + "\nTask:\n" + task
+      if ctx:
+        prompt += "\n\nContext:\n" + ctx
+
       run_subtask = make_run_subtask_tool(cfg)
       out = await run_subtask(prompt, "")
       result = out.get("result") if isinstance(out, dict) else out
-      await _publish_org_report(
-        m=m, status="finished", task=task, context=ctx, result=result,
-      )
+      await _publish_org_report(m=m, status="finished", task=task, context=ctx, result=result)
       return {"ok": True, "delegated_to": m.to_dict(), "result": result}
     except Exception as e:
-      await _publish_org_report(
-        m=m, status="failed", task=task, context=ctx,
-        error=f"all_strategies_failed: {type(e).__name__}: {e}",
-      )
+      await _publish_org_report(m=m, status="failed", task=task, context=ctx,
+                                error=f"delegation_failed: {type(e).__name__}: {e}")
       return {"ok": False, "error": f"delegation_failed: {type(e).__name__}: {e}"}
 
   async def org_spawn(

{gemcode-0.4.6 → gemcode-0.4.9/src/gemcode.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gemcode
-Version: 0.4.6
+Version: 0.4.9
 Summary: Local-first coding agent on Google Gemini + ADK
 Author: GemCode Contributors
 License:                                  Apache License