@mka-rainmaker/ama 0.1.0

package/dist/analyzers/baseline/swift.js

@@ -0,0 +1,19 @@
+/**
+ * Baseline (syntactic) spec for Swift. tree-sitter-swift carries a `name` field,
+ * so no special extraction is needed. `class`, `struct`, and `enum` share one
+ * `class_declaration` (an enum is refined to Enum by its `enum_class_body`;
+ * structs stay Class at this tier); `protocol_declaration` is an Interface; and
+ * `function_declaration` covers free functions and methods, which nest under
+ * their type (e.g. `Sample.square`). (ama-p3a)
+ */
+export const swiftSpec = {
+    language: "swift",
+    extensions: [".swift"],
+    grammar: "swift",
+    symbols: {
+        class_declaration: { kind: "Class", kindByChild: { enum_class_body: "Enum" } },
+        protocol_declaration: { kind: "Interface" },
+        function_declaration: { kind: "Function" },
+    },
+};
+//# sourceMappingURL=swift.js.map

package/dist/analyzers/baseline/swift.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"swift.js","sourceRoot":"","sources":["../../../src/analyzers/baseline/swift.ts"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,SAAS,GAAiB;IACrC,QAAQ,EAAE,OAAO;IACjB,UAAU,EAAE,CAAC,QAAQ,CAAC;IACtB,OAAO,EAAE,OAAO;IAChB,OAAO,EAAE;QACP,iBAAiB,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,EAAE,eAAe,EAAE,MAAM,EAAE,EAAE;QAC9E,oBAAoB,EAAE,EAAE,IAAI,EAAE,WAAW,EAAE;QAC3C,oBAAoB,EAAE,EAAE,IAAI,EAAE,UAAU,EAAE;KAC3C;CACF,CAAC"}

package/dist/analyzers/baseline/treesitter.d.ts

@@ -0,0 +1,11 @@
+import Parser from "web-tree-sitter";
+/** How many parsers have been allocated (test hook for the no-leak guarantee). */
+export declare function parsersAllocated(): number;
+/**
+ * Parse source code in `language` into a tree-sitter CST, loading (and caching)
+ * the grammar on first use. Rejects for a language with no bundled grammar.
+ */
+export declare function parse(language: string, code: string): Promise<Parser.Tree>;
+/** Languages that have a bundled grammar (so a baseline analyzer can claim them). */
+export declare function supportedLanguages(): string[];
+//# sourceMappingURL=treesitter.d.ts.map

package/dist/analyzers/baseline/treesitter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"treesitter.d.ts","sourceRoot":"","sources":["../../../src/analyzers/baseline/treesitter.ts"],"names":[],"mappings":"AAGA,OAAO,MAAM,MAAM,iBAAiB,CAAC;AA4CrC,kFAAkF;AAClF,wBAAgB,gBAAgB,IAAI,MAAM,CAEzC;AA8BD;;;GAGG;AACH,wBAAsB,KAAK,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,CAQhF;AAED,qFAAqF;AACrF,wBAAgB,kBAAkB,IAAI,MAAM,EAAE,CAE7C"}

package/dist/analyzers/baseline/treesitter.js

