universal-ast-mapper 1.27.0 → 2.0.0

package/dist/testmap.js

@@ -1,167 +0,0 @@
-/**
- * Test-coverage mapping — pair test files with the source files they exercise,
- * and surface source files no test touches.
- *
- * This is *structural* coverage (which files have tests at all), not line
- * coverage — no instrumentation, no test runner, works on a cold checkout.
- *
- * Two matching signals, strongest first:
- *   1. import  — a test file imports the source file (graph edge; definitive).
- *   2. name    — naming convention pairs them ("auth.test.ts" → "auth.ts",
- *                "test_utils.py" → "utils.py", "FooTest.java" → "Foo.java"),
- *                resolved to the candidate sharing the longest path prefix.
- */
-// ─── Test-file detection ───────────────────────────────────────────────────────
-const TEST_DIRS = new Set(["test", "tests", "__tests__", "spec", "specs", "testing", "e2e", "integration-tests"]);
-/** Support material, not tests and not production source: excluded from both sides. */
-const FIXTURE_DIRS = new Set(["fixtures", "fixture", "__fixtures__", "__mocks__", "mocks", "testdata", "snapshots", "__snapshots__"]);
-/** True when a rel path lives under a fixtures/mocks/testdata directory. */
-export function isFixtureFile(rel) {
-    return rel.split("/").slice(0, -1).some((d) => FIXTURE_DIRS.has(d.toLowerCase()));
-}
-const TEST_BASENAME_PATTERNS = [
-    /\.(test|spec)\.[^.]+$/i, // auth.test.ts, auth.spec.js
-    /[_-](test|tests|spec)\.[^.]+$/i, // auth_test.go, auth-test.js, auth_spec.rb
-    /^(test|spec)[_-]/i, // test_auth.py, spec_auth.rb
-    /Tests?\.(java|cs|kt|kts|swift|scala)$/, // AuthTest.java, AuthTests.cs
-    /Spec\.(java|cs|kt|kts|swift|scala)$/, // AuthSpec.kt
-];
-/** True when a rel path (forward-slashed) looks like a test file. */
-export function isTestFile(rel) {
-    const parts = rel.split("/");
-    const base = parts[parts.length - 1];
-    if (parts.slice(0, -1).some((d) => TEST_DIRS.has(d.toLowerCase())))
-        return true;
-    return TEST_BASENAME_PATTERNS.some((re) => re.test(base));
-}
-/**
- * Derive the source basename a test file's name points at, or null when the
- * name carries no convention ("smoke.mjs" in a test dir → null).
- * "auth.test.ts" → "auth" · "test_utils.py" → "utils" · "AuthTest.java" → "Auth"
- */
-export function testNameTarget(rel) {
-    const base = rel.split("/").pop();
-    const noExt = base.replace(/\.[^.]+$/, "");
-    let t = noExt
-        .replace(/\.(test|spec)$/i, "")
-        .replace(/[_-](test|tests|spec|smoke)$/i, "")
-        .replace(/\.(smoke)$/i, "")
-        .replace(/^(test|spec)[_-]/i, "")
-        .replace(/(Test|Tests|Spec)$/, "");
-    if (t === noExt || t.length === 0)
-        return null;
-    return t;
-}
-// ─── Mapping ───────────────────────────────────────────────────────────────────
-function commonPrefixLen(a, b) {
-    const pa = a.split("/");
-    const pb = b.split("/");
-    let i = 0;
-    while (i < pa.length - 1 && i < pb.length - 1 && pa[i] === pb[i])
-        i++;
-    return i;
-}
-function baseNoExt(rel) {
-    return rel.split("/").pop().replace(/\.[^.]+$/, "");
-}
-/**
- * Build the test↔source coverage map from a symbol graph
- * (use `buildSymbolGraph` over a directory that includes the test files).
- */
-export function mapTestCoverage(graph) {
-    const nodeMap = new Map(graph.nodes.map((n) => [n.id, n]));
-    const allFiles = graph.nodes.filter((n) => n.nodeType === "file");
-    const fixtureCount = allFiles.filter((f) => isFixtureFile(f.id)).length;
-    const files = allFiles.filter((f) => !isFixtureFile(f.id));
-    const testFiles = files.filter((f) => isTestFile(f.id));
-    const sourceFiles = files.filter((f) => !isTestFile(f.id));
-    const isTest = new Set(testFiles.map((f) => f.id));
-    const sourceByBase = new Map();
-    for (const s of sourceFiles) {
-        const b = baseNoExt(s.id).toLowerCase();
-        (sourceByBase.get(b) ?? sourceByBase.set(b, []).get(b)).push(s.id);
-    }
-    // Signal 1: import edges test → source. Also count source-side fan-in (Ca).
-    const links = [];
-    const seen = new Set();
-    const afferent = new Map(); // source ← importers (non-test)
-    for (const e of graph.edges) {
-        if (e.edgeType !== "imports")
-            continue;
-        const to = nodeMap.get(e.to);
-        const toFile = to ? (to.nodeType === "file" ? to.id : to.file) : null;
-        if (!toFile || e.from === toFile)
-            continue;
-        if (isTest.has(e.from) && !isTest.has(toFile)) {
-            const key = e.from + "|" + toFile;
-            if (!seen.has(key)) {
-                seen.add(key);
-                links.push({ test: e.from, source: toFile, via: "import" });
-            }
-        }
-        else if (!isTest.has(e.from) && !isTest.has(toFile)) {
-            (afferent.get(toFile) ?? afferent.set(toFile, new Set()).get(toFile)).add(e.from);
-        }
-    }
-    // Signal 2: naming convention, for test files with no import link yet.
-    const linkedTests = new Set(links.map((l) => l.test));
-    for (const t of testFiles) {
-        if (linkedTests.has(t.id))
-            continue;
-        // Explicit marker in the name, else (for files inside test dirs, where the
-        // dir itself is the marker) the plain basename: test/analysis.mjs → "analysis".
-        const target = testNameTarget(t.id) ?? baseNoExt(t.id);
-        const candidates = sourceByBase.get(target.toLowerCase());
-        if (!candidates || candidates.length === 0)
-            continue;
-        // Prefer the candidate sharing the longest directory prefix with the test.
-        let best = [];
-        let bestScore = -1;
-        for (const c of candidates) {
-            const s = commonPrefixLen(t.id, c);
-            if (s > bestScore) {
-                bestScore = s;
-                best = [c];
-            }
-            else if (s === bestScore)
-                best.push(c);
-        }
-        for (const c of best) {
-            const key = t.id + "|" + c;
-            if (!seen.has(key)) {
-                seen.add(key);
-                links.push({ test: t.id, source: c, via: "name" });
-            }
-        }
-    }
-    // Aggregate.
-    const testsBySource = new Map();
-    for (const l of links) {
-        (testsBySource.get(l.source) ?? testsBySource.set(l.source, []).get(l.source)).push(l.test);
-    }
-    const tested = [];
-    const untested = [];
-    for (const s of sourceFiles) {
-        const tests = testsBySource.get(s.id);
-        if (tests)
-            tested.push({ file: s.id, tests: [...new Set(tests)].sort() });
-        else
-            untested.push({ file: s.id, symbols: s.symbolCount, afferent: afferent.get(s.id)?.size ?? 0 });
-    }
-    tested.sort((a, b) => a.file.localeCompare(b.file));
-    untested.sort((a, b) => b.afferent - a.afferent || b.symbols - a.symbols || a.file.localeCompare(b.file));
-    const covered = new Set(links.map((l) => l.test));
-    const orphanTests = testFiles.map((f) => f.id).filter((id) => !covered.has(id)).sort();
-    return {
-        sourceFiles: sourceFiles.length,
-        testFiles: testFiles.length,
-        fixtureFiles: fixtureCount,
-        testedSources: tested.length,
-        untestedSources: untested.length,
-        coverageRatio: sourceFiles.length === 0 ? 0 : Math.round((tested.length / sourceFiles.length) * 100) / 100,
-        links,
-        tested,
-        untested,
-        orphanTests,
-    };
-}

