universal-ast-mapper 1.13.0 → 1.19.0

package/CHANGELOG.md

@@ -6,6 +6,66 @@ since 1.0.0, guarantees a stable MCP tool / CLI surface across the 1.x line.
 
 ---
 
+## [1.19.0] — 2026-06-09 · Dashboard: coupling + SDP
+- The health dashboard (`ast-map report` / `get_codebase_report`) now surfaces the
+  v1.14–1.16 architecture metrics: a **Module coupling** card (per-directory instability
+  bars with Ca/Ce) and a **Layer violations** card (stable→volatile SDP inversions),
+  plus an **SDP violations** stat tile.
+- SDP violations now factor into the health score (small capped penalty), so a codebase
+  that systematically depends "uphill" on the stability gradient scores lower.
+- `ReportData` gains `layerViolations` and `modules`; purely additive.
+- Tests: 4 new assertions (131 total) — report carries the new data and the HTML renders
+  both cards.
+
+## [1.18.0] — 2026-06-09 · Vue & Svelte SFC support
+- `.vue` and `.svelte` **single-file components** are now first-class inputs. The
+  `<script>` / `<script setup>` block is lifted out and parsed with the TS/JS extractor
+  (grammar chosen from `lang="ts"`), so component symbols and imports are extracted and
+  wired into the dependency graph — including edges from a component into a plain `.ts`
+  module, and into other components.
+- Offsets are preserved: everything outside the script is blank-padded, so every symbol
+  range still points at the exact line/column in the original SFC.
+- New languages `vue` and `svelte` (extensions `.vue`, `.svelte`); resolver now resolves
+  imports of `.vue` / `.svelte` files. **14 languages.**
+- Tests: 8 new assertions (127 total) + Vue/Svelte fixtures — symbol extraction, import
+  capture, and cross-file graph edges for both.
+
+## [1.17.0] — 2026-06-09 · MCP prompts
+- The server now registers **MCP prompts** — named, parameterized workflows a client
+  can invoke from its prompt/slash menu, each returning a ready-to-run instruction that
+  chains the right tools: `architecture_audit` (dir?), `safe_refactor` (file, symbol),
+  `dead_code_cleanup` (dir?), `health_check` (dir?), `onboard_codebase` (dir?).
+- The Cookbook recipes become first-class, discoverable, and one call away — no pasting.
+- New `test/prompts-smoke.mjs` (12 checks): `prompts/list` returns all 5, argument
+  interpolation works, and rendered prompts reference real tools. Wired into CI.
+
+## [1.16.0] — 2026-06-09 · Module coupling
+- **`get_module_coupling`** + **`ast-map modules`** (alias `mods`): aggregates the
+  file-level import graph up to the **directory/module level** — per-module afferent
+  (Ca) / efferent (Ce) coupling and instability, plus the weighted inter-module edges.
+  Intra-module imports (files importing siblings in the same directory) are ignored;
+  only cross-module dependencies count. The architectural view above per-file coupling.
+- Tests: 5 new assertions (119 total) — a three-module ui→api→core gradient with the
+  expected stability ordering and edge count.
+
+## [1.15.0] — 2026-06-09 · Layer-violation detection
+- **`get_layer_violations`** + **`ast-map layers`** (alias `sdp`): detect violations of
+  Robert C. Martin's **Stable Dependencies Principle** — a stable file (low instability)
+  that imports a more volatile one (high instability). Such dependencies point "uphill"
+  on the stability gradient and drag stable code along every time the volatile file churns.
+  Sorted by severity (the instability gap crossed). `minGap` filters small gaps.
+- Builds directly on the v1.14.0 coupling metrics.
+- Tests: 5 new assertions (114 total) — clean fixture yields none, a synthetic
+  stable→volatile graph yields exactly one with the correct severity.
+
+## [1.14.0] — 2026-06-09 · Coupling metrics
+- **`get_coupling`** + **`ast-map coupling [dir]`**: Robert C. Martin's per-file
+  coupling metrics — afferent coupling (Ca, fan-in), efferent coupling (Ce,
+  fan-out), and instability I = Ce/(Ca+Ce). High-Ca files are load-bearing (break
+  carefully); high-instability files change freely. Derived from the import graph.
+- Tests: 4 new assertions (109 total) verifying stable/unstable/middle files and
+  the [0,1] instability bound.
+
 ## [1.13.0] — 2026-06-08 · Context-pack
 - **`pack_context`** + **`ast-map pack <file> [symbol]`**: the minimal context to
   work on a symbol — its source, the signatures it depends on, and its dependents
@@ -103,43 +163,4 @@ since 1.0.0, guarantees a stable MCP tool / CLI surface across the 1.x line.
   declared in 2+ files.
 
 ## [0.8.3] — 2026-05-31 · TSX/React component props
-- Component symbols carry `propsType` + `props[]`; detects `React.FC<P>` and
-  JSX-returning PascalCase functions. MCP server version now read from package.json.
-
-## [0.8.2] — 2026-05-30 · Swift cross-file wiring
-- `import <Module>` → that module's files (`Sources/<Module>/`). Completes
-  cross-file graph/resolver support for all four v0.8.0 languages.
-
-## [0.8.1] — 2026-05-30 · Kotlin + C/C++ cross-file wiring
-- Kotlin FQCN/package index; C/C++ `#include` resolution with header↔impl pairing.
-- Fixes: parse-cache rel-path leak; Kotlin call-graph extraction.
-
----
-
-## Earlier (pre-session history)
-
-- **0.8.0** — +4 languages: C · C++ · Kotlin · Swift (symbol extraction + imports).
-- **0.7.0** — Go full module resolution; C# reverse `calledBy`; 4-suite test harness.
-- **0.6.0** — +3 languages: Rust · Java · C#; cross-language resolver.
-- **0.5.x** — `/ast-map` skill auto-install; iterative DFS; barrel re-exports; parse cache; call-graph aliases; `.ast-map.config.json`.
-- **0.4.0** — `search_symbol`, `get_file_deps`, `get_top_symbols`, dead-code tiers.
-- **0.3.0** — CLI; `find_dead_code`, `find_circular_deps`, `get_change_impact`, `get_call_graph`.
-- **0.2.0** — import extraction; `resolve_imports`; `build_symbol_graph`.
-- **0.1.0** — `get_skeleton_json`, `generate_skeleton`, `get_symbol_context`, `validate_architecture`.
-
-[1.13.0]: https://github.com/6ixthxense/AST-MCP/releases/tag/v1.13.0
-[1.12.0]: https://github.com/6ixthxense/AST-MCP/releases/tag/v1.12.0
-[1.11.0]: https://github.com/6ixthxense/AST-MCP/releases/tag/v1.11.0
-[1.10.0]: https://github.com/6ixthxense/AST-MCP/releases/tag/v1.10.0
-[1.9.0]: https://github.com/6ixthxense/AST-MCP/releases/tag/v1.9.0
-[1.8.0]: https://github.com/6ixthxense/AST-MCP/releases/tag/v1.8.0
-[1.7.0]: https://github.com/6ixthxense/AST-MCP/releases/tag/v1.7.0
-[1.6.0]: https://github.com/6ixthxense/AST-MCP/releases/tag/v1.6.0
-[1.5.0]: https://github.com/6ixthxense/AST-MCP/releases/tag/v1.5.0
-[1.4.0]: https://github.com/6ixthxense/AST-MCP/releases/tag/v1.4.0
-[1.3.0]: https://github.com/6ixthxense/AST-MCP/releases/tag/v1.3.0
-[1.2.0]: https://github.com/6ixthxense/AST-MCP/releases/tag/v1.2.0
-[1.1.0]: https://github.com/6ixthxense/AST-MCP/releases/tag/v1.1.0
-[1.0.0]: https://github.com/6ixthxense/AST-MCP/releases/tag/v1.0.0
-[0.9.0]: https://github.com/6ixthxense/AST-MCP/releases/tag/v0.9.0
-[0.8.1]: https://github.com/6ixthxense/AST-MCP/releases/tag/v0.8.1
+- Component s