@@ -0,0 +1,87 @@
+import * as fs from "node:fs";
+import { createRequire } from "node:module";
+import * as path from "node:path";
+import Parser from "web-tree-sitter";
+const require = createRequire(import.meta.url);
+/**
+ * Languages we ship a prebuilt tree-sitter grammar for (via `tree-sitter-wasms`),
+ * mapped to the grammar's wasm filename. Grow this as baseline analyzers land.
+ *
+ * The runtime (`web-tree-sitter`) is pinned to match the grammar bundle's ABI:
+ * `tree-sitter-wasms@0.1.13` grammars are built with tree-sitter 0.20.x, so the
+ * runtime must be `web-tree-sitter@0.20.x` — a newer runtime fails to load them.
+ */
+const GRAMMARS = {
+    python: "tree-sitter-python.wasm",
+    javascript: "tree-sitter-javascript.wasm",
+    // For SFC `<script lang="ts">` bodies parsed by the SfcAnalyzer (the deep TS
+    // analyzer still owns `.ts`/`.tsx` files themselves). (ama-q1u)
+    typescript: "tree-sitter-typescript.wasm",
+    java: "tree-sitter-java.wasm",
+    csharp: "tree-sitter-c_sharp.wasm",
+    go: "tree-sitter-go.wasm",
+    rust: "tree-sitter-rust.wasm",
+    php: "tree-sitter-php.wasm",
+    c: "tree-sitter-c.wasm",
+    cpp: "tree-sitter-cpp.wasm",
+    kotlin: "tree-sitter-kotlin.wasm",
+    swift: "tree-sitter-swift.wasm",
+};
+/** Runtime init is one-shot; each grammar is loaded once and cached. */
+let runtime;
+const grammars = new Map();
+/**
+ * One reused parser. A web-tree-sitter `Parser` holds WASM linear memory and
+ * must be freed with `.delete()`; allocating a fresh one per file (and never
+ * deleting it) leaks ~a parser per source file, which across a large
+ * multi-language index exhausts process memory and crashes V8 with a fatal
+ * WASM-compilation OOM. Reusing one is safe because `setLanguage` + `parse` is a
+ * synchronous block — concurrent `parse()` calls can't interleave it. (ama-5o1)
+ */
+let parser;
+let parserAllocCount = 0;
+/** How many parsers have been allocated (test hook for the no-leak guarantee). */
+export function parsersAllocated() {
+    return parserAllocCount;
+}
+/** Absolute path to a file bundled inside an installed package. */
+function packageFile(pkg, ...rel) {
+    return path.join(path.dirname(require.resolve(`${pkg}/package.json`)), ...rel);
+}
+function initRuntime() {
+    // Point Emscripten at the runtime wasm explicitly so init works regardless of
+    // the process cwd (vitest, the dev loop, an installed CLI).
+    runtime ??= Parser.init({ locateFile: () => packageFile("web-tree-sitter", "tree-sitter.wasm") });
+    return runtime;
+}
+/** Load a grammar on demand, caching the (async) result per language. */
+function loadLanguage(language) {
+    const file = GRAMMARS[language];
+    if (!file) {
+        return Promise.reject(new Error(`No bundled tree-sitter grammar for language: ${language}`));
+    }
+    let pending = grammars.get(language);
+    if (!pending) {
+        pending = initRuntime().then(() => Parser.Language.load(fs.readFileSync(packageFile("tree-sitter-wasms", "out", file))));
+        grammars.set(language, pending);
+    }
+    return pending;
+}
+/**
+ * Parse source code in `language` into a tree-sitter CST, loading (and caching)
+ * the grammar on first use. Rejects for a language with no bundled grammar.
+ */
+export async function parse(language, code) {
+    const lang = await loadLanguage(language);
+    if (!parser) {
+        parser = new Parser();
+        parserAllocCount++;
+    }
+    parser.setLanguage(lang);
+    return parser.parse(code);
+}
+/** Languages that have a bundled grammar (so a baseline analyzer can claim them). */
+export function supportedLanguages() {
+    return Object.keys(GRAMMARS);
+}
+//# sourceMappingURL=treesitter.js.map

package/dist/analyzers/baseline/treesitter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"treesitter.js","sourceRoot":"","sources":["../../../src/analyzers/baseline/treesitter.ts"],"names":[],"mappings":"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"}

package/dist/analyzers/baseline/walk.d.ts

@@ -0,0 +1,26 @@
+import type Parser from "web-tree-sitter";
+import { type GraphEdge, type GraphNode, type NodeKind } from "../../graph/index.js";
+/** How to turn one kind of CST node into a graph symbol. */
+export interface SymbolRule {
+    /** Graph node kind to emit (the fallback when {@link kindByChild} matches nothing). */
+    readonly kind: NodeKind;
+    /** CST field holding the symbol's identifier (default "name"). */
+    readonly nameField?: string;
+    /**
+     * Refine the kind by a child node's type — for languages where one CST node
+     * covers several kinds (e.g. Go's `type_spec` is a `struct_type` → Class, an
+     * `interface_type` → Interface, else a TypeAlias). First matching named child
+     * wins; falls back to {@link kind}.
+     */
+    readonly kindByChild?: Readonly<Record<string, NodeKind>>;
+}
+/**
+ * Walk named CST children, emitting a symbol node for each that matches a
+ * {@link SymbolRule} (with a `Defines` edge from its container and a dotted
+ * qualified name for nesting), and recursing. Shared by the {@link BaselineAnalyzer}
+ * and the SFC analyzer; `lineOffset` is added to every emitted line so a fragment
+ * parsed out of a larger file (an SFC `<script>` block) maps back to file lines.
+ * (ama-q1u)
+ */
+export declare function walkSymbols(node: Parser.SyntaxNode, symbols: Readonly<Record<string, SymbolRule>>, rel: string, containerId: string, prefix: string, nodes: GraphNode[], edges: GraphEdge[], lineOffset?: number): void;
+//# sourceMappingURL=walk.d.ts.map

