@unerr-ai/unerr 0.2.0 → 0.2.2

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

@@ -1,358 +0,0 @@
-/**
- * Python Language Plugin — entity, edge, and import extraction
- * from Tree-sitter AST.
- *
- * Handles: .py
- *
- * Entity extraction: functions, classes, methods, decorators (unwrapped)
- * Edge extraction: contains, calls, extends
- * Import resolution: import, from...import
- */
-import { bodyHash, entityKey } from "../entity-key.js";
-function textOf(node) {
-    return node?.text ?? "";
-}
-function isAsync(node) {
-    for (const child of node.children) {
-        if (child.type === "async")
-            return true;
-    }
-    return (node.type === "async_function_definition" ||
-        node.type === "async_with_statement");
-}
-function extractDoc(node) {
-    const body = node.childForFieldName("body");
-    if (!body)
-        return null;
-    const firstStmt = body.namedChildren[0];
-    if (firstStmt?.type === "expression_statement") {
-        const expr = firstStmt.namedChildren[0];
-        if (expr?.type === "string" || expr?.type === "concatenated_string") {
-            const text = textOf(expr);
-            return text.slice(0, 500);
-        }
-    }
-    return null;
-}
-function countParameters(node) {
-    const params = node.childForFieldName("parameters");
-    if (!params)
-        return 0;
-    return params.namedChildren.filter((c) => c.type === "identifier" ||
-        c.type === "default_parameter" ||
-        c.type === "typed_parameter" ||
-        c.type === "typed_default_parameter" ||
-        c.type === "list_splat_pattern" ||
-        c.type === "dictionary_splat_pattern").length;
-}
-function countParametersExcludingSelf(node) {
-    const params = node.childForFieldName("parameters");
-    if (!params)
-        return 0;
-    return params.namedChildren.filter((c) => {
-        if (c.type !== "identifier" &&
-            c.type !== "default_parameter" &&
-            c.type !== "typed_parameter" &&
-            c.type !== "typed_default_parameter" &&
-            c.type !== "list_splat_pattern" &&
-            c.type !== "dictionary_splat_pattern")
-            return false;
-        const nameNode = c.type === "identifier"
-            ? c
-            : (c.childForFieldName("name") ?? c.namedChildren[0] ?? null);
-        const name = textOf(nameNode);
-        return name !== "self" && name !== "cls";
-    }).length;
-}
-function extractSignature(node, name) {
-    const params = node.childForFieldName("parameters");
-    const returnType = node.childForFieldName("return_type");
-    const paramsText = params ? textOf(params) : "()";
-    const returnText = returnType ? ` -> ${textOf(returnType)}` : "";
-    return `def ${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 isTopLevel(node) {
-    let parent = node.parent;
-    while (parent) {
-        if (parent.type === "module")
-            return true;
-        if (parent.type === "class_definition" ||
-            parent.type === "function_definition" ||
-            parent.type === "async_function_definition")
-            return false;
-        parent = parent.parent;
-    }
-    return true;
-}
-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);
-    ctx.entities.push({
-        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),
-        body_hash: bodyHash(body || textOf(node)),
-        exported: opts.exported ?? true,
-        parent_key: scope || null,
-        language: "python",
-        is_async: opts.isAsync ?? false,
-        parameter_count: opts.paramCount ?? 0,
-        doc,
-    });
-    if (scope) {
-        ctx.edges.push({
-            from_key: scope,
-            to_key: key,
-            type: "contains",
-            file_path: ctx.filePath,
-            line: node.startPosition.row + 1,
-        });
-    }
-    return key;
-}
-function unwrapDecorated(node) {
-    if (node.type === "decorated_definition") {
-        const definition = node.childForFieldName("definition") ??
-            node.namedChildren[node.namedChildren.length - 1];
-        if (definition)
-            return definition;
-    }
-    return node;
-}
-function visitNode(node, ctx) {
-    const actualNode = unwrapDecorated(node);
-    switch (actualNode.type) {
-        case "function_definition":
-        case "async_function_definition": {
-            const name = getName(actualNode);
-            if (!name)
-                break;
-            const inClass = ctx.scopeStack.length > 0;
-            const kind = inClass ? "method" : "function";
-            const asyncFn = actualNode.type === "async_function_definition" || isAsync(actualNode);
-            const paramCount = inClass
-                ? countParametersExcludingSelf(actualNode)
-                : countParameters(actualNode);
-            const key = addEntity(ctx, node, kind, name, {
-                exported: true,
-                isAsync: asyncFn,
-                paramCount,
-                signature: extractSignature(actualNode, name),
-            });
-            ctx.scopeStack.push({ key, name });
-            visitChildren(actualNode, ctx);
-            ctx.scopeStack.pop();
-            return;
-        }
-        case "class_definition": {
-            const name = getName(actualNode);
-            if (!name)
-                break;
-            const key = addEntity(ctx, node, "class", name, {
-                exported: true,
-                signature: `class ${name}`,
-            });
-            const superclasses = actualNode.childForFieldName("superclasses");
-            if (superclasses) {
-                for (const arg of superclasses.namedChildren) {
-                    const baseName = textOf(arg).split("(")[0]?.trim();
-                    if (baseName && baseName !== "object") {
-                        ctx.edges.push({
-                            from_key: key,
-                            to_key: `unresolved:${baseName}`,
-                            type: "extends",
-                            file_path: ctx.filePath,
-                            line: arg.startPosition.row + 1,
-                        });
-                    }
-                }
-            }
-            ctx.scopeStack.push({ key, name });
-            visitChildren(actualNode, ctx);
-            ctx.scopeStack.pop();
-            return;
-        }
-        case "call": {
-            const fn = actualNode.childForFieldName("function") ?? actualNode.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: actualNode.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 === "attribute") {
-        const attr = node.childForFieldName("attribute");
-        return attr ? textOf(attr) : null;
-    }
-    return null;
-}
-function extractImports(tree, filePath) {
-    const imports = [];
-    function visit(node) {
-        if (node.type === "import_statement") {
-            const line = node.startPosition.row + 1;
-            for (const child of node.namedChildren) {
-                if (child.type === "dotted_name") {
-                    const moduleName = textOf(child);
-                    imports.push({
-                        source: moduleName,
-                        symbols: [moduleName.split(".").pop()],
-                        isDefault: true,
-                        isNamespace: false,
-                        localName: moduleName.split(".").pop(),
-                        line,
-                    });
-                }
-                else if (child.type === "aliased_import") {
-                    const name = child.childForFieldName("name");
-                    const alias = child.childForFieldName("alias");
-                    if (name) {
-                        imports.push({
-                            source: textOf(name),
-                            symbols: [textOf(name)],
-                            isDefault: true,
-                            isNamespace: false,
-                            localName: alias ? textOf(alias) : undefined,
-                            line,
-                        });
-                    }
-                }
-            }
-        }
-        else if (node.type === "import_from_statement") {
-            const line = node.startPosition.row + 1;
-            const moduleNode = node.childForFieldName("module_name") ??
-                node.namedChildren.find((c) => c.type === "dotted_name" || c.type === "relative_import");
-            const source = moduleNode ? textOf(moduleNode) : ".";
-            const symbols = [];
-            let isWildcard = false;
-            for (const child of node.namedChildren) {
-                if (child.type === "dotted_name" && child !== moduleNode) {
-                    symbols.push(textOf(child));
-                }
-                else if (child.type === "aliased_import") {
-                    const name = child.childForFieldName("name");
-                    if (name)
-                        symbols.push(textOf(name));
-                }
-                else if (child.type === "wildcard_import") {
-                    isWildcard = true;
-                }
-            }
-            if (isWildcard) {
-                imports.push({
-                    source,
-                    symbols: ["*"],
-                    isDefault: false,
-                    isNamespace: true,
-                    line,
-                });
-            }
-            else if (symbols.length > 0) {
-                imports.push({
-                    source,
-                    symbols,
-                    isDefault: false,
-                    isNamespace: false,
-                    line,
-                });
-            }
-            else {
-                imports.push({
-                    source,
-                    symbols: [],
-                    isDefault: false,
-                    isNamespace: false,
-                    line,
-                });
-            }
-        }
-        for (const child of node.namedChildren) {
-            visit(child);
-        }
-    }
-    visit(tree.rootNode);
-    return imports;
-}
-export const pythonPlugin = {
-    id: "python",
-    extensions: [".py"],
-    grammarWasmName: "tree-sitter-python.wasm",
-    extract(tree, filePath, source) {
-        const ctx = {
-            filePath,
-            source,
-            entities: [],
-            edges: [],
-            scopeStack: [],
-        };
-        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") {
-                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",
-                    });
-                }
-            }
-            for (const child of node.namedChildren) {
-                visit(child);
-            }
-        }
-        visit(bodyNode);
-        return calls;
-    },
-};

package/dist/intelligence/indexer/plugins/regex-fallback.js

@@ -1,82 +0,0 @@
-/**
- * Tier-3 Regex Fallback Plugin — basic entity detection for unsupported languages.
- *
- * Produces file-level entities and basic function/class detection using
- * language-agnostic regex patterns. Lower confidence than tree-sitter,
- * but provides baseline coverage for any text file with code-like structure.
- */
-import { bodyHash, entityKey } from "../entity-key.js";
-const FUNCTION_PATTERN = /(?:^|\n)\s*(?:export\s+)?(?:async\s+)?(?:function|def|func|fn|fun|sub|proc)\s+(\w+)/gm;
-const CLASS_PATTERN = /(?:^|\n)\s*(?:export\s+)?(?:abstract\s+)?(?:class|struct|interface|trait|enum|module|object)\s+(\w+)/gm;
-function extractWithRegex(source, filePath, language) {
-    const entities = [];
-    const edges = [];
-    const lines = source.split("\n");
-    let match;
-    FUNCTION_PATTERN.lastIndex = 0;
-    match = FUNCTION_PATTERN.exec(source);
-    while (match !== null) {
-        const name = match[1];
-        const lineNum = source.slice(0, match.index).split("\n").length;
-        entities.push({
-            key: entityKey(filePath, "function", name, ""),
-            kind: "function",
-            name,
-            file_path: filePath,
-            start_line: lineNum,
-            end_line: lineNum + 5,
-            signature: `${name}()`,
-            body_hash: bodyHash(match[0]),
-            exported: match[0].includes("export"),
-            parent_key: null,
-            language,
-            is_async: match[0].includes("async"),
-            parameter_count: 0,
-            doc: null,
-        });
-        match = FUNCTION_PATTERN.exec(source);
-    }
-    CLASS_PATTERN.lastIndex = 0;
-    match = CLASS_PATTERN.exec(source);
-    while (match !== null) {
-        const name = match[1];
-        const lineNum = source.slice(0, match.index).split("\n").length;
-        entities.push({
-            key: entityKey(filePath, "class", name, ""),
-            kind: "class",
-            name,
-            file_path: filePath,
-            start_line: lineNum,
-            end_line: lineNum + 10,
-            signature: `class ${name}`,
-            body_hash: bodyHash(match[0]),
-            exported: match[0].includes("export"),
-            parent_key: null,
-            language,
-            is_async: false,
-            parameter_count: 0,
-            doc: null,
-        });
-        match = CLASS_PATTERN.exec(source);
-    }
-    return { entities, edges };
-}
-export const regexFallbackPlugin = {
-    id: "regex-fallback",
-    extensions: [],
-    grammarWasmName: "",
-    extract(_tree, filePath, source) {
-        const ext = filePath.slice(filePath.lastIndexOf(".") + 1);
-        return extractWithRegex(source, filePath, ext);
-    },
-    resolveImports() {
-        return [];
-    },
-};
-/**
- * Standalone extraction without tree-sitter (for files with no grammar).
- */
-export function regexExtract(source, filePath) {
-    const ext = filePath.slice(filePath.lastIndexOf(".") + 1);
-    return extractWithRegex(source, filePath, ext);
-}