universal-ast-mapper 1.22.1 → 1.24.0

package/CHANGELOG.md

@@ -6,6 +6,36 @@ since 1.0.0, guarantees a stable MCP tool / CLI surface across the 1.x line.
 
 ---
 
+## [1.24.0] — 2026-06-10 · TS path-alias resolution
+- Bare imports like `@/components/Button` now resolve through **`tsconfig.json` /
+  `jsconfig.json` `compilerOptions.paths`** (+ `baseUrl`): nearest-config lookup above
+  the importing file (monorepo-safe, per-process cached), relative `extends` chains
+  (child `paths` replace the parent's, per TS semantics), longest-prefix pattern
+  matching, candidate probing with the usual extension/index logic.
+- **String-aware JSONC parser** — comments/trailing commas are stripped with a
+  character walk, not regex (naive stripping corrupts Next.js configs where `"@/*"`
+  pairs with the `*/` inside `"**/*.ts"` include globs).
+- Wired into `resolve_imports` (aliased imports report `importKind: "relative"` +
+  resolved file), `build_symbol_graph` (alias edges before workspace-package fallback),
+  and the call graph (callee origin + reverse `calledBy`).
+- Real-world effect (Next.js app, 186 files): import graph 31 → **324 edges**;
+  dead exports 210 → 153; god nodes now reflect true usage.
+- New module `tsconfig` (`aliasCandidates`, `clearAliasCaches`) + `resolveAliasedImport`
+  in the resolver. Tests: new `test/tsalias-smoke.mjs` (15 checks), wired into `npm test`.
+
+## [1.23.0] — 2026-06-10 · Configurable root boundary (multi-root + unlocked)
+- **`AST_MAP_ROOT` accepts multiple roots**, separated by the OS path delimiter
+  (`;` Windows / `:` POSIX). The first root is primary; absolute paths inside any
+  listed root are allowed.
+- **`AST_MAP_UNLOCKED=1`** — opt-in: the MCP server analyzes **any existing absolute
+  path** the client asks for. Default behavior is unchanged (locked to the root list).
+- Every tool now computes rel-paths and graph roots against the **matched** root, so
+  reports/graphs on outside-root projects come out correct.
+- Clearer boundary error message (suggests both escape hatches).
+- New module `roots` (`parseRootsFromEnv`, `resolvePathInRoots`); CLI shares the parser.
+- Tests: new `test/roots-smoke.mjs` (13 checks) + end-to-end verified over MCP stdio
+  (locked rejects / unlocked analyzes an outside project).
+
 ## [1.22.1] — 2026-06-10 · Docs
 - README refreshed to match v1.20–1.22: 28 tools / 30 commands, PHP+Ruby capability
   columns, `cache`/`check` CLI + config + env-var docs, `check_quality_gate` reference,

package/README.md

@@ -20,7 +20,7 @@ Built on [tree-sitter](https://tree-sitter.github.io/) WASM grammars. Zero regex
 > As of v0.8.2, all four v0.8.0 languages have **cross-file graph + resolver** wiring: Kotlin (FQCN/package index), C/C++ (`#include` with header↔impl pairing), and Swift (module = directory under `Sources/`). Call-graph callee origin is resolved for Kotlin; for C/C++/Swift it stays limited because their imports don't name individual symbols. (PHP & Ruby landed in v1.22.0 — symbol extraction + imports; cross-file graph wiring for them is the next step. Ruby was unblocked by upgrading `web-tree-sitter` to 0.21.0.)
 
 Each language uses the resolution strategy that fits it:
-- **TS/JS/Python** — relative paths (`./foo`, `..mod`) resolved against the importing file's directory, with TS-ESM `.js` → `.ts` rewriting.
+- **TS/JS/Python** — relative paths (`./foo`, `..mod`) resolved against the importing file's directory, with TS-ESM `.js` → `.ts` rewriting. **Path aliases** (`@/*` etc.) resolve via the nearest `tsconfig.json`/`jsconfig.json` (`paths` + `baseUrl`, relative `extends`). *(v1.24.0)*
 - **Go** — `go.mod` ancestor lookup → module path prefix → package directory → all `.go` files (skips `_test.go`).
 - **Rust** — `Cargo.toml` ancestor → `crate::` / `self::` / `super::` walks; supports `mod.rs` + Rust-2018 sibling-dir style.
 - **Java** — project-wide FQCN index (`package + "." + className → file`) built lazily on first cross-lang call; supports wildcard imports.
@@ -79,6 +79,20 @@ node dist/cli.js dead src/
 
 > `AST_MAP_ROOT` is the security boundary — the server only reads files inside this path.
 
+Since **v1.23.0** the boundary is configurable:
+
+- **Multi-root** — list several projects in `AST_MAP_ROOT`, separated by the OS path delimiter (`;` on Windows, `:` on macOS/Linux). The first root is the primary (relative paths resolve against it):
+
+```json
+      "env": { "AST_MAP_ROOT": "C:\\proj\\app;C:\\proj\\chem_sc_su" }
+```
+
+- **Unlocked** — set `AST_MAP_UNLOCKED: "1"` to let the server analyze **any absolute path** the client asks for (relative paths still resolve against the primary root). Use this for a personal "analyze anything" setup; keep it off for shared/untrusted environments:
+
+```json
+      "env": { "AST_MAP_ROOT": "C:\\proj\\app", "AST_MAP_UNLOCKED": "1" }
+```
+
 ---
 
 ## CLI Reference
@@ -787,6 +801,8 @@ Not part of the public API: the internal `src/` module layout and the generated
 
 | Version | What changed |
 |---------|--------------|
+| **1.24.0** | **TS path-alias resolution** — bare imports like `@/components/Button` now resolve via the **nearest** `tsconfig.json`/`jsconfig.json` (`compilerOptions.paths` + `baseUrl`, relative `extends` chains, longest-prefix matching, string-aware JSONC parser). Wired into `resolve_imports`, the symbol graph, and the call graph — on a real Next.js app this took the import graph from 31 to **324 edges** and cut false dead-exports by ~30%. |
+| **1.23.0** | **Configurable root boundary** — `AST_MAP_ROOT` accepts **multiple roots** (path-delimiter separated) and `AST_MAP_UNLOCKED=1` allows analyzing **any absolute path** on request (default stays locked). Analysis/graph/report rel-paths now computed against the matched root, so cross-root results are correct. New `roots` module + 13-check test suite. |
 | **1.22.0** | **PHP & Ruby support** — `.php` (classes, interfaces, traits, enums, methods with visibility, `use` imports incl. grouped, require/include) and `.rb`/`.rake` (classes, modules, methods, `self.` singleton methods, `private` section tracking, require/require_relative). Unblocked by upgrading `web-tree-sitter` 0.20.8 → 0.21.0 (all existing grammars re-verified). **16 languages**. |
 | **1.21.0** | **Quality gate** — `ast-map check` fails CI when quality regresses: **baseline ratchet** vs `.ast-map.baseline.json` (cycles · dead exports · SDP · very-high complexity · score; `--update-baseline` re-anchors) + absolute thresholds (flags or config `"check"`). New MCP tool `check_quality_gate` (**28 tools**); GitHub Action gains `mode: check`. |
 | **1.20.0** | **Incremental cache + parallel parsing** — persistent content-hash parse cache in `.ast-map/cache` (on by default, never stale, warm hits ~60× faster on large files; `ast-map cache stats|clear`, `AST_MAP_NO_CACHE`, `"cache": false`) + worker-thread **parallel parsing** for bulk scans (auto-sized, `AST_MAP_WORKERS` override, sequential fallback). |

package/dist/callgraph.js

@@ -4,7 +4,7 @@ import { parseSource } from "./parser.js";
 import { buildSkeleton } from "./skeleton.js";
 import { resolveOptions, loadProjectConfig } from "./config.js";
 import { detectLanguage } from "./registry.js";
-import { resolveImportPath, getOrBuildCrossLangIndex } from "./resolver.js";
+import { resolveImportPath, resolveAliasedImport, getOrBuildCrossLangIndex } from "./resolver.js";
 import { resolveCrossLangTarget } from "./crosslang.js";
 const CROSS_LANG = new Set(["java", "csharp", "rust", "go", "kotlin", "c", "cpp", "swift"]);
 function pushCall(out, callee, anchor) {
@@ -313,8 +313,14 @@ export async function buildCallGraph(filePath, funcName, root, allSkeletons) {
                 }
             }
             else {
-                call.isExternal = true;
-                call.calleeFileRel = importRef.from;
+                const aliasAbs = resolveAliasedImport(importRef.from, filePath);
+                if (aliasAbs) {
+                    call.calleeFileRel = path.relative(root, aliasAbs).split(path.sep).join("/");
+                }
+                else {
+                    call.isExternal = true;
+                    call.calleeFileRel = importRef.from;
+                }
             }
         }
         else if (aliasOrigin) {
@@ -326,8 +332,14 @@ export async function buildCallGraph(filePath, funcName, root, allSkeletons) {
                 }
             }
             else {
-                call.isExternal = true;
-                call.calleeFileRel = aliasOrigin;
+                const aliasAbs = resolveAliasedImport(aliasOrigin, filePath);
+                if (aliasAbs) {
+                    call.calleeFileRel = path.relative(root, aliasAbs).split(path.sep).join("/");
+                }
+                else {
+                    call.isExternal = true;
+                    call.calleeFileRel = aliasOrigin;
+                }
             }
         }
         else if (crossIndex && skel.language === "csharp") {
@@ -387,8 +399,10 @@ export async function buildCallGraph(filePath, funcName, root, allSkeletons) {
                         break;
                     }
                 }
