universal-ast-mapper 2.0.0 → 2.0.2

package/dist/worker.js

@@ -0,0 +1,27 @@
+// Worker-thread entry: builds skeletons (and optionally per-file complexity)
+// off the main thread. Spawned by pool.ts with { cacheDir } as workerData.
+import { parentPort, workerData } from "node:worker_threads";
+import { buildSkeleton } from "./skeleton.js";
+import { computeFileComplexity } from "./complexity.js";
+import { initDiskCache } from "./diskcache.js";
+const data = (workerData ?? {});
+if (data.cacheDir)
+    initDiskCache(data.cacheDir);
+parentPort.on("message", (msg) => {
+    void (async () => {
+        try {
+            const skel = await buildSkeleton(msg.abs, msg.rel, msg.opts);
+            const complexity = msg.withComplexity
+                ? await computeFileComplexity(msg.abs, msg.rel)
+                : undefined;
+            parentPort.postMessage({ id: msg.id, ok: true, skel, complexity });
+        }
+        catch (e) {
+            parentPort.postMessage({
+                id: msg.id,
+                ok: false,
+                error: e instanceof Error ? e.message : String(e),
+            });
+        }
+    })();
+});

package/dist/workspace.js

@@ -0,0 +1,330 @@
+import fs from "node:fs";
+import path from "node:path";
+const IGNORE_DIRS = new Set(["node_modules", ".git", "dist", "build", ".next", "coverage"]);
+function readJson(file) {
+    try {
+        return JSON.parse(fs.readFileSync(file, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+/** Minimal `packages:` list reader for pnpm-workspace.yaml (no YAML dep). */
+function readPnpmPatterns(file) {
+    let text;
+    try {
+        text = fs.readFileSync(file, "utf8");
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    let inPackages = false;
+    for (const raw of text.split(/\r?\n/)) {
+        const line = raw.replace(/#.*$/, "");
+        if (/^packages\s*:/.test(line)) {
+            inPackages = true;
+            continue;
+        }
+        if (inPackages) {
+            const m = line.match(/^\s*-\s*['"]?([^'"]+?)['"]?\s*$/);
+            if (m)
+                out.push(m[1].trim());
+            else if (/^\S/.test(line))
+                break; // next top-level key
+        }
+    }
+    return out;
+}
+/** Expand a workspace glob pattern to package directories containing package.json. */
+function expandPattern(rootAbs, pattern) {
+    const clean = pattern.replace(/\/+$/, "");
+    const dirs = [];
+    const hasPkg = (dir) => fs.existsSync(path.join(dir, "package.json"));
+    if (!clean.includes("*")) {
+        const abs = path.resolve(rootAbs, clean);
+        if (hasPkg(abs))
+            dirs.push(abs);
+        return dirs;
+    }
+    if (clean.endsWith("/**")) {
+        const base = path.resolve(rootAbs, clean.slice(0, -3));
+        walkForPackages(base, dirs, 6);
+        return dirs;
+    }
+    // `prefix/*` — immediate subdirectories.
+    if (clean.endsWith("/*")) {
+        const base = path.resolve(rootAbs, clean.slice(0, -2));
+        let entries = [];
+        try {
+            entries = fs.readdirSync(base, { withFileTypes: true });
+        }
+        catch {
+            return dirs;
+        }
+        for (const e of entries) {
+            if (e.isDirectory() && !IGNORE_DIRS.has(e.name) && hasPkg(path.join(base, e.name))) {
+                dirs.push(path.join(base, e.name));
+            }
+        }
+        return dirs;
+    }
+    // Fallback: bounded recursive scan under the non-glob prefix.
+    const prefix = clean.split("*")[0];
+    walkForPackages(path.resolve(rootAbs, prefix), dirs, 6);
+    return dirs;
+}
+function walkForPackages(base, out, depth) {
+    if (depth < 0)
+        return;
+    let entries;
+    try {
+        entries = fs.readdirSync(base, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    if (fs.existsSync(path.join(base, "package.json")))
+        out.push(base);
+    for (const e of entries) {
+        if (e.isDirectory() && !IGNORE_DIRS.has(e.name)) {
+            walkForPackages(path.join(base, e.name), out, depth - 1);
+        }
+    }
+}
+function depNames(pkg) {
+    const out = new Set();
+    for (const key of ["dependencies", "devDependencies", "peerDependencies", "optionalDependencies"]) {
+        const d = pkg?.[key];
+        if (d && typeof d === "object")
+            for (const k of Object.keys(d))
+                out.add(k);
+    }
+    return [...out];
+}
+/**
+ * Discover the packages in a JS/TS monorepo and the dependency edges between
+ * them. Supports npm/yarn `workspaces`, pnpm-workspace.yaml, and lerna.json.
+ */
+export function discoverWorkspace(rootAbs) {
+    const rootPkg = readJson(path.join(rootAbs, "package.json"));
+    let tool = "none";
+    const patterns = [];
+    // npm / yarn workspaces
+    const ws = rootPkg?.workspaces;
+    if (Array.isArray(ws)) {
+        patterns.push(...ws);
+        tool = "npm";
+    }
+    else if (ws && Array.isArray(ws.packages)) {
+        patterns.push(...ws.packages);
+        tool = "npm";
+    }
+    // pnpm
+    const pnpmFile = path.join(rootAbs, "pnpm-workspace.yaml");
+    if (fs.existsSync(pnpmFile)) {
+        patterns.push(...readPnpmPatterns(pnpmFile));
+        tool = "pnpm";
+    }
+    // lerna
+    const lerna = readJson(path.join(rootAbs, "lerna.json"));
+    if (lerna && Array.isArray(lerna.packages)) {
+        patterns.push(...lerna.packages);
+        if (tool === "none")
+            tool = "lerna";
+    }
+    // Dedupe patterns, expand to package dirs.
+    const dirSet = new Set();
+    for (const p of [...new Set(patterns)]) {
+        for (const d of expandPattern(rootAbs, p))
+            dirSet.add(d);
+    }
+    const packages = [];
+    const nameToPkg = new Map();
+    const pending = [];
+    for (const dirAbs of [...dirSet].sort()) {
+        const pj = readJson(path.join(dirAbs, "package.json"));
+        if (!pj || !pj.name)
+            continue;
+        const rel = path.relative(rootAbs, dirAbs).split(path.sep).join("/");
+        const allDeps = depNames(pj);
+        const wp = { name: pj.name, dir: rel || ".", internalDeps: [], allDeps };
+        packages.push(wp);
+        nameToPkg.set(pj.name, wp);
+        pending.push({ pkg: wp, deps: allDeps });
+    }
+    // Resolve internal deps now that all package names are known.
+    const edges = [];
+    for (const { pkg, deps } of pending) {
+        for (const d of deps) {
+            if (nameToPkg.has(d) && d !== pkg.name) {
+                pkg.internalDeps.push(d);
+                edges.push({ from: pkg.name, to: d });
+            }
+        }
+        pkg.internalDeps.sort();
+    }
+    return { root: rootAbs, tool, packages, edges };
+}
+/** Detect circular dependencies among workspace packages (package-level). */
+export function findPackageCycles(info) {
+    const adj = new Map();
+    for (const p of info.packages)
+        adj.set(p.name, p.internalDeps.slice());
+    const color = new Map();
+    for (const k of adj.keys())
+        color.set(k, "white");
+    const cycles = [];
+    const seen = new Set();
+    const path = [];
+    const dfs = (node) => {
+        color.set(node, "gray");
+        path.push(node);
+        for (const next of adj.get(node) ?? []) {
+            const c = color.get(next);
+            if (c === "gray") {
+                const start = path.indexOf(next);
+                const raw = path.slice(start);
+                const min = raw.reduce((b, n, i) => (n < raw[b] ? i : b), 0);
+                const canon = [...raw.slice(min), ...raw.slice(0, min)];
+                const key = canon.join(">");
+                if (!seen.has(key)) {
+                    seen.add(key);
+                    cycles.push([...canon, canon[0]]);
+                }
+            }
+            else if (c === "white") {
+                dfs(next);
+            }
+        }
+        path.pop();
+        color.set(node, "black");
+    };
+    for (const k of adj.keys())
+        if (color.get(k) === "white")
+            dfs(k);
+    return cycles;
+}
+/* ─── File-level cross-package import resolution ───────────────────────────── */
+const SRC_EXTS = [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"];
+const JS_TO_SRC = {
+    ".js": [".ts", ".tsx", ".js"],
+    ".jsx": [".tsx", ".jsx"],
+    ".mjs": [".mts", ".mjs"],
+    ".cjs": [".cts", ".cjs"],
+};
+function existsFileSync(p) {
+    try {
+        return fs.statSync(p).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Resolve a candidate path (file, extensionless, or directory) to a real source
+ * file, preferring TS sources over the declared `.js` build output.
+ */
+function resolveSourceFile(candidate) {
+    const ext = path.extname(candidate).toLowerCase();
+    if (ext && JS_TO_SRC[ext]) {
+        const base = candidate.slice(0, candidate.length - ext.length);
+        for (const e of JS_TO_SRC[ext]) {
+            if (existsFileSync(base + e))
+                return base + e;
+        }
+    }
+    if (existsFileSync(candidate))
+        return candidate;
+    for (const e of SRC_EXTS)
+        if (existsFileSync(candidate + e))
+            return candidate + e;
+    for (const e of SRC_EXTS) {
+        const idx = path.join(candidate, `index${e}`);
+        if (existsFileSync(idx))
+            return idx;
+    }
+    return null;
+}
+/** Pick the source entry file of a package, preferring real source over dist. */
+function packageEntry(pkgDir, pkg) {
+    const candidates = [];
+    // explicit source-ish fields first
+    for (const f of [pkg?.source, pkg?.module, pkg?.types, pkg?.typings, pkg?.main]) {
+        if (typeof f === "string")
+            candidates.push(f);
+    }
+    // exports["."] as a string or { source/import/default/types }
+    const dot = pkg?.exports?.["."] ?? pkg?.exports;
+    if (typeof dot === "string")
+        candidates.push(dot);
+    else if (dot && typeof dot === "object") {
+        for (const k of ["source", "import", "default", "types"]) {
+            if (typeof dot[k] === "string")
+                candidates.push(dot[k]);
+        }
+    }
+    // conventional source roots
+    candidates.push("src/index.ts", "src/index.tsx", "src/index.js", "index.ts", "index.tsx", "index.js");
+    for (const c of candidates) {
+        const resolved = resolveSourceFile(path.resolve(pkgDir, c));
+        if (resolved)
+            return resolved;
+    }
+    return null;
+}
+/**
+ * Resolve a bare import specifier to an in-monorepo source file when it targets
+ * a workspace package. Handles exact package imports (`@org/utils`) and subpaths
+ * (`@org/utils/helpers`). Returns null for non-workspace (external) specifiers.
+ */
+export function resolveWorkspaceImport(importFrom, rootAbs, info) {
+    if (importFrom.startsWith("."))
+        return null; // relative, not a package import
+    let match = null;
+    let subpath = "";
+    for (const p of info.packages) {
+        if (importFrom === p.name) {
+            match = p;
+            subpath = "";
+            break;
+        }
+        if (importFrom.startsWith(p.name + "/")) {
+            match = p;
+            subpath = importFrom.slice(p.name.length + 1);
+            break;
+        }
+    }
+    if (!match)
+        return null;
+    const pkgDir = path.resolve(rootAbs, match.dir);
+    const pj = readJson(path.join(pkgDir, "package.json"));
+    const entry = packageEntry(pkgDir, pj);
+    if (!subpath)
+        return entry;
+    // Subpath import (`@org/utils/helpers`): resolve against the source root
+    // (the entry file's directory, typically `src/`) first, then the package dir.
+    const srcRoot = entry ? path.dirname(entry) : pkgDir;
+    return (resolveSourceFile(path.resolve(srcRoot, subpath)) ??
+        resolveSourceFile(path.resolve(pkgDir, subpath)));
+}
+/* ─── Cached per-root workspace index (for resolvers) ──────────────────────── */
+const workspaceCache = new Map();
+/** Discover (and cache) the workspace for a root, then resolve a package import. */
+export function resolveWorkspaceImportCached(importFrom, rootAbs) {
+    if (importFrom.startsWith("."))
+        return null;
+    const key = path.resolve(rootAbs);
+    let info = workspaceCache.get(key);
+    if (!info) {
+        info = discoverWorkspace(key);
+        workspaceCache.set(key, info);
+    }
+    if (info.packages.length === 0)
+        return null;
+    return resolveWorkspaceImport(importFrom, key, info);
+}
+/** Test/debug hook: drop the cached workspace index. */
+export function clearWorkspaceCache() {
+    workspaceCache.clear();
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "universal-ast-mapper",
-  "version": "2.0.0",
+  "version": "2.0.2",
   "description": "MCP server that maps source files into a normalized code skeleton (JSON + HTML) using tree-sitter.",
   "type": "module",
   "main": "dist/index.js",
@@ -17,6 +17,7 @@
     "BLUEPRINT.md"
   ],
   "scripts": {
+    "prepare": "npm run build",
     "build": "tsc",
     "start": "node dist/index.js",
     "smoke": "node test/smoke.mjs",