reverseport 1.2.0 → 1.4.0

package/README.md

@@ -242,10 +242,10 @@ command and its JSON error. Every error names the next step, so include that lin
 Two small tools from the same author that work well next to ReversePort. Both are local, open source and have their
 own MCP server, and both install from the ReversePort marketplace:
 
-| Tool | What it does | Claude Code |
-|---|---|---|
-| [**Stashpad**](https://github.com/laaielichter/stashpad) | Memory for agents that you can read, edit and trust: plain Markdown files with a source and dates, a review queue for agent writes, and a handoff note for the next session. `re_case remember` sends a proof case's findings there ([how](docs/proof-and-memory.md#memory-across-sessions-stashpad-optional)). | `/plugin install stashpad@reverseport` |
-| [**agentdisk**](https://github.com/laaielichter/agentdisk) | The disk report for coding agents: the worktrees, checkpoints, `node_modules`, `.venv` and `.godot/` folders agents leave behind (porting work makes plenty), and a cleanup you can undo. Needs the `agentdisk` binary ([install](https://github.com/laaielichter/agentdisk#install)). | `/plugin install agentdisk@reverseport` |
+| Tool                                                       | What it does                                                                                                                                                                                                                                                                                                    | Claude Code                             |
+| ---------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------- |
+| [**Stashpad**](https://github.com/laaielichter/stashpad)   | Memory for agents that you can read, edit and trust: plain Markdown files with a source and dates, a review queue for agent writes, and a handoff note for the next session. `re_case remember` sends a proof case's findings there ([how](docs/proof-and-memory.md#memory-across-sessions-stashpad-optional)). | `/plugin install stashpad@reverseport`  |
+| [**agentdisk**](https://github.com/laaielichter/agentdisk) | The disk report for coding agents: the worktrees, checkpoints, `node_modules`, `.venv` and `.godot/` folders agents leave behind (porting work makes plenty), and a cleanup you can undo. Needs the `agentdisk` binary ([install](https://github.com/laaielichter/agentdisk#install)).                          | `/plugin install agentdisk@reverseport` |
 
 Add the marketplace first with `/plugin marketplace add laaielichter/reverseport`. Other agents: see each project's
 README.

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.2.0", // x-release-please-version
+    version: "1.4.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.2.0",
+  "packageVersion": "1.4.0",
   "platform": "win32",
   "architecture": "x64",
   "abiVersion": 1,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "reverseport",
   "mcpName": "io.github.laaielichter/reverseport",
-  "version": "1.2.0",
+  "version": "1.4.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": {

package/port/src/budget.mjs

@@ -0,0 +1,135 @@
+// Output budget for agents: a tool result that would flood the agent's context is saved whole to a file in the
+// workspace, and the agent gets a shortened result plus where the full one is. Same idea as coding agents that save
+// long tool output to disk ("full output saved to …"). Files older than a week are removed on the next save.
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import { workspaceDir } from './workspace.mjs';
+
+export const DEFAULT_MAX_OUTPUT_BYTES = 256 * 1024;
+const KEEP_DAYS = 7;
+const LONG_STRING = 16 * 1024;
+
+/** Byte budget from REVERSEPORT_MAX_OUTPUT_BYTES: a number (at least 4096), or "off"/"0" for no budget. */
+export function outputLimit(env = process.env) {
+  const raw = String(env.REVERSEPORT_MAX_OUTPUT_BYTES ?? '').trim().toLowerCase();
+  if (raw === 'off' || raw === '0') return Infinity;
+  const n = Number(raw);
+  return raw && Number.isFinite(n) ? Math.max(4096, Math.floor(n)) : DEFAULT_MAX_OUTPUT_BYTES;
+}
+
+const size = v => Buffer.byteLength(JSON.stringify(v) ?? '', 'utf8');
+
+/** Every array and long string in a value, with its path and serialized size. */
+function parts(value, at = '', out = []) {
+  if (Array.isArray(value)) {
+    out.push({ at, kind: 'array', ref: value, bytes: size(value) });
+    value.forEach((v, i) => parts(v, `${at}[${i}]`, out));
+  } else if (value && typeof value === 'object') {
+    for (const [k, v] of Object.entries(value)) parts(v, at ? `${at}.${k}` : k, out);
+  } else if (typeof value === 'string' && value.length > LONG_STRING) out.push({ at, kind: 'string', bytes: value.length });
+  return out;
+}
+
+const isUnder = (at, parent) => at.length > parent.length && at.startsWith(parent) && (parent === '' || at[parent.length] === '.' || at[parent.length] === '[');
+
+function setAt(root, at, fn) {
+  const keys = [...at.matchAll(/\[(\d+)\]|([^.[\]]+)/g)].map(m => (m[1] !== undefined ? Number(m[1]) : m[2]));
+  if (!keys.length) return fn(root);
+  let o = root;
+  for (const k of keys.slice(0, -1)) o = o[k];
+  o[keys.at(-1)] = fn(o[keys.at(-1)]);
+  return root;
+}
+
+/**
+ * Shorten a JSON value until it fits `max` bytes: halve the biggest array (keeping its head) or cut the longest
+ * string, again and again. Returns { value, shortened: [{ path, kept, of }] }.
+ */
+export function shrink(value, max) {
+  let v = structuredClone(value);
+  const originals = new Map();
+  for (let round = 0; round < 200 && size(v) > max; round++) {
+    const cands = parts(v).filter(p => (p.kind === 'array' ? p.ref.length > 1 : true)).sort((a, b) => b.bytes - a.bytes);
+    // Start at the biggest part; when most of it sits in one child (a list inside a list item, a long string),
+    // shorten that child instead, so one huge entry does not empty the whole list.
+    let pick = cands[0];
+    if (!pick) break;
+    for (;;) {
+      const child = cands.find(p => p !== pick && isUnder(p.at, pick.at) && p.bytes >= pick.bytes * 0.6);
+      if (!child) break;
+      pick = child;
+    }
+    if (pick.kind === 'array') {
+      if (!originals.has(pick.at)) originals.set(pick.at, pick.ref.length);
+      v = setAt(v, pick.at, a => a.slice(0, Math.max(1, Math.floor(a.length / 2))));
+    } else {
+      if (!originals.has(pick.at)) originals.set(pick.at, pick.bytes);
+      v = setAt(v, pick.at, s => `${s.slice(0, Math.max(1024, Math.floor(s.length / 2)))}… [cut]`);
+    }
+  }
+  const shortened = [];
+  for (const [at, of] of originals) {
+    let now; try { now = at ? setAtRead(v, at) : v; } catch { continue; }
+    if (Array.isArray(now)) shortened.push({ path: at, kept: now.length, of });
+    else if (typeof now === 'string') shortened.push({ path: at, keptChars: now.length, ofChars: of });
+  }
+  return { value: v, shortened };
+}
+
+function setAtRead(root, at) {
+  const keys = [...at.matchAll(/\[(\d+)\]|([^.[\]]+)/g)].map(m => (m[1] !== undefined ? Number(m[1]) : m[2]));
+  let o = root;
+  for (const k of keys) o = o[k];
+  return o;
+}
+
+async function saveFull(tool, text, ext) {
+  const dir = await workspaceDir('tool-output');
+  const stamp = new Date().toISOString().replace(/[:.]/g, '-');
+  const file = path.join(dir, `${String(tool).replace(/[^\w-]+/g, '_')}-${stamp}-${crypto.randomBytes(3).toString('hex')}.${ext}`);
+  await fs.writeFile(file, text);
+  cleanOld(dir).catch(() => {});
+  return file;
+}
+
+async function cleanOld(dir, now = Date.now()) {
+  for (const name of await fs.readdir(dir)) {
+    const f = path.join(dir, name);
+    const st = await fs.stat(f).catch(() => null);
+    if (st?.isFile() && now - st.mtimeMs > KEEP_DAYS * 86400000) await fs.rm(f, { force: true });
+  }
+}
+
+const NEXT = 'The result was too big for one answer, so lists were shortened (see shortened). The full result is saved in fullOutput: read the part you need from that file, or call again with a narrower request (match, limit, a subfolder or byte range).';
+
+/** Budget for one of ReversePort's own results (a JSON value). */
+export async function budgetValue(tool, value, max = outputLimit()) {
+  if (value === null || typeof value !== 'object' || !Number.isFinite(max)) return value;
+  const full = JSON.stringify(value);
+  const bytes = Buffer.byteLength(full, 'utf8');
+  if (bytes <= max) return value;
+  const fullOutput = await saveFull(tool, full, 'json');
+  const room = Math.max(2048, Math.floor(max * 0.9) - 2048);
+  const { value: small, shortened } = shrink(value, room);
+  const note = { fullOutput, fullBytes: bytes, limitBytes: max, shortened: shortened.slice(0, 20), next: NEXT };
+  return Array.isArray(small) ? { result: small, outputTruncated: note } : { ...small, outputTruncated: note };
+}
+
+/** Budget for a raw MCP tool result from the deep-analysis engine ({ content, structuredContent?, isError? }). */
+export async function budgetMcpResult(tool, result, max = outputLimit()) {
+  if (!result || typeof result !== 'object' || !Number.isFinite(max) || result.isError) return result;
+  const texts = (result.content ?? []).filter(c => c?.type === 'text').map(c => c.text ?? '');
+  const bytes = Math.max(texts.reduce((n, t) => n + Buffer.byteLength(t, 'utf8'), 0), result.structuredContent ? size(result.structuredContent) : 0);
+  if (bytes <= max) return result;
+  if (result.structuredContent && typeof result.structuredContent === 'object') {
+    const small = await budgetValue(tool, result.structuredContent, max);
+    return { ...result, content: [...(result.content ?? []).filter(c => c?.type !== 'text'), { type: 'text', text: JSON.stringify(small) }], structuredContent: small };
+  }
+  const full = texts.join('\n');
+  const fullOutput = await saveFull(tool, full, 'txt');
+  const head = Buffer.from(full, 'utf8').subarray(0, Math.max(1024, max - 1024)).toString('utf8').replace(/�+$/, '');
+  const lines = full.split('\n').length, shown = head.split('\n').length;
+  const marker = `\n\n[showing lines 1-${shown} of ${lines} (${head.length} of ${full.length} characters); full output saved to ${fullOutput}. Read the rest from that file, or call again with a narrower request.]`;
+  return { ...result, content: [...(result.content ?? []).filter(c => c?.type !== 'text'), { type: 'text', text: head + marker }] };
+}

package/port/src/graph.mjs

@@ -7,6 +7,7 @@ import { requireDir, walk, isText } from './util.mjs';
 import { languageOf, fileSymbols, stripComments, identifiers, CODE_LANGUAGES } from './symbols.mjs';
 import { unityGuidMap } from './scene.mjs';
 import { detectEngines } from './scan.mjs';
+import { workspacePackages, packageCandidates, splitSpecifier, tsconfigAliases } from './jsworkspace.mjs';
 
 const JS_EXT = ['.ts', '.tsx', '.mts', '.js', '.mjs', '.cjs', '.jsx', '.vue', '.svelte', '.json'];
 const TYPE_INDEX_LANGS = new Set(['csharp', 'java', 'kotlin', 'gdscript', 'swift', 'haxe', 'dart', 'scala']);
@@ -61,13 +62,27 @@ export async function buildGraph(dir, { maxFiles = 30000 } = {}) {
     if (spec.startsWith('res://')) { const r = godotRootOf(from); return exists(path.posix.normalize((r ? `${r}/` : '') + spec.slice(6))); }
     return exists(path.posix.normalize(path.posix.join(path.posix.dirname(from), spec)));
   };
-  const resolveJs = (from, spec) => {
-    if (!/^\.{1,2}\//.test(spec) && !spec.startsWith('/')) return null;
-    const base = spec.startsWith('/') ? spec.slice(1) : path.posix.normalize(path.posix.join(path.posix.dirname(from), spec));
+  // Monorepos: workspace packages by name and tsconfig "paths" aliases resolve to files in this folder.
+  const hasJs = files.some(f => /\.(m?[jt]sx?|cjs|cts)$/.test(f.rel));
+  const wsPackages = hasJs ? await workspacePackages(files) : new Map();
+  const aliasOf = hasJs ? await tsconfigAliases(files, byRel) : () => [];
+  const jsFile = (base, from) => {
     const stem = base.replace(/\.(m?js|cjs|jsx)$/, '');
+    for (const c of [base, ...JS_EXT.map(e => stem + e), ...JS_EXT.map(e => `${base}/index${e}`)]) { const hit = exists(c); if (hit && hit !== from && nodes.has(hit)) return hit; }
     for (const c of [base, ...JS_EXT.map(e => stem + e), ...JS_EXT.map(e => `${base}/index${e}`)]) { const hit = exists(c); if (hit && hit !== from) return hit; }
     return null;
   };
+  let workspaceEdges = 0, aliasEdges = 0;
+  const resolveJs = (from, spec) => {
+    if (/^\.{1,2}\//.test(spec) || spec.startsWith('/')) {
+      return jsFile(spec.startsWith('/') ? spec.slice(1) : path.posix.normalize(path.posix.join(path.posix.dirname(from), spec)), from);
+    }
+    for (const c of aliasOf(from, spec)) { const hit = jsFile(c, from); if (hit) { aliasEdges++; return hit; } }
+    const { name, sub } = splitSpecifier(spec);
+    const ws = wsPackages.get(name);
+    if (ws) for (const c of packageCandidates(ws, sub)) { const hit = jsFile(c, from); if (hit) { workspaceEdges++; return hit; } }
+    return null;
+  };
   const resolvePy = (from, spec) => {
     const dots = spec.match(/^\.*/)[0].length;
     const mod = spec.slice(dots).replace(/\./g, '/');
@@ -115,7 +130,7 @@ export async function buildGraph(dir, { maxFiles = 30000 } = {}) {
       let hit = null;
       switch (n.language) {
         case 'gdscript': case 'shader': hit = resolveRes(n.file, d.spec); break;
-        case 'javascript': case 'typescript': hit = resolveJs(n.file, d.spec); if (!hit && !/^[./]/.test(d.spec)) external(d.spec.startsWith('@') ? d.spec.split('/').slice(0, 2).join('/') : d.spec.split('/')[0]); break;
+        case 'javascript': case 'typescript': hit = resolveJs(n.file, d.spec); if (!hit && !/^[./]/.test(d.spec) && !wsPackages.has(splitSpecifier(d.spec).name)) external(d.spec.startsWith('@') ? d.spec.split('/').slice(0, 2).join('/') : d.spec.split('/')[0]); break;
         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;
@@ -166,7 +181,25 @@ export async function buildGraph(dir, { maxFiles = 30000 } = {}) {
   const { sccs, order } = tarjanOrder([...nodes.keys()], out);
   const cycles = sccs.filter(c => c.length > 1).sort((a, b) => b.length - a.length);
   const orphans = [...nodes.keys()].filter(k => !inc.get(k) && !entry.has(k) && nodes.get(k).kind !== 'scene' && !(out.get(k).length));
-  return { root, truncated, unreadable, engines, nodes, edges: edges.filter(e => nodes.has(e.to)), externals, cycles, order, entryPoints: [...entry], orphans, inDegree: inc, outEdges: out };
+  let workspace = null;
+  if (wsPackages.size > 1 || aliasEdges) {
+    // Package-level view: which workspace package uses which (counts of file imports across packages).
+    const dirs = [...wsPackages.entries()].map(([name, w]) => ({ name, dir: w.dir })).sort((a, b) => b.dir.length - a.dir.length);
+    const pkgOf = rel => dirs.find(d => !d.dir || rel === d.dir || rel.startsWith(`${d.dir}/`))?.name ?? null;
+    const files = new Map(), links = new Map();
+    for (const k of nodes.keys()) { const p = pkgOf(k); if (p) files.set(p, (files.get(p) ?? 0) + 1); }
+    for (const e of edges) {
+      const a = pkgOf(e.from), b = pkgOf(e.to);
+      if (!a || !b || a === b) continue;
+      const key = `${a}\0${b}`; links.set(key, (links.get(key) ?? 0) + 1);
+    }
+    workspace = {
+      packages: wsPackages.size, workspaceEdges, aliasEdges,
+      packageList: dirs.map(d => ({ name: d.name, dir: d.dir || '.', files: files.get(d.name) ?? 0 })).sort((a, b) => b.files - a.files),
+      packageEdges: [...links.entries()].map(([k, uses]) => { const [from, to] = k.split('\0'); return { from, to, uses }; }).sort((a, b) => b.uses - a.uses),
+    };
+  }
+  return { root, truncated, unreadable, engines, workspace, nodes, edges: edges.filter(e => nodes.has(e.to)), externals, cycles, order, entryPoints: [...entry], orphans, inDegree: inc, outEdges: out };
 }
 
 function commonPrefix(a, b) { let i = 0; while (i < a.length && i < b.length && a[i] === b[i]) i++; return i; }
@@ -232,6 +265,7 @@ export async function graphTool({ path: dir, limit, format = 'json' } = {}) {
   return {
     root: g.root, truncated: g.truncated, ...(g.unreadable?.length ? { unreadable: g.unreadable, warnings: [`${g.unreadable.length} folder(s) could not be read; the graph does not cover them.`] } : {}), fileCount: g.nodes.size, edgeCount: g.edges.length,
     entryPoints: g.entryPoints, cycles: g.cycles.slice(0, 20).map(c => c.slice(0, 30)), orphans: g.orphans.slice(0, 100),
+    ...(g.workspace ? { workspace: { packages: g.workspace.packages, resolvedByPackageName: g.workspace.workspaceEdges, resolvedByTsconfigPaths: g.workspace.aliasEdges, packageList: g.workspace.packageList.slice(0, max), packageEdges: g.workspace.packageEdges.slice(0, edgeMax) } } : {}),
     mostUsed: files.slice(0, 25), externals: ext,
     portOrder: g.order.slice(0, max), portOrderTruncated: g.order.length > max,
     edges: g.edges.slice(0, edgeMax), edgesTruncated: g.edges.length > edgeMax,

package/port/src/jsworkspace.mjs

@@ -0,0 +1,155 @@
+// JavaScript/TypeScript monorepos: workspace packages (npm/yarn/pnpm/bun workspaces, turbo, nx, lerna)
+// and tsconfig "paths" aliases. Lets the graph follow `@scope/pkg/sub` and `@/foo` imports to real files
+// instead of counting them as outside libraries.
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+/** JSON with comments and trailing commas (tsconfig, turbo.json, jsconfig). Returns null when damaged. */
+export function parseJsonc(text) {
+  if (typeof text !== 'string') return null;
+  let out = '', i = 0, inStr = false;
+  while (i < text.length) {
+    const c = text[i], n = text[i + 1];
+    if (inStr) { out += c; if (c === '\\') { out += n ?? ''; i += 2; continue; } if (c === '"') inStr = false; i++; continue; }
+    if (c === '"') { inStr = true; out += c; i++; continue; }
+    if (c === '/' && n === '/') { while (i < text.length && text[i] !== '\n') i++; continue; }
+    if (c === '/' && n === '*') { i += 2; while (i < text.length && !(text[i] === '*' && text[i + 1] === '/')) i++; i += 2; continue; }
+    out += c; i++;
+  }
+  out = out.replace(/,(\s*[}\]])/g, '$1');
+  try { return JSON.parse(out); } catch { return null; }
+}
+
+const readMaybe = async abs => { try { return await fs.readFile(abs, 'utf8'); } catch { return null; } };
+
+/** Package manager and monorepo tool from lockfiles and config at the root. */
+export function workspaceTooling(rels, rootPkg = {}) {
+  const has = f => rels.includes(f);
+  const manager = rootPkg.packageManager?.split('@')[0]
+    ?? (has('bun.lock') || has('bun.lockb') ? 'bun' : has('pnpm-lock.yaml') ? 'pnpm' : has('yarn.lock') ? 'yarn' : has('package-lock.json') ? 'npm' : null);
+  const tools = [['turbo.json', 'Turborepo'], ['nx.json', 'Nx'], ['lerna.json', 'Lerna'], ['rush.json', 'Rush'], ['pnpm-workspace.yaml', 'pnpm workspaces']]
+    .filter(([f]) => has(f)).map(([, n]) => n);
+  return { manager, tools };
+}
+
+/**
+ * Workspace packages by name. `files` are walk() entries ({rel, abs}). Every package.json outside
+ * node_modules counts; that also covers repos that do not declare workspaces but import siblings by name.
+ */
+export async function workspacePackages(files) {
+  const packages = new Map();
+  for (const f of files) {
+    if (!/(^|\/)package\.json$/.test(f.rel) || f.rel.includes('node_modules/')) continue;
+    const pkg = parseJsonc(await readMaybe(f.abs));
+    if (!pkg?.name || typeof pkg.name !== 'string') continue;
+    const dir = path.posix.dirname(f.rel) === '.' ? '' : path.posix.dirname(f.rel);
+    if (!packages.has(pkg.name) || dir.length < packages.get(pkg.name).dir.length) packages.set(pkg.name, { dir, pkg });
+  }
+  return packages;
+}
+
+/** Split `@scope/name/sub/path` or `name/sub` into package name and subpath ('' when none). */
+export function splitSpecifier(spec) {
+  const parts = spec.split('/');
+  const n = spec.startsWith('@') ? 2 : 1;
+  return { name: parts.slice(0, n).join('/'), sub: parts.slice(n).join('/') };
+}
+
+// Pick a file-looking target out of an exports entry (string, conditions object, or array).
+function exportTarget(v) {
+  if (typeof v === 'string') return v;
+  if (Array.isArray(v)) { for (const x of v) { const t = exportTarget(x); if (t) return t; } return null; }
+  if (v && typeof v === 'object') {
+    for (const k of ['source', 'bun', 'development', 'import', 'types', 'module', 'node', 'require', 'browser', 'default']) if (k in v) { const t = exportTarget(v[k]); if (t) return t; }
+    for (const x of Object.values(v)) { const t = exportTarget(x); if (t) return t; }
+  }
+  return null;
+}
+
+/** Candidate relative paths inside the package for a subpath, most likely first. */
+export function packageCandidates({ dir, pkg }, sub) {
+  const base = dir ? `${dir}/` : '';
+  const out = [];
+  const key = sub ? `./${sub}` : '.';
+  const ex = pkg.exports;
+  if (ex && typeof ex === 'object' && !Array.isArray(ex) && Object.keys(ex).some(k => k.startsWith('.'))) {
+    if (key in ex) { const t = exportTarget(ex[key]); if (t) out.push(t); }
+    for (const [k, v] of Object.entries(ex)) {
+      const star = k.indexOf('*');
+      if (star < 0 || !sub) continue;
+      const pre = k.slice(0, star), post = k.slice(star + 1);
+      if (key.startsWith(pre) && key.endsWith(post) && key.length >= pre.length + post.length) {
+        const t = exportTarget(v);
+        if (t) out.push(t.replace('*', key.slice(pre.length, key.length - post.length)));
+      }
+    }
+  } else if (!sub && (typeof ex === 'string' || Array.isArray(ex))) { const t = exportTarget(ex); if (t) out.push(t); }
+  if (!sub) for (const k of ['source', 'module', 'main', 'types', 'typings']) if (typeof pkg[k] === 'string') out.push(pkg[k]);
+  if (sub) out.push(sub, `src/${sub}`);
+  else out.push('src/index', 'index', 'src/main', 'mod');
+  // Built output often points at dist/; the source usually sits at the same place under src/.
+  const extra = [];
+  for (const c of out) { const m = c.replace(/^\.\//, '').match(/^(dist|build|lib|out)\/(.*)$/); if (m) extra.push(`src/${m[2]}`); }
+  return [...out, ...extra].map(c => path.posix.normalize(base + c.replace(/^\.\//, '')));
+}
+
+/** tsconfig/jsconfig `paths` per folder, following `extends` to local files (a few levels). */
+export async function tsconfigAliases(files, byRel) {
+  const configs = new Map();
+  const load = async (rel, depth = 0) => {
+    if (configs.has(rel)) return configs.get(rel);
+    const f = byRel.get(rel);
+    const json = f ? parseJsonc(await readMaybe(f.abs)) : null;
+    let result = null;
+    if (json) {
+      const dir = path.posix.dirname(rel) === '.' ? '' : path.posix.dirname(rel);
+      let inherited = null;
+      for (const ext of [json.extends].flat().filter(e => typeof e === 'string' && e.startsWith('.'))) {
+        if (depth > 4) break;
+        let target = path.posix.normalize(path.posix.join(dir || '.', ext));
+        if (!target.endsWith('.json')) target += '.json';
+        const parent = await load(target, depth + 1);
+        if (parent) inherited = parent;
+      }
+      const co = json.compilerOptions ?? {};
+      if (co.paths && typeof co.paths === 'object') {
+        // Paths resolve against baseUrl when set, else against the tsconfig that declares them.
+        const baseDir = typeof co.baseUrl === 'string' ? path.posix.normalize(path.posix.join(dir || '.', co.baseUrl)) : (dir || '.');
+        result = { baseDir: baseDir === '.' ? '' : baseDir, paths: co.paths };
+      } else if (inherited) result = inherited;
+    }
+    configs.set(rel, result);
+    return result;
+  };
+  for (const f of files) if (/(^|\/)(tsconfig[\w.-]*|jsconfig)\.json$/.test(f.rel) && !f.rel.includes('node_modules/')) await load(f.rel);
+  const byDir = new Map();
+  for (const [rel, cfg] of configs) {
+    if (!cfg || !/(^|\/)(tsconfig|jsconfig)\.json$/.test(rel)) continue;
+    byDir.set(path.posix.dirname(rel) === '.' ? '' : path.posix.dirname(rel), cfg);
+  }
+  /** Candidate relative paths for `spec` imported from `from`; [] when no alias matches. */
+  return (from, spec) => {
+    let dir = path.posix.dirname(from);
+    for (;;) {
+      const key = dir === '.' ? '' : dir;
+      const cfg = byDir.get(key);
+      if (cfg) {
+        const out = [];
+        for (const [pattern, targets] of Object.entries(cfg.paths)) {
+          const star = pattern.indexOf('*');
+          let wild = null;
+          if (star < 0) { if (spec !== pattern) continue; wild = ''; }
+          else {
+            const pre = pattern.slice(0, star), post = pattern.slice(star + 1);
+            if (!spec.startsWith(pre) || !spec.endsWith(post) || spec.length < pre.length + post.length) continue;
+            wild = spec.slice(pre.length, spec.length - post.length);
+          }
+          for (const t of [targets].flat()) if (typeof t === 'string') out.push(path.posix.normalize(path.posix.join(cfg.baseDir || '.', t.replace('*', wild))));
+        }
+        return out;
+      }
+      if (key === '') return [];
+      dir = path.posix.dirname(dir);
+    }
+  };
+}

package/port/src/relay.mjs

@@ -15,6 +15,7 @@ import { fileURLToPath } from 'node:url';
 import { tools as localToolDefs, callTool, coerceArgs, VERSION } from './tools.mjs';
 import { errorPayload, closest, portableSchema } from './agent.mjs';
 import { RPError } from './util.mjs';
+import { budgetValue, budgetMcpResult } from './budget.mjs';
 
 const REPO = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..');
 export const SUPPORTED_PROTOCOLS = ['2025-11-25', '2025-06-18', '2025-03-26', '2024-11-05'];
@@ -366,12 +367,12 @@ export function createRelay(hooks = {}, options = {}) {
     const input = coerceArgs(schema, dropDisallowedNulls(schema, args ?? {}));
     const res = await engine.forward('tools/call', { name, arguments: input, ...(meta ? { _meta: meta } : {}) }, clientKey);
     if (!res.error && !res.result?.structuredContent?.error?.code?.startsWith?.('ENGINE_')) state.restarts = 0; // a working call resets the restart budget
-    return res.error ? toolError(Object.assign(new Error(res.error.message), { code: 'TOOL_FAILED', details: { rpc: res.error } })) : res.result;
+    return res.error ? toolError(Object.assign(new Error(res.error.message), { code: 'TOOL_FAILED', details: { rpc: res.error } })) : budgetMcpResult(name, res.result);
   }
 
   async function runLocal(name, args) {
     const def = localToolDefs.find(t => t.name === name);
-    const run = async () => { try { return toolResult(await callTool(name, args ?? {})); } catch (e) { return toolError(e); } };
+    const run = async () => { try { return toolResult(await budgetValue(name, await callTool(name, args ?? {}))); } catch (e) { return toolError(e); } };
     if (def?.annotations?.readOnlyHint) return run();
     const p = writerQueue.then(run);
     writerQueue = p.catch(() => {});

package/port/src/scan.mjs

@@ -5,6 +5,7 @@ import path from 'node:path';
 import { RPError, requireDir, walk, readAt, countLines, isText, MiB } from './util.mjs';
 import { LANGUAGE_BY_EXT, CODE_LANGUAGES } from './symbols.mjs';
 import { parseGodotProject } from './scene.mjs';
+import { workspaceTooling } from './jsworkspace.mjs';
 
 const CATEGORY_BY_EXT = {};
 const cat = (name, exts) => exts.split(' ').forEach(e => { CATEGORY_BY_EXT[`.${e}`] = name; });
@@ -19,6 +20,36 @@ cat('config', 'json yaml yml toml ini cfg xml plist properties godot import meta
 cat('build-binary', 'exe dll so dylib pck pak ucas utoc bundle assets ress resource apk aab ipa jar class dex wasm pdb lib a o obj node');
 cat('docs', 'md txt rst pdf html htm');
 
+// npm dependency → framework name, for "what is this built with" in JS/TS projects.
+const JS_FRAMEWORKS = [['three', 'three.js'], ['phaser', 'Phaser'], ['@babylonjs/core', 'Babylon.js'], ['babylonjs', 'Babylon.js'], ['pixi.js', 'PixiJS'], ['playcanvas', 'PlayCanvas'], ['excalibur', 'Excalibur'], ['kaboom', 'Kaboom'], ['kaplay', 'KAPLAY'],
+  ['electron', 'Electron'], ['electron-vite', 'Electron'], ['electron-builder', 'Electron'], ['@tauri-apps/api', 'Tauri'], ['@capacitor/core', 'Capacitor'], ['react-native', 'React Native'], ['expo', 'Expo'],
+  ['react', 'React'], ['vue', 'Vue'], ['svelte', 'Svelte'], ['solid-js', 'SolidJS'], ['preact', 'Preact'], ['@angular/core', 'Angular'], ['lit', 'Lit'],
+  ['next', 'Next.js'], ['nuxt', 'Nuxt'], ['@sveltejs/kit', 'SvelteKit'], ['@solidjs/start', 'SolidStart'], ['astro', 'Astro'], ['@remix-run/react', 'Remix'], ['react-router', 'React Router'],
+  ['vite', 'Vite'], ['webpack', 'webpack'], ['esbuild', 'esbuild'],
+  ['express', 'Express'], ['fastify', 'Fastify'], ['hono', 'Hono'], ['koa', 'Koa'], ['@nestjs/core', 'NestJS'], ['elysia', 'Elysia'],
+  ['effect', 'Effect'], ['drizzle-orm', 'Drizzle ORM'], ['@prisma/client', 'Prisma'], ['@trpc/server', 'tRPC'],
+  ['@modelcontextprotocol/sdk', 'MCP SDK'], ['ai', 'Vercel AI SDK'], ['@opentui/core', 'OpenTUI'], ['ink', 'Ink (terminal UI)'], ['sst', 'SST']];
+
+/** The file a package script starts (`node x.js`, `tsx src/a.ts`, `bun run --cwd pkg src/index.ts`). A leading \0 marks a path relative to --cwd's target, already joined. */
+function scriptEntry(cmd) {
+  if (typeof cmd !== 'string') return null;
+  for (const part of cmd.split(/&&|\|\||;|\|/)) {
+    const t = part.trim().split(/\s+/);
+    const i = t.findIndex(x => /^(node|tsx|ts-node|bun|deno|esno|vite-node)$/.test(x));
+    if (i < 0) continue;
+    let cwd = null;
+    for (let j = i + 1; j < t.length; j++) {
+      const x = t[j];
+      if (x === 'run' || x === 'x') continue;
+      if (x === '--cwd' && t[j + 1]) { cwd = t[++j]; continue; }
+      if (x.startsWith('--cwd=')) { cwd = x.slice(6); continue; }
+      if (x.startsWith('-')) continue;
+      if (/\.[cm]?[jt]sx?$/.test(x)) return cwd ? `\0${path.posix.normalize(path.posix.join(cwd, x))}` : x;
+    }
+  }
+  return null;
+}
+
 function categoryOf(f) {
   const lang = LANGUAGE_BY_EXT[f.ext];
   if (lang && CODE_LANGUAGES.has(lang)) return 'code';
@@ -104,18 +135,37 @@ export async function detectEngines(root, files) {
     else if (/\bFNA\b/.test(t)) add({ id: 'fna', name: 'FNA', kind: 'project', evidence: [f.rel] });
     else if (/Godot\.NET\.Sdk/i.test(t)) { /* part of a Godot .NET project */ }
   }
-  for (const f of find(/(^|\/)package\.json$/).filter(f => !f.rel.includes('node_modules')).slice(0, 10)) {
+  const pkgFiles = find(/(^|\/)package\.json$/).filter(f => !f.rel.includes('node_modules')).sort((a, b) => a.rel.split('/').length - b.rel.split('/').length);
+  const PKG_MAX = 60;
+  for (const f of pkgFiles.slice(0, PKG_MAX)) {
     let pkg = {};
     try { pkg = JSON.parse(await readText(f.abs)); } catch { continue; }
     const deps = { ...pkg.dependencies, ...pkg.devDependencies };
-    const known = [['three', 'three.js'], ['phaser', 'Phaser'], ['@babylonjs/core', 'Babylon.js'], ['babylonjs', 'Babylon.js'], ['pixi.js', 'PixiJS'], ['playcanvas', 'PlayCanvas'], ['excalibur', 'Excalibur'], ['kaboom', 'Kaboom'], ['electron', 'Electron'], ['react', 'React'], ['vue', 'Vue'], ['svelte', 'Svelte'], ['next', 'Next.js'], ['react-native', 'React Native']];
-    const found = known.filter(([d]) => deps[d]).map(([, n]) => n);
-    const starts = [...(typeof pkg.bin === 'string' ? [pkg.bin] : Object.values(pkg.bin ?? {})), ...['start', 'dev', 'serve'].map(k => String(pkg.scripts?.[k] ?? '').match(/\b(?:node|tsx|ts-node|bun|deno run)\s+(?:--?\S+\s+)*([^\s&|;]+\.[cm]?[jt]s)\b/)?.[1]).filter(Boolean)];
+    const found = JS_FRAMEWORKS.filter(([d]) => deps[d]).map(([, n]) => n);
+    const pkgDir = path.posix.dirname(f.rel) === '.' ? '' : path.posix.dirname(f.rel);
+    const starts = [...(typeof pkg.bin === 'string' ? [pkg.bin] : Object.values(pkg.bin ?? {})), ...['start', 'dev', 'serve'].map(k => scriptEntry(pkg.scripts?.[k])).filter(Boolean)];
+    // `bun run --cwd packages/cli src/index.ts` at the root starts a file in another package.
+    for (let i = 0; i < starts.length; i++) if (typeof starts[i] === 'string' && starts[i].startsWith('\0')) starts[i] = path.posix.relative(pkgDir || '.', starts[i].slice(1)) || starts[i].slice(1);
     add({ id: 'node', name: `Node.js package${found.length ? ` (${[...new Set(found)].join(', ')})` : ''}`, kind: 'project', root: path.posix.dirname(f.rel) === '.' ? '' : path.posix.dirname(f.rel), evidence: [f.rel], details: { name: pkg.name, main: pkg.main, bin: pkg.bin, starts: [...new Set(starts)], scripts: Object.keys(pkg.scripts ?? {}), frameworks: [...new Set(found)] } });
   }
+  if (pkgFiles.length > 1 || rels.some(r => /^(turbo|nx|lerna|rush)\.json$|^pnpm-workspace\.yaml$/.test(r))) {
+    let rootPkg = {};
+    if (has('package.json')) { try { rootPkg = JSON.parse(await readText(path.join(root, 'package.json'))); } catch { /* damaged */ } }
+    const { manager, tools } = workspaceTooling(rels, rootPkg);
+    const declared = Array.isArray(rootPkg.workspaces) ? rootPkg.workspaces : rootPkg.workspaces?.packages ?? [];
+    if (declared.length || tools.length || pkgFiles.length > 2) {
+      add({ id: 'js-monorepo', name: `JavaScript/TypeScript monorepo (${[manager, ...tools].filter(Boolean).join(', ') || 'workspaces'})`, kind: 'project', evidence: ['package.json', ...rels.filter(r => /^(turbo|nx|lerna|rush)\.json$|^pnpm-workspace\.yaml$|^bun\.lockb?$/.test(r))].filter(r => rels.includes(r)), details: { packageManager: manager, tools, workspaces: declared, packages: pkgFiles.length, packagesListed: Math.min(pkgFiles.length, PKG_MAX) } });
+    }
+  }
   if (rels.some(r => /(^|\/)resources\/app\.asar$/i.test(r))) add({ id: 'electron-build', name: 'Electron app build', kind: 'build', evidence: rels.filter(r => /app\.asar$/i.test(r)).slice(0, 3) });
   if (find(/(^|\/)pubspec\.yaml$/).length) add({ id: 'flutter', name: 'Flutter / Dart', kind: 'project', evidence: find(/(^|\/)pubspec\.yaml$/).map(f => f.rel) });
-  if (find(/(^|\/)AndroidManifest\.xml$/).length) add({ id: 'android', name: 'Android app', kind: 'project', evidence: find(/(^|\/)AndroidManifest\.xml$/).slice(0, 3).map(f => f.rel) });
+  const depthOfRel = r => r.split('/').length;
+  const manifests = find(/(^|\/)AndroidManifest\.xml$/).map(f => f.rel).sort((a, b) => depthOfRel(a) - depthOfRel(b));
+  if (manifests.length) {
+    // The project root is the folder above src/main (and above app/ for a Gradle app module).
+    const root = path.posix.dirname(manifests[0]).replace(/(^|\/)src\/main$/, '').replace(/(^|\/)app$/, '');
+    add({ id: 'android', name: 'Android app', kind: 'project', root: root === '.' ? '' : root, evidence: manifests.slice(0, 3) });
+  }
   if (find(/\.xcodeproj\//).length) add({ id: 'xcode', name: 'Xcode project (Apple)', kind: 'project', evidence: [...new Set(find(/\.xcodeproj\//).map(f => f.rel.split('.xcodeproj/')[0] + '.xcodeproj'))].slice(0, 3) });
   if (find(/\.sln$/i).length && !engines.some(e => ['unity', 'godot'].includes(e.id))) add({ id: 'dotnet', name: '.NET solution', kind: 'project', evidence: find(/\.sln$/i).map(f => f.rel).slice(0, 3) });
   for (const [file, id, name] of [['go.mod', 'go', 'Go module'], ['CMakeLists.txt', 'cmake', 'CMake (C/C++)'], ['pyproject.toml', 'python', 'Python project'], ['setup.py', 'python', 'Python project'], ['requirements.txt', 'python', 'Python project'], ['pom.xml', 'maven', 'Maven (Java)'], ['build.gradle', 'gradle', 'Gradle (JVM)'], ['build.gradle.kts', 'gradle', 'Gradle (JVM)'], ['Makefile', 'make', 'Makefile build']]) {
@@ -148,7 +198,7 @@ export async function scanProject({ path: dir, maxFiles = 50000 } = {}) {
   }
   const engines = await detectEngines(abs, files);
   const depthOf = e => (e.root ? e.root.split('/').length : 0);
-  const primary = engines.filter(e => e.kind === 'project').sort((a, b) => depthOf(a) - depthOf(b))[0] ?? engines[0] ?? null;
+  const primary = engines.filter(e => e.kind === 'project').sort((a, b) => depthOf(a) - depthOf(b) || (b.id === 'js-monorepo') - (a.id === 'js-monorepo'))[0] ?? engines[0] ?? null;
   const entryPoints = [];
   for (const e of engines) {
     if (e.id === 'godot') {

package/port/src/tools.mjs

@@ -35,7 +35,7 @@ export const tools = [
     description: 'Reconnaissance of a folder: detects the engine/framework (Godot, Unity, Unreal, GameMaker, RPG Maker, Ren\'Py, LÖVE, Defold, Bevy, MonoGame, three.js/Phaser/Electron, Flutter, .NET, Go, Rust, Python…) for source projects AND exported game builds, languages with line counts, file categories, entry points, biggest files and binaries. Start here.',
     inputSchema: obj({ path: str('Folder to scan.'), maxFiles: int('Stop after this many files (default 50000).', { minimum: 100, maximum: 500000 }) }, ['path']) },
   { name: 're_graph', brief: 'Dependency graph of a project: entry points, cycles, most-used files and the port order.', title: 'Dependency graph and port order',
-    description: 'Builds the dependency graph of a project: imports/includes/requires, Godot res:// loads and scene resources, Unity script/prefab GUIDs, and type references (C#, GDScript class_name/autoloads, Java…). Returns entry points, cycles, orphans, most-used files, external packages and the port order (dependencies first). format:"mermaid" adds a diagram.',
+    description: 'Builds the dependency graph of a project: imports/includes/requires, Godot res:// loads and scene resources, Unity script/prefab GUIDs, and type references (C#, GDScript class_name/autoloads, Java…). JS/TS monorepos: imports of workspace packages by name and tsconfig paths aliases resolve to their files, and a workspace section shows which package uses which. Returns entry points, cycles, orphans, most-used files, external packages and the port order (dependencies first). format:"mermaid" adds a diagram.',
     inputSchema: obj({ path: str('Project folder.'), limit: int('Files in portOrder (default 80; edges 40). Larger values return more.', { minimum: 10, maximum: 5000 }), format: str('json (default), mermaid or both.', { enum: ['json', 'mermaid', 'both'] }) }, ['path']) },
   { name: 're_symbols', brief: 'Classes, functions, signals and exported fields of a file or folder; match filters by name.', title: 'Classes, functions, signals',
     description: 'Code structure for one file or a whole folder (30+ languages: GDScript, C#, C/C++ incl. Unreal macros, Python, JS/TS, Lua, Java/Kotlin, Go, Rust, Swift, shaders, Ren\'Py…): classes with base classes, functions with lines, signals/events, exported/serialized fields, dependencies, node paths. match filters by name (substring or * wildcard).',
@@ -181,7 +181,23 @@ function coerce(schema, value, adjusted = null, at = '') {
     }
   }
   if ((schema?.type === 'integer' && typeof value === 'string' && /^-?\d+$/.test(value.trim())) || (schema?.type === 'number' && typeof value === 'string' && value.trim() !== '' && Number.isFinite(Number(value)))) return Number(value);
-  if (schema?.type === 'boolean' && (value === 'true' || value === 'false')) return value === 'true';
+  if (schema?.type === 'boolean' && typeof value === 'string') {
+    const b = value.trim().toLowerCase();
+    if (b === 'true' || b === 'false') return b === 'true';
+    if (adjusted && ['yes', 'no', 'on', 'off', '1', '0'].includes(b)) { adjusted[at] = `read "${value}" as ${['yes', 'on', '1'].includes(b)}`; return ['yes', 'on', '1'].includes(b); }
+  }
+  if (schema?.type === 'boolean' && adjusted && (value === 1 || value === 0)) { adjusted[at] = `read ${value} as ${value === 1}`; return value === 1; }
+  // "Godot" for "godot", "Mermaid " for "mermaid": only when exactly one allowed value matches.
+  if (schema?.type === 'string' && Array.isArray(schema.enum) && typeof value === 'string' && !schema.enum.includes(value) && adjusted) {
+    const norm = x => String(x).trim().toLowerCase().replace(/[\s_-]+/g, '');
+    const hits = schema.enum.filter(e => norm(e) === norm(value));
+    if (hits.length === 1) { adjusted[at] = `read "${value}" as "${hits[0]}"`; return hits[0]; }
+  }
+  if (schema?.type === 'array' && typeof value === 'string' && adjusted) {
+    // A JSON list sent as text, or one value where a list is expected.
+    if (/^\s*\[/.test(value)) { try { const parsed = JSON.parse(value); if (Array.isArray(parsed)) { adjusted[at] = 'parsed the list from text'; return parsed.map((v, i) => coerce(schema.items, v, adjusted, `${at}[${i}]`)); } } catch { /* not JSON: validation explains */ } }
+    else if (schema.items?.type === 'string' && value.trim() !== '') { adjusted[at] = 'wrapped the single value in a list'; return [value]; }
+  }
   if (schema?.type === 'array' && Array.isArray(value)) return value.map((v, i) => coerce(schema.items, v, adjusted, `${at}[${i}]`));
   return value;
 }

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.2.0` in its place.
+is within the authorized scope, use `npx -y reverseport@1.4.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