gemcode 0.4.14__tar.gz → 0.4.16__tar.gz

{gemcode-0.4.14/src/gemcode.egg-info → gemcode-0.4.16}/PKG-INFO

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

{gemcode-0.4.14 → gemcode-0.4.16}/pyproject.toml

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

{gemcode-0.4.14 → gemcode-0.4.16}/src/gemcode/agent_mesh.py

@@ -16,8 +16,10 @@ Slash **`/agent assign`** / **`trigger`** publish `org.assign` over IPC when the
 from __future__ import annotations
 
 import asyncio
+import concurrent.futures
 import copy
 import os
+import threading
 import time
 import uuid
 from dataclasses import dataclass, field
@@ -42,6 +44,8 @@ class AgentJob:
   result: str = ""
   error: str = ""
   created_ms: int = field(default_factory=lambda: int(time.time() * 1000))
+  # When set, completed with this AgentJob from the mesh thread (cross-thread wait).
+  completion_future: concurrent.futures.Future | None = None
 
 
 def _apply_mesh_worker_unattended_policy(cfg: GemCodeConfig) -> None:
@@ -80,6 +84,11 @@ class AgentMesh:
     self._sem = asyncio.Semaphore(self.max_concurrency)
     self._running: dict[str, asyncio.Task] = {}
     self._completed: list[AgentJob] = []
+    self._completed_lock = threading.Lock()
+    self._enqueue_lock = threading.Lock()
+    self._bg_thread_ident: int | None = None
+    # >0 while executing a mesh job on the background loop (nested delegate avoids deadlock).
+    self._mesh_job_depth: int = 0
     self._scheduler_task: asyncio.Task | None = None
     self._stop: asyncio.Event | None = None  # Created in background loop
     self._bg_thread: "threading.Thread | None" = None