package/dist/tsconfig.js

@@ -1,212 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-const CONFIG_NAMES = ["tsconfig.json", "jsconfig.json"];
-/**
- * Tolerant JSONC parse. String-aware: comments and trailing commas are removed
- * with a character walk, never with regex — naive stripping corrupts configs
- * whose strings contain comment-like text (e.g. Next.js `"include": ["**\/*.ts"]`
- * pairs the `/*` inside `"@/*"` with the `*\/` inside the glob).
- */
-function parseJsonc(raw) {
-    let out = "";
-    let i = 0;
-    let inStr = false;
-    while (i < raw.length) {
-        const c = raw[i];
-        if (inStr) {
-            out += c;
-            if (c === "\\") {
-                out += raw[i + 1] ?? "";
-                i += 2;
-                continue;
-            }
-            if (c === '"')
-                inStr = false;
-            i++;
-        }
-        else if (c === '"') {
-            inStr = true;
-            out += c;
-            i++;
-        }
-        else if (c === "/" && raw[i + 1] === "/") {
-            while (i < raw.length && raw[i] !== "\n")
-                i++;
-        }
-        else if (c === "/" && raw[i + 1] === "*") {
-            i += 2;
-            while (i < raw.length && !(raw[i] === "*" && raw[i + 1] === "/"))
-                i++;
-            i += 2;
-        }
-        else if (c === ",") {
-            // trailing comma: skip when the next non-whitespace char closes a scope
-            let j = i + 1;
-            while (j < raw.length && /\s/.test(raw[j]))
-                j++;
-            if (raw[j] === "}" || raw[j] === "]")
-                i++; // drop the comma
-            else {
-                out += c;
-                i++;
-            }
-        }
-        else {
-            out += c;
-            i++;
-        }
-    }
-    try {
-        return JSON.parse(out);
-    }
-    catch {
-        return null;
-    }
-}
-/** Read a config file, following relative `extends` (child overrides parent). */
-function readConfigChain(configPath, depth = 0) {
-    if (depth > 5)
-        return null;
-    let raw;
-    try {
-        raw = fs.readFileSync(configPath, "utf8");
-    }
-    catch {
-        return null;
-    }
-    const json = parseJsonc(raw);
-    if (!json || typeof json !== "object")
-        return null;
-    const dir = path.dirname(configPath);
-    let baseUrl;
-    let paths;
-    let baseDir = dir;
-    const ext = json.extends;
-    if (typeof ext === "string" && ext.startsWith(".")) {
-        let parentPath = path.resolve(dir, ext);
-        if (!parentPath.endsWith(".json"))
-            parentPath += ".json";
-        const parent = readConfigChain(parentPath, depth + 1);
-        if (parent) {
-            baseUrl = parent.baseUrl;
-            paths = parent.paths;
-            baseDir = parent.dir; // paths in a parent resolve against the parent's dir
-        }
-    }
-    const co = json.compilerOptions;
-    if (co && typeof co === "object") {
-        if (typeof co.baseUrl === "string") {
-            baseUrl = co.baseUrl;
-            baseDir = dir;
-        }
-        if (co.paths && typeof co.paths === "object") {
-            paths = co.paths;
-            baseDir = dir;
-        }
-    }
-    return { baseUrl, paths, dir: baseDir };
-}
-function buildAliasConfig(configPath) {
-    const merged = readConfigChain(configPath);
-    if (!merged || !merged.paths)
-        return null;
-    const base = path.resolve(merged.dir, merged.baseUrl ?? ".");
-    const patterns = [];
-    for (const [key, targets] of Object.entries(merged.paths)) {
-        if (!Array.isArray(targets) || targets.length === 0)
-            continue;
-        const star = key.indexOf("*");
-        const abs = targets
-            .filter((t) => typeof t === "string")
-            .map((t) => path.resolve(base, t));
-        if (abs.length === 0)
-            continue;
-        if (star === -1) {
-            patterns.push({ prefix: key, suffix: "", exact: true, targets: abs });
-        }
-        else {
-            patterns.push({ prefix: key.slice(0, star), suffix: key.slice(star + 1), exact: false, targets: abs });
-        }
-    }
-    // Longest prefix wins (TypeScript's matching rule).
-    patterns.sort((a, b) => b.prefix.length - a.prefix.length);
-    return patterns.length > 0 ? { patterns } : null;
-}
-// dir → config path (or null when none found up the tree)
-const configPathCache = new Map();
-// config path → parsed alias config (or null when it has no paths)
-const aliasCache = new Map();
-function findNearestConfig(fromDir) {
-    const cached = configPathCache.get(fromDir);
-    if (cached !== undefined)
-        return cached;
-    let dir = fromDir;
-    let result = null;
-    const visited = [];
-    for (;;) {
-        const hit = configPathCache.get(dir);
-        if (hit !== undefined) {
-            result = hit;
-            break;
-        }
-        visited.push(dir);
-        let found = null;
-        for (const name of CONFIG_NAMES) {
-            const p = path.join(dir, name);
-            if (fs.existsSync(p)) {
-                found = p;
-                break;
-            }
-        }
-        if (found) {
-            result = found;
-            break;
-        }
-        const parent = path.dirname(dir);
-        if (parent === dir || dir.includes("node_modules")) {
-            result = null;
-            break;
-        }
-        dir = parent;
-    }
-    for (const d of visited)
-        configPathCache.set(d, result);
-    return result;
-}
-/** Test-only: clear the per-process caches. */
-export function clearAliasCaches() {
-    configPathCache.clear();
-    aliasCache.clear();
-}
-/**
- * Map an aliased bare import to absolute candidate base paths (no extension
- * probing). Empty array = not an alias / no config / no pattern match.
- */
-export function aliasCandidates(importFrom, fromAbs) {
-    if (importFrom.startsWith(".") || path.isAbsolute(importFrom))
-        return [];
-    const configPath = findNearestConfig(path.dirname(fromAbs));
-    if (!configPath)
-        return [];
-    let cfg = aliasCache.get(configPath);
-    if (cfg === undefined) {
-        cfg = buildAliasConfig(configPath);
-        aliasCache.set(configPath, cfg);
-    }
-    if (!cfg)
-        return [];
-    for (const p of cfg.patterns) {
-        if (p.exact) {
-            if (importFrom === p.prefix)
-                return p.targets;
-            continue;
-        }
-        if (importFrom.length >= p.prefix.length + p.suffix.length &&
-            importFrom.startsWith(p.prefix) &&
-            importFrom.endsWith(p.suffix)) {
-            const star = importFrom.slice(p.prefix.length, importFrom.length - p.suffix.length);
-            return p.targets.map((t) => t.replace("*", star));
-        }
-    }
-    return [];
-}

