distill-mcp 0.6.0-beta

package/dist/ast/rust/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Rust AST Parser Module
+ *
+ * Exports the Tree-sitter based Rust parser.
+ */
+export { rustTreeSitterParser, parseRust, parseRustAsync, extractRustElement, searchRustElements, initRustParser, } from "./parser.js";
+export { QUERIES } from "./queries.js";
+export { getLineNumber, getEndLineNumber, extractRustDoc, hasVisibility, isAsyncFn, getFunctionSignature, getStructSignature, getEnumSignature, getTraitSignature, createCodeElement, } from "./utils.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/ast/rust/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/ast/rust/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EACL,oBAAoB,EACpB,SAAS,EACT,cAAc,EACd,kBAAkB,EAClB,kBAAkB,EAClB,cAAc,GACf,MAAM,aAAa,CAAC;AAErB,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAEvC,OAAO,EACL,aAAa,EACb,gBAAgB,EAChB,cAAc,EACd,aAAa,EACb,SAAS,EACT,oBAAoB,EACpB,kBAAkB,EAClB,gBAAgB,EAChB,iBAAiB,EACjB,iBAAiB,GAClB,MAAM,YAAY,CAAC"}

package/dist/ast/rust/index.js

@@ -0,0 +1,8 @@
+/**
+ * Rust AST Parser Module
+ *
+ * Exports the Tree-sitter based Rust parser.
+ */
+export { rustTreeSitterParser, parseRust, parseRustAsync, extractRustElement, searchRustElements, initRustParser, } from "./parser.js";
+export { QUERIES } from "./queries.js";
+export { getLineNumber, getEndLineNumber, extractRustDoc, hasVisibility, isAsyncFn, getFunctionSignature, getStructSignature, getEnumSignature, getTraitSignature, createCodeElement, } from "./utils.js";

package/dist/ast/rust/parser.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Rust Tree-sitter Parser
+ *
+ * AST parser for Rust using Tree-sitter for accurate code analysis.
+ */
+import type { CodeElement, FileStructure, ExtractedContent, ExtractionTarget, ExtractionOptions, LanguageParser } from "../types.js";
+/**
+ * Parse Rust content and extract structure
+ */
+export declare function parseRust(content: string): FileStructure;
+/**
+ * Async version of parseRust
+ */
+export declare function parseRustAsync(content: string): Promise<FileStructure>;
+/**
+ * Extract a specific element from Rust code
+ */
+export declare function extractRustElement(content: string, target: ExtractionTarget, options: ExtractionOptions): Promise<ExtractedContent | null>;
+/**
+ * Search for elements matching a query
+ */
+export declare function searchRustElements(content: string, query: string): Promise<CodeElement[]>;
+/**
+ * LanguageParser implementation for Rust
+ */
+export declare const rustTreeSitterParser: LanguageParser;
+/**
+ * Initialize the Rust parser
+ */
+export declare function initRustParser(): Promise<void>;
+//# sourceMappingURL=parser.d.ts.map

package/dist/ast/rust/parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../../../src/ast/rust/parser.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAWH,OAAO,KAAK,EACV,WAAW,EACX,aAAa,EACb,gBAAgB,EAChB,gBAAgB,EAChB,iBAAiB,EAEjB,cAAc,EACf,MAAM,aAAa,CAAC;AAqErB;;GAEG;AACH,wBAAgB,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,aAAa,CAWxD;AAED;;GAEG;AACH,wBAAsB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC,CAW5E;AAqLD;;GAEG;AACH,wBAAsB,kBAAkB,CACtC,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,gBAAgB,EACxB,OAAO,EAAE,iBAAiB,GACzB,OAAO,CAAC,gBAAgB,GAAG,IAAI,CAAC,CAoElC;AAED;;GAEG;AACH,wBAAsB,kBAAkB,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC,CAwB/F;AAED;;GAEG;AACH,eAAO,MAAM,oBAAoB,EAAE,cAmHlC,CAAC;AAEF;;GAEG;AACH,wBAAsB,cAAc,IAAI,OAAO,CAAC,IAAI,CAAC,CAEpD"}

package/dist/ast/rust/parser.js

