selenium-selector-autocorrect 0.1.1__py3-none-any.whl → 0.1.2__py3-none-any.whl

selenium_selector_autocorrect/__init__.py

@@ -15,7 +15,7 @@ Environment Variables:
     SELENIUM_AUTO_UPDATE_TESTS: Auto-update test files with corrections (default: "0")
 """
 
-__version__ = "0.1.1"
+__version__ = "0.1.2"
 
 from .ai_providers import AIProvider, LocalAIProvider, configure_provider, get_provider
 from .auto_correct import (

selenium_selector_autocorrect/ai_providers.py

@@ -48,14 +48,24 @@ class LocalAIProvider(AIProvider):
         if self._available is not None:
             return self._available
         try:
-            response = requests.post(
-                f"{self.base_url}/v1/chat/completions",
-                json={"messages": [{"role": "user", "content": "test"}], "max_tokens": 1},
-                timeout=5
-            )
+            url = f"{self.base_url}/v1/chat/completions"
+            payload = {"messages": [{"role": "user", "content": "test"}], "max_tokens": 1}
+            
+            logger.debug(f"[AI-REQUEST] POST {url}")
+            logger.debug(f"[AI-REQUEST] Payload: {payload}")
+            
+            response = requests.post(url, json=payload, timeout=30)
+            
+            logger.debug(f"[AI-RESPONSE] Status: {response.status_code}")
+            logger.debug(f"[AI-RESPONSE] Headers: {dict(response.headers)}")
+            logger.debug(f"[AI-RESPONSE] Body length: {len(response.text)} chars")
+            if response.text:
+                logger.debug(f"[AI-RESPONSE] Body preview: {response.text[:500]}")
+            
             self._available = response.status_code in (200, 400)
         except Exception as e:
             logger.info(f"Local AI service not available at {self.base_url}: {e}")
+            logger.debug(f"[AI-ERROR] Exception details: {type(e).__name__}: {str(e)}")
             self._available = False
         return self._available
     
@@ -70,23 +80,37 @@ class LocalAIProvider(AIProvider):
             AI response text or None if request fails
         """
         try:
-            response = requests.post(
-                f"{self.base_url}/v1/chat/completions",
-                json={
-                    "messages": [
-                        {"role": "system", "content": system_prompt},
-                        {"role": "user", "content": user_prompt}
-                    ],
-                    "temperature": 0.3,
-                    "max_tokens": 500
-                },
-                timeout=30
-            )
+            url = f"{self.base_url}/v1/chat/completions"
+            payload = {
+                "messages": [
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": user_prompt}
+                ],
+                "temperature": 0.3,
+                "max_tokens": 500
+            }
+            
+            logger.debug(f"[AI-REQUEST] POST {url}")
+            logger.debug(f"[AI-REQUEST] System prompt ({len(system_prompt)} chars): {system_prompt[:200]}...")
+            logger.debug(f"[AI-REQUEST] User prompt ({len(user_prompt)} chars): {user_prompt[:200]}...")
+            logger.debug(f"[AI-REQUEST] Full payload: {payload}")
+            
+            response = requests.post(url, json=payload, timeout=30)
+            
+            logger.debug(f"[AI-RESPONSE] Status: {response.status_code}")
+            logger.debug(f"[AI-RESPONSE] Headers: {dict(response.headers)}")
+            logger.debug(f"[AI-RESPONSE] Body length: {len(response.text)} chars")
+            logger.debug(f"[AI-RESPONSE] Full body: {response.text[:2000]}")
+            
             response.raise_for_status()
             data: Dict[str, Any] = response.json()
             content: Optional[str] = data.get("choices", [{}])[0].get("message", {}).get("content", "")
+            logger.debug(f"[AI-PARSED] Content length: {len(content) if content else 0} chars")
+            logger.debug(f"[AI-PARSED] Content preview: {content[:500] if content else 'None'}")
             return content
         except requests.exceptions.HTTPError as e:
+            logger.error(f"[AI-ERROR] HTTP Error {e.response.status_code}")
+            logger.error(f"[AI-ERROR] Response body: {e.response.text[:1000]}")
             if e.response.status_code == 503:
                 logger.info(f"Local AI service unavailable (503). Disabling auto-correction.")
                 self._available = False
@@ -94,7 +118,8 @@ class LocalAIProvider(AIProvider):
                 logger.warning(f"Local AI HTTP error: {e}")
             return None
         except Exception as e:
-            logger.warning(f"Local AI request failed: {e}")
+            logger.error(f"[AI-ERROR] Request failed: {type(e).__name__}: {str(e)}")
+            logger.debug(f"[AI-ERROR] Exception details: {e}", exc_info=True)
             self._available = False
             return None
 

selenium_selector_autocorrect/correction_tracker.py

@@ -3,8 +3,10 @@
 import json
 import logging
 import os
+import re
 import traceback
 from datetime import datetime
+from pathlib import Path
 from typing import Any, Dict, List, Optional, TypedDict
 
 import requests
@@ -39,6 +41,8 @@ class CorrectionTracker:
         self._corrections: List[CorrectionRecord] = []
         self._local_ai_url: str = os.environ.get("LOCAL_AI_API_URL", "http://localhost:8765")
         self._auto_update_enabled: bool = os.environ.get("SELENIUM_AUTO_UPDATE_TESTS", "0").lower() in ("1", "true", "yes")