package/dist/analyzers/baseline/walk.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"walk.d.ts","sourceRoot":"","sources":["../../../src/analyzers/baseline/walk.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,iBAAiB,CAAC;AAC1C,OAAO,EAAE,KAAK,SAAS,EAAE,KAAK,SAAS,EAAE,KAAK,QAAQ,EAAY,MAAM,sBAAsB,CAAC;AAE/F,4DAA4D;AAC5D,MAAM,WAAW,UAAU;IACzB,uFAAuF;IACvF,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB,kEAAkE;IAClE,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B;;;;;OAKG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC;CAC3D;AAED;;;;;;;GAOG;AACH,wBAAgB,WAAW,CACzB,IAAI,EAAE,MAAM,CAAC,UAAU,EACvB,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC,EAC7C,GAAG,EAAE,MAAM,EACX,WAAW,EAAE,MAAM,EACnB,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,SAAS,EAAE,EAClB,KAAK,EAAE,SAAS,EAAE,EAClB,UAAU,SAAI,GACb,IAAI,CA2BN"}

package/dist/analyzers/baseline/walk.js

@@ -0,0 +1,76 @@
+import { symbolId } from "../../graph/index.js";
+/**
+ * Walk named CST children, emitting a symbol node for each that matches a
+ * {@link SymbolRule} (with a `Defines` edge from its container and a dotted
+ * qualified name for nesting), and recursing. Shared by the {@link BaselineAnalyzer}
+ * and the SFC analyzer; `lineOffset` is added to every emitted line so a fragment
+ * parsed out of a larger file (an SFC `<script>` block) maps back to file lines.
+ * (ama-q1u)
+ */
+export function walkSymbols(node, symbols, rel, containerId, prefix, nodes, edges, lineOffset = 0) {
+    for (const child of node.namedChildren) {
+        const rule = symbols[child.type];
+        const name = rule ? symbolName(child, rule) : undefined;
+        if (rule && name) {
+            const qualifiedName = prefix ? `${prefix}.${name}` : name;
+            const id = symbolId({ file: rel, qualifiedName });
+            nodes.push({
+                id,
+                kind: kindFor(rule, child),
+                name,
+                file: rel,
+                qualifiedName,
+                tier: "baseline",
+                range: {
+                    startLine: child.startPosition.row + 1 + lineOffset,
+                    endLine: child.endPosition.row + 1 + lineOffset,
+                },
+            });
+            edges.push({ from: containerId, to: id, kind: "Defines" });
+            // Descend into the symbol so members nest under it (e.g. `Class.method`).
+            walkSymbols(child, symbols, rel, id, qualifiedName, nodes, edges, lineOffset);
+        }
+        else {
+            // Not a symbol (or anonymous) — keep looking for symbols inside it.
+            walkSymbols(child, symbols, rel, containerId, prefix, nodes, edges, lineOffset);
+        }
+    }
+}
+/** A symbol's name, by descending tiers of grammar convention:
+ *  1. a `name` field (most languages);
+ *  2. a `declarator` field drilled to its identifier (C/C++ — ama-s8q.9);
+ *  3. the first identifier-like child (Kotlin et al. name declarations
+ *     positionally, with no field — ama-0ze). */
+function symbolName(node, rule) {
+    const named = node.childForFieldName(rule.nameField ?? "name");
+    if (named)
+        return named.text;
+    const decl = node.childForFieldName("declarator");
+    if (decl)
+        return declaratorIdentifier(decl);
+    for (const child of node.namedChildren) {
+        if (child.type.endsWith("identifier"))
+            return child.text;
+    }
+    return undefined;
+}
+/** Drill a C/C++ declarator (function_declarator, pointer_declarator, …) down its
+ *  `declarator` field to the identifier it ultimately names. (ama-s8q.9) */
+function declaratorIdentifier(node) {
+    if (node.type.endsWith("identifier"))
+        return node.text;
+    const inner = node.childForFieldName("declarator");
+    return inner ? declaratorIdentifier(inner) : undefined;
+}
+/** Resolve a symbol's kind, refining by a child node type when the rule asks. */
+function kindFor(rule, node) {
+    if (rule.kindByChild) {
+        for (const child of node.namedChildren) {
+            const refined = rule.kindByChild[child.type];
+            if (refined)
+                return refined;
+        }
+    }
+    return rule.kind;
+}
+//# sourceMappingURL=walk.js.map

