@unerr-ai/unerr 0.2.1 → 0.2.3

package/dist/intelligence/file-intelligence.js

@@ -1,59 +0,0 @@
-/**
- * File-Level Intelligence Assembly — combines all entity intelligence for a file.
- *
- * S.1: Given a file path, assembles a comprehensive intelligence profile:
- *   - All entities in the file ranked by risk
- *   - Total blast radius (sum of all entity callers)
- *   - Dominant community
- *   - Top conventions that apply
- *   - Aggregate file risk level
- */
-/**
- * Assemble file-level intelligence from entity data.
- */
-export function assembleFileIntelligence(filePath, entities) {
-    const fileEntities = entities.filter((e) => e.file_path === filePath);
-    const profiles = fileEntities.map((e) => ({
-        key: e.key,
-        name: e.name,
-        kind: e.kind,
-        riskLevel: e.risk_level ?? "normal",
-        fanIn: e.fan_in ?? 0,
-        community: e.community ?? -1,
-    }));
-    profiles.sort((a, b) => b.fanIn - a.fanIn);
-    const topRiskEntities = profiles
-        .filter((e) => e.riskLevel !== "normal")
-        .slice(0, 3);
-    const totalBlastRadius = profiles.reduce((sum, e) => sum + e.fanIn, 0);
-    const communityVotes = new Map();
-    for (const e of profiles) {
-        if (e.community >= 0) {
-            communityVotes.set(e.community, (communityVotes.get(e.community) ?? 0) + 1);
-        }
-    }
-    const dominantCommunity = communityVotes.size > 0
-        ? [...communityVotes.entries()].sort((a, b) => b[1] - a[1])[0][0]
-        : -1;
-    const maxRisk = profiles.reduce((max, e) => {
-        const order = { critical: 4, high: 3, medium: 2, normal: 1 };
-        const eLevel = order[e.riskLevel] ?? 1;
-        return eLevel > max ? eLevel : max;
-    }, 1);
-    const fileRiskLevel = maxRisk >= 4
-        ? "critical"
-        : maxRisk >= 3
-            ? "high"
-            : maxRisk >= 2
-                ? "medium"
-                : "normal";
-    return {
-        filePath,
-        entities: profiles,
-        topRiskEntities,
-        totalBlastRadius,
-        dominantCommunity,
-        fileRiskLevel,
-        entityCount: profiles.length,
-    };
-}

package/dist/intelligence/graph-holder.js

