@oisheek_c/codeforge 1.0.1

package/packages/retrieval/parser/extractors/exports.js

@@ -0,0 +1,71 @@
+/**
+ * packages/retrieval/parser/extractors/exports.js
+ */
+
+import {
+    iterateCaptures,
+    getNodeLocation,
+    getNodeText,
+} from "../helpers.js";
+
+import { createExport } from "../types.js";
+
+export default function extractExports({
+    query,
+    tree,
+    source,
+}) {
+    const exportsList = [];
+
+    if (!query) {
+        return exportsList;
+    }
+
+    for (const { node, name } of iterateCaptures(query, tree)) {
+        if (
+            !name ||
+            !name.startsWith("export.")
+        ) {
+            continue;
+        }
+
+        const exportName =
+            typeof node?.text === "string"
+                ? node.text.trim()
+                : "";
+
+        if (!exportName) {
+            continue;
+        }
+
+        const kind =
+            name.replace(/^export\./, "");
+
+        exportsList.push(
+            createExport({
+                name: exportName,
+
+                kind,
+
+                default:
+                    kind === "default",
+
+                exported:
+                    exportName,
+
+                location:
+                    getNodeLocation(node),
+
+                metadata: {
+                    text:
+                        getNodeText(
+                            node,
+                            source
+                        ),
+                },
+            })
+        );
+    }
+
+    return exportsList;
+}

package/packages/retrieval/parser/extractors/imports.js

@@ -0,0 +1,40 @@
+/**
+ * packages/retrieval/parser/extractors/imports.js
+ */
+
+import {
+    iterateCaptures,
+    getNodeLocation,
+    getNodeText,
+} from "../helpers.js";
+
+import { createImport } from "../types.js";
+
+export default function extractImports({
+    query,
+    tree,
+    source,
+}) {
+    const imports = [];
+
+    if (!query) {
+        return imports;
+    }
+
+    for (const { node } of iterateCaptures(query, tree)) {
+        imports.push(
+            createImport({
+                // The Tree-sitter query should capture only the module/source node.
+                source: node.text,
+
+                location: getNodeLocation(node),
+
+                metadata: {
+                    text: getNodeText(node, source),
+                },
+            })
+        );
+    }
+
+    return imports;
+}

package/packages/retrieval/parser/extractors/index.js

@@ -0,0 +1,12 @@
+/**
+ * packages/retrieval/parser/extractors/index.js
+ */
+
+export { default as symbols } from "./symbols.js";
+export { default as imports } from "./imports.js";
+export { default as exports } from "./exports.js";
+export { default as calls } from "./calls.js";
+export { default as comments } from "./comments.js";
+export { default as todos } from "./todos.js";
+export { default as diagnostics } from "./diagnostics.js";
+export { default as metrics } from "./metrics.js";

package/packages/retrieval/parser/extractors/metrics.js

@@ -0,0 +1,78 @@
+/**
+ * packages/retrieval/parser/extractors/metrics.js
+ */
+
+import { createMetrics } from "../types.js";
+
+export default function extractMetrics({
+    source,
+    symbols = [],
+    imports = [],
+    exports = [],
+    todos = [],
+}) {
+    const lines = source.split(/\r?\n/);
+
+    let code = 0;
+    let comments = 0;
+    let blanks = 0;
+
+    for (const line of lines) {
+        const text = line.trim();
+
+        if (!text) {
+            blanks++;
+            continue;
+        }
+
+        if (
+            text.startsWith("//") ||
+            text.startsWith("#") ||
+            text.startsWith("/*") ||
+            text.startsWith("*") ||
+            text.startsWith("--")
+        ) {
+            comments++;
+            continue;
+        }
+
+        code++;
+    }
+
+    const functions = symbols.filter(
+        (s) => s.kind === "function"
+    ).length;
+
+    const classes = symbols.filter(
+        (s) =>
+            s.kind === "class" ||
+            s.kind === "interface" ||
+            s.kind === "struct" ||
+            s.kind === "trait"
+    ).length;
+
+    const methods = symbols.filter(
+        (s) => s.kind === "method"
+    ).length;
+
+    return createMetrics({
+        lines: lines.length,
+
+        code,
+        comments,
+        blanks,
+
+        functions,
+        classes,
+        methods,
+
+        imports: imports.length,
+
+        exports: exports.length,
+
+        todos: todos.length,
+
+        // Placeholder until we implement CFG/cyclomatic analysis
+        complexity: functions,
+    });
+}