package/dist/analyzers/baseline/walk.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"walk.js","sourceRoot":"","sources":["../../../src/analyzers/baseline/walk.ts"],"names":[],"mappings":"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"}

package/dist/analyzers/registry.d.ts

@@ -0,0 +1,19 @@
+import type { Analyzer } from "./types.js";
+/**
+ * Selects an analyzer for a file by its extension. The indexer asks the registry
+ * "who handles this file?" so adding a language is just registering an analyzer.
+ */
+export declare class AnalyzerRegistry {
+    private readonly byExtension;
+    private readonly analyzers;
+    register(analyzer: Analyzer): void;
+    /** Register an analyzer only if it reports itself available — for sidecars whose
+     *  subprocess may be absent. Returns whether it was registered. An analyzer without
+     *  an {@link Analyzer.isAvailable} probe (every in-process one) always registers. */
+    registerIfAvailable(analyzer: Analyzer): Promise<boolean>;
+    /** The analyzer for a file path, or undefined if no language handles it. */
+    forFile(path: string): Analyzer | undefined;
+    /** All registered analyzers, in registration order. */
+    all(): Analyzer[];
+}
+//# sourceMappingURL=registry.d.ts.map

package/dist/analyzers/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/analyzers/registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3C;;;GAGG;AACH,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,QAAQ,CAAC,WAAW,CAA+B;IAC3D,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAkB;IAE5C,QAAQ,CAAC,QAAQ,EAAE,QAAQ,GAAG,IAAI;IAelC;;yFAEqF;IAC/E,mBAAmB,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAAC,OAAO,CAAC;IAM/D,4EAA4E;IAC5E,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,QAAQ,GAAG,SAAS;IAM3C,uDAAuD;IACvD,GAAG,IAAI,QAAQ,EAAE;CAGlB"}

package/dist/analyzers/registry.js

@@ -0,0 +1,43 @@
+/**
+ * Selects an analyzer for a file by its extension. The indexer asks the registry
+ * "who handles this file?" so adding a language is just registering an analyzer.
+ */
+export class AnalyzerRegistry {
+    byExtension = new Map();
+    analyzers = [];
+    register(analyzer) {
+        this.analyzers.push(analyzer);
+        for (const ext of analyzer.extensions) {
+            const key = ext.toLowerCase();
+            const existing = this.byExtension.get(key);
+            // Deep beats baseline for the same extension, regardless of registration order —
+            // so a deep sidecar takes over a language the baseline also claims. Same tier keeps
+            // the first registered. This is the "deep-if-available" routing rule; availability
+            // is gated upstream by {@link registerIfAvailable}. (ama-3bb.4)
+            if (!existing || (analyzer.tier === "deep" && existing.tier === "baseline")) {
+                this.byExtension.set(key, analyzer);
+            }
+        }
+    }
+    /** Register an analyzer only if it reports itself available — for sidecars whose
+     *  subprocess may be absent. Returns whether it was registered. An analyzer without
+     *  an {@link Analyzer.isAvailable} probe (every in-process one) always registers. */
+    async registerIfAvailable(analyzer) {
+        const available = (await analyzer.isAvailable?.()) ?? true;
+        if (available)
+            this.register(analyzer);
+        return available;
+    }
+    /** The analyzer for a file path, or undefined if no language handles it. */
+    forFile(path) {
+        const dot = path.lastIndexOf(".");
+        if (dot < 0)
+            return undefined;
+        return this.byExtension.get(path.slice(dot).toLowerCase());
+    }
+    /** All registered analyzers, in registration order. */
+    all() {
+        return this.analyzers.slice();
+    }
+}
+//# sourceMappingURL=registry.js.map

