gemcode 0.3.67__tar.gz → 0.3.69__tar.gz

{gemcode-0.3.67/src/gemcode.egg-info → gemcode-0.3.69}/PKG-INFO

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

{gemcode-0.3.67 → gemcode-0.3.69}/pyproject.toml

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

{gemcode-0.3.67 → gemcode-0.3.69}/src/gemcode/callbacks.py

@@ -43,6 +43,8 @@ _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"
 
 def _truthy_env(name: str, *, default: bool = False) -> bool:
   v = os.environ.get(name)
@@ -141,6 +143,36 @@ 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:
+          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:
+          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.
@@ -384,6 +416,28 @@ def make_after_tool_callback(cfg: GemCodeConfig):
         st[_STATE_FAILURE_KEY] = 0
     else:
       st[_STATE_FAILURE_KEY] = 0
+
+    # Risk feedback: if tools are failing or commands return non-zero, treat the
+    # task as higher-risk and allow more evidence in subsequent tool outputs.
+    try:
+      cur = float(getattr(cfg, "_risk_score", 0.0) or 0.0)
+      bump = 0.0
+      if err:
+        bump += 0.15
+      if isinstance(tool_response, dict) and isinstance(tool_response.get("exit_code"), int):
+        if int(tool_response["exit_code"]) != 0:
+          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)
+      else:
+        cur = min(1.0, cur + bump)
+      object.__setattr__(cfg, "_risk_score", cur)
+    except Exception:
+      pass
     # ── Shell hooks: post_tool_use ────────────────────────────────────────
     try:
       from gemcode.hooks import run_post_tool_use_hook

{gemcode-0.3.67 → gemcode-0.3.69}/src/gemcode/config.py

@@ -143,6 +143,16 @@ class GemCodeConfig:
   dynamic_token_policy: bool = field(
     default_factory=lambda: _truthy_env("GEMCODE_DYNAMIC_TOKEN_POLICY", default=True)
   )