package/packages/retrieval/parser/extractors/symbols.js

@@ -0,0 +1,51 @@
+/**
+ * packages/retrieval/parser/extractors/symbols.js
+ */
+
+import {
+    iterateCaptures,
+    createId,
+    getNodeLocation,
+    getNodeText,
+    normalizeCapture,
+} from "../helpers.js";
+
+import { createSymbol } from "../types.js";
+
+export default function extractSymbols({
+    query,
+    tree,
+    source,
+    file,
+    language,
+}) {
+    const symbols = [];
+
+    if (!query) return symbols;
+
+    for (const capture of iterateCaptures(query, tree)) {
+        const node = capture.node;
+
+        symbols.push(
+            createSymbol({
+                id: createId(),
+
+                name: node.text,
+
+                kind: normalizeCapture(capture.name),
+
+                language,
+
+                file,
+
+                location: getNodeLocation(node),
+
+                metadata: {
+                    text: getNodeText(node, source),
+                },
+            })
+        );
+    }
+
+    return symbols;
+}

package/packages/retrieval/parser/extractors/todos.js

@@ -0,0 +1,53 @@
+/**
+ * packages/retrieval/parser/extractors/todos.js
+ */
+
+import {
+    iterateCaptures,
+    getNodeLocation,
+    getNodeText,
+} from "../helpers.js";
+
+import { createTodo } from "../types.js";
+
+const TODO_PATTERN = /\b(TODO|FIXME|BUG|HACK|NOTE|XXX)\b[:\-\s]?(.*)/i;
+
+export default function extractTodos({
+    query,
+    tree,
+    source,
+}) {
+    const todos = [];
+
+    if (!query) {
+        return todos;
+    }
+
+    for (const { node } of iterateCaptures(query, tree)) {
+        const text = getNodeText(node, source);
+
+        const match = text.match(TODO_PATTERN);
+
+        if (!match) {
+            continue;
+        }
+
+        todos.push(
+            createTodo({
+                type: match[1].toUpperCase(),
+
+                text: match[2]?.trim() ?? "",
+
+                line: node.startPosition.row + 1,
+
+                metadata: {
+                    raw: text,
+                },
+
+                location: getNodeLocation(node),
+            })
+        );
+    }
+
+    return todos;
+}

package/packages/retrieval/parser/helpers.js

