Skip to content
Back to search

jev-review

Local-first MCP plugin for continuous software-quality review by AI coding agents, powered by Jev.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/niazmorshed2007--jev-review/badge.svg)](/listings/niazmorshed2007--jev-review)

HTML

<a href="/listings/niazmorshed2007--jev-review"><img src="/api/listings/niazmorshed2007--jev-review/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Requirements:

- Node.js 20 or newer - A Jev API key from the [TypeSafe console](https://console.typesafe.ai/) - Claude Code, Codex, Cursor, or OpenCode

Set your API key before starting the coding agent:

export JEV_API_KEY="your-key"

Install Jev Review directly from GitHub—no npm publication is required:

npx plugins add NiazMorshed2007/jev-review

Choose your coding client when prompted, restart it, and ask the agent to use `jev-review` while implementing a nontrivial change.

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

plugin.json · Manifest · 16 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. {
  2. "$schema": "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
  3. "name": "jev-review",
  4. "version": "0.1.1",
  5. "description": "An iterative, local-first software-quality score loop for AI coding agents, powered by Jev.",
  6. "author": {
  7. "name": "Jev Review contributors"
  8. },
  9. "license": "MIT",
  10. "keywords": [
  11. "code-review",
  12. "mcp",
  13. "software-quality",
  14. "jev"
  15. ]
  16. }
README.md · README · 330 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. # Jev Review
  2. <div align="center">
  3. **Continuous software-quality review for AI coding agents, powered by [Jev](https://typesafe.ai/).**
  4. [![License: MIT](https://img.shields.io/badge/License-MIT-2563EB.svg)](LICENSE)
  5. ![Node.js 20+](https://img.shields.io/badge/Node.js-20%2B-339933.svg)
  6. ![MCP transport: stdio](https://img.shields.io/badge/MCP-stdio-7C3AED.svg)
  7. ![Backend: none](https://img.shields.io/badge/Hosted_backend-none-059669.svg)
  8. [Quick start](#quick-start) · [Client setup](#client-setup) · [Quality dimensions](#quality-dimensions) · [Security](#security-and-privacy)
  9. </div>
  10. Jev Review runs as a local MCP server and gives Claude Code, Codex, Cursor, and OpenCode structured quality scores while they work. Your coding agent remains responsible for diagnosing weaknesses and changing the code; Jev supplies a fast scalar signal across correctness, complexity, changeability, modularity, tests, security, and other independent quality dimensions.
  11. > [!IMPORTANT]
  12. > **Your API key stays on your machine.** Jev Review has no hosted backend, database, telemetry service, or author-operated proxy. The only remote request is sent directly to the configured Jev API.
  13. ## Demo
  14. <p align="center">
  15. https://github.com/user-attachments/assets/0ff9f873-0652-4826-af3d-6bb4f42c70b1
  16. </p>
  17. ## At a glance
  18. | | |
  19. | --- | --- |
  20. | **Purpose** | Continuous, structured software-quality evaluation |
  21. | **Supported clients** | Claude Code, Codex, Cursor, OpenCode |
  22. | **Distribution** | This GitHub repository—no npm publication |
  23. | **Runtime** | Local Node.js process over MCP stdio |
  24. | **Remote access** | Direct requests to Jev using your API key |
  25. | **MCP tools** | One focused tool: `jev_review` |
  26. | **Code changes** | Always performed by the primary coding agent |
  27. ## Quick start
  28. Requirements:
  29. - Node.js 20 or newer
  30. - A Jev API key from the [TypeSafe console](https://console.typesafe.ai/)
  31. - Claude Code, Codex, Cursor, or OpenCode
  32. Set your API key before starting the coding agent:
  33. ```bash
  34. export JEV_API_KEY="your-key"
  35. ```
  36. Install Jev Review directly from GitHub—no npm publication is required:
  37. ```bash
  38. npx plugins add NiazMorshed2007/jev-review
  39. ```
  40. Choose your coding client when prompted, restart it, and ask the agent to use `jev-review` while implementing a nontrivial change.
  41. ## How it works
  42. ```mermaid
  43. flowchart LR
  44. A[Agent implements] --> B[Focused diff and context]
  45. B --> C[Jev Review MCP]
  46. C --> D[Jev evaluation]
  47. D --> E[Structured quality signals]
  48. E --> F[Agent improves the code]
  49. F -. review again .-> B
  50. ```
  51. Jev Review is intended for frequent, focused checkpoints: after a coherent implementation slice, after a score-driven improvement, and before final handoff. The first call establishes a baseline. The agent then inspects its own implementation, forms a hypothesis about weak dimensions, improves the code, validates it, and rescores.
  52. Jev returns typed Score, Choice, and Noul decisions rather than a free-form review essay. It does not generate a prose explanation of why a score is low. Jev Review validates and converts those decisions into metric scores, confidence levels, coarse rubric hints, and comparisons with a previous evaluation. The coding agent—not Jev—must determine the actual cause and appropriate code change.
  53. There is deliberately no synthetic “82/100” overall score. Dimension changes such as `Readability 6.3 → 8.1` and `Security 8.2 → 8.2` are more useful than a blended percentage.
  54. ## Client setup
  55. | Client | Plugin installation | Manual MCP available |
  56. | --- | --- | --- |
  57. | Claude Code | `npx plugins add NiazMorshed2007/jev-review --target claude-code` | Yes |
  58. | Codex | `npx plugins add NiazMorshed2007/jev-review --target codex` | Yes |
  59. | Cursor | `npx plugins add NiazMorshed2007/jev-review --target cursor` | Yes |
  60. | OpenCode | Manual configuration below | Yes |
  61. Every client starts the same bundled `dist/server.js` process locally over stdio.
  62. ### Claude Code
  63. ```bash
  64. npx plugins add NiazMorshed2007/jev-review --target claude-code
  65. ```
  66. Restart Claude Code and run `/mcp` to confirm that `jev-review` is connected.
  67. To load a local clone while developing:
  68. ```bash
  69. claude --plugin-dir /absolute/path/to/jev-review
  70. ```
  71. Manual MCP-only setup:
  72. ```bash
  73. claude mcp add --scope user jev-review -- node /absolute/path/to/jev-review/dist/server.js
  74. ```
  75. ### Codex
  76. ```bash
  77. npx plugins add NiazMorshed2007/jev-review --target codex
  78. ```
  79. Restart Codex and run `/mcp` to verify the connection.
  80. Manual setup in `~/.codex/config.toml`:
  81. ```toml
  82. [mcp_servers.jev-review]
  83. command = "node"
  84. args = ["/absolute/path/to/jev-review/dist/server.js"]
  85. env_vars = ["JEV_API_KEY"]
  86. ```
  87. ### Cursor
  88. ```bash
  89. npx plugins add NiazMorshed2007/jev-review --target cursor
  90. ```
  91. Restart Cursor and check **Settings → MCP**. The bundled skill is named `jev-review`; invoke it with `/jev-review` or leave it on **Agent Decides**.
  92. Manual setup in `~/.cursor/mcp.json`:
  93. ```json
  94. {
  95. "mcpServers": {
  96. "jev-review": {
  97. "type": "stdio",
  98. "command": "node",
  99. "args": ["/absolute/path/to/jev-review/dist/server.js"],
  100. "env": {
  101. "JEV_API_KEY": "${env:JEV_API_KEY}"
  102. }
  103. }
  104. }
  105. }
  106. ```
  107. If Cursor is launched from the macOS Dock, it may not inherit variables from your shell profile. Make the already-exported key available to GUI applications before starting Cursor:
  108. ```bash
  109. launchctl setenv JEV_API_KEY "$JEV_API_KEY"
  110. ```
  111. Verify without printing the key:
  112. ```bash
  113. test -n "$(launchctl getenv JEV_API_KEY)" && echo "JEV_API_KEY is configured"
  114. ```
  115. ### OpenCode
  116. OpenCode does not currently appear in the portable `plugins` installer targets. Point it at the same bundled server instead:
  117. ```bash
  118. git clone https://github.com/NiazMorshed2007/jev-review.git
  119. cd jev-review
  120. opencode mcp add jev-review --global -- node "$PWD/dist/server.js"
  121. ```
  122. For the full skill and MCP setup, add this to `~/.config/opencode/opencode.json`, replacing the absolute path:
  123. ```json
  124. {
  125. "$schema": "https://opencode.ai/config.json",
  126. "skills": ["/absolute/path/to/jev-review/skills"],
  127. "mcp": {
  128. "servers": {
  129. "jev-review": {
  130. "type": "local",
  131. "command": ["node", "/absolute/path/to/jev-review/dist/server.js"],
  132. "environment": {
  133. "JEV_API_KEY": "{env:JEV_API_KEY}"
  134. }
  135. }
  136. }
  137. }
  138. }
  139. ```
  140. Run `opencode mcp list` to verify the connection. OpenCode may display the tool as `jev-review_jev_review`; the underlying MCP tool is still `jev_review`.
  141. ## MCP tool
  142. Jev Review intentionally starts with one tool: `jev_review`.
  143. ```ts
  144. {
  145. task?: string;
  146. diff?: string;
  147. files?: Array<{
  148. path: string;
  149. content: string;
  150. }>;
  151. repositoryContext?: string;
  152. previousEvaluation?: Evaluation;
  153. }
  154. ```
  155. At least one current-context field is required. Callers should normally send the task and focused diff, adding complete files only when the surrounding implementation is necessary to understand the change. Jev Review never reads the repository automatically.
  156. Jev Review does not impose an additional character, token, or file-count limit. The Jev API currently enforces its own token ceiling: live `jev-latest` behavior indicates roughly 32,768 tokens for the submitted state, although this number is not published in the API documentation or OpenAPI schema and may change. When Jev returns `max_tokens_exceeded`, the server asks the agent to reduce unrelated context or split the change into coherent review slices.
  157. The response contains:
  158. - An independent 1–10 score and 0–1 confidence for each applicable metric
  159. - `{ "applicable": false }` for dimensions unsupported by the supplied context
  160. - Prioritized weak dimensions and coarse predefined rubric hints—not generated root-cause explanations
  161. - Per-metric deltas, improvements, regressions, and unresolved weaknesses when `previousEvaluation` is supplied
  162. ## Quality dimensions
  163. Always evaluated when the supplied context is sufficient:
  164. - Correctness and requirement fit
  165. - Cognitive complexity
  166. - Readability and intent
  167. - Modularity and cohesion
  168. - Coupling and dependency quality
  169. - Changeability and change amplification
  170. - Abstraction and API design
  171. - Project and file structure
  172. - Duplication and reuse
  173. - Maintainability
  174. - Testability and test quality
  175. - Reliability and error handling
  176. - Security
  177. - Consistency and conventions
  178. - Documentation and explainability
  179. Evaluated only when relevant evidence is present:
  180. - Performance and resource efficiency
  181. - Scalability and flexibility
  182. - Compatibility and API stability
  183. - Observability and operability
  184. The evaluator judges consequences in context. It does not assume short functions, small files, zero duplication, more layers, more comments, or more tests are automatically better.
  185. ## Evaluation workflow
  186. The included `jev-review` skill teaches agents to treat Jev as a repeated scalar feedback loop:
  187. 1. Understand the task and inspect the repository.
  188. 2. Implement a coherent change and run relevant checks.
  189. 3. Call `jev_review` with focused context to establish a baseline.
  190. 4. Inspect the code themselves and form a hypothesis for weak important scores.
  191. 5. Make the smallest justified improvement and validate it.
  192. 6. Rescore with `previousEvaluation`, then inspect improvements and regressions.
  193. 7. Repeat while another evidence-based improvement remains.
  194. 8. Stop when requirements and checks pass and further score-seeking would add little real value.
  195. Correctness and the user's requirements always outrank score improvement. A higher score never justifies speculative architecture, unnecessary abstraction, scope expansion, breaking behavior, meaningless tests, or needless rewrites.
  196. ## Architecture
  197. ```text
  198. jev-review/
  199. ├── plugin.json # Portable Agent Plugin manifest
  200. ├── mcp.json # Portable stdio MCP definition
  201. ├── .claude-plugin/
  202. │ └── plugin.json # Claude Code adapter
  203. ├── .codex-plugin/
  204. │ └── plugin.json # Codex metadata
  205. ├── skills/
  206. │ └── jev-review/
  207. │ └── SKILL.md # Agent review workflow
  208. ├── src/
  209. │ ├── config/ # Environment handling
  210. │ ├── evaluation/ # Metrics, scoring, and comparisons
  211. │ ├── jev/ # Direct Jev client and validation
  212. │ └── mcp/ # MCP tool boundary
  213. ├── dist/
  214. │ └── server.js # Committed standalone server bundle
  215. ├── public/
  216. │ └── jev-review-demo.mp4 # Product demonstration
  217. └── test/ # Unit and MCP protocol tests
  218. ```
  219. `plugin.json` and `mcp.json` are the portable [Agent Plugins 1.0](https://agent-plugins.org/specification) package. `.claude-plugin/plugin.json` and `.mcp.json` provide Claude Code compatibility, while `.codex-plugin/plugin.json` supplies Codex metadata. These are small packaging adapters around one MCP implementation.
  220. ## Development
  221. ```bash
  222. git clone https://github.com/NiazMorshed2007/jev-review.git
  223. cd jev-review
  224. npm install
  225. npm run validate
  226. ```
  227. Useful commands:
  228. ```bash
  229. npm run check
  230. npm test
  231. npm run build
  232. npx plugins discover .
  233. claude plugin validate . --strict
  234. ```
  235. `npm run build` creates the committed `dist/server.js` bundle. Unit and MCP protocol tests use local fakes and do not consume Jev API quota; a live Jev call requires `JEV_API_KEY`.
  236. ## Security and privacy
  237. The local MCP process reads `JEV_API_KEY` and uses it only in the TLS Authorization header sent directly to `https://api.typesafe.ai/v1/systemone`. Jev Review never stores or logs the key.
  238. Only the `task`, `diff`, `files`, and `repositoryContext` explicitly supplied to `jev_review` are sent to Jev. `previousEvaluation` is compared locally and is not included in the current code context. No repository files are discovered or uploaded automatically.
  239. Review context does leave your machine for TypeSafe's Jev API. Do not supply secrets or unrelated proprietary content, and review [TypeSafe's privacy policy](https://typesafe.ai/privacy) for the remote service's handling terms. Jev Review complements rather than replaces dedicated security tooling.
  240. ## License
  241. [MIT](LICENSE)

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.