Api Governance

io.github.coderiftsPublished by GitHub account coderiftsv1.0.3Updated Oct 24, 2026

Signed, offline-verifiable contract-change authorization. Only a granted change can proceed.

VerifiedStreamable HTTPWeb executableDeveloper ToolsSecurity & Monitoring

Overview

AI-generated overview

Hosted MCP server that preflights API contract changes, issues signed governance decisions and verifies receipts before a change merges or an agent acts.

What you can do
  • Preflight a base-to-head change set of contract artifacts (OpenAPI, GraphQL, protobuf, AsyncAPI, MCP manifests, agent tool schemas) and get breaking-change analysis and a risk score
  • Authorize a change to receive a governance decision (ALLOW, WARN, REQUIRE_APPROVAL, BLOCK) and a signed chain-receipt
  • Verify a receipt you already hold for signature authenticity, body binding and current authorization for a stated operation and target
  • Look up a past decision by case, decision or fingerprint identifier, including its report, breaking changes, scores and linked receipt metadata
When to use it
Use it when an API or tool contract is about to merge, deploy, publish or be registered, and you want a deterministic, fail-closed check rather than an AI compatibility scan. Also useful when an agent must prove a held receipt still authorizes the operation it is about to perform.
Requirements
Remote Streamable HTTP endpoint; no local runtime or package needed. An API key is required only for authorize calls, sent as an Authorization Bearer header or an X-API-Key header; analyze calls, initialize and tools/list work without a key. Network access to the hosted endpoint.
Before you install
The API key is a credential sent in the Authorization or X-API-Key header; keep it out of shared configs and logs. Authorize calls mint signed receipts and record decisions on the provider's servers, so contract artifacts you submit leave your machine. Analyze results are informational only (may_execute is false) and must not be treated as permission; branch on execution_action and fail closed on unknown values.

Installation

In SourceWeft

  1. Open Api Governance in the dashboard and add it to a workspace.
  2. Enable the server for the chats that should use its tools.

Web executable via Streamable HTTP. Remote servers run from the web runtime once configured in a workspace.

Use with an agent

Paste this prompt into Claude Code, Codex, Cursor or another agent — or into SourceWeft chat. The agent reads this server's install guide, shows you its publisher, endpoint and sign-in, and adds it to your client once you agree. Keys never go into a command.

Read https://sourceweft.com/mcp/io.github.coderifts%2Fapi-governance/install.md and connect the MCP server it describes to my client. Before changing any config, show me its publisher, endpoint and sign-in method and wait for my OK. Never put an API key in a command or in a file I would commit; ask me where it should come from.

Read the install guide the agent follows

Other MCP clients

Add this to your client's mcpServers config.

{
  "mcpServers": {
    "api-governance": {
      "type": "http",
      "url": "https://app.coderifts.com/mcp"
    }
  }
}

README

CodeRifts — contract-change authorization

Only a granted change can proceed. Before a contract change merges, deploys or registers, CodeRifts decides whether it is authorized — and the check is red without a grant.

One grant binds three things: the authorization, its single use, and the target state the change moves to. The decision is signed, and the receipt verifies offline — you do not have to trust our database to check what was authorized.

Every decision also names what it does not prove.

  • Hosted MCP server: https://app.coderifts.com/mcp
  • Manifest: https://coderifts.com/mcp.json — the canonical published document. The mcp.json at the root of this repository is a pointer to it, not a second copy.
  • Official MCP Registry: io.github.coderifts/api-governance
  • Website: https://coderifts.com
  • Live demo PR: https://github.com/coderifts/demo/pull/4

Install

text
# Claude Code/plugin marketplace add coderifts/api-governance/plugin install api-governance@coderifts
# Any MCP client (Streamable HTTP) — add to its MCP config{ "mcpServers": { "coderifts": { "url": "https://app.coderifts.com/mcp",  "headers": { "Authorization": "Bearer <YOUR_CODERIFTS_API_KEY>" } } } }
# SDKsnpm install @coderifts/sdkpip install coderifts-sdk

GitHub Copilot reads the same server under three different root keys — servers in .vscode/mcp.json, mcpServers in the cloud agent's MCP settings, and mcp-servers in a custom agent's frontmatter — and npx coderifts copilot-setup writes all three (details below).

A key is needed only to authorize; get one at https://app.coderifts.com/api/signup.


