vesper-memory 0.3.0

package/dist/router/smart-router.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"smart-router.d.ts","sourceRoot":"","sources":["../../src/router/smart-router.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,kBAAkB,EAAE,MAAM,oCAAoC,CAAC;AACxE,OAAO,EAAE,mBAAmB,EAAE,MAAM,qCAAqC,CAAC;AAY1E;;GAEG;AACH,wBAAgB,IAAI,CAAC,IAAI,EAAE;IAAE,aAAa,CAAC,EAAE,kBAAkB,CAAA;CAAE,GAAG,IAAI,CAEvE;AAED;;;GAGG;AACH,oBAAY,SAAS;IACnB,OAAO,YAAY;IACnB,UAAU,eAAe;IACzB,OAAO,YAAY;IACnB,QAAQ,aAAa;IACrB,KAAK,UAAU;IACf,OAAO,YAAY;CACpB;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,SAAS,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,cAAc,EAAE,MAAM,CAAC;IACvB,SAAS,EAAE,IAAI,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACpC;AAED;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,SAAS,GAAG,UAAU,GAAG,YAAY,GAAG,QAAQ,CAAC;IACzD,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,IAAI,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,oBAAoB,CA0FjE;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAsB,QAAQ,CAC5B,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,cAAc,GACtB,OAAO,CAAC,YAAY,EAAE,CAAC,CAyDzB;AA2ND;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAI/D;AAED;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAE1D;AAED;;;;;GAKG;AACH,MAAM,WAAW,SAAS;IACxB,SAAS,EAAE,IAAI,CAAC;IAChB,OAAO,EAAE,IAAI,CAAC;CACf;AAED,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,CAI/D;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CA+BpE;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,cAAc,EAAE,mBAAmB,GAAG,IAAI,CAE/E;AAuBD;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,2BAA2B,CAC/C,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,cAAc,GACvB,OAAO,CAAC,YAAY,EAAE,CAAC,CAwCzB"}

package/dist/router/smart-router.js