@@ -0,0 +1,138 @@
+/**
+ * packages/retrieval/parser/helpers.js
+ */
+
+import crypto from "node:crypto";
+import { createLocation } from "./types.js";
+
+/* -------------------------------------------------------------------------- */
+/* IDs                                                                         */
+/* -------------------------------------------------------------------------- */
+
+export function createId() {
+    return crypto.randomUUID();
+}
+
+/* -------------------------------------------------------------------------- */
+/* Node Text                                                                   */
+/* -------------------------------------------------------------------------- */
+
+export function getNodeText(node, source) {
+    if (!node) return "";
+
+    return source.slice(node.startIndex, node.endIndex);
+}
+
+/* -------------------------------------------------------------------------- */
+/* Node Name                                                                   */
+/* -------------------------------------------------------------------------- */
+
+export function getNodeName(node) {
+    return node?.text ?? "";
+}
+
+/* -------------------------------------------------------------------------- */
+/* Location                                                                    */
+/* -------------------------------------------------------------------------- */
+
+export function getNodeLocation(node) {
+    if (!node) return createLocation();
+
+    return createLocation({
+        startLine: node.startPosition.row + 1,
+        startColumn: node.startPosition.column + 1,
+
+        endLine: node.endPosition.row + 1,
+        endColumn: node.endPosition.column + 1,
+    });
+}
+
+/* -------------------------------------------------------------------------- */
+/* Capture Helpers                                                             */
+/* -------------------------------------------------------------------------- */
+
+export function normalizeCapture(name = "") {
+    return name.replace(/^symbol\./, "");
+}
+
+export function isSymbolCapture(name) {
+    return name.startsWith("symbol.");
+}
+
+export function isImportCapture(name) {
+    return name === "import";
+}
+
+export function isExportCapture(name) {
+    return name === "export";
+}
+
+export function isCallCapture(name) {
+    return name === "call";
+}
+
+export function isCommentCapture(name) {
+    return name === "comment";
+}
+
+export function isTodoCapture(name) {
+    return name === "todo";
+}
+
+/* -------------------------------------------------------------------------- */
+/* Query Execution                                                             */
+/* -------------------------------------------------------------------------- */
+
+export function runQuery(query, tree) {
+    if (!query) return [];
+
+    return query.matches(tree.rootNode);
+}
+
+export function* iterateCaptures(query, tree) {
+    for (const match of runQuery(query, tree)) {
+        for (const capture of match.captures) {
+            yield {
+                node: capture.node,
+                name: capture.name,
+            };
+        }
+    }
+}
+
+/* -------------------------------------------------------------------------- */
+/* Tree Helpers                                                                */
+/* -------------------------------------------------------------------------- */
+
+
+export function getParent(node) {
+    return node?.parent ?? null;
+}
+
+export function isTopLevel(node) {
+    if (!node) return false;
+
+    const parent = node.parent;
+
+    return (
+        !parent ||
+        parent.type === "program" ||
+        parent.type === "module"
+    );
+}
+
+/* -------------------------------------------------------------------------- */
+/* Utilities                                                                   */
+/* -------------------------------------------------------------------------- */
+
+export function unique(array) {
+    return [...new Set(array)];
+}
+
+export function hasErrors(tree) {
+    return tree.rootNode.hasError;
+}
+
+export function getRoot(tree) {
+    return tree.rootNode;
+}

package/packages/retrieval/parser/index.js

@@ -0,0 +1,10 @@
+/**
+ * packages/retrieval/parser/index.js
+ */
+
+export { parseFile } from "./parseFile.js";
+export { parseRepository } from "./parseRepository.js";
+
+export * from "./registry.js";
+export * from "./languages.js";
+export * from "./types.js";

package/packages/retrieval/parser/languages/c.js

@@ -0,0 +1,14 @@
+import C from "tree-sitter-c";
+import * as queries from "../queries/c.js";
+
+export default {
+    id: "c",
+
+    grammar: C,
+
+    queries,
+
+    extensions: [".c", ".h"],
+
+    aliases: ["c"],
+};

package/packages/retrieval/parser/languages/cpp.js

@@ -0,0 +1,21 @@
+import CPP from "tree-sitter-cpp";
+import * as queries from "../queries/cpp.js";
+
+export default {
+    id: "cpp",
+
+    grammar: CPP,
+
+    queries,
+
+    extensions: [
+        ".cpp",
+        ".cc",
+        ".cxx",
+        ".hpp",
+        ".hh",
+        ".hxx",
+    ],
+
+    aliases: ["cpp", "c++"],
+};

package/packages/retrieval/parser/languages/csharp.js

@@ -0,0 +1,14 @@
+import CSharp from "tree-sitter-c-sharp";
+import * as queries from "../queries/csharp.js";
+
+export default {
+    id: "csharp",
+
+    grammar: CSharp,
+
+    queries,
+
+    extensions: [".cs"],
+
+    aliases: ["csharp", "c#"],
+};

package/packages/retrieval/parser/languages/go.js

