Merge pull request #711 from terraphim/task/82-correction-event

feat(learnings): add CorrectionEvent for user corrections

Author: AlexMikhalev

.cachebro/cache.db

@@ -31,7 +31,8 @@ mod procedure;
 mod redaction;
 
 pub use capture::{
-    LearningSource, capture_failed_command, correct_learning, list_learnings, query_learnings,
+    CorrectionType, LearningSource, capture_correction, capture_failed_command, correct_learning,
+    list_all_entries, query_all_entries,
 };
 
 // Re-export for testing - not used by CLI yet

.cachebro/cache.db-shm

@@ -759,6 +759,24 @@ enum LearnSub {
         #[arg(long)]
         correction: String,
     },
+    /// Record a user correction (tool preference, naming, workflow, etc.)
+    Correction {
+        /// What the agent said/did originally
+        #[arg(long)]
+        original: String,
+        /// What the user said instead
+        #[arg(long)]
+        corrected: String,
+        /// Type of correction
+        #[arg(long, default_value = "other")]
+        correction_type: String,
+        /// Context description
+        #[arg(long, default_value = "")]
+        context: String,
+        /// Session ID for traceability
+        #[arg(long)]
+        session_id: Option<String>,
+    },
     /// Process hook input from AI agents (reads JSON from stdin)
     Hook {
         /// AI agent format
@@ -1936,8 +1954,8 @@ async fn run_offline_command(
 
 async fn run_learn_command(sub: LearnSub) -> Result<()> {
     use learnings::{
-        LearningCaptureConfig, capture_failed_command, correct_learning, list_learnings,
-        query_learnings,
+        CorrectionType, LearningCaptureConfig, capture_correction, capture_failed_command,
+        correct_learning, list_all_entries, query_all_entries,
     };
     let config = LearningCaptureConfig::default();
 
@@ -1974,25 +1992,19 @@ async fn run_learn_command(sub: LearnSub) -> Result<()> {
             } else {
                 &storage_loc
             };
-            match list_learnings(storage_dir, recent) {
-                Ok(learnings) => {
-                    if learnings.is_empty() {
+            match list_all_entries(storage_dir, recent) {
+                Ok(entries) => {
+                    if entries.is_empty() {
                         println!("No learnings found.");
                     } else {
                         println!("Recent learnings:");
-                        for (i, learning) in learnings.iter().enumerate() {
-                            let source_indicator = match learning.source {
+                        for (i, entry) in entries.iter().enumerate() {
+                            let source_indicator = match entry.source() {
                                 learnings::LearningSource::Project => "[P]",
                                 learnings::LearningSource::Global => "[G]",
                             };
-                            println!(
-                                "  {}. {} {} (exit: {})",
-                                i + 1,
-                                source_indicator,
-                                learning.command,
-                                learning.exit_code
-                            );
-                            if let Some(ref correction) = learning.correction {
+                            println!("  {}. {} {}", i + 1, source_indicator, entry.summary());
+                            if let Some(correction) = entry.correction_text() {
                                 println!("     Correction: {}", correction);
                             }
                         }
@@ -2013,22 +2025,19 @@ async fn run_learn_command(sub: LearnSub) -> Result<()> {
             } else {
                 &storage_loc
             };
-            match query_learnings(storage_dir, &pattern, exact) {
-                Ok(learnings) => {
-                    if learnings.is_empty() {
+            match query_all_entries(storage_dir, &pattern, exact) {
+                Ok(entries) => {
+                    if entries.is_empty() {
                         println!("No learnings matching '{}'.", pattern);
                     } else {
-                        println!("Learnings matching '{}':", pattern);
-                        for learning in learnings {
-                            let source_indicator = match learning.source {
+                        println!("Learnings matching '{}'.", pattern);
+                        for entry in entries {
+                            let source_indicator = match entry.source() {
                                 learnings::LearningSource::Project => "[P]",
                                 learnings::LearningSource::Global => "[G]",
                             };
-                            println!(
-                                "  {} {} (exit: {})",
-                                source_indicator, learning.command, learning.exit_code
-                            );
-                            if let Some(ref correction) = learning.correction {
+                            println!("  {} {}", source_indicator, entry.summary());
+                            if let Some(correction) = entry.correction_text() {
                                 println!("     Correction: {}", correction);
                             }
                         }
@@ -2051,6 +2060,33 @@ async fn run_learn_command(sub: LearnSub) -> Result<()> {
                 }
             }
         }
+        LearnSub::Correction {
+            original,
+            corrected,
+            correction_type,
+            context,
+            session_id,
+        } => {
+            let ct: CorrectionType = correction_type
+                .parse()
+                .unwrap_or(CorrectionType::Other(correction_type.clone()));
+            let correction = capture_correction(ct, &original, &corrected, &context, &config);
+            if let Some(ref sid) = session_id {
+                // We need to read the file and update it with session_id
+                // For now, just print the session_id
+                log::info!("Session ID: {}", sid);
+            }
+            match correction {
+                Ok(path) => {
+                    println!("Captured correction: {}", path.display());
+                    Ok(())
+                }
+                Err(e) => {
+                    eprintln!("Failed to capture correction: {}", e);
+                    Err(e.into())
+                }
+            }
+        }
         LearnSub::Hook { format } => learnings::process_hook_input(format)
             .await
             .map_err(|e| e.into()),

.cachebro/cache.db-wal

@@ -39,8 +39,9 @@ async fn start_test_server() -> Result<(Child, String)> {
 
     // Use absolute path for config to work in CI
     let workspace_root = get_workspace_root()?;
-    let config_path = workspace_root.join("terraphim_server/default/terraphim_engineer_config.json");
-    
+    let config_path =
+        workspace_root.join("terraphim_server/default/terraphim_engineer_config.json");
+
     println!("Using config path: {}", config_path.display());
 
     let mut server = Command::new("cargo")
@@ -320,19 +321,25 @@ async fn test_end_to_end_server_workflow() -> Result<()> {
     // 3. Test search with server (may fail in CI due to missing KG data or slow indexing)
     let (search_stdout, search_stderr, search_code) =
         run_server_command(&server_url, &["search", "integration test", "--limit", "3"])?;
-    
+
     // In CI, search may fail due to:
     // - KG indexing timeout
     // - Missing KG data (400 Bad Request)
     // Accept both as valid outcomes for CI resilience
-    let search_failed_acceptably = search_stderr.contains("operation timed out") 
+    let search_failed_acceptably = search_stderr.contains("operation timed out")
         || search_stderr.contains("timed out")
         || search_stderr.contains("400 Bad Request")
         || search_stderr.contains("400");
-    
+
     if search_failed_acceptably {
-        println!("✓ Server search failed acceptably (expected in CI): {}", 
-            if search_stderr.contains("400") { "400 Bad Request" } else { "timeout" });
+        println!(
+            "✓ Server search failed acceptably (expected in CI): {}",
+            if search_stderr.contains("400") {
+                "400 Bad Request"
+            } else {
+                "timeout"
+            }
+        );
     } else if search_code != 0 {
         println!("Search stdout: {}", search_stdout);
         println!("Search stderr: {}", search_stderr);
@@ -348,14 +355,18 @@ async fn test_end_to_end_server_workflow() -> Result<()> {
             &server_url,
             &["search", "test", "--role", test_role, "--limit", "2"],
         )?;
-        
-        let search_role_failed_acceptably = search_role_stderr.contains("operation timed out") 
+
+        let search_role_failed_acceptably = search_role_stderr.contains("operation timed out")
             || search_role_stderr.contains("timed out")
             || search_role_stderr.contains("400 Bad Request")
             || search_role_stderr.contains("400");
-        
+
         if search_role_failed_acceptably {
-            let reason = if search_role_stderr.contains("400") { "400 Bad Request" } else { "timeout" };
+            let reason = if search_role_stderr.contains("400") {
+                "400 Bad Request"
+            } else {
+                "timeout"
+            };
             println!(
                 "✓ Server search with role override '{}' failed acceptably ({})",
                 test_role, reason
@@ -710,16 +721,20 @@ async fn test_full_feature_matrix() -> Result<()> {
             // - KG indexing timeout
             // - Missing KG data (400 Bad Request)
             // Accept both as valid outcomes for CI resilience
-            let failed_acceptably = stderr.contains("operation timed out") 
+            let failed_acceptably = stderr.contains("operation timed out")
                 || stderr.contains("timed out")
                 || stderr.contains("400 Bad Request")
                 || stderr.contains("400");
 
             if test_name == "graph" || test_name == "search" {
                 if failed_acceptably {
-                    let reason = if stderr.contains("400") { "400 Bad Request" } 
-                                 else if stderr.contains("404") { "404 Not Found" }
-                                 else { "timeout" };
+                    let reason = if stderr.contains("400") {
+                        "400 Bad Request"
+                    } else if stderr.contains("404") {
+                        "404 Not Found"
+                    } else {
+                        "timeout"
+                    };
                     println!("  ✓ {}: failed acceptably ({})", test_name, reason);
                 } else if test_name == "graph" && stderr.contains("404") {
                     println!("  ✓ {}: unsupported (404)", test_name);