reverseport 1.4.0 → 1.5.0

package/bin/reverseport.mjs

@@ -17,7 +17,7 @@ const VERSION = JSON.parse(readFileSync(path.join(REPO, 'package.json'), 'utf8')
 const PORT_COMMANDS = new Set([
   'scan', 'graph', 'symbols', 'scene', 'binary', 'bin', 'archive', 'pck', 'probe', 'extract', 'carve', 'diff',
   'compare-builds', 'report', 'lookup', 'recon', 'web', 'blueprint', 'rebuild', 'map', 'convert', 'plan', 'unit',
-  'write', 'port-scene', 'copy-assets', 'status', 'verify', 'case', 'proof', 'tools', 'serve', 'describe', 'feedback', 'connect',
+  'write', 'port-scene', 'copy-assets', 'status', 'verify', 'case', 'proof', 'tools', 'serve', 'describe', 'feedback', 'connect', 'skills',
 ]);
 const ALWAYS_ENGINE = ['setup', 'doctor', 'update', 'uninstall', 'mcp', 'capabilities', 'providers', 'help'];
 

package/dist/generatedPackageMetadata.js

@@ -1,7 +1,7 @@
 /** Generated from package.json and package-lock.json; do not edit. */
 export const PACKAGE_METADATA = {
     name: "reverseport",
-    version: "1.4.0", // x-release-please-version
+    version: "1.5.0", // x-release-please-version
     serverSdkVersion: "2.3.1",
     clientSdkVersion: "2.3.1",
     coreSdkVersion: "2.3.1",

package/native/windows/build/manifest.json

@@ -1,5 +1,5 @@
 {
-  "packageVersion": "1.4.0",
+  "packageVersion": "1.5.0",
   "platform": "win32",
   "architecture": "x64",
   "abiVersion": 1,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "reverseport",
   "mcpName": "io.github.laaielichter/reverseport",
-  "version": "1.4.0",
+  "version": "1.5.0",
   "description": "Reverse engineer anything. Port it anywhere. One CLI and MCP server that lets coding agents take apart apps, games, binaries and websites — decompile, trace, compare builds, recon without files — and rebuild or port them to Godot, Unity, Unreal, three.js or any language.",
   "license": "MIT",
   "repository": {
@@ -301,8 +301,8 @@
   },
   "lint-staged": {
     "*.{cjs,cts,js,jsx,mjs,mts,ts,tsx}": [
-      "oxfmt",
-      "oxlint --fix"
+      "oxfmt --no-error-on-unmatched-pattern",
+      "oxlint --fix --no-error-on-unmatched-pattern"
     ],
     "*.{json,md,yml,yaml}": "oxfmt --no-error-on-unmatched-pattern"
   },

package/port/cli.mjs

@@ -118,6 +118,8 @@ Proof (evidence ledger)
 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)
+  skills [list]              the skills bundled with this version
+  skills get <name>          one skill's full guide, matching this version (--json for JSON)
   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)
@@ -153,6 +155,20 @@ export async function main(argv = process.argv.slice(2)) {
     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 === 'skills') {
+    const { listSkills, getSkill } = await import('./src/skills.mjs');
+    const [sub, name] = rest.filter(x => !x.startsWith('--'));
+    try {
+      if (!sub || sub === 'list') { print({ version: VERSION, skills: await listSkills() }); return 0; }
+      if (sub === 'get') {
+        const s = await getSkill(name);
+        if (argv.includes('--json')) print({ version: VERSION, name: s.name, description: s.description, body: s.body });
+        else process.stdout.write(`<!-- ReversePort ${VERSION} · skill ${s.name} -->\n${s.text.endsWith('\n') ? s.text : `${s.text}\n`}`);
+        return 0;
+      }
+      return printError(new RPError('INVALID_ARGUMENT', `Unknown skills command "${sub}". Use: reverseport skills list | reverseport skills get <name>`));
+    } catch (e) { return printError(e); }
+  }
   if (cmd === 'feedback') { print(await readFeedback()); return 0; }
   if (cmd === 'connect') {
     const { connect } = await import('./src/connect.mjs');

package/port/src/graph.mjs

@@ -103,10 +103,27 @@ export async function buildGraph(dir, { maxFiles = 30000 } = {}) {
     for (const b of ['', path.posix.dirname(from)]) for (const c of [`${p}.lua`, `${p}/init.lua`]) { const hit = exists(path.posix.normalize(b ? `${b}/${c}` : c)); if (hit) return hit; }
     return null;
   };
-  const resolveRustMod = (from, name) => {
-    const dir = path.posix.dirname(from), stem = path.posix.basename(from, '.rs');
-    const base = ['mod', 'main', 'lib'].includes(stem) ? dir : path.posix.join(dir, stem);
-    return exists(path.posix.normalize(`${base}/${name}.rs`)) ?? exists(path.posix.normalize(`${base}/${name}/mod.rs`));
+  // Rust: a file's child modules live in `<stem>/` (or next to mod.rs/lib.rs/main.rs); `crate::` starts at the
+  // crate's src/, and a workspace crate is reachable by its package name (`-` reads as `_`).
+  const rustModuleDir = from => { const dir = path.posix.dirname(from), stem = path.posix.basename(from, '.rs'); return ['mod', 'main', 'lib'].includes(stem) ? dir : path.posix.join(dir, stem); };
+  const rustModuleFile = dir => exists(`${dir}.rs`) ?? exists(`${dir}/mod.rs`) ?? exists(`${dir}/lib.rs`) ?? exists(`${dir}/main.rs`);
+  const resolveRustMod = (from, name) => { const base = rustModuleDir(from); return exists(path.posix.normalize(`${base}/${name}.rs`)) ?? exists(path.posix.normalize(`${base}/${name}/mod.rs`)); };
+  const rustCrates = new Map();
+  for (const f of files) if (/(^|\/)Cargo\.toml$/.test(f.rel)) {
+    const name = (await fs.readFile(f.abs, 'utf8').catch(() => '')).match(/^\[package\][^[]*?^\s*name\s*=\s*"([^"]+)"/ms)?.[1];
+    if (name) rustCrates.set(name.replace(/-/g, '_'), path.posix.join(path.posix.dirname(f.rel), 'src').replace(/^\.\//, ''));
+  }
+  const rustCrateSrc = from => { let dir = path.posix.dirname(from); while (dir && dir !== '.') { if (path.posix.basename(dir) === 'src' && exists(path.posix.join(path.posix.dirname(dir), 'Cargo.toml'))) return dir; dir = path.posix.dirname(dir); } return null; };
+  const resolveRustUse = (from, spec) => {
+    const segs = spec.split('::').filter(Boolean);
+    let base;
+    if (segs[0] === 'crate') { base = rustCrateSrc(from); segs.shift(); }
+    else if (segs[0] === 'self') { base = rustModuleDir(from); segs.shift(); }
+    else if (segs[0] === 'super') { base = rustModuleDir(from); while (segs[0] === 'super') { segs.shift(); base = path.posix.dirname(base); } }
+    else if (rustCrates.has(segs[0])) base = rustCrates.get(segs.shift());
+    if (!base || base === '.') return null;
+    for (let i = segs.length; i >= 1; i--) { const p = `${base}/${segs.slice(0, i).join('/')}`; const hit = exists(`${p}.rs`) ?? exists(`${p}/mod.rs`); if (hit) return hit; }
+    return rustModuleFile(base);
   };
 
   for (const n of nodes.values()) {
@@ -134,7 +151,7 @@ export async function buildGraph(dir, { maxFiles = 30000 } = {}) {
         case 'python': hit = resolvePy(n.file, d.spec); if (!hit && !d.spec.startsWith('.')) external(d.spec.split('.')[0]); break;
         case 'c': case 'c-header': case 'cpp': case 'objc': if (d.kind === 'system') external(`<${d.spec}>`); else { hit = resolveInclude(n.file, d.spec); if (!hit) external(`"${d.spec}"`); } break;
         case 'lua': hit = resolveLua(n.file, d.spec); if (!hit) external(d.spec); break;
-        case 'rust': if (d.kind === 'mod') hit = resolveRustMod(n.file, d.spec); else if (!/^(crate|self|super)::/.test(d.spec)) external(d.spec.split('::')[0]); break;
+        case 'rust': if (d.kind === 'mod') hit = resolveRustMod(n.file, d.spec); else { hit = resolveRustUse(n.file, d.spec); if (!hit && !/^(crate|self|super)(::|$)/.test(d.spec)) external(d.spec.split('::')[0]); } break;
         case 'go':
           if (goModule && d.spec.startsWith(`${goModule}/`)) {
             const pkgDir = d.spec.slice(goModule.length + 1);
@@ -239,9 +256,14 @@ export function tarjanOrder(keys, out) {
   return { sccs, order: sccs.flat() };
 }
 
+/** Test files: under a test folder, or named *.test.*, *.spec.*, *_test.*, test_*. */
+export const isTestFile = rel => /(^|\/)(tests?|__tests__|specs?|testing)\//.test(rel) || /(\.(test|spec)\.\w+|_tests?\.\w+)$/.test(rel) || /(^|\/)test_[^/]+$/.test(rel);
+
 export function graphMermaid(graph, max = 60) {
   const score = k => (graph.inDegree.get(k) ?? 0) + (graph.outEdges.get(k)?.length ?? 0);
-  const keep = [...graph.nodes.keys()].sort((a, b) => score(b) - score(a)).slice(0, max);
+  // Tests depend on many files, so by degree alone they would crowd out the modules a reader wants to see.
+  const ranked = [...graph.nodes.keys()].sort((a, b) => score(b) - score(a));
+  const keep = [...ranked.filter(k => !isTestFile(k)), ...ranked.filter(isTestFile)].slice(0, max);
   const id = new Map(keep.map((k, i) => [k, `f${i}`]));
   const lines = ['graph LR'];
   for (const k of keep) lines.push(`  ${id.get(k)}["${path.posix.basename(k).replace(/"/g, "'")}"]`);

package/port/src/skills.mjs

@@ -0,0 +1,41 @@
+// The skills that ship with this exact ReversePort version, served by the CLI.
+// An agent that runs `reverseport skills get <name>` always reads the guide that matches the binary it calls,
+// even when a copied SKILL.md in its own skills folder is older.
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { RPError } from './util.mjs';
+
+const SKILLS_DIR = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..', 'skills');
+
+function frontmatter(text) {
+  const m = text.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?/);
+  const meta = {};
+  if (m) for (const line of m[1].split(/\r?\n/)) { const kv = line.match(/^([a-zA-Z_-]+):\s*(.*)$/); if (kv) meta[kv[1]] = kv[2].replace(/^["']|["']$/g, ''); }
+  return { meta, body: m ? text.slice(m[0].length) : text };
+}
+
+async function load(dir) {
+  let folders = [];
+  try { folders = (await fs.readdir(dir, { withFileTypes: true })).filter(d => d.isDirectory()).map(d => d.name).sort(); } catch { return []; }
+  const out = [];
+  for (const folder of folders) {
+    const file = path.join(dir, folder, 'SKILL.md');
+    let text;
+    try { text = await fs.readFile(file, 'utf8'); } catch { continue; } // a folder without SKILL.md is not a skill
+    const { meta, body } = frontmatter(text);
+    out.push({ name: meta.name || folder, description: meta.description ?? '', file, body: body.trim(), text });
+  }
+  return out;
+}
+
+export async function listSkills({ dir = SKILLS_DIR } = {}) {
+  return (await load(dir)).map(({ name, description }) => ({ name, description }));
+}
+
+export async function getSkill(name, { dir = SKILLS_DIR } = {}) {
+  const all = await load(dir);
+  const hit = all.find(s => s.name === name);
+  if (!hit) throw new RPError('INVALID_ARGUMENT', `${name ? `Unknown skill "${name}".` : 'Name a skill.'} Skills: ${all.map(s => s.name).join(', ') || '(none bundled)'}.`);
+  return hit;
+}

package/port/src/symbols.mjs

@@ -55,6 +55,25 @@ function lineIndex(text) {
 
 const all = (re, text) => [...text.matchAll(re)];
 
+/** `a::{b, c::{self, D}, *}` → `a::b`, `a::c`, `a::c::D`, `a`. Aliases (`as X`) and leading `::` are dropped. */
+export function expandRustUse(spec) {
+  const text = spec.replace(/\s+as\s+\w+/g, '').replace(/\s+/g, '').replace(/^::/, '');
+  const out = [];
+  const walk = (prefix, s) => {
+    const open = s.indexOf('{');
+    if (open < 0) { const p = `${prefix}${s}`.replace(/::(self|\*)$/, '').replace(/^(self|\*)$/, ''); if (p) out.push(p); return; }
+    let depth = 0, close = open;
+    for (; close < s.length; close++) { if (s[close] === '{') depth++; else if (s[close] === '}' && --depth === 0) break; }
+    const items = [];
+    let start = open + 1, level = 0;
+    for (let i = open + 1; i < close; i++) { if (s[i] === '{') level++; else if (s[i] === '}') level--; else if (s[i] === ',' && !level) { items.push(s.slice(start, i)); start = i + 1; } }
+    items.push(s.slice(start, close));
+    for (const item of items) if (item) walk(prefix + s.slice(0, open), item);
+  };
+  walk('', text);
+  return [...new Set(out)];
+}
+
 export function extractSymbols(text, language) {
   const code = stripComments(text, language);
   const line = lineIndex(code);
@@ -150,7 +169,9 @@ export function extractSymbols(text, language) {
       for (const m of all(/\bfn\s+(\w+)/g, code)) fn(m[1], m);
       for (const m of all(/\b(struct|enum|trait|union)\s+(\w+)/g, code)) cls(m[2], m, { kind: m[1] });
       for (const m of all(/^\s*(?:pub(?:\([^)]*\))?\s+)?mod\s+(\w+)\s*;/gm, code)) dep(m[1], 'mod');
-      for (const m of all(/^\s*(?:pub\s+)?use\s+([\w:]+)/gm, code)) dep(m[1], 'use');
+      // `use a::{b, c::{self, D}};` names every leaf; a `use super::…` that is indented sits in an inline
+      // `mod tests { … }`, whose parent is this file, so one `super` becomes `self`.
+      for (const m of all(/^([ \t]*)(?:pub(?:\([^)]*\))?\s+)?use\s+([^;]+);/gm, code)) for (const spec of expandRustUse(m[2])) dep(m[1] ? spec.replace(/^super(?=::|$)/, 'self') : spec, 'use');
       if (/\bfn\s+main\s*\(/.test(code)) out.entry = true;
       break;
     }

package/port/src/tools.mjs

@@ -125,8 +125,8 @@ function validate(schema, args, where = 'arguments') {
       throw new RPError('INVALID_ARGUMENT', `Unknown argument ${hints.join(', ')}${where === 'arguments' ? '' : ` in ${where}`}. Allowed: ${allowed.join(', ')}.`);
     }
     for (const r of schema.required ?? []) if (args[r] === undefined || args[r] === null || args[r] === '') {
-      const d = schema.properties?.[r]?.description;
-      throw new RPError('INVALID_ARGUMENT', `Missing ${r}${d ? ` (${d.replace(/\.$/, '')})` : ''}.`);
+      const { description: d, enum: choices } = schema.properties?.[r] ?? {};
+      throw new RPError('INVALID_ARGUMENT', `Missing ${r}${d ? ` (${d.replace(/\.$/, '')})` : ''}.${choices ? ` One of: ${choices.join(', ')}.` : ''}`);
     }
     for (const [k, v] of Object.entries(args)) if (v !== undefined && v !== null && schema.properties?.[k]) validate(schema.properties[k], v, k);
     return;

package/port/src/util.mjs

@@ -15,8 +15,22 @@ export const IGNORED_DIRS = new Set([
   '.git', '.svn', '.hg', 'node_modules', '.godot', '.import', 'Library', 'Temp', 'Logs', 'UserSettings', 'obj',
   '__pycache__', '.venv', 'venv', '.gradle', '.idea', '.vs', '.vscode', 'DerivedDataCache', 'Intermediate', 'Saved',
   '.mono', '.reverseport', '.cache', '.next', '.nuxt', '.parcel-cache', '.turbo', 'Pods', '.dart_tool',
+  '.pytest_cache', '.mypy_cache', '.ruff_cache', '.tox', 'zig-cache', '.zig-cache', 'zig-out', 'DerivedData',
+  '.svelte-kit', '.angular', '.vite', '.expo', '.terraform', 'bower_components', 'jspm_packages',
 ]);
 
+/**
+ * Folders that are build output or a package store only next to a marker file: `target/` is Rust or Maven output
+ * beside Cargo.toml/pom.xml but may be real source elsewhere; `vendor/` holds copied dependencies beside go.mod,
+ * composer.json or a Gemfile.
+ */
+export const IGNORED_DIRS_BESIDE = {
+  target: ['Cargo.toml', 'pom.xml', 'build.sbt'],
+  vendor: ['go.mod', 'composer.json', 'Gemfile'],
+  '.build': ['Package.swift'],
+  '.gradle': [],
+};
+
 export async function statOrNull(file) { try { return await fs.stat(file); } catch { return null; } }
 
 export async function requireFile(file, what = 'file') {
@@ -88,7 +102,7 @@ export function isText(buf) {
 export const toPosix = p => p.split(path.sep).join('/');
 
 /** Walk a folder. Returns files with posix relative paths; skips IGNORED_DIRS and symlinks. */
-export async function walk(root, { maxFiles = 50000, ignore = IGNORED_DIRS, maxDepth = 40 } = {}) {
+export async function walk(root, { maxFiles = 50000, ignore = IGNORED_DIRS, ignoreBeside = ignore === IGNORED_DIRS ? IGNORED_DIRS_BESIDE : {}, maxDepth = 40 } = {}) {
   const files = [];
   const skipped = new Set();
   const unreadable = [];
@@ -98,12 +112,14 @@ export async function walk(root, { maxFiles = 50000, ignore = IGNORED_DIRS, maxD
     let entries;
     try { entries = await fs.readdir(dir, { withFileTypes: true }); } catch (e) { if (unreadable.length < 50) unreadable.push({ path: toPosix(path.relative(root, dir)) || '.', code: e.code ?? 'ERROR' }); return; }
     entries.sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
+    const names = new Set(entries.map(e => e.name));
+    const buildOutput = name => ignoreBeside[name]?.some(marker => names.has(marker));
     for (const e of entries) {
       if (truncated) return;
       const abs = path.join(dir, e.name);
       if (e.isSymbolicLink()) continue;
       if (e.isDirectory()) {
-        if (ignore.has(e.name)) { skipped.add(toPosix(path.relative(root, abs))); continue; }
+        if (ignore.has(e.name) || buildOutput(e.name)) { skipped.add(toPosix(path.relative(root, abs))); continue; }
         await visit(abs, depth + 1);
       } else if (e.isFile()) {
         if (files.length >= maxFiles) { truncated = true; return; }

package/skills/reverse-engineer-anything/SKILL.md

@@ -34,7 +34,7 @@ original task after repair. Client approval, shell PATH, registration and engine
 availability have different remedies; avoid repeating setup for all of them.
 
 Prefer an existing `reverseport` CLI. When none is installed and ReversePort package acquisition
-is within the authorized scope, use `npx -y reverseport@1.4.0` in its place.
+is within the authorized scope, use `npx -y reverseport@1.5.0` in its place.
 Configuration repair starts with a read-only setup plan; show paths, backups and
 skill replacement before applying authorized changes. Preserve existing approval
 and target-execution boundaries. ReversePort setup never installs or upgrades unrelated