@mka-rainmaker/ama 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mykhaylo Katruk
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,149 @@
+# Ama 🐶
+
+**Ama** is a local-first **code-intelligence server** that speaks the [Model Context Protocol (MCP)](https://modelcontextprotocol.io). It parses a codebase into a queryable knowledge graph of symbols and their relationships, then hands that graph to AI coding agents — so an agent can answer *"who calls this?"*, *"what breaks if I change this?"*, and *"show me this function and its callers"* in a **single tool call** instead of dozens of file reads.
+
+Named after a puppy: small, eager, and a little smarter every day.
+
+> Status: **0.1.** Deep TypeScript analysis plus syntactic baseline coverage for 13 more languages, 27 MCP tools, an `ama` CLI, and persistent incremental indexing — all able to index Ama's own source cleanly as the built-in regression test. Deep-tier .NET/Java analyzers (behind the sidecar protocol) are next.
+
+## Why Ama
+
+Most code-graph tools parse every language the same way: one fast, syntactic pass that sees *shapes* but not *meaning*. Ama takes a different bet — **use each language's real compiler when one exists.**
+
+- **Deep tier — language-specific semantic analysis.** TypeScript via the TypeScript Compiler API today; .NET via Roslyn and Java via its native tooling next. This resolves types, overloads, generics, imports/re-exports, interface dispatch, and cross-file symbol binding that a purely syntactic parser cannot.
+- **Baseline tier — universal syntactic analysis for breadth.** Every other language still gets parsed for structure, so the whole repo is navigable from day one.
+
+Every answer reports **which tier produced it**, so partial coverage never quietly masquerades as complete.
+
+And because it's built for agents:
+
+- **100% local.** No external APIs, no API keys, no telemetry. Your code never leaves your machine.
+- **Cheaper and faster.** Fewer tool calls and fewer tokens per question, because one graph query replaces a pile of file reads.
+
+## Install
+
+> Requires **Node.js 24+**.
+
+Ama runs as a local MCP server your coding agent launches over stdio. Install it once, then point your agent at `ama mcp`:
+
+```bash
+npm install -g @mka-rainmaker/ama
+```
+
+(Or skip the global install and use `npx -y @mka-rainmaker/ama mcp` as the command below.)
+
+### Configure your coding agent
+
+Every MCP client spawns the same stdio command — `ama mcp` — only the config location differs.
+
+**Claude Code** — add it with one command:
+
+```bash
+claude mcp add ama -- ama mcp
+```
+
+…or add it to a project `.mcp.json`:
+
+```json
+{ "mcpServers": { "ama": { "command": "ama", "args": ["mcp"] } } }
+```
+
+**Cursor** — `.cursor/mcp.json` (project) or `~/.cursor/mcp.json` (global):
+
+```json
+{ "mcpServers": { "ama": { "command": "ama", "args": ["mcp"] } } }
+```
+
+**Windsurf** — `~/.codeium/windsurf/mcp_config.json`:
+
+```json
+{ "mcpServers": { "ama": { "command": "ama", "args": ["mcp"] } } }
+```
+
+**Any other MCP client** — spawn `ama mcp` over stdio. If you didn't install globally, run it via `npx`:
+
+```json
+{ "mcpServers": { "ama": { "command": "npx", "args": ["-y", "@mka-rainmaker/ama", "mcp"] } } }
+```
+
+### Quick start
+
+Once connected, point Ama at a repo and start asking graph questions:
+
+1. **`index_repository("/path/to/your/project")`** — builds the graph (run this first).
+2. **`search_symbol`**, **`find_callers`**, **`find_callees`**, **`get_code_snippet`**, **`impact_analysis`**, … — query it.
+
+Ama re-indexes changed files automatically while connected. Call `index_status()` to see what's indexed and the per-language coverage + tier.
+
+### CLI
+
+The same package ships an `ama` CLI mirroring the query surface, for one-shot use and scripting (e.g. `git diff --name-only | ama affected`):
+
+```bash
+ama --help     # list commands
+ama mcp        # run the MCP server over stdio (what coding agents spawn)
+```
+
+## What's in 0.1
+
+- **Deep TypeScript analysis** via the TypeScript Compiler API — types, overloads, generics, imports/re-exports, inheritance, interface dispatch, cross-file binding, and call graphs.
+- **Baseline breadth** for 13 more languages via tree-sitter: C, C++, C#, Go, Java, JavaScript, Kotlin, PHP, Python, Rust, Swift, and Vue/Svelte single-file components.
+- **27 MCP tools** — search, call graph, references, type usage, inheritance/overrides, imports/importers, routes → handlers, code snippets, plus higher-order `explore`, `impact_analysis`, and `search_code` — each tagging the tier that produced it.
+- **Persistent indexing** (SQLite + full-text search) with **incremental re-indexing**: edits are picked up automatically while connected.
+- **Cross-project queries** — index several repos in one session and target any of them by path.
+- **An `ama` CLI** for one-shot queries and scripting.
+
+## Next
+
+- **Deep-tier .NET (Roslyn) and Java analyzers** behind the sidecar protocol (the protocol + harness ship in 0.1; the analyzers need their language toolchains).
+- More baseline languages and richer framework awareness.
+
+## How it works
+
+```
+ source files ──▶ analyzer (deep | baseline) ──▶ graph (nodes + edges) ──▶ store ──▶ query ──▶ MCP tools
+```
+
+- **Graph model** — language-agnostic `nodes` (File, Module, Class, Interface, Enum, Function, Method, …) and `edges` (Defines, Calls, Inherits, Implements, UsesType, Imports, References, …). Each symbol gets a stable, location-independent id.
+- **Analyzers** — pluggable per language, each declaring its tier (`deep` or `baseline`). The TypeScript deep analyzer is the reference implementation.
+- **Store** — in-memory, or SQLite with full-text search for persistence.
+- **Query service** — search, call-graph traversal, code snippets, and impact analysis.
+- **MCP server** — exposes the query surface over stdio.
+
+## MCP tools
+
+| Tool | What it does |
+|---|---|
+| `index_repository(path)` | Build the graph for a directory or project. Run first. |
+| `index_status()` | What's indexed: node/edge counts, per-language coverage + tier. |
+| `search_symbol(query)` / `search_code(query)` | Find symbols by name, or search snippet text. |
+| `find_callers` / `find_callees` | Who calls a function/method, and what it calls. |
+| `find_referrers` / `find_imports` / `find_importers` | Where a symbol is used / what a file imports / who imports it. |
+| `impact_analysis(symbol)` | Transitive blast radius for change/test selection. |
+| `explore(question)` | Relevant symbols, a relationship map, and blast radius in one call. |
+| `get_code_snippet(symbol)` / `file_skeleton(file)` | A symbol's source, or a file's symbol outline. |
+
+…and more (overrides, interfaces, type users, routes → handlers, circular imports). Call `get_graph_schema()` for the full node/edge model, or `ama --help` for the CLI.
+
+## How Ama is built
+
+Ama improves itself by **dogfooding**: each change is made by using Ama's own tools on Ama's own source, and is only considered done once Ama can **re-index itself cleanly** — that self-index is the project's built-in regression test. Lessons learned along the way are recorded in [`docs/insights/`](docs/insights/README.md) so they compound over time. See [`docs/SELF_IMPROVEMENT_LOOP.md`](docs/SELF_IMPROVEMENT_LOOP.md) for the workflow and [`AGENTS.md`](AGENTS.md) for contributor and agent conventions.
+
+## Development
+
+> Requires **Node.js 24+**.
+
+```bash
+git clone https://github.com/mka-rainmaker/ama.git
+cd ama
+npm install
+npm run build       # compile TypeScript to dist/
+npm test            # run the test suite (vitest)
+npm run typecheck   # type-check without emitting
+```
+
+The backlog is tracked with [beads](https://github.com/steveyegge/beads) (`bd ready` to see what's actionable).
+
+## License
+
+[MIT](LICENSE) © 2026 Mykhaylo Katruk

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

@@ -0,0 +1,47 @@
+import type Parser from "web-tree-sitter";
+import type { AnalysisResult, Analyzer } from "../types.js";
+import { type SymbolRule } from "./walk.js";
+export type { SymbolRule };
+/**
+ * Describes a language for the {@link BaselineAnalyzer}: which extensions it
+ * owns, which bundled tree-sitter grammar to parse with, and which CST node
+ * types are symbols. Deep semantics (calls, types) are out of scope — baseline
+ * is syntactic breadth: files and the symbols they define.
+ */
+export interface LanguageSpec {
+    readonly language: string;
+    readonly extensions: readonly string[];
+    /** Key into the bundled grammar registry (see {@link parse}). */
+    readonly grammar: string;
+    /** CST node type → how to emit a symbol for it. */
+    readonly symbols: Readonly<Record<string, SymbolRule>>;
+    /**
+     * Optional import resolver: given an import CST node, the importing file's
+     * repo-relative path, and the index root, return each imported module as an
+     * ordered list of candidate repo-relative file paths — the analyzer emits a
+     * File→File `Imports` edge to the first candidate that exists on disk. Returns
+     * `undefined` for a non-import node, `[]` for an unresolvable (stdlib/third-party)
+     * import. `root` lets a config-aware language (Go's `go.mod`) resolve a
+     * module-qualified path; path-based languages can ignore it. (ama-8nr, ama-9yu)
+     */
+    readonly resolveImports?: (node: Parser.SyntaxNode, importerRel: string, root: string) => string[][] | undefined;
+}
+/**
+ * A language-agnostic, syntactic (tier `baseline`) analyzer driven by a
+ * {@link LanguageSpec}. It parses each file with tree-sitter and walks the CST,
+ * emitting a File node plus a node for every symbol the spec recognizes, with a
+ * `Defines` edge from the enclosing symbol (or the file) and a dotted
+ * qualified name for nested symbols. One instance handles one language.
+ */
+export declare class BaselineAnalyzer implements Analyzer {
+    private readonly spec;
+    readonly tier = "baseline";
+    readonly language: string;
+    readonly extensions: readonly string[];
+    constructor(spec: LanguageSpec);
+    analyze(root: string, files: string[]): Promise<AnalysisResult>;
+    /** Walk the CST for import statements and emit a File→File `Imports` edge to
+     *  each imported module that resolves (by path) to a file on disk. (ama-8nr) */
+    private collectImports;
+}
+//# sourceMappingURL=analyzer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"analyzer.d.ts","sourceRoot":"","sources":["../../../src/analyzers/baseline/analyzer.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,MAAM,MAAM,iBAAiB,CAAC;AAE1C,OAAO,KAAK,EAAE,cAAc,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAE5D,OAAO,EAAE,KAAK,UAAU,EAAe,MAAM,WAAW,CAAC;AAEzD,YAAY,EAAE,UAAU,EAAE,CAAC;AAE3B;;;;;GAKG;AACH,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,UAAU,EAAE,SAAS,MAAM,EAAE,CAAC;IACvC,iEAAiE;IACjE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,mDAAmD;IACnD,QAAQ,CAAC,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC;IACvD;;;;;;;;OAQG;IACH,QAAQ,CAAC,cAAc,CAAC,EAAE,CACxB,IAAI,EAAE,MAAM,CAAC,UAAU,EACvB,WAAW,EAAE,MAAM,EACnB,IAAI,EAAE,MAAM,KACT,MAAM,EAAE,EAAE,GAAG,SAAS,CAAC;CAC7B;AAED;;;;;;GAMG;AACH,qBAAa,gBAAiB,YAAW,QAAQ;IAKnC,OAAO,CAAC,QAAQ,CAAC,IAAI;IAJjC,QAAQ,CAAC,IAAI,cAAc;IAC3B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,UAAU,EAAE,SAAS,MAAM,EAAE,CAAC;gBAEV,IAAI,EAAE,YAAY;IAKzC,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,cAAc,CAAC;IA8CrE;oFACgF;IAChF,OAAO,CAAC,cAAc;CAkBvB"}

package/dist/analyzers/baseline/analyzer.js

@@ -0,0 +1,84 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { fileId } from "../../graph/index.js";
+import { parse } from "./treesitter.js";
+import { walkSymbols } from "./walk.js";
+/**
+ * A language-agnostic, syntactic (tier `baseline`) analyzer driven by a
+ * {@link LanguageSpec}. It parses each file with tree-sitter and walks the CST,
+ * emitting a File node plus a node for every symbol the spec recognizes, with a
+ * `Defines` edge from the enclosing symbol (or the file) and a dotted
+ * qualified name for nested symbols. One instance handles one language.
+ */
+export class BaselineAnalyzer {
+    spec;
+    tier = "baseline";
+    language;
+    extensions;
+    constructor(spec) {
+        this.spec = spec;
+        this.language = spec.language;
+        this.extensions = spec.extensions;
+    }
+    async analyze(root, files) {
+        const nodes = [];
+        const edges = [];
+        for (const rel of files) {
+            // Per-file isolation: a single unreadable or unparseable file must not lose
+            // the whole language's batch — finer than the indexer's per-analyzer catch
+            // (ama-m8k.9). Build into local arrays and merge only on success, so a
+            // mid-walk throw leaves no partial nodes behind. (ama-eww)
+            try {
+                const code = fs.readFileSync(path.join(root, rel), "utf8");
+                const tree = await parse(this.spec.grammar, code);
+                // A web-tree-sitter Tree holds WASM memory; free it once walked so a large
+                // index doesn't accumulate one tree per file. `finally` covers a throw in
+                // walk. The extracted GraphNodes are plain copies, valid after delete. (ama-5o1)
+                try {
+                    const id = fileId(rel);
+                    const fileNodes = [
+                        {
+                            id,
+                            kind: "File",
+                            name: path.basename(rel),
+                            file: rel,
+                            qualifiedName: "",
+                            tier: "baseline",
+                            range: { startLine: 1, endLine: tree.rootNode.endPosition.row + 1 },
+                        },
+                    ];
+                    const fileEdges = [];
+                    walkSymbols(tree.rootNode, this.spec.symbols, rel, id, "", fileNodes, fileEdges);
+                    if (this.spec.resolveImports)
+                        this.collectImports(tree.rootNode, rel, root, id, fileEdges);
+                    nodes.push(...fileNodes);
+                    edges.push(...fileEdges);
+                }
+                finally {
+                    tree.delete();
+                }
+            }
+            catch (err) {
+                console.error(`[ama] ${this.spec.language} analyzer failed on ${rel}; skipping it. ` +
+                    `${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+        return { nodes, edges };
+    }
+    /** Walk the CST for import statements and emit a File→File `Imports` edge to
+     *  each imported module that resolves (by path) to a file on disk. (ama-8nr) */
+    collectImports(node, importerRel, root, fileNodeId, edges) {
+        const groups = this.spec.resolveImports?.(node, importerRel, root);
+        if (groups) {
+            for (const candidates of groups) {
+                const target = candidates.find((c) => fs.existsSync(path.join(root, c)));
+                if (target)
+                    edges.push({ from: fileNodeId, to: fileId(target), kind: "Imports" });
+            }
+        }
+        for (const child of node.namedChildren) {
+            this.collectImports(child, importerRel, root, fileNodeId, edges);
+        }
+    }
+}
+//# sourceMappingURL=analyzer.js.map

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

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

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

@@ -0,0 +1,12 @@
+import type { LanguageSpec } from "./analyzer.js";
+/**
+ * Baseline (syntactic) specs for C and C++. Both share a grammar family: structs,
+ * unions, enums, and typedefs carry a `name` field, while a `function_definition`
+ * nests its name in a `declarator` chain — the analyzer's `symbolName` drills that
+ * for us. C++ adds classes and namespaces; a method defined inline is a
+ * `function_definition` inside the class body, so it surfaces as a Function
+ * qualified under its class (e.g. `Sample.square`). (ama-s8q.9)
+ */
+export declare const cSpec: LanguageSpec;
+export declare const cppSpec: LanguageSpec;
+//# sourceMappingURL=c.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"c.d.ts","sourceRoot":"","sources":["../../../src/analyzers/baseline/c.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAiBlD;;;;;;;GAOG;AACH,eAAO,MAAM,KAAK,EAAE,YAYnB,CAAC;AAEF,eAAO,MAAM,OAAO,EAAE,YAerB,CAAC"}

package/dist/analyzers/baseline/c.js

@@ -0,0 +1,56 @@
+import * as path from "node:path";
+/** Resolve a C/C++ `#include "foo.h"` to its header file. The quoted form is
+ *  relative to the including file's directory (and resolved on disk, like JS/Python
+ *  relative imports), so it's single-file-reindex-safe; the angle form `#include <…>`
+ *  is a system/include-path header (external) and resolves to nothing. (ama-ftg) */
+function includeImports(node, importerRel) {
+    if (node.type !== "preproc_include")
+        return undefined;
+    const lit = node.namedChildren.find((c) => c.type === "string_literal");
+    if (!lit)
+        return []; // `#include <…>` (system_lib_string) — external
+    const content = lit.namedChildren.find((c) => c.type === "string_content");
+    const includePath = (content?.text ?? lit.text.replace(/^"|"$/g, "")).trim();
+    if (!includePath)
+        return [];
+    // join() normalizes `..`, so `#include "../inc/x.h"` from `src/a.c` → `inc/x.h`.
+    return [[path.posix.join(path.posix.dirname(importerRel), includePath)]];
+}
+/**
+ * Baseline (syntactic) specs for C and C++. Both share a grammar family: structs,
+ * unions, enums, and typedefs carry a `name` field, while a `function_definition`
+ * nests its name in a `declarator` chain — the analyzer's `symbolName` drills that
+ * for us. C++ adds classes and namespaces; a method defined inline is a
+ * `function_definition` inside the class body, so it surfaces as a Function
+ * qualified under its class (e.g. `Sample.square`). (ama-s8q.9)
+ */
+export const cSpec = {
+    language: "c",
+    extensions: [".c"],
+    grammar: "c",
+    symbols: {
+        function_definition: { kind: "Function" },
+        struct_specifier: { kind: "Class" },
+        union_specifier: { kind: "Class" },
+        enum_specifier: { kind: "Enum" },
+        type_definition: { kind: "TypeAlias" },
+    },
+    resolveImports: includeImports,
+};
+export const cppSpec = {
+    language: "cpp",
+    // `.h` routes here: the C++ grammar is a superset, so it parses C headers too.
+    extensions: [".cpp", ".cc", ".cxx", ".hpp", ".hh", ".h"],
+    grammar: "cpp",
+    symbols: {
+        function_definition: { kind: "Function" },
+        struct_specifier: { kind: "Class" },
+        union_specifier: { kind: "Class" },
+        enum_specifier: { kind: "Enum" },
+        type_definition: { kind: "TypeAlias" },
+        class_specifier: { kind: "Class" },
+        namespace_definition: { kind: "Module" },
+    },
+    resolveImports: includeImports,
+};
+//# sourceMappingURL=c.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"c.js","sourceRoot":"","sources":["../../../src/analyzers/baseline/c.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,IAAI,MAAM,WAAW,CAAC;AAIlC;;;oFAGoF;AACpF,SAAS,cAAc,CAAC,IAAuB,EAAE,WAAmB;IAClE,IAAI,IAAI,CAAC,IAAI,KAAK,iBAAiB;QAAE,OAAO,SAAS,CAAC;IACtD,MAAM,GAAG,GAAG,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,gBAAgB,CAAC,CAAC;IACxE,IAAI,CAAC,GAAG;QAAE,OAAO,EAAE,CAAC,CAAC,gDAAgD;IACrE,MAAM,OAAO,GAAG,GAAG,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,gBAAgB,CAAC,CAAC;IAC3E,MAAM,WAAW,GAAG,CAAC,OAAO,EAAE,IAAI,IAAI,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;IAC7E,IAAI,CAAC,WAAW;QAAE,OAAO,EAAE,CAAC;IAC5B,iFAAiF;IACjF,OAAO,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,WAAW,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC,CAAC;AAC3E,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,KAAK,GAAiB;IACjC,QAAQ,EAAE,GAAG;IACb,UAAU,EAAE,CAAC,IAAI,CAAC;IAClB,OAAO,EAAE,GAAG;IACZ,OAAO,EAAE;QACP,mBAAmB,EAAE,EAAE,IAAI,EAAE,UAAU,EAAE;QACzC,gBAAgB,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE;QACnC,eAAe,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE;QAClC,cAAc,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE;QAChC,eAAe,EAAE,EAAE,IAAI,EAAE,WAAW,EAAE;KACvC;IACD,cAAc,EAAE,cAAc;CAC/B,CAAC;AAEF,MAAM,CAAC,MAAM,OAAO,GAAiB;IACnC,QAAQ,EAAE,KAAK;IACf,+EAA+E;IAC/E,UAAU,EAAE,CAAC,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,CAAC;IACxD,OAAO,EAAE,KAAK;IACd,OAAO,EAAE;QACP,mBAAmB,EAAE,EAAE,IAAI,EAAE,UAAU,EAAE;QACzC,gBAAgB,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE;QACnC,eAAe,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE;QAClC,cAAc,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE;QAChC,eAAe,EAAE,EAAE,IAAI,EAAE,WAAW,EAAE;QACtC,eAAe,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE;QAClC,oBAAoB,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE;KACzC;IACD,cAAc,EAAE,cAAc;CAC/B,CAAC"}

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

@@ -0,0 +1,21 @@
+/** The repo-relative parent directory of a repo-relative path, with the repo root as
+ *  `""` (not `"."`). */
+export declare function parentDir(rel: string): string;
+/**
+ * The nearest project-config file at or above `dirRel` (walking up to the index root),
+ * parsed by `read` into a value, paired with the repo-relative directory it was found in
+ * — so a baseline analyzer resolves imports whether the index root *is* the package or
+ * merely contains it (a monorepo / Ama's own fixtures). `read(absDir)` returns the parsed
+ * config for that directory or `undefined` if there's none there. Results (including
+ * "none found") are memoized in `cache` per absolute directory, so a package isn't
+ * re-walked once per import. Shared by Go (`go.mod`), PHP (`composer.json`), and C#
+ * (`.csproj`). (ama-9yu, ama-x96, ama-66z)
+ */
+export declare function nearestConfig<T>(root: string, dirRel: string, read: (absDir: string) => T | undefined, cache: Map<string, {
+    dir: string;
+    value: T;
+} | null>): {
+    dir: string;
+    value: T;
+} | null;
+//# sourceMappingURL=config.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../src/analyzers/baseline/config.ts"],"names":[],"mappings":"AAEA;wBACwB;AACxB,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAG7C;AAED;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAC7B,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,CAAC,GAAG,SAAS,EACvC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,CAAC,CAAA;CAAE,GAAG,IAAI,CAAC,GACnD;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,CAAC,CAAA;CAAE,GAAG,IAAI,CAWlC"}

package/dist/analyzers/baseline/config.js

@@ -0,0 +1,32 @@
+import * as path from "node:path";
+/** The repo-relative parent directory of a repo-relative path, with the repo root as
+ *  `""` (not `"."`). */
+export function parentDir(rel) {
+    const p = path.posix.dirname(rel);
+    return p === "." ? "" : p;
+}
+/**
+ * The nearest project-config file at or above `dirRel` (walking up to the index root),
+ * parsed by `read` into a value, paired with the repo-relative directory it was found in
+ * — so a baseline analyzer resolves imports whether the index root *is* the package or
+ * merely contains it (a monorepo / Ama's own fixtures). `read(absDir)` returns the parsed
+ * config for that directory or `undefined` if there's none there. Results (including
+ * "none found") are memoized in `cache` per absolute directory, so a package isn't
+ * re-walked once per import. Shared by Go (`go.mod`), PHP (`composer.json`), and C#
+ * (`.csproj`). (ama-9yu, ama-x96, ama-66z)
+ */
+export function nearestConfig(root, dirRel, read, cache) {
+    const absDir = path.join(root, dirRel);
+    const cached = cache.get(absDir);
+    if (cached !== undefined)
+        return cached;
+    let result = null;
+    const value = read(absDir);
+    if (value !== undefined)
+        result = { dir: dirRel, value };
+    else if (dirRel !== "" && dirRel !== ".")
+        result = nearestConfig(root, parentDir(dirRel), read, cache);
+    cache.set(absDir, result);
+    return result;
+}
+//# sourceMappingURL=config.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"config.js","sourceRoot":"","sources":["../../../src/analyzers/baseline/config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,IAAI,MAAM,WAAW,CAAC;AAElC;wBACwB;AACxB,MAAM,UAAU,SAAS,CAAC,GAAW;IACnC,MAAM,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;IAClC,OAAO,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;AAC5B,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,aAAa,CAC3B,IAAY,EACZ,MAAc,EACd,IAAuC,EACvC,KAAoD;IAEpD,MAAM,MAAM,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;IACvC,MAAM,MAAM,GAAG,KAAK,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;IACjC,IAAI,MAAM,KAAK,SAAS;QAAE,OAAO,MAAM,CAAC;IACxC,IAAI,MAAM,GAAqC,IAAI,CAAC;IACpD,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC;IAC3B,IAAI,KAAK,KAAK,SAAS;QAAE,MAAM,GAAG,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC;SACpD,IAAI,MAAM,KAAK,EAAE,IAAI,MAAM,KAAK,GAAG;QACtC,MAAM,GAAG,aAAa,CAAC,IAAI,EAAE,SAAS,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC;IAC/D,KAAK,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC1B,OAAO,MAAM,CAAC;AAChB,CAAC"}

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

@@ -0,0 +1,9 @@
+import type { LanguageSpec } from "./analyzer.js";
+/**
+ * Baseline (syntactic) spec for C#. Like Java, every kind has its own CST node
+ * type. Structs and records are value/data types with members, mapped to Class
+ * (the graph has no dedicated struct/record kind); methods nest under their
+ * type's body (e.g. `Sample.Square`).
+ */
+export declare const csharpSpec: LanguageSpec;
+//# sourceMappingURL=csharp.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"csharp.d.ts","sourceRoot":"","sources":["../../../src/analyzers/baseline/csharp.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AA2FlD;;;;;GAKG;AACH,eAAO,MAAM,UAAU,EAAE,YAaxB,CAAC"}

package/dist/analyzers/baseline/csharp.js

@@ -0,0 +1,107 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { nearestConfig, parentDir } from "./config.js";
+import { ancestorDirs } from "./paths.js";
+/** Cache for the nearest `.csproj`'s root namespace, by importer directory. */
+const csprojCache = new Map();
+/** The C# root namespace declared by a `.csproj` in `absDir` — its `<RootNamespace>`, or
+ *  (the C# default) the project file's base name. Undefined when `absDir` holds no
+ *  `.csproj`, so the walk-up continues. (ama-66z) */
+function readCsprojRootNamespace(absDir) {
+    let entries;
+    try {
+        entries = fs.readdirSync(absDir, { withFileTypes: true });
+    }
+    catch {
+        return undefined;
+    }
+    const proj = entries.find((e) => e.isFile() && e.name.endsWith(".csproj"));
+    if (!proj)
+        return undefined;
+    try {
+        const content = fs.readFileSync(path.join(absDir, proj.name), "utf8");
+        return (content.match(/<RootNamespace>\s*([^<\s]+)\s*<\/RootNamespace>/)?.[1] ??
+            proj.name.replace(/\.csproj$/i, ""));
+    }
+    catch {
+        return proj.name.replace(/\.csproj$/i, ""); // unreadable body — default to the file name
+    }
+}
+/** The `.cs` files directly in repo-relative `rel` (excluding the importer), one
+ *  File→File candidate group each — or undefined if `rel` isn't a directory or holds no
+ *  `.cs` files. */
+function csFilesIn(root, rel, importerRel) {
+    let entries;
+    try {
+        entries = fs.readdirSync(path.join(root, rel), { withFileTypes: true });
+    }
+    catch {
+        return undefined; // not a directory on disk
+    }
+    const files = entries
+        .filter((e) => e.isFile() && e.name.endsWith(".cs"))
+        .map((e) => (rel ? `${rel}/${e.name}` : e.name))
+        .filter((f) => f !== importerRel);
+    return files.length > 0 ? files.map((f) => [f]) : undefined;
+}
+/** Resolve a C# `using A.B.C;` to the source files of that namespace. C# has no 1:1
+ *  namespace→file mapping: a namespace is a *set* of files, conventionally a directory,
+ *  so a `using` links to every `.cs` file in the matching directory — the "package =
+ *  directory" shape Go has. Two strategies, precise first: (1) if the namespace is under
+ *  the nearest `.csproj`'s root namespace (`<RootNamespace>`, else the project file
+ *  name), map it *exactly* to that project's directory tree — avoiding a coincidental
+ *  match at a closer ancestor. (2) Otherwise (a namespace from another project, or no
+ *  `.csproj`), ancestor-scan from the importer's own directory upward, trying
+ *  progressively shorter suffixes of the dotted name — longest (most specific) first —
+ *  and take the first directory holding `.cs` files; this favors recall. `using Alias =
+ *  …` and framework namespaces resolve to nothing. (ama-7e3, ama-66z) */
+function csharpImports(node, importerRel, root) {
+    if (node.type !== "using_directive")
+        return undefined;
+    if (node.namedChildren.some((c) => c.type === "name_equals"))
+        return []; // `using Alias = …;`
+    const name = node.namedChildren.find((c) => c.type === "qualified_name" || c.type === "identifier");
+    if (!name)
+        return [];
+    // (1) Precise: a namespace under this project's root namespace maps to an exact dir.
+    const proj = nearestConfig(root, parentDir(importerRel), readCsprojRootNamespace, csprojCache);
+    if (proj && (name.text === proj.value || name.text.startsWith(`${proj.value}.`))) {
+        const sub = name.text === proj.value ? "" : name.text.slice(proj.value.length + 1);
+        const exact = [proj.dir, sub.replace(/\./g, "/")].filter(Boolean).join("/");
+        const files = csFilesIn(root, exact, importerRel);
+        if (files)
+            return files;
+    }
+    // (2) Heuristic fallback: ancestor-scan + progressively shorter suffixes (recall).
+    const segments = name.text.split(".");
+    for (const ancestor of ancestorDirs(importerRel)) {
+        for (let len = segments.length; len >= 1; len--) {
+            const rel = [ancestor, ...segments.slice(segments.length - len)].filter(Boolean).join("/");
+            const files = csFilesIn(root, rel, importerRel);
+            if (files)
+                return files;
+        }
+    }
+    return []; // a framework/NuGet namespace, or none on disk
+}
+/**
+ * Baseline (syntactic) spec for C#. Like Java, every kind has its own CST node
+ * type. Structs and records are value/data types with members, mapped to Class
+ * (the graph has no dedicated struct/record kind); methods nest under their
+ * type's body (e.g. `Sample.Square`).
+ */
+export const csharpSpec = {
+    language: "csharp",
+    extensions: [".cs"],
+    grammar: "csharp",
+    symbols: {
+        class_declaration: { kind: "Class" },
+        interface_declaration: { kind: "Interface" },
+        struct_declaration: { kind: "Class" },
+        record_declaration: { kind: "Class" },
+        enum_declaration: { kind: "Enum" },
+        method_declaration: { kind: "Method" },
+    },
+    resolveImports: csharpImports,
+};
+//# sourceMappingURL=csharp.js.map

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

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

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

@@ -0,0 +1,11 @@
+import type { LanguageSpec } from "./analyzer.js";
+/**
+ * Baseline (syntactic) spec for Go. Go declares named types with a single
+ * `type_spec` node regardless of whether the body is a struct, interface, or
+ * alias — so it uses {@link SymbolRule.kindByChild} to refine: a `struct_type`
+ * child → Class, an `interface_type` child → Interface, else a TypeAlias.
+ * Methods are top-level `method_declaration`s (the receiver isn't a container),
+ * so they surface as Methods named for the function, not qualified by the type.
+ */
+export declare const goSpec: LanguageSpec;
+//# sourceMappingURL=go.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"go.d.ts","sourceRoot":"","sources":["../../../src/analyzers/baseline/go.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AA6ClD;;;;;;;GAOG;AACH,eAAO,MAAM,MAAM,EAAE,YAapB,CAAC"}