codejury 0.14.1__tar.gz → 0.14.3__tar.gz

{codejury-0.14.1 → codejury-0.14.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codejury
-Version: 0.14.1
+Version: 0.14.3
 Summary: AI code security review: an adversarial diff-audit engine and an agent-driven whole-repo review methodology, with security knowledge as rich rules
 Author: AISecLabs
 License-Expression: MIT

{codejury-0.14.1 → codejury-0.14.3}/codejury/cli.py

@@ -1,14 +1,15 @@
-"""codejury CLI.
+"""codejury CLI: thin argument parsing and dispatch.
 
-Two entry points matched to their nature:
+Two paths matched to their nature:
 
-- ``audit`` runs the coded diff engine over a unified diff: a single balanced
-  call (standard) or the adversarial Finder/Challenger/Judge pass.
-- ``full-review`` scaffolds a workspace and prints the methodology for an
+- ``review diff`` runs the coded diff engine over a unified diff: a single
+  balanced call (standard) or the adversarial Finder/Challenger/Judge pass.
+- ``review repo`` scaffolds a workspace and prints the methodology for an
   interactive agent to run a whole-repo review (it does not run an LLM pipeline,
   which a single call cannot do for a whole codebase).
 
-``dry-run`` exercises the diff engine with a mock provider and no API key.
+``review diff --dry-run`` exercises the engine with a mock provider and no key.
+The audit orchestration itself lives in ``codejury.diff.runner``.
 """
 
 from __future__ import annotations
@@ -17,20 +18,9 @@ import argparse
 import subprocess
 import sys
 
-import dataclasses
-
 from codejury import __version__
-from codejury.diff.debate import AdversarialAuditRunner
-from codejury.diff.engine import AuditRunner
-from codejury.diff.findings_filter import FindingsFilter
-from codejury.diff.report import gate, render
-from codejury.diff.rules import allowed_categories, normalize_category
-from codejury.domain.finding import Finding
-
-# A diff larger than this is audited file-by-file so a big PR does not overflow
-# the model's context and silently truncate the reply.
-_MAX_DIFF_CHARS = 60_000
-from codejury.repo.scaffold import scaffold
+from codejury.report import gate, render
+from codejury.diff.runner import audit_diff
 from codejury.providers.factory import (
     DEFAULT_API_BASE,
     DEFAULT_API_KEY,
@@ -42,75 +32,12 @@ from codejury.providers.factory import (
     make_provider,
 )
 from codejury.providers.mock import MockProvider
+from codejury.repo.scaffold import scaffold
 
 _FORMATS = ("text", "markdown", "json", "sarif")
 _FAIL_ON = ("critical", "high", "medium", "low")
 
 
-def _split_diff_by_file(diff: str) -> list[str]:
-    """Split a unified diff into one diff per file (`diff --git ...` boundaries)."""
-    chunks: list[str] = []
-    cur: list[str] = []
-    for line in diff.splitlines(keepends=True):
-        if line.startswith("diff --git ") and cur:
-            chunks.append("".join(cur))
-            cur = []
-        cur.append(line)
-    if cur:
-        chunks.append("".join(cur))
-    return chunks or ([diff] if diff.strip() else [])
-
-
-def _dedup_findings(findings: list[Finding]) -> list[Finding]:
-    seen: set = set()
-    out: list[Finding] = []
-    for f in findings:
-        k = (f.file, f.line, f.category, f.description)
-        if k not in seen:
-            seen.add(k)
-            out.append(f)
-    return out
-
-
-def audit_diff(
-    diff: str,
-    *,
-    provider,
-    model: str,
-    mode: str = "standard",
-    max_rounds: int = 3,
-    filter_findings: bool = True,
-    finder_model: str | None = None,
-    challenger_model: str | None = None,
-    judge_model: str | None = None,
-    exclude_paths: tuple[str, ...] = (),
-) -> tuple[list[Finding], list[tuple[Finding, str]]]:
-    """Audit a diff and return (kept findings, dropped (finding, reason)).
-
-    A diff over the size budget is audited one file at a time so it does not
-    overflow the context. Finding categories are normalized to the rule-id set.
-    ``exclude_paths`` are operator-supplied path substrings to drop."""
-    def _run_one(d: str) -> list[Finding]:
-        if mode == "adversarial":
-            return AdversarialAuditRunner(
-                provider=provider, model=model,
-                finder_model=finder_model, challenger_model=challenger_model, judge_model=judge_model,
-            ).run(d, max_rounds=max_rounds).findings
-        return AuditRunner(provider=provider, model=model).run(d)
-
-    if len(diff) > _MAX_DIFF_CHARS:
-        chunks = _split_diff_by_file(diff)
-        findings = _dedup_findings([f for c in chunks for f in _run_one(c)])
-    else:
-        findings = _run_one(diff)
-
-    allowed = set(allowed_categories())
-    findings = [dataclasses.replace(f, category=normalize_category(f.category, allowed)) for f in findings]
-    if filter_findings:
-        return FindingsFilter(exclude_paths=exclude_paths).filter(findings)
-    return findings, []
-
-
 def _read_diff(args) -> str:
     if args.diff_file:
         with open(args.diff_file, encoding="utf-8") as f:

{codejury-0.14.1 → codejury-0.14.3}/codejury/diff/debate.py

@@ -21,7 +21,7 @@ from codejury.diff.debate_prompts import (
 )
 from codejury.diff.rules import rules_for_diff
 from codejury.domain.finding import Finding, findings_from_list
-from codejury.infrastructure.json_parse import extract_json_object
+from codejury.json_parse import extract_json_object
 from codejury.providers.base import Message, Provider
 
 
@@ -56,6 +56,28 @@ def _dedup(items: list[dict]) -> list[dict]:
     return out
 
 
+_DISMISS_VERDICTS = frozenset({"dismiss", "dismissed", "false_positive", "reject", "rejected"})
+
+
+def _loc(d: dict) -> str:
+    line = d.get("line")
+    return f"{d.get('file')}:{line}" if line else str(d.get("file") or "")
+
+
+def _apply_dismissals(findings: list[dict], rebuttals: list[dict]) -> list[dict]:
+    """Drop findings the challenger dismissed. The challenger is recall-safe (it
+    dismisses only when the diff shows a safe pattern: a parameterized query,
+    basename, an allowlist, shell=False), so honoring its dismissals is sound even
+    when the judge is unavailable."""
+    dismissed = {
+        str(r.get("target")) for r in rebuttals
+        if str(r.get("verdict", "")).strip().lower() in _DISMISS_VERDICTS
+    }
+    if not dismissed:
+        return findings
+    return [f for f in findings if _loc(f) not in dismissed and str(f.get("file") or "") not in dismissed]
+
+
 class AdversarialAuditRunner:
     def __init__(
         self,
@@ -116,16 +138,19 @@ class AdversarialAuditRunner:
             rebuttals = _dicts(challenger.get("rebuttals"))
             new_findings = _dicts(challenger.get("new_findings"))
 
-            verdict, judge_ok = self._ask(
-                JUDGE_SYSTEM,
-                judge_prompt(diff, finder_findings, rebuttals, new_findings, context=context),
-                self._judge_model,
-            )
+            jp = judge_prompt(diff, finder_findings, rebuttals, new_findings, context=context)
+            verdict, judge_ok = self._ask(JUDGE_SYSTEM, jp, self._judge_model)
+            if not judge_ok:
+                # the judge is the filter that controls false positives, and an
+                # unusable reply is often transient (a flaky proxy, a blocked
+                # request); re-ask once before giving up on it
+                verdict, judge_ok = self._ask(JUDGE_SYSTEM, jp, self._judge_model)
             if not judge_ok:
-                # the judge reply was unusable (provider error, blocked request,
-                # prose): do not let that silently drop the candidate findings;
-                # fall back to the unjudged finder + challenger set, flagged degraded
-                fallback = _dedup(finder_findings + new_findings)
+                # judge still unusable: degrade, but apply the recall-safe
+                # challenger's dismissals so a transient judge outage does not pass
+                # through findings the challenger already showed are safe (this is
+                # what otherwise inflates false positives in degraded runs)
+                fallback = _dedup(_apply_dismissals(finder_findings, rebuttals) + new_findings)
                 judged = AdversarialResult(findings=findings_from_list(fallback), rounds=rounds, degraded=True)
                 degraded = True
                 break

{codejury-0.14.1 → codejury-0.14.3}/codejury/diff/engine.py

@@ -10,7 +10,7 @@ from __future__ import annotations
 from codejury.domain.finding import Finding, findings_from_list
 from codejury.diff.prompts import SYSTEM, standard_audit_prompt
 from codejury.diff.rules import rules_for_diff
-from codejury.infrastructure.json_parse import extract_json_object
+from codejury.json_parse import extract_json_object
 from codejury.providers.base import Message, Provider
 
 

codejury-0.14.3/codejury/diff/runner.py

@@ -0,0 +1,85 @@
+"""Diff-audit orchestration: run a diff through the engine and clean the result.
+
+The library entry point behind `review diff`. Picks the standard or adversarial
+engine, audits a large diff one file at a time so a big PR does not overflow the
+model context, normalizes finding categories onto the rule-id set, and applies
+the false-positive filter. Kept out of the CLI so it can be called as a library.
+"""
+
+from __future__ import annotations
+
+import dataclasses
+
+from codejury.diff.debate import AdversarialAuditRunner
+from codejury.diff.engine import AuditRunner
+from codejury.diff.findings_filter import FindingsFilter
+from codejury.diff.rules import allowed_categories, normalize_category
+from codejury.domain.finding import Finding
+
+# A diff larger than this is audited file-by-file so a big PR does not overflow
+# the model's context and silently truncate the reply.
+_MAX_DIFF_CHARS = 60_000
+
+
+def split_diff_by_file(diff: str) -> list[str]:
+    """Split a unified diff into one diff per file (`diff --git ...` boundaries)."""
+    chunks: list[str] = []
+    cur: list[str] = []
+    for line in diff.splitlines(keepends=True):
+        if line.startswith("diff --git ") and cur:
+            chunks.append("".join(cur))
+            cur = []
+        cur.append(line)
+    if cur:
+        chunks.append("".join(cur))
+    return chunks or ([diff] if diff.strip() else [])
+
+
+def dedup_findings(findings: list[Finding]) -> list[Finding]:
+    seen: set = set()
+    out: list[Finding] = []
+    for f in findings:
+        k = (f.file, f.line, f.category, f.description)
+        if k not in seen:
+            seen.add(k)
+            out.append(f)
+    return out
+
+
+def audit_diff(
+    diff: str,
+    *,
+    provider,
+    model: str,
+    mode: str = "standard",
+    max_rounds: int = 3,
+    filter_findings: bool = True,
+    finder_model: str | None = None,
+    challenger_model: str | None = None,
+    judge_model: str | None = None,
+    exclude_paths: tuple[str, ...] = (),
+) -> tuple[list[Finding], list[tuple[Finding, str]]]:
+    """Audit a diff and return (kept findings, dropped (finding, reason)).
+
+    A diff over the size budget is audited one file at a time so it does not
+    overflow the context. Finding categories are normalized to the rule-id set.
+    ``exclude_paths`` are operator-supplied path substrings to drop."""
+    def _run_one(d: str) -> list[Finding]:
+        if mode == "adversarial":
+            return AdversarialAuditRunner(
+                provider=provider, model=model,
+                finder_model=finder_model, challenger_model=challenger_model, judge_model=judge_model,
+            ).run(d, max_rounds=max_rounds).findings
+        return AuditRunner(provider=provider, model=model).run(d)
+
+    if len(diff) > _MAX_DIFF_CHARS:
+        chunks = split_diff_by_file(diff)
+        findings = dedup_findings([f for c in chunks for f in _run_one(c)])
+    else:
+        findings = _run_one(diff)
+
+    allowed = set(allowed_categories())
+    findings = [dataclasses.replace(f, category=normalize_category(f.category, allowed)) for f in findings]
+    if filter_findings:
+        return FindingsFilter(exclude_paths=exclude_paths).filter(findings)
+    return findings, []

{codejury-0.14.1 → codejury-0.14.3}/codejury.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codejury
-Version: 0.14.1
+Version: 0.14.3
 Summary: AI code security review: an adversarial diff-audit engine and an agent-driven whole-repo review methodology, with security knowledge as rich rules
 Author: AISecLabs
 License-Expression: MIT

{codejury-0.14.1 → codejury-0.14.3}/codejury.egg-info/SOURCES.txt

@@ -3,6 +3,8 @@ README.md
 pyproject.toml
 codejury/__init__.py
 codejury/cli.py
+codejury/json_parse.py
+codejury/report.py
 codejury/resources.py
 codejury.egg-info/PKG-INFO
 codejury.egg-info/SOURCES.txt
@@ -45,12 +47,10 @@ codejury/diff/debate_prompts.py
 codejury/diff/engine.py
 codejury/diff/findings_filter.py
 codejury/diff/prompts.py
-codejury/diff/report.py
 codejury/diff/rules.py
+codejury/diff/runner.py
 codejury/domain/__init__.py
 codejury/domain/finding.py
-codejury/infrastructure/__init__.py
-codejury/infrastructure/json_parse.py
 codejury/providers/__init__.py
 codejury/providers/anthropic.py
 codejury/providers/base.py
@@ -67,12 +67,12 @@ tests/test_anthropic_provider.py
 tests/test_cli_audit.py
 tests/test_diff_debate.py
 tests/test_diff_engine.py
-tests/test_diff_report.py
 tests/test_json_parse.py
 tests/test_litellm_provider.py
 tests/test_openai_format.py
 tests/test_openai_provider.py
 tests/test_repo_model.py
 tests/test_repo_scaffold.py
+tests/test_report.py
 tests/test_retry_provider.py
 tests/test_rules.py

{codejury-0.14.1 → codejury-0.14.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "codejury"
-version = "0.14.1"
+version = "0.14.3"
 description = "AI code security review: an adversarial diff-audit engine and an agent-driven whole-repo review methodology, with security knowledge as rich rules"
 readme = "README.md"
 requires-python = ">=3.12"

{codejury-0.14.1 → codejury-0.14.3}/tests/test_cli_audit.py

@@ -1,4 +1,4 @@
-"""CLI audit_diff helpers: large-diff chunking and finding de-duplication.
+"""Diff-audit orchestration (codejury.diff.runner) plus the thin CLI surface.
 
 A diff over the size budget is split per file and audited one file at a time so a
 big PR does not overflow the model context and silently truncate the reply; the
@@ -7,7 +7,8 @@ per-file findings are then de-duplicated.
 
 import pytest
 
-from codejury.cli import _dedup_findings, _split_diff_by_file, audit_diff, main
+from codejury.cli import main
+from codejury.diff.runner import audit_diff, dedup_findings, split_diff_by_file
 from codejury.domain.finding import Finding
 from codejury.providers.mock import MockProvider
 
@@ -16,14 +17,14 @@ _FILE_B = "diff --git a/b.py b/b.py\n@@ -0,0 +1 @@\n+y = 2\n"
 
 
 def test_split_diff_by_file():
-    chunks = _split_diff_by_file(_FILE_A + _FILE_B)
+    chunks = split_diff_by_file(_FILE_A + _FILE_B)
     assert chunks == [_FILE_A, _FILE_B]
 
 
 def test_split_diff_empty_and_unbounded():
-    assert _split_diff_by_file("") == []
+    assert split_diff_by_file("") == []
     # a fragment with no `diff --git` boundary is returned as one chunk
-    assert _split_diff_by_file("just text\n") == ["just text\n"]
+    assert split_diff_by_file("just text\n") == ["just text\n"]
 
 
 def test_dedup_findings_collapses_identical():
@@ -31,12 +32,12 @@ def test_dedup_findings_collapses_identical():
                 description="d", confidence=0.9)
     g = Finding(file="a.py", line=2, severity="HIGH", category="sql-injection",
                 description="d", confidence=0.9)
-    assert _dedup_findings([f, f, g]) == [f, g]
+    assert dedup_findings([f, f, g]) == [f, g]
 
 
 def test_large_diff_is_audited_per_file(monkeypatch):
     # force the chunking path on a small diff
-    monkeypatch.setattr("codejury.cli._MAX_DIFF_CHARS", 1)
+    monkeypatch.setattr("codejury.diff.runner._MAX_DIFF_CHARS", 1)
     resp = ('{"findings": [{"file": "a.py", "line": 1, "severity": "HIGH", '
             '"category": "sql_injection", "description": "x", "confidence": 0.9}]}')
     provider = MockProvider(default=resp)

{codejury-0.14.1 → codejury-0.14.3}/tests/test_diff_debate.py

@@ -156,6 +156,29 @@ def test_provider_exception_degrades_rather_than_crashes():
     assert out.degraded is True
 
 
+def test_judge_retry_recovers_from_a_transient_unusable_reply():
+    # the judge's first reply is unusable, the retry succeeds: not degraded,
+    # and the judge verdict is applied normally
+    _, out = _run([_finder([_VULN]), _challenger(), "blocked by waf", _judge([_VULN])], max_rounds=1)
+    assert out.degraded is False
+    assert [f.category for f in out.findings] == ["sql_injection"]
+
+
+def test_degraded_fallback_drops_challenger_dismissed_findings():
+    # judge stays unusable (both the call and its retry); the degraded fallback
+    # must still honor the challenger's recall-safe dismissals rather than pass
+    # every finder finding through, which is what inflates false positives
+    second = {**_VULN, "line": 5, "category": "xss"}
+    _, out = _run(
+        [_finder([_VULN, second]),
+         _challenger(rebuttals=[{"target": "app.py:5", "verdict": "dismiss", "reason": "output is escaped"}]),
+         "blocked", "blocked"],   # judge call + its one retry both unusable
+        max_rounds=1,
+    )
+    assert out.degraded is True
+    assert [f.category for f in out.findings] == ["sql_injection"]   # the dismissed xss at app.py:5 is dropped
+
+
 def test_per_role_models_are_used():
     provider = MockProvider(responses=[_finder([]), _challenger(), _judge([])], default="{}")
     AdversarialAuditRunner(

{codejury-0.14.1 → codejury-0.14.3}/tests/test_json_parse.py

@@ -1,6 +1,6 @@
 import pytest
 
-from codejury.infrastructure.json_parse import extract_json_object
+from codejury.json_parse import extract_json_object
 
 
 def test_direct_object():

codejury-0.14.1/tests/test_diff_report.py → codejury-0.14.3/tests/test_report.py

@@ -5,7 +5,7 @@ from pathlib import Path
 
 import jsonschema
 
-from codejury.diff.report import (
+from codejury.report import (
     gate,
     render,
     severity_breakdown,

codejury-0.14.1/codejury/infrastructure/__init__.py

@@ -1,4 +0,0 @@
-"""codejury.infrastructure: Layer 1 cross-cutting utilities, json parsing and the verdict cache.
-
-Lowest layer: depends on nothing else in codejury, used by the layers above.
-"""