codna 0.2.9__tar.gz → 0.2.11__tar.gz

{codna-0.2.9 → codna-0.2.11}/PKG-INFO

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

{codna-0.2.9 → codna-0.2.11}/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.2.9"
+__version__ = "0.2.11"

{codna-0.2.9 → codna-0.2.11}/codna/admission_control.py

@@ -37,6 +37,7 @@ thread-pool of fixes.
 from __future__ import annotations
 
 import contextlib
+import sys as _sys
 import threading
 import time
 from collections import deque
@@ -101,22 +102,77 @@ def mojo_breach_probability(
         "runs": int(min(max(n, 100), 1_000_000)),
         "seed": 7,  # deterministic: the window already moves, so a fixed seed keeps the estimate reproducible
     }
-    if client is None:
-        from codna.cli import _client as _mk
+    if client is not None:                      # injected (tests / an explicit HTTP client)
+        resp = client._request("POST", "/v1/simulate", json=body)
+        return float(resp["metrics"]["probability_of_loss"])
+    return _encapsulated_simulate(body)
+
+
+def _encapsulated_simulate(body: dict) -> float:
+    """Run the simulation IN-PROCESS through the encapsulated engine. No HTTP, no daemon, no cloud.
+
+    This replaces a `client._request("POST", "/v1/simulate", ...)` call that could never work on the
+    local path: with no remote engine configured, ``codna.cli._client()`` returns
+    ``LocalCodnaRuntimeClient``, which has no ``_request`` method at all — so every local call raised
+    AttributeError and make_mojo_breach_fn silently swallowed it into the numpy fallback. The kernel
+    "decision" only ever happened by pointing at a REMOTE HTTP engine, which is exactly the shape
+    Codna does not ship: Mojo is encapsulated, reached through the local SDK, never a sidecar or a
+    cloud round-trip.
+
+    Same in-process import route ``local_client`` already uses for repository intelligence
+    (``_ensure_decision_engine_imports`` → ``apps.api_server.services.*``), and it sets
+    ``RUNTIME_FALLBACK_MODE=deny`` so the compiled kernel — not a silent Python reimplementation —
+    computes the answer. Raises on anything unexpected so the caller's fallback is a DELIBERATE,
+    logged degradation rather than an invisible default."""
+    import asyncio
+    import os
+    import uuid
+
+    try:                                        # a running loop means asyncio.run() would explode
+        asyncio.get_running_loop()
+    except RuntimeError:
+        pass
+    else:
+        raise RuntimeError("encapsulated simulate called from an async context")
+
+    from .local_client import _ensure_decision_engine_imports
+    from .runtime.config import resolve_runtime_config
+
+    os.environ.setdefault("RUNTIME_FALLBACK_MODE", "deny")   # compiled kernel, never a Python stand-in
+    _ensure_decision_engine_imports(resolve_runtime_config())
+
+    from pydantic import TypeAdapter
 
-        client = _mk()
-    resp = client._request("POST", "/v1/simulate", json=body)
-    return float(resp["metrics"]["probability_of_loss"])
+    from apps.api_server.schemas.simulate import SimulateRequest        # type: ignore[import-not-found]
+    from apps.api_server.services.simulation_service import run_simulation_fast  # type: ignore[import-not-found]
+
+    request = TypeAdapter(SimulateRequest).validate_python(body)        # SimulateRequest is a union
+    envelope, _meta = asyncio.run(run_simulation_fast(request, uuid.uuid4(), None))
+    payload = envelope.model_dump() if hasattr(envelope, "model_dump") else envelope
+    return float((payload.get("metrics") or {})["probability_of_loss"])
 
 
 def make_mojo_breach_fn(client: object | None = None, *, fallback: BreachFn = _numpy_breach_probability) -> BreachFn:
-    """Build a ``BreachFn`` that routes to the mojo kernel, falling back to ``fallback`` (numpy by
-    default) on any error so a predictor/engine outage never stalls admission."""
+    """Build a ``BreachFn`` that routes to the encapsulated kernel, falling back to ``fallback``
+    (numpy by default) on any error so a predictor/engine outage never stalls admission.
+
+    The fallback is logged ONCE per process. It used to be silent, which made the headline claim
+    ("the compiled kernel decides") unfalsifiable: the kernel path was broken on every local call and
+    nothing said so — a green test suite proved only that *some* number came back."""
+    warned = [False]
 
     def _fn(durations: list[float], contention: float, sla: float, n: int) -> float:
         try:
             return mojo_breach_probability(durations, contention, sla, n, client=client)
