codna 0.1.20__tar.gz → 0.1.22__tar.gz

{codna-0.1.20 → codna-0.1.22}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codna
-Version: 0.1.20
+Version: 0.1.22
 Summary: Local-first repo intelligence and agent fixing for Codna.
 Author: Thyn
 Maintainer: Thyn

{codna-0.1.20 → codna-0.1.22}/codna/__init__.py

@@ -5,4 +5,4 @@ This package is the `codna` CLI. Users never touch "algenta" directly — the en
 is an internal dependency reached over HTTP.
 """
 
-__version__ = "0.1.20"
+__version__ = "0.1.22"

{codna-0.1.20 → codna-0.1.22}/codna/fix_run.py

@@ -24,7 +24,7 @@ def summarize_plan(plan: dict) -> dict:
     """Extract the stable fields the CLI reports (human + JSON) from a decision plan."""
     dp = plan.get("decision_plan") or {}
     ra = dp.get("repository_analysis") or {}
-    usage = plan.get("planner_usage") or {}
+    usage = _normalized_usage(plan.get("planner_usage") or {})
     tr = ra.get("token_reduction_metrics") or {}
     risk = dp.get("risk") or {}
     return {
@@ -35,14 +35,92 @@ def summarize_plan(plan: dict) -> dict:
         "regression_risk": risk.get("probability_of_loss"),
         "patch_ref": ra.get("generated_patch_ref"),
         "runtime_model": plan.get("runtime_model"),
-        "tokens": {"input": usage.get("input_tokens"), "output": usage.get("output_tokens")},
-        "cost_usd": usage.get("cost_usd"),
+        "input_tokens": usage["input_tokens"],
+        "output_tokens": usage["output_tokens"],
+        "total_tokens": usage["total_tokens"],
+        "cache_read_tokens": usage["cache_read_tokens"],
+        "cache_write_tokens": usage["cache_write_tokens"],
+        "tokens": {
+            "input": usage["input_tokens"],
+            "output": usage["output_tokens"],
+            "total": usage["total_tokens"],
+            "cache_read": usage["cache_read_tokens"],
+            "cache_write": usage["cache_write_tokens"],
+        },
+        "cost_usd": usage["cost_usd"],
         "reduction_ratio": tr.get("reduction_ratio"),
         "raw_repo_tokens": tr.get("raw_repo_token_estimate"),
         "evidence_bundle_tokens": tr.get("evidence_bundle_token_count"),
     }
 
 
+def _normalized_usage(raw: dict) -> dict:
+    input_tokens = _int_or_zero(raw.get("input_tokens"))
+    output_tokens = _int_or_zero(raw.get("output_tokens"))
+    cache_read_tokens = _int_or_zero(raw.get("cache_read_tokens"))
+    cache_write_tokens = _int_or_zero(raw.get("cache_write_tokens"))
+    cost = raw.get("cost_usd")
+    return {
+        "input_tokens": input_tokens,
+        "output_tokens": output_tokens,
+        "total_tokens": input_tokens + output_tokens,
+        "cache_read_tokens": cache_read_tokens,
+        "cache_write_tokens": cache_write_tokens,
+        "cost_usd": cost if isinstance(cost, (int, float)) else None,
+    }
+
+
+def _int_or_zero(value) -> int:
+    if isinstance(value, bool):
+        return 0
+    if isinstance(value, int):
+        return value
+    if isinstance(value, float) and value.is_integer():
+        return int(value)
+    return 0
+
+
+def attach_usage_totals(result: dict) -> dict:
+    """Expose aggregate model usage at the top level for scriptable ``codna fix --json`` users."""
+    totals = {
+        "input_tokens": 0,
+        "output_tokens": 0,
+        "total_tokens": 0,
+        "cache_read_tokens": 0,
+        "cache_write_tokens": 0,
+    }
+    total_cost = 0.0
+    saw_cost = False
+    runtime_models: list[str] = []
+    for iteration in result.get("iterations") or []:
+        summary = iteration.get("summary") if isinstance(iteration, dict) else None
+        if not isinstance(summary, dict):
+            continue
+        usage = _normalized_usage(summary)
+        for key in totals:
+            totals[key] += usage[key]
+        if usage["cost_usd"] is not None:
+            total_cost += float(usage["cost_usd"])
+            saw_cost = True
+        model = summary.get("runtime_model")
+        if isinstance(model, str) and model and model not in runtime_models:
+            runtime_models.append(model)
+    result["usage"] = totals
+    result["tokens"] = {
+        "input": totals["input_tokens"],
+        "output": totals["output_tokens"],
+        "total": totals["total_tokens"],
+        "cache_read": totals["cache_read_tokens"],
+        "cache_write": totals["cache_write_tokens"],
+    }
+    result["cost_usd"] = total_cost if saw_cost else None
+    if len(runtime_models) == 1:
+        result["runtime_model"] = runtime_models[0]
+    elif runtime_models:
+        result["runtime_models"] = runtime_models
+    return result
+
+
 def _plan_once(c, *, repo, ref, issue, failing, model, open_pr, gh_token):
     from . import cli as _cli
 
@@ -193,7 +271,7 @@ def run_fix(c, args) -> dict:
         if not (apply or open_pr):
             result["iterations"].append(iteration)
             result["elapsed_s"] = round(time.perf_counter() - t0, 1)
-            return result
+            return attach_usage_totals(result)
 
         apply_artifacts_before = _snapshot_generated_apply_artifacts(repo) if apply and not open_pr else {}
         try:
@@ -249,7 +327,7 @@ def run_fix(c, args) -> dict:
         repo = checkout
 
     result["elapsed_s"] = round(time.perf_counter() - t0, 1)
-    return result
+    return attach_usage_totals(result)
 
 
 def render_human(result: dict) -> list[str]:

{codna-0.1.20 → codna-0.1.22}/codna/packaged_agent_runner.py

@@ -121,10 +121,17 @@ class SidecarPackagedAgentRunner:
 def _sidecar_payload(request: PackagedAgentRunRequest, workspace: Path) -> dict[str, Any]:
     timeout_ms = _dynamic_timeout_ms(request.snapshot)
     max_turns = _env_int("ALGENTA_AGENT_MAX_TURNS", default=4, minimum=1, maximum=50)
-    provider = os.environ.get("ALGENTA_AGENT_PROVIDER") or os.environ.get("CODNA_AGENT_PROVIDER")
-    model = os.environ.get("ALGENTA_AGENT_MODEL") or os.environ.get("CODNA_AGENT_MODEL")
-    if not model and request.model != _VERIFIED_AGENTIC_MODEL:
-        model = request.model
+    requested_provider, requested_model = _provider_model_from_request(request.model)
+    provider = (
+        os.environ.get("ALGENTA_AGENT_PROVIDER")
+        or os.environ.get("CODNA_AGENT_PROVIDER")
+        or requested_provider
+    )
+    model = (
+        os.environ.get("ALGENTA_AGENT_MODEL")
+        or os.environ.get("CODNA_AGENT_MODEL")
+        or requested_model
+    )
     payload: dict[str, Any] = {
         "working_dir": str(workspace),
         "channel": "cli",
@@ -149,6 +156,20 @@ def _sidecar_payload(request: PackagedAgentRunRequest, workspace: Path) -> dict[
     return payload
 
 
+def _provider_model_from_request(model: str) -> tuple[str | None, str | None]:
+    requested = (model or "").strip()
+    if not requested or requested == _VERIFIED_AGENTIC_MODEL:
+        return None, None
+    if "/" not in requested:
+        return None, requested
+    provider, model_id = requested.split("/", 1)
+    provider = provider.strip()
+    model_id = model_id.strip()
+    if not provider or not model_id:
+        return None, requested
+    return provider, model_id
+
+
 def _project_guidance(request: PackagedAgentRunRequest) -> str | None:
     """Project rules (AGENTS.md / .codna/rules) for the executing Cline agent to honor.
 

