@lsctech/polaris 0.1.0

package/dist/graph/adapter/kotlin-java/java-adapter.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JavaAdapter = void 0;
+exports.createJavaAdapter = createJavaAdapter;
+const node_path_1 = require("node:path");
+const java_extract_js_1 = require("./java-extract.js");
+const runtime_js_1 = require("./runtime.js");
+const DEFAULT_EXTENSIONS = [".java"];
+class JavaAdapter {
+    loadRuntime;
+    languageId = "java";
+    fileExtensions = DEFAULT_EXTENSIONS;
+    confidence = "high";
+    limitations = [
+        "Extracts declaration-level symbols only (classes/interfaces, methods, imports).",
+        "Does not resolve overloads, inherited methods, or semantic type relationships.",
+    ];
+    constructor(loadRuntime) {
+        this.loadRuntime = loadRuntime;
+    }
+    async extractSymbols(filePath, source) {
+        const language = detectLanguage(filePath);
+        if (!language) {
+            throw new Error(`Unsupported Java file extension: ${(0, node_path_1.extname)(filePath)}`);
+        }
+        const runtime = await this.loadRuntime();
+        const tree = runtime.parse(source, language);
+        return (0, java_extract_js_1.extractJavaSymbolsFromTree)(tree);
+    }
+    resolveImportSpecifier(specifier, _context) {
+        const trimmed = specifier.trim();
+        if (trimmed.length === 0) {
+            return null;
+        }
+        return trimmed;
+    }
+}
+exports.JavaAdapter = JavaAdapter;
+function createJavaAdapter(options = {}) {
+    return new JavaAdapter(options.loadRuntime ?? runtime_js_1.loadTreeSitterRuntime);
+}
+function detectLanguage(filePath) {
+    const extension = (0, node_path_1.extname)(filePath).toLowerCase();
+    return extension === ".java" ? "java" : null;
+}

