distill-mcp 0.6.0-beta

package/dist/ast/python/parser.js

@@ -0,0 +1,422 @@
+/**
+ * Python Tree-sitter Parser
+ *
+ * AST parser for Python 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 { extractDocstring, getFunctionSignature, getClassSignature, createCodeElement, getBodyNode, getImportName, getImportSignature, } from "./utils.js";
+// Singleton for lazy initialization
+let parserInstance = null;
+let pythonLanguage = null;
+let initPromise = null;
+/**
+ * Get the path to the Python WASM file
+ */
+function getPythonWasmPath() {
+    // Use createRequire to resolve the path in ESM context
+    const require = createRequire(import.meta.url);
+    try {
+        const wasmDir = dirname(require.resolve("tree-sitter-wasms/package.json"));
+        return join(wasmDir, "out", "tree-sitter-python.wasm");
+    }
+    catch {
+        // Fallback: try common locations
+        const __dirname = dirname(fileURLToPath(import.meta.url));
+        return join(__dirname, "..", "..", "..", "node_modules", "tree-sitter-wasms", "out", "tree-sitter-python.wasm");
+    }
+}
+/**
+ * Initialize Tree-sitter and load Python language
+ */
+async function initParser() {
+    if (parserInstance && pythonLanguage)
+        return;
+    if (initPromise) {
+        await initPromise;
+        return;
+    }
+    initPromise = (async () => {
+        await Parser.init();
+        parserInstance = new Parser();
+        const wasmPath = getPythonWasmPath();
+        // Read WASM file as buffer for reliable loading in all environments
+        const wasmBuffer = readFileSync(wasmPath);
+        pythonLanguage = await Parser.Language.load(wasmBuffer);
+        parserInstance.setLanguage(pythonLanguage);
+    })();
+    await initPromise;
+}
+/**
+ * Parse Python code and return AST tree
+ */
+async function parseCode(content) {
+    await initParser();
+    if (!parserInstance) {
+        throw new Error("Parser not initialized");
+    }
+    return parserInstance.parse(content);
+}
+/**
+ * Check if a node is at module level (not nested inside a class or function)
+ */
+function isModuleLevel(node) {
+    let parent = node.parent;
+    while (parent) {
+        if (parent.type === "function_definition" || parent.type === "class_definition") {
+            return false;
+        }
+        parent = parent.parent;
+    }
+    return true;
+}
+/**
+ * Check if a function is async
+ */
+function isAsyncFunction(node) {
+    // In Tree-sitter Python, 'async' is a child of function_definition
+    for (const child of node.children) {
+        if (child.type === "async")
+            return true;
+    }
+    return false;
+}
+/**
+ * Get the parent class name if this function is a method
+ */
+function getParentClassName(node) {
+    let parent = node.parent;
+    while (parent) {
+        if (parent.type === "class_definition") {
+            const nameNode = parent.childForFieldName("name");
+            return nameNode?.text;
+        }
+        parent = parent.parent;
+    }
+    return undefined;
+}
+/**
+ * Parse Python content and extract structure
+ * @param options ParseOptions - set detailed: true for signature/documentation
+ */
+export function parsePython(content, options = {}) {
+    const { detailed = false } = options;
+    // Use synchronous parsing for the interface
+    // Tree-sitter is async for initialization but sync for parsing after that
+    let structure = null;
+    // We need to handle async initialization
+    // For now, use a sync approach with cached parser
+    if (!parserInstance || !pythonLanguage) {
+        // Return empty structure if parser not ready
+        // The async version will be called on first use
+        return createEmptyStructure("python", content.split("\n").length);
+    }
+    const tree = parserInstance.parse(content);
+    if (!tree) {
+        return createEmptyStructure("python", content.split("\n").length);
+    }
+    structure = extractStructure(tree, content, detailed);
+    return structure;
+}
+/**
+ * Async version of parsePython for initial calls
+ */
+export async function parsePythonAsync(content, options = {}) {
+    const { detailed = false } = options;
+    await initParser();
+    if (!parserInstance) {
+        return createEmptyStructure("python", content.split("\n").length);
+    }
+    const tree = parserInstance.parse(content);
+    if (!tree) {
+        return createEmptyStructure("python", content.split("\n").length);
+    }
+    return extractStructure(tree, content, detailed);
+}
+/**
+ * Extract file structure from parsed tree
+ */
+function extractStructure(tree, content, detailed = false) {
+    const lines = content.split("\n");
+    const structure = createEmptyStructure("python", lines.length);
+    const rootNode = tree.rootNode;
+    // Walk the tree and extract elements
+    walkNode(rootNode, structure, lines, detailed);
+    return structure;
+}
+/**
+ * Recursively walk the AST and extract code elements
+ * @param detailed When true, extract signature and documentation
+ */
+function walkNode(node, structure, lines, detailed) {
+    switch (node.type) {
+        case "import_statement":
+        case "import_from_statement": {
+            const opts = {};
+            if (detailed) {
+                opts.signature = getImportSignature(node);
+            }
+            structure.imports.push(createCodeElement("import", getImportName(node), node, opts));
+            break;
+        }
+        case "function_definition": {
+            if (isModuleLevel(node)) {
+                const nameNode = node.childForFieldName("name");
+                const bodyNode = getBodyNode(node);
+                const isAsync = isAsyncFunction(node);
+                const opts = { isAsync };
+                if (detailed) {
+                    opts.signature = getFunctionSignature(node, isAsync);
+                    opts.documentation = extractDocstring(bodyNode);
+                }
+                structure.functions.push(createCodeElement("function", nameNode?.text ?? "unknown", node, opts));
+            }
+            else {
+                // It's a method
+                const nameNode = node.childForFieldName("name");
+                const bodyNode = getBodyNode(node);
+                const isAsync = isAsyncFunction(node);
+                const parentClass = getParentClassName(node);
+                const opts = { isAsync, parent: parentClass };
+                if (detailed) {
+                    opts.signature = getFunctionSignature(node, isAsync);
+                    opts.documentation = extractDocstring(bodyNode);
+                }
+                structure.functions.push(createCodeElement("method", nameNode?.text ?? "unknown", node, opts));
+            }
+            break;
+        }
+        case "class_definition": {
+            const nameNode = node.childForFieldName("name");
+            const bodyNode = getBodyNode(node);
+            const opts = {};
+            if (detailed) {
+                opts.signature = getClassSignature(node);
+                opts.documentation = extractDocstring(bodyNode);
+            }
+            structure.classes.push(createCodeElement("class", nameNode?.text ?? "unknown", node, opts));
+            // Walk into class body to find methods
+            if (bodyNode) {
+                for (const child of bodyNode.children) {
+                    walkNode(child, structure, lines, detailed);
+                }
+            }
+            return; // Don't walk children again
+        }
+        case "expression_statement": {
+            // Check for module-level assignments (variables)
+            if (isModuleLevel(node)) {
+                const assignment = node.firstNamedChild;
+                if (assignment?.type === "assignment") {
+                    const leftNode = assignment.childForFieldName("left");
+                    if (leftNode?.type === "identifier") {
+                        const opts = {};
+                        if (detailed) {
+                            opts.signature = node.text.split("\n")[0];
+                        }
+                        structure.variables.push(createCodeElement("variable", leftNode.text, node, opts));
+                    }
+                }
+            }
+            break;
+        }
+        case "decorated_definition": {
+            // Let the child function/class handle itself
+            for (const child of node.children) {
+                walkNode(child, structure, lines, detailed);
+            }
+            return; // Don't walk again
+        }
+    }
+    // Walk children
+    for (const child of node.children) {
+        walkNode(child, structure, lines, detailed);
+    }
+}
+/**
+ * Extract a specific element from Python code
+ */
+export async function extractPythonElement(content, target, options) {
+    const structure = await parsePythonAsync(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 "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) {
+        // Look for docstrings/comments above the element
+        for (let i = element.startLine - 2; i >= 0; i--) {
+            const line = lines[i]?.trim() ?? "";
+            if (line.startsWith("#") || line.startsWith('"""') || 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 searchPythonElements(content, query) {
+    const structure = await parsePythonAsync(content);
+    const queryLower = query.toLowerCase();
+    const results = [];
+    const allElements = [...structure.functions, ...structure.classes, ...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 Python
+ */
+export const pythonTreeSitterParser = {
+    languages: ["python"],
+    parse(content, options) {
+        // Synchronous parse - requires parser to be initialized first
+        // If not initialized, return empty structure
+        // The async initialization will happen on first tool call
+        if (!parserInstance || !pythonLanguage) {
+            // Trigger async init for next call
+            initParser().catch(() => { });
+            return parsePython(content, options);
+        }
+        return parsePython(content, options);
+    },
+    extractElement(content, target, options) {
+        // This is sync interface but we need async
+        // For now, ensure parser is initialized and use sync parsing
+        if (!parserInstance || !pythonLanguage) {
+            // Can't do async in sync interface, return null
+            // Trigger init for next call
+            initParser().catch(() => { });
+            return null;
+        }
+        // Extraction needs detailed parsing for proper display
+        const structure = parsePython(content, { detailed: true });
+        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 "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('"""') || 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 || !pythonLanguage) {
+            initParser().catch(() => { });
+            return [];
+        }
+        // Search needs detailed parsing to match against signature/documentation
+        const structure = parsePython(content, { detailed: true });
+        const queryLower = query.toLowerCase();
+        const results = [];
+        const allElements = [...structure.functions, ...structure.classes, ...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 parser (call this at server startup)
+ */
+export async function initPythonParser() {
+    await initParser();
+}

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

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

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

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

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

@@ -0,0 +1,186 @@
+/**
+ * Python Tree-sitter Parser Tests
+ */
+import { describe, it, expect, beforeAll } from "vitest";
+import { pythonTreeSitterParser, parsePythonAsync, initPythonParser, } from "./parser.js";
+// Sample Python code for testing
+const SAMPLE_PYTHON = `
+"""Module docstring."""
+
+import os
+from typing import List, Optional
+from dataclasses import dataclass
+
+# Constants
+MAX_SIZE = 100
+DEBUG = True
+
+@dataclass
+class User:
+    """A user class with name and age."""
+    name: str
+    age: int
+
+    def greet(self) -> str:
+        """Return a greeting message."""
+        return f"Hello, {self.name}!"
+
+    async def fetch_data(self) -> dict:
+        """Fetch user data asynchronously."""
+        return {"name": self.name, "age": self.age}
+
+
+class AdminUser(User):
+    """Admin user with extra permissions."""
+    permissions: List[str]
+
+    def has_permission(self, perm: str) -> bool:
+        return perm in self.permissions
+
+
+def calculate_sum(numbers: List[int]) -> int:
+    """Calculate the sum of a list of numbers."""
+    return sum(numbers)
+
+
+async def fetch_users() -> List[User]:
+    """Fetch all users from the database."""
+    return []
+
+
+def nested_function():
+    def inner():
+        pass
+    return inner
+`;
+describe("Python Tree-sitter Parser", () => {
+    beforeAll(async () => {
+        await initPythonParser();
+    });
+    describe("parsePythonAsync", () => {
+        it("should parse imports correctly", async () => {
+            const structure = await parsePythonAsync(SAMPLE_PYTHON);
+            expect(structure.language).toBe("python");
+            expect(structure.imports.length).toBeGreaterThanOrEqual(3);
+            const importNames = structure.imports.map((i) => i.name);
+            expect(importNames).toContain("os");
+        });
+        it("should parse functions correctly", async () => {
+            const structure = await parsePythonAsync(SAMPLE_PYTHON);
+            const funcNames = structure.functions.map((f) => f.name);
+            expect(funcNames).toContain("calculate_sum");
+            expect(funcNames).toContain("fetch_users");
+            expect(funcNames).toContain("nested_function");
+        });
+        it("should detect async functions", async () => {
+            const structure = await parsePythonAsync(SAMPLE_PYTHON);
+            const fetchUsers = structure.functions.find((f) => f.name === "fetch_users");
+            expect(fetchUsers).toBeDefined();
+            expect(fetchUsers?.isAsync).toBe(true);
+            const calculateSum = structure.functions.find((f) => f.name === "calculate_sum");
+            expect(calculateSum?.isAsync).toBeFalsy();
+        });
+        it("should parse classes correctly", async () => {
+            const structure = await parsePythonAsync(SAMPLE_PYTHON);
+            expect(structure.classes.length).toBeGreaterThanOrEqual(2);
+            const classNames = structure.classes.map((c) => c.name);
+            expect(classNames).toContain("User");
+            expect(classNames).toContain("AdminUser");
+        });
+        it("should extract docstrings", async () => {
+            const structure = await parsePythonAsync(SAMPLE_PYTHON, { detailed: true });
+            const userClass = structure.classes.find((c) => c.name === "User");
+            expect(userClass?.documentation).toContain("user class");
+            const calcSum = structure.functions.find((f) => f.name === "calculate_sum");
+            expect(calcSum?.documentation).toContain("sum");
+        });
+        it("should parse methods inside classes", async () => {
+            const structure = await parsePythonAsync(SAMPLE_PYTHON);
+            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("fetch_data");
+            expect(methodNames).toContain("has_permission");
+        });
+        it("should track parent class for methods", async () => {
+            const structure = await parsePythonAsync(SAMPLE_PYTHON);
+            const greet = structure.functions.find((f) => f.name === "greet");
+            expect(greet?.parent).toBe("User");
+            const hasPermission = structure.functions.find((f) => f.name === "has_permission");
+            expect(hasPermission?.parent).toBe("AdminUser");
+        });
+        it("should parse module-level variables", async () => {
+            const structure = await parsePythonAsync(SAMPLE_PYTHON);
+            const varNames = structure.variables.map((v) => v.name);
+            expect(varNames).toContain("MAX_SIZE");
+            expect(varNames).toContain("DEBUG");
+        });
+        it("should return correct line numbers", async () => {
+            const structure = await parsePythonAsync(SAMPLE_PYTHON);
+            const userClass = structure.classes.find((c) => c.name === "User");
+            expect(userClass?.startLine).toBeGreaterThan(0);
+            expect(userClass?.endLine).toBeGreaterThan(userClass?.startLine ?? 0);
+        });
+    });
+    describe("LanguageParser interface", () => {
+        it("should implement parse() method", () => {
+            // Note: This will return empty structure on first call if parser not initialized
+            const structure = pythonTreeSitterParser.parse(SAMPLE_PYTHON);
+            expect(structure).toBeDefined();
+            expect(structure.language).toBe("python");
+        });
+        it("should implement extractElement() method", async () => {
+            await initPythonParser();
+            const result = pythonTreeSitterParser.extractElement(SAMPLE_PYTHON, { type: "function", name: "calculate_sum" }, { includeImports: true, includeComments: true });
+            expect(result).not.toBeNull();
+            expect(result?.content).toContain("def calculate_sum");
+            expect(result?.elements[0]?.name).toBe("calculate_sum");
+        });
+        it("should implement searchElements() method", async () => {
+            await initPythonParser();
+            const results = pythonTreeSitterParser.searchElements(SAMPLE_PYTHON, "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 initPythonParser();
+            const result = pythonTreeSitterParser.extractElement(SAMPLE_PYTHON, { type: "function", name: "non_existent_function" }, { includeImports: false, includeComments: false });
+            expect(result).toBeNull();
+        });
+    });
+    describe("Edge cases", () => {
+        it("should handle empty content", async () => {
+            const structure = await parsePythonAsync("");
+            expect(structure.language).toBe("python");
+            expect(structure.totalLines).toBe(1);
+            expect(structure.functions).toHaveLength(0);
+        });
+        it("should handle syntax errors gracefully", async () => {
+            const invalidCode = `
+def broken_function(
+    # Missing closing parenthesis and body
+`;
+            const structure = await parsePythonAsync(invalidCode);
+            expect(structure).toBeDefined();
+            expect(structure.language).toBe("python");
+        });
+        it("should handle decorated functions", async () => {
+            const code = `
+@decorator
+def decorated_func():
+    pass
+
+@decorator1
+@decorator2
+async def multi_decorated():
+    pass
+`;
+            const structure = await parsePythonAsync(code);
+            const funcNames = structure.functions.map((f) => f.name);
+            expect(funcNames).toContain("decorated_func");
+            expect(funcNames).toContain("multi_decorated");
+        });
+    });
+});

package/dist/ast/python/queries.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Python Tree-sitter Queries
+ *
+ * S-expression queries for extracting Python code elements.
+ * Tree-sitter uses a query language similar to Lisp S-expressions.
+ */
+/**
+ * Query to find all function definitions (including async)
+ * Captures:
+ * - @function: the function_definition node
+ * - @name: the function name
+ */
+export declare const FUNCTION_QUERY = "\n(function_definition\n  name: (identifier) @name) @function\n";
+/**
+ * Query to find all class definitions
+ * Captures:
+ * - @class: the class_definition node
+ * - @name: the class name
+ */
+export declare const CLASS_QUERY = "\n(class_definition\n  name: (identifier) @name) @class\n";
+/**
+ * Query to find all import statements
+ * Captures:
+ * - @import: the import statement node
+ */
+export declare const IMPORT_QUERY = "\n[\n  (import_statement) @import\n  (import_from_statement) @import\n]\n";
+/**
+ * Query to find all decorated definitions
+ * Captures:
+ * - @decorator: the decorator node
+ * - @definition: the decorated definition (function or class)
+ */
+export declare const DECORATED_QUERY = "\n(decorated_definition\n  (decorator) @decorator\n  definition: [\n    (function_definition) @function\n    (class_definition) @class\n  ])\n";
+/**
+ * Query to find all assignments at module level (variables)
+ * Captures:
+ * - @variable: the assignment node
+ * - @name: the variable name
+ */
+export declare const VARIABLE_QUERY = "\n(module\n  (expression_statement\n    (assignment\n      left: (identifier) @name) @variable))\n";
+/**
+ * Query to find all type aliases (using TypeAlias or simple assignment with type annotation)
+ * Captures:
+ * - @type_alias: the type alias definition
+ */
+export declare const TYPE_ALIAS_QUERY = "\n(module\n  (type_alias_statement\n    name: (type) @name) @type_alias)\n";
+/**
+ * Query to find class methods
+ * Captures:
+ * - @method: the function_definition node inside a class
+ * - @name: the method name
+ * - @class_name: the parent class name
+ */
+export declare const METHOD_QUERY = "\n(class_definition\n  name: (identifier) @class_name\n  body: (block\n    (function_definition\n      name: (identifier) @method_name) @method))\n";
+/**
+ * Combined query for all top-level definitions
+ * This is more efficient than running multiple queries
+ */
+export declare const ALL_DEFINITIONS_QUERY = "\n; Functions at module level\n(module\n  (function_definition\n    name: (identifier) @func_name) @function)\n\n; Decorated functions at module level\n(module\n  (decorated_definition\n    (function_definition\n      name: (identifier) @decorated_func_name) @decorated_function))\n\n; Classes at module level\n(module\n  (class_definition\n    name: (identifier) @class_name) @class)\n\n; Decorated classes at module level\n(module\n  (decorated_definition\n    (class_definition\n      name: (identifier) @decorated_class_name) @decorated_class))\n\n; Import statements\n(import_statement) @import\n(import_from_statement) @import_from\n\n; Module-level variables\n(module\n  (expression_statement\n    (assignment\n      left: (identifier) @var_name) @variable))\n";
+/**
+ * Query patterns as a single object for easy access
+ */
+export declare const QUERIES: {
+    readonly function: "\n(function_definition\n  name: (identifier) @name) @function\n";
+    readonly class: "\n(class_definition\n  name: (identifier) @name) @class\n";
+    readonly import: "\n[\n  (import_statement) @import\n  (import_from_statement) @import\n]\n";
+    readonly decorated: "\n(decorated_definition\n  (decorator) @decorator\n  definition: [\n    (function_definition) @function\n    (class_definition) @class\n  ])\n";
+    readonly variable: "\n(module\n  (expression_statement\n    (assignment\n      left: (identifier) @name) @variable))\n";
+    readonly typeAlias: "\n(module\n  (type_alias_statement\n    name: (type) @name) @type_alias)\n";
+    readonly method: "\n(class_definition\n  name: (identifier) @class_name\n  body: (block\n    (function_definition\n      name: (identifier) @method_name) @method))\n";
+    readonly all: "\n; Functions at module level\n(module\n  (function_definition\n    name: (identifier) @func_name) @function)\n\n; Decorated functions at module level\n(module\n  (decorated_definition\n    (function_definition\n      name: (identifier) @decorated_func_name) @decorated_function))\n\n; Classes at module level\n(module\n  (class_definition\n    name: (identifier) @class_name) @class)\n\n; Decorated classes at module level\n(module\n  (decorated_definition\n    (class_definition\n      name: (identifier) @decorated_class_name) @decorated_class))\n\n; Import statements\n(import_statement) @import\n(import_from_statement) @import_from\n\n; Module-level variables\n(module\n  (expression_statement\n    (assignment\n      left: (identifier) @var_name) @variable))\n";
+};
+//# sourceMappingURL=queries.d.ts.map