reverseport

<div align="center">

# ReversePort

### Reverse engineer anything. Port it anywhere.

**One CLI and one MCP server that let your coding agent take apart apps, games, binaries and websites — and rebuild them.**

[![MCP tool catalog](https://img.shields.io/badge/MCP-tool_catalog-5c4ee5?style=flat-square)](docs/mcp-contracts.md#generated-catalog)
[![License: MIT](https://img.shields.io/badge/license-MIT-22c55e?style=flat-square)](LICENSE)
[![Node.js](https://img.shields.io/badge/Node.js-22.19%2B-339933?style=flat-square&logo=nodedotjs&logoColor=white)](docs/installation.md)
[![Rated by agents](https://img.shields.io/badge/rated_by-agents-f59e0b?style=flat-square)](AGENT-RATINGS.md)
[![Agents](https://img.shields.io/badge/agents-Claude_Code_·_Codex_·_Cursor_·_Gemini_·_Copilot_·_more-111827?style=flat-square)](docs/installation.md#supported-agents)

```bash
npx reverseport setup
```

[Quick start](#quick-start) · [Every agent](#works-with-every-agent) · [What it does](#what-it-does) · [Prompts to try](#prompts-to-try) · [CLI](#cli) · [Tools](#tools) · [Docs](#documentation)

</div>

---

See a feature you like in an app or a game? Ask your agent how it works — down to the decompiled function — and
then ask it to build your own version. Have a game in Godot and want it in Unity? Ask your agent to port it, unit by
unit, verified. No files at all? Give it a name or a store page.

ReversePort gives agents one consistent way to do all of that:

- 🔍 **Understand anything** — engine and version of any project or exported game, dependency graphs, scenes,
  symbols in 30+ languages, executables, packs and unknown data. No build step, no dependencies.
- 🧠 **Go deep** — decompile, cross-reference and trace native, managed (.NET), Android, Electron/JavaScript,
  WebAssembly, firmware and browser targets through Ghidra, Hopper, IDA, JADX and more. ReversePort installs and
  drives the tools for you and shows the evidence behind every conclusion.
- 🌐 **No files? Still recon** — a name, a store page, a website or a public repo is enough to learn the engine,
  stack, file layout and open-source remakes from public sources.
- 🧩 **Rebuild precisely** — turn what you learned into a clean-room rebuild spec: every system, the parameters to
  measure on the original, a parity table and a project skeleton with every value as a tunable.
- 🚚 **Port for real** — Godot ⇄ Unity, Godot → Unreal, Godot → three.js, GDScript → C#, or language to language.
  Scenes and transforms convert automatically; code is ported by your agent with API maps; `port_verify` proves
  nothing was left behind.
- 🔒 **Local** — runs on your machine. Targets are only read; output goes to new folders. Nothing is uploaded to an
  analysis service and there is no extra API bill.

## Quick start

### 1. Connect your agent

With Node.js 22.19 or newer:

```bash
npx reverseport setup
```

Pick your agents, review the changes and approve. Setup registers one MCP server and installs the matching skill,
with backups of existing configuration. Restart your agent afterwards. Setup supports Claude Code, Codex, Cursor,
Gemini CLI, GitHub Copilot, OpenCode and [more agents](docs/installation.md#supported-agents); other clients can use
[manual MCP registration](docs/installation.md#mcp-registry).

**Claude Code plugin** (instead of setup for Claude Code — includes the server, the porting skills and the
`port-architect` agent; do not use both):

```text
/plugin marketplace add laaielichter/reverseport
/plugin install reverseport@reverseport
```

**From source:**

```bash
git clone https://github.com/laaielichter/reverseport && cd reverseport
npm ci && npm run build
./bin/reverseport.mjs setup
```

The recon, build-inspection, lookup, blueprint and porting commands already work right after `git clone`, with no
install at all: `node bin/reverseport.mjs scan ./MyGame`.

### 2. Ask your agent

```text
Understand how search works in the Notes app, show me the evidence, and build a similar feature for my project.
```

That's it. The agent picks the tools; you get answers with the evidence behind them.

## Works with every agent

Any vendor, any framework, any model size — the same tools through the door that fits:

- **MCP**: `npx -y reverseport@latest setup` configures installed agents; `reverseport connect <client>` prints the
  snippet for any other MCP client (Windsurf, Cline, Continue, Zed, Goose, LM Studio, VS Code…).
- **MCP over HTTP**: `reverseport serve` → `http://127.0.0.1:32147/mcp`.
- **Function calling**: `/api/agent/tools?format=openai-strict|responses|anthropic|gemini`, plus OpenAPI 3.1 at
  `/api/openapi.json` for GPT Actions, LangChain, LlamaIndex, Semantic Kernel, CrewAI, AutoGen and n8n.
- **Shell-only agents**: JSON on stdout, errors as JSON on stderr, `reverseport describe <tool>`.

Built for the agent's circumstances too:

- **A short list by default.** About 45 tools are listed instead of almost 200. Every other tool is one call away:
  `engine_tools` finds it and `engine_call` runs it.
- **The list fits the agent.** Small or older models use `compact`, large-context agents use `full`, and an agent
  can switch itself with `set_tool_profile`.
- **One error shape everywhere**, with a code, whether retrying helps, and the exact next step.
- **A `next` field wherever there is an obvious next step** (graphs, truncated results, every porting step), with the exact call.
- **Agents are heard.** `share_feedback` leaves a note for the maintainers; it stays on the user's machine until
  they share it.

See [Connect any agent](docs/connect-any-agent.md).

## Prompts to try

| You ask                                                                  | ReversePort does                                                                |
| ------------------------------------------------------------------------ | ------------------------------------------------------------------------------- |
| _What is this game made with, and how is it built?_                      | `re_scan` → engine + version, languages, entry points, how it starts            |
| _Map this codebase and write ARCHITECTURE.md._                           | `re_graph`, `re_symbols`, `re_report`                                           |
| _What changed between build 43 and 44?_                                  | `re_compare` folder-to-folder and pack-to-pack, biggest changes first           |
| _Decompile the function that saves settings in this app and explain it._ | opens the binary, finds it, decompiles it, shows the evidence                   |
| _How does this Electron app talk to its native side?_                    | maps modules, IPC and Electron boundaries                                       |
| _What is `<some game>` made with? I don't have the files._               | `re_lookup` from public sources: engine with confidence, stack, layout, remakes |
| _Rebuild the movement of `<game>` as precisely as possible in Godot._    | `re_blueprint`: systems, parameters to measure, parity table, skeleton          |
| _Port my Godot game to Unity._                                           | `port_plan` → `port_unit`/`port_write` loop → `port_scene` → `port_verify`      |

```text
You:    Port my Godot game to Unity.
Agent:  re_scan → Godot 4.3, 6 scripts, 5 scenes, main scene main.tscn, autoload Global
        port_plan → 13 units, dependencies first; Unity scene builder + PORT-PLAN.md created
        port_unit / port_write × 7 → C# MonoBehaviours (signals → events, $Node → [SerializeField])
        port_scene × 5 → prefab and scene specs, transforms mirrored to Unity's axes
        port_verify → passed: 13/13 units, 0 leftovers, 0 missing functions
```

## What it does

### Understand and go deep

| Target                             | What you get                                                                                                                                                                        | Needs                                                                          |
| ---------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------ |
| Source projects and exported games | Engine + version (Godot, Unity, Unreal, GameMaker, RPG Maker, Ren'Py, LÖVE, Defold, Bevy, MonoGame, web, Electron, Flutter, .NET, Go, Rust…), dependencies, cycles, scenes, symbols | Nothing                                                                        |
| Packs and archives                 | Godot `.pck` (also embedded in the `.exe`), zip/apk/jar, `.unitypackage`, tar.gz, asar — list and extract                                                                           | Nothing                                                                        |
| Native binaries                    | Mach-O, ELF, PE, wasm: functions, pseudocode, strings, xrefs, call paths, layout                                                                                                    | Ghidra, Hopper or IDA for decompilation ([setup](docs/installation.md#hopper)) |
| .NET assemblies                    | Metadata, CIL, native boundaries, build comparisons                                                                                                                                 | Nothing                                                                        |
| Android                            | Manifest, classes, decompiled methods, references, resources, devices                                                                                                               | JADX / Apktool / adb ([guide](docs/android-analysis.md))                       |
| JavaScript and Electron            | Modules, imports, source maps, Electron boundaries, runtime observation