gemcode 0.3.68__tar.gz → 0.3.70__tar.gz

{gemcode-0.3.68/src/gemcode.egg-info → gemcode-0.3.70}/PKG-INFO

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

{gemcode-0.3.68 → gemcode-0.3.70}/pyproject.toml

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

{gemcode-0.3.68 → gemcode-0.3.70}/src/gemcode/callbacks.py

@@ -43,6 +43,11 @@ _CTX_WARN_LEVEL_NOTIFIED = "gemcode:ctx_warn_level_notified"
 _LAST_PROMPT_TOKENS = "gemcode:last_prompt_tokens"
 _LAST_CONTEXT_PCT = "gemcode:last_context_percent_left"
 _LAST_CONTEXT_LEVEL = "gemcode:last_context_alert_level"
+_RISK_FILES_TOUCHED = "gemcode:risk_files_touched"
+_RISK_TOOL_CALLS = "gemcode:risk_tool_calls"
+_RISK_HAD_SHELL = "gemcode:risk_had_shell"
+_RISK_HAD_WRITE = "gemcode:risk_had_write"
+_RISK_HAD_FAILURE = "gemcode:risk_had_failure"
 
 def _truthy_env(name: str, *, default: bool = False) -> bool:
   v = os.environ.get(name)
@@ -141,6 +146,38 @@ def make_before_tool_callback(cfg: GemCodeConfig):
     record = {"tool": name, "args": _redact_args(name, args)}
     append_audit(cfg.project_root, record)
 
+    # Dynamic risk signals from actual repo interaction.
+    try:
+      if tool_context is not None:
+        st = tool_context.state
+        st[_RISK_TOOL_CALLS] = int(st.get(_RISK_TOOL_CALLS, 0) or 0) + 1
+        if name == "read_file":
+          p = (args or {}).get("path")
+          if isinstance(p, str) and p.strip():
+            touched: set[str] = set(st.get(_RISK_FILES_TOUCHED, []) or [])
+            touched.add(p.strip())
+            # Store as list for JSON-serializable session state.
+            st[_RISK_FILES_TOUCHED] = list(sorted(touched))[:200]
+            # More files touched => higher complexity.
+            n = len(touched)
+            cur = float(getattr(cfg, "_risk_score", 0.0) or 0.0)
+            if n >= 10:
+              cur = min(1.0, cur + 0.08)
+            elif n >= 5:
+              cur = min(1.0, cur + 0.04)
+            object.__setattr__(cfg, "_risk_score", cur)
+        # Writes / shell are inherently higher risk; allow more evidence.
+        if name in MUTATING_TOOLS:
+          st[_RISK_HAD_WRITE] = True
+          cur = float(getattr(cfg, "_risk_score", 0.0) or 0.0)
+          object.__setattr__(cfg, "_risk_score", min(1.0, cur + 0.12))
+        if name in SHELL_TOOLS:
+          st[_RISK_HAD_SHELL] = True
+          cur = float(getattr(cfg, "_risk_score", 0.0) or 0.0)
+          object.__setattr__(cfg, "_risk_score", min(1.0, cur + 0.08))
+    except Exception:
+      pass
+
     # ── Shell hooks: pre_tool_use ─────────────────────────────────────────
     # If the project has a .gemcode/hooks/pre_tool_use.sh, run it now.
     # Non-zero exit or {"decision":"deny"} stdout will block the tool call.
@@ -391,10 +428,21 @@ def make_after_tool_callback(cfg: GemCodeConfig):
       cur = float(getattr(cfg, "_risk_score", 0.0) or 0.0)
       bump = 0.0
       if err:
+        try:
+          st[_RISK_HAD_FAILURE] = True
+        except Exception:
+          pass
         bump += 0.15
       if isinstance(tool_response, dict) and isinstance(tool_response.get("exit_code"), int):
         if int(tool_response["exit_code"]) != 0:
+          try:
+            st[_RISK_HAD_FAILURE] = True
+          except Exception:
+            pass
           bump += 0.10
+          # Test/build failures should boost evidence allowance more.
+          if name in ("bash", "run_command"):
+            bump += 0.05
       # decay slowly when things are healthy
       if bump == 0.0:
         cur = max(0.0, cur * 0.90)
@@ -403,6 +451,27 @@ def make_after_tool_callback(cfg: GemCodeConfig):
       object.__setattr__(cfg, "_risk_score", cur)
     except Exception:
       pass
