synapse-hub 2.2.2 → 2.2.4

package/tools/repo_map.py

@@ -21,10 +21,11 @@ HUB_ROOT = os.path.abspath(os.path.join(SCRIPT_DIR, ".."))
 OUTPUT_TXT = os.path.join(SCRIPT_DIR, "repo_map.txt")
 OUTPUT_JSON = os.path.join(SCRIPT_DIR, "repo_map.json")
 
-# Regex patterns for Groovy classes and methods
-CLASS_PATTERN = re.compile(r'^\s*(?:public\s+)?class\s+(\w+)(?:\s+extends\s+(\w+))?', re.MULTILINE)
+# Regex patterns for Groovy/Java classes and methods
+CLASS_PATTERN = re.compile(r'^\s*(?:public\s+|export\s+)?class\s+(\w+)(?:\s+extends\s+(\w+))?', re.MULTILINE)
+PY_CLASS_PATTERN = re.compile(r'^\s*class\s+(\w+)(?:\(([^)]*)\))?\s*:', re.MULTILINE)
 METHOD_PATTERN = re.compile(
-    r'^\s*(?:@\w+\s+)*(?:public\s+|protected\s+|private\s+)?(?:static\s+)?(?:def\s+|void\s+|[\w<>\[\],]+\s+)?(\w+)\s*\(([^)]*)\)\s*(?:throws\s+[\w,\s]+)?\s*\{',
+    r'^\s*(?:@\w+\s+)*(?:public\s+|protected\s+|private\s+)?(?:static\s+)?(?:async\s+)?(?:def\s+|void\s+|[\w<>\[\],]+\s+)?(\w+)\s*\(([^)]*)\)\s*(?:throws\s+[\w,\s]+)?\s*\{',
     re.MULTILINE
 )
 DOC_PATTERN = re.compile(r'/\*\*(.*?)\*/', re.DOTALL)
@@ -35,7 +36,7 @@ def resolve_target_repo(cli_target=None, cli_repo=None):
     Resolves the target repository path for repo mapping:
     1. Explicit CLI flag: --repo / --path or positional target.
     2. Environment variable: TARGET_PROJECT_DIR.
-    3. Current Working Directory (if different from Hub and has Keywords/ or Scripts/).
+    3. Current Working Directory (if different from Hub and has Keywords/, pages/, or tests/).
     4. Default fallback: QA Hub root (parent of tools/).
     """
     chosen = cli_repo or cli_target
@@ -51,14 +52,15 @@ def resolve_target_repo(cli_target=None, cli_repo=None):
 
     cwd = os.path.abspath(os.getcwd())
     if cwd.lower() != HUB_ROOT.lower():
-        if os.path.exists(os.path.join(cwd, "Keywords")) or os.path.exists(os.path.join(cwd, "Scripts")):
+        markers = ("Keywords", "Scripts", "pages", "tests", "src/pages", "e2e")
+        if any(os.path.exists(os.path.join(cwd, m)) for m in markers):
             return cwd
 
     return HUB_ROOT
 
 
 def extract_class_info(file_path, repo_root=None):
-    """Parses a Groovy file and extracts class name, parent, and exported methods."""
+    """Parses a Groovy, TypeScript, JavaScript, or Python file and extracts class name and methods."""
     with open(file_path, "r", encoding="utf-8", errors="ignore") as f:
         content = f.read()
 
@@ -68,48 +70,72 @@ def extract_class_info(file_path, repo_root=None):
     except ValueError:
         rel_path = os.path.abspath(file_path)
 
-    class_match = CLASS_PATTERN.search(content)
-    if not class_match:
-        return None
-
-    class_name = class_match.group(1)
-    extends_name = class_match.group(2) or ""
-
+    ext = os.path.splitext(file_path)[1].lower()
     methods = []
-    control_keywords = {"if", "for", "while", "switch", "catch", "synchronized"}
-
-    lines = content.splitlines()
-    for idx, line in enumerate(lines):
-        line_clean = line.strip()
-        if not line_clean or line_clean.startswith("//") or line_clean.startswith("/*") or line_clean.startswith("*"):
-            continue
-
-        # If '=' appears before '(', it's a variable assignment / constant declaration, not a method
-        if "=" in line_clean:
-            eq_pos = line_clean.find("=")
-            paren_pos = line_clean.find("(")
-            if paren_pos != -1 and eq_pos < paren_pos:
+    control_keywords = {"if", "for", "while", "switch", "catch", "synchronized", "constructor"}
+
+    if ext in (".groovy", ".java", ".ts", ".js"):
+        class_match = CLASS_PATTERN.search(content)
+        if not class_match:
+            return None
+        class_name = class_match.group(1)
+        extends_name = class_match.group(2) or ""
+
+        lines = content.splitlines()
+        for idx, line in enumerate(lines):
+            line_clean = line.strip()
+            if not line_clean or line_clean.startswith(("//", "/*", "*")):
                 continue
 
-        # Must have parentheses and end with '{' or next line starts with '{'
-        if "(" in line_clean and ")" in line_clean:
-            has_brace = line_clean.endswith("{") or (idx + 1 < len(lines) and lines[idx + 1].strip().startswith("{"))
-            if has_brace:
-                # Match method definition: modifiers + return type + name + (params)
-                m = re.search(r'(?:public\s+|protected\s+|private\s+|static\s+|def\s+|void\s+|[\w<>\[\],]+\s+)+([a-zA-Z_]\w*)\s*\(([^)]*)\)', line_clean)
+            if "=" in line_clean:
+                eq_pos = line_clean.find("=")
+                paren_pos = line_clean.find("(")
+                if paren_pos != -1 and eq_pos < paren_pos:
+                    continue
+
+            if "(" in line_clean and ")" in line_clean:
+                has_brace = "{" in line_clean or (idx + 1 < len(lines) and lines[idx + 1].strip().startswith("{"))
+                if has_brace:
+                    m = re.search(r'(?:public\s+|protected\s+|private\s+|static\s+|async\s+|def\s+|void\s+|[\w<>\[\],]+\s+)*([a-zA-Z_]\w*)\s*\(([^)]*)\)', line_clean)
+                    if m:
+                        name = m.group(1)
+                        params = m.group(2).strip()
+                        if name not in control_keywords and name != class_name:
+                            comment = ""
+                            if idx > 0 and lines[idx - 1].strip().startswith("//"):
+                                comment = lines[idx - 1].strip().lstrip("/ ").strip()
+                            methods.append({
+                                "name": name,
+                                "params": re.sub(r'\s+', ' ', params),
+                                "comment": comment
+                            })
+
+    elif ext == ".py":
+        class_match = PY_CLASS_PATTERN.search(content)
+        if not class_match:
+            return None
+        class_name = class_match.group(1)
+        extends_name = class_match.group(2) or ""
+
+        lines = content.splitlines()
+        for idx, line in enumerate(lines):
+            line_clean = line.strip()
+            if line_clean.startswith("def "):
+                m = re.search(r'def\s+([a-zA-Z_]\w*)\s*\(([^)]*)\):', line_clean)
                 if m:
                     name = m.group(1)
-                    params = m.group(2).strip()
-                    if name not in control_keywords and name != class_name:
-                        # Extract preceding single-line comment if any
+                    params = m.group(2).replace("self,", "").replace("self", "").strip()
+                    if not name.startswith("__") and name not in control_keywords:
                         comment = ""
-                        if idx > 0 and lines[idx - 1].strip().startswith("//"):
-                            comment = lines[idx - 1].strip().lstrip("/ ").strip()
+                        if idx + 1 < len(lines) and '"""' in lines[idx + 1]:
+                            comment = lines[idx + 1].replace('"""', '').strip()
                         methods.append({
                             "name": name,
                             "params": re.sub(r'\s+', ' ', params),
                             "comment": comment
                         })
+    else:
+        return None
 
     # Deduplicate methods preserving order
     seen = set()
@@ -120,6 +146,7 @@ def extract_class_info(file_path, repo_root=None):
             seen.add(sig)
             unique_methods.append(meth)
 