package/dist/analyzers/registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.js","sourceRoot":"","sources":["../../src/analyzers/registry.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,MAAM,OAAO,gBAAgB;IACV,WAAW,GAAG,IAAI,GAAG,EAAoB,CAAC;IAC1C,SAAS,GAAe,EAAE,CAAC;IAE5C,QAAQ,CAAC,QAAkB;QACzB,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAC9B,KAAK,MAAM,GAAG,IAAI,QAAQ,CAAC,UAAU,EAAE,CAAC;YACtC,MAAM,GAAG,GAAG,GAAG,CAAC,WAAW,EAAE,CAAC;YAC9B,MAAM,QAAQ,GAAG,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;YAC3C,iFAAiF;YACjF,oFAAoF;YACpF,mFAAmF;YACnF,gEAAgE;YAChE,IAAI,CAAC,QAAQ,IAAI,CAAC,QAAQ,CAAC,IAAI,KAAK,MAAM,IAAI,QAAQ,CAAC,IAAI,KAAK,UAAU,CAAC,EAAE,CAAC;gBAC5E,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAC;YACtC,CAAC;QACH,CAAC;IACH,CAAC;IAED;;yFAEqF;IACrF,KAAK,CAAC,mBAAmB,CAAC,QAAkB;QAC1C,MAAM,SAAS,GAAG,CAAC,MAAM,QAAQ,CAAC,WAAW,EAAE,EAAE,CAAC,IAAI,IAAI,CAAC;QAC3D,IAAI,SAAS;YAAE,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;QACvC,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,4EAA4E;IAC5E,OAAO,CAAC,IAAY;QAClB,MAAM,GAAG,GAAG,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC;QAClC,IAAI,GAAG,GAAG,CAAC;YAAE,OAAO,SAAS,CAAC;QAC9B,OAAO,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,WAAW,EAAE,CAAC,CAAC;IAC7D,CAAC;IAED,uDAAuD;IACvD,GAAG;QACD,OAAO,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,CAAC;IAChC,CAAC;CACF"}

package/dist/analyzers/sfc/analyzer.d.ts

@@ -0,0 +1,17 @@
+import type { AnalysisResult, Analyzer } from "../types.js";
+/**
+ * Baseline (syntactic) analyzer for single-file components. A `.vue`/`.svelte` file
+ * becomes a {@link "Component"} node named after the file; the modules its `<script>`
+ * imports become File→File `Imports` edges; and the symbols the `<script>` declares
+ * (functions, classes, methods, types) become nodes with file-relative line numbers,
+ * so SFCs are searchable, connected, and navigable. Calls/types resolution is deep-tier
+ * and out of scope. One instance per language (vue/svelte) for honest coverage. (ama-krw, ama-q1u)
+ */
+export declare class SfcAnalyzer implements Analyzer {
+    readonly language: string;
+    readonly extensions: readonly string[];
+    readonly tier = "baseline";
+    constructor(language: string, extensions: readonly string[]);
+    analyze(root: string, files: string[]): Promise<AnalysisResult>;
+}
+//# sourceMappingURL=analyzer.d.ts.map

package/dist/analyzers/sfc/analyzer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"analyzer.d.ts","sourceRoot":"","sources":["../../../src/analyzers/sfc/analyzer.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,cAAc,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AA2D5D;;;;;;;GAOG;AACH,qBAAa,WAAY,YAAW,QAAQ;IAIxC,QAAQ,CAAC,QAAQ,EAAE,MAAM;IACzB,QAAQ,CAAC,UAAU,EAAE,SAAS,MAAM,EAAE;IAJxC,QAAQ,CAAC,IAAI,cAAc;gBAGhB,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,SAAS,MAAM,EAAE;IAGlC,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,cAAc,CAAC;CA+DtE"}

package/dist/analyzers/sfc/analyzer.js

