gemcode 0.3.105__tar.gz → 0.3.106__tar.gz

{gemcode-0.3.105/src/gemcode.egg-info → gemcode-0.3.106}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gemcode
-Version: 0.3.105
+Version: 0.3.106
 Summary: Local-first coding agent on Google Gemini + ADK
 Author: GemCode Contributors
 License:                                  Apache License
@@ -349,6 +349,33 @@ gemcode -C . --attach ./report.pdf "Summarize this"
 gemcode kaira -C .
 ```
 
+### Orchestration (Kaira + org delegation)
+
+Docs:
+- `../docs/orchestration.md`
+
+In one terminal:
+
+```bash
+gemcode kaira -C .
+```
+
+In another terminal:
+
+```bash
+gemcode -C .
+```
+
+Then in the REPL/TUI:
+
+```text
+/org tree
+/org hire verifier "QA / test planner" subagent gemcode "Find risks, propose tests, review plans."
+/org assign verifier "Review the plan and propose tests"
+/kaira jobs
+/kaira follow <job_id_prefix>
+```
+
 ### Start the IDE bridge
 ```bash
 gemcode ide --stdio

{gemcode-0.3.105 → gemcode-0.3.106}/README.md

@@ -157,6 +157,33 @@ gemcode -C . --attach ./report.pdf "Summarize this"
 gemcode kaira -C .
 ```
 
+### Orchestration (Kaira + org delegation)
+
+Docs:
+- `../docs/orchestration.md`
+
+In one terminal:
+
+```bash
+gemcode kaira -C .
+```
+
+In another terminal:
+
+```bash
+gemcode -C .
+```
+
+Then in the REPL/TUI:
+
+```text
+/org tree
+/org hire verifier "QA / test planner" subagent gemcode "Find risks, propose tests, review plans."
+/org assign verifier "Review the plan and propose tests"
+/kaira jobs
+/kaira follow <job_id_prefix>
+```
+
 ### Start the IDE bridge
 ```bash
 gemcode ide --stdio

{gemcode-0.3.105 → gemcode-0.3.106}/pyproject.toml

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

{gemcode-0.3.105 → gemcode-0.3.106}/src/gemcode/agent.py

@@ -733,6 +733,11 @@ If you need more tool usage examples, set `GEMCODE_VERBOSE_INSTRUCTIONS=1`.
   - Always give the sub-agent enough context to operate independently.
   - End your task prompt with "Summarise your findings clearly." so the result is useful.
 
+- **`spawn_subtasks`** — spawn multiple isolated sub-agents in parallel (preferred fan-out helper).
+  - Use this instead of manually issuing many `run_subtask` calls.
+  - Provide 3–6 focused tasks; keep each subtask self-contained.
+  - Then synthesise the combined findings into a single plan/answer.
+
 ## Multi-step task execution
 One user message = many model↔tool rounds (up to 256 LLM calls by default). This is intentional — you are expected to do complete tasks autonomously.
 

{gemcode-0.3.105 → gemcode-0.3.106}/src/gemcode/invoke.py

@@ -25,6 +25,82 @@ _TRANSIENT_RETRY_DELAYS = [2.0, 5.0, 12.0]
 
 _HITL_PROMPT_LOCK = Lock()
 