@@ -172,6 +181,7 @@ class AgentMesh:
       """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)
+      self._bg_thread_ident = threading.current_thread().ident
       try:
         self._bg_loop.run_until_complete(self._bg_main())
       except Exception:
@@ -190,7 +200,9 @@ class AgentMesh:
     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())
+    # Tests can set PYTEST_GEMCODE_MESH_SCHEDULER=0 to inspect the queue without workers consuming it.
+    if os.environ.get("PYTEST_GEMCODE_MESH_SCHEDULER", "").strip() != "0":
+      self._scheduler_task = asyncio.create_task(self._scheduler_loop())
 
     if self._trigger_engine is not None:
       self._trigger_engine.start()
@@ -217,6 +229,40 @@ class AgentMesh:
       except Exception:
         pass
 
+  def _is_on_mesh_thread(self) -> bool:
+    ident = threading.current_thread().ident
+    return self._bg_thread_ident is not None and ident == self._bg_thread_ident
+
+  def _wait_bg_loop_ready(self, timeout_s: float = 5.0) -> bool:
+    """Wait until the background thread has assigned ``_bg_loop``."""
+    deadline = time.time() + timeout_s
+    while time.time() < deadline:
+      if self._bg_loop is not None:
+        return True
+      if self._bg_thread is not None and not self._bg_thread.is_alive():
+        return False
+      time.sleep(0.001)
+    return self._bg_loop is not None
+
+  def wait_for_pending_enqueues(self, timeout: float = 5.0) -> None:
+    """
+    Block until callbacks scheduled with ``call_soon_threadsafe`` (for enqueues
+    from other threads) have run on the mesh loop. Useful in tests.
+    """
+    if self._bg_loop is None:
+      return
+    fut: concurrent.futures.Future[None] = concurrent.futures.Future()
+
+    def _poke() -> None:
+      if not fut.done():
+        try:
+          fut.set_result(None)
+        except Exception:
+          pass
+
+    self._bg_loop.call_soon_threadsafe(_poke)
+    fut.result(timeout=timeout)
+
   def enqueue(
     self,
     *,
@@ -225,10 +271,13 @@ class AgentMesh:
     session_id: str = "",
     member_name: str = "",
     meta: dict[str, Any] | None = None,
+    completion_future: concurrent.futures.Future | None = None,
   ) -> str:
-    """Enqueue a job and return its job_id. Thread-safe."""
+    """Enqueue a job and return its job_id. Safe to call from any thread."""
     job_id = f"mesh_{uuid.uuid4().hex[:10]}"
-    self._seq += 1
+    with self._enqueue_lock:
+      self._seq += 1
+      seq = self._seq
     job = AgentJob(
       job_id=job_id,
       prompt=prompt,
@@ -236,22 +285,45 @@ class AgentMesh:
       session_id=session_id or str(uuid.uuid4()),
       member_name=member_name,
       meta=meta or {},
+      completion_future=completion_future,
     )
-    # Higher priority = runs first (negate for min-heap)
-    self._queue.put_nowait((-priority, self._seq, job))
+    item = (-priority, seq, job)
 
-    # Publish queued event
-    self._bus.publish_sync(BusMessage(
-      topic="job.queued",
-      from_addr="mesh",
-      to_addr="manager",
-      payload={"job_id": job_id, "member": member_name, "priority": priority},
-    ))
+    def do_put() -> None:
+      try:
+        self._queue.put_nowait(item)
+      except Exception as e:
+        fut = job.completion_future
+        if fut is not None and not fut.done():
+          try:
+            fut.set_exception(e)
+          except Exception:
+            pass
+        return
+      self._bus.publish_sync(BusMessage(
+        topic="job.queued",
+        from_addr="mesh",
+        to_addr="manager",
+        payload={"job_id": job_id, "member": member_name, "priority": priority},
+      ))
 
-    # Auto-start the background thread if not running
     if self._bg_thread is None or not self._bg_thread.is_alive():
       self.start()
 
+    if not self._wait_bg_loop_ready():
+      fut = job.completion_future
+      if fut is not None and not fut.done():
+        try:
+          fut.set_exception(RuntimeError("mesh background loop failed to start"))
+        except Exception:
+          pass
+      return job_id
+
+    if self._is_on_mesh_thread():
+      do_put()
+    else:
+      self._bg_loop.call_soon_threadsafe(do_put)
+
     return job_id
 
   async def delegate_to_member(
@@ -303,39 +375,63 @@ class AgentMesh:
     if context:
       full_prompt += "\n\nContext:\n" + context
 
+    org_meta = {
+      "org": {
+        "member": m.to_dict() if hasattr(m, "to_dict") else {},
+        "task": task,
+        "context": context,
+      }
+    }
+
+    if not wait:
+      job_id = self.enqueue(
+        prompt=full_prompt,
+        priority=priority,
+        session_id="",
+        member_name=m.name,
+        meta=org_meta,
+      )
+      return {"ok": True, "job_id": job_id, "delegated_to": m.name, "async": True}
+
+    # Nested wait=True from inside a running mesh job would deadlock the scheduler
+    # (parent holds a concurrency slot while the child waits for another slot).
+    # Only use the inline path on the mesh thread: the manager runs on a different
+    # event loop; _mesh_job_depth can be >0 while a habit runs, but inline
+    # _run_job_inner must not run there (asyncio locks / ADK are mesh-loop-local).
+    if self._is_on_mesh_thread() and self._mesh_job_depth > 0:
+      job_id = f"mesh_{uuid.uuid4().hex[:10]}"
+      with self._enqueue_lock:
+        self._seq += 1
+      inline_job = AgentJob(
+        job_id=job_id,
+        prompt=full_prompt,
+        priority=priority,
+        session_id="",
+        member_name=m.name,
+        meta=org_meta,
+      )
+      await self._run_job_inner(inline_job)
+      if inline_job.status == "finished":
+        return {"ok": True, "job_id": job_id, "result": inline_job.result}
+      return {"ok": False, "job_id": job_id, "error": inline_job.error}
+
+    loop = asyncio.get_running_loop()
+    fut: concurrent.futures.Future[AgentJob] = concurrent.futures.Future()
     job_id = self.enqueue(
       prompt=full_prompt,
       priority=priority,
       session_id="",
       member_name=m.name,
-      meta={
-        "org": {
-          "member": m.to_dict() if hasattr(m, "to_dict") else {},
-          "task": task,
-          "context": context,
-        }
-      },
+      meta=org_meta,
+      completion_future=fut,
     )
-
-    if not wait:
-      return {"ok": True, "job_id": job_id, "delegated_to": m.name, "async": True}
-
-    # Wait for completion
-    result = await self._wait_for_job(job_id, timeout=300.0)
-    return result
-
-  async def _wait_for_job(self, job_id: str, timeout: float = 300.0) -> dict[str, Any]:
-    """Wait for a specific job to complete."""
-    deadline = time.time() + timeout
-    while time.time() < deadline:
-      for job in self._completed:
-        if job.job_id == job_id:
-          if job.status == "finished":
-            return {"ok": True, "job_id": job_id, "result": job.result}
-          else:
-            return {"ok": False, "job_id": job_id, "error": job.error}
-      await asyncio.sleep(0.1)
-    return {"ok": False, "job_id": job_id, "error": "timeout"}
+    try:
+      job = await asyncio.wait_for(asyncio.wrap_future(fut, loop=loop), timeout=300.0)
+    except asyncio.TimeoutError:
+      return {"ok": False, "job_id": job_id, "error": "timeout"}
+    if job.status == "finished":
+      return {"ok": True, "job_id": job_id, "result": job.result}
+    return {"ok": False, "job_id": job_id, "error": job.error}
 
   async def _handle_org_assign(self, msg: BusMessage) -> None:
     """Handle org.assign bus messages (A2A-style delegation)."""
@@ -373,6 +469,14 @@ class AgentMesh:
 
   async def _run_job(self, job: AgentJob) -> None:
     """Execute a single job using a fresh ADK Runner."""
+    self._mesh_job_depth += 1
+    try:
+      await self._run_job_inner(job)
+    finally:
+      self._mesh_job_depth -= 1
+
+  async def _run_job_inner(self, job: AgentJob) -> None:
+    """Full job lifecycle (shared by the scheduler and nested inline delegation)."""
     job.status = "running"
     start_ms = int(time.time() * 1000)
 
@@ -499,10 +603,17 @@ class AgentMesh:
         pass
 
     finally:
-      self._completed.append(job)
-      # Keep completed list bounded
-      if len(self._completed) > 200:
-        self._completed = self._completed[-100:]
+      cf = job.completion_future
+      if cf is not None and not cf.done():
+        try:
+          cf.set_result(job)
+        except Exception:
+          pass
+      with self._completed_lock:
+        self._completed.append(job)
+        # Keep completed list bounded
+        if len(self._completed) > 200:
+          self._completed = self._completed[-100:]
 
   async def _execute_agent_turn(self, job: AgentJob) -> str:
     """
