reverseport 0.0.0-stage → 1.0.0

package/port/cli.mjs

@@ -0,0 +1,195 @@
+#!/usr/bin/env node
+// ReversePort's own commands (recon, builds, lookups, blueprints, porting). Reached through `reverseport <command>`
+// (bin/reverseport.mjs), which also routes the deep-analysis engine's commands.
+//   reverseport scan ./MyGame
+//   reverseport binary Game.exe --strings.match "*.dll"
+//   reverseport archive Game.pck --action extract --match "*.gd"
+//   reverseport plan ./MyGame --to unity
+//   reverseport re_scene main.tscn            (tool names work too)
+//   reverseport port_write --request write.json
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { tools, callTool, VERSION } from './src/tools.mjs';
+import { workspaceRoot } from './src/workspace.mjs';
+import { isMainModule } from './src/main-module.mjs';
+import { errorPayload, formatTools, FORMATS, closest, readFeedback } from './src/agent.mjs';
+import { RPError } from './src/util.mjs';
+
+const ALIASES = {
+  scan: 're_scan', graph: 're_graph', symbols: 're_symbols', scene: 're_scene', binary: 're_binary', bin: 're_binary', archive: 're_archive', pck: 're_archive',
+  probe: 're_probe', extract: 're_extract', carve: 're_extract', compare: 're_compare', diff: 're_compare', 'compare-builds': 're_compare', report: 're_report',
+  lookup: 're_lookup', recon: 're_lookup', web: 're_lookup', blueprint: 're_blueprint', rebuild: 're_blueprint',
+  map: 'port_map', convert: 'port_convert', plan: 'port_plan', unit: 'port_unit', write: 'port_write', 'port-scene': 'port_scene', 'copy-assets': 'port_copy_assets', status: 'port_status', verify: 'port_verify',
+};
+const POSITIONAL = { re_scan: ['path'], re_graph: ['path'], re_symbols: ['path'], re_scene: ['file'], re_binary: ['file'], re_archive: ['file'], re_probe: ['file'], re_extract: ['file'], re_compare: ['a', 'b'], re_report: ['path'], re_lookup: ['query'], re_blueprint: ['name'], port_map: ['from', 'to'], port_convert: ['from', 'to'], port_plan: ['source'], port_unit: ['planId', 'unit'], port_write: ['planId', 'unit'], port_scene: ['planId', 'unit'], port_copy_assets: ['planId'], port_status: ['planId'], port_verify: ['planId'] };
+
+export function parseArgs(name, argv) {
+  const tool = tools.find(t => t.name === name);
+  const props = tool.inputSchema.properties ?? {};
+  const args = {};
+  const pos = [];
+  const coerce = (key, raw) => {
+    const top = key.split('.')[0];
+    const schema = key.includes('.') ? props[top]?.properties?.[key.split('.')[1]] : props[top];
+    if (raw === undefined) return true;
+    if (schema?.type === 'string') return raw;
+    try { return JSON.parse(raw); } catch { return raw; }
+  };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a.startsWith('--')) {
+      let [key, val] = a.slice(2).split(/=(.*)/s, 2);
+      if (val === undefined && argv[i + 1] !== undefined && !argv[i + 1].startsWith('--')) val = argv[++i];
+      if (key === 'json' || key === 'args') {
+        if (val === undefined || !/^\s*\{/.test(val)) { if (val !== undefined) pos.push(val); continue; } // bare --json: output is JSON anyway
+        try { Object.assign(args, JSON.parse(val)); } catch { throw new RPError('INVALID_ARGUMENT', `--${key} expects a JSON object, e.g. --args '{"path":"./Game"}'.`); }
+        continue;
+      }
+      if (key === 'pretty' || key === 'compact') { if (val !== undefined) pos.push(val); continue; }
+      const camel = key.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+      const v = coerce(camel, val);
+      if (camel.includes('.')) { const [k, sub] = camel.split('.'); args[k] = { ...(args[k] ?? {}), [sub]: v }; }
+      else args[camel] = v;
+    } else pos.push(a);
+  }
+  (POSITIONAL[name] ?? []).forEach((k, i) => { if (pos[i] !== undefined && args[k] === undefined) args[k] = pos[i]; });
+  if (name === 'port_convert' && pos.length > 2) for (const p of pos.slice(2)) { const [k, v] = p.split('='); if (v) { try { args[k] = JSON.parse(v); } catch { throw new RPError('INVALID_ARGUMENT', `${k}= expects JSON, e.g. position=[1,2,3].`); } } }
+  return args;
+}
+
+export async function doctor() {
+  const major = Number(process.versions.node.split('.')[0]);
+  const ws = workspaceRoot();
+  let writable = true;
+  try { await fs.mkdir(ws, { recursive: true }); await fs.writeFile(path.join(ws, '.doctor'), 'ok'); await fs.rm(path.join(ws, '.doctor')); } catch { writable = false; }
+  const [maj, min] = process.versions.node.split('.').map(Number);
+  const nodeOk = (maj === 22 && min >= 19) || (maj === 24 && min >= 11) || maj >= 26 || maj === 25 || maj === 23;
+  return { ok: nodeOk && writable, version: VERSION, node: process.versions.node, nodeOk, nodeRequired: '>=22.19 (22.x), >=24.11 (24.x) or newer', workspace: ws, workspaceWritable: writable, tools: tools.length, platform: `${os.platform()} ${os.arch()}` };
+}
+
+function help() {
+  return `ReversePort ${VERSION} — reverse engineer anything, port it anywhere.
+
+Usage: reverseport <command> [positional] [--key value] [--json '{…}'] [--request args.json]
+
+Reverse engineering
+  scan <folder>              engine, languages, entry points (projects and game builds)
+  graph <folder>             dependency graph, cycles, port order   (--format mermaid)
+  symbols <file|folder>      classes, functions, signals            (--match player)
+  scene <file>               Godot .tscn/.tres/project.godot, Unity .unity/.prefab
+  binary <file>              PE/.NET/ELF/Mach-O/wasm/class/dex      (--strings.match "*.dll")
+  archive <file>             .pck (also inside .exe), zip/apk/jar, tar.gz, asar  (--action extract --match "*.gd")
+  probe <file>               hex, entropy map, embedded files, record strides (--offset 4096)
+  extract <file> --offset N  carve bytes out (--length N)
+  diff <a> <b>               diff two folders, packs, binaries or files (builds)
+  report <folder>            write ARCHITECTURE.md
+
+Recon without files and rebuilds
+  lookup "<name>"            public dossier: engine, stack, structure, where files live, remakes  (--url, --steam-app-id, --github owner/repo --mirror)
+  blueprint --lookup-id <id> precise clean-room rebuild spec + parity table + project skeleton (--target godot)
+
+Porting
+  map [from] [to]            conventions + API map (godot→unity, unity→godot, godot→unreal, godot→threejs…)
+  convert <from> <to> position=[1,2,3] rotation=[0,0,0,1]   coordinates between engines
+  plan <source> --to unity   plan a port and scaffold the output project
+  unit <planId>              next unit with source, API hints, conventions
+  write <planId> <unit> --content "…" | --copy | --request write.json
+  port-scene <planId> <unit> convert a scene/prefab
+  copy-assets <planId>       copy all asset units
+  status [planId]            progress (no id: all plans)
+  verify <planId>            parity, leftovers, markers
+
+Other
+  tools [--all] [--format f] list the tools (--all adds the engine's when built); formats: ${FORMATS.join(', ')}
+  describe <tool>            one tool's description and input schema (engine tools too, when built)
+  feedback                   notes agents left with share_feedback (stays on this computer)
+  connect [client]           config snippet for any agent: MCP clients, HTTP/OpenAPI, OpenAI, Anthropic, Gemini, shell
+  serve                      HTTP API on http://127.0.0.1:32147 (REVERSEPORT_PORT)
+  mcp                        MCP server on stdio (these tools + the deep-analysis engine)
+  port doctor                check Node and the workspace (${workspaceRoot()})
+`;
+}
+
+export async function main(argv = process.argv.slice(2)) {
+  const [cmd, ...rest] = argv;
+  const compact = argv.includes('--compact');
+  const print = v => process.stdout.write(`${compact ? JSON.stringify(v) : JSON.stringify(v, null, 2)}\n`);
+  const printError = e => { process.stderr.write(`${JSON.stringify({ error: errorPayload(e) }, null, compact ? 0 : 2)}\n`); return e.code === 'INVALID_ARGUMENT' || e.code === 'UNKNOWN_TOOL' ? 2 : 1; };
+  if (!cmd || cmd === 'help' || cmd === '--help' || cmd === '-h') { process.stdout.write(help()); return 0; }
+  if (cmd === '--version' || cmd === 'version') { process.stdout.write(`${VERSION}\n`); return 0; }
+  if (cmd === 'tools') {
+    const fi = rest.indexOf('--format');
+    const all = await withEngineTools(rest.includes('--all'));
+    try {
+      if (fi < 0) print(all.map(t => ({ name: t.name, title: t.title, description: t.description })));
+      else print(formatTools(all, rest[fi + 1]));
+      return 0;
+    } catch (e) { return printError(e); }
+  }
+  if (cmd === 'describe') {
+    const all = await withEngineTools(true);
+    const t = all.find(x => x.name === (ALIASES[rest[0]] ?? rest[0]));
+    if (!t) {
+      const { knownEngineToolNames } = await import('./src/relay.mjs');
+      if (knownEngineToolNames().has(rest[0])) return printError(new RPError('ENGINE_UNAVAILABLE', `${rest[0]} is a deep-analysis engine tool; its schema comes from the built engine, which is not built in this copy.`));
+    }
+    if (!t) return printError(new RPError('UNKNOWN_TOOL', `Unknown tool "${rest[0] ?? ''}". ${closest(rest[0] ?? '', all.map(x => x.name), 3) ? `Did you mean "${closest(rest[0], all.map(x => x.name), 3)}"? ` : ''}reverseport tools --all lists them.`));
+    print({ name: t.name, title: t.title, description: t.description, inputSchema: t.inputSchema, annotations: t.annotations, cli: `reverseport ${t.name} ${(POSITIONAL[t.name] ?? []).map(p => `<${p}>`).join(' ')} [--key value] [--args '{…}']`.replace(/\s+/g, ' ').trim() });
+    return 0;
+  }
+  if (cmd === 'feedback') { print(await readFeedback()); return 0; }
+  if (cmd === 'connect') {
+    const { connect } = await import('./src/connect.mjs');
+    const mi = rest.indexOf('--mode');
+    try {
+      const r = connect({ client: rest.find((x, i) => !x.startsWith('--') && !(mi >= 0 && i === mi + 1)), mode: mi >= 0 ? rest[mi + 1] : undefined });
+      if (r.snippet && !argv.includes('--json')) { process.stdout.write(`# ${r.where}\n${r.snippet}\n`); return 0; }
+      print(r); return 0;
+    } catch (e) { return printError(e); }
+  }
+  if (cmd === 'doctor') { const r = await doctor(); print(r); return r.ok ? 0 : 1; }
+  if (cmd === 'serve') { const { start } = await import('./server.mjs'); const s = await start(); console.log(`ReversePort ${VERSION} — http://127.0.0.1:${s.address().port}/api/agent/tools`); return null; }
+  if (cmd === 'mcp') { await import('./mcp.mjs'); return null; }
+  const name = ALIASES[cmd] ?? cmd;
+  if (!tools.some(t => t.name === name)) {
+    const near = closest(cmd, [...Object.keys(ALIASES), ...tools.map(t => t.name)], 2);
+    return printError(new RPError('UNKNOWN_TOOL', `Unknown command "${cmd}".${near ? ` Did you mean "${near}"?` : ''} Run: reverseport help`));
+  }
+  try {
+    let args = {};
+    const reqIdx = rest.indexOf('--request');
+    if (reqIdx >= 0) {
+      const src = rest[reqIdx + 1];
+      if (!src) throw new RPError('INVALID_ARGUMENT', '--request needs a JSON file path, or - for stdin.');
+      let text;
+      try { text = src === '-' ? await readStdin() : await fs.readFile(src, 'utf8'); } catch (e) { throw new RPError(e.code === 'ENOENT' ? 'NOT_FOUND' : 'INVALID_ARGUMENT', `--request: cannot read ${src} (${e.code ?? e.message}).`); }
+      try { args = JSON.parse(text); } catch { throw new RPError('INVALID_ARGUMENT', `--request: ${src} is not a JSON object.`); }
+      rest.splice(reqIdx, 2);
+    }
+    Object.assign(args, parseArgs(name, rest));
+    print(await callTool(name, args));
+    return 0;
+  } catch (e) { return printError(e); }
+}
+
+/** ReversePort's tools, plus the engine's when it is built and `include` is set. */
+async function withEngineTools(include) {
+  if (!include) return tools;
+  const { createRelay, engineCommand } = await import('./src/relay.mjs');
+  if (!engineCommand().command) return tools;
+  const relay = createRelay({}, { tools: 'all' });
+  try { await relay.ensureStarted({ name: 'reverseport-cli', version: VERSION }); return [...tools, ...relay.allEngineTools()]; }
+  finally { relay.close(); }
+}
+
+async function readStdin() {
+  let text = '';
+  for await (const chunk of process.stdin) text += chunk;
+  return text;
+}
+
+if (isMainModule(import.meta.url)) {
+  const code = await main();
+  if (code !== null) process.exitCode = code;
+}