+async def _maybe_enqueue_kaira_autopilot(*, cfg: "GemCodeConfig", session_id: str) -> None:
+  """If Kaira IPC is available, enqueue background quality checks after edits."""
+  try:
+    enabled = os.environ.get("GEMCODE_KAIRA_AUTOPILOT", "1").strip().lower() in (
+      "1",
+      "true",
+      "yes",
+      "on",
+    )
+    if not enabled:
+      return
+    # Only run when files were touched (edit tools track this).
+    touched = getattr(cfg, "_touched_paths", None)
+    if not touched:
+      return
+    # Avoid enqueuing repeatedly within the same session unless touched paths change.
+    last_fp = str(getattr(cfg, "_kaira_autopilot_fp", "") or "")
+    fp = ",".join(sorted(str(x) for x in touched))[:4000]
+    if fp and fp == last_fp:
+      return
+    object.__setattr__(cfg, "_kaira_autopilot_fp", fp)
+
+    sock = os.environ.get("GEMCODE_KAIRA_SOCKET") or str(cfg.project_root / ".gemcode" / "ipc.sock")
+    if not Path(sock).exists():
+      return
+    # Heuristic: suggest likely checks, but let the agent choose based on repo.
+    prompt = (
+      "You are Kaira (background worker). Run the most relevant automated quality checks for this repo "
+      "based on its files, and report succinctly.\n\n"
+      "Rules:\n"
+      "- Prefer fast checks first (lint/typecheck/unit tests).\n"
+      "- If Python: try `pytest -q` (or detect other common runners).\n"
+      "- If Node: try `npm test` / `npm run lint` when package.json exists.\n"
+      "- If there are failures, include the smallest actionable summary and exact command to reproduce.\n"
+      "- If everything passes, say PASS and list what you ran.\n"
+      "- Return a final STRICT JSON report with keys: status, summary, evidence, recommended_next_actions.\n\n"
+      f"Touched files (recent): {', '.join(sorted(list(touched))[:30])}"
+    )
+
+    # Org-aware routing: delegate to the kaira org member if present so the
+    # manager/worker hierarchy stays consistent.
+    try:
+      auto_org = os.environ.get("GEMCODE_AUTO_SLASH_ORG", "1").strip().lower() in (
+        "1",
+        "true",
+        "yes",
+        "on",
+      )
+      if auto_org:
+        from gemcode.org import find_member
+        m = find_member(cfg.project_root, "kaira")
+        if m is not None and m.kind == "kaira_worker":
+          from gemcode.tools.org_tools import make_org_tools
+          tools = make_org_tools(cfg)
+          org_delegate = None
+          for t in tools:
+            if getattr(t, "__name__", "") == "org_delegate":
+              org_delegate = t
+              break
+          if org_delegate is not None:
+            await org_delegate("kaira", prompt, "")  # type: ignore[misc]
+            return
+    except Exception:
+      pass
+
+    from gemcode.kaira_client import KairaIpcClient
+
+    client = await KairaIpcClient.connect(socket_path=sock)
+    try:
+      # Low priority by default; user can override with env in future.
+      await client.request(action="enqueue", prompt=prompt, priority=-1, session_id=session_id)
+    finally:
+      await client.close()
+  except Exception:
+    return
+
 
 def _events_to_text(events: list[Any]) -> str:
   """Best-effort extraction of assistant text from ADK events."""
