@unerr-ai/unerr 0.0.1 → 0.1.1

package/dist/intelligence/indexer/mutation-tracker.js

@@ -0,0 +1,79 @@
+/**
+ * State Mutation Detector — tracks assignments to member expressions.
+ *
+ * Detects when code modifies object state:
+ *   - this.x = value → "writes" edge from method to property
+ *   - obj.field = value → "writes" edge from scope to external entity
+ *   - array[i] = value → mutation detected
+ *
+ * These "writes" edges are critical for blast radius computation:
+ * a function that mutates shared state has a wider blast radius.
+ */
+/**
+ * Detect state mutations within a function/method body.
+ */
+export function detectMutations(bodyNode) {
+    const mutations = [];
+    function visit(node) {
+        if (node.type === "assignment_expression" ||
+            node.type === "augmented_assignment_expression") {
+            const left = node.childForFieldName("left") ?? node.namedChildren[0];
+            if (left?.type === "member_expression") {
+                const object = left.childForFieldName("object") ?? left.namedChildren[0];
+                const property = left.childForFieldName("property") ?? left.namedChildren[1];
+                if (object && property) {
+                    const isThis = object.text === "this";
+                    mutations.push({
+                        target: left.text,
+                        isThisMutation: isThis,
+                        line: node.startPosition.row + 1,
+                        propertyName: property.text,
+                    });
+                }
+            }
+            if (left?.type === "subscript_expression") {
+                const object = left.namedChildren[0];
+                if (object) {
+                    mutations.push({
+                        target: object.text,
+                        isThisMutation: object.text === "this",
+                        line: node.startPosition.row + 1,
+                        propertyName: "[index]",
+                    });
+                }
+            }
+        }
+        if (node.type === "update_expression") {
+            const arg = node.namedChildren[0];
+            if (arg?.type === "member_expression") {
+                const object = arg.childForFieldName("object") ?? arg.namedChildren[0];
+                const property = arg.childForFieldName("property") ?? arg.namedChildren[1];
+                if (object && property) {
+                    mutations.push({
+                        target: arg.text,
+                        isThisMutation: object.text === "this",
+                        line: node.startPosition.row + 1,
+                        propertyName: property.text,
+                    });
+                }
+            }
+        }
+        for (const child of node.namedChildren) {
+            visit(child);
+        }
+    }
+    visit(bodyNode);
+    return mutations;
+}
+/**
+ * Convert mutation sites into "writes" edges.
+ */
+export function mutationsToEdges(mutations, scopeKey, filePath) {
+    return mutations.map((m) => ({
+        from_key: scopeKey,
+        to_key: `property:${m.target}`,
+        type: "writes",
+        file_path: filePath,
+        line: m.line,
+    }));
+}

package/dist/intelligence/indexer/orchestrator.js