@@ -0,0 +1,416 @@
+/**
+ * Rust Tree-sitter Parser
+ *
+ * AST parser for Rust using Tree-sitter for accurate code analysis.
+ */
+import Parser from "web-tree-sitter";
+import { readFileSync } from "fs";
+import { createRequire } from "module";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+import { createEmptyStructure } from "../types.js";
+import { extractRustDoc, hasVisibility, isAsyncFn, getFunctionSignature, getStructSignature, getEnumSignature, getTraitSignature, getImplTypeName, getUsePath, getUseShortName, getConstSignature, getTypeAliasSignature, createCodeElement, } from "./utils.js";
+// Singleton for lazy initialization
+let parserInstance = null;
+let rustLanguage = null;
+let initPromise = null;
+/**
+ * Get the path to the Rust WASM file
+ */
+function getRustWasmPath() {
+    const require = createRequire(import.meta.url);
+    try {
+        const wasmDir = dirname(require.resolve("tree-sitter-wasms/package.json"));
+        return join(wasmDir, "out", "tree-sitter-rust.wasm");
+    }
+    catch {
+        const __dirname = dirname(fileURLToPath(import.meta.url));
+        return join(__dirname, "..", "..", "..", "node_modules", "tree-sitter-wasms", "out", "tree-sitter-rust.wasm");
+    }
+}
+/**
+ * Initialize Tree-sitter and load Rust language
+ */
+async function initParser() {
+    if (parserInstance && rustLanguage)
+        return;
+    if (initPromise) {
+        await initPromise;
+        return;
+    }
+    initPromise = (async () => {
+        await Parser.init();
+        parserInstance = new Parser();
+        const wasmPath = getRustWasmPath();
+        // Read WASM file as buffer for reliable loading in all environments
+        const wasmBuffer = readFileSync(wasmPath);
+        rustLanguage = await Parser.Language.load(wasmBuffer);
+        parserInstance.setLanguage(rustLanguage);
+    })();
+    await initPromise;
+}
+/**
+ * Check if a node is at module level (top level)
+ */
+function isModuleLevel(node) {
+    return node.parent?.type === "source_file";
+}
+/**
+ * Parse Rust content and extract structure
+ */
+export function parseRust(content) {
+    if (!parserInstance || !rustLanguage) {
+        initParser().catch(() => { });
+        return createEmptyStructure("rust", content.split("\n").length);
+    }
+    const tree = parserInstance.parse(content);
+    if (!tree) {
+        return createEmptyStructure("rust", content.split("\n").length);
+    }
+    return extractStructure(tree, content);
+}
+/**
+ * Async version of parseRust
+ */
+export async function parseRustAsync(content) {
+    await initParser();
+    if (!parserInstance) {
+        return createEmptyStructure("rust", content.split("\n").length);
+    }
+    const tree = parserInstance.parse(content);
+    if (!tree) {
+        return createEmptyStructure("rust", content.split("\n").length);
+    }
+    return extractStructure(tree, content);
+}
+/**
+ * Extract file structure from parsed tree
+ */
+function extractStructure(tree, content) {
+    const lines = content.split("\n");
+    const structure = createEmptyStructure("rust", lines.length);
+    const rootNode = tree.rootNode;
+    walkNode(rootNode, structure, lines, undefined);
+    return structure;
+}
+/**
+ * Recursively walk the AST and extract code elements
+ */
+function walkNode(node, structure, lines, currentImplType) {
+    switch (node.type) {
+        case "use_declaration": {
+            const usePath = getUsePath(node);
+            const name = getUseShortName(usePath);
+            structure.imports.push(createCodeElement("import", name, node, {
+                signature: `use ${usePath}`,
+            }));
+            return;
+        }
+        case "function_item": {
+            const nameNode = node.childForFieldName("name");
+            const name = nameNode?.text ?? "unknown";
+            const isAsync = isAsyncFn(node);
+            const isExported = hasVisibility(node);
+            // If inside an impl block, treat as method
+            if (currentImplType) {
+                structure.functions.push(createCodeElement("method", name, node, {
+                    signature: getFunctionSignature(node),
+                    documentation: extractRustDoc(node, lines),
+                    isAsync,
+                    isExported,
+                    parent: currentImplType,
+                }));
+            }
+            else {
+                structure.functions.push(createCodeElement("function", name, node, {
+                    signature: getFunctionSignature(node),
+                    documentation: extractRustDoc(node, lines),
+                    isAsync,
+                    isExported,
+                }));
+            }
+            return;
+        }
+        case "struct_item": {
+            const nameNode = node.childForFieldName("name");
+            const name = nameNode?.text ?? "unknown";
+            const isExported = hasVisibility(node);
+            structure.classes.push(createCodeElement("class", name, node, {
+                signature: getStructSignature(node),
+                documentation: extractRustDoc(node, lines),
+                isExported,
+            }));
+            return;
+        }
+        case "enum_item": {
+            const nameNode = node.childForFieldName("name");
+            const name = nameNode?.text ?? "unknown";
+            const isExported = hasVisibility(node);
+            structure.classes.push(createCodeElement("class", name, node, {
+                signature: getEnumSignature(node),
+                documentation: extractRustDoc(node, lines),
+                isExported,
+            }));
+            return;
+        }
+        case "trait_item": {
+            const nameNode = node.childForFieldName("name");
+            const name = nameNode?.text ?? "unknown";
+            const isExported = hasVisibility(node);
+            structure.interfaces.push(createCodeElement("interface", name, node, {
+                signature: getTraitSignature(node),
+                documentation: extractRustDoc(node, lines),
+                isExported,
+            }));
+            return;
+        }
+        case "impl_item": {
+            const typeName = getImplTypeName(node);
+            // Walk into impl block with the type name as context
+            const body = node.childForFieldName("body");
+            if (body) {
+                for (const child of body.children) {
+                    walkNode(child, structure, lines, typeName);
+                }
+            }
+            return;
+        }
+        case "type_item": {
+            const nameNode = node.childForFieldName("name");
+            const name = nameNode?.text ?? "unknown";
+            const isExported = hasVisibility(node);
+            structure.types.push(createCodeElement("type", name, node, {
+                signature: getTypeAliasSignature(node),
+                documentation: extractRustDoc(node, lines),
+                isExported,
+            }));
+            return;
+        }
+        case "const_item": {
+            if (isModuleLevel(node)) {
+                const nameNode = node.childForFieldName("name");
+                const name = nameNode?.text ?? "unknown";
+                const isExported = hasVisibility(node);
+                structure.variables.push(createCodeElement("variable", name, node, {
+                    signature: getConstSignature(node, "const"),
+                    documentation: extractRustDoc(node, lines),
+                    isExported,
+                }));
+            }
+            return;
+        }
+        case "static_item": {
+            if (isModuleLevel(node)) {
+                const nameNode = node.childForFieldName("name");
+                const name = nameNode?.text ?? "unknown";
+                const isExported = hasVisibility(node);
+                structure.variables.push(createCodeElement("variable", name, node, {
+                    signature: getConstSignature(node, "static"),
+                    documentation: extractRustDoc(node, lines),
+                    isExported,
+                }));
+            }
+            return;
+        }
+    }
+    // Walk children
+    for (const child of node.children) {
+        walkNode(child, structure, lines, currentImplType);
+    }
+}
+/**
+ * Extract a specific element from Rust code
+ */
+export async function extractRustElement(content, target, options) {
+    const structure = await parseRustAsync(content);
+    let element;
+    switch (target.type) {
+        case "function":
+        case "method":
+            element = structure.functions.find((f) => f.name === target.name);
+            break;
+        case "class":
+            element = structure.classes.find((c) => c.name === target.name);
+            break;
+        case "interface":
+            element = structure.interfaces.find((i) => i.name === target.name);
+            break;
+        case "type":
+            element = structure.types.find((t) => t.name === target.name);
+            break;
+        case "variable":
+            element = structure.variables.find((v) => v.name === target.name);
+            break;
+    }
+    if (!element) {
+        return null;
+    }
+    const lines = content.split("\n");
+    // Find start line (include documentation if requested)
+    let startLine = element.startLine;
+    if (options.includeComments && element.documentation) {
+        for (let i = element.startLine - 2; i >= 0; i--) {
+            const line = lines[i]?.trim() ?? "";
+            if (line.startsWith("///") || line.startsWith("//!")) {
+                startLine = i + 1;
+            }
+            else if (line === "") {
+                continue;
+            }
+            else {
+                break;
+            }
+        }
+    }
+    const extractedLines = lines.slice(startLine - 1, element.endLine);
+    const extractedCode = extractedLines.join("\n");
+    // Find related imports
+    const relatedImports = [];
+    if (options.includeImports) {
+        for (const imp of structure.imports) {
+            if (extractedCode.includes(imp.name)) {
+                const importLine = lines[imp.startLine - 1];
+                if (importLine && !relatedImports.includes(importLine)) {
+                    relatedImports.push(importLine);
+                }
+            }
+        }
+    }
+    return {
+        content: extractedCode,
+        elements: [element],
+        relatedImports,
+        startLine,
+        endLine: element.endLine,
+    };
+}
+/**
+ * Search for elements matching a query
+ */
+export async function searchRustElements(content, query) {
+    const structure = await parseRustAsync(content);
+    const queryLower = query.toLowerCase();
+    const results = [];
+    const allElements = [
+        ...structure.functions,
+        ...structure.classes,
+        ...structure.interfaces,
+        ...structure.types,
+        ...structure.variables,
+    ];
+    for (const element of allElements) {
+        if (element.name.toLowerCase().includes(queryLower) ||
+            element.signature?.toLowerCase().includes(queryLower) ||
+            element.documentation?.toLowerCase().includes(queryLower)) {
+            results.push(element);
+        }
+    }
+    return results;
+}
+/**
+ * LanguageParser implementation for Rust
+ */
+export const rustTreeSitterParser = {
+    languages: ["rust"],
+    parse(content, _options) {
+        if (!parserInstance || !rustLanguage) {
+            initParser().catch(() => { });
+            return parseRust(content);
+        }
+        return parseRust(content);
+    },
+    extractElement(content, target, options) {
+        if (!parserInstance || !rustLanguage) {
+            initParser().catch(() => { });
+            return null;
+        }
+        const structure = parseRust(content);
+        let element;
+        switch (target.type) {
+            case "function":
+            case "method":
+                element = structure.functions.find((f) => f.name === target.name);
+                break;
+            case "class":
+                element = structure.classes.find((c) => c.name === target.name);
+                break;
+            case "interface":
+                element = structure.interfaces.find((i) => i.name === target.name);
+                break;
+            case "type":
+                element = structure.types.find((t) => t.name === target.name);
+                break;
+            case "variable":
+                element = structure.variables.find((v) => v.name === target.name);
+                break;
+        }
+        if (!element)
+            return null;
+        const lines = content.split("\n");
+        let startLine = element.startLine;
+        if (options.includeComments && element.documentation) {
+            for (let i = element.startLine - 2; i >= 0; i--) {
+                const line = lines[i]?.trim() ?? "";
+                if (line.startsWith("///") || line.startsWith("//!")) {
+                    startLine = i + 1;
+                }
+                else if (line === "") {
+                    continue;
+                }
+                else {
+                    break;
+                }
+            }
+        }
+        const extractedLines = lines.slice(startLine - 1, element.endLine);
+        const extractedCode = extractedLines.join("\n");
+        const relatedImports = [];
+        if (options.includeImports) {
+            for (const imp of structure.imports) {
+                if (extractedCode.includes(imp.name)) {
+                    const importLine = lines[imp.startLine - 1];
+                    if (importLine && !relatedImports.includes(importLine)) {
+                        relatedImports.push(importLine);
+                    }
+                }
+            }
+        }
+        return {
+            content: extractedCode,
+            elements: [element],
+            relatedImports,
+            startLine,
+            endLine: element.endLine,
+        };
+    },
+    searchElements(content, query) {
+        if (!parserInstance || !rustLanguage) {
+            initParser().catch(() => { });
+            return [];
+        }
+        const structure = parseRust(content);
+        const queryLower = query.toLowerCase();
+        const results = [];
+        const allElements = [
+            ...structure.functions,
+            ...structure.classes,
+            ...structure.interfaces,
+            ...structure.types,
+            ...structure.variables,
+        ];
+        for (const element of allElements) {
+            if (element.name.toLowerCase().includes(queryLower) ||
+                element.signature?.toLowerCase().includes(queryLower) ||
+                element.documentation?.toLowerCase().includes(queryLower)) {
+                results.push(element);
+            }
+        }
+        return results;
+    },
+};
+/**
+ * Initialize the Rust parser
+ */
+export async function initRustParser() {
+    await initParser();
+}

package/dist/ast/rust/parser.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Rust Tree-sitter Parser Tests
+ */
+export {};
+//# sourceMappingURL=parser.test.d.ts.map

package/dist/ast/rust/parser.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parser.test.d.ts","sourceRoot":"","sources":["../../../src/ast/rust/parser.test.ts"],"names":[],"mappings":"AAAA;;GAEG"}