codejury 0.18.0__tar.gz → 0.20.0__tar.gz

{codejury-0.18.0 → codejury-0.20.0}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: codejury
-Version: 0.18.0
-Summary: AI code security review: an adversarial diff-audit engine and an agent-driven whole-repo review methodology, with security knowledge as rich rules
+Version: 0.20.0
+Summary: AI code security review for diffs and whole repositories.
 Author: AISecLabs
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/aiseclabs/codejury
@@ -40,52 +40,61 @@ Dynamic: license-file
 
 > AI code security review for diffs and whole repositories.
 
-It runs two paths matched to their nature.
+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.
-- **Repo Review** is agent driven. It is a methodology an interactive agent such
-  as Claude Code or Codex runs to map a codebase attack surface, trace inputs to
-  sinks across files, verify issues with a real PoC, and iterate over rounds with
-  a persistent memory. A whole repository is too large for one LLM call, so it
-  ships the methodology and scaffolds the workspace instead of running a
-  pipeline.
-
-Security knowledge lives in rich vulnerability classes under `codejury/data/vulnerabilities/*.md`, with a
-vulnerable and a secure example per language, injected into the audit prompt
-rather than buried in code.
+  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.
 
 ## Install
 
 ```bash
-pip install codejury                 # core
-pip install "codejury[anthropic]"    # add a backend, also openai or litellm
+pip install codejury                       # core
+pip install "codejury[anthropic]"          # add a backend, also openai or litellm
+codejury install-slash-command             # Claude Code, ~/.claude/commands/
+codejury install-slash-command --agent codex   # Codex, ~/.codex/prompts/
 ```
 
+`install-slash-command` copies the `/codejury-review` 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` and
+tell any agent to follow the methodology it writes.
+
 ## Diff Review
 
 ```bash
 # audit a diff file
-codejury review diff --diff-file changes.diff
+codejury diff --diff-file changes.diff
 
 # audit a git range in a repo
-codejury review diff --repo /path/to/app --git-range origin/main...HEAD
+codejury diff --repo /path/to/app --git-range origin/main...HEAD
 
 # from stdin
-git diff HEAD~1 | codejury review diff
+git diff HEAD~1 | codejury diff
 
 # adversarial mode, more recall on subtle flaws, about 3x the cost
-codejury review diff --diff-file changes.diff --mode adversarial
+codejury diff --diff-file changes.diff --mode adversarial
 
 # CI gate and SARIF
-codejury review diff --diff-file changes.diff --format sarif --fail-on high
+codejury diff --diff-file changes.diff --format sarif --fail-on high
 ```
 
 Configure a backend with `--provider`, `--model`, `--api-key`, `--api-base`, or
 the `CODEJURY_API_KEY`, `CODEJURY_MODEL`, and `CODEJURY_API_BASE` environment
-variables. `codejury review diff --dry-run` exercises the engine with a mock
+variables. `codejury 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
@@ -120,17 +129,49 @@ 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.
+
 ```bash
-codejury review repo /path/to/your/repo
+codejury review /path/to/your/repo
 ```
 
-This scaffolds a review workspace with `entrypoints/`, `issues/`, `analysis/`,
-and a `security-review-memory.md`, seeds the entrypoint inventory from a
-deterministic scan, and prints the methodology. Run it with an interactive agent.
-It reads the methodology and the vulnerability classes, maps the attack surface, traces inputs to
-sinks across files, records high confidence issues with a PoC, and asks you to
-confirm credentials or false positives along the way. Nothing runs against
-production.
+This 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:
+
+```
+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
+```
+
+Then run it with an interactive agent. In Claude Code or Codex:
+
+```
+/codejury-review /path/to/your/repo
+```
+
+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.
+
+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.
 
 ## Findings
 
@@ -142,6 +183,15 @@ production config leaks.
 
 ## Extending
 
