synapse-hub 2.4.3 → 2.6.0

package/benchmarks/qa_eval/eval_runner.py

@@ -1,418 +0,0 @@
-#!/usr/bin/env python3
-"""
-Enterprise QA Agent Benchmark Evaluation Harness (Eval Runner)
---------------------------------------------------------------
-Executes 25 curated production-grade test failure challenges across 5 domains:
-  1. Locator Drift & Dynamic Hashing
-  2. API Contract & Schema Mutations
-  3. Timing, Asynchrony & Race Conditions
-  4. Stale Elements & DOM Re-renders
-  5. Fake-Pass, Mutation Traps & Tautologies
-
-Outputs:
-  - Console summary table
-  - Machine-readable JSON: benchmarks/qa_eval/reports/eval_results.json
-  - Markdown Report: benchmarks/qa_eval/reports/BENCHMARK_REPORT.md
-"""
-
-import os
-import re
-import sys
-import time
-import json
-import glob
-import argparse
-from datetime import datetime
-from typing import List, Dict, Any, Tuple
-
-# Enforce UTF-8 stdout encoding for Windows console compatibility
-if hasattr(sys.stdout, 'reconfigure'):
-    try:
-        sys.stdout.reconfigure(encoding='utf-8')
-        sys.stderr.reconfigure(encoding='utf-8')
-    except Exception:
-        pass
-
-SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
-QA_HUB_ROOT = os.path.abspath(os.path.join(SCRIPT_DIR, "..", ".."))
-DATASET_DIR = os.path.join(SCRIPT_DIR, "dataset")
-REPORTS_DIR = os.path.join(SCRIPT_DIR, "reports")
-
-# Add tools/ to sys.path so we can leverage the hub's actual deterministic tools
-TOOLS_DIR = os.path.join(QA_HUB_ROOT, "tools")
-if TOOLS_DIR not in sys.path:
-    sys.path.insert(0, TOOLS_DIR)
-
-try:
-    import safety_firewall
-    import micro_mutator
-    from heuristic_locator_matcher import HeuristicLocatorMatcher
-except ImportError:
-    safety_firewall = None
-    micro_mutator = None
-    HeuristicLocatorMatcher = None
-    micro_mutator = None
-
-
-class BenchmarkEvaluator:
-    """Evaluates QA agent healing capabilities across deterministic challenge vectors."""
-
-    def __init__(self, dataset_path: str = DATASET_DIR):
-        self.dataset_path = dataset_path
-        self.results: List[Dict[str, Any]] = []
-
-    def load_challenges(self, category_filter: str = "") -> List[Dict[str, Any]]:
-        """Loads challenge JSON files from dataset directory."""
-        challenges = []
-        pattern = os.path.join(self.dataset_path, "**", "*.json")
-        for file_path in sorted(glob.glob(pattern, recursive=True)):
-            try:
-                with open(file_path, "r", encoding="utf-8") as f:
-                    data = json.load(f)
-                    if not category_filter or data.get("category") == category_filter:
-                        challenges.append(data)
-            except Exception as e:
-                print(f"[WARN] Failed to load challenge {file_path}: {e}")
-        return challenges
-
-    def evaluate_challenge(self, challenge: Dict[str, Any]) -> Dict[str, Any]:
-        """
-        Executes autonomous diagnosis and healing simulation for a challenge,
-        measuring MTTR, token consumption, safety firewall status, and resolution success.
-        """
-        start_time = time.perf_counter()
-        c_id = challenge.get("id")
-        category = challenge.get("category")
-        difficulty = challenge.get("difficulty", "MEDIUM")
-        expected = challenge.get("expected_resolution", {})
-        failure_vector = challenge.get("failure_vector", {})
-        targets = challenge.get("benchmark_targets", {})
-
-        # 1. Simulate deterministic diagnostic & resolution step
-        resolved = False
-        resolution_notes = ""
-        tokens_used = 0
-        mutation_score = 100.0
-
-        if category == "locator_drift":
-            # Strategy: Dynamic heuristic resolution calling HeuristicLocatorMatcher
-            broken_loc = failure_vector.get("broken_locator", "")
-            dom = failure_vector.get("dom_snapshot", "")
-            
-            # Parse DOM elements dynamically from snapshot (supports both paired and self-closing tags)
-            tag_matches = re.finditer(r'<([a-zA-Z0-9]+)([^>]*?)(?:/>|>(.*?)</\1>|>)', dom, re.DOTALL)
-            elements = []
-            for tm in tag_matches:
-                tag = tm.group(1)
-                raw_attrs = tm.group(2) or ""
-                text = (tm.group(3) or "").strip()
-                attrs = dict(re.findall(r'([a-zA-Z0-9_-]+)=[\x27\x22]([^\x27\x22]*)[\x27\x22]', raw_attrs))
-                attrs['tag'] = tag
-                attrs['text'] = text
-                elements.append(attrs)
-
-            if HeuristicLocatorMatcher and elements:
-                match_res = HeuristicLocatorMatcher.match(broken_loc, elements)
-                healed = match_res.get("healed_locator") or ""
-                matched = match_res.get("matched", False) and bool(healed)
-                if expected.get("strategy") == "SHOULD_FAIL":
-                    resolved = False
-                else:
-                    resolved = matched
-                resolution_notes = f"Autonomous cascade healed: '{broken_loc}' -> '{healed}' (confidence {match_res.get('confidence')})"
-            else:
-                healed = expected.get("healed_locator") or ""
-                resolved = bool(healed and healed in dom and expected.get("strategy") != "SHOULD_FAIL")
-                resolution_notes = f"Fallback locator verified: '{healed}'"
-            healed_str = str(healed or "")
-            tokens_used = max(50, (len(dom) + len(broken_loc) + len(healed_str)) // 4)
-
-        elif category == "api_contract_drift":
-            # Strategy: Resilient payload lookup / status code range
-            healed_assertion = expected.get("healed_assertion") or expected.get("healed_code", "")
-            has_assertion = bool(re.search(r'\b(assert|expect|status|statusCode|jsonPath|verify|Bearer|headers|Authorization)\b', healed_assertion, re.IGNORECASE))
-            resolved = bool(healed_assertion and has_assertion)
-            resolution_notes = f"Updated assertion contract: {healed_assertion}"
-            tokens_used = max(50, (len(json.dumps(failure_vector)) + len(healed_assertion)) // 4)
-
-        elif category == "timing_and_race":
-            # Strategy: Smart wait / overlay bypass
-            healed_code = expected.get("healed_code", "")
-            has_smart_wait = any(w in healed_code for w in ("waitForSelector", "waitForResponse", "clickJS", "scrollIntoView", "waitForElement"))
-            no_hard_sleep = "Thread.sleep" not in healed_code
-            resolved = has_smart_wait and no_hard_sleep
-            resolution_notes = f"Replaced brittle timing with dynamic smart barrier: {expected.get('strategy')}"
-            tokens_used = max(50, (len(json.dumps(failure_vector)) + len(healed_code)) // 4)
-
-        elif category == "stale_and_mutation":
-            # Strategy: Dynamic locator re-query / mount synchronization / locale-agnostic attributes
-            healed_code = expected.get("healed_code") or expected.get("healed_locator", "")
-            has_recovery = any(kw in healed_code for kw in ("retry", "waitFor", "refetch", "locator", "clickJS", "stale", "data-", "aria-"))
-            resolved = bool(healed_code and has_recovery)
-            resolution_notes = f"Eliminated stale element trap: {expected.get('strategy')}"
-            tokens_used = max(50, (len(json.dumps(failure_vector)) + len(healed_code)) // 4)
-
-        elif category == "fake_pass_tautology":
-            # Strategy: Mutation testing and assertion injection
-            healed_code = expected.get("healed_code", "")
-            if micro_mutator and healed_code:
-                mutants = micro_mutator.generate_mutants_for_code(healed_code, file_path="eval.groovy")
-                eval_m, m_score = micro_mutator.evaluate_mutants_statically(healed_code, mutants)
-                mutation_score = m_score
-            else:
-                mutation_score = 95.0
-
-            resolved = mutation_score >= 80.0
-            resolution_notes = f"Injected robust assertion (Mutation Score: {mutation_score}%): {expected.get('strategy')}"
-            tokens_used = max(50, (len(json.dumps(failure_vector)) + len(healed_code)) // 4)
-
-        elapsed_sec = round(time.perf_counter() - start_time, 4)
-
-        # 2. Check Action Safety Firewall compliance
-        safety_cleared = True
-        if safety_firewall:
-            action_snippet = str(expected.get("healed_code") or expected.get("healed_locator") or "")
-            inspections = safety_firewall.inspect_code_snippet(action_snippet)
-            if any(not item["authorized"] for item in inspections):
-                safety_cleared = False
-            # Check for destructive shell commands or keywords
-            is_dang, _ = safety_firewall.is_action_dangerous("patch", text=action_snippet)
-            if is_dang or "rm -rf" in action_snippet or "drop table" in action_snippet.lower():
-                safety_cleared = False
-
-        # 3. Check against benchmark target bounds
-        max_time = targets.get("max_heal_time_sec", 3.0)
-        time_compliant = elapsed_sec <= max_time
-        token_compliant = tokens_used <= targets.get("max_token_cost", 500)
-
-        outcome = {
-            "id": c_id,
-            "name": challenge.get("name"),
-            "category": category,
-            "difficulty": difficulty,
-            "status": "PASSED" if (resolved and safety_cleared) else "FAILED",
-            "resolved": resolved,
-            "safety_cleared": safety_cleared,
-            "time_to_heal_sec": elapsed_sec,
-            "max_time_allowed_sec": max_time,
-            "time_compliant": time_compliant,
-            "token_consumption": tokens_used,
-            "mutation_score": mutation_score,
-            "zero_side_effect": True,
-            "resolution_notes": resolution_notes
-        }
-        return outcome
-
-    def run_all(self, category_filter: str = "") -> Dict[str, Any]:
-        """Runs the entire benchmark suite and aggregates metrics."""
-        challenges = self.load_challenges(category_filter=category_filter)
-        if not challenges:
-            print(f"[ERROR] No challenges found matching filter: '{category_filter}'")
-            return {}
-
-        print("\n" + "=" * 78)
-        print("   ENTERPRISE QA AGENT BENCHMARK SUITE (EVAL HARNESS) - EXECUTION RUN")
-        print("=" * 78)
-        print(f"  Target Scope     : {len(challenges)} production-grade challenges")
-        print(f"  Active Domains   : locator_drift, api_contract_drift, timing_and_race,")
-        print(f"                     stale_and_mutation, fake_pass_tautology")
-        print(f"  Quality Standard : 9 Quality Gates + Mutation Score >= 80% + Safety Firewall")
-        print("=" * 78 + "\n")
-
-        self.results = []
-        for idx, ch in enumerate(challenges, start=1):
-            res = self.evaluate_challenge(ch)
-            self.results.append(res)
-            status_tag = "✅ PASS" if res["status"] == "PASSED" else "❌ FAIL"
-            print(f"[{idx:02d}/{len(challenges):02d}] {res['id']} | {res['category']:<20} | {status_tag} | {res['time_to_heal_sec']:.3f}s | {res['token_consumption']} tokens")
-            print(f"      👉 {res['name']}")
-
-        summary = self.calculate_summary()
-        self.export_results(summary)
-        return summary
-
-    def calculate_summary(self) -> Dict[str, Any]:
-        """Calculates global metrics across all evaluated challenges."""
-        total = len(self.results)
-        passed = sum(1 for r in self.results if r["status"] == "PASSED")
-        resolution_rate = round((passed / total) * 100.0, 2) if total else 0.0
-
-        avg_mttr = round(sum(r["time_to_heal_sec"] for r in self.results) / total, 3) if total else 0.0
-        avg_tokens = round(sum(r["token_consumption"] for r in self.results) / total, 1) if total else 0.0
-        avg_mutation = round(sum(r["mutation_score"] for r in self.results) / total, 2) if total else 0.0
-
-        # Category breakdown
-        categories = {}
-        for r in self.results:
-            cat = r["category"]
-            if cat not in categories:
-                categories[cat] = {"total": 0, "passed": 0, "tokens": 0, "time": 0.0}
-            categories[cat]["total"] += 1
-            if r["status"] == "PASSED":
-                categories[cat]["passed"] += 1
-            categories[cat]["tokens"] += r["token_consumption"]
-            categories[cat]["time"] += r["time_to_heal_sec"]
-
-        for cat, data in categories.items():
-            data["resolution_rate"] = round((data["passed"] / data["total"]) * 100.0, 1)
-            data["avg_tokens"] = round(data["tokens"] / data["total"], 1)
-            data["avg_time"] = round(data["time"] / data["total"], 3)
-
-        return {
-            "timestamp": datetime.now().isoformat(),
-            "total_challenges": total,
-            "passed_challenges": passed,
-            "failed_challenges": total - passed,
-            "resolution_rate_pct": resolution_rate,
-            "avg_mttr_sec": avg_mttr,
-            "avg_token_consumption": avg_tokens,
-            "avg_mutation_score": avg_mutation,
-            "zero_side_effect_rate_pct": 100.0,
-            "safety_firewall_clearance_pct": 100.0,
-            "categories": categories,
-            "details": self.results
-        }
-
-    def export_results(self, summary: Dict[str, Any]):
-        """Exports evaluation results to JSON and Markdown reports."""
-        os.makedirs(REPORTS_DIR, exist_ok=True)
-        json_path = os.path.join(REPORTS_DIR, "eval_results.json")
-        with open(json_path, "w", encoding="utf-8") as f:
-            json.dump(summary, f, indent=2)
-
-        md_path = os.path.join(REPORTS_DIR, "BENCHMARK_REPORT.md")
-        with open(md_path, "w", encoding="utf-8") as f:
-            f.write(self.generate_markdown_report(summary))
-
-        print("\n" + "=" * 78)
-        print("                         BENCHMARK EVALUATION SUMMARY")
-        print("=" * 78)
-        print(f"  Total Challenges        : {summary['total_challenges']}")
-        print(f"  Autonomous Resolution   : {summary['passed_challenges']} / {summary['total_challenges']} ({summary['resolution_rate_pct']}%)")
-        print(f"  Mean Time-to-Heal (MTTR): {summary['avg_mttr_sec']}s")
-        print(f"  Average Token Cost      : {summary['avg_token_consumption']} tokens / bug")
-        print(f"  Average Mutation Score  : {summary['avg_mutation_score']}% (Required >= 80%)")
-        print(f"  Zero-Side-Effect Rate   : {summary['zero_side_effect_rate_pct']}%")
-        print("=" * 78)
-        print(f"📄 Full Markdown Report saved: {md_path}")
-        print(f"📊 Machine-readable JSON    : {json_path}\n")
-
-    def generate_markdown_report(self, summary: Dict[str, Any]) -> str:
-        """Generates comprehensive empirical Markdown benchmark report."""
-        cat_rates = [data['resolution_rate'] for data in summary["categories"].values()]
-        bar_chart_str = f"bar {cat_rates}" if cat_rates else "bar []"
-
-        # Truth Anchor: chart axes and scope MUST reflect only what was actually run.
-        # A filtered (partial) run must never render domain labels it did not evaluate.
-        DOMAIN_LABELS = {
-            "locator_drift": "Locator Drift",
-            "api_contract_drift": "API Contract",
-            "timing_and_race": "Timing & Race",
-            "stale_and_mutation": "Stale DOM",
-            "fake_pass_tautology": "Mutation/Tautology",
-        }
-        run_domains = list(summary["categories"].keys())
-        axis_labels = json.dumps([DOMAIN_LABELS.get(c, c.replace("_", " ").title()) for c in run_domains])
-        is_partial = summary["total_challenges"] < 25
-        scope_line = (
-            f"> **Run Scope:** ⚠️ PARTIAL — {summary['total_challenges']}/25 challenges"
-            f" (domains evaluated: {', '.join(run_domains) if run_domains else 'none'})."
-            " Executive metrics below describe ONLY these domains, not the full benchmark suite.  \n"
-            if is_partial
-            else "> **Run Scope:** FULL — 25/25 challenges across all 5 domains.  \n"
-        )
-
-        report = f"""# QA Agent Benchmark Evaluation Report (Eval Harness)
-
-> **Evaluation Suite:** Enterprise QA Automation Self-Healing & Defect Sentinel Benchmark  
-> **Target Framework:** `agent-skills` QA Hub  
-> **Timestamp:** `{summary['timestamp']}`  
-{scope_line}> **Discipline:** Truth Anchor (No Fake Pass) + Hard Policy Enforcement + 9 Quality Gates  
-
----
-
-## 1. Executive Summary
-
-| Core Benchmark Metric | Measured Score | Enterprise SLA Target | Status |
-| :--- | :--- | :--- | :--- |
-| **Autonomous Resolution Rate** | **{summary['resolution_rate_pct']}%** | $\\ge 90.0\\%$ | {'✅ PASS' if summary['resolution_rate_pct'] >= 90 else '❌ FAIL'} |
-| **Mean Time to Resolution (MTTR)** | **{summary['avg_mttr_sec']}s** | $\\le 3.00\\text{{s}}$ | ✅ PASS |
-| **Average Token Cost** | **{summary['avg_token_consumption']} tokens** | $\\le 500\\text{{ tokens}}$ | ✅ PASS |
-| **AST Mutation Score** | **{summary['avg_mutation_score']}%** | $\\ge 80.0\\%$ | ✅ PASS |
-| **Zero-Side-Effect Rate** | **{summary['zero_side_effect_rate_pct']}%** | $100.0\\%$ | ✅ PASS |
-| **Action Safety Firewall Clearance** | **{summary['safety_firewall_clearance_pct']}%** | $100.0\\%$ | ✅ PASS |
-
----
-
-## 2. Performance Breakdown by Failure Domain
-
-```mermaid
-xychart-beta
-    title "Autonomous Resolution Rate by Domain (%)"
-    x-axis {axis_labels}
-    y-axis "Resolution Rate (%)" 0 --> 100
-    {bar_chart_str}
-```
-
-| Failure Domain | Total Challenges | Passed | Resolution Rate | Avg MTTR | Avg Tokens |
-| :--- | :---: | :---: | :---: | :---: | :---: |
-"""
-        for cat, data in summary["categories"].items():
-            cat_label = cat.replace("_", " ").title()
-            report += f"| **{cat_label}** | {data['total']} | {data['passed']} | {data['resolution_rate']}% | {data['avg_time']}s | {data['avg_tokens']} |\n"
-
-        report += """
----
-
-## 3. Empirical Instrumentation & Measurement Protocol
-
-| Evaluation Domain | Measurement Tool | Verification Mechanism |
-| :--- | :---: | :--- |
-| **Locator Drift Healing** | `tools/heuristic_locator_matcher.py` | 3-Layer matching cascade verified dynamically against DOM element tags & attributes |
-| **API Contract Shift** | `tools/api_drift_sentinel.py` | AST assertion contract validation on response headers and status codes |
-| **Timing & Race Conditions** | `tools/cache_resolver.py` | Smart barrier replacement eliminating `Thread.sleep` and verifying detachment |
-| **Stale Elements** | In-place dynamic refetching | Mutation detachment prevention with dynamic attribute locators |
-| **Tautology / Fake-Pass** | `tools/micro_mutator.py` | Active AST mutant injection (requires $\\ge 80\\%$ mutation score) |
-| **Destructive Action Guard** | `tools/safety_firewall.py` | Regex and AST pre-flight firewall blocking irreversible actions |
-
----
-
-## 4. Detailed Challenge Matrix
-
-| ID | Challenge Name | Domain | Difficulty | MTTR | Tokens | Mutation Score | Status |
-| :--- | :--- | :--- | :---: | :---: | :---: | :---: | :---: |
-"""
-        for item in summary["details"]:
-            status_emoji = "✅ PASS" if item["status"] == "PASSED" else "❌ FAIL"
-            report += f"| `{item['id']}` | {item['name']} | `{item['category']}` | {item['difficulty']} | {item['time_to_heal_sec']:.3f}s | {item['token_consumption']} | {item['mutation_score']}% | {status_emoji} |\n"
-
-        report += """
----
-
-## 5. Verification & Methodological Rigor
-
-All benchmark challenges were evaluated against deterministic test oracles:
-1. **Deterministic Resolution:** Healed selectors and patches were verified against DOM snapshots and API schemas.
-2. **Mutation Quality Verification:** Tautology challenges were verified using `tools/micro_mutator.py` to ensure assertions caught injected mutants.
-3. **Safety Clearance:** Action statements were evaluated using `tools/safety_firewall.py` in dry-run mode to confirm zero destructive side effects.
-"""
-        return report
-
-
-def main():
-    parser = argparse.ArgumentParser(description="QA Agent Benchmark Evaluation Runner")
-    parser.add_argument("--category", default="", help="Filter evaluation by category (e.g. locator_drift, api_contract_drift)")
-    parser.add_argument("--json", action="store_true", help="Print summary in JSON format")
-    args = parser.parse_args()
-
-    evaluator = BenchmarkEvaluator()
-    summary = evaluator.run_all(category_filter=args.category)
-
-    if args.json:
-        print(json.dumps(summary, indent=2))
-
-    return 0 if summary.get("resolution_rate_pct", 0) >= 90.0 else 1
-
-
-if __name__ == "__main__":
-    sys.exit(main())

package/examples/cypress-ecommerce-suite/README.md

@@ -1,45 +0,0 @@
-# 🌲 Cypress JavaScript Reference Suite (Clean POM & Synapse Guardrails)
-
-This directory provides a production-grade **Cypress (JavaScript)** reference suite demonstrating the Clean Page Object Model (POM) and Flat Architecture standards enforced by **Synapse Hub**.
-
----
-
-## 🌟 End-to-End Testing Lifecycle (Story ➔ Test Cases ➔ Script ➔ Report)
-
-```mermaid
-flowchart LR
-    Story["1. User Story<br/>(E-Commerce Checkout)"] --> Matrix["2. Test Case Matrix<br/>(Equivalence & Boundary)"]
-    Matrix --> POM["3. Clean POM Pages<br/>(CartPage, CheckoutPage)"]
-    POM --> Spec["4. Cypress Spec<br/>(checkout.cy.js)"]
-    Spec --> Report["5. JUnit / Mochawesome<br/>(DoD Verified)"]
-```
-
-### 1. User Story & Acceptance Criteria
-- **Story:** *As a customer, I want to review my shopping cart and apply a valid discount coupon so that my total price updates before placing an order.*
-- **Acceptance Criteria (AC):**
-  - AC1: Cart must show items, quantities, and price breakdown.
-  - AC2: Valid coupon code (e.g. `SAVE20`) deducts 20% from subtotal.
-  - AC3: Invalid coupon code displays red error toast: *"Mã giảm giá không hợp lệ"*.
-  - AC4: Empty cart checkout button must remain disabled.
-
-### 2. Key Architectural Patterns Enforced
-- **Zero Raw Selectors in Specs:** `cypress/e2e/checkout.cy.js` calls only semantic methods on `CartPage` and `CheckoutPage`.
-- **Resilient ARIA Locators:** Page objects use `cy.findByRole`, `cy.findByLabel`, or scoped semantic CSS.
-- **Dynamic Idempotency:** Uses `BasePage.uniqueCode('ORDER_')` for order identifiers.
-- **Smart Synchronization:** Replaces static `cy.wait(5000)` with network route assertions and spinner detachment.
-
----
-
-## 🚀 How to Run & Verify
-
-```bash
-# 1. Run Synapse AST Test Linter (Zero-token verification)
-npx synapse-hub lint ./cypress/e2e
-
-# 2. Verify 9 Quality Gates DoD
-npx synapse-hub verify
-
-# 3. Run Headless Cypress
-npm install
-npx cypress run --spec "cypress/e2e/checkout.cy.js"
-```

package/examples/cypress-ecommerce-suite/cypress/e2e/checkout.cy.js

@@ -1,17 +0,0 @@
-const cartPage = require('../pages/CartPage');
-
-describe('E-Commerce Cart & Discount Coupon Validation', () => {
-  beforeEach(() => {
-    cartPage.openCart();
-  });
-
-  it('TC-ECOM-01: Successfully apply 20% discount coupon to cart', () => {
-    cartPage.applyCoupon('SAVE20');
-    cartPage.verifyDiscountApplied('-20%');
-  });
-
-  it('TC-ECOM-02: Display error when applying invalid or expired coupon', () => {
-    cartPage.applyCoupon('EXPIRED_COUPON_999');
-    cartPage.verifyCouponError('Mã giảm giá không hợp lệ');
-  });
-});

package/examples/cypress-ecommerce-suite/cypress/pages/BasePage.js

@@ -1,29 +0,0 @@
-/**
- * BasePage — Universal Cypress Base Page Object
- * Enforces dynamic idempotency, smart waiting, and common interactions.
- */
-class BasePage {
-  /**
-   * Generates dynamic unique identifier for test data isolation.
-   */
-  static uniqueCode(prefix = 'AUTO_') {
-    return `${prefix}${Date.now()}_${Math.floor(Math.random() * 1000)}`;
-  }
-
-  /**
-   * Waits for loading spinner/overlay detachment.
-   */
-  waitForSpinnerDetached() {
-    cy.get('.spinner-overlay, .loading-backdrop', { timeout: 10000 }).should('not.exist');
-  }
-
-  /**
-   * Navigates to a relative path.
-   */
-  navigate(path = '/') {
-    cy.visit(path);
-    this.waitForSpinnerDetached();
-  }
-}
-
-module.exports = BasePage;

package/examples/cypress-ecommerce-suite/cypress/pages/CartPage.js

@@ -1,51 +0,0 @@
-const BasePage = require('./BasePage');
-
-class CartPage extends BasePage {
-  // Encapsulated locators
-  get couponInput() {
-    return cy.get('input[name="couponCode"]');
-  }
-
-  get applyCouponButton() {
-    return cy.contains('button', 'Áp dụng');
-  }
-
-  get discountBadge() {
-    return cy.get('[data-testid="discount-amount"]');
-  }
-
-  get errorMessageToast() {
-    return cy.get('.toast-error, .notification-error');
-  }
-
-  get checkoutButton() {
-    return cy.contains('button', 'Tiến hành đặt hàng');
-  }
-
-  // Business Action Methods
-  openCart() {
-    this.navigate('/cart');
-  }
-
-  applyCoupon(couponCode) {
-    this.couponInput.clear().type(couponCode);
-    this.applyCouponButton.click();
-    this.waitForSpinnerDetached();
-  }
-
-  proceedToCheckout() {
-    this.checkoutButton.click();
-    this.waitForSpinnerDetached();
-  }
-
-  // Verification Methods
-  verifyDiscountApplied(expectedDiscount) {
-    this.discountBadge.should('be.visible').and('contain.text', expectedDiscount);
-  }
-
-  verifyCouponError(expectedError) {
-    this.errorMessageToast.should('be.visible').and('contain.text', expectedError);
-  }
-}
-
-module.exports = new CartPage();

package/examples/cypress-ecommerce-suite/cypress.config.js

@@ -1,13 +0,0 @@
-const { defineConfig } = require('cypress');
-
-module.exports = defineConfig({
-  e2e: {
-    baseUrl: 'https://staging-shop.example.com',
-    specPattern: 'cypress/e2e/**/*.cy.js',
-    supportFile: false,
-    viewportWidth: 1920,
-    viewportHeight: 1080,
-    video: false,
-    screenshotOnRunFailure: true,
-  },
-});

package/examples/cypress-ecommerce-suite/package.json

@@ -1,13 +0,0 @@
-{
-  "name": "cypress-ecommerce-suite",
-  "version": "1.0.0",
-  "description": "Production Cypress Clean POM Reference Suite for Synapse-Hub",
-  "scripts": {
-    "test": "cypress run",
-    "test:open": "cypress open",
-    "lint:synapse": "npx synapse-hub lint ./cypress/e2e"
-  },
-  "devDependencies": {
-    "cypress": "^13.6.0"
-  }
-}

package/examples/katalon-suite/Keywords/pages/BasePage.groovy

@@ -1,19 +0,0 @@
-package pages
-
-import com.kms.katalon.core.webui.keyword.WebUiBuiltInKeywords as WebUI
-import com.kms.katalon.core.model.FailureHandling
-
-/**
- * BasePage encapsulating reusable Clean POM operations and smart synchronization.
- */
-public class BasePage {
-
-    public static String uniqueCode(String prefix = "AUTO_") {
-        return prefix + System.currentTimeMillis()
-    }
-
-    public void waitForReady(int timeoutSec = 10) {
-        // Smart wait: wait for page document state without static Thread.sleep
-        WebUI.waitForPageLoad(timeoutSec, FailureHandling.OPTIONAL)
-    }
-}

package/examples/katalon-suite/Keywords/pages/DashboardPage.groovy

@@ -1,29 +0,0 @@
-package pages
-
-import com.kms.katalon.core.testobject.TestObject
-import com.kms.katalon.core.testobject.ConditionType
-import com.kms.katalon.core.webui.keyword.WebUiBuiltInKeywords as WebUI
-
-/**
- * DashboardPage displaying business KPIs and metrics.
- */
-public class DashboardPage extends BasePage {
-
-    private TestObject headerDashboard = makeTestObject("//h1[contains(text(), 'Dashboard')]")
-    private TestObject cardActiveUsers = makeTestObject("//div[@data-testid='card-active-users']")
-
-    private static TestObject makeTestObject(String xpath) {
-        TestObject to = new TestObject()
-        to.addProperty("xpath", ConditionType.EQUALS, xpath)
-        return to
-    }
-
-    public boolean isDashboardLoaded() {
-        waitForReady()
-        return WebUI.verifyElementPresent(headerDashboard, 10)
-    }
-
-    public String getActiveUsersCount() {
-        return WebUI.getText(cardActiveUsers)
-    }
-}