monomind 2.7.12 → 2.7.14

package/packages/@monomind/cli/dist/src/memory/query-router.js

@@ -1,113 +0,0 @@
-/**
- * Query Router + RRF fusion — Phase 4 of the cognee port plan.
- *
- * routeQuery: cognee's rule-based (non-LLM) recall router scaled to our four
- * retrieval surfaces — document chunks, knowledge-graph triplets, distilled
- * rules, and org/pattern memories. Weighted regex rules with a negation
- * window, a confidence gate (winner must be ≥2× runner-up), and an in-memory
- * misroute counter for debuggability.
- *
- * rrfFuse: Reciprocal Rank Fusion across result lists whose raw scores are
- * not comparable (cosine vs blended vs keyword) — `Σ 1/(rrf_k + rank + 1)`
- * with cognee's adaptive rrf_k = max(30, min(60, 20 + 2·top_k)).
- *
- * @module v1/cli/memory/query-router
- */
-import fs from 'node:fs';
-import path from 'node:path';
-// Order matters only for tie display; scoring is additive per surface.
-const ROUTE_RULES = [
-    // Rules: "how should I", conventions, policies, dos and don'ts.
-    { surface: 'rules', pattern: /\b(rules?|conventions?|policy|policies|guidelines?|best practices?|should (i|we|you)|always|never|allowed|forbidden)\b/i, weight: 2 },
-    // KG: relationships, structure, "how does X relate to / depend on Y", who/what connects.
-    { surface: 'kg', pattern: /\b(relat(e|es|ed|ionship)|depend(s|ency|encies)?|connect(s|ed|ion)?|link(s|ed)?|between|structure|architecture|who (owns|maintains|uses)|what (uses|calls|imports))\b/i, weight: 2 },
-    { surface: 'kg', pattern: /\b(entity|entities|graph|triplet)\b/i, weight: 1.5 },
-    // Memory: past runs/decisions/outcomes/history.
-    { surface: 'memory', pattern: /\b(last (run|time)|previous(ly)?|history|past|earlier|before|decision|decided|outcome|learned|remember)\b/i, weight: 2 },
-    // Chunks: docs/specs/definitions/how-to content.
-    { surface: 'chunks', pattern: /\b(doc(s|ument|umentation)?|spec|readme|guide|manual|note(s)?|wrote|written|what is|how (do|to)|explain|describe|definition)\b/i, weight: 1.5 },
-];
-/** Negated mentions must not vote: "not about the architecture" (cognee uses
- *  a 20-char pre-match negation window; same here). */
-const NEGATION_RE = /\b(not?|without|except|ignore|don'?t|excluding)\b[^.!?]{0,20}$/i;
-const overrideCounts = {};
-/** Overrides persist across processes (the CLI is one-shot — an in-memory
- *  counter alone evaporates before doctor/debugging can read it). Best-effort
- *  read-merge-write of a tiny JSON file; never throws into the caller. */
-const OVERRIDES_FILE = ['.monomind', 'metrics', 'route-overrides.json'];
-function persistOverride(key) {
-    try {
-        const file = path.join(process.cwd(), ...OVERRIDES_FILE);
-        fs.mkdirSync(path.dirname(file), { recursive: true });
-        let disk = {};
-        try {
-            disk = JSON.parse(fs.readFileSync(file, 'utf-8'));
-        }
-        catch { /* fresh file */ }
-        disk[key] = (typeof disk[key] === 'number' ? disk[key] : 0) + 1;
-        fs.writeFileSync(file, JSON.stringify(disk, null, 2));
-    }
-    catch { /* telemetry must never block or throw */ }
-}
-export function routeQuery(query) {
-    const q = String(query ?? '').slice(0, 2000);
-    const scores = { chunks: 0.5, kg: 0, rules: 0, memory: 0 }; // chunks = weak prior
-    for (const rule of ROUTE_RULES) {
-        for (const m of q.matchAll(new RegExp(rule.pattern.source, rule.pattern.flags + 'g'))) {
-            const before = q.slice(Math.max(0, (m.index ?? 0) - 26), m.index ?? 0);
-            if (NEGATION_RE.test(before))
-                continue;
-            scores[rule.surface] += rule.weight;
-        }
-    }
-    const ranked = Object.entries(scores)
-        .sort((a, b) => b[1] - a[1]);
-    const [winner, runnerUp] = ranked;
-    const confident = winner[1] >= 2 * Math.max(runnerUp[1], 0.25);
-    const surfaces = confident
-        ? [winner[0]]
-        : ranked.filter(([, s]) => s > 0).map(([k]) => k);
-    return { surfaces: surfaces.length ? surfaces : ['chunks'], confident, scores };
-}
-/** Call when a route proved wrong (caller retried another surface) — counts
- *  feed debugging, mirroring cognee's record_override telemetry. */
-export function recordRouteOverride(from, to) {
-    const key = `${from}->${to}`;
-    overrideCounts[key] = (overrideCounts[key] ?? 0) + 1;
-    persistOverride(key);
-}
-/** In-memory counts from this process only; pass merged=true to include the
- *  persisted cross-process counts from .monomind/metrics/route-overrides.json. */
-export function getRouteOverrides(merged = false) {
-    if (!merged)
-        return { ...overrideCounts };
-    try {
-        const disk = JSON.parse(fs.readFileSync(path.join(process.cwd(), ...OVERRIDES_FILE), 'utf-8'));
-        return { ...disk }; // disk already includes this process's persisted increments
-    }
-    catch {
-        return { ...overrideCounts };
-    }
-}
-/** Fuse ranked lists via RRF × importance factor (cognee hybrid/ranking.py).
- *  Input lists must each be ranked best-first; raw scores are ignored. */
-export function rrfFuse(lists, topK) {
-    const rrfK = Math.max(30, Math.min(60, 20 + 2 * topK));
-    const byId = new Map();
-    for (const list of lists) {
-        list.forEach((item, rank) => {
-            const importance = typeof item.importance === 'number' ? item.importance : 0.5;
-            const contribution = (1 / (rrfK + rank + 1)) * (0.75 + 0.5 * importance);
-            const existing = byId.get(item.id);
-            if (existing)
-                existing.rrf += contribution;
-            else
-                byId.set(item.id, { item, rrf: contribution });
-        });
-    }
-    return [...byId.values()]
-        .sort((a, b) => b.rrf - a.rrf)
-        .slice(0, topK)
-        .map(({ item, rrf }) => ({ ...item, rrf }));
-}
-//# sourceMappingURL=query-router.js.map

package/packages/@monomind/cli/dist/src/memory/sona-optimizer.d.ts

@@ -1,237 +0,0 @@
-/**
- * SONA (Self-Optimizing Neural Architecture) Optimizer
- *
- * Processes trajectory outcomes to learn optimal routing patterns.
- * Integrates with Q-learning router and persistence layer.
- *
- * Features:
- * - Processes trajectory outcomes from hooksTrajectoryEnd
- * - Extracts keywords from tasks for pattern matching
- * - Maintains learned routing patterns with confidence scoring
- * - Persists patterns to .swarm/sona-patterns.json
- * @module v1/cli/memory/sona-optimizer
- */
-/**
- * Trajectory outcome from hooks/intelligence/trajectory-end
- */
-export interface TrajectoryOutcome {
-    trajectoryId: string;
-    task: string;
-    agent: string;
-    success: boolean;
-    steps?: Array<{
-        action: string;
-        result: string;
-        quality: number;
-        timestamp: string;
-    }>;
-    feedback?: string;
-    duration?: number;
-}
-/**
- * Learned routing pattern
- */
-export interface LearnedPattern {
-    /** Keywords extracted from task descriptions */
-    keywords: string[];
-    /** Agent that handled the task */
-    agent: string;
-    /** Confidence score (0-1) */
-    confidence: number;
-    /** Number of successful uses */
-    successCount: number;
-    /** Number of failed uses */
-    failureCount: number;
-    /** Last time pattern was used */
-    lastUsed: number;
-    /** Pattern creation time */
-    createdAt: number;
-}
-/**
- * Routing suggestion result
- */
-export interface RoutingSuggestion {
-    /** Recommended agent */
-    agent: string;
-    /** Confidence in recommendation (0-1) */
-    confidence: number;
-    /** Source of recommendation */
-    source: 'sona-pattern' | 'keyword-match' | 'default';
-    /** Alternative agents with scores */
-    alternatives: Array<{
-        agent: string;
-        score: number;
-    }>;
-    /** Matched keywords */
-    matchedKeywords?: string[];
-}
-/**
- * SONA optimizer statistics
- */
-export interface SONAStats {
-    /** Total patterns learned */
-    totalPatterns: number;
-    /** Successful routing decisions */
-    successfulRoutings: number;
-    /** Failed routing decisions */
-    failedRoutings: number;
-    /** Total trajectories processed */
-    trajectoriesProcessed: number;
-    /** Average confidence of patterns */
-    avgConfidence: number;
-    /** Time of last learning update */
-    lastUpdate: number | null;
-}
-/**
- * SONA Optimizer for adaptive routing based on trajectory outcomes
- *
- * Learns from past task outcomes to improve future routing decisions.
- */
-export declare class SONAOptimizer {
-    private patterns;
-    private trajectoriesProcessed;
-    private successfulRoutings;
-    private failedRoutings;
-    private lastUpdate;
-    private persistencePath;
-    /** Set when in-memory state diverges from disk — triggers next debounced write */
-    private dirty;
-    /** NodeJS timeout handle for debounced disk flush */
-    private saveTimer;
-    /** Debounce window for disk writes (ms) — batches rapid trajectory bursts */
-    private static readonly SAVE_DEBOUNCE_MS;
-    constructor(options?: {
-        persistencePath?: string;
-    });
-    /**
-     * Initialize the optimizer and load persisted state
-     */
-    initialize(): Promise<{
-        success: boolean;
-        patternsLoaded: number;
-    }>;
-    /**
-     * Process a trajectory outcome and learn from it
-     * Called by hooksTrajectoryEnd
-     */
-    processTrajectoryOutcome(outcome: TrajectoryOutcome): {
-        learned: boolean;
-        patternKey: string;
-        confidence: number;
-        keywordsExtracted: string[];
-    };
-    /**
-     * Get routing suggestion based on learned patterns
-     */
-    getRoutingSuggestion(task: string): RoutingSuggestion;
-    /**
-     * Get optimizer statistics
-     */
-    getStats(): SONAStats;
-    /**
-     * Apply temporal decay to pattern confidence
-     * Reduces confidence of unused patterns
-     */
-    applyTemporalDecay(): number;
-    /**
-     * Reset all learned patterns
-     */
-    reset(): void;
-    /**
-     * Export patterns for analysis
-     */
-    exportPatterns(): Record<string, LearnedPattern>;
-    /**
-     * Import patterns (for migration or testing)
-     */
-    importPatterns(patterns: Record<string, LearnedPattern>): number;
-    /**
-     * Extract meaningful keywords from task description
-     */
-    private extractKeywords;
-    /**
-     * Check if word is a stop word
-     */
-    private isStopWord;
-    /**
-     * Create a unique pattern key from keywords and agent
-     */
-    private createPatternKey;
-    /**
-     * Find the best matching pattern for given keywords
-     */
-    private findBestPatternMatch;
-    /**
-     * Match keywords to agent using category heuristics
-     */
-    private matchKeywordsToAgent;
-    /**
-     * Get alternative agent suggestions
-     */
-    private getAlternatives;
-    /**
-     * Prune old/low-confidence patterns if over limit
-     */
-    private prunePatterns;
-    /**
-     * Validate pattern structure with strict bounds.
-     * SECURITY: confidence/keywords/agent fields must be bounds-checked to
-     * defeat poisoning. typeof NaN === 'number' and typeof Infinity === 'number'
-     * pass the loose typeof check; without bounds, an attacker who writes
-     * sona-patterns.json (poisoned bundle, malicious test fixture, co-located
-     * compromise) can inject `confidence: 1e308` to deterministically win
-     * every routing decision via findBestPatternMatch's `score = matchRatio *
-     * confidence`. Mirrors the pattern in intelligence.ts:loadFromDisk.
-     */
-    private validatePattern;
-    /**
-     * Load patterns from disk
-     */
-    private loadFromDisk;
-    /**
-     * Schedule a debounced disk flush.
-     * Multiple calls within SAVE_DEBOUNCE_MS coalesce into a single write,
-     * preventing blocking I/O on every trajectory event during swarm bursts.
-     */
-    private scheduleSave;
-    /**
-     * Save patterns to disk
-     */
-    private saveToDisk;
-}
-/**
- * Get the singleton SONAOptimizer instance
- * Uses lazy initialization to avoid circular imports
- */
-export declare function getSONAOptimizer(): Promise<SONAOptimizer>;
-/**
- * Reset the singleton instance (for testing)
- */
-export declare function resetSONAOptimizer(): void;
-/**
- * Process a trajectory outcome (convenience function)
- */
-export declare function processTrajectory(outcome: TrajectoryOutcome): Promise<{
-    learned: boolean;
-    patternKey: string;
-    confidence: number;
-    keywordsExtracted: string[];
-}>;
-/**
- * Get routing suggestion (convenience function)
- */
-export declare function getSuggestion(task: string): Promise<RoutingSuggestion>;
-/**
- * Get SONA statistics (convenience function)
- */
-export declare function getSONAStats(): Promise<SONAStats>;
-declare const _default: {
-    SONAOptimizer: typeof SONAOptimizer;
-    getSONAOptimizer: typeof getSONAOptimizer;
-    resetSONAOptimizer: typeof resetSONAOptimizer;
-    processTrajectory: typeof processTrajectory;
-    getSuggestion: typeof getSuggestion;
-    getSONAStats: typeof getSONAStats;
-};
-export default _default;
-//# sourceMappingURL=sona-optimizer.d.ts.map