@unerr-ai/unerr 0.1.0 → 0.1.1

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

@@ -0,0 +1,335 @@
+/**
+ * Go Language Plugin — entity, edge, and import extraction
+ * from Tree-sitter AST.
+ *
+ * Handles: .go
+ *
+ * Entity extraction: functions, methods, structs, interfaces, type declarations
+ * Edge extraction: contains, calls, extends (interface embedding)
+ * Import resolution: import declarations
+ */
+import { bodyHash, entityKey } from "../entity-key.js";
+function textOf(node) {
+    return node?.text ?? "";
+}
+function isExported(name) {
+    if (!name || name.length === 0)
+        return false;
+    const firstChar = name.charCodeAt(0);
+    return firstChar >= 65 && firstChar <= 90;
+}
+function extractDoc(node) {
+    const prev = node.previousSibling;
+    if (prev?.type === "comment") {
+        return textOf(prev).slice(0, 500);
+    }
+    let doc = "";
+    let sibling = node.previousSibling;
+    while (sibling?.type === "comment") {
+        doc = `${textOf(sibling)}\n${doc}`;
+        sibling = sibling.previousSibling;
+    }
+    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_declaration" ||
+        c.type === "variadic_parameter_declaration").length;
+}
+function extractSignature(node, name, kind) {
+    if (kind === "class" || kind === "interface" || kind === "type") {
+        return `type ${name}`;
+    }
+    const params = node.childForFieldName("parameters");
+    const result = node.childForFieldName("result");
+    const paramsText = params ? textOf(params) : "()";
+    const resultText = result ? ` ${textOf(result)}` : "";
+    return `func ${name}${paramsText}${resultText}`;
+}
+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);
+    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, kind),
+        body_hash: bodyHash(body || textOf(node)),
+        exported: opts.exported ?? isExported(name),
+        parent_key: scope || null,
+        language: "go",
+        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 visitNode(node, ctx) {
+    switch (node.type) {
+        case "function_declaration": {
+            const name = getName(node);
+            if (!name)
+                break;
+            const key = addEntity(ctx, node, "function", name, {
+                exported: isExported(name),
+                paramCount: countParameters(node),
+            });
+            ctx.scopeStack.push({ key, name });
+            visitChildren(node, ctx);
+            ctx.scopeStack.pop();
+            return;
+        }
+        case "method_declaration": {
+            const name = getName(node);
+            if (!name)
+                break;
+            const receiver = node.childForFieldName("receiver");
+            const receiverName = receiver
+                ? receiver.namedChildren
+                    .find((c) => c.type === "parameter_declaration")
+                    ?.childForFieldName("type")
+                : null;
+            const receiverText = receiverName
+                ? textOf(receiverName).replace("*", "")
+                : "";
+            const params = node.childForFieldName("parameters");
+            const result = node.childForFieldName("result");
+            const paramsText = params ? textOf(params) : "()";
+            const resultText = result ? ` ${textOf(result)}` : "";
+            const sig = `func (${receiverText}) ${name}${paramsText}${resultText}`;
+            const key = addEntity(ctx, node, "method", name, {
+                exported: isExported(name),
+                paramCount: countParameters(node),
+                signature: sig,
+            });
+            ctx.scopeStack.push({ key, name });
+            visitChildren(node, ctx);
+            ctx.scopeStack.pop();
+            return;
+        }
+        case "type_declaration": {
+            for (const spec of node.namedChildren) {
+                if (spec.type === "type_spec") {
+                    const name = getName(spec);
+                    if (!name)
+                        continue;
+                    const typeNode = spec.childForFieldName("type");
+                    const typeStr = typeNode ? typeNode.type : "";
+                    let kind;
+                    if (typeStr === "struct_type")
+                        kind = "class";
+                    else if (typeStr === "interface_type")
+                        kind = "interface";
+                    else
+                        kind = "type";
+                    const key = addEntity(ctx, spec, kind, name, {
+                        exported: isExported(name),
+                        signature: `type ${name}`,
+                    });
+                    if (typeNode && typeStr === "interface_type") {
+                        for (const field of typeNode.namedChildren) {
+                            if (field.type === "type_elem" ||
+                                field.type === "qualified_type" ||
+                                field.type === "type_identifier") {
+                                const embeddedName = textOf(field);
+                                if (embeddedName) {
+                                    ctx.edges.push({
+                                        from_key: key,
+                                        to_key: `unresolved:${embeddedName}`,
+                                        type: "extends",
+                                        file_path: ctx.filePath,
+                                        line: field.startPosition.row + 1,
+                                    });
+                                }
+                            }
+                        }
+                    }
+                    if (typeNode && typeStr === "struct_type") {
+                        ctx.scopeStack.push({ key, name });
+                        for (const field of typeNode.namedChildren) {
+                            if (field.type === "field_declaration") {
+                                const fieldNames = field.namedChildren.filter((c) => c.type === "field_identifier");
+                                for (const fn of fieldNames) {
+                                    addEntity(ctx, field, "property", textOf(fn), {
+                                        exported: isExported(textOf(fn)),
+                                        signature: textOf(fn),
+                                    });
+                                }
+                            }
+                        }
+                        ctx.scopeStack.pop();
+                    }
+                }
+            }
+            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;
+        }
+    }
+    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 === "selector_expression") {
+        const field = node.childForFieldName("field");
+        return field ? textOf(field) : null;
+    }
+    return null;
+}
+function extractImports(tree, filePath) {
+    const imports = [];
+    function visit(node) {
+        if (node.type === "import_declaration") {
+            for (const child of node.namedChildren) {
+                if (child.type === "import_spec") {
+                    const pathNode = child.childForFieldName("path");
+                    const nameNode = child.childForFieldName("name");
+                    if (pathNode) {
+                        const source = textOf(pathNode).replace(/"/g, "");
+                        const localName = nameNode ? textOf(nameNode) : undefined;
+                        const pkgName = localName ?? source.split("/").pop();
+                        imports.push({
+                            source,
+                            symbols: [pkgName],
+                            isDefault: false,
+                            isNamespace: true,
+                            localName: localName === "." ? undefined : (localName ?? pkgName),
+                            line: child.startPosition.row + 1,
+                        });
+                    }
+                }
+                else if (child.type === "import_spec_list") {
+                    for (const spec of child.namedChildren) {
+                        if (spec.type === "import_spec") {
+                            const pathNode = spec.childForFieldName("path");
+                            const nameNode = spec.childForFieldName("name");
+                            if (pathNode) {
+                                const source = textOf(pathNode).replace(/"/g, "");
+                                const localName = nameNode ? textOf(nameNode) : undefined;
+                                const pkgName = localName ?? source.split("/").pop();
+                                imports.push({
+                                    source,
+                                    symbols: [pkgName],
+                                    isDefault: false,
+                                    isNamespace: true,
+                                    localName: localName === "." ? undefined : (localName ?? pkgName),
+                                    line: spec.startPosition.row + 1,
+                                });
+                            }
+                        }
+                    }
+                }
+                else if (child.type === "interpreted_string_literal") {
+                    const source = textOf(child).replace(/"/g, "");
+                    const pkgName = source.split("/").pop();
+                    imports.push({
+                        source,
+                        symbols: [pkgName],
+                        isDefault: false,
+                        isNamespace: true,
+                        localName: pkgName,
+                        line: child.startPosition.row + 1,
+                    });
+                }
+            }
+        }
+        for (const child of node.namedChildren) {
+            visit(child);
+        }
+    }
+    visit(tree.rootNode);
+    return imports;
+}
+export const goPlugin = {
+    id: "go",
+    extensions: [".go"],
+    grammarWasmName: "tree-sitter-go.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_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: false,
+                    });
+                }
+            }
+            for (const child of node.namedChildren) {
+                visit(child);
+            }
+        }
+        visit(bodyNode);
+        return calls;
+    },
+};

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