-                else if (imp.from.startsWith(".")) {
-                    const resolvedAbs = resolveImportPath(imp.from, otherAbs);
+                else {
+                    const resolvedAbs = imp.from.startsWith(".")
+                        ? resolveImportPath(imp.from, otherAbs)
+                        : resolveAliasedImport(imp.from, otherAbs);
                     if (!resolvedAbs)
                         continue;
                     const resolvedRel = path.relative(root, resolvedAbs).split(path.sep).join("/");

package/dist/cli.js

@@ -27,7 +27,8 @@ import { findLayerViolations } from "./layers.js";
 import { computeModuleCoupling } from "./modulecoupling.js";
 import { buildCallGraph } from "./callgraph.js";
 import { searchSymbols } from "./search.js";
-const ROOT = path.resolve(process.env.AST_MAP_ROOT ?? process.cwd());
+import { parseRootsFromEnv } from "./roots.js";
+const ROOT = parseRootsFromEnv().roots[0]; // CLI is local — no boundary, primary root only
 // Persistent parse cache (disable with AST_MAP_NO_CACHE=1 or "cache": false in config).
 if (process.env.AST_MAP_NO_CACHE !== "1" && loadProjectConfig(ROOT).cache !== false) {
     initDiskCache(defaultCacheDir(ROOT));

package/dist/graph.js

@@ -1,5 +1,5 @@
 import path from "node:path";
-import { resolveImportPath } from "./resolver.js";
+import { resolveImportPath, resolveAliasedImport } from "./resolver.js";
 import { resolveWorkspaceImportCached } from "./workspace.js";
 import { buildCrossLangIndex, resolveCrossLangTarget, } from "./crosslang.js";
 // ─── Internal helpers ─────────────────────────────────────────────────────────
@@ -38,7 +38,7 @@ function wirePathImport(skel, imp, fromFileAbs, root, exportedSymbolMap, edges)
     // Relative import → path resolve; bare specifier → monorepo workspace package.
     const resolvedAbs = imp.from.startsWith(".")
         ? resolveImportPath(imp.from, fromFileAbs)
-        : resolveWorkspaceImportCached(imp.from, root);
+        : resolveAliasedImport(imp.from, fromFileAbs) ?? resolveWorkspaceImportCached(imp.from, root);
     if (!resolvedAbs)
         return;
     const resolvedRel = path.relative(root, resolvedAbs).split(path.sep).join("/");

package/dist/index.js

@@ -30,20 +30,20 @@ import { computeCoupling } from "./coupling.js";
 import { findLayerViolations } from "./layers.js";
 import { computeModuleCoupling } from "./modulecoupling.js";
 import { registerPrompts } from "./prompts.js";
-/** Files may only be read inside this root (override with AST_MAP_ROOT). */
-const ROOT = path.resolve(process.env.AST_MAP_ROOT ?? process.cwd());
+import { parseRootsFromEnv, resolvePathInRoots } from "./roots.js";
+/**
+ * Security boundary. AST_MAP_ROOT may list several roots (path-delimiter
+ * separated); AST_MAP_UNLOCKED=1 allows any absolute path. The first root is
+ * the primary — relative inputs resolve against it.
+ */
+const ROOTS = parseRootsFromEnv();
+const ROOT = ROOTS.roots[0];
 // Persistent parse cache (disable with AST_MAP_NO_CACHE=1 or "cache": false in config).
 if (process.env.AST_MAP_NO_CACHE !== "1" && loadProjectConfig(ROOT).cache !== false) {
     initDiskCache(defaultCacheDir(ROOT));
 }
 function resolveInRoot(input) {
-    const abs = path.resolve(ROOT, input);
-    const rel = path.relative(ROOT, abs);
-    if (rel.startsWith("..") || path.isAbsolute(rel)) {
-        throw new Error(`Path "${input}" is outside the allowed root (${ROOT}). ` +
-            `Set the AST_MAP_ROOT environment variable to the project you want to map.`);
-    }
-    return { abs, rel: rel === "" ? path.basename(abs) : rel };
+    return resolvePathInRoots(input, ROOTS);
 }
 function htmlPathFor(rel, opts) {
     const outDir = opts.outputDir ? path.resolve(ROOT, opts.outputDir) : path.join(ROOT, ".ast-map");
@@ -99,7 +99,7 @@ server.registerTool("get_skeleton_json", {
     },
 }, async ({ path: input, detail }) => {
     try {
-        const { abs, rel } = resolveInRoot(input);
+        const { abs, rel, root } = resolveInRoot(input);
         if (fs.statSync(abs).isDirectory()) {
             return errorText(`"${input}" is a directory. Use generate_skeleton for directories.`);
         }
@@ -135,7 +135,7 @@ server.registerTool("generate_skeleton", {
 }, async ({ path: input, detail, emitHtml, combineHtml, outputDir }) => {
     try {
         const opts = resolveOptions({ detail, emitHtml, combineHtml, outputDir });
-        const { abs, rel } = resolveInRoot(input);
+        const { abs, rel, root } = resolveInRoot(input);
         const stat = fs.statSync(abs);
         if (stat.isDirectory()) {
             const files = collectSourceFiles(abs, opts);
@@ -144,7 +144,7 @@ server.registerTool("generate_skeleton", {
             let totalSymbols = 0;
             const items = files.map((file) => ({
                 abs: file,
-                rel: path.relative(ROOT, file).split(path.sep).join("/"),
+                rel: path.relative(root, file).split(path.sep).join("/"),
             }));
             const built = await buildSkeletonsBulk(items, opts);
             for (let i = 0; i < built.length; i++) {
@@ -168,15 +168,15 @@ server.registerTool("generate_skeleton", {
             let combinedHtmlPath = null;
             if (opts.combineHtml && successSkeletons.length > 0) {
                 const outDir = opts.outputDir
-                    ? path.resolve(ROOT, opts.outputDir)
-                    : path.join(ROOT, ".ast-map");
+                    ? path.resolve(root, opts.outputDir)
+                    : path.join(root, ".ast-map");
                 fs.mkdirSync(outDir, { recursive: true });
                 combinedHtmlPath = path.join(outDir, "index.html");
                 fs.writeFileSync(combinedHtmlPath, renderCombinedHtml(successSkeletons), "utf8");
             }
             return jsonText({
                 mode: "directory",
-                root: ROOT,
+                root: root,
                 directory: rel.split(path.sep).join("/"),
                 fileCount: files.length,
                 totalSymbols,
@@ -214,7 +214,7 @@ server.registerTool("get_symbol_context", {
     },
 }, async ({ path: input, symbol, kind, includeRelated }) => {
     try {
-        const { abs, rel } = resolveInRoot(input);
+        const { abs, rel, root } = resolveInRoot(input);
         if (fs.statSync(abs).isDirectory()) {
             return errorText(`"${input}" is a directory. Provide a single file path.`);
         }
@@ -269,8 +269,8 @@ server.registerTool("validate_architecture", {
     },
 }, async ({ path: input, maxLines, maxImports, maxExports }) => {
     try {
-        const { abs } = resolveInRoot(input);
-        const projectConfig = loadProjectConfig(ROOT);
+        const { abs, root } = resolveInRoot(input);
+        const projectConfig = loadProjectConfig(root);
         const opts = resolveOptions({ detail: "full", emitHtml: false }, projectConfig);
         const stat = fs.statSync(abs);
         const filesToCheck = stat.isDirectory()
@@ -284,7 +284,7 @@ server.registerTool("validate_architecture", {
         };
         const violations = [];
         for (const file of filesToCheck) {
-            const fileRel = path.relative(ROOT, file).split(path.sep).join("/");
+            const fileRel = path.relative(root, file).split(path.sep).join("/");
             let source;
             try {
                 source = fs.readFileSync(file, "utf8");
@@ -357,13 +357,13 @@ server.registerTool("resolve_imports", {
     },
 }, async ({ path: input }) => {
     try {
-        const { abs, rel } = resolveInRoot(input);
+        const { abs, rel, root } = resolveInRoot(input);
         if (fs.statSync(abs).isDirectory()) {
             return errorText(`"${input}" is a directory. Provide a single file path.`);
         }
         const opts = resolveOptions({ detail: "full", emitHtml: false });
         const skel = await buildSkeleton(abs, rel, opts);
-        const resolved = await resolveFileImports(skel, abs, ROOT);
+        const resolved = await resolveFileImports(skel, abs, root);
         return jsonText({
             file: rel,
             importCount: resolved.length,
@@ -402,7 +402,7 @@ server.registerTool("build_symbol_graph", {
     },
 }, async ({ path: input, detail, outputFile }) => {
     try {
-        const { abs, rel } = resolveInRoot(input);
+        const { abs, rel, root } = resolveInRoot(input);
         if (!fs.statSync(abs).isDirectory()) {
             return errorText(`"${input}" is not a directory. build_symbol_graph requires a directory.`);
         }
@@ -411,7 +411,7 @@ server.registerTool("build_symbol_graph", {
         const skeletons = [];
         const errors = [];
         for (const file of files) {
-            const fileRel = path.relative(ROOT, file).split(path.sep).join("/");
+            const fileRel = path.relative(root, file).split(path.sep).join("/");
             try {
                 skeletons.push(await buildSkeleton(file, fileRel, opts));
             }
@@ -419,7 +419,7 @@ server.registerTool("build_symbol_graph", {
                 errors.push({ file: fileRel, error: describeError(err) });
             }
         }
-        const graph = buildSymbolGraph(skeletons, ROOT);
+        const graph = buildSymbolGraph(skeletons, root);
         if (outputFile) {
             const { abs: outAbs } = resolveInRoot(outputFile);
             fs.mkdirSync(path.dirname(outAbs), { recursive: true });
@@ -474,7 +474,7 @@ server.registerTool("find_dead_code", {
     },
 }, async ({ path: input, detail }) => {
     try {
-        const { abs, rel } = resolveInRoot(input);
+        const { abs, rel, root } = resolveInRoot(input);
         if (!fs.statSync(abs).isDirectory()) {
             return errorText(`"${input}" is not a directory. find_dead_code requires a directory.`);
         }
@@ -483,7 +483,7 @@ server.registerTool("find_dead_code", {
         const skeletons = [];
         const errors = [];
         for (const file of files) {
-            const fileRel = path.relative(ROOT, file).split(path.sep).join("/");
+            const fileRel = path.relative(root, file).split(path.sep).join("/");
             try {
                 skeletons.push(await buildSkeleton(file, fileRel, opts));
             }
@@ -491,7 +491,7 @@ server.registerTool("find_dead_code", {
                 errors.push({ file: fileRel, error: describeError(err) });
             }
         }
-        const graph = buildSymbolGraph(skeletons, ROOT);
+        const graph = buildSymbolGraph(skeletons, root);
         const dead = findDeadExports(graph);
         return jsonText({
             directory: rel.split(path.sep).join("/"),
@@ -517,7 +517,7 @@ server.registerTool("find_circular_deps", {
     },
 }, async ({ path: input }) => {
     try {
-        const { abs, rel } = resolveInRoot(input);
+        const { abs, rel, root } = resolveInRoot(input);
         if (!fs.statSync(abs).isDirectory()) {
             return errorText(`"${input}" is not a directory. find_circular_deps requires a directory.`);
         }
@@ -526,7 +526,7 @@ server.registerTool("find_circular_deps", {
         const skeletons = [];
         const errors = [];
         for (const file of files) {
-            const fileRel = path.relative(ROOT, file).split(path.sep).join("/");
+            const fileRel = path.relative(root, file).split(path.sep).join("/");
             try {
                 skeletons.push(await buildSkeleton(file, fileRel, opts));
             }
@@ -534,7 +534,7 @@ server.registerTool("find_circular_deps", {
                 errors.push({ file: fileRel, error: describeError(err) });
             }
         }
-        const graph = buildSymbolGraph(skeletons, ROOT);
+        const graph = buildSymbolGraph(skeletons, root);
         const cycles = findCircularDeps(graph);
         return jsonText({
             directory: rel.split(path.sep).join("/"),
@@ -561,7 +561,7 @@ server.registerTool("find_duplicate_symbols", {
     },
 }, async ({ path: input }) => {
     try {
-        const { abs, rel } = resolveInRoot(input);
+        const { abs, rel, root } = resolveInRoot(input);
         if (!fs.statSync(abs).isDirectory()) {
             return errorText(`"${input}" is not a directory. find_duplicate_symbols requires a directory.`);
         }
@@ -570,7 +570,7 @@ server.registerTool("find_duplicate_symbols", {
         const skeletons = [];
         const errors = [];
         for (const file of files) {
-            const fileRel = path.relative(ROOT, file).split(path.sep).join("/");
+            const fileRel = path.relative(root, file).split(path.sep).join("/");
             try {
                 skeletons.push(await buildSkeleton(file, fileRel, opts));
             }
@@ -578,7 +578,7 @@ server.registerTool("find_duplicate_symbols", {
                 errors.push({ file: fileRel, error: describeError(err) });
             }
         }
-        const graph = buildSymbolGraph(skeletons, ROOT);
+        const graph = buildSymbolGraph(skeletons, root);
         const duplicates = findDuplicateSymbols(graph);
         return jsonText({
             directory: rel.split(path.sep).join("/"),
@@ -604,7 +604,7 @@ server.registerTool("get_complexity", {
     },
 }, async ({ path: input }) => {
     try {
-        const { abs, rel } = resolveInRoot(input);
+        const { abs, rel, root } = resolveInRoot(input);
         const stat = fs.statSync(abs);
         if (stat.isDirectory()) {
             const opts = resolveOptions({ detail: "outline", emitHtml: false });
@@ -612,7 +612,7 @@ server.registerTool("get_complexity", {
             const results = [];
             const errors = [];
             for (const file of files) {
-                const fileRel = path.relative(ROOT, file).split(path.sep).join("/");
+                const fileRel = path.relative(root, file).split(path.sep).join("/");
                 try {
                     const fc = await computeFileComplexity(file, fileRel);
                     if (fc)
@@ -654,7 +654,7 @@ server.registerTool("find_unused_params", {
     },
 }, async ({ path: input }) => {
     try {
-        const { abs, rel } = resolveInRoot(input);
+        const { abs, rel, root } = resolveInRoot(input);
         const stat = fs.statSync(abs);
         if (stat.isDirectory()) {
             const opts = resolveOptions({ detail: "outline", emitHtml: false });
@@ -662,7 +662,7 @@ server.registerTool("find_unused_params", {
             const results = [];
             const errors = [];
             for (const file of files) {
-                const fileRel = path.relative(ROOT, file).split(path.sep).join("/");
+                const fileRel = path.relative(root, file).split(path.sep).join("/");
                 try {
                     const r = await findUnusedParams(file, fileRel);
                     if (r && r.functions.length > 0)
@@ -702,7 +702,7 @@ server.registerTool("trace_type", {
     },
 }, async ({ type: typeName, path: input }) => {
     try {
-        const { abs, rel } = resolveInRoot(input);
+        const { abs, rel, root } = resolveInRoot(input);
         if (!fs.statSync(abs).isDirectory()) {
             return errorText(`"${input}" is not a directory. trace_type requires a directory.`);
         }
@@ -711,7 +711,7 @@ server.registerTool("trace_type", {
         const refs = [];
         const errors = [];
         for (const file of files) {
-            const fileRel = path.relative(ROOT, file).split(path.sep).join("/");
+            const fileRel = path.relative(root, file).split(path.sep).join("/");
             try {
                 refs.push(...(await traceTypeInFile(file, fileRel, typeName)));
             }
@@ -747,7 +747,7 @@ server.registerTool("analyze_workspace", {
     },
 }, async ({ path: input }) => {
     try {
-        const { abs, rel } = resolveInRoot(input ?? ".");
+        const { abs, rel, root } = resolveInRoot(input ?? ".");
         if (!fs.statSync(abs).isDirectory()) {
             return errorText(`"${input}" is not a directory. analyze_workspace requires a directory.`);
         }
@@ -777,7 +777,7 @@ server.registerTool("read_source_map", {
     },
 }, async ({ path: input }) => {
     try {
-        const { abs, rel } = resolveInRoot(input);
+        const { abs, rel, root } = resolveInRoot(input);
         const info = readSourceMap(abs, rel.split(path.sep).join("/"));
         if (!info)
             return errorText(`No source map found for "${input}".`);
@@ -798,11 +798,11 @@ server.registerTool("get_codebase_report", {
     },
 }, async ({ path: input }) => {
     try {
-        const { abs, rel } = resolveInRoot(input ?? ".");
+        const { abs, rel, root } = resolveInRoot(input ?? ".");
         if (!fs.statSync(abs).isDirectory()) {
             return errorText(`"${input}" is not a directory. get_codebase_report requires a directory.`);
         }
-        const data = await buildReport(abs, ROOT);
+        const data = await buildReport(abs, root);
         return jsonText({ directory: rel.split(path.sep).join("/") || ".", ...data });
     }
     catch (err) {
@@ -824,12 +824,12 @@ server.registerTool("check_quality_gate", {
     },
 }, async ({ path: input, baseline, updateBaseline }) => {
     try {
-        const { abs, rel } = resolveInRoot(input ?? ".");
+        const { abs, rel, root } = resolveInRoot(input ?? ".");
         if (!fs.statSync(abs).isDirectory()) {
             return errorText(`"${input}" is not a directory. check_quality_gate requires a directory.`);
         }
-        const thresholds = loadProjectConfig(ROOT).check;
-        const result = await runQualityGate(abs, ROOT, {
+        const thresholds = loadProjectConfig(root).check;
+        const result = await runQualityGate(abs, root, {
             baselinePath: baseline,
             thresholds,
             updateBaseline,
@@ -852,10 +852,10 @@ server.registerTool("get_diff", {
     },
 }, async ({ base, path: input }) => {
     try {
-        if (!isGitRepo(ROOT))
+        const { abs, rel, root } = resolveInRoot(input ?? ".");
+        if (!isGitRepo(root))
             return errorText("Not a git repository (or git is unavailable).");
-        const { abs, rel } = resolveInRoot(input ?? ".");
-        const data = await computeDiff(abs, ROOT, base ?? "HEAD");
+        const data = await computeDiff(abs, root, base ?? "HEAD");
         return jsonText({ directory: rel.split(path.sep).join("/") || ".", ...data });
     }
     catch (err) {
@@ -873,10 +873,10 @@ server.registerTool("get_risk_map", {
     },
 }, async ({ path: input }) => {
     try {
-        if (!isGitRepo(ROOT))
+        const { abs, rel, root } = resolveInRoot(input ?? ".");
+        if (!isGitRepo(root))
             return errorText("Not a git repository (or git is unavailable).");
-        const { abs, rel } = resolveInRoot(input ?? ".");
-        const files = await computeRisk(abs, ROOT);
+        const files = await computeRisk(abs, root);
         return jsonText({ directory: rel.split(path.sep).join("/") || ".", count: files.length, files: files.slice(0, 50) });
     }
     catch (err) {
@@ -896,11 +896,11 @@ server.registerTool("pack_context", {
     },
 }, async ({ path: input, symbol, scan }) => {
     try {
-        const { abs, rel } = resolveInRoot(input);
+        const { abs, rel, root } = resolveInRoot(input);
         if (fs.statSync(abs).isDirectory())
             return errorText(`"${input}" is a directory; pass a file.`);
-        const scanAbs = scan ? resolveInRoot(scan).abs : ROOT;
-        const pack = await packContext(abs, rel.split(path.sep).join("/"), ROOT, symbol, scanAbs);
+        const scanAbs = scan ? resolveInRoot(scan).abs : root;
+        const pack = await packContext(abs, rel.split(path.sep).join("/"), root, symbol, scanAbs);
         return jsonText(pack);
     }
     catch (err) {
@@ -918,7 +918,7 @@ server.registerTool("get_coupling", {
     },
 }, async ({ path: input }) => {
     try {
-        const { abs, rel } = resolveInRoot(input ?? ".");
+        const { abs, rel, root } = resolveInRoot(input ?? ".");
         if (!fs.statSync(abs).isDirectory()) {
             return errorText(`"${input}" is not a directory. get_coupling requires a directory.`);
         }
@@ -926,13 +926,13 @@ server.registerTool("get_coupling", {
         const files = collectSourceFiles(abs, opts);
         const skels = [];
         for (const f of files) {
-            const r = path.relative(ROOT, f).split(path.sep).join("/");
+            const r = path.relative(root, f).split(path.sep).join("/");
             try {
                 skels.push(await buildSkeleton(f, r, opts));
             }
             catch { /* skip */ }
         }
-        const metrics = computeCoupling(buildSymbolGraph(skels, ROOT));
+        const metrics = computeCoupling(buildSymbolGraph(skels, root));
         return jsonText({ directory: rel.split(path.sep).join("/") || ".", count: metrics.length, files: metrics });
     }
     catch (err) {
@@ -952,7 +952,7 @@ server.registerTool("get_layer_violations", {
     },
 }, async ({ path: input, minGap }) => {
     try {
-        const { abs, rel } = resolveInRoot(input ?? ".");
+        const { abs, rel, root } = resolveInRoot(input ?? ".");
         if (!fs.statSync(abs).isDirectory()) {
             return errorText(`"${input}" is not a directory. get_layer_violations requires a directory.`);
         }
@@ -960,13 +960,13 @@ server.registerTool("get_layer_violations", {
         const files = collectSourceFiles(abs, opts);
         const skels = [];
         for (const f of files) {
-            const r = path.relative(ROOT, f).split(path.sep).join("/");
+            const r = path.relative(root, f).split(path.sep).join("/");
             try {
                 skels.push(await buildSkeleton(f, r, opts));
             }
             catch { /* skip */ }
         }
-        const violations = findLayerViolations(buildSymbolGraph(skels, ROOT), minGap ?? 0);
+        const violations = findLayerViolations(buildSymbolGraph(skels, root), minGap ?? 0);
         return jsonText({ directory: rel.split(path.sep).join("/") || ".", count: violations.length, violations });
     }
     catch (err) {
@@ -985,7 +985,7 @@ server.registerTool("get_module_coupling", {
     },
 }, async ({ path: input }) => {
     try {
-        const { abs, rel } = resolveInRoot(input ?? ".");
+        const { abs, rel, root } = resolveInRoot(input ?? ".");
         if (!fs.statSync(abs).isDirectory()) {
             return errorText(`"${input}" is not a directory. get_module_coupling requires a directory.`);
         }
@@ -993,13 +993,13 @@ server.registerTool("get_module_coupling", {
         const files = collectSourceFiles(abs, opts);
         const skels = [];
         for (const f of files) {
-            const r = path.relative(ROOT, f).split(path.sep).join("/");
+            const r = path.relative(root, f).split(path.sep).join("/");
             try {
                 skels.push(await buildSkeleton(f, r, opts));
             }
             catch { /* skip */ }
         }
-        const mc = computeModuleCoupling(buildSymbolGraph(skels, ROOT));
+        const mc = computeModuleCoupling(buildSymbolGraph(skels, root));
         return jsonText({ directory: rel.split(path.sep).join("/") || ".", moduleCount: mc.modules.length, ...mc });
     }
     catch (err) {
@@ -1025,7 +1025,7 @@ server.registerTool("get_change_impact", {
     },
 }, async ({ path: input, symbol, scanDir }) => {
     try {
-        const { abs, rel } = resolveInRoot(input);
+        const { abs, rel, root } = resolveInRoot(input);
         if (fs.statSync(abs).isDirectory()) {
             return errorText(`"${input}" is a directory. Provide a single file path.`);
         }
@@ -1034,7 +1034,7 @@ server.registerTool("get_change_impact", {
         const files = collectSourceFiles(scanRoot, opts);
         const skeletons = [];
         for (const file of files) {
-            const fileRel = path.relative(ROOT, file).split(path.sep).join("/");
+            const fileRel = path.relative(root, file).split(path.sep).join("/");
             try {
                 skeletons.push(await buildSkeleton(file, fileRel, opts));
             }
@@ -1042,7 +1042,7 @@ server.registerTool("get_change_impact", {
                 // skip parse errors
             }
         }
-        const graph = buildSymbolGraph(skeletons, ROOT);
+        const graph = buildSymbolGraph(skeletons, root);
         const targetNodeId = `${rel.split(path.sep).join("/")}::${symbol}`;
         const impact = getChangeImpact(graph, targetNodeId);
         if (!impact) {
@@ -1076,7 +1076,7 @@ server.registerTool("get_call_graph", {
     },
 }, async ({ path: input, function: funcName, scanDir }) => {
     try {
-        const { abs, rel } = resolveInRoot(input);
+        const { abs, rel, root } = resolveInRoot(input);
         if (fs.statSync(abs).isDirectory()) {
             return errorText(`"${input}" is a directory. Provide a single file path.`);
         }
@@ -1086,7 +1086,7 @@ server.registerTool("get_call_graph", {
         const files = collectSourceFiles(scanRoot, opts);
         const skeletons = [];
         for (const file of files) {
-            const fileRel = path.relative(ROOT, file).split(path.sep).join("/");
+            const fileRel = path.relative(root, file).split(path.sep).join("/");
             try {
                 skeletons.push(await buildSkeleton(file, fileRel, opts));
             }
@@ -1094,7 +1094,7 @@ server.registerTool("get_call_graph", {
                 // skip
             }
         }
-        const result = await buildCallGraph(abs, funcName, ROOT, skeletons);
+        const result = await buildCallGraph(abs, funcName, root, skeletons);
         if (!result) {
             return errorText(`Function "${funcName}" not found in "${rel}", or the file language is unsupported.`);
         }
@@ -1130,11 +1130,11 @@ server.registerTool("search_symbol", {
     },
 }, async ({ path: input, name, matchType, kind, exportedOnly }) => {
     try {
-        const { abs, rel } = resolveInRoot(input);
+        const { abs, rel, root } = resolveInRoot(input);
         if (!fs.statSync(abs).isDirectory()) {
             return errorText(`"${input}" is not a directory. search_symbol requires a directory.`);
         }
-        const matches = await searchSymbols(abs, name, ROOT, { matchType, kind, exportedOnly });
+        const matches = await searchSymbols(abs, name, root, { matchType, kind, exportedOnly });
         return jsonText({
             directory: rel.split(path.sep).join("/"),
             pattern: name,
@@ -1162,7 +1162,7 @@ server.registerTool("get_file_deps", {
     },
 }, async ({ path: input, scanDir }) => {
     try {
-        const { abs, rel } = resolveInRoot(input);
+        const { abs, rel, root } = resolveInRoot(input);
         if (fs.statSync(abs).isDirectory()) {
             return errorText(`"${input}" is a directory. Provide a single file path.`);
         }
@@ -1171,13 +1171,13 @@ server.registerTool("get_file_deps", {
         const files = collectSourceFiles(scanRoot, opts);
         const skeletons = [];
         for (const file of files) {
-            const fileRel = path.relative(ROOT, file).split(path.sep).join("/");
+            const fileRel = path.relative(root, file).split(path.sep).join("/");
             try {
                 skeletons.push(await buildSkeleton(file, fileRel, opts));
             }
             catch { /* skip */ }
         }
-        const graph = buildSymbolGraph(skeletons, ROOT);
+        const graph = buildSymbolGraph(skeletons, root);
         const fileId = rel.split(path.sep).join("/");
         const result = getFileDeps(graph, fileId);
         if (!result) {
@@ -1210,7 +1210,7 @@ server.registerTool("get_top_symbols", {
     },
 }, async ({ path: input, limit }) => {
     try {
-        const { abs, rel } = resolveInRoot(input);
+        const { abs, rel, root } = resolveInRoot(input);
         if (!fs.statSync(abs).isDirectory()) {
             return errorText(`"${input}" is not a directory. get_top_symbols requires a directory.`);
         }
@@ -1218,13 +1218,13 @@ server.registerTool("get_top_symbols", {
         const files = collectSourceFiles(abs, opts);
         const skeletons = [];
         for (const file of files) {
-            const fileRel = path.relative(ROOT, file).split(path.sep).join("/");
+            const fileRel = path.relative(root, file).split(path.sep).join("/");
             try {
                 skeletons.push(await buildSkeleton(file, fileRel, opts));
             }
             catch { /* skip */ }
         }
-        const graph = buildSymbolGraph(skeletons, ROOT);
+        const graph = buildSymbolGraph(skeletons, root);
         const top = getTopSymbols(graph, limit ?? 10);
         return jsonText({
             directory: rel.split(path.sep).join("/"),
@@ -1313,7 +1313,8 @@ async function main() {
     const transport = new StdioServerTransport();
     await server.connect(transport);
     // stderr is safe for logging; stdout is reserved for the MCP protocol.
-    process.stderr.write(`universal-ast-mapper running. root=${ROOT}\n`);
+    process.stderr.write(`universal-ast-mapper running. roots=${ROOTS.roots.join(path.delimiter)}` +
+        (ROOTS.unlocked ? " (UNLOCKED: any absolute path allowed)" : "") + "\n");
 }
 main().catch((err) => {
     process.stderr.write(`Fatal: ${err instanceof Error ? err.stack : String(err)}\n`);

package/dist/resolver.js

@@ -5,6 +5,7 @@ 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("(");
@@ -46,6 +47,10 @@ export function resolveImportPath(importFrom, fromAbs) {
                 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())
@@ -64,6 +69,28 @@ export function resolveImportPath(importFrom, fromAbs) {
     }
     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
@@ -124,6 +151,8 @@ 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;

package/dist/roots.js

@@ -0,0 +1,47 @@
+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/tsconfig.js

@@ -0,0 +1,212 @@
+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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "universal-ast-mapper",
-  "version": "1.22.1",
+  "version": "1.24.0",
   "description": "MCP server that maps source files into a normalized code skeleton (JSON + HTML) using tree-sitter.",
   "type": "module",
   "main": "dist/index.js",
@@ -19,7 +19,7 @@
     "build": "tsc",
     "start": "node dist/index.js",
     "smoke": "node test/smoke.mjs",
-    "test": "node test/smoke.mjs && node test/analysis.mjs && node test/cache-smoke.mjs && node test/check-smoke.mjs",
+    "test": "node test/smoke.mjs && node test/analysis.mjs && node test/cache-smoke.mjs && node test/check-smoke.mjs && node test/roots-smoke.mjs && node test/tsalias-smoke.mjs",
     "postinstall": "node scripts/install-skill.mjs"
   },
   "engines": {