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/state.rs

@@ -0,0 +1,377 @@
+//! Pipeline execution state management
+//!
+//! Manages state during pipeline execution, including:
+//! - Input parameters
+//! - Step outputs
+//! - Loop variables (item, index)
+//! - Custom variables
+
+use std::collections::HashMap;
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+use regex::Regex;
+
+/// Execution context for a running pipeline
+#[derive(Debug, Clone)]
+pub struct ExecutionContext {
+    /// Pipeline input values
+    inputs: HashMap<String, Value>,
+
+    /// Step outputs (step_id -> output)
+    steps_output: HashMap<String, Value>,
+
+    /// Custom variables (set by set_var action)
+    variables: HashMap<String, Value>,
+
+    /// Loop context (item, index for parallel/each)
+    loop_context: Option<LoopContext>,
+
+    /// Expression parser
+    expr_regex: Regex,
+}
+
+/// Loop context for parallel/each iterations
+#[derive(Debug, Clone)]
+pub struct LoopContext {
+    /// Current item
+    pub item: Value,
+    /// Current index
+    pub index: usize,
+    /// Parent loop context (for nested loops)
+    pub parent: Option<Box<LoopContext>>,
+}
+
+impl ExecutionContext {
+    /// Create a new execution context with inputs
+    pub fn new(inputs: HashMap<String, Value>) -> Self {
+        Self {
+            inputs,
+            steps_output: HashMap::new(),
+            variables: HashMap::new(),
+            loop_context: None,
+            expr_regex: Regex::new(r"\$\{([^}]+)\}").unwrap(),
+        }
+    }
+
+    /// Create from JSON value
+    pub fn from_value(inputs: Value) -> Self {
+        let inputs_map = if let Value::Object(obj) = inputs {
+            obj.into_iter().collect()
+        } else {
+            HashMap::new()
+        };
+        Self::new(inputs_map)
+    }
+
+    /// Get an input value
+    pub fn get_input(&self, name: &str) -> Option<&Value> {
+        self.inputs.get(name)
+    }
+
+    /// Set a step output
+    pub fn set_output(&mut self, step_id: &str, value: Value) {
+        self.steps_output.insert(step_id.to_string(), value);
+    }
+
+    /// Get a step output
+    pub fn get_output(&self, step_id: &str) -> Option<&Value> {
+        self.steps_output.get(step_id)
+    }
+
+    /// Set a variable
+    pub fn set_var(&mut self, name: &str, value: Value) {
+        self.variables.insert(name.to_string(), value);
+    }
+
+    /// Get a variable
+    pub fn get_var(&self, name: &str) -> Option<&Value> {
+        self.variables.get(name)
+    }
+
+    /// Set loop context
+    pub fn set_loop_context(&mut self, item: Value, index: usize) {
+        self.loop_context = Some(LoopContext {
+            item,
+            index,
+            parent: self.loop_context.take().map(Box::new),
+        });
+    }
+
+    /// Clear loop context
+    pub fn clear_loop_context(&mut self) {
+        if let Some(ctx) = self.loop_context.take() {
+            self.loop_context = ctx.parent.map(|b| *b);
+        }
+    }
+
+    /// Resolve an expression to a value
+    ///
+    /// Supported expressions:
+    /// - `${inputs.topic}` - Input parameter
+    /// - `${steps.step_id.output}` - Step output
+    /// - `${steps.step_id.output.field}` - Nested field access
+    /// - `${item}` - Current loop item
+    /// - `${index}` - Current loop index
+    /// - `${var.name}` - Custom variable
+    pub fn resolve(&self, expr: &str) -> Result<Value, StateError> {
+        // If not an expression, return as-is
+        if !expr.contains("${") {
+            return Ok(Value::String(expr.to_string()));
+        }
+
+        // Replace all expressions
+        let result = self.expr_regex.replace_all(expr, |caps: &regex::Captures| {
+            let path = &caps[1];
+            match self.resolve_path(path) {
+                Ok(value) => value_to_string(&value),
+                Err(_) => caps[0].to_string(), // Keep original if not found
+            }
+        });
+
+        // If the result is a valid JSON value, parse it
+        if result.starts_with('{') || result.starts_with('[') || result.starts_with('"') {
+            if let Ok(value) = serde_json::from_str(&result) {
+                return Ok(value);
+            }
+        }
+
+        // If the entire string was an expression, try to return the actual value
+        if expr.starts_with("${") && expr.ends_with("}") {
+            let path = &expr[2..expr.len()-1];
+            return self.resolve_path(path);
+        }
+
+        Ok(Value::String(result.to_string()))
+    }
+
+    /// Resolve a path like "inputs.topic" or "steps.step1.output.field"
+    fn resolve_path(&self, path: &str) -> Result<Value, StateError> {
+        let parts: Vec<&str> = path.split('.').collect();
+        if parts.is_empty() {
+            return Err(StateError::InvalidPath(path.to_string()));
+        }
+
+        let first = parts[0];
+        let rest = &parts[1..];
+
+        match first {
+            "inputs" => self.resolve_from_map(&self.inputs, rest, path),
+            "steps" => self.resolve_from_map(&self.steps_output, rest, path),
+            "vars" | "var" => self.resolve_from_map(&self.variables, rest, path),
+            "item" => {
+                if let Some(ctx) = &self.loop_context {
+                    if rest.is_empty() {
+                        Ok(ctx.item.clone())
+                    } else {
+                        self.resolve_from_value(&ctx.item, rest, path)
+                    }
+                } else {
+                    Err(StateError::VariableNotFound("item".to_string()))
+                }
+            }
+            "index" => {
+                if let Some(ctx) = &self.loop_context {
+                    Ok(Value::Number(ctx.index.into()))
+                } else {
+                    Err(StateError::VariableNotFound("index".to_string()))
+                }
+            }
+            _ => Err(StateError::InvalidPath(path.to_string())),
+        }
+    }
+
+    /// Resolve a path from a map
+    fn resolve_from_map(
+        &self,
+        map: &HashMap<String, Value>,
+        path_parts: &[&str],
+        full_path: &str,
+    ) -> Result<Value, StateError> {
+        if path_parts.is_empty() {
+            return Err(StateError::InvalidPath(full_path.to_string()));
+        }
+
+        let key = path_parts[0];
+        let value = map.get(key)
+            .ok_or_else(|| StateError::VariableNotFound(key.to_string()))?;
+
+        if path_parts.len() == 1 {
+            Ok(value.clone())
+        } else {
+            self.resolve_from_value(value, &path_parts[1..], full_path)
+        }
+    }
+
+    /// Resolve a path from a value (nested access)
+    fn resolve_from_value(
+        &self,
+        value: &Value,
+        path_parts: &[&str],
+        full_path: &str,
+    ) -> Result<Value, StateError> {
+        let mut current = value;
+
+        for part in path_parts {
+            current = match current {
+                Value::Object(map) => map.get(*part)
+                    .ok_or_else(|| StateError::FieldNotFound(part.to_string()))?,
+                Value::Array(arr) => {
+                    // Try to parse as index
+                    if let Ok(idx) = part.parse::<usize>() {
+                        arr.get(idx)
+                            .ok_or_else(|| StateError::IndexOutOfBounds(idx))?
+                    } else {
+                        return Err(StateError::InvalidPath(full_path.to_string()));
+                    }
+                }
+                _ => return Err(StateError::InvalidPath(full_path.to_string())),
+            };
+        }
+
+        Ok(current.clone())
+    }
+
+    /// Resolve multiple expressions in a map
+    pub fn resolve_map(&self, input: &HashMap<String, String>) -> Result<HashMap<String, Value>, StateError> {
+        let mut result = HashMap::new();
+        for (key, expr) in input {
+            let value = self.resolve(expr)?;
+            result.insert(key.clone(), value);
+        }
+        Ok(result)
+    }
+
+    /// Get all step outputs
+    pub fn all_outputs(&self) -> &HashMap<String, Value> {
+        &self.steps_output
+    }
+
+    /// Extract final outputs from the context
+    pub fn extract_outputs(&self, output_defs: &HashMap<String, String>) -> Result<HashMap<String, Value>, StateError> {
+        let mut outputs = HashMap::new();
+        for (name, expr) in output_defs {
+            let value = self.resolve(expr)?;
+            outputs.insert(name.clone(), value);
+        }
+        Ok(outputs)
+    }
+}
+
+/// Convert a value to string for template replacement
+fn value_to_string(value: &Value) -> String {
+    match value {
+        Value::String(s) => s.clone(),
+        Value::Number(n) => n.to_string(),
+        Value::Bool(b) => b.to_string(),
+        Value::Null => String::new(),
+        Value::Array(arr) => {
+            serde_json::to_string(arr).unwrap_or_default()
+        }
+        Value::Object(obj) => {
+            serde_json::to_string(obj).unwrap_or_default()
+        }
+    }
+}
+
+/// State errors
+#[derive(Debug, thiserror::Error)]
+pub enum StateError {
+    #[error("Invalid path: {0}")]
+    InvalidPath(String),
+
+    #[error("Variable not found: {0}")]
+    VariableNotFound(String),
+
+    #[error("Field not found: {0}")]
+    FieldNotFound(String),
+
+    #[error("Index out of bounds: {0}")]
+    IndexOutOfBounds(usize),
+
+    #[error("Type error: {0}")]
+    TypeError(String),
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use serde_json::json;
+
+    #[test]
+    fn test_resolve_input() {
+        let ctx = ExecutionContext::new(
+            vec![("topic".to_string(), json!("physics"))]
+                .into_iter()
+                .collect()
+        );
+
+        let result = ctx.resolve("${inputs.topic}").unwrap();
+        assert_eq!(result, json!("physics"));
+    }
+
+    #[test]
+    fn test_resolve_step_output() {
+        let mut ctx = ExecutionContext::new(HashMap::new());
+        ctx.set_output("step1", json!({"result": "hello", "count": 42}));
+
+        let result = ctx.resolve("${steps.step1.output.result}").unwrap();
+        assert_eq!(result, json!("hello"));
+
+        let count = ctx.resolve("${steps.step1.output.count}").unwrap();
+        assert_eq!(count, json!(42));
+    }
+
+    #[test]
+    fn test_resolve_loop_context() {
+        let mut ctx = ExecutionContext::new(HashMap::new());
+        ctx.set_loop_context(json!({"name": "item1"}), 2);
+
+        let item = ctx.resolve("${item}").unwrap();
+        assert_eq!(item, json!({"name": "item1"}));
+
+        let index = ctx.resolve("${index}").unwrap();
+        assert_eq!(index, json!(2));
+
+        let name = ctx.resolve("${item.name}").unwrap();
+        assert_eq!(name, json!("item1"));
+    }
+
+    #[test]
+    fn test_resolve_array_access() {
+        let mut ctx = ExecutionContext::new(HashMap::new());
+        ctx.set_output("step1", json!({"items": ["a", "b", "c"]}));
+
+        let result = ctx.resolve("${steps.step1.output.items.0}").unwrap();
+        assert_eq!(result, json!("a"));
+
+        let result = ctx.resolve("${steps.step1.output.items.2}").unwrap();
+        assert_eq!(result, json!("c"));
+    }
+
+    #[test]
+    fn test_resolve_mixed_string() {
+        let ctx = ExecutionContext::new(
+            vec![("name".to_string(), json!("World"))]
+                .into_iter()
+                .collect()
+        );
+
+        let result = ctx.resolve("Hello, ${inputs.name}!").unwrap();
+        assert_eq!(result, json!("Hello, World!"));
+    }
+
+    #[test]
+    fn test_extract_outputs() {
+        let mut ctx = ExecutionContext::new(HashMap::new());
+        ctx.set_output("render", json!({"id": "classroom-123", "url": "/preview"}));
+
+        let outputs = vec![
+            ("classroom_id".to_string(), "${steps.render.output.id}".to_string()),
+            ("preview_url".to_string(), "${steps.render.output.url}".to_string()),
+        ].into_iter().collect();
+
+        let result = ctx.extract_outputs(&outputs).unwrap();
+        assert_eq!(result.get("classroom_id").unwrap(), &json!("classroom-123"));
+        assert_eq!(result.get("preview_url").unwrap(), &json!("/preview"));
+    }
+}