@@ -0,0 +1,370 @@
+/**
+ * Java Language Plugin — entity, edge, and import extraction
+ * from Tree-sitter AST.
+ *
+ * Handles: .java
+ *
+ * Entity extraction: classes, methods, interfaces, enums, constructors
+ * Edge extraction: contains, calls, extends, implements
+ * Import resolution: import declarations
+ */
+import { bodyHash, entityKey } from "../entity-key.js";
+function textOf(node) {
+    return node?.text ?? "";
+}
+function hasModifier(node, modifier) {
+    for (const child of node.children) {
+        if (child.type === "modifiers") {
+            for (const mod of child.children) {
+                if (textOf(mod) === modifier)
+                    return true;
+            }
+        }
+        if (child.type === modifier)
+            return true;
+        if (textOf(child) === modifier)
+            return true;
+    }
+    return false;
+}
+function isPublic(node) {
+    return hasModifier(node, "public");
+}
+function isStatic(node) {
+    return hasModifier(node, "static");
+}
+function extractDoc(node) {
+    const prev = node.previousSibling;
+    if (prev?.type === "block_comment" || prev?.type === "line_comment") {
+        const text = textOf(prev);
+        if (text.startsWith("/**")) {
+            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 === "formal_parameter" || c.type === "spread_parameter").length;
+}
+function extractSignature(node, name, kind) {
+    if (kind === "class")
+        return `class ${name}`;
+    if (kind === "interface")
+        return `interface ${name}`;
+    if (kind === "enum")
+        return `enum ${name}`;
+    const params = node.childForFieldName("parameters");
+    const returnType = node.childForFieldName("type");
+    const paramsText = params ? textOf(params) : "()";
+    const returnText = returnType ? `${textOf(returnType)} ` : "";
+    if (kind === "constructor")
+        return `${name}${paramsText}`;
+    return `${returnText}${name}${paramsText}`;
+}
+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);
+    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, kind),
+        body_hash: bodyHash(body || textOf(node)),
+        exported: opts.exported ?? isPublic(node),
+        parent_key: scope || null,
+        language: "java",
+        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 extractSuperclass(node, entityKey, ctx) {
+    const superclass = node.childForFieldName("superclass");
+    if (superclass) {
+        const name = textOf(superclass).replace(/^extends\s+/, "");
+        if (name) {
+            ctx.edges.push({
+                from_key: entityKey,
+                to_key: `unresolved:${name}`,
+                type: "extends",
+                file_path: ctx.filePath,
+                line: superclass.startPosition.row + 1,
+            });
+        }
+    }
+}
+function extractInterfaces(node, entityKey, ctx) {
+    const interfaces = node.childForFieldName("interfaces");
+    if (interfaces) {
+        for (const child of interfaces.namedChildren) {
+            if (child.type === "type_list") {
+                for (const type of child.namedChildren) {
+                    const name = textOf(type);
+                    if (name) {
+                        ctx.edges.push({
+                            from_key: entityKey,
+                            to_key: `unresolved:${name}`,
+                            type: "implements",
+                            file_path: ctx.filePath,
+                            line: type.startPosition.row + 1,
+                        });
+                    }
+                }
+            }
+            else {
+                const name = textOf(child);
+                if (name) {
+                    ctx.edges.push({
+                        from_key: entityKey,
+                        to_key: `unresolved:${name}`,
+                        type: "implements",
+                        file_path: ctx.filePath,
+                        line: child.startPosition.row + 1,
+                    });
+                }
+            }
+        }
+    }
+}
+function extractSuperInterfaces(node, entityKey, ctx) {
+    for (const child of node.namedChildren) {
+        if (child.type === "extends_interfaces" || child.type === "type_list") {
+            for (const type of child.namedChildren) {
+                const name = textOf(type);
+                if (name) {
+                    ctx.edges.push({
+                        from_key: entityKey,
+                        to_key: `unresolved:${name}`,
+                        type: "extends",
+                        file_path: ctx.filePath,
+                        line: type.startPosition.row + 1,
+                    });
+                }
+            }
+        }
+    }
+}
+function visitNode(node, ctx) {
+    switch (node.type) {
+        case "class_declaration": {
+            const name = getName(node);
+            if (!name)
+                break;
+            const key = addEntity(ctx, node, "class", name, {
+                exported: isPublic(node),
+                signature: `class ${name}`,
+            });
+            extractSuperclass(node, key, ctx);
+            extractInterfaces(node, key, ctx);
+            ctx.scopeStack.push({ key, name });
+            visitChildren(node, ctx);
+            ctx.scopeStack.pop();
+            return;
+        }
+        case "interface_declaration": {
+            const name = getName(node);
+            if (!name)
+                break;
+            const key = addEntity(ctx, node, "interface", name, {
+                exported: isPublic(node),
+                signature: `interface ${name}`,
+            });
+            extractSuperInterfaces(node, key, ctx);
+            ctx.scopeStack.push({ key, name });
+            visitChildren(node, ctx);
+            ctx.scopeStack.pop();
+            return;
+        }
+        case "enum_declaration": {
+            const name = getName(node);
+            if (!name)
+                break;
+            const key = addEntity(ctx, node, "enum", name, {
+                exported: isPublic(node),
+                signature: `enum ${name}`,
+            });
+            ctx.scopeStack.push({ key, name });
+            visitChildren(node, ctx);
+            ctx.scopeStack.pop();
+            return;
+        }
+        case "method_declaration": {
+            const name = getName(node);
+            if (!name)
+                break;
+            const key = addEntity(ctx, node, "method", name, {
+                exported: isPublic(node),
+                paramCount: countParameters(node),
+                isAsync: hasModifier(node, "synchronized"),
+            });
+            ctx.scopeStack.push({ key, name });
+            visitChildren(node, ctx);
+            ctx.scopeStack.pop();
+            return;
+        }
+        case "constructor_declaration": {
+            const name = getName(node);
+            if (!name)
+                break;
+            const key = addEntity(ctx, node, "constructor", name, {
+                exported: isPublic(node),
+                paramCount: countParameters(node),
+            });
+            ctx.scopeStack.push({ key, name });
+            visitChildren(node, ctx);
+            ctx.scopeStack.pop();
+            return;
+        }
+        case "method_invocation": {
+            const nameNode = node.childForFieldName("name");
+            if (nameNode && ctx.scopeStack.length > 0) {
+                const calleeName = textOf(nameNode);
+                ctx.edges.push({
+                    from_key: currentScope(ctx),
+                    to_key: `unresolved:${calleeName}`,
+                    type: "calls",
+                    file_path: ctx.filePath,
+                    line: node.startPosition.row + 1,
+                });
+            }
+            break;
+        }
+        case "object_creation_expression": {
+            const typeNode = node.childForFieldName("type");
+            if (typeNode && ctx.scopeStack.length > 0) {
+                const calleeName = textOf(typeNode);
+                ctx.edges.push({
+                    from_key: currentScope(ctx),
+                    to_key: `unresolved:${calleeName}`,
+                    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 extractImports(tree, filePath) {
+    const imports = [];
+    function visit(node) {
+        if (node.type === "import_declaration") {
+            const line = node.startPosition.row + 1;
+            const isStaticImport = node.children.some((c) => textOf(c) === "static");
+            const scopedId = node.namedChildren.find((c) => c.type === "scoped_identifier" || c.type === "identifier");
+            if (!scopedId)
+                return;
+            const fullPath = textOf(scopedId);
+            const parts = fullPath.split(".");
+            const lastPart = parts[parts.length - 1];
+            const isWildcard = lastPart === "*";
+            const source = isWildcard
+                ? parts.slice(0, -1).join(".")
+                : parts.slice(0, -1).join(".");
+            if (isWildcard) {
+                imports.push({
+                    source: source || fullPath,
+                    symbols: ["*"],
+                    isDefault: false,
+                    isNamespace: true,
+                    line,
+                });
+            }
+            else {
+                imports.push({
+                    source,
+                    symbols: [lastPart],
+                    isDefault: false,
+                    isNamespace: false,
+                    localName: lastPart,
+                    line,
+                });
+            }
+        }
+        for (const child of node.namedChildren) {
+            visit(child);
+        }
+    }
+    visit(tree.rootNode);
+    return imports;
+}
+export const javaPlugin = {
+    id: "java",
+    extensions: [".java"],
+    grammarWasmName: "tree-sitter-java.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 === "method_invocation") {
+                const nameNode = node.childForFieldName("name");
+                if (nameNode) {
+                    calls.push({
+                        calleeName: textOf(nameNode),
+                        line: node.startPosition.row + 1,
+                        isAwait: false,
+                    });
+                }
+            }
+            for (const child of node.namedChildren) {
+                visit(child);
+            }
+        }
+        visit(bodyNode);
+        return calls;
+    },
+};