@@ -0,0 +1,155 @@
+/**
+ * Indexer Orchestrator — file discovery → plugin dispatch → results merge.
+ *
+ * Discovers source files, selects the appropriate language plugin, parses
+ * via tree-sitter, extracts entities + edges, and returns the merged result.
+ *
+ * Supports both single-file and batch-file indexing.
+ * Worker pool integration is optional (see worker.ts).
+ */
+import { readFileSync, readdirSync, statSync } from "node:fs";
+import { join, relative } from "node:path";
+import { createModuleLogger } from "../../utils/logger.js";
+import { parseSource } from "../tree-sitter-loader.js";
+import { getPluginForFile, } from "./plugin-interface.js";
+const log = createModuleLogger("indexer");
+const DEFAULT_IGNORE = new Set([
+    "node_modules",
+    ".git",
+    ".unerr",
+    "dist",
+    "build",
+    "out",
+    ".next",
+    ".nuxt",
+    "coverage",
+    "__pycache__",
+    ".venv",
+    "vendor",
+]);
+/**
+ * Path-prefix exclusions (relative to projectRoot). Used in addition to
+ * the basename-only DEFAULT_IGNORE check above to handle agent worktrees
+ * precisely without over-matching user-named `worktrees/` folders.
+ */
+const EXCLUDED_PATH_PREFIXES = [
+    ".claude/worktrees",
+    ".cursor/worktrees",
+    ".idea/worktrees",
+];
+function isExcludedPath(relPath) {
+    for (const prefix of EXCLUDED_PATH_PREFIXES) {
+        if (relPath === prefix || relPath.startsWith(`${prefix}/`))
+            return true;
+    }
+    return false;
+}
+const MAX_FILE_SIZE = 500 * 1024;
+/**
+ * Discover all indexable source files in a project.
+ */
+export function discoverFiles(projectRoot, ignorePatterns = DEFAULT_IGNORE) {
+    const files = [];
+    function walk(dir) {
+        let entries;
+        try {
+            entries = readdirSync(dir);
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (entry.startsWith(".") && entry !== ".")
+                continue;
+            if (ignorePatterns.has(entry))
+                continue;
+            const fullPath = join(dir, entry);
+            // Path-aware exclusion (e.g. `.claude/worktrees/`).
+            if (isExcludedPath(relative(projectRoot, fullPath)))
+                continue;
+            let stat;
+            try {
+                stat = statSync(fullPath);
+            }
+            catch {
+                continue;
+            }
+            if (stat.isDirectory()) {
+                walk(fullPath);
+            }
+            else if (stat.isFile()) {
+                const plugin = getPluginForFile(fullPath);
+                if (plugin && stat.size <= MAX_FILE_SIZE) {
+                    files.push(relative(projectRoot, fullPath));
+                }
+            }
+        }
+    }
+    walk(projectRoot);
+    return files;
+}
+/**
+ * Index a single file. Returns extraction results.
+ */
+export async function indexFile(filePath, projectRoot) {
+    const plugin = getPluginForFile(filePath);
+    if (!plugin)
+        return null;
+    const absolutePath = filePath.startsWith("/")
+        ? filePath
+        : join(projectRoot, filePath);
+    let source;
+    try {
+        source = readFileSync(absolutePath, "utf-8");
+    }
+    catch {
+        return null;
+    }
+    if (source.length > MAX_FILE_SIZE)
+        return null;
+    try {
+        const tree = await parseSource(source, plugin.grammarWasmName);
+        const relativePath = filePath.startsWith("/")
+            ? relative(projectRoot, filePath)
+            : filePath;
+        const extraction = plugin.extract(tree, relativePath, source);
+        const imports = plugin.resolveImports(tree, relativePath);
+        tree.delete();
+        return { extraction, imports };
+    }
+    catch (err) {
+        log.debug(`Failed to index ${filePath}: ${err instanceof Error ? err.message : String(err)}`);
+        return null;
+    }
+}
+/**
+ * Index all files in a project. Returns merged results.
+ */
+export async function indexProject(options) {
+    const start = performance.now();
+    const { projectRoot, ignorePatterns } = options;
+    const files = discoverFiles(projectRoot, ignorePatterns ?? DEFAULT_IGNORE);
+    const allEntities = [];
+    const allEdges = [];
+    const allImports = [];
+    let errorCount = 0;
+    for (const file of files) {
+        const result = await indexFile(file, projectRoot);
+        if (result) {
+            allEntities.push(...result.extraction.entities);
+            allEdges.push(...result.extraction.edges);
+            allImports.push(...result.imports);
+        }
+        else {
+            errorCount++;
+        }
+    }
+    return {
+        entities: allEntities,
+        edges: allEdges,
+        imports: allImports,
+        fileCount: files.length,
+        errorCount,
+        durationMs: performance.now() - start,
+    };
+}

package/dist/intelligence/indexer/plugin-interface.js

@@ -0,0 +1,31 @@
+/**
+ * Language Plugin Interface — contract for all language extractors.
+ *
+ * Each plugin handles one language family and provides:
+ *   - Entity extraction from a Tree-sitter AST
+ *   - Intra-file edge extraction (contains, calls, extends, implements)
+ *   - Import resolution (source path + imported symbols)
+ *
+ * Plugins are registered in the registry and looked up by file extension.
+ */
+const pluginRegistry = new Map();
+const extensionIndex = new Map();
+export function registerPlugin(plugin) {
+    pluginRegistry.set(plugin.id, plugin);
+    for (const ext of plugin.extensions) {
+        extensionIndex.set(ext, plugin);
+    }
+}
+export function getPluginForFile(filePath) {
+    const dot = filePath.lastIndexOf(".");
+    if (dot < 0)
+        return null;
+    const ext = filePath.slice(dot);
+    return extensionIndex.get(ext) ?? null;
+}
+export function getPlugin(id) {
+    return pluginRegistry.get(id) ?? null;
+}
+export function getAllPlugins() {
+    return [...pluginRegistry.values()];
+}

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

