codejury 0.9.0__tar.gz → 0.9.1__tar.gz

{codejury-0.9.0 → codejury-0.9.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codejury
-Version: 0.9.0
+Version: 0.9.1
 Summary: General-purpose Application Security AI audit framework -- five-layer architecture, capabilities as first-class data
 Author: AISecLabs
 License-Expression: MIT

{codejury-0.9.0 → codejury-0.9.1}/codejury/agents/verifier.py

@@ -93,16 +93,25 @@ def _build_prompt(path: str, content: str, cap: Capability, context: str = "") -
     )
 
 
-def _anti_pattern_cwes(cap: Capability) -> dict[str, str]:
-    """Map anti_pattern id -> CWE, so a verdict can inherit the CWE it matched."""
+_SEVERITY_RANK = {"CRITICAL": 4, "HIGH": 3, "MEDIUM": 2, "LOW": 1, "INFO": 0}
+
+
+def _anti_pattern_cwes(cap: Capability) -> dict[str, tuple[int, str]]:
+    """Map anti_pattern id -> (severity rank, CWE), so a verdict can inherit the CWE
+    of the most severe anti-pattern it matched (deterministic, not first-seen)."""
     return {
-        p.id: p.cwe
+        p.id: (_SEVERITY_RANK.get(p.severity, 2), p.cwe)
         for sub in cap.sub_capabilities.values()
         for p in sub.anti_patterns
         if p.cwe
     }
 
 
+def _resolve_cwe(matched_anti: list[str], cwe_by_id: dict[str, tuple[int, str]]) -> str:
+    matched = [cwe_by_id[a] for a in matched_anti if a in cwe_by_id]
+    return max(matched, key=lambda rank_cwe: rank_cwe[0])[1] if matched else ""
+
+
 def _parse_verdicts(text: str, cap: Capability) -> list[Verdict]:
     obj = extract_json_object(text)
     if not obj:
@@ -122,7 +131,7 @@ def _parse_verdicts(text: str, cap: Capability) -> list[Verdict]:
                 reasoning=str(v.get("reasoning", "")),
                 matched_correct=str_list(v.get("matched_correct")),
                 matched_anti=matched_anti,
-                cwe=next((cwe_by_id[a] for a in matched_anti if a in cwe_by_id), ""),
+                cwe=_resolve_cwe(matched_anti, cwe_by_id),
                 evidence=to_evidence(v.get("evidence")),
                 confidence=to_float(v.get("confidence"), 0.5),
             )

{codejury-0.9.0 → codejury-0.9.1}/codejury/analysis/taint.py

@@ -21,6 +21,7 @@ PARAM, for the cross-file caller hop (next) to resolve.
 from __future__ import annotations
 
 import ast
+import functools
 from dataclasses import dataclass
 from enum import Enum
 from pathlib import Path
@@ -133,6 +134,12 @@ def _walk(func, expr, vocab, assigns, params, seen, resolve) -> Taint:
             return Taint.SANITIZED            # a sanitizer cleans its result regardless of input
         if _callee_in(expr, vocab.sources):
             return Taint.EXTERNAL             # e.g. input()
+        # a method ON a source/trusted object, e.g. request.args.get("id") or os.environ.get("X")
+        func_path = access_path(expr.func)
+        if func_path and _access_in(func_path, vocab.sources):
+            return Taint.EXTERNAL
+        if func_path and _access_in(func_path, vocab.trusted):
+            return Taint.TRUSTED
         if _callee_in(expr, vocab.propagators) or _callee_in(expr, vocab.safe_sinks):
             return _combine([w(a) for a in expr.args] or [Taint.CONSTANT])
         return Taint.UNKNOWN                  # unknown call -- a cross-file hop may resolve it later
