@unerr-ai/unerr 0.2.1 → 0.2.2

package/dist/intelligence/indexer/centrality.js

@@ -1,62 +0,0 @@
-/**
- * Centrality Computation — fan-in/fan-out counts + hub node detection.
- *
- * Post-processing pass over resolved edges to compute:
- *   - fan_in: how many entities call this entity
- *   - fan_out: how many entities this entity calls
- *   - risk_level: "critical" (50+), "high" (20+), "medium" (10+), "normal"
- *
- * Hub nodes (high fan_in) are the chokepoints of the codebase — changes
- * to them have the widest blast radius.
- */
-const RISK_THRESHOLDS = {
-    critical: 50,
-    high: 20,
-    medium: 10,
-};
-/**
- * Compute fan-in and fan-out for all entities from resolved edges.
- */
-export function computeCentrality(edges) {
-    const fanIn = new Map();
-    const fanOut = new Map();
-    const callEdges = edges.filter((e) => e.type === "calls");
-    for (const edge of callEdges) {
-        fanOut.set(edge.from_key, (fanOut.get(edge.from_key) ?? 0) + 1);
-        fanIn.set(edge.to_key, (fanIn.get(edge.to_key) ?? 0) + 1);
-    }
-    const hubNodes = [...fanIn.entries()]
-        .filter(([_, count]) => count >= RISK_THRESHOLDS.high)
-        .sort((a, b) => b[1] - a[1])
-        .map(([key]) => key);
-    return { fanIn, fanOut, hubNodes };
-}
-/**
- * Determine risk level from fan_in count.
- */
-export function riskLevel(fanInCount) {
-    if (fanInCount >= RISK_THRESHOLDS.critical)
-        return "critical";
-    if (fanInCount >= RISK_THRESHOLDS.high)
-        return "high";
-    if (fanInCount >= RISK_THRESHOLDS.medium)
-        return "medium";
-    return "normal";
-}
-/**
- * Apply centrality metrics to entities.
- * Returns updated entities with fan_in, fan_out, and risk_level set.
- */
-export function applyCentrality(entities, edges) {
-    const { fanIn, fanOut } = computeCentrality(edges);
-    return entities.map((entity) => {
-        const fi = fanIn.get(entity.key) ?? 0;
-        const fo = fanOut.get(entity.key) ?? 0;
-        return {
-            ...entity,
-            fan_in: fi,
-            fan_out: fo,
-            risk_level: riskLevel(fi),
-        };
-    });
-}

package/dist/intelligence/indexer/cfg-context.js