{codna-0.1.20 → codna-0.1.22}/codna.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codna
-Version: 0.1.20
+Version: 0.1.22
 Summary: Local-first repo intelligence and agent fixing for Codna.
 Author: Thyn
 Maintainer: Thyn

{codna-0.1.20 → codna-0.1.22}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "codna"
-version = "0.1.20"
+version = "0.1.22"
 description = "Local-first repo intelligence and agent fixing for Codna."
 readme = "README.md"
 requires-python = ">=3.10"

{codna-0.1.20 → codna-0.1.22}/tests/test_fix_run.py

@@ -27,9 +27,19 @@ class _Args:
         self.__dict__.update(kw)
 
 
-def _plan(root="rc", patch="p1"):
-    return {"decision_plan": {"repository_analysis": {"root_cause": root, "generated_patch_ref": patch,
-                                                      "impacted_symbols": ["f"]}, "confidence": 0.9}}
+def _plan(root="rc", patch="p1", usage=None, model="m"):
+    return {
+        "runtime_model": model,
+        "planner_usage": usage or {},
+        "decision_plan": {
+            "repository_analysis": {
+                "root_cause": root,
+                "generated_patch_ref": patch,
+                "impacted_symbols": ["f"],
+            },
+            "confidence": 0.9,
+        },
+    }
 
 
 def test_report_only_no_apply(monkeypatch):
@@ -42,6 +52,42 @@ def test_report_only_no_apply(monkeypatch):
     assert any("root cause" in ln for ln in fix_run.render_human(result))
 
 