package/README.md

@@ -4,9 +4,9 @@ An **MCP server + CLI tool** that turns source code into structured, machine-rea
 
 Built on [tree-sitter](https://tree-sitter.github.io/) WASM grammars. Zero regex guessing — real AST parsing.
 
-**24 MCP tools / 25 CLI commands** spanning skeletons, dependency graphs, and deep analysis — dead code, cycles, change-impact, complexity, duplicates, unused params, type-flow, decorators — plus monorepo support, an interactive **graph explorer** (`ast-map explore`), **watch mode**, and a one-page **health dashboard** (`ast-map report`).
+**27 MCP tools / 28 CLI commands / 5 MCP prompts** spanning skeletons, dependency graphs, and deep analysis — dead code, cycles, change-impact, complexity, duplicates, unused params, type-flow, decorators — plus monorepo support, an interactive **graph explorer** (`ast-map explore`), **watch mode**, and a one-page **health dashboard** (`ast-map report`).
 
-**Supported languages:** TypeScript · TSX · JavaScript (ESM/CJS) · Python · Go · Rust · Java · C# · C · C++ · Kotlin · Swift
+**Supported languages:** TypeScript · TSX · JavaScript (ESM/CJS) · Python · Go · Rust · Java · C# · C · C++ · Kotlin · Swift · **Vue** · **Svelte** (SFC `<script>`)
 
 | Capability               | TS/JS | Python | Go  | Rust | Java | C#  | C   | C++ | Kt  | Swift |
 |--------------------------|:-----:|:------:|:---:|:----:|:----:|:---:|:---:|:---:|:---:|:-----:|
@@ -107,6 +107,9 @@ ast-map report    [dir]            [-o report.html]
 ast-map diff      [base]           [--dir <d>]   # git-aware changed symbols + impact
 ast-map risk      [dir]            [-n N]        # churn × complexity
 ast-map pack      <file> [symbol]  [--scan <d>] # minimal context pack
+ast-map coupling  [dir]            [-n N]        # Ca / Ce / instability per file
+ast-map layers    [dir]            [-g gap]      # SDP: stable→volatile violations
+ast-map modules   [dir]                          # directory-level coupling + edges
 ast-map search   <pattern> [dir]   [-m contains|exact|regex] [-k kind] [-e]
 ast-map deps     <file>            [--scan <dir>]
 ast-map top      <dir>             [-n 10]
@@ -365,7 +368,7 @@ Given a compiled JS/CSS file with an inline (`data:`) or external `sourceMapping
 ---
 
 ### `get_codebase_report`
-A one-shot **codebase health summary**: file/symbol counts, language breakdown, a health **grade (A–F)** + score, complexity hotspots, god nodes, dead exports, and circular dependencies. Rendered as a premium HTML dashboard by `ast-map report`.
+A one-shot **codebase health summary**: file/symbol counts, language breakdown, a health **grade (A–F)** + score, complexity hotspots, god nodes, dead exports, circular dependencies, **module coupling** (per-directory instability), and **layer violations** (SDP). Rendered as a premium HTML dashboard by `ast-map report`.
 
 ```json
 { "grade": "B", "score": 82, "fileCount": 120, "symbolCount": 1400,
@@ -414,6 +417,42 @@ Rank files by **refactor risk = git churn × max complexity** — the files that
 
 ---
 
+### `get_coupling`
+Per-file **coupling metrics** (Robert C. Martin): afferent coupling **Ca** (fan-in), efferent coupling **Ce** (fan-out), and **instability** I = Ce/(Ca+Ce) (0 = stable / load-bearing, 1 = unstable / volatile).
+
+```json
+{ "files": [ { "file": "src/types.ts", "afferent": 27, "efferent": 0, "instability": 0 } ] }
+```
+
+**Params:** `path` (optional)
+
+---
+
+### `get_layer_violations`
+Find dependencies that point **the wrong way on the stability gradient** — a stable file (low instability) importing a more volatile one (high instability), violating Martin's **Stable Dependencies Principle**. Sorted by severity (the instability gap crossed).
+
+```json
+{ "violations": [ { "from": "src/skeleton.ts", "to": "src/registry.ts", "fromInstability": 0.36, "toInstability": 0.6, "severity": 0.24 } ] }
+```
+
+**Params:** `path` (optional), `minGap` (optional, 0–1)
+
+---
+
+### `get_module_coupling`
+Aggregate the import graph up to the **directory/module level** — per-module Ca / Ce / instability plus the weighted inter-module edges. Intra-module imports are ignored, so this is the architectural bird's-eye view above per-file coupling.
+
+```json
+{
+  "modules": [ { "module": "src/extractors", "files": 11, "afferent": 1, "efferent": 1, "instability": 0.5 } ],
+  "edges": [ { "from": "src/extractors", "to": "src", "weight": 75 } ]
+}
+```
+
+**Params:** `path` (optional)
+
+---
+
 ### `get_change_impact`
 Given a file + symbol, reverse-traverse the import graph to compute **blast radius**.
 
@@ -644,6 +683,20 @@ Beyond tools, the server exposes the codebase as **browseable MCP resources**, s
 
 ---
 
+## MCP prompts — one-call recipes
+
+The server also registers **prompts**: named, parameterized workflows an MCP client can invoke directly (they show up in the client's prompt/slash menu). Each returns a ready-to-run instruction that chains the right tools, so you don't paste the recipe by hand.
+
+| Prompt | Args | What it does |
+|--------|------|--------------|
+| `architecture_audit` | `dir?` | God Nodes → cycles → rule violations → module coupling → SDP breaks, then a prioritized summary |
+| `safe_refactor` | `file`, `symbol` | blast radius → call graph → minimal context before changing a symbol |
+| `dead_code_cleanup` | `dir?` | unused exports, each verified zero-impact before deletion |
+| `health_check` | `dir?` | grade A–F → risk map → layer violations, with the 3 files to fix first |
+| `onboard_codebase` | `dir?` | languages → structure → core symbols → module map, as a "start here" guide |
+
+---
+
 ## GitHub Action — architecture gate in CI
 
 Use AST-MCP as a CI check with the bundled composite action (`action.yml`):
@@ -687,6 +740,12 @@ Not part of the public API: the internal `src/` module layout and the generated
 
 | Version | What changed |
 |---------|--------------|
+| **1.19.0** | **Dashboard: coupling + SDP** — `ast-map report` / `get_codebase_report` now include **module coupling** (per-directory instability bars) and **layer violations** (stable→volatile, SDP) cards, plus an SDP stat; SDP inversions also factor into the health score. The v1.14–1.16 metrics are now visual. |
+| **1.18.0** | **Vue & Svelte SFC support** — `.vue` and `.svelte` single-file components are now parsed: the `<script>` / `<script setup>` block is lifted out (TS or JS) and its symbols + imports extracted, with cross-file graph edges into plain modules. Blank-padding keeps every symbol's line numbers pointing at the original SFC. **14 languages**. |
+| **1.17.0** | **MCP prompts** — the server now registers 5 parameterized **prompts** (`architecture_audit`, `safe_refactor`, `dead_code_cleanup`, `health_check`, `onboard_codebase`): named workflows a client can invoke from its prompt menu, each chaining the right tools. The Cookbook recipes, one call away. |
+| **1.16.0** | **Module coupling** — new `get_module_coupling` MCP tool + `ast-map modules` (alias `mods`) CLI: aggregates the import graph to the **directory/module level** — per-module Ca / Ce / instability plus weighted inter-module edges (intra-module imports ignored). The bird's-eye view above per-file coupling. **27 MCP tools**. |
+| **1.15.0** | **Layer-violation detection** — new `get_layer_violations` MCP tool + `ast-map layers` (alias `sdp`) CLI: flags dependencies that break Martin's **Stable Dependencies Principle** — a stable file (low instability) importing a more volatile one — sorted by the instability gap. Builds directly on the coupling metrics. **26 MCP tools**. |
+| **1.14.0** | **Coupling metrics** — new `get_coupling` MCP tool + `ast-map coupling [dir]` CLI: per-file afferent (Ca) / efferent (Ce) coupling and **instability** I = Ce/(Ca+Ce), the way to spot load-bearing files (high Ca) vs. volatile ones (high I). **25 MCP tools**. |
 | **1.13.0** | **Context-pack** — new `pack_context` MCP tool + `ast-map pack <file> [symbol]` CLI: the minimal context to work on a symbol (its source + the signatures it depends on + its dependents) with a token estimate, instead of reading whole files. **24 MCP tools**. |
 | **1.12.0** | **Git-aware analysis** — `ast-map diff [base]` + `get_diff` tool: changed symbols since a ref, **breaking changes** (removed / signature-changed exports), and blast radius. `ast-map risk` + `get_risk_map` tool: rank files by churn × complexity. Brings a time/history dimension. **23 MCP tools**. |
 | **1.11.0** | **Code-health dashboard** — new `ast-map report` CLI writes a premium self-contained HTML overview (grade A–F, stats, language breakdown, complexity hotspots, god nodes, dead code, cycles) + `get_codebase_report` MCP tool for the same as JSON. |
@@ -709,19 +768,4 @@ Not part of the public API: the internal `src/` module layout and the generated
 | **0.9.0** | **Scoped type-flow tracing** — new `trace_type` MCP tool + `ast-map trace-type` (alias `flow`) CLI: follow a named type through function params, return types, typed variables, and class fields across a directory. Completes the deeper-analysis suite (dead code · cycles · impact · complexity · duplicates · unused params · type flow). **18 MCP tools**. |
 | **0.8.7** | **Python decorators in the call graph** — function/method symbols now carry a `decorators` field (`@router.get("/x")` → `router.get("/x")`), surfaced in skeletons (outline + full) and in `get_call_graph`. Traces framework wiring like FastAPI/Flask routes and `@staticmethod`/`@property` stacks to their handler. |
 | **0.8.6** | **Unused parameter detection** — new `find_unused_params` MCP tool + `ast-map unused-params` (alias `unused`) CLI: named functions whose params are never referenced. Skips `_`-prefixed/destructured/anonymous and treats object-shorthand as a use (low false-positive). Server now 17 tools. |
-| **0.8.5** | **Cyclomatic complexity** — new `get_complexity` MCP tool + `ast-map complexity` (alias `cx`, `--min N`) CLI: per-function AST-based complexity score (`1 + if/for/while/case/catch/ternary/&&/\|\|`) with low/moderate/high/very-high ratings and directory hotspots. Server now 16 tools. |
-| **0.8.4** | **Duplicate symbol detection** — new `find_duplicate_symbols` MCP tool + `ast-map duplicates` (alias `dupes`) CLI command: finds symbol names exported from more than one file, with every file/kind that declares each name. |
-| **0.8.3** | **TSX/React component props** — component symbols now carry extracted prop fields. PascalCase functions/arrows that return JSX or are typed `React.FC<P>`/`FC<P>` get `propsType` (named props type) + `props[]` (name, type, optional), resolved from same-file `interface`/`type` declarations or inline object types. Plus: MCP server now reports its real version from `package.json` (was hardcoded `0.5.3`). |
-| **0.8.2** | **Swift cross-file wiring** — `import <Module>` resolves to that module's files (module = the `Sources/<Module>/` directory, else parent dir), wired into `build_symbol_graph` + `resolve_imports`. System modules (Foundation, UIKit, …) stay external. Completes cross-file graph/resolver support for all four v0.8.0 languages. |
-| **0.8.1** | **Cross-file graph wiring for Kotlin & C/C++** — Kotlin FQCN/package index + C/C++ `#include` resolution (with header↔impl pairing) wired into `build_symbol_graph`, `resolve_imports`, and `get_call_graph`. Fixes a parse-cache rel-path leak (stale `.file` poisoned the cross-lang index → doubled paths) and Kotlin call-graph extraction (`function_declaration` name + field-less `call_expression`). |
-| **0.8.0** | **4 new languages: C · C++ · Kotlin · Swift** — symbol extraction + imports parsing. C++ tracks access_specifier through class bodies. Kotlin handles `package`/`object`/`data class`. Swift handles `class`/`struct`/`enum` (all under `class_declaration`) and `protocol_declaration`. Ruby grammar in tree-sitter-wasms@0.1.13 is unstable — skipped. |
-| **0.7.0** | Go full resolution (reads `go.mod`, resolves package-as-directory) · C# reverse `calledBy` via call-site scanning · `csharpTypes` index lets `using` directives resolve to specific types · 4-suite test harness (smoke + graph-smoke + resolver-smoke + callgraph-smoke) |
-| **0.6.0** | **3 new languages: Rust · Java · C#** (extractors + import parsing) · cross-language resolver in `crosslang.ts` (Java FQCN index, C# namespace index, Rust `crate::` module walk) · symbol-graph `imports` edges + `resolveFileImports` enrichment + `get_call_graph` callee resolution rewired through it · Java `package` and C# `namespace` captured as directives |
-| **0.5.3** | Auto-install `/ast-map` Claude Code skill on `npm install` · `postinstall` writes `~/.claude/skills/ast-map/SKILL.md` + registers trigger in `CLAUDE.md` (idempotent, CI-safe) |
-| **0.5.2** | Iterative DFS in `findCircularDeps` (eliminates stack overflow on large codebases) · `build_symbol_graph` inline size guard (>2000 nodes → stats + warning) · integration test suite (`test/analysis.mjs`) |
-| **0.5.1** | Re-export tracking (`export { X } from './foo'`, barrel files) · `export const` surfaced as symbols · `const X = class {}` support · Python relative import fix · parser instance cache |
-| **0.5.0** | Call graph destructuring aliases · in-process parse cache · `.ast-map.config.json` · general validation rules (large-file, too-many-imports, god-export) |
-| **0.4.0** | `search_symbol` · `get_file_deps` · `get_top_symbols` · dead code confidence tiers · 3 new CLI commands |
-| **0.3.0** | `ast-map` CLI · `find_dead_code` · `find_circular_deps` · `get_change_impact` · `get_call_graph` |
-| **0.2.0** | Import extraction · `resolve_imports` · `build_symbol_graph` |
-| **0.1.0** | `get_skeleton_json` · `generate_skeleton` · `get_symbol_context` · `validate_architecture` |
+| **0.8.5** | **Cyclomatic complexity** — new `get_complexity` MCP tool + `ast-map complex

package/dist/cli.js

@@ -19,6 +19,9 @@ import { readSourceMap } from "./sourcemap.js";
 import { buildReport, buildReportHtml } from "./report.js";
 import { computeDiff, computeRisk, isGitRepo } from "./gitdiff.js";
 import { packContext } from "./contextpack.js";
+import { computeCoupling } from "./coupling.js";
+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());
@@ -543,6 +546,89 @@ program
     table(files.slice(0, opts.top).map((f) => [String(f.risk), `${f.churn} × ${f.maxComplexity}`, f.file]), [["Risk", 7], ["churn×cx", 12], ["File", 44]]);
     console.log();
 });
+// ─── Command: coupling ────────────────────────────────────────────────────────
+program
+    .command("coupling [dir]")
+    .description("Per-file coupling metrics: afferent (Ca), efferent (Ce), instability")
+    .option("--json", "Output as JSON")
+    .option("-n, --top <n>", "Show top N by total coupling", (v) => parseInt(v, 10), 25)
+    .action(async (dir, opts) => {
+    const { abs, rel } = resolveArg(dir ?? ".");
+    if (!fs.statSync(abs).isDirectory())
+        die(`"${rel}" is not a directory`);
+    const skeletons = await gatherSkeletons(abs);
+    const metrics = computeCoupling(buildSymbolGraph(skeletons, ROOT));
+    if (opts.json)
+        return jsonOut({ count: metrics.length, files: metrics });
+    header(`Coupling \u2014 ${rel}/  ${dim("(Ca = fan-in, Ce = fan-out, I = instability)")}`);
+    if (metrics.length === 0) {
+        console.log(indent(dim("No import edges found.")));
+        console.log();
+        return;
+    }
+    const icolor = (i) => (i >= 0.8 ? red : i <= 0.2 ? green : yellow);
+    table(metrics.slice(0, opts.top).map((m) => [String(m.afferent), String(m.efferent), icolor(m.instability)(m.instability.toFixed(2)), m.file]), [["Ca", 4], ["Ce", 4], ["I", 6], ["File", 46]]);
+    console.log(indent(dim("high Ca = load-bearing (break carefully) · high I = volatile")));
+    console.log();
+});
+// ─── Command: layers ──────────────────────────────────────────────────────────
+program
+    .command("layers [dir]")
+    .alias("sdp")
+    .description("Stable Dependencies Principle: stable files that depend on volatile ones")
+    .option("--json", "Output as JSON")
+    .option("-g, --min-gap <n>", "Only show violations with instability gap > n", (v) => parseFloat(v), 0)
+    .action(async (dir, opts) => {
+    const { abs, rel } = resolveArg(dir ?? ".");
+    if (!fs.statSync(abs).isDirectory())
+        die(`"${rel}" is not a directory`);
+    const skeletons = await gatherSkeletons(abs);
+    const violations = findLayerViolations(buildSymbolGraph(skeletons, ROOT), opts.minGap);
+    if (opts.json)
+        return jsonOut({ count: violations.length, violations });
+    header(`Layer Violations \u2014 ${rel}/  ${dim("(stable \u2192 volatile dependencies, SDP)")}`);
+    if (violations.length === 0) {
+        console.log(indent(green("\u2713 No SDP violations \u2014 dependencies flow toward stability.")));
+        console.log();
+        return;
+    }
+    for (const v of violations) {
+        const sev = v.severity >= 0.4 ? red : v.severity >= 0.2 ? yellow : dim;
+        console.log(indent(`${sev(v.severity.toFixed(2))}  ${bold(v.from)} ${dim(`(I=${v.fromInstability})`)} ${red("\u2192")} ${v.to} ${dim(`(I=${v.toInstability})`)}`));
+    }
+    console.log();
+    console.log(indent(dim(`${violations.length} stable file(s) depend on more volatile ones \u2014 they churn when those do`)));
+    console.log();
+});
+// ─── Command: modules ─────────────────────────────────────────────────────────
+program
+    .command("modules [dir]")
+    .alias("mods")
+    .description("Directory/module-level coupling: per-module Ca / Ce / instability + edges")
+    .option("--json", "Output as JSON")
+    .action(async (dir, opts) => {
+    const { abs, rel } = resolveArg(dir ?? ".");
+    if (!fs.statSync(abs).isDirectory())
+        die(`"${rel}" is not a directory`);
+    const skeletons = await gatherSkeletons(abs);
+    const mc = computeModuleCoupling(buildSymbolGraph(skeletons, ROOT));
+    if (opts.json)
+        return jsonOut(mc);
+    header(`Module Coupling \u2014 ${rel}/  ${dim("(directory-level Ca / Ce / instability)")}`);
+    if (mc.modules.length === 0) {
+        console.log(indent(dim("No cross-module imports found.")));
+        console.log();
+        return;
+    }
+    const icolor = (i) => (i >= 0.8 ? red : i <= 0.2 ? green : yellow);
+    table(mc.modules.map((m) => [String(m.files), String(m.afferent), String(m.efferent), icolor(m.instability)(m.instability.toFixed(2)), m.module]), [["Files", 6], ["Ca", 4], ["Ce", 4], ["I", 6], ["Module", 40]]);
+    if (mc.edges.length) {
+        console.log(indent(bold("Inter-module dependencies:")));
+        for (const e of mc.edges.slice(0, 20))
+            console.log(indent(`  ${e.from} ${dim("\u2192")} ${e.to} ${dim(`(${e.weight})`)}`));
+    }
+    console.log();
+});
 // ─── Command: report ──────────────────────────────────────────────────────────
 program
     .command("report [dir]")

package/dist/coupling.js

@@ -0,0 +1,35 @@
+/**
+ * Compute Robert C. Martin's coupling metrics per file from the symbol graph's
+ * file-level import edges: afferent (fan-in), efferent (fan-out), and instability.
+ */
+export function computeCoupling(graph) {
+    const nodeMap = new Map(graph.nodes.map((n) => [n.id, n]));
+    const out = new Map(); // file -> set of files it imports
+    const inc = new Map(); // file -> set of files that import it
+    const files = new Set();
+    for (const n of graph.nodes)
+        if (n.nodeType === "file")
+            files.add(n.id);
+    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;
+        const fromFile = e.from;
+        if (!toFile || fromFile === toFile)
+            continue;
+        files.add(fromFile);
+        files.add(toFile);
+        (out.get(fromFile) ?? out.set(fromFile, new Set()).get(fromFile)).add(toFile);
+        (inc.get(toFile) ?? inc.set(toFile, new Set()).get(toFile)).add(fromFile);
+    }
+    const metrics = [];
+    for (const f of files) {
+        const ce = out.get(f)?.size ?? 0;
+        const ca = inc.get(f)?.size ?? 0;
+        const instability = ca + ce === 0 ? 0 : Math.round((ce / (ca + ce)) * 100) / 100;
+        metrics.push({ file: f, afferent: ca, efferent: ce, instability });
+    }
+    // Sort by total coupling desc (most-connected first).
+    return metrics.sort((a, b) => (b.afferent + b.efferent) - (a.afferent + a.efferent) || a.file.localeCompare(b.file));
+}

package/dist/graph.js

@@ -27,7 +27,9 @@ function isPathBasedLanguage(language) {
     return (language === "typescript" ||
         language === "tsx" ||
         language === "javascript" ||
-        language === "python");
+        language === "python" ||
+        language === "vue" ||
+        language === "svelte");
 }
 // Wire one TS/JS/Python-style relative import.
 function wirePathImport(skel, imp, fromFileAbs, root, exportedSymbolMap, edges) {

package/dist/index.js

@@ -23,6 +23,10 @@ import { readSourceMap } from "./sourcemap.js";
 import { buildReport } from "./report.js";
 import { computeDiff, computeRisk, isGitRepo } from "./gitdiff.js";
 import { packContext } from "./contextpack.js";
+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());
 function resolveInRoot(input) {
@@ -67,6 +71,7 @@ const server = new McpServer({
     name: "universal-ast-mapper",
     version: PKG_VERSION,
 });
+registerPrompts(server);
 /* ----------------------- tool: list_supported_languages ----------------------- */
 server.registerTool("list_supported_languages", {
     title: "List supported languages",
@@ -859,6 +864,105 @@ server.registerTool("pack_context", {
         return errorText(describeError(err));
     }
 });
+/* ─────────────────── tool: get_coupling ────────────────────────────────── */
+server.registerTool("get_coupling", {
+    title: "Coupling metrics (afferent / efferent / instability)",
+    description: "Compute Robert C. Martin's coupling metrics per file from the import graph: afferent coupling " +
+        "(Ca, fan-in), efferent coupling (Ce, fan-out), and instability I = Ce/(Ca+Ce) (0 = stable, " +
+        "1 = unstable). High-Ca files are load-bearing; high-instability files change freely.",
+    inputSchema: {
+        path: z.string().optional().describe("Directory to scan. Default project root."),
+    },
+}, async ({ path: input }) => {
+    try {
+        const { abs, rel } = resolveInRoot(input ?? ".");
+        if (!fs.statSync(abs).isDirectory()) {
+            return errorText(`"${input}" is not a directory. get_coupling requires a directory.`);
+        }
+        const opts = resolveOptions({ detail: "outline", emitHtml: false });
+        const files = collectSourceFiles(abs, opts);
+        const skels = [];
+        for (const f of files) {
+            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));
+        return jsonText({ directory: rel.split(path.sep).join("/") || ".", count: metrics.length, files: metrics });
+    }
+    catch (err) {
+        return errorText(describeError(err));
+    }
+});
+/* ─────────────────── tool: get_layer_violations ────────────────────────── */
+server.registerTool("get_layer_violations", {
+    title: "Layer violations (Stable Dependencies Principle)",
+    description: "Find dependencies that point the wrong way on the stability gradient: a stable file " +
+        "(low instability) that imports a more volatile file (high instability). Per Robert C. Martin's " +
+        "Stable Dependencies Principle, stable code should not depend on volatile code — it gets dragged " +
+        "along every time the volatile file churns. Results are sorted by severity (the instability gap).",
+    inputSchema: {
+        path: z.string().optional().describe("Directory to scan. Default project root."),
+        minGap: z.number().optional().describe("Only report violations whose instability gap exceeds this (0-1). Default 0."),
+    },
+}, async ({ path: input, minGap }) => {
+    try {
+        const { abs, rel } = resolveInRoot(input ?? ".");
+        if (!fs.statSync(abs).isDirectory()) {
+            return errorText(`"${input}" is not a directory. get_layer_violations requires a directory.`);
+        }
+        const opts = resolveOptions({ detail: "outline", emitHtml: false });
+        const files = collectSourceFiles(abs, opts);
+        const skels = [];
+        for (const f of files) {
+            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);
+        return jsonText({ directory: rel.split(path.sep).join("/") || ".", count: violations.length, violations });
+    }
+    catch (err) {
+        return errorText(describeError(err));
+    }
+});
+/* ─────────────────── tool: get_module_coupling ─────────────────────────── */
+server.registerTool("get_module_coupling", {
+    title: "Module coupling (directory-level Ca / Ce / instability)",
+    description: "Aggregate the import graph up to the directory/module level: per-module afferent (Ca) / " +
+        "efferent (Ce) coupling and instability, plus the weighted inter-module edges. Intra-module " +
+        "imports (files importing siblings in the same directory) are ignored — only cross-module " +
+        "dependencies count. The architectural bird's-eye view above per-file coupling.",
+    inputSchema: {
+        path: z.string().optional().describe("Directory to scan. Default project root."),
+    },
+}, async ({ path: input }) => {
+    try {
+        const { abs, rel } = resolveInRoot(input ?? ".");
+        if (!fs.statSync(abs).isDirectory()) {
+            return errorText(`"${input}" is not a directory. get_module_coupling requires a directory.`);
+        }
+        const opts = resolveOptions({ detail: "outline", emitHtml: false });
+        const files = collectSourceFiles(abs, opts);
+        const skels = [];
+        for (const f of files) {
+            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));
+        return jsonText({ directory: rel.split(path.sep).join("/") || ".", moduleCount: mc.modules.length, ...mc });
+    }
+    catch (err) {
+        return errorText(describeError(err));
+    }
+});
 /* ─────────────────── tool: get_change_impact ───────────────────────────── */
 server.registerTool("get_change_impact", {
     title: "Get change impact (blast radius)",

package/dist/layers.js

@@ -0,0 +1,36 @@
+import { computeCoupling } from "./coupling.js";
+/**
+ * Detect violations of Robert C. Martin's Stable Dependencies Principle (SDP):
+ * a module should depend only on modules at least as stable as itself. A "stable"
+ * file (low instability) that imports a "volatile" file (high instability) is a
+ * violation — volatile code changes often and will keep dragging the stable code
+ * with it. Severity is the instability gap the dependency crosses.
+ */
+export function findLayerViolations(graph, minGap = 0) {
+    const inst = new Map(computeCoupling(graph).map((m) => [m.file, m.instability]));
+    const nodeMap = new Map(graph.nodes.map((n) => [n.id, n]));
+    const seen = new Set();
+    const violations = [];
+    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;
+        const fromFile = e.from;
+        if (!toFile || fromFile === toFile)
+            continue;
+        const fi = inst.get(fromFile);
+        const ti = inst.get(toFile);
+        if (fi === undefined || ti === undefined)
+            continue;
+        const severity = Math.round((ti - fi) * 100) / 100;
+        if (severity <= minGap)
+            continue; // only "uphill" dependencies (stable -> volatile)
+        const key = fromFile + " " + toFile;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        violations.push({ from: fromFile, to: toFile, fromInstability: fi, toInstability: ti, severity });
+    }
+    return violations.sort((a, b) => b.severity - a.severity || a.from.localeCompare(b.from));
+}

package/dist/prompts.js

@@ -0,0 +1,67 @@
+import { z } from "zod";
+/** GetPromptResult helper — a single user-role text message. */
+function userPrompt(text) {
+    return { messages: [{ role: "user", content: { type: "text", text } }] };
+}
+const dirArg = { dir: z.string().optional().describe("Directory to analyze, relative to the project root. Default 'src'.") };
+const d = (dir) => (dir && dir.trim() ? dir.trim() : "src");
+/**
+ * Register the Cookbook recipes as MCP prompts so clients can invoke a whole
+ * AST-MCP workflow (a chain of tool calls) by name, instead of the user pasting
+ * the recipe text. Each prompt returns a ready-to-run instruction that references
+ * the server's own tools.
+ */
+export function registerPrompts(server) {
+    server.registerPrompt("architecture_audit", {
+        title: "Architecture audit",
+        description: "Full structural audit of a directory: God Nodes, cycles, rule violations, and module coupling.",
+        argsSchema: dirArg,
+    }, ({ dir }) => userPrompt(`Run a full architecture audit of \`${d(dir)}\` using the ast-mapper tools, in this order:\n\n` +
+        `1. \`build_symbol_graph\` on \`${d(dir)}\` to load the dependency graph.\n` +
+        `2. \`get_top_symbols\` — identify the 5 most-imported symbols (the "God Nodes").\n` +
+        `3. \`find_circular_deps\` — report any circular import chains.\n` +
+        `4. \`validate_architecture\` — list structural rule violations (large files, too many imports, god exports).\n` +
+        `5. \`get_module_coupling\` — which directories are load-bearing (high Ca) vs. volatile (high I)?\n` +
+        `6. \`get_layer_violations\` — any stable code depending on volatile code (SDP breaks)?\n\n` +
+        `Then write a short prioritized summary: the top 3 architectural risks and a concrete first step for each.`));
+    server.registerPrompt("safe_refactor", {
+        title: "Safe refactor checklist",
+        description: "Everything you need to know before changing a specific symbol: blast radius, callees, and minimal context.",
+        argsSchema: {
+            file: z.string().describe("File containing the symbol, relative to the project root."),
+            symbol: z.string().describe("Name of the function/class/symbol you intend to change."),
+        },
+    }, ({ file, symbol }) => userPrompt(`Before refactoring \`${symbol}\` in \`${file}\`, gather the impact using the ast-mapper tools:\n\n` +
+        `1. \`get_change_impact\` for \`${file}\` / \`${symbol}\` — who depends on it (the blast radius)?\n` +
+        `2. \`get_call_graph\` — what does \`${symbol}\` call, and what calls it?\n` +
+        `3. \`pack_context\` for \`${file}\` / \`${symbol}\` — the minimal context (its source + the signatures it depends on).\n\n` +
+        `Then summarize: what will break if the signature changes, which call sites need updating, and a safe step-by-step refactor order.`));
+    server.registerPrompt("dead_code_cleanup", {
+        title: "Dead-code cleanup",
+        description: "Find unused exports and verify each is safe to delete before removing it.",
+        argsSchema: dirArg,
+    }, ({ dir }) => userPrompt(`Help me remove dead code from \`${d(dir)}\` using the ast-mapper tools:\n\n` +
+        `1. \`find_dead_code\` on \`${d(dir)}\` — list exported symbols nobody imports.\n` +
+        `2. For each HIGH-confidence result, double-check with \`get_change_impact\` (should be empty).\n` +
+        `3. Before suggesting deletion, show the symbol's source with \`get_symbol_context\`.\n\n` +
+        `Produce a deletion checklist: only symbols that are high-confidence AND have zero impact. Flag anything dynamic (string-referenced, re-exported) as "verify manually".`));
+    server.registerPrompt("health_check", {
+        title: "Codebase health check",
+        description: "A one-pass health report: overall grade, riskiest files, and stability inversions.",
+        argsSchema: dirArg,
+    }, ({ dir }) => userPrompt(`Give me a health check of \`${d(dir)}\` using the ast-mapper tools:\n\n` +
+        `1. \`get_codebase_report\` on \`${d(dir)}\` — overall grade A–F, hotspots, god nodes, dead code, cycles.\n` +
+        `2. \`get_risk_map\` — the files with the highest churn × complexity (best refactor / test targets).\n` +
+        `3. \`get_layer_violations\` — stable files depending on volatile ones.\n\n` +
+        `Summarize as: the grade, the single biggest problem, and the 3 files I should touch first to improve it.`));
+    server.registerPrompt("onboard_codebase", {
+        title: "Onboard to a codebase",
+        description: "Get oriented in an unfamiliar directory: languages, structure, the core symbols, and how modules connect.",
+        argsSchema: dirArg,
+    }, ({ dir }) => userPrompt(`I'm new to this codebase. Walk me through \`${d(dir)}\` using the ast-mapper tools:\n\n` +
+        `1. \`list_supported_languages\` then \`generate_skeleton\` on \`${d(dir)}\` — what languages and overall shape?\n` +
+        `2. \`get_top_symbols\` — the most-depended-on symbols are the concepts to learn first.\n` +
+        `3. \`get_module_coupling\` — how do the directories relate; what's the stable core?\n` +
+        `4. For the top God Node, \`get_symbol_context\` with related symbols to see how it's used.\n\n` +
+        `Then write a 5-bullet "start here" orientation: what this code does, its core abstractions, and where to begin reading.`));
+}

