feat(plugin): implement Phase 4 — hook system complete

Implement all 7 todo!() items across 3 files:

- hook_types.rs: 4 execute_* functions — command hooks delegate to
  crab_process::spawn with env vars (CRAB_HOOK_EVENT, CRAB_TOOL_NAME,
  CRAB_TOOL_INPUT), agent hooks expand prompt templates, HTTP hooks
  use curl subprocess with SSRF validation, prompt hooks expand
  templates for caller LLM dispatch
- hook_watchers.rs: polling-based file watcher with debounce (500ms),
  recursive .md/.json scanning, shutdown signal via tokio::Notify
- frontmatter_hooks.rs: simple YAML parser for skill frontmatter,
  hooks section extraction, async registration with HookRegistry,
  event type mapping (8 event types supported)

hook_registry.rs (531 LOC), hook.rs (874 LOC), and config/hooks.rs
(139 LOC) were already complete.

Author: lingcoder

crates/plugin/src/frontmatter_hooks.rs

@@ -6,12 +6,12 @@
 //!
 //! Maps to CCB `hooks/registerFrontmatterHooks.ts` + `hooks/registerSkillHooks.ts`.
 
-use super::hook_registry::HookRegistry;
+use super::hook_registry::{HookEventType, HookRegistry, HookSource, RegisteredHook};
+use super::hook_types::{CommandHook, HookType, PromptHook};
 
 // ─── Frontmatter hook definition ───────────────────────────────────────
 
 /// A hook definition parsed from a skill file's YAML frontmatter.
