@unerr-ai/unerr 0.1.0 → 0.1.1

package/dist/intelligence/ast-worker.js

@@ -0,0 +1,34 @@
+/**
+ * Tinypool worker entry point for parallel AST entity extraction.
+ *
+ * Runs in a worker thread — must not import native main-thread-only modules.
+ * Receives file path + content, returns extracted entities.
+ *
+ * Uses dynamic import with fallback to handle both production (.js) and
+ * development (.ts) environments since worker threads don't inherit
+ * TypeScript loaders.
+ */
+let _extractEntities = null;
+async function loadExtractor() {
+    if (_extractEntities)
+        return _extractEntities;
+    try {
+        const mod = await import("./ast-extractor.js");
+        _extractEntities = mod.extractEntities;
+    }
+    catch {
+        // @ts-expect-error .ts import used as runtime fallback in non-compiled environments
+        const mod = await import("./ast-extractor.ts");
+        _extractEntities = mod.extractEntities;
+    }
+    return _extractEntities;
+}
+export default async function parse(input) {
+    try {
+        const extractEntities = await loadExtractor();
+        return extractEntities(input.content, input.filePath);
+    }
+    catch {
+        return [];
+    }
+}

package/dist/intelligence/background-indexer.js

@@ -0,0 +1,121 @@
+/**
+ * Background Index Runner — Sprint L11.1
+ *
+ * Non-blocking wrapper around `indexLocalProject()` that runs indexing
+ * as an async task. Exposes observable progress state that the proxy,
+ * query router, and ora spinner can poll at any time.
+ *
+ * Contract TL-25: MCP server starts within 2 seconds of boot.
+ * Contract TL-26: Background indexing never blocks the MCP event loop.
+ * Contract TL-30: Zero LLM calls during indexing (tree-sitter only).
+ */
+// ── BackgroundIndexer ────────────────────────────────────────────
+export class BackgroundIndexer {
+    _status = "idle";
+    _processed = 0;
+    _total = 0;
+    _phase = "";
+    _currentFile = null;
+    _result = null;
+    _error = null;
+    _startedAt = null;
+    _completedAt = null;
+    /**
+     * Start background indexing. Returns immediately — indexing runs
+     * as an async microtask that yields to the event loop between files.
+     *
+     * @param projectRoot - Absolute path to the project root
+     * @param graphStore - CozoGraphStore instance (schema already initialized)
+     * @param repoId - Repository ID for entity key generation
+     * @param onComplete - Called when indexing finishes successfully
+     * @param onError - Called if indexing fails (proxy continues with empty graph)
+     */
+    start(projectRoot, graphStore, repoId, onComplete, onError) {
+        if (this._status === "indexing")
+            return; // Already running
+        this._status = "indexing";
+        this._startedAt = Date.now();
+        this._processed = 0;
+        this._total = 0;
+        this._phase = "discovering";
+        this._currentFile = null;
+        this._result = null;
+        this._error = null;
+        this._completedAt = null;
+        // Fire-and-forget async — does not block the caller
+        this.runIndexing(projectRoot, graphStore, repoId, onComplete, onError);
+    }
+    /** Whether indexing is currently in progress. */
+    isIndexing() {
+        return this._status === "indexing";
+    }
+    /** Whether indexing has completed successfully. */
+    isComplete() {
+        return this._status === "complete";
+    }
+    /** Current status. */
+    getStatus() {
+        return this._status;
+    }
+    /** Current progress snapshot (safe to poll from any module). */
+    getProgress() {
+        const pct = this._total > 0 ? Math.round((this._processed / this._total) * 100) : 0;
+        return {
+            processed: this._processed,
+            total: this._total,
+            phase: this._phase,
+            pct,
+            currentFile: this._currentFile,
+        };
+    }
+    /** Full state snapshot. */
+    getState() {
+        return {
+            status: this._status,
+            progress: this.getProgress(),
+            result: this._result,
+            error: this._error,
+            startedAt: this._startedAt,
+            completedAt: this._completedAt,
+        };
+    }
+    /** Index result (null if not yet complete). */
+    getResult() {
+        return this._result;
+    }
+    /** Error (null if no error). */
+    getError() {
+        return this._error;
+    }
+    /** Elapsed time in milliseconds since indexing started. */
+    getElapsedMs() {
+        if (!this._startedAt)
+            return 0;
+        const end = this._completedAt ?? Date.now();
+        return end - this._startedAt;
+    }
+    // ── Internal ──────────────────────────────────────────────────
+    async runIndexing(projectRoot, graphStore, repoId, onComplete, onError) {
+        try {
+            const { indexLocalProject } = await import("./local-indexer.js");
+            const result = await indexLocalProject(projectRoot, graphStore, repoId, {
+                onProgress: (event) => {
+                    this._processed = event.processed;
+                    this._total = event.total;
+                    this._phase = event.phase;
+                    this._currentFile = event.currentFile;
+                },
+            });
+            this._status = "complete";
+            this._result = result;
+            this._completedAt = Date.now();
+            onComplete(result);
+        }
+        catch (err) {
+            this._status = "error";
+            this._error = err instanceof Error ? err : new Error(String(err));
+            this._completedAt = Date.now();
+            onError(this._error);
+        }
+    }
+}

