@mka-rainmaker/ama 0.1.0

package/dist/analyzers/baseline/go.js

@@ -0,0 +1,66 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { nearestConfig, parentDir } from "./config.js";
+/** Cache for the nearest `go.mod`'s declared module path, by importer directory. */
+const goModuleCache = new Map();
+/** The `module` path declared by a `go.mod` in `absDir`, or undefined if there's none. */
+function readGoModule(absDir) {
+    try {
+        return fs.readFileSync(path.join(absDir, "go.mod"), "utf8").match(/^module\s+(\S+)/m)?.[1];
+    }
+    catch {
+        return undefined; // no go.mod here — nearestConfig walks to the parent
+    }
+}
+/** Resolve a Go import to the `.go` files of its package directory. Go imports a
+ *  *package* (a directory), so the import links to every non-test `.go` file in it.
+ *  The import path is module-qualified (`<module>/<pkg>`); strip the module prefix
+ *  (from the nearest `go.mod`) to get the directory, relative to that `go.mod`.
+ *  Stdlib and third-party imports don't match the module, so they resolve to
+ *  nothing. (ama-9yu) */
+function goImports(node, importerRel, root) {
+    if (node.type !== "import_spec")
+        return undefined;
+    const str = node.namedChildren.find((c) => c.type === "interpreted_string_literal");
+    if (!str)
+        return [];
+    const importPath = str.text.replace(/^["`]|["`]$/g, "");
+    const mod = nearestConfig(root, parentDir(importerRel), readGoModule, goModuleCache);
+    if (!mod || (importPath !== mod.value && !importPath.startsWith(`${mod.value}/`)))
+        return [];
+    const sub = importPath === mod.value ? "" : importPath.slice(mod.value.length + 1);
+    const pkgDir = [mod.dir, sub].filter(Boolean).join("/");
+    let entries;
+    try {
+        entries = fs.readdirSync(path.join(root, pkgDir));
+    }
+    catch {
+        return [];
+    }
+    return entries
+        .filter((f) => f.endsWith(".go") && !f.endsWith("_test.go"))
+        .map((f) => [pkgDir ? `${pkgDir}/${f}` : f]);
+}
+/**
+ * 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 const goSpec = {
+    language: "go",
+    extensions: [".go"],
+    grammar: "go",
+    symbols: {
+        function_declaration: { kind: "Function" },
+        method_declaration: { kind: "Method" },
+        type_spec: {
+            kind: "TypeAlias",
+            kindByChild: { struct_type: "Class", interface_type: "Interface" },
+        },
+    },
+    resolveImports: goImports,
+};
+//# sourceMappingURL=go.js.map

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

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

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

@@ -0,0 +1,9 @@
+import type { LanguageSpec } from "./analyzer.js";
+/**
+ * Baseline (syntactic) spec for Java. Java gives every kind its own CST node
+ * type — class/interface/enum declarations and methods — so each maps directly
+ * to the right graph kind, and methods (inside a class/interface body) qualify
+ * cleanly under their type (e.g. `Sample.square`).
+ */
+export declare const javaSpec: LanguageSpec;
+//# sourceMappingURL=java.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"java.d.ts","sourceRoot":"","sources":["../../../src/analyzers/baseline/java.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAiClD;;;;;GAKG;AACH,eAAO,MAAM,QAAQ,EAAE,YAWtB,CAAC"}

package/dist/analyzers/baseline/java.js

@@ -0,0 +1,50 @@
+import { ancestorDirs } from "./paths.js";
+/** Try a repo-relative file under every ancestor directory of the importer. A
+ *  package import gives a *source-root-relative* path (`com/example/Foo.java`)
+ *  but not the source root itself (`src/main/java`), which varies by build tool —
+ *  so the correct root is simply whichever ancestor makes the file exist. Disk-
+ *  based (via the analyzer's existsSync), so it's single-file-reindex-safe. */
+function ancestorCandidates(importerRel, file) {
+    return ancestorDirs(importerRel).map((d) => (d ? `${d}/${file}` : file));
+}
+/** Resolve a Java `import a.b.C;` to its class file. Java's convention (lowercase
+ *  packages, PascalCase types) lets one rule cover regular, `static`, and nested
+ *  imports: the class file is the dotted name up to and including the first
+ *  PascalCase segment — trailing segments are a static member or a nested type,
+ *  which live in that same file. `import a.b.*;` (wildcard) targets a package, not
+ *  a file, and is skipped; an unresolved (JDK/dependency) import simply matches no
+ *  file on disk. (ama-bsj) */
+function javaImports(node, importerRel) {
+    if (node.type !== "import_declaration")
+        return undefined;
+    if (node.namedChildren.some((c) => c.type === "asterisk"))
+        return []; // wildcard import
+    const scoped = node.namedChildren.find((c) => c.type === "scoped_identifier" || c.type === "identifier");
+    if (!scoped)
+        return [];
+    const segments = scoped.text.split(".");
+    const classEnd = segments.findIndex((s) => /^[A-Z]/.test(s));
+    if (classEnd < 0)
+        return []; // no PascalCase (type) segment — nothing to resolve
+    const file = `${segments.slice(0, classEnd + 1).join("/")}.java`;
+    return [ancestorCandidates(importerRel, file)];
+}
+/**
+ * Baseline (syntactic) spec for Java. Java gives every kind its own CST node
+ * type — class/interface/enum declarations and methods — so each maps directly
+ * to the right graph kind, and methods (inside a class/interface body) qualify
+ * cleanly under their type (e.g. `Sample.square`).
+ */
+export const javaSpec = {
+    language: "java",
+    extensions: [".java"],
+    grammar: "java",
+    symbols: {
+        class_declaration: { kind: "Class" },
+        interface_declaration: { kind: "Interface" },
+        enum_declaration: { kind: "Enum" },
+        method_declaration: { kind: "Method" },
+    },
+    resolveImports: javaImports,
+};
+//# sourceMappingURL=java.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"java.js","sourceRoot":"","sources":["../../../src/analyzers/baseline/java.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAE1C;;;;+EAI+E;AAC/E,SAAS,kBAAkB,CAAC,WAAmB,EAAE,IAAY;IAC3D,OAAO,YAAY,CAAC,WAAW,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,IAAI,IAAI,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC;AAC3E,CAAC;AAED;;;;;;8BAM8B;AAC9B,SAAS,WAAW,CAAC,IAAuB,EAAE,WAAmB;IAC/D,IAAI,IAAI,CAAC,IAAI,KAAK,oBAAoB;QAAE,OAAO,SAAS,CAAC;IACzD,IAAI,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,UAAU,CAAC;QAAE,OAAO,EAAE,CAAC,CAAC,kBAAkB;IACxF,MAAM,MAAM,GAAG,IAAI,CAAC,aAAa,CAAC,IAAI,CACpC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,mBAAmB,IAAI,CAAC,CAAC,IAAI,KAAK,YAAY,CACjE,CAAC;IACF,IAAI,CAAC,MAAM;QAAE,OAAO,EAAE,CAAC;IACvB,MAAM,QAAQ,GAAG,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IACxC,MAAM,QAAQ,GAAG,QAAQ,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;IAC7D,IAAI,QAAQ,GAAG,CAAC;QAAE,OAAO,EAAE,CAAC,CAAC,oDAAoD;IACjF,MAAM,IAAI,GAAG,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC,EAAE,QAAQ,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC;IACjE,OAAO,CAAC,kBAAkB,CAAC,WAAW,EAAE,IAAI,CAAC,CAAC,CAAC;AACjD,CAAC;AAED;;;;;GAKG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAiB;IACpC,QAAQ,EAAE,MAAM;IAChB,UAAU,EAAE,CAAC,OAAO,CAAC;IACrB,OAAO,EAAE,MAAM;IACf,OAAO,EAAE;QACP,iBAAiB,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE;QACpC,qBAAqB,EAAE,EAAE,IAAI,EAAE,WAAW,EAAE;QAC5C,gBAAgB,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE;QAClC,kBAAkB,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE;KACvC;IACD,cAAc,EAAE,WAAW;CAC5B,CAAC"}

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

@@ -0,0 +1,10 @@
+import type { LanguageSpec } from "./analyzer.js";
+/**
+ * Baseline (syntactic) spec for JavaScript (and JSX — tree-sitter-javascript
+ * parses JSX too). Unlike Python, JS distinguishes methods syntactically
+ * (`method_definition`), so class methods surface as Method nodes qualified
+ * under their class. The `.ts`/`.tsx` extensions stay with the deep TypeScript
+ * analyzer; this claims the plain-JS variants.
+ */
+export declare const javascriptSpec: LanguageSpec;
+//# sourceMappingURL=javascript.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"javascript.d.ts","sourceRoot":"","sources":["../../../src/analyzers/baseline/javascript.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAoClD;;;;;;GAMG;AACH,eAAO,MAAM,cAAc,EAAE,YAW5B,CAAC"}

package/dist/analyzers/baseline/javascript.js

@@ -0,0 +1,55 @@
+import * as path from "node:path";
+const JS_EXTENSIONS = [".js", ".mjs", ".cjs", ".jsx"];
+/** Candidate repo-relative files for a relative JS specifier, resolved against the
+ *  importer's directory. An explicit extension is used as-is; otherwise each JS
+ *  extension and an `/index.*` variant is tried. A bare/package specifier (not
+ *  `./` or `../`) is external and yields no candidates. (ama-2dn) */
+function jsCandidates(specifier, importerRel) {
+    if (!specifier.startsWith("./") && !specifier.startsWith("../"))
+        return [];
+    const base = path.posix.join(path.posix.dirname(importerRel), specifier);
+    if (/\.(?:js|mjs|cjs|jsx)$/.test(specifier))
+        return [base];
+    return [...JS_EXTENSIONS.map((e) => base + e), ...JS_EXTENSIONS.map((e) => `${base}/index${e}`)];
+}
+/** Resolve a JS module dependency to candidate files: an ES `import`/`export … from`
+ *  (its `source` field) or a CommonJS `require("…")` call. (ama-2dn) */
+function jsImports(node, importerRel) {
+    let str = null;
+    if (node.type === "import_statement" || node.type === "export_statement") {
+        str = node.childForFieldName("source");
+    }
+    else if (node.type === "call_expression") {
+        const callee = node.childForFieldName("function");
+        if (callee?.type === "identifier" && callee.text === "require") {
+            str =
+                node.childForFieldName("arguments")?.namedChildren.find((c) => c.type === "string") ?? null;
+        }
+    }
+    if (!str)
+        return undefined;
+    const specifier = str.namedChildren.find((c) => c.type === "string_fragment")?.text ??
+        str.text.replace(/^['"`]|['"`]$/g, "");
+    const candidates = jsCandidates(specifier, importerRel);
+    return candidates.length > 0 ? [candidates] : [];
+}
+/**
+ * Baseline (syntactic) spec for JavaScript (and JSX — tree-sitter-javascript
+ * parses JSX too). Unlike Python, JS distinguishes methods syntactically
+ * (`method_definition`), so class methods surface as Method nodes qualified
+ * under their class. The `.ts`/`.tsx` extensions stay with the deep TypeScript
+ * analyzer; this claims the plain-JS variants.
+ */
+export const javascriptSpec = {
+    language: "javascript",
+    extensions: [".js", ".jsx", ".mjs", ".cjs"],
+    grammar: "javascript",
+    symbols: {
+        function_declaration: { kind: "Function" },
+        generator_function_declaration: { kind: "Function" },
+        class_declaration: { kind: "Class" },
+        method_definition: { kind: "Method" },
+    },
+    resolveImports: jsImports,
+};
+//# sourceMappingURL=javascript.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"javascript.js","sourceRoot":"","sources":["../../../src/analyzers/baseline/javascript.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,IAAI,MAAM,WAAW,CAAC;AAIlC,MAAM,aAAa,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;AAEtD;;;qEAGqE;AACrE,SAAS,YAAY,CAAC,SAAiB,EAAE,WAAmB;IAC1D,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,KAAK,CAAC;QAAE,OAAO,EAAE,CAAC;IAC3E,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,WAAW,CAAC,EAAE,SAAS,CAAC,CAAC;IACzE,IAAI,uBAAuB,CAAC,IAAI,CAAC,SAAS,CAAC;QAAE,OAAO,CAAC,IAAI,CAAC,CAAC;IAC3D,OAAO,CAAC,GAAG,aAAa,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,GAAG,CAAC,CAAC,EAAE,GAAG,aAAa,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,IAAI,SAAS,CAAC,EAAE,CAAC,CAAC,CAAC;AACnG,CAAC;AAED;wEACwE;AACxE,SAAS,SAAS,CAAC,IAAuB,EAAE,WAAmB;IAC7D,IAAI,GAAG,GAA6B,IAAI,CAAC;IACzC,IAAI,IAAI,CAAC,IAAI,KAAK,kBAAkB,IAAI,IAAI,CAAC,IAAI,KAAK,kBAAkB,EAAE,CAAC;QACzE,GAAG,GAAG,IAAI,CAAC,iBAAiB,CAAC,QAAQ,CAAC,CAAC;IACzC,CAAC;SAAM,IAAI,IAAI,CAAC,IAAI,KAAK,iBAAiB,EAAE,CAAC;QAC3C,MAAM,MAAM,GAAG,IAAI,CAAC,iBAAiB,CAAC,UAAU,CAAC,CAAC;QAClD,IAAI,MAAM,EAAE,IAAI,KAAK,YAAY,IAAI,MAAM,CAAC,IAAI,KAAK,SAAS,EAAE,CAAC;YAC/D,GAAG;gBACD,IAAI,CAAC,iBAAiB,CAAC,WAAW,CAAC,EAAE,aAAa,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,QAAQ,CAAC,IAAI,IAAI,CAAC;QAChG,CAAC;IACH,CAAC;IACD,IAAI,CAAC,GAAG;QAAE,OAAO,SAAS,CAAC;IAC3B,MAAM,SAAS,GACb,GAAG,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,iBAAiB,CAAC,EAAE,IAAI;QACjE,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,gBAAgB,EAAE,EAAE,CAAC,CAAC;IACzC,MAAM,UAAU,GAAG,YAAY,CAAC,SAAS,EAAE,WAAW,CAAC,CAAC;IACxD,OAAO,UAAU,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;AACnD,CAAC;AAED;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,cAAc,GAAiB;IAC1C,QAAQ,EAAE,YAAY;IACtB,UAAU,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC;IAC3C,OAAO,EAAE,YAAY;IACrB,OAAO,EAAE;QACP,oBAAoB,EAAE,EAAE,IAAI,EAAE,UAAU,EAAE;QAC1C,8BAA8B,EAAE,EAAE,IAAI,EAAE,UAAU,EAAE;QACpD,iBAAiB,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE;QACpC,iBAAiB,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE;KACtC;IACD,cAAc,EAAE,SAAS;CAC1B,CAAC"}

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

@@ -0,0 +1,11 @@
+import type { LanguageSpec } from "./analyzer.js";
+/**
+ * Baseline (syntactic) spec for Kotlin. tree-sitter-kotlin uses one
+ * `class_declaration` for class / interface / enum class (refined to Enum by its
+ * `enum_class_body`; interfaces stay Class at this tier), `object_declaration`
+ * for singletons, and `function_declaration` for functions — methods nest under
+ * their class (e.g. `Sample.square`). None carry a `name` field, so the analyzer
+ * reads the name from the first identifier child. (ama-0ze)
+ */
+export declare const kotlinSpec: LanguageSpec;
+//# sourceMappingURL=kotlin.d.ts.map

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

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

package/dist/analyzers/baseline/kotlin.js

@@ -0,0 +1,67 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { ancestorDirs } from "./paths.js";
+/** Resolve a Kotlin `import a.b.C` to the source files of its package. Kotlin file
+ *  naming is free-form (a file holds any number of declarations and need not be named
+ *  after a class), so — like Go's "package = directory" — a `import` links to every
+ *  `.kt` file in the package's directory rather than to one file. The package is the
+ *  dotted name with its trailing symbol dropped: segments before the first PascalCase
+ *  one (Java's class-boundary heuristic), or all-but-last for an all-lowercase member
+ *  import; a `*` wildcard imports the package itself, so nothing is dropped. The
+ *  directory lives under a source root (e.g. `src/main/kotlin`), found by ancestor-scan;
+ *  a framework/stdlib package matches nothing on disk. (ama-e23) */
+function kotlinImports(node, importerRel, root) {
+    if (node.type !== "import_header")
+        return undefined;
+    const id = node.namedChildren.find((c) => c.type === "identifier");
+    if (!id)
+        return [];
+    const segments = id.text.split(".");
+    const wildcard = node.namedChildren.some((c) => c.type === "wildcard_import");
+    const pascal = segments.findIndex((s) => /^[A-Z]/.test(s));
+    const pkg = wildcard
+        ? segments // `import a.b.*` → the package is a.b
+        : pascal >= 0
+            ? segments.slice(0, pascal) // `import a.b.C` → package a.b (C is the type)
+            : segments.slice(0, -1); // `import a.b.foo` → package a.b (foo is a member)
+    if (pkg.length === 0)
+        return [];
+    const pkgPath = pkg.join("/");
+    for (const ancestor of ancestorDirs(importerRel)) {
+        const rel = ancestor ? `${ancestor}/${pkgPath}` : pkgPath;
+        let entries;
+        try {
+            entries = fs.readdirSync(path.join(root, rel), { withFileTypes: true });
+        }
+        catch {
+            continue; // not a directory under this ancestor
+        }
+        const files = entries
+            .filter((e) => e.isFile() && (e.name.endsWith(".kt") || e.name.endsWith(".kts")))
+            .map((e) => `${rel}/${e.name}`)
+            .filter((f) => f !== importerRel);
+        if (files.length > 0)
+            return files.map((f) => [f]); // one File→File edge per .kt file
+    }
+    return []; // a stdlib/framework package, or none on disk
+}
+/**
+ * Baseline (syntactic) spec for Kotlin. tree-sitter-kotlin uses one
+ * `class_declaration` for class / interface / enum class (refined to Enum by its
+ * `enum_class_body`; interfaces stay Class at this tier), `object_declaration`
+ * for singletons, and `function_declaration` for functions — methods nest under
+ * their class (e.g. `Sample.square`). None carry a `name` field, so the analyzer
+ * reads the name from the first identifier child. (ama-0ze)
+ */
+export const kotlinSpec = {
+    language: "kotlin",
+    extensions: [".kt", ".kts"],
+    grammar: "kotlin",
+    symbols: {
+        class_declaration: { kind: "Class", kindByChild: { enum_class_body: "Enum" } },
+        object_declaration: { kind: "Class" },
+        function_declaration: { kind: "Function" },
+    },
+    resolveImports: kotlinImports,
+};
+//# sourceMappingURL=kotlin.js.map

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

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

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

@@ -0,0 +1,6 @@
+/** Ancestor directories of a repo-relative file, closest first, ending at the repo
+ *  root (""). The importer's own directory is first. Shared by the baseline import
+ *  resolvers that locate a package/namespace directory or a source root relative to
+ *  the importing file rather than the index root (Java, C#, Kotlin). (ama-mgn) */
+export declare function ancestorDirs(rel: string): string[];
+//# sourceMappingURL=paths.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"paths.d.ts","sourceRoot":"","sources":["../../../src/analyzers/baseline/paths.ts"],"names":[],"mappings":"AAEA;;;kFAGkF;AAClF,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,CASlD"}

package/dist/analyzers/baseline/paths.js

@@ -0,0 +1,17 @@
+import * as path from "node:path";
+/** Ancestor directories of a repo-relative file, closest first, ending at the repo
+ *  root (""). The importer's own directory is first. Shared by the baseline import
+ *  resolvers that locate a package/namespace directory or a source root relative to
+ *  the importing file rather than the index root (Java, C#, Kotlin). (ama-mgn) */
+export function ancestorDirs(rel) {
+    const dirs = [];
+    let dir = path.posix.dirname(rel);
+    while (true) {
+        dirs.push(dir === "." ? "" : dir);
+        if (dir === "." || dir === "")
+            break;
+        dir = path.posix.dirname(dir);
+    }
+    return dirs;
+}
+//# sourceMappingURL=paths.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"paths.js","sourceRoot":"","sources":["../../../src/analyzers/baseline/paths.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,IAAI,MAAM,WAAW,CAAC;AAElC;;;kFAGkF;AAClF,MAAM,UAAU,YAAY,CAAC,GAAW;IACtC,MAAM,IAAI,GAAa,EAAE,CAAC;IAC1B,IAAI,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;IAClC,OAAO,IAAI,EAAE,CAAC;QACZ,IAAI,CAAC,IAAI,CAAC,GAAG,KAAK,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;QAClC,IAAI,GAAG,KAAK,GAAG,IAAI,GAAG,KAAK,EAAE;YAAE,MAAM;QACrC,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;IAChC,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC"}

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

@@ -0,0 +1,11 @@
+import type { LanguageSpec } from "./analyzer.js";
+/**
+ * Baseline (syntactic) spec for PHP. Each top-level construct has its own CST
+ * node type — class/interface/trait/enum declarations, free functions, and
+ * methods inside a class body — so each maps directly to a graph kind, and
+ * methods qualify under their type (e.g. `Sample.square`). A trait is a set of
+ * reusable method implementations, so it's modelled as a Class (the closest
+ * kind); there's no dedicated Trait kind.
+ */
+export declare const phpSpec: LanguageSpec;
+//# sourceMappingURL=php.d.ts.map

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

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

package/dist/analyzers/baseline/php.js

@@ -0,0 +1,76 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { nearestConfig, parentDir } from "./config.js";
+/** Cache for the nearest composer.json's PSR-4 `[prefix, baseDir]` map, by directory. */
+const composerCache = new Map();
+/** The PSR-4 autoload prefix→directory map declared by a composer.json in `absDir`, or
+ *  undefined if there's none (or no `autoload.psr-4`). */
+function readComposerPsr4(absDir) {
+    try {
+        const json = JSON.parse(fs.readFileSync(path.join(absDir, "composer.json"), "utf8"));
+        const map = json?.autoload?.["psr-4"];
+        if (!map || typeof map !== "object")
+            return undefined;
+        const psr4 = [];
+        for (const [prefix, base] of Object.entries(map)) {
+            const dir = Array.isArray(base) ? base[0] : base; // a prefix may map to one dir or a list
+            if (typeof dir === "string")
+                psr4.push([prefix, dir.replace(/\/+$/, "")]);
+        }
+        return psr4;
+    }
+    catch {
+        return undefined; // no/invalid composer.json — nearestConfig walks to the parent
+    }
+}
+/** Resolve a PHP `use Vendor\Pkg\Klass;` to its class file via PSR-4. The class is
+ *  the whole fully-qualified name (one class = one file); the namespace→directory
+ *  mapping lives in composer.json's `autoload.psr-4`, so strip the longest matching
+ *  prefix and map the rest to a path under its base directory. A `use` whose
+ *  namespace matches no PSR-4 prefix (a third-party/global class) resolves to
+ *  nothing. (ama-x96) */
+function phpImports(node, importerRel, root) {
+    if (node.type !== "namespace_use_clause")
+        return undefined;
+    const qn = node.namedChildren.find((c) => c.type === "qualified_name");
+    if (!qn)
+        return [];
+    const fqn = qn.text.replace(/^\\/, ""); // a leading `\` just marks the FQN as absolute
+    const composer = nearestConfig(root, parentDir(importerRel), readComposerPsr4, composerCache);
+    if (!composer)
+        return [];
+    let best;
+    for (const [prefix, base] of composer.value) {
+        if (fqn.startsWith(prefix) && (!best || prefix.length > best.prefix.length)) {
+            best = { prefix, base };
+        }
+    }
+    if (!best)
+        return [];
+    const relPath = fqn.slice(best.prefix.length).replace(/\\/g, "/");
+    const file = [composer.dir, best.base, `${relPath}.php`].filter(Boolean).join("/");
+    return [[file]];
+}
+/**
+ * Baseline (syntactic) spec for PHP. Each top-level construct has its own CST
+ * node type — class/interface/trait/enum declarations, free functions, and
+ * methods inside a class body — so each maps directly to a graph kind, and
+ * methods qualify under their type (e.g. `Sample.square`). A trait is a set of
+ * reusable method implementations, so it's modelled as a Class (the closest
+ * kind); there's no dedicated Trait kind.
+ */
+export const phpSpec = {
+    language: "php",
+    extensions: [".php"],
+    grammar: "php",
+    symbols: {
+        class_declaration: { kind: "Class" },
+        interface_declaration: { kind: "Interface" },
+        trait_declaration: { kind: "Class" },
+        enum_declaration: { kind: "Enum" },
+        function_definition: { kind: "Function" },
+        method_declaration: { kind: "Method" },
+    },
+    resolveImports: phpImports,
+};
+//# sourceMappingURL=php.js.map

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

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

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

@@ -0,0 +1,10 @@
+import type { LanguageSpec } from "./analyzer.js";
+/**
+ * Baseline (syntactic) spec for Python. Functions and classes are the symbols
+ * worth a node; methods are `function_definition` too (Python doesn't
+ * distinguish them syntactically), so they surface as Functions qualified under
+ * their class (e.g. `Greeter.hello`). Decorated defs nest a `function_definition`
+ * inside a `decorated_definition`, which the analyzer's recursion already reaches.
+ */
+export declare const pythonSpec: LanguageSpec;
+//# sourceMappingURL=python.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"python.d.ts","sourceRoot":"","sources":["../../../src/analyzers/baseline/python.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAwClD;;;;;;GAMG;AACH,eAAO,MAAM,UAAU,EAAE,YASxB,CAAC"}

package/dist/analyzers/baseline/python.js

@@ -0,0 +1,63 @@
+import * as path from "node:path";
+/**
+ * Resolve a Python relative import (`from .x import y`, `from . import m`,
+ * `from ..pkg import z`) to candidate repo-relative module files. The leading
+ * dots count up from the importer's own package (one dot = its directory). An
+ * absolute import (`import os`, `from pkg import x`) resolves via `sys.path` — too
+ * ambiguous to back with a node — so it emits nothing. (ama-8nr)
+ */
+function pythonImports(node, importerRel) {
+    if (node.type !== "import_from_statement")
+        return undefined;
+    const relative = node.namedChildren.find((c) => c.type === "relative_import");
+    if (!relative)
+        return []; // `from pkg import x` — absolute, unresolvable here
+    const prefix = relative.namedChildren.find((c) => c.type === "import_prefix");
+    const dots = prefix ? prefix.text.length : 1;
+    // One dot = the importer's own package (its directory); each extra dot goes up.
+    let base = path.posix.dirname(importerRel);
+    for (let i = 1; i < dots; i++)
+        base = path.posix.dirname(base);
+    if (base === ".")
+        base = "";
+    const candidates = (segments) => {
+        const p = [base, ...segments].filter(Boolean).join("/");
+        return [`${p}.py`, `${p}/__init__.py`];
+    };
+    const segsOf = (dotted) => dotted.namedChildren.filter((c) => c.type === "identifier").map((c) => c.text);
+    const module = relative.namedChildren.find((c) => c.type === "dotted_name");
+    if (module)
+        return [candidates(segsOf(module))]; // `from .pkg.sub import x` → pkg/sub
+    // `from . import a, b` — each imported name is a submodule of the base package.
+    const groups = [];
+    for (const child of node.namedChildren) {
+        if (child === relative)
+            continue;
+        if (child.type === "dotted_name")
+            groups.push(candidates(segsOf(child)));
+        else if (child.type === "aliased_import") {
+            const dn = child.namedChildren.find((c) => c.type === "dotted_name");
+            if (dn)
+                groups.push(candidates(segsOf(dn)));
+        }
+    }
+    return groups;
+}
+/**
+ * Baseline (syntactic) spec for Python. Functions and classes are the symbols
+ * worth a node; methods are `function_definition` too (Python doesn't
+ * distinguish them syntactically), so they surface as Functions qualified under
+ * their class (e.g. `Greeter.hello`). Decorated defs nest a `function_definition`
+ * inside a `decorated_definition`, which the analyzer's recursion already reaches.
+ */
+export const pythonSpec = {
+    language: "python",
+    extensions: [".py"],
+    grammar: "python",
+    symbols: {
+        function_definition: { kind: "Function" },
+        class_definition: { kind: "Class" },
+    },
+    resolveImports: pythonImports,
+};
+//# sourceMappingURL=python.js.map

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

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

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

@@ -0,0 +1,10 @@
+import type { LanguageSpec } from "./analyzer.js";
+/**
+ * Baseline (syntactic) spec for Rust. Rust gives each kind its own node type, so
+ * the plain map suffices: struct → Class, enum → Enum, trait → Interface, fn →
+ * Function. Trait methods nest under the trait (`Shape.area`); methods defined
+ * in separate `impl` blocks are top-level `function_item`s (the impl isn't a
+ * container), so they surface unqualified — acceptable for a syntactic tier.
+ */
+export declare const rustSpec: LanguageSpec;
+//# sourceMappingURL=rust.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"rust.d.ts","sourceRoot":"","sources":["../../../src/analyzers/baseline/rust.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAuBlD;;;;;;GAMG;AACH,eAAO,MAAM,QAAQ,EAAE,YAatB,CAAC"}

package/dist/analyzers/baseline/rust.js

@@ -0,0 +1,45 @@
+import * as path from "node:path";
+/** Files whose `mod foo;` submodules live in the *same* directory (a crate root
+ *  or a `mod.rs`); any other `foo.rs` owns a `foo/` directory for its submodules. */
+const RUST_DIR_MODULES = new Set(["mod", "lib", "main"]);
+/** Resolve a Rust `mod foo;` file-module declaration to candidate files. An inline
+ *  `mod foo { … }` has a `declaration_list` body and declares no file. A submodule
+ *  sits beside the declaring file, except a non-`mod.rs`/`lib.rs`/`main.rs` file
+ *  owns a directory named after its stem (Rust 2018) — so `mod bar;` in `a/foo.rs`
+ *  is `a/foo/bar.rs`. `use` imports items, not files, and is skipped. (ama-90x) */
+function rustImports(node, importerRel) {
+    if (node.type !== "mod_item")
+        return undefined;
+    if (node.namedChildren.some((c) => c.type === "declaration_list"))
+        return []; // inline module
+    const name = node.childForFieldName("name")?.text;
+    if (!name)
+        return undefined;
+    const stem = path.posix.basename(importerRel, ".rs");
+    const dir = path.posix.dirname(importerRel);
+    const baseDir = RUST_DIR_MODULES.has(stem) ? dir : path.posix.join(dir, stem);
+    const base = baseDir === "." ? name : `${baseDir}/${name}`;
+    return [[`${base}.rs`, `${base}/mod.rs`]];
+}
+/**
+ * Baseline (syntactic) spec for Rust. Rust gives each kind its own node type, so
+ * the plain map suffices: struct → Class, enum → Enum, trait → Interface, fn →
+ * Function. Trait methods nest under the trait (`Shape.area`); methods defined
+ * in separate `impl` blocks are top-level `function_item`s (the impl isn't a
+ * container), so they surface unqualified — acceptable for a syntactic tier.
+ */
+export const rustSpec = {
+    language: "rust",
+    extensions: [".rs"],
+    grammar: "rust",
+    symbols: {
+        function_item: { kind: "Function" },
+        // A bodyless fn (trait method declaration, extern block) is a signature item.
+        function_signature_item: { kind: "Function" },
+        struct_item: { kind: "Class" },
+        enum_item: { kind: "Enum" },
+        trait_item: { kind: "Interface" },
+    },
+    resolveImports: rustImports,
+};
+//# sourceMappingURL=rust.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"rust.js","sourceRoot":"","sources":["../../../src/analyzers/baseline/rust.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,IAAI,MAAM,WAAW,CAAC;AAIlC;qFACqF;AACrF,MAAM,gBAAgB,GAAG,IAAI,GAAG,CAAC,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,CAAC,CAAC,CAAC;AAEzD;;;;mFAImF;AACnF,SAAS,WAAW,CAAC,IAAuB,EAAE,WAAmB;IAC/D,IAAI,IAAI,CAAC,IAAI,KAAK,UAAU;QAAE,OAAO,SAAS,CAAC;IAC/C,IAAI,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,kBAAkB,CAAC;QAAE,OAAO,EAAE,CAAC,CAAC,gBAAgB;IAC9F,MAAM,IAAI,GAAG,IAAI,CAAC,iBAAiB,CAAC,MAAM,CAAC,EAAE,IAAI,CAAC;IAClD,IAAI,CAAC,IAAI;QAAE,OAAO,SAAS,CAAC;IAC5B,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,WAAW,EAAE,KAAK,CAAC,CAAC;IACrD,MAAM,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC;IAC5C,MAAM,OAAO,GAAG,gBAAgB,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;IAC9E,MAAM,IAAI,GAAG,OAAO,KAAK,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,OAAO,IAAI,IAAI,EAAE,CAAC;IAC3D,OAAO,CAAC,CAAC,GAAG,IAAI,KAAK,EAAE,GAAG,IAAI,SAAS,CAAC,CAAC,CAAC;AAC5C,CAAC;AAED;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAiB;IACpC,QAAQ,EAAE,MAAM;IAChB,UAAU,EAAE,CAAC,KAAK,CAAC;IACnB,OAAO,EAAE,MAAM;IACf,OAAO,EAAE;QACP,aAAa,EAAE,EAAE,IAAI,EAAE,UAAU,EAAE;QACnC,8EAA8E;QAC9E,uBAAuB,EAAE,EAAE,IAAI,EAAE,UAAU,EAAE;QAC7C,WAAW,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE;QAC9B,SAAS,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE;QAC3B,UAAU,EAAE,EAAE,IAAI,EAAE,WAAW,EAAE;KAClC;IACD,cAAc,EAAE,WAAW;CAC5B,CAAC"}

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

@@ -0,0 +1,11 @@
+import type { LanguageSpec } from "./analyzer.js";
+/**
+ * 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 declare const swiftSpec: LanguageSpec;
+//# sourceMappingURL=swift.d.ts.map

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

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