package/dist/graph/adapter/kotlin-java/java-extract.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractJavaSymbolsFromTree = extractJavaSymbolsFromTree;
+const extract_common_js_1 = require("./extract-common.js");
+function extractJavaSymbolsFromTree(tree) {
+    const symbols = [];
+    (0, extract_common_js_1.walkNodes)(tree.rootNode, (node) => {
+        const symbol = toExtractedSymbol(node);
+        if (symbol) {
+            symbols.push(symbol);
+        }
+    });
+    return {
+        language: "java",
+        symbols: (0, extract_common_js_1.dedupeAndSortSymbols)(symbols),
+    };
+}
+function toExtractedSymbol(node) {
+    if (node.type === "import_declaration") {
+        return (0, extract_common_js_1.createSymbol)(node, "import", extractImportName(node), null, false);
+    }
+    if (node.type === "class_declaration" || node.type === "interface_declaration") {
+        return (0, extract_common_js_1.createSymbol)(node, "class", extractTypeName(node), null, isPublic(node.text));
+    }
+    if (node.type === "method_declaration") {
+        return (0, extract_common_js_1.createSymbol)(node, "method", extractMethodName(node), (0, extract_common_js_1.sanitizeSignature)(node.text), isPublic(node.text));
+    }
+    return null;
+}
+function extractTypeName(node) {
+    return (0, extract_common_js_1.extractDeclaredName)(node, IDENTIFIER_NODE_TYPES, /\b(?:class|interface)\s+([A-Za-z_][A-Za-z0-9_]*)/);
+}
+function extractMethodName(node) {
+    return (0, extract_common_js_1.extractDeclaredName)(node, IDENTIFIER_NODE_TYPES, /\b([A-Za-z_][A-Za-z0-9_]*)\s*\(/);
+}
+function extractImportName(node) {
+    return node.text.match(/^\s*import\s+(?:static\s+)?([A-Za-z_][A-Za-z0-9_.$]*(?:\.\*)?)\s*;/m)?.[1] ?? null;
+}
+function isPublic(text) {
+    return /\bpublic\b/.test(text);
+}
+const IDENTIFIER_NODE_TYPES = new Set(["identifier", "type_identifier"]);

package/dist/graph/adapter/kotlin-java/kotlin-adapter.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KotlinAdapter = void 0;
+exports.createKotlinAdapter = createKotlinAdapter;
+const node_path_1 = require("node:path");
+const kotlin_extract_js_1 = require("./kotlin-extract.js");
+const runtime_js_1 = require("./runtime.js");
+const DEFAULT_EXTENSIONS = [".kt", ".kts"];
+class KotlinAdapter {
+    loadRuntime;
+    languageId = "kotlin";
+    fileExtensions = DEFAULT_EXTENSIONS;
+    confidence = "medium";
+    limitations = [
+        "Extracts declaration-level symbols only (classes/objects, functions/methods, imports).",
+        "Uses tree-sitter-kotlin@0.3.x; newer language constructs may parse incompletely until grammar updates.",
+    ];
+    constructor(loadRuntime) {
+        this.loadRuntime = loadRuntime;
+    }
+    async extractSymbols(filePath, source) {
+        const language = detectLanguage(filePath);
+        if (!language) {
+            throw new Error(`Unsupported Kotlin file extension: ${(0, node_path_1.extname)(filePath)}`);
+        }
+        const runtime = await this.loadRuntime();
+        const tree = runtime.parse(source, language);
+        return (0, kotlin_extract_js_1.extractKotlinSymbolsFromTree)(tree);
+    }
+    resolveImportSpecifier(specifier, _context) {
+        const trimmed = specifier.trim();
+        if (trimmed.length === 0) {
+            return null;
+        }
+        return trimmed;
+    }
+}
+exports.KotlinAdapter = KotlinAdapter;
+function createKotlinAdapter(options = {}) {
+    return new KotlinAdapter(options.loadRuntime ?? runtime_js_1.loadTreeSitterRuntime);
+}
+function detectLanguage(filePath) {
+    const extension = (0, node_path_1.extname)(filePath).toLowerCase();
+    if (extension === ".kt" || extension === ".kts") {
+        return "kotlin";
+    }
+    return null;
+}

package/dist/graph/adapter/kotlin-java/kotlin-extract.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractKotlinSymbolsFromTree = extractKotlinSymbolsFromTree;
+const extract_common_js_1 = require("./extract-common.js");
+function extractKotlinSymbolsFromTree(tree) {
+    const symbols = [];
+    (0, extract_common_js_1.walkNodes)(tree.rootNode, (node) => {
+        const symbol = toExtractedSymbol(node);
+        if (symbol) {
+            symbols.push(symbol);
+        }
+    });
+    return {
+        language: "kotlin",
+        symbols: (0, extract_common_js_1.dedupeAndSortSymbols)(symbols),
+    };
+}
+function toExtractedSymbol(node) {
+    if (node.type === "import_header") {
+        return (0, extract_common_js_1.createSymbol)(node, "import", extractImportName(node), null, false);
+    }
+    if (node.type === "class_declaration" || node.type === "object_declaration") {
+        return (0, extract_common_js_1.createSymbol)(node, "class", extractTypeName(node), null, isExported(node.text));
+    }
+    if (node.type === "function_declaration") {
+        const kind = (0, extract_common_js_1.isMethodContext)(node, METHOD_CONTAINER_NODE_TYPES) ? "method" : "function";
+        return (0, extract_common_js_1.createSymbol)(node, kind, extractFunctionName(node), (0, extract_common_js_1.sanitizeSignature)(node.text), isExported(node.text));
+    }
+    return null;
+}
+function extractTypeName(node) {
+    return (0, extract_common_js_1.extractDeclaredName)(node, IDENTIFIER_NODE_TYPES, /\b(?:class|object)\s+([A-Za-z_][A-Za-z0-9_]*)/);
+}
+function extractFunctionName(node) {
+    return (0, extract_common_js_1.extractDeclaredName)(node, IDENTIFIER_NODE_TYPES, /\bfun\s+([A-Za-z_][A-Za-z0-9_]*)\s*\(/);
+}
+function extractImportName(node) {
+    return node.text.match(/^\s*import\s+([A-Za-z_][A-Za-z0-9_.*]*)\b/m)?.[1] ?? null;
+}
+function isExported(text) {
+    const headerText = getNodeHeader(text);
+    return !/\b(?:private|internal|protected)\b/.test(headerText);
+}
+function getNodeHeader(text) {
+    const openBrace = text.indexOf("{");
+    if (openBrace !== -1) {
+        return text.substring(0, openBrace);
+    }
+    return text;
+}
+const IDENTIFIER_NODE_TYPES = new Set(["identifier", "simple_identifier", "type_identifier"]);
+const METHOD_CONTAINER_NODE_TYPES = new Set([
+    "class_declaration",
+    "object_declaration",
+    "class_body",
+    "class_member_declarations",
+    "companion_object",
+]);

package/dist/graph/adapter/kotlin-java/runtime.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadTreeSitterRuntime = loadTreeSitterRuntime;
+let cachedRuntime = null;
+async function loadTreeSitterRuntime() {
+    if (cachedRuntime) {
+        return cachedRuntime;
+    }
+    const loaded = await loadTreeSitterModules();
+    const parserByLanguage = new Map();
+    cachedRuntime = {
+        parse(source, language) {
+            const parser = getOrCreateParser(language, loaded, parserByLanguage);
+            return parser.parse(source);
+        },
+    };
+    return cachedRuntime;
+}
+function getOrCreateParser(language, loaded, parserByLanguage) {
+    const existing = parserByLanguage.get(language);
+    if (existing) {
+        return existing;
+    }
+    const parser = new loaded.parserConstructor();
+    parser.setLanguage(loaded.languages[language]);
+    parserByLanguage.set(language, parser);
+    return parser;
+}
+async function loadTreeSitterModules() {
+    const dynamicImport = createDynamicImporter();
+    const [treeSitterModule, javaModule, kotlinModule] = await Promise.all([
+        dynamicImport("tree-sitter"),
+        dynamicImport("tree-sitter-java"),
+        dynamicImport("tree-sitter-kotlin"),
+    ]);
+    return {
+        parserConstructor: resolveParserConstructor(treeSitterModule),
+        languages: {
+            java: resolveGrammar(javaModule, "tree-sitter-java"),
+            kotlin: resolveGrammar(kotlinModule, "tree-sitter-kotlin"),
+        },
+    };
+}
+function createDynamicImporter() {
+    const importer = new Function("specifier", "return import(specifier);");
+    return (specifier) => importer(specifier);
+}
+function resolveParserConstructor(moduleValue) {
+    if (typeof moduleValue === "function") {
+        return moduleValue;
+    }
+    if (moduleValue && typeof moduleValue === "object") {
+        const directDefault = moduleValue.default;
+        if (typeof directDefault === "function") {
+            return directDefault;
+        }
+        const namedParser = moduleValue.Parser;
+        if (typeof namedParser === "function") {
+            return namedParser;
+        }
+    }
+    throw new Error("Unable to resolve tree-sitter parser constructor.");
+}
+function resolveGrammar(moduleValue, packageName) {
+    if (moduleValue && typeof moduleValue === "object") {
+        const directDefault = moduleValue.default;
+        if (directDefault) {
+            return directDefault;
+        }
+    }
+    if (moduleValue) {
+        return moduleValue;
+    }
+    throw new Error(`Unable to resolve ${packageName} grammar.`);
+}

package/dist/graph/adapter/python/adapter.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PythonAdapter = void 0;
+exports.createPythonAdapter = createPythonAdapter;
+const node_path_1 = require("node:path");
+const extract_js_1 = require("./extract.js");
+const runtime_js_1 = require("./runtime.js");
+const DEFAULT_EXTENSIONS = [".py", ".pyi"];
+class PythonAdapter {
+    loadRuntime;
+    languageId = "python";
+    fileExtensions = DEFAULT_EXTENSIONS;
+    confidence = "high";
+    limitations = [
+        "Extracts declaration-level symbols only (classes, functions, methods, imports).",
+        "Does not perform runtime import resolution or call/reference extraction.",
+    ];
+    constructor(loadRuntime) {
+        this.loadRuntime = loadRuntime;
+    }
+    async extractSymbols(filePath, source) {
+        const language = detectLanguage(filePath);
+        if (!language) {
+            throw new Error(`Unsupported Python file extension: ${(0, node_path_1.extname)(filePath)}`);
+        }
+        const runtime = await this.loadRuntime();
+        const tree = runtime.parse(source, language);
+        return (0, extract_js_1.extractPythonSymbolsFromTree)(tree);
+    }
+    resolveImportSpecifier(specifier, _context) {
+        const trimmed = specifier.trim();
+        if (trimmed.length === 0) {
+            return null;
+        }
+        return trimmed;
+    }
+}
+exports.PythonAdapter = PythonAdapter;
+function createPythonAdapter(options = {}) {
+    return new PythonAdapter(options.loadRuntime ?? runtime_js_1.loadTreeSitterRuntime);
+}
+function detectLanguage(filePath) {
+    const extension = (0, node_path_1.extname)(filePath).toLowerCase();
+    return extension === ".py" || extension === ".pyi" ? "python" : null;
+}

package/dist/graph/adapter/python/extract.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractPythonSymbolsFromTree = extractPythonSymbolsFromTree;
+function extractPythonSymbolsFromTree(tree) {
+    const symbols = [];
+    walkNode(tree.rootNode, symbols, 0, 0);
+    const deduped = dedupeSymbols(symbols);
+    deduped.sort(compareExtractedSymbols);
+    return {
+        language: "python",
+        symbols: deduped,
+    };
+}
+function walkNode(node, output, classDepth, functionDepth) {
+    const current = toExtractedSymbols(node, classDepth, functionDepth);
+    if (current.length > 0) {
+        output.push(...current);
+    }
+    const nextClassDepth = node.type === "class_definition" ? classDepth + 1 : classDepth;
+    const nextFunctionDepth = node.type === "function_definition" ? functionDepth + 1 : functionDepth;
+    for (const child of node.namedChildren ?? []) {
+        walkNode(child, output, nextClassDepth, nextFunctionDepth);
+    }
+}
+function toExtractedSymbols(node, classDepth, functionDepth) {
+    if (node.type === "class_definition") {
+        const name = extractClassName(node);
+        const symbol = buildSymbol(node, "class", name, null);
+        return symbol ? [symbol] : [];
+    }
+    if (node.type === "function_definition") {
+        const name = extractFunctionName(node);
+        const kind = (classDepth > 0 && functionDepth === 0) ? "method" : "function";
+        const signature = sanitizeSignature(node.text);
+        const symbol = buildSymbol(node, kind, name, signature);
+        return symbol ? [symbol] : [];
+    }
+    if (node.type === "import_statement") {
+        return extractImportNames(node).flatMap((name) => {
+            const symbol = buildSymbol(node, "import", name, null);
+            return symbol ? [symbol] : [];
+        });
+    }
+    if (node.type === "import_from_statement") {
+        const symbol = buildSymbol(node, "import", extractFromImportName(node), null);
+        return symbol ? [symbol] : [];
+    }
+    return [];
+}
+function buildSymbol(node, kind, name, signature) {
+    if (!name) {
+        return null;
+    }
+    return {
+        kind,
+        name,
+        signature,
+        exported: !name.startsWith("_"),
+        startLine: node.startPosition.row + 1,
+        startColumn: node.startPosition.column,
+        endLine: node.endPosition.row + 1,
+        endColumn: node.endPosition.column,
+    };
+}
+function extractClassName(node) {
+    const byField = node.childForFieldName?.("name");
+    if (byField?.text?.trim()) {
+        return byField.text.trim();
+    }
+    const byText = node.text.match(/\bclass\s+([A-Za-z_][A-Za-z0-9_]*)/);
+    return byText?.[1] ?? null;
+}
+function extractFunctionName(node) {
+    const byField = node.childForFieldName?.("name");
+    if (byField?.text?.trim()) {
+        return byField.text.trim();
+    }
+    const byText = node.text.match(/\bdef\s+([A-Za-z_][A-Za-z0-9_]*)\s*\(/);
+    return byText?.[1] ?? null;
+}
+function extractImportNames(node) {
+    const byText = node.text.match(/^\s*import\s+(.+)$/m)?.[1];
+    if (!byText) {
+        return [];
+    }
+    return byText
+        .split(",")
+        .map((part) => part.trim().replace(/\s+as\s+[A-Za-z_][A-Za-z0-9_]*$/, ""))
+        .filter((part) => part.length > 0);
+}
+function extractFromImportName(node) {
+    const byText = node.text.match(/^\s*from\s+([.\w]+)\s+import\b/m);
+    return byText?.[1] ?? null;
+}
+function sanitizeSignature(signature) {
+    const compact = signature.replace(/\s+/g, " ").trim();
+    return compact.length === 0 ? null : compact;
+}
+function dedupeSymbols(symbols) {
+    const byFingerprint = new Map();
+    for (const symbol of symbols) {
+        const fingerprint = [
+            symbol.kind,
+            symbol.name,
+            symbol.startLine,
+            symbol.startColumn,
+            symbol.endLine,
+            symbol.endColumn,
+        ].join(":");
+        byFingerprint.set(fingerprint, symbol);
+    }
+    return Array.from(byFingerprint.values());
+}
+function compareExtractedSymbols(left, right) {
+    return (left.startLine - right.startLine ||
+        left.startColumn - right.startColumn ||
+        left.endLine - right.endLine ||
+        left.endColumn - right.endColumn ||
+        left.kind.localeCompare(right.kind) ||
+        left.name.localeCompare(right.name));
+}

package/dist/graph/adapter/python/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadTreeSitterRuntime = exports.extractPythonSymbolsFromTree = exports.createPythonAdapter = exports.PythonAdapter = void 0;
+var adapter_js_1 = require("./adapter.js");
+Object.defineProperty(exports, "PythonAdapter", { enumerable: true, get: function () { return adapter_js_1.PythonAdapter; } });
+Object.defineProperty(exports, "createPythonAdapter", { enumerable: true, get: function () { return adapter_js_1.createPythonAdapter; } });
+var extract_js_1 = require("./extract.js");
+Object.defineProperty(exports, "extractPythonSymbolsFromTree", { enumerable: true, get: function () { return extract_js_1.extractPythonSymbolsFromTree; } });
+var runtime_js_1 = require("./runtime.js");
+Object.defineProperty(exports, "loadTreeSitterRuntime", { enumerable: true, get: function () { return runtime_js_1.loadTreeSitterRuntime; } });

package/dist/graph/adapter/python/runtime.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadTreeSitterRuntime = loadTreeSitterRuntime;
+let cachedRuntime = null;
+let runtimeInitPromise = null;
+async function loadTreeSitterRuntime() {
+    if (cachedRuntime) {
+        return cachedRuntime;
+    }
+    if (runtimeInitPromise) {
+        return await runtimeInitPromise;
+    }
+    runtimeInitPromise = (async () => {
+        const loaded = await loadTreeSitterModules();
+        const parser = new loaded.parserConstructor();
+        parser.setLanguage(loaded.language);
+        const runtime = {
+            parse(source) {
+                return parser.parse(source);
+            },
+        };
+        cachedRuntime = runtime;
+        runtimeInitPromise = null;
+        return runtime;
+    })();
+    return await runtimeInitPromise;
+}
+async function loadTreeSitterModules() {
+    const dynamicImport = createDynamicImporter();
+    const [treeSitterModule, pythonModule] = await Promise.all([
+        dynamicImport("tree-sitter"),
+        dynamicImport("tree-sitter-python"),
+    ]);
+    return {
+        parserConstructor: resolveParserConstructor(treeSitterModule),
+        language: resolveGrammar(pythonModule, "tree-sitter-python"),
+    };
+}
+function createDynamicImporter() {
+    const importer = new Function("specifier", "return import(specifier);");
+    return (specifier) => importer(specifier);
+}
+function resolveParserConstructor(moduleValue) {
+    if (typeof moduleValue === "function") {
+        return moduleValue;
+    }
+    if (moduleValue && typeof moduleValue === "object") {
+        const directDefault = moduleValue.default;
+        if (typeof directDefault === "function") {
+            return directDefault;
+        }
+        const namedParser = moduleValue.Parser;
+        if (typeof namedParser === "function") {
+            return namedParser;
+        }
+    }
+    throw new Error("Unable to resolve tree-sitter parser constructor.");
+}
+function resolveGrammar(moduleValue, packageName) {
+    if (moduleValue && typeof moduleValue === "object") {
+        const directDefault = moduleValue.default;
+        if (directDefault) {
+            return directDefault;
+        }
+    }
+    if (moduleValue) {
+        return moduleValue;
+    }
+    throw new Error(`Unable to resolve ${packageName} grammar.`);
+}

package/dist/graph/adapter/registry.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphAdapterRegistry = void 0;
+exports.getDefaultAdapterRegistry = getDefaultAdapterRegistry;
+const index_js_1 = require("./c/index.js");
+const index_js_2 = require("./cpp/index.js");
+const index_js_3 = require("./csharp/index.js");
+const index_js_4 = require("./dart/index.js");
+const index_js_5 = require("./go/index.js");
+const index_js_6 = require("./kotlin-java/index.js");
+const index_js_7 = require("./python/index.js");
+const index_js_8 = require("./rust/index.js");
+const index_js_9 = require("./shell/index.js");
+const index_js_10 = require("./svelte/index.js");
+const index_js_11 = require("./swift/index.js");
+const index_js_12 = require("./typescript-javascript/index.js");
+class GraphAdapterRegistry {
+    adaptersByLanguage = new Map();
+    adaptersByExtension = new Map();
+    register(adapter) {
+        if (this.adaptersByLanguage.has(adapter.languageId)) {
+            throw new Error(`Language adapter already registered: ${adapter.languageId}`);
+        }
+        // Validate all extensions first before mutating state
+        const normalizedExtensions = [];
+        for (const extension of adapter.fileExtensions) {
+            const normalized = normalizeExtension(extension);
+            const existing = this.adaptersByExtension.get(normalized);
+            if (existing) {
+                throw new Error(`File extension ${normalized} is already handled by adapter ${existing.languageId}`);
+            }
+            normalizedExtensions.push(normalized);
+        }
+        // Only mutate state after validation completes
+        this.adaptersByLanguage.set(adapter.languageId, adapter);
+        for (const normalized of normalizedExtensions) {
+            this.adaptersByExtension.set(normalized, adapter);
+        }
+    }
+    getForExtension(extension) {
+        if (!extension || extension.trim().length === 0) {
+            return null;
+        }
+        return this.adaptersByExtension.get(normalizeExtension(extension)) ?? null;
+    }
+    getSupportedExtensions() {
+        return Array.from(this.adaptersByExtension.keys()).sort((left, right) => left.localeCompare(right));
+    }
+    getAll() {
+        return Array.from(this.adaptersByLanguage.values());
+    }
+}
+exports.GraphAdapterRegistry = GraphAdapterRegistry;
+let defaultRegistry = null;
+function getDefaultAdapterRegistry() {
+    if (defaultRegistry) {
+        return defaultRegistry;
+    }
+    const registry = new GraphAdapterRegistry();
+    registry.register((0, index_js_12.createTypeScriptJavaScriptAdapter)());
+    registry.register((0, index_js_1.createCAdapter)());
+    registry.register((0, index_js_2.createCppAdapter)());
+    registry.register((0, index_js_3.createCSharpAdapter)());
+    registry.register((0, index_js_4.createDartAdapter)());
+    registry.register((0, index_js_5.createGoAdapter)());
+    registry.register((0, index_js_6.createJavaAdapter)());
+    registry.register((0, index_js_6.createKotlinAdapter)());
+    registry.register((0, index_js_7.createPythonAdapter)());
+    registry.register((0, index_js_8.createRustAdapter)());
+    registry.register((0, index_js_9.createShellAdapter)());
+    registry.register((0, index_js_10.createSvelteAdapter)());
+    registry.register((0, index_js_11.createSwiftAdapter)());
+    defaultRegistry = registry;
+    return defaultRegistry;
+}
+function normalizeExtension(extension) {
+    const trimmed = extension.trim().toLowerCase();
+    if (trimmed.length === 0) {
+        throw new Error("Adapter extension cannot be empty.");
+    }
+    return trimmed.startsWith(".") ? trimmed : `.${trimmed}`;
+}

package/dist/graph/adapter/rust/adapter.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RustAdapter = void 0;
+exports.createRustAdapter = createRustAdapter;
+const node_path_1 = require("node:path");
+const extract_js_1 = require("./extract.js");
+const runtime_js_1 = require("./runtime.js");
+const DEFAULT_EXTENSIONS = [".rs"];
+class RustAdapter {
+    loadRuntime;
+    languageId = "rust";
+    fileExtensions = DEFAULT_EXTENSIONS;
+    confidence = "high";
+    limitations = [
+        "Extracts declaration-level symbols only (types, functions, impl methods, use declarations).",
+        "Does not model lifetimes/generics as separate symbols or resolve call/reference edges.",
+    ];
+    constructor(loadRuntime) {
+        this.loadRuntime = loadRuntime;
+    }
+    async extractSymbols(filePath, source) {
+        const language = detectLanguage(filePath);
+        if (!language) {
+            throw new Error(`Unsupported Rust file extension: ${(0, node_path_1.extname)(filePath)}`);
+        }
+        const runtime = await this.loadRuntime();
+        const tree = runtime.parse(source, language);
+        return (0, extract_js_1.extractRustSymbolsFromTree)(tree);
+    }
+    resolveImportSpecifier(specifier, _context) {
+        const trimmed = specifier.trim();
+        if (trimmed.length === 0) {
+            return null;
+        }
+        return trimmed;
+    }
+}
+exports.RustAdapter = RustAdapter;
+function createRustAdapter(options = {}) {
+    return new RustAdapter(options.loadRuntime ?? runtime_js_1.loadTreeSitterRuntime);
+}
+function detectLanguage(filePath) {
+    const extension = (0, node_path_1.extname)(filePath).toLowerCase();
+    return extension === ".rs" ? "rust" : null;
+}