universal-ast-mapper 1.27.0 → 2.0.0

package/dist/resolver.js

@@ -1,222 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import { buildSkeleton, collectSourceFiles } from "./skeleton.js";
-import { resolveOptions } from "./config.js";
-import { findSymbol } from "./analysis.js";
-import { buildCrossLangIndex, resolveCrossLangTarget, } from "./crosslang.js";
-import { resolveWorkspaceImportCached } from "./workspace.js";
-import { aliasCandidates } from "./tsconfig.js";
-const SRC_EXTS = [".ts", ".tsx", ".js", ".jsx", ".mts", ".cts", ".mjs", ".cjs", ".vue", ".svelte"];
-function extractParams(sig) {
-    const start = sig.indexOf("(");
-    if (start === -1)
-        return null;
-    let depth = 0;
-    for (let i = start; i < sig.length; i++) {
-        if (sig[i] === "(")
-            depth++;
-        else if (sig[i] === ")") {
-            depth--;
-            if (depth === 0)
-                return sig.slice(start, i + 1);
-        }
-    }
-    return null;
-}
-const JS_TO_TS = {
-    ".js": [".ts", ".tsx", ".js"],
-    ".jsx": [".tsx", ".jsx"],
-    ".mjs": [".mts", ".mjs"],
-    ".cjs": [".cts", ".cjs"],
-};
-/**
- * Resolve a TS/JS-style relative import path to an absolute file path.
- * Returns null for external packages or when the file cannot be found.
- */
-export function resolveImportPath(importFrom, fromAbs) {
-    if (!importFrom.startsWith("."))
-        return null;
-    const fromDir = path.dirname(fromAbs);
-    const candidate = path.resolve(fromDir, importFrom);
-    const declaredExt = path.extname(candidate).toLowerCase();
-    if (declaredExt && JS_TO_TS[declaredExt]) {
-        const base = candidate.slice(0, candidate.length - declaredExt.length);
-        for (const ext of JS_TO_TS[declaredExt]) {
-            const p = base + ext;
-            if (fs.existsSync(p))
-                return p;
-        }
-    }
-    return probeCandidate(candidate);
-}
-/** Probe a path base: exact file → +extensions → /index.<ext>. */
-function probeCandidate(candidate) {
-    try {
-        const stat = fs.statSync(candidate);
-        if (stat.isFile())
-            return candidate;
-    }
-    catch { /* not found */ }
-    for (const ext of SRC_EXTS) {
-        const p = candidate + ext;
-        if (fs.existsSync(p))
-            return p;
-    }
-    for (const ext of SRC_EXTS) {
-        const p = path.join(candidate, `index${ext}`);
-        if (fs.existsSync(p))
-            return p;
-    }
-    return null;
-}
-/**
- * Resolve a tsconfig/jsconfig path-aliased bare import (e.g. `@/components/X`
- * with `"@/*": ["./src/*"]`) to an absolute file path, using the nearest
- * config above the importing file. Returns null when not an alias.
- */
-export function resolveAliasedImport(importFrom, fromAbs) {
-    for (const base of aliasCandidates(importFrom, fromAbs)) {
-        const declaredExt = path.extname(base).toLowerCase();
-        if (declaredExt && JS_TO_TS[declaredExt]) {
-            const stem = base.slice(0, base.length - declaredExt.length);
-            for (const ext of JS_TO_TS[declaredExt]) {
-                const p = stem + ext;
-                if (fs.existsSync(p))
-                    return p;
-            }
-        }
-        const hit = probeCandidate(base);
-        if (hit)
-            return hit;
-    }
-    return null;
-}
-/* ─── Cross-language index cache ──────────────────────────────────────────── */
-// Java/C# need a project-wide index to resolve fully-qualified imports.
-// Built lazily on first cross-language resolve, then reused for the process
-// lifetime (the MCP server is per-root, so this is safe).
-const indexCache = new Map();
-export async function getOrBuildCrossLangIndex(root) {
-    const key = path.resolve(root);
-    let p = indexCache.get(key);
-    if (p)
-        return p;
-    p = (async () => {
-        const opts = resolveOptions({ detail: "outline", emitHtml: false });
-        const files = collectSourceFiles(key, opts);
-        const skels = [];
-        for (const abs of files) {
-            const ext = path.extname(abs).toLowerCase();
-            // Only Java/C# contribute to the index (Rust resolves via direct
-            // module-path walk against the filesystem, no index needed).
-            if (ext !== ".java" && ext !== ".cs" && ext !== ".kt" && ext !== ".kts" && ext !== ".swift")
-                continue;
-            const rel = path.relative(key, abs).split(path.sep).join("/");
-            try {
-                skels.push(await buildSkeleton(abs, rel, opts));
-            }
-            catch { /* skip unparsable files */ }
-        }
-        return buildCrossLangIndex(skels);
-    })();
-    indexCache.set(key, p);
-    return p;
-}
-/** Test/debug hook: drop the cached index (rebuilds on next call). */
-export function clearCrossLangIndexCache() {
-    indexCache.clear();
-}
-async function lookupSymbolInTarget(targetAbs, targetRel, symbol) {
-    const opts = resolveOptions({ detail: "full", emitHtml: false });
-    try {
-        const targetSkel = await buildSkeleton(targetAbs, targetRel, opts);
-        const sym = findSymbol(targetSkel.symbols, symbol);
-        if (sym) {
-            const signature = sym.signature ?? null;
-            const out = { found: true, kind: sym.kind };
-            if (signature !== undefined)
-                out.signature = signature;
-            if (signature) {
-                const params = extractParams(signature);
-                if (params)
-                    out.params = params;
-            }
-            return out;
-        }
-    }
-    catch { /* unresolvable / parse error */ }
-    return { found: false };
-}
-async function enrichRelativeImport(imp, fromAbs, root) {
-    const isBare = !imp.from.startsWith(".");
-    // Relative import → path resolve; bare specifier → try monorepo workspace.
-    let resolvedAbs = isBare ? null : resolveImportPath(imp.from, fromAbs);
-    if (!resolvedAbs && isBare)
-        resolvedAbs = resolveAliasedImport(imp.from, fromAbs);
-    if (!resolvedAbs && isBare)
-        resolvedAbs = resolveWorkspaceImportCached(imp.from, root);
-    const treatedExternal = isBare && !resolvedAbs;
-    const resolvedRel = resolvedAbs
-        ? path.relative(root, resolvedAbs).split(path.sep).join("/")
-        : null;
-    let enrichment = { found: false };
-    if (resolvedAbs && !imp.isSideEffect && !imp.isNamespaceImport && imp.symbol !== "*") {
-        enrichment = await lookupSymbolInTarget(resolvedAbs, resolvedRel, imp.symbol);
-    }
-    else if (resolvedAbs) {
-        enrichment = { found: true };
-    }
-    return assembleResolved(imp, resolvedAbs, resolvedRel, treatedExternal, enrichment);
-}
-async function enrichCrossLangImport(imp, skel, fromAbs, root, index) {
-    const target = resolveCrossLangTarget(imp, skel, fromAbs, root, index);
-    if (!target) {
-        return assembleResolved(imp, null, null, true, { found: false });
-    }
-    if (target.kind === "file") {
-        // Namespace-style (Java wildcard / C# using). Point to the first file —
-        // useful for navigation; the symbol itself isn't a specific declaration.
-        const firstRel = target.files[0];
-        const firstAbs = path.resolve(root, firstRel);
-        return assembleResolved(imp, firstAbs, firstRel, false, { found: true });
-    }
-    // Symbol-level (Java FQCN, Rust crate::path::Item)
-    const targetAbs = path.resolve(root, target.file);
-    const enrichment = await lookupSymbolInTarget(targetAbs, target.file, target.symbol);
-    return assembleResolved(imp, targetAbs, target.file, false, enrichment);
-}
-function assembleResolved(imp, resolvedAbs, resolvedRel, isExternal, enrichment) {
-    const out = {
-        ...imp,
-        resolvedPath: resolvedAbs,
-        resolvedRel,
-        found: enrichment.found,
-        importKind: isExternal ? "external" : "relative",
-    };
-    if (enrichment.kind !== undefined)
-        out.kind = enrichment.kind;
-    if (enrichment.signature !== undefined)
-        out.signature = enrichment.signature;
-    if (enrichment.params !== undefined)
-        out.params = enrichment.params;
-    return out;
-}
-/* ─── Public entry point ──────────────────────────────────────────────────── */
-const CROSS_LANG = new Set(["java", "csharp", "rust", "go", "kotlin", "c", "cpp", "swift"]);
-export async function resolveFileImports(skel, absPath, root) {
-    if (!skel.imports || skel.imports.length === 0)
-        return [];
-    const results = [];
-    // Lazy-build the cross-lang index only when actually needed.
-    let indexPromise = null;
-    const getIndex = () => (indexPromise ??= getOrBuildCrossLangIndex(root));
-    for (const imp of skel.imports) {
-        if (CROSS_LANG.has(skel.language)) {
-            results.push(await enrichCrossLangImport(imp, skel, absPath, root, await getIndex()));
-        }
-        else {
-            results.push(await enrichRelativeImport(imp, absPath, root));
-        }
-    }
-    return results;
-}

