Discover the Best AI Tools

check-risk combines repository policy rules with optional Jev semantic analysis to score Git changes and recommend checks and reviewers. It runs locally as a CLI or GitHub Action; semantic mode sends code context externally. Live Jev validation remains pending, offline results are incomplete, and risk scores are not failure probabilities.

pi-jev-code adds Jev search ranking, pre-edit semantic checks and baseline-to-current diff review to a single Pi coding agent. It needs Pi, Node.js and a TypeSafe key and sends task/code context for judgments. Thresholds remain heuristic; API failures allow continuation and final reviews occur after the agent's edits.

Ask Jev provides explicit advisory audits and binary questions over recorded local Codex conversations through Windows PowerShell hooks. Requested audits send selected transcript content to paid TypeSafe inference; evidence is bounded and probabilities are not guarantees or automatic fixes.

TypeSafe Code Guard is a Python MCP server that uses Jev to rank candidate files and code blocks and flag potential issues in diffs. It requires a TypeSafe key and sends selected code context to the service; rankings and flags are advisory, not proof of correctness.

jev-git is a Rust Git extension that scores staged or piped diffs for secrets and harmful payloads through TypeSafe Jev. It needs an API key, sends diff content externally and truncates large inputs. Its pre-push wiring and chained-hook exit handling need review; it is not a comprehensive security gate.

Typesafe Migration Guard sends SQL to Jev and returns a CI-facing safety verdict, with 403 for DANGER when the supplied environment is production. It needs explicit pipeline integration and trusts the caller’s environment label. The model judgment is probabilistic, not database enforcement; a SAFE response does not prove a migration harmless.

Turns evidence-grounded project preferences into configurable semantic checks over code changes and returns findings to a coding agent. Requires a configured decision service; it does not fix code itself or replace deterministic checks, and vague preferences must first become observable criteria.

Compares code with Markdown requirements using Jev judgments and configurable thresholds for CI or commit checks. Sends specification and code context remotely; Markdown tables are currently omitted, oversized targets fail, and probabilities do not replace tests or review.

Analyzes public GitHub pull-request context with Jev and presents structured risk and review-depth judgments. Requires a TypeSafe key; large diffs may be trimmed, private repositories are unsupported, and the verdict is advisory rather than a correctness guarantee.

Checks commit messages against staged changes and flags debug leftovers or credential-shaped additions. Sends review context to Jev; most findings warn by default, and API failures allow the commit, so it is not a reliable substitute for dedicated security checks.

Clean Code Review evaluates files or public GitHub diffs against Clean Code questions with Jev, then uses Luna to write a review. Browser and MCP interfaces share model budgets and rate limits. Reviews cover at most 24 code files and bounded text; skipped prose and generated files are not judged, and model feedback is not a correctness guarantee.

Lintus checks repository files against natural-language rules in YAML using Jev, supporting full-tree, changed-file and staged-file runs. It requires a Jev API key and sends eligible file content for probabilistic judgments; results depend on rule wording and thresholds.

A CLI that checks a file tree against natural-language rules, with optional agent write hooks and replaceable decision backends. The default judge sends content to TypeSafe; judgments can be wrong, and the Claude hook integration is documented as best-effort pending local validation.

Scans selected source and configuration files with Jev for deceptive or data-stealing behavior and reports suspicious locations. Sends eligible content to the configured service; excludes binaries and other filtered files, provides no sandbox, and a clean report does not prove safety.

Runs isolated read-only Pi reviewers and combines structured findings through configurable panel consensus, with optional Jev screening. Requires Pi and configured model providers; agreement is a review signal, not proof that code is correct or secure.

ErisLint applies configurable JSON rules to source code using Jev judgments, mapping probabilities or scores to lint warnings and errors. It offers a Rust CLI and optional VS Code integration. Live checks require an API key and send selected code and context externally; probabilistic findings need threshold tuning and do not replace compilation.

Canny hooks coding agents to record edits and check outcomes, gating completion on observable ledger facts and flagging risky patterns. Optional Jev judgments add advice rather than blocking changes. It needs compatible trusted hooks; observing a passing check does not prove full test coverage or code correctness, and host integrations differ.

jev-lint uses ast-grep to select code and asks Jev whether names, comments, tests or repository rules contradict the implementation. It reports thresholded findings and supports diff and commit review. Code is sent to an API; this supplements existing static tools, has uneven language maturity, and cannot reliably catch every API-specific defect.

oxlint-plugin-jev turns natural-language questions about functions, calls, JSX or files into probabilistic Oxlint diagnostics. It sends selected code to Jev and needs an API key. This experimental plugin caps and truncates inputs; unavailable requests normally report no findings, including default CI behavior unless fail mode is configured.

crapkit combines function complexity, test coverage and file churn into code-risk worklists and commit gates, with JSON and MCP interfaces. It reads Git-tracked files and needs coverage artifacts from configured test commands. Thresholds and ratchets manage existing debt; passing a score does not establish functional correctness.

DiffGate applies deterministic rules to changed lines, ranks findings and can run a configured test command for higher-impact changes through editor, MCP and CI integrations. Optional code-graph evidence can affect escalation; benchmark results do not guarantee zero false blocks elsewhere.

pi-warden adds completion checks, rule reminders and action holds to Pi coding-agent sessions, with offline patterns and optional Jev judgments. It requires a supported Pi host; enabled cloud features send selected redacted context, and guard decisions do not guarantee safe or correct work.

Stanley routes code-change requests into bounded workflows using Jev, with an optional Pi-agent fallback and manually promoted generated workflows. It is unreleased source requiring Node.js 22.18+, Git and a TypeSafe key; the old jev-code npm placeholder does nothing.

Abide turns repository agent instructions into review rubrics and checks edits against them with Jev, sending rules and diffs rather than conversation history. Hooks feed findings back to the coding agent. It needs configured credentials and has no built-in rules; missing keys or network failures allow edits through unchecked, and flagged issues still need review.