@@ -197,10 +204,11 @@ def taint_in_repo(
 
 
 def _caller_resolver(func, files, vocab):
+    sites = _call_sites(func.name, files)  # computed once, reused across parameters
     def resolve(param_name: str) -> Taint:
         index = _param_index(func, param_name)
         results = []
-        for scope, call in _call_sites(func.name, files):
+        for scope, call in sites:
             arg = _arg_for_param(call, index, param_name)
             # one hop only: classify the caller's argument without recursing further
             results.append(taint_of(scope, arg, vocab) if arg is not None else Taint.UNKNOWN)
@@ -210,6 +218,8 @@ def _caller_resolver(func, files, vocab):
 
 def _param_index(func, name: str) -> int | None:
     positional = [*func.args.posonlyargs, *func.args.args]
+    if positional and positional[0].arg in ("self", "cls"):
+        positional = positional[1:]  # bound-method call sites omit the receiver
     for i, arg in enumerate(positional):
         if arg.arg == name:
             return i
@@ -225,12 +235,21 @@ def _arg_for_param(call: ast.Call, index: int | None, name: str) -> ast.AST | No
     return None
 
 
+@functools.lru_cache(maxsize=256)
+def _parse(source: str) -> ast.Module | None:
+    """Parse a source string once and cache it (the same files are walked repeatedly
+    during cross-file resolution); None if it does not parse."""
+    try:
+        return ast.parse(source)
+    except SyntaxError:
+        return None
+
+
 def _call_sites(name: str, files: dict[str, str]) -> list[tuple[ast.AST, ast.Call]]:
     sites = []
     for source in files.values():
-        try:
-            tree = ast.parse(source)
-        except SyntaxError:
+        tree = _parse(source)
+        if tree is None:
             continue
         funcs = [n for n in ast.walk(tree) if isinstance(n, (ast.FunctionDef, ast.AsyncFunctionDef))]
         for call in find_calls(tree, name):
@@ -250,24 +269,27 @@ def worst_sink_taint(content: str, files: dict[str, str], vocab: TaintVocab) ->
 
     A "potential sink" is any call that is not a safe sink, sanitizer, or
     propagator (those are not where injection happens). Each such call's argument
-    taint is classified with the cross-file resolver, and the worst is returned.
-    ``Taint.CONSTANT`` when there is no sink to worry about; ``None`` when the
-    code does not parse (the caller should then not act).
-
-    Used by the taint gate to downgrade an input_validation finding only when the
-    whole artifact is provably clean -- so a single tainted sink keeps every
-    finding (recall preserved).
+    taint is classified with the cross-file resolver. A safe sink that consumes
+    tainted data (e.g. ``json.loads(request.data)``) contributes SANITIZED -- the
+    data was handled safely. The worst contribution is returned.
+
+    ``Taint.UNKNOWN`` when no inspectable sink is found (the artifact may still be
+    unsafe via a return value or an implicit sink, so it is NOT assumed clean);
+    ``None`` when the code does not parse. The taint gate downgrades a finding only
+    on a SAFE result, so an unproven artifact keeps its findings (recall preserved).
     """
-    try:
-        tree = ast.parse(content)
-    except SyntaxError:
+    tree = _parse(content)
+    if tree is None:
         return None
     funcs = [n for n in ast.walk(tree) if isinstance(n, (ast.FunctionDef, ast.AsyncFunctionDef))]
     taints: list[Taint] = []
     for call in [n for n in ast.walk(tree) if isinstance(n, ast.Call)]:
-        if is_safe_sink(call, vocab) or _callee_in(call, vocab.sanitizers) or _callee_in(call, vocab.propagators):
-            continue  # not a place an injection lands
+        if is_safe_sink(call, vocab):
+            taints.append(Taint.SANITIZED)  # tainted data consumed by a safe parser
+            continue
+        if _callee_in(call, vocab.sanitizers) or _callee_in(call, vocab.propagators):
+            continue  # not a sink itself; counted via the enclosing sink's argument
         scope = _enclosing_scope(funcs, call) or tree
         for arg in (*call.args, *(kw.value for kw in call.keywords)):
             taints.append(taint_in_repo(scope, arg, vocab, files))
-    return _combine(taints) if taints else Taint.CONSTANT
+    return _combine(taints) if taints else Taint.UNKNOWN

{codejury-0.9.0 → codejury-0.9.1}/codejury/assembly.py

@@ -79,9 +79,15 @@ def build_orchestration(
     return verifier, SingleOrchestrator()
 
 
-def orchestration_descriptor(strategy: str, model: str, max_tokens: int) -> str:
+def provider_tag(provider: Provider) -> str:
+    """A stable short name for a provider (unwrapping RetryProvider) for cache keys,
+    so two providers that accept the same model string do not share cached verdicts."""
+    return type(getattr(provider, "_inner", provider)).__name__
+
+
+def orchestration_descriptor(provider: Provider, strategy: str, model: str, max_tokens: int) -> str:
     """The non-code, non-capability inputs that affect a verdict, as a cache tag."""
-    return f"{strategy}|{model}|{max_tokens}"
+    return f"{provider_tag(provider)}|{strategy}|{model}|{max_tokens}"
 
 
 def run_over_artifacts(

{codejury-0.9.0 → codejury-0.9.1}/codejury/cli.py

@@ -79,7 +79,7 @@ def audit(
     agents, orchestrator = build_orchestration(strategy, provider=provider, model=model, max_tokens=max_tokens)
     return run_over_source(
         DiffSource(diff_text), capabilities, agents, orchestrator,
-        cache=cache, orchestration=orchestration_descriptor(strategy, model, max_tokens),
+        cache=cache, orchestration=orchestration_descriptor(provider, strategy, model, max_tokens),
     )
 
 
@@ -114,7 +114,7 @@ def scan(
     agents, orchestrator = build_orchestration(strategy, provider=provider, model=model, max_tokens=max_tokens)
     return run_over_artifacts(
         artifacts, capabilities, agents, orchestrator,
-        cache=cache, orchestration=orchestration_descriptor(strategy, model, max_tokens),
+        cache=cache, orchestration=orchestration_descriptor(provider, strategy, model, max_tokens),
     )
 
 

{codejury-0.9.0 → codejury-0.9.1}/codejury/evaluation.py

@@ -159,8 +159,19 @@ def evaluate(
             capabilities=[capability],
         )
         result = orchestrator.run(agents, ctx)
-        if result.error:  # e.g. a provider auth failure -- surface it, don't score blanks
-            raise RuntimeError(result.error)
-        predicted = any(getattr(o, "status", None) == "VULNERABLE" for o in result.observations)
+        if result.error:  # e.g. a provider auth failure -- surface it (with the case), don't score blanks
+            raise RuntimeError(f"case {case.name!r}: {result.error}")
+        predicted = _predicted_vulnerable(result.observations)
         report.record(case.capability, actual=case.vulnerable, predicted=predicted)
     return report
+
+
+def _predicted_vulnerable(observations: list) -> bool:
+    """Did the run flag a problem? A Finding (debate/reflexion) or a VULNERABLE
+    Verdict (single/pipeline/taint) counts; SECURE verdicts and dismissed
+    concessions do not. (A bare Finding has no ``status``, so checking only
+    status would score debate/reflexion as zero recall.)"""
+    return any(
+        o.kind == "finding" or (o.kind == "verdict" and getattr(o, "status", None) == "VULNERABLE")
+        for o in observations
+    )

{codejury-0.9.0 → codejury-0.9.1}/codejury/orchestrators/taint_gate.py

@@ -58,7 +58,7 @@ class TaintGateOrchestrator(Orchestrator):
         for v in verdicts:
             if (
                 isinstance(v, Verdict)
-                and v.status in ("VULNERABLE", "PARTIAL")
+                and v.status == "VULNERABLE"  # leave PARTIAL ("incomplete validation") signal intact
                 and v.capability.split(".")[0] in self._taint_capabilities
             ):
                 observations.append(

{codejury-0.9.0 → codejury-0.9.1}/codejury/reporting.py

@@ -9,8 +9,8 @@ dismissed.
 from __future__ import annotations
 
 import json
-from importlib.metadata import PackageNotFoundError, version
 
+from codejury import __version__ as _tool_version
 from codejury.domain.observation import Observation, observation_from_dict
 from codejury.domain.result import AnalysisResult
 
@@ -24,13 +24,6 @@ _PROBLEM_STATUSES = ("VULNERABLE", "PARTIAL")
 _SARIF_LEVEL = {"CRITICAL": "error", "HIGH": "error", "MEDIUM": "warning", "LOW": "note", "INFO": "note"}
 
 
-def _tool_version() -> str:
-    try:
-        return version("codejury")
-    except PackageNotFoundError:
-        return "0"
-
-
 def to_json(results: Results) -> str:
     payload = {
         "files": [
@@ -183,7 +176,7 @@ def to_sarif(results: Results) -> str:
                     "driver": {
                         "name": "codejury",
                         "informationUri": "https://github.com/aiseclabs/codejury",
-                        "version": _tool_version(),
+                        "version": _tool_version,
                         "rules": rules,
                     }
                 },

{codejury-0.9.0 → codejury-0.9.1}/codejury.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codejury
-Version: 0.9.0
+Version: 0.9.1
 Summary: General-purpose Application Security AI audit framework -- five-layer architecture, capabilities as first-class data
 Author: AISecLabs
 License-Expression: MIT

{codejury-0.9.0 → codejury-0.9.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "codejury"
-version = "0.9.0"
+version = "0.9.1"
 description = "General-purpose Application Security AI audit framework -- five-layer architecture, capabilities as first-class data"
 readme = "README.md"
 requires-python = ">=3.12"

{codejury-0.9.0 → codejury-0.9.1}/tests/test_assembly.py

@@ -2,7 +2,14 @@ from types import SimpleNamespace
 
 import pytest
 
-from codejury.assembly import build_orchestration, make_provider, run_over_source
+from codejury.assembly import (
+    build_orchestration,
+    make_provider,
+    orchestration_descriptor,
+    provider_tag,
+    run_over_source,
+)
+from codejury.providers.retry import RetryProvider
 from codejury.domain.capability import Capability
 from codejury.orchestrators.debate import DebateOrchestrator
 from codejury.orchestrators.pipeline import PipelineOrchestrator
@@ -42,6 +49,18 @@ def test_make_provider_forwards_api_base_and_key():
     assert captured["api_key"] == "sk-test"
 
 
+def test_cache_descriptor_includes_provider():
+    # two providers accepting the same model string must not share a cache key
+    a = orchestration_descriptor(MockProvider(), "single", "gpt-4o", 8)
+    b = orchestration_descriptor(make_provider("openai"), "single", "gpt-4o", 8)
+    assert a != b
+
+
+def test_provider_tag_unwraps_retry():
+    assert provider_tag(MockProvider()) == "MockProvider"
+    assert provider_tag(RetryProvider(MockProvider())) == "MockProvider"
+
+
 def test_run_over_source_runs_each_artifact():
     provider = MockProvider(default='{"verdicts": [{"sub_capability": "x", "status": "SECURE"}]}')
     agents, orchestrator = build_orchestration("single", provider=provider, model="m", max_tokens=8)

{codejury-0.9.0 → codejury-0.9.1}/tests/test_evaluation.py

@@ -155,6 +155,17 @@ def test_evaluate_taint_strategy_gates_constant_sink():
     assert taint.overall.fp == 0 and taint.overall.tn == 1  # gate cleared it
 
 
+def test_predicted_counts_finding_not_just_verdict():
+    # debate/reflexion emit Findings (no .status); they must count as a prediction,
+    # else eval --orchestrator debate scores recall 0.
+    from codejury.domain.observation import Concession, Finding, Verdict
+    from codejury.evaluation import _predicted_vulnerable
+    assert _predicted_vulnerable([Finding(capability="x", title="t")]) is True
+    assert _predicted_vulnerable([Verdict(capability="x", status="VULNERABLE")]) is True
+    assert _predicted_vulnerable([Verdict(capability="x", status="SECURE")]) is False
+    assert _predicted_vulnerable([Concession(capability="x", target="t")]) is False
+
+
 def test_eval_cli_reports_provider_error_without_traceback(monkeypatch, capsys):
     class _Boom(Provider):
         def complete(self, **kwargs):

{codejury-0.9.0 → codejury-0.9.1}/tests/test_taint.py

@@ -1,7 +1,7 @@
 import ast
 
 from codejury.analysis.provenance import find_calls, parse_function
-from codejury.analysis.taint import SAFE, Taint, is_safe_sink, load_vocab, taint_of
+from codejury.analysis.taint import SAFE, Taint, is_safe_sink, load_vocab, taint_of, worst_sink_taint
 
 VOCAB = load_vocab()  # the shipped codejury/data/taint.yaml
 
@@ -95,3 +95,29 @@ def test_is_safe_sink_matches_json_and_literal_eval_not_pickle():
 def test_safe_set_membership():
     assert Taint.CONSTANT in SAFE and Taint.SANITIZED in SAFE and Taint.TRUSTED in SAFE
     assert Taint.EXTERNAL not in SAFE and Taint.UNKNOWN not in SAFE and Taint.PARAM not in SAFE
+
+
+def test_source_method_call_is_external():
+    # request.args.get("id") -- a method ON a source object -- must be EXTERNAL, not UNKNOWN
+    src = "def f(request):\n    return request.args.get('id')\n"
+    func = parse_function(src, "f")
+    call = find_calls(func, "get")[0]
+    assert taint_of(func, call, VOCAB) is Taint.EXTERNAL
+
+
+def test_trusted_method_call_is_trusted():
+    src = "def f():\n    return os.environ.get('X')\n"
+    func = parse_function(src, "f")
+    assert taint_of(func, find_calls(func, "get")[0], VOCAB) is Taint.TRUSTED
+
+
+def test_worst_sink_taint_unknown_when_no_sink_call():
+    # tainted data escapes via return with no call sink -> NOT provably safe (UNKNOWN)
+    code = "def q(request):\n    sql = 'SELECT ' + request.args['id']\n    return sql\n"
+    assert worst_sink_taint(code, {"m.py": code}, VOCAB) is Taint.UNKNOWN
+
+
+def test_worst_sink_taint_safe_sink_only_is_sanitized():
+    # a safe parser consuming external data is provably safe
+    code = "def f(request):\n    return ast.literal_eval(request.data)\n"
+    assert worst_sink_taint(code, {"m.py": code}, VOCAB) is Taint.SANITIZED

{codejury-0.9.0 → codejury-0.9.1}/tests/test_taint_crossfile.py

@@ -57,6 +57,16 @@ def test_module_level_caller_resolves():
     assert _sink_arg_taint(caller) is Taint.EXTERNAL
 
 
+def test_method_call_site_resolves():
+    # serve is a method (has self); a bound call site obj.serve(evil) omits self,
+    # so the parameter index must skip self or the caller arg is never matched.
+    method = "class S:\n    def serve(self, name):\n        return open(os.path.join(STATIC_DIR, name)).read()\n"
+    caller = "def view(request):\n    return s.serve(request.args['name'])\n"
+    func = parse_function(method, "serve")
+    open_call = find_calls(func, "open")[0]
+    assert taint_in_repo(func, open_call.args[0], VOCAB, {"m.py": method, "h.py": caller}) is Taint.EXTERNAL
+
+
 def test_multiple_callers_combine_to_worst():
     caller = (
         "def a(request):\n"

{codejury-0.9.0 → codejury-0.9.1}/tests/test_taint_gate.py

@@ -87,3 +87,20 @@ def test_unknown_call_is_not_cleared():
     # a value from an unknown function is not provably safe -> keep the finding.
     src = "def f(request):\n    return run_query(helper(request.args['q']))\n"
     assert _statuses(_run(src)) == ["VULNERABLE"]
+
+
+def test_tainted_value_without_call_sink_is_kept():
+    # tainted SQL string escapes via return with no call sink -> must NOT be cleared
+    src = "def q(request):\n    sql = 'SELECT * FROM t WHERE id=' + request.args['id']\n    return sql\n"
+    assert _statuses(_run(src)) == ["VULNERABLE"]
+
+
+def test_partial_verdict_is_not_downgraded():
+    # the gate downgrades only VULNERABLE; PARTIAL ("incomplete validation") is kept
+    partial = json.dumps({"verdicts": [{"sub_capability": "x", "status": "PARTIAL"}]})
+    agents = {"verifier": VerifierAgent(provider=MockProvider(default=partial), model="m")}
+    ctx = AnalysisContext(
+        artifact=CodeArtifact(kind="file", path="m.py", content="def q():\n    cursor.execute('SELECT 1')\n"),
+        capabilities=[Capability(id="input_validation", name="input_validation")],
+    )
+    assert _statuses(TaintGateOrchestrator().run(agents, ctx)) == ["PARTIAL"]