+        # Configurable import pattern - set via environment variable for project-specific structure
+        self._import_pattern: str = os.environ.get("SELENIUM_IMPORT_PATTERN", r'from\s+([\w.]+)\s+import')
 
     def record_correction(
         self,
@@ -65,16 +69,11 @@ class CorrectionTracker:
                     '/selenium_selector_autocorrect/' in filename_lower or
                     '\\selenium_selector_autocorrect\\' in filename):
                     continue
-                # Prioritize test files, then page objects, then ui_client
-                if ('test_library' in filename or
-                    'test_' in filename or
-                    'page_factory' in filename_lower or
-                    'ui_client' in filename_lower):
+                # Prioritize test files first
+                if 'test_' in filename:
                     test_file = filename
                     test_line = frame.lineno
-                    # Don't break - keep looking for test files specifically
-                    if 'test_' in filename or 'test_library' in filename:
-                        break
+                    break
 
         correction: CorrectionRecord = {
             "original_by": original_by,
@@ -113,20 +112,349 @@ class CorrectionTracker:
             test_file = correction.get("test_file")
             if not test_file:
                 return
-            result = self.update_test_file_via_service(
+            
+            # Get all files that need to be updated (test file + referenced files)
+            files_to_update = self._find_files_with_selector(
                 test_file,
-                correction["original_by"],
-                correction["original_value"],
-                correction["corrected_by"],
-                correction["corrected_value"]
+                correction["original_value"]
             )
-            if result.get("success"):
-                logger.info(f"[AUTO-UPDATE] Successfully updated {test_file}")
-            else:
-                logger.warning(f"[AUTO-UPDATE] Failed to update {test_file}: {result.get('errors', [])}")
+            
+            updated_count = 0
+            failed_count = 0
+            
+            for file_path in files_to_update:
+                result = self.update_test_file_via_service(
+                    file_path,
+                    correction["original_by"],
+                    correction["original_value"],
+                    correction["corrected_by"],
+                    correction["corrected_value"]
+                )
+                if result.get("success"):
+                    updated_count += 1
+                    logger.info(f"[AUTO-UPDATE] Successfully updated {file_path}")
+                else:
+                    failed_count += 1
+                    logger.warning(f"[AUTO-UPDATE] Failed to update {file_path}: {result.get('errors', [])}")
+            
+            if updated_count > 0:
+                logger.info(f"[AUTO-UPDATE] Updated {updated_count} file(s), {failed_count} failed")
         except Exception as e:
             logger.warning(f"[AUTO-UPDATE] Error updating test file: {e}")
 
+    def _find_files_with_selector(self, test_file: str, selector_value: str) -> List[str]:
+        """Find all files that contain the selector and are used by the test file.
+        
+        Backward search strategy:
+        1. Search for selector text in all Python files (fast workspace grep)
+        2. Extract all imports from test file (with recursion for nested imports)
+        3. Return only files that contain the selector AND are imported by the test
+        
+        This is efficient because:
+        - Workspace search is very fast (indexed)
+        - We only verify imports for files that actually have the selector
+        - Typically finds 1-5 files instead of checking 100s
+        """
+        files_with_selector: List[str] = []
+        
+        try:
+            logger.debug(f"[BACKWARD SEARCH] Searching for selector: {selector_value}")
+            
+            # Step 1: Search for files containing the selector (fast workspace search)
+            # Try different search queries since literal string search may fail with special characters
+            workspace_files = []
+            search_queries = [
+                selector_value,  # Try full selector first
+                # Strip common CSS selector wrappers and search for cleaner text
+                selector_value.replace('[', '').replace(']', '').replace('"', '').replace("'", '').strip(),
+            ]
+            
+            logger.debug(f"[BACKWARD SEARCH] Will try {len(search_queries)} search queries")
+            for i, search_query in enumerate(search_queries):
+                logger.debug(f"[BACKWARD SEARCH] Query {i+1}: {search_query[:100]}")
+                if search_query and not workspace_files:
+                    files = self._workspace_search_for_selector(search_query)
+                    if files:
+                        workspace_files = files
+                        logger.debug(f"[BACKWARD SEARCH] ✓ Found {len(files)} matches with query {i+1}")
+                        break
+                    else:
+                        logger.debug(f"[BACKWARD SEARCH] ✗ No matches with query {i+1}")
+            
+            logger.info(f"[BACKWARD SEARCH] Workspace search found {len(workspace_files)} file(s)")
+            
+            if not workspace_files:
+                logger.debug(f"[BACKWARD SEARCH] No matches found with workspace search")
+                logger.info(f"[AUTO-UPDATE] Found selector in 0 file(s): []")
+                return files_with_selector
+            
+            # Step 2: Extract all imports from test file (with recursion for nested imports)
+            all_imports = self._extract_all_imports_from_test(test_file)
+            logger.debug(f"[BACKWARD SEARCH] Test file imports {len(all_imports)} files")
+            
+            # Normalize paths for comparison
+            test_file_normalized = os.path.normpath(test_file)
+            all_imports_normalized = {os.path.normpath(f) for f in all_imports}
+            
+            # Step 3: Verify which matched files are actually used by the test
+            for file_path in workspace_files:
+                file_path_normalized = os.path.normpath(file_path)
+                
+                # Check if this is the test file itself
+                if file_path_normalized == test_file_normalized:
+                    logger.debug(f"[BACKWARD SEARCH] ✓ Selector in test file: {file_path}")
+                    files_with_selector.append(file_path)
+                    continue
+                
+                # Check if this file is in the imports (direct match)
+                if file_path_normalized in all_imports_normalized:
+                    logger.debug(f"[BACKWARD SEARCH] ✓ Selector in imported file: {file_path}")
+                    files_with_selector.append(file_path)
+                    continue
+                
+                # Check if the file path matches any import by filename
+                # (handles different path separators and relative vs absolute paths)
+                file_name = os.path.basename(file_path)
+                for imported_file in all_imports:
+                    if os.path.basename(imported_file) == file_name:
+                        # Verify it's the same file by checking if paths end the same way
+                        imported_parts = imported_file.replace('\\', '/').split('/')
+                        file_parts = file_path.replace('\\', '/').split('/')
+                        
+                        # Compare the last N parts of the path
+                        min_parts = min(len(imported_parts), len(file_parts))
+                        if imported_parts[-min_parts:] == file_parts[-min_parts:]:
+                            logger.debug(f"[BACKWARD SEARCH] ✓ Selector in imported file: {file_path}")
+                            files_with_selector.append(imported_file)  # Use the full path from imports
+                            break
+                else:
+                    logger.debug(f"[BACKWARD SEARCH] ✗ Selector in unrelated file: {file_path}")
+        
+        except Exception as e:
+            logger.debug(f"[BACKWARD SEARCH] Error during search: {e}")
+        
+        logger.info(f"[AUTO-UPDATE] Found selector in {len(files_with_selector)} file(s): {files_with_selector}")
+        return files_with_selector
+    
+    def _workspace_search_for_selector(self, selector_value: str) -> List[str]:
+        """Try to find files using workspace search API. Returns empty list if not found or API unavailable."""
+        try:
+            # Use dedicated search endpoint (not the unified AI endpoint)
+            search_url = f"{self._local_ai_url}/v1/workspace/files/search"
+            # Prefer a narrower search first (avoids huge workspaces like venv), then fall back.
+            preferred_pattern = os.environ.get("SELENIUM_WORKSPACE_SEARCH_FILE_PATTERN", "src/**/*.py")
+            patterns_to_try = [preferred_pattern, "**/*.py"]
+            seen_patterns = set()
+
+            for file_pattern in patterns_to_try:
+                if not file_pattern or file_pattern in seen_patterns:
+                    continue
+                seen_patterns.add(file_pattern)
+
+                search_payload = {
+                    "query": selector_value,
+                    "filePattern": file_pattern,
+                    "maxResults": 50
+                }
+
+                logger.debug(f"[WORKSPACE-SEARCH-REQUEST] URL: {search_url}")
+                logger.debug(f"[WORKSPACE-SEARCH-REQUEST] Payload: {search_payload}")
+
+                response = requests.post(search_url, json=search_payload, timeout=30)
+
+                logger.debug(f"[WORKSPACE-SEARCH-RESPONSE] Status: {response.status_code}")
+                logger.debug(f"[WORKSPACE-SEARCH-RESPONSE] Headers: {dict(response.headers)}")
+                logger.debug(f"[WORKSPACE-SEARCH-RESPONSE] Body length: {len(response.text)} chars")
+
+                if not response.ok:
+                    logger.debug(f"[WORKSPACE-SEARCH-RESPONSE] Body: {response.text[:500]}")
+                    logger.debug(f"[WORKSPACE-SEARCH] Request failed: {response.status_code}")
+                    continue
+
+                search_results = response.json()
+                logger.debug(f"[WORKSPACE-SEARCH-RESPONSE] Parsed JSON keys: {list(search_results.keys())}")
+                logger.debug(f"[WORKSPACE-SEARCH-RESPONSE] Full response: {search_results}")
+
+                file_paths: List[str] = []
+
+                # Handle dedicated endpoint 'results' markdown format
+                results_text = search_results.get("results", "")
+                logger.debug(f"[WORKSPACE-SEARCH] Results text length: {len(results_text)} chars")
+                logger.debug(f"[WORKSPACE-SEARCH] Results text preview: {results_text[:300]}")
+
+                if results_text and "No matches found" not in results_text:
+                    logger.debug(f"[WORKSPACE-SEARCH] Parsing markdown results ({len(results_text)} chars)")
+                    for line in results_text.split('\n'):
+                        if line.startswith('## ') and line.endswith('.py'):
+                            file_path = line[3:].strip()
+                            if '__pycache__' not in file_path and not file_path.endswith('.pyc') and file_path not in file_paths:
+                                file_paths.append(file_path)
+                                logger.debug(f"[WORKSPACE-SEARCH] Added file: {file_path}")
+                else:
+                    logger.debug(f"[WORKSPACE-SEARCH] No results in response")
+
+                if file_paths:
+                    logger.info(
+                        f"[WORKSPACE-SEARCH] Found {len(file_paths)} file(s) with selector (pattern={file_pattern})"
+                    )
+                    return file_paths
+
+                logger.debug(f"[WORKSPACE-SEARCH] No files found (pattern={file_pattern})")
+
+            return []
+            
+        except Exception as e:
+            logger.error(f"[WORKSPACE-SEARCH-ERROR] Failed: {type(e).__name__}: {str(e)}")
+            logger.debug(f"[WORKSPACE-SEARCH-ERROR] Details: {e}", exc_info=True)
+            return []
+    
+    def _extract_all_imports_from_test(self, test_file: str, max_depth: int = 3, visited: Optional[set] = None) -> List[str]:  # noqa: A006
+        """Extract all imported files from test file recursively.
+        
+        Used by backward search to verify if a file is actually imported by the test.
+        Only recurses into page objects (not utilities) for efficiency.
+        """
+        if visited is None:
+            visited = set()
+        
+        if test_file in visited or max_depth <= 0:
+            return []
+        
+        visited.add(test_file)
+        all_imports = []
+        
+        try:
+            direct_imports = self._extract_imported_files(test_file)
+            all_imports.extend(direct_imports)
+            
+            # Recursively extract imports from page objects only
+            if max_depth > 1:
+                for imported_file in direct_imports:
+                    if imported_file not in visited and self._is_page_object_file(imported_file):
+                        nested = self._extract_all_imports_from_test(imported_file, max_depth - 1, visited)
+                        all_imports.extend(nested)
+        
+        except Exception as e:
+            logger.debug(f"[IMPORT EXTRACTION] Error: {e}")
+        
+        return all_imports
+    
+    def _is_page_object_file(self, file_path: str) -> bool:
+        """Check if a file is likely a page object or steps file (not a utility or base class)."""
+        file_lower = file_path.lower()
+        
+        # Include: Page objects, Dialogs, Modals, Components, Steps
+        if any(pattern in file_lower for pattern in ['page.py', 'dialog.py', 'modal.py', 'section.py', 'steps.py', 'step.py']):
+            return True
+        
+        # Include: Files in component/header/steps directories
+        if any(pattern in file_lower for pattern in ['component', 'header', 'footer', 'sidebar', '/steps/', '\\steps\\']):
+            return True
+        
+        # Exclude: Utilities, base classes, helpers, drivers, clients
+        if any(pattern in file_lower for pattern in ['utility.py', 'helper.py', 'base.py', 'util.py', '__init__.py', 'driver.py', 'client.py']):
+            return False
+        
+        return False
+
+    def _extract_imported_files(self, test_file: str) -> List[str]:
+        """Extract imported page object file paths from a test file."""
+        imported_files: List[str] = []
+        
+        try:
+            # Read the test file content via dedicated endpoint
+            read_url = f"{self._local_ai_url}/v1/workspace/files/read"
+            read_payload = {"filePath": test_file}
+            
+            logger.debug(f"[FILE-READ-REQUEST] URL: {read_url}")
+            logger.debug(f"[FILE-READ-REQUEST] Payload: {read_payload}")
+            
+            read_response = requests.post(read_url, json=read_payload, timeout=30)
+            
+            logger.debug(f"[FILE-READ-RESPONSE] Status: {read_response.status_code}")
+            logger.debug(f"[FILE-READ-RESPONSE] Headers: {dict(read_response.headers)}")
+            logger.debug(f"[FILE-READ-RESPONSE] Body length: {len(read_response.text)} chars")
+            
+            if not read_response.ok:
+                logger.debug(f"[FILE-READ-RESPONSE] Body: {read_response.text[:500]}")
+                return imported_files
+            
+            file_content = read_response.json()
+            logger.debug(f"[FILE-READ-RESPONSE] Parsed JSON keys: {list(file_content.keys())}")
+            logger.debug(f"[FILE-READ-RESPONSE] Full response: {file_content}")
+            
+            if not file_content.get("success"):
+                logger.debug(f"[FILE-READ] Read failed: success={file_content.get('success')}")
+                return imported_files
+            
+            content = file_content.get("content", "")
+            logger.debug(f"[FILE-READ] Content length: {len(content)} chars")
+            
+            # Pattern to match imports - configurable via SELENIUM_IMPORT_PATTERN env var
+            for match in re.finditer(self._import_pattern, content):
+                module_path = match.group(1)
+                # Convert module path to file path
+                file_path = self._module_to_file_path(module_path, test_file)
+                if file_path:
+                    imported_files.append(file_path)
+            
+            # Also extract from imports in step functions and page objects
+            # Pattern: from <path> import <class>
+            step_import_pattern = r'from\s+([\w.]+)\s+import\s+([\w,\s]+)'
+            for match in re.finditer(step_import_pattern, content):
+                module_path = match.group(1)
+                # Include Page classes and step files (configurable via environment variable)
+                keywords = os.environ.get("SELENIUM_IMPORT_KEYWORDS", "Page,.steps.,steps").split(",")
+                if any(keyword.strip() in module_path for keyword in keywords):
+                    file_path = self._module_to_file_path(module_path, test_file)
+                    if file_path:
+                        imported_files.append(file_path)
+        
+        except Exception as e:
+            logger.debug(f"[IMPORT EXTRACTION] Error: {e}")
+        
+        return imported_files
+
+    def _module_to_file_path(self, module_path: str, reference_file: str) -> Optional[str]:
+        """Convert a Python module path to a file path."""
+        try:
+            # Extract the root package name from module_path
+            parts = module_path.split('.')
+            if not parts:
+                return None
+            
+            root_package = parts[0]
+            ref_path = Path(reference_file)
+            
+            # Find the root package directory by going up from the reference file
+            current = ref_path.parent
+            package_root = None
+            
+            while current.parent != current:
+                if (current / root_package).exists():
+                    package_root = current / root_package
+                    break
+                current = current.parent
+            
+            if not package_root:
+                return None
+            
+            # Convert module path to relative path, removing the root package
+            relative_parts = parts[1:]  # Remove root package prefix
+            if not relative_parts:
+                return None
+            
+            relative_path = Path(*relative_parts)
+            file_path = package_root / relative_path.with_suffix('.py')
+            
+            if file_path.exists():
+                return str(file_path).replace('\\', '/')
+            
+        except Exception as e:
+            logger.debug(f"[MODULE CONVERSION] Error converting {module_path}: {e}")
+        
+        return None
+
     def update_test_file_via_service(
         self,
         file_path: str,
@@ -136,45 +464,152 @@ class CorrectionTracker:
         corrected_value: str
     ) -> Dict[str, Any]:
         try:
+            # Read the file using dedicated endpoint
             read_url = f"{self._local_ai_url}/v1/workspace/files/read"
-            read_response = requests.post(read_url, json={"filePath": file_path}, timeout=30)
+            read_payload = {"filePath": file_path}
+            
+            logger.debug(f"[FILE-EDIT-READ-REQUEST] URL: {read_url}")
+            logger.debug(f"[FILE-EDIT-READ-REQUEST] Payload: {read_payload}")
+            
+            read_response = requests.post(read_url, json=read_payload, timeout=30)
+            
+            logger.debug(f"[FILE-EDIT-READ-RESPONSE] Status: {read_response.status_code}")
+            logger.debug(f"[FILE-EDIT-READ-RESPONSE] Headers: {dict(read_response.headers)}")
+            logger.debug(f"[FILE-EDIT-READ-RESPONSE] Body length: {len(read_response.text)} chars")
+            
             read_response.raise_for_status()
             file_content = read_response.json()
+            
+            logger.debug(f"[FILE-EDIT-READ-RESPONSE] Parsed JSON keys: {list(file_content.keys())}")
 
             if not file_content.get("success"):
+                logger.error(f"[FILE-EDIT] Read failed: {file_content}")
                 return {"success": False, "errors": ["Could not read file"]}
 
             content = file_content.get("content", "")
-            old_patterns = [
-                f'"{original_value}"',
-                f"'{original_value}'",
-            ]
+            logger.debug(f"[FILE-EDIT] Read {len(content)} chars from {file_path}")
+
+            def _strategy_to_by_token(strategy: str) -> Optional[str]:
+                s = (strategy or "").strip().lower()
+                mapping = {
+                    "css selector": "CSS_SELECTOR",
+                    "css": "CSS_SELECTOR",
+                    "xpath": "XPATH",
+                    "id": "ID",
+                    "name": "NAME",
+                    "class name": "CLASS_NAME",
+                    "class": "CLASS_NAME",
+                    "tag name": "TAG_NAME",
+                    "tag": "TAG_NAME",
+                    "link text": "LINK_TEXT",
+                    "partial link text": "PARTIAL_LINK_TEXT",
+                }
+                return mapping.get(s)
+
+            corrected_by_token = _strategy_to_by_token(corrected_by)
+
+            # Prefer strategy-aware replacements like: By.XPATH, '<old>' -> By.ID, '<new>'
+            # This prevents invalid updates such as leaving By.XPATH with an id value.
+            replacements: List[Dict[str, str]] = []
+            if corrected_by_token:
+                # Find all occurrences of the selector value inside a By.<TOKEN>, '<value>' pair.
+                # We intentionally allow any existing By token to be replaced.
+                locator_pattern = re.compile(
+                    r"By\\.[A-Z_]+(\\s*,\\s*)(['\"])" + re.escape(original_value) + r"\\2"
+                )
+
+                for match in locator_pattern.finditer(content):
+                    quote = match.group(2)
+                    escaped_corrected_value = corrected_value.replace(quote, f"\\{quote}")
+                    old_substring = match.group(0)
+                    new_substring = f"By.{corrected_by_token}{match.group(1)}{quote}{escaped_corrected_value}{quote}"
+                    if old_substring != new_substring:
+                        replacements.append({"oldString": old_substring, "newString": new_substring})
+
+                if replacements:
+                    logger.debug(f"[FILE-EDIT] Prepared {len(replacements)} strategy-aware replacement(s)")
+                else:
+                    logger.debug("[FILE-EDIT] No strategy-aware matches found")
+            
+            # If we couldn't find a By.<TOKEN>, '<value>' match, fall back to value-only replacement
+            # ONLY when the strategy does not change (or we don't know the corrected strategy).
+            if not replacements:
+                corrected_by_normalized = (corrected_by or "").strip().lower()
+                original_by_normalized = (original_by or "").strip().lower()
+
+                if corrected_by_token and corrected_by_normalized != original_by_normalized:
+                    logger.warning(
+                        "[FILE-EDIT] Strategy changed but no locator match found; refusing unsafe value-only update"
+                    )
+                    return {
+                        "success": False,
+                        "errors": [
+                            "Strategy changed (e.g. xpath -> id) but locator tuple not found in file; skipping unsafe edit"
+                        ],
+                    }
+
+                old_patterns = [
+                    f'"{original_value}"',
+                    f"'{original_value}'",
+                ]
+
+                found_pattern = None
+                new_pattern = None
+                for old_pattern in old_patterns:
+                    if old_pattern in content:
+                        found_pattern = old_pattern
+                        logger.debug(f"[FILE-EDIT] Found value-only pattern: {old_pattern[:100]}")
+
+                        # Choose quote style based on what's in the corrected value
+                        if "'" in corrected_value and '"' not in corrected_value:
+                            new_pattern = f'"{corrected_value}"'
+                        elif '"' in corrected_value and "'" not in corrected_value:
+                            new_pattern = f"'{corrected_value}'"
+                        elif "'" in corrected_value and '"' in corrected_value:
+                            if old_pattern.startswith('"'):
+                                escaped_value = corrected_value.replace('"', '\\"')
+                                new_pattern = f'"{escaped_value}"'
+                            else:
+                                escaped_value = corrected_value.replace("'", "\\'")
+                                new_pattern = f"'{escaped_value}'"
+                        else:
+                            new_pattern = f'"{corrected_value}"' if old_pattern.startswith('"') else f"'{corrected_value}'"
 
-            found_pattern = None
-            new_pattern = None
-            for old_pattern in old_patterns:
-                if old_pattern in content:
-                    found_pattern = old_pattern
-                    new_pattern = f'"{corrected_value}"' if old_pattern.startswith('"') else f"'{corrected_value}'"
-                    break
+                        break
 
-            if not found_pattern:
-                return {"success": False, "errors": [f"Could not find selector: {original_value[:50]}..."]}
+                if not found_pattern or new_pattern is None:
+                    logger.warning(f"[FILE-EDIT] Could not find selector: {original_value[:50]}")
+                    return {"success": False, "errors": [f"Could not find selector: {original_value[:50]}..."]}
 
+                replacements = [{"oldString": found_pattern, "newString": new_pattern}]
+
+            # Use dedicated endpoint for edit (supports multiple replacements)
             edit_url = f"{self._local_ai_url}/v1/workspace/files/edit"
-            edit_response = requests.post(
-                edit_url,
-                json={"filePath": file_path, "oldString": found_pattern, "newString": new_pattern},
-                timeout=30
-            )
+            edit_payload = {"filePath": file_path, "replacements": replacements}
+            
+            logger.debug(f"[FILE-EDIT-REQUEST] URL: {edit_url}")
+            logger.debug(f"[FILE-EDIT-REQUEST] Payload: {edit_payload}")
+            
+            edit_response = requests.post(edit_url, json=edit_payload, timeout=30)
+            
+            logger.debug(f"[FILE-EDIT-RESPONSE] Status: {edit_response.status_code}")
+            logger.debug(f"[FILE-EDIT-RESPONSE] Headers: {dict(edit_response.headers)}")
+            logger.debug(f"[FILE-EDIT-RESPONSE] Body length: {len(edit_response.text)} chars")
+            logger.debug(f"[FILE-EDIT-RESPONSE] Body: {edit_response.text[:1000]}")
+            
             edit_response.raise_for_status()
             result: Dict[str, Any] = edit_response.json()
+            
+            logger.debug(f"[FILE-EDIT-RESPONSE] Parsed JSON: {result}")
+            logger.info(f"[FILE-EDIT] File update result: success={result.get('success')}")
             return result
-        except requests.exceptions.ConnectionError:
+        except requests.exceptions.ConnectionError as e:
+            logger.error(f"[FILE-EDIT-ERROR] Connection failed: {e}")
             logger.warning(f"[LOCAL AI SERVICE] Not available at {self._local_ai_url}")
             return {"success": False, "errors": ["Local AI service not available"]}
         except Exception as e:
-            logger.warning(f"[UPDATE ERROR] {e}")
+            logger.error(f"[FILE-EDIT-ERROR] {type(e).__name__}: {str(e)}")
+            logger.debug(f"[FILE-EDIT-ERROR] Details: {e}", exc_info=True)
             return {"success": False, "errors": [str(e)]}
 
     def export_corrections_report(self, output_file: str = "selector_corrections.json") -> None:

{selenium_selector_autocorrect-0.1.1.dist-info → selenium_selector_autocorrect-0.1.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: selenium-selector-autocorrect
-Version: 0.1.1
+Version: 0.1.2
 Summary: Automatic Selenium selector correction using AI when elements fail to be found
 Author-email: Marty Zhou <marty.zhou@example.com>
 Maintainer-email: Marty Zhou <marty.zhou@example.com>
@@ -75,22 +75,6 @@ element = WebDriverWait(driver, 10).until(
 )
 ```
 
-## AI Service Setup
-
-This package requires a local AI service with an OpenAI-compatible API. We recommend using **[VS Code Copilot as Service](https://marketplace.visualstudio.com/items?itemName=MartyZhou.vscode-copilot-as-service)**, which exposes GitHub Copilot through a local HTTP server.
-
-### Installing VS Code Copilot as Service
-
-1. Install from VS Code Marketplace or run:
-   ```bash
-   code --install-extension MartyZhou.vscode-copilot-as-service
-   ```
-
-2. The extension automatically starts a server on `http://localhost:8765`
-
-3. Requires an active GitHub Copilot subscription
-
-
 ## Configuration
 
 Configure via environment variables:
@@ -124,67 +108,28 @@ install_auto_correct_hook()
 
 ```python
 from selenium_selector_autocorrect import (
-    install_auto_correct_hook,
     get_auto_correct,
     get_correction_tracker,
-    export_corrections_report
+    export_corrections_report,
 )
 
-install_auto_correct_hook()
-
 auto_correct = get_auto_correct()
 auto_correct.enabled = True
-auto_correct.suggest_better_selectors = False
 
-# Export corrections report at end of test run
 tracker = get_correction_tracker()
 export_corrections_report("corrections_report.json")
-tracker = get_correction_tracker()
-export_corrections_report("corrections_report.json")
-
-print(f"Total corrections: {len(tracker.get_corrections())}")
-print(f"Successful corrections: {len(tracker.get_successful_corrections())}")
 ```
 
-### Custom AI Provider
-
-```python
-from selenium_selector_autocorrect import AIProvider, configure_provider
-
-class CustomAIProvider(AIProvider):
-    def is_available(self) -> bool:
-        return True
-    
-    def suggest_selector(self, system_prompt: str, user_prompt: str):))
-```
-
-## How It Works
-
-1. **Hook Installation**: Patches `WebDriverWait.until()` to add auto-correction
-2. **Timeout Detection**: When a selector times out, the original exception is caught
-3. **Page Analysis**: JavaScript extracts visible elements and their attributes
-4. **AI Suggestion**: Sends page context to AI provider for selector suggestion
-5. **Verification**: Tests the suggested selector
-6. **Success Handling**: If successful, records the correction and optionally updates the test file
-7. **Fallback**: If correction fails, raises the original TimeoutException
-
-## AI Provider Setup
-
-### Local AI Service
-
-The package requires a local AI service with OpenAI-compatible API:
+## AI Service Setup
 
-```bash
-POST http://localhost:8765/v1/chat/completions
-```
+This package requires a local AI service with an OpenAI-compatible API. The following endpoints are used:
 
-For file auto-updates:
-```bash
-POST http://localhost:8765/v1/workspace/files/read
-POST http://localhost:8765/v1/workspace/files/edit
-## Correction Reports
+- `POST {LOCAL_AI_API_URL}/v1/chat/completions` — chat completions for suggestions
+- `POST {LOCAL_AI_API_URL}/v1/workspace/files/read` — read file content
+- `POST {LOCAL_AI_API_URL}/v1/workspace/files/edit` — apply edits to files
+- `POST {LOCAL_AI_API_URL}/v1/workspace/files/search` — search workspace
 
-Export correction reports in JSON format:
+## Exporting Reports
 
 ```python
 from selenium_selector_autocorrect import export_corrections_report
@@ -193,6 +138,7 @@ export_corrections_report("corrections_report.json")
 ```
 
 Report format:
+
 ```json
 {
   "corrections": [
@@ -215,13 +161,13 @@ Report format:
 }
 ```
 
-## Best Practices
+## Troubleshooting
+
+**AI service not available**: Ensure the local AI service is running and reachable via `LOCAL_AI_API_URL`.
 
-1. **Install Once**: Call `install_auto_correct_hook()` once at test suite startup (e.g., in `conftest.py`)
-2. **Review Corrections**: Regularly review correction reports to identify brittle selectors
-3. **Update Tests**: Use auto-update sparingly and review changes before committing
-4. **Monitor AI Service**: Ensure your AI service is running and responsive
-5. **Use Strong Selectors**: The tool helps with failures but writing robust selectors is still preferred
+**Auto-update not running**: Verify `SELENIUM_AUTO_UPDATE_TESTS` is set to `"1"`.
+
+**Selector strings not found when updating**: Check quote styles in your source files match those used in the correction.
 
 ## Requirements
 
@@ -231,47 +177,45 @@ Report format:
 
 ## License
 
-MITInstall hook once at test suite startup (e.g., in conftest.py)
-2. Review correction reports regularly to identify brittle selectors
-3. Use auto-update sparingly and review changes before committing
-4. Ensure your AI service is running and responsive
-5. Write robust selectors - the tool helps with failures but prevention is better
+MIT
 
-When contributing:
-1. Follow PEP 8 style guidelines
-2. Add tests for new features
-3. Update documentation
-4. No emojis in code or documentation
+## Contributing
 
-## Troubleshooting
+Please follow PEP 8, add tests for new features, and update documentation when changing behavior.
 
-### AI Service Not Available
+See [CHANGELOG.md](CHANGELOG.md) for release notes and version history.
 
-Contributions are welcome! Please:
-1. Follow PEP 8 style guidelines
-2. Add tests for new features
-3. Update documentation
-4. Maintain consistency with existing code
+## Publishing to PyPI
 
-**Possible causes**:
-- `SELENIUM_AUTO_UPDATE_TESTS` not set to `"1"`
-- Test file path not detected correctly
-- Selector string not found in source file (check quotes)
+Create a PyPI API token at https://pypi.org/manage/account/#api-tokens (recommended scope: project or account) and keep the token secret. PyPI no longer accepts username/password uploads — use the token as the password and `__token__` as the username.
 
-### No Corrections Happening
-Solution: Ensure your local AI service is running on the configured port.
+PowerShell (Windows) example:
 
-### Test File Not Updated
+```powershell
+$env:TWINE_USERNAME='__token__'
+$env:TWINE_PASSWORD='pypi-XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX'
+.\venv\Scripts\python.exe -m pip install --upgrade build twine
+.\venv\Scripts\python.exe -m build
+.\venv\Scripts\python.exe -m twine upload dist/*
+```
 
-Possible causes:
-- `SELENIUM_AUTO_UPDATE_TESTS` not set to "1"
-- Test file path not detected correctly
-- Selector string not found in source file
+Unix / macOS example:
 
-### No Corrections Happening
+```bash
+export TWINE_USERNAME='__token__'
+export TWINE_PASSWORD='pypi-XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX'
+python3 -m pip install --upgrade build twine
+python3 -m build
+python3 -m twine upload dist/*
+```
+
+To publish to TestPyPI (verify release first):
+
+```bash
+python3 -m twine upload --repository-url https://test.pypi.org/legacy/ dist/*
+```
 
-Check:
-1. Hook is installed - look for log message
-2. AI service is available - check `get_auto_correct().is_service_available()`
-3. Auto-correct is enabled - c
-See CHANGELOG.md for version history and changes.
+Notes:
+- Use an API token (not account password). If using a CI system, store the token in secure secrets.
+- You can add a persistent `~/.pypirc` for repeated uploads; see PyPI documentation for details.
+- If upload fails with a 403, verify the token is correct and has the required scope.

selenium_selector_autocorrect-0.1.2.dist-info/RECORD

@@ -0,0 +1,10 @@
+selenium_selector_autocorrect/__init__.py,sha256=aP02rJbuJxwqMDuc1Y-LoNA3AMYeoCe0_0q_xYNKnTE,1665
+selenium_selector_autocorrect/ai_providers.py,sha256=MIsnwIgTSQQxL4uex4f_4l886EvGLLXvojbheyMgjuI,5966
+selenium_selector_autocorrect/auto_correct.py,sha256=ME2dxkN4liNC797x1nFn-HAKvyXxl7q2ePv5SNon42w,11335
+selenium_selector_autocorrect/correction_tracker.py,sha256=VXmu-9Qgcknl6DOuIuawG_LQJNr3B_N0eHQDghygQEk,32927
+selenium_selector_autocorrect/wait_hook.py,sha256=Vs1FRtKG73i1Cphgf4a3_P5MTdlrWdeOnmzG1ewnlS4,7659
+selenium_selector_autocorrect-0.1.2.dist-info/licenses/LICENSE,sha256=VRPy6YXF2wA_3MeTDnpa_-6Zgjt8c2C0D_iIyhDkduc,1095
+selenium_selector_autocorrect-0.1.2.dist-info/METADATA,sha256=Oh8ha_xAm2MGYGx_lguQ2_citrtVBoaLSM83u236qGk,7318
+selenium_selector_autocorrect-0.1.2.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+selenium_selector_autocorrect-0.1.2.dist-info/top_level.txt,sha256=nQ78Mk-XHDhYBckP0tMZvoFAZmZGO4Ec4-e1i61Fdz0,30
+selenium_selector_autocorrect-0.1.2.dist-info/RECORD,,

selenium_selector_autocorrect-0.1.1.dist-info/RECORD

@@ -1,10 +0,0 @@
-selenium_selector_autocorrect/__init__.py,sha256=v1Up86il_XXBgXbZLZiXm_hFlTO1MO5EXKCPQfb0pAs,1665
-selenium_selector_autocorrect/ai_providers.py,sha256=CtoLGYvzKWsZBzr5DW6H8vWnTpb5HIAmPhmi_BYddsU,4237
-selenium_selector_autocorrect/auto_correct.py,sha256=ME2dxkN4liNC797x1nFn-HAKvyXxl7q2ePv5SNon42w,11335
-selenium_selector_autocorrect/correction_tracker.py,sha256=XG3U3tSoGxwmLoBrPi8tc3eWtMDqKG6qJa0K4W7pK54,9984
-selenium_selector_autocorrect/wait_hook.py,sha256=Vs1FRtKG73i1Cphgf4a3_P5MTdlrWdeOnmzG1ewnlS4,7659
-selenium_selector_autocorrect-0.1.1.dist-info/licenses/LICENSE,sha256=VRPy6YXF2wA_3MeTDnpa_-6Zgjt8c2C0D_iIyhDkduc,1095
-selenium_selector_autocorrect-0.1.1.dist-info/METADATA,sha256=EGdbgP_v7OyZDGcNLeFafxY_DcjRoiZRf-mxbjGK4fo,9221
-selenium_selector_autocorrect-0.1.1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-selenium_selector_autocorrect-0.1.1.dist-info/top_level.txt,sha256=nQ78Mk-XHDhYBckP0tMZvoFAZmZGO4Ec4-e1i61Fdz0,30
-selenium_selector_autocorrect-0.1.1.dist-info/RECORD,,