OrangePro

Find the behaviors your tests miss. Generate grounded tests that actually run.

opro builds a knowledge graph from your local checkout, maps every behavior in your code, shows which ones are tested and which aren't, and generates integration-level tests grounded in real symbols — not hallucinated imports. Runs as a CLI and an MCP server.

npx @orangepro/mcp-server
cd /path/to/your/repo
opro

That's it. You get:

.orangepro/
├── behavior-coverage.html   ← open this: interactive gap report
├── rtm.md                   ← requirements traceability matrix
└── evidence-pack.json       ← machine-readable metadata export

Install

# No install needed (npx)
npx @orangepro/mcp-server

# Or global install
npm install -g @orangepro/orangepro-mcp

# Or from source
git clone https://github.com/OrangeproAI/orangepro-mcp.git
cd orangepro-mcp && npm ci && npm run build && npm link

Related MCP server: GPA Backend Test Analyst MCP

Use with your coding agent

OrangePro runs as an MCP server. Any MCP-compatible agent (Cursor, Claude Code, Codex, Copilot, OpenCode) can drive it.

Setup

Add to your client's MCP config:

{
  "mcpServers": {
    "orangepro-local": {
      "command": "npx",
      "args": ["-y", "@orangepro/mcp-server@latest", "mcp"]
    }
  }
}

The workflow

Tell your agent:

"Use orangepro_start, then orangepro_generate_tests with base_ref=main. Write each test to its suggested_path, run it, and report pass/fail."

The agent writes the test, runs it, calls orangepro_prove, and the behavior turns Dynamically Proven. One prompt, full loop.

MCP tools (18 total)

CLI reference

opro                          # analyze + report + agent next actions
opro start --base main        # same, scoped to a branch diff
opro analyze                  # build the evidence graph
opro score                    # graph readiness (0–100)
opro gaps --limit 10          # top 10 untested behaviors
opro generate --base main     # tests for PR diff
opro generate --single        # top gap, whole repo
opro prove                    # mutation-kill oracle (use the prove_run args returned by generate)
opro rtm                      # traceability matrix
opro export                   # metadata-only evidence pack
opro mcp                      # run as MCP server (stdio)
opro doctor                   # what evidence to add next
opro coverage                 # ingest runtime coverage

Add --json to any read command for machine output. Run opro help for the full reference.

PR workflow

opro generate --base main              # tests for what this branch changed
opro generate --pr 1234                # checks out PR #1234 — mutates your working tree; needs gh + confirmation (prefer --base)
opro generate --changed                # current branch diff vs main

Each generated test includes:

• Grounding — the real files, symbols, and existing tests it cites

• Run hints — where to write it, how to run it

• Scenario bucket + technique — what failure mode it targets and how

Test categories

Generation is evidence-gated. A category is produced only when the graph has supporting evidence — never padded with generic filler. These are the public local generation buckets. The broader concern taxonomy used by planning prompts is not a public coverage taxonomy and does not change report tiers.

Evidence tiers

Every behavior gets exactly one tier. Nothing is labeled "tested" on faith.

"Dynamically Proven 0" is normal on first run. Static analysis always runs. Dynamic proof requires running tests against targeted mutations. That's the trust model — nothing is Dynamically Proven until a real test kills a real mutant.

Language support

OrangePro separates static mapping, generated tests, runtime coverage, and dynamic proof. Those are different confidence bars.

Static mapping works across many languages through tree-sitter and repo metadata. Dynamic proof is deliberately narrower: each language needs a runner, mutation locator, sandbox profile, and false-proof regressions before it can mint Dynamically Proven.

Model setup (BYOK)

Analysis, scoring, and proof need no model key. Generation does.

Auto-detect order: OpenAI → Ollama → Anthropic. Override with --provider and --model.

Run opro setup to configure interactively. Keys stay in your environment — never written to graph, config, or artifacts.

AI candidate lanes

With a provider key, OrangePro can stage weak AI behavior→symbol links and AI-suggested candidate flows. These are ready for local use as review/generation worklists, but they are not evidence:

• AI links appear as AI-linked suggestions.

• AI flows are stored separately from deterministic flows.

• Neither lane changes Dynamically Proven, Runtime-covered, Statically Linked, denominator counts, or evidence tiers.

Use them when you want the agent to find likely service-boundary flows faster; ignore them when you want a deterministic-only report.

How it works

OrangePro separates analysis (what your code does) from proof (whether tests actually verify it).

┌─────────────┐     ┌──────────────┐     ┌─────────────┐
│  Your Code  │ ──► │  Knowledge   │ ──► │  Evidence   │
│  (any lang) │     │    Graph     │     │   Tiers     │
└─────────────┘     └──────────────┘     └─────────────┘
                           │
                    ┌──────┴──────┐
                    ▼             ▼
             ┌───────────┐  ┌──────────┐
             │ Gap Report│  │ Generate │
             │ + Risks   │  │  Tests   │
             └───────────┘  └──────────┘

Privacy

• No stored source. Reads code in-process. Never uploads to an OrangePro server.

• No source mutation. Never edits your existing files. Writes metadata to .orangepro/.

• Metadata-only exports. File paths, names, hashes, scores — not raw source.

• Your keys stay yours. Read from env at call time, never persisted.

What's on the hosted platform

This repo is the free local tool. The OrangePro platform adds:

• Persistent knowledge graph across PRs and repos

• Managed dynamic proof at scale (larger budgets, CI workers, service setup profiles)

• PR/CI policy gates over Dynamically Proven, Runtime-covered, and risk deltas

• Jira / Confluence / TestRail / OpenAPI enrichment

• Cross-repo intelligence and recurring-flow memory

• Production incident correlation and regression targeting

• Full test lifecycle management and team dashboards

Contributing

npm run build       # compile to dist/
npm test            # vitest
npm run typecheck   # type check without emitting

See docs/local-proof-kit.md for the full development reference.

License

MIT © OrangePro