@@ -740,15 +851,18 @@ class AgentMesh:
 
   def status(self) -> dict[str, Any]:
     """Get mesh status for debugging/display."""
+    with self._completed_lock:
+      recent = [
+        {"job_id": j.job_id, "member": j.member_name, "status": j.status}
+        for j in self._completed[-10:]
+      ]
+      n_completed = len(self._completed)
     return {
       "running_jobs": len(self._running),
       "queued_jobs": self._queue.qsize(),
-      "completed_jobs": len(self._completed),
+      "completed_jobs": n_completed,
       "max_concurrency": self.max_concurrency,
-      "recent_completed": [
-        {"job_id": j.job_id, "member": j.member_name, "status": j.status}
-        for j in self._completed[-10:]
-      ],
+      "recent_completed": recent,
     }
 
 
@@ -757,12 +871,41 @@ class AgentMesh:
 _global_mesh: AgentMesh | None = None
 
 
+def _sync_mesh_cfg_project_root(mesh: AgentMesh, cfg: GemCodeConfig) -> None:
+  """
+  Keep the singleton aligned with the active manager ``cfg.project_root``.
+
+  If the mesh was created from a different cwd than a later ``ensure_mesh`` /
+  ``get_mesh`` (e.g. ``-C``), habits/triggers/fleet would otherwise read the
+  wrong ``.gemcode/`` tree while the UI used another.
+  """
+  try:
+    cur = Path(mesh.cfg.project_root).resolve()
+    nxt = Path(cfg.project_root).resolve()
+    if cur == nxt:
+      return
+    mesh.cfg.project_root = cfg.project_root
+    if mesh._trigger_engine is not None:
+      mesh._trigger_engine.cfg = mesh.cfg
+      mesh._trigger_engine.reload()
+    if mesh._habit_scheduler is not None:
+      mesh._habit_scheduler.cfg = mesh.cfg
+    if mesh._learner is not None:
+      mesh._learner.cfg = mesh.cfg
+    if mesh._self_healing is not None:
+      mesh._self_healing.cfg = mesh.cfg
+  except Exception:
+    pass
+
+
 def get_mesh(cfg: GemCodeConfig | None = None) -> AgentMesh | None:
   """Get or create the global agent mesh."""
   global _global_mesh
   if _global_mesh is None and cfg is not None:
     concurrency = int(os.environ.get("GEMCODE_MESH_CONCURRENCY", "3"))
     _global_mesh = AgentMesh(cfg, max_concurrency=concurrency)