@@ -1,220 +0,0 @@
-/**
- * Graph Holder — manages the active CozoGraphStore reference and handles
- * swap-on-idle rebuilds for consistent, always-queryable graph access.
- *
- * Design: The old graph remains fully operational during rebuild (~8s).
- * Once the new graph is ready, all consumers are atomically swapped to the
- * new instance. The old graph is then eligible for GC.
- *
- * Trigger: File changes (from file watcher or LLM tool calls) reset an idle
- * timer. When no file change occurs for IDLE_THRESHOLD_MS, a full reindex
- * is triggered into a fresh CozoDB instance. On completion, the reference
- * is swapped across all consumers.
- */
-const DEFAULT_IDLE_THRESHOLD_MS = 5_000;
-const _log = {
-    info: (msg) => process.stderr.write(`▸ [graph-holder] ${msg}\n`),
-    warn: (msg) => process.stderr.write(`⚠ [graph-holder] ${msg}\n`),
-};
-export class GraphHolder {
-    current;
-    rebuildFactory = null;
-    incrementalFactory = null;
-    swapCallbacks = [];
-    idleTimer = null;
-    idleThresholdMs;
-    incrementalFileLimit;
-    fullReindexEveryNCycles;
-    rebuilding = false;
-    rebuildPending = false;
-    fileChangesSinceLastRebuild = 0;
-    lastRebuildTimestamp = 0;
-    changedFilePaths = new Set();
-    incrementalCycleCount = 0;
-    constructor(initialGraph, config) {
-        this.current = initialGraph;
-        this.idleThresholdMs = config?.idleThresholdMs ?? DEFAULT_IDLE_THRESHOLD_MS;
-        this.incrementalFileLimit = config?.incrementalFileLimit ?? 20;
-        this.fullReindexEveryNCycles = config?.fullReindexEveryNCycles ?? 10;
-    }
-    /** Get the current active graph instance. Always valid, never null. */
-    get graph() {
-        return this.current;
-    }
-    /** Register the factory that creates a fresh graph + indexes into it. */
-    setRebuildFactory(factory) {
-        this.rebuildFactory = factory;
-    }
-    /** Register the incremental indexing factory (processes only changed files). */
-    setIncrementalFactory(factory) {
-        this.incrementalFactory = factory;
-    }
-    /**
-     * Register a callback invoked when the graph is swapped.
-     * Used to propagate the new instance to QueryRouter, DriftTracker, behaviors, etc.
-     */
-    onSwap(callback) {
-        this.swapCallbacks.push(callback);
-    }
-    /**
-     * Notify the holder that files changed. Resets the idle timer.
-     * Called by file watcher (covers both LLM writes and user edits).
-     * @param filePaths — absolute paths of changed files (for incremental indexing)
-     */
-    notifyFileChange(filePaths) {
-        this.fileChangesSinceLastRebuild++;
-        if (filePaths) {
-            for (const fp of filePaths) {
-                this.changedFilePaths.add(fp);
-            }
-        }
-        // Reset idle timer
-        if (this.idleTimer) {
-            clearTimeout(this.idleTimer);
-        }
-        this.idleTimer = setTimeout(() => {
-            this.idleTimer = null;
-            this.triggerRebuild();
-        }, this.idleThresholdMs);
-    }
-    /**
-     * Force an immediate rebuild (e.g., on explicit user command).
-     * Skips idle timer.
-     */
-    forceRebuild() {
-        if (this.idleTimer) {
-            clearTimeout(this.idleTimer);
-            this.idleTimer = null;
-        }
-        this.triggerRebuild();
-    }
-    /** Whether a rebuild is currently in progress. */
-    get isRebuilding() {
-        return this.rebuilding;
-    }
-    /** Number of file changes since last successful rebuild. */
-    get pendingChanges() {
-        return this.fileChangesSinceLastRebuild;
-    }
-    /** Clean up timers on shutdown. */
-    dispose() {
-        if (this.idleTimer) {
-            clearTimeout(this.idleTimer);
-            this.idleTimer = null;
-        }
-    }
-    // ─── Private ───────────────────────────────────────────────────────────────
-    /**
-     * Decide whether to use incremental or full reindex, then execute.
-     * Incremental when: factory exists, file count ≤ limit, not a periodic full cycle.
-     * Full otherwise (or as fallback on incremental failure).
-     */
-    triggerRebuild() {
-        if (!this.rebuildFactory)
-            return;
-        if (this.fileChangesSinceLastRebuild === 0)
-            return; // No changes since last rebuild
-        if (this.rebuilding) {
-            this.rebuildPending = true;
-            return;
-        }
-        this.rebuilding = true;
-        const changesAtStart = this.fileChangesSinceLastRebuild;
-        const changedFiles = [...this.changedFilePaths];
-        const startMs = Date.now();
-        // Decision: incremental or full?
-        const useIncremental = this.incrementalFactory !== null &&
-            changedFiles.length > 0 &&
-            changedFiles.length <= this.incrementalFileLimit &&
-            this.incrementalCycleCount < this.fullReindexEveryNCycles;
-        if (useIncremental) {
-            this.runIncremental(changedFiles, changesAtStart, startMs);
-        }
-        else {
-            if (this.incrementalCycleCount >= this.fullReindexEveryNCycles) {
-                _log.info(`Periodic full reindex (after ${this.incrementalCycleCount} incremental cycles)`);
-                this.incrementalCycleCount = 0;
-            }
-            this.runFullRebuild(changesAtStart, startMs);
-        }
-    }
-    runIncremental(changedFiles, changesAtStart, startMs) {
-        _log.info(`Incremental indexing ${changedFiles.length} files...`);
-        this.incrementalFactory?.(changedFiles)
-            .then((result) => {
-            // Clear tracked files that were processed
-            for (const fp of changedFiles) {
-                this.changedFilePaths.delete(fp);
-            }
-            this.fileChangesSinceLastRebuild = Math.max(0, this.fileChangesSinceLastRebuild - changesAtStart);
-            this.lastRebuildTimestamp = Date.now();
-            this.incrementalCycleCount++;
-            _log.info(`Incremental done in ${Date.now() - startMs}ms — ` +
-                `+${result.entitiesAdded}/-${result.entitiesDeleted}/~${result.entitiesUpdated} entities, ` +
-                `+${result.edgesAdded}/-${result.edgesDeleted} edges`);
-            // Notify swap callbacks (graph is same instance, but data changed)
-            for (const cb of this.swapCallbacks) {
-                try {
-                    cb(this.current);
-                }
-                catch (err) {
-                    _log.warn(`Swap callback failed: ${err instanceof Error ? err.message : String(err)}`);
-                }
-            }
-        })
-            .catch((err) => {
-            _log.warn(`Incremental indexing failed: ${err instanceof Error ? err.message : String(err)}. Falling back to full reindex.`);
-            // Fallback to full reindex
-            this.runFullRebuild(changesAtStart, startMs);
-            return; // runFullRebuild handles its own finally logic via .finally()
-        })
-            .finally(() => {
-            this.rebuilding = false;
-            if (this.rebuildPending) {
-                this.rebuildPending = false;
-                this.triggerRebuild();
-            }
-        });
-    }
-    runFullRebuild(changesAtStart, startMs) {
-        _log.info(`Full reindex (${changesAtStart} file changes since last rebuild)...`);
-        this.rebuildFactory?.()
-            .then(({ graph: newGraph, result }) => {
-            const oldGraph = this.current;
-            this.current = newGraph;
-            // Propagate to all consumers
-            for (const cb of this.swapCallbacks) {
-                try {
-                    cb(newGraph);
-                }
-                catch (err) {
-                    _log.warn(`Swap callback failed: ${err instanceof Error ? err.message : String(err)}`);
-                }
-            }
-            // Clear all tracked state — full reindex is authoritative
-            this.changedFilePaths.clear();
-            this.fileChangesSinceLastRebuild = Math.max(0, this.fileChangesSinceLastRebuild - changesAtStart);
-            this.lastRebuildTimestamp = Date.now();
-            _log.info(`Graph rebuilt in ${Date.now() - startMs}ms — ${result.entityCount} entities, ${result.edgeCount} edges. Swapped.`);
-            // Close old graph if different instance
-            if (oldGraph !== newGraph) {
-                try {
-                    oldGraph.close?.();
-                }
-                catch {
-                    // best-effort
-                }
-            }
-        })
-            .catch((err) => {
-            _log.warn(`Graph rebuild failed: ${err instanceof Error ? err.message : String(err)}`);
-        })
-            .finally(() => {
-            this.rebuilding = false;
-            if (this.rebuildPending) {
-                this.rebuildPending = false;
-                this.triggerRebuild();
-            }
-        });
-    }
-}