Claude Code plugin

Install the CodeRifts marketplace, then the api-governance plugin (MCP server + skill). Requires CODERIFTS_API_KEY for tool calls.

text
/plugin marketplace add coderifts/api-governance/plugin install api-governance@coderifts

Local checkout (after clone):

text
/plugin marketplace add ./plugin install api-governance@coderifts

The plugin wires the hosted MCP at https://app.coderifts.com/mcp and the api-governance skill. Tools exposed: preflight_change_set, verify_receipt, get_decision_details only.


Cursor plugin

Cursor Plugin package (measured Cursor layout: .cursor-plugin/plugin.json + skills/ + rules/ + mcp.json + hooks/hooks.json). Same hosted MCP and the same three tools as the Claude plugin — no fourth tool. Deterministic / signed / fail-closed — not an AI compatibility scan.

PathRoleSource of truth
plugins/api-governance-cursor/.cursor-plugin/plugin.jsonCursor Plugin manifestcursor/plugins plugin.schema.json
plugins/api-governance-cursor/skills/coderifts/SKILL.mdSkill (name: coderifts)Generated — coderifts-app scripts/generate-skill-carriers.js; the website .well-known/agent-skills/coderifts/SKILL.md is vendored from it
plugins/api-governance-cursor/rules/coderifts.mdcCursor ruleGenerated — generate-agent-host-files.js
plugins/api-governance-cursor/mcp.jsonStreamable HTTP MCP wiringSame endpoint as Claude .mcp.json (not the website tool-card)
plugins/api-governance-cursor/hooks/hooks.jsonpreToolUse adapter, failClosed: trueCLI coderifts cursor-hook on Write|Delete — same shape as the app's generated .cursor/hooks.json
.cursor-plugin/marketplace.jsonCursor marketplace entryCursor marketplace.schema.json

Validate:

bash
npm run validate:cursor

The generated-rule check is LIVE when CODERIFTS_APP_ROOT (default ~/coderifts-app) has generated/agent-host/.cursor/rules/coderifts.mdc, and RECORDED against fixtures/recorded/app-generator when it does not (weaker, named). A missing or corrupt snapshot still exits 1 — no silent skip.


OpenAI / Codex package

Codex plugin package (measured OpenAI Codex layout: .codex-plugin/plugin.json + .mcp.json + skills/ + AGENTS.md). Same hosted MCP and the same three tools as the Claude plugin — no fourth tool.

PathRoleSource of truth
plugins/api-governance-openai/.codex-plugin/plugin.jsonCodex plugin manifestCodex plugin-json-spec (scaffold skill)
plugins/api-governance-openai/.mcp.jsonStreamable HTTP MCP wiringSame endpoint as Claude .mcp.json
plugins/api-governance-openai/skills/api-governance/SKILL.mdSkill + tool listTrigger wording from agent-setup rule; tool names/descriptions from generated mcp.json
plugins/api-governance-openai/AGENTS.mdAgent rules fileGenerated — coderifts agent-setup / generate-agent-host-files.js
plugins/api-governance-openai/openai-agent-instructions.mdOpenAI Agents SDK instructionsGenerated — same generator
plugins/api-governance-openai/docs/openai-production-pattern.mdProduction pattern (ID108) — host dispatch loop with executeOpenAIToolCallHand-authored recipe on shipped @coderifts/agent-guard ≥ 6.4.0 (first npm release that exports executeOpenAIToolCall; current npm 17.3.3)
plugins/api-governance-openai/scripts/smoke-execute-openai-tool-call.mjsOffline smoke (ALLOW + BLOCK; no OpenAI key)Real dispatcher + stub client
.agents/plugins/marketplace.jsonCodex marketplace entryCodex marketplace schema

Production pattern (function-calling apps)

OpenAI’s model only emits tool_call JSON; your app executes it. Wire governance at that host loop — not as a Claude-style PreToolUse hook. Full steps + one canonical loop:

→ plugins/api-governance-openai/docs/openai-production-pattern.md

bash
# Offline smoke (needs ~/coderifts-agent-guard built, or CODERIFTS_AGENT_GUARD_ROOT)npm run smoke:openai-dispatch