@@ -0,0 +1,524 @@
+/**
+ * Smart Query Router
+ *
+ * Implements intelligent routing logic from v3.0 plan:
+ * 1. Always check working memory first (fast path)
+ * 2. Classify query type using regex patterns
+ * 3. Route to appropriate handler based on classification
+ * 4. Fall back to hybrid search for complex queries
+ */
+/**
+ * Module-level dependency - set via init()
+ */
+let workingMemoryLayer = null;
+/**
+ * Module-level semantic memory dependency for preference queries
+ */
+let semanticMemoryLayer = null;
+/**
+ * Initialize the router with dependencies
+ */
+export function init(deps) {
+    workingMemoryLayer = deps.workingMemory || null;
+}
+/**
+ * Query type enumeration
+ * Used to classify queries and route to appropriate handlers
+ */
+export var QueryType;
+(function (QueryType) {
+    QueryType["FACTUAL"] = "factual";
+    QueryType["PREFERENCE"] = "preference";
+    QueryType["PROJECT"] = "project";
+    QueryType["TEMPORAL"] = "temporal";
+    QueryType["SKILL"] = "skill";
+    QueryType["COMPLEX"] = "complex";
+})(QueryType || (QueryType = {}));
+/**
+ * Classify a query into one of the six query types
+ *
+ * Uses simple regex patterns to identify query intent without LLM calls.
+ * Falls back to 'complex' for ambiguous queries.
+ *
+ * Patterns (in order of specificity):
+ * - skill: "like before", "same as", "same way", "how you", "analyze"
+ * - factual: "what is", "who is", "where is"
+ * - temporal: "last week", "yesterday", "recently", etc.
+ * - preference: "prefer", "want", "style", "favorite"
+ * - project: "project", "working on", "decided", "building", "creating", "developing"
+ * - complex: fallback for anything else
+ */
+export function classifyQuery(query) {
+    const normalizedQuery = query.toLowerCase().trim();
+    // Pattern definitions with confidence scores
+    // NOTE: More specific patterns should be checked first to avoid ambiguity
+    const patterns = [
+        // Skill patterns are most specific - check before preference and temporal
+        {
+            type: QueryType.SKILL,
+            regex: /\b(like before|same as|same way|how you)\b/i,
+            confidence: 0.85,
+            label: "skill"
+        },
+        {
+            type: QueryType.SKILL,
+            regex: /\banalyze\b/i,
+            confidence: 0.75,
+            label: "skill_analyze"
+        },
+        // Temporal patterns - check before factual WH questions since temporal is more specific
+        {
+            type: QueryType.TEMPORAL,
+            regex: /\b(last week|last month|last year|last time)\b/i,
+            confidence: 0.95,
+            label: "temporal_specific"
+        },
+        {
+            type: QueryType.TEMPORAL,
+            regex: /\b(yesterday|recently|earlier)\b/i,
+            confidence: 0.9,
+            label: "temporal"
+        },
+        {
+            type: QueryType.TEMPORAL,
+            regex: /\bbefore\b/i,
+            confidence: 0.7,
+            label: "temporal_before"
+        },
+        // Factual patterns (WH questions) - after temporal to avoid misclassifying temporal queries
+        {
+            type: QueryType.FACTUAL,
+            regex: /\b(what|who|where)\s+(is|was|are|were)\b/i,
+            confidence: 0.95,
+            label: "factual_wh"
+        },
+        // Preference patterns
+        {
+            type: QueryType.PREFERENCE,
+            regex: /\b(prefer|want|style|favorite)\b/i,
+            confidence: 0.9,
+            label: "preference"
+        },
+        // Note: 'like' as preference is checked but has lower confidence due to ambiguity
+        {
+            type: QueryType.PREFERENCE,
+            regex: /\bhow do i like\b/i,
+            confidence: 0.85,
+            label: "preference_like"
+        },
+        // Project patterns
+        {
+            type: QueryType.PROJECT,
+            regex: /\b(working on|decided|decide|decision)\b/i,
+            confidence: 0.9,
+            label: "project_specific"
+        },
+        {
+            type: QueryType.PROJECT,
+            regex: /\b(project|building|creating|developing)\b/i,
+            confidence: 0.85,
+            label: "project"
+        }
+    ];
+    // Check each pattern in order
+    for (const pattern of patterns) {
+        if (pattern.regex.test(normalizedQuery)) {
+            return {
+                type: pattern.type,
+                confidence: pattern.confidence,
+                matchedPattern: pattern.label
+            };
+        }
+    }
+    // Default to complex query
+    return {
+        type: QueryType.COMPLEX,
+        confidence: 0.5
+    };
+}
+/**
+ * Smart query router following v3.0 plan retrieval strategy
+ *
+ * Routing decision tree:
+ * 1. Check working memory first (5ms, high confidence threshold)
+ * 2. Classify query type with regex
+ * 3. Route to appropriate handler:
+ *    - factual: direct entity lookup
+ *    - preference: preference retrieval
+ *    - project: graph traversal with HippoRAG
+ *    - temporal: time-based filtering
+ *    - skill: skill library search
+ *    - complex: hybrid search (dense + sparse + BM25)
+ *
+ * @param query - The user's query string
+ * @param context - Routing context (user, conversation, etc.)
+ * @returns Promise resolving to array of memory results
+ *
+ * @throws Error if query is empty or context is invalid
+ */
+export async function retrieve(query, context) {
+    // Input validation
+    if (!query || query.trim().length === 0) {
+        throw new Error("Query cannot be empty");
+    }
+    if (!context || !context.userId) {
+        throw new Error("Valid routing context with userId is required");
+    }
+    // Step 1: ALWAYS check working memory first (5ms fast path)
+    const recentMemories = await checkWorkingMemory(query, context);
+    // High similarity threshold suggests cache hit - return immediately
+    if (recentMemories.length > 0 && recentMemories[0].similarity > 0.85) {
+        console.debug(`[Router] Cache hit in working memory for query: "${query}"`);
+        return recentMemories;
+    }
+    // Step 2: Classify query type using regex patterns
+    const classification = classifyQuery(query);
+    console.debug(`[Router] Query classified as ${classification.type} ` +
+        `(confidence: ${classification.confidence}, pattern: ${classification.matchedPattern})`);
+    // Step 3: Route to appropriate handler based on classification
+    let results = [];
+    switch (classification.type) {
+        case QueryType.FACTUAL:
+            results = await handleFactualQuery(query, context);
+            break;
+        case QueryType.PREFERENCE:
+            results = await handlePreferenceQuery(query, context);
+            break;
+        case QueryType.PROJECT:
+            results = await handleProjectQuery(query, context);
+            break;
+        case QueryType.TEMPORAL:
+            results = await handleTemporalQuery(query, context);
+            break;
+        case QueryType.SKILL:
+            results = await handleSkillQuery(query, context);
+            break;
+        case QueryType.COMPLEX:
+        default:
+            results = await handleComplexQuery(query, context);
+            break;
+    }
+    return results;
+}
+/**
+ * Check working memory for recent relevant memories
+ *
+ * Implementation stub - will integrate with Redis/Hopfield layer
+ * Current behavior: returns empty array (no working memory yet)
+ *
+ * @param query - Search query
+ * @param context - Routing context
+ * @returns Recent memory results matching query
+ */
+async function checkWorkingMemory(query, _context) {
+    console.debug(`[Router] Checking working memory for: "${query}"`);
+    // Early return if working memory not available
+    if (!workingMemoryLayer) {
+        console.debug(`[Router] Working memory layer not initialized`);
+        return [];
+    }
+    try {
+        // Search working memory using keyword matching (5ms fast path)
+        const results = await workingMemoryLayer.search(query, 3);
+        // Transform to MemoryResult format
+        return results.map(r => ({
+            id: r.memory.conversationId,
+            source: "working",
+            content: r.memory.fullText,
+            similarity: r.similarity,
+            timestamp: r.memory.timestamp,
+        }));
+    }
+    catch (err) {
+        console.error(`[Router] Working memory search error:`, err);
+        return [];
+    }
+}
+/**
+ * Handle factual queries
+ *
+ * Pattern: "What is X?", "Who is Y?", "Where is Z?"
+ * Handler: Direct entity lookup in semantic memory
+ *
+ * Implementation stub
+ *
+ * @param query - The factual query
+ * @param context - Routing context
+ * @returns Entity information
+ */
+async function handleFactualQuery(query, _context) {
+    console.debug(`[Router] Handling factual query: "${query}"`);
+    // TODO: Implement factual query handler
+    // 1. Extract entity name from query (using NER or simple heuristics)
+    // 2. Lookup entity in semantic memory
+    // 3. Retrieve related facts and properties
+    // 4. Return with confidence scores
+    return [];
+}
+/**
+ * Handle preference queries
+ *
+ * Pattern: "How do I prefer X?", "What style do I like?"
+ * Handler: Optimized direct SQLite lookup with temporal decay
+ *
+ * This function uses direct database queries instead of embedding generation
+ * for improved latency (~50ms vs ~200ms).
+ *
+ * @param query - The preference query
+ * @param context - Routing context
+ * @returns User preference information
+ */
+async function handlePreferenceQuery(query, context) {
+    return handlePreferenceQueryDirect(query, context);
+}
+/**
+ * Handle project queries
+ *
+ * Pattern: "What did we decide about X?", "What's the status on Y?"
+ * Handler: Graph traversal with HippoRAG personalized PageRank
+ *
+ * Implementation stub
+ *
+ * @param query - The project query
+ * @param context - Routing context
+ * @returns Project-related information via graph traversal
+ */
+async function handleProjectQuery(query, _context) {
+    console.debug(`[Router] Handling project query: "${query}"`);
+    // TODO: Implement project query handler
+    // 1. Extract project entity name from query
+    // 2. Lookup project entity in semantic memory
+    // 3. Run HippoRAG personalized PageRank from project node (depth=2)
+    // 4. Return connected entities and relationships
+    return [];
+}
+/**
+ * Handle temporal queries
+ *
+ * Pattern: "What were we working on last week?", "What was discussed yesterday?"
+ * Handler: Time-based filtering from semantic memory
+ *
+ * Implementation stub
+ *
+ * @param query - The temporal query
+ * @param context - Routing context
+ * @returns Memories from specified time range
+ */
+async function handleTemporalQuery(query, _context) {
+    console.debug(`[Router] Handling temporal query: "${query}"`);
+    // TODO: Implement temporal query handler
+    // 1. Parse temporal references from query
+    // 2. Convert to time range (start_date, end_date)
+    // 3. Query semantic memory for memories in that range
+    // 4. Apply temporal decay based on specificity
+    return [];
+}
+/**
+ * Handle skill queries
+ *
+ * Pattern: "Analyze this like before", "Same way as last time"
+ * Handler: Skill library semantic search
+ *
+ * Implementation stub
+ *
+ * @param query - The skill query
+ * @param context - Routing context
+ * @returns Matching skills from skill library
+ */
+async function handleSkillQuery(query, _context) {
+    console.debug(`[Router] Handling skill query: "${query}"`);
+    // TODO: Implement skill query handler
+    // 1. Embed query using BGE-large
+    // 2. Search skill library for matching triggers
+    // 3. Filter by prerequisites being met in context
+    // 4. Return skills ranked by success rate
+    return [];
+}
+/**
+ * Handle complex queries
+ *
+ * Pattern: Ambiguous queries that don't match specific patterns
+ * Handler: Hybrid search across all representations
+ *
+ * Hybrid search pipeline:
+ * 1. Parallel search: dense embeddings + sparse vectors + BM25
+ * 2. Reciprocal Rank Fusion (k=60) to combine results
+ * 3. Light reranking with cross-encoder on top-10
+ * 4. Return top-5 fused results
+ *
+ * Implementation stub
+ *
+ * @param query - The complex query
+ * @param context - Routing context
+ * @returns Hybrid search results
+ */
+async function handleComplexQuery(query, _context) {
+    console.debug(`[Router] Handling complex query with hybrid search: "${query}"`);
+    // TODO: Implement hybrid search
+    // 1. Embed query in multiple representations:
+    //    - Dense: BGE-large embeddings
+    //    - Sparse: SPLADE++ sparse vectors
+    //    - Keyword: BM25 tokenization
+    //
+    // 2. Parallel search in Qdrant:
+    //    - Dense similarity search (limit: 20)
+    //    - Sparse similarity search (limit: 20)
+    //    - BM25 full-text search (limit: 20)
+    //
+    // 3. Reciprocal Rank Fusion:
+    //    - Combine ranked lists from three searches
+    //    - Weight scores using RRF formula with k=60
+    //
+    // 4. Light reranking:
+    //    - Use cross-encoder (not ColBERT for speed)
+    //    - Rerank only top-10 results
+    //    - Adds ~20ms but significant accuracy gain
+    //
+    // 5. Return top-5 after reranking
+    return [];
+}
+/**
+ * Extract entity name from a query
+ *
+ * Implementation stub for entity extraction
+ * Will later integrate with NER or simple heuristics
+ */
+export function extractEntityName(_query) {
+    // TODO: Implement entity extraction
+    // Current: just return null
+    return null;
+}
+/**
+ * Extract domain/category from a query
+ *
+ * Delegates to extractPreferenceDomain for preference queries.
+ * Used for preference and skill queries.
+ *
+ * @param query - The query string
+ * @returns Extracted domain (lowercase) or null if not extractable
+ */
+export function extractDomain(query) {
+    return extractPreferenceDomain(query);
+}
+export function parseTimeRange(_query) {
+    // TODO: Implement temporal reference parsing
+    // Current: just return null
+    return null;
+}
+/**
+ * Extract preference domain from a query using regex patterns
+ *
+ * Patterns recognized:
+ * - "my X style" -> X (coding, writing, etc.)
+ * - "favorite X" -> X (language, framework, etc.)
+ * - "prefer X" -> X (TypeScript, tabs, etc.)
+ * - "like my X" -> X (coffee, code, etc.)
+ *
+ * @param query - The preference query
+ * @returns Extracted domain (lowercase) or null if not extractable
+ */
+export function extractPreferenceDomain(query) {
+    const normalizedQuery = query.toLowerCase().trim();
+    // Pattern definitions for domain extraction
+    // Each pattern has a capture group for the domain noun
+    // NOTE: Order matters - more specific patterns should come before generic ones
+    const patterns = [
+        // "my X style" pattern - captures word before "style"
+        /\bmy\s+(\w+)\s+style\b/i,
+        // "favorite X" pattern - captures word after "favorite"
+        /\bfavorite\s+(\w+)\b/i,
+        // "prefer my X" pattern - captures word after "my" (more specific than "prefer X")
+        /\bprefer\s+my\s+(\w+)\b/i,
+        // "prefer X" or "prefer X or Y" pattern - captures first word after "prefer"
+        /\bprefer\s+(\w+)\b/i,
+        // "like my X" pattern - captures word after "my"
+        /\blike\s+my\s+(\w+)\b/i,
+        // "my X formatted" or "my X preferences" pattern
+        /\bmy\s+(\w+)\s+(formatted|preference|preferences)\b/i,
+        // "X preference" pattern - captures word before "preference"
+        /\b(\w+)\s+preference\b/i,
+    ];
+    for (const pattern of patterns) {
+        const match = normalizedQuery.match(pattern);
+        if (match && match[1]) {
+            return match[1].toLowerCase();
+        }
+    }
+    return null;
+}
+/**
+ * Initialize the preference handler with semantic memory dependency
+ *
+ * @param semanticMemory - SemanticMemoryLayer instance for preference lookups
+ */
+export function initPreferenceHandler(semanticMemory) {
+    semanticMemoryLayer = semanticMemory;
+}
+/**
+ * Calculate temporal decay weight using exponential formula
+ *
+ * Decay formula: weight = e^(-days/30)
+ * - Decays to 50% in ~21 days
+ * - Decays to 10% in ~69 days
+ *
+ * @param lastAccessed - Date when the preference was last accessed
+ * @returns Weight between 0 and 1
+ */
+function calculateTemporalDecay(lastAccessed) {
+    const lastAccessedDate = typeof lastAccessed === 'string'
+        ? new Date(lastAccessed)
+        : lastAccessed;
+    const now = new Date();
+    const daysSinceAccess = (now.getTime() - lastAccessedDate.getTime()) / (1000 * 60 * 60 * 24);
+    // Exponential decay with 30-day half-life
+    return Math.exp(-daysSinceAccess / 30);
+}
+/**
+ * Direct preference query handler - optimized for low latency
+ *
+ * This handler bypasses embedding generation by using direct SQLite lookup:
+ * 1. Extract preference domain from query using regex
+ * 2. Query semantic memory with domain filter (or get all preferences)
+ * 3. Apply temporal decay weighting to prioritize recent preferences
+ * 4. Return results sorted by weighted score
+ *
+ * Performance target: <50ms (vs ~200ms for embedding-based search)
+ *
+ * @param query - The preference query
+ * @param _context - Routing context (userId, etc.)
+ * @returns Array of MemoryResult objects
+ */
+export async function handlePreferenceQueryDirect(query, _context) {
+    console.debug(`[Router] Handling preference query (optimized): "${query}"`);
+    if (!semanticMemoryLayer) {
+        console.debug(`[Router] Semantic memory layer not initialized for preference queries`);
+        return [];
+    }
+    // Step 1: Extract domain from query
+    const domain = extractPreferenceDomain(query);
+    console.debug(`[Router] Extracted preference domain: ${domain || 'none'}`);
+    // Step 2: Get preferences from semantic memory (filtered by domain if available)
+    const preferences = semanticMemoryLayer.getPreferences(domain || undefined);
+    if (preferences.length === 0) {
+        console.debug(`[Router] No preferences found for domain: ${domain || 'all'}`);
+        return [];
+    }
+    // Step 3: Apply temporal decay weighting and transform to MemoryResult
+    const weightedResults = preferences.map((pref) => {
+        const decayWeight = calculateTemporalDecay(pref.last_accessed || pref.created_at);
+        const confidenceWeight = pref.confidence || 1.0;
+        // Combined score: temporal decay * confidence
+        const similarity = decayWeight * confidenceWeight;
+        return {
+            id: pref.id,
+            source: "semantic",
+            content: pref.description || pref.name,
+            similarity,
+            timestamp: new Date(pref.last_accessed || pref.created_at),
+            confidence: pref.confidence
+        };
+    });
+    // Step 4: Sort by similarity (descending) and return
+    return weightedResults.sort((a, b) => b.similarity - a.similarity);
+}
+//# sourceMappingURL=smart-router.js.map

