codejury 0.21.0__tar.gz → 0.22.0__tar.gz

{codejury-0.21.0 → codejury-0.22.0}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: codejury
-Version: 0.21.0
-Summary: AI code security review for diffs and whole repositories.
+Version: 0.22.0
+Summary: AI code security review for diffs and repos.
 Author: AISecLabs
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/aiseclabs/codejury
@@ -38,25 +38,15 @@ Dynamic: license-file
  ╚═════╝ ╚═════╝ ╚═════╝ ╚══════╝ ╚════╝  ╚═════╝ ╚═╝  ╚═╝   ╚═╝
 ```
 
-> AI code security review for diffs and whole repositories.
+An AI code security review tool. It works two ways. `review diff` audits a pull
+request diff for newly introduced exploitable risk in one command. `review repo`
+sets up an interactive agent such as Claude Code or Codex to audit a whole
+repository, mapping the attack surface, tracing inputs to sinks across files, and
+verifying each issue with a real PoC.
 
-codejury runs two paths matched to their nature.
-
-- **Diff Review** is coded. It audits a pull request diff for newly introduced
-  exploitable risk, as a single balanced LLM call or an adversarial Finder,
-  Challenger, and Judge pass that trades roughly 3x the cost for extra recall on
-  subtle flaws that span files. One command in, findings out.
-- **Repo Review** is agent driven. A whole repository is too large for one LLM
-  call, so codejury scaffolds a workspace and hands an interactive agent such as
-  Claude Code or Codex a methodology to run. The agent maps the attack surface,
-  traces inputs to sinks across files, verifies issues with a real PoC, and
-  iterates over rounds with a persistent memory.
-
-Security knowledge is data, not code. Vulnerability classes live in
-`codejury/data/vulnerabilities/*.md` with a vulnerable and a secure example per
-language, and the stack guides live under `data/languages`, `data/frameworks`,
-and `data/protocols`. The engine stays language neutral and names no framework,
-so adding a stack is a drop-in markdown file.
+Security knowledge is data, not code. Drop-in markdown guides hold the
+vulnerability classes, languages, frameworks, and protocols, so the engine names
+no language and adding a stack is a new file.
 
 ## Install
 
@@ -67,19 +57,21 @@ codejury install-slash-command             # Claude Code, ~/.claude/commands/
 codejury install-slash-command --agent codex   # Codex, ~/.codex/prompts/
 ```
 
-`install-slash-command` copies the `/codejury-review-repo` command into the agent's
-command directory. The command body is the same for every agent, only the
-directory differs, so pass `--dir` for any other agent. The repo review itself is
-agent neutral, so even without the command you can run `codejury review repo` and
-tell any agent to follow the methodology it writes.
+`install-slash-command` copies the `/codejury-review-repo` command into the
+agent's command directory. The command body is the same for every agent, only the
+directory differs, so pass `--dir` for any other agent.
 
 ## Diff Review
 
+The coded engine. It audits a diff in one command, as a single balanced LLM call
+or an adversarial Finder, Challenger, and Judge pass that trades roughly 3x the
+cost for extra recall on subtle flaws that span files.
+
 ```bash
-# audit a diff file
+# a diff file
 codejury review diff --file changes.diff
 
-# audit a git range in a repo
+# a git range in a repo
 codejury review diff --repo /path/to/app --git-range origin/main...HEAD
 
 # from stdin
@@ -97,57 +89,25 @@ the `CODEJURY_API_KEY`, `CODEJURY_MODEL`, and `CODEJURY_API_BASE` environment
 variables. `codejury review diff --dry-run` exercises the engine with a mock
 provider and no key, and falls back to a built in demo diff when you pass none.
 
-### Choosing a Model and Mode
-
-Detection quality is dominated by the model first, then the mode. On real diff
-probes:
-
-- A strong model at the Claude Sonnet tier in standard mode caught every planted
-  vulnerability with almost no false positives. A weaker model raised false
-  positives in both modes, so the model is the lever that matters most.
-- Adversarial mode did not lower false positives over standard on those probes
-  and costs about 3x. Reach for it to gain recall on subtle logic that spans
-  files, not as a way to cut false positives.
-
-Default to standard mode with a strong model, set with `--model` or
-`CODEJURY_MODEL`. False positives are held down by the do not report list and the
-post filter, not by the mode.
-
-### Use in CI with GitHub Actions
-
-Audit every pull request and surface findings in the code scanning tab. Copy
-`examples/codejury-pr-review.yml` into `.github/workflows/`, add a
-`CODEJURY_API_KEY` repository secret, and it will
-
-1. diff the pull request against its base with `--git-range origin/<base>...HEAD`,
-2. write SARIF and upload it with `github/codeql-action/upload-sarif`,
-3. fail the check on a HIGH or CRITICAL finding with `--fail-on high`.
-
-The job makes one model call per pull request in standard mode. The SARIF is
-uploaded even when the gate fails, so findings always show up on the pull
-request.
-
 ## Repo Review
 
-Repo Review does not scan and print findings. It sets up a review for an agent to
-run, because a whole repository needs many rounds of reading, cross-file tracing,
-and PoC work that an agent does, not a single call.
+The agent path. A whole repo is too large for one LLM call, so this sets up a
+review for an interactive agent rather than running a pipeline.
 
 ```bash
 codejury review repo /path/to/your/repo
 ```
 
-This detects the stack, seeds the entrypoint inventory and the downstream trace
+It detects the stack, seeds the entrypoint inventory and the downstream trace
 targets from a deterministic scan, writes the methodology to
-`<workspace>/METHODOLOGY.md`, and prints a short pointer. It creates the
-workspace:
+`<workspace>/METHODOLOGY.md`, and prints a short pointer. The workspace:
 
 ```
 entrypoints/   the candidate entrypoint files to start from
 issues/        one write-up per confirmed or suspected issue
 pocs/          a runnable PoC per issue, same name as the issue
 analysis/      _trace_targets.md, the round ledger, and trace notes
-security-review-memory.md
+METHODOLOGY.md and MEMORY.md
 ```
 
 Then run it with an interactive agent. In Claude Code or Codex:
@@ -157,22 +117,49 @@ Then run it with an interactive agent. In Claude Code or Codex:
 ```
 
 Any agent works, the slash command is just a shortcut. Without it, tell the agent
-to follow the `METHODOLOGY.md` the scaffold wrote.
-
-The agent follows `METHODOLOGY.md`: it maps the attack surface including non HTTP
-sources, traces each input to its sink through the downstream layers, runs an
-Authorization Model pass for missing-auth and IDOR, and follows a control into a
-library when an entrypoint delegates it. It keeps going until a Completeness Gate
-passes, two consecutive rounds that add nothing new. It confirms each issue with
-a real PoC against a sandbox or dev environment and asks you for any credential or
-test data it needs. Only a reproduced PoC is a confirmed finding, and nothing
-runs against production.
+to follow the `METHODOLOGY.md` the scaffold wrote. The agent maps the attack
+surface including non HTTP sources, traces each input to its sink through the
+downstream layers, runs an Authorization Model pass for missing-auth and IDOR,
+and follows a control into a library when an entrypoint delegates it. It iterates
+until a Completeness Gate passes, confirms each issue with a real PoC against a
+sandbox or dev environment, and asks you for any credential it needs. Only a
+reproduced PoC is a confirmed finding, and nothing runs against production.
 
 The supported stacks today are Python with Django, Celery, Flask, and FastAPI,
 Go with Gin and Echo, JavaScript and TypeScript with Express and NestJS, and the
 OAuth and OIDC protocol. The methodology still works on an unguided stack, it just
 leans more on the agent's own knowledge.
 
+## Choosing a Model and Mode
+
+Detection quality is dominated by the model first, then the mode. On real diff
+probes:
+
+- A strong model at the Claude Sonnet tier in standard mode caught every planted
+  vulnerability with almost no false positives. A weaker model raised false
+  positives in both modes, so the model is the lever that matters most.
+- Adversarial mode did not lower false positives over standard on those probes
+  and costs about 3x. Reach for it to gain recall on subtle logic that spans
+  files, not as a way to cut false positives.
+
+Default to standard mode with a strong model, set with `--model` or
+`CODEJURY_MODEL`. False positives are held down by the do not report list and the
+post filter, not by the mode.
+
+## Use in CI with GitHub Actions
+
+Audit every pull request and surface findings in the code scanning tab. Copy
+`examples/codejury-pr-review.yml` into `.github/workflows/`, add a
+`CODEJURY_API_KEY` repository secret, and it will
+
+1. diff the pull request against its base with `--git-range origin/<base>...HEAD`,
+2. write SARIF and upload it with `github/codeql-action/upload-sarif`,
+3. fail the check on a HIGH or CRITICAL finding with `--fail-on high`.
+
+The job makes one model call per pull request in standard mode. The SARIF is
+uploaded even when the gate fails, so findings always show up on the pull
+request.
+
 ## Findings
 
 Each finding carries a file and line, a severity and category, a concrete exploit

{codejury-0.21.0 → codejury-0.22.0}/README.md

@@ -7,25 +7,15 @@
  ╚═════╝ ╚═════╝ ╚═════╝ ╚══════╝ ╚════╝  ╚═════╝ ╚═╝  ╚═╝   ╚═╝
 ```
 
-> AI code security review for diffs and whole repositories.
-
-codejury runs two paths matched to their nature.
-
-- **Diff Review** is coded. It audits a pull request diff for newly introduced
-  exploitable risk, as a single balanced LLM call or an adversarial Finder,
-  Challenger, and Judge pass that trades roughly 3x the cost for extra recall on
-  subtle flaws that span files. One command in, findings out.
-- **Repo Review** is agent driven. A whole repository is too large for one LLM
-  call, so codejury scaffolds a workspace and hands an interactive agent such as
-  Claude Code or Codex a methodology to run. The agent maps the attack surface,
-  traces inputs to sinks across files, verifies issues with a real PoC, and
-  iterates over rounds with a persistent memory.
-
-Security knowledge is data, not code. Vulnerability classes live in
-`codejury/data/vulnerabilities/*.md` with a vulnerable and a secure example per
-language, and the stack guides live under `data/languages`, `data/frameworks`,
-and `data/protocols`. The engine stays language neutral and names no framework,
-so adding a stack is a drop-in markdown file.
+An AI code security review tool. It works two ways. `review diff` audits a pull
+request diff for newly introduced exploitable risk in one command. `review repo`
+sets up an interactive agent such as Claude Code or Codex to audit a whole
+repository, mapping the attack surface, tracing inputs to sinks across files, and
+verifying each issue with a real PoC.
+
+Security knowledge is data, not code. Drop-in markdown guides hold the
+vulnerability classes, languages, frameworks, and protocols, so the engine names
+no language and adding a stack is a new file.
 
 ## Install
 
@@ -36,19 +26,21 @@ codejury install-slash-command             # Claude Code, ~/.claude/commands/
 codejury install-slash-command --agent codex   # Codex, ~/.codex/prompts/
 ```
 
-`install-slash-command` copies the `/codejury-review-repo` command into the agent's
-command directory. The command body is the same for every agent, only the
-directory differs, so pass `--dir` for any other agent. The repo review itself is
-agent neutral, so even without the command you can run `codejury review repo` and
-tell any agent to follow the methodology it writes.
+`install-slash-command` copies the `/codejury-review-repo` command into the
+agent's command directory. The command body is the same for every agent, only the
+directory differs, so pass `--dir` for any other agent.
 
 ## Diff Review
 
+The coded engine. It audits a diff in one command, as a single balanced LLM call
+or an adversarial Finder, Challenger, and Judge pass that trades roughly 3x the
+cost for extra recall on subtle flaws that span files.
+
 ```bash
-# audit a diff file
+# a diff file
 codejury review diff --file changes.diff
 
-# audit a git range in a repo
+# a git range in a repo
 codejury review diff --repo /path/to/app --git-range origin/main...HEAD
 
 # from stdin
@@ -66,57 +58,25 @@ the `CODEJURY_API_KEY`, `CODEJURY_MODEL`, and `CODEJURY_API_BASE` environment
 variables. `codejury review diff --dry-run` exercises the engine with a mock
 provider and no key, and falls back to a built in demo diff when you pass none.
 
-### Choosing a Model and Mode
-
-Detection quality is dominated by the model first, then the mode. On real diff
-probes:
-
-- A strong model at the Claude Sonnet tier in standard mode caught every planted
-  vulnerability with almost no false positives. A weaker model raised false
-  positives in both modes, so the model is the lever that matters most.
-- Adversarial mode did not lower false positives over standard on those probes
-  and costs about 3x. Reach for it to gain recall on subtle logic that spans
-  files, not as a way to cut false positives.
-
-Default to standard mode with a strong model, set with `--model` or
-`CODEJURY_MODEL`. False positives are held down by the do not report list and the
-post filter, not by the mode.
-
-### Use in CI with GitHub Actions
-
-Audit every pull request and surface findings in the code scanning tab. Copy
-`examples/codejury-pr-review.yml` into `.github/workflows/`, add a
-`CODEJURY_API_KEY` repository secret, and it will
-
-1. diff the pull request against its base with `--git-range origin/<base>...HEAD`,
-2. write SARIF and upload it with `github/codeql-action/upload-sarif`,
-3. fail the check on a HIGH or CRITICAL finding with `--fail-on high`.
-
-The job makes one model call per pull request in standard mode. The SARIF is
-uploaded even when the gate fails, so findings always show up on the pull
-request.
-
 ## Repo Review
 
-Repo Review does not scan and print findings. It sets up a review for an agent to
-run, because a whole repository needs many rounds of reading, cross-file tracing,
-and PoC work that an agent does, not a single call.
+The agent path. A whole repo is too large for one LLM call, so this sets up a
+review for an interactive agent rather than running a pipeline.
 
 ```bash
 codejury review repo /path/to/your/repo
 ```
 
-This detects the stack, seeds the entrypoint inventory and the downstream trace
+It detects the stack, seeds the entrypoint inventory and the downstream trace
 targets from a deterministic scan, writes the methodology to
-`<workspace>/METHODOLOGY.md`, and prints a short pointer. It creates the
-workspace:
+`<workspace>/METHODOLOGY.md`, and prints a short pointer. The workspace:
 
 ```
 entrypoints/   the candidate entrypoint files to start from
 issues/        one write-up per confirmed or suspected issue
 pocs/          a runnable PoC per issue, same name as the issue
 analysis/      _trace_targets.md, the round ledger, and trace notes
-security-review-memory.md
+METHODOLOGY.md and MEMORY.md
 ```
 
 Then run it with an interactive agent. In Claude Code or Codex:
@@ -126,22 +86,49 @@ Then run it with an interactive agent. In Claude Code or Codex:
 ```
 
 Any agent works, the slash command is just a shortcut. Without it, tell the agent
-to follow the `METHODOLOGY.md` the scaffold wrote.
-
-The agent follows `METHODOLOGY.md`: it maps the attack surface including non HTTP
-sources, traces each input to its sink through the downstream layers, runs an
-Authorization Model pass for missing-auth and IDOR, and follows a control into a
-library when an entrypoint delegates it. It keeps going until a Completeness Gate
-passes, two consecutive rounds that add nothing new. It confirms each issue with
-a real PoC against a sandbox or dev environment and asks you for any credential or
-test data it needs. Only a reproduced PoC is a confirmed finding, and nothing
-runs against production.
+to follow the `METHODOLOGY.md` the scaffold wrote. The agent maps the attack
+surface including non HTTP sources, traces each input to its sink through the
+downstream layers, runs an Authorization Model pass for missing-auth and IDOR,
+and follows a control into a library when an entrypoint delegates it. It iterates
+until a Completeness Gate passes, confirms each issue with a real PoC against a
+sandbox or dev environment, and asks you for any credential it needs. Only a
+reproduced PoC is a confirmed finding, and nothing runs against production.
 
 The supported stacks today are Python with Django, Celery, Flask, and FastAPI,
 Go with Gin and Echo, JavaScript and TypeScript with Express and NestJS, and the
 OAuth and OIDC protocol. The methodology still works on an unguided stack, it just
 leans more on the agent's own knowledge.
 
+## Choosing a Model and Mode
+
+Detection quality is dominated by the model first, then the mode. On real diff
+probes:
+
+- A strong model at the Claude Sonnet tier in standard mode caught every planted
+  vulnerability with almost no false positives. A weaker model raised false
+  positives in both modes, so the model is the lever that matters most.
+- Adversarial mode did not lower false positives over standard on those probes
+  and costs about 3x. Reach for it to gain recall on subtle logic that spans
+  files, not as a way to cut false positives.
+
+Default to standard mode with a strong model, set with `--model` or
+`CODEJURY_MODEL`. False positives are held down by the do not report list and the
+post filter, not by the mode.
+
+## Use in CI with GitHub Actions
+
+Audit every pull request and surface findings in the code scanning tab. Copy
+`examples/codejury-pr-review.yml` into `.github/workflows/`, add a
+`CODEJURY_API_KEY` repository secret, and it will
+
+1. diff the pull request against its base with `--git-range origin/<base>...HEAD`,
+2. write SARIF and upload it with `github/codeql-action/upload-sarif`,
+3. fail the check on a HIGH or CRITICAL finding with `--fail-on high`.
+
+The job makes one model call per pull request in standard mode. The SARIF is
+uploaded even when the gate fails, so findings always show up on the pull
+request.
+
 ## Findings
 
 Each finding carries a file and line, a severity and category, a concrete exploit

codejury-0.22.0/codejury/__init__.py

@@ -0,0 +1,15 @@
+"""AI code security review tool.
+
+Two paths matched to their nature: a coded diff-audit engine, a standard single
+call or an adversarial Finder/Challenger/Judge pass, and a whole-repo review run
+as a methodology by an interactive agent. Security knowledge lives in rich
+markdown vulnerability classes under data/vulnerabilities, injected into the
+audit prompt, not in a rendered schema.
+"""
+
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    __version__ = version("codejury")
+except PackageNotFoundError:  # running from a source tree without an install
+    __version__ = "0.0.0"

{codejury-0.21.0 → codejury-0.22.0}/codejury/cli.py

@@ -3,10 +3,10 @@
 Two paths matched to their nature:
 
 - ``review diff`` runs the coded diff engine over a unified diff: a single
-  balanced call (standard) or the adversarial Finder/Challenger/Judge pass.
+  balanced call in standard mode or the adversarial Finder/Challenger/Judge pass.
 - ``review repo <dir>`` 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).
+  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.
 
 ``review diff --dry-run`` exercises the engine with a mock provider and no key.
 The audit orchestration itself lives in ``codejury.review.diff.runner``.

{codejury-0.21.0 → codejury-0.22.0}/codejury/data/commands/codejury-review-repo.md

@@ -1,7 +1,7 @@
 ---
 description: Run a codejury whole-repo security review on a repository, interactively
 ---
-Run a codejury whole-repository security review of: $ARGUMENTS
+Run a codejury whole-repo security review of: $ARGUMENTS
 
 1. Scaffold the workspace:
 

{codejury-0.21.0 → codejury-0.22.0}/codejury/data/methodologies/repo-review.md

@@ -1,6 +1,6 @@
 # Repo Security Review: Agent Methodology
 
-The `review repo` path: a whole-repository security audit, run by an interactive
+The `review repo` path: a whole-repo security audit, run by an interactive
 coding agent such as Claude Code or Codex, not a one-shot LLM call. It maps the
 attack surface, traces inputs to sinks across files, verifies issues with a real
 PoC, and iterates over multiple rounds with a persistent memory. One round is
@@ -8,13 +8,13 @@ roughly 30 minutes. Run as many rounds as needed.
 
 Target repository: the directory you were given.
 Workspace: `<workspace>/<project>/`, created for you, holding `entrypoints/`,
-`issues/`, `analysis/`, and `security-review-memory.md`.
+`issues/`, `analysis/`, and `MEMORY.md`.
 
 ---
 
 ## On Start
 
-1. Read `security-review-memory.md` in the workspace if it exists:
+1. Read `MEMORY.md` in the workspace if it exists:
    - skip every pattern under "Confirmed false positives".
    - do not re-report anything under "Fixed".
    - weight the files under "High-risk areas" more heavily.
@@ -226,6 +226,6 @@ If any item fails, run another round. State which items pass when you report.
 
 Report the confirmed findings, the ones with a reproduced PoC, separately from
 the suspected ones still blocked on verification, so the two are never conflated.
-Append a row to the audit history in `security-review-memory.md`, and ask the
+Append a row to the audit history in `MEMORY.md`, and ask the
 operator which findings were false positives. Record those under "Confirmed false
 positives" so future rounds skip them.

{codejury-0.21.0 → codejury-0.22.0}/codejury/domain/__init__.py

@@ -1,5 +1,5 @@
 """The framework's typed data model.
 
 Layers communicate only through these structures. This package depends on no
-concrete implementation (Provider / Source / ...).
+concrete implementation such as a Provider or a Source.
 """

{codejury-0.21.0 → codejury-0.22.0}/codejury/domain/finding.py

@@ -45,7 +45,7 @@ def _to_line(value: object) -> int | None:
 
 def finding_from_dict(data: dict[str, Any]) -> Finding | None:
     """Map one loosely-typed model finding onto a Finding, or None if it has no
-    location (invariant: every finding carries a file)."""
+    location, since every finding carries a file, that is the invariant."""
     if not isinstance(data, dict):
         return None
     file = str(data.get("file", "")).strip()

{codejury-0.21.0 → codejury-0.22.0}/codejury/json_parse.py

@@ -1,12 +1,12 @@
 """Best-effort extraction of a JSON object from model output.
 
 Models often wrap JSON in prose or code fences, and sometimes emit slightly
-malformed JSON (an unescaped quote, a trailing comma, a reply truncated at the
-token limit). This recovers the object: a direct parse, then a fenced ```json
-block, then the first balanced-brace span (string-aware, so braces inside string
-values do not throw off the count), then a json-repair fallback for malformed or
-truncated output. The repair step keeps a single bad character from silently
-dropping an entire findings list.
+malformed JSON, for example an unescaped quote, a trailing comma, or a reply
+truncated at the token limit. This recovers the object: a direct parse, then a
+fenced ```json block, then the first balanced-brace span, which is string-aware
+so braces inside string values do not throw off the count, then a json-repair
+fallback for malformed or truncated output. The repair step keeps a single bad
+character from silently dropping an entire findings list.
 """
 
 from __future__ import annotations
@@ -17,7 +17,7 @@ import re
 _FENCE = re.compile(r"```(?:json)?\s*(\{.*?\})\s*```", re.DOTALL)
 
 # Defensive ceiling: model output is bounded by max_tokens, but never scan an
-# unbounded string (the balanced-brace pass is superlinear on pathological input).
+# unbounded string, the balanced-brace pass is superlinear on pathological input.
 _MAX_SCAN = 1_000_000
 
 
@@ -49,7 +49,7 @@ def extract_json_object(text: str) -> dict | None:
 
 def _first_balanced_object(text: str) -> dict | None:
     """The first complete top-level {...} span, counting braces only outside of
-    string literals so braces inside a value (code in a description, "{x}") do not
+    string literals so braces inside a value, for example code in a description like "{x}", do not
     corrupt the depth count."""
     depth = 0
     start = -1
@@ -85,8 +85,8 @@ def _first_balanced_object(text: str) -> dict | None:
 
 
 def _repair(text: str) -> dict | None:
-    """Last resort: repair malformed or truncated JSON (unescaped quotes, trailing
-    commas, an unterminated reply). Optional dependency, a no-op if absent."""
+    """Last resort: repair malformed or truncated JSON such as unescaped quotes, trailing
+    commas, or an unterminated reply. Optional dependency, a no-op if absent."""
     try:
         from json_repair import repair_json
     except ImportError:

{codejury-0.21.0 → codejury-0.22.0}/codejury/mddoc.py

@@ -1,7 +1,7 @@
 """Shared markdown-doc plumbing: frontmatter parsing and directory loading.
 
-Both the vulnerability classes (`data/vulnerabilities`) and the guides
-(`data/languages`, `data/frameworks`, `data/protocols`) are markdown files with a
+Both the vulnerability classes under `data/vulnerabilities` and the guides under
+`data/languages`, `data/frameworks`, and `data/protocols` are markdown files with a
 YAML frontmatter and a body. This holds only that shared mechanics. Each caller
 builds its own typed record and applies its own selection, since vulnerability
 classes select by trigger text and guides select by detection signals.
@@ -16,7 +16,7 @@ import yaml
 
 
 def parse_frontmatter(text: str) -> tuple[dict, str]:
-    """Return (frontmatter dict, body). A doc with no `---` frontmatter is ({}, text)."""
+    """Return the frontmatter dict and the body. A doc with no `---` frontmatter yields an empty dict and the text."""
     if text.startswith("---"):
         parts = text.split("---", 2)
         if len(parts) == 3:
@@ -26,7 +26,7 @@ def parse_frontmatter(text: str) -> tuple[dict, str]:
 
 
 def iter_md_docs(directory: str | Path) -> Iterator[tuple[Path, dict, str]]:
-    """Yield (path, meta, body) for each `*.md` under `directory`, recursively,
+    """Yield the path, meta, and body for each `*.md` under `directory`, recursively,
     skipping `SKILL.md`. This lets a guide axis group files into subdirectories,
     for example frameworks by language. Yields nothing if the directory does not
     exist. Sorted by path for determinism."""

{codejury-0.21.0 → codejury-0.22.0}/codejury/providers/openai_format.py

@@ -1,7 +1,7 @@
 """Text extraction for the OpenAI chat-completions response shape.
 
 Shared by OpenAIProvider and LiteLLMProvider, since LiteLLM returns the same
-``choices[0].message.content`` structure (a string, or a list of content blocks).
+``choices[0].message.content`` structure, a string or a list of content blocks.
 """
 
 from __future__ import annotations

{codejury-0.21.0 → codejury-0.22.0}/codejury/providers/retry.py

@@ -4,7 +4,7 @@ Real model calls fail intermittently, for example on timeouts or rate limits.
 This decorator retries with linear backoff and re-raises the last error once
 attempts are exhausted. A 200 response with a blank body is treated as a
 transient failure and retried too, since an empty reply is unusable and must
-not be passed downstream as a clean (no-findings) result. ``sleep`` is
+not be passed downstream as a clean no-findings result. ``sleep`` is
 injectable so tests do not actually wait.
 """
 

{codejury-0.21.0 → codejury-0.22.0}/codejury/report.py

@@ -111,7 +111,7 @@ def render(fmt: str, findings: list[Finding]) -> str:
 
 
 def gate(findings: list[Finding], fail_on: str | None) -> bool:
-    """True if any finding is at or above ``fail_on`` (critical|high|medium|low)."""
+    """True if any finding is at or above ``fail_on``, one of critical, high, medium, or low."""
     if not fail_on:
         return False
     threshold = _GATE_RANK.get(fail_on.lower())

{codejury-0.21.0 → codejury-0.22.0}/codejury/resources.py

@@ -8,10 +8,10 @@ from pathlib import Path
 
 _DATA = Path(__file__).resolve().parent / "data"
 
-VULNERABILITIES_DIR = _DATA / "vulnerabilities"  # vulnerability-class definitions (what to find)
-LANGUAGES_DIR = _DATA / "languages"    # per-language review guides (how the target works)
-FRAMEWORKS_DIR = _DATA / "frameworks"  # per-framework review guides (how the target works)
-PROTOCOLS_DIR = _DATA / "protocols"    # protocol guides such as oauth (what to check)
+VULNERABILITIES_DIR = _DATA / "vulnerabilities"  # vulnerability-class definitions, what to find
+LANGUAGES_DIR = _DATA / "languages"    # per-language review guides, how the target works
+FRAMEWORKS_DIR = _DATA / "frameworks"  # per-framework review guides, how the target works
+PROTOCOLS_DIR = _DATA / "protocols"    # protocol guides such as oauth, what to check
 METHODOLOGIES_DIR = _DATA / "methodologies"  # repo-review methodology and memory template
 DETECTION_FILE = _DATA / "detection.yaml"    # file and path classification across ecosystems
 COMMANDS_DIR = _DATA / "commands"            # Claude Code slash commands shipped for install

{codejury-0.21.0 → codejury-0.22.0}/codejury/review/diff/debate.py

@@ -2,7 +2,7 @@
 
 Each round runs the three roles once: the finder scans, the challenger rebuts and
 independently re-scans, the judge cross-validates and keeps the survivors. Rounds
-repeat (feeding the judged set back to the finder) until the confirmed set is
+repeat, feeding the judged set back to the finder, until the confirmed set is
 stable or ``max_rounds`` is hit. Higher coverage and lower false positives than
 the standard single call, at roughly three times the cost.
 """
@@ -65,9 +65,9 @@ def _loc(d: dict) -> str:
 
 
 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
+    """Drop findings the challenger dismissed. The challenger is recall-safe: it
+    dismisses only when the diff shows a safe pattern such as a parameterized query,
+    a basename, an allowlist, or shell=False, so honoring its dismissals is sound even
     when the judge is unavailable."""
     dismissed = {
         str(r.get("target")) for r in rebuttals

{codejury-0.21.0 → codejury-0.22.0}/codejury/review/diff/debate_prompts.py

@@ -1,14 +1,14 @@
 """Adversarial-mode prompts: three roles over the same diff.
 
-- Finder (red team): attacker view, exhaustive, does not self-filter, so misses
+- Finder, the red team: attacker view, exhaustive, does not self-filter, so misses
   are rare.
-- Challenger (blue team): two jobs in one pass: rebut each Finder finding it
+- Challenger, the blue team: two jobs in one pass: rebut each Finder finding it
   believes is a false positive, and independently scan the diff for what Finder
   missed.
 - Judge: cross-validate both independent scans and rule each finding, keeping the
   survivors with calibrated severity.
 
-The shared knowledge (focus areas, do-not-report list) is reused from the
+The shared knowledge, the focus areas and the do-not-report list, is reused from the
 standard prompt so the two modes hunt the same things.
 """