⚠ Still failing on the same one assertion, re-measured 2026-09-24: ALLOW factory ran — execute() did not run. The other eight assertions pass (4 ALLOW, 5 BLOCK), and the BLOCK side — the side that matters for a gate — is fully green: the factory does not run, the content is the gate denial with no fabricated success, and the decision identity is surfaced. The failing assertion is on the ALLOW path, where the dispatch wrapper returns the function result without having invoked the injected factory.

The 2026-09-14 version of this note ended "Investigation is in progress." That was dropped rather than re-dated: ten days on, it is a claim about activity that nothing here can verify, and a README that reports its own diligence is reporting the one thing a reader cannot check. What a reader can check is the assertion name and today's date.

Local checkout in Codex (team marketplace path):

text
# From a clone of this repo, point Codex at .agents/plugins/marketplace.json# then install api-governance-openai (UI / plugin install — see Codex plugin docs).

Validate package consistency (manifest, tool parity, AGENTS.md empty-diff vs regeneration):

bash
npm run validate:openai# or: node scripts/validate-openai-package.js

AGENTS.md regeneration is LIVE when ~/coderifts-app (or CODERIFTS_APP_ROOT) exists, and RECORDED against fixtures/recorded/app-generator when it does not (weaker, named). A missing or corrupt snapshot still exits 1. Directory listing / account submission steps are not automated here.


GitHub Copilot kit

Reference copies of the generated Copilot MCP configs + instructions (single source: coderifts-app generators). Same hosted MCP and the same three tools — no fourth tool.

Primary install (living command — prefer this over copying from the kit):

bash
npx coderifts copilot-setup# optional: --out <dir>   --check (drift-gate)   --force

Agent-host instructions (including .github/copilot-instructions.md) come from:

bash
npx coderifts agent-setup

Three Copilot surfaces (root keys differ)

From the generated guide (copilot/docs/copilot-mcp.md — do not re-author this table):

SurfaceConfig locationRoot keyAuth
VS Code / Copilot Chat.vscode/mcp.jsonservers${input:coderifts_api_key} + inputs[]
Copilot cloud agent + code reviewRepo Settings → Copilot → MCP servers (paste JSON)mcpServersAgents secret COPILOT_MCP_CODERIFTS_API_KEY in headers
Custom agent (org/enterprise)Agent profile .md YAML frontmattermcp-servers${{ secrets.COPILOT_MCP_CODERIFTS_API_KEY }}

Tools allowlisted everywhere: preflight_change_set, verify_receipt, get_decision_details.

Vendored reference tree (copilot/)

PathRoleSource of truth
copilot/.vscode/mcp.jsonVS Code / Copilot ChatGenerated — generate-copilot-mcp.js
copilot/copilot-cloud-agent-mcp.jsonCloud agent paste JSON (mcpServers)Generated — same
copilot/copilot-custom-agent-mcp.frontmatter.mdCustom agent YAML frontmatterGenerated — same
copilot/docs/copilot-mcp.mdInstall guide + surfaces tableGenerated — same
copilot/.github/copilot-instructions.mdCopilot coding-agent instructionsGenerated — generate-agent-host-files.js
copilot/SOURCE.mdProvenance + re-sync commandsPackaging note (this repo)

Validate empty-diff vs regeneration + 3-tool discipline:

bash
node scripts/validate-copilot-kit.js

Empty-diff vs regeneration is LIVE when CODERIFTS_APP_ROOT has the generators, and RECORDED against fixtures/recorded/app-generator when it does not (weaker, named). A missing or corrupt snapshot still exits 1. The kit is a communication / distribution mirror — npx coderifts copilot-setup remains the install path.


Agent Skill (skills.sh)

bash
npx skills add coderifts/api-governance

The skills CLI discovers skills/api-governance/SKILL.md at this repository's root and installs it under the name api-governance. Where it lands depends on the agent (the CLI's own table): .agents/skills/api-governance/ for most agents (Codex, Cursor, Gemini CLI, GitHub Copilot, OpenCode, …) and .claude/skills/api-governance/ for Claude Code.

