distill-mcp 0.6.0-beta

package/dist/ast/go/parser.js

@@ -0,0 +1,428 @@
+/**
+ * Go Tree-sitter Parser
+ *
+ * AST parser for Go 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 { extractGoDoc, getFunctionSignature, getMethodSignature, getTypeSignature, isExported, getReceiverType, createCodeElement, getImportPath, getImportName, getImportAlias, } from "./utils.js";
+// Singleton for lazy initialization
+let parserInstance = null;
+let goLanguage = null;
+let initPromise = null;
+/**
+ * Get the path to the Go WASM file
+ */
+function getGoWasmPath() {
+    const require = createRequire(import.meta.url);
+    try {
+        const wasmDir = dirname(require.resolve("tree-sitter-wasms/package.json"));
+        return join(wasmDir, "out", "tree-sitter-go.wasm");
+    }
+    catch {
+        const __dirname = dirname(fileURLToPath(import.meta.url));
+        return join(__dirname, "..", "..", "..", "node_modules", "tree-sitter-wasms", "out", "tree-sitter-go.wasm");
+    }
+}
+/**
+ * Initialize Tree-sitter and load Go language
+ */
+async function initParser() {
+    if (parserInstance && goLanguage)
+        return;
+    if (initPromise) {
+        await initPromise;
+        return;
+    }
+    initPromise = (async () => {
+        await Parser.init();
+        parserInstance = new Parser();
+        const wasmPath = getGoWasmPath();
+        // Read WASM file as buffer for reliable loading in all environments
+        const wasmBuffer = readFileSync(wasmPath);
+        goLanguage = await Parser.Language.load(wasmBuffer);
+        parserInstance.setLanguage(goLanguage);
+    })();
+    await initPromise;
+}
+/**
+ * Check if a node is at package level
+ */
+function isPackageLevel(node) {
+    return node.parent?.type === "source_file";
+}
+/**
+ * Parse Go content and extract structure
+ */
+export function parseGo(content) {
+    if (!parserInstance || !goLanguage) {
+        initParser().catch(() => { });
+        return createEmptyStructure("go", content.split("\n").length);
+    }
+    const tree = parserInstance.parse(content);
+    if (!tree) {
+        return createEmptyStructure("go", content.split("\n").length);
+    }
+    return extractStructure(tree, content);
+}
+/**
+ * Async version of parseGo
+ */
+export async function parseGoAsync(content) {
+    await initParser();
+    if (!parserInstance) {
+        return createEmptyStructure("go", content.split("\n").length);
+    }
+    const tree = parserInstance.parse(content);
+    if (!tree) {
+        return createEmptyStructure("go", 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("go", lines.length);
+    const rootNode = tree.rootNode;
+    walkNode(rootNode, structure, lines);
+    return structure;
+}
+/**
+ * Recursively walk the AST and extract code elements
+ */
+function walkNode(node, structure, lines) {
+    switch (node.type) {
+        case "import_declaration": {
+            // Handle both single and grouped imports
+            for (const child of node.namedChildren) {
+                if (child.type === "import_spec") {
+                    processImportSpec(child, structure);
+                }
+                else if (child.type === "import_spec_list") {
+                    for (const spec of child.namedChildren) {
+                        if (spec.type === "import_spec") {
+                            processImportSpec(spec, structure);
+                        }
+                    }
+                }
+            }
+            return;
+        }
+        case "function_declaration": {
+            const nameNode = node.childForFieldName("name");
+            const name = nameNode?.text ?? "unknown";
+            structure.functions.push(createCodeElement("function", name, node, {
+                signature: getFunctionSignature(node),
+                documentation: extractGoDoc(node, lines),
+                isExported: isExported(name),
+            }));
+            return;
+        }
+        case "method_declaration": {
+            const nameNode = node.childForFieldName("name");
+            const name = nameNode?.text ?? "unknown";
+            const receiverType = getReceiverType(node);
+            structure.functions.push(createCodeElement("method", name, node, {
+                signature: getMethodSignature(node),
+                documentation: extractGoDoc(node, lines),
+                isExported: isExported(name),
+                parent: receiverType,
+            }));
+            return;
+        }
+        case "type_declaration": {
+            // Process type specs inside
+            for (const child of node.namedChildren) {
+                if (child.type === "type_spec") {
+                    processTypeSpec(child, structure, lines);
+                }
+            }
+            return;
+        }
+        case "var_declaration": {
+            if (isPackageLevel(node)) {
+                for (const child of node.namedChildren) {
+                    if (child.type === "var_spec") {
+                        const nameNode = child.childForFieldName("name");
+                        const name = nameNode?.text ?? "";
+                        if (name) {
+                            structure.variables.push(createCodeElement("variable", name, node, {
+                                signature: `var ${name}`,
+                                documentation: extractGoDoc(node, lines),
+                                isExported: isExported(name),
+                            }));
+                        }
+                    }
+                }
+            }
+            return;
+        }
+        case "const_declaration": {
+            if (isPackageLevel(node)) {
+                for (const child of node.namedChildren) {
+                    if (child.type === "const_spec") {
+                        const nameNode = child.childForFieldName("name");
+                        const name = nameNode?.text ?? "";
+                        if (name) {
+                            structure.variables.push(createCodeElement("variable", name, node, {
+                                signature: `const ${name}`,
+                                documentation: extractGoDoc(node, lines),
+                                isExported: isExported(name),
+                            }));
+                        }
+                    }
+                }
+            }
+            return;
+        }
+    }
+    // Walk children
+    for (const child of node.children) {
+        walkNode(child, structure, lines);
+    }
+}
+/**
+ * Process an import spec
+ */
+function processImportSpec(node, structure) {
+    const importPath = getImportPath(node);
+    const alias = getImportAlias(node);
+    const name = alias ?? getImportName(importPath);
+    structure.imports.push(createCodeElement("import", name, node, {
+        signature: alias ? `import ${alias} "${importPath}"` : `import "${importPath}"`,
+    }));
+}
+/**
+ * Process a type spec (struct, interface, alias)
+ */
+function processTypeSpec(node, structure, lines) {
+    const nameNode = node.childForFieldName("name");
+    const typeNode = node.childForFieldName("type");
+    const name = nameNode?.text ?? "unknown";
+    if (!typeNode)
+        return;
+    if (typeNode.type === "struct_type") {
+        structure.classes.push(createCodeElement("class", name, node, {
+            signature: getTypeSignature(node, "struct"),
+            documentation: extractGoDoc(node.parent ?? node, lines),
+            isExported: isExported(name),
+        }));
+    }
+    else if (typeNode.type === "interface_type") {
+        structure.interfaces.push(createCodeElement("interface", name, node, {
+            signature: getTypeSignature(node, "interface"),
+            documentation: extractGoDoc(node.parent ?? node, lines),
+            isExported: isExported(name),
+        }));
+    }
+    else {
+        // Type alias
+        structure.types.push(createCodeElement("type", name, node, {
+            signature: `type ${name} ${typeNode.text}`,
+            documentation: extractGoDoc(node.parent ?? node, lines),
+            isExported: isExported(name),
+        }));
+    }
+}
+/**
+ * Extract a specific element from Go code
+ */
+export async function extractGoElement(content, target, options) {
+    const structure = await parseGoAsync(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("//")) {
+                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 searchGoElements(content, query) {
+    const structure = await parseGoAsync(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 Go
+ */
+export const goTreeSitterParser = {
+    languages: ["go"],
+    parse(content, _options) {
+        if (!parserInstance || !goLanguage) {
+            initParser().catch(() => { });
+            return parseGo(content);
+        }
+        return parseGo(content);
+    },
+    extractElement(content, target, options) {
+        if (!parserInstance || !goLanguage) {
+            initParser().catch(() => { });
+            return null;
+        }
+        const structure = parseGo(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("//")) {
+                    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 || !goLanguage) {
+            initParser().catch(() => { });
+            return [];
+        }
+        const structure = parseGo(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 Go parser
+ */
+export async function initGoParser() {
+    await initParser();
+}

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

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

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

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

package/dist/ast/go/parser.test.js

@@ -0,0 +1,241 @@
+/**
+ * Go Tree-sitter Parser Tests
+ */
+import { describe, it, expect, beforeAll } from "vitest";
+import { goTreeSitterParser, parseGoAsync, initGoParser, } from "./parser.js";
+// Sample Go code for testing
+const SAMPLE_GO = `
+package main
+
+import (
+	"fmt"
+	"net/http"
+	"encoding/json"
+)
+
+// MaxSize is the maximum allowed size
+const MaxSize = 100
+
+// Debug enables debug mode
+var Debug = false
+
+// User represents a user in the system
+type User struct {
+	Name string
+	Age  int
+}
+
+// Greet returns a greeting message
+func (u *User) Greet() string {
+	return fmt.Sprintf("Hello, %s!", u.Name)
+}
+
+// FetchData fetches user data
+func (u User) FetchData() map[string]interface{} {
+	return map[string]interface{}{
+		"name": u.Name,
+		"age":  u.Age,
+	}
+}
+
+// AdminUser is a user with admin privileges
+type AdminUser struct {
+	User
+	Permissions []string
+}
+
+// HasPermission checks if admin has a permission
+func (a *AdminUser) HasPermission(perm string) bool {
+	for _, p := range a.Permissions {
+		if p == perm {
+			return true
+		}
+	}
+	return false
+}
+
+// Handler defines HTTP handler interface
+type Handler interface {
+	ServeHTTP(w http.ResponseWriter, r *http.Request)
+}
+
+// CalculateSum calculates the sum of numbers
+func CalculateSum(numbers []int) int {
+	sum := 0
+	for _, n := range numbers {
+		sum += n
+	}
+	return sum
+}
+
+// privateFunc is unexported
+func privateFunc() {
+	// internal function
+}
+
+// main is the entry point
+func main() {
+	fmt.Println("Hello, World!")
+}
+`;
+describe("Go Tree-sitter Parser", () => {
+    beforeAll(async () => {
+        await initGoParser();
+    });
+    describe("parseGoAsync", () => {
+        it("should parse imports correctly", async () => {
+            const structure = await parseGoAsync(SAMPLE_GO);
+            expect(structure.language).toBe("go");
+            expect(structure.imports.length).toBeGreaterThanOrEqual(3);
+            const importNames = structure.imports.map((i) => i.name);
+            expect(importNames).toContain("fmt");
+            expect(importNames).toContain("http");
+            expect(importNames).toContain("json");
+        });
+        it("should parse functions correctly", async () => {
+            const structure = await parseGoAsync(SAMPLE_GO);
+            const funcNames = structure.functions.map((f) => f.name);
+            expect(funcNames).toContain("CalculateSum");
+            expect(funcNames).toContain("privateFunc");
+            expect(funcNames).toContain("main");
+        });
+        it("should detect exported functions", async () => {
+            const structure = await parseGoAsync(SAMPLE_GO);
+            const calcSum = structure.functions.find((f) => f.name === "CalculateSum");
+            expect(calcSum?.isExported).toBe(true);
+            const privateFunc = structure.functions.find((f) => f.name === "privateFunc");
+            expect(privateFunc?.isExported).toBe(false);
+        });
+        it("should parse methods correctly", async () => {
+            const structure = await parseGoAsync(SAMPLE_GO);
+            const methods = structure.functions.filter((f) => f.type === "method");
+            expect(methods.length).toBeGreaterThanOrEqual(3);
+            const methodNames = methods.map((m) => m.name);
+            expect(methodNames).toContain("Greet");
+            expect(methodNames).toContain("FetchData");
+            expect(methodNames).toContain("HasPermission");
+        });
+        it("should track receiver type for methods", async () => {
+            const structure = await parseGoAsync(SAMPLE_GO);
+            const greet = structure.functions.find((f) => f.name === "Greet");
+            expect(greet?.parent).toBe("User");
+            const hasPermission = structure.functions.find((f) => f.name === "HasPermission");
+            expect(hasPermission?.parent).toBe("AdminUser");
+        });
+        it("should parse structs as classes", async () => {
+            const structure = await parseGoAsync(SAMPLE_GO);
+            expect(structure.classes.length).toBeGreaterThanOrEqual(2);
+            const classNames = structure.classes.map((c) => c.name);
+            expect(classNames).toContain("User");
+            expect(classNames).toContain("AdminUser");
+        });
+        it("should detect exported structs", async () => {
+            const structure = await parseGoAsync(SAMPLE_GO);
+            const user = structure.classes.find((c) => c.name === "User");
+            expect(user?.isExported).toBe(true);
+        });
+        it("should parse interfaces", async () => {
+            const structure = await parseGoAsync(SAMPLE_GO);
+            expect(structure.interfaces.length).toBeGreaterThanOrEqual(1);
+            const interfaceNames = structure.interfaces.map((i) => i.name);
+            expect(interfaceNames).toContain("Handler");
+        });
+        it("should extract doc comments", async () => {
+            const structure = await parseGoAsync(SAMPLE_GO);
+            const userStruct = structure.classes.find((c) => c.name === "User");
+            expect(userStruct?.documentation).toContain("represents a user");
+            const calcSum = structure.functions.find((f) => f.name === "CalculateSum");
+            expect(calcSum?.documentation).toContain("calculates the sum");
+        });
+        it("should parse package-level variables", async () => {
+            const structure = await parseGoAsync(SAMPLE_GO);
+            const varNames = structure.variables.map((v) => v.name);
+            expect(varNames).toContain("Debug");
+        });
+        it("should parse constants", async () => {
+            const structure = await parseGoAsync(SAMPLE_GO);
+            const varNames = structure.variables.map((v) => v.name);
+            expect(varNames).toContain("MaxSize");
+        });
+        it("should return correct line numbers", async () => {
+            const structure = await parseGoAsync(SAMPLE_GO);
+            const userStruct = structure.classes.find((c) => c.name === "User");
+            expect(userStruct?.startLine).toBeGreaterThan(0);
+            expect(userStruct?.endLine).toBeGreaterThan(userStruct?.startLine ?? 0);
+        });
+    });
+    describe("LanguageParser interface", () => {
+        it("should implement parse() method", () => {
+            const structure = goTreeSitterParser.parse(SAMPLE_GO);
+            expect(structure).toBeDefined();
+            expect(structure.language).toBe("go");
+        });
+        it("should implement extractElement() method", async () => {
+            await initGoParser();
+            const result = goTreeSitterParser.extractElement(SAMPLE_GO, { type: "function", name: "CalculateSum" }, { includeImports: true, includeComments: true });
+            expect(result).not.toBeNull();
+            expect(result?.content).toContain("func CalculateSum");
+            expect(result?.elements[0]?.name).toBe("CalculateSum");
+        });
+        it("should extract methods by name", async () => {
+            await initGoParser();
+            const result = goTreeSitterParser.extractElement(SAMPLE_GO, { type: "method", name: "Greet" }, { includeImports: false, includeComments: true });
+            expect(result).not.toBeNull();
+            expect(result?.content).toContain("func (u *User) Greet");
+        });
+        it("should implement searchElements() method", async () => {
+            await initGoParser();
+            const results = goTreeSitterParser.searchElements(SAMPLE_GO, "user");
+            expect(results.length).toBeGreaterThan(0);
+            const names = results.map((r) => r.name.toLowerCase());
+            expect(names.some((n) => n.includes("user"))).toBe(true);
+        });
+        it("should return null for non-existent elements", async () => {
+            await initGoParser();
+            const result = goTreeSitterParser.extractElement(SAMPLE_GO, { type: "function", name: "NonExistentFunc" }, { includeImports: false, includeComments: false });
+            expect(result).toBeNull();
+        });
+    });
+    describe("Edge cases", () => {
+        it("should handle empty content", async () => {
+            const structure = await parseGoAsync("");
+            expect(structure.language).toBe("go");
+            expect(structure.totalLines).toBe(1);
+            expect(structure.functions).toHaveLength(0);
+        });
+        it("should handle single import", async () => {
+            const code = `
+package main
+
+import "fmt"
+
+func main() {}
+`;
+            const structure = await parseGoAsync(code);
+            expect(structure.imports.length).toBeGreaterThanOrEqual(1);
+        });
+        it("should handle import with alias", async () => {
+            const code = `
+package main
+
+import (
+	f "fmt"
+	. "strings"
+	_ "database/sql"
+)
+`;
+            const structure = await parseGoAsync(code);
+            expect(structure.imports.length).toBeGreaterThanOrEqual(3);
+        });
+        it("should handle type aliases", async () => {
+            const code = `
+package main
+
+type MyInt int
+type MyString = string
+`;
+            const structure = await parseGoAsync(code);
+            expect(structure.types.length).toBeGreaterThanOrEqual(1);
+        });
+    });
+});