gemcode 0.3.67__tar.gz → 0.3.68__tar.gz

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

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

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

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

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

@@ -384,6 +384,25 @@ 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
+      # 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.68}/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.68}/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.68}/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.68/src/gemcode.egg-info}/PKG-INFO

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