One skill, one name (2026-09-29). The three SKILL.md carriers — Claude (plugins/api-governance/skills/api-governance/), Cursor (plugins/api-governance-cursor/skills/coderifts/) and Codex/OpenAI (plugins/api-governance-openai/skills/api-governance/) — carry the same body byte for byte and the same name: coderifts, the name skills.sh lists (npx skills add coderifts/api-governance installs ./.agents/skills/coderifts/, measured 2026-09-29). Only the frontmatter description is per host. All three are generated by coderifts-app scripts/generate-skill-carriers.js from agent/skills/coderifts/SKILL.md; test/one-skill.test.js holds them together. The website's .well-known/agent-skills/coderifts/SKILL.md is the Cursor carrier, vendored.

MCP server

CodeRifts runs as a hosted Streamable HTTP MCP server. Any MCP-compatible agent (Claude Desktop, Cursor, LangGraph, AutoGen, custom) can connect and run governance checks before tool calls or merges.

  • Endpoint: https://app.coderifts.com/mcp
  • Transport: Streamable HTTP (protocol version 2025-06-18)
  • Server: CodeRifts API Governance v1.0.3 — read from initialize → result.serverInfo.version on 2026-09-24. A version typed into a README is a claim with a date on it; npm run validate:tools-wire compares the TOOLS to the live server on every push, pull request and daily cron, but nothing compares this line, so re-read it rather than trust it.
  • Auth: initialize, tools/list and an analyze tools/call need no key (measured live 2026-09-26). An authorize call mints a signed receipt and needs an API key — send Authorization: Bearer <key> or X-API-Key: <key>.

Connect

json
{  "mcpServers": {    "coderifts": {      "url": "https://app.coderifts.com/mcp",      "headers": {        "Authorization": "Bearer <YOUR_CODERIFTS_API_KEY>"      }    }  }}

Verify the connection

bash
curl -sS https://app.coderifts.com/mcp \  -H 'Content-Type: application/json' \  -H 'Accept: application/json, text/event-stream' \  -d '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-06-18","capabilities":{},"clientInfo":{"name":"curl","version":"1.0"}}}'

Expected: a JSON-RPC result with serverInfo and capabilities.tools.

Try without a key

An analyze call over MCP needs no key:

bash
curl -sS https://app.coderifts.com/mcp \  -H 'Content-Type: application/json' \  -H 'Accept: application/json, text/event-stream' \  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"preflight_change_set","arguments":{"preflight_mode":"analyze","artifacts":[{"id":"api","type":"openapi","before":"openapi: 3.0.0\ninfo: {title: Pets, version: 1.0.0}\npaths:\n  /pets:\n    get:\n      responses:\n        \"200\":\n          description: ok\n          content:\n            application/json:\n              schema:\n                type: object\n                properties:\n                  id: {type: string}\n                  name: {type: string}\n","after":"openapi: 3.0.0\ninfo: {title: Pets, version: 1.0.0}\npaths:\n  /pets:\n    get:\n      responses:\n        \"200\":\n          description: ok\n          content:\n            application/json:\n              schema:\n                type: object\n                properties:\n                  id: {type: string}\n"}]}}}'

Measured response (live, 2026-09-26 — removing name from GET /pets), in the tool result:

json
{ "preflight_mode": "analyze", "analysis_outcome": "BREAKS_DETECTED",  "authorization_effect": "NONE", "may_execute": false, "receipt_kind": "NONE",  "breaking_changes": 1, "risk_score": 14 }

That is information, not permission: may_execute is false on every analyze answer. To act, call again with preflight_mode: "authorize" and context.operation, with a key.

Two public REST endpoints need no auth at all:

bash
curl -s "https://app.coderifts.com/api/v1/public/preflight?url=https://petstore3.swagger.io/api/v3/openapi.json"
curl -s -X POST https://app.coderifts.com/api/v1/public/actionguard-check \  -H "Content-Type: application/json" \  -d '{"filename":".github/workflows/ci.yml","base_content":null,"head_content":"jobs:\n  b:\n    steps:\n      - uses: some-owner/some-action@main"}'

Both return HTTP 200 without a key. They do not share a response shape:

  • GET /api/v1/public/preflight is analyze-only. There is no decision field. The body carries analysis_outcome (Petstore URL: NO_BREAK_DETECTED), authorization_effect: NONE, and may_execute: false.
  • POST /api/v1/public/actionguard-check does return a decision field (unpinned uses: @main payload: WARN) plus execution_action: CONTINUE_WITH_MONITORING.

Tools

The hosted MCP server exposes exactly three tools (from live tools/list; pinned in this repository as tools.wire.v1.json, which npm run validate:tools-wire checks against the live server on every push, pull request and the daily cron):

