rf-mcp 0.28.dev1__tar.gz → 0.28.dev2__tar.gz

{rf_mcp-0.28.dev1 → rf_mcp-0.28.dev2}/.gitignore

@@ -223,4 +223,7 @@ playwright*.txt
 .swarm/
 *.robot
 
-tests/e2e/metrics/*.json
+tests/e2e/metrics/*.json
+
+tests/experiments/*
+resources/

{rf_mcp-0.28.dev1 → rf_mcp-0.28.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rf-mcp
-Version: 0.28.dev1
+Version: 0.28.dev2
 Summary: Robot Framework MCP Server - Natural Language Test Automation Bridge
 Project-URL: Homepage, https://github.com/manykarim/rf-mcp
 Project-URL: Repository, https://github.com/manykarim/rf-mcp

{rf_mcp-0.28.dev1 → rf_mcp-0.28.dev2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "rf-mcp"
-version = "0.28.dev01"
+version = "0.28.dev02"
 description = "Robot Framework MCP Server - Natural Language Test Automation Bridge"
 authors = [{ name = "Many Kasiriha" }]
 license = { text = "Apache-2.0" }

{rf_mcp-0.28.dev1 → rf_mcp-0.28.dev2}/src/robotmcp/components/execution/keyword_executor.py

@@ -2547,6 +2547,19 @@ class KeywordExecutor:
                 ]
                 base_response["resolved_arguments"] = serialized_resolved_args
 
+        else:
+            # Unrecognized detail_level — fall back to minimal (includes output)
+            logger.warning(
+                f"Unrecognized detail_level '{detail_level}', "
+                f"falling back to 'minimal'. Valid values: minimal, standard, full"
+            )
+            raw_output = result.get("output", "")
+            base_response["output"] = self.response_serializer.serialize_for_response(
+                raw_output
+            )
+            if "assigned_variables" in result:
+                base_response["assigned_variables"] = result["assigned_variables"]
+
         return base_response
 
     def get_supported_detail_levels(self) -> List[str]:

{rf_mcp-0.28.dev1 → rf_mcp-0.28.dev2}/src/robotmcp/components/execution/page_source_service.py

@@ -994,300 +994,3 @@ class PageSourceService:
         except Exception as e:
             logger.debug(f"Direct mobile source retrieval failed: {e}")
             return None
-
-    # =========================================================================
-    # DDD Integration Methods - Using domains for optimized snapshot capture
-    # =========================================================================
-
-    async def capture_optimized_snapshot(
-        self,
-        session: ExecutionSession,
-        browser_library_manager: Any,
-        snapshot_mode: str = "incremental",
-        selector: Optional[str] = None,
-        include_refs: bool = True,
-    ) -> Dict[str, Any]:
-        """Capture ARIA snapshot with full optimization pipeline.
-
-        Uses the DDD domains for:
-        - Token optimization via list folding
-        - Incremental diff mode for reduced responses
-        - Element ref registration for subsequent actions
-        - Performance metrics collection
-
-        Args:
-            session: The execution session
-            browser_library_manager: Browser library manager instance
-            snapshot_mode: "full", "incremental", or "none"
-            selector: Optional CSS selector to scope the snapshot
-            include_refs: Whether to include element refs in response
-
-        Returns:
-            Dict with snapshot content, refs, and metrics
-        """
-        import time
-        start_time = time.perf_counter()
-
-        try:
-            from robotmcp.container import get_container
-
-            container = get_container()
-
-            # 1. Capture raw ARIA snapshot
-            aria_result = await self._capture_browser_aria_snapshot(
-                session,
-                browser_library_manager,
-                selector=selector or "css=html",
-            )
-
-            if not aria_result.get("success"):
-                return {
-                    "success": False,
-                    "error": aria_result.get("error", "Failed to capture ARIA snapshot"),
-                }
-
-            raw_aria = aria_result.get("content", "")
-            if not raw_aria:
-                return {
-                    "success": False,
-                    "error": "Empty ARIA snapshot returned",
-                }
-
-            # 2. Build PageSnapshot using domain
-            from robotmcp.domains.snapshot import PageSnapshot, AriaTree
-
-            capture_duration_ms = (time.perf_counter() - start_time) * 1000
-
-            # Parse ARIA YAML into AriaTree
-            try:
-                aria_tree = AriaTree.from_yaml(raw_aria)
-            except Exception as parse_err:
-                logger.warning(f"Failed to parse ARIA YAML: {parse_err}")
-                # Create a simple tree from raw content
-                from robotmcp.domains.snapshot import AriaNode, AriaRole, ElementRef
-                aria_tree = AriaTree(
-                    root=AriaNode(
-                        ref=ElementRef.from_index(0),
-                        role=AriaRole("document"),
-                        name="(parse error)",
-                    )
-                )
-
-            snapshot = PageSnapshot.create(
-                session_id=session.session_id,
-                aria_tree=aria_tree,
-                url=session.browser_state.current_url,
-                title=session.browser_state.page_title,
-            )
-
-            # 3. Get compression settings from learned patterns
-            page_type = self._classify_page_type(session)
-            compression_settings = container.get_compression_settings(page_type)
-
-            # 4. Apply list folding if beneficial
-            fold_threshold = compression_settings.get("fold_threshold", 0.85)
-            if compression_settings.get("apply_folding", True):
-                snapshot = snapshot.fold_lists(threshold=fold_threshold)
-
-            # 5. Handle snapshot mode
-            if snapshot_mode == "none":
-                snapshot_content = "[Snapshot omitted]"
-            elif snapshot_mode == "incremental":
-                previous = container.get_cached_snapshot(session.session_id)
-                if previous:
-                    snapshot_content = snapshot.get_incremental_diff(previous)
-                else:
-                    snapshot_content = snapshot.to_yaml()
-            else:  # full
-                snapshot_content = snapshot.to_yaml()
-
-            # 6. Update element registry
-            refs = {}
-            if include_refs:
-                registry = container.get_element_registry(session.session_id)
-                # Register elements from snapshot
-                refs = self._update_element_registry_from_snapshot(
-                    registry, snapshot
-                )
-
-            # 7. Cache snapshot for incremental mode
-            container.cache_snapshot(session.session_id, snapshot)
-
-            # 8. Record metrics
-            latency_ms = (time.perf_counter() - start_time) * 1000
-            container.record_snapshot_metrics(
-                raw_chars=len(raw_aria),
-                aria_chars=len(snapshot_content),
-                latency_ms=latency_ms,
-                page_type=page_type,
-                fold_threshold=fold_threshold,
-            )
-
-            return {
-                "success": True,
-                "content": snapshot_content,
-                "refs": refs,
-                "token_estimate": snapshot.estimate_tokens(),
-                "node_count": snapshot.aria_tree.node_count,
-                "interactive_count": snapshot.aria_tree.interactive_count,
-                "compression_applied": snapshot.compression_applied,
-                "latency_ms": latency_ms,
-                "mode": snapshot_mode,
-            }
-
-        except Exception as e:
-            logger.error(f"Error in optimized snapshot capture: {e}")
-            return {
-                "success": False,
-                "error": f"Snapshot capture failed: {str(e)}",
-            }
-
-    def _classify_page_type(self, session: ExecutionSession) -> str:
-        """Classify the current page type for optimization.
-
-        Args:
-            session: The execution session
-
-        Returns:
-            Page type string (e.g., "search_results", "form", "article")
-        """
-        try:
-            from robotmcp.container import get_container
-
-            container = get_container()
-            analyzer = container.page_analyzer
-
-            # Analyze based on URL and title
-            url = session.browser_state.current_url or ""
-            title = session.browser_state.page_title or ""
-
-            classification = analyzer.classify_page(url, title)
-            return classification.page_type
-
-        except Exception as e:
-            logger.debug(f"Page classification failed: {e}")
-            return "unknown"
-
-    def _update_element_registry_from_snapshot(
-        self,
-        registry: Any,  # ElementRegistry
-        snapshot: Any,  # PageSnapshot
-    ) -> Dict[str, str]:
-        """Update element registry with refs from snapshot.
-
-        Args:
-            registry: The element registry to update
-            snapshot: The page snapshot with elements
-
-        Returns:
-            Dict mapping ref -> brief description
-        """
-        refs = {}
-        try:
-            # Iterate through snapshot's ARIA tree
-            for node in snapshot.aria_tree.root.traverse():
-                ref_str = str(node.ref)
-                description = node.display_name
-
-                # Register in registry (converts aria to locator)
-                # The registry will create appropriate locators based on node properties
-                try:
-                    registry.register_from_aria_node(node)
-                    refs[ref_str] = description
-                except Exception as reg_err:
-                    logger.debug(f"Failed to register ref {ref_str}: {reg_err}")
-
-        except Exception as e:
-            logger.warning(f"Failed to update element registry: {e}")
-
-        return refs
-
-    def get_element_registry(self, session_id: str) -> Any:
-        """Get the element registry for a session.
-
-        Args:
-            session_id: The session ID
-
-        Returns:
-            ElementRegistry instance
-        """
-        from robotmcp.container import get_container
-        return get_container().get_element_registry(session_id)
-
-    def get_locator_for_ref(self, session_id: str, ref: str) -> Optional[str]:
-        """Get the browser locator for an element ref.
-
-        Args:
-            session_id: The session ID
-            ref: Element reference (e.g., "e1", "e42")
-
-        Returns:
-            Browser-compatible locator string or None
-        """
-        try:
-            from robotmcp.container import get_container
-            from robotmcp.domains.shared.kernel import ElementRef
-
-            registry = get_container().get_element_registry(session_id)
-            element_ref = ElementRef(ref)
-
-            if not registry.has_ref(element_ref):
-                return None
-
-            locator = registry.get_locator(element_ref)
-            return locator.to_browser_library()
-
-        except Exception as e:
-            logger.warning(f"Failed to get locator for ref {ref}: {e}")
-            return None
-
-    def validate_ref(self, session_id: str, ref: str) -> Dict[str, Any]:
-        """Validate an element ref exists and is not stale.
-
-        Args:
-            session_id: The session ID
-            ref: Element reference to validate
-
-        Returns:
-            Dict with validation result
-        """
-        try:
-            from robotmcp.container import get_container
-            from robotmcp.domains.shared.kernel import ElementRef
-
-            registry = get_container().get_element_registry(session_id)
-
-            # Validate ref format
-            try:
-                element_ref = ElementRef(ref)
-            except ValueError as e:
-                return {
-                    "valid": False,
-                    "error": f"Invalid ref format: {e}",
-                }
-
-            if registry.is_stale():
-                return {
-                    "valid": False,
-                    "error": "Registry is stale. Capture a new snapshot to get fresh refs.",
-                }
-
-            # Check if ref exists in registry
-            if element_ref not in registry.refs:
-                available_refs = [str(r) for r in list(registry.refs.keys())[:10]]
-                return {
-                    "valid": False,
-                    "error": f"Ref '{ref}' not found. Available refs: {available_refs}",
-                }
-
-            return {
-                "valid": True,
-                "ref": ref,
-                "locator": self.get_locator_for_ref(session_id, ref),
-            }
-
-        except Exception as e:
-            return {
-                "valid": False,
-                "error": str(e),
-            }

{rf_mcp-0.28.dev1 → rf_mcp-0.28.dev2}/src/robotmcp/container.py

@@ -2,8 +2,6 @@
 
 This container wires together the various DDD bounded contexts:
 - Snapshot Context: ARIA tree capture and token optimization
-- Element Registry Context: Ref-to-locator mapping
-- Action Context: Pre-validation and response filtering
 - Timeout Context: Dual timeout management
 
 Usage:
@@ -22,8 +20,6 @@ from typing import Dict, Optional, TYPE_CHECKING
 
 if TYPE_CHECKING:
     from robotmcp.domains.timeout import TimeoutService, TimeoutPolicy
-    from robotmcp.domains.action import PreValidator
-    from robotmcp.domains.element_registry import ElementRegistry
     from robotmcp.domains.snapshot import PageSnapshot
     from robotmcp.optimization import (
         PatternStore,
@@ -48,11 +44,9 @@ class ServiceContainer:
         pattern_store: Shared pattern storage for learned optimizations
         performance_collector: Centralized performance metrics
         timeout_service: Timeout management service
-        pre_validator: Pre-validation service for actions
         page_analyzer: Page complexity analyzer
 
     Session-specific services (keyed by session_id):
-        - Element registries
         - Timeout policies
         - Snapshot caches
     """
@@ -63,13 +57,9 @@ class ServiceContainer:
         default=None, repr=False
     )
     _timeout_service: Optional["TimeoutService"] = field(default=None, repr=False)
-    _pre_validator: Optional["PreValidator"] = field(default=None, repr=False)
     _page_analyzer: Optional["PageAnalyzer"] = field(default=None, repr=False)
 
     # Session-scoped registries
-    _element_registries: Dict[str, "ElementRegistry"] = field(
-        default_factory=dict, repr=False
-    )
     _timeout_policies: Dict[str, "TimeoutPolicy"] = field(
         default_factory=dict, repr=False
     )
@@ -103,14 +93,6 @@ class ServiceContainer:
             self._timeout_service = TimeoutService()
         return self._timeout_service
 
-    @property
-    def pre_validator(self) -> "PreValidator":
-        """Get the pre-validation service."""
-        if self._pre_validator is None:
-            from robotmcp.domains.action import PreValidator
-            self._pre_validator = PreValidator()
-        return self._pre_validator
-
     @property
     def page_analyzer(self) -> "PageAnalyzer":
         """Get the page complexity analyzer."""
@@ -119,20 +101,6 @@ class ServiceContainer:
             self._page_analyzer = PageAnalyzer()
         return self._page_analyzer
 
-    def get_element_registry(self, session_id: str) -> "ElementRegistry":
-        """Get or create an element registry for a session.
-
-        Args:
-            session_id: The session identifier
-
-        Returns:
-            ElementRegistry for the session
-        """
-        if session_id not in self._element_registries:
-            from robotmcp.domains.element_registry import ElementRegistry
-            self._element_registries[session_id] = ElementRegistry.create_for_session(session_id)
-        return self._element_registries[session_id]
-
     def get_timeout_policy(self, session_id: str) -> "TimeoutPolicy":
         """Get or create a timeout policy for a session.
 
@@ -174,7 +142,6 @@ class ServiceContainer:
         Args:
             session_id: The session to clear
         """
-        self._element_registries.pop(session_id, None)
         self._timeout_policies.pop(session_id, None)
         self._snapshot_cache.pop(session_id, None)
         logger.debug(f"Cleared container data for session {session_id}")

{rf_mcp-0.28.dev1 → rf_mcp-0.28.dev2}/src/robotmcp/domains/__init__.py

@@ -2,8 +2,6 @@
 
 This package contains the DDD implementation for:
 - Snapshot Context: Accessibility tree generation and compression
-- Element Registry Context: Element reference mapping and stale detection
-- Action Context: Tool execution and response filtering
 - Timeout Context: Timeout configuration and enforcement
 
 For architecture details, see:
@@ -37,33 +35,6 @@ from robotmcp.domains.timeout import (
     TimeoutContextManager,
 )
 
-from robotmcp.domains.action import (
-    # Value Objects
-    ActionParameters,
-    ExecutionId,
-    FilteredResponse,
-    PreValidationResult,
-    ResponseConfig,
-    # Protocols
-    BrowserAdapter,
-    ElementRegistry,
-    Locator,
-    # Services
-    PreValidator,
-    ResponseBuilder,
-    IncrementalResponseBuilder,
-    # Aggregates
-    ActionExecution,
-    RetryableActionExecution,
-    # Events
-    ActionCompleted,
-    ActionFailed,
-    ActionRetrying,
-    ActionStarted,
-    PreValidationCompleted,
-    TimeoutExceeded as ActionTimeoutExceeded,
-)
-
 __all__ = [
     # Shared Kernel
     "AriaNode",
@@ -87,28 +58,4 @@ __all__ = [
     # Timeout Domain - Services
     "TimeoutService",
     "TimeoutContextManager",
-    # Action Domain - Value Objects
-    "ActionParameters",
-    "ExecutionId",
-    "FilteredResponse",
-    "PreValidationResult",
-    "ResponseConfig",
-    # Action Domain - Protocols
-    "BrowserAdapter",
-    "ElementRegistry",
-    "Locator",
-    # Action Domain - Services
-    "PreValidator",
-    "ResponseBuilder",
-    "IncrementalResponseBuilder",
-    # Action Domain - Aggregates
-    "ActionExecution",
-    "RetryableActionExecution",
-    # Action Domain - Events
-    "ActionCompleted",
-    "ActionFailed",
-    "ActionRetrying",
-    "ActionStarted",
-    "PreValidationCompleted",
-    "ActionTimeoutExceeded",
 ]

{rf_mcp-0.28.dev1 → rf_mcp-0.28.dev2}/src/robotmcp/server.py

@@ -2329,6 +2329,18 @@ async def manage_session(
                     name, value = item.split("=", 1)
                     data[name.strip()] = value
 
+        if not data:
+            return {
+                "success": False,
+                "action": "set_variables",
+                "session_id": session_id,
+                "error": "No variables to set. Provide a non-empty 'variables' parameter.",
+                "hint": (
+                    "Pass variables as a dict: variables={\"MY_VAR\": \"value\"} "
+                    "or as a list: variables=[\"MY_VAR=value\", \"OTHER=123\"]"
+                ),
+            }
+
         set_kw = {
             "test": "Set Test Variable",
             "suite": "Set Suite Variable",
@@ -2336,22 +2348,34 @@ async def manage_session(
         }.get(scope.lower(), "Set Suite Variable")
 
         results: Dict[str, bool] = {}
+        errors: Dict[str, str] = {}
         client = _get_external_client_if_configured()
         if client is not None:
             for name, value in data.items():
                 try:
                     resp = client.set_variable(name, value, scope=scope)
                     results[name] = bool(resp.get("success"))
-                except Exception:
+                    if not results[name]:
+                        errors[name] = resp.get("error", "Bridge returned success=false")
+                except Exception as e:
                     results[name] = False
-            return {
+                    errors[name] = str(e)
+            result_payload: Dict[str, Any] = {
                 "success": all(results.values()),
                 "action": "set_variables",
                 "session_id": session_id,
-                "set": list(results.keys()),
+                "set": [k for k, v in results.items() if v],
                 "scope": scope,
                 "external": True,
             }
+            if errors:
+                result_payload["errors"] = errors
+                result_payload["hint"] = (
+                    "Some variables failed to set via bridge. "
+                    "Check that the RF process is running and the bridge is reachable. "
+                    "Use manage_attach(action='status') to verify bridge health."
+                )
+            return result_payload
 
         for name, value in data.items():
             # Pass value directly with ${name} syntax - RF 7 handles Python
@@ -2364,6 +2388,8 @@ async def manage_session(
                 use_context=True,
             )
             results[name] = bool(res.get("success"))
+            if not results[name]:
+                errors[name] = res.get("error", "Keyword execution returned success=false")
 
         # Track ALL manage_session variables for *** Variables *** section generation
         # Variables set via manage_session (any scope) should be included in the Variables
@@ -2384,13 +2410,20 @@ async def manage_session(
         except Exception as track_error:
             logger.warning(f"Failed to track manage_session variables: {track_error}")
 
-        return {
+        result_payload = {
             "success": all(results.values()),
             "action": "set_variables",
             "session_id": session_id,
-            "set": list(results.keys()),
+            "set": [k for k, v in results.items() if v],
             "scope": scope,
         }
+        if errors:
+            result_payload["errors"] = errors
+            result_payload["hint"] = (
+                "Some variables failed to set. Ensure the session was initialized "
+                "with manage_session(action='init') first and that BuiltIn library is loaded."
+            )
+        return result_payload
 
     if action_norm in {"import_variables", "load_variables"}:
         if not variable_file_path:

{rf_mcp-0.28.dev1 → rf_mcp-0.28.dev2}/src/robotmcp/utils/rf_libdoc_integration.py

@@ -284,20 +284,32 @@ class RobotFrameworkDocStorage:
         return keywords
     
     def search_keywords(self, pattern: str) -> List[RFKeywordInfo]:
-        """Search for keywords matching a pattern."""
+        """Search for keywords matching a pattern.
+
+        Supports glob wildcards (*, ?, []) for name matching.
+        Plain text without wildcards uses substring matching across
+        name, doc, short_doc, and tags.
+        """
         if not HAS_LIBDOC:
             return []
-            
-        pattern = pattern.lower()
+
+        import fnmatch
+
+        is_glob = any(c in pattern for c in "*?[")
+        pattern_lower = pattern.lower()
         matches = []
-        
+
         for keyword_info in self.get_all_keywords():
-            if (pattern in keyword_info.name.lower() or 
-                pattern in keyword_info.doc.lower() or
-                pattern in keyword_info.short_doc.lower() or
-                any(pattern in tag.lower() for tag in keyword_info.tags)):
-                matches.append(keyword_info)
-        
+            if is_glob:
+                if fnmatch.fnmatch(keyword_info.name.lower(), pattern_lower):
+                    matches.append(keyword_info)
+            else:
+                if (pattern_lower in keyword_info.name.lower() or
+                    pattern_lower in keyword_info.doc.lower() or
+                    pattern_lower in keyword_info.short_doc.lower() or
+                    any(pattern_lower in tag.lower() for tag in keyword_info.tags)):
+                    matches.append(keyword_info)
+
         return matches
     
     def get_library_documentation(self, library_name: str) -> Optional[RFLibraryInfo]: