codejury 0.22.0__tar.gz → 0.23.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codejury
-Version: 0.22.0
+Version: 0.23.0
 Summary: AI code security review for diffs and repos.
 Author: AISecLabs
 License-Expression: MIT

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

@@ -98,7 +98,9 @@ def main(argv: list[str] | None = None) -> int:
     _add_audit_args(rsub.add_parser("diff", help="audit a unified diff (the coded engine)"))
     repo = rsub.add_parser("repo", help="scaffold a whole-repo review for an interactive agent")
     repo.add_argument("directory", help="target repository to review")
-    repo.add_argument("--workspace", default="codejury-review", help="where to create the review workspace")
+    repo.add_argument("--workspace", default="/var/tmp/codejury-review", help="where to create the review workspace")
+    repo.add_argument("--fresh", action="store_true",
+                      help="clear a previous review's output in the workspace first, MEMORY.md included")
 
     inst = sub.add_parser("install-slash-command",
                           help="install the /codejury-review-repo slash command for an agent")
@@ -137,8 +139,13 @@ def _dispatch(args, parser) -> int:
         return 1 if gate(kept, args.fail_on) else 0
 
     if args.command == "review" and scope == "repo":
-        res = scaffold(args.directory, args.workspace)
+        res = scaffold(args.directory, args.workspace, fresh=args.fresh)
         (Path(res.workspace) / "METHODOLOGY.md").write_text(res.methodology, encoding="utf-8")
+        if res.cleared:
+            print(f"Cleared {len(res.cleared)} prior-run paths in {res.workspace}, MEMORY.md included", file=sys.stderr)
+        elif res.had_prior_run:
+            print(f"A previous review's output is in {res.workspace}. Re-run with --fresh to clear it "
+                  "first, MEMORY.md included.", file=sys.stderr)
         print(f"Workspace ready: {res.workspace}", file=sys.stderr)
         if res.guides:
             print(f"Detected stack: {', '.join(res.guides)}, notes in {res.workspace}/_stack.md", file=sys.stderr)

codejury-0.23.0/codejury/data/commands/codejury-review-repo.md

@@ -0,0 +1,42 @@
+---
+description: Run a codejury whole-repo security review on a repository, interactively
+---
+Run a codejury whole-repo security review of: $ARGUMENTS
+
+1. Scaffold the workspace:
+
+   ```
+   codejury review repo $ARGUMENTS --workspace /var/tmp/codejury-review
+   ```
+
+   If `codejury` is not on PATH it is a pip-installed console script, so activate
+   the project venv first, for example `. .venv/bin/activate`, or run it through
+   that venv's Python, for example `python -m codejury`.
+
+   If the output reports that a previous review's output is already in the
+   workspace, ask me whether to clear it and start fresh. If I say yes, re-run the
+   same command with `--fresh`, which clears the prior issues, PoCs, round ledger,
+   and MEMORY.md for a clean slate. If I say no, continue and build on what is
+   there.
+
+2. Read `<workspace>/METHODOLOGY.md` and follow it to completion. It is the single
+   source of truth for how to run the review, the entrypoint map, the trace
+   targets, the Authorization Model pass, the dependency-control checks, the round
+   ledger, and the Completeness Gate. Do not improvise a different process.
+
+   Run every round to the Completeness Gate on your own. Do not pause between
+   rounds to ask whether to continue, do not stop early because a round felt
+   productive, and do not report the review done until the gate passes. The only
+   reasons to stop and ask me are in step 3.
+
+3. Verify each issue with a real PoC, human in the loop. Stop and ask me only for
+   what the PoC genuinely needs: a credential, a test account, an MFA step, or
+   go-ahead before a destructive action. Never touch production, never use real
+   credentials, and never run a destructive action without my go-ahead. Only a
+   reproduced PoC is a confirmed finding, so keep reviewing while a PoC is blocked
+   on me rather than waiting.
+
+4. Report confirmed findings, the ones with a reproduced PoC, separately from
+   suspected ones still blocked on verification, as a table: title, class,
+   `file:line`, exploit, verification status. The issue files live in the
+   workspace `issues/`.

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

@@ -136,6 +136,40 @@ third-party. It is not auditing the library for its own bugs, which belongs to
 that library's own review. It is confirming that the control your endpoint relies
 on holds here.
 