@@ -0,0 +1,141 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { fileId, symbolId } from "../../graph/index.js";
+import { parse } from "../baseline/treesitter.js";
+import { walkSymbols } from "../baseline/walk.js";
+/** Extensions an SFC `<script>` import may resolve to — sibling components, plus
+ *  the TS/JS modules they pull in (composables, stores, utils). */
+const SFC_EXTENSIONS = [".vue", ".svelte", ".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"];
+/** Symbols a `<script>` defines, by tree-sitter-typescript node type (which parses
+ *  plain JS too). Baseline-tier breadth: declarations, not calls/types. (ama-q1u) */
+const SFC_SYMBOLS = {
+    function_declaration: { kind: "Function" },
+    generator_function_declaration: { kind: "Function" },
+    class_declaration: { kind: "Class" },
+    abstract_class_declaration: { kind: "Class" },
+    method_definition: { kind: "Method" },
+    interface_declaration: { kind: "Interface" },
+    type_alias_declaration: { kind: "TypeAlias" },
+    enum_declaration: { kind: "Enum" },
+};
+/** Candidate repo-relative files for a relative SFC import specifier, resolved against
+ *  the importer's directory. An explicit known extension is used as-is; otherwise each
+ *  SFC/TS/JS extension and an `/index.*` variant is tried. A bare/package specifier
+ *  (not `./` or `../`) is external and yields no candidates. (ama-krw) */
+function sfcCandidates(specifier, importerRel) {
+    if (!specifier.startsWith("./") && !specifier.startsWith("../"))
+        return [];
+    const base = path.posix.join(path.posix.dirname(importerRel), specifier);
+    if (/\.(?:vue|svelte|tsx?|jsx?|mjs|cjs)$/.test(specifier))
+        return [base];
+    return [
+        ...SFC_EXTENSIONS.map((e) => base + e),
+        ...SFC_EXTENSIONS.map((e) => `${base}/index${e}`),
+    ];
+}
+/** Each `<script>` block's source paired with the file line its content starts on, so a
+ *  symbol parsed out of the block maps back to a real file line. Vue allows two blocks
+ *  (`<script>` + `<script setup>`); Svelte adds `<script context="module">`. */
+function scriptBlocks(code) {
+    const blocks = [];
+    for (const m of code.matchAll(/<script\b[^>]*>([\s\S]*?)<\/script>/gi)) {
+        const content = m[1] ?? "";
+        const contentStart = (m.index ?? 0) + m[0].length - content.length - "</script>".length;
+        const lineOffset = code.slice(0, contentStart).split("\n").length - 1;
+        blocks.push({ code: content, lineOffset });
+    }
+    return blocks;
+}
+/** Module specifiers a `<script>` imports or re-exports: `… from "x"` (import,
+ *  `export … from`), side-effect `import "x"`, and dynamic `import("x")` — the last
+ *  is how SFCs lazy-load components/routes, so it belongs in the import graph too.
+ *  Baseline (syntactic) breadth: a best-effort scan, not a full parse. (ama-krw, ama-grb) */
+function importSpecifiers(script) {
+    const specs = [];
+    for (const m of script.matchAll(/\bfrom\s*['"]([^'"]+)['"]/g))
+        specs.push(m[1]);
+    for (const m of script.matchAll(/\bimport\s*['"]([^'"]+)['"]/g))
+        specs.push(m[1]);
+    for (const m of script.matchAll(/\bimport\s*\(\s*['"]([^'"]+)['"]/g))
+        specs.push(m[1]);
+    return specs;
+}
+/**
+ * Baseline (syntactic) analyzer for single-file components. A `.vue`/`.svelte` file
+ * becomes a {@link "Component"} node named after the file; the modules its `<script>`
+ * imports become File→File `Imports` edges; and the symbols the `<script>` declares
+ * (functions, classes, methods, types) become nodes with file-relative line numbers,
+ * so SFCs are searchable, connected, and navigable. Calls/types resolution is deep-tier
+ * and out of scope. One instance per language (vue/svelte) for honest coverage. (ama-krw, ama-q1u)
+ */
+export class SfcAnalyzer {
+    language;
+    extensions;
+    tier = "baseline";
+    constructor(language, extensions) {
+        this.language = language;
+        this.extensions = extensions;
+    }
+    async analyze(root, files) {
+        const nodes = [];
+        const edges = [];
+        for (const rel of files) {
+            // Per-file isolation, like the BaselineAnalyzer: build locally, merge on success,
+            // so a mid-parse throw on one SFC leaves no partial nodes behind.
+            try {
+                const code = fs.readFileSync(path.join(root, rel), "utf8");
+                const fileNodes = [];
+                const fileEdges = [];
+                const endLine = code.split("\n").length;
+                const id = fileId(rel);
+                fileNodes.push({
+                    id,
+                    kind: "File",
+                    name: path.basename(rel),
+                    file: rel,
+                    qualifiedName: "",
+                    tier: "baseline",
+                    range: { startLine: 1, endLine },
+                });
+                // The SFC file *is* a component, named from the filename (Foo.vue → Foo).
+                const name = path.basename(rel, path.extname(rel));
+                const componentId = symbolId({ file: rel, qualifiedName: name });
+                fileNodes.push({
+                    id: componentId,
+                    kind: "Component",
+                    name,
+                    file: rel,
+                    qualifiedName: name,
+                    tier: "baseline",
+                    range: { startLine: 1, endLine },
+                });
+                fileEdges.push({ from: id, to: componentId, kind: "Defines" });
+                for (const { code: script, lineOffset } of scriptBlocks(code)) {
+                    // <script> imports → File→File Imports edges (the import graph).
+                    for (const specifier of importSpecifiers(script)) {
+                        const target = sfcCandidates(specifier, rel).find((c) => fs.existsSync(path.join(root, c)));
+                        if (target && target !== rel)
+                            fileEdges.push({ from: id, to: fileId(target), kind: "Imports" });
+                    }
+                    // <script> declarations → symbol nodes, parsed with the TS grammar (it parses
+                    // plain JS too) and offset back to file lines. A WASM Tree must be freed.
+                    const tree = await parse("typescript", script);
+                    try {
+                        walkSymbols(tree.rootNode, SFC_SYMBOLS, rel, id, "", fileNodes, fileEdges, lineOffset);
+                    }
+                    finally {
+                        tree.delete();
+                    }
+                }
+                nodes.push(...fileNodes);
+                edges.push(...fileEdges);
+            }
+            catch (err) {
+                console.error(`[ama] ${this.language} analyzer failed on ${rel}; skipping it. ` +
+                    `${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+        return { nodes, edges };
+    }
+}
+//# sourceMappingURL=analyzer.js.map

package/dist/analyzers/sfc/analyzer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"analyzer.js","sourceRoot":"","sources":["../../../src/analyzers/sfc/analyzer.ts"],"names":[],"mappings":"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"}

package/dist/analyzers/sidecar/analyzer.d.ts

@@ -0,0 +1,29 @@
+import type { AnalysisResult, Analyzer } from "../types.js";
+/**
+ * Drives an out-of-process deep analyzer (a "sidecar") over the {@link ./protocol.ts}
+ * contract. Implements {@link Analyzer} (tier `deep`) so it plugs in alongside the
+ * in-process analyzers, but delegates the actual work to a subprocess (e.g. a Roslyn or
+ * native-Java tool) that speaks NDJSON over stdio.
+ *
+ * One subprocess per `analyze` call (one per language batch per index): spawn, send the
+ * `analyze` request on stdin, read the matching `result` from stdout, then tear it down.
+ * The sidecar's stderr is inherited so its logs reach Ama's stderr, never the protocol
+ * stream. A spawn failure, a malformed message, an `error` reply, or an exit-without-result
+ * rejects — the indexer's per-analyzer isolation then skips this language (graceful
+ * fall-through to baseline is the routing layer's job, ama-3bb.4). (ama-3bb.1)
+ */
+export declare class SidecarAnalyzer implements Analyzer {
+    readonly language: string;
+    readonly extensions: readonly string[];
+    private readonly command;
+    private readonly args;
+    readonly tier = "deep";
+    constructor(language: string, extensions: readonly string[], command: string, args?: readonly string[]);
+    /** Probe whether the sidecar can start and speak the protocol: spawn it and wait for
+     *  its `ready` handshake within `timeoutMs`. A spawn failure, an early exit, or a
+     *  timeout means unavailable — routing then leaves the language to the baseline tier
+     *  rather than dropping it. (ama-3bb.4) */
+    isAvailable(timeoutMs?: number): Promise<boolean>;
+    analyze(root: string, files: string[]): Promise<AnalysisResult>;
+}
+//# sourceMappingURL=analyzer.d.ts.map

package/dist/analyzers/sidecar/analyzer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"analyzer.d.ts","sourceRoot":"","sources":["../../../src/analyzers/sidecar/analyzer.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAG5D;;;;;;;;;;;;GAYG;AACH,qBAAa,eAAgB,YAAW,QAAQ;IAI5C,QAAQ,CAAC,QAAQ,EAAE,MAAM;IACzB,QAAQ,CAAC,UAAU,EAAE,SAAS,MAAM,EAAE;IACtC,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,IAAI;IANvB,QAAQ,CAAC,IAAI,UAAU;gBAGZ,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,SAAS,MAAM,EAAE,EACrB,OAAO,EAAE,MAAM,EACf,IAAI,GAAE,SAAS,MAAM,EAAO;IAG/C;;;+CAG2C;IAC3C,WAAW,CAAC,SAAS,SAAO,GAAG,OAAO,CAAC,OAAO,CAAC;IA8B/C,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,cAAc,CAAC;CA8ChE"}