+def test_fix_json_exposes_top_level_usage_totals(monkeypatch):
+    usage = {
+        "input_tokens": 3239,
+        "output_tokens": 256,
+        "cache_read_tokens": 1024,
+        "cache_write_tokens": 0,
+        "cost_usd": 0.019267,
+    }
+    monkeypatch.setattr(
+        fix_run,
+        "_plan_once",
+        lambda c, **k: ("rid", {"snapshot_id": "s"}, _plan(usage=usage, model="gpt-5.5")),
+    )
+
+    result = fix_run.run_fix(object(), _Args())
+
+    assert result["usage"] == {
+        "input_tokens": 3239,
+        "output_tokens": 256,
+        "total_tokens": 3495,
+        "cache_read_tokens": 1024,
+        "cache_write_tokens": 0,
+    }
+    assert result["tokens"] == {
+        "input": 3239,
+        "output": 256,
+        "total": 3495,
+        "cache_read": 1024,
+        "cache_write": 0,
+    }
+    assert result["cost_usd"] == 0.019267
+    assert result["runtime_model"] == "gpt-5.5"
+    assert result["iterations"][0]["summary"]["input_tokens"] == 3239
+    assert result["iterations"][0]["summary"]["total_tokens"] == 3495
+
+
 def test_apply_local_branch(monkeypatch):
     monkeypatch.setattr(fix_run, "_plan_once", lambda c, **k: ("rid", {"snapshot_id": "s"}, _plan()))
     monkeypatch.setattr(fix_run, "_apply_once",
@@ -103,6 +149,31 @@ def test_verify_refixes_until_green(monkeypatch):
     assert len(result["iterations"]) == 2  # took a re-fix
 
 
+def test_usage_totals_sum_multiple_fix_iterations(monkeypatch):
+    plans = iter([
+        _plan(usage={"input_tokens": 100, "output_tokens": 10, "cache_read_tokens": 5, "cost_usd": 0.01}, model="m1"),
+        _plan(usage={"input_tokens": 200, "output_tokens": 20, "cache_write_tokens": 7, "cost_usd": 0.02}, model="m2"),
+    ])
+    monkeypatch.setattr(fix_run, "_plan_once", lambda c, **k: ("rid", {"snapshot_id": "s"}, next(plans)))
+    monkeypatch.setattr(fix_run, "_apply_once", _apply)
+    monkeypatch.setattr("os.path.isdir", lambda p: True)
+    seq = iter([_FAIL, _FAIL, _GREEN])
+    monkeypatch.setattr("codna.testrun.discover_failing_tests", lambda repo, cmd=None: next(seq))
+
+    result = fix_run.run_fix(object(), _Args(apply=True, tests=True, max_iterations=2))
+
+    assert result["usage"] == {
+        "input_tokens": 300,
+        "output_tokens": 30,
+        "total_tokens": 330,
+        "cache_read_tokens": 5,
+        "cache_write_tokens": 7,
+    }
+    assert result["tokens"]["total"] == 330
+    assert result["cost_usd"] == 0.03
+    assert result["runtime_models"] == ["m1", "m2"]
+
+
 def test_verify_gives_up_after_max_iterations(monkeypatch):
     monkeypatch.setattr(fix_run, "_plan_once", lambda c, **k: ("rid", {"snapshot_id": "s"}, _plan()))
     monkeypatch.setattr(fix_run, "_apply_once", _apply)

{codna-0.1.20 → codna-0.1.22}/tests/test_packaged_guidance.py

@@ -49,3 +49,27 @@ def test_localized_payload_limits_fast_path_writes_to_evidence_files():
     assert "tests.test_calc::test_add" in payload["task_spec"]["issue_text"]
     assert "test identifiers, not file paths" in payload["task_spec"]["issue_text"]
     assert "do not leave duplicate unreachable code behind" in payload["task_spec"]["issue_text"]
+
+
+def test_provider_qualified_model_populates_sidecar_provider_and_model(monkeypatch):
+    monkeypatch.delenv("ALGENTA_AGENT_PROVIDER", raising=False)
+    monkeypatch.delenv("CODNA_AGENT_PROVIDER", raising=False)
+    monkeypatch.delenv("ALGENTA_AGENT_MODEL", raising=False)
+    monkeypatch.delenv("CODNA_AGENT_MODEL", raising=False)
+
+    payload = par._sidecar_payload(_req(model="openai-native/gpt-5.5"), Path("/tmp"))
+
+    assert payload["provider"] == "openai-native"
+    assert payload["model"] == "gpt-5.5"
+
+
+def test_default_repository_model_does_not_force_agent_provider(monkeypatch):
+    monkeypatch.delenv("ALGENTA_AGENT_PROVIDER", raising=False)
+    monkeypatch.delenv("CODNA_AGENT_PROVIDER", raising=False)
+    monkeypatch.delenv("ALGENTA_AGENT_MODEL", raising=False)
+    monkeypatch.delenv("CODNA_AGENT_MODEL", raising=False)
+
+    payload = par._sidecar_payload(_req(model="repository.verified_agentic_v1"), Path("/tmp"))
+
+    assert "provider" not in payload
+    assert "model" not in payload