+## Challenge Every Control, Presence Is Not Sufficiency
+
+A control being present is not the same as the control holding. The most common
+way a real review misses a real flaw is clearing a path the moment it sees a
+gate, a signature, or a single-use token, without asking whether that control
+actually defeats the specific attack. For every control you find on a path, do
+not clear on presence. Challenge it on these axes:
+
+- **Replay**. A signed or authenticated privileged request is replayable unless
+  the control BOTH consumes a one-time nonce AND enforces a freshness window such
+  as a timestamp or short expiry. That the caller is authenticated, that the
+  scheme fails closed, or that a TOTP is single-use is orthogonal to replay, so
+  do not let any of them clear it. Capture one valid signed request and ask: can
+  the exact same bytes be sent again and accepted? If nothing is consumed and no
+  window is checked, it replays.
+- **Concurrency and state**. A check-then-act is bypassable under concurrent
+  requests unless a lock is held across the act, even when the single-request
+  path looks single-use. A redeem, a balance debit, or a status transition that
+  reads then writes without a row lock or atomic guard double-spends under a race.
+- **Sibling coverage**. A gate on one endpoint does not cover its siblings. When
+  you find a missing-authorization or IDOR pattern, enumerate every endpoint
+  behind the same controller or gate and report the highest-impact instance, not
+  the first one you saw. A read variant flagged MEDIUM often has a create or push
+  sibling that is HIGH.
+- **Trusted-source assumptions**. A value is not safe just because a caller you
+  treat as trusted set it. If that caller is a distinct tenant or service, the
+  value is still attacker-influenced. A self-set `callback_url` that flows into a
+  server-side fetch is SSRF or a worker-blocking DoS unless there is an allowlist,
+  so do not clear it on "the owner set it".
+
+When a control passes one axis, it can still fail another, so run all four before
+you mark a path cleared. Record which axis you checked, not just that a control
+exists.
+
 ## Scope
 
 Report only HIGH / CRITICAL, exploitable, high-confidence issues. **Do not report**
@@ -205,6 +239,12 @@ from the inventory, trace it through the downstream layers, and log the round in
 bugs. The hard classes such as authorization, replay, and broken business state
 usually appear only after several rounds, so keep going.
 
+Run the rounds to the Completeness Gate on your own. Do not pause between rounds
+to ask whether to continue, and do not stop early because a round was productive.
+The one place to stop and ask the operator is PoC verification, when a PoC needs a
+credential, test data, or go-ahead for a destructive action. While a PoC is
+blocked on the operator, keep reviewing other sources rather than waiting.
+
 ## Completeness Gate
 
 Do not report the review complete until all of the following hold. A short run
@@ -217,6 +257,10 @@ reporting it as clean is the failure this gate exists to prevent.
   at the view.
 - The Authorization Model pass ran: the access gate is mapped, sibling endpoints
   compared, and IDOR and unauthenticated privileged paths checked.
+- Every control on a cleared path was challenged for sufficiency, not presence:
+  replay needs a nonce and a freshness window, check-then-act needs a lock,
+  sibling endpoints behind a shared gate were all enumerated, and a trusted-source
+  value flowing to a sink was still treated as attacker-influenced.
 - `analysis/_rounds.md` shows two consecutive rounds that added no new source, no
   new traced path, and no new issue.
 

{codejury-0.22.0 → codejury-0.23.0}/codejury/review/repo/scaffold.py

@@ -10,6 +10,7 @@ the methodology text to print.
 
 from __future__ import annotations
 
+import shutil
 from dataclasses import dataclass, field
 from pathlib import Path
 
@@ -41,6 +42,8 @@ class ScaffoldResult:
     trace_targets: tuple[str, ...] = ()     # downstream logic-layer files to trace into
     guides: tuple[str, ...] = ()
     created: list[str] = field(default_factory=list)
+    had_prior_run: bool = False             # the workspace already held a previous review's output
+    cleared: list[str] = field(default_factory=list)  # paths removed by a fresh run, MEMORY.md included
 
 
 def _read_manifests(target: Path) -> str:
@@ -146,10 +149,48 @@ clean one.
 """
 
 
-def scaffold(target: str | Path, workspace: str | Path) -> ScaffoldResult:
+def _has_prior_run(ws: Path) -> bool:
+    """True when the workspace already holds a previous review's output, not just
+    a bare scaffold. Findings, PoCs, a logged round ledger, or a hand-built
+    entrypoint inventory all count. The regenerated seeds alone do not."""
+    if not ws.exists():
+        return False
+    for sub in ("issues", "pocs"):
+        d = ws / sub
+        if d.is_dir() and any(d.iterdir()):
+            return True
+    rounds = ws / "analysis" / "_rounds.md"
+    if rounds.exists() and rounds.read_text(encoding="utf-8") != _ROUNDS_TEMPLATE:
+        return True
+    inv = ws / "entrypoints"
+    if inv.is_dir() and any(p.name != "_entrypoints.md" for p in inv.iterdir()):
+        return True
+    return False
+
+
+def _clear_prior_run(ws: Path) -> list[str]:
+    """Remove a previous review's output so a fresh run starts clean. This wipes
+    MEMORY.md too, so the cross-run memory of confirmed false positives and fixed
+    issues is reset, the run starts from a blank slate with no stale judgments
+    suppressing a finding."""
+    removed: list[str] = []
+    for child in ws.iterdir():
+        if child.is_dir():
+            shutil.rmtree(child)
+        else:
+            child.unlink()
+        removed.append(str(child))
+    return removed
+
+
+def scaffold(target: str | Path, workspace: str | Path, *, fresh: bool = False) -> ScaffoldResult:
     target = Path(target).resolve()
     project = target.name
     ws = Path(workspace) / project
+    had_prior_run = _has_prior_run(ws)
+    cleared: list[str] = []
+    if fresh and ws.exists():
+        cleared = _clear_prior_run(ws)
     created: list[str] = []
     for sub in ("entrypoints", "issues", "pocs", "analysis"):
         d = ws / sub
@@ -201,4 +242,6 @@ def scaffold(target: str | Path, workspace: str | Path) -> ScaffoldResult:
         trace_targets=tuple(layers),
         guides=tuple(g.id for g in guides),
         created=created,
+        had_prior_run=had_prior_run,
+        cleared=cleared,
     )

{codejury-0.22.0 → codejury-0.23.0}/codejury.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codejury
-Version: 0.22.0
+Version: 0.23.0
 Summary: AI code security review for diffs and repos.
 Author: AISecLabs
 License-Expression: MIT

{codejury-0.22.0 → codejury-0.23.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "codejury"
-version = "0.22.0"
+version = "0.23.0"
 description = "AI code security review for diffs and repos."
 readme = "README.md"
 requires-python = ">=3.12"

{codejury-0.22.0 → codejury-0.23.0}/tests/test_repo_scaffold.py

@@ -136,6 +136,36 @@ def test_scaffold_does_not_clobber_existing_memory(tmp_path):
     assert str(second.memory_path) not in second.created  # not recreated
 
 
+def test_scaffold_flags_a_prior_run(tmp_path):
+    target = _target(tmp_path)
+    ws_root = tmp_path / "work"
+    first = scaffold(target, ws_root)
+    assert first.had_prior_run is False  # a bare first scaffold is not a prior run
+
+    (first.workspace / "issues" / "found.md").write_text("# a finding\n")
+    second = scaffold(target, ws_root)
+    assert second.had_prior_run is True
+    assert second.cleared == []  # not cleared without fresh
+    assert (second.workspace / "issues" / "found.md").is_file()  # left intact
+
+
+def test_scaffold_fresh_clears_prior_output_including_memory(tmp_path):
+    target = _target(tmp_path)
+    ws_root = tmp_path / "work"
+    first = scaffold(target, ws_root)
+    (first.workspace / "issues" / "found.md").write_text("# a finding\n")
+    (first.workspace / "pocs" / "found.py").write_text("print('poc')\n")
+    first.memory_path.write_text("# edited memory\nFP-001 ...\n")
+
+    fresh = scaffold(target, ws_root, fresh=True)
+    assert fresh.had_prior_run is True
+    assert fresh.cleared  # something was removed
+    assert not (fresh.workspace / "issues" / "found.md").exists()  # stale finding gone
+    assert not (fresh.workspace / "pocs" / "found.py").exists()
+    assert "# edited memory" not in fresh.memory_path.read_text()  # MEMORY.md reset to template
+    assert (fresh.workspace / "entrypoints" / "_entrypoints.md").is_file()  # reseeded
+
+
 def test_plain_repo_still_scaffolds(tmp_path):
     d = tmp_path / "plain"
     d.mkdir()

codejury-0.22.0/codejury/data/commands/codejury-review-repo.md

@@ -1,29 +0,0 @@
----
-description: Run a codejury whole-repo security review on a repository, interactively
----
-Run a codejury whole-repo security review of: $ARGUMENTS
-
-1. Scaffold the workspace:
-
-   ```
-   codejury review repo $ARGUMENTS --workspace /tmp/codejury-review
-   ```
-
-   If `codejury` is not on PATH it is a pip-installed console script, so activate
-   the project venv first, for example `. .venv/bin/activate`, or run it through
-   that venv's Python, for example `python -m codejury`.
-
-2. Read `<workspace>/METHODOLOGY.md` and follow it to completion. It is the single
-   source of truth for how to run the review, the entrypoint map, the trace
-   targets, the Authorization Model pass, the dependency-control checks, the round
-   ledger, and the Completeness Gate. Do not improvise a different process.
-
-3. Verify each issue with a real PoC, human in the loop. Ask me for any
-   credential, test account, or MFA step you need. Never touch production, never
-   use real credentials, and never run a destructive action without my go-ahead.
-   Only a reproduced PoC is a confirmed finding.
-
-4. Report confirmed findings, the ones with a reproduced PoC, separately from
-   suspected ones still blocked on verification, as a table: title, class,
-   `file:line`, exploit, verification status. The issue files live in the
-   workspace `issues/`.