@unerr-ai/unerr 0.2.0 → 0.2.2

package/dist/intelligence/semantic/path-domain-inference.js

@@ -1,112 +0,0 @@
-/**
- * Path-Based Domain Inference — infers domain labels from file paths.
- *
- * Uses directory naming conventions to assign domain labels:
- *   src/auth/ → "authentication"
- *   src/payments/ → "payments"
- *   src/api/routes/ → "api"
- *   tests/ → "testing"
- */
-const PATH_PATTERNS = [
-    { pattern: /\bauth\b/i, domain: "authentication", confidence: 0.9 },
-    {
-        pattern: /\bpayment|billing|stripe|checkout\b/i,
-        domain: "payments",
-        confidence: 0.9,
-    },
-    { pattern: /\bapi\b/i, domain: "api", confidence: 0.8 },
-    {
-        pattern: /\broute|router|middleware\b/i,
-        domain: "routing",
-        confidence: 0.8,
-    },
-    {
-        pattern: /\bdb|database|model|schema|migration\b/i,
-        domain: "database",
-        confidence: 0.85,
-    },
-    {
-        pattern: /\btest|spec|__tests__|__test__\b/i,
-        domain: "testing",
-        confidence: 0.95,
-    },
-    {
-        pattern: /\bconfig|settings|env\b/i,
-        domain: "configuration",
-        confidence: 0.8,
-    },
-    {
-        pattern: /\blog|logger|telemetry|monitor\b/i,
-        domain: "observability",
-        confidence: 0.8,
-    },
-    {
-        pattern: /\butil|helper|lib|common|shared\b/i,
-        domain: "utilities",
-        confidence: 0.7,
-    },
-    {
-        pattern: /\bui|component|view|page|layout\b/i,
-        domain: "frontend",
-        confidence: 0.85,
-    },
-    {
-        pattern: /\bstyle|css|theme|design\b/i,
-        domain: "styling",
-        confidence: 0.85,
-    },
-    {
-        pattern: /\bsecurity|crypto|encrypt|token\b/i,
-        domain: "security",
-        confidence: 0.9,
-    },
-    {
-        pattern: /\bemail|notification|message|queue\b/i,
-        domain: "messaging",
-        confidence: 0.8,
-    },
-    {
-        pattern: /\bstorage|upload|file|asset|media\b/i,
-        domain: "storage",
-        confidence: 0.8,
-    },
-    { pattern: /\bcache|redis|memcache\b/i, domain: "caching", confidence: 0.9 },
-    { pattern: /\bsearch|index|elastic\b/i, domain: "search", confidence: 0.85 },
-    {
-        pattern: /\bgraph|intelligence|semantic|embedding\b/i,
-        domain: "intelligence",
-        confidence: 0.9,
-    },
-    {
-        pattern: /\bproxy|transport|protocol|mcp\b/i,
-        domain: "infrastructure",
-        confidence: 0.8,
-    },
-    {
-        pattern: /\btracking|analytics|metric\b/i,
-        domain: "tracking",
-        confidence: 0.85,
-    },
-];
-/**
- * Infer domain labels for a file path.
- * Returns all matching domains sorted by confidence.
- */
-export function inferDomain(filePath) {
-    const labels = [];
-    for (const { pattern, domain, confidence } of PATH_PATTERNS) {
-        if (pattern.test(filePath)) {
-            labels.push({ domain, confidence, source: "path-pattern" });
-        }
-    }
-    labels.sort((a, b) => b.confidence - a.confidence);
-    return labels;
-}
-/**
- * Get the primary domain for a file path.
- * Returns null if no domain pattern matches.
- */
-export function getPrimaryDomain(filePath) {
-    const labels = inferDomain(filePath);
-    return labels[0]?.domain ?? null;
-}

package/dist/intelligence/semantic/similarity-engine.js