+
+    # Persist repo calibration profile (best-effort).
+    try:
+      files = st.get(_RISK_FILES_TOUCHED, []) or []
+      files_n = len(files) if isinstance(files, list) else 0
+      tool_calls = int(st.get(_RISK_TOOL_CALLS, 0) or 0)
+      had_shell = bool(st.get(_RISK_HAD_SHELL, False))
+      had_write = bool(st.get(_RISK_HAD_WRITE, False))
+      had_failure = bool(st.get(_RISK_HAD_FAILURE, False))
+      from gemcode.policy_profile import update_profile
+      prof = update_profile(
+        cfg.project_root,
+        files_touched=files_n,
+        tool_calls=tool_calls,
+        had_shell=had_shell,
+        had_write=had_write,
+        had_failure=had_failure,
+      )
+      object.__setattr__(cfg, "_policy_profile", prof.to_dict())
+    except Exception:
+      pass
     # ── Shell hooks: post_tool_use ────────────────────────────────────────
     try:
       from gemcode.hooks import run_post_tool_use_hook

gemcode-0.3.70/src/gemcode/policy_profile.py

@@ -0,0 +1,135 @@
+"""
+Persistent per-repo policy profile.
+
+Goal: make dynamic budgets self-tuning per repository without requiring manual
+configuration. This stores lightweight rolling stats under `.gemcode/policy.json`.
+"""
+
+from __future__ import annotations
+
+import json
+import time
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+
+def _path(root: Path) -> Path:
+  d = root / ".gemcode"
+  d.mkdir(parents=True, exist_ok=True)
+  return d / "policy.json"
+
+
+def _clamp(x: float, lo: float, hi: float) -> float:
+  return lo if x < lo else hi if x > hi else x
+
+
+def _ema(prev: float, x: float, *, alpha: float) -> float:
+  return (alpha * x) + ((1.0 - alpha) * prev)
+
+
+@dataclass(frozen=True)
+class PolicyProfile:
+  # Rolling averages in [0,1] where possible.
+  failure_rate_ema: float = 0.0
+  shell_rate_ema: float = 0.0
+  write_rate_ema: float = 0.0
+  files_touched_ema: float = 0.0  # scaled 0..1 (e.g. 0.5 ~ 10 files)
+  updated_at: int = 0
+
+  def to_dict(self) -> dict[str, Any]:
+    return {
+      "failure_rate_ema": self.failure_rate_ema,
+      "shell_rate_ema": self.shell_rate_ema,
+      "write_rate_ema": self.write_rate_ema,
+      "files_touched_ema": self.files_touched_ema,
+      "updated_at": self.updated_at,
+      "version": 1,
+    }
+
+  @staticmethod
+  def from_dict(d: dict[str, Any]) -> "PolicyProfile":
+    try:
+      return PolicyProfile(
+        failure_rate_ema=float(d.get("failure_rate_ema", 0.0) or 0.0),
+        shell_rate_ema=float(d.get("shell_rate_ema", 0.0) or 0.0),
+        write_rate_ema=float(d.get("write_rate_ema", 0.0) or 0.0),
+        files_touched_ema=float(d.get("files_touched_ema", 0.0) or 0.0),
+        updated_at=int(d.get("updated_at", 0) or 0),
+      )
+    except Exception:
+      return PolicyProfile()
+
+
+def load_profile(project_root: Path) -> PolicyProfile:
+  p = _path(project_root)
+  if not p.exists():
+    return PolicyProfile()
+  try:
+    raw = p.read_text(encoding="utf-8", errors="replace")
+    d = json.loads(raw) if raw.strip() else {}
+    if isinstance(d, dict):
+      return PolicyProfile.from_dict(d)
+  except Exception:
+    return PolicyProfile()
+  return PolicyProfile()
+
+
+def save_profile(project_root: Path, profile: PolicyProfile) -> None:
+  p = _path(project_root)
+  p.write_text(
+    json.dumps(profile.to_dict(), ensure_ascii=False, indent=2),
+    encoding="utf-8",
+    errors="replace",
+  )
+
+
+def update_profile(
+  project_root: Path,
+  *,
+  files_touched: int,
+  tool_calls: int,
+  had_shell: bool,
+  had_write: bool,
+  had_failure: bool,
+  alpha: float = 0.08,
+) -> PolicyProfile:
+  """
+  Update profile with a single-turn observation.
+
+  We scale files_touched into [0,1] via min(files/20, 1).
+  """
+  prof = load_profile(project_root)
+  alpha = _clamp(alpha, 0.01, 0.3)
+  ft_scaled = _clamp(float(files_touched) / 20.0, 0.0, 1.0)
+  fail = 1.0 if had_failure else 0.0
+  shell = 1.0 if had_shell else 0.0
+  write = 1.0 if had_write else 0.0
+  # tool_calls unused for now, but reserved for future calibration.
+  _ = tool_calls
+  updated = PolicyProfile(
+    failure_rate_ema=_ema(prof.failure_rate_ema, fail, alpha=alpha),
+    shell_rate_ema=_ema(prof.shell_rate_ema, shell, alpha=alpha),
+    write_rate_ema=_ema(prof.write_rate_ema, write, alpha=alpha),
+    files_touched_ema=_ema(prof.files_touched_ema, ft_scaled, alpha=alpha),
+    updated_at=int(time.time()),
+  )
+  save_profile(project_root, updated)
+  return updated
+
+
+def calibrated_baseline_risk(profile: PolicyProfile) -> float:
+  """
+  Convert profile into a baseline risk prior for a repo.
+
+  Repos with frequent failures, many writes, and lots of files touched tend to
+  benefit from higher evidence budgets by default.
+  """
+  r = (
+    0.55 * profile.failure_rate_ema
+    + 0.20 * profile.write_rate_ema
+    + 0.15 * profile.shell_rate_ema
+    + 0.10 * profile.files_touched_ema
+  )
+  return _clamp(r, 0.0, 0.8)
+

