@codebolt/codeboltjs 2.0.5 → 2.0.7

package/dist/modules/terminal.js

@@ -51,7 +51,7 @@ const cbterminal = {
      */
     sendManualInterrupt() {
         return websocket_1.default.messageManager.sendAndWaitForResponse({
-            "type": "sendInterruptToTerminal"
+            "type": "sendInterruptToTerminal",
         }, "terminalInterrupted");
     },
     /**

package/dist/{modules → utils}/docutils.d.ts

@@ -1,12 +1,9 @@
-/**
- * A module for document utility functions.
- */
-declare const cbdocutils: {
+declare const docutils: {
     /**
      * Converts a PDF document to text.
      * @param pdf_path - The file path to the PDF document to be converted.
      * @returns {Promise<string>} A promise that resolves with the converted text.
      */
-    pdf_to_text: (pdf_path: any) => Promise<string>;
+    pdf_to_text: (pdf_path: string) => Promise<string>;
 };
-export default cbdocutils;
+export default docutils;

package/dist/utils/docutils.js

@@ -0,0 +1,69 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * A module for document utility functions.
+ */
+const fs = __importStar(require("fs"));
+const pdf_parse_1 = __importDefault(require("pdf-parse"));
+const docutils = {
+    /**
+     * Converts a PDF document to text.
+     * @param pdf_path - The file path to the PDF document to be converted.
+     * @returns {Promise<string>} A promise that resolves with the converted text.
+     */
+    pdf_to_text: (pdf_path) => {
+        return new Promise((resolve, reject) => {
+            try {
+                // Check if file exists
+                if (!fs.existsSync(pdf_path)) {
+                    return reject(new Error(`PDF file not found at path: ${pdf_path}`));
+                }
+                // Read the PDF file as buffer
+                const dataBuffer = fs.readFileSync(pdf_path);
+                // Parse the PDF document
+                (0, pdf_parse_1.default)(dataBuffer)
+                    .then((data) => {
+                    resolve(data.text);
+                })
+                    .catch((error) => {
+                    reject(new Error(`Error parsing PDF: ${error.message}`));
+                });
+            }
+            catch (error) {
+                if (error instanceof Error) {
+                    reject(new Error(`Error processing PDF: ${error.message}`));
+                }
+                else {
+                    reject(new Error('Unknown error processing PDF'));
+                }
+            }
+        });
+    }
+};
+exports.default = docutils;

package/dist/utils/parse-source-code/index.d.ts

@@ -0,0 +1,9 @@
+export declare const LIST_FILES_LIMIT = 200;
+export declare function parseSourceCodeForDefinitionsTopLevel(dirPath: string): Promise<string>;
+export declare function listFiles(dirPath: string, recursive: boolean): Promise<string[]>;
+export declare function globbyLevelByLevel(options: any): Promise<string[]>;
+export declare function separateFiles(allFiles: string[]): {
+    filesToParse: string[];
+    remainingFiles: string[];
+};
+export declare function parseFile(filePath: string, languageParsers: any): Promise<string | undefined>;

package/dist/utils/parse-source-code/index.js

@@ -0,0 +1,233 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseFile = exports.separateFiles = exports.globbyLevelByLevel = exports.listFiles = exports.parseSourceCodeForDefinitionsTopLevel = exports.LIST_FILES_LIMIT = void 0;
+const fs = require("fs/promises");
+const os = require("os");
+const path = require("path");
+const { LanguageParser, loadRequiredLanguageParsers } = require("./languageParser");
+// const { globby } = await import("globby");
+const { globby } = require('@codebolt/globby');
+exports.LIST_FILES_LIMIT = 200;
+// TODO: implement caching behavior to avoid having to keep analyzing project for new tasks.
+async function parseSourceCodeForDefinitionsTopLevel(dirPath) {
+    // check if the path exists
+    const dirExists = await fs
+        .access(path.resolve(dirPath))
+        .then(() => true)
+        .catch(() => false);
+    if (!dirExists) {
+        return "This directory does not exist or you do not have permission to access it.";
+    }
+    // Get all files at top level (not gitignored)
+    const allFiles = await listFiles(dirPath, false);
+    let result = "";
+    // Separate files to parse and remaining files
+    const { filesToParse, remainingFiles } = separateFiles(allFiles);
+    const languageParsers = await loadRequiredLanguageParsers(filesToParse);
+    // Parse specific files we have language parsers for
+    // const filesWithoutDefinitions: string[] = []
+    for (const file of filesToParse) {
+        const definitions = await parseFile(file, languageParsers);
+        if (definitions) {
+            result += `${path.relative(dirPath, file)}\n${definitions}\n`;
+        }
+        // else {
+        // 	filesWithoutDefinitions.push(file)
+        // }
+    }
+    // List remaining files' paths
+    // let didFindUnparsedFiles = false
+    // filesWithoutDefinitions
+    // 	.concat(remainingFiles)
+    // 	.sort()
+    // 	.forEach((file) => {
+    // 		if (!didFindUnparsedFiles) {
+    // 			result += "# Unparsed Files\n\n"
+    // 			didFindUnparsedFiles = true
+    // 		}
+    // 		result += `${path.relative(dirPath, file)}\n`
+    // 	})
+    return result ? result : "No source code definitions found.";
+}
+exports.parseSourceCodeForDefinitionsTopLevel = parseSourceCodeForDefinitionsTopLevel;
+async function listFiles(dirPath, recursive) {
+    const absolutePath = path.resolve(dirPath);
+    // Do not allow listing files in root or home directory, which Claude tends to want to do when the user's prompt is vague.
+    const root = process.platform === "win32" ? path.parse(absolutePath).root : "/";
+    const isRoot = absolutePath === root;
+    if (isRoot) {
+        return [root];
+    }
+    const homeDir = os.homedir();
+    const isHomeDir = absolutePath === homeDir;
+    if (isHomeDir) {
+        return [homeDir];
+    }
+    const dirsToIgnore = [
+        "node_modules",
+        "__pycache__",
+        "env",
+        "venv",
+        "target/dependency",
+        "build/dependencies",
+        "dist",
+        "out",
+        "bundle",
+        "vendor",
+        "tmp",
+        "temp",
+        "deps",
+        "pkg",
+        "Pods",
+        ".*", // Ignore all hidden directories and files
+    ].map((dir) => `**/${dir}/**`);
+    const options = {
+        cwd: dirPath,
+        dot: false, // do not ignore hidden files/directories
+        absolute: true,
+        markDirectories: true, // Append a / on any directories matched
+        gitignore: recursive, // globby ignores any files that are gitignored
+        ignore: recursive ? dirsToIgnore : undefined, // just in case there is no gitignore, we ignore sensible defaults
+        onlyFiles: false, // true by default, false means it will list directories on their own too
+    };
+    // * globs all files in one dir, ** globs files in nested directories
+    const files = recursive
+        ? await globbyLevelByLevel(options)
+        : (await globby("*", options)).slice(0, exports.LIST_FILES_LIMIT);
+    return files;
+}
+exports.listFiles = listFiles;
+// globby doesnt natively support top down level by level globbing, so we implement it ourselves
+async function globbyLevelByLevel(options) {
+    let results = [];
+    const globbingProcess = async () => {
+        let currentLevel = 0;
+        // const { globby } = await import("globby");
+        while (results.length < exports.LIST_FILES_LIMIT) {
+            const pattern = currentLevel === 0 ? "*" : `${"*/".repeat(currentLevel)}*`;
+            const filesAtLevel = await globby(pattern, options);
+            if (filesAtLevel.length === 0) {
+                break;
+            }
+            results.push(...filesAtLevel);
+            if (results.length >= exports.LIST_FILES_LIMIT) {
+                results = results.slice(0, exports.LIST_FILES_LIMIT);
+                break;
+            }
+            currentLevel++;
+        }
+        return results;
+    };
+    // Timeout after 10 seconds and return partial results
+    const timeoutPromise = new Promise((_, reject) => {
+        setTimeout(() => reject(new Error("Globbing timeout")), 10000);
+    });
+    try {
+        return await Promise.race([globbingProcess(), timeoutPromise]);
+    }
+    catch (error) {
+        console.log(error);
+        console.warn("Globbing timed out, returning partial results");
+        return results;
+    }
+}
+exports.globbyLevelByLevel = globbyLevelByLevel;
+function separateFiles(allFiles) {
+    const extensions = [
+        "js",
+        "jsx",
+        "ts",
+        "tsx",
+        "py",
+        // Rust
+        "rs",
+        "go",
+        // C
+        "c",
+        "h",
+        // C++
+        "cpp",
+        "hpp",
+        // C#
+        "cs",
+        // Ruby
+        "rb",
+        "java",
+        "php",
+        "swift",
+    ].map((e) => `.${e}`);
+    const filesToParse = allFiles.filter((file) => extensions.includes(path.extname(file))).slice(0, 50); // 50 files max
+    const remainingFiles = allFiles.filter((file) => !filesToParse.includes(file));
+    return { filesToParse, remainingFiles };
+}
+exports.separateFiles = separateFiles;
+/*
+Parsing files using tree-sitter
+
+1. Parse the file content into an AST (Abstract Syntax Tree) using the appropriate language grammar (set of rules that define how the components of a language like keywords, expressions, and statements can be combined to create valid programs).
+2. Create a query using a language-specific query string, and run it against the AST's root node to capture specific syntax elements.
+    - We use tag queries to identify named entities in a program, and then use a syntax capture to label the entity and its name. A notable example of this is GitHub's search-based code navigation.
+    - Our custom tag queries are based on tree-sitter's default tag queries, but modified to only capture definitions.
+3. Sort the captures by their position in the file, output the name of the definition, and format by i.e. adding "|----\n" for gaps between captured sections.
+
+This approach allows us to focus on the most relevant parts of the code (defined by our language-specific queries) and provides a concise yet informative view of the file's structure and key elements.
+
+- https://github.com/tree-sitter/node-tree-sitter/blob/master/test/query_test.js
+- https://github.com/tree-sitter/tree-sitter/blob/master/lib/binding_web/test/query-test.js
+- https://github.com/tree-sitter/tree-sitter/blob/master/lib/binding_web/test/helper.js
+- https://tree-sitter.github.io/tree-sitter/code-navigation-systems
+*/
+async function parseFile(filePath, languageParsers) {
+    const fileContent = await fs.readFile(filePath, "utf8");
+    const ext = path.extname(filePath).toLowerCase().slice(1);
+    const { parser, query } = languageParsers[ext] || {};
+    if (!parser || !query) {
+        return `Unsupported file type: ${filePath}`;
+    }
+    let formattedOutput = "";
+    try {
+        // Parse the file content into an Abstract Syntax Tree (AST), a tree-like representation of the code
+        const tree = parser.parse(fileContent);
+        // Apply the query to the AST and get the captures
+        // Captures are specific parts of the AST that match our query patterns, each capture represents a node in the AST that we're interested in.
+        const captures = query.captures(tree.rootNode);
+        // Sort captures by their start position
+        captures.sort((a, b) => a.node.startPosition.row - b.node.startPosition.row);
+        // Split the file content into individual lines
+        const lines = fileContent.split("\n");
+        // Keep track of the last line we've processed
+        let lastLine = -1;
+        captures.forEach((capture) => {
+            const { node, name } = capture;
+            // Get the start and end lines of the current AST node
+            const startLine = node.startPosition.row;
+            const endLine = node.endPosition.row;
+            // Once we've retrieved the nodes we care about through the language query, we filter for lines with definition names only.
+            // name.startsWith("name.reference.") > refs can be used for ranking purposes, but we don't need them for the output
+            // previously we did `name.startsWith("name.definition.")` but this was too strict and excluded some relevant definitions
+            // Add separator if there's a gap between captures
+            if (lastLine !== -1 && startLine > lastLine + 1) {
+                formattedOutput += "|----\n";
+            }
+            // Only add the first line of the definition
+            // query captures includes the definition name and the definition implementation, but we only want the name (I found discrepencies in the naming structure for various languages, i.e. javascript names would be 'name' and typescript names would be 'name.definition)
+            if (name.includes("name") && lines[startLine]) {
+                formattedOutput += `│${lines[startLine]}\n`;
+            }
+            // Adds all the captured lines
+            // for (let i = startLine; i <= endLine; i++) {
+            // 	formattedOutput += `│${lines[i]}\n`
+            // }
+            //}
+            lastLine = endLine;
+        });
+    }
+    catch (error) {
+        console.log(`Error parsing file: ${error}\n`);
+    }
+    if (formattedOutput.length > 0) {
+        return `|----\n${formattedOutput}|----\n`;
+    }
+    return undefined;
+}
+exports.parseFile = parseFile;

package/dist/utils/parse-source-code/languageParser.d.ts

@@ -0,0 +1,8 @@
+import Parser from "web-tree-sitter";
+export interface LanguageParser {
+    [key: string]: {
+        parser: Parser;
+        query: Parser.Query;
+    };
+}
+export declare function loadRequiredLanguageParsers(filesToParse: string[]): Promise<LanguageParser>;

package/dist/utils/parse-source-code/languageParser.js

@@ -0,0 +1,137 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadRequiredLanguageParsers = void 0;
+const path = __importStar(require("path"));
+const web_tree_sitter_1 = __importDefault(require("web-tree-sitter"));
+const queries_1 = require("./queries");
+async function loadLanguage(langName) {
+    return await web_tree_sitter_1.default.Language.load(path.join(__dirname, `tree-sitter-${langName}.wasm`));
+}
+let isParserInitialized = false;
+async function initializeParser() {
+    if (!isParserInitialized) {
+        await web_tree_sitter_1.default.init();
+        isParserInitialized = true;
+    }
+}
+/*
+Using node bindings for tree-sitter is problematic in vscode extensions
+because of incompatibility with electron. Going the .wasm route has the
+advantage of not having to build for multiple architectures.
+
+We use web-tree-sitter and tree-sitter-wasms which provides auto-updating prebuilt WASM binaries for tree-sitter's language parsers.
+
+This function loads WASM modules for relevant language parsers based on input files:
+1. Extracts unique file extensions
+2. Maps extensions to language names
+3. Loads corresponding WASM files (containing grammar rules)
+4. Uses WASM modules to initialize tree-sitter parsers
+
+This approach optimizes performance by loading only necessary parsers once for all relevant files.
+
+Sources:
+- https://github.com/tree-sitter/node-tree-sitter/issues/169
+- https://github.com/tree-sitter/node-tree-sitter/issues/168
+- https://github.com/Gregoor/tree-sitter-wasms/blob/main/README.md
+- https://github.com/tree-sitter/tree-sitter/blob/master/lib/binding_web/README.md
+- https://github.com/tree-sitter/tree-sitter/blob/master/lib/binding_web/test/query-test.js
+*/
+async function loadRequiredLanguageParsers(filesToParse) {
+    await initializeParser();
+    const extensionsToLoad = new Set(filesToParse.map((file) => path.extname(file).toLowerCase().slice(1)));
+    const parsers = {};
+    for (const ext of extensionsToLoad) {
+        let language;
+        let query;
+        switch (ext) {
+            case "js":
+            case "jsx":
+                language = await loadLanguage("javascript");
+                query = language.query(queries_1.javascriptQuery);
+                break;
+            case "ts":
+                language = await loadLanguage("typescript");
+                query = language.query(queries_1.typescriptQuery);
+                break;
+            case "tsx":
+                language = await loadLanguage("tsx");
+                query = language.query(queries_1.typescriptQuery);
+                break;
+            case "py":
+                language = await loadLanguage("python");
+                query = language.query(queries_1.pythonQuery);
+                break;
+            case "rs":
+                language = await loadLanguage("rust");
+                query = language.query(queries_1.rustQuery);
+                break;
+            case "go":
+                language = await loadLanguage("go");
+                query = language.query(queries_1.goQuery);
+                break;
+            case "cpp":
+            case "hpp":
+                language = await loadLanguage("cpp");
+                query = language.query(queries_1.cppQuery);
+                break;
+            case "c":
+            case "h":
+                language = await loadLanguage("c");
+                query = language.query(queries_1.cQuery);
+                break;
+            case "cs":
+                language = await loadLanguage("c_sharp");
+                query = language.query(queries_1.csharpQuery);
+                break;
+            case "rb":
+                language = await loadLanguage("ruby");
+                query = language.query(queries_1.rubyQuery);
+                break;
+            case "java":
+                language = await loadLanguage("java");
+                query = language.query(queries_1.javaQuery);
+                break;
+            case "php":
+                language = await loadLanguage("php");
+                query = language.query(queries_1.phpQuery);
+                break;
+            case "swift":
+                language = await loadLanguage("swift");
+                query = language.query(queries_1.swiftQuery);
+                break;
+            default:
+                throw new Error(`Unsupported language: ${ext}`);
+        }
+        const parser = new web_tree_sitter_1.default();
+        parser.setLanguage(language);
+        parsers[ext] = { parser, query };
+    }
+    return parsers;
+}
+exports.loadRequiredLanguageParsers = loadRequiredLanguageParsers;

package/dist/utils/parse-source-code/queries/c-sharp.d.ts

@@ -0,0 +1,2 @@
+declare const _default: "\n(class_declaration\n name: (identifier) @name.definition.class\n) @definition.class\n\n(interface_declaration\n name: (identifier) @name.definition.interface\n) @definition.interface\n\n(method_declaration\n name: (identifier) @name.definition.method\n) @definition.method\n\n(namespace_declaration\n name: (identifier) @name.definition.module\n) @definition.module\n";
+export default _default;

package/dist/utils/parse-source-code/queries/c-sharp.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/*
+- class declarations
+- interface declarations
+- method declarations
+- namespace declarations
+*/
+exports.default = `
+(class_declaration
+ name: (identifier) @name.definition.class
+) @definition.class
+
+(interface_declaration
+ name: (identifier) @name.definition.interface
+) @definition.interface
+
+(method_declaration
+ name: (identifier) @name.definition.method
+) @definition.method
+
+(namespace_declaration
+ name: (identifier) @name.definition.module
+) @definition.module
+`;

package/dist/utils/parse-source-code/queries/c.d.ts

@@ -0,0 +1,2 @@
+declare const _default: "\n(struct_specifier name: (type_identifier) @name.definition.class body:(_)) @definition.class\n\n(declaration type: (union_specifier name: (type_identifier) @name.definition.class)) @definition.class\n\n(function_declarator declarator: (identifier) @name.definition.function) @definition.function\n\n(type_definition declarator: (type_identifier) @name.definition.type) @definition.type\n";
+export default _default;

package/dist/utils/parse-source-code/queries/c.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/*
+- struct declarations
+- union declarations
+- function declarations
+- typedef declarations
+*/
+exports.default = `
+(struct_specifier name: (type_identifier) @name.definition.class body:(_)) @definition.class
+
+(declaration type: (union_specifier name: (type_identifier) @name.definition.class)) @definition.class
+
+(function_declarator declarator: (identifier) @name.definition.function) @definition.function
+
+(type_definition declarator: (type_identifier) @name.definition.type) @definition.type
+`;

package/dist/utils/parse-source-code/queries/cpp.d.ts

@@ -0,0 +1,2 @@
+declare const _default: "\n(struct_specifier name: (type_identifier) @name.definition.class body:(_)) @definition.class\n\n(declaration type: (union_specifier name: (type_identifier) @name.definition.class)) @definition.class\n\n(function_declarator declarator: (identifier) @name.definition.function) @definition.function\n\n(function_declarator declarator: (field_identifier) @name.definition.function) @definition.function\n\n(function_declarator declarator: (qualified_identifier scope: (namespace_identifier) @scope name: (identifier) @name.definition.method)) @definition.method\n\n(type_definition declarator: (type_identifier) @name.definition.type) @definition.type\n\n(class_specifier name: (type_identifier) @name.definition.class) @definition.class\n";
+export default _default;

package/dist/utils/parse-source-code/queries/cpp.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/*
+- struct declarations
+- union declarations
+- function declarations
+- method declarations (with namespace scope)
+- typedef declarations
+- class declarations
+*/
+exports.default = `
+(struct_specifier name: (type_identifier) @name.definition.class body:(_)) @definition.class
+
+(declaration type: (union_specifier name: (type_identifier) @name.definition.class)) @definition.class
+
+(function_declarator declarator: (identifier) @name.definition.function) @definition.function
+
+(function_declarator declarator: (field_identifier) @name.definition.function) @definition.function
+
+(function_declarator declarator: (qualified_identifier scope: (namespace_identifier) @scope name: (identifier) @name.definition.method)) @definition.method
+
+(type_definition declarator: (type_identifier) @name.definition.type) @definition.type
+
+(class_specifier name: (type_identifier) @name.definition.class) @definition.class
+`;

package/dist/utils/parse-source-code/queries/go.d.ts

@@ -0,0 +1,2 @@
+declare const _default: "\n(\n  (comment)* @doc\n  .\n  (function_declaration\n    name: (identifier) @name.definition.function) @definition.function\n  (#strip! @doc \"^//\\s*\")\n  (#set-adjacent! @doc @definition.function)\n)\n\n(\n  (comment)* @doc\n  .\n  (method_declaration\n    name: (field_identifier) @name.definition.method) @definition.method\n  (#strip! @doc \"^//\\s*\")\n  (#set-adjacent! @doc @definition.method)\n)\n\n(type_spec\n  name: (type_identifier) @name.definition.type) @definition.type\n";
+export default _default;

package/dist/utils/parse-source-code/queries/go.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/*
+- function declarations (with associated comments)
+- method declarations (with associated comments)
+- type specifications
+*/
+exports.default = `
+(
+  (comment)* @doc
+  .
+  (function_declaration
+    name: (identifier) @name.definition.function) @definition.function
+  (#strip! @doc "^//\\s*")
+  (#set-adjacent! @doc @definition.function)
+)
+
+(
+  (comment)* @doc
+  .
+  (method_declaration
+    name: (field_identifier) @name.definition.method) @definition.method
+  (#strip! @doc "^//\\s*")
+  (#set-adjacent! @doc @definition.method)
+)
+
+(type_spec
+  name: (type_identifier) @name.definition.type) @definition.type
+`;

package/dist/utils/parse-source-code/queries/index.d.ts

@@ -0,0 +1,12 @@
+export { default as phpQuery } from "./php";
+export { default as typescriptQuery } from "./typescript";
+export { default as pythonQuery } from "./python";
+export { default as javascriptQuery } from "./javascript";
+export { default as javaQuery } from "./java";
+export { default as rustQuery } from "./rust";
+export { default as rubyQuery } from "./ruby";
+export { default as cppQuery } from "./cpp";
+export { default as cQuery } from "./c";
+export { default as csharpQuery } from "./c-sharp";
+export { default as goQuery } from "./go";
+export { default as swiftQuery } from "./swift";

package/dist/utils/parse-source-code/queries/index.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.swiftQuery = exports.goQuery = exports.csharpQuery = exports.cQuery = exports.cppQuery = exports.rubyQuery = exports.rustQuery = exports.javaQuery = exports.javascriptQuery = exports.pythonQuery = exports.typescriptQuery = exports.phpQuery = void 0;
+var php_1 = require("./php");
+Object.defineProperty(exports, "phpQuery", { enumerable: true, get: function () { return __importDefault(php_1).default; } });
+var typescript_1 = require("./typescript");
+Object.defineProperty(exports, "typescriptQuery", { enumerable: true, get: function () { return __importDefault(typescript_1).default; } });
+var python_1 = require("./python");
+Object.defineProperty(exports, "pythonQuery", { enumerable: true, get: function () { return __importDefault(python_1).default; } });
+var javascript_1 = require("./javascript");
+Object.defineProperty(exports, "javascriptQuery", { enumerable: true, get: function () { return __importDefault(javascript_1).default; } });
+var java_1 = require("./java");
+Object.defineProperty(exports, "javaQuery", { enumerable: true, get: function () { return __importDefault(java_1).default; } });
+var rust_1 = require("./rust");
+Object.defineProperty(exports, "rustQuery", { enumerable: true, get: function () { return __importDefault(rust_1).default; } });
+var ruby_1 = require("./ruby");
+Object.defineProperty(exports, "rubyQuery", { enumerable: true, get: function () { return __importDefault(ruby_1).default; } });
+var cpp_1 = require("./cpp");
+Object.defineProperty(exports, "cppQuery", { enumerable: true, get: function () { return __importDefault(cpp_1).default; } });
+var c_1 = require("./c");
+Object.defineProperty(exports, "cQuery", { enumerable: true, get: function () { return __importDefault(c_1).default; } });
+var c_sharp_1 = require("./c-sharp");
+Object.defineProperty(exports, "csharpQuery", { enumerable: true, get: function () { return __importDefault(c_sharp_1).default; } });
+var go_1 = require("./go");
+Object.defineProperty(exports, "goQuery", { enumerable: true, get: function () { return __importDefault(go_1).default; } });
+var swift_1 = require("./swift");
+Object.defineProperty(exports, "swiftQuery", { enumerable: true, get: function () { return __importDefault(swift_1).default; } });

package/dist/utils/parse-source-code/queries/java.d.ts

@@ -0,0 +1,2 @@
+declare const _default: "\n(class_declaration\n  name: (identifier) @name.definition.class) @definition.class\n\n(method_declaration\n  name: (identifier) @name.definition.method) @definition.method\n\n(interface_declaration\n  name: (identifier) @name.definition.interface) @definition.interface\n";
+export default _default;