@@ -1,60 +0,0 @@
-/**
- * Combined Similarity Engine — weighted cosine across lexical + structural + metadata.
- *
- * Weights: 0.5 lexical (TF-IDF) + 0.3 structural (Node2Vec) + 0.2 metadata (domain + git)
- */
-import { cosineSimilarity } from "./embedding-store.js";
-const DEFAULT_WEIGHTS = {
-    lexical: 0.5,
-    structural: 0.3,
-    metadata: 0.2,
-};
-/**
- * Compute combined similarity between two entities.
- */
-export function computeSimilarity(a, b, weights = DEFAULT_WEIGHTS) {
-    const lexicalSim = cosineSimilarity(a.lexical, b.lexical);
-    const structuralSim = cosineSimilarity(a.structural, b.structural);
-    const metadataSim = computeMetadataSimilarity(a, b);
-    return (weights.lexical * lexicalSim +
-        weights.structural * structuralSim +
-        weights.metadata * metadataSim);
-}
-/**
- * Find the top-K most similar entities using the combined metric.
- */
-export function findMostSimilar(queryKey, queryEmbeddings, allEmbeddings, topK = 10, weights = DEFAULT_WEIGHTS) {
-    const results = [];
-    for (const [key, embeddings] of allEmbeddings) {
-        if (key === queryKey)
-            continue;
-        const lexicalScore = cosineSimilarity(queryEmbeddings.lexical, embeddings.lexical);
-        const structuralScore = cosineSimilarity(queryEmbeddings.structural, embeddings.structural);
-        const metadataScore = computeMetadataSimilarity(queryEmbeddings, embeddings);
-        const score = weights.lexical * lexicalScore +
-            weights.structural * structuralScore +
-            weights.metadata * metadataScore;
-        results.push({
-            entityKey: key,
-            score,
-            lexicalScore,
-            structuralScore,
-            metadataScore,
-        });
-    }
-    results.sort((a, b) => b.score - a.score);
-    return results.slice(0, topK);
-}
-function computeMetadataSimilarity(a, b) {
-    let score = 0;
-    if (a.domain && b.domain && a.domain === b.domain) {
-        score += 0.5;
-    }
-    if (a.keywords.length > 0 && b.keywords.length > 0) {
-        const aSet = new Set(a.keywords);
-        const overlap = b.keywords.filter((k) => aSet.has(k)).length;
-        const maxPossible = Math.max(a.keywords.length, b.keywords.length);
-        score += 0.5 * (overlap / maxPossible);
-    }
-    return Math.min(1, score);
-}

package/dist/intelligence/semantic/tfidf-vectors.js