package/port/knowledge/engines.json

@@ -0,0 +1,67 @@
+{
+  "godot": {
+    "name": "Godot 4 (GDScript)",
+    "language": "gdscript",
+    "scriptExt": ".gd",
+    "sceneFormat": ".tscn (text) / .scn (binary)",
+    "axes": { "right": "+X", "up": "+Y", "forward": "-Z (cameras, look_at, Vector3.FORWARD)", "modelFront": "+Z (Vector3.MODEL_FRONT, glTF imports)" },
+    "handedness": "right",
+    "units": "meters",
+    "eulerOrder": "YXZ (rotation in radians, rotation_degrees in degrees)",
+    "fov": "Camera3D.fov is vertical (keep_aspect = KEEP_HEIGHT, default)",
+    "physicsTick": "60 Hz (physics/common/physics_ticks_per_second)",
+    "lifecycle": ["_init", "_enter_tree", "_ready", "_process(delta)", "_physics_process(delta)", "_input(event)", "_unhandled_input(event)", "_exit_tree", "_notification(what)"]
+  },
+  "godot-csharp": {
+    "name": "Godot 4 (C#)",
+    "language": "csharp",
+    "scriptExt": ".cs",
+    "sceneFormat": ".tscn",
+    "axes": { "right": "+X", "up": "+Y", "forward": "-Z", "modelFront": "+Z" },
+    "handedness": "right",
+    "units": "meters",
+    "eulerOrder": "YXZ",
+    "fov": "vertical",
+    "physicsTick": "60 Hz",
+    "lifecycle": ["_Ready()", "_Process(double delta)", "_PhysicsProcess(double delta)", "_Input(InputEvent @event)", "_UnhandledInput(InputEvent @event)", "_ExitTree()"]
+  },
+  "unity": {
+    "name": "Unity (C#)",
+    "language": "csharp",
+    "scriptExt": ".cs",
+    "sceneFormat": ".unity / .prefab (YAML when Asset Serialization = Force Text)",
+    "axes": { "right": "+X", "up": "+Y", "forward": "+Z (transform.forward)" },
+    "handedness": "left",
+    "units": "meters",
+    "eulerOrder": "applied Z, then X, then Y (same matrix order as Godot YXZ); degrees",
+    "fov": "Camera.fieldOfView is vertical (degrees)",
+    "physicsTick": "50 Hz (Fixed Timestep 0.02 s)",
+    "lifecycle": ["Awake()", "OnEnable()", "Start()", "FixedUpdate()", "Update()", "LateUpdate()", "OnDisable()", "OnDestroy()"]
+  },
+  "unreal": {
+    "name": "Unreal Engine 5 (C++ / Blueprint)",
+    "language": "cpp",
+    "scriptExt": ".h + .cpp",
+    "sceneFormat": ".umap (level) / .uasset (Blueprint) — binary",
+    "axes": { "right": "+Y", "up": "+Z", "forward": "+X" },
+    "handedness": "left",
+    "units": "centimeters",
+    "eulerOrder": "FRotator(Pitch, Yaw, Roll) in degrees",
+    "fov": "UCameraComponent::FieldOfView is horizontal (degrees)",
+    "physicsTick": "variable by default (frame rate); optional substepping / async physics tick",
+    "lifecycle": ["constructor (CreateDefaultSubobject)", "PostInitializeComponents()", "BeginPlay()", "Tick(float DeltaTime)", "EndPlay(EEndPlayReason::Type)"]
+  },
+  "threejs": {
+    "name": "three.js (TypeScript)",
+    "language": "typescript",
+    "scriptExt": ".ts",
+    "sceneFormat": "code + glTF (.glb) assets",
+    "axes": { "right": "+X", "up": "+Y", "forward": "-Z (cameras and lights look down -Z; Object3D.lookAt points +Z for other objects)" },
+    "handedness": "right",
+    "units": "meters by convention (physical lights assume meters)",
+    "eulerOrder": "XYZ by default (radians); set object.rotation.order = 'YXZ' to match Godot",
+    "fov": "PerspectiveCamera.fov is vertical (degrees)",
+    "physicsTick": "none built in — fixed-step accumulator with Rapier / cannon-es",
+    "lifecycle": ["constructor / init()", "renderer.setAnimationLoop(update)", "dispose()"]
+  }
+}

