codna 0.1.0__py3-none-any.whl

codna/patchgen.py

@@ -0,0 +1,115 @@
+"""Engine-backed patch generator — the remediation seam the worker invokes.
+
+`LocalWorker.remediate` calls a `patch_generator(finding, cwd) -> diff`. The real generator is
+codna's existing decision-plan agent: it turns a security finding into a remediation obligation
+("fix this source→sink without changing behavior, don't touch tests/CI/suppressions"), asks the
+engine to produce a fix, and returns the unified diff for the worker to apply in its sandboxed
+worktree.
+
+Transport is the same injected `post(path, body) -> dict` callable the `EngineAdapter` uses, so
+this is testable offline with a stub. The generated diff is then subject to the worker's G4
+anti-evasion check before it is ever applied.
+"""
+from __future__ import annotations
+
+import subprocess
+from typing import Callable
+
+from .findings import NormalizedFinding
+
+PostFn = Callable[[str, dict], dict]
+
+
+class PatchGenError(Exception):
+    pass
+
+
+def finding_issue(finding: NormalizedFinding) -> str:
+    """Render a finding as a remediation obligation for the agent."""
+    loc = finding.primary_location
+    where = f"{loc.uri}:{loc.start_line}" if loc and loc.start_line else (loc.uri if loc else "(unknown location)")
+    flow = ""
+    if finding.code_flows:
+        seq = finding.code_flows[0]
+        if seq:
+            src, sink = seq[0], seq[-1]
+            flow = f" Dataflow: {src.uri}:{src.start_line} -> {sink.uri}:{sink.start_line}."
+    return (
+        f"Security finding {finding.rule_id} ({finding.severity.value}, kind={finding.finding_kind.value}) "
+        f"at {where}: {finding.message}.{flow} "
+        "Remediate the vulnerability without changing behavior. "
+        "Do NOT modify tests, CI, scanner configuration, or suppressions."
+    )
+
+
+class EnginePatchGenerator:
+    def __init__(
+        self,
+        post: PostFn,
+        *,
+        repository_id: str,
+        snapshot_id: str,
+        model: str = "repository.verified_agentic_v1",
+    ):
+        self._post = post
+        self.repository_id = repository_id
+        self.snapshot_id = snapshot_id
+        self.model = model
+
+    def __call__(self, finding: NormalizedFinding, cwd: str) -> str:
+        resp = self._post(
+            f"/v1/repositories/{self.repository_id}/decision-plan",
+            {
+                "snapshot_id": self.snapshot_id,
+                "model": self.model,
+                "signals": {
+                    "issue_text": finding_issue(finding),
+                    "security_finding": {
+                        "canonical_id": finding.canonical_id,
+                        "rule_id": finding.rule_id,
+                        "finding_kind": finding.finding_kind.value,
+                    },
+                },
+            },
+        )
+        diff = resp.get("patch_diff") or (resp.get("decision_plan") or {}).get("patch_diff")
+        if not diff or not str(diff).strip():
+            raise PatchGenError(f"engine returned no patch for {finding.rule_id} ({finding.canonical_id})")
+        return diff
+
+
+class ClinePatchGenerator:
+    """`patch_generator(finding, cwd) -> diff` backed by the agentic Cline SDK (agent-core).
+
+    This is the self-hosted remediation seam: instead of asking a remote engine for a patch, it
+    drives codna's own vendored coding agent against the worktree. The agent edits files in
+    place; we capture the unified diff, reset the worktree to a clean tree, and return the diff
+    for the caller to subject to the G4 anti-evasion check and then apply. Returning a diff
+    against a clean tree (rather than leaving edits applied) keeps it drop-in compatible with the
+    worker contract used by `run_secure`/`LocalWorker`.
+    """
+
+    def __init__(self, *, model: str | None = None, max_iterations: int = 20, timeout_s: int = 360):
+        self.model = model
+        self.max_iterations = max_iterations
+        self.timeout_s = timeout_s
+
+    def __call__(self, finding: NormalizedFinding, cwd: str) -> str:
+        from .cline_agent import run_cline_fix
+
+        prompt = (
+            finding_issue(finding)
+            + " Edit only the vulnerable source file(s); use REPOSITORY-RELATIVE paths."
+        )
+        run_cline_fix(
+            cwd, prompt, model=self.model,
+            max_iterations=self.max_iterations, timeout_s=self.timeout_s,
+        )
+        diff = subprocess.run(
+            ["git", "-C", cwd, "diff"], capture_output=True, text=True,
+        ).stdout
+        # Reset the worktree so the returned diff is against a clean tree (caller applies it).
+        subprocess.run(["git", "-C", cwd, "checkout", "--", "."], capture_output=True, text=True)
+        if not diff.strip():
+            raise PatchGenError(f"cline agent produced no changes for {finding.rule_id} ({finding.canonical_id})")
+        return diff