@@ -1,95 +0,0 @@
-/**
- * CFG Context Extractor — walks up the AST from a call site to annotate
- * the control-flow context of each edge.
- *
- * Detects:
- *   - try/catch guarding: call is inside a try block
- *   - loop context: call is inside for/while/do-while/for-of/for-in
- *   - conditional: call is inside if/else/switch/ternary
- *   - error handler: call is inside a catch/finally block
- *   - async/await: call is awaited
- */
-const LOOP_TYPES = new Set([
-    "for_statement",
-    "for_in_statement",
-    "while_statement",
-    "do_statement",
-]);
-const CONDITIONAL_TYPES = new Set([
-    "if_statement",
-    "switch_statement",
-    "ternary_expression",
-    "conditional_expression",
-]);
-/**
- * Extract CFG context by walking up from a node to the function boundary.
- */
-export function extractCFGContext(node) {
-    const ctx = {
-        isTryGuarded: false,
-        isLoop: false,
-        isConditional: false,
-        isErrorHandler: false,
-        isAsync: false,
-        nestingDepth: 0,
-    };
-    if (node.parent?.type === "await_expression") {
-        ctx.isAsync = true;
-    }
-    let current = node.parent;
-    while (current) {
-        if (current.type === "function_declaration" ||
-            current.type === "arrow_function" ||
-            current.type === "method_definition" ||
-            current.type === "function_expression") {
-            break;
-        }
-        if (current.type === "try_statement") {
-            const tryBody = current.childForFieldName("body");
-            if (tryBody && isDescendantOf(node, tryBody)) {
-                ctx.isTryGuarded = true;
-            }
-        }
-        if (current.type === "catch_clause" || current.type === "finally_clause") {
-            ctx.isErrorHandler = true;
-        }
-        if (LOOP_TYPES.has(current.type)) {
-            ctx.isLoop = true;
-            ctx.nestingDepth++;
-        }
-        if (CONDITIONAL_TYPES.has(current.type)) {
-            ctx.isConditional = true;
-            ctx.nestingDepth++;
-        }
-        current = current.parent;
-    }
-    return ctx;
-}
-function isDescendantOf(node, ancestor) {
-    let current = node;
-    while (current) {
-        if (current.id === ancestor.id)
-            return true;
-        current = current.parent;
-    }
-    return false;
-}
-/**
- * Flatten CFG context into edge metadata fields.
- */
-export function cfgToEdgeFields(cfg) {
-    const fields = {};
-    if (cfg.isTryGuarded)
-        fields.is_try_guarded = true;
-    if (cfg.isLoop)
-        fields.is_loop = true;
-    if (cfg.isConditional)
-        fields.is_conditional = true;
-    if (cfg.isErrorHandler)
-        fields.is_error_handler = true;
-    if (cfg.isAsync)
-        fields.is_async = true;
-    if (cfg.nestingDepth > 0)
-        fields.nesting_depth = cfg.nestingDepth;
-    return fields;
-}

package/dist/intelligence/indexer/confidence.js

@@ -1,34 +0,0 @@
-/**
- * Confidence Labeling — tracks provenance of extracted entities and edges.
- *
- * Confidence levels:
- *   - "compiler-verified": From SCIP (compiler-resolved, highest accuracy)
- *   - "structural": From tree-sitter AST (syntactic structure, high accuracy)
- *   - "heuristic": From regex fallback or heuristic rules (lower accuracy)
- *
- * Every entity and edge carries a confidence label that downstream
- * consumers can use to weight results.
- */
-export function labelFromTier(tier) {
-    switch (tier) {
-        case 1:
-            return { level: "structural", source: "tree-sitter-tier1" };
-        case 2:
-            return { level: "structural", source: "tree-sitter-tier2" };
-        case 3:
-            return { level: "heuristic", source: "regex-fallback" };
-    }
-}
-export function upgradeToCompilerVerified(label) {
-    return { level: "compiler-verified", source: `scip+${label.source}` };
-}
-export function confidenceScore(level) {
-    switch (level) {
-        case "compiler-verified":
-            return 1.0;
-        case "structural":
-            return 0.85;
-        case "heuristic":
-            return 0.5;
-    }
-}

package/dist/intelligence/indexer/cross-file-resolver.js

