use crate::{dom::{AriaChild, AriaNode, yaml_escape_key_if_needed, yaml_escape_value_if_needed}, error::Result, tools::{Tool, ToolContext, ToolResult}}; use schemars::JsonSchema; use serde::{Deserialize, Serialize}; /// Parameters for the snapshot tool #[derive(Debug, Clone, Serialize, Deserialize, JsonSchema, Default)] pub struct SnapshotParams { /// Whether to include full snapshot or incremental #[serde(default)] pub incremental: bool, } /// Tool for getting an ARIA snapshot of the page in YAML format #[derive(Default)] pub struct SnapshotTool; impl Tool for SnapshotTool { type Params = SnapshotParams; fn name(&self) -> &str { "snapshot" } fn execute_typed(&self, params: SnapshotParams, context: &mut ToolContext) -> Result { // Get or extract the DOM tree let dom = context.get_dom()?; // Generate YAML snapshot let yaml_snapshot = render_aria_tree(&dom.root, RenderMode::Ai, None); // Count interactive elements let interactive_count = dom.count_interactive(); let result = if params.incremental { // TODO: Implement incremental snapshots serde_json::json!({ "full": yaml_snapshot, "interactive_count": interactive_count, }) } else { serde_json::json!({ "snapshot": yaml_snapshot, "interactive_count": interactive_count, }) }; Ok(ToolResult::success_with(result)) } } /// Rendering mode for ARIA tree #[derive(Debug, Clone, Copy)] pub enum RenderMode { /// AI consumption mode (includes refs, cursor, active markers) Ai, /// Expect mode (for testing) Expect, } /// Render an ARIA tree to YAML format /// Based on Playwright's renderAriaTree function pub fn render_aria_tree(root: &AriaNode, mode: RenderMode, previous: Option<&AriaNode>) -> String { let mut lines = Vec::new(); let render_cursor_pointer = matches!(mode, RenderMode::Ai); let render_active = matches!(mode, RenderMode::Ai); // Do not render the root fragment, just its children let nodes_to_render = if root.role == "fragment" { &root.children } else { // Single root node case - wrap it return render_single_node(root, mode, previous); }; for node in nodes_to_render { match node { AriaChild::Text(text) => { visit_text(text, "", &mut lines); } AriaChild::Node(node) => { visit(node, "", render_cursor_pointer, render_active, &mut lines, previous); } } } lines.join("\n") } fn render_single_node(root: &AriaNode, mode: RenderMode, previous: Option<&AriaNode>) -> String { let mut lines = Vec::new(); let render_cursor_pointer = matches!(mode, RenderMode::Ai); let render_active = matches!(mode, RenderMode::Ai); visit(root, "", render_cursor_pointer, render_active, &mut lines, previous); lines.join("\n") } fn visit_text(text: &str, indent: &str, lines: &mut Vec) { let escaped = yaml_escape_value_if_needed(text); if !escaped.is_empty() { lines.push(format!("{}- text: {}", indent, escaped)); } } fn visit( aria_node: &AriaNode, indent: &str, render_cursor_pointer: bool, render_active: bool, lines: &mut Vec, _previous: Option<&AriaNode>, ) { // Create the key (role + name + attributes) let key = create_key(aria_node, render_cursor_pointer, render_active); let escaped_key = format!("{}- {}", indent, yaml_escape_key_if_needed(&key)); // Get single inlined text child if applicable let single_text_child = get_single_inlined_text_child(aria_node); if aria_node.children.is_empty() && aria_node.props.is_empty() { // Leaf node without children or props lines.push(escaped_key); } else if let Some(text) = single_text_child { // Leaf node with just text inside lines.push(format!("{}: {}", escaped_key, yaml_escape_value_if_needed(&text))); } else { // Node with props and/or children lines.push(format!("{}:", escaped_key)); // Render props for (name, value) in &aria_node.props { lines.push(format!("{} - /{}: {}", indent, name, yaml_escape_value_if_needed(value))); } // Render children let child_indent = format!("{} ", indent); let in_cursor_pointer = aria_node.index.is_some() && render_cursor_pointer && aria_node.has_pointer_cursor(); for child in &aria_node.children { match child { AriaChild::Text(text) => { visit_text(text, &child_indent, lines); } AriaChild::Node(child_node) => { visit( child_node, &child_indent, render_cursor_pointer && !in_cursor_pointer, render_active, lines, None, ); } } } } } fn create_key(aria_node: &AriaNode, render_cursor_pointer: bool, render_active: bool) -> String { let mut key = aria_node.role.clone(); // Add name if present and not too long if !aria_node.name.is_empty() && aria_node.name.len() <= 900 { // YAML has a limit of 1024 characters per key let name = &aria_node.name; // Simple stringification (no regex handling for now) key.push(' '); key.push_str(&format!("{:?}", name)); // JSON-style quoting } // Add ARIA state attributes if let Some(checked) = &aria_node.checked { match checked { crate::dom::element::AriaChecked::Bool(true) => key.push_str(" [checked]"), crate::dom::element::AriaChecked::Bool(false) => {} crate::dom::element::AriaChecked::Mixed(_) => key.push_str(" [checked=mixed]"), } } if aria_node.disabled == Some(true) { key.push_str(" [disabled]"); } if aria_node.expanded == Some(true) { key.push_str(" [expanded]"); } if render_active && aria_node.active == Some(true) { key.push_str(" [active]"); } if let Some(level) = aria_node.level { key.push_str(&format!(" [level={}]", level)); } if let Some(pressed) = &aria_node.pressed { match pressed { crate::dom::element::AriaPressed::Bool(true) => key.push_str(" [pressed]"), crate::dom::element::AriaPressed::Bool(false) => {} crate::dom::element::AriaPressed::Mixed(_) => key.push_str(" [pressed=mixed]"), } } if aria_node.selected == Some(true) { key.push_str(" [selected]"); } // Add index attribute if let Some(index) = aria_node.index { key.push_str(&format!(" [index={}]", index)); if render_cursor_pointer && aria_node.has_pointer_cursor() { key.push_str(" [cursor=pointer]"); } } key } fn get_single_inlined_text_child(aria_node: &AriaNode) -> Option { if aria_node.children.len() == 1 && aria_node.props.is_empty() { if let AriaChild::Text(text) = &aria_node.children[0] { return Some(text.clone()); } } None } #[cfg(test)] mod tests { use super::*; #[test] fn test_render_simple_tree() { let mut root = AriaNode::fragment(); root.children.push(AriaChild::Node(Box::new( AriaNode::new("button", "Click me").with_index(0).with_box(true, Some("pointer".to_string())), ))); let yaml = render_aria_tree(&root, RenderMode::Ai, None); assert!(yaml.contains("button")); assert!(yaml.contains("Click me")); assert!(yaml.contains("[index=0]")); assert!(yaml.contains("[cursor=pointer]")); } #[test] fn test_render_tree_with_text() { let mut root = AriaNode::fragment(); root.children.push(AriaChild::Text("Hello world".to_string())); let yaml = render_aria_tree(&root, RenderMode::Ai, None); eprintln!("YAML output:\n{}", yaml); assert!(yaml.contains("text:")); assert!(yaml.contains("Hello world")); } #[test] fn test_render_nested_tree() { let mut root = AriaNode::fragment(); let mut div = AriaNode::new("generic", ""); div.children.push(AriaChild::Text("Parent text".to_string())); div.children.push(AriaChild::Node(Box::new(AriaNode::new("button", "Child button").with_index(0)))); root.children.push(AriaChild::Node(Box::new(div))); let yaml = render_aria_tree(&root, RenderMode::Ai, None); assert!(yaml.contains("generic")); assert!(yaml.contains("Parent text")); assert!(yaml.contains("button")); assert!(yaml.contains("Child button")); } #[test] fn test_render_with_props() { let mut root = AriaNode::fragment(); root.children.push(AriaChild::Node(Box::new( AriaNode::new("link", "Go to page").with_index(0).with_prop("url", "https://example.com"), ))); let yaml = render_aria_tree(&root, RenderMode::Ai, None); eprintln!("YAML output:\n{}", yaml); assert!(yaml.contains("link")); assert!(yaml.contains("[index=0]")); assert!(yaml.contains("/url:")); assert!(yaml.contains("https://example.com")); } #[test] fn test_render_with_aria_states() { let mut root = AriaNode::fragment(); root.children.push(AriaChild::Node(Box::new( AriaNode::new("checkbox", "Accept terms").with_index(0).with_checked(true).with_disabled(false), ))); let yaml = render_aria_tree(&root, RenderMode::Ai, None); assert!(yaml.contains("checkbox")); assert!(yaml.contains("[checked]")); // disabled=false should not appear assert!(!yaml.contains("[disabled]")); } #[test] fn test_render_heading_with_level() { let mut root = AriaNode::fragment(); root.children.push(AriaChild::Node(Box::new(AriaNode::new("heading", "Page Title").with_level(1)))); let yaml = render_aria_tree(&root, RenderMode::Ai, None); assert!(yaml.contains("heading")); assert!(yaml.contains("Page Title")); assert!(yaml.contains("[level=1]")); } #[test] fn test_empty_snapshot() { let root = AriaNode::fragment(); let yaml = render_aria_tree(&root, RenderMode::Ai, None); assert_eq!(yaml.trim(), ""); } }