ToolWhat it does
preflight_change_setPreflight a complete base→head change set of contract artifacts. Returns risk score and breaking-change analysis. With preflight_mode: "authorize" (and context.operation), returns a governance decision (ALLOW / WARN / REQUIRE_APPROVAL / BLOCK) and may mint a signed chain-receipt. With preflight_mode: "analyze", returns informational risk only (may_execute: false, no decision, no receipt). Requires artifacts + preflight_mode.
verify_receiptVerify a signed chain-receipt you already hold: signature authenticity, body binding, and (when lifecycle indices are available) whether it is currently authorized for a stated operation/target. Requires token. Does not re-diff specs.
get_decision_detailsRetrieve a past decision by decision_id (preferred) or fingerprint: stored report, breaking changes, scores, and linked receipt metadata if present. Not for a new analysis of the current change set.

On the authorize path of preflight_change_set, the decision envelope includes fields such as decision, execution_action, risk_score, safe_for_agent, and related analysis fields so agent runtimes can branch on a stable contract. Prefer branching on execution_action when present.


How agents use it

  1. Before merging an API change (or before an agent acts on a contract change), call preflight_change_set with full before/after artifacts and preflight_mode: "authorize" (plus context.operation).
  2. Branch on execution_action only: CONTINUE proceeds, CONTINUE_WITH_MONITORING proceeds with a wired monitoring sink, REQUEST_APPROVAL pauses for a human, STOP stops the merge / aborts the agent step. Any other value is not permission — fail closed.
  3. Before acting under the receipt you hold, call verify_receipt with the same context the preflight was made under, and act only when currently_authorized is true. Do not re-preflight unless the change set or operation changed.
  4. To inspect a prior decision by id, call get_decision_details.

Decision logic is deterministic: a single breaking change is never silently allowed. Tests can pass and still ship a broken contract — CodeRifts checks the contract itself at PR time.


Also available

  • GitHub App on the GitHub Marketplace — installs without configuration and posts a signed contract-change decision (ALLOW / WARN / REQUIRE_APPROVAL / BLOCK) on every pull request, across four gates: API contract, schema-vs-code, auth surface and workflow actions. ⚠ It reports by default: the check's phase-1 conclusion is clamped to neutral and MERGEGATE_ENFORCE defaults false, so it prevents a merge only once the check is required on the branch and that variable is on. The platform truth table is the source of truth for that distinction: https://coderifts.com/docs/platform-truth-table/
  • SDKs: npm install @coderifts/sdk (TypeScript), pip install coderifts-sdk (Python).
  • CLI: coderifts (npm) with a pre-push hook.
  • Integrations: Backstage plugin, VS Code extension, LangGraph / AutoGen / CrewAI.

Links

License

See LICENSE.

Source: README.md at commit b22a061

Tools

3

preflight_change_set

Use this when: a contract artifact (OpenAPI, GraphQL, protobuf, AsyncAPI, MCP manifests, or agent tool schemas) changes before merge, deploy, publish, or tool registration; AND any agent-executed operation with no supported contract type — send type agent_operation. Do not call for documentation-only changes, static readiness scoring, or receipt verification. Use analyze for risk only; authorize requires context.operation. Skipping this call is not permission. Absence of a key is not permission. Inputs: preflight_mode is required: "analyze" (risk only; no receipt, no execution_action) or "authorize" (may mint a receipt; requires context.operation — merge is not deploy is not publish). Supply exactly one artifact source: artifacts[] (1–20 items, each {id, type, before, after} as the FULL spec/schema text, not a path or URL; type is openapi|graphql|grpc|asyncapi|mcp_manifest|agent_tools|agent_operation) XOR derivation="server" (server reads GitHub Compare; needs context.repository + context.base + context.head; sending artifacts[] together is 400). Grant fields sit in one object, execution_grant_request {include_execution_grant, grant_version, tenant_id, executor_id, adapter_id, target_uri, expected_state_token, state_nonce, audience, policy_hash}; analyze ignores it; required is preflight_mode only. previous_receipt is a chain token base64url(body).base64url(signature) to LINK a prior decision — it does not re-verify; use coderifts.verify_receipt instead; for details of a past decision use coderifts.get_decision_details instead. idempotency_key replays authorize only (24h), never analyze.