package/dist/typeflow.js

@@ -1,124 +0,0 @@
-import fs from "node:fs";
-import { parseSource } from "./parser.js";
-import { detectLanguage } from "./registry.js";
-const FN_TYPES = new Set([
-    "function_declaration", "generator_function_declaration", "function_definition",
-    "async_function_definition", "method_definition", "method_declaration",
-    "constructor_declaration", "function_item",
-]);
-const ID_TYPES = new Set(["identifier", "simple_identifier"]);
-const TYPE_ID_TYPES = new Set(["type_identifier", "identifier"]);
-const PARAM_CONTAINERS = new Set([
-    "formal_parameters", "parameters", "parameter_list", "function_value_parameters",
-]);
-function fnName(node) {
-    const nm = node.childForFieldName("name");
-    if (nm)
-        return nm.text;
-    for (let i = 0; i < node.namedChildCount; i++) {
-        const c = node.namedChild(i);
-        if (c && c.type === "simple_identifier")
-            return c.text;
-    }
-    return "(anonymous)";
-}
-/** Does this type-annotation subtree reference the bare type name `name`? */
-function typeRefsName(node, name) {
-    if (!node)
-        return false;
-    let hit = false;
-    const walk = (n) => {
-        if (hit)
-            return;
-        if (TYPE_ID_TYPES.has(n.type) && n.text === name) {
-            hit = true;
-            return;
-        }
-        for (let i = 0; i < n.namedChildCount; i++) {
-            const c = n.namedChild(i);
-            if (c)
-                walk(c);
-        }
-    };
-    walk(node);
-    return hit;
-}
-function paramName(p) {
-    if (ID_TYPES.has(p.type))
-        return p.text;
-    const pat = p.childForFieldName("pattern");
-    if (pat && ID_TYPES.has(pat.type))
-        return pat.text;
-    const nm = p.childForFieldName("name");
-    if (nm && ID_TYPES.has(nm.type))
-        return nm.text;
-    return undefined;
-}
-function paramsNode(fn) {
-    const p = fn.childForFieldName("parameters");
-    if (p)
-        return p;
-    for (let i = 0; i < fn.namedChildCount; i++) {
-        const c = fn.namedChild(i);
-        if (c && PARAM_CONTAINERS.has(c.type))
-            return c;
-    }
-    return null;
-}
-export async function traceTypeInFile(absPath, relPath, typeName) {
-    const lang = detectLanguage(absPath);
-    if (!lang)
-        return [];
-    const source = fs.readFileSync(absPath, "utf8");
-    const root = await parseSource(lang.grammar, source);
-    const refs = [];
-    const walk = (node) => {
-        if (FN_TYPES.has(node.type)) {
-            const name = fnName(node);
-            // return type
-            const rt = node.childForFieldName("return_type");
-            if (typeRefsName(rt, typeName)) {
-                refs.push({ file: relPath, symbol: name, role: "return", line: node.startPosition.row + 1 });
-            }
-            // params
-            const pnode = paramsNode(node);
-            if (pnode) {
-                for (let i = 0; i < pnode.namedChildCount; i++) {
-                    const p = pnode.namedChild(i);
-                    if (!p)
-                        continue;
-                    const ty = p.childForFieldName("type");
-                    if (typeRefsName(ty, typeName)) {
-                        const pn = paramName(p);
-                        refs.push({
-                            file: relPath, symbol: name, role: "param",
-                            ...(pn ? { detail: pn } : {}),
-                            line: p.startPosition.row + 1,
-                        });
-                    }
-                }
-            }
-        }
-        else if (node.type === "variable_declarator") {
-            const ty = node.childForFieldName("type");
-            const nm = node.childForFieldName("name");
-            if (ty && nm && typeRefsName(ty, typeName)) {
-                refs.push({ file: relPath, symbol: nm.text, role: "variable", line: node.startPosition.row + 1 });
-            }
-        }
-        else if (node.type === "public_field_definition" || node.type === "field_definition") {
-            const ty = node.childForFieldName("type");
-            const nm = node.childForFieldName("name");
-            if (ty && nm && typeRefsName(ty, typeName)) {
-                refs.push({ file: relPath, symbol: nm.text, role: "field", line: node.startPosition.row + 1 });
-            }
-        }
-        for (let i = 0; i < node.namedChildCount; i++) {
-            const c = node.namedChild(i);
-            if (c)
-                walk(c);
-        }
-    };
-    walk(root);
-    return refs;
-}

