feat(phase5-6): Wire metadata boost + cache alignment into FullPipeline

FullPipeline (Phase 1-6 Integration) - FullPipeline: complete orchestration of all phases - PipelineConfig: unified configuration for all phases - PipelineBuilder: fluent API for pipeline construction - EnrichedChunk: fully enriched result with all metadata - PipelineMetrics: comprehensive metrics per phase - 14 unit tests Phase 5 Integration - Query intent inference (FixError, LearnConcept, UseTool, FindReference) - Category-based metadata boost - Intent-category matching for relevance boost Phase 6 Integration - Wiki-distance based cache priority - LRU cache preloading for hot chunks - Cache slot assignment - Phase timing profiling Integration Tests (it_phase5_phase6.rs) - 24 end-to-end tests covering all phases - Metadata boost enable/disable - Cache locality and preload - Edge cases (empty, no matches, unknown intent) Total: 145 tests passing (was 107)
2026-08-31 22:48:42 -07:00
parent cd76424baa
commit 21600c7231
4 changed files with 1452 additions and 13 deletions
@@ -0,0 +1,594 @@
+/// Integration Tests: Phase 5 (Metadata) + Phase 6 (Cache) + Full Pipeline
+///
+/// Tests end-to-end flow with all phases integrated:
+/// 1. Query intent inference
+/// 2. Wiki-scoped + hybrid retrieval
+/// 3. LLM optimization
+/// 4. Metadata boost based on intent-category match
+/// 5. Cache alignment with wiki distances
+
+use std::collections::BTreeMap;
+use std::sync::Arc;
+
+use mem_core::{GlobalTfIdfScorer, SemanticScorer};
+use mem_ingest::wiki_link::WikiLinkGraph;
+use mem_cli::{
+    FullPipeline, PipelineConfig, PipelineBuilder, EnrichedChunk,
+    MetadataExtractor, MetadataBooster, ChunkCategory, QueryIntent,
+    LruChunkCache, KvCacheAligner, CacheLocalityAnalyzer, CacheMetrics,
+};
+
+// ============================================================================
+// Test Fixtures
+// ============================================================================
+
+fn create_test_vocab() -> Arc<BTreeMap<String, f32>> {
+    let mut vocab = BTreeMap::new();
+    vocab.insert("kubernetes".to_string(), 0.8);
+    vocab.insert("pod".to_string(), 0.7);
+    vocab.insert("error".to_string(), 0.95);
+    vocab.insert("crashloopbackoff".to_string(), 1.0);
+    vocab.insert("fix".to_string(), 0.85);
+    vocab.insert("solution".to_string(), 0.8);
+    vocab.insert("debug".to_string(), 0.9);
+    vocab.insert("explain".to_string(), 0.75);
+    vocab.insert("concept".to_string(), 0.7);
+    vocab.insert("api".to_string(), 0.6);
+    Arc::new(vocab)
+}
+
+fn create_test_pipeline() -> FullPipeline {
+    let vocab = create_test_vocab();
+    let tfidf = Arc::new(GlobalTfIdfScorer::new(vocab));
+    let semantic = Arc::new(SemanticScorer::new());
+    FullPipeline::new(tfidf, semantic, PipelineConfig::default())
+}
+
+fn create_test_wiki_graph() -> WikiLinkGraph {
+    let mut graph = WikiLinkGraph::new("poimen");
+    // Build realistic wiki structure
+    graph.add_link("index.md", "tools/kubectl.md");
+    graph.add_link("index.md", "concepts/pods.md");
+    graph.add_link("tools/kubectl.md", "debugging/pod-errors.md");
+    graph.add_link("debugging/pod-errors.md", "solutions/restart-pod.md");
+    graph.add_link("concepts/pods.md", "concepts/lifecycle.md");
+    graph
+}
+
+fn create_diverse_candidates() -> Vec<(String, String)> {
+    vec![
+        // Error category
+        ("debugging/pod-errors.md".to_string(), 
+         "# Pod Errors\n\nError: CrashLoopBackOff when pod fails to start. Check container logs.".to_string()),
+        
+        // Solution category  
+        ("solutions/restart-pod.md".to_string(),
+         "# Restart Pod Solution\n\nTo fix the crashing pod, configure restart policy and check resources.".to_string()),
+        
+        // Tool category
+        ("tools/kubectl.md".to_string(),
+         "# Kubectl Tool\n\nUsage: kubectl get pods\n$ kubectl describe pod <name>\nAPI reference for kubernetes CLI.".to_string()),
+        
+        // Concept category
+        ("concepts/pods.md".to_string(),
+         "# Pod Concepts\n\nA kubernetes pod is the smallest deployable unit. Explain the design pattern.".to_string()),
+        
+        // Reference category
+        ("concepts/lifecycle.md".to_string(),
+         "# Pod Lifecycle Reference\n\nDocumentation and specification for pod states: Pending, Running, Succeeded, Failed.".to_string()),
+        
+        // Index
+        ("index.md".to_string(),
+         "# Kubernetes Guide\n\nMain entry point for kubernetes documentation.".to_string()),
+         
+        // Unrelated (outside wiki scope)
+        ("unrelated/docker.md".to_string(),
+         "# Docker Guide\n\nDocker container basics unrelated to kubernetes.".to_string()),
+    ]
+}
+
+// ============================================================================
+// Phase 5: Metadata Enhancement Tests
+// ============================================================================
+
+#[test]
+fn test_query_intent_inference() {
+    // FixError intents
+    assert_eq!(MetadataExtractor::infer_query_intent("fix pod crash"), QueryIntent::FixError);
+    assert_eq!(MetadataExtractor::infer_query_intent("debug kubernetes error"), QueryIntent::FixError);
+    assert_eq!(MetadataExtractor::infer_query_intent("troubleshoot deployment"), QueryIntent::FixError);
+    
+    // LearnConcept intents
+    assert_eq!(MetadataExtractor::infer_query_intent("explain kubernetes pods"), QueryIntent::LearnConcept);
+    assert_eq!(MetadataExtractor::infer_query_intent("understand deployment patterns"), QueryIntent::LearnConcept);
+    assert_eq!(MetadataExtractor::infer_query_intent("what is a service mesh"), QueryIntent::LearnConcept);
+    
+    // UseTool intents
+    assert_eq!(MetadataExtractor::infer_query_intent("use kubectl api"), QueryIntent::UseTool);
+    assert_eq!(MetadataExtractor::infer_query_intent("run helm command"), QueryIntent::UseTool);
+    assert_eq!(MetadataExtractor::infer_query_intent("call kubernetes api"), QueryIntent::UseTool);
+    
+    // FindReference intents
+    assert_eq!(MetadataExtractor::infer_query_intent("reference for pod spec"), QueryIntent::FindReference);
+    assert_eq!(MetadataExtractor::infer_query_intent("definition of deployment"), QueryIntent::FindReference);
+}
+
+#[test]
+fn test_category_inference() {
+    // Error category
+    let (cat, conf) = MetadataExtractor::infer_category("Error: CrashLoopBackOff exception");
+    assert_eq!(cat, ChunkCategory::Error);
+    assert!(conf >= 0.8);
+    
+    // Solution category
+    let (cat, _) = MetadataExtractor::infer_category("Fix this by configuring the solution");
+    assert_eq!(cat, ChunkCategory::Solution);
+    
+    // Tool category
+    let (cat, _) = MetadataExtractor::infer_category("Usage: kubectl get pods\n$ kubectl apply");
+    assert_eq!(cat, ChunkCategory::Tool);
+    
+    // Concept category
+    let (cat, _) = MetadataExtractor::infer_category("The design pattern explains the principle");
+    assert_eq!(cat, ChunkCategory::Concept);
+    
+    // Reference category
+    let (cat, _) = MetadataExtractor::infer_category("Documentation reference and specification");
+    assert_eq!(cat, ChunkCategory::Reference);
+}
+
+#[test]
+fn test_metadata_extraction_full() {
+    let text = "# Pod Debugging\n\nError: CrashLoopBackOff when kubernetes pod fails.";
+    let metadata = MetadataExtractor::extract("doc1", text);
+    
+    assert_eq!(metadata.chunk_id, "doc1");
+    assert_eq!(metadata.heading, Some("Pod Debugging".to_string()));
+    assert!(!metadata.key_terms.is_empty());
+    assert_eq!(metadata.category, ChunkCategory::Error);
+    assert!(metadata.category_confidence > 0.0);
+}
+
+#[test]
+fn test_metadata_booster_intent_match() {
+    let booster = MetadataBooster::new();
+    
+    // Error chunk + FixError intent = boost
+    let error_metadata = MetadataExtractor::extract("doc1", "Error: pod crash");
+    let boost = booster.calculate_boost(QueryIntent::FixError, &error_metadata);
+    assert!(boost > 0.0, "Error chunk should boost for FixError intent");
+    
+    // Solution chunk + FixError intent = boost
+    let solution_metadata = MetadataExtractor::extract("doc2", "Fix the issue by configuring solution");
+    let boost = booster.calculate_boost(QueryIntent::FixError, &solution_metadata);
+    assert!(boost > 0.0, "Solution chunk should boost for FixError intent");
+    
+    // Concept chunk + LearnConcept intent = boost
+    let concept_metadata = MetadataExtractor::extract("doc3", "Explain the design pattern principle");
+    let boost = booster.calculate_boost(QueryIntent::LearnConcept, &concept_metadata);
+    assert!(boost > 0.0, "Concept chunk should boost for LearnConcept intent");
+    
+    // Tool chunk + UseTool intent = boost
+    let tool_metadata = MetadataExtractor::extract("doc4", "Usage: kubectl get pods\n$ kubectl apply");
+    let boost = booster.calculate_boost(QueryIntent::UseTool, &tool_metadata);
+    assert!(boost > 0.0, "Tool chunk should boost for UseTool intent");
+}
+
+#[test]
+fn test_metadata_booster_intent_mismatch() {
+    let booster = MetadataBooster::new();
+    
+    // Reference chunk + FixError intent = no boost
+    let ref_metadata = MetadataExtractor::extract("doc1", "Documentation reference specification");
+    let boost = booster.calculate_boost(QueryIntent::FixError, &ref_metadata);
+    assert_eq!(boost, 0.0, "Reference chunk should not boost for FixError intent");
+}
+
+#[test]
+fn test_boost_application() {
+    let booster = MetadataBooster::new();
+    
+    // Normal boost
+    let score = booster.apply_boost(0.7, 0.15);
+    assert_eq!(score, 0.85);
+    
+    // Capped at 1.0
+    let score = booster.apply_boost(0.95, 0.2);
+    assert_eq!(score, 1.0);
+    
+    // Zero boost
+    let score = booster.apply_boost(0.7, 0.0);
+    assert_eq!(score, 0.7);
+}
+
+// ============================================================================
+// Phase 6: Cache Alignment Tests
+// ============================================================================
+
+#[test]
+fn test_lru_cache_basic() {
+    let cache = LruChunkCache::new(3);
+    
+    cache.put("chunk1", "content1");
+    cache.put("chunk2", "content2");
+    
+    assert_eq!(cache.get("chunk1"), Some("content1".to_string()));
+    assert_eq!(cache.get("chunk2"), Some("content2".to_string()));
+    assert_eq!(cache.get("nonexistent"), None);
+    
+    let metrics = cache.metrics();
+    assert_eq!(metrics.hits, 2);
+    assert_eq!(metrics.misses, 1);
+}
+
+#[test]
+fn test_lru_cache_eviction() {
+    let cache = LruChunkCache::new(2);
+    
+    cache.put("chunk1", "content1");
+    cache.put("chunk2", "content2");
+    cache.put("chunk3", "content3"); // Should evict chunk1
+    
+    assert_eq!(cache.get("chunk1"), None); // Evicted
+    assert_eq!(cache.get("chunk2"), Some("content2".to_string()));
+    assert_eq!(cache.get("chunk3"), Some("content3".to_string()));
+    
+    assert_eq!(cache.metrics().evictions, 1);
+}
+
+#[test]
+fn test_cache_locality_distance() {
+    let mut graph = std::collections::HashMap::new();
+    graph.insert("root".to_string(), vec!["level1".to_string()]);
+    graph.insert("level1".to_string(), vec!["level2".to_string()]);
+    graph.insert("level2".to_string(), vec!["level3".to_string()]);
+    
+    assert_eq!(CacheLocalityAnalyzer::calculate_distance("root", "root", &graph), 0);
+    assert_eq!(CacheLocalityAnalyzer::calculate_distance("level1", "root", &graph), 1);
+    assert_eq!(CacheLocalityAnalyzer::calculate_distance("level2", "root", &graph), 2);
+    assert_eq!(CacheLocalityAnalyzer::calculate_distance("level3", "root", &graph), 3);
+    assert_eq!(CacheLocalityAnalyzer::calculate_distance("nonexistent", "root", &graph), u32::MAX);
+}
+
+#[test]
+fn test_kv_cache_aligner_slot_assignment() {
+    let aligner = KvCacheAligner::new(4096, 100, 10);
+    
+    let chunks = vec![
+        mem_cli::cache_alignment::CachedChunk {
+            chunk_id: "chunk1".to_string(),
+            text: "content1".to_string(),
+            score: 0.9,
+            cache_distance: 1,
+            access_count: 5,
+            last_accessed_slot: 0,
+        },
+        mem_cli::cache_alignment::CachedChunk {
+            chunk_id: "chunk2".to_string(),
+            text: "content2".to_string(),
+            score: 0.8,
+            cache_distance: 2,
+            access_count: 3,
+            last_accessed_slot: 1,
+        },
+    ];
+    
+    let slots = aligner.assign_slots(&chunks);
+    assert_eq!(slots.len(), 2);
+    assert_eq!(slots[0], ("chunk1".to_string(), 0));
+    assert_eq!(slots[1], ("chunk2".to_string(), 1));
+}
+
+#[test]
+fn test_kv_cache_will_fit() {
+    let aligner = KvCacheAligner::new(1000, 100, 10);
+    
+    assert!(aligner.will_fit(5));   // 500 tokens < 1000
+    assert!(aligner.will_fit(10));  // 1000 tokens = 1000 (fits)
+    assert!(!aligner.will_fit(15)); // 1500 tokens > 1000
+}
+
+// ============================================================================
+// Full Pipeline Integration Tests
+// ============================================================================
+
+#[tokio::test]
+async fn test_full_pipeline_with_wiki() {
+    let pipeline = create_test_pipeline();
+    let graph = create_test_wiki_graph();
+    let candidates = create_diverse_candidates();
+    
+    let result = pipeline
+        .execute_with_wiki("fix kubernetes pod error", &graph, candidates)
+        .await
+        .unwrap();
+    
+    // Query should be classified as FixError
+    assert_eq!(result.query_intent, QueryIntent::FixError);
+    
+    // Should have processed candidates
+    assert!(result.metrics.wiki_scope_docs > 0);
+    
+    // Phase timings should be recorded
+    assert!(!result.metrics.phase_timings.is_empty());
+    
+    // Total latency should be recorded (may be 0 for fast operations)
+    assert!(result.metrics.total_latency_ms >= 0);
+}
+
+#[tokio::test]
+async fn test_full_pipeline_direct() {
+    let pipeline = create_test_pipeline();
+    let candidates = create_diverse_candidates();
+    
+    let result = pipeline
+        .execute_direct("explain kubernetes concepts", candidates)
+        .await
+        .unwrap();
+    
+    // Query should be classified as LearnConcept
+    assert_eq!(result.query_intent, QueryIntent::LearnConcept);
+    
+    // All candidates should be in scope (no wiki filtering)
+    assert!(result.metrics.wiki_scope_docs >= 5);
+}
+
+#[tokio::test]
+async fn test_metadata_boost_integration() {
+    let vocab = create_test_vocab();
+    let tfidf = Arc::new(GlobalTfIdfScorer::new(vocab));
+    let semantic = Arc::new(SemanticScorer::new());
+    
+    let config = PipelineConfig {
+        enable_metadata_boost: true,
+        ..PipelineConfig::default()
+    };
+    
+    let pipeline = FullPipeline::new(tfidf, semantic, config);
+    let candidates = create_diverse_candidates();
+    
+    let result = pipeline
+        .execute_direct("fix pod crash error", candidates)
+        .await
+        .unwrap();
+    
+    // Should have applied metadata boosts
+    // Error/Solution chunks should get boosted for FixError query
+    assert!(result.metrics.metadata_boosts_applied >= 0);
+    
+    // Chunks with boost should have query_intent_match = true
+    for chunk in &result.chunks {
+        if chunk.metadata_boost > 0.0 {
+            assert!(chunk.query_intent_match);
+        }
+    }
+}
+
+#[tokio::test]
+async fn test_metadata_boost_disabled() {
+    let vocab = create_test_vocab();
+    let tfidf = Arc::new(GlobalTfIdfScorer::new(vocab));
+    let semantic = Arc::new(SemanticScorer::new());
+    
+    let config = PipelineConfig {
+        enable_metadata_boost: false,
+        ..PipelineConfig::default()
+    };
+    
+    let pipeline = FullPipeline::new(tfidf, semantic, config);
+    let candidates = create_diverse_candidates();
+    
+    let result = pipeline
+        .execute_direct("fix pod error", candidates)
+        .await
+        .unwrap();
+    
+    // No metadata boosts should be applied
+    assert_eq!(result.metrics.metadata_boosts_applied, 0);
+    assert_eq!(result.metrics.avg_boost, 0.0);
+    
+    // All chunks should have metadata_boost = 0
+    for chunk in &result.chunks {
+        assert_eq!(chunk.metadata_boost, 0.0);
+    }
+}
+
+#[tokio::test]
+async fn test_cache_preload_integration() {
+    let vocab = create_test_vocab();
+    let tfidf = Arc::new(GlobalTfIdfScorer::new(vocab));
+    let semantic = Arc::new(SemanticScorer::new());
+    
+    let config = PipelineConfig {
+        preload_top_k: 3,
+        ..PipelineConfig::default()
+    };
+    
+    let pipeline = FullPipeline::new(tfidf, semantic, config);
+    let candidates = create_diverse_candidates();
+    
+    let result = pipeline
+        .execute_direct("kubernetes", candidates)
+        .await
+        .unwrap();
+    
+    // Should have preloaded up to preload_top_k chunks
+    assert!(result.metrics.preloaded_chunks <= 3);
+}
+
+#[tokio::test]
+async fn test_wiki_distance_in_enriched_chunks() {
+    let pipeline = create_test_pipeline();
+    let graph = create_test_wiki_graph();
+    let candidates = create_diverse_candidates();
+    
+    let result = pipeline
+        .execute_with_wiki("kubernetes", &graph, candidates)
+        .await
+        .unwrap();
+    
+    // Chunks should have wiki_distance populated (within max_hops)
+    for chunk in &result.chunks {
+        if let Some(dist) = chunk.wiki_distance {
+            assert!(dist <= pipeline.config().max_wiki_hops);
+        }
+    }
+}
+
+#[tokio::test]
+async fn test_cache_priority_ordering() {
+    let pipeline = create_test_pipeline();
+    let graph = create_test_wiki_graph();
+    let candidates = create_diverse_candidates();
+    
+    let result = pipeline
+        .execute_with_wiki("kubernetes", &graph, candidates)
+        .await
+        .unwrap();
+    
+    // Cache priority should be positive for all chunks
+    for chunk in &result.chunks {
+        assert!(chunk.cache_priority >= 0.0);
+    }
+    
+    // Higher scoring chunks closer in wiki-graph should have higher priority
+    if result.chunks.len() >= 2 {
+        let priorities: Vec<f32> = result.chunks.iter().map(|c| c.cache_priority).collect();
+        // Just verify priorities are computed, not necessarily ordered
+        // (ordering depends on score * distance factor)
+        assert!(priorities.iter().all(|&p| p >= 0.0));
+    }
+}
+
+#[tokio::test]
+async fn test_pipeline_builder_full() {
+    let vocab = create_test_vocab();
+    let tfidf = Arc::new(GlobalTfIdfScorer::new(vocab));
+    let semantic = Arc::new(SemanticScorer::new());
+    
+    let pipeline = PipelineBuilder::new()
+        .with_scorers(tfidf, semantic)
+        .with_project("test-project")
+        .with_wiki_root("docs/index.md")
+        .with_budget(4096)
+        .with_score_threshold(0.7)
+        .with_metadata_boost(true)
+        .with_cache_capacity(500)
+        .build()
+        .unwrap();
+    
+    assert_eq!(pipeline.config().project, "test-project");
+    assert_eq!(pipeline.config().wiki_root_doc, "docs/index.md");
+    assert_eq!(pipeline.config().budget_bytes, 4096);
+    assert_eq!(pipeline.config().score_threshold, 0.7);
+    assert!(pipeline.config().enable_metadata_boost);
+    assert_eq!(pipeline.config().cache_capacity, 500);
+}
+
+#[tokio::test]
+async fn test_enriched_chunk_all_fields() {
+    let pipeline = create_test_pipeline();
+    let candidates = vec![
+        ("doc1.md".to_string(), "# Error Handling\n\nError: CrashLoopBackOff fix solution.".to_string()),
+    ];
+    
+    let result = pipeline
+        .execute_direct("fix error", candidates)
+        .await
+        .unwrap();
+    
+    if !result.chunks.is_empty() {
+        let chunk = &result.chunks[0];
+        
+        // All fields should be populated
+        assert!(!chunk.id.is_empty());
+        assert!(!chunk.text.is_empty());
+        assert!(chunk.final_score >= 0.0);
+        assert!(chunk.final_score <= 1.0);
+        
+        // Heading should be extracted if present
+        // Category should be inferred
+        assert!(matches!(chunk.category, 
+            ChunkCategory::Error | ChunkCategory::Solution | 
+            ChunkCategory::Tool | ChunkCategory::Concept | 
+            ChunkCategory::Reference | ChunkCategory::Unknown
+        ));
+    }
+}
+
+#[tokio::test]
+async fn test_phase_timing_coverage() {
+    let pipeline = create_test_pipeline();
+    let candidates = create_diverse_candidates();
+    
+    let result = pipeline
+        .execute_direct("test query", candidates)
+        .await
+        .unwrap();
+    
+    let phase_names: Vec<&str> = result.metrics.phase_timings
+        .iter()
+        .map(|(name, _)| name.as_str())
+        .collect();
+    
+    // All phases should be timed
+    assert!(phase_names.contains(&"intent_inference"), "Missing intent_inference timing");
+    assert!(phase_names.contains(&"routing_retrieval"), "Missing routing_retrieval timing");
+    assert!(phase_names.contains(&"metadata_boost"), "Missing metadata_boost timing");
+    assert!(phase_names.contains(&"cache_alignment"), "Missing cache_alignment timing");
+}
+
+// ============================================================================
+// Edge Cases
+// ============================================================================
+
+#[tokio::test]
+async fn test_empty_candidates() {
+    let pipeline = create_test_pipeline();
+    let graph = create_test_wiki_graph();
+    
+    let result = pipeline
+        .execute_with_wiki("query", &graph, vec![])
+        .await
+        .unwrap();
+    
+    assert!(result.chunks.is_empty());
+    assert_eq!(result.metrics.post_optimization_count, 0);
+    assert_eq!(result.metrics.preloaded_chunks, 0);
+}
+
+#[tokio::test]
+async fn test_no_wiki_matches() {
+    let pipeline = create_test_pipeline();
+    let graph = create_test_wiki_graph();
+    
+    // Candidates that don't match wiki graph
+    let candidates = vec![
+        ("orphan1.md".to_string(), "orphan content".to_string()),
+        ("orphan2.md".to_string(), "more orphan content".to_string()),
+    ];
+    
+    let result = pipeline
+        .execute_with_wiki("query", &graph, candidates)
+        .await
+        .unwrap();
+    
+    // Should still complete (graceful handling)
+    assert!(result.metrics.total_latency_ms >= 0);
+    assert!(!result.metrics.phase_timings.is_empty());
+}
+
+#[tokio::test]
+async fn test_unknown_query_intent() {
+    let pipeline = create_test_pipeline();
+    let candidates = create_diverse_candidates();
+    
+    // Ambiguous query
+    let result = pipeline
+        .execute_direct("something random here", candidates)
+        .await
+        .unwrap();
+    
+    // Should default to Unknown intent
+    assert_eq!(result.query_intent, QueryIntent::Unknown);
+}