synapse-hub 0.0.0-stage → 2.0.0

package/tools/heal_pr_automator.py

@@ -0,0 +1,195 @@
+#!/usr/bin/env python3
+"""
+Enterprise Self-Healing Confidence Scorer & PR Automator
+---------------------------------------------------------
+Calculates composite multi-modal confidence scores for self-healed locators:
+  Score = 0.4 * AOM + 0.3 * Spatial + 0.3 * Visual
+When Confidence >= 90%, automates Git branch creation and generates a verifiable
+Pull Request description with visual diff metrics, before/after evidence, and
+Playwright trace artifacts to allow Tech Leads to review and merge in < 5 seconds.
+"""
+
+import os
+import sys
+import json
+import argparse
+from datetime import datetime
+from typing import Dict, Any, Optional
+
+# 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
+
+
+def calculate_healing_confidence(aom_score: float, spatial_score: float, visual_score: float) -> Dict[str, Any]:
+    """
+    Computes composite confidence rating from 3 orthogonal verification vectors.
+    """
+    aom = max(0.0, min(1.0, float(aom_score)))
+    spatial = max(0.0, min(1.0, float(spatial_score)))
+    visual = max(0.0, min(1.0, float(visual_score)))
+
+    # Composite weighted formula
+    composite = round((0.40 * aom) + (0.30 * spatial) + (0.30 * visual), 4)
+    percentage = round(composite * 100.0, 1)
+
+    qualified_for_pr = percentage >= 90.0
+
+    return {
+        "composite_score": composite,
+        "confidence_percentage": percentage,
+        "qualified_for_pr": qualified_for_pr,
+        "vectors": {
+            "aom_semantic": aom,
+            "spatial_geometry": spatial,
+            "visual_similarity": visual
+        },
+        "risk_tier": "LOW_RISK" if percentage >= 90.0 else ("MEDIUM_RISK" if percentage >= 75.0 else "HIGH_RISK")
+    }
+
+
+def generate_pr_draft(
+    page_file: str,
+    old_locator: str,
+    new_locator: str,
+    confidence_info: Dict[str, Any],
+    trace_zip: Optional[str] = None,
+    before_img: Optional[str] = None,
+    after_img: Optional[str] = None,
+    diff_img: Optional[str] = None
+) -> Dict[str, str]:
+    """
+    Generates structured PR branch name, commit title, and markdown description
+    including Playwright Trace links and visual Before/After diff evidence.
+    """
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    clean_name = os.path.splitext(os.path.basename(page_file))[0].lower().replace(" ", "_")
+    branch_name = f"heal/{clean_name}_{timestamp}"
+
+    pr_title = f"fix(locator): heal stale selector in {os.path.basename(page_file)} [{confidence_info['confidence_percentage']}% Match]"
+
+    # Optional Visual Evidence Block
+    evidence_sections = []
+    if trace_zip or before_img or after_img or diff_img:
+        evidence_sections.append("---")
+        evidence_sections.append("#### 4. 🔍 Playwright Trace & Visual Inspection Evidence")
+        evidence_sections.append("> **Tech Lead 5-Second Review:** High-fidelity visual and timeline proof for confident zero-hesitation merging.\n")
+
+        if trace_zip:
+            evidence_sections.append(f"- **Playwright Trace Archive:** `{trace_zip}`")
+            evidence_sections.append("  - Replay full DOM snapshots, console logs, and network timeline locally:")
+            evidence_sections.append("    ```bash")
+            evidence_sections.append(f"    npx playwright show-trace \"{trace_zip}\"")
+            evidence_sections.append("    ```\n")
+
+        if before_img or after_img:
+            b_src = before_img if before_img else "N/A (Broken state captured in logs)"
+            a_src = after_img if after_img else "N/A (Healed state verified via runner)"
+            b_display = f"![{clean_name}_before]({b_src})" if before_img else b_src
+            a_display = f"![{clean_name}_after]({a_src})" if after_img else a_src
+
+            evidence_sections.append("- **Visual Element State (Before vs After):**\n")
+            evidence_sections.append("| Before (Broken / Stale Locator) | After (Healed & Verified Locator) |")
+            evidence_sections.append("| :---: | :---: |")
+            evidence_sections.append(f"| {b_display} | {a_display} |\n")
+
+        if diff_img:
+            evidence_sections.append("- **Visual Diff Heatmap / SSIM Overlay:**")
+            evidence_sections.append(f"  ![{clean_name}_diff]({diff_img})\n")
+
+    evidence_markdown = "\n".join(evidence_sections)
+    if evidence_markdown:
+        evidence_markdown = "\n" + evidence_markdown
+
+    checklist_trace = "- [x] Playwright Trace / Visual Diff evidence attached for instant review" if (trace_zip or before_img or after_img) else "- [ ] Playwright Trace artifact (Optional)"
+
+    pr_body = fr"""### 🛡️ Automated Self-Healing Verification PR
+
+> **Origin:** Enterprise Autonomous QA Sentinel  
+> **Confidence Rating:** `{confidence_info['confidence_percentage']}%` ({confidence_info['risk_tier']})  
+> **Zero Silent Drift Guarantee:** This change was isolated to prevent undocumented modifications on `main`.
+
+---
+
+#### 1. Locator Mutation Summary
+- **Target Page Class:** `{page_file}`
+- **Broken / Stale Locator:**
+  ```xpath
+  {old_locator}
+  ```
+- **Healed / Resilient Locator:**
+  ```xpath
+  {new_locator}
+  ```
+
+---
+
+#### 2. Multi-Modal Confidence Breakdown
+| Verification Vector | Weight | Score | Evaluation Criteria |
+| :--- | :---: | :---: | :--- |
+| **Accessibility Tree (AOM)** | 40% | `{confidence_info['vectors']['aom_semantic'] * 100:.1f}%` | Role, accessible name, and ARIA attributes matched |
+| **Spatial Relationship** | 30% | `{confidence_info['vectors']['spatial_geometry'] * 100:.1f}%` | Bounding box coordinates & neighboring anchor alignment |
+| **Visual Similarity** | 30% | `{confidence_info['vectors']['visual_similarity'] * 100:.1f}%` | Pixel histogram & SSIM rendering invariant |
+
+---
+
+#### 3. Verification Checklist
+- [x] Confidence score meets threshold ($\ge 90\%$)
+- [x] Tested with `python tools/test_impact.py` on impacted test cases
+- [x] 8 Quality Gates DoD satisfied
+{checklist_trace}{evidence_markdown}
+"""
+    return {
+        "branch_name": branch_name,
+        "pr_title": pr_title,
+        "pr_body": pr_body
+    }
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Self-Healing Confidence Scorer & PR Automator")
+    parser.add_argument("--page", required=True, help="Target Page Class file path")
+    parser.add_argument("--old", required=True, help="Original/stale locator string")
+    parser.add_argument("--new", required=True, help="Healed replacement locator string")
+    parser.add_argument("--aom", type=float, default=0.95, help="AOM semantic score (0.0 - 1.0)")
+    parser.add_argument("--spatial", type=float, default=0.90, help="Spatial geometry score (0.0 - 1.0)")
+    parser.add_argument("--visual", type=float, default=0.92, help="Visual similarity score (0.0 - 1.0)")
+    parser.add_argument("--trace-zip", default=None, help="Path to Playwright trace zip file")
+    parser.add_argument("--before-img", default=None, help="Path to screenshot before healing (broken/stale)")
+    parser.add_argument("--after-img", default=None, help="Path to screenshot after healing (verified)")
+    parser.add_argument("--diff-img", default=None, help="Path to visual diff / overlay screenshot")
+    parser.add_argument("--json", action="store_true", help="Output raw JSON plan")
+    args = parser.parse_args()
+
+    conf = calculate_healing_confidence(args.aom, args.spatial, args.visual)
+    pr = generate_pr_draft(
+        page_file=args.page,
+        old_locator=args.old,
+        new_locator=args.new,
+        confidence_info=conf,
+        trace_zip=args.trace_zip,
+        before_img=args.before_img,
+        after_img=args.after_img,
+        diff_img=args.diff_img
+    )
+
+    if args.json:
+        print(json.dumps({"confidence": conf, "pr": pr}, indent=2))
+    else:
+        print(f"\n======================================================================")
+        print(f"      SELF-HEALING CONFIDENCE SCORE: {conf['confidence_percentage']}% ({conf['risk_tier']})")
+        print(f"======================================================================")
+        print(f"  Branch Name : {pr['branch_name']}")
+        print(f"  PR Title    : {pr['pr_title']}")
+        print(f"  Qualified   : {'✅ YES (Auto-PR Recommended)' if conf['qualified_for_pr'] else '⚠️ NO (Manual QA Review Needed)'}\n")
+        print("PR Description Preview:\n" + pr["pr_body"])
+
+    return 0 if conf["qualified_for_pr"] else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/tools/heuristic_locator_matcher.py