+  elif _global_mesh is not None and cfg is not None:
+    _sync_mesh_cfg_project_root(_global_mesh, cfg)
   return _global_mesh
 
 
@@ -772,6 +915,8 @@ def ensure_mesh(cfg: GemCodeConfig) -> AgentMesh:
   if _global_mesh is None:
     concurrency = int(os.environ.get("GEMCODE_MESH_CONCURRENCY", "3"))
     _global_mesh = AgentMesh(cfg, max_concurrency=concurrency)
+  else:
+    _sync_mesh_cfg_project_root(_global_mesh, cfg)
   return _global_mesh
 
 

{gemcode-0.4.14 → gemcode-0.4.16/src/gemcode.egg-info}/PKG-INFO

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

{gemcode-0.4.14 → gemcode-0.4.16}/tests/test_agent_mesh.py

@@ -4,6 +4,8 @@ from __future__ import annotations
 
 import asyncio
 import os
+import threading
+import time
 from pathlib import Path
 
 import pytest
@@ -63,22 +65,52 @@ def test_mesh_singleton(tmp_path: Path) -> None:
 
 
 def test_mesh_enqueue(tmp_path: Path) -> None:
-  cfg = GemCodeConfig(project_root=tmp_path)
-  mesh = AgentMesh(cfg, max_concurrency=2)
-  job_id = mesh.enqueue(prompt="test task", priority=5, member_name="worker")
-  assert job_id.startswith("mesh_")
-  assert mesh._queue.qsize() == 1
+  old_s = os.environ.get("PYTEST_GEMCODE_MESH_SCHEDULER")
+  old_h = os.environ.get("GEMCODE_AGENT_HABITS")
+  os.environ["PYTEST_GEMCODE_MESH_SCHEDULER"] = "0"
+  os.environ["GEMCODE_AGENT_HABITS"] = "0"
+  try:
+    cfg = GemCodeConfig(project_root=tmp_path)
+    mesh = AgentMesh(cfg, max_concurrency=2)
+    job_id = mesh.enqueue(prompt="test task", priority=5, member_name="worker")
+    assert job_id.startswith("mesh_")
+    mesh.wait_for_pending_enqueues()
+    assert mesh._queue.qsize() == 1
+  finally:
+    if old_s is None:
+      os.environ.pop("PYTEST_GEMCODE_MESH_SCHEDULER", None)
+    else:
+      os.environ["PYTEST_GEMCODE_MESH_SCHEDULER"] = old_s
+    if old_h is None:
+      os.environ.pop("GEMCODE_AGENT_HABITS", None)
+    else:
+      os.environ["GEMCODE_AGENT_HABITS"] = old_h
 
 
 def test_mesh_status(tmp_path: Path) -> None:
-  cfg = GemCodeConfig(project_root=tmp_path)
-  mesh = AgentMesh(cfg, max_concurrency=2)
-  mesh.enqueue(prompt="task1", priority=1, member_name="a")
-  mesh.enqueue(prompt="task2", priority=2, member_name="b")
-  status = mesh.status()
-  assert status["queued_jobs"] == 2
-  assert status["running_jobs"] == 0
-  assert status["max_concurrency"] == 2
+  old_s = os.environ.get("PYTEST_GEMCODE_MESH_SCHEDULER")
+  old_h = os.environ.get("GEMCODE_AGENT_HABITS")
+  os.environ["PYTEST_GEMCODE_MESH_SCHEDULER"] = "0"
+  os.environ["GEMCODE_AGENT_HABITS"] = "0"
+  try:
+    cfg = GemCodeConfig(project_root=tmp_path)
+    mesh = AgentMesh(cfg, max_concurrency=2)
+    mesh.enqueue(prompt="task1", priority=1, member_name="a")
+    mesh.enqueue(prompt="task2", priority=2, member_name="b")
+    mesh.wait_for_pending_enqueues()
+    status = mesh.status()
+    assert status["queued_jobs"] == 2
+    assert status["running_jobs"] == 0
+    assert status["max_concurrency"] == 2
+  finally:
+    if old_s is None:
+      os.environ.pop("PYTEST_GEMCODE_MESH_SCHEDULER", None)
+    else:
+      os.environ["PYTEST_GEMCODE_MESH_SCHEDULER"] = old_s
+    if old_h is None:
+      os.environ.pop("GEMCODE_AGENT_HABITS", None)
+    else:
+      os.environ["GEMCODE_AGENT_HABITS"] = old_h
 
 
 def test_mesh_bus_integration(tmp_path: Path) -> None:
