codejury 0.10.4__tar.gz → 0.10.5__tar.gz

{codejury-0.10.4 → codejury-0.10.5}/PKG-INFO

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

codejury-0.10.5/codejury/analysis/__init__.py

@@ -0,0 +1,8 @@
+"""Static analysis for provenance (P1).
+
+The code-graph / data-flow engine that gives the verifier provenance: whether a
+value reaching a sink is attacker-controlled, sanitized, or a trusted constant.
+It targets the taint precision floor that single-file LLM review cannot reach,
+see ROADMAP P1. Python AST based, currently intra-procedural plus a one-hop
+cross-file caller resolution, not yet a full code graph.
+"""

{codejury-0.10.4 → codejury-0.10.5}/codejury/analysis/taint.py

@@ -130,7 +130,15 @@ def taint_of(
             if func_path and _access_in(func_path, vocab.trusted):
                 return Taint.TRUSTED
             if _callee_in(node, vocab.propagators) or _callee_in(node, vocab.safe_sinks):
-                return _combine([recurse(a) for a in node.args])
+                parts = [recurse(a) for a in node.args]
+                # a method-form propagator carries the receiver's taint too, e.g.
+                # request.args.get("id").strip(). Recurse the receiver when it is a
+                # value (Name/Call/Subscript), not a module path like os.path.join.
+                if isinstance(node.func, ast.Attribute) and isinstance(
+                    node.func.value, (ast.Name, ast.Call, ast.Subscript)
+                ):
+                    parts.append(recurse(node.func.value))
+                return _combine(parts)
             return Taint.UNKNOWN              # unknown call; a cross-file hop may resolve it later
         if isinstance(node, (ast.Attribute, ast.Subscript)):
             path = access_path(node)
@@ -242,17 +250,26 @@ def _call_sites(name: str, files: dict[str, str]) -> list[tuple[ast.AST, ast.Cal
         tree = _parse(source)
         if tree is None:
             continue
-        funcs = [n for n in ast.walk(tree) if isinstance(n, (ast.FunctionDef, ast.AsyncFunctionDef))]
+        scopes = _scope_index(tree)
         for call in find_calls(tree, name):
-            sites.append((_enclosing_scope(funcs, call) or tree, call))
+            sites.append((scopes.get(id(call), tree), call))
     return sites
 
 
-def _enclosing_scope(funcs: list[ast.AST], call: ast.Call) -> ast.AST | None:
-    containing = [f for f in funcs if any(node is call for node in ast.walk(f))]
-    if not containing:
-        return None  # module-level call site
-    return min(containing, key=lambda f: sum(1 for _ in ast.walk(f)))  # innermost
+@functools.lru_cache(maxsize=256)
+def _scope_index(tree: ast.Module) -> dict[int, ast.AST]:
+    """Map id(node) to its innermost enclosing function (or the module tree) in one
+    pass, so a call's scope is an O(1) lookup instead of an O(functions) re-walk."""
+    mapping: dict[int, ast.AST] = {}
+
+    def walk(node: ast.AST, scope: ast.AST) -> None:
+        inner = node if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)) else scope
+        for child in ast.iter_child_nodes(node):
+            mapping[id(child)] = inner
+            walk(child, inner)
+
+    walk(tree, tree)
+    return mapping
 
 
 def worst_sink_taint(content: str, files: dict[str, str], vocab: TaintVocab) -> Taint | None:
@@ -272,7 +289,7 @@ def worst_sink_taint(content: str, files: dict[str, str], vocab: TaintVocab) ->
     tree = _parse(content)
     if tree is None:
         return None
-    funcs = [n for n in ast.walk(tree) if isinstance(n, (ast.FunctionDef, ast.AsyncFunctionDef))]
+    scopes = _scope_index(tree)
     taints: list[Taint] = []
     for call in [n for n in ast.walk(tree) if isinstance(n, ast.Call)]:
         if is_safe_sink(call, vocab):
@@ -280,7 +297,7 @@ def worst_sink_taint(content: str, files: dict[str, str], vocab: TaintVocab) ->
             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
+        scope = scopes.get(id(call), 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.UNKNOWN

{codejury-0.10.4 → codejury-0.10.5}/codejury/cli.py

@@ -290,6 +290,7 @@ def main(argv: list[str] | None = None) -> int:
     run_p.add_argument("--capabilities", default=CAPABILITIES_DIR, help="capability YAML directory")
     run_p.add_argument("--format", choices=_FORMATS, default="text", dest="fmt")
     run_p.add_argument("--no-suppress", action="store_true", help="disable the known-noise suppression filter")
+    run_p.add_argument("--no-cache", action="store_true", help="bypass the verdict cache (always re-query the model)")
     run_p.add_argument("--fail-on", choices=_FAIL_ON, default=None, dest="fail_on", help="exit 1 if a finding at/above this severity is found")
 
     eval_p = sub.add_parser("eval", help="score golden cases and report precision/recall")
@@ -366,7 +367,10 @@ def _dispatch(args, parser) -> int:
             print(f"unknown task {args.task!r}; available: {', '.join(sorted(tasks)) or '(none)'}")
             return 1
         results = run_task(
-            tasks[args.task], DiffSource(_read_diff(args.diff)), load_capabilities(args.capabilities)
+            tasks[args.task],
+            DiffSource(_read_diff(args.diff)),
+            load_capabilities(args.capabilities),
+            cache=None if args.no_cache else VerdictCache(),
         )
         results = _maybe_suppress(results, not args.no_suppress)
         print(_render_results(args.fmt, results))

codejury-0.10.5/codejury/infrastructure/__init__.py

@@ -0,0 +1,4 @@
+"""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.
+"""

{codejury-0.10.4 → codejury-0.10.5}/codejury/infrastructure/cache.py

@@ -22,6 +22,7 @@ from __future__ import annotations
 
 import hashlib
 import json
+import os
 from pathlib import Path
 
 from codejury.domain.artifact import CodeArtifact
@@ -30,6 +31,10 @@ from codejury.domain.result import AnalysisResult
 
 DEFAULT_CACHE_DIR = Path.home() / ".cache" / "codejury" / "verdicts"
 
+# Bump when the cached payload shape changes, so entries written by an older
+# codejury are not read back under a changed schema. It is folded into the key.
+_SCHEMA = "1"
+
 
 def _normalize(code: str) -> str:
     lines = code.replace("\r\n", "\n").replace("\r", "\n").split("\n")
@@ -40,6 +45,7 @@ def verdict_key(
     artifact: CodeArtifact, capabilities: list[Capability], *, orchestration: str
 ) -> str:
     payload = {
+        "schema": _SCHEMA,
         "kind": artifact.kind,
         "path": artifact.path,
         "code": _normalize(artifact.content),
@@ -65,12 +71,20 @@ class VerdictCache:
         path = self._dir / f"{key}.json"
         if not path.exists():
             return None
-        with open(path, encoding="utf-8") as f:
-            return AnalysisResult.from_dict(json.load(f))
+        try:
+            with open(path, encoding="utf-8") as f:
+                return AnalysisResult.from_dict(json.load(f))
+        except (ValueError, OSError):  # corrupt or half-written entry: treat as a miss
+            return None
 
     def put(self, key: str, result: AnalysisResult) -> None:
         if result.error:  # never cache a partial/failed run
             return
         self._dir.mkdir(parents=True, exist_ok=True)
-        with open(self._dir / f"{key}.json", "w", encoding="utf-8") as f:
+        path = self._dir / f"{key}.json"
+        # write to a temp file then atomically rename, so a concurrent reader never
+        # sees a half-written entry
+        tmp = path.with_suffix(f".{os.getpid()}.tmp")
+        with open(tmp, "w", encoding="utf-8") as f:
             json.dump(result.to_dict(), f, ensure_ascii=False)
+        os.replace(tmp, path)

codejury-0.10.5/codejury/orchestrators/__init__.py

@@ -0,0 +1,6 @@
+"""codejury.orchestrators: strategies for running agents over a context.
+
+single, pipeline, debate, reflexion, challenge, taint, and adaptive. The strategy
+is the orchestration axis; a task picks one. Each takes the same agents and
+context and returns an AnalysisResult, so they are interchangeable.
+"""

{codejury-0.10.4 → codejury-0.10.5}/codejury/orchestrators/challenge.py

@@ -38,7 +38,10 @@ class ChallengeOrchestrator(Orchestrator):
         if missing:
             return AnalysisResult(error=f"challenge requires agents: {', '.join(missing)}")
 
-        verdicts = agents["verifier"].run(context)
+        try:
+            verdicts = agents["verifier"].run(context)
+        except Exception as exc:
+            return AnalysisResult(error=f"agent 'verifier' failed: {exc}")
         flagged = [
             v
             for v in verdicts
@@ -49,7 +52,11 @@ class ChallengeOrchestrator(Orchestrator):
         if not flagged:
             return AnalysisResult(observations=verdicts)
 
-        refutations = agents["refuter"].run(dataclasses.replace(context, history=flagged))
+        try:
+            refutations = agents["refuter"].run(dataclasses.replace(context, history=flagged))
+        except Exception as exc:
+            # a refuter failure must not lose the verdicts already produced
+            return AnalysisResult(observations=verdicts, error=f"agent 'refuter' failed: {exc}")
         reasons = {c.target: c.reason for c in refutations if isinstance(c, Concession)}
         # the refuter targets a capability, not an individual verdict; if a capability
         # has more than one flagged verdict the refutation is ambiguous, so leave them

{codejury-0.10.4 → codejury-0.10.5}/codejury/reporting.py

@@ -11,14 +11,13 @@ from __future__ import annotations
 import json
 
 from codejury import __version__ as _tool_version
-from codejury.domain.observation import Observation, is_problem, observation_from_dict
+from codejury.domain.observation import _PROBLEM_STATUSES, Observation, is_problem, observation_from_dict
 from codejury.domain.result import AnalysisResult
 
 Results = list[tuple[str, AnalysisResult]]
 
 _SEVERITY_ORDER = {"CRITICAL": 0, "HIGH": 1, "MEDIUM": 2, "LOW": 3, "INFO": 4}
 _CLEARED = ("SECURE", "NOT_PRESENT")
-_PROBLEM_STATUSES = ("VULNERABLE", "PARTIAL")
 
 # Finding severity -> SARIF result level; VULNERABLE verdict is error, PARTIAL warning.
 _SARIF_LEVEL = {"CRITICAL": "error", "HIGH": "error", "MEDIUM": "warning", "LOW": "note", "INFO": "note"}

{codejury-0.10.4 → codejury-0.10.5}/codejury/tasks/base.py

@@ -15,10 +15,12 @@ from codejury.assembly import (
     DEFAULT_MODEL,
     build_orchestration,
     make_provider,
+    orchestration_descriptor,
     run_over_source,
 )
 from codejury.domain.capability import Capability
 from codejury.domain.result import AnalysisResult
+from codejury.infrastructure.cache import VerdictCache
 from codejury.sources.base import Source
 
 
@@ -57,7 +59,7 @@ class Task:
 
 
 def run_task(
-    task: Task, source: Source, capabilities: list[Capability]
+    task: Task, source: Source, capabilities: list[Capability], *, cache: VerdictCache | None = None
 ) -> list[tuple[str, AnalysisResult]]:
     # api_base may come from the task as a non-secret URL; the key only from the env.
     provider = make_provider(
@@ -69,4 +71,11 @@ def run_task(
     agents, orchestrator = build_orchestration(
         task.orchestrator, provider=provider, model=task.model, max_tokens=task.max_tokens
     )
-    return run_over_source(source, task.select(capabilities), agents, orchestrator)
+    return run_over_source(
+        source,
+        task.select(capabilities),
+        agents,
+        orchestrator,
+        cache=cache,
+        orchestration=orchestration_descriptor(provider, task.orchestrator, task.model, task.max_tokens),
+    )

{codejury-0.10.4 → codejury-0.10.5}/codejury.egg-info/PKG-INFO

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

{codejury-0.10.4 → codejury-0.10.5}/codejury.egg-info/SOURCES.txt

@@ -171,6 +171,7 @@ tests/test_function_source.py
 tests/test_integrations.py
 tests/test_json_parse.py
 tests/test_litellm_provider.py
+tests/test_openai_format.py
 tests/test_openai_provider.py
 tests/test_orchestrator.py
 tests/test_parsing.py

{codejury-0.10.4 → codejury-0.10.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "codejury"
-version = "0.10.4"
+version = "0.10.5"
 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.10.5/tests/test_openai_format.py

@@ -0,0 +1,30 @@
+from types import SimpleNamespace
+
+from codejury.providers.openai_format import choice_text
+
+
+def test_extracts_plain_string_content():
+    resp = SimpleNamespace(choices=[SimpleNamespace(message=SimpleNamespace(content="hello"))])
+    assert choice_text(resp) == "hello"
+
+
+def test_extracts_content_block_list():
+    resp = SimpleNamespace(
+        choices=[SimpleNamespace(message={"content": [{"text": "a"}, {"text": "b"}, "c"]})]
+    )
+    assert choice_text(resp) == "abc"
+
+
+def test_no_choices_returns_empty():
+    assert choice_text(SimpleNamespace(choices=[])) == ""
+    assert choice_text(SimpleNamespace(choices=None)) == ""
+
+
+def test_none_content_returns_empty():
+    resp = SimpleNamespace(choices=[SimpleNamespace(message=SimpleNamespace(content=None))])
+    assert choice_text(resp) == ""
+
+
+def test_dict_message_without_content():
+    resp = SimpleNamespace(choices=[SimpleNamespace(message={})])
+    assert choice_text(resp) == ""

{codejury-0.10.4 → codejury-0.10.5}/tests/test_review_fixes.py

@@ -98,3 +98,29 @@ def test_suppression_rejects_empty_match_any(tmp_path):
     f.write_text("- {id: noop, path_ext: ['.py']}\n")
     with pytest.raises(ValueError):
         load_suppressions(f)
+
+
+def test_challenge_surfaces_verifier_error_not_traceback():
+    # a provider failure in challenge must become AnalysisResult.error, not raise
+    from codejury.domain.artifact import CodeArtifact
+    from codejury.domain.capability import Capability
+    from codejury.domain.context import AnalysisContext
+    from codejury.orchestrators.challenge import ChallengeOrchestrator
+
+    class _Boom:
+        def run(self, ctx):
+            raise RuntimeError("provider down")
+
+    ctx = AnalysisContext(
+        artifact=CodeArtifact(kind="file", path="a.py", content="x"),
+        capabilities=[Capability(id="input_validation", name="iv")],
+    )
+    result = ChallengeOrchestrator().run({"verifier": _Boom(), "refuter": _Boom()}, ctx)
+    assert result.error and "verifier" in result.error
+
+
+def test_cache_get_tolerates_corrupt_entry(tmp_path):
+    from codejury.infrastructure.cache import VerdictCache
+    (tmp_path / "k.json").write_text("{ not valid json")
+    assert VerdictCache(tmp_path).get("k") is None  # treated as a miss, not a crash
+

{codejury-0.10.4 → codejury-0.10.5}/tests/test_taint.py

@@ -121,3 +121,15 @@ 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
+
+
+def test_method_form_propagator_keeps_receiver_taint():
+    # request.args.get("id").strip() must stay EXTERNAL, not collapse to CONSTANT
+    src = "def f(request):\n    return open(request.args.get('id').strip())\n"
+    assert _taint(src, "f", "open") is Taint.EXTERNAL
+
+
+def test_module_function_propagator_not_polluted_by_receiver():
+    # os.path.join's receiver is a module path, not a value; taint comes from the args
+    src = "def f(request):\n    return open(os.path.join(BASE, request.args['p']))\n"
+    assert _taint(src, "f", "open") is Taint.EXTERNAL  # not UNKNOWN from the os.path receiver

codejury-0.10.4/codejury/analysis/__init__.py

@@ -1,7 +0,0 @@
-"""Static analysis for provenance (P1).
-
-The code-graph / data-flow engine that gives the verifier provenance: whether a
-value reaching a sink is attacker-controlled, sanitized, or a trusted constant.
-This is the real fix for the taint precision floor that single-file LLM review
-cannot reach (see ROADMAP P1). Python / AST based to start.
-"""

codejury-0.10.4/codejury/infrastructure/__init__.py

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

codejury-0.10.4/codejury/orchestrators/__init__.py

@@ -1,6 +0,0 @@
-"""codejury.orchestrators: strategies for running agents over a context.
-
-single / debate / pipeline / reflexion. The strategy is the "any orchestration"
-axis; a task picks one. Each takes the same agents and context and returns an
-AnalysisResult, so they are interchangeable.
-"""