package/dist/intelligence/graph-temporal-joiner.js

@@ -1,238 +0,0 @@
-/**
- * GraphTemporalJoiner — combines graph topology with temporal facts
- * to predict co-change patterns and detect hidden coupling.
- *
- * Part of Layer A of the Three-Layer Experience System.
- *
- * Co-change prediction: "when you change file A, you likely need to change file B"
- * Hidden coupling: files that always co-change but have no structural connection.
- *
- * Combined score formula: 0.4 * graph_coupling + 0.6 * temporal_coupling
- * (temporal is weighted higher — actual editing patterns are more predictive
- * than static structure)
- */
-export class GraphTemporalJoiner {
-    localGraph;
-    factStore;
-    constructor(localGraph, factStore) {
-        this.localGraph = localGraph;
-        this.factStore = factStore;
-    }
-    /**
-     * Predict which files are likely to need changes when targetFile changes.
-     * Combines graph structure (imports/calls) with temporal facts (co-change history).
-     */
-    async predictCoChanges(targetFile) {
-        const [graphNeighbors, temporalCouplings] = await Promise.all([
-            this.getGraphNeighbors(targetFile),
-            this.getTemporalCouplings(targetFile),
-        ]);
-        // Merge graph and temporal signals by file
-        const merged = new Map();
-        for (const [file, score, evidence] of graphNeighbors) {
-            if (file === targetFile)
-                continue;
-            merged.set(file, {
-                graph: score,
-                temporal: 0,
-                graphEvidence: evidence,
-                temporalEvidence: "",
-            });
-        }
-        for (const [file, score, evidence] of temporalCouplings) {
-            if (file === targetFile)
-                continue;
-            const existing = merged.get(file);
-            if (existing) {
-                existing.temporal = score;
-                existing.temporalEvidence = evidence;
-            }
-            else {
-                merged.set(file, {
-                    graph: 0,
-                    temporal: score,
-                    graphEvidence: "",
-                    temporalEvidence: evidence,
-                });
-            }
-        }
-        // Compute combined scores and sort
-        const signals = [];
-        for (const [file, data] of merged) {
-            const combined = 0.4 * data.graph + 0.6 * data.temporal;
-            if (combined < 0.1)
-                continue; // Filter noise
-            const evidenceParts = [];
-            if (data.graphEvidence)
-                evidenceParts.push(data.graphEvidence);
-            if (data.temporalEvidence)
-                evidenceParts.push(data.temporalEvidence);
-            signals.push({
-                file_a: targetFile,
-                file_b: file,
-                graph_coupling: data.graph,
-                temporal_coupling: data.temporal,
-                combined_score: Math.round(combined * 100) / 100,
-                evidence: evidenceParts.join(" + "),
-            });
-        }
-        return signals.sort((a, b) => b.combined_score - a.combined_score);
-    }
-    /**
-     * Detect hidden couplings — files with high temporal coupling but no graph edges.
-     * These are the most dangerous: changes can silently break co-dependent files.
-     */
-    async detectHiddenCouplings() {
-        if (!this.factStore)
-            return [];
-        // Get all coupling facts from temporal store
-        const couplingFacts = await this.getCouplingFacts();
-        const hidden = [];
-        for (const fact of couplingFacts) {
-            const { fileA, fileB, score, sessions } = this.parseCouplingFact(fact);
-            if (!fileA || !fileB || score < 0.5)
-                continue;
-            // Check if there's a structural connection
-            const graphCoupling = await this.getGraphCouplingBetween(fileA, fileB);
-            if (graphCoupling < 0.1) {
-                hidden.push({
-                    file_a: fileA,
-                    file_b: fileB,
-                    temporal_coupling: score,
-                    graph_coupling: graphCoupling,
-                    sessions_observed: sessions,
-                    evidence: `Co-changed in ${sessions} sessions but no import/call edges`,
-                });
-            }
-        }
-        return hidden.sort((a, b) => b.temporal_coupling - a.temporal_coupling);
-    }
-    /**
-     * Get graph-based neighbors for a file (via imports/calls).
-     * Returns [filePath, couplingScore, evidence] tuples.
-     */
-    async getGraphNeighbors(filePath) {
-        const neighbors = [];
-        try {
-            // Get entities in this file and their callers/callees
-            const entities = await this.localGraph.getEntitiesByFile(filePath);
-            if (!entities || entities.length === 0)
-                return neighbors;
-            const fileCounts = new Map();
-            for (const entity of entities.slice(0, 10)) {
-                const [callers, callees] = await Promise.all([
-                    this.localGraph.getCallersOf(entity.key),
-                    this.localGraph.getCalleesOf(entity.key),
-                ]);
-                for (const caller of callers) {
-                    if (caller.file_path && caller.file_path !== filePath) {
-                        fileCounts.set(caller.file_path, (fileCounts.get(caller.file_path) ?? 0) + 1);
-                    }
-                }
-                for (const callee of callees) {
-                    if (callee.file_path && callee.file_path !== filePath) {
-                        fileCounts.set(callee.file_path, (fileCounts.get(callee.file_path) ?? 0) + 1);
-                    }
-                }
-            }
-            // Normalize: max edges → 1.0
-            const maxCount = Math.max(...fileCounts.values(), 1);
-            for (const [file, count] of fileCounts) {
-                const score = Math.min(1.0, count / maxCount);
-                neighbors.push([file, score, `${count} shared edges`]);
-            }
-        }
-        catch {
-            // Graph query failure is non-critical
-        }
-        return neighbors;
-    }
-    /**
-     * Get temporal coupling facts for a file.
-     * Returns [filePath, couplingScore, evidence] tuples.
-     */
-    async getTemporalCouplings(filePath) {
-        if (!this.factStore)
-            return [];
-        try {
-            const facts = await this.factStore.recallBySubject(`coupling:${filePath}`, 0.2);
-            const couplings = [];
-            for (const fact of facts) {
-                const parsed = this.parseCouplingFact(fact);
-                if (!parsed.fileB)
-                    continue;
-                const otherFile = parsed.fileA === filePath ? parsed.fileB : parsed.fileA;
-                if (!otherFile)
-                    continue;
-                couplings.push([
-                    otherFile,
-                    parsed.score,
-                    `co-changed in ${parsed.sessions} sessions`,
-                ]);
-            }
-            return couplings;
-        }
-        catch {
-            return [];
-        }
-    }
-    /**
-     * Get all coupling facts from the temporal store.
-     */
-    async getCouplingFacts() {
-        if (!this.factStore)
-            return [];
-        try {
-            const allFacts = await this.factStore.recallByScope("project", 0.2);
-            return allFacts.filter((f) => f.fact_type === "semantic" && f.subject.startsWith("coupling:"));
-        }
-        catch {
-            return [];
-        }
-    }
-    /**
-     * Parse a coupling fact's subject and content.
-     * Subject format: "coupling:fileA↔fileB"
-     * Content format: "Files co-accessed in N sessions"
-     */
-    parseCouplingFact(fact) {
-        const parts = fact.subject.replace("coupling:", "").split("↔");
-        const fileA = parts[0] ?? "";
-        const fileB = parts[1] ?? "";
-        // Extract session count from content
-        const sessionMatch = fact.content.match(/(\d+)\s*session/);
-        const sessions = sessionMatch?.[1]
-            ? Number.parseInt(sessionMatch[1], 10)
-            : 1;
-        return {
-            fileA,
-            fileB,
-            score: fact.base_confidence,
-            sessions,
-        };
-    }
-    /**
-     * Check structural coupling between two specific files.
-     * Returns 0-1 based on shared edges.
-     */
-    async getGraphCouplingBetween(fileA, fileB) {
-        try {
-            const entitiesA = await this.localGraph.getEntitiesByFile(fileA);
-            if (!entitiesA || entitiesA.length === 0)
-                return 0;
-            for (const entity of entitiesA.slice(0, 5)) {
-                const [callers, callees] = await Promise.all([
-                    this.localGraph.getCallersOf(entity.key),
-                    this.localGraph.getCalleesOf(entity.key),
-                ]);
-                const hasConnection = [...callers, ...callees].some((e) => e.file_path === fileB);
-                if (hasConnection)
-                    return 0.5; // At least one structural connection
-            }
-            return 0;
-        }
-        catch {
-            return 0;
-        }
-    }
-}