-Add a vulnerability class by dropping a new file `codejury/data/vulnerabilities/<class>.md`
-with the standard frontmatter of title, impact, tags, and triggers plus a
-vulnerable and a secure example. It is data, no code change needed.
+Knowledge is data, so extending codejury is a drop-in markdown file with no code
+change.
+
+- A vulnerability class: `codejury/data/vulnerabilities/<class>.md` with
+  frontmatter of title, impact, tags, and triggers, plus a vulnerable and a
+  secure example.
+- A language or framework: `codejury/data/languages/<lang>.md` or
+  `codejury/data/frameworks/<lang>/<framework>.md`, declaring its detect signals,
+  entrypoint markers, and downstream logic layers.
+- A protocol such as OAuth: `codejury/data/protocols/<name>.md`, detected by
+  language neutral content tokens.
+```

codejury-0.20.0/README.md

@@ -0,0 +1,166 @@
+```
+ ██████╗ ██████╗ ██████╗ ███████╗     ██╗██╗   ██╗██████╗ ██╗   ██╗
+██╔════╝██╔═══██╗██╔══██╗██╔════╝     ██║██║   ██║██╔══██╗╚██╗ ██╔╝
+██║     ██║   ██║██║  ██║█████╗       ██║██║   ██║██████╔╝ ╚████╔╝
+██║     ██║   ██║██║  ██║██╔══╝  ██   ██║██║   ██║██╔══██╗  ╚██╔╝
+╚██████╗╚██████╔╝██████╔╝███████╗╚█████╔╝╚██████╔╝██║  ██║   ██║
+ ╚═════╝ ╚═════╝ ╚═════╝ ╚══════╝ ╚════╝  ╚═════╝ ╚═╝  ╚═╝   ╚═╝
+```
+
+> 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.
+
+## Install
+
+```bash
+pip install codejury                       # core
+pip install "codejury[anthropic]"          # add a backend, also openai or litellm
+codejury install-slash-command             # Claude Code, ~/.claude/commands/
+codejury install-slash-command --agent codex   # Codex, ~/.codex/prompts/
+```
+
+`install-slash-command` copies the `/codejury-review` 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` and
+tell any agent to follow the methodology it writes.
+
+## Diff Review
+
+```bash
+# audit a diff file
+codejury diff --diff-file changes.diff
+
+# audit a git range in a repo
+codejury diff --repo /path/to/app --git-range origin/main...HEAD
+
+# from stdin
+git diff HEAD~1 | codejury diff
+
+# adversarial mode, more recall on subtle flaws, about 3x the cost
+codejury diff --diff-file changes.diff --mode adversarial
+
+# CI gate and SARIF
+codejury diff --diff-file changes.diff --format sarif --fail-on high
+```
+
+Configure a backend with `--provider`, `--model`, `--api-key`, `--api-base`, or
+the `CODEJURY_API_KEY`, `CODEJURY_MODEL`, and `CODEJURY_API_BASE` environment
+variables. `codejury 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.
+
+```bash
+codejury review /path/to/your/repo
+```
+
+This 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:
+
+```
+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
+```
+
+Then run it with an interactive agent. In Claude Code or Codex:
+
+```
+/codejury-review /path/to/your/repo
+```
+
+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.
+
+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.
+
+## Findings
+
+Each finding carries a file and line, a severity and category, a concrete exploit
+scenario, a recommendation, and a confidence. A false positive filter drops test
+paths, mock paths, and low confidence noise. The model is also told not to report
+dependency CVEs, style notes, speculation, or risks that only matter when
+production config leaks.
+
+## Extending
+
+Knowledge is data, so extending codejury is a drop-in markdown file with no code
+change.
+
+- A vulnerability class: `codejury/data/vulnerabilities/<class>.md` with
+  frontmatter of title, impact, tags, and triggers, plus a vulnerable and a
+  secure example.
+- A language or framework: `codejury/data/languages/<lang>.md` or
+  `codejury/data/frameworks/<lang>/<framework>.md`, declaring its detect signals,
+  entrypoint markers, and downstream logic layers.
+- A protocol such as OAuth: `codejury/data/protocols/<name>.md`, detected by
+  language neutral content tokens.
+```