{gemcode-0.3.68 → gemcode-0.3.70}/src/gemcode/repl_slash.py

@@ -391,6 +391,27 @@ async def process_repl_slash(
     out(f"    thinking_budget:       {cfg.thinking_budget if cfg.thinking_budget is not None else '(auto)'}")
     out(f"    show_full_thinking:    {cfg.show_full_thinking}")
     out()
+    # Dynamic policy telemetry
+    try:
+      risk = float(getattr(cfg, "_risk_score", 0.0) or 0.0)
+      pct = getattr(cfg, "_context_percent_left", None)
+      prof = getattr(cfg, "_policy_profile", None)
+      out("  Dynamic policy:")
+      out(f"    dynamic_token_policy:  {getattr(cfg, 'dynamic_token_policy', True)}")
+      out(f"    dynamic_risk_policy:   {getattr(cfg, 'dynamic_risk_policy', True)}")
+      out(f"    dynamic_risk_boost:    {getattr(cfg, 'dynamic_risk_boost', 0.6)}")
+      out(f"    risk_score:            {risk:.2f}")
+      if isinstance(pct, int):
+        out(f"    context_percent_left:  {pct}%")
+      if isinstance(prof, dict):
+        try:
+          out(f"    profile.failure_rate_ema: {float(prof.get('failure_rate_ema', 0.0) or 0.0):.2f}")
+          out(f"    profile.files_touched_ema: {float(prof.get('files_touched_ema', 0.0) or 0.0):.2f}")
+        except Exception:
+          pass
+      out()
+    except Exception:
+      pass
     out("  Autocompact:")
     out(f"    GEMCODE_AUTOCOMPACT:               {os.environ.get('GEMCODE_AUTOCOMPACT', '1')}")
     out(f"    GEMCODE_AUTOCOMPACT_BUFFER_CHARS:  {os.environ.get('GEMCODE_AUTOCOMPACT_BUFFER_CHARS', '60000')}")

{gemcode-0.3.68 → gemcode-0.3.70}/src/gemcode/session_runtime.py

@@ -314,6 +314,16 @@ def _build_artifact_service(cfg: GemCodeConfig):
 
 def create_runner(cfg: GemCodeConfig, extra_tools: list | None = None) -> Runner:
   """Construct Runner + SQLite session service + root LlmAgent."""
+  # Load per-repo calibration profile (self-tuning dynamic policy).
+  try:
+    from gemcode.policy_profile import calibrated_baseline_risk, load_profile
+    prof = load_profile(cfg.project_root)
+    base = calibrated_baseline_risk(prof)
+    cur = float(getattr(cfg, "_risk_score", 0.0) or 0.0)
+    object.__setattr__(cfg, "_risk_score", max(cur, base))
+    object.__setattr__(cfg, "_policy_profile", prof.to_dict())
+  except Exception:
+    pass
   modality_tools = build_modality_extra_tools(cfg)
   merged_extra_tools: list | None
   if extra_tools:

{gemcode-0.3.68 → gemcode-0.3.70/src/gemcode.egg-info}/PKG-INFO

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

{gemcode-0.3.68 → gemcode-0.3.70}/src/gemcode.egg-info/SOURCES.txt

@@ -32,6 +32,7 @@ src/gemcode/model_routing.py
 src/gemcode/openapi_loader.py
 src/gemcode/paths.py
 src/gemcode/permissions.py
+src/gemcode/policy_profile.py
 src/gemcode/pricing.py
 src/gemcode/prompt_suggestions.py
 src/gemcode/refine.py