@unerr-ai/unerr 0.2.1 → 0.2.3

package/dist/intelligence/indexer/plugins/rust.js

@@ -1,484 +0,0 @@
-/**
- * Rust Language Plugin — entity, edge, and import extraction
- * from Tree-sitter AST.
- *
- * Handles: .rs
- *
- * Entity extraction: functions, structs, enums, traits, impl blocks, type aliases
- * Edge extraction: contains, calls, extends (trait bounds), implements (impl Trait)
- * Import resolution: use declarations
- */
-import { bodyHash, entityKey } from "../entity-key.js";
-function textOf(node) {
-    return node?.text ?? "";
-}
-function hasPubVisibility(node) {
-    for (const child of node.children) {
-        if (child.type === "visibility_modifier")
-            return true;
-    }
-    return false;
-}
-function isAsync(node) {
-    for (const child of node.children) {
-        if (textOf(child) === "async")
-            return true;
-    }
-    return false;
-}
-function extractDoc(node) {
-    let doc = "";
-    let sibling = node.previousSibling;
-    while (sibling) {
-        if (sibling.type === "line_comment" || sibling.type === "block_comment") {
-            const text = textOf(sibling);
-            if (text.startsWith("///") ||
-                text.startsWith("//!") ||
-                text.startsWith("/**")) {
-                doc = `${text}\n${doc}`;
-                sibling = sibling.previousSibling;
-                continue;
-            }
-        }
-        break;
-    }
-    return doc.length > 0 ? doc.trim().slice(0, 500) : null;
-}
-function countParameters(node) {
-    const params = node.childForFieldName("parameters");
-    if (!params)
-        return 0;
-    return params.namedChildren.filter((c) => c.type === "parameter" ||
-        c.type === "self_parameter" ||
-        c.type === "variadic_parameter").length;
-}
-function countParametersExcludingSelf(node) {
-    const params = node.childForFieldName("parameters");
-    if (!params)
-        return 0;
-    return params.namedChildren.filter((c) => c.type === "parameter" || c.type === "variadic_parameter").length;
-}
-function hasSelfParam(node) {
-    const params = node.childForFieldName("parameters");
-    if (!params)
-        return false;
-    return params.namedChildren.some((c) => c.type === "self_parameter");
-}
-function extractSignature(node, name, kind) {
-    if (kind === "class")
-        return `struct ${name}`;
-    if (kind === "interface")
-        return `trait ${name}`;
-    if (kind === "enum")
-        return `enum ${name}`;
-    if (kind === "type")
-        return `type ${name}`;
-    if (kind === "namespace")
-        return `impl ${name}`;
-    const params = node.childForFieldName("parameters");
-    const returnType = node.childForFieldName("return_type");
-    const paramsText = params ? textOf(params) : "()";
-    const returnText = returnType ? ` -> ${textOf(returnType)}` : "";
-    const asyncPrefix = isAsync(node) ? "async " : "";
-    return `${asyncPrefix}fn ${name}${paramsText}${returnText}`;
-}
-function getBody(node) {
-    const body = node.childForFieldName("body");
-    return body ? textOf(body) : "";
-}
-function getName(node) {
-    const nameNode = node.childForFieldName("name");
-    if (nameNode)
-        return textOf(nameNode);
-    return null;
-}
-function currentScope(ctx) {
-    return ctx.scopeStack.length > 0
-        ? ctx.scopeStack[ctx.scopeStack.length - 1].key
-        : "";
-}
-function addEntity(ctx, node, kind, name, opts = {}) {
-    const scope = currentScope(ctx);
-    const key = entityKey(ctx.filePath, kind, name, scope);
-    const doc = extractDoc(node);
-    const body = getBody(node);
-    const entity = {
-        key,
-        kind,
-        name,
-        file_path: ctx.filePath,
-        start_line: node.startPosition.row + 1,
-        end_line: node.endPosition.row + 1,
-        signature: opts.signature ?? extractSignature(node, name, kind),
-        body_hash: bodyHash(body || textOf(node)),
-        exported: opts.exported ?? hasPubVisibility(node),
-        parent_key: scope || null,
-        language: "rust",
-        is_async: opts.isAsync ?? false,
-        parameter_count: opts.paramCount ?? 0,
-        doc,
-    };
-    if (ctx.inCfgTest) {
-        entity.is_test = true;
-    }
-    ctx.entities.push(entity);
-    if (scope) {
-        ctx.edges.push({
-            from_key: scope,
-            to_key: key,
-            type: "contains",
-            file_path: ctx.filePath,
-            line: node.startPosition.row + 1,
-        });
-    }
-    return key;
-}
-/**
- * Check if a node has a #[cfg(test)] attribute.
- * Tree-sitter represents this as an attribute_item sibling before the node.
- */
-function hasCfgTestAttribute(node) {
-    let sibling = node.previousSibling;
-    while (sibling) {
-        if (sibling.type === "attribute_item") {
-            const text = textOf(sibling);
-            if (text.includes("cfg") && text.includes("test"))
-                return true;
-        }
-        else if (sibling.type !== "line_comment" &&
-            sibling.type !== "block_comment") {
-            break;
-        }
-        sibling = sibling.previousSibling;
-    }
-    return false;
-}
-function visitNode(node, ctx) {
-    switch (node.type) {
-        case "function_item": {
-            const name = getName(node);
-            if (!name)
-                break;
-            const inImpl = ctx.scopeStack.length > 0;
-            const kind = inImpl && hasSelfParam(node) ? "method" : "function";
-            const paramCount = inImpl
-                ? countParametersExcludingSelf(node)
-                : countParameters(node);
-            const key = addEntity(ctx, node, kind, name, {
-                exported: hasPubVisibility(node),
-                isAsync: isAsync(node),
-                paramCount,
-            });
-            ctx.scopeStack.push({ key, name });
-            visitChildren(node, ctx);
-            ctx.scopeStack.pop();
-            return;
-        }
-        case "struct_item": {
-            const name = getName(node);
-            if (!name)
-                break;
-            const key = addEntity(ctx, node, "class", name, {
-                exported: hasPubVisibility(node),
-                signature: `struct ${name}`,
-            });
-            ctx.scopeStack.push({ key, name });
-            const body = node.childForFieldName("body");
-            if (body) {
-                for (const field of body.namedChildren) {
-                    if (field.type === "field_declaration") {
-                        const fieldName = getName(field);
-                        if (fieldName) {
-                            addEntity(ctx, field, "property", fieldName, {
-                                exported: hasPubVisibility(field),
-                                signature: fieldName,
-                            });
-                        }
-                    }
-                }
-            }
-            ctx.scopeStack.pop();
-            return;
-        }
-        case "enum_item": {
-            const name = getName(node);
-            if (!name)
-                break;
-            addEntity(ctx, node, "enum", name, {
-                exported: hasPubVisibility(node),
-                signature: `enum ${name}`,
-            });
-            return;
-        }
-        case "trait_item": {
-            const name = getName(node);
-            if (!name)
-                break;
-            const key = addEntity(ctx, node, "interface", name, {
-                exported: hasPubVisibility(node),
-                signature: `trait ${name}`,
-            });
-            const bounds = node.childForFieldName("bounds");
-            if (bounds) {
-                for (const bound of bounds.namedChildren) {
-                    const boundName = textOf(bound).split("<")[0]?.trim();
-                    if (boundName) {
-                        ctx.edges.push({
-                            from_key: key,
-                            to_key: `unresolved:${boundName}`,
-                            type: "extends",
-                            file_path: ctx.filePath,
-                            line: bound.startPosition.row + 1,
-                        });
-                    }
-                }
-            }
-            ctx.scopeStack.push({ key, name });
-            visitChildren(node, ctx);
-            ctx.scopeStack.pop();
-            return;
-        }
-        case "impl_item": {
-            const typeNode = node.childForFieldName("type");
-            const traitNode = node.childForFieldName("trait");
-            const typeName = typeNode ? textOf(typeNode).split("<")[0]?.trim() : null;
-            if (!typeName)
-                break;
-            const implName = traitNode
-                ? `${textOf(traitNode).split("<")[0]?.trim()} for ${typeName}`
-                : typeName;
-            const key = addEntity(ctx, node, "namespace", implName, {
-                exported: true,
-                signature: `impl ${implName}`,
-            });
-            if (traitNode) {
-                const traitName = textOf(traitNode).split("<")[0]?.trim();
-                const typeKey = entityKey(ctx.filePath, "class", typeName, "");
-                ctx.edges.push({
-                    from_key: typeKey,
-                    to_key: `unresolved:${traitName}`,
-                    type: "implements",
-                    file_path: ctx.filePath,
-                    line: traitNode.startPosition.row + 1,
-                });
-            }
-            ctx.scopeStack.push({ key, name: implName });
-            visitChildren(node, ctx);
-            ctx.scopeStack.pop();
-            return;
-        }
-        case "mod_item": {
-            const name = getName(node);
-            if (!name)
-                break;
-            // Detect #[cfg(test)] attribute on this module
-            const isCfgTest = hasCfgTestAttribute(node);
-            const key = addEntity(ctx, node, "namespace", name, {
-                exported: hasPubVisibility(node),
-                signature: `mod ${name}`,
-            });
-            const prevCfgTest = ctx.inCfgTest;
-            if (isCfgTest)
-                ctx.inCfgTest = true;
-            ctx.scopeStack.push({ key, name });
-            visitChildren(node, ctx);
-            ctx.scopeStack.pop();
-            ctx.inCfgTest = prevCfgTest;
-            return;
-        }
-        case "type_item": {
-            const name = getName(node);
-            if (!name)
-                break;
-            addEntity(ctx, node, "type", name, {
-                exported: hasPubVisibility(node),
-                signature: `type ${name}`,
-            });
-            return;
-        }
-        case "call_expression": {
-            const fn = node.childForFieldName("function") ?? node.namedChildren[0];
-            if (fn && ctx.scopeStack.length > 0) {
-                const calleeName = extractCalleeName(fn);
-                if (calleeName) {
-                    ctx.edges.push({
-                        from_key: currentScope(ctx),
-                        to_key: `unresolved:${calleeName}`,
-                        type: "calls",
-                        file_path: ctx.filePath,
-                        line: node.startPosition.row + 1,
-                    });
-                }
-            }
-            break;
-        }
-        case "macro_invocation": {
-            const macro = node.namedChildren[0];
-            if (macro && ctx.scopeStack.length > 0) {
-                const macroName = textOf(macro);
-                if (macroName) {
-                    ctx.edges.push({
-                        from_key: currentScope(ctx),
-                        to_key: `unresolved:${macroName}`,
-                        type: "calls",
-                        file_path: ctx.filePath,
-                        line: node.startPosition.row + 1,
-                    });
-                }
-            }
-            break;
-        }
-    }
-    visitChildren(node, ctx);
-}
-function visitChildren(node, ctx) {
-    for (const child of node.namedChildren) {
-        visitNode(child, ctx);
-    }
-}
-function extractCalleeName(node) {
-    if (node.type === "identifier")
-        return textOf(node);
-    if (node.type === "field_expression") {
-        const field = node.childForFieldName("field");
-        return field ? textOf(field) : null;
-    }
-    if (node.type === "scoped_identifier") {
-        const name = node.childForFieldName("name");
-        return name ? textOf(name) : null;
-    }
-    return null;
-}
-function extractImports(tree, filePath) {
-    const imports = [];
-    function processUseTree(useTree, basePath, line) {
-        if (useTree.type === "use_as_clause") {
-            const path = useTree.namedChildren[0];
-            const alias = useTree.childForFieldName("alias");
-            const source = path ? basePath + textOf(path) : basePath;
-            const parts = source.split("::");
-            const symbol = parts[parts.length - 1];
-            imports.push({
-                source: parts.slice(0, -1).join("::"),
-                symbols: [symbol],
-                isDefault: false,
-                isNamespace: false,
-                localName: alias ? textOf(alias) : symbol,
-                line,
-            });
-            return;
-        }
-        if (useTree.type === "use_list") {
-            for (const child of useTree.namedChildren) {
-                processUseTree(child, basePath, line);
-            }
-            return;
-        }
-        if (useTree.type === "use_wildcard") {
-            imports.push({
-                source: basePath.replace(/::$/, ""),
-                symbols: ["*"],
-                isDefault: false,
-                isNamespace: true,
-                line,
-            });
-            return;
-        }
-        if (useTree.type === "scoped_use_list") {
-            const path = useTree.childForFieldName("path");
-            const list = useTree.childForFieldName("list");
-            const newBase = path ? `${basePath + textOf(path)}::` : basePath;
-            if (list) {
-                processUseTree(list, newBase, line);
-            }
-            return;
-        }
-        if (useTree.type === "scoped_identifier" || useTree.type === "identifier") {
-            const fullPath = basePath + textOf(useTree);
-            const parts = fullPath.split("::");
-            const symbol = parts[parts.length - 1];
-            imports.push({
-                source: parts.slice(0, -1).join("::"),
-                symbols: [symbol],
-                isDefault: false,
-                isNamespace: false,
-                localName: symbol,
-                line,
-            });
-            return;
-        }
-        const text = textOf(useTree);
-        if (text) {
-            const fullPath = basePath + text;
-            const parts = fullPath.split("::");
-            const symbol = parts[parts.length - 1];
-            imports.push({
-                source: parts.slice(0, -1).join("::") || fullPath,
-                symbols: [symbol],
-                isDefault: false,
-                isNamespace: false,
-                localName: symbol,
-                line,
-            });
-        }
-    }
-    function visit(node) {
-        if (node.type === "use_declaration") {
-            const line = node.startPosition.row + 1;
-            const argument = node.namedChildren.find((c) => c.type !== "visibility_modifier" &&
-                c.type !== "line_comment" &&
-                c.type !== "block_comment");
-            if (argument) {
-                processUseTree(argument, "", line);
-            }
-        }
-        for (const child of node.namedChildren) {
-            visit(child);
-        }
-    }
-    visit(tree.rootNode);
-    return imports;
-}
-export const rustPlugin = {
-    id: "rust",
-    extensions: [".rs"],
-    grammarWasmName: "tree-sitter-rust.wasm",
-    extract(tree, filePath, source) {
-        const ctx = {
-            filePath,
-            source,
-            entities: [],
-            edges: [],
-            scopeStack: [],
-            inCfgTest: false,
-        };
-        for (const child of tree.rootNode.namedChildren) {
-            visitNode(child, ctx);
-        }
-        return { entities: ctx.entities, edges: ctx.edges };
-    },
-    resolveImports(tree, filePath) {
-        return extractImports(tree, filePath);
-    },
-    detectCalls(bodyNode) {
-        const calls = [];
-        function visit(node) {
-            if (node.type === "call_expression") {
-                const fn = node.childForFieldName("function") ?? node.namedChildren[0];
-                const name = fn ? extractCalleeName(fn) : null;
-                if (name) {
-                    calls.push({
-                        calleeName: name,
-                        line: node.startPosition.row + 1,
-                        isAwait: node.parent?.type === "await_expression",
-                    });
-                }
-            }
-            for (const child of node.namedChildren) {
-                visit(child);
-            }
-        }
-        visit(bodyNode);
-        return calls;
-    },
-};