gemcode 0.3.109__tar.gz → 0.3.111__tar.gz

{gemcode-0.3.109/src/gemcode.egg-info → gemcode-0.3.111}/PKG-INFO

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

{gemcode-0.3.109 → gemcode-0.3.111}/pyproject.toml

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

gemcode-0.3.111/src/gemcode/automations.py

@@ -0,0 +1,198 @@
+from __future__ import annotations
+
+import json
+import time
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+
+@dataclass(frozen=True)
+class AutomationTrigger:
+  kind: str  # interval|cron|daily
+  every_seconds: int | None = None
+  cron: str | None = None
+  at_hhmm: str | None = None
+
+  def key(self) -> str:
+    if self.kind == "interval":
+      return f"interval:{self.every_seconds}"
+    if self.kind == "cron":
+      return f"cron:{self.cron}"
+    if self.kind == "daily":
+      return f"daily:{self.at_hhmm}"
+    return self.kind
+
+
+@dataclass(frozen=True)
+class Automation:
+  name: str
+  prompt: str
+  priority: int = 0
+  enabled: bool = True
+  session_id: str | None = None
+  triggers: tuple[AutomationTrigger, ...] = ()
+
+
+def automations_dir(project_root: Path) -> Path:
+  return project_root / ".gemcode" / "automations"
+
+
+def automations_state_path(project_root: Path) -> Path:
+  return automations_dir(project_root) / "state.json"
+
+
+def load_automations(project_root: Path) -> list[Automation]:
+  root = automations_dir(project_root)
+  if not root.is_dir():
+    return []
+  out: list[Automation] = []
+  for p in sorted(root.glob("*.json")):
+    try:
+      data = json.loads(p.read_text(encoding="utf-8"))
+    except Exception:
+      continue
+    try:
+      a = _parse_automation(data)
+    except Exception:
+      continue
+    out.append(a)
+  return out
+
+
+def _parse_automation(data: dict[str, Any]) -> Automation:
+  name = str(data.get("name") or "").strip()
+  prompt = str(data.get("prompt") or "").strip()
+  if not name or not prompt:
+    raise ValueError("missing name/prompt")
+  enabled = bool(data.get("enabled", True))
+  priority = int(data.get("priority") or 0)
+  session_id = (str(data.get("session_id")).strip() if data.get("session_id") else None)
+
+  triggers_raw = data.get("triggers") or []
+  if isinstance(triggers_raw, dict):
+    triggers_raw = [triggers_raw]
+  triggers: list[AutomationTrigger] = []
+  for t in triggers_raw:
+    if not isinstance(t, dict):
+      continue
+    kind = str(t.get("kind") or t.get("type") or "").strip().lower()
+    if kind in ("interval", "every"):
+      every = int(t.get("every_seconds") or t.get("every") or 0)
+      if every <= 0:
+        continue
+      triggers.append(AutomationTrigger(kind="interval", every_seconds=every))
+      continue
+    if kind == "hourly":
+      triggers.append(AutomationTrigger(kind="interval", every_seconds=3600))
+      continue
+    if kind in ("nightly", "daily"):
+      at = str(t.get("at") or "02:00").strip()
+      triggers.append(AutomationTrigger(kind="daily", at_hhmm=at))
+      continue
+    if kind == "cron":
+      cron = str(t.get("cron") or "").strip()
+      if not cron:
+        continue
+      triggers.append(AutomationTrigger(kind="cron", cron=cron))
+      continue
+
+  return Automation(
+    name=name,
+    prompt=prompt,
+    priority=priority,
+    enabled=enabled,
+    session_id=session_id,
+    triggers=tuple(triggers),
+  )
+
+
+def load_automation_state(project_root: Path) -> dict[str, float]:
+  p = automations_state_path(project_root)
+  if not p.is_file():
+    return {}
+  try:
+    data = json.loads(p.read_text(encoding="utf-8"))
+    if isinstance(data, dict):
+      return {str(k): float(v) for k, v in data.items()}
+  except Exception:
+    pass
+  return {}
+
+
+def save_automation_state(project_root: Path, state: dict[str, float]) -> None:
+  d = automations_dir(project_root)
+  d.mkdir(parents=True, exist_ok=True)
+  p = automations_state_path(project_root)
+  try:
+    p.write_text(json.dumps(state, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+  except Exception:
+    pass
+
+
+def is_due(*, now_s: float, last_s: float | None, trig: AutomationTrigger) -> bool:
+  if trig.kind == "interval":
+    if not trig.every_seconds or trig.every_seconds <= 0:
+      return False
+    if last_s is None:
+      return True
+    return (now_s - last_s) >= float(trig.every_seconds)
+  if trig.kind == "daily":
+    at = trig.at_hhmm or "02:00"
+    try:
+      hh, mm = at.split(":", 1)
+      h = int(hh)
+      m = int(mm)
+      if not (0 <= h <= 23 and 0 <= m <= 59):
+        return False
+    except Exception:
+      return False
+    # Compute today's fire time in local epoch seconds.
+    lt = time.localtime(now_s)
+    fire_today = time.mktime((lt.tm_year, lt.tm_mon, lt.tm_mday, h, m, 0, lt.tm_wday, lt.tm_yday, lt.tm_isdst))
+    # If we already passed today's fire time, next is tomorrow.
+    fire_s = fire_today if now_s >= fire_today else fire_today - 86400.0
+    # Due if we crossed the boundary since last_s.
+    if last_s is None:
+      return now_s >= fire_today
+    return last_s < fire_today <= now_s
+  if trig.kind == "cron":
+    return _cron_due(now_s=now_s, last_s=last_s, cron=str(trig.cron or ""))
+  return False
+
+
+def _cron_due(*, now_s: float, last_s: float | None, cron: str) -> bool:
+  # Minimal cron: "M H * * *" with *, */N, or integer for M/H.
+  parts = (cron or "").split()
+  if len(parts) != 5:
+    return False
+  m_s, h_s, dom, mon, dow = parts
+  if dom != "*" or mon != "*" or dow != "*":
+    return False
+
+  def _match(field: str, val: int, *, min_v: int, max_v: int) -> bool:
+    if field == "*":
+      return True
+    if field.startswith("*/"):
+      try:
+        step = int(field[2:])
+        if step <= 0:
+          return False
+        return (val - min_v) % step == 0
+      except Exception:
+        return False
+    try:
+      x = int(field)
+      return x == val and min_v <= x <= max_v
+    except Exception:
+      return False
+
+  lt = time.localtime(now_s)
+  if not (_match(m_s, lt.tm_min, min_v=0, max_v=59) and _match(h_s, lt.tm_hour, min_v=0, max_v=23)):
+    return False
+  # Trigger only once per matching minute.
+  minute_start = now_s - float(lt.tm_sec)
+  if last_s is None:
+    return True
+  return last_s < minute_start <= now_s
+

{gemcode-0.3.109 → gemcode-0.3.111}/src/gemcode/cli.py

@@ -977,6 +977,23 @@ def main() -> None:
       metavar="N",
       help="Cap model↔tool iterations for each job message (ADK RunConfig.max_llm_calls).",
     )
+    kaira_parser.add_argument(
+      "--automations",
+      action="store_true",
+      help="Enable local scheduled automations from .gemcode/automations/*.json.",
+    )
+    kaira_parser.add_argument(
+      "--heartbeat-every-s",
+      type=int,
+      default=0,
+      metavar="N",
+      help="Optional heartbeat job interval (seconds). Enqueues heartbeat prompt repeatedly.",
+    )
+    kaira_parser.add_argument(
+      "--heartbeat-prompt",
+      default=None,
+      help="Prompt text for heartbeat jobs (used with --heartbeat-every-s).",
+    )
 
     args = kaira_parser.parse_args(sys.argv[2:])
     load_cli_environment()
@@ -1013,6 +1030,16 @@ def main() -> None:
     if args.max_llm_calls is not None:
       cfg.max_llm_calls = args.max_llm_calls
 
+    # Local automations / heartbeat configuration (implemented in KairaDaemon loop).
+    if getattr(args, "automations", False):
+      os.environ["GEMCODE_AUTOMATIONS"] = "1"
+    hb_every = int(getattr(args, "heartbeat_every_s", 0) or 0)
+    if hb_every > 0:
+      os.environ["GEMCODE_AUTOMATIONS"] = "1"
+      os.environ["GEMCODE_KAIRA_HEARTBEAT_EVERY_S"] = str(hb_every)
+      if getattr(args, "heartbeat_prompt", None):
+        os.environ["GEMCODE_KAIRA_HEARTBEAT_PROMPT"] = str(args.heartbeat_prompt)
+
     _maybe_prompt_trust(cfg)
     _maybe_prompt_google_api_key()
     require_google_api_key()

{gemcode-0.3.109 → gemcode-0.3.111}/src/gemcode/kaira_daemon.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import asyncio
 import copy
 import sys
+import time
 import uuid
 from dataclasses import dataclass
 from typing import Awaitable, Callable
@@ -94,6 +95,22 @@ def _fmt_tool_result(resp: object) -> str:
   return ""
 
 
+def _should_stream_to_terminal() -> bool:
+  """Stream live job output to the local terminal when interactive."""
+  try:
+    return bool(hasattr(sys.stdin, "isatty") and sys.stdin.isatty())
+  except Exception:
+    return False
+
+
+def _stream_print(s: str) -> None:
+  try:
+    sys.stdout.write(s)
+    sys.stdout.flush()
+  except Exception:
+    pass
+
+
 async def _broadcast_text_delta(
   *,
   ipc: KairaIpcServer,
@@ -206,6 +223,65 @@ class KairaDaemon:
     # We'll implement dynamic resizing once the rest of the control plane is stable.
     return int(self.concurrency)
 
+  async def _automations_loop(
+    self,
+    *,
+    session_id: str,
+    heartbeat_every_s: int | None = None,
+    heartbeat_prompt: str | None = None,
+  ) -> None:
+    """
+    Run saved scheduled automations from `.gemcode/automations/*.json`.
+
+    This is a simple local scheduler. It is intentionally conservative:
+    - interval triggers can be as fast as seconds
+    - cron/daily triggers are minute-level
+    """
+    import os
+
+    from gemcode.automations import (
+      is_due,
+      load_automation_state,
+      load_automations,
+      save_automation_state,
+    )
+
+    state = load_automation_state(self.cfg.project_root)
+    hb_last: float | None = None
+    while not self._stop_event.is_set():
+      try:
+        if os.environ.get("GEMCODE_AUTOMATIONS", "0").strip().lower() not in ("1", "true", "yes", "on"):
+          await asyncio.sleep(1.0)
+          continue
+        now_s = time.time()
+
+        # Heartbeat (ephemeral; CLI-configured).
+        if heartbeat_every_s and heartbeat_every_s > 0:
+          if hb_last is None or (now_s - hb_last) >= float(heartbeat_every_s):
+            hb_last = now_s
+            p = (heartbeat_prompt or "Heartbeat: summarize running jobs and system status.").strip()
+            if p:
+              self.enqueue_prompt(prompt=p, priority=self.default_priority, session_id=session_id)
+
+        autos = load_automations(self.cfg.project_root)
+        changed = False
+        for a in autos:
+          if not a.enabled:
+            continue
+          for trig in a.triggers:
+            key = f"{a.name}:{trig.key()}"
+            last_s = state.get(key)
+            if is_due(now_s=now_s, last_s=last_s, trig=trig):
+              state[key] = now_s
+              changed = True
+              sid = a.session_id or session_id
+              self.enqueue_prompt(prompt=a.prompt, priority=a.priority, session_id=sid)
+        if changed:
+          save_automation_state(self.cfg.project_root, state)
+      except Exception:
+        pass
+      await asyncio.sleep(5.0)
+
   def enqueue_prompt(
     self,
     *,
@@ -402,6 +478,9 @@ class KairaDaemon:
     async def _stream_one_message(*, current_message: types.Content) -> tuple[list, str]:
       emitted_text = ""
       events: list = []
+      stream_live = _should_stream_to_terminal()
+      if stream_live:
+        _stream_print(f"\n[kaira {job.job_id}] started\n")
       async for ev in runner.run_async(
         user_id=self.user_id,
         session_id=job.session_id,
@@ -409,6 +488,28 @@ class KairaDaemon:
         **({"run_config": run_config} if run_config is not None else {}),
       ):
         events.append(ev)
+        # Live terminal streaming (independent of IPC).
+        if stream_live:
+          try:
+            from gemcode.web.sse_adapter import extract_text_from_event
+
+            txt_live = extract_text_from_event(ev)
+            if txt_live:
+              if txt_live.startswith(emitted_text):
+                delta_live = txt_live[len(emitted_text) :]
+              else:
+                # Fallback: find common prefix.
+                common = 0
+                max_common = min(len(txt_live), len(emitted_text))
+                while common < max_common and txt_live[common] == emitted_text[common]:
+                  common += 1
+                delta_live = txt_live[common:]
+              if delta_live:
+                _stream_print(delta_live)
+                emitted_text = txt_live
+          except Exception:
+            pass
+
         if self._ipc is None:
           continue
 
@@ -460,7 +561,7 @@ class KairaDaemon:
         except Exception:
           pass
 
-        # Text deltas
+        # Text deltas (IPC subscribers)
         try:
           from gemcode.web.sse_adapter import extract_text_from_event
 
@@ -602,8 +703,12 @@ class KairaDaemon:
         session_id=session_id,
       )
 
-  async def run_forever(self, *, session_id: str) -> None:
-    """Start the scheduler and keep running until stdin EOF/quit."""
+  async def run_forever(self, *, session_id: str, enable_stdin: bool = True) -> None:
+    """Start the scheduler and keep running until stopped.
+
+    When enable_stdin=False, Kaira runs headless (IPC-only) and does not read
+    from stdin. This mode is used when embedding Kaira inside the GemCode TUI.
+    """
 
     # Start IPC server for two-way control + event streaming.
     try:
@@ -622,12 +727,26 @@ class KairaDaemon:
       self._ipc = None
       print(f"[kaira] ipc disabled: {e}", file=sys.stderr, flush=True)
 
+    import os as _os
+
     scheduler_task = asyncio.create_task(self._scheduler_loop())
-    stdin_task = asyncio.create_task(self._stdin_loop(session_id=session_id))
+    automations_task = asyncio.create_task(
+      self._automations_loop(
+        session_id=session_id,
+        heartbeat_every_s=int(_os.environ.get("GEMCODE_KAIRA_HEARTBEAT_EVERY_S", "0") or "0") or None,
+        heartbeat_prompt=_os.environ.get("GEMCODE_KAIRA_HEARTBEAT_PROMPT", None),
+      )
+    )
+    stdin_task = None
+    if enable_stdin:
+      stdin_task = asyncio.create_task(self._stdin_loop(session_id=session_id))
 
     # Wait for either scheduler to stop (shouldn't happen) or stdin loop to end.
+    wait_set = {scheduler_task, automations_task}
+    if stdin_task is not None:
+      wait_set.add(stdin_task)
     done, pending = await asyncio.wait(
-      {scheduler_task, stdin_task},
+      wait_set,
       return_when=asyncio.FIRST_COMPLETED,
     )
     for p in pending:

{gemcode-0.3.109 → gemcode-0.3.111}/src/gemcode/repl_commands.py

@@ -381,6 +381,10 @@ def slash_help_lines() -> list[str]:
       "  /mcp                  MCP status (reads .gemcode/mcp.json; shows loaded toolsets)",
       "  /mcp list             List configured MCP servers",
       "  /mcp reload           Rebuild runner to reload MCP toolsets",
+      "  /automations          Local scheduled automations (Kaira) + heartbeat",
+      "  /automations list     List .gemcode/automations/*.json",
+      "  /automations run <n>  Enqueue an automation now (needs Kaira IPC running)",
+      "  /afc                  AFC prompt defaults (avoid afc> prompt)",
       "  /eval [llm]           Run tools_smoke (+ pytest if tests/ exist); optional LLM goldens",
       "  /autotune init <tag>  Git branch autotune/<tag> for experiment tracking",
       "  /autotune eval [llm]  Eval + append .gemcode/evals/autotune_ledger.jsonl",