codejury 0.17.1__tar.gz → 0.19.0__tar.gz

codejury-0.19.0/PKG-INFO

@@ -0,0 +1,147 @@
+Metadata-Version: 2.4
+Name: codejury
+Version: 0.19.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
+Author: AISecLabs
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/aiseclabs/codejury
+Project-URL: Repository, https://github.com/aiseclabs/codejury
+Keywords: security,appsec,static analysis,llm,owasp,asvs,code review
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Security
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: json-repair>=0.30
+Provides-Extra: anthropic
+Requires-Dist: anthropic>=0.40; extra == "anthropic"
+Provides-Extra: openai
+Requires-Dist: openai>=1.0; extra == "openai"
+Provides-Extra: litellm
+Requires-Dist: litellm>=1.0; extra == "litellm"
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: jsonschema>=4.0; extra == "dev"
+Dynamic: license-file
+
+```
+ ██████╗ ██████╗ ██████╗ ███████╗     ██╗██╗   ██╗██████╗ ██╗   ██╗
+██╔════╝██╔═══██╗██╔══██╗██╔════╝     ██║██║   ██║██╔══██╗╚██╗ ██╔╝
+██║     ██║   ██║██║  ██║█████╗       ██║██║   ██║██████╔╝ ╚████╔╝
+██║     ██║   ██║██║  ██║██╔══╝  ██   ██║██║   ██║██╔══██╗  ╚██╔╝
+╚██████╗╚██████╔╝██████╔╝███████╗╚█████╔╝╚██████╔╝██║  ██║   ██║
+ ╚═════╝ ╚═════╝ ╚═════╝ ╚══════╝ ╚════╝  ╚═════╝ ╚═╝  ╚═╝   ╚═╝
+```
+
+> AI code security review for diffs and whole repositories.
+
+It 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.
+
+## Install
+
+```bash
+pip install codejury                 # core
+pip install "codejury[anthropic]"    # add a backend, also openai or litellm
+```
+
+## Diff Review
+
+```bash
+# audit a diff file
+codejury review diff --diff-file changes.diff
+
+# audit a git range in a repo
+codejury review diff --repo /path/to/app --git-range origin/main...HEAD
+
+# from stdin
+git diff HEAD~1 | codejury review diff
+
+# adversarial mode, more recall on subtle flaws, about 3x the cost
+codejury review diff --diff-file changes.diff --mode adversarial
+
+# CI gate and SARIF
+codejury review 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
+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
+
+```bash
+codejury review repo /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.
+
+## 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
+
+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.

codejury-0.19.0/README.md

@@ -0,0 +1,116 @@
+```
+ ██████╗ ██████╗ ██████╗ ███████╗     ██╗██╗   ██╗██████╗ ██╗   ██╗
+██╔════╝██╔═══██╗██╔══██╗██╔════╝     ██║██║   ██║██╔══██╗╚██╗ ██╔╝
+██║     ██║   ██║██║  ██║█████╗       ██║██║   ██║██████╔╝ ╚████╔╝
+██║     ██║   ██║██║  ██║██╔══╝  ██   ██║██║   ██║██╔══██╗  ╚██╔╝
+╚██████╗╚██████╔╝██████╔╝███████╗╚█████╔╝╚██████╔╝██║  ██║   ██║
+ ╚═════╝ ╚═════╝ ╚═════╝ ╚══════╝ ╚════╝  ╚═════╝ ╚═╝  ╚═╝   ╚═╝
+```
+
+> AI code security review for diffs and whole repositories.
+
+It 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.
+
+## Install
+
+```bash
+pip install codejury                 # core
+pip install "codejury[anthropic]"    # add a backend, also openai or litellm
+```
+
+## Diff Review
+
+```bash
+# audit a diff file
+codejury review diff --diff-file changes.diff
+
+# audit a git range in a repo
+codejury review diff --repo /path/to/app --git-range origin/main...HEAD
+
+# from stdin
+git diff HEAD~1 | codejury review diff
+
+# adversarial mode, more recall on subtle flaws, about 3x the cost
+codejury review diff --diff-file changes.diff --mode adversarial
+
+# CI gate and SARIF
+codejury review 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
+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
+
+```bash
+codejury review repo /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.
+
+## 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
+
+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.