@@ -0,0 +1,440 @@
+/**
+ * C# Language Plugin — entity, edge, and import extraction
+ * from Tree-sitter AST.
+ *
+ * Handles: .cs
+ *
+ * Entity extraction: classes, methods, interfaces, enums, structs, namespaces
+ * Edge extraction: contains, calls, extends, implements
+ * Import resolution: using directives
+ */
+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 === "modifier") {
+            if (textOf(child) === modifier)
+                return true;
+        }
+        if (textOf(child) === modifier)
+            return true;
+    }
+    for (const child of node.namedChildren) {
+        if (child.type === "modifier_list" || child.type === "modifiers") {
+            for (const mod of child.children) {
+                if (textOf(mod) === modifier)
+                    return true;
+            }
+        }
+    }
+    return false;
+}
+function isPublic(node) {
+    return hasModifier(node, "public");
+}
+function isAsync(node) {
+    return hasModifier(node, "async");
+}
+function isStatic(node) {
+    return hasModifier(node, "static");
+}
+function extractDoc(node) {
+    const prev = node.previousSibling;
+    if (!prev)
+        return null;
+    if (prev.type === "comment") {
+        const text = textOf(prev);
+        if (text.startsWith("///") || text.startsWith("/**")) {
+            return text.slice(0, 500);
+        }
+    }
+    let doc = "";
+    let sibling = node.previousSibling;
+    while (sibling?.type === "comment") {
+        const text = textOf(sibling);
+        if (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 === "params_keyword").length;
+}
+function extractSignature(node, name, kind) {
+    if (kind === "class")
+        return `class ${name}`;
+    if (kind === "interface")
+        return `interface ${name}`;
+    if (kind === "enum")
+        return `enum ${name}`;
+    if (kind === "namespace")
+        return `namespace ${name}`;
+    const params = node.childForFieldName("parameters");
+    const returnType = node.childForFieldName("type") ?? node.childForFieldName("returns");
+    const paramsText = params ? textOf(params) : "()";
+    const returnText = returnType ? `${textOf(returnType)} ` : "void ";
+    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: "csharp",
+        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 extractBaseTypes(node, entityKey, ctx) {
+    const baseList = node.childForFieldName("bases") ?? node.childForFieldName("base_list");
+    if (!baseList) {
+        for (const child of node.namedChildren) {
+            if (child.type === "base_list") {
+                extractBaseList(child, entityKey, ctx);
+                return;
+            }
+        }
+        return;
+    }
+    extractBaseList(baseList, entityKey, ctx);
+}
+function extractBaseList(baseList, key, ctx) {
+    for (const child of baseList.namedChildren) {
+        const typeName = textOf(child).split("<")[0]?.trim();
+        if (!typeName || typeName === ":")
+            continue;
+        const startsWithI = typeName.length > 1 &&
+            typeName[0] === "I" &&
+            typeName.charCodeAt(1) >= 65 &&
+            typeName.charCodeAt(1) <= 90;
+        const edgeType = startsWithI ? "implements" : "extends";
+        ctx.edges.push({
+            from_key: key,
+            to_key: `unresolved:${typeName}`,
+            type: edgeType,
+            file_path: ctx.filePath,
+            line: child.startPosition.row + 1,
+        });
+    }
+}
+function visitNode(node, ctx) {
+    switch (node.type) {
+        case "namespace_declaration":
+        case "file_scoped_namespace_declaration": {
+            const name = getName(node);
+            if (!name)
+                break;
+            const key = addEntity(ctx, node, "namespace", name, {
+                exported: true,
+                signature: `namespace ${name}`,
+            });
+            ctx.scopeStack.push({ key, name });
+            visitChildren(node, ctx);
+            ctx.scopeStack.pop();
+            return;
+        }
+        case "class_declaration": {
+            const name = getName(node);
+            if (!name)
+                break;
+            const key = addEntity(ctx, node, "class", name, {
+                exported: isPublic(node),
+                signature: `class ${name}`,
+            });
+            extractBaseTypes(node, key, ctx);
+            ctx.scopeStack.push({ key, name });
+            visitChildren(node, ctx);
+            ctx.scopeStack.pop();
+            return;
+        }
+        case "struct_declaration": {
+            const name = getName(node);
+            if (!name)
+                break;
+            const key = addEntity(ctx, node, "class", name, {
+                exported: isPublic(node),
+                signature: `struct ${name}`,
+            });
+            extractBaseTypes(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}`,
+            });
+            extractBaseTypes(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;
+            addEntity(ctx, node, "enum", name, {
+                exported: isPublic(node),
+                signature: `enum ${name}`,
+            });
+            return;
+        }
+        case "method_declaration": {
+            const name = getName(node);
+            if (!name)
+                break;
+            const key = addEntity(ctx, node, "method", name, {
+                exported: isPublic(node),
+                isAsync: isAsync(node),
+                paramCount: countParameters(node),
+            });
+            ctx.scopeStack.push({ key, name });
+            visitChildren(node, ctx);
+            ctx.scopeStack.pop();
+            return;
+        }
+        case "constructor_declaration": {
+            const name = getName(node) ??
+                ctx.scopeStack[ctx.scopeStack.length - 1]?.name ??
+                "ctor";
+            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 "property_declaration": {
+            const name = getName(node);
+            if (!name)
+                break;
+            addEntity(ctx, node, "property", name, {
+                exported: isPublic(node),
+                signature: name,
+            });
+            break;
+        }
+        case "invocation_expression": {
+            const fn = 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 "object_creation_expression": {
+            const typeNode = node.childForFieldName("type") ?? node.namedChildren[0];
+            if (typeNode && ctx.scopeStack.length > 0) {
+                const typeName = textOf(typeNode).split("<")[0]?.trim();
+                if (typeName) {
+                    ctx.edges.push({
+                        from_key: currentScope(ctx),
+                        to_key: `unresolved:${typeName}`,
+                        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 === "member_access_expression") {
+        const name = node.childForFieldName("name");
+        return name ? textOf(name) : null;
+    }
+    if (node.type === "generic_name") {
+        const name = node.childForFieldName("name") ?? node.namedChildren[0];
+        return name ? textOf(name) : null;
+    }
+    return null;
+}
+function extractImports(tree, filePath) {
+    const imports = [];
+    function visit(node) {
+        if (node.type === "using_directive") {
+            const line = node.startPosition.row + 1;
+            const isStaticUsing = node.children.some((c) => textOf(c) === "static");
+            const nameNode = node.namedChildren.find((c) => c.type === "qualified_name" ||
+                c.type === "identifier" ||
+                c.type === "name_equals");
+            if (!nameNode) {
+                for (const child of node.namedChildren) {
+                    if (child.type !== "predefined_type") {
+                        const fullName = textOf(child);
+                        if (fullName) {
+                            const parts = fullName.split(".");
+                            imports.push({
+                                source: fullName,
+                                symbols: [parts[parts.length - 1]],
+                                isDefault: false,
+                                isNamespace: true,
+                                line,
+                            });
+                        }
+                    }
+                }
+                return;
+            }
+            if (nameNode.type === "name_equals") {
+                const alias = nameNode.childForFieldName("name") ?? nameNode.namedChildren[0];
+                const target = node.namedChildren.find((c) => c !== nameNode &&
+                    (c.type === "qualified_name" || c.type === "identifier"));
+                if (alias && target) {
+                    imports.push({
+                        source: textOf(target),
+                        symbols: [textOf(target).split(".").pop()],
+                        isDefault: false,
+                        isNamespace: false,
+                        localName: textOf(alias),
+                        line,
+                    });
+                }
+                return;
+            }
+            const fullName = textOf(nameNode);
+            const parts = fullName.split(".");
+            const lastPart = parts[parts.length - 1];
+            if (isStaticUsing) {
+                imports.push({
+                    source: fullName,
+                    symbols: ["*"],
+                    isDefault: false,
+                    isNamespace: true,
+                    line,
+                });
+            }
+            else {
+                imports.push({
+                    source: fullName,
+                    symbols: [lastPart],
+                    isDefault: false,
+                    isNamespace: true,
+                    localName: lastPart,
+                    line,
+                });
+            }
+        }
+        for (const child of node.namedChildren) {
+            visit(child);
+        }
+    }
+    visit(tree.rootNode);
+    return imports;
+}
+export const csharpPlugin = {
+    id: "csharp",
+    extensions: [".cs"],
+    grammarWasmName: "tree-sitter-c_sharp.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 === "invocation_expression") {
+                const fn = 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;
+    },
+};