codejury 0.10.4__tar.gz → 0.10.6__tar.gz

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

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

codejury-0.10.6/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.6}/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.6}/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.4 → codejury-0.10.6}/codejury/data/golden/ag_arbitrary_tool_vuln.yaml

@@ -1,4 +1,5 @@
 capability: excessive_agency
+split: held-out
 vulnerable: true
 expected_verdict: VULNERABLE
 cwe: CWE-862

{codejury-0.10.4 → codejury-0.10.6}/codejury/data/golden/authn_sha256_password.yaml

@@ -1,4 +1,5 @@
 capability: authn
+split: held-out
 vulnerable: true
 code: |
   def store_password(pwd: str) -> str:

{codejury-0.10.4 → codejury-0.10.6}/codejury/data/golden/authz_idor_vuln.yaml

@@ -1,4 +1,5 @@
 capability: authz
+split: held-out
 vulnerable: true
 code: |
   def get_invoice(request):

codejury-0.10.6/codejury/data/golden/business_logic_atomic_safe.yaml

@@ -0,0 +1,15 @@
+capability: business_logic
+vulnerable: false
+expected_verdict: SECURE
+cwe: ""
+source: synthetic
+notes: >
+  A single atomic conditional update debits only when the balance suffices, so
+  there is no check-then-act race.
+code: |
+  def withdraw(account, amount):
+      result = db.execute(
+          "UPDATE accounts SET balance = balance - %s WHERE id = %s AND balance >= %s",
+          (amount, account.id, amount),
+      )
+      return result.rowcount == 1

codejury-0.10.6/codejury/data/golden/business_logic_toctou_vuln.yaml

@@ -0,0 +1,14 @@
+capability: business_logic
+vulnerable: true
+expected_verdict: VULNERABLE
+cwe: CWE-367
+source: synthetic
+notes: >
+  The balance is checked and then debited without a lock or atomic update, so two
+  concurrent withdrawals both pass the check and overdraw the account.
+code: |
+  def withdraw(account, amount):
+      if account.balance >= amount:
+          account.balance -= amount
+          return True
+      return False

codejury-0.10.6/codejury/data/golden/crypto_aesgcm_nonce_safe.yaml

@@ -0,0 +1,13 @@
+capability: crypto
+vulnerable: false
+expected_verdict: SECURE
+cwe: ""
+source: synthetic
+split: held-out
+notes: >
+  Authenticated encryption (AES-GCM) with a fresh random nonce per message. No
+  fixed IV, no unauthenticated mode.
+code: |
+  def encrypt(data, key):
+      nonce = os.urandom(12)
+      return nonce + AESGCM(key).encrypt(nonce, data, None)

codejury-0.10.6/codejury/data/golden/crypto_static_iv_vuln.yaml

@@ -0,0 +1,14 @@
+capability: crypto
+vulnerable: true
+expected_verdict: VULNERABLE
+cwe: CWE-329
+source: synthetic
+notes: >
+  A fixed all-zero IV with CBC makes encryption deterministic, so identical
+  plaintexts produce identical ciphertexts and patterns leak. The IV must be
+  random per message.
+code: |
+  def encrypt(data, key):
+      iv = b"\x00" * 16
+      cipher = AES.new(key, AES.MODE_CBC, iv)
+      return cipher.encrypt(pad(data))

codejury-0.10.6/codejury/data/golden/data_protection_cleartext_http_vuln.yaml

@@ -0,0 +1,11 @@
+capability: data_protection
+vulnerable: true
+expected_verdict: VULNERABLE
+cwe: CWE-319
+source: synthetic
+notes: >
+  PII is posted over plaintext http, so it can be read by anyone on the network
+  path. It must travel over TLS.
+code: |
+  def sync(user):
+      requests.post("http://crm.internal/contacts", json={"ssn": user.ssn, "email": user.email})

codejury-0.10.6/codejury/data/golden/data_protection_encrypted_at_rest_safe.yaml

@@ -0,0 +1,11 @@
+capability: data_protection
+vulnerable: false
+expected_verdict: SECURE
+cwe: ""
+source: synthetic
+notes: >
+  The SSN is encrypted before it is stored, so no plaintext PII is persisted.
+code: |
+  def save(user):
+      ciphertext = AESGCM(KEY).encrypt(os.urandom(12), user.ssn.encode(), None)
+      db.store(user.id, ciphertext)

codejury-0.10.6/codejury/data/golden/dependency_config_debug_off_safe.yaml

@@ -0,0 +1,12 @@
+capability: dependency_config
+vulnerable: false
+expected_verdict: SECURE
+cwe: ""
+source: synthetic
+split: held-out
+notes: >
+  An ordinary run with the debugger left at its safe default. A normal app.run
+  must not be flagged.
+code: |
+  def main():
+      app.run(host="127.0.0.1")