@@ -88,17 +120,21 @@ def test_mesh_bus_integration(tmp_path: Path) -> None:
   bus = get_bus()
 
   received: list[BusMessage] = []
+  got = threading.Event()
+
+  async def capture(msg: BusMessage) -> None:
+    received.append(msg)
+    got.set()
 
   async def run():
-    sub = bus.subscribe(topic="job.queued")
+    bus.subscribe(topic="job.queued", callback=capture)
     mesh.enqueue(prompt="hello", priority=0, member_name="test")
-    # Give the sync publish a moment to schedule
-    await asyncio.sleep(0.1)
-    msg = await sub.get(timeout=1.0)
-    if msg:
-      received.append(msg)
+    mesh.wait_for_pending_enqueues()
 
   asyncio.run(run())
+  # Mesh loop processes publish asynchronously on a background thread.
+  assert got.wait(timeout=3.0), "timed out waiting for job.queued on bus"
+  time.sleep(0.01)
   assert len(received) == 1
   assert received[0].payload["member"] == "test"
 
@@ -139,19 +175,34 @@ def test_apply_mesh_worker_unattended_off_inherits_manager(tmp_path: Path) -> No
 
 def test_mesh_priority_ordering(tmp_path: Path) -> None:
   """Higher priority jobs should be dequeued first."""
-  cfg = GemCodeConfig(project_root=tmp_path)
-  mesh = AgentMesh(cfg, max_concurrency=1)
-
-  mesh.enqueue(prompt="low", priority=1, member_name="a")
-  mesh.enqueue(prompt="high", priority=10, member_name="b")
-  mesh.enqueue(prompt="mid", priority=5, member_name="c")
-
-  # Drain the queue manually to check ordering
-  items = []
-  while not mesh._queue.empty():
-    neg_pri, seq, job = mesh._queue.get_nowait()
-    items.append((job.prompt, job.priority))
-
-  assert items[0] == ("high", 10)
-  assert items[1] == ("mid", 5)
-  assert items[2] == ("low", 1)
+  old_s = os.environ.get("PYTEST_GEMCODE_MESH_SCHEDULER")
+  old_h = os.environ.get("GEMCODE_AGENT_HABITS")
+  os.environ["PYTEST_GEMCODE_MESH_SCHEDULER"] = "0"
+  os.environ["GEMCODE_AGENT_HABITS"] = "0"
+  try:
+    cfg = GemCodeConfig(project_root=tmp_path)
+    mesh = AgentMesh(cfg, max_concurrency=1)
+
+    mesh.enqueue(prompt="low", priority=1, member_name="a")
+    mesh.enqueue(prompt="high", priority=10, member_name="b")
+    mesh.enqueue(prompt="mid", priority=5, member_name="c")
+    mesh.wait_for_pending_enqueues()
+
+    # Drain the queue manually to check ordering
+    items = []
+    while not mesh._queue.empty():
+      neg_pri, seq, job = mesh._queue.get_nowait()
+      items.append((job.prompt, job.priority))
+
+    assert items[0] == ("high", 10)
+    assert items[1] == ("mid", 5)
+    assert items[2] == ("low", 1)
+  finally:
+    if old_s is None:
+      os.environ.pop("PYTEST_GEMCODE_MESH_SCHEDULER", None)
+    else:
+      os.environ["PYTEST_GEMCODE_MESH_SCHEDULER"] = old_s
+    if old_h is None:
+      os.environ.pop("GEMCODE_AGENT_HABITS", None)
+    else:
+      os.environ["GEMCODE_AGENT_HABITS"] = old_h