package/dist/registry.js

@@ -16,6 +16,14 @@ const TS_ENTRY = (language, grammar) => ({
     extractDirectives: extractDirectivesTS,
     extractImports: extractImportsTS,
 });
+const SFC_ENTRY = (language) => ({
+    language,
+    grammar: "typescript", // overridden per-file after detecting lang="ts" vs js
+    extract: extractTypeScript,
+    extractDirectives: extractDirectivesTS,
+    extractImports: extractImportsTS,
+    sfc: true,
+});
 const BY_EXT = {
     ".ts": TS_ENTRY("typescript", "typescript"),
     ".mts": TS_ENTRY("typescript", "typescript"),
@@ -54,6 +62,8 @@ const BY_EXT = {
         extract: extractKotlin, extractDirectives: extractDirectivesKotlin, extractImports: extractImportsKotlin,
     },
     ".swift": { language: "swift", grammar: "swift", extract: extractSwift, extractImports: extractImportsSwift },
+    ".vue": SFC_ENTRY("vue"),
+    ".svelte": SFC_ENTRY("svelte"),
 };
 export function detectLanguage(filePath) {
     return BY_EXT[path.extname(filePath).toLowerCase()] ?? null;

package/dist/report.js

@@ -4,6 +4,8 @@ import { resolveOptions } from "./config.js";
 import { buildSymbolGraph } from "./graph.js";
 import { findDeadExports, findCircularDeps, getTopSymbols } from "./graph-analysis.js";
 import { computeFileComplexity } from "./complexity.js";
+import { findLayerViolations } from "./layers.js";
+import { computeModuleCoupling } from "./modulecoupling.js";
 function gradeFor(score) {
     if (score >= 90)
         return "A";
@@ -46,6 +48,8 @@ export async function buildReport(absDir, root) {
     const dead = findDeadExports(graph).filter((d) => d.confidence === "high");
     const cycles = findCircularDeps(graph);
     const god = getTopSymbols(graph, 8);
+    const layerViolations = findLayerViolations(graph);
+    const modules = computeModuleCoupling(graph).modules;
     hotspots.sort((a, b) => b.complexity - a.complexity);
     const veryHigh = hotspots.filter((f) => f.complexity > 20).length;
     const high = hotspots.filter((f) => f.complexity > 10 && f.complexity <= 20).length;
@@ -55,6 +59,7 @@ export async function buildReport(absDir, root) {
     score -= Math.min(22, cycles.length * 6);
     score -= Math.min(28, veryHigh * 4 + high * 1);
     score -= Math.min(12, god.filter((g) => g.importCount >= 8).length * 4);
+    score -= Math.min(10, layerViolations.length);
     score = Math.max(0, Math.round(score));
     const languages = [...langCount.entries()]
         .map(([lang, f]) => ({ lang, files: f }))
@@ -72,6 +77,8 @@ export async function buildReport(absDir, root) {
         cycles: { count: cycles.length, items: cycles.slice(0, 12).map((c) => c.cycle) },
         godNodes: god.map((g) => ({ symbol: g.symbol, file: g.file, importCount: g.importCount })),
         complexity: { average: cxN ? Math.round((cxSum / cxN) * 10) / 10 : 0, max: cxMax, hotspots: hotspots.slice(0, 12) },
+        layerViolations: { count: layerViolations.length, items: layerViolations.slice(0, 12) },
+        modules: modules.slice(0, 10),
     };
 }
 /* ─── Premium HTML dashboard ───────────────────────────────────────────────── */
@@ -84,6 +91,9 @@ function esc(s) {
 function ratingColor(r) {
     return r === "very-high" ? "#e24b4a" : r === "high" ? "#d85a30" : r === "moderate" ? "#ba7517" : "#1d9e75";
 }
+function instColor(i) {
+    return i >= 0.8 ? "#e24b4a" : i <= 0.2 ? "#1d9e75" : "#ba7517";
+}
 function statCard(label, value, accent) {
     return `<div class="stat"><div class="sv"${accent ? ` style="color:${accent}"` : ""}>${value}</div><div class="sl">${label}</div></div>`;
 }
@@ -109,6 +119,13 @@ export function buildReportHtml(d) {
     const cycles = d.cycles.count
         ? d.cycles.items.map((c) => `<div class="li"><span class="mono">${esc(c.join("  →  "))}</span></div>`).join("")
         : `<div class="ok">✓ No circular dependencies</div>`;
+    const modules = d.modules.length
+        ? d.modules.map((m) => bar(`${m.module}  ·  ${m.files} file(s)`, m.instability, 1, instColor(m.instability), `Ca ${m.afferent} · Ce ${m.efferent} · <b>I ${m.instability.toFixed(2)}</b>`)).join("")
+        : `<div class="empty">No cross-module imports.</div>`;
+    const sdp = d.layerViolations.count
+        ? d.layerViolations.items.map((v) => `<div class="li"><span class="mono">${esc(v.from)}</span><span class="dim">→ ${esc(v.to)}</span><span class="pill" style="color:${instColor(0.9)}">+${v.severity.toFixed(2)}</span></div>`).join("")
+            + (d.layerViolations.count > d.layerViolations.items.length ? `<div class="more">+${d.layerViolations.count - d.layerViolations.items.length} more…</div>` : "")
+        : `<div class="ok">✓ No stability inversions (SDP)</div>`;
     return `<!doctype html><html><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">
 <title>${esc(d.project)} — code health</title><style>
 :root{--bg:#fafaf8;--card:#fff;--bd:#e7e5df;--tx:#2b2b28;--dim:#8a8880;--soft:#f1efe9}
@@ -149,6 +166,7 @@ export function buildReportHtml(d) {
   ${statCard("Max complexity", d.complexity.max, ratingColor(d.complexity.max > 20 ? "very-high" : d.complexity.max > 10 ? "high" : "low"))}
   ${statCard("Dead exports", d.dead.count, d.dead.count ? "#d85a30" : "#1d9e75")}
   ${statCard("Cycles", d.cycles.count, d.cycles.count ? "#e24b4a" : "#1d9e75")}
+  ${statCard("SDP violations", d.layerViolations.count, d.layerViolations.count ? "#d85a30" : "#1d9e75")}
 </div>
 <div class="card"><h2>Language breakdown</h2>${langs}</div>
 <div class="card"><h2>Complexity hotspots</h2>${hotspots}</div>
@@ -156,6 +174,10 @@ export function buildReportHtml(d) {
   <div class="card"><h2>God nodes (most imported)</h2>${god}</div>
   <div class="card"><h2>Circular dependencies</h2>${cycles}</div>
 </div>
+<div class="two">
+  <div class="card"><h2>Module coupling (instability)</h2>${modules}</div>
+  <div class="card"><h2>Layer violations (stable → volatile)</h2>${sdp}</div>
+</div>
 <div class="card"><h2>Dead exports (high confidence)</h2>${dead}</div>
 <div class="foot">Generated by AST-MCP · universal-ast-mapper</div>
 </div></body></html>`;

package/dist/resolver.js

@@ -5,7 +5,7 @@ import { resolveOptions } from "./config.js";
 import { findSymbol } from "./analysis.js";
 import { buildCrossLangIndex, resolveCrossLangTarget, } from "./crosslang.js";
 import { resolveWorkspaceImportCached } from "./workspace.js";
-const SRC_EXTS = [".ts", ".tsx", ".js", ".jsx", ".mts", ".cts", ".mjs", ".cjs"];
+const SRC_EXTS = [".ts", ".tsx", ".js", ".jsx", ".mts", ".cts", ".mjs", ".cjs", ".vue", ".svelte"];
 function extractParams(sig) {
     const start = sig.indexOf("(");
     if (start === -1)

package/dist/sfc.js

@@ -0,0 +1,27 @@
+const SCRIPT_RE = /<script\b([^>]*)>([\s\S]*?)<\/script>/gi;
+export function isSfcExt(ext) {
+    return ext === ".vue" || ext === ".svelte";
+}
+export function extractScript(source) {
+    // Start from an all-blank canvas the same shape as the source (newlines kept,
+    // every other character turned into a space) to preserve line/column offsets.
+    let out = source.replace(/[^\n]/g, " ");
+    let hasScript = false;
+    let lang = "js";
+    let m;
+    SCRIPT_RE.lastIndex = 0;
+    while ((m = SCRIPT_RE.exec(source)) !== null) {
+        hasScript = true;
+        const attrs = m[1] ?? "";
+        if (/lang\s*=\s*["'](ts|typescript)["']/i.test(attrs))
+            lang = "ts";
+        const inner = m[2] ?? "";
+        const innerStart = m.index + m[0].indexOf(inner, m[1] ? m[1].length : 0);
+        out = out.slice(0, innerStart) + inner + out.slice(innerStart + inner.length);
+    }
+    return {
+        code: hasScript ? out : "",
+        grammar: lang === "ts" ? "typescript" : "javascript",
+        hasScript,
+    };
+}

package/dist/skeleton.js

@@ -3,6 +3,7 @@ import path from "node:path";
 import { detectLanguage, supportedExtensions } from "./registry.js";
 import { parseSource } from "./parser.js";
 import { countSymbols, toOutline } from "./extractors/common.js";
+import { extractScript } from "./sfc.js";
 export const SCHEMA_VERSION = "1.1";
 export const GRAMMAR_SOURCE = "tree-sitter-wasms@0.1.13";
 const parseCache = new Map();
@@ -57,8 +58,14 @@ export async function buildSkeleton(absPath, relPath, opts) {
         const wantFile = relPath.split(path.sep).join("/");
         return cached.file === wantFile ? cached : { ...cached, file: wantFile };
     }
-    const source = fs.readFileSync(absPath, "utf8");
-    const root = await parseSource(entry.grammar, source);
+    let source = fs.readFileSync(absPath, "utf8");
+    let grammar = entry.grammar;
+    if (entry.sfc) {
+        const script = extractScript(source);
+        source = script.code; // blank-padded script-only source (offsets preserved)
+        grammar = script.grammar;
+    }
+    const root = await parseSource(grammar, source);
     let symbols = entry.extract(root, source);
     if (opts.detail === "outline")
         symbols = toOutline(symbols);
@@ -69,7 +76,7 @@ export async function buildSkeleton(absPath, relPath, opts) {
         file: relPath.split(path.sep).join("/"),
         language: entry.language,
         generatedAt: new Date().toISOString(),
-        parser: { engine: "tree-sitter", grammar: `${entry.grammar} (${GRAMMAR_SOURCE})` },
+        parser: { engine: "tree-sitter", grammar: `${grammar} (${GRAMMAR_SOURCE})` },
         symbolCount: countSymbols(symbols),
         ...(directives.length > 0 ? { directives } : {}),
         ...(imports.length > 0 ? { imports } : {}),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "universal-ast-mapper",
-  "version": "1.13.0",
+  "version": "1.19.0",
   "description": "MCP server that maps source files into a normalized code skeleton (JSON + HTML) using tree-sitter.",
   "type": "module",
   "main": "dist/index.js",