@unerr-ai/unerr 0.2.0 → 0.2.2

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

@@ -1,79 +0,0 @@
-/**
- * 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

@@ -1,155 +0,0 @@
-/**
- * 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

@@ -1,31 +0,0 @@
-/**
- * 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

@@ -1,440 +0,0 @@
-/**
- * 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;
-    },
-};