@unerr-ai/unerr 0.2.1 → 0.2.3

package/dist/intelligence/ast-worker.js

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

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

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