+    lines = content.splitlines()
     return {
         "rel_path": rel_path,
         "class_name": class_name,
@@ -131,13 +158,7 @@ def extract_class_info(file_path, repo_root=None):
 
 
 def build_repo_map(target_repo=None, output_txt=None, output_json=None):
-    """Scans Keywords in target_repo and builds the condensed repo map."""
-    try:
-        from author_integrity import assert_integrity_or_raise
-        assert_integrity_or_raise()
-    except Exception:
-        pass
-
+    """Scans Page Classes across polyglot targets (Groovy, TypeScript, Python) and builds map."""
     repo = target_repo or resolve_target_repo()
     txt_dest = output_txt or OUTPUT_TXT
     json_dest = output_json or OUTPUT_JSON
@@ -146,18 +167,31 @@ def build_repo_map(target_repo=None, output_txt=None, output_json=None):
     total_raw_bytes = 0
     total_raw_lines = 0
 
-    keywords_dir = os.path.join(repo, "Keywords")
-
-    if os.path.isdir(keywords_dir):
-        for root, dirs, files in os.walk(keywords_dir):
-            for fname in sorted(files):
-                if fname.endswith(".groovy"):
-                    full_path = os.path.join(root, fname)
-                    info = extract_class_info(full_path, repo_root=repo)
-                    if info:
-                        classes.append(info)
-                        total_raw_bytes += info["raw_size_bytes"]
-                        total_raw_lines += info["line_count"]
+    candidate_dirs = [
+        os.path.join(repo, "Keywords"),
+        os.path.join(repo, "pages"),
+        os.path.join(repo, "page-objects"),
+        os.path.join(repo, "page_objects"),
+        os.path.join(repo, "src", "pages"),
+        os.path.join(repo, "tests", "pages"),
+    ]
+
+    scanned_files = set()
+    for d in candidate_dirs:
+        if os.path.isdir(d):
+            for root, _, files in os.walk(d):
+                if any(ignored in root for ignored in (".git", "node_modules", "__pycache__", ".venv")):
+                    continue
+                for fname in sorted(files):
+                    if fname.endswith((".groovy", ".ts", ".js", ".py", ".java")):
+                        full_path = os.path.join(root, fname)
+                        if full_path not in scanned_files:
+                            scanned_files.add(full_path)
+                            info = extract_class_info(full_path, repo_root=repo)
+                            if info and info.get("methods"):
+                                classes.append(info)
+                                total_raw_bytes += info["raw_size_bytes"]
+                                total_raw_lines += info["line_count"]
 
     # Sort classes: BasePage first, then alphabetical
     classes.sort(key=lambda c: (0 if c["class_name"] == "BasePage" else 1, c["class_name"]))

package/tools/safety_firewall.py

@@ -41,6 +41,13 @@ DANGEROUS_ACTION_KEYWORDS = [
     r"\breset\b",
     r"\btransfer\b",
     r"\bformat\b",
+    # Multilingual & Vietnamese destructive keywords
+    r"x[oóòỏõọ][aáàảãạ]",
+    r"x[oóòỏõọ]a\s+t[aáàảãạ]t\s+c[aảáàãạ]",
+    r"h[uủúùũụ]y",
+    r"thanh\s+to[aáàảãạ]n",
+    r"r[uúùủũụ]t\s+ti[eềéèẻẽẹ]n",
+    r"n[aạáàảã]p\s+ti[eềéèẻẽẹ]n",
 ]
 
 DANGEROUS_SELECTOR_PATTERNS = [
@@ -50,6 +57,8 @@ DANGEROUS_SELECTOR_PATTERNS = [
     r"\.p-button-danger\b",
     r"\[aria-label\*=['\"]?delete['\"]?\]",
     r"button[#\.\-_a-zA-Z0-9]*[_\-]*(?:del|delete|purge|remove|wipe|drop)",
+    r":(?:has-text|text)\s*\(\s*['\"][^'\"]*(?:delete|remove|wipe|purge|pay|x[oóòỏõọ][aáàảãạ]|h[uủúùũụ]y|thanh\s*to[aáàảãạ]n)[^'\"]*['\"]\s*\)",
+    r"text=['\"][^'\"]*(?:delete|remove|wipe|purge|pay|x[oóòỏõọ][aáàảãạ]|h[uủúùũụ]y|thanh\s*to[aáàảãạ]n)",
 ]
 
 COMPILED_TEXT_REGEX = re.compile("|".join(DANGEROUS_ACTION_KEYWORDS), re.IGNORECASE)
@@ -84,8 +93,12 @@ def is_action_dangerous(action_type: str, text: str = "", selector: str = "") ->
         return True, f"Element text contains dangerous keyword: '{match}'"
 
     # Check selector
-    if sel_clean and COMPILED_SEL_REGEX.search(sel_clean):
-        return True, f"Element selector matches destructive pattern: '{sel_clean}'"
+    if sel_clean:
+        if COMPILED_SEL_REGEX.search(sel_clean):
+            return True, f"Element selector matches destructive pattern: '{sel_clean}'"
+        if COMPILED_TEXT_REGEX.search(sel_clean):
+            match = COMPILED_TEXT_REGEX.search(sel_clean).group(0)
+            return True, f"Element selector contains dangerous keyword: '{match}' in '{sel_clean}'"
 
     # Specific dangerous action types
     if action_type.lower() in ("drop_database", "wipe_environment", "execute_payment"):

package/tools/setup_project.py

@@ -175,7 +175,10 @@ def ensure_project_ai_guide(target_dir, stack_info):
 
 
 def install_git_pre_push_hook(target_dir):
-    """Installs an automated pre-push hook into target project's .git repository."""
+    """
+    Installs or appends an automated pre-push hook into target project's .git repository.
+    Safely backs up any existing pre-push hook (e.g. Husky, Lefthook) to prevent side-effects.
+    """
     git_dir = os.path.join(target_dir, ".git")
     if not os.path.isdir(git_dir):
         print("  [SKIP] Not a Git repository root (.git folder not found). Skipped Git Hook installation.")
@@ -185,37 +188,64 @@ def install_git_pre_push_hook(target_dir):
     os.makedirs(hooks_dir, exist_ok=True)
     hook_file = os.path.join(hooks_dir, "pre-push")
 
+    # Resolve pinned package version
+    manifest_file = os.path.join(HUB_ROOT, "skills_manifest.json")
+    pkg_ver = "2.2.2"
+    if os.path.exists(manifest_file):
+        try:
+            with open(manifest_file, "r", encoding="utf-8") as f:
+                pkg_ver = json.load(f).get("version", pkg_ver)
+        except Exception:
+            pass
+
     verify_all_script = os.path.join(SCRIPT_DIR, "verify_all.py").replace("\\", "/")
     analyze_script = os.path.join(SCRIPT_DIR, "analyze_project.py").replace("\\", "/")
 
-    hook_content = f"""#!/bin/sh
-# Automated Zero-Leakage Pre-Push Hook (Installed by Synapse-Hub)
-# Enforces 8 Quality Gates DoD and syncs project intelligence before pushing.
-
-echo "\\n[AI-GUARD] Running Pre-Push Verification (8 Quality Gates DoD)..."
+    hook_snippet = f"""
+# --- Synapse-Hub Pre-Push Quality Gate (v{pkg_ver}) ---
+echo "\\n[AI-GUARD] Running Pre-Push Verification (Quality Gates DoD)..."
 if command -v npx >/dev/null 2>&1; then
-    npx synapse-hub verify
+    npx synapse-hub@{pkg_ver} verify || npx synapse-hub verify
 elif [ -f "{verify_all_script}" ]; then
     python3 "{verify_all_script}" || python "{verify_all_script}"
 fi
 if [ $? -ne 0 ]; then
     echo "\\n[AI-GUARD - REJECTED] Git Push aborted: Quality Gates verification failed!"
-    echo "Please fix defects or run 'npx synapse-hub verify' locally before pushing.\\n"
+    echo "Please fix defects or run 'npx synapse-hub@{pkg_ver} verify' locally before pushing.\\n"
     exit 1
 fi
 
-echo "[AI-GUARD - PASSED] 8 Quality Gates satisfied. Syncing project health report..."
+echo "[AI-GUARD - PASSED] Quality Gates satisfied. Syncing project health report..."
 if command -v npx >/dev/null 2>&1; then
-    npx synapse-hub analyze
+    npx synapse-hub@{pkg_ver} analyze || npx synapse-hub analyze
 elif [ -f "{analyze_script}" ]; then
     python3 "{analyze_script}" || python "{analyze_script}"
 fi
 echo "[AI-GUARD - READY] Pushing to remote...\\n"
-exit 0
+# --- End Synapse-Hub Quality Gate ---
 """
+
     try:
+        if os.path.exists(hook_file):
+            with open(hook_file, "r", encoding="utf-8", errors="ignore") as f:
+                existing_content = f.read()
+
+            if "Synapse-Hub" in existing_content or "synapse-hub" in existing_content:
+                print(f"  {CYAN}[SKIP] Pre-Push Git Hook already present:{RESET} {hook_file}")
+                return True
+
+            # Safely backup existing hook (e.g. Husky, Lefthook)
+            backup_file = f"{hook_file}.backup"
+            shutil.copy2(hook_file, backup_file)
+            print(f"  {YELLOW}[BACKUP] Existing pre-push hook backed up to:{RESET} {backup_file}")
+
+            # Append non-destructively
+            final_content = existing_content.rstrip() + "\n" + hook_snippet
+        else:
+            final_content = "#!/bin/sh\n" + hook_snippet
+
         with open(hook_file, "w", encoding="utf-8", newline="\n") as f:
-            f.write(hook_content)
+            f.write(final_content)
 
         # Attempt to make executable on Unix-like environments
         try:
@@ -223,7 +253,7 @@ exit 0
         except Exception:
             pass
 
-        print(f"  {GREEN}[OK] Installed automated Pre-Push Git Hook:{RESET} {hook_file}")
+        print(f"  {GREEN}[OK] Configured automated Pre-Push Git Hook:{RESET} {hook_file} (pinned to v{pkg_ver})")
         return True
     except Exception as e:
         print(f"  ⚠️ Could not install Git hook: {e}")

package/tools/skillspector.py

@@ -165,7 +165,7 @@ PROHIBITION_PREFIX = re.compile(
 )
 
 ALERT_BLOCK_PREFIX = re.compile(
-    r"^\s*>\s*\[!(?:WARNING|CAUTION|DANGER|ALERT|IMPORTANT|NOTE|TIP)\]",
+    r"^\s*>\s*\[!(?:WARNING|CAUTION|DANGER|ALERT)\]",
     re.IGNORECASE | re.MULTILINE,
 )
 
@@ -189,23 +189,20 @@ def is_in_prohibition_context(content: str, start: int, end: int) -> bool:
     if PROHIBITION_PREFIX.search(current_line):
         return True
 
-    # 2. Markdown Caution/Warning Callout Block
-    if any(ALERT_BLOCK_PREFIX.search(line) for line in lines[-5:]):
+    # 2. Markdown Caution/Warning Callout Block with explicit negative imperative
+    has_alert = any(ALERT_BLOCK_PREFIX.search(line) for line in lines[-5:])
+    if has_alert and any(re.search(r'\b(never|do not|don[\'’]t|must not|forbidden|prohibited|avoid)\b', line, re.IGNORECASE) for line in lines[-5:]):
         return True
 
     # 3. Defensive Guideline headings ("Anti-Pattern Blacklist", "Forbidden actions")
     preceding_lower = preceding_text.lower()
     defensive_markers = (
-        "anti-pattern",
+        "anti-pattern blacklist",
         "mistake / anti-pattern",
         "strictly forbidden",
         "never use",
         "mandatory avoidance",
         "forbidden actions",
-        "prohibited",
-        "blacklist",
-        "threat model",
-        "vulnerability check",
         "zero-token error blacklist",
     )
     if any(marker in preceding_lower for marker in defensive_markers):
@@ -927,6 +924,9 @@ def scan_target(target_path: str) -> ScanReport:
         pass
 
     path_obj = Path(target_path).resolve()
+    if not path_obj.exists():
+        raise FileNotFoundError(f"Target path does not exist: {target_path}")
+
     all_findings: List[Finding] = []
     scanned_count = 0
 

package/tools/verify_all.py

@@ -237,43 +237,42 @@ def gate_2_path_portability(repo_root, mode="AUTO"):
 
 
 def gate_3_clean_pom(repo_root, mode="AUTO"):
-    print("\n[GATE 3] Checking Clean POM & Flat Architecture in Scripts/......")
-    scripts_dir = os.path.join(repo_root, "Scripts")
-
-    has_groovy = False
-    if os.path.isdir(scripts_dir):
-        groovy_files = [f for f in glob.glob(os.path.join(scripts_dir, "**", "*.groovy"), recursive=True)]
-        has_groovy = len(groovy_files) > 0
-
-    if not has_groovy:
-        if mode == "HUB":
-            print("[SKIP] Hub Mode: Repository contains QA Hub assets; no target Groovy scripts in Scripts/ to verify.")
-            return True
-        else:
-            print("[SKIP] No Groovy test scripts present in Scripts/ directory.")
-            return True
+    print("\n[GATE 3] Checking Clean POM & Flat Architecture in Test Scripts...")
+    effective_mode = detect_repo_mode(repo_root) if mode == "AUTO" else mode
+    if effective_mode == "HUB":
+        print("[PASS] Hub Mode: Repository contains QA Hub assets; Clean POM applies to target test suites.")
+        return True
+
+    test_dirs = ["Scripts", "tests", "test", "e2e", "specs", "cypress"]
+    test_files = []
+    for td in test_dirs:
+        d = os.path.join(repo_root, td)
+        if os.path.isdir(d):
+            for ext in ("*.groovy", "*.ts", "*.js", "*.py", "*.java"):
+                test_files.extend(glob.glob(os.path.join(d, "**", ext), recursive=True))
+
+    if not test_files:
+        print("[SKIP] No test scripts present in candidate directories (Scripts/, tests/, e2e/).")
+        return True
 
     violations = []
-    for root, dirs, files in os.walk(scripts_dir):
-        for f in files:
-            if f.endswith(".groovy"):
-                full_path = os.path.join(root, f)
-                rel_path = os.path.relpath(full_path, repo_root)
-                try:
-                    with open(full_path, "r", encoding="utf-8", errors="ignore") as fp:
-                        for line_no, line in enumerate(fp, 1):
-                            stripped = line.strip()
-                            if stripped.startswith("//") or stripped.startswith("/*"):
-                                continue
-                            if "findTestObject" in line:
-                                violations.append((rel_path, line_no, "Raw findTestObject"))
-                            if "//" in line and ("//table" in line or "//input" in line or "//button" in line):
-                                violations.append((rel_path, line_no, "Raw XPath"))
-                except Exception:
-                    pass
+    for full_path in sorted(set(test_files)):
+        rel_path = os.path.relpath(full_path, repo_root)
+        try:
+            with open(full_path, "r", encoding="utf-8", errors="ignore") as fp:
+                for line_no, line in enumerate(fp, 1):
+                    stripped = line.strip()
+                    if stripped.startswith("//") or stripped.startswith("/*") or stripped.startswith("#"):
+                        continue
+                    if "findTestObject" in line:
+                        violations.append((rel_path, line_no, "Raw findTestObject"))
+                    if "//" in line and ("//table" in line or "//input" in line or "//button" in line):
+                        violations.append((rel_path, line_no, "Raw XPath"))
+        except Exception:
+            pass
 
     if violations:
-        print(f"[FAIL] {len(violations)} Clean POM violations in Scripts/:")
+        print(f"[FAIL] {len(violations)} Clean POM violations in test scripts:")
         for rel_path, line_no, reason in violations:
             print(f"   - {rel_path}:{line_no} ({reason})")
         return False
@@ -404,26 +403,35 @@ def gate_6_credential_security(repo_root, mode="AUTO"):
 
 def gate_7_infer_linter(repo_root, mode="AUTO"):
     print("\n[GATE 7] Running Meta Infer-Style Static Defect & Fake-Pass Sentinel...")
-    scripts_dir = os.path.join(repo_root, "Scripts")
-    has_groovy = False
-    if os.path.isdir(scripts_dir):
-        groovy_files = [f for f in glob.glob(os.path.join(scripts_dir, "**", "*.groovy"), recursive=True)]
-        has_groovy = len(groovy_files) > 0
-
-    if not has_groovy:
-        if mode == "HUB":
-            print("[SKIP] Hub Mode: No Groovy test scripts in Scripts/ to scan (Static Defect Sentinel active for target projects).")
-            return True
-        else:
-            print("[SKIP] No Groovy test scripts present in Scripts/ directory.")
-            return True
+    effective_mode = detect_repo_mode(repo_root) if mode == "AUTO" else mode
+    if effective_mode == "HUB":
+        print("[PASS] Hub Mode: Static Defect Sentinel active for target projects.")
+        return True
+
+    test_dirs = ["Scripts", "tests", "test", "e2e", "specs", "cypress"]
+    has_tests = False
+    target_scan_dir = None
+    for td in test_dirs:
+        d = os.path.join(repo_root, td)
+        if os.path.isdir(d):
+            for ext in ("*.groovy", "*.ts", "*.js", "*.py", "*.java"):
+                if glob.glob(os.path.join(d, "**", ext), recursive=True):
+                    has_tests = True
+                    target_scan_dir = d
+                    break
+        if has_tests:
+            break
+
+    if not has_tests:
+        print("[SKIP] No test scripts (Groovy/TS/JS/Py) present in candidate test directories.")
+        return True
 
     infer_script = os.path.join(SCRIPT_DIR, "infer_linter.py")
     if not os.path.exists(infer_script):
         infer_script = os.path.join(repo_root, "tools", "infer_linter.py")
 
     if os.path.exists(infer_script):
-        res = subprocess.run([sys.executable, infer_script, "--dir", scripts_dir], stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+        res = subprocess.run([sys.executable, infer_script, "--dir", target_scan_dir], stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
         if res.returncode != 0:
             print("[FAIL] Static Defect Sentinel detected critical issues in test scripts:")
             print(res.stdout)