package/dist/roots.js

@@ -1,47 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-export function parseRootsFromEnv(env = process.env) {
-    const raw = env.AST_MAP_ROOT ?? process.cwd();
-    const roots = raw
-        .split(path.delimiter)
-        .map((p) => p.trim())
-        .filter((p) => p.length > 0)
-        .map((p) => path.resolve(p));
-    return {
-        roots: roots.length > 0 ? roots : [path.resolve(process.cwd())],
-        unlocked: env.AST_MAP_UNLOCKED === "1",
-    };
-}
-function within(root, abs) {
-    const rel = path.relative(root, abs);
-    if (rel === "")
-        return path.basename(abs);
-    if (rel.startsWith("..") || path.isAbsolute(rel))
-        return null;
-    return rel;
-}
-/**
- * Resolve a client-supplied path against the allowed roots.
- * Throws when the path escapes every root and unlocked mode is off.
- */
-export function resolvePathInRoots(input, cfg) {
-    const primary = cfg.roots[0];
-    const abs = path.resolve(primary, input);
-    for (const root of cfg.roots) {
-        const rel = within(root, abs);
-        if (rel !== null)
-            return { abs, rel, root };
-    }
-    if (cfg.unlocked) {
-        if (!fs.existsSync(abs)) {
-            throw new Error(`Path "${input}" does not exist (resolved to ${abs}).`);
-        }
-        const stat = fs.statSync(abs);
-        const root = stat.isDirectory() ? abs : path.dirname(abs);
-        return { abs, rel: path.basename(abs), root };
-    }
-    throw new Error(`Path "${input}" is outside the allowed root${cfg.roots.length > 1 ? "s" : ""} ` +
-        `(${cfg.roots.join(", ")}). Either set AST_MAP_ROOT to that project ` +
-        `(multiple roots allowed, separated by "${path.delimiter}"), or set ` +
-        `AST_MAP_UNLOCKED=1 to allow any absolute path.`);
-}