@@ -1,88 +0,0 @@
-/**
- * TF-IDF Vector Builder — produces 64-dimensional lexical embeddings.
- *
- * Corpus: all entity identifiers in the project.
- * Method: standard TF-IDF with dimensionality reduction via hashing trick.
- *
- * Output: Float32Array[64] per entity, normalized to unit length.
- * Performance: <500ms for 1K entities.
- */
-import { tokenizeIdentifier } from "./identifier-tokenizer.js";
-/**
- * Build a TF-IDF corpus from entity identifiers.
- */
-export function buildCorpus(identifiers) {
-    const documentFrequency = new Map();
-    const vocabulary = new Map();
-    let vocabIndex = 0;
-    for (const id of identifiers) {
-        const tokens = new Set(tokenizeIdentifier(id));
-        for (const token of tokens) {
-            documentFrequency.set(token, (documentFrequency.get(token) ?? 0) + 1);
-            if (!vocabulary.has(token)) {
-                vocabulary.set(token, vocabIndex++);
-            }
-        }
-    }
-    const idf = new Map();
-    const N = identifiers.length;
-    for (const [token, df] of documentFrequency) {
-        idf.set(token, Math.log((N + 1) / (df + 1)) + 1);
-    }
-    return { vocabulary, idf, documentCount: N };
-}
-const VECTOR_DIM = 64;
-/**
- * Compute a 64-dim TF-IDF vector for a single identifier.
- * Uses hashing trick for dimensionality reduction.
- */
-export function computeTfIdfVector(identifier, corpus) {
-    const vector = new Float32Array(VECTOR_DIM);
-    const tokens = tokenizeIdentifier(identifier);
-    if (tokens.length === 0)
-        return vector;
-    const tokenCounts = new Map();
-    for (const token of tokens) {
-        tokenCounts.set(token, (tokenCounts.get(token) ?? 0) + 1);
-    }
-    for (const [token, count] of tokenCounts) {
-        const tf = count / tokens.length;
-        const idfVal = corpus.idf.get(token) ?? 1;
-        const tfidf = tf * idfVal;
-        const hashIdx = hashToken(token) % VECTOR_DIM;
-        vector[hashIdx] += tfidf;
-    }
-    normalize(vector);
-    return vector;
-}
-/**
- * Build TF-IDF vectors for all entities at once.
- */
-export function buildTfIdfVectors(identifiers) {
-    const corpus = buildCorpus(identifiers);
-    const vectors = new Map();
-    for (const id of identifiers) {
-        vectors.set(id, computeTfIdfVector(id, corpus));
-    }
-    return vectors;
-}
-function hashToken(token) {
-    let hash = 0;
-    for (let i = 0; i < token.length; i++) {
-        hash = ((hash << 5) - hash + token.charCodeAt(i)) | 0;
-    }
-    return Math.abs(hash);
-}
-function normalize(vector) {
-    let norm = 0;
-    for (let i = 0; i < vector.length; i++) {
-        norm += vector[i] * vector[i];
-    }
-    norm = Math.sqrt(norm);
-    if (norm > 0) {
-        for (let i = 0; i < vector.length; i++) {
-            vector[i] /= norm;
-        }
-    }
-}
-export { VECTOR_DIM };

package/dist/intelligence/session-brief-builder.js