@@ -0,0 +1,14 @@
+import Go from "tree-sitter-go";
+import * as queries from "../queries/go.js";
+
+export default {
+    id: "go",
+
+    grammar: Go,
+
+    queries,
+
+    extensions: [".go"],
+
+    aliases: ["go", "golang"],
+};

package/packages/retrieval/parser/languages/index.js

@@ -0,0 +1,12 @@
+export { default as javascript } from "./javascript.js";
+export { default as typescript } from "./typescript.js";
+export { default as python } from "./python.js";
+export { default as java } from "./java.js";
+export { default as go } from "./go.js";
+export { default as rust } from "./rust.js";
+export { default as c } from "./c.js";
+export { default as cpp } from "./cpp.js";
+export { default as csharp } from "./csharp.js";
+export { default as php } from "./php.js";
+export { default as ruby } from "./ruby.js";
+export { default as swift } from "./swift.js";

package/packages/retrieval/parser/languages/java.js

@@ -0,0 +1,14 @@
+import Java from "tree-sitter-java";
+import * as queries from "../queries/java.js";
+
+export default {
+    id: "java",
+
+    grammar: Java,
+
+    queries,
+
+    extensions: [".java"],
+
+    aliases: ["java"],
+};

package/packages/retrieval/parser/languages/javascript.js

@@ -0,0 +1,14 @@
+import JavaScript from "tree-sitter-javascript";
+import * as queries from "../queries/javascript.js";
+
+export default {
+    id: "javascript",
+
+    grammar: JavaScript,
+
+    queries,
+
+    extensions: [".js", ".mjs", ".cjs"],
+
+    aliases: ["javascript", "js"],
+};

package/packages/retrieval/parser/languages/php.js

@@ -0,0 +1,14 @@
+import PHP from "tree-sitter-php";
+import * as queries from "../queries/php.js";
+
+export default {
+    id: "php",
+
+    grammar: PHP,
+
+    queries,
+
+    extensions: [".php"],
+
+    aliases: ["php"],
+};

package/packages/retrieval/parser/languages/python.js

@@ -0,0 +1,14 @@
+import Python from "tree-sitter-python";
+import * as queries from "../queries/python.js";
+
+export default {
+    id: "python",
+
+    grammar: Python,
+
+    queries,
+
+    extensions: [".py"],
+
+    aliases: ["python", "py"],
+};

package/packages/retrieval/parser/languages/ruby.js

@@ -0,0 +1,14 @@
+import Ruby from "tree-sitter-ruby";
+import * as queries from "../queries/ruby.js";
+
+export default {
+    id: "ruby",
+
+    grammar: Ruby,
+
+    queries,
+
+    extensions: [".rb"],
+
+    aliases: ["ruby", "rb"],
+};

package/packages/retrieval/parser/languages/rust.js

@@ -0,0 +1,14 @@
+import Rust from "tree-sitter-rust";
+import * as queries from "../queries/rust.js";
+
+export default {
+    id: "rust",
+
+    grammar: Rust,
+
+    queries,
+
+    extensions: [".rs"],
+
+    aliases: ["rust", "rs"],
+};

package/packages/retrieval/parser/languages/swift.js

@@ -0,0 +1,14 @@
+import Swift from "tree-sitter-swift";
+import * as queries from "../queries/swift.js";
+
+export default {
+    id: "swift",
+
+    grammar: Swift,
+
+    queries,
+
+    extensions: [".swift"],
+
+    aliases: ["swift"],
+};

package/packages/retrieval/parser/languages/typescript.js

@@ -0,0 +1,14 @@
+import TypeScript from "tree-sitter-typescript";
+import * as queries from "../queries/typescript.js";
+
+export default {
+    id: "typescript",
+
+    grammar: TypeScript.typescript,
+
+    queries,
+
+    extensions: [".ts", ".mts", ".cts"],
+
+    aliases: ["typescript", "ts"],
+};