package/port/knowledge/footprints.json

@@ -0,0 +1,189 @@
+{
+  "about": "What an engine or stack leaves behind in a shipped game or app: install layout, file formats, scripting, which ReversePort tools read it, and the natural rebuild target. Used by re_lookup (to tell an agent where the material is and how it is structured, without files) and re_blueprint. Only layouts that are stable across versions are listed.",
+  "footprints": {
+    "unity": {
+      "name": "Unity",
+      "match": ["unity"],
+      "engineId": "unity",
+      "scripting": "C# (Mono or IL2CPP)",
+      "layout": [
+        "<Game>.exe + UnityPlayer.dll (Windows player)",
+        "<Game>_Data/ — globalgamemanagers (holds the Unity version), level0…levelN (scenes), sharedassets*.assets, resources.assets",
+        "<Game>_Data/Managed/Assembly-CSharp.dll — game code (Mono builds)",
+        "GameAssembly.dll + <Game>_Data/il2cpp_data/Metadata/global-metadata.dat — game code compiled to native (IL2CPP builds)",
+        "<Game>_Data/StreamingAssets/ — files shipped as-is (often AssetBundles, videos, configs)"
+      ],
+      "formats": [".assets", ".resS", "AssetBundles (UnityFS)", ".dll (.NET)"],
+      "readWith": ["re_scan on the install folder → engine, version, Mono or IL2CPP", "re_binary on Assembly-CSharp.dll → classes and methods (Mono)", "re_probe on .assets/.resS for embedded data"],
+      "limits": "IL2CPP builds have no .NET assemblies: only native code plus metadata. Asset files are binary serialized; ReversePort lists and probes them but does not unpack them.",
+      "rebuildTarget": "unity"
+    },
+    "godot": {
+      "name": "Godot",
+      "match": ["godot"],
+      "engineId": "godot",
+      "scripting": "GDScript or C#",
+      "layout": [
+        "<Game>.exe / .x86_64 + <Game>.pck (or the pack embedded at the end of the executable)",
+        "inside the pack: project.godot, *.tscn/*.scn scenes, *.gd scripts (text or tokenized), .import/ converted assets",
+        "C# games: data_<Game>_<platform>/ with the .NET assemblies"
+      ],
+      "formats": [".pck (GDPC)", ".tscn/.scn", ".gd/.gdc", ".ctex/.stex", ".import"],
+      "readWith": ["re_scan → engine + packs", "re_archive on the .pck or .exe → list/extract scenes and scripts", "re_scene on extracted .tscn"],
+      "limits": "Encrypted packs are reported and left alone.",
+      "rebuildTarget": "godot"
+    },
+    "unreal": {
+      "name": "Unreal Engine",
+      "match": ["unreal"],
+      "engineId": "unreal",
+      "scripting": "C++ and Blueprints",
+      "layout": [
+        "<Project>/Binaries/<Platform>/<Project>-<Platform>-Shipping.exe — game code (native)",
+        "<Project>/Content/Paks/*.pak — cooked assets (UE5 also .utoc/.ucas IoStore containers)",
+        "Engine/ — engine binaries and shared content"
+      ],
+      "formats": [".pak", ".utoc/.ucas", ".uasset/.umap (cooked)", ".exe (native)"],
+      "readWith": ["re_scan → Unreal build, paks, IoStore", "re_archive identifies paks (header only)", "re_binary on the Shipping exe → imports, sections, strings"],
+      "limits": "Paks are often encrypted and cooked assets are binary; no source code ships. Rebuild from observation.",
+      "rebuildTarget": "unreal"
+    },
+    "gamemaker": {
+      "name": "GameMaker",
+      "match": ["gamemaker", "game maker"],
+      "scripting": "GML",
+      "layout": ["<Game>.exe + data.win (all rooms, sprites, sounds and compiled code in one file); YYC builds compile GML to native code"],
+      "formats": ["data.win (FORM/IFF chunks)", "audiogroup*.dat"],
+      "readWith": ["re_scan → GameMaker build", "re_probe on data.win → chunk layout, embedded PNG/OGG"],
+      "limits": "YYC builds contain native code only.",
+      "rebuildTarget": "godot"
+    },
+    "rpgmaker": {
+      "name": "RPG Maker MV/MZ",
+      "match": ["rpg maker"],
+      "scripting": "JavaScript",
+      "layout": ["www/ or root: index.html, js/rpg_*.js (MV) or js/rmmz_*.js (MZ), js/plugins/*.js, data/*.json (maps, actors, items, events), img/, audio/"],
+      "formats": [".json", ".js", ".rpgmvp/.png_ (encrypted images, optional)", ".rpgmvo/.ogg_ (encrypted audio, optional)"],
+      "readWith": ["re_scan → RPG Maker MV/MZ", "re_symbols on js/plugins", "data/*.json is readable as is"],
+      "limits": "Encrypted images/audio are left alone.",
+      "rebuildTarget": "godot"
+    },
+    "renpy": {
+      "name": "Ren'Py",
+      "match": ["ren'py", "renpy"],
+      "scripting": "Ren'Py script / Python",
+      "layout": ["game/ with *.rpy (source), *.rpyc (compiled), *.rpa (archives with images/audio)", "renpy/ engine, lib/ Python runtime"],
+      "formats": [".rpy", ".rpyc", ".rpa"],
+      "readWith": ["re_scan → Ren'Py", "re_symbols on .rpy (labels, screens)"],
+      "rebuildTarget": "renpy"
+    },
+    "love2d": {
+      "name": "LÖVE",
+      "match": ["löve", "love2d", "love 2d"],
+      "scripting": "Lua",
+      "layout": ["<Game>.exe with a .love (zip) appended, or a .love file next to love.exe; main.lua + conf.lua inside"],
+      "formats": [".love (zip)", ".lua"],
+      "readWith": ["re_probe on the exe → embedded ZIP offset", "re_extract the ZIP, then re_archive"],
+      "rebuildTarget": "godot"
+    },
+    "source": {
+      "name": "Source engine (Valve)",
+      "match": ["source engine", "source 2", "source"],
+      "scripting": "C++ (Source 2: also Lua/Panorama JS)",
+      "layout": ["<game>/ with gameinfo.txt, bin/ (client.dll, server.dll), *.vpk archives, maps/*.bsp (Source 2: .vpk with .vmap_c)"],
+      "formats": [".vpk", ".bsp", ".mdl/.vtx/.vvd", ".vtf/.vmt"],
+      "readWith": ["re_binary on client.dll/server.dll", "re_probe on .vpk/.bsp"],
+      "rebuildTarget": "unreal"
+    },
+    "electron": {
+      "name": "Electron",
+      "match": ["electron"],
+      "scripting": "JavaScript/TypeScript + HTML/CSS",
+      "layout": ["<App>.exe + resources/app.asar (the app's JS/HTML/CSS) or resources/app/ unpacked; *.node native modules"],
+      "formats": [".asar", ".js", ".node"],
+      "readWith": ["re_scan → Electron build", "re_archive on app.asar → list/extract", "re_graph/re_symbols on the extracted code"],
+      "rebuildTarget": "electron"
+    },
+    "nwjs": {
+      "name": "NW.js",
+      "match": ["nw.js", "node-webkit", "nwjs"],
+      "scripting": "JavaScript",
+      "layout": ["nw.exe/<Game>.exe + package.nw (zip) or package.json + html/js next to it (Construct 2/3 and RPG Maker MV desktop exports use it)"],
+      "formats": [".nw (zip)", ".js"],
+      "readWith": ["re_archive on package.nw", "re_probe on the exe for an appended zip"],
+      "rebuildTarget": "threejs"
+    },
+    "monogame": {
+      "name": "MonoGame / XNA / FNA",
+      "match": ["monogame", "xna", "fna"],
+      "scripting": "C#",
+      "layout": ["<Game>.exe/.dll (.NET) + Content/*.xnb (compiled content)"],
+      "formats": [".xnb", ".dll (.NET)"],
+      "readWith": ["re_binary on the game .exe/.dll → .NET types and methods", "re_probe on .xnb"],
+      "rebuildTarget": "godot-csharp"
+    },
+    "construct": {
+      "name": "Construct",
+      "match": ["construct"],
+      "scripting": "event sheets (exported to JavaScript)",
+      "layout": ["HTML5 export: index.html, scripts/c3runtime.js (Construct 3) or c2runtime.js, data.json (project data), images/, media/"],
+      "formats": ["data.json", "c3runtime.js"],
+      "readWith": ["re_scan on the export folder", "data.json is readable as is"],
+      "rebuildTarget": "godot"
+    },
+    "defold": {
+      "name": "Defold",
+      "match": ["defold"],
+      "scripting": "Lua",
+      "layout": ["game.arcd + game.arci (resource archive and index), game.dmanifest, game.projectc"],
+      "formats": [".arcd/.arci", ".projectc"],
+      "readWith": ["re_probe on game.arcd"],
+      "rebuildTarget": "godot"
+    },
+    "cocos": {
+      "name": "Cocos2d-x / Cocos Creator",
+      "match": ["cocos"],
+      "scripting": "C++, Lua or JavaScript/TypeScript",
+      "layout": ["Android: lib/<abi>/libcocos2d*.so or libcocos*.so, assets/ with .jsc/.luac or res/ and src/"],
+      "formats": [".jsc/.luac (compiled scripts)", ".plist sprite sheets"],
+      "readWith": ["re_archive on the .apk", "re_binary on the .so"],
+      "rebuildTarget": "godot"
+    },
+    "libgdx": {
+      "name": "libGDX / Java",
+      "match": ["libgdx", "java"],
+      "scripting": "Java/Kotlin",
+      "layout": ["desktop: <game>.jar (classes + assets); Android: classes*.dex + assets/"],
+      "formats": [".jar", ".class", ".dex"],
+      "readWith": ["re_archive on the .jar/.apk", "re_binary on .class/.dex → classes and methods"],
+      "rebuildTarget": "godot"
+    },
+    "flutter": {
+      "name": "Flutter",
+      "match": ["flutter"],
+      "scripting": "Dart",
+      "layout": ["Android: lib/<abi>/libapp.so (compiled Dart) + libflutter.so, assets/flutter_assets/ (images, fonts, AssetManifest)", "iOS: Frameworks/App.framework + flutter_assets"],
+      "formats": ["libapp.so (AOT snapshot)", "flutter_assets/"],
+      "readWith": ["re_archive on the .apk", "re_binary on libapp.so → strings"],
+      "rebuildTarget": "flutter"
+    },
+    "react-native": {
+      "name": "React Native",
+      "match": ["react native", "react-native"],
+      "scripting": "JavaScript/TypeScript",
+      "layout": ["Android: assets/index.android.bundle (JS or Hermes bytecode); iOS: main.jsbundle"],
+      "formats": ["index.android.bundle", "Hermes bytecode (.hbc)"],
+      "readWith": ["re_archive on the .apk", "re_probe on the bundle"],
+      "rebuildTarget": "react-native"
+    },
+    "web": {
+      "name": "Web app / browser game",
+      "match": ["html5", "javascript", "webgl", "three.js", "phaser", "pixijs", "babylon.js", "playcanvas"],
+      "scripting": "JavaScript/TypeScript (+ WebAssembly)",
+      "layout": ["index.html + bundled scripts (often hashed names under /assets or /_next), styles, images, .wasm and data files loaded at runtime"],
+      "formats": [".js", ".wasm", ".data", ".json", ".glb"],
+      "readWith": ["re_lookup {url} lists the scripts, wasm and data files the page loads", "re_binary on a downloaded .wasm"],
+      "rebuildTarget": "threejs"
+    }
+  }
+}