-#[allow(dead_code)]
 struct FrontmatterHookDef {
     /// The event this hook responds to (e.g. `pre_tool_use`, `session_start`).
     event: String,
@@ -29,12 +29,6 @@ struct FrontmatterHookDef {
 /// hook definition with the provided [`HookRegistry`]. Returns the IDs of
 /// all successfully registered hooks.
 ///
-/// # Arguments
-///
-/// * `registry` — The hook registry to register hooks with.
-/// * `skill_name` — Name of the skill (used for hook ID prefixing and logging).
-/// * `frontmatter` — Raw YAML frontmatter string (without `---` delimiters).
-///
 /// # Expected frontmatter format
 ///
 /// ```yaml
@@ -44,23 +38,193 @@ struct FrontmatterHookDef {
 ///   - event: session_start
 ///     prompt: "Initialize the session context for {{tool_name}}"
 /// ```
-pub fn register_frontmatter_hooks(
-    _registry: &HookRegistry,
-    _skill_name: &str,
-    _frontmatter: &str,
+pub async fn register_frontmatter_hooks(
+    registry: &HookRegistry,
+    skill_name: &str,
+    frontmatter: &str,
 ) -> Vec<String> {
-    todo!(
-        "register_frontmatter_hooks: parse frontmatter, extract hooks section, register with registry"
-    )
+    // Parse the frontmatter as simple key-value YAML, then extract hooks
+    let yaml_value = parse_simple_yaml_to_json(frontmatter);
+    let hook_defs = parse_hooks_section(&yaml_value);
+
+    let mut registered_ids = Vec::new();
+
+    for def in hook_defs {
+        // Parse the event type
+        let event_filter = parse_event_type(&def.event);
+
+        // Build the HookType from the definition
+        let hook_type = if let Some(ref cmd) = def.command {
+            HookType::Command(CommandHook {
+                command: cmd.clone(),
+                timeout_secs: 10,
+            })
+        } else if let Some(ref prompt) = def.prompt {
+            HookType::Prompt(PromptHook {
+                prompt_template: prompt.clone(),
+            })
+        } else {
+            // Neither command nor prompt — skip
+            continue;
+        };
+
+        let hook = RegisteredHook {
+            id: format!("{skill_name}:{}", def.event),
+            hook_type,
+            event_filter: event_filter.into_iter().collect(),
+            source: HookSource::Frontmatter,
+        };
+
+        let id = registry.register(hook).await;
+        registered_ids.push(id);
+    }
+
+    registered_ids
 }
 
-/// Parse the `hooks` section from frontmatter YAML.
+/// Parse the `hooks` section from frontmatter JSON/YAML value.
 ///
 /// Extracts an array of hook definitions from the JSON representation of
 /// the frontmatter. Returns an empty vec if no `hooks` key is present.
-#[allow(dead_code)]
-fn parse_hooks_section(_yaml: &serde_json::Value) -> Vec<FrontmatterHookDef> {
-    todo!("parse_hooks_section: extract hooks array from YAML value and map to FrontmatterHookDef")
+fn parse_hooks_section(yaml: &serde_json::Value) -> Vec<FrontmatterHookDef> {
+    let Some(hooks_array) = yaml.get("hooks").and_then(|v| v.as_array()) else {
+        return Vec::new();
+    };
+
+    hooks_array
+        .iter()
+        .filter_map(|entry| {
+            let event = entry.get("event")?.as_str()?.to_string();
+            let command = entry
+                .get("command")
+                .and_then(|v| v.as_str())
+                .map(String::from);
+            let prompt = entry
+                .get("prompt")
+                .and_then(|v| v.as_str())
+                .map(String::from);
+
+            // Must have at least one of command or prompt
+            if command.is_none() && prompt.is_none() {
+                return None;
+            }
+
+            Some(FrontmatterHookDef {
+                event,
+                command,
+                prompt,
+            })
+        })
+        .collect()
+}
+
+/// Parse a simple flat YAML string into a JSON Value.
+///
+/// Handles the basic `key: value` and `key:` + array format used in
+/// skill frontmatter. This is not a full YAML parser.
+fn parse_simple_yaml_to_json(yaml: &str) -> serde_json::Value {
+    let mut root = serde_json::Map::new();
+    let mut current_array: Option<(String, Vec<serde_json::Value>)> = None;
+    let mut current_item: Option<serde_json::Map<String, serde_json::Value>> = None;
+
+    for line in yaml.lines() {
+        let trimmed = line.trim();
+        if trimmed.is_empty() || trimmed.starts_with('#') {
+            continue;
+        }
+
+        // Array item: "  - event: pre_tool_use" or "  - event: ..."
+        if let Some(rest) = trimmed.strip_prefix("- ") {
+            // Start a new item in the current array
+            if let Some(ref mut item) = current_item {
+                // Save previous item
+                if let Some((_, ref mut arr)) = current_array {
+                    arr.push(serde_json::Value::Object(item.clone()));
+                }
+            }
+            current_item = Some(serde_json::Map::new());
+
+            // Parse key: value from the rest
+            if let Some((key, value)) = rest.split_once(':') {
+                let key = key.trim();
+                let value = value.trim();
+                if !value.is_empty()
+                    && let Some(ref mut item) = current_item
+                {
+                    item.insert(
+                        key.to_string(),
+                        serde_json::Value::String(value.to_string()),
+                    );
+                }
+            }
+        } else if trimmed.contains(':') && !line.starts_with(' ') && !line.starts_with('\t') {
+            // Top-level key
+            // Flush any current array
+            #[allow(clippy::collapsible_if)]
+            if let Some(ref item) = current_item {
+                if let Some((_, ref mut arr)) = current_array {
+                    arr.push(serde_json::Value::Object(item.clone()));
+                }
+                current_item = None;
+            }
+            if let Some((name, arr)) = current_array.take() {
+                root.insert(name, serde_json::Value::Array(arr));
+            }
+
+            if let Some((key, value)) = trimmed.split_once(':') {
+                let key = key.trim();
+                let value = value.trim();
+                if value.is_empty() {
+                    // Start of an array or nested object
+                    current_array = Some((key.to_string(), Vec::new()));
+                } else {
+                    root.insert(
+                        key.to_string(),
+                        serde_json::Value::String(value.to_string()),
+                    );
+                }
+            }
+        } else if let Some(ref mut item) = current_item {
+            // Continuation of array item properties: "    command: echo check"
+            if let Some((key, value)) = trimmed.split_once(':') {
+                let key = key.trim();
+                let value = value.trim();
+                if !value.is_empty() {
+                    item.insert(
+                        key.to_string(),
+                        serde_json::Value::String(value.to_string()),
+                    );
+                }
+            }
+        }
+    }
+
+    // Flush remaining
+    if let Some(item) = current_item
+        && let Some((_, ref mut arr)) = current_array
+    {
+        arr.push(serde_json::Value::Object(item));
+    }
+    if let Some((name, arr)) = current_array {
+        root.insert(name, serde_json::Value::Array(arr));
+    }
+
+    serde_json::Value::Object(root)
+}
+
+/// Map event name string to `HookEventType`.
+fn parse_event_type(event: &str) -> Vec<HookEventType> {
+    match event.to_lowercase().as_str() {
+        "session_start" | "sessionstart" => vec![HookEventType::SessionStart],
+        "session_end" | "sessionend" => vec![HookEventType::SessionEnd],
+        "pre_tool_use" | "pretooluse" => vec![HookEventType::PreToolUse],
+        "post_tool_use" | "posttooluse" => vec![HookEventType::PostToolUse],
+        "user_prompt_submit" | "userpromptsubmit" => vec![HookEventType::UserPromptSubmit],
+        "stop" => vec![HookEventType::Stop],
+        "file_changed" | "filechanged" => vec![HookEventType::FileChanged],
+        "notification" => vec![HookEventType::Notification],
+        _ => Vec::new(), // Unknown event — no filter, won't match anything
+    }
 }
 
 // ─── Tests ─────────────────────────────────────────────────────────────
@@ -71,7 +235,6 @@ mod tests {
 
     #[test]
     fn frontmatter_hook_def_fields() {
-        // Verify the struct can be constructed and has the expected fields.
         let def = FrontmatterHookDef {
             event: "pre_tool_use".into(),
             command: Some("echo check".into()),
@@ -93,4 +256,96 @@ mod tests {
         assert!(def.command.is_none());
         assert!(def.prompt.is_some());
     }
+
+    #[test]
+    fn parse_hooks_section_with_hooks() {
+        let yaml = serde_json::json!({
+            "hooks": [
+                {"event": "pre_tool_use", "command": "echo check"},
+                {"event": "session_start", "prompt": "Init context"}
+            ]
+        });
+        let defs = parse_hooks_section(&yaml);
+        assert_eq!(defs.len(), 2);
+        assert_eq!(defs[0].event, "pre_tool_use");
+        assert_eq!(defs[0].command.as_deref(), Some("echo check"));
+        assert_eq!(defs[1].event, "session_start");
+        assert_eq!(defs[1].prompt.as_deref(), Some("Init context"));
+    }
+
+    #[test]
+    fn parse_hooks_section_no_hooks_key() {
+        let yaml = serde_json::json!({"name": "test"});
+        let defs = parse_hooks_section(&yaml);
+        assert!(defs.is_empty());
+    }
+
+    #[test]
+    fn parse_hooks_section_skips_invalid() {
+        let yaml = serde_json::json!({
+            "hooks": [
+                {"event": "pre_tool_use"},  // no command or prompt
+                {"command": "echo"},         // no event
+                {"event": "stop", "command": "echo done"}
+            ]
+        });
+        let defs = parse_hooks_section(&yaml);
+        assert_eq!(defs.len(), 1);
+        assert_eq!(defs[0].event, "stop");
+    }
+
+    #[test]
+    fn parse_simple_yaml_basic() {
+        let yaml = "name: test-skill\ndescription: A test";
+        let json = parse_simple_yaml_to_json(yaml);
+        assert_eq!(json["name"], "test-skill");
+        assert_eq!(json["description"], "A test");
+    }
+
+    #[test]
+    fn parse_simple_yaml_with_hooks_array() {
+        let yaml = "name: test\nhooks:\n  - event: pre_tool_use\n    command: echo check\n  - event: stop\n    prompt: verify";
+        let json = parse_simple_yaml_to_json(yaml);
+        let hooks = json["hooks"].as_array().unwrap();
+        assert_eq!(hooks.len(), 2);
+        assert_eq!(hooks[0]["event"], "pre_tool_use");
+        assert_eq!(hooks[0]["command"], "echo check");
+        assert_eq!(hooks[1]["event"], "stop");
+        assert_eq!(hooks[1]["prompt"], "verify");
+    }
+
+    #[test]
+    fn parse_event_type_known() {
+        assert_eq!(parse_event_type("pre_tool_use").len(), 1);
+        assert_eq!(parse_event_type("session_start").len(), 1);
+        assert_eq!(parse_event_type("PreToolUse").len(), 1);
+    }
+
+    #[test]
+    fn parse_event_type_unknown() {
+        assert!(parse_event_type("unknown_event").is_empty());
+    }
+
+    #[tokio::test]
+    async fn register_frontmatter_hooks_basic() {
+        let registry = HookRegistry::new();
+        let frontmatter = "hooks:\n  - event: pre_tool_use\n    command: echo check";
+        let ids = register_frontmatter_hooks(&registry, "my-skill", frontmatter).await;
+        assert_eq!(ids.len(), 1);
+    }
+
+    #[tokio::test]
+    async fn register_frontmatter_hooks_empty() {
+        let registry = HookRegistry::new();
+        let ids = register_frontmatter_hooks(&registry, "my-skill", "name: test").await;
+        assert!(ids.is_empty());
+    }
+
+    #[tokio::test]
+    async fn register_frontmatter_hooks_multiple() {
+        let registry = HookRegistry::new();
+        let frontmatter = "hooks:\n  - event: pre_tool_use\n    command: echo before\n  - event: stop\n    prompt: check done";
+        let ids = register_frontmatter_hooks(&registry, "my-skill", frontmatter).await;
+        assert_eq!(ids.len(), 2);
+    }
 }