fix(engine): fix visual baseline location, optimize a11y script injection, and resolve windows terminal encoding crash

Author: pras-ops

scrapewizard/cli/main.py

@@ -1,7 +1,18 @@
+import sys
 import typer
 from scrapewizard.cli.commands import setup, scrape, utils, engine
 from scrapewizard.core.logging import Logger
 
+# Ensure Windows/CMD/PowerShell console supports UTF-8/emoji output without crashing
+try:
+    if hasattr(sys.stdout, "reconfigure"):
+        sys.stdout.reconfigure(encoding="utf-8")
+    if hasattr(sys.stderr, "reconfigure"):
+        sys.stderr.reconfigure(encoding="utf-8")
+except Exception:
+    pass
+
+
 app = typer.Typer(
     name="scrapewizard",
     help="Agentic Web Scraper Builder",

scrapewizard/engine/checks/a11y.py

@@ -3,18 +3,18 @@
 from typing import List, Dict, Any
 from scrapewizard.core.logging import log
 
-# Read the bundled script content once and cache it in memory
+# Read the bundled script content once at module load and cache it
 AXE_SCRIPT_PATH = Path(__file__).parent / "axe.min.js"
 AXE_SCRIPT_CONTENT = None
 
 if AXE_SCRIPT_PATH.exists():
     with open(AXE_SCRIPT_PATH, "r", encoding="utf-8") as f:
         AXE_SCRIPT_CONTENT = f.read()
 
-async def perform_a11y_check(page) -> List[Dict[str, Any]]:
+async def _ensure_axe_loaded(page) -> bool:
     """
-    Inject axe-core into the target Playwright page, run analysis,
-    and return a structured list of accessibility violations.
+    Check if axe-core is already loaded in the page context.
+    If not, inject it once. Returns True if axe is available.
     """
     global AXE_SCRIPT_CONTENT
 
@@ -24,11 +24,23 @@ async def perform_a11y_check(page) -> List[Dict[str, Any]]:
                 AXE_SCRIPT_CONTENT = f.read()
         else:
             log("axe.min.js not found, skipping accessibility check", level="warning")
-            return []
+            return False
 
-    try:
-        # Inject the axe-core library
+    # Check if axe is already injected (avoids re-injecting 538KB on every step)
+    already_loaded = await page.evaluate("typeof window.axe !== 'undefined'")
+    if not already_loaded:
         await page.evaluate(AXE_SCRIPT_CONTENT)
+    
+    return True
+
+async def perform_a11y_check(page) -> List[Dict[str, Any]]:
+    """
+    Inject axe-core into the target Playwright page (if not already present),
+    run analysis, and return a structured list of accessibility violations.
+    """
+    try:
+        if not await _ensure_axe_loaded(page):
+            return []
 
         # Run accessibility analysis
         # axe.run() returns a promise, so we evaluate it asynchronously

scrapewizard/engine/recorder.py

@@ -60,11 +60,10 @@ async def on_event_callback(action: str, temp_id: str, value: str, warnings_json
                     log(f"Failed to capture element fingerprint: {e}", level="error")
                     return
 
-                # Check for password masking
+                # Mask password field values for security
                 recorded_value = value
-                if fingerprint.attributes.get("type") == "password" or action == "fill" and value != "***MASKED***":
-                    if fingerprint.attributes.get("type") == "password":
-                        recorded_value = "***MASKED***"
+                if fingerprint.attributes.get("type") == "password":
+                    recorded_value = "***MASKED***"
 
                 # Primary selector
                 primary_selector = fingerprint.selectors[0]["value"] if fingerprint.selectors else ""

scrapewizard/engine/sandbox.py

@@ -66,20 +66,35 @@ class SandboxRunner:
     Isolated test runner that executes generated steps and tracks visual, console,
     network, and accessibility status quality signals.
     """
-    def __init__(self, artifacts_dir: Optional[str] = None, headless: bool = True):
+    def __init__(
+        self,
+        artifacts_dir: Optional[str] = None,
+        baselines_dir: Optional[str] = None,
+        flow_name: str = "default",
+        headless: bool = True,
+    ):
         self.headless = headless
 
-        # Setup artifacts directories
+        # Setup per-run artifacts directory (screenshots, diffs, reports)
         if artifacts_dir:
             self.artifacts_dir = Path(artifacts_dir)
         else:
             timestamp = int(time.time())
             self.artifacts_dir = Path("runs") / f"run_{timestamp}"
 
         self.screenshots_dir = self.artifacts_dir / "screenshots"
-        self.baselines_dir = self.artifacts_dir / "baselines"
         self.diffs_dir = self.artifacts_dir / "diffs"
 
+        # Baselines live in a STABLE shared location, NOT under the per-run
+        # artifacts dir. This ensures successive runs compare against the same
+        # baseline images instead of re-baselining every execution.
+        if baselines_dir:
+            self.baselines_dir = Path(baselines_dir)
+        else:
+            self.baselines_dir = (
+                Path.home() / ".scrapewizard" / "baselines" / flow_name
+            )
+
         self.screenshots_dir.mkdir(parents=True, exist_ok=True)
         self.baselines_dir.mkdir(parents=True, exist_ok=True)
         self.diffs_dir.mkdir(parents=True, exist_ok=True)

tests/engine/test_sandbox.py

@@ -18,6 +18,7 @@ async def test_sandbox_runner_golden_flow(demo_server, tmp_path):
     flow_json = tmp_path / "flow.json"
     screenshots_dir = tmp_path / "screenshots"
     artifacts_dir = tmp_path / "sandbox_artifacts"
+    baselines_dir = tmp_path / "baselines"
 
     # 1. Record
     recorder = InteractiveRecorder(
@@ -47,7 +48,7 @@ async def drive_recorder():
     test_def = generator.generate()
 
     # 3. Run sandbox
-    runner = SandboxRunner(artifacts_dir=str(artifacts_dir), headless=True)
+    runner = SandboxRunner(artifacts_dir=str(artifacts_dir), baselines_dir=str(baselines_dir), headless=True)
     run_result = await runner.run(test_def)
 
     # 4. Assertions
@@ -71,3 +72,93 @@ async def drive_recorder():
     assert step1.console_errors is not None
     assert step1.network_errors is not None
     assert step1.a11y_violations is not None
+
+
+@pytest.mark.asyncio
+async def test_baselines_are_stable(demo_server, tmp_path):
+    """
+    Verify that running the sandbox twice with the same baselines_dir actually
+    REUSES baselines from the first run (no re-baselining).
+    """
+    baselines_dir = tmp_path / "shared_baselines"
+
+    # Minimal test def: just navigate
+    test_def = {
+        "url": demo_server,
+        "steps": [{
+            "name": "navigate_to_start",
+            "action": "navigate",
+            "value": demo_server,
+            "selectors": [],
+            "assertions": [{"kind": "url", "value": demo_server}]
+        }]
+    }
+
+    # Run 1: should CREATE baselines
+    runner1 = SandboxRunner(
+        artifacts_dir=str(tmp_path / "run1"),
+        baselines_dir=str(baselines_dir),
+        headless=True,
+    )
+    result1 = await runner1.run(test_def)
+    assert result1.status == "passed"
+
+    # Baselines should now exist
+    baseline_files = list(baselines_dir.glob("*.png"))
+    assert len(baseline_files) > 0, "Baselines should have been created"
+
+    # Record the modification time of the baseline
+    mtime_after_run1 = baseline_files[0].stat().st_mtime
+
+    # Run 2: should COMPARE against existing baselines (not overwrite)
+    runner2 = SandboxRunner(
+        artifacts_dir=str(tmp_path / "run2"),
+        baselines_dir=str(baselines_dir),
+        headless=True,
+    )
+    result2 = await runner2.run(test_def)
+    assert result2.status == "passed"
+
+    # Baseline file should NOT have been overwritten
+    mtime_after_run2 = baseline_files[0].stat().st_mtime
+    assert mtime_after_run1 == mtime_after_run2, "Baseline should not be overwritten on second run"
+
+    # Visual diff should be 0 or very close (same page, same viewport)
+    nav_step = result2.step_results[0]
+    assert nav_step.visual_diff_score is not None
+    assert nav_step.visual_diff_score < 0.1, f"Expected near-zero visual diff, got {nav_step.visual_diff_score}"
+
+
+def test_visual_check_diff_detection(tmp_path):
+    """Unit test for the visual comparison engine's diff detection."""
+    from PIL import Image
+    from scrapewizard.engine.checks.visual import perform_visual_check
+
+    baselines_dir = tmp_path / "baselines"
+    diff_dir = tmp_path / "diffs"
+
+    # Create a solid red baseline image
+    img1 = Image.new("RGB", (100, 100), color="red")
+    baselines_dir.mkdir(parents=True, exist_ok=True)
+    img1.save(baselines_dir / "step_1.png")
+
+    # Create a solid blue "current" screenshot
+    current_path = tmp_path / "current.png"
+    img2 = Image.new("RGB", (100, 100), color="blue")
+    img2.save(current_path)
+
+    # They should differ significantly
+    score, diff_path = perform_visual_check(
+        str(current_path), "step_1", str(baselines_dir), str(diff_dir)
+    )
+    assert score > 0.5, f"Expected high diff score for red vs blue, got {score}"
+    assert diff_path is not None
+    assert Path(diff_path).exists()
+
+    # Now compare identical images — diff should be 0
+    score2, diff_path2 = perform_visual_check(
+        str(baselines_dir / "step_1.png"), "step_1", str(baselines_dir), str(diff_dir)
+    )
+    assert score2 == 0.0
+    assert diff_path2 is None
+