@@ -1,104 +0,0 @@
-/**
- * Cross-File Call Resolver — resolves import → entity → calls edges.
- *
- * Given per-file extraction results with unresolved call edges (to_key starts
- * with "unresolved:"), resolves them to actual entity keys using the export map.
- *
- * Also handles:
- *   J.3 — Barrel file / re-export chain resolution
- *   - export { X } from "./other" → follow to original entity
- *   - export * from "./module" → resolve all namespace imports
- */
-import { buildExportMap } from "./export-map.js";
-/**
- * Resolve all unresolved cross-file edges using the export map.
- *
- * For each file's edges where to_key starts with "unresolved:", look up the
- * callee name in the file's import map, then resolve via the export map.
- */
-export function resolveCrossFileEdges(fileResults) {
-    const exportMap = buildExportMap(fileResults);
-    const allResolvedEdges = [];
-    // R.3: Track file→file import relationships (deduplicated by pair)
-    const fileImportPairs = new Set();
-    let unresolvedCount = 0;
-    let resolvedCount = 0;
-    for (const [filePath, result] of fileResults) {
-        const importLookup = buildImportLookup(result.imports, filePath);
-        const localEntityNames = new Map(result.entities.map((e) => [e.name, e.key]));
-        // R.3: Emit file→file imports edges from the import declarations directly
-        for (const imp of result.imports) {
-            if (imp.source && imp.source !== filePath) {
-                const pairKey = `${filePath}\0${imp.source}`;
-                fileImportPairs.add(pairKey);
-            }
-        }
-        for (const edge of result.edges) {
-            if (!edge.to_key.startsWith("unresolved:")) {
-                allResolvedEdges.push(edge);
-                continue;
-            }
-            const calleeName = edge.to_key.slice("unresolved:".length);
-            const localKey = localEntityNames.get(calleeName);
-            if (localKey) {
-                allResolvedEdges.push({ ...edge, to_key: localKey });
-                resolvedCount++;
-                continue;
-            }
-            const importedFrom = importLookup.get(calleeName);
-            if (importedFrom) {
-                const resolved = exportMap.resolveSymbol(importedFrom.source, importedFrom.originalName, filePath);
-                if (resolved) {
-                    allResolvedEdges.push({ ...edge, to_key: resolved.entityKey });
-                    resolvedCount++;
-                    continue;
-                }
-            }
-            unresolvedCount++;
-        }
-    }
-    // R.3: Build deduplicated file→file import edges
-    const fileImportEdges = Array.from(fileImportPairs, (pair) => {
-        const [from, to] = pair.split("\0");
-        return {
-            from_key: `file:${from}`,
-            to_key: `file:${to}`,
-            type: "imports",
-            file_path: from,
-            line: 0,
-        };
-    });
-    return {
-        resolvedEdges: allResolvedEdges,
-        fileImportEdges,
-        unresolvedCount,
-        resolvedCount,
-    };
-}
-function buildImportLookup(imports, filePath) {
-    const lookup = new Map();
-    for (const imp of imports) {
-        if (imp.isDefault && imp.localName) {
-            lookup.set(imp.localName, {
-                source: imp.source,
-                originalName: "default",
-                isDefault: true,
-            });
-        }
-        if (imp.isNamespace && imp.localName) {
-            lookup.set(imp.localName, {
-                source: imp.source,
-                originalName: "*",
-                isDefault: false,
-            });
-        }
-        for (const symbol of imp.symbols) {
-            lookup.set(symbol, {
-                source: imp.source,
-                originalName: symbol,
-                isDefault: false,
-            });
-        }
-    }
-    return lookup;
-}

package/dist/intelligence/indexer/edge-repair.js