package/port/knowledge/maps/godot-godot-csharp.json

@@ -0,0 +1,38 @@
+{
+  "from": "godot",
+  "to": "godot-csharp",
+  "title": "Godot 4 GDScript → Godot 4 C# (.NET)",
+  "conventions": [
+    "Needs the .NET build of Godot; the project gets a .csproj. Each script: public partial class Name : BaseType, file name = class name.",
+    "Scenes stay as they are: swap the script path in each .tscn ext_resource from res://x.gd to res://X.cs once the C# class compiles.",
+    "Names become PascalCase: _physics_process → _PhysicsProcess, move_and_slide → MoveAndSlide, global_position → GlobalPosition. Delta is double.",
+    "Struct properties cannot be changed in place: var v = Velocity; v.X = 3; Velocity = v;",
+    "Engine collections are Godot.Collections.Array/Dictionary (Variant-compatible); use them for exported and signal data, .NET List/Dictionary elsewhere."
+  ],
+  "entries": [
+    { "id": "script-class", "topic": "structure", "from": "class_name Player / extends CharacterBody3D", "to": "public partial class Player : CharacterBody3D", "pattern": "^extends\\s" },
+    { "id": "ready", "topic": "lifecycle", "from": "_ready()", "to": "public override void _Ready()", "pattern": "\\bfunc\\s+_ready\\b" },
+    { "id": "process", "topic": "lifecycle", "from": "_process(delta)", "to": "public override void _Process(double delta)", "pattern": "\\bfunc\\s+_process\\b" },
+    { "id": "physics-process", "topic": "lifecycle", "from": "_physics_process(delta)", "to": "public override void _PhysicsProcess(double delta)", "pattern": "\\bfunc\\s+_physics_process\\b" },
+    { "id": "input-event", "topic": "input", "from": "_input(event) / _unhandled_input(event)", "to": "public override void _Input(InputEvent @event) / _UnhandledInput", "pattern": "\\bfunc\\s+_(unhandled_)?input\\b" },
+    { "id": "export", "topic": "inspector", "from": "@export var speed := 6.0", "to": "[Export] public float Speed { get; set; } = 6f;", "pattern": "@export" },
+    { "id": "onready", "topic": "scene tree", "from": "@onready var anim = $AnimationPlayer", "to": "private AnimationPlayer _anim; … in _Ready(): _anim = GetNode<AnimationPlayer>(\"AnimationPlayer\");", "pattern": "@onready" },
+    { "id": "get-node", "topic": "scene tree", "from": "$Path / get_node(\"Path\") / %Unique", "to": "GetNode<T>(\"Path\") / GetNode<T>(\"%Unique\")", "pattern": "(get_node\\(|\\$[A-Za-z\"%])", "leftover": "\\bget_node\\(|\\$\\w" },
+    { "id": "signal-declare", "topic": "events", "from": "signal hit(damage: int)", "to": "[Signal] public delegate void HitEventHandler(int damage);", "pattern": "^signal\\s" },
+    { "id": "signal-emit", "topic": "events", "from": "hit.emit(d) / emit_signal(\"hit\", d)", "to": "EmitSignal(SignalName.Hit, d);", "pattern": "\\.emit\\(|emit_signal\\(", "leftover": "emit_signal\\(" },
+    { "id": "signal-connect", "topic": "events", "from": "hit.connect(_on_hit)", "to": "Hit += OnHit;", "pattern": "\\.connect\\(" },
+    { "id": "preload", "topic": "resources", "from": "preload(\"res://x.tscn\")", "to": "GD.Load<PackedScene>(\"res://x.tscn\") (cache it in a static readonly field)", "pattern": "\\bpreload\\(", "leftover": "\\bpreload\\(" },
+    { "id": "instantiate", "topic": "scene tree", "from": "scene.instantiate()", "to": "scene.Instantiate<Node3D>()", "pattern": "\\.instantiate\\(" },
+    { "id": "queue-free", "topic": "scene tree", "from": "queue_free()", "to": "QueueFree()", "pattern": "\\bqueue_free\\(?", "leftover": "\\bqueue_free\\(" },
+    { "id": "timer-await", "topic": "async", "from": "await get_tree().create_timer(t).timeout", "to": "await ToSignal(GetTree().CreateTimer(t), SceneTreeTimer.SignalName.Timeout);", "pattern": "create_timer\\(" },
+    { "id": "await-signal", "topic": "async", "from": "await some_signal", "to": "await ToSignal(obj, Obj.SignalName.SomeSignal); (method becomes async)", "pattern": "\\bawait\\s" },
+    { "id": "input", "topic": "input", "from": "Input.is_action_pressed / get_axis", "to": "Input.IsActionPressed / Input.GetAxis", "pattern": "Input\\.(is_action|get_axis|get_vector)" },
+    { "id": "velocity", "topic": "physics", "from": "velocity.x = …; move_and_slide()", "to": "var v = Velocity; v.X = …; Velocity = v; MoveAndSlide();", "pattern": "\\bvelocity\\.|move_and_slide\\(" },
+    { "id": "groups", "topic": "architecture", "from": "add_to_group(\"x\")", "to": "AddToGroup(\"x\")", "pattern": "add_to_group\\(" },
+    { "id": "autoload", "topic": "architecture", "from": "Global.add_score(…) (autoload by name)", "to": "GetNode<Global>(\"/root/Global\").AddScore(…) or a static Instance set in _Ready", "pattern": "^\\[autoload\\]" },
+    { "id": "print", "topic": "debug", "from": "print(), push_error()", "to": "GD.Print(), GD.PushError()", "pattern": "\\b(print|push_error|push_warning)\\(", "leftover": "^\\s*print\\(" },
+    { "id": "math", "topic": "math", "from": "lerp, clamp, deg_to_rad, randf", "to": "Mathf.Lerp, Mathf.Clamp, Mathf.DegToRad, GD.Randf()", "pattern": "\\b(lerp|clamp|deg_to_rad|randf|randi)\\(" },
+    { "id": "typed", "topic": "language", "from": "var x := 1, Array[int], Dictionary", "to": "var x = 1; Godot.Collections.Array<int>; Godot.Collections.Dictionary", "pattern": "\\bArray\\[|\\bDictionary\\b" },
+    { "id": "match", "topic": "language", "from": "match value:", "to": "switch statement / switch expression", "pattern": "^\\s*match\\s" }
+  ]
+}