package/dist/search.js

@@ -1,68 +0,0 @@
-import path from "node:path";
-import { buildSkeleton, collectSourceFiles } from "./skeleton.js";
-import { resolveOptions, loadProjectConfig } from "./config.js";
-// ─── Helpers ──────────────────────────────────────────────────────────────────
-/** Recursively yield every symbol in a file, including nested ones. */
-function* flattenSymbols(symbols, file, parentName) {
-    for (const sym of symbols) {
-        const fullName = parentName ? `${parentName}.${sym.name}` : sym.name;
-        yield {
-            file,
-            symbol: fullName,
-            kind: sym.kind,
-            exported: sym.exported ?? false,
-            range: sym.range,
-            ...(sym.signature ? { signature: sym.signature } : {}),
-        };
-        if (sym.children.length > 0) {
-            yield* flattenSymbols(sym.children, file, fullName);
-        }
-    }
-}
-function makeMatcher(pattern, matchType) {
-    if (matchType === "exact") {
-        return (name) => name === pattern || name.endsWith(`.${pattern}`);
-    }
-    if (matchType === "regex") {
-        const re = new RegExp(pattern, "i");
-        return (name) => re.test(name);
-    }
-    // contains (default) — case-insensitive
-    const lower = pattern.toLowerCase();
-    return (name) => name.toLowerCase().includes(lower);
-}
-/**
- * Search for symbols by name pattern across all source files in a directory.
- * Traverses nested symbols (methods inside classes, etc.) with dot-notation names.
- *
- * @param dirAbs    Absolute path of directory to scan.
- * @param pattern   Name to search for (matched per `matchType`).
- * @param root      Project root (for relative paths in results).
- * @param options   matchType, kind filter, exportedOnly, detail level.
- */
-export async function searchSymbols(dirAbs, pattern, root, options = {}) {
-    const { matchType = "contains", kind, exportedOnly = false, detail = "outline" } = options;
-    const test = makeMatcher(pattern, matchType);
-    const opts = resolveOptions({ detail, emitHtml: false }, loadProjectConfig(root));
-    const files = collectSourceFiles(dirAbs, opts);
-    const results = [];
-    for (const file of files) {
-        const fileRel = path.relative(root, file).split(path.sep).join("/");
-        try {
-            const skel = await buildSkeleton(file, fileRel, opts);
-            for (const match of flattenSymbols(skel.symbols, skel.file)) {
-                if (!test(match.symbol))
-                    continue;
-                if (kind && match.kind !== kind)
-                    continue;
-                if (exportedOnly && !match.exported)
-                    continue;
-                results.push(match);
-            }
-        }
-        catch {
-            // skip unreadable / unparseable files
-        }
-    }
-    return results;
-}