package/dist/intelligence/blast-radius.js

@@ -0,0 +1,200 @@
+/**
+ * Blast Radius Engine — N-hop traversal + risk assessment.
+ *
+ * N.1: Datalog-style N-hop traversal (1, 2, 3 hops from target entity)
+ * N.2: Result assembly (callers, files, communities, risk per hop)
+ * N.3: Suggestion generation (risk → human-readable guidance)
+ * N.4: File-level blast radius (given file change → affected entities in other files)
+ * N.5: Performance optimization (adjacency-list cached traversal, <5ms target)
+ *
+ * Performance: all queries <5ms on 10K entity graphs via in-memory adjacency.
+ */
+/**
+ * Build a reverse adjacency index (callees → callers) for fast traversal.
+ */
+export function buildReverseAdjacency(edges) {
+    const adj = new Map();
+    for (const edge of edges) {
+        if (edge.type !== "calls")
+            continue;
+        if (!adj.has(edge.to_key))
+            adj.set(edge.to_key, new Set());
+        adj.get(edge.to_key)?.add(edge.from_key);
+    }
+    return adj;
+}
+/**
+ * Compute blast radius via N-hop BFS traversal on the reverse call graph.
+ * Returns all entities that transitively depend on the target.
+ */
+export function computeBlastRadius(targetKey, entities, reverseAdj, options = {}) {
+    const start = performance.now();
+    const maxHops = options.maxHops ?? 3;
+    const maxResults = options.maxResults ?? 500;
+    const target = entities.get(targetKey);
+    const hops = new Map();
+    const visited = new Set([targetKey]);
+    let frontier = new Set([targetKey]);
+    for (let hop = 1; hop <= maxHops; hop++) {
+        const nextFrontier = new Set();
+        const hopEntities = [];
+        for (const nodeKey of frontier) {
+            const callers = reverseAdj.get(nodeKey);
+            if (!callers)
+                continue;
+            for (const callerKey of callers) {
+                if (visited.has(callerKey))
+                    continue;
+                visited.add(callerKey);
+                const entity = entities.get(callerKey);
+                if (entity) {
+                    hopEntities.push({
+                        key: entity.key,
+                        name: entity.name,
+                        kind: entity.kind,
+                        file_path: entity.file_path,
+                        risk_level: entity.risk_level ??
+                            "normal",
+                        community: entity.community ?? -1,
+                        hop,
+                    });
+                    nextFrontier.add(callerKey);
+                }
+                if (visited.size > maxResults)
+                    break;
+            }
+            if (visited.size > maxResults)
+                break;
+        }
+        if (hopEntities.length > 0) {
+            hops.set(hop, hopEntities);
+        }
+        frontier = nextFrontier;
+        if (frontier.size === 0)
+            break;
+    }
+    const allAffected = [...hops.values()].flat();
+    const affectedFiles = [...new Set(allAffected.map((e) => e.file_path))];
+    const affectedCommunities = [
+        ...new Set(allAffected.map((e) => e.community).filter((c) => c >= 0)),
+    ];
+    const riskSummary = { critical: 0, high: 0, medium: 0, normal: 0 };
+    for (const entity of allAffected) {
+        const level = entity.risk_level;
+        if (level in riskSummary)
+            riskSummary[level]++;
+    }
+    const suggestions = generateSuggestions(allAffected, riskSummary, target);
+    return {
+        target: {
+            key: targetKey,
+            name: target?.name ?? targetKey,
+            file_path: target?.file_path ?? "",
+        },
+        hops,
+        totalAffected: allAffected.length,
+        affectedFiles,
+        affectedCommunities,
+        riskSummary,
+        suggestions,
+        resolvedInMs: performance.now() - start,
+    };
+}
+/**
+ * File-level blast radius — given a file path, find all entities in OTHER files
+ * that are affected by changes to any entity in the target file.
+ */
+export function computeFileBlastRadius(filePath, entities, reverseAdj, options = {}) {
+    const fileEntities = [...entities.values()].filter((e) => e.file_path === filePath);
+    if (fileEntities.length === 0) {
+        return emptyResult(filePath);
+    }
+    const start = performance.now();
+    const maxHops = options.maxHops ?? 2;
+    const visited = new Set(fileEntities.map((e) => e.key));
+    const hops = new Map();
+    let frontier = new Set(fileEntities.map((e) => e.key));
+    for (let hop = 1; hop <= maxHops; hop++) {
+        const nextFrontier = new Set();
+        const hopEntities = [];
+        for (const nodeKey of frontier) {
+            const callers = reverseAdj.get(nodeKey);
+            if (!callers)
+                continue;
+            for (const callerKey of callers) {
+                if (visited.has(callerKey))
+                    continue;
+                visited.add(callerKey);
+                const entity = entities.get(callerKey);
+                if (entity && entity.file_path !== filePath) {
+                    hopEntities.push({
+                        key: entity.key,
+                        name: entity.name,
+                        kind: entity.kind,
+                        file_path: entity.file_path,
+                        risk_level: entity.risk_level ??
+                            "normal",
+                        community: entity.community ?? -1,
+                        hop,
+                    });
+                    nextFrontier.add(callerKey);
+                }
+            }
+        }
+        if (hopEntities.length > 0)
+            hops.set(hop, hopEntities);
+        frontier = nextFrontier;
+        if (frontier.size === 0)
+            break;
+    }
+    const allAffected = [...hops.values()].flat();
+    const affectedFiles = [...new Set(allAffected.map((e) => e.file_path))];
+    const affectedCommunities = [
+        ...new Set(allAffected.map((e) => e.community).filter((c) => c >= 0)),
+    ];
+    const riskSummary = { critical: 0, high: 0, medium: 0, normal: 0 };
+    for (const e of allAffected) {
+        const level = e.risk_level;
+        if (level in riskSummary)
+            riskSummary[level]++;
+    }
+    return {
+        target: { key: filePath, name: filePath, file_path: filePath },
+        hops,
+        totalAffected: allAffected.length,
+        affectedFiles,
+        affectedCommunities,
+        riskSummary,
+        suggestions: generateSuggestions(allAffected, riskSummary, null),
+        resolvedInMs: performance.now() - start,
+    };
+}
+function generateSuggestions(affected, riskSummary, target) {
+    const suggestions = [];
+    if (riskSummary.critical > 0) {
+        suggestions.push(`${riskSummary.critical} critical entity(ies) affected — consider adding overload/adapter pattern to isolate changes.`);
+    }
+    if (affected.length > 20) {
+        suggestions.push(`Wide blast radius (${affected.length} entities). Consider extracting an interface to reduce coupling.`);
+    }
+    const communities = new Set(affected.map((e) => e.community).filter((c) => c >= 0));
+    if (communities.size > 2) {
+        suggestions.push(`Change spans ${communities.size} communities — verify cross-team contracts are maintained.`);
+    }
+    if (affected.length > 0 && suggestions.length === 0) {
+        suggestions.push(`${affected.length} dependent(s) affected. Review callers before modifying.`);
+    }
+    return suggestions;
+}
+function emptyResult(target) {
+    return {
+        target: { key: target, name: target, file_path: target },
+        hops: new Map(),
+        totalAffected: 0,
+        affectedFiles: [],
+        affectedCommunities: [],
+        riskSummary: { critical: 0, high: 0, medium: 0, normal: 0 },
+        suggestions: [],
+        resolvedInMs: 0,
+    };
+}