@@ -102,6 +178,56 @@ async def run_turn(
       object.__setattr__(cfg, "_risk_score", risk)
     except Exception:
       pass
+
+    # Deterministic manager dispatcher: pre-delegate certain work to org members
+    # and inject their results into the prompt before the main agent runs.
+    try:
+      auto_mgr = os.environ.get("GEMCODE_MANAGER_DISPATCH", "1").strip().lower() in (
+        "1","true","yes","on"
+      )
+      if auto_mgr:
+        import re
+        p0 = (prompt or "")[:12_000]
+        # Only do this for broad/complex prompts.
+        score = float(getattr(cfg, "_parallelism_score", 0.0) or 0.0)
+        if score >= float(os.environ.get("GEMCODE_MANAGER_DISPATCH_THRESHOLD", "0.7")):
+          from gemcode.tools.org_tools import make_org_tools
+          tools = make_org_tools(cfg)
+          org_delegate = None
+          for t in tools:
+            if getattr(t, "__name__", "") == "org_delegate":
+              org_delegate = t
+              break
+          # Ask verifier for a quick risk check / plan critique (fast, in-process).
+          if org_delegate is not None and re.search(r"\\b(fix|refactor|rewrite|change|implement)\\b", p0, re.I):
+            v = await org_delegate("verifier", "Review the requested task and list key risks + verification steps.", p0)  # type: ignore[misc]
+            if isinstance(v, dict) and v.get("ok") and v.get("result"):
+              object.__setattr__(cfg, "_manager_verifier_context", str(v.get("result"))[:4000])
+    except Exception:
+      pass
+    # Parallelism score: heuristic signal for automatic subtask fan-out.
+    try:
+      import re
+      p2 = (prompt or "")[:20_000]
+      par = 0.0
+      if len(p2) > 800:
+        par += 0.15
+      if len(p2) > 2400:
+        par += 0.2
+      if re.search(r"\b(analy[sz]e|audit|map|inventory|scan|survey)\b", p2, re.I):
+        par += 0.2
+      if re.search(r"\b(refactor|migrate|rewrite|redesign|architecture)\b", p2, re.I):
+        par += 0.2
+      if re.search(r"\b(across|entire|whole|end-to-end|e2e|multiple modules|many files)\b", p2, re.I):
+        par += 0.2
+      if p2.count("/") >= 8 or p2.count(".py") + p2.count(".ts") + p2.count(".tsx") >= 5:
+        par += 0.15
+      if attachment_paths:
+        par += 0.08
+      par = max(0.0, min(1.0, float(par)))
+      object.__setattr__(cfg, "_parallelism_score", par)
+    except Exception:
+      pass
   run_config = (
     RunConfig(max_llm_calls=max_llm_calls) if max_llm_calls is not None else None
   )
@@ -222,9 +348,48 @@ async def run_turn(
         for w in attach_warn:
           print(f"[gemcode] {w}", file=sys.stderr)
       else:
-        current_message = types.Content(
-            role="user", parts=[types.Part(text=prompt)]
-        )
+        effective_prompt = prompt
+        # Auto fan-out: when prompt looks broad, guide model to spawn parallel
+        # isolated subtasks first (bounded) and then synthesise.
+        try:
+          auto_on = os.environ.get("GEMCODE_AUTO_FANOUT", "1").strip().lower() in (
+            "1",
+            "true",
+            "yes",
+            "on",
+          )
+          threshold = float(os.environ.get("GEMCODE_AUTO_FANOUT_THRESHOLD", "0.6"))
+          if auto_on and cfg is not None:
+            score = float(getattr(cfg, "_parallelism_score", 0.0) or 0.0)
+            already = bool(getattr(cfg, "_auto_fanout_applied", False))
+            if (not already) and score >= threshold:
+              object.__setattr__(cfg, "_auto_fanout_applied", True)
+              effective_prompt = (
+                "Before you answer, do a quick parallel exploration pass:\n"
+                "- Decompose this into 3–6 independent investigation subtasks.\n"
+                "- Call `spawn_subtasks(tasks=[...], max_concurrency=4)` to run them in parallel.\n"
+                "- If an org member is appropriate, prefer delegating with `org_delegate` / `org_spawn`.\n"
+                "- Synthesize the results into a single plan/answer, then proceed.\n\n"
+                + (prompt or "")
+              )
+        except Exception:
+          pass
+
+        # Inject dispatcher context (e.g., verifier critique) if available.
+        try:
+          if cfg is not None:
+            ctx = str(getattr(cfg, "_manager_verifier_context", "") or "").strip()
+            if ctx:
+              effective_prompt = (
+                "Manager pre-delegation result (verifier):\n"
+                + ctx
+                + "\n\nUser request:\n"
+                + (effective_prompt or "")
+              )
+        except Exception:
+          pass
+
+        current_message = types.Content(role="user", parts=[types.Part(text=effective_prompt)])
 
       async def _await_runner_events(
         *, next_message: types.Content, do_reset: bool
@@ -347,6 +512,12 @@ async def run_turn(
           )
           continue
 
+      # Background autopilot: if we touched files, enqueue Kaira checks (best-effort).
+      if cfg is not None:
+        try:
+          await _maybe_enqueue_kaira_autopilot(cfg=cfg, session_id=session_id)
+        except Exception:
+          pass
       return collected
   finally:
     if cfg is not None and orig_ctx_chars is not None:

gemcode-0.3.106/src/gemcode/kaira_client.py

@@ -0,0 +1,51 @@
+from __future__ import annotations
+
+import asyncio
+import uuid
+from dataclasses import dataclass
+from typing import Any, AsyncIterator
+
+from gemcode.ide_protocol import IdeEmitter, make_response, parse_json_line
+
+
+@dataclass
+class KairaIpcClient:
+  reader: asyncio.StreamReader
+  writer: asyncio.StreamWriter
+  emitter: IdeEmitter
+
+  @classmethod
+  async def connect(cls, *, socket_path: str) -> "KairaIpcClient":
+    reader, writer = await asyncio.open_unix_connection(socket_path)
+    return cls(reader=reader, writer=writer, emitter=IdeEmitter(stream=writer))
+
+  async def close(self) -> None:
+    try:
+      self.writer.close()
+      await self.writer.wait_closed()
+    except Exception:
+      pass
+
+  async def request(self, *, action: str, **payload: Any) -> dict[str, Any]:
+    req_id = f"req_{uuid.uuid4().hex[:12]}"
+    msg = {"type": "request", "id": req_id, "action": action}
+    msg.update(payload)
+    self.emitter.send(msg)
+    # Wait for matching response.
+    while True:
+      line = await self.reader.readline()
+      if not line:
+        return make_response(id=req_id, ok=False, error="ipc_eof")
+      obj = parse_json_line(line.decode("utf-8", errors="replace").strip())
+      if obj.get("type") == "response" and str(obj.get("id") or "") == req_id:
+        return obj
+      # Other messages (events) are ignored here; caller should use iter_messages.
+
+  async def iter_messages(self) -> AsyncIterator[dict[str, Any]]:
+    while True:
+      line = await self.reader.readline()
+      if not line:
+        return
+      obj = parse_json_line(line.decode("utf-8", errors="replace").strip())
+      yield obj
+