codejury-0.20.0/codejury/__main__.py

@@ -0,0 +1,10 @@
+"""Entry point for `python -m codejury`, mirroring the `codejury` console script.
+
+Lets the tool run without the console script on PATH, for example from a fresh
+shell that has not activated the project venv: `python -m codejury ...`.
+"""
+
+from codejury.cli import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

{codejury-0.18.0 → codejury-0.20.0}/codejury/cli.py

@@ -2,13 +2,13 @@
 
 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.
-- ``review repo`` scaffolds a workspace and prints the methodology for an
+- ``diff`` runs the coded diff engine over a unified diff: a single balanced call
+  (standard) or the adversarial Finder/Challenger/Judge pass.
+- ``review <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).
 
-``review diff --dry-run`` exercises the engine with a mock provider and no key.
+``diff --dry-run`` exercises the engine with a mock provider and no key.
 The audit orchestration itself lives in ``codejury.diff.runner``.
 """
 
@@ -17,6 +17,7 @@ from __future__ import annotations
 import argparse
 import subprocess
 import sys
+from pathlib import Path
 
 from codejury import __version__
 from codejury.report import gate, render
@@ -92,12 +93,17 @@ def main(argv: list[str] | None = None) -> int:
     parser.add_argument("--version", action="version", version=f"codejury {__version__}")
     sub = parser.add_subparsers(dest="command")
 
-    review = sub.add_parser("review", help="review code for security findings")
-    rsub = review.add_subparsers(dest="scope")
-    _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")
+    _add_audit_args(sub.add_parser("diff", help="audit a unified diff (the coded engine)"))
+
+    review = sub.add_parser("review", help="scaffold a whole-repo review for an interactive agent")
+    review.add_argument("directory", help="target repository to review")
+    review.add_argument("--workspace", default="codejury-review", help="where to create the review workspace")
+
+    inst = sub.add_parser("install-slash-command",
+                          help="install the /codejury-review slash command for an agent")
+    inst.add_argument("--agent", choices=("claude", "codex"), default="claude",
+                      help="which agent's command directory to install into")
+    inst.add_argument("--dir", default=None, help="explicit target directory, overrides --agent")
 
     args = parser.parse_args(argv)
     try:
@@ -109,8 +115,7 @@ def main(argv: list[str] | None = None) -> int:
 
 
 def _dispatch(args, parser) -> int:
-    scope = getattr(args, "scope", None)
-    if args.command == "review" and scope == "diff":
+    if args.command == "diff":
         if args.dry_run:
             provider = MockProvider(default=_MOCK_REPLY)
             model = "mock"
@@ -129,23 +134,38 @@ def _dispatch(args, parser) -> int:
         print(render(args.fmt, kept))
         return 1 if gate(kept, args.fail_on) else 0
 
-    if args.command == "review" and scope == "repo":
+    if args.command == "review":
         res = scaffold(args.directory, args.workspace)
-        print(f"Workspace: {res.workspace}", file=sys.stderr)
+        (Path(res.workspace) / "METHODOLOGY.md").write_text(res.methodology, encoding="utf-8")
+        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)
+            print(f"Detected stack: {', '.join(res.guides)}, notes in {res.workspace}/_stack.md", file=sys.stderr)
         print(f"Flagged {len(res.candidate_files)} candidate entrypoint files into "
               f"{res.workspace}/entrypoints/_entrypoints.md", file=sys.stderr)
-        print(f"Memory: {res.memory_path}", file=sys.stderr)
-        print("\nRun this review with an interactive agent (Claude Code / Codex) using the methodology below.\n")
-        print(res.methodology)
+        print(f"Methodology: {res.workspace}/METHODOLOGY.md", file=sys.stderr)
+        print(
+            "This command sets up the review, it does not find the issues itself. Next, have an "
+            f"interactive agent follow {res.workspace}/METHODOLOGY.md to run the review, or use the "
+            "/codejury-review command in Claude Code or Codex. Findings are written to "
+            f"{res.workspace}/issues/."
+        )
         return 0
 
-    if args.command == "review":  # no scope given
-        print("usage: codejury review {diff,repo} ...", file=sys.stderr)
-        print("  diff   audit a unified diff for security findings", file=sys.stderr)
-        print("  repo   scaffold a whole-repo review for an interactive agent", file=sys.stderr)
-        return 1
+    if args.command == "install-slash-command":
+        from codejury.resources import COMMANDS_DIR
+        # the command body is portable, only the directory differs per agent
+        agent_dirs = {
+            "claude": Path.home() / ".claude" / "commands",
+            "codex": Path.home() / ".codex" / "prompts",
+        }
+        target_dir = Path(args.dir) if args.dir else agent_dirs[args.agent]
+        target_dir.mkdir(parents=True, exist_ok=True)
+        name = "codejury-review.md"
+        dst = target_dir / name
+        dst.write_text((COMMANDS_DIR / name).read_text(encoding="utf-8"), encoding="utf-8")
+        print(f"Installed slash command to {dst}")
+        print("Run it in the agent with: /codejury-review <repository>")
+        return 0
 
     parser.print_help()
     return 1

codejury-0.20.0/codejury/data/commands/codejury-review.md

@@ -0,0 +1,29 @@
+---
+description: Run a codejury whole-repo security review on a repository, interactively
+---
+Run a codejury whole-repository security review of: $ARGUMENTS
+
+1. Scaffold the workspace:
+
+   ```
+   codejury review $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/`.

codejury-0.20.0/codejury/data/detection.yaml

@@ -0,0 +1,17 @@
+# File and path classification, across ecosystems: what the engine treats as a
+# source file, a dependency manifest, a noise directory, or test code. Kept here
+# so the implementation enumerates no language itself, adding a language is a
+# data edit. This is distinct from a guide's stack detection, which decides which
+# language, framework, or protocol applies.
+
+skip_dirs: [".git", ".venv", "venv", "node_modules", "__pycache__", ".mypy_cache", ".pytest_cache", "build", "dist", "target", "out", ".tox", ".eggs", ".next", ".nuxt"]
+
+source_extensions: [".py", ".js", ".ts", ".tsx", ".jsx", ".mjs", ".go", ".rb", ".java", ".kt", ".php", ".cs", ".scala", ".rs"]
+
+config_extensions: [".yaml", ".yml", ".toml", ".ini", ".cfg", ".conf", ".env"]
+
+manifests: ["requirements.txt", "requirements-dev.txt", "pyproject.toml", "setup.py", "Pipfile", "package.json", "go.mod", "Gemfile", "pom.xml", "build.gradle", "Cargo.toml", "composer.json"]
+
+test_dirs: ["test", "tests", "__tests__", "__mocks__", "mocks", "fixtures", "testdata", "e2e", "spec", "specs"]
+
+test_name_patterns: ["test_*", "*_test.*", "*.test.*", "*.spec.*"]

codejury-0.20.0/codejury/data/frameworks/go/echo.md

@@ -0,0 +1,31 @@
+---
+id: echo
+title: Echo
+kind: framework
+language: go
+detect:
+  manifest: ["labstack/echo"]
+  imports: ["github.com/labstack/echo"]
+entrypoint_files: ["*main.go", "*/handlers/*.go", "*/handler/*.go", "*/api/*.go", "*/routes/*.go", "*/controllers/*.go"]
+entrypoint_markers: ["echo.New(", "echo.Context", "e.GET", "e.POST", ".GET(", ".POST(", ".Group(", "c.Param", "c.QueryParam", "c.Bind"]
+logic_layers: ["*/service/*.go", "*/services/*.go", "*/usecase/*.go", "*/repository/*.go", "*/repo/*.go", "*/store/*.go", "*/dao/*.go", "*/model/*.go"]
+---
+# Echo Review Notes
+
+## Entrypoints
+- Handlers have the signature `func(c echo.Context) error`, registered with
+  `e.GET`, `.POST`, and grouped under `e.Group`. Input comes from `c.Param`,
+  `c.QueryParam`, `c.FormValue`, `c.Request().Header`, and `c.Bind` into a struct.
+
+## Authorization / IDOR
+- Auth is middleware, applied globally, on a `Group`, or per route. The flaw to
+  hunt is a route registered outside the authenticated group, inheriting no
+  check. Compare grouped routes against routes on the bare instance.
+- IDOR: a record loaded by `c.Param("id")` with no owner or tenant scope.
+
+## Common Sinks / Gotchas
+- SQL: `fmt.Sprintf` into `db.Query` or `db.Exec`, instead of placeholders.
+- Command: `exec.Command` built from input.
+- Path: `c.File` or `c.Attachment` and `filepath.Join` on a path from input.
+- `c.Bind` into a struct with privileged fields is mass assignment.
+- A returned `error` that the caller drops can hide a failed auth or validation.

codejury-0.20.0/codejury/data/frameworks/go/gin.md

@@ -0,0 +1,34 @@
+---
+id: gin
+title: Gin
+kind: framework
+language: go
+detect:
+  manifest: ["gin-gonic/gin"]
+  imports: ["github.com/gin-gonic/gin"]
+entrypoint_files: ["*main.go", "*/handlers/*.go", "*/handler/*.go", "*/api/*.go", "*/routes/*.go", "*/controllers/*.go"]
+entrypoint_markers: ["gin.Default(", "gin.New(", "*gin.Context", "router.GET", "router.POST", ".GET(", ".POST(", ".Group(", "c.Param", "c.Query", "c.ShouldBind"]
+logic_layers: ["*/service/*.go", "*/services/*.go", "*/usecase/*.go", "*/repository/*.go", "*/repo/*.go", "*/store/*.go", "*/dao/*.go", "*/model/*.go"]
+---
+# Gin Review Notes
+
+## Entrypoints
+- Handlers have the signature `func(c *gin.Context)`, registered with
+  `router.GET`, `.POST`, and grouped under `router.Group`. Input comes from
+  `c.Param`, `c.Query`, `c.PostForm`, `c.GetHeader`, and `c.ShouldBindJSON` or
+  `c.Bind` into a struct.
+
+## Authorization / IDOR
+- Auth is middleware, applied globally, on a `Group`, or per route. The classic
+  flaw is a route registered outside the authenticated group, so it inherits no
+  check. Compare a group's routes against the routes registered on the bare
+  engine.
+- IDOR: a record loaded by `c.Param("id")` with no owner or tenant scope.
+
+## Common Sinks / Gotchas
+- SQL: `fmt.Sprintf` into `db.Query` or `db.Exec`, instead of placeholders.
+- Command: `exec.Command` built from input.
+- Path: `c.File` or `filepath.Join` on a path from input, the traversal sink.
+- `c.ShouldBindJSON` into a struct with privileged fields is mass assignment.
+- A handler that ignores the error from a bind or an auth call proceeds as if it
+  passed.

codejury-0.20.0/codejury/data/frameworks/javascript/express.md

@@ -0,0 +1,36 @@
+---
+id: express
+title: Express
+kind: framework
+language: javascript
+detect:
+  manifest: ["express"]
+  imports: ["require('express')", "require(\"express\")", "from 'express'"]
+entrypoint_files: ["*app.js", "*server.js", "*app.ts", "*server.ts", "*/routes/*.js", "*/routes/*.ts", "*/controllers/*.js", "*/controllers/*.ts", "*router*.js", "*router*.ts"]
+entrypoint_markers: ["express()", "app.get(", "app.post(", "app.use(", "router.get(", "router.post(", ".get(", ".post(", "req.params", "req.query", "req.body"]
+logic_layers: ["*/services/*.js", "*/services/*.ts", "*/models/*.js", "*/models/*.ts", "*/repositories/*.js", "*/repositories/*.ts", "*/dao/*.js", "*/dao/*.ts"]
+---
+# Express Review Notes
+
+Works the same in JavaScript and TypeScript. See the JavaScript guide for the
+runtime sinks.
+
+## Entrypoints
+- Routes are `app.get` / `app.post` / `router.*`, and a `Router` mounted with
+  `app.use("/prefix", router)`. The handler is `(req, res, next)`. Input is
+  `req.params`, `req.query`, `req.body`, `req.headers`, and `req.cookies`.
+
+## Authorization / IDOR
+- Auth is middleware, passed to `app.use` or per route. The flaw to hunt is a
+  route mounted before the auth middleware, or one that omits the middleware its
+  siblings have, so order and placement matter.
+- IDOR: a record loaded by `req.params.id` with no owner or tenant scope.
+
+## Common Sinks / Gotchas
+- SQL and NoSQL: a query built by string concatenation, or a Mongo filter built
+  straight from `req.body`, the operator-injection sink.
+- Command: `child_process.exec` from input. Code: `eval` from input.
+- Path: `res.sendFile` or `path.join` on a path from input, the traversal sink.
+- Open redirect via `res.redirect(req.query...)`, and prototype pollution from a
+  body merge.
+- A body spread whole into a model or an ORM create is mass assignment.

codejury-0.20.0/codejury/data/frameworks/javascript/nestjs.md

@@ -0,0 +1,36 @@
+---
+id: nestjs
+title: NestJS
+kind: framework
+language: javascript
+detect:
+  manifest: ["@nestjs/core", "@nestjs/common"]
+  imports: ["@nestjs/common", "@nestjs/core"]
+entrypoint_files: ["*.controller.ts", "*.controller.js", "*/controllers/*.ts", "*.resolver.ts", "*.gateway.ts"]
+entrypoint_markers: ["@Controller(", "@Get(", "@Post(", "@Put(", "@Delete(", "@Body(", "@Param(", "@Query(", "@UseGuards("]
+logic_layers: ["*.service.ts", "*.service.js", "*/services/*.ts", "*.repository.ts", "*/repositories/*.ts", "*.entity.ts", "*/dao/*.ts"]
+---
+# NestJS Review Notes
+
+Usually TypeScript on Node. See the JavaScript and TypeScript guides for the
+runtime sinks and for why types do not sanitize input.
+
+## Entrypoints
+- A `@Controller` class with `@Get` / `@Post` methods. Input binds through
+  `@Param`, `@Query`, `@Body`, and `@Headers`. GraphQL resolvers and WebSocket
+  gateways are entrypoints too.
+
+## Authorization / IDOR
+- Access control is a guard applied with `@UseGuards`, at the controller or the
+  method, plus role decorators. The flaw to hunt is a route or controller missing
+  the guard its siblings declare, and a guard that authenticates but does not
+  authorize the specific resource.
+- IDOR: a handler that loads by `@Param("id")` with no owner or tenant check.
+
+## Common Sinks / Gotchas
+- Mass assignment: a `@Body` DTO with no `ValidationPipe` and `whitelist: true`
+  binds any field the client sends. Confirm the pipe is global or applied.
+- SQL: a TypeORM or Prisma raw query built from input.
+- SSRF: a server-side `fetch` or `axios` to a URL from input.
+- A custom guard that returns true on an unhandled path, or reads the user from a
+  header the client controls.