-        except Exception:  # noqa: BLE001 — never let the predictor block the gate
+        except Exception as exc:  # noqa: BLE001 — never let the predictor block the gate
+            if not warned[0]:
+                warned[0] = True
+                print(
+                    "codna: admission predictor fell back to in-process numpy "
+                    f"({type(exc).__name__}: {exc}); concurrency is still governed, but not by the "
+                    "compiled kernel",
+                    file=_sys.stderr,
+                )
             return fallback(durations, contention, sla, n)
 
     return _fn
@@ -218,6 +274,24 @@ class MCAdmissionDecider:
         with self._lock:
             return self._decide(self._in_flight, list(self._durations), det_cap)
 
+    def decide_for(
+        self,
+        inflight: int,
+        durations: list[float],
+        model_rate_budget: int | None = None,
+    ) -> AdmissionVerdict:
+        """Evaluate the SAME decision against occupancy this process does not own.
+
+        `can_admit`/`try_admit` read `self._in_flight`, which is per-process. CI admission
+        (`ci_admission`) counts jobs across every runner on the machine via a lease directory, and
+        reads durations from that job class's on-disk history — so it must supply both. Exposed rather
+        than reaching into `_decide` so there is exactly one copy of the floor/MC-zone/ceiling policy;
+        a second copy would be free to drift from the documented behaviour.
+
+        Reserving is the caller's job here: the fleet's slot is the lease file, not this counter.
+        """
+        return self._decide(inflight, list(durations), self._det_cap(model_rate_budget))
+
     def try_admit(self, model_rate_budget: int | None = None) -> AdmissionVerdict:
         """Atomic check-and-reserve: the in-flight slot is taken under the SAME lock as the capacity
         check, so concurrent callers can't all pass the check before any increments. Pair with

{codna-0.2.9 → codna-0.2.11}/codna/agent-core/run-server.bundle.mjs

@@ -110643,7 +110643,7 @@ var init_bowser = __esm(() => {
 
 // agent-core/vendor/cline/node_modules/.bun/@aws-sdk+core@3.974.15/node_modules/@aws-sdk/core/dist-cjs/submodules/client/index.js
 var require_client2 = __commonJS((exports) => {
-  var __dirname = "/Users/angel/actions-runner-mac-2/_work/codna/codna/agent-core/vendor/cline/node_modules/.bun/@aws-sdk+core@3.974.15/node_modules/@aws-sdk/core/dist-cjs/submodules/client";
+  var __dirname = "/Users/angel/Developer/actions-runner/_work/codna/codna/agent-core/vendor/cline/node_modules/.bun/@aws-sdk+core@3.974.15/node_modules/@aws-sdk/core/dist-cjs/submodules/client";
   var retry2 = require_retry2();
   var protocols = require_protocols();
   var lambdaInvokeStore = require_invoke_store();

{codna-0.2.9 → codna-0.2.11}/codna/byok_cli.py

@@ -95,3 +95,23 @@ def cmd_key(args) -> int:
         return 1
     print(json.dumps({"ok": False, "error": "usage: codna key {set|list|rm} …"}, indent=2), file=sys.stderr)
     return 2
+
+
+def register(sub) -> None:
+    """Attach `codna key {set,list,rm}` to the top-level subparsers.
+
+    Lives here rather than in `cli.py` for the reason `impact_cli.register_cli` does: a command's
+    parser belongs with its handler, and cli.py is held under a hard line ceiling by
+    `test_modularity` — which is what forced this move when `codna ci` was added.
+    """
+    pk = sub.add_parser("key", help="Manage the on-device LLM provider key for local `codna fix` (OS keychain).")
+    pk_sub = pk.add_subparsers(dest="key_action")
+    pk_set = pk_sub.add_parser("set", help="Store a provider key (read via hidden prompt; never on the command line).")
+    pk_set.add_argument("provider", help="provider name (anthropic/openai/gemini/…) or *_API_KEY variable name")
+    pk_set.add_argument("--stdin", action="store_true", help="read the key from stdin (for CI) instead of prompting")
+    pk_set.set_defaults(func=cmd_key)
+    pk_list = pk_sub.add_parser("list", help="List which provider keys are stored (values never shown).")
+    pk_list.set_defaults(func=cmd_key)
+    pk_rm = pk_sub.add_parser("rm", help="Remove a stored provider key.")
+    pk_rm.add_argument("provider", help="provider name or *_API_KEY variable name")
+    pk_rm.set_defaults(func=cmd_key)