refactor and deduplicate

Author: dineshdb

Cargo.lock

@@ -40,7 +40,7 @@ reqwest = { version = "0.13", features = ["json"] }
 schemars = "1"
 serde.workspace = true
 serde_json.workspace = true
-serde_yml = "0.0.12"
+serde_yaml = "0.9"
 strum = { version = "0.28", features = ["derive"] }
 tachyonfx = "0.25"
 tokio = { version = "1", features = ["rt-multi-thread", "macros", "process", "io-util", "io-std", "sync"] }

Cargo.toml

@@ -74,7 +74,7 @@ fn parse_agent(raw: &str, filename: &str) -> Option<Agent> {
     let meta: AgentFrontmatter = if yaml.is_empty() {
         AgentFrontmatter::default()
     } else {
-        serde_yml::from_str(&yaml).unwrap_or_default()
+        serde_yaml::from_str(&yaml).unwrap_or_default()
     };
     let name = meta.name.map_or_else(
         || {

src/agent/definition.rs

@@ -430,7 +430,10 @@ pub fn extract_output_text(text: &str, tool_results: Option<&[ToolResultInfo]>)
         let subagent_res = tool_results.and_then(|results| {
             results
                 .iter()
-                .rfind(|r| r.tool.name == "subagent")
+                .rfind(|r| {
+                    crate::tools::ToolName::from_str_lossy(&r.tool.name)
+                        == Some(crate::tools::ToolName::Subagent)
+                })
                 .and_then(|r| r.output.as_ref().ok()?.as_str())
         });
 
@@ -446,7 +449,10 @@ pub fn extract_output_text(text: &str, tool_results: Option<&[ToolResultInfo]>)
         .and_then(|results| {
             results
                 .iter()
-                .rfind(|r| r.tool.name == "shell")
+                .rfind(|r| {
+                    crate::tools::ToolName::from_str_lossy(&r.tool.name)
+                        == Some(crate::tools::ToolName::Shell)
+                })
                 .or_else(|| results.last())?
                 .output
                 .as_ref()
@@ -542,7 +548,8 @@ impl<'a> StreamProcessor<'a> {
                     .to_string();
                 let output_str = anonymize_path(&output_str);
 
-                let is_plan_tool = name == "plan_set" || name == "plan_step_update";
+                let tool = crate::tools::ToolName::from_str_lossy(&name);
+                let is_plan_tool = tool.is_some_and(crate::tools::ToolName::is_plan_tool);
                 if is_plan_tool {
                     let _ = self.event_tx.send(AgentEvent::PlanUpdate);
                 }

src/agent/engine.rs

@@ -65,60 +65,9 @@ pub fn load_config() -> anyhow::Result<PieConfig> {
         .extract()
         .map_err(|e| anyhow::anyhow!("config parse error: {e}"))?;
 
-    // Modular Hook Loading from plugins directory
-    let mut scan_dirs = Vec::new();
-    scan_dirs.push(global_home.join("plugins"));
-    if let Some(root) = &project_root {
-        scan_dirs.push(root.join(".pie").join("plugins"));
-    }
-
-    for dir in scan_dirs {
-        if !dir.exists() {
-            continue;
-        }
-
-        if let Ok(entries) = std::fs::read_dir(&dir) {
-            for entry in entries.flatten() {
-                let path = entry.path();
-
-                if path.is_dir() {
-                    let plugin_toml = path.join("plugin.toml");
-                    if plugin_toml.exists()
-                        && let Ok(content) = std::fs::read_to_string(&plugin_toml)
-                        && let Ok(mut plugin_config) = Figment::new()
-                            .merge(Toml::string(&content))
-                            .extract::<PieConfig>()
-                    {
-                        let plugin_dir_str = path.to_string_lossy().to_string();
-                        for hook in &mut plugin_config.hooks {
-                            hook.plugin_dir = Some(plugin_dir_str.clone());
-                            if hook.handler.starts_with("./") {
-                                let abs_handler = path
-                                    .join(&hook.handler)
-                                    .canonicalize()
-                                    .unwrap_or_else(|_| path.join(&hook.handler));
-                                hook.handler = abs_handler.to_string_lossy().to_string();
-                            }
-                        }
-                        pie_config.hooks.extend(plugin_config.hooks);
-                        if let Some(to) = plugin_config.hooks_timeout_ms {
-                            pie_config.hooks_timeout_ms = Some(to);
-                        }
-                    }
-                } else if path.extension().and_then(|s| s.to_str()) == Some("toml")
-                    && let Ok(content) = std::fs::read_to_string(&path)
-                    && let Ok(plugin_config) = Figment::new()
-                        .merge(Toml::string(&content))
-                        .extract::<PieConfig>()
-                {
-                    pie_config.hooks.extend(plugin_config.hooks);
-                    if let Some(to) = plugin_config.hooks_timeout_ms {
-                        pie_config.hooks_timeout_ms = Some(to);
-                    }
-                }
-            }
-        }
-    }
+    // Load hooks from plugin directories.
+    let (plugin_hooks, _) = crate::plugin::scan_plugins();
+    pie_config.hooks.extend(plugin_hooks);
 
     Ok(pie_config)
 }

src/config/loader.rs

@@ -254,7 +254,7 @@ impl Hook {
         let stderr = String::from_utf8_lossy(&output.stderr).trim().to_string();
 
         Ok(HookOutcome::from_cmd(
-            &hook_name, exit_code, stdout, stderr, context,
+            &hook_name, exit_code, &stdout, &stderr, context,
         ))
     }
 
@@ -501,85 +501,98 @@ impl HookOutcome {
     fn from_cmd(
         name: &str,
         exit_code: Option<i32>,
-        stdout: String,
-        stderr: String,
+        stdout: &str,
+        stderr: &str,
         context: &HookContext,
     ) -> Self {
-        if !stdout.is_empty()
-            && let Ok(json_val) = serde_json::from_str::<serde_json::Value>(&stdout)
-        {
-            let action_res = serde_json::from_value::<ActionOutput>(json_val.clone());
-            if let Ok(action) = action_res {
-                if let Some(decision) = &action.decision {
-                    match decision {
-                        ActionDecision::Block | ActionDecision::Deny => {
-                            return HookOutcome::Error {
-                                name: name.to_string(),
-                                exit_code,
-                                message: format!(
-                                    "Operation blocked by decision:\n{}",
-                                    action.message.unwrap_or(stdout)
-                                ),
-                            };
-                        }
-                        ActionDecision::Allow if action.updated_input.is_none() => {
-                            return HookOutcome::Success;
-                        }
-                        _ => {}
-                    }
-                }
-
-                if let Some(data) = action.updated_input {
-                    return HookOutcome::Transformed {
-                        name: name.to_string(),
-                        data,
-                    };
-                }
-
-                // Return raw JSON as delta — the pipeline handles merging.
-                if context.data.is_tool() || action.decision.is_none() {
-                    return HookOutcome::Transformed {
-                        name: name.to_string(),
-                        data: json_val,
-                    };
-                }
-
-                if matches!(action.decision, Some(ActionDecision::Allow)) {
-                    return HookOutcome::Success;
-                }
-            }
+        // Try parsing stdout as structured action output.
+        if let Some(outcome) = Self::parse_action_response(name, exit_code, stdout, context) {
+            return outcome;
         }
 
-        // Exit-code based fallback
+        // Exit-code based fallback.
         if exit_code == Some(0) {
             return HookOutcome::Success;
         }
 
-        let combined_output = if stderr.is_empty() {
-            stdout
-        } else if stdout.is_empty() {
-            stderr
-        } else {
-            format!("{stdout}\n{stderr}")
+        let combined = match (stdout, stderr) {
+            ("", s) | (s, "") => s.to_string(),
+            (s, e) => format!("{s}\n{e}"),
         };
 
-        let is_rejection = matches!(exit_code, Some(2 | 64 | 65 | 77));
-
-        if is_rejection {
+        if matches!(exit_code, Some(2 | 64 | 65 | 77)) {
             HookOutcome::Error {
                 name: name.to_string(),
                 exit_code,
-                message: format!("Operation blocked:\n{combined_output}"),
+                message: format!("Operation blocked:\n{combined}"),
             }
         } else {
             HookOutcome::Warning {
                 name: name.to_string(),
                 exit_code,
-                message: combined_output,
+                message: combined,
             }
         }
     }
 
+    /// Try to interpret stdout as a structured action response.
+    fn parse_action_response(
+        name: &str,
+        exit_code: Option<i32>,
+        stdout: &str,
+        context: &HookContext,
+    ) -> Option<Self> {
+        if stdout.is_empty() {
+            return None;
+        }
+        let json_val: serde_json::Value = serde_json::from_str(stdout).ok()?;
+        let action: ActionOutput = serde_json::from_value(json_val.clone()).ok()?;
+
+        // Decision-based handling.
+        if let Some(ref decision) = action.decision {
+            match decision {
+                ActionDecision::Block | ActionDecision::Deny => {
+                    return Some(HookOutcome::Error {
+                        name: name.to_string(),
+                        exit_code,
+                        message: format!(
+                            "Operation blocked by decision:\n{}",
+                            action.message.as_deref().unwrap_or(stdout)
+                        ),
+                    });
+                }
+                ActionDecision::Allow if action.updated_input.is_none() => {
+                    return Some(HookOutcome::Success);
+                }
+                ActionDecision::Allow => {
+                    return action.updated_input.map(|data| HookOutcome::Transformed {
+                        name: name.to_string(),
+                        data,
+                    });
+                }
+                ActionDecision::Ask => {}
+            }
+        }
+
+        // Explicit data transform takes priority.
+        if let Some(data) = action.updated_input {
+            return Some(HookOutcome::Transformed {
+                name: name.to_string(),
+                data,
+            });
+        }
+
+        // Return raw JSON as delta for tool contexts or when no decision was made.
+        if context.data.is_tool() || action.decision.is_none() {
+            return Some(HookOutcome::Transformed {
+                name: name.to_string(),
+                data: json_val,
+            });
+        }
+
+        None
+    }
+
     pub fn format(&self) -> String {
         match self {
             HookOutcome::Success => String::new(),

src/hook/types.rs

@@ -16,6 +16,7 @@ mod handler;
 mod hook;
 mod instructions;
 mod output;
+mod plugin;
 mod prompt;
 mod providers;
 mod registry;