package/dist/types.js

@@ -1,5 +0,0 @@
-/**
- * Standard Skeleton JSON schema — the shared "interlingua" that every
- * language extractor must produce, regardless of the source language.
- */
-export {};

package/dist/unused-params.js

@@ -1,127 +0,0 @@
-import fs from "node:fs";
-import { parseSource } from "./parser.js";
-import { detectLanguage } from "./registry.js";
-// Named function-like nodes across the supported languages. Anonymous arrows /
-// lambdas are intentionally skipped: they're usually callbacks where an unused
-// parameter is required by the caller's signature (event handlers, map indices).
-const FN_TYPES = new Set([
-    "function_declaration",
-    "generator_function_declaration",
-    "function_definition", // Python / C / C++
-    "async_function_definition", // Python
-    "method_definition", // TS/JS class member
-    "method_declaration", // Go / Java / C#
-    "constructor_declaration", // Java / C#
-    "function_item", // Rust
-]);
-const PARAM_CONTAINERS = new Set([
-    "formal_parameters", "parameters", "parameter_list", "function_value_parameters",
-]);
-const ID_TYPES = new Set(["identifier", "simple_identifier"]);
-// Identifier-like nodes that count as a *usage* of a name. Includes object
-// shorthand (`{ foo }` references `foo`), which is ubiquitous in JS/TS.
-const USE_TYPES = new Set([
-    "identifier", "simple_identifier",
-    "shorthand_property_identifier", "shorthand_property_identifier_pattern",
-]);
-// Binding shapes we do NOT try to resolve to a single name (avoid false positives).
-const SKIP_PARAM = /splat|rest|spread|object_pattern|array_pattern|tuple_pattern|object_type/;
-function fnName(node) {
-    const nm = node.childForFieldName("name");
-    if (nm)
-        return nm.text;
-    // Kotlin/Swift function_declaration: name is the first simple_identifier child.
-    for (let i = 0; i < node.namedChildCount; i++) {
-        const c = node.namedChild(i);
-        if (c && c.type === "simple_identifier")
-            return c.text;
-    }
-    return "(anonymous)";
-}
-function paramsNode(fn) {
-    const p = fn.childForFieldName("parameters");
-    if (p)
-        return p;
-    for (let i = 0; i < fn.namedChildCount; i++) {
-        const c = fn.namedChild(i);
-        if (c && PARAM_CONTAINERS.has(c.type))
-            return c;
-    }
-    return null;
-}
-/** Best-effort binding names for one parameter node (may be empty when unsure). */
-function paramNames(p) {
-    if (ID_TYPES.has(p.type))
-        return [p.text];
-    if (SKIP_PARAM.test(p.type))
-        return [];
-    const pat = p.childForFieldName("pattern");
-    if (pat)
-        return ID_TYPES.has(pat.type) ? [pat.text] : [];
-    const nm = p.childForFieldName("name");
-    if (nm && ID_TYPES.has(nm.type))
-        return [nm.text];
-    // Go: `a, b int` → several identifier children before the type.
-    const ids = [];
-    for (let i = 0; i < p.namedChildCount; i++) {
-        const c = p.namedChild(i);
-        if (c && c.type === "identifier")
-            ids.push(c.text);
-    }
-    return ids;
-}
-/** Collect every bare identifier reference in the subtree (not member/field names). */
-function collectIdentifierUses(node, out) {
-    if (USE_TYPES.has(node.type))
-        out.add(node.text);
-    for (let i = 0; i < node.namedChildCount; i++) {
-        const c = node.namedChild(i);
-        if (c)
-            collectIdentifierUses(c, out);
-    }
-}
-function unusedInFunction(fn) {
-    const pnode = paramsNode(fn);
-    const body = fn.childForFieldName("body");
-    if (!pnode || !body)
-        return [];
-    const names = [];
-    for (let i = 0; i < pnode.namedChildCount; i++) {
-        const p = pnode.namedChild(i);
-        if (p)
-            names.push(...paramNames(p));
-    }
-    if (names.length === 0)
-        return [];
-    const used = new Set();
-    collectIdentifierUses(body, used);
-    // Skip `_`-prefixed (conventionally intentional) and `this`/`self`.
-    return names.filter((n) => n !== "_" && !n.startsWith("_") && n !== "this" && n !== "self" && !used.has(n));
-}
-export async function findUnusedParams(absPath, relPath) {
-    const lang = detectLanguage(absPath);
-    if (!lang)
-        return null;
-    const source = fs.readFileSync(absPath, "utf8");
-    const root = await parseSource(lang.grammar, source);
-    const functions = [];
-    const walk = (node) => {
-        if (FN_TYPES.has(node.type)) {
-            const unused = unusedInFunction(node);
-            if (unused.length > 0) {
-                functions.push({
-                    function: fnName(node),
-                    line: node.startPosition.row + 1,
-                    unused,
-                });
-            }
-        }
-        for (let i = 0; i < node.namedChildCount; i++) {
-            const c = node.namedChild(i);
-            if (c)
-                walk(c);
-        }
-    };
-    walk(root);
-    return { file: relPath, functions };
-}

package/dist/worker.js

@@ -1,27 +0,0 @@
-// 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),
-            });
-        }
-    })();
-});