+
+  # Dynamic risk policy: boosts caps when the current task appears risky/complex.
+  dynamic_risk_policy: bool = field(
+    default_factory=lambda: _truthy_env("GEMCODE_DYNAMIC_RISK_POLICY", default=True)
+  )
+
+  # How much the risk score can expand caps (0.0-1.5 reasonable).
+  dynamic_risk_boost: float = field(
+    default_factory=lambda: float(os.environ.get("GEMCODE_DYNAMIC_RISK_BOOST", "0.6"))
+  )
   # Trim oldest text in llm_request.contents when over budget (see context_budget.py).
   context_shrink_enabled: bool = field(
     default_factory=lambda: _truthy_env("GEMCODE_CONTEXT_SHRINK", default=True)

{gemcode-0.3.67 → gemcode-0.3.69}/src/gemcode/dynamic_policy.py

@@ -32,6 +32,20 @@ def _pct_left(cfg) -> int | None:
   return None
 
 
+def _risk(cfg) -> float:
+  try:
+    v = getattr(cfg, "_risk_score", None)
+    if isinstance(v, (int, float)):
+      return float(v)
+  except Exception:
+    return 0.0
+  return 0.0
+
+
+def _clamp(x: float, lo: float, hi: float) -> float:
+  return lo if x < lo else hi if x > hi else x
+
+
 @dataclass(frozen=True)
 class DynamicCaps:
   tool_inline_chars: int
@@ -52,6 +66,8 @@ def get_dynamic_caps(cfg) -> DynamicCaps:
   - Healthy (>=45% left): generous caps (better evidence, less re-asking).
   - Warning (20-44%): moderate caps.
   - Tight (<20%): strict caps + prefer offload.
+
+  Then apply a risk-based boost (if enabled) so complex tasks stay evidence-rich.
   """
   # cfg can be None in some tool contexts; treat as enabled with defaults.
   enabled = _truthy(getattr(cfg, "dynamic_token_policy", True) if cfg is not None else True, default=True)
@@ -76,42 +92,52 @@ def get_dynamic_caps(cfg) -> DynamicCaps:
   base_tool = int(getattr(cfg, "tool_result_max_chars", 12000) or 12000) if cfg is not None else 12000
   base_tool = max(1000, base_tool)
 
+  # Risk boost: scale caps upward for risky tasks, but keep bounded.
+  risk_enabled = _truthy(getattr(cfg, "dynamic_risk_policy", True) if cfg is not None else True, default=True)
+  risk_boost = float(getattr(cfg, "dynamic_risk_boost", 0.6) if cfg is not None else 0.6)
+  risk_score = _risk(cfg) if (cfg is not None and risk_enabled) else 0.0
+  risk_score = _clamp(risk_score, 0.0, 1.0)
+  boost = 1.0 + (_clamp(risk_boost, 0.0, 1.5) * risk_score)
+
+  def _scale(n: int, *, cap: int) -> int:
+    return min(cap, max(1000, int(n * boost)))
+
   if pct >= 45:
     mult = 1.4
     return DynamicCaps(
-      tool_inline_chars=min(24_000, int(base_tool * mult)),
-      read_file_max_bytes=140_000,
-      web_fetch_max_chars=30_000,
-      bash_stdout_chars=30_000,
-      bash_stderr_chars=15_000,
-      run_stdout_chars=30_000,
-      run_stderr_chars=30_000,
-      grep_max_matches=60,
+      tool_inline_chars=_scale(min(24_000, int(base_tool * mult)), cap=30_000),
+      read_file_max_bytes=min(200_000, int(140_000 * boost)),
+      web_fetch_max_chars=min(60_000, int(30_000 * boost)),
+      bash_stdout_chars=min(80_000, int(30_000 * boost)),
+      bash_stderr_chars=min(40_000, int(15_000 * boost)),
+      run_stdout_chars=min(80_000, int(30_000 * boost)),
+      run_stderr_chars=min(80_000, int(30_000 * boost)),
+      grep_max_matches=min(200, int(60 * boost)),
     )
 
   if pct >= 20:
     mult = 1.0
     return DynamicCaps(
-      tool_inline_chars=min(18_000, int(base_tool * mult)),
-      read_file_max_bytes=80_000,
-      web_fetch_max_chars=20_000,
-      bash_stdout_chars=20_000,
-      bash_stderr_chars=10_000,
-      run_stdout_chars=20_000,
-      run_stderr_chars=20_000,
-      grep_max_matches=40,
+      tool_inline_chars=_scale(min(18_000, int(base_tool * mult)), cap=24_000),
+      read_file_max_bytes=min(160_000, int(80_000 * boost)),
+      web_fetch_max_chars=min(40_000, int(20_000 * boost)),
+      bash_stdout_chars=min(50_000, int(20_000 * boost)),
+      bash_stderr_chars=min(30_000, int(10_000 * boost)),
+      run_stdout_chars=min(50_000, int(20_000 * boost)),
+      run_stderr_chars=min(50_000, int(20_000 * boost)),
+      grep_max_matches=min(120, int(40 * boost)),
     )
 
   # Tight
   mult = 0.6
   return DynamicCaps(
-    tool_inline_chars=max(2000, int(base_tool * mult)),
-    read_file_max_bytes=35_000,
-    web_fetch_max_chars=10_000,
-    bash_stdout_chars=10_000,
-    bash_stderr_chars=8_000,
-    run_stdout_chars=10_000,
-    run_stderr_chars=10_000,
-    grep_max_matches=20,
+    tool_inline_chars=max(2000, min(12_000, int(base_tool * mult * boost))),
+    read_file_max_bytes=min(90_000, int(35_000 * boost)),
+    web_fetch_max_chars=min(20_000, int(10_000 * boost)),
+    bash_stdout_chars=min(25_000, int(10_000 * boost)),
+    bash_stderr_chars=min(20_000, int(8_000 * boost)),
+    run_stdout_chars=min(25_000, int(10_000 * boost)),
+    run_stderr_chars=min(25_000, int(10_000 * boost)),
+    grep_max_matches=min(80, int(20 * boost)),
   )
 

{gemcode-0.3.67 → gemcode-0.3.69}/src/gemcode/invoke.py

@@ -68,6 +68,32 @@ async def run_turn(
     cfg: "GemCodeConfig | None" = None,
 ) -> list:
   """Execute one user message; collect all Events (caller aggregates text)."""
+  # Dynamic risk score: updated each user message; later refined by tool outcomes.
+  # This is intentionally heuristic but configurable via env knobs.
+  if cfg is not None:
+    try:
+      import re
+      p = (prompt or "")[:20_000]
+      risk = 0.0
+      # Complexity signals
+      if len(p) > 600:
+        risk += 0.15
+      if len(p) > 2000:
+        risk += 0.15
+      if re.search(r"\\b(refactor|migrate|rewrite|optimi[sz]e|architecture)\\b", p, re.I):
+        risk += 0.2
+      if re.search(r"\\b(bug|fix|regression|error|traceback|failing)\\b", p, re.I):
+        risk += 0.2
+      if re.search(r"\\b(test|pytest|ci|build|deploy|release)\\b", p, re.I):
+        risk += 0.1
+      # Multi-file hints
+      if p.count(\"/\") >= 6 or p.count(\".py\") + p.count(\".ts\") + p.count(\".tsx\") >= 3:
+        risk += 0.1
+      # Clamp 0..1
+      risk = max(0.0, min(1.0, float(risk)))
+      object.__setattr__(cfg, \"_risk_score\", risk)
+    except Exception:
+      pass
   run_config = (
     RunConfig(max_llm_calls=max_llm_calls) if max_llm_calls is not None else None
   )

{gemcode-0.3.67 → gemcode-0.3.69}/src/gemcode/repl_slash.py

@@ -391,6 +391,20 @@ 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)
+      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}%")
+      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.67 → gemcode-0.3.69/src/gemcode.egg-info}/PKG-INFO

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