@@ -1,89 +0,0 @@
-/**
- * Cross-File Edge Repair — when an import target changes, re-resolve edges.
- *
- * After incremental reindex of a changed file, other files that import
- * from it may have stale edge targets. This module identifies affected
- * files and repairs their cross-file edges.
- */
-import { createModuleLogger } from "../../utils/logger.js";
-import { buildExportMap } from "./export-map.js";
-const log = createModuleLogger("edge-repair");
-/**
- * Find files that import from a changed file.
- */
-export function findDependentFiles(changedFile, allImports) {
-    const dependents = [];
-    const changedBase = stripExtension(changedFile);
-    for (const [filePath, imports] of allImports) {
-        if (filePath === changedFile)
-            continue;
-        for (const imp of imports) {
-            if (!imp.source.startsWith("."))
-                continue;
-            const { dirname, join, normalize } = require("node:path");
-            const importerDir = dirname(filePath);
-            let resolved = normalize(join(importerDir, imp.source)).replace(/\\/g, "/");
-            if (resolved.startsWith("./"))
-                resolved = resolved.slice(2);
-            if (stripExtension(resolved) === changedBase ||
-                resolved === changedFile) {
-                dependents.push(filePath);
-                break;
-            }
-        }
-    }
-    return dependents;
-}
-/**
- * Repair cross-file edges for dependent files after a target file changes.
- */
-export function repairCrossFileEdges(dependentFiles, fileResults) {
-    const exportMap = buildExportMap(fileResults);
-    const repairedEdges = [];
-    let count = 0;
-    for (const filePath of dependentFiles) {
-        const result = fileResults.get(filePath);
-        if (!result)
-            continue;
-        const importLookup = new Map();
-        for (const imp of result.imports) {
-            if (imp.isDefault && imp.localName) {
-                importLookup.set(imp.localName, {
-                    source: imp.source,
-                    originalName: "default",
-                });
-            }
-            for (const symbol of imp.symbols) {
-                importLookup.set(symbol, { source: imp.source, originalName: symbol });
-            }
-        }
-        for (const edge of result.edges) {
-            if (!edge.to_key.startsWith("unresolved:")) {
-                repairedEdges.push(edge);
-                continue;
-            }
-            const calleeName = edge.to_key.slice("unresolved:".length);
-            const localKey = result.entities.find((e) => e.name === calleeName)?.key;
-            if (localKey) {
-                repairedEdges.push({ ...edge, to_key: localKey });
-                count++;
-                continue;
-            }
-            const imported = importLookup.get(calleeName);
-            if (imported) {
-                const resolved = exportMap.resolveSymbol(imported.source, imported.originalName, filePath);
-                if (resolved) {
-                    repairedEdges.push({ ...edge, to_key: resolved.entityKey });
-                    count++;
-                    continue;
-                }
-            }
-            repairedEdges.push(edge);
-        }
-    }
-    log.debug(`Repaired ${count} cross-file edges in ${dependentFiles.length} files`);
-    return { repairedEdges, count };
-}
-function stripExtension(filePath) {
-    return filePath.replace(/\.(ts|tsx|js|jsx|mjs|cjs)$/, "");
-}

package/dist/intelligence/indexer/entity-key.js

@@ -1,17 +0,0 @@
-/**
- * Deterministic Entity Key Generation — stable across re-indexes.
- *
- * Keys are SHA-256 hashes of (filePath:kind:name:scope), truncated to 16 hex chars.
- * This ensures:
- *   - Same entity always gets the same key
- *   - Different entities in different files never collide
- *   - Nested entities (methods in classes) include parent scope
- */
-import { createHash } from "node:crypto";
-export function entityKey(filePath, kind, name, scope = "") {
-    const input = `${filePath}:${kind}:${name}:${scope}`;
-    return createHash("sha256").update(input).digest("hex").slice(0, 16);
-}
-export function bodyHash(content) {
-    return createHash("sha256").update(content).digest("hex").slice(0, 16);
-}

package/dist/intelligence/indexer/export-map.js