@@ -1,159 +0,0 @@
-/**
- * SessionBriefBuilder — constructs a structured intelligence brief
- * for the first tool call of a session.
- *
- * Replaces flat session_greeting + session_resume with a structured
- * SessionBrief that includes inter-session changes, unfinished work,
- * key facts, convention summary, and intelligence health.
- *
- * Part of Layer B of the Three-Layer Experience System.
- */
-export class SessionBriefBuilder {
-    localGraph;
-    factStore;
-    graphStats;
-    healthGrade;
-    constructor(localGraph, factStore, graphStats, healthGrade) {
-        this.localGraph = localGraph;
-        this.factStore = factStore;
-        this.graphStats = graphStats;
-        this.healthGrade = healthGrade;
-    }
-    /**
-     * Build a structured session brief.
-     * Gathers intelligence from graph, fact store, and resume context.
-     */
-    async build(resumeContext) {
-        const brief = {
-            greeting: this.buildGreeting(),
-        };
-        // Inter-session changes from resume context
-        if (resumeContext?.filesModified &&
-            resumeContext.filesModified.length > 0) {
-            brief.inter_session_changes = resumeContext.filesModified.slice(0, 10);
-        }
-        // Unfinished work from resume context
-        if (resumeContext?.incompleteEntities &&
-            resumeContext.incompleteEntities.length > 0) {
-            brief.unfinished_work = resumeContext.incompleteEntities.slice(0, 5);
-        }
-        // Gather async data in parallel
-        const [keyFacts, conventionSummary] = await Promise.all([
-            this.getKeyFacts(),
-            this.getConventionSummary(),
-        ]);
-        if (keyFacts.length > 0) {
-            brief.key_facts = keyFacts;
-        }
-        if (conventionSummary) {
-            brief.convention_summary = conventionSummary;
-        }
-        // Intelligence health from graph stats + fact count
-        const health = await this.getIntelligenceHealth();
-        if (health) {
-            brief.intelligence_health = health;
-        }
-        return brief;
-    }
-    /**
-     * Build the greeting line based on codebase health grade.
-     */
-    buildGreeting() {
-        if (!this.healthGrade || !this.graphStats) {
-            return "unerr proxy ready. Graph intelligence active.";
-        }
-        const { entities, edges, rules } = this.graphStats;
-        const grade = this.healthGrade;
-        if (grade === "A" || grade === "A+") {
-            return `Codebase scores ${grade} — ${entities} entities, ${edges} edges, ${rules} rules. Architecture is healthy.`;
-        }
-        if (grade === "B" || grade === "B+") {
-            return `Codebase health: ${grade}. Tracking ${entities} entities, ${edges} edges, ${rules} rules. Some areas could improve.`;
-        }
-        if (grade.startsWith("C")) {
-            return `Codebase health: ${grade}. ${entities} entities tracked, ${rules} rules active. Structural issues affect maintainability.`;
-        }
-        return `Warning: codebase health is ${grade}. Significant structural issues across ${entities} entities.`;
-    }
-    /**
-     * Get top 3 most relevant project-scope facts.
-     */
-    async getKeyFacts() {
-        if (!this.factStore)
-            return [];
-        try {
-            const facts = await this.factStore.recallByScope("project", 0.4);
-            return facts
-                .sort((a, b) => b.effective_confidence - a.effective_confidence)
-                .slice(0, 3)
-                .map((f) => f.content);
-        }
-        catch {
-            return [];
-        }
-    }
-    /**
-     * Get convention summary from graph store.
-     */
-    async getConventionSummary() {
-        if (!this.localGraph)
-            return null;
-        try {
-            const conventions = await this.localGraph.getConventions();
-            if (!conventions || conventions.length === 0)
-                return null;
-            const avgAdherence = Math.round(conventions.reduce((sum, c) => sum + c.adherence_rate, 0) /
-                conventions.length);
-            return `${conventions.length} conventions detected, ${avgAdherence}% avg adherence`;
-        }
-        catch {
-            return null;
-        }
-    }
-    /**
-     * Get intelligence health summary.
-     */
-    async getIntelligenceHealth() {
-        const parts = [];
-        if (this.graphStats) {
-            parts.push(`${this.graphStats.entities} entities`);
-        }
-        if (this.factStore) {
-            try {
-                const facts = await this.factStore.recallByScope("project", 0.0);
-                if (facts.length > 0) {
-                    parts.push(`${facts.length} facts`);
-                }
-            }
-            catch {
-                // Non-critical
-            }
-        }
-        if (this.localGraph) {
-            try {
-                const conventions = await this.localGraph.getConventions();
-                if (conventions && conventions.length > 0) {
-                    parts.push(`${conventions.length} conventions`);
-                }
-            }
-            catch {
-                // Non-critical
-            }
-        }
-        return parts.length > 0 ? parts.join(", ") : null;
-    }
-}
-let instance = null;
-/**
- * Get or create the SessionBriefBuilder singleton.
- * Must be re-created if graph/facts change (call resetSessionBriefBuilder).
- */
-export function getSessionBriefBuilder(localGraph, factStore, graphStats, healthGrade) {
-    if (!instance) {
-        instance = new SessionBriefBuilder(localGraph, factStore, graphStats, healthGrade);
-    }
-    return instance;
-}
-export function resetSessionBriefBuilder() {
-    instance = null;
-}

package/dist/intelligence/session-context.js

