codejury 0.14.0__tar.gz → 0.14.2__tar.gz

{codejury-0.14.0 → codejury-0.14.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codejury
-Version: 0.14.0
+Version: 0.14.2
 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.0 → codejury-0.14.2}/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.fullreview.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.0 → codejury-0.14.2}/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
 
 

{codejury-0.14.0 → codejury-0.14.2}/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.2/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.0/codejury/fullreview → codejury-0.14.2/codejury/repo}/scaffold.py

@@ -1,10 +1,11 @@
-"""Full-review scaffold: set up the agent's workspace, do not run a pipeline.
+"""Whole-repo review scaffold: set up the agent's workspace, do not run a pipeline.
 
-Whole-repo review is too large for a single LLM call, so codejury does not run it
-as a pipeline. Instead it scaffolds a workspace for an interactive agent (Claude
-Code, Codex) and hands over the methodology: it creates the api/issues/analysis
-directories, copies the review-memory template, seeds the API inventory from a
-deterministic RepoModel scan, and returns the methodology text to print.
+The `review repo` path. Whole-repo review is too large for a single LLM call, so
+codejury does not run it as a pipeline. Instead it scaffolds a workspace for an
+interactive agent (Claude Code, Codex) and hands over the methodology: it creates
+the api/issues/analysis directories, copies the review-memory template, seeds the
+API inventory from a deterministic RepoModel scan, and returns the methodology
+text to print.
 """
 
 from __future__ import annotations
@@ -12,7 +13,7 @@ from __future__ import annotations
 from dataclasses import dataclass, field
 from pathlib import Path
 
-from codejury.analysis.repo_model import build_repo_model_from_dir
+from codejury.repo.model import build_repo_model_from_dir
 from codejury.resources import AGENT_DIR
 
 _METHODOLOGY = AGENT_DIR / "full-review.md"

{codejury-0.14.0 → codejury-0.14.2}/codejury.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codejury
-Version: 0.14.0
+Version: 0.14.2
 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.0 → codejury-0.14.2}/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
@@ -10,8 +12,6 @@ codejury.egg-info/dependency_links.txt
 codejury.egg-info/entry_points.txt
 codejury.egg-info/requires.txt
 codejury.egg-info/top_level.txt
-codejury/analysis/__init__.py
-codejury/analysis/repo_model.py
 codejury/data/entrypoints.yaml
 codejury/data/agent/full-review.md
 codejury/data/agent/security-review-memory.md
@@ -47,14 +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/fullreview/__init__.py
-codejury/fullreview/scaffold.py
-codejury/infrastructure/__init__.py
-codejury/infrastructure/json_parse.py
 codejury/providers/__init__.py
 codejury/providers/anthropic.py
 codejury/providers/base.py
@@ -64,16 +60,19 @@ codejury/providers/mock.py
 codejury/providers/openai.py
 codejury/providers/openai_format.py
 codejury/providers/retry.py
+codejury/repo/__init__.py
+codejury/repo/model.py
+codejury/repo/scaffold.py
 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_full_review_scaffold.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.0 → codejury-0.14.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "codejury"
-version = "0.14.0"
+version = "0.14.2"
 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.0 → codejury-0.14.2}/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.0 → codejury-0.14.2}/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.0 → codejury-0.14.2}/tests/test_repo_model.py

@@ -1,6 +1,6 @@
 """P6-01: the RepoModel entrypoint detection is deterministic and data-driven."""
 
-from codejury.analysis.repo_model import (
+from codejury.repo.model import (
     Entrypoint,
     build_repo_model,
     build_repo_model_from_dir,

codejury-0.14.0/tests/test_full_review_scaffold.py → codejury-0.14.2/tests/test_repo_scaffold.py

@@ -2,7 +2,7 @@
 analysis + memory + seeded entrypoints) and returns the methodology. It does not
 run an LLM pipeline."""
 
-from codejury.fullreview.scaffold import scaffold
+from codejury.repo.scaffold import scaffold
 
 APP = '''
 from flask import Flask

codejury-0.14.0/tests/test_diff_report.py → codejury-0.14.2/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.0/codejury/analysis/__init__.py

@@ -1,8 +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.
-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.14.0/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.
-"""