package/port/knowledge/maps/godot-threejs.json

@@ -0,0 +1,42 @@
+{
+  "from": "godot",
+  "to": "threejs",
+  "title": "Godot 4 (GDScript) → three.js (TypeScript, browser)",
+  "conventions": [
+    "three.js is a renderer, not a game engine: physics, input mapping, scene files, audio buses and UI are yours to choose. A common stack: three + Rapier (@dimforge/rapier3d-compat) for physics, plain DOM/CSS for UI, Vite for building.",
+    "Axes match Godot (right-handed, Y up, cameras look down -Z, meters): positions and quaternions carry over unchanged. Godot's default Euler order is YXZ; set object.rotation.order = 'YXZ' when copying Euler angles.",
+    "Godot scenes: export meshes and materials as glTF 2.0 (Scene → Export As → glTF 2.0) and load them with GLTFLoader; recreate the node logic in TypeScript classes that own an Object3D. ReversePort can write a TypeScript scene-builder module from a .tscn (port_scene).",
+    "Each GDScript becomes a TypeScript class with update(dt) and fixedUpdate(dt) methods; a small game loop calls them from renderer.setAnimationLoop.",
+    "Dispose geometries, materials and textures when removing objects (the browser does not free GPU memory for you)."
+  ],
+  "entries": [
+    { "id": "script-class", "topic": "structure", "from": "extends Node3D", "to": "class X { object = new THREE.Group(); update(dt: number) {} }", "pattern": "^extends\\s" },
+    { "id": "ready", "topic": "lifecycle", "from": "_ready()", "to": "constructor / async init() after assets are loaded", "pattern": "\\bfunc\\s+_ready\\b" },
+    { "id": "process", "topic": "lifecycle", "from": "_process(delta)", "to": "update(dt) called from renderer.setAnimationLoop with clock.getDelta()", "pattern": "\\bfunc\\s+_process\\b" },
+    { "id": "physics-process", "topic": "lifecycle", "from": "_physics_process(delta)", "to": "fixedUpdate(1/60) from an accumulator loop; step the physics world there", "pattern": "\\bfunc\\s+_physics_process\\b" },
+    { "id": "input", "topic": "input", "from": "Input.is_action_pressed(\"x\") / InputMap", "to": "own action map over keydown/keyup listeners and the Gamepad API (navigator.getGamepads())", "pattern": "Input\\.(is_action|get_axis|get_vector)" },
+    { "id": "signal", "topic": "events", "from": "signal / emit / connect", "to": "THREE.EventDispatcher (dispatchEvent / addEventListener) or a typed emitter", "pattern": "^signal\\s|\\.emit\\(|\\.connect\\(" },
+    { "id": "get-node", "topic": "scene tree", "from": "$Path / get_node", "to": "object.getObjectByName(\"Path\") or keep direct references in the class", "pattern": "(get_node\\(|\\$[A-Za-z\"%])", "leftover": "\\bget_node\\(" },
+    { "id": "preload", "topic": "resources", "from": "preload(\"res://x.tscn\")", "to": "await new GLTFLoader().loadAsync('x.glb') once, then clone per instance", "pattern": "\\bpreload\\(|\\bload\\(" },
+    { "id": "instantiate", "topic": "scene tree", "from": "instantiate() + add_child()", "to": "template.clone() (SkeletonUtils.clone for skinned meshes) + parent.add(obj)", "pattern": "\\.instantiate\\(" },
+    { "id": "queue-free", "topic": "scene tree", "from": "queue_free()", "to": "obj.removeFromParent() + dispose() of geometry/material/texture", "pattern": "\\bqueue_free\\(?", "leftover": "queue_free" },
+    { "id": "timer", "topic": "async", "from": "await get_tree().create_timer(t).timeout", "to": "await new Promise(r => setTimeout(r, t * 1000)) — or a game-time timer that respects pause", "pattern": "create_timer\\(" },
+    { "id": "tween", "topic": "animation", "from": "create_tween()", "to": "a small tween in update(dt), or @tweenjs/tween.js / GSAP", "pattern": "create_tween\\(" },
+    { "id": "character-body", "topic": "physics", "from": "CharacterBody3D.move_and_slide()", "to": "Rapier KinematicCharacterController.computeColliderMovement + setNextKinematicTranslation", "pattern": "move_and_slide\\(|CharacterBody3D" },
+    { "id": "rigid-body", "topic": "physics", "from": "RigidBody3D.apply_central_impulse", "to": "Rapier RigidBody.applyImpulse({x, y, z}, true)", "pattern": "RigidBody3D|apply_(central_)?impulse\\(" },
+    { "id": "area", "topic": "physics", "from": "Area3D.body_entered", "to": "Rapier sensor collider + collision events (EventQueue)", "pattern": "Area3D|body_entered" },
+    { "id": "raycast", "topic": "physics", "from": "RayCast3D", "to": "THREE.Raycaster (meshes) or Rapier world.castRay (physics)", "pattern": "RayCast3D|intersect_ray" },
+    { "id": "camera", "topic": "rendering", "from": "Camera3D (fov vertical)", "to": "THREE.PerspectiveCamera(fov, aspect, near, far) (fov vertical, degrees)", "pattern": "Camera3D" },
+    { "id": "lights", "topic": "rendering", "from": "DirectionalLight3D / OmniLight3D / SpotLight3D", "to": "DirectionalLight (+ target) / PointLight / SpotLight", "pattern": "(Directional|Omni|Spot)Light3D", "notes": "three.js uses physical light units; retune intensities." },
+    { "id": "environment", "topic": "rendering", "from": "WorldEnvironment (sky, tonemap, glow)", "to": "scene.background / scene.environment (PMREMGenerator), renderer.toneMapping, postprocessing (EffectComposer, UnrealBloomPass)", "pattern": "WorldEnvironment|Environment" },
+    { "id": "animation", "topic": "animation", "from": "AnimationPlayer.play(\"x\")", "to": "new THREE.AnimationMixer(root).clipAction(clip).play(); mixer.update(dt)", "pattern": "AnimationPlayer" },
+    { "id": "audio", "topic": "audio", "from": "AudioStreamPlayer3D", "to": "THREE.PositionalAudio with an AudioListener on the camera", "pattern": "AudioStreamPlayer" },
+    { "id": "ui", "topic": "ui", "from": "Control / Label / CanvasLayer", "to": "HTML/CSS overlay (or a UI library) above the canvas", "pattern": "\\b(Control|Label|Button|CanvasLayer)\\b" },
+    { "id": "autoload", "topic": "architecture", "from": "Autoload singleton", "to": "an exported module-level instance (ES module singletons)", "pattern": "^\\[autoload\\]" },
+    { "id": "change-scene", "topic": "architecture", "from": "change_scene_to_file", "to": "dispose the current world, build the next one (your own scene manager)", "pattern": "change_scene_to_(file|packed)\\(" },
+    { "id": "groups", "topic": "architecture", "from": "groups", "to": "Sets/arrays per group, or object.userData.tags", "pattern": "(add_to_group|get_nodes_in_group)\\(" },
+    { "id": "print", "topic": "debug", "from": "print()", "to": "console.log()", "pattern": "\\bprint\\(", "leftover": "^\\s*print\\(" },
+    { "id": "math", "topic": "math", "from": "lerp, clamp, deg_to_rad", "to": "THREE.MathUtils.lerp, clamp, degToRad", "pattern": "\\b(lerp|clamp|deg_to_rad)\\(" },
+    { "id": "shader", "topic": "rendering", "from": ".gdshader", "to": "ShaderMaterial (GLSL) or TSL node materials (WebGPU renderer)", "pattern": "shader_type\\s" }
+  ]
+}