universal-ast-mapper 1.28.0 → 2.0.0

package/dist/gitdiff.js

@@ -1,178 +0,0 @@
-import { execFileSync } from "node:child_process";
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { buildSkeleton, collectSourceFiles } from "./skeleton.js";
-import { resolveOptions } from "./config.js";
-import { buildSymbolGraph } from "./graph.js";
-import { getChangeImpact } from "./graph-analysis.js";
-import { detectLanguage } from "./registry.js";
-import { computeFileComplexity } from "./complexity.js";
-function git(args, cwd) {
-    return execFileSync("git", args, { cwd, encoding: "utf8", maxBuffer: 64 * 1024 * 1024 });
-}
-export function isGitRepo(root) {
-    try {
-        git(["rev-parse", "--is-inside-work-tree"], root);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-function changedFiles(root, base) {
-    let out;
-    try {
-        out = git(["diff", "--name-status", base, "--"], root);
-    }
-    catch {
-        return [];
-    }
-    const res = [];
-    for (const line of out.split(/\r?\n/)) {
-        if (!line.trim())
-            continue;
-        const m = line.match(/^([AMD])\t(.+)$/);
-        if (m) {
-            res.push({ status: m[1], file: m[2] });
-            continue;
-        }
-        const r = line.match(/^R\d+\t\S+\t(.+)$/); // rename → treat new path as modified
-        if (r)
-            res.push({ status: "M", file: r[1] });
-    }
-    // Untracked files are new since any ref — treat them as added.
-    try {
-        const untracked = git(["ls-files", "--others", "--exclude-standard"], root);
-        for (const f of untracked.split(/\r?\n/)) {
-            if (f.trim() && !res.some((x) => x.file === f))
-                res.push({ status: "A", file: f });
-        }
-    }
-    catch { /* ignore */ }
-    return res.filter((f) => detectLanguage(f.file));
-}
-function oldContent(root, base, rel) {
-    try {
-        return git(["show", `${base}:${rel}`], root);
-    }
-    catch {
-        return null;
-    }
-}
-async function skeletonFromSource(source, rel) {
-    const ext = path.extname(rel);
-    const tmp = path.join(os.tmpdir(), `astdiff-${Date.now()}-${Math.random().toString(36).slice(2)}${ext}`);
-    try {
-        fs.writeFileSync(tmp, source);
-        return await buildSkeleton(tmp, rel, resolveOptions({ detail: "full", emitHtml: false }));
-    }
-    catch {
-        return null;
-    }
-    finally {
-        try {
-            fs.unlinkSync(tmp);
-        }
-        catch { /* ignore */ }
-    }
-}
-function flatten(syms, prefix, acc) {
-    for (const s of syms) {
-        const q = prefix ? prefix + "." + s.name : s.name;
-        acc.set(q, s);
-        flatten(s.children, q, acc);
-    }
-    return acc;
-}
-const sc = (s) => ({ symbol: s.name, kind: s.kind, exported: s.exported ?? false });
-export async function computeDiff(absDir, root, base) {
-    const absDirNorm = path.resolve(absDir);
-    const changed = changedFiles(root, base).filter((f) => path.resolve(root, f.file).startsWith(absDirNorm));
-    const files = [];
-    const breaking = [];
-    for (const cf of changed) {
-        const rel = cf.file;
-        const newSkel = cf.status === "D" ? null : await safeBuildFromDisk(path.resolve(root, rel), rel);
-        const oldSrc = cf.status === "A" ? null : oldContent(root, base, rel);
-        const oldSkel = oldSrc != null ? await skeletonFromSource(oldSrc, rel) : null;
-        const oldMap = oldSkel ? flatten(oldSkel.symbols, "", new Map()) : new Map();
-        const newMap = newSkel ? flatten(newSkel.symbols, "", new Map()) : new Map();
-        const added = [], removed = [], modified = [];
-        for (const [q, s] of newMap)
-            if (!oldMap.has(q))
-                added.push(sc(s));
-        for (const [q, s] of oldMap)
-            if (!newMap.has(q))
-                removed.push(sc(s));
-        for (const [q, s] of newMap) {
-            const o = oldMap.get(q);
-            if (o && (o.signature ?? "") !== (s.signature ?? ""))
-                modified.push(sc(s));
-        }
-        const status = cf.status === "A" ? "added" : cf.status === "D" ? "deleted" : "modified";
-        files.push({ file: rel, status, added, removed, modified });
-        for (const r of removed)
-            if (r.exported && !r.symbol.includes(" ")) {
-                breaking.push({ file: rel, symbol: r.symbol, reason: cf.status === "D" ? "file deleted" : "export removed" });
-            }
-        for (const m of modified)
-            if (m.exported)
-                breaking.push({ file: rel, symbol: m.symbol, reason: "signature changed" });
-    }
-    // Blast radius of breaking changes (top-level symbols only).
-    const impacted = new Set();
-    if (breaking.length > 0) {
-        const opts = resolveOptions({ detail: "outline", emitHtml: false });
-        const skels = [];
-        for (const f of collectSourceFiles(absDirNorm, opts)) {
-            const r = path.relative(root, f).split(path.sep).join("/");
-            try {
-                skels.push(await buildSkeleton(f, r, opts));
-            }
-            catch { /* skip */ }
-        }
-        const graph = buildSymbolGraph(skels, root);
-        for (const b of breaking) {
-            const imp = getChangeImpact(graph, `${b.file}::${b.symbol}`);
-            if (imp)
-                for (const d of [...imp.direct, ...imp.transitive])
-                    if (d.file !== b.file)
-                        impacted.add(d.file);
-        }
-    }
-    const sum = files.reduce((a, f) => ({ added: a.added + f.added.length, removed: a.removed + f.removed.length, modified: a.modified + f.modified.length }), { added: 0, removed: 0, modified: 0 });
-    return {
-        base,
-        files,
-        breaking,
-        impactedFiles: [...impacted].sort(),
-        summary: { filesChanged: files.length, ...sum, breaking: breaking.length, impactedFiles: impacted.size },
-    };
-}
-async function safeBuildFromDisk(abs, rel) {
-    try {
-        return await buildSkeleton(abs, rel, resolveOptions({ detail: "full", emitHtml: false }));
-    }
-    catch {
-        return null;
-    }
-}
-export async function computeRisk(absDir, root) {
-    const opts = resolveOptions({ detail: "outline", emitHtml: false });
-    const out = [];
-    for (const f of collectSourceFiles(absDir, opts)) {
-        const rel = path.relative(root, f).split(path.sep).join("/");
-        let churn = 0;
-        try {
-            churn = parseInt(git(["rev-list", "--count", "HEAD", "--", rel], root).trim(), 10) || 0;
-        }
-        catch {
-            churn = 0;
-        }
-        const fc = await computeFileComplexity(f, rel);
-        const maxC = fc ? fc.maxComplexity : 0;
-        out.push({ file: rel, churn, maxComplexity: maxC, risk: churn * maxC });
-    }
-    return out.filter((r) => r.risk > 0).sort((a, b) => b.risk - a.risk);
-}

package/dist/graph-analysis.js

@@ -1,279 +0,0 @@
-// ─── Dead Code Detection ──────────────────────────────────────────────────────
-/**
- * "High" confidence = functions / classes / consts that are unlikely to be
- * used purely as type annotations.
- * "Low" confidence = interfaces / types / enums — these are often imported
- * implicitly through the TypeScript type system without an explicit import
- * statement, so they may appear "dead" even when they're actively used.
- */
-const HIGH_CONFIDENCE_KINDS = new Set(["function", "class", "const", "var", "method"]);
-/**
- * Return exported symbols that have no incoming "imports" edges within the
- * scanned directory — i.e. nothing inside the scan root depends on them.
- */
-export function findDeadExports(graph) {
-    const importedIds = new Set();
-    for (const edge of graph.edges) {
-        if (edge.edgeType === "imports")
-            importedIds.add(edge.to);
-    }
-    const dead = [];
-    for (const node of graph.nodes) {
-        if (node.nodeType !== "symbol")
-            continue;
-        const sym = node;
-        if (sym.exported && !importedIds.has(sym.id)) {
-            dead.push({
-                file: sym.file,
-                symbol: sym.symbol,
-                kind: sym.kind,
-                nodeId: sym.id,
-                confidence: HIGH_CONFIDENCE_KINDS.has(sym.kind) ? "high" : "low",
-            });
-        }
-    }
-    return dead;
-}
-/**
- * Detect circular import dependencies among the scanned files using DFS.
- * Each reported cycle is canonicalised (rotated to start at the
- * lexicographically smallest node) to avoid duplicates.
- *
- * Re-uses the graph's already-resolved import edges — no path re-resolution needed.
- */
-export function findCircularDeps(graph) {
-    const nodeMap = new Map(graph.nodes.map(n => [n.id, n]));
-    // Build deduplicated file-level adjacency from the graph's "imports" edges
-    const adjSets = new Map();
-    for (const node of graph.nodes) {
-        if (node.nodeType === "file")
-            adjSets.set(node.id, new Set());
-    }
-    for (const edge of graph.edges) {
-        if (edge.edgeType !== "imports")
-            continue;
-        const toNode = nodeMap.get(edge.to);
-        if (!toNode)
-            continue;
-        const toFile = toNode.nodeType === "file" ? toNode.id : toNode.file;
-        if (edge.from !== toFile)
-            adjSets.get(edge.from)?.add(toFile);
-    }
-    const adj = new Map();
-    for (const [k, v] of adjSets)
-        adj.set(k, [...v]);
-    const color = new Map();
-    for (const f of adj.keys())
-        color.set(f, "white");
-    const cycles = [];
-    const cycleKeys = new Set();
-    for (const startNode of adj.keys()) {
-        if (color.get(startNode) !== "white")
-            continue;
-        const stack = [{ node: startNode, nextIdx: 0 }];
-        const path = [startNode];
-        color.set(startNode, "gray");
-        while (stack.length > 0) {
-            const frame = stack[stack.length - 1];
-            const neighbors = adj.get(frame.node) ?? [];
-            if (frame.nextIdx >= neighbors.length) {
-                stack.pop();
-                path.pop();
-                color.set(frame.node, "black");
-                continue;
-            }
-            const neighbor = neighbors[frame.nextIdx++];
-            const nc = color.get(neighbor);
-            if (nc === "gray") {
-                const start = path.indexOf(neighbor);
-                const raw = path.slice(start);
-                const canonical = rotateCycle(raw);
-                const key = canonical.join("→");
-                if (!cycleKeys.has(key)) {
-                    cycleKeys.add(key);
-                    cycles.push({ cycle: [...canonical, canonical[0]], length: canonical.length });
-                }
-            }
-            else if (nc === "white") {
-                color.set(neighbor, "gray");
-                path.push(neighbor);
-                stack.push({ node: neighbor, nextIdx: 0 });
-            }
-        }
-    }
-    return cycles;
-}
-function rotateCycle(nodes) {
-    const minIdx = nodes.reduce((best, n, i) => (n < nodes[best] ? i : best), 0);
-    return [...nodes.slice(minIdx), ...nodes.slice(0, minIdx)];
-}
-/**
- * Compute the blast radius of changing a symbol: traverse the import graph in
- * reverse to find every file/symbol that directly or transitively depends on
- * the given node ID.
- *
- * Returns null if the target node ID is not found in the graph.
- */
-export function getChangeImpact(graph, targetNodeId) {
-    const nodeMap = new Map(graph.nodes.map((n) => [n.id, n]));
-    if (!nodeMap.has(targetNodeId))
-        return null;
-    // Reverse adjacency: target → [nodes that import it]
-    const reverseAdj = new Map();
-    for (const edge of graph.edges) {
-        if (edge.edgeType === "imports") {
-            if (!reverseAdj.has(edge.to))
-                reverseAdj.set(edge.to, new Set());
-            reverseAdj.get(edge.to).add(edge.from);
-        }
-    }
-    const visited = new Set([targetNodeId]);
-    const directSet = new Set();
-    for (const dep of reverseAdj.get(targetNodeId) ?? []) {
-        if (!visited.has(dep)) {
-            visited.add(dep);
-            directSet.add(dep);
-        }
-    }
-    const transitiveSet = new Set();
-    const queue = [...directSet];
-    while (queue.length > 0) {
-        const current = queue.shift();
-        for (const dep of reverseAdj.get(current) ?? []) {
-            if (!visited.has(dep)) {
-                visited.add(dep);
-                transitiveSet.add(dep);
-                queue.push(dep);
-            }
-        }
-    }
-    function toImpactNode(id) {
-        const n = nodeMap.get(id);
-        if (!n)
-            return { nodeId: id, file: id };
-        if (n.nodeType === "file")
-            return { nodeId: id, file: n.id };
-        const sym = n;
-        return { nodeId: id, file: sym.file, symbol: sym.symbol };
-    }
-    const direct = [...directSet].map(toImpactNode);
-    const transitive = [...transitiveSet].map(toImpactNode);
-    const allFiles = new Set([...direct.map((e) => e.file), ...transitive.map((e) => e.file)]);
-    return { targetNodeId, direct, transitive, totalFiles: allFiles.size };
-}
-/**
- * Show the import relationships for a single file:
- *   - `imports`    — what this file pulls in (outgoing edges)
- *   - `importedBy` — who depends on this file (incoming edges)
- *
- * Returns null if the file node is not in the graph.
- */
-export function getFileDeps(graph, fileId) {
-    if (!graph.nodes.some((n) => n.id === fileId && n.nodeType === "file"))
-        return null;
-    const nodeMap = new Map(graph.nodes.map((n) => [n.id, n]));
-    // fileId → set of imported symbol names
-    const outgoing = new Map();
-    // fileId → set of symbols they import from us
-    const incoming = new Map();
-    for (const edge of graph.edges) {
-        if (edge.edgeType !== "imports")
-            continue;
-        const toNode = nodeMap.get(edge.to);
-        if (!toNode)
-            continue;
-        const toFile = toNode.nodeType === "file"
-            ? toNode.id
-            : toNode.file;
-        const symbolName = toNode.nodeType === "symbol"
-            ? toNode.symbol
-            : null;
-        if (edge.from === fileId && toFile !== fileId) {
-            if (!outgoing.has(toFile))
-                outgoing.set(toFile, new Set());
-            if (symbolName)
-                outgoing.get(toFile).add(symbolName);
-        }
-        if (toFile === fileId && edge.from !== fileId) {
-            if (!incoming.has(edge.from))
-                incoming.set(edge.from, new Set());
-            if (symbolName)
-                incoming.get(edge.from).add(symbolName);
-        }
-    }
-    return {
-        file: fileId,
-        imports: [...outgoing.entries()].map(([file, syms]) => ({ file, symbols: [...syms].sort() })),
-        importedBy: [...incoming.entries()].map(([file, syms]) => ({ file, symbols: [...syms].sort() })),
-    };
-}
-/**
- * Return the most-imported symbols in the graph, sorted descending by
- * the number of distinct files that depend on them. These are "God Nodes" —
- * high-risk symbols where a breaking change has maximum blast radius.
- */
-export function getTopSymbols(graph, limit = 10) {
-    // nodeId → set of importing file IDs
-    const importers = new Map();
-    for (const edge of graph.edges) {
-        if (edge.edgeType !== "imports")
-            continue;
-        if (!importers.has(edge.to))
-            importers.set(edge.to, new Set());
-        importers.get(edge.to).add(edge.from);
-    }
-    const results = [];
-    for (const node of graph.nodes) {
-        if (node.nodeType !== "symbol")
-            continue;
-        const sym = node;
-        const fileImporters = importers.get(sym.id);
-        if (!fileImporters || fileImporters.size === 0)
-            continue;
-        results.push({
-            nodeId: sym.id,
-            file: sym.file,
-            symbol: sym.symbol,
-            kind: sym.kind,
-            importCount: fileImporters.size,
-            importedByFiles: [...fileImporters].sort(),
-        });
-    }
-    return results.sort((a, b) => b.importCount - a.importCount).slice(0, limit);
-}
-/**
- * Find symbol names that are exported from more than one file. These are often
- * accidental collisions (copy-paste, parallel implementations) that make a
- * codebase harder to navigate and can cause the wrong import to be auto-suggested.
- *
- * Only exported symbols are considered, and a name must appear in at least two
- * distinct files to count as a duplicate.
- */
-export function findDuplicateSymbols(graph) {
-    const byName = new Map();
-    for (const node of graph.nodes) {
-        if (node.nodeType !== "symbol")
-            continue;
-        const sym = node;
-        if (!sym.exported)
-            continue;
-        const arr = byName.get(sym.symbol) ?? [];
-        arr.push(sym);
-        byName.set(sym.symbol, arr);
-    }
-    const out = [];
-    for (const [name, syms] of byName) {
-        // Collapse to one location per file (a file may declare the name once).
-        const perFile = new Map();
-        for (const s of syms)
-            if (!perFile.has(s.file))
-                perFile.set(s.file, s);
-        if (perFile.size < 2)
-            continue;
-        const locations = [...perFile.values()]
-            .map((s) => ({ file: s.file, kind: s.kind, nodeId: s.id }))
-            .sort((a, b) => a.file.localeCompare(b.file));
-        out.push({ symbol: name, count: perFile.size, locations });
-    }
-    return out.sort((a, b) => b.count - a.count || a.symbol.localeCompare(b.symbol));
-}

package/dist/graph.js

@@ -1,165 +0,0 @@
-import path from "node:path";
-import { resolveImportPath, resolveAliasedImport } from "./resolver.js";
-import { resolveWorkspaceImportCached } from "./workspace.js";
-import { buildCrossLangIndex, resolveCrossLangTarget, } from "./crosslang.js";
-// ─── Internal helpers ─────────────────────────────────────────────────────────
-function collectSymbolNodes(symbols, parentId, file, nodes, edges) {
-    for (const sym of symbols) {
-        const nodeId = `${parentId}.${sym.name}`;
-        nodes.push({
-            id: nodeId,
-            nodeType: "symbol",
-            file,
-            symbol: sym.name,
-            kind: sym.kind,
-            exported: sym.exported ?? false,
-            range: sym.range,
-            ...(sym.signature ? { signature: sym.signature } : {}),
-        });
-        edges.push({ from: parentId, to: nodeId, edgeType: "contains" });
-        if (sym.children.length > 0) {
-            collectSymbolNodes(sym.children, nodeId, file, nodes, edges);
-        }
-    }
-}
-// Returns true for path-based import languages (TS/JS/Python/Go).
-function isPathBasedLanguage(language) {
-    return (language === "typescript" ||
-        language === "tsx" ||
-        language === "javascript" ||
-        language === "python" ||
-        language === "vue" ||
-        language === "svelte");
-}
-// Wire one TS/JS/Python-style relative import.
-function wirePathImport(skel, imp, fromFileAbs, root, exportedSymbolMap, edges) {
-    if (imp.isSideEffect)
-        return;
-    // Relative import → path resolve; bare specifier → monorepo workspace package.
-    const resolvedAbs = imp.from.startsWith(".")
-        ? resolveImportPath(imp.from, fromFileAbs)
-        : resolveAliasedImport(imp.from, fromFileAbs) ?? resolveWorkspaceImportCached(imp.from, root);
-    if (!resolvedAbs)
-        return;
-    const resolvedRel = path.relative(root, resolvedAbs).split(path.sep).join("/");
-    if (imp.isNamespaceImport || imp.symbol === "*") {
-        if (exportedSymbolMap.has(resolvedRel)) {
-            edges.push({ from: skel.file, to: resolvedRel, edgeType: "imports" });
-        }
-    }
-    else {
-        const fileExports = exportedSymbolMap.get(resolvedRel);
-        const targetNodeId = fileExports?.get(imp.symbol);
-        if (targetNodeId) {
-            edges.push({ from: skel.file, to: targetNodeId, edgeType: "imports" });
-        }
-    }
-}
-// Wire one cross-language import (Java/C#/Rust) using the project-wide index.
-function wireCrossLangImport(skel, imp, fromFileAbs, root, index, exportedSymbolMap, edges) {
-    if (imp.isSideEffect)
-        return;
-    const target = resolveCrossLangTarget(imp, skel, fromFileAbs, root, index);
-    if (!target)
-        return;
-    if (target.kind === "file") {
-        for (const f of target.files) {
-            if (exportedSymbolMap.has(f) && f !== skel.file) {
-                edges.push({ from: skel.file, to: f, edgeType: "imports" });
-            }
-        }
-        return;
-    }
-    // target.kind === "symbol"
-    const fileExports = exportedSymbolMap.get(target.file);
-    const targetNodeId = fileExports?.get(target.symbol);
-    if (targetNodeId) {
-        edges.push({ from: skel.file, to: targetNodeId, edgeType: "imports" });
-    }
-    else if (exportedSymbolMap.has(target.file) && target.file !== skel.file) {
-        // Symbol not found in the resolved file — fall back to a file-level edge so
-        // the graph still reflects the cross-file dependency.
-        edges.push({ from: skel.file, to: target.file, edgeType: "imports" });
-    }
-}
-// ─── Public builder ──────────────────────────────────────────────────────────
-export function buildSymbolGraph(skeletons, root) {
-    const nodes = [];
-    const edges = [];
-    const exportedSymbolMap = new Map();
-    // First pass: build file and symbol nodes.
-    for (const skel of skeletons) {
-        nodes.push({
-            id: skel.file,
-            nodeType: "file",
-            language: skel.language,
-            symbolCount: skel.symbolCount,
-        });
-        const fileExports = new Map();
-        exportedSymbolMap.set(skel.file, fileExports);
-        for (const sym of skel.symbols) {
-            const nodeId = `${skel.file}::${sym.name}`;
-            nodes.push({
-                id: nodeId,
-                nodeType: "symbol",
-                file: skel.file,
-                symbol: sym.name,
-                kind: sym.kind,
-                exported: sym.exported ?? false,
-                range: sym.range,
-                ...(sym.signature ? { signature: sym.signature } : {}),
-            });
-            edges.push({ from: skel.file, to: nodeId, edgeType: "contains" });
-            // Index exported (and visible-by-convention) top-level symbols so that
-            // imports can find them. Languages like Java/C# may have visible types
-            // without an explicit "exported" flag — fall back to indexing all
-            // top-level symbols for those languages.
-            if (sym.exported)
-                fileExports.set(sym.name, nodeId);
-            else if (skel.language === "java" || skel.language === "csharp") {
-                fileExports.set(sym.name, nodeId);
-            }
-            if (sym.children.length > 0) {
-                const childNodes = [];
-                const childEdges = [];
-                collectSymbolNodes(sym.children, nodeId, skel.file, childNodes, childEdges);
-                nodes.push(...childNodes);
-                edges.push(...childEdges);
-            }
-        }
-    }
-    // Build cross-language indexes once (Java FQCN, C# namespaces).
-    const crossIndex = buildCrossLangIndex(skeletons);
-    // Second pass: wire import edges, dispatched by language.
-    for (const skel of skeletons) {
-        if (!skel.imports || skel.imports.length === 0)
-            continue;
-        const fromFileAbs = path.resolve(root, skel.file);
-        const pathBased = isPathBasedLanguage(skel.language);
-        for (const imp of skel.imports) {
-            if (pathBased) {
-                wirePathImport(skel, imp, fromFileAbs, root, exportedSymbolMap, edges);
-            }
-            else if (skel.language === "java" ||
-                skel.language === "csharp" ||
-                skel.language === "rust" ||
-                skel.language === "go" ||
-                skel.language === "kotlin" ||
-                skel.language === "c" ||
-                skel.language === "cpp" ||
-                skel.language === "swift") {
-                wireCrossLangImport(skel, imp, fromFileAbs, root, crossIndex, exportedSymbolMap, edges);
-            }
-        }
-    }
-    const symbolNodeCount = nodes.filter((n) => n.nodeType === "symbol").length;
-    return {
-        nodes,
-        edges,
-        stats: {
-            fileCount: skeletons.length,
-            symbolNodeCount,
-            edgeCount: edges.length,
-        },
-    };
-}