codejury-0.10.6/codejury/data/golden/dependency_config_debug_true_vuln.yaml

@@ -0,0 +1,11 @@
+capability: dependency_config
+vulnerable: true
+expected_verdict: VULNERABLE
+cwe: CWE-489
+source: synthetic
+notes: >
+  Running with the debugger enabled in production exposes an interactive console
+  that can execute code on the server.
+code: |
+  def main():
+      app.run(host="0.0.0.0", debug=True)

codejury-0.10.6/codejury/data/golden/error_logging_reraise_safe.yaml

@@ -0,0 +1,15 @@
+capability: error_logging
+vulnerable: false
+expected_verdict: SECURE
+cwe: ""
+source: synthetic
+split: held-out
+notes: >
+  The error is logged and re-raised, so the failure is recorded and not hidden.
+code: |
+  def charge(card):
+      try:
+          gateway.charge(card)
+      except PaymentError:
+          logger.exception("charge failed")
+          raise

codejury-0.10.6/codejury/data/golden/error_logging_swallow_vuln.yaml

@@ -0,0 +1,14 @@
+capability: error_logging
+vulnerable: true
+expected_verdict: VULNERABLE
+cwe: CWE-390
+source: synthetic
+notes: >
+  The bare except discards every error, including security-relevant failures, so
+  a failed charge looks like a success and nothing is logged.
+code: |
+  def charge(card):
+      try:
+          gateway.charge(card)
+      except Exception:
+          pass

{codejury-0.10.4 → codejury-0.10.6}/codejury/data/golden/ioh_exec_output_vuln.yaml

@@ -1,4 +1,5 @@
 capability: insecure_output_handling
+split: held-out
 vulnerable: true
 expected_verdict: VULNERABLE
 cwe: CWE-94

codejury-0.10.6/codejury/data/golden/output_encoding_header_injection_vuln.yaml

@@ -0,0 +1,11 @@
+capability: output_encoding
+vulnerable: true
+expected_verdict: VULNERABLE
+cwe: CWE-113
+source: synthetic
+notes: >
+  User input is concatenated into a response header without stripping CR or LF, so
+  a crafted value can inject extra headers or split the response.
+code: |
+  def download(response, filename):
+      response.headers["Content-Disposition"] = "attachment; filename=" + filename

{codejury-0.10.4 → codejury-0.10.6}/codejury/data/golden/pi_system_concat_vuln.yaml

@@ -1,4 +1,5 @@
 capability: prompt_injection
+split: held-out
 vulnerable: true
 expected_verdict: VULNERABLE
 cwe: CWE-1427

{codejury-0.10.4 → codejury-0.10.6}/codejury/data/golden/sc_trust_remote_code_vuln.yaml

@@ -1,4 +1,5 @@
 capability: model_supply_chain
+split: held-out
 vulnerable: true
 expected_verdict: VULNERABLE
 cwe: CWE-494

codejury-0.10.6/codejury/data/golden/secrets_from_config_safe.yaml

@@ -0,0 +1,12 @@
+capability: secrets
+vulnerable: false
+expected_verdict: SECURE
+cwe: ""
+source: synthetic
+split: held-out
+notes: >
+  The token is read from settings at runtime, not a literal. A variable named
+  token that holds a config lookup must not be flagged.
+code: |
+  def client():
+      return Service(token=settings.API_TOKEN)

codejury-0.10.6/codejury/data/golden/secrets_hardcoded_token_vuln.yaml

@@ -0,0 +1,13 @@
+capability: secrets
+vulnerable: true
+expected_verdict: VULNERABLE
+cwe: CWE-798
+source: synthetic
+notes: >
+  A credential literal committed in source is exposed to everyone with repo
+  access and lives forever in version history. It belongs in the environment.
+code: |
+  API_TOKEN = "9c1185a5c5e9fc54612808977ee8f548b2258d31"
+
+  def client():
+      return Service(token=API_TOKEN)

codejury-0.10.6/codejury/data/golden/session_cookie_flags_safe.yaml

@@ -0,0 +1,10 @@
+capability: session
+vulnerable: false
+expected_verdict: SECURE
+cwe: ""
+source: synthetic
+notes: >
+  The session cookie sets Secure, HttpOnly, and SameSite.
+code: |
+  def set_session(response, sid):
+      response.set_cookie("session", sid, secure=True, httponly=True, samesite="Lax")

codejury-0.10.6/codejury/data/golden/session_insecure_cookie_vuln.yaml

