@lsctech/polaris 0.1.0

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

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractRustSymbolsFromTree = extractRustSymbolsFromTree;
+function extractRustSymbolsFromTree(tree) {
+    const symbols = [];
+    walkNode(tree.rootNode, symbols, false);
+    const deduped = dedupeSymbols(symbols);
+    deduped.sort(compareExtractedSymbols);
+    return {
+        language: "rust",
+        symbols: deduped,
+    };
+}
+function walkNode(node, output, insideImpl) {
+    const current = toExtractedSymbol(node, insideImpl);
+    if (current) {
+        output.push(current);
+    }
+    const nextInsideImpl = insideImpl || node.type === "impl_item";
+    for (const child of node.namedChildren ?? []) {
+        walkNode(child, output, nextInsideImpl);
+    }
+}
+function toExtractedSymbol(node, insideImpl) {
+    if (node.type === "use_declaration") {
+        return buildSymbol(node, "import", extractUseName(node), null);
+    }
+    if (node.type === "struct_item" || node.type === "enum_item" || node.type === "trait_item") {
+        return buildSymbol(node, "class", extractTypeName(node), null);
+    }
+    if (node.type === "function_item") {
+        const kind = insideImpl ? "method" : "function";
+        return buildSymbol(node, kind, extractFunctionName(node), sanitizeSignature(node.text));
+    }
+    return null;
+}
+function buildSymbol(node, kind, name, signature) {
+    if (!name) {
+        return null;
+    }
+    return {
+        kind,
+        name,
+        signature,
+        exported: /\bpub\b/.test(node.text),
+        startLine: node.startPosition.row + 1,
+        startColumn: node.startPosition.column,
+        endLine: node.endPosition.row + 1,
+        endColumn: node.endPosition.column,
+    };
+}
+function extractUseName(node) {
+    const argumentField = node.childForFieldName?.("argument");
+    if (argumentField?.text?.trim()) {
+        return argumentField.text.trim();
+    }
+    for (const child of node.namedChildren ?? []) {
+        if (child.type === "use_list" || child.type === "scoped_identifier" || child.type === "identifier") {
+            const text = child.text.trim();
+            if (text.length > 0) {
+                return text;
+            }
+        }
+    }
+    const byText = node.text.match(/^\s*(?:pub\s+)?use\s+([\s\S]+?)\s*;/m);
+    return byText?.[1] ?? null;
+}
+function extractTypeName(node) {
+    const byField = node.childForFieldName?.("name");
+    if (byField?.text?.trim()) {
+        return byField.text.trim();
+    }
+    const byText = node.text.match(/\b(struct|enum|trait)\s+([A-Za-z_][A-Za-z0-9_]*)/);
+    return byText?.[2] ?? null;
+}
+function extractFunctionName(node) {
+    const byField = node.childForFieldName?.("name");
+    if (byField?.text?.trim()) {
+        return byField.text.trim();
+    }
+    const byText = node.text.match(/\bfn\s+([A-Za-z_][A-Za-z0-9_]*)\s*\(/);
+    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/rust/index.js

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

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

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadTreeSitterRuntime = loadTreeSitterRuntime;
+let cachedRuntime = null;
+let cachedRuntimePromise = null;
+async function loadTreeSitterRuntime() {
+    if (cachedRuntime) {
+        return cachedRuntime;
+    }
+    if (cachedRuntimePromise) {
+        return await cachedRuntimePromise;
+    }
+    cachedRuntimePromise = (async () => {
+        try {
+            const loaded = await loadTreeSitterModules();
+            const parser = new loaded.parserConstructor();
+            parser.setLanguage(loaded.language);
+            const runtime = {
+                parse(source) {
+                    return parser.parse(source);
+                },
+            };
+            cachedRuntime = runtime;
+            return runtime;
+        }
+        finally {
+            cachedRuntimePromise = null;
+        }
+    })();
+    return await cachedRuntimePromise;
+}
+async function loadTreeSitterModules() {
+    const dynamicImport = createDynamicImporter();
+    const [treeSitterModule, rustModule] = await Promise.all([
+        dynamicImport("tree-sitter"),
+        dynamicImport("tree-sitter-rust"),
+    ]);
+    return {
+        parserConstructor: resolveParserConstructor(treeSitterModule),
+        language: resolveGrammar(rustModule, "tree-sitter-rust"),
+    };
+}
+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/shell/adapter.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ShellAdapter = void 0;
+exports.createShellAdapter = createShellAdapter;
+const node_path_1 = require("node:path");
+const extract_js_1 = require("./extract.js");
+const DEFAULT_EXTENSIONS = [".sh", ".bash", ".zsh"];
+class ShellAdapter {
+    languageId = "shell";
+    fileExtensions = DEFAULT_EXTENSIONS;
+    confidence = "low";
+    limitations = [
+        "Uses regex-based function extraction (phase 1 heuristic).",
+        "Does not parse shell includes (source/dot) or dynamic function definitions.",
+    ];
+    async extractSymbols(filePath, source) {
+        const extension = (0, node_path_1.extname)(filePath).toLowerCase();
+        if (!DEFAULT_EXTENSIONS.includes(extension)) {
+            throw new Error(`Unsupported shell file extension: ${extension}`);
+        }
+        return (0, extract_js_1.extractShellSymbolsFromSource)(source);
+    }
+    resolveImportSpecifier(specifier, _context) {
+        const trimmed = specifier.trim();
+        if (trimmed.length === 0) {
+            return null;
+        }
+        return trimmed;
+    }
+}
+exports.ShellAdapter = ShellAdapter;
+function createShellAdapter() {
+    return new ShellAdapter();
+}

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

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractShellSymbolsFromSource = extractShellSymbolsFromSource;
+function extractShellSymbolsFromSource(source) {
+    const symbols = [];
+    const lineStarts = buildLineStarts(source);
+    collectMatches(source, /^\s*function\s+([A-Za-z_][A-Za-z0-9_]*)\s*(?:\(\))?\s*\{/gm, symbols, lineStarts);
+    collectMatches(source, /^\s*([A-Za-z_][A-Za-z0-9_]*)\s*\(\)\s*\{/gm, symbols, lineStarts, true);
+    const deduped = dedupeSymbols(symbols);
+    deduped.sort(compareExtractedSymbols);
+    return {
+        language: "shell",
+        symbols: deduped,
+    };
+}
+function collectMatches(source, pattern, output, lineStarts, skipKeywords = false) {
+    let match;
+    while ((match = pattern.exec(source)) !== null) {
+        const name = match[1];
+        if (!name) {
+            continue;
+        }
+        if (skipKeywords && SHELL_KEYWORDS.has(name)) {
+            continue;
+        }
+        const startIndex = match.index;
+        const endIndex = startIndex + match[0].length;
+        const start = indexToPoint(startIndex, lineStarts);
+        const end = indexToPoint(endIndex, lineStarts);
+        output.push({
+            kind: "function",
+            name,
+            signature: sanitizeSignature(match[0]),
+            exported: false,
+            startLine: start.line,
+            startColumn: start.column,
+            endLine: end.line,
+            endColumn: end.column,
+        });
+    }
+}
+function buildLineStarts(source) {
+    const starts = [0];
+    for (let index = 0; index < source.length; index += 1) {
+        if (source[index] === "\n") {
+            starts.push(index + 1);
+        }
+    }
+    return starts;
+}
+function indexToPoint(index, lineStarts) {
+    let low = 0;
+    let high = lineStarts.length - 1;
+    while (low <= high) {
+        const mid = Math.floor((low + high) / 2);
+        const start = lineStarts[mid];
+        const nextStart = mid + 1 < lineStarts.length ? lineStarts[mid + 1] : Number.POSITIVE_INFINITY;
+        if (index >= start && index < nextStart) {
+            return { line: mid + 1, column: index - start };
+        }
+        if (index < start) {
+            high = mid - 1;
+        }
+        else {
+            low = mid + 1;
+        }
+    }
+    const fallbackLine = lineStarts.length;
+    return { line: fallbackLine, column: index - lineStarts[fallbackLine - 1] };
+}
+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));
+}
+const SHELL_KEYWORDS = new Set(["if", "for", "while", "case", "select", "until", "time", "coproc"]);

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

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractShellSymbolsFromSource = exports.createShellAdapter = exports.ShellAdapter = void 0;
+var adapter_js_1 = require("./adapter.js");
+Object.defineProperty(exports, "ShellAdapter", { enumerable: true, get: function () { return adapter_js_1.ShellAdapter; } });
+Object.defineProperty(exports, "createShellAdapter", { enumerable: true, get: function () { return adapter_js_1.createShellAdapter; } });
+var extract_js_1 = require("./extract.js");
+Object.defineProperty(exports, "extractShellSymbolsFromSource", { enumerable: true, get: function () { return extract_js_1.extractShellSymbolsFromSource; } });

package/dist/graph/adapter/svelte/adapter.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SvelteAdapter = void 0;
+exports.createSvelteAdapter = createSvelteAdapter;
+const node_path_1 = require("node:path");
+const index_js_1 = require("../typescript-javascript/index.js");
+const extract_js_1 = require("./extract.js");
+const DEFAULT_EXTENSIONS = [".svelte"];
+class SvelteAdapter {
+    scriptDelegate;
+    languageId = "svelte";
+    fileExtensions = DEFAULT_EXTENSIONS;
+    confidence = "medium";
+    limitations = [
+        "Extracts declaration-level symbols from <script> blocks by delegating to the TypeScript/JavaScript adapter.",
+        "Does not parse markup/template-level symbols or <style> blocks.",
+    ];
+    constructor(scriptDelegate) {
+        this.scriptDelegate = scriptDelegate;
+    }
+    async extractSymbols(filePath, source) {
+        if ((0, node_path_1.extname)(filePath).toLowerCase() !== ".svelte") {
+            throw new Error(`Unsupported Svelte file extension: ${(0, node_path_1.extname)(filePath)}`);
+        }
+        const symbols = [createComponentSymbol(filePath)];
+        const scriptBlocks = (0, extract_js_1.extractSvelteScriptBlocks)(source);
+        for (const block of scriptBlocks) {
+            const delegated = await this.scriptDelegate.extractSymbols(toDelegatedFilePath(filePath, block), block.content);
+            symbols.push(...delegated.symbols.map((symbol) => offsetSymbol(symbol, block)));
+        }
+        return {
+            language: "svelte",
+            symbols: dedupeAndSort(symbols),
+        };
+    }
+    resolveImportSpecifier(specifier, context) {
+        return this.scriptDelegate.resolveImportSpecifier(specifier, context);
+    }
+}
+exports.SvelteAdapter = SvelteAdapter;
+function createSvelteAdapter(options = {}) {
+    return new SvelteAdapter(options.scriptDelegate ?? (0, index_js_1.createTypeScriptJavaScriptAdapter)());
+}
+function createComponentSymbol(filePath) {
+    const componentName = (0, node_path_1.basename)(filePath, (0, node_path_1.extname)(filePath));
+    return {
+        kind: "class",
+        name: componentName,
+        signature: null,
+        exported: true,
+        startLine: 1,
+        startColumn: 0,
+        endLine: 1,
+        endColumn: componentName.length,
+    };
+}
+function toDelegatedFilePath(filePath, block) {
+    return block.language === "typescript" ? `${filePath}.ts` : `${filePath}.js`;
+}
+function offsetSymbol(symbol, block) {
+    const lineOffset = block.startLine - 1;
+    return {
+        ...symbol,
+        startLine: symbol.startLine + lineOffset,
+        endLine: symbol.endLine + lineOffset,
+        startColumn: symbol.startLine === 1 ? symbol.startColumn + block.startColumn : symbol.startColumn,
+        endColumn: symbol.endLine === 1 ? symbol.endColumn + block.startColumn : symbol.endColumn,
+    };
+}
+function dedupeAndSort(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()).sort((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/svelte/extract.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractSvelteScriptBlocks = extractSvelteScriptBlocks;
+function extractSvelteScriptBlocks(source) {
+    const blocks = [];
+    const scriptPattern = /<script\b((?:[^>"']|"[^"]*"|'[^']*')*)>([\s\S]*?)<\/script>/gi;
+    for (const match of source.matchAll(scriptPattern)) {
+        const fullMatch = match[0];
+        const attributes = match[1] ?? "";
+        const content = match[2] ?? "";
+        const matchIndex = match.index ?? 0;
+        const tagEndOffset = fullMatch.indexOf(">") + 1;
+        const contentStartIndex = matchIndex + tagEndOffset;
+        const position = toLineColumn(source, contentStartIndex);
+        blocks.push({
+            content,
+            language: detectScriptLanguage(attributes),
+            startLine: position.line,
+            startColumn: position.column,
+        });
+    }
+    return blocks;
+}
+function detectScriptLanguage(attributes) {
+    const langMatch = attributes.match(/lang\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'=<>`]+))/i);
+    const rawLang = (langMatch?.[1] ?? langMatch?.[2] ?? langMatch?.[3] ?? "").trim().toLowerCase();
+    return rawLang === "ts" || rawLang === "typescript" ? "typescript" : "javascript";
+}
+function toLineColumn(source, index) {
+    let line = 1;
+    let column = 0;
+    for (let cursor = 0; cursor < index; cursor += 1) {
+        if (source[cursor] === "\n") {
+            line += 1;
+            column = 0;
+            continue;
+        }
+        column += 1;
+    }
+    return { line, column };
+}

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

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractSvelteScriptBlocks = exports.SvelteAdapter = exports.createSvelteAdapter = void 0;
+var adapter_js_1 = require("./adapter.js");
+Object.defineProperty(exports, "createSvelteAdapter", { enumerable: true, get: function () { return adapter_js_1.createSvelteAdapter; } });
+Object.defineProperty(exports, "SvelteAdapter", { enumerable: true, get: function () { return adapter_js_1.SvelteAdapter; } });
+var extract_js_1 = require("./extract.js");
+Object.defineProperty(exports, "extractSvelteScriptBlocks", { enumerable: true, get: function () { return extract_js_1.extractSvelteScriptBlocks; } });

package/dist/graph/adapter/swift/adapter.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SwiftAdapter = void 0;
+exports.createSwiftAdapter = createSwiftAdapter;
+const node_path_1 = require("node:path");
+const extract_js_1 = require("./extract.js");
+const runtime_js_1 = require("./runtime.js");
+const DEFAULT_EXTENSIONS = [".swift"];
+class SwiftAdapter {
+    loadRuntime;
+    languageId = "swift";
+    fileExtensions = DEFAULT_EXTENSIONS;
+    confidence = "medium";
+    limitations = [
+        "Extracts declaration-level symbols only (classes/structs/protocols, functions/methods, imports).",
+        "Uses tree-sitter-swift@0.7.x; newer Swift constructs (including async/await nuance and macro declarations) are deferred.",
+    ];
+    constructor(loadRuntime) {
+        this.loadRuntime = loadRuntime;
+    }
+    async extractSymbols(filePath, source) {
+        const language = detectLanguage(filePath);
+        if (!language) {
+            throw new Error(`Unsupported Swift file extension: ${(0, node_path_1.extname)(filePath)}`);
+        }
+        const runtime = await this.loadRuntime();
+        const tree = runtime.parse(source, language);
+        return (0, extract_js_1.extractSwiftSymbolsFromTree)(tree);
+    }
+    resolveImportSpecifier(specifier, _context) {
+        const trimmed = specifier.trim();
+        if (trimmed.length === 0) {
+            return null;
+        }
+        return trimmed;
+    }
+}
+exports.SwiftAdapter = SwiftAdapter;
+function createSwiftAdapter(options = {}) {
+    return new SwiftAdapter(options.loadRuntime ?? runtime_js_1.loadTreeSitterRuntime);
+}
+function detectLanguage(filePath) {
+    const extension = (0, node_path_1.extname)(filePath).toLowerCase();
+    return extension === ".swift" ? "swift" : null;
+}

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

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractSwiftSymbolsFromTree = extractSwiftSymbolsFromTree;
+function extractSwiftSymbolsFromTree(tree) {
+    const symbols = [];
+    walkNode(tree.rootNode, symbols);
+    const deduped = dedupeSymbols(symbols);
+    deduped.sort(compareExtractedSymbols);
+    return {
+        language: "swift",
+        symbols: deduped,
+    };
+}
+function walkNode(node, output) {
+    const current = toExtractedSymbol(node);
+    if (current) {
+        output.push(current);
+    }
+    for (const child of node.namedChildren ?? []) {
+        walkNode(child, output);
+    }
+}
+function toExtractedSymbol(node) {
+    if (CLASS_DECLARATION_TYPES.has(node.type)) {
+        return buildSymbol(node, "class", extractDeclarationName(node), null);
+    }
+    if (node.type === "function_declaration") {
+        const kind = isMethodContext(node) ? "method" : "function";
+        return buildSymbol(node, kind, extractFunctionName(node), sanitizeSignature(node.text));
+    }
+    if (node.type === "import_declaration") {
+        return buildSymbol(node, "import", extractImportName(node), null);
+    }
+    return null;
+}
+function buildSymbol(node, kind, name, signature) {
+    if (!name) {
+        return null;
+    }
+    return {
+        kind,
+        name,
+        signature,
+        exported: !/\b(?:private|fileprivate)\b/.test(node.text),
+        startLine: node.startPosition.row + 1,
+        startColumn: node.startPosition.column,
+        endLine: node.endPosition.row + 1,
+        endColumn: node.endPosition.column,
+    };
+}
+function extractDeclarationName(node) {
+    const byField = node.childForFieldName?.("name");
+    if (byField?.text?.trim()) {
+        return byField.text.trim();
+    }
+    for (const child of node.namedChildren ?? []) {
+        if (IDENTIFIER_NODE_TYPES.has(child.type) && child.text.trim().length > 0) {
+            return child.text.trim();
+        }
+    }
+    const byText = node.text.match(/\b(?:class|struct|protocol)\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();
+    }
+    for (const child of node.namedChildren ?? []) {
+        if (IDENTIFIER_NODE_TYPES.has(child.type) && child.text.trim().length > 0) {
+            return child.text.trim();
+        }
+    }
+    const byText = node.text.match(/\bfunc\s+([A-Za-z_][A-Za-z0-9_]*)\s*\(/);
+    return byText?.[1] ?? null;
+}
+function extractImportName(node) {
+    const byText = node.text.match(/^\s*import\s+(?:\w+\s+)?([A-Za-z_][A-Za-z0-9_.]*)\b/m);
+    return byText?.[1] ?? null;
+}
+function isMethodContext(node) {
+    let current = node.parent;
+    while (current) {
+        if (METHOD_CONTAINER_TYPES.has(current.type)) {
+            return true;
+        }
+        current = current.parent;
+    }
+    return false;
+}
+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));
+}
+const CLASS_DECLARATION_TYPES = new Set(["class_declaration", "struct_declaration", "protocol_declaration"]);
+const METHOD_CONTAINER_TYPES = new Set(["class_declaration", "struct_declaration", "extension_declaration"]);
+const IDENTIFIER_NODE_TYPES = new Set(["identifier", "simple_identifier", "type_identifier"]);

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

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