@@ -1,221 +0,0 @@
-/**
- * Session Context — tracks per-session state for intelligent context injection.
- *
- * Used by QueryRouter to decide when to inject blast radius, conventions,
- * corrections, and risk information into tool responses.
- */
-export class SessionContext {
-    toolCallCount = 0;
-    greeted = false;
-    injectedBlastRadius = new Set();
-    /**
-     * Convention / fact reinforcement windows: track WHEN each key was last
-     * shown (tool-call index + wall-clock ms) so we can re-surface after a
-     * stale window instead of going silent for the rest of the session.
-     *
-     * Stale = 10+ unrelated tool calls since last show, OR 30+ min wall-clock.
-     * Tunable via STALE_CALL_GAP / STALE_TIME_MS constants below.
-     */
-    injectedConventions = new Map();
-    injectedRisk = new Set();
-    injectedCorrections = new Set();
-    injectedFacts = new Map();
-    STALE_CALL_GAP = 10;
-    STALE_TIME_MS = 30 * 60 * 1000;
-    entityHistory = new Map();
-    lastFiredThreshold = 0;
-    /**
-     * Tier-3 rotational signal decay: how many times each unique signal has
-     * been emitted in the body prefix this session. Used by signal-scorer.rank()
-     * to deprioritize already-shown signals (`adjusted_score = base / (1 + shows * 0.5)`),
-     * so anti-pattern facts surface fresh information instead of repeating.
-     * Key: stable signal id (sha256(content).slice(0,16) or fact_id).
-     *
-     * In-memory fallback used when no SignalShowStore has been attached
-     * (tests, --mcp during facts.db boot). When the store is present its
-     * effective count is preferred so rotation survives restarts and is
-     * coordinated across parallel sessions in the same repo.
-     */
-    signalShowCount = new Map();
-    showStore = null;
-    recordToolCall() {
-        this.toolCallCount++;
-    }
-    getToolCallCount() {
-        return this.toolCallCount;
-    }
-    isFirstCall() {
-        return !this.greeted && this.toolCallCount <= 1;
-    }
-    markGreeted() {
-        this.greeted = true;
-    }
-    /**
-     * Attach the persistent rotation store. Once attached, getSignalShowCount
-     * returns the time-decayed cross-session count and recordSignalShown writes
-     * through to facts.db on the next flush tick.
-     */
-    setSignalShowStore(store) {
-        this.showStore = store;
-    }
-    // ── Tier-3 rotational signal decay ────────────────────────────────────
-    /** Record that a signal was emitted in a prefix line (called by ranker). */
-    recordSignalShown(signalId, scope = "") {
-        if (!signalId)
-            return;
-        this.signalShowCount.set(signalId, (this.signalShowCount.get(signalId) ?? 0) + 1);
-        this.showStore?.recordShown(signalId, scope);
-    }
-    /** How many times this signal has been emitted this session (or effective decayed count if persisted). */
-    getSignalShowCount(signalId) {
-        if (!signalId)
-            return 0;
-        if (this.showStore)
-            return this.showStore.getEffectiveShowCount(signalId);
-        return this.signalShowCount.get(signalId) ?? 0;
-    }
-    /** Last-shown timestamp (ms since epoch) across all sessions; 0 if never shown. */
-    getSignalLastShownMs(signalId) {
-        if (!signalId)
-            return 0;
-        return this.showStore?.getLastShownMs(signalId) ?? 0;
-    }
-    /** Reset rotation state — useful for tests or explicit "fresh start" intents. */
-    resetSignalRotation() {
-        this.signalShowCount.clear();
-    }
-    hasHistory(entityKey) {
-        return this.entityHistory.has(entityKey);
-    }
-    getHistory(entityKey) {
-        return this.entityHistory.get(entityKey);
-    }
-    /**
-     * Entity keys recently queried this session (Map insertion order — newest
-     * last). Returns the trailing slice up to `max` so the recall_facts ranker
-     * can give a small boost to facts whose subject matches active context.
-     */
-    getRecentSubjects(max = 10) {
-        const keys = Array.from(this.entityHistory.keys());
-        return new Set(keys.slice(-max));
-    }
-    recordEntityHistory(entityKey, blastRadius, risk) {
-        // Only record on first call — do not overwrite
-        if (this.entityHistory.has(entityKey))
-            return;
-        this.entityHistory.set(entityKey, {
-            blast_radius: blastRadius,
-            risk,
-            queriedAt: Date.now(),
-        });
-    }
-    shouldInjectBlastRadius(entityKey) {
-        if (this.injectedBlastRadius.has(entityKey))
-            return false;
-        this.injectedBlastRadius.add(entityKey);
-        return true;
-    }
-    shouldInjectCorrection(entityKey, _errorType) {
-        if (this.injectedCorrections.has(entityKey))
-            return false;
-        this.injectedCorrections.add(entityKey);
-        return true;
-    }
-    shouldInjectConvention(entityKey) {
-        const key = Array.isArray(entityKey) ? entityKey.join(",") : entityKey;
-        return this.isStale(this.injectedConventions.get(key));
-    }
-    recordConventions(conventions) {
-        // Set-once semantics: stamp on FIRST show only. Refreshing on every
-        // re-show defeats the stale-window predicate (the gap can never
-        // accumulate when each show resets atCall to current). Once a key
-        // becomes stale, isStale returns true, the caller surfaces it again,
-        // and only then does recordConventions overwrite the stamp.
-        const items = Array.isArray(conventions) ? conventions : [conventions];
-        const stamp = { atCall: this.toolCallCount, atMs: Date.now() };
-        for (const item of items) {
-            const existing = this.injectedConventions.get(item);
-            if (!existing || this.isStale(existing)) {
-                this.injectedConventions.set(item, stamp);
-            }
-        }
-    }
-    shouldInjectFact(factId) {
-        return this.isStale(this.injectedFacts.get(factId));
-    }
-    recordFacts(factIds) {
-        // Set-once semantics — same reasoning as recordConventions above.
-        const stamp = { atCall: this.toolCallCount, atMs: Date.now() };
-        for (const id of factIds) {
-            const existing = this.injectedFacts.get(id);
-            if (!existing || this.isStale(existing)) {
-                this.injectedFacts.set(id, stamp);
-            }
-        }
-    }
-    /**
-     * "Should re-surface" predicate: true when never shown, or when the gap
-     * since last show exceeds either threshold (call-count or wall-clock).
-     * Both thresholds matter — pure call-count misses long idle gaps, pure
-     * time misses rapid-fire sessions.
-     */
-    isStale(last) {
-        if (!last)
-            return true;
-        if (this.toolCallCount - last.atCall >= this.STALE_CALL_GAP)
-            return true;
-        if (Date.now() - last.atMs >= this.STALE_TIME_MS)
-            return true;
-        return false;
-    }
-    shouldInjectRisk(entityKey) {
-        if (this.injectedRisk.has(entityKey))
-            return false;
-        return true;
-    }
-    recordRisk(entityKey) {
-        this.injectedRisk.add(entityKey);
-    }
-    /**
-     * Value counter — surfaces "unerr has caught N issues this session" every 3rd caught event.
-     * Conditions: toolCallCount > 10, caught > 0, caught % 3 === 0, fires once per threshold.
-     */
-    getValueCounter(events) {
-        if (this.toolCallCount <= 10)
-            return undefined;
-        const caught = events.conventionViolationsCaught +
-            events.chokepointWarningsIssued +
-            events.circularDepsDetected;
-        if (caught === 0)
-            return undefined;
-        if (caught % 3 !== 0)
-            return undefined;
-        if (caught === this.lastFiredThreshold)
-            return undefined;
-        this.lastFiredThreshold = caught;
-        return `(unerr has caught ${caught} issues this session)`;
-    }
-    recordQuery(entityKey) {
-        // Mark as having had blast radius injected (dedup future calls)
-        this.injectedBlastRadius.add(entityKey);
-    }
-    get entitiesQueried() {
-        return this.injectedBlastRadius.size;
-    }
-    get conventionsSurfaced() {
-        return this.injectedConventions.size;
-    }
-    get risksSurfaced() {
-        return this.injectedRisk.size;
-    }
-    reset() {
-        this.toolCallCount = 0;
-        this.greeted = false;
-        this.injectedBlastRadius.clear();
-        this.injectedConventions.clear();
-        this.injectedRisk.clear();
-        this.injectedCorrections.clear();
-        this.entityHistory.clear();
-        this.lastFiredThreshold = 0;
-    }
-}