package/dist/router/smart-router.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"smart-router.js","sourceRoot":"","sources":["../../src/router/smart-router.ts"],"names":[],"mappings":"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"}

package/dist/router 2/smart-router.d.ts

@@ -0,0 +1,111 @@
+/**
+ * Smart Query Router
+ *
+ * Implements intelligent routing logic from v3.0 plan:
+ * 1. Always check working memory first (fast path)
+ * 2. Classify query type using regex patterns
+ * 3. Route to appropriate handler based on classification
+ * 4. Fall back to hybrid search for complex queries
+ */
+/**
+ * Query type enumeration
+ * Used to classify queries and route to appropriate handlers
+ */
+export declare enum QueryType {
+    FACTUAL = "factual",
+    PREFERENCE = "preference",
+    PROJECT = "project",
+    TEMPORAL = "temporal",
+    SKILL = "skill",
+    COMPLEX = "complex"
+}
+/**
+ * Query classification result
+ */
+export interface ClassificationResult {
+    type: QueryType;
+    confidence: number;
+    matchedPattern?: string;
+}
+/**
+ * Context for routing decisions
+ */
+export interface RoutingContext {
+    userId: string;
+    conversationId: string;
+    timestamp: Date;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Memory result from any layer
+ */
+export interface MemoryResult {
+    id: string;
+    source: "working" | "semantic" | "procedural" | "hybrid";
+    content: string;
+    similarity: number;
+    timestamp: Date;
+    confidence?: number;
+}
+/**
+ * Classify a query into one of the six query types
+ *
+ * Uses simple regex patterns to identify query intent without LLM calls.
+ * Falls back to 'complex' for ambiguous queries.
+ *
+ * Patterns (in order of specificity):
+ * - skill: "like before", "same as", "same way", "how you", "analyze"
+ * - factual: "what is", "who is", "where is"
+ * - temporal: "last week", "yesterday", "recently", etc.
+ * - preference: "prefer", "want", "style", "favorite"
+ * - project: "project", "working on", "decided", "building", "creating", "developing"
+ * - complex: fallback for anything else
+ */
+export declare function classifyQuery(query: string): ClassificationResult;
+/**
+ * Smart query router following v3.0 plan retrieval strategy
+ *
+ * Routing decision tree:
+ * 1. Check working memory first (5ms, high confidence threshold)
+ * 2. Classify query type with regex
+ * 3. Route to appropriate handler:
+ *    - factual: direct entity lookup
+ *    - preference: preference retrieval
+ *    - project: graph traversal with HippoRAG
+ *    - temporal: time-based filtering
+ *    - skill: skill library search
+ *    - complex: hybrid search (dense + sparse + BM25)
+ *
+ * @param query - The user's query string
+ * @param context - Routing context (user, conversation, etc.)
+ * @returns Promise resolving to array of memory results
+ *
+ * @throws Error if query is empty or context is invalid
+ */
+export declare function retrieve(query: string, context: RoutingContext): Promise<MemoryResult[]>;
+/**
+ * Extract entity name from a query
+ *
+ * Implementation stub for entity extraction
+ * Will later integrate with NER or simple heuristics
+ */
+export declare function extractEntityName(query: string): string | null;
+/**
+ * Extract domain/category from a query
+ *
+ * Implementation stub for domain extraction
+ * Used for preference and skill queries
+ */
+export declare function extractDomain(query: string): string | null;
+/**
+ * Parse temporal references from query
+ *
+ * Implementation stub for temporal parsing
+ * Will extract time ranges like "last week", "yesterday", etc.
+ */
+export interface TimeRange {
+    startDate: Date;
+    endDate: Date;
+}
+export declare function parseTimeRange(query: string): TimeRange | null;
+//# sourceMappingURL=smart-router.d.ts.map

package/dist/router 2/smart-router.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"smart-router.d.ts","sourceRoot":"","sources":["../../src/router/smart-router.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH;;;GAGG;AACH,oBAAY,SAAS;IACnB,OAAO,YAAY;IACnB,UAAU,eAAe;IACzB,OAAO,YAAY;IACnB,QAAQ,aAAa;IACrB,KAAK,UAAU;IACf,OAAO,YAAY;CACpB;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,SAAS,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,cAAc,EAAE,MAAM,CAAC;IACvB,SAAS,EAAE,IAAI,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACpC;AAED;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,SAAS,GAAG,UAAU,GAAG,YAAY,GAAG,QAAQ,CAAC;IACzD,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,IAAI,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,oBAAoB,CA0FjE;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAsB,QAAQ,CAC5B,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,cAAc,GACtB,OAAO,CAAC,YAAY,EAAE,CAAC,CAyDzB;AAmND;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAI9D;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAI1D;AAED;;;;;GAKG;AACH,MAAM,WAAW,SAAS;IACxB,SAAS,EAAE,IAAI,CAAC;IAChB,OAAO,EAAE,IAAI,CAAC;CACf;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,CAI9D"}