Parameterscontextartifactsderivationpreflight_moderequiredidempotency_keyresponse_detailprevious_receiptdecision_spec_versionexecution_grant_request

verify_receipt

Verify a CodeRifts signed chain-receipt you ALREADY HOLD: cryptographic authenticity (signature + key id), body binding, and — when lifecycle indices are available — whether it is currently valid authorization (not expired, superseded, or revoked) for a stated operation/target. Use this when: - You already obtained a chain_receipt / receipt token from a prior preflight (or CI artifact) and are about to act (merge/deploy) under that receipt. - A contract-gate or policy requires offline/online proof that the receipt is authentic for this change before proceeding. - You must distinguish "signature ok" from "currently authorized" (stale or superseded receipts must not be treated as live approval). Do not use when: - You do not have a receipt yet — call coderifts.preflight_change_set first. - You need a NEW decision for a changed base→head set — preflight again; verify_receipt does not re-diff specs. - The receipt you hold binds a different operation or target than the one you are about to perform — call coderifts.preflight_change_set with context.operation set to that operation (a merge receipt does not authorize a deploy); verify_receipt cannot re-scope or re-issue a decision. - You only need human-readable history of an old decision_id without a receipt token — use coderifts.get_decision_details. - The change set itself is unknown or incomplete — fix the change set and preflight; do not "verify" a placeholder. Inputs: receipt token (required); target_id = decision_result.artifact_digest — required for an authorization verdict; omitted → target_not_stated. Optional intended context (operation, environment, fingerprint, audience, repository/branch/pull_request, base/head) and the body_hash-bound decision_result envelope. 30s clock-skew leeway on expiry. A 0s grace for declared destructive production operations is defined in the policy but is unreachable today: the intended-context schema has no destructive field, so nothing can declare one and the 3

Parametersbaseheadtokenrequiredbranchaudienceoperationtarget_idrepositoryenvironmentfingerprintpull_requestdecision_result

get_decision_details

Retrieve a PAST CodeRifts decision by exactly one identifier (case_id | decision_id | fingerprint): full report, breaking changes, scores, and linked receipt metadata if stored. Use this when: - You have a decision_id (or fingerprint) from a previous preflight, PR comment, or CI log and need to inspect or explain that past decision. - You are auditing why a prior ALLOW/WARN/BLOCK was issued. - You are NOT requesting a new analysis of current before/after specs. Do not use when: - You need a decision for the CURRENT uncommitted or PR head change set — call coderifts.preflight_change_set with the current artifacts. - You hold a receipt token and only need cryptographic/lifecycle verification — use coderifts.verify_receipt. - You have no identifier — run preflight first to create one. Inputs: exactly one of case_id, decision_id, or fingerprint. {} → INVALID_INPUT; two identifiers → LOOKUP_IDENTIFIER_CONFLICT; case_id → CASE_NOT_FOUND (lookup never opens a case). Returns the stored document or not_found. Scoping — fingerprint lookup returns only YOUR OWN decisions. A fingerprint is derived from content, not from an account, so two callers who preflight byte-identical specs derive the same one; the lookup is therefore constrained to the decisions your credential can prove it owns. A decision that exists but is not yours returns the SAME not_found as one that was never issued. This is deliberate: a distinguishable "exists but forbidden" would confirm to any caller that a given content hash had been decided on by someone, which is the fact the scoping exists to withhold. Do not read not_found as proof that no such decision exists anywhere. Decisions persisted without context.repository cannot currently be attributed to an account, and are not retrievable by fingerprint at all — not by their owner either. Retrieve those by decision_id, which is unchanged and unscoped. This is a limitation of what older stored rows carry, not a property of the lookup: rows writte

Parameterscase_iddecision_idfingerprint

Version history

2
  1. v1.0.3LatestSep 20, 2026
  2. v1.0.2Sep 16, 2026

Score

100% of the applicable checks met

How complete this listing is, computed from the registry entry, the endpoint and public sources. Not a rating of the server and not a statement that it is safe or working today: reachability is a dated check, and no installs or reviews go into the score.

  • Reached in the last 30 daysRequired25 pts
  • Auth declaredRequired10 pts
  • Tools listedRequired15 pts
  • DescriptionRequired15 pts
  • Logo10 pts
  • Documentation15 pts
  • License10 pts