feat(agent): wire user-prompt-submit hook into Terraphim AI and OpenCode plugins Refs #674

Author: AlexMikhalev

crates/terraphim_agent/src/learnings/hook.rs

@@ -202,11 +202,11 @@ fn process_user_prompt_submit(json: &str) {
         None => return,
     };
 
-    // Look for correction patterns: "use X instead of Y", "don't use X", "prefer X over Y"
+    // Look for correction patterns: "use X instead of Y", "use X not Y", "prefer X over Y"
     if let Some((original, corrected)) = parse_correction_pattern(prompt) {
         let config = LearningCaptureConfig::default();
         if let Err(e) = crate::learnings::capture_correction(
-            crate::learnings::CorrectionType::Other("user-prompt".to_string()),
+            crate::learnings::CorrectionType::ToolPreference,
             &original,
             &corrected,
             &format!("Auto-captured from user prompt: {}", prompt),
@@ -221,36 +221,59 @@ fn process_user_prompt_submit(json: &str) {
 ///
 /// Supports patterns:
 /// - "use X instead of Y"  -> (Y, X)
+/// - "use X not Y"         -> (Y, X)
 /// - "prefer X over Y"     -> (Y, X)
 ///
 /// Returns None if no pattern matches.
 fn parse_correction_pattern(text: &str) -> Option<(String, String)> {
     let lower = text.to_lowercase();
-
-    // "use X instead of Y"
-    if let Some(use_idx) = lower.find("use ") {
-        if let Some(instead_idx) = lower.find(" instead of ") {
-            let corrected = text[use_idx + 4..instead_idx].trim().to_string();
-            let original = text[instead_idx + 12..]
-                .trim()
-                .trim_end_matches('.')
-                .to_string();
-            if !corrected.is_empty() && !original.is_empty() {
-                return Some((original, corrected));
+    let trimmed = lower.trim_start();
+
+    // "use X instead of Y" (must start with "use")
+    if let Some(use_idx) = trimmed.find("use ") {
+        if use_idx == 0 {
+            let text_after_use =
+                &text[text.to_lowercase().trim_start().find("use ").unwrap() + 4..];
+            let lower_after_use = text_after_use.to_lowercase();
+            if let Some(instead_idx) = lower_after_use.find(" instead of ") {
+                let corrected = text_after_use[..instead_idx].trim().to_string();
+                let original = text_after_use[instead_idx + 12..]
+                    .trim()
+                    .trim_end_matches('.')
+                    .to_string();
+                if !corrected.is_empty() && !original.is_empty() {
+                    return Some((original, corrected));
+                }
+            }
+            // "use X not Y"
+            if let Some(not_idx) = lower_after_use.find(" not ") {
+                let corrected = text_after_use[..not_idx].trim().to_string();
+                let original = text_after_use[not_idx + 5..]
+                    .trim()
+                    .trim_end_matches('.')
+                    .to_string();
+                if !corrected.is_empty() && !original.is_empty() {
+                    return Some((original, corrected));
+                }
             }
         }
     }
 
-    // "prefer X over Y"
-    if let Some(prefer_idx) = lower.find("prefer ") {
-        if let Some(over_idx) = lower.find(" over ") {
-            let corrected = text[prefer_idx + 7..over_idx].trim().to_string();
-            let original = text[over_idx + 6..]
-                .trim()
-                .trim_end_matches('.')
-                .to_string();
-            if !corrected.is_empty() && !original.is_empty() {
-                return Some((original, corrected));
+    // "prefer X over Y" (must start with "prefer")
+    if let Some(prefer_idx) = trimmed.find("prefer ") {
+        if prefer_idx == 0 {
+            let text_after_prefer =
+                &text[text.to_lowercase().trim_start().find("prefer ").unwrap() + 7..];
+            let lower_after_prefer = text_after_prefer.to_lowercase();
+            if let Some(over_idx) = lower_after_prefer.find(" over ") {
+                let corrected = text_after_prefer[..over_idx].trim().to_string();
+                let original = text_after_prefer[over_idx + 6..]
+                    .trim()
+                    .trim_end_matches('.')
+                    .to_string();
+                if !corrected.is_empty() && !original.is_empty() {
+                    return Some((original, corrected));
+                }
             }
         }
     }
@@ -763,10 +786,18 @@ mod tests {
         );
     }
 
+    #[test]
+    fn test_parse_correction_pattern_use_not() {
+        let result = parse_correction_pattern("use uv not pip");
+        assert_eq!(result, Some(("pip".to_string(), "uv".to_string())));
+    }
+
     #[test]
     fn test_parse_correction_pattern_no_match() {
         assert!(parse_correction_pattern("hello world").is_none());
         assert!(parse_correction_pattern("this is fine").is_none());
+        // "I prefer tea over coffee" is a preference, not a tool correction
+        assert!(parse_correction_pattern("I prefer tea over coffee").is_none());
     }
 
     #[test]

crates/terraphim_agent/tests/user_prompt_submit_tests.rs

@@ -0,0 +1,218 @@
+//! Integration tests for user-prompt-submit hook patterns.
+//!
+//! Tests that `terraphim-agent learn hook --learn-hook-type user-prompt-submit`
+//! correctly captures tool preference corrections from user prompts and writes
+//! `CorrectionType::ToolPreference` files.
+
+use std::path::Path;
+use std::process::{Command, Stdio};
+
+fn agent_binary() -> String {
+    let output = Command::new("cargo")
+        .args(["build", "-p", "terraphim_agent"])
+        .output()
+        .expect("cargo build should succeed");
+    if !output.status.success() {
+        panic!(
+            "cargo build failed: {}",
+            String::from_utf8_lossy(&output.stderr)
+        );
+    }
+
+    let workspace_root = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
+        .parent()
+        .unwrap()
+        .parent()
+        .unwrap();
+    workspace_root
+        .join("target/debug/terraphim-agent")
+        .to_string_lossy()
+        .to_string()
+}
+
+/// Run the user-prompt-submit hook with a JSON payload, returning whether it succeeded.
+fn run_user_prompt_submit(binary: &str, prompt: &str, env_home: &str) -> bool {
+    let json = format!(r#"{{"user_prompt":"{}"}}"#, prompt);
+    let output = Command::new(binary)
+        .args(["learn", "hook", "--learn-hook-type", "user-prompt-submit"])
+        .env("HOME", env_home)
+        .env("XDG_DATA_HOME", format!("{}/data", env_home))
+        .stdin(Stdio::piped())
+        .stdout(Stdio::piped())
+        .stderr(Stdio::piped())
+        .spawn()
+        .expect("should spawn hook process")
+        .communicate(json.into_bytes())
+        .expect("should communicate with hook process");
+
+    output.status.success()
+}
+
+trait Communicate {
+    fn communicate(self, stdin: Vec<u8>) -> std::io::Result<std::process::Output>;
+}
+
+impl Communicate for std::process::Child {
+    fn communicate(mut self, stdin: Vec<u8>) -> std::io::Result<std::process::Output> {
+        use std::io::Write;
+        if let Some(mut child_stdin) = self.stdin.take() {
+            child_stdin.write_all(&stdin)?;
+        }
+        self.wait_with_output()
+    }
+}
+
+/// Return all correction markdown files in the learnings directory.
+fn find_correction_files(home: &str) -> Vec<std::path::PathBuf> {
+    let learnings_dir = Path::new(home)
+        .join("data")
+        .join("terraphim")
+        .join("learnings");
+    if !learnings_dir.exists() {
+        return vec![];
+    }
+    std::fs::read_dir(&learnings_dir)
+        .expect("should read learnings dir")
+        .filter_map(|entry| entry.ok().map(|e| e.path()))
+        .filter(|path| {
+            path.file_name()
+                .and_then(|n| n.to_str())
+                .map_or(false, |name| {
+                    name.starts_with("correction-") && name.ends_with(".md")
+                })
+        })
+        .collect()
+}
+
+/// Clear all correction files from a previous test run.
+fn clear_correction_files(home: &str) {
+    for path in find_correction_files(home) {
+        let _ = std::fs::remove_file(path);
+    }
+}
+
+#[test]
+fn user_prompt_submit_use_instead_of_creates_tool_preference() {
+    let binary = agent_binary();
+    let tmp = tempfile::tempdir().expect("create temp dir");
+    let home = tmp.path().to_string_lossy().to_string();
+
+    clear_correction_files(&home);
+    let success = run_user_prompt_submit(&binary, "use uv instead of pip", &home);
+    assert!(success, "hook should exit 0");
+
+    let files = find_correction_files(&home);
+    assert_eq!(
+        files.len(),
+        1,
+        "expected exactly one correction file, found: {:?}",
+        files
+    );
+
+    let content = std::fs::read_to_string(&files[0]).expect("should read correction file");
+    assert!(
+        content.contains("tool-preference"),
+        "correction should be ToolPreference, got:\n{}",
+        content
+    );
+    assert!(
+        content.contains("uv"),
+        "correction should contain corrected tool 'uv', got:\n{}",
+        content
+    );
+    assert!(
+        content.contains("pip"),
+        "correction should contain original tool 'pip', got:\n{}",
+        content
+    );
+}
+
+#[test]
+fn user_prompt_submit_use_not_creates_tool_preference() {
+    let binary = agent_binary();
+    let tmp = tempfile::tempdir().expect("create temp dir");
+    let home = tmp.path().to_string_lossy().to_string();
+
+    clear_correction_files(&home);
+    let success = run_user_prompt_submit(&binary, "use cargo not make", &home);
+    assert!(success, "hook should exit 0");
+
+    let files = find_correction_files(&home);
+    assert_eq!(
+        files.len(),
+        1,
+        "expected exactly one correction file, found: {:?}",
+        files
+    );
+
+    let content = std::fs::read_to_string(&files[0]).expect("should read correction file");
+    assert!(
+        content.contains("tool-preference"),
+        "correction should be ToolPreference, got:\n{}",
+        content
+    );
+    assert!(
+        content.contains("cargo"),
+        "correction should contain corrected tool 'cargo', got:\n{}",
+        content
+    );
+    assert!(
+        content.contains("make"),
+        "correction should contain original tool 'make', got:\n{}",
+        content
+    );
+}
+
+#[test]
+fn user_prompt_submit_prefer_over_creates_tool_preference() {
+    let binary = agent_binary();
+    let tmp = tempfile::tempdir().expect("create temp dir");
+    let home = tmp.path().to_string_lossy().to_string();
+
+    clear_correction_files(&home);
+    let success = run_user_prompt_submit(&binary, "prefer bunx over npx", &home);
+    assert!(success, "hook should exit 0");
+
+    let files = find_correction_files(&home);
+    assert_eq!(
+        files.len(),
+        1,
+        "expected exactly one correction file, found: {:?}",
+        files
+    );
+
+    let content = std::fs::read_to_string(&files[0]).expect("should read correction file");
+    assert!(
+        content.contains("tool-preference"),
+        "correction should be ToolPreference, got:\n{}",
+        content
+    );
+    assert!(
+        content.contains("bunx"),
+        "correction should contain corrected tool 'bunx', got:\n{}",
+        content
+    );
+    assert!(
+        content.contains("npx"),
+        "correction should contain original tool 'npx', got:\n{}",
+        content
+    );
+}
+
+#[test]
+fn user_prompt_submit_personal_preference_does_not_capture() {
+    let binary = agent_binary();
+    let tmp = tempfile::tempdir().expect("create temp dir");
+    let home = tmp.path().to_string_lossy().to_string();
+
+    clear_correction_files(&home);
+    let success = run_user_prompt_submit(&binary, "I prefer tea over coffee", &home);
+    assert!(success, "hook should exit 0 (fail-open)");
+
+    let files = find_correction_files(&home);
+    assert!(
+        files.is_empty(),
+        "personal preference should NOT create a correction file, found: {:?}",
+        files
+    );
+}