@@ -1,132 +0,0 @@
-/**
- * Export Map Builder — builds a project-wide lookup of all exported entities.
- *
- * Given per-file extraction results, produces a map from (filePath, symbolName)
- * to entity key. This enables cross-file call resolution: when file A imports
- * `fn` from file B, we look up B's export map to find the entity key for `fn`.
- *
- * Handles:
- *   - Named exports: export function foo() {}
- *   - Default exports: export default class Bar {}
- *   - Re-exports: export { X } from "./other"
- *   - Barrel files: export * from "./module"
- */
-/**
- * Normalize an import path relative to the importer's directory.
- * Handles: "./foo" → "src/foo", "../utils/bar" → "utils/bar"
- */
-function resolveImportPath(importSource, importerFilePath) {
-    if (!importSource.startsWith("."))
-        return null;
-    // biome-ignore format: typeof import() must stay single-line for TS
-    const { dirname, join, normalize } = require("node:path");
-    const importerDir = dirname(importerFilePath);
-    let resolved = normalize(join(importerDir, importSource));
-    resolved = resolved.replace(/\\/g, "/");
-    if (resolved.startsWith("./"))
-        resolved = resolved.slice(2);
-    return resolved;
-}
-function stripExtension(filePath) {
-    return filePath.replace(/\.(ts|tsx|js|jsx|mjs|cjs)$/, "");
-}
-/**
- * Build the export map from per-file extraction results.
- */
-export function buildExportMap(fileResults) {
-    const exports = new Map();
-    const reExports = new Map();
-    for (const [filePath, result] of fileResults) {
-        const fileExports = [];
-        for (const entity of result.entities) {
-            if (entity.exported) {
-                fileExports.push({
-                    entityKey: entity.key,
-                    name: entity.name,
-                    kind: entity.kind,
-                    filePath: entity.file_path,
-                    isDefault: false,
-                });
-            }
-        }
-        const fileReExports = [];
-        for (const imp of result.imports) {
-            if (imp.source.startsWith(".") && imp.symbols.length > 0) {
-                const isReExport = result.entities.some((e) => imp.symbols.includes(e.name) && e.exported);
-                if (!isReExport) {
-                    fileReExports.push({
-                        fromFile: imp.source,
-                        symbols: imp.symbols,
-                        isNamespace: imp.isNamespace,
-                        line: imp.line,
-                    });
-                }
-            }
-        }
-        exports.set(filePath, fileExports);
-        if (fileReExports.length > 0) {
-            reExports.set(filePath, fileReExports);
-        }
-    }
-    function getExport(filePath, symbolName) {
-        const fileExports = exports.get(filePath);
-        if (!fileExports)
-            return null;
-        return fileExports.find((e) => e.name === symbolName) ?? null;
-    }
-    function getDefaultExport(filePath) {
-        const fileExports = exports.get(filePath);
-        if (!fileExports)
-            return null;
-        return fileExports.find((e) => e.isDefault) ?? null;
-    }
-    function getAllExports(filePath) {
-        return exports.get(filePath) ?? [];
-    }
-    function getReExports(filePath) {
-        return reExports.get(filePath) ?? [];
-    }
-    function resolveSymbol(importSource, symbolName, importerPath) {
-        const resolvedPath = resolveImportPath(importSource, importerPath);
-        if (!resolvedPath)
-            return null;
-        const candidates = [
-            resolvedPath,
-            `${resolvedPath}.ts`,
-            `${resolvedPath}.tsx`,
-            `${resolvedPath}.js`,
-            `${resolvedPath}/index.ts`,
-            `${resolvedPath}/index.tsx`,
-            `${resolvedPath}/index.js`,
-        ];
-        for (const candidate of candidates) {
-            const stripped = stripExtension(candidate);
-            for (const [filePath] of exports) {
-                if (stripExtension(filePath) === stripped || filePath === candidate) {
-                    const found = getExport(filePath, symbolName);
-                    if (found)
-                        return found;
-                    const fileReExports = reExports.get(filePath) ?? [];
-                    for (const re of fileReExports) {
-                        if (re.symbols.includes(symbolName) || re.isNamespace) {
-                            const reResolved = resolveImportPath(re.fromFile, filePath);
-                            if (reResolved) {
-                                const deep = resolveSymbol(re.fromFile, symbolName, filePath);
-                                if (deep)
-                                    return deep;
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        return null;
-    }
-    return {
-        getExport,
-        getDefaultExport,
-        getAllExports,
-        getReExports,
-        resolveSymbol,
-    };
-}

package/dist/intelligence/indexer/git-cochange.js

@@ -1,128 +0,0 @@
-/**
- * R.4: Compute file→file co-change edges from git log.
- *
- * Two files that frequently change together in the same commit are likely
- * structurally coupled (even if no import edge exists). This creates
- * "co_changes" edges between file entities in the graph.
- *
- * Algorithm:
- *   1. Read last N commits (default 100)
- *   2. For each commit, extract the list of changed files
- *   3. For each pair of files in the same commit, increment co-occurrence count
- *   4. Normalize by individual file change counts (Jaccard-like)
- *   5. Return top K pairs with highest correlation as edges
- */
-import { execSync } from "node:child_process";
-/**
- * Compute co-change file pairs from git history.
- *
- * @param projectRoot - Absolute path to the git repo root
- * @param maxCommits - Number of recent commits to analyze (default 100)
- * @param topK - Maximum number of co-change pairs to return (default 20)
- * @param minCoOccurrences - Minimum co-occurrences to include (default 3)
- */
-export function computeCoChangeEdges(projectRoot, maxCommits = 100, topK = 20, minCoOccurrences = 3) {
-    const commits = getCommitFileLists(projectRoot, maxCommits);
-    if (commits.length === 0)
-        return [];
-    // Count individual file changes and pair co-occurrences
-    const fileChanges = new Map();
-    const pairCount = new Map();
-    for (const files of commits) {
-        // Skip very large commits (merges, bulk renames) — they add noise
-        if (files.length > 30)
-            continue;
-        for (const file of files) {
-            fileChanges.set(file, (fileChanges.get(file) ?? 0) + 1);
-        }
-        // Count co-occurrences for all pairs in this commit
-        for (let i = 0; i < files.length; i++) {
-            for (let j = i + 1; j < files.length; j++) {
-                const key = pairKey(files[i], files[j]);
-                pairCount.set(key, (pairCount.get(key) ?? 0) + 1);
-            }
-        }
-    }
-    // Build edges for pairs that meet the threshold
-    const edges = [];
-    for (const [key, count] of pairCount) {
-        if (count < minCoOccurrences)
-            continue;
-        const [a, b] = key.split("\0");
-        const changesA = fileChanges.get(a) ?? 1;
-        const changesB = fileChanges.get(b) ?? 1;
-        const correlation = count / Math.min(changesA, changesB);
-        edges.push({
-            from_file: a,
-            to_file: b,
-            co_occurrences: count,
-            correlation,
-        });
-    }
-    // Sort by correlation descending, take top K
-    edges.sort((a, b) => b.correlation - a.correlation);
-    return edges.slice(0, topK);
-}
-/** Canonical pair key (sorted to ensure A-B == B-A). */
-function pairKey(a, b) {
-    return a < b ? `${a}\0${b}` : `${b}\0${a}`;
-}
-/**
- * Get file lists per commit from git log.
- * Returns array of arrays, each inner array is the list of changed files in one commit.
- */
-function getCommitFileLists(projectRoot, maxCommits) {
-    let output;
-    try {
-        output = execSync(`git log --name-only --pretty=format:"" -n ${maxCommits}`, { cwd: projectRoot, encoding: "utf-8", maxBuffer: 10 * 1024 * 1024 });
-    }
-    catch {
-        return [];
-    }
-    // Split by double newlines (commit boundaries) then filter
-    const commits = [];
-    let currentFiles = [];
-    for (const line of output.split("\n")) {
-        if (line === "") {
-            if (currentFiles.length > 0) {
-                commits.push(currentFiles);
-                currentFiles = [];
-            }
-        }
-        else {
-            // Only include source files (skip binary, lockfiles, etc.)
-            if (isSourceFile(line)) {
-                currentFiles.push(line);
-            }
-        }
-    }
-    if (currentFiles.length > 0) {
-        commits.push(currentFiles);
-    }
-    return commits;
-}
-const SOURCE_EXTENSIONS = new Set([
-    ".ts",
-    ".tsx",
-    ".js",
-    ".jsx",
-    ".mjs",
-    ".cjs",
-    ".py",
-    ".go",
-    ".rs",
-    ".java",
-    ".kt",
-    ".rb",
-    ".vue",
-    ".svelte",
-    ".css",
-    ".scss",
-    ".html",
-]);
-function isSourceFile(path) {
-    const dotIdx = path.lastIndexOf(".");
-    if (dotIdx < 0)
-        return false;
-    return SOURCE_EXTENSIONS.has(path.slice(dotIdx));
-}