{codejury-0.17.1 → codejury-0.19.0}/codejury/__init__.py

@@ -1,9 +1,10 @@
-"""codejury: an AI code security review tool.
+"""AI code security review tool.
 
 Two paths matched to their nature: a coded diff-audit engine (standard single
 call or adversarial Finder/Challenger/Judge), and a whole-repo review run as a
 methodology by an interactive agent. Security knowledge lives in rich markdown
-rules (data/rules) injected into the audit prompt, not in a rendered schema.
+vulnerability classes (data/vulnerabilities) injected into the audit prompt, not
+in a rendered schema.
 """
 
 from importlib.metadata import PackageNotFoundError, version

{codejury-0.17.1 → codejury-0.19.0}/codejury/cli.py

@@ -1,4 +1,4 @@
-"""codejury CLI: thin argument parsing and dispatch.
+"""Command line interface: thin argument parsing and dispatch.
 
 Two paths matched to their nature:
 

codejury-0.19.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"]
+
+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.19.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.19.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.19.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.19.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.

codejury-0.19.0/codejury/data/frameworks/python/celery.md

@@ -0,0 +1,36 @@
+---
+id: celery
+title: Celery
+kind: framework
+language: python
+detect:
+  imports: ["celery", "shared_task"]
+entrypoint_files: ["*tasks.py", "*/tasks/*.py"]
+entrypoint_markers: ["@shared_task", "@app.task", "@celery_app.task", "@periodic_task", ".delay(", ".apply_async(", "crontab("]
+---
+# Celery Review Notes
+
+A task is an entrypoint, not just glue. Its arguments are attacker-influenced
+whenever the enqueue site passes request input through, so review a task the same
+way as an HTTP handler. The web view that calls `.delay()` or `.apply_async()` is
+the producer, and the task body is where the value lands.
+
+## Entrypoints
+- Task definitions in `tasks.py` or a `tasks/` package, marked by `@shared_task`,
+  `@app.task`, or `@celery_app.task`. Periodic tasks wired by `crontab()` or a
+  beat schedule run with no caller, so their inputs are config or stored state.
+- Trace each task back to its `.delay(...)` and `.apply_async(...)` callers to see
+  which arguments are user-controlled.
+
+## What to Hunt
+- A task that fetches a URL, runs a command, opens a file path, or renders a
+  template from an argument, the same sink classes as a web handler, now reached
+  off the request cycle.
+- Authorization re-check. A producer that checked the caller does not carry that
+  identity into the task, so a task that acts on a resource by an id in its
+  arguments needs its own owner or tenant check.
+- Secret and token exposure. A task that logs full request headers, a response
+  body, or a fetched credential leaks it into worker logs. See the
+  information-exposure vulnerability class.
+- Replayable or duplicate enqueue. A task with a side effect that is enqueued from
+  an unauthenticated or replayable producer runs more than once.

{codejury-0.17.1/codejury/data/frameworks → codejury-0.19.0/codejury/data/frameworks/python}/django.md

@@ -2,13 +2,16 @@
 id: django
 title: Django
 kind: framework
+language: python
 detect:
   files: ["*urls.py", "manage.py", "*settings.py"]
   manifest: ["django"]
   imports: ["from django", "import django"]
-entrypoint_files: ["*urls.py"]
+entrypoint_files: ["*urls.py", "*views.py", "*viewsets.py", "*/views/*.py", "*serializers.py", "*api.py", "*consumers.py"]
+entrypoint_markers: ["APIView", "ViewSet", "@api_view", "@action", "router.register", "path(", "re_path(", "as_view("]
+logic_layers: ["*/controllers/*.py", "*controllers.py", "*/managers/*.py", "*managers.py", "*/dao/*.py", "*dao.py", "*/services/*.py", "*services.py", "*/models/*.py", "*models.py"]
 ---
-# Django review notes
+# Django Review Notes
 
 ## Entrypoints
 - Routes live in `urls.py`: `path()` / `re_path()` map a URL to a view.
@@ -18,14 +21,14 @@ entrypoint_files: ["*urls.py"]
   signals, and middleware.
 
 ## Authorization / IDOR
-- Auth is enforced by decorators (`@login_required`), DRF permission classes, or
+- Auth is enforced by decorators such as `@login_required`, DRF permission classes, or
   middleware. Note where it is and where it is missing.
-- Classic IDOR shape: `Model.objects.get(pk=<user input>)` (or `filter(id=...)`)
+- Classic IDOR shape: `Model.objects.get(pk=<user input>)` or `filter(id=...)`
   with no owner/tenant scoping, then returned to the caller. Inspect every object
   fetch keyed by a user-supplied id.
 
-## Common sinks / gotchas
+## Common Sinks / Gotchas
 - SQL: `.raw()`, `.extra()`, `RawSQL`, or string-built SQL via `connection.cursor()`.
 - Templates: `mark_safe`, `|safe`, `format_html` on unescaped user input, autoescape off.
-- `pickle` / `yaml.load` on a cookie or upload, `DEBUG=True` leaking internals,
-  a hardcoded `SECRET_KEY`.
+- Settings: `DEBUG=True` leaks internals, a hardcoded `SECRET_KEY`. Untrusted
+  deserialization is a language-level sink, see the Python guide.

codejury-0.19.0/codejury/data/frameworks/python/fastapi.md

@@ -0,0 +1,37 @@
+---
+id: fastapi
+title: FastAPI
+kind: framework
+language: python
+detect:
+  manifest: ["fastapi"]
+  imports: ["from fastapi", "import fastapi"]
+entrypoint_files: ["*main.py", "*/routers/*.py", "*/api/*.py", "*api.py", "*routes.py", "*/endpoints/*.py"]
+entrypoint_markers: ["FastAPI(", "APIRouter(", "@app.get", "@app.post", "@router.get", "@router.post", "Depends("]
+logic_layers: ["*/services/*.py", "*services.py", "*/models/*.py", "*models.py", "*/repositories/*.py", "*/crud/*.py", "*/dao/*.py"]
+---
+# FastAPI Review Notes
+
+## Entrypoints
+- Path operations decorated with `@app.get` / `@app.post` or `@router.*` on an
+  `APIRouter`. Inputs arrive as path and query parameters, and as a request body
+  validated by a Pydantic model.
+- A Pydantic model bounds the body's shape, but an over-wide model still binds
+  privileged fields, the mass-assignment shape.
+
+## Authorization / IDOR
+- Auth and access control run through `Depends`, for example a dependency that
+  resolves the current user or checks a scope. Note an endpoint that omits the
+  dependency its siblings use, or a dependency that authenticates but does not
+  authorize the specific resource.
+- IDOR: an endpoint that loads a record by an id parameter with no owner or tenant
+  check.
+
+## Common Sinks / Gotchas
+- SQL: a raw query or an ORM `text()` built from a parameter.
+- SSRF: `httpx` or `requests` to a URL from input, common in webhook and fetch
+  endpoints.
+- Path: `FileResponse` on a path from input.
+- `CORSMiddleware` with `allow_origins=["*"]` together with credentials, and an
+  OAuth2 bearer dependency that decodes a token without verifying signature,
+  audience, and expiry.

codejury-0.19.0/codejury/data/frameworks/python/flask.md

@@ -0,0 +1,37 @@
+---
+id: flask
+title: Flask
+kind: framework
+language: python
+detect:
+  manifest: ["flask"]
+  imports: ["from flask", "import flask"]
+entrypoint_files: ["*app.py", "*views.py", "*routes.py", "*/views/*.py", "*/blueprints/*.py", "*api.py"]
+entrypoint_markers: ["@app.route", ".route(", "Blueprint(", "add_url_rule(", "MethodView", "@app.before_request"]
+logic_layers: ["*/services/*.py", "*services.py", "*/models/*.py", "*models.py", "*/repositories/*.py", "*/dao/*.py"]
+---
+# Flask Review Notes
+
+## Entrypoints
+- Routes are functions decorated with `@app.route` or `@bp.route`, or registered
+  with `add_url_rule`. Blueprints mount a group under a URL prefix. Class views
+  subclass `MethodView`.
+- Read input from `request.args`, `request.form`, `request.values`,
+  `request.json`, `request.files`, `request.headers`, and `request.cookies`, all
+  attacker-controlled.
+
+## Authorization / IDOR
+- Auth is enforced by a `@login_required` style decorator, a `before_request`
+  hook, or an explicit check in the view. Note where it is and where a route
+  lacks it.
+- IDOR: a model fetched by an id from the request with no owner or tenant scope,
+  then returned.
+
+## Common Sinks / Gotchas
+- SSTI: `render_template_string` on input, or `Markup` and `|safe` on unescaped
+  input.
+- SQL: raw `cursor.execute` or an ORM `text()` built from input.
+- Path: `send_file` or `send_from_directory` with a path from input, the traversal
+  sink.
+- A hardcoded `SECRET_KEY`, `debug=True` in production, and an open redirect via
+  `redirect(request.args[...])`.

codejury-0.19.0/codejury/data/languages/go.md

@@ -0,0 +1,35 @@
+---
+id: go
+title: Go
+kind: language
+detect:
+  files: ["*.go", "go.mod"]
+entrypoint_files: ["*main.go", "*/handlers/*.go", "*/handler/*.go", "*/api/*.go", "*/routes/*.go"]
+entrypoint_markers: ["http.HandleFunc", "http.ListenAndServe", "ServeMux", "http.Handler", "func(w http.ResponseWriter"]
+logic_layers: ["*/service/*.go", "*/services/*.go", "*/usecase/*.go", "*/repository/*.go", "*/repo/*.go", "*/store/*.go", "*/dao/*.go", "*/model/*.go", "*/models/*.go"]
+---
+# Go Review Notes
+
+Where untrusted input enters beyond web routes, which the framework guides cover.
+The standard `net/http` server is itself an entrypoint: a handler that takes an
+`http.ResponseWriter` and an `*http.Request`, registered with `http.HandleFunc`
+or a `ServeMux`. Read the request through `r.URL.Query`, `r.FormValue`, `r.PathValue`,
+`r.Header`, and the decoded body, all attacker-controlled.
+
+## Common Sinks
+- SQL: a query built with `fmt.Sprintf` or string concatenation passed to
+  `db.Query` or `db.Exec`. Use placeholders, never build SQL from input.
+- Command: `exec.Command` with a shell or with arguments built from input,
+  `os/exec` reaching `sh -c`.
+- Path: `filepath.Join` or `os.Open` on a path from input with no `filepath.Clean`
+  and containment check, the traversal sink.
+- SSRF: `http.Get`, `http.NewRequest`, or a client `Do` on a URL from input.
+- Deserialization and templates: `encoding/gob`, `text/template` rendering input,
+  and `html/template` used with the wrong escaping context.
+
+## Gotchas
+- Errors ignored with `_` can skip a security check whose failure is never seen.
+- A type assertion or `interface{}` body decoded with `json.Unmarshal` into a
+  wide struct is mass assignment if privileged fields are bound.
+- Goroutines and shared state without a lock are a race, relevant to one-time
+  tokens and balances.