codna/policy.py

@@ -0,0 +1,85 @@
+"""Autofix policy — who is eligible for an automated fix PR, and how severity maps.
+
+Encodes gate condition G3 (policy-eligible proof): the default eligible classification is
+`exploitable`; `production-reachable` is eligible ONLY when the policy explicitly opts in
+(an override the operator must record); `unreachable` and `unknown` are NEVER auto-fixed.
+Also carries the scanner-severity overrides `sarif.ingest_sarif` applies, and the set of
+new-finding severities that block a PR (G8).
+
+Pure stdlib, no engine/http. Deterministic `digest` so the policy participates in the
+immutable-provenance binding (G1).
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+from .findings import Classification, Severity, digest_of
+
+# Default new-finding severities that block a PR (G8) and the default eligible set (G3).
+DEFAULT_BLOCK_NEW = (Severity.HIGH, Severity.CRITICAL)
+DEFAULT_AUTOFIX = ("exploitable",)
+
+
+def _as_severity(v) -> Severity:
+    return v if isinstance(v, Severity) else Severity(str(v).strip().lower())
+
+
+@dataclass
+class Policy:
+    autofix_classifications: tuple[str, ...] = DEFAULT_AUTOFIX
+    block_new_severities: tuple[Severity, ...] = DEFAULT_BLOCK_NEW
+    severity_overrides: dict[str, Severity] = field(default_factory=dict)
+    digest: str = ""
+
+    def __post_init__(self):
+        # Normalize, then bind a content digest so the policy can be provenance-pinned (G1).
+        self.autofix_classifications = tuple(
+            c.value if isinstance(c, Classification) else str(c).strip().lower()
+            for c in self.autofix_classifications
+        )
+        self.block_new_severities = tuple(_as_severity(s) for s in self.block_new_severities)
+        self.severity_overrides = {k: _as_severity(v) for k, v in self.severity_overrides.items()}
+        if not self.digest:
+            self.digest = self.compute_digest()
+
+    def compute_digest(self) -> str:
+        return digest_of(
+            {
+                "autofix_classifications": sorted(self.autofix_classifications),
+                "block_new_severities": sorted(s.value for s in self.block_new_severities),
+                "severity_overrides": {k: v.value for k, v in sorted(self.severity_overrides.items())},
+            }
+        )
+
+    @classmethod
+    def from_dict(cls, d: dict | None) -> "Policy":
+        d = d or {}
+        return cls(
+            autofix_classifications=tuple(d.get("autofix_classifications", DEFAULT_AUTOFIX)),
+            block_new_severities=tuple(d.get("block_new_severities", DEFAULT_BLOCK_NEW)),
+            severity_overrides={k: _as_severity(v) for k, v in (d.get("severity_overrides") or {}).items()},
+        )
+
+    # -- G3: which reachability verdicts may receive an automated fix PR --------------
+
+    def is_autofix_eligible(self, classification: "Classification | str") -> tuple[bool, str]:
+        c = classification.value if isinstance(classification, Classification) else str(classification).lower()
+        if c in (Classification.UNREACHABLE.value, Classification.UNKNOWN.value):
+            return False, f"{c} findings are never auto-fixed"
+        if c == Classification.EXPLOITABLE.value:
+            ok = "exploitable" in self.autofix_classifications
+            return ok, "exploitable (policy default)" if ok else "exploitable not in policy autofix set"
+        if c == Classification.PRODUCTION_REACHABLE.value:
+            ok = "production-reachable" in self.autofix_classifications
+            return (
+                ok,
+                "production-reachable allowed by explicit policy override"
+                if ok
+                else "production-reachable requires an explicit policy override",
+            )
+        return False, f"unrecognized classification {classification!r}"
+
+    # -- G8: does a newly-introduced finding's severity block the PR? -----------------
+
+    def blocks_new_severity(self, severity: "Severity | str") -> bool:
+        return _as_severity(severity) in self.block_new_severities

codna/refengine.py

@@ -0,0 +1,132 @@
+"""LocalReferenceEngine — a bounded, self-hostable implementation of the SecurityEngine seam.
+
+This is the in-repo reference engine for offline / air-gapped runs. It is deliberately
+CONSERVATIVE and HONEST: it does NOT perform independent interprocedural taint analysis, so it
+NEVER returns `exploitable` — the strongest verdict it will assert is `production-reachable`
+(the vulnerable operation is callable in production; taint is not independently proven). The
+full independent taint engine that earns `exploitable` lives in `decision-engine`; this
+reference exists so `codna secure` runs end to end without a remote engine and so the
+four-outcome discipline is exercised faithfully:
+
+    validated source->sink (independent)  -> exploitable      (ONLY the real engine; never here)
+    production entrypoint reaches op       -> production-reachable
+    no path + COMPLETE sound envelope      -> unreachable
+    no path + INCOMPLETE/UNSUPPORTED       -> unknown          (never silently 'unreachable')
+
+The support matrix is keyed by (language, framework, build_mode) — "java" is not "java+spring"
+(reflection makes the envelope incomplete). Scanner code-flows are recorded as CORROBORATION,
+never trusted as proof. Closure is a bounded diff heuristic (recognized sanitizer at the sink).
+"""
+from __future__ import annotations
+
+import posixpath
+import re
+from enum import Enum
+from typing import Callable
+
+from .evasion import added_lines, changed_paths
+from .findings import Classification, ClosureStatus, IngestResult, NormalizedFinding
+from .secure import ClosureVerdict, ReachVerdict
+
+
+class Envelope(Enum):
+    COMPLETE = "complete"   # sound enough to assert 'unreachable'
+    BOUNDED = "bounded"     # production-callability only; cannot prove absence
+    UNSUPPORTED = "unsupported"
+
+
+_EXT_LANG = {
+    ".py": "python", ".js": "javascript", ".jsx": "javascript", ".ts": "typescript",
+    ".tsx": "typescript", ".go": "go", ".java": "java", ".rb": "ruby", ".php": "php",
+}
+
+# (language, framework, build_mode) -> envelope completeness. Lookup falls back from most to
+# least specific. Reflection-heavy stacks are intentionally BOUNDED.
+_SUPPORT: dict[tuple, Envelope] = {
+    ("python", None, None): Envelope.COMPLETE,
+    ("javascript", None, None): Envelope.COMPLETE,
+    ("typescript", None, None): Envelope.COMPLETE,
+    ("go", None, None): Envelope.COMPLETE,
+    ("java", None, None): Envelope.COMPLETE,
+    ("java", "spring", None): Envelope.BOUNDED,
+    ("ruby", None, None): Envelope.BOUNDED,
+    ("php", None, None): Envelope.BOUNDED,
+}
+
+_TEST_PATH = re.compile(r"(^|/)(tests?|spec|__tests__)(/|$)|(_test\.|\.test\.|_spec\.)", re.IGNORECASE)
+_SANITIZER = re.compile(
+    r"(parameteri|saniti[sz]e|escape|shlex\.quote|bleach\.clean|html\.escape|quote\(|"
+    r"prepared\s*statement|placeholder|bindparam"
+    # any `.execute(<sql>, (params))` / `(<sql>, [params])` — a bound-parameter query
+    # (greedy across the SQL literal so commas inside it don't break the match)
+    r"|\.execute\(.+,\s*[(\[])",
+    re.IGNORECASE,
+)
+
+
+def _lang(path: str | None) -> str | None:
+    if not path:
+        return None
+    return _EXT_LANG.get(posixpath.splitext(path)[1].lower())
+
+
+def _envelope(lang: str | None, framework: str | None, build_mode: str | None) -> Envelope:
+    if lang is None:
+        return Envelope.UNSUPPORTED
+    for key in ((lang, framework, build_mode), (lang, framework, None), (lang, None, None)):
+        if key in _SUPPORT:
+            return _SUPPORT[key]
+    return Envelope.UNSUPPORTED
+
+
+class LocalReferenceEngine:
+    """SecurityEngine implementation (analyze / reprove_closure). `framework_for` and
+    `build_mode_for` let a deployment refine the envelope per path; both default to None."""
+
+    def __init__(
+        self,
+        *,
+        framework_for: Callable[[str], str | None] | None = None,
+        build_mode_for: Callable[[str], str | None] | None = None,
+    ):
+        self._framework_for = framework_for or (lambda path: None)
+        self._build_mode_for = build_mode_for or (lambda path: None)
+
+    def analyze(self, ingest: IngestResult, finding: NormalizedFinding) -> ReachVerdict:
+        path = finding.primary_location.uri if finding.primary_location else None
+        lang = _lang(path)
+        env = _envelope(lang, self._framework_for(path or ""), self._build_mode_for(path or ""))
+
+        if env is Envelope.UNSUPPORTED:
+            return ReachVerdict(Classification.UNKNOWN, envelope_complete=False,
+                                proof_type=f"off-matrix ({lang or 'unknown-language'})")
+
+        if path and _TEST_PATH.search(path):
+            if env is Envelope.COMPLETE:
+                return ReachVerdict(Classification.UNREACHABLE, envelope_complete=True,
+                                    proof_type="test-only sink; no production entrypoint (complete envelope)")
+            return ReachVerdict(Classification.UNKNOWN, envelope_complete=False,
+                                proof_type="test-only but envelope is bounded")
+
+        if env is Envelope.COMPLETE:
+            # Honest ceiling: production-reachable. 'exploitable' requires the independent
+            # taint engine; scanner code-flows only corroborate.
+            corro = "scanner-flow-corroborated" if finding.code_flows else "production-callability"
+            return ReachVerdict(Classification.PRODUCTION_REACHABLE, envelope_complete=True, proof_type=corro)
+
+        return ReachVerdict(Classification.UNKNOWN, envelope_complete=False,
+                            proof_type="bounded envelope: production-reachability not independently provable")
+
+    def reprove_closure(self, finding: NormalizedFinding, patch) -> ClosureVerdict:
+        diff = getattr(patch, "diff", "") or ""
+        sink = finding.primary_location
+        if not diff.strip() or sink is None:
+            return ClosureVerdict(ClosureStatus.UNKNOWN, alternate_path_found=False, new_blocking_findings=[])
+        touched = {posixpath.normpath(p) for p in changed_paths(diff)}
+        if posixpath.normpath(sink.uri) not in touched:
+            # the sink file wasn't modified -> the obligation cannot be closed
+            return ClosureVerdict(ClosureStatus.OPEN, alternate_path_found=False, new_blocking_findings=[])
+        if any(_SANITIZER.search(line) for line in added_lines(diff)):
+            return ClosureVerdict(ClosureStatus.CLOSED, alternate_path_found=False, new_blocking_findings=[])
+        # sink touched but no recognized barrier added -> conservatively OPEN (e.g. sink moved)
+        return ClosureVerdict(ClosureStatus.OPEN, alternate_path_found=False, new_blocking_findings=[])

codna/repo_backend.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+from typing import Any, Mapping
+
+from .local_client import LocalCodnaRuntimeClient
+
+_GET = "GET"
+_POST = "POST"
+
+
+class CodnaRepositoryBackend:
+    """Algenta local Runtime backend for Codna repository intelligence.
+
+    This backend is intentionally in-process. It does not call Codna's FastAPI
+    router and does not require local Postgres; Algenta repository-intelligence
+    services persist their own local manifests and Arrow/Parquet artifacts.
+    """
+
+    def __init__(self, client: Any | None = None) -> None:
+        self._client = client
+        self._local_client: LocalCodnaRuntimeClient | None = None
+
+    def _local(self) -> LocalCodnaRuntimeClient:
+        if self._local_client is None:
+            self._local_client = LocalCodnaRuntimeClient()
+        return self._local_client
+
+    def _req(self, method: str, path: str, request: Mapping[str, Any] | None = None) -> dict[str, Any]:
+        if self._client is not None:
+            if request is None:
+                return self._client._request(method, path)
+            return self._client._request(method, path, json=dict(request))
+        raise RuntimeError("HTTP compatibility client is not configured.")
+
+    def get_repository_intelligence_capabilities(self) -> dict[str, Any]:
+        if self._client is not None:
+            return self._req(_GET, "/v1/repositories/capabilities")
+        return self._local().get_repository_intelligence_capabilities()
+
+    def create_repository_snapshot(self, repository_id: str, request: Mapping[str, Any]) -> dict[str, Any]:
+        if self._client is not None:
+            return self._req(_POST, f"/v1/repositories/{repository_id}/snapshots", request)
+        return self._local().create_repository_snapshot(repository_id, dict(request))
+
+    def get_repository_snapshot(self, repository_id: str, snapshot_id: str) -> dict[str, Any]:
+        if self._client is not None:
+            return self._req(_GET, f"/v1/repositories/{repository_id}/snapshots/{snapshot_id}")
+        return self._local().get_repository_snapshot(repository_id, snapshot_id)
+
+    def triage_repository(self, repository_id: str, request: Mapping[str, Any]) -> dict[str, Any]:
+        if self._client is not None:
+            return self._req(_POST, f"/v1/repositories/{repository_id}/triage", request)
+        return self._local().triage_repository(repository_id, dict(request))
+
+    def create_repository_decision_plan(self, repository_id: str, request: Mapping[str, Any]) -> dict[str, Any]:
+        if self._client is not None:
+            return self._req(_POST, f"/v1/repositories/{repository_id}/decision-plans", request)
+        return self._local().create_repository_decision_plan(repository_id, dict(request))
+
+    def query_repository_graph(self, repository_id: str, request: Mapping[str, Any]) -> dict[str, Any]:
+        if self._client is not None:
+            return self._req(_POST, f"/v1/repositories/{repository_id}/graph-query", request)
+        return self._local().query_repository_graph(repository_id, dict(request))
+
+    def simulate_repository(self, repository_id: str, request: Mapping[str, Any]) -> dict[str, Any]:
+        if self._client is not None:
+            return self._req(_POST, f"/v1/repositories/{repository_id}/simulate", request)
+        return self._local().simulate_repository(repository_id, dict(request))
+
+    def apply_repository(self, repository_id: str, request: Mapping[str, Any]) -> dict[str, Any]:
+        if self._client is not None:
+            return self._req(_POST, f"/v1/repositories/{repository_id}/apply", request)
+        return self._local().apply_repository(repository_id, dict(request))
+
+
+def build_backend() -> CodnaRepositoryBackend:
+    """Zero-arg factory for ``codna.repo_backend:build_backend``."""
+    return CodnaRepositoryBackend()