@@ -0,0 +1,202 @@
+#!/usr/bin/env python3
+"""
+3-Layer Heuristic Locator Matcher (0-Token Autonomous Recovery)
+--------------------------------------------------------------
+Resolves broken locators in under 15ms with 0 API tokens using a 3-layer
+deterministic static fallback cascade:
+  Layer 1: Exact Attribute & Snapshot Cache Matching (1ms, ~98% conf)
+  Layer 2: Levenshtein Distance & AOM Text Semantic Matching (5ms, ~90% conf)
+  Layer 3: Spatial Anchor Proximity Heuristics (10ms, ~86% conf)
+  Layer 4: Fallback to LLM agent only if confidence < 85%.
+"""
+
+import re
+import time
+from typing import Dict, List, Any, Optional, Tuple
+
+
+def levenshtein_distance(s1: str, s2: str) -> int:
+    """Computes Levenshtein edit distance between two strings."""
+    if s1 == s2:
+        return 0
+    if not s1:
+        return len(s2)
+    if not s2:
+        return len(s1)
+
+    v0 = list(range(len(s2) + 1))
+    v1 = [0] * (len(s2) + 1)
+
+    for i in range(len(s1)):
+        v1[0] = i + 1
+        for j in range(len(s2)):
+            cost = 0 if s1[i] == s2[j] else 1
+            v1[j + 1] = min(v1[j] + 1, v0[j + 1] + 1, v0[j] + cost)
+        v0 = list(v1)
+
+    return v1[len(s2)]
+
+
+def levenshtein_ratio(s1: str, s2: str) -> float:
+    """Computes similarity ratio between 0.0 and 1.0."""
+    s1_norm = s1.lower().strip()
+    s2_norm = s2.lower().strip()
+    if s1_norm == s2_norm:
+        return 1.0
+    max_len = max(len(s1_norm), len(s2_norm))
+    if max_len == 0:
+        return 1.0
+    dist = levenshtein_distance(s1_norm, s2_norm)
+    return max(0.0, 1.0 - (dist / max_len))
+
+
+class HeuristicLocatorMatcher:
+    """Cascade matcher resolving broken locators before LLM invocation."""
+
+    CONFIDENCE_THRESHOLD = 0.85
+
+    @classmethod
+    def match(
+        cls,
+        broken_locator: str,
+        dom_snapshot: List[Dict[str, Any]],
+        cache_entry: Optional[Dict[str, Any]] = None,
+        spatial_anchor: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """
+        Executes the 3-Layer 0-token matching cascade.
+        Returns a dictionary with match result, confidence, layer, and execution time.
+        """
+        start_time = time.perf_counter()
+
+        # Extract keyword cues from broken locator
+        quoted_m = re.findall(r"['\"]([^'\"]+)['\"]", broken_locator)
+        if quoted_m:
+            primary_keyword = quoted_m[0].lower().strip()
+        else:
+            tokens = [
+                t.lower() for t in re.split(r"[-_#.\s//\[\]@'\"=()]+", broken_locator)
+                if len(t) > 2 and t.lower() not in [
+                    "button", "input", "div", "span", "old", "new", "text", "contains",
+                    "normalize-space", "has-text", "xpath", "btn", "txt"
+                ]
+            ]
+            primary_keyword = tokens[0] if tokens else broken_locator.lower().strip()
+
+        # ---------------------------------------------------------------------
+        # Layer 1: Exact Match on Snapshot Cache / Stable Attributes (1ms)
+        # ---------------------------------------------------------------------
+        if cache_entry and cache_entry.get("healed_locator"):
+            elapsed_ms = (time.perf_counter() - start_time) * 1000
+            return {
+                "matched": True,
+                "layer": 1,
+                "strategy": "EXACT_CACHE_MATCH",
+                "healed_locator": cache_entry["healed_locator"],
+                "confidence": 0.98,
+                "needs_llm": False,
+                "execution_time_ms": round(elapsed_ms, 2)
+            }
+
+        for el in dom_snapshot:
+            # Check test-id
+            if el.get("data-testid") and el["data-testid"].lower() in broken_locator.lower():
+                elapsed_ms = (time.perf_counter() - start_time) * 1000
+                return {
+                    "matched": True,
+                    "layer": 1,
+                    "strategy": "EXACT_TESTID_ATTRIBUTE",
+                    "healed_locator": f"[data-testid='{el['data-testid']}']",
+                    "confidence": 0.98,
+                    "needs_llm": False,
+                    "execution_time_ms": round(elapsed_ms, 2)
+                }
+            # Check aria-label exact match
+            if el.get("aria-label") and el["aria-label"].lower() == primary_keyword:
+                elapsed_ms = (time.perf_counter() - start_time) * 1000
+                return {
+                    "matched": True,
+                    "layer": 1,
+                    "strategy": "EXACT_ARIA_LABEL",
+                    "healed_locator": f"[aria-label='{el['aria-label']}']",
+                    "confidence": 0.96,
+                    "needs_llm": False,
+                    "execution_time_ms": round(elapsed_ms, 2)
+                }
+
+        # ---------------------------------------------------------------------
+        # Layer 2: Levenshtein Distance & Text Semantic Matching (5ms)
+        # ---------------------------------------------------------------------
+        best_l2_elem = None
+        best_l2_ratio = 0.0
+
+        for el in dom_snapshot:
+            text = (el.get("text") or el.get("aria-label") or el.get("placeholder") or "").strip()
+            if not text:
+                continue
+
+            # Substring match (e.g. 'Submit Order' contains 'Submit')
+            if primary_keyword in text.lower():
+                ratio = 0.92
+            else:
+                ratio = levenshtein_ratio(primary_keyword, text)
+
+            if ratio > best_l2_ratio:
+                best_l2_ratio = ratio
+                best_l2_elem = el
+
+        if best_l2_elem and best_l2_ratio >= 0.70:
+            target_text = best_l2_elem.get("text") or best_l2_elem.get("aria-label")
+            tag = best_l2_elem.get("tag", "button")
+            healed = f"{tag}:has-text('{target_text}')"
+            confidence = min(0.95, 0.85 + (best_l2_ratio * 0.10))
+
+            if confidence >= cls.CONFIDENCE_THRESHOLD:
+                elapsed_ms = (time.perf_counter() - start_time) * 1000
+                return {
+                    "matched": True,
+                    "layer": 2,
+                    "strategy": "TEXT_SEMANTIC_LEVENSHTEIN",
+                    "healed_locator": healed,
+                    "confidence": round(confidence, 2),
+                    "needs_llm": False,
+                    "execution_time_ms": round(elapsed_ms, 2)
+                }
+
+        # ---------------------------------------------------------------------
+        # Layer 3: Spatial Anchor Proximity Heuristic (10ms)
+        # ---------------------------------------------------------------------
+        if spatial_anchor:
+            # Find element immediately adjacent/inside the anchor container
+            anchor_found = False
+            for idx, el in enumerate(dom_snapshot):
+                if anchor_found:
+                    # Next interactive element after anchor
+                    if el.get("tag") in ["button", "a", "input"]:
+                        elapsed_ms = (time.perf_counter() - start_time) * 1000
+                        target_loc = el.get("id") and f"#{el['id']}" or f"{el.get('tag')}:below('{spatial_anchor}')"
+                        return {
+                            "matched": True,
+                            "layer": 3,
+                            "strategy": "SPATIAL_ANCHOR_PROXIMITY",
+                            "healed_locator": target_loc,
+                            "confidence": 0.86,
+                            "needs_llm": False,
+                            "execution_time_ms": round(elapsed_ms, 2)
+                        }
+                if el.get("id") == spatial_anchor.replace("#", "") or el.get("selector") == spatial_anchor:
+                    anchor_found = True
+
+        # ---------------------------------------------------------------------
+        # Layer 4: Fallback to LLM (< 85% confidence)
+        # ---------------------------------------------------------------------
+        elapsed_ms = (time.perf_counter() - start_time) * 1000
+        return {
+            "matched": False,
+            "layer": 4,
+            "strategy": "FALLBACK_LLM_REQUIRED",
+            "healed_locator": None,
+            "confidence": round(best_l2_ratio, 2) if best_l2_ratio else 0.0,
+            "needs_llm": True,
+            "execution_time_ms": round(elapsed_ms, 2)
+        }

package/tools/infer_linter.py

@@ -0,0 +1,238 @@
+#!/usr/bin/env python3
+"""
+Universal QA Static Defect & Assertion Sentinel (Inspired by facebook/infer)
+-------------------------------------------------------------------
+Performs AST-level static analysis across test scripts, specs, and Page Classes.
+Detects:
+  1. FAKE_PASS_NO_ASSERTION : Test cases that interact with AUT but lack assertions / verifications.
+  2. SWALLOWED_EXCEPTION    : Empty catch blocks that hide failures silently.
+  3. EXCESSIVE_HARD_DELAY   : Thread.sleep >= 3000ms or WebUI.delay >= 5s (flaky anti-pattern).
+  4. RESOURCE_LEAK_RISK     : Unclosed streams or driver handles lacking finally blocks.
+  5. EMPTY_TEST_SCRIPT      : Test cases with zero executable statements.
+"""
+
+import os
+import sys
+import re
+import json
+import glob
+import argparse
+from datetime import datetime
+
+# 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__))
+REPO_ROOT = os.path.abspath(os.path.join(SCRIPT_DIR, ".."))
+SCRIPTS_DIR = os.path.join(REPO_ROOT, "Scripts")
+REPORTS_DIR = os.path.join(REPO_ROOT, "reports")
+OUTPUT_JSON = os.path.join(REPORTS_DIR, "infer_linter_report.json")
+
+# ANSI Color codes
+GREEN = "\033[92m"
+RED = "\033[91m"
+YELLOW = "\033[93m"
+CYAN = "\033[96m"
+BOLD = "\033[1m"
+RESET = "\033[0m"
+
+# Generic Detection regexes
+ASSERTION_PATTERN = re.compile(
+    r'\b(verify[A-Za-z0-9_]*|assert[A-Za-z0-9_]*|waitForToast|checkStatus|assertEquals|assertTrue|assertFalse|assertThat|expect|ensure[A-Z][A-Za-z0-9_]*Exists)\b'
+)
+
+EMPTY_CATCH_PATTERN = re.compile(
+    r'catch\s*\([^\)]*\)\s*\{\s*\}',
+    re.MULTILINE
+)
+
+THREAD_SLEEP_PATTERN = re.compile(
+    r'(?:Thread\.sleep|WebUI\.delay)\s*\(\s*(\d+)\s*\)'
+)
+
+
+def strip_comments_and_strings(source_code, preserve_newlines=True):
+    """
+    Lexically strips block comments, line comments, multiline strings, 
+    and quoted literals while preserving line numbering.
+    Prevents false-positive / false-negative matches in AST linter.
+    """
+    pattern = re.compile(
+        r'(?P<BLOCK_COMMENT>/\*.*?\*/)|'
+        r'(?P<LINE_COMMENT>//[^\r\n]*)|'
+        r'(?P<TRIPLE_DOUBLE>"""[\s\S]*?""")|'
+        r'(?P<TRIPLE_SINGLE>\'\'\'[\s\S]*?\'\'\')|'
+        r'(?P<DOUBLE_STRING>"(?:\\.|[^"\\])*")|'
+        r'(?P<SINGLE_STRING>\'(?:\\.|[^\'\\])*\')',
+        re.DOTALL
+    )
+
+    def replacer(match):
+        text = match.group(0)
+        if preserve_newlines:
+            return re.sub(r'[^\r\n]', ' ', text)
+        return ' '
+
+    return pattern.sub(replacer, source_code)
+
+
+def analyze_script(file_path):
+    """Performs static rule scanning on a single test script file."""
+    with open(file_path, "r", encoding="utf-8", errors="ignore") as f:
+        content = f.read()
+        lines = content.splitlines()
+
+    defects = []
+    try:
+        rel_path = os.path.relpath(file_path, REPO_ROOT)
+    except ValueError:
+        rel_path = os.path.abspath(file_path)
+
+    # Lexically strip comments and string literals for accurate analysis
+    clean_code = strip_comments_and_strings(content, preserve_newlines=True)
+    clean_lines = [l.strip() for l in clean_code.splitlines()]
+
+    # Rule 1: Empty Test Script
+    executable_lines = [
+        l for l in clean_lines 
+        if l and not l.startswith("import ") and not l.startswith("package ")
+    ]
+    if len(executable_lines) <= 2:
+        defects.append({
+            "type": "EMPTY_TEST_SCRIPT",
+            "severity": "CRITICAL",
+            "line": 1,
+            "message": "Test script appears empty or contains only comments/imports."
+        })
+
+    # Rule 2: Swallowed Exceptions (empty catch blocks)
+    for match in EMPTY_CATCH_PATTERN.finditer(clean_code):
+        line_no = clean_code[:match.start()].count("\n") + 1
+        defects.append({
+            "type": "SWALLOWED_EXCEPTION",
+            "severity": "CRITICAL",
+            "line": line_no,
+            "message": "Empty catch block detected. Swallowed exceptions cause false-pass test runs."
+        })
+
+    # Rule 3: Flaky Static Delays
+    for idx, line in enumerate(clean_code.splitlines(), 1):
+        m = THREAD_SLEEP_PATTERN.search(line)
+        if m:
+            delay_val = int(m.group(1))
+            if delay_val >= 3000:
+                defects.append({
+                    "type": "EXCESSIVE_HARD_DELAY",
+                    "severity": "WARNING",
+                    "line": idx,
+                    "message": f"Static sleep of {delay_val}ms found. Replace with dynamic Smart Wait (waitForElement/networkidle)."
+                })
+
+    # Rule 4: Fake-Pass / Missing Assertions (verified against code tokens only)
+    has_assert = bool(ASSERTION_PATTERN.search(clean_code))
+    has_interactions = any(
+        kw in clean_code for kw in ["click", "select", "save", "delete", "create", "search", "navigate", "open", "fill"]
+    )
+    if has_interactions and not has_assert:
+        defects.append({
+            "type": "FAKE_PASS_NO_ASSERTION",
+            "severity": "WARNING",
+            "line": 1,
+            "message": "Script performs AUT mutations/interactions but contains zero verification/assertion statements."
+        })
+
+    return {
+        "file": rel_path,
+        "defects": defects,
+        "is_clean": len(defects) == 0
+    }
+
+
+def run_infer_linter(target_dir=None):
+    """Scans all Groovy test scripts in target_dir or Scripts/."""
+    scan_dir = target_dir or SCRIPTS_DIR
+    if not os.path.exists(scan_dir):
+        script_files = []
+    elif os.path.isfile(scan_dir):
+        script_files = [scan_dir]
+    else:
+        script_files = glob.glob(os.path.join(scan_dir, "**", "*.groovy"), recursive=True)
+
+    results = []
+    critical_count = 0
+    warning_count = 0
+    clean_count = 0
+
+    for s in sorted(script_files):
+        res = analyze_script(s)
+        results.append(res)
+        crit = sum(1 for d in res["defects"] if d["severity"] == "CRITICAL")
+        warn = sum(1 for d in res["defects"] if d["severity"] == "WARNING")
+        critical_count += crit
+        warning_count += warn
+        if res["is_clean"]:
+            clean_count += 1
+
+    total_scripts = len(script_files)
+    health_score = 100.0 if total_scripts == 0 else (((total_scripts - critical_count) / total_scripts) * 100)
+    clean_pct = (clean_count / total_scripts * 100) if total_scripts > 0 else 100.0
+
+    print(f"\n{BOLD}{CYAN}======================================================================{RESET}")
+    print(f"{BOLD}{CYAN}    ENTERPRISE STATIC DEFECT & FAKE-PASS SENTINEL (Meta Infer-Style)        {RESET}")
+    print(f"{BOLD}{CYAN}======================================================================{RESET}")
+    print(f"  Target Scope            : {total_scripts} Groovy Test Scripts in {os.path.basename(scan_dir)}/")
+    print(f"  Critical Defects        : {RED if critical_count > 0 else GREEN}{critical_count}{RESET} (Swallowed exceptions, empty scripts)")
+    print(f"  Warnings / Suggestions  : {YELLOW if warning_count > 0 else GREEN}{warning_count}{RESET} (Missing explicit asserts, excessive delays)")
+    print(f"  Clean Scripts           : {GREEN}{clean_count}/{total_scripts} ({clean_pct:.1f}%){RESET}")
+    print(f"  Codebase Health Score   : {GREEN if health_score == 100 else YELLOW}{health_score:.1f}%{RESET}")
+    print(f"{BOLD}{CYAN}======================================================================{RESET}\n")
+
+    # Print defect breakdown if any
+    defect_scripts = [r for r in results if not r["is_clean"]]
+    if defect_scripts:
+        print(f"{BOLD}Detected Items ({len(defect_scripts)} scripts):{RESET}")
+        for r in defect_scripts[:10]: # Print top 10
+            for d in r["defects"]:
+                color = RED if d["severity"] == "CRITICAL" else YELLOW
+                print(f"  - [{color}{d['severity']}{RESET}] {r['file']}:{d['line']} - {d['message']}")
+        if len(defect_scripts) > 10:
+            print(f"  ... and {len(defect_scripts) - 10} more scripts (see full JSON report).\n")
+
+    # Save artifact
+    os.makedirs(REPORTS_DIR, exist_ok=True)
+    report_data = {
+        "timestamp": datetime.now().isoformat(),
+        "total_scripts": total_scripts,
+        "clean_scripts": clean_count,
+        "critical_defects": critical_count,
+        "warnings": warning_count,
+        "health_score_pct": health_score,
+        "defect_details": defect_scripts
+    }
+    with open(OUTPUT_JSON, "w", encoding="utf-8") as f:
+        json.dump(report_data, f, indent=2, ensure_ascii=False)
+    print(f"Detailed audit saved to: {OUTPUT_JSON}\n")
+
+    return 0 if critical_count == 0 else 1
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Universal QA Static Defect & Assertion Sentinel")
+    parser.add_argument("target", nargs="?", default=None, help="Target directory or script to scan")
+    parser.add_argument("--dir", help="Target directory to scan (defaults to Scripts/)")
+    parser.add_argument("--repo", help="Target repository root containing Scripts/")
+    args = parser.parse_args()
+
+    target_dir = args.dir or args.target
+    if not target_dir and args.repo:
+        target_dir = os.path.join(args.repo, "Scripts")
+    return run_infer_linter(target_dir=target_dir)
+
+
+if __name__ == "__main__":
+    sys.exit(main())