@@ -0,0 +1,11 @@
+capability: session
+vulnerable: true
+expected_verdict: VULNERABLE
+cwe: CWE-614
+source: synthetic
+notes: >
+  The session cookie is set without Secure, HttpOnly, or SameSite, so it is
+  readable by JavaScript and sent over plaintext.
+code: |
+  def set_session(response, sid):
+      response.set_cookie("session", sid)

{codejury-0.10.4 → codejury-0.10.6}/codejury/data/golden/xss_innerhtml_vuln.yaml

@@ -1,4 +1,5 @@
 capability: output_encoding
+split: held-out
 vulnerable: true
 code: |
   function render(name) {

codejury-0.10.6/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.6}/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.6/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.6}/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.6}/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.6}/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.6}/codejury.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codejury
-Version: 0.10.4
+Version: 0.10.6
 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.6}/codejury.egg-info/SOURCES.txt

@@ -56,21 +56,31 @@ codejury/data/golden/authn_sha256_password.yaml
 codejury/data/golden/authn_weak_hash_indirect_vuln.yaml
 codejury/data/golden/authz_idor_vuln.yaml
 codejury/data/golden/authz_owner_safe.yaml
+codejury/data/golden/business_logic_atomic_safe.yaml
 codejury/data/golden/business_logic_price_tamper_vuln.yaml
 codejury/data/golden/business_logic_server_checked_safe.yaml
+codejury/data/golden/business_logic_toctou_vuln.yaml
 codejury/data/golden/cmdi_fixed_argv_safe.yaml
 codejury/data/golden/cmdi_ossystem_vuln.yaml
 codejury/data/golden/cmdi_subprocess_safe.yaml
+codejury/data/golden/crypto_aesgcm_nonce_safe.yaml
 codejury/data/golden/crypto_aesgcm_safe.yaml
 codejury/data/golden/crypto_ecb_vuln.yaml
+codejury/data/golden/crypto_static_iv_vuln.yaml
+codejury/data/golden/data_protection_cleartext_http_vuln.yaml
+codejury/data/golden/data_protection_encrypted_at_rest_safe.yaml
 codejury/data/golden/data_protection_plaintext_pii_vuln.yaml
 codejury/data/golden/data_protection_tokenized_safe.yaml
+codejury/data/golden/dependency_config_debug_off_safe.yaml
+codejury/data/golden/dependency_config_debug_true_vuln.yaml
 codejury/data/golden/dependency_config_tls_verify_off_vuln.yaml
 codejury/data/golden/dependency_config_tls_verify_on_safe.yaml
 codejury/data/golden/deserialize_json_safe.yaml
 codejury/data/golden/deserialize_pickle_vuln.yaml
 codejury/data/golden/error_logging_redacted_safe.yaml
+codejury/data/golden/error_logging_reraise_safe.yaml
 codejury/data/golden/error_logging_secret_leak_vuln.yaml
+codejury/data/golden/error_logging_swallow_vuln.yaml
 codejury/data/golden/ioh_escaped_output_safe.yaml
 codejury/data/golden/ioh_exec_output_vuln.yaml
 codejury/data/golden/ioh_innerhtml_output_vuln.yaml
@@ -78,6 +88,7 @@ codejury/data/golden/ioh_json_response_safe.yaml
 codejury/data/golden/ioh_output_to_sql_vuln.yaml
 codejury/data/golden/ioh_schema_validated_safe.yaml
 codejury/data/golden/literal_eval_safe.yaml
+codejury/data/golden/output_encoding_header_injection_vuln.yaml
 codejury/data/golden/path_basename_safe.yaml
 codejury/data/golden/path_contained_safe.yaml
 codejury/data/golden/path_traversal_vuln.yaml
@@ -92,8 +103,12 @@ codejury/data/golden/sc_safetensors_safe.yaml
 codejury/data/golden/sc_torch_load_vuln.yaml
 codejury/data/golden/sc_trust_remote_code_vuln.yaml
 codejury/data/golden/secrets_env_safe.yaml
+codejury/data/golden/secrets_from_config_safe.yaml
+codejury/data/golden/secrets_hardcoded_token_vuln.yaml
 codejury/data/golden/secrets_hardcoded_vuln.yaml
+codejury/data/golden/session_cookie_flags_safe.yaml
 codejury/data/golden/session_fixation_vuln.yaml
+codejury/data/golden/session_insecure_cookie_vuln.yaml
 codejury/data/golden/session_secure_cookie_safe.yaml
 codejury/data/golden/sql_constant_concat_safe.yaml
 codejury/data/golden/sqli_format_vuln.yaml
@@ -171,6 +186,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.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "codejury"
-version = "0.10.4"
+version = "0.10.6"
 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.6/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) == ""