feat(pipeline): implement Pipeline DSL system for automated workflows

Add complete Pipeline DSL system including:
- Rust backend (zclaw-pipeline crate) with parser, executor, and state management
- Frontend components: PipelinesPanel, PipelineResultPreview, ClassroomPreviewer
- Pipeline recommender for Agent conversation integration
- 5 pipeline templates: education, marketing, legal, research, productivity
- Documentation for Pipeline DSL architecture

Pipeline DSL enables declarative workflow definitions with:
- YAML-based configuration
- Expression resolution (${inputs.topic}, ${steps.step1.output})
- LLM integration, parallel execution, file export
- Agent smart recommendations in conversations

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

crates/zclaw-pipeline/src/actions/mod.rs

@@ -0,0 +1,379 @@
+//! Pipeline actions module
+//!
+//! Built-in actions that can be used in pipelines.
+
+mod llm;
+mod parallel;
+mod render;
+mod export;
+mod http;
+mod skill;
+mod hand;
+
+pub use llm::*;
+pub use parallel::*;
+pub use render::*;
+pub use export::*;
+pub use http::*;
+pub use skill::*;
+pub use hand::*;
+
+use std::collections::HashMap;
+use std::sync::Arc;
+use serde_json::Value;
+use async_trait::async_trait;
+
+use crate::types::ExportFormat;
+
+/// Action execution error
+#[derive(Debug, thiserror::Error)]
+pub enum ActionError {
+    #[error("LLM error: {0}")]
+    Llm(String),
+
+    #[error("Skill error: {0}")]
+    Skill(String),
+
+    #[error("Hand error: {0}")]
+    Hand(String),
+
+    #[error("Render error: {0}")]
+    Render(String),
+
+    #[error("Export error: {0}")]
+    Export(String),
+
+    #[error("HTTP error: {0}")]
+    Http(String),
+
+    #[error("IO error: {0}")]
+    Io(#[from] std::io::Error),
+
+    #[error("JSON error: {0}")]
+    Json(#[from] serde_json::Error),
+
+    #[error("Template not found: {0}")]
+    TemplateNotFound(String),
+
+    #[error("Invalid input: {0}")]
+    InvalidInput(String),
+}
+
+/// Action registry - holds references to all action executors
+pub struct ActionRegistry {
+    /// LLM driver (injected from runtime)
+    llm_driver: Option<Arc<dyn LlmActionDriver>>,
+
+    /// Skill registry (injected from kernel)
+    skill_registry: Option<Arc<dyn SkillActionDriver>>,
+
+    /// Hand registry (injected from kernel)
+    hand_registry: Option<Arc<dyn HandActionDriver>>,
+
+    /// Template directory
+    template_dir: Option<std::path::PathBuf>,
+}
+
+impl ActionRegistry {
+    /// Create a new action registry
+    pub fn new() -> Self {
+        Self {
+            llm_driver: None,
+            skill_registry: None,
+            hand_registry: None,
+            template_dir: None,
+        }
+    }
+
+    /// Set LLM driver
+    pub fn with_llm_driver(mut self, driver: Arc<dyn LlmActionDriver>) -> Self {
+        self.llm_driver = Some(driver);
+        self
+    }
+
+    /// Set skill registry
+    pub fn with_skill_registry(mut self, registry: Arc<dyn SkillActionDriver>) -> Self {
+        self.skill_registry = Some(registry);
+        self
+    }
+
+    /// Set hand registry
+    pub fn with_hand_registry(mut self, registry: Arc<dyn HandActionDriver>) -> Self {
+        self.hand_registry = Some(registry);
+        self
+    }
+
+    /// Set template directory
+    pub fn with_template_dir(mut self, dir: std::path::PathBuf) -> Self {
+        self.template_dir = Some(dir);
+        self
+    }
+
+    /// Execute LLM generation
+    pub async fn execute_llm(
+        &self,
+        template: &str,
+        input: HashMap<String, Value>,
+        model: Option<String>,
+        temperature: Option<f32>,
+        max_tokens: Option<u32>,
+        json_mode: bool,
+    ) -> Result<Value, ActionError> {
+        if let Some(driver) = &self.llm_driver {
+            // Load template if it's a file path
+            let prompt = if template.ends_with(".md") || template.contains('/') {
+                self.load_template(template)?
+            } else {
+                template.to_string()
+            };
+
+            driver.generate(prompt, input, model, temperature, max_tokens, json_mode)
+                .await
+                .map_err(ActionError::Llm)
+        } else {
+            Err(ActionError::Llm("LLM driver not configured".to_string()))
+        }
+    }
+
+    /// Execute a skill
+    pub async fn execute_skill(
+        &self,
+        skill_id: &str,
+        input: HashMap<String, Value>,
+    ) -> Result<Value, ActionError> {
+        if let Some(registry) = &self.skill_registry {
+            registry.execute(skill_id, input)
+                .await
+                .map_err(ActionError::Skill)
+        } else {
+            Err(ActionError::Skill("Skill registry not configured".to_string()))
+        }
+    }
+
+    /// Execute a hand action
+    pub async fn execute_hand(
+        &self,
+        hand_id: &str,
+        action: &str,
+        params: HashMap<String, Value>,
+    ) -> Result<Value, ActionError> {
+        if let Some(registry) = &self.hand_registry {
+            registry.execute(hand_id, action, params)
+                .await
+                .map_err(ActionError::Hand)
+        } else {
+            Err(ActionError::Hand("Hand registry not configured".to_string()))
+        }
+    }
+
+    /// Render classroom
+    pub async fn render_classroom(&self, data: &Value) -> Result<Value, ActionError> {
+        // This will integrate with the classroom renderer
+        // For now, return the data as-is
+        Ok(data.clone())
+    }
+
+    /// Export files
+    pub async fn export_files(
+        &self,
+        formats: &[ExportFormat],
+        data: &Value,
+        output_dir: Option<&str>,
+    ) -> Result<Value, ActionError> {
+        let mut paths = Vec::new();
+
+        let dir = output_dir
+            .map(std::path::PathBuf::from)
+            .unwrap_or_else(|| std::env::temp_dir());
+
+        for format in formats {
+            let path = self.export_single(format, data, &dir).await?;
+            paths.push(path);
+        }
+
+        Ok(serde_json::to_value(paths).unwrap_or(Value::Null))
+    }
+
+    async fn export_single(
+        &self,
+        format: &ExportFormat,
+        data: &Value,
+        dir: &std::path::Path,
+    ) -> Result<String, ActionError> {
+        let filename = format!("output_{}.{}", chrono::Utc::now().format("%Y%m%d_%H%M%S"), format.extension());
+        let path = dir.join(&filename);
+
+        match format {
+            ExportFormat::Json => {
+                let content = serde_json::to_string_pretty(data)?;
+                tokio::fs::write(&path, content).await?;
+            }
+            ExportFormat::Markdown => {
+                let content = self.render_markdown(data)?;
+                tokio::fs::write(&path, content).await?;
+            }
+            ExportFormat::Html => {
+                let content = self.render_html(data)?;
+                tokio::fs::write(&path, content).await?;
+            }
+            ExportFormat::Pptx => {
+                // Will integrate with pptx exporter
+                return Err(ActionError::Export("PPTX export not yet implemented".to_string()));
+            }
+            ExportFormat::Pdf => {
+                return Err(ActionError::Export("PDF export not yet implemented".to_string()));
+            }
+        }
+
+        Ok(path.to_string_lossy().to_string())
+    }
+
+    /// Make HTTP request
+    pub async fn http_request(
+        &self,
+        url: &str,
+        method: &str,
+        headers: &HashMap<String, String>,
+        body: Option<&Value>,
+    ) -> Result<Value, ActionError> {
+        let client = reqwest::Client::new();
+
+        let mut request = match method.to_uppercase().as_str() {
+            "GET" => client.get(url),
+            "POST" => client.post(url),
+            "PUT" => client.put(url),
+            "DELETE" => client.delete(url),
+            "PATCH" => client.patch(url),
+            _ => return Err(ActionError::Http(format!("Unsupported HTTP method: {}", method))),
+        };
+
+        for (key, value) in headers {
+            request = request.header(key, value);
+        }
+
+        if let Some(body) = body {
+            request = request.json(body);
+        }
+
+        let response = request.send()
+            .await
+            .map_err(|e| ActionError::Http(e.to_string()))?;
+
+        let status = response.status();
+        let body = response.text()
+            .await
+            .map_err(|e| ActionError::Http(e.to_string()))?;
+
+        Ok(serde_json::json!({
+            "status": status.as_u16(),
+            "body": body,
+        }))
+    }
+
+    /// Load a template file
+    fn load_template(&self, path: &str) -> Result<String, ActionError> {
+        let template_path = if let Some(dir) = &self.template_dir {
+            dir.join(path)
+        } else {
+            std::path::PathBuf::from(path)
+        };
+
+        std::fs::read_to_string(&template_path)
+            .map_err(|_| ActionError::TemplateNotFound(path.to_string()))
+    }
+
+    /// Render data to markdown
+    fn render_markdown(&self, data: &Value) -> Result<String, ActionError> {
+        // Simple markdown rendering
+        let mut md = String::new();
+
+        if let Some(title) = data.get("title").and_then(|v| v.as_str()) {
+            md.push_str(&format!("# {}\n\n", title));
+        }
+
+        if let Some(items) = data.get("items").and_then(|v| v.as_array()) {
+            for item in items {
+                if let Some(text) = item.as_str() {
+                    md.push_str(&format!("- {}\n", text));
+                }
+            }
+        }
+
+        Ok(md)
+    }
+
+    /// Render data to HTML
+    fn render_html(&self, data: &Value) -> Result<String, ActionError> {
+        let mut html = String::from("<!DOCTYPE html><html><head><meta charset=\"utf-8\"><title>Export</title></head><body>");
+
+        if let Some(title) = data.get("title").and_then(|v| v.as_str()) {
+            html.push_str(&format!("<h1>{}</h1>", title));
+        }
+
+        if let Some(items) = data.get("items").and_then(|v| v.as_array()) {
+            html.push_str("<ul>");
+            for item in items {
+                if let Some(text) = item.as_str() {
+                    html.push_str(&format!("<li>{}</li>", text));
+                }
+            }
+            html.push_str("</ul>");
+        }
+
+        html.push_str("</body></html>");
+        Ok(html)
+    }
+}
+
+impl ExportFormat {
+    fn extension(&self) -> &'static str {
+        match self {
+            ExportFormat::Pptx => "pptx",
+            ExportFormat::Html => "html",
+            ExportFormat::Pdf => "pdf",
+            ExportFormat::Markdown => "md",
+            ExportFormat::Json => "json",
+        }
+    }
+}
+
+impl Default for ActionRegistry {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+/// LLM action driver trait
+#[async_trait]
+pub trait LlmActionDriver: Send + Sync {
+    async fn generate(
+        &self,
+        prompt: String,
+        input: HashMap<String, Value>,
+        model: Option<String>,
+        temperature: Option<f32>,
+        max_tokens: Option<u32>,
+        json_mode: bool,
+    ) -> Result<Value, String>;
+}
+
+/// Skill action driver trait
+#[async_trait]
+pub trait SkillActionDriver: Send + Sync {
+    async fn execute(
+        &self,
+        skill_id: &str,
+        input: HashMap<String, Value>,
+    ) -> Result<Value, String>;
+}
+
+/// Hand action driver trait
+#[async_trait]
+pub trait HandActionDriver: Send + Sync {
+    async fn execute(
+        &self,
+        hand_id: &str,
+        action: &str,
+        params: HashMap<String, Value>,
+    ) -> Result<Value, String>;
+}