synapse-hub 2.7.0 → 3.0.0

package/tools/omni_emitter.py

@@ -12,18 +12,15 @@ Supports:
   5. Cypress JavaScript (cypress-js)
 """
 
-import os
-from typing import Dict, List, Optional
+from typing import Dict
 
 try:
     from tools.universal_ir import (
-        ProjectIR, PageClassIR, TestCaseIR, MethodIR, StepIR, LocatorIR,
-        ActionType, LocatorStrategy, AssertionType
+        ProjectIR, ActionType, LocatorStrategy
     )
 except ImportError:
     from universal_ir import (
-        ProjectIR, PageClassIR, TestCaseIR, MethodIR, StepIR, LocatorIR,
-        ActionType, LocatorStrategy, AssertionType
+        ProjectIR, ActionType, LocatorStrategy
     )
 
 
@@ -243,7 +240,7 @@ export async function safeInteract(
             for tc in project.test_cases:
                 t_code.extend([
                     f"test('{escape_js(tc.id)}: {escape_js(tc.title)}', async ({{ page }}) => {{",
-                    f"  const uniqueCode = 'AUTO_' + Date.now();",
+                    "  const uniqueCode = 'AUTO_' + Date.now();",
                 ])
 
                 # Emit Hermetic Pre-flight Fixtures if present
@@ -445,7 +442,7 @@ export async function safeInteract(
                     "import com.kms.katalon.core.webui.keyword.WebUiBuiltInKeywords as WebUI",
                     "import pages.*",
                     "",
-                    f"String uniqueCode = BasePage.uniqueCode('AUTO_')",
+                    "String uniqueCode = BasePage.uniqueCode('AUTO_')",
                     "",
                 ]
                 for s in tc.steps:

package/tools/omni_parser.py

@@ -10,7 +10,6 @@ the Universal Intermediate Representation (universal_ir.ProjectIR).
 
 import os
 import re
-import sys
 from typing import Dict, List, Optional, Tuple
 
 try:
@@ -38,7 +37,7 @@ class OmniParser:
     @staticmethod
     def detect_language_and_framework(file_path: str, content: str) -> Tuple[str, str]:
         ext = os.path.splitext(file_path)[1].lower()
-        
+
         # Groovy / Katalon
         if ext == ".groovy":
             return "groovy", "katalon"
@@ -369,8 +368,8 @@ class OmniParser:
             # 0. Detect Hardcoded Sleep Antipatterns (Thread.sleep, WebUI.delay, cy.wait, time.sleep)
             sleep_m = re.search(r"(?:Thread\.sleep|WebUI\.delay|time\.sleep|cy\.wait)\s*\(\s*(\d+)\s*\)", line_str, re.IGNORECASE)
             if sleep_m:
-                val = int(sleep_m.group(1))
-                ms = val * 1000 if val <= 60 else val  # WebUI.delay(3) vs Thread.sleep(3000)
+                sleep_val = int(sleep_m.group(1))
+                ms = sleep_val * 1000 if sleep_val <= 60 else sleep_val  # WebUI.delay(3) vs Thread.sleep(3000)
                 steps.append(StepIR(
                     action=ActionType.WAIT,
                     wait_strategy=WaitStrategy.STATIC_SLEEP,
@@ -389,7 +388,8 @@ class OmniParser:
                 if cy_act == "click":
                     steps.append(StepIR(action=ActionType.CLICK, target=sel, description=f"Cypress click on {sel}"))
                 elif cy_act in ["type", "clear"]:
-                    type_val = extract_quoted_string(re.search(r"(?:\"([^\"]*)\"|'([^']*)')", cy_args).groups()) if re.search(r"(?:\"([^\"]*)\"|'([^']*)')", cy_args) else ""
+                    m_type = re.search(r"(?:\"([^\"]*)\"|'([^']*)')", cy_args)
+                    type_val = extract_quoted_string((m_type.group(1), m_type.group(2))) if m_type else ""
                     steps.append(StepIR(action=ActionType.FILL, target=sel, value=type_val, description=f"Cypress type on {sel}"))
                 elif cy_act == "should":
                     steps.append(StepIR(action=ActionType.ASSERT, target=sel, assertion_type=AssertionType.VISIBLE, description=line_str))

package/tools/omni_transpiler.py

@@ -12,15 +12,15 @@ import os
 import sys
 import json
 import argparse
-from typing import Dict, List, Any, Optional
+from typing import Dict, Any, Optional
 
 # Dynamic imports
 try:
-    from tools.universal_ir import ProjectIR, resolve_hermetic_fixtures, analyze_data_dependencies
+    from tools.universal_ir import resolve_hermetic_fixtures
     from tools.omni_parser import OmniParser
     from tools.omni_emitter import OmniEmitter
 except ImportError:
-    from universal_ir import ProjectIR, resolve_hermetic_fixtures, analyze_data_dependencies
+    from universal_ir import resolve_hermetic_fixtures
     from omni_parser import OmniParser
     from omni_emitter import OmniEmitter
 
@@ -65,7 +65,7 @@ def scan_repository(repo_path: str) -> Dict[str, Any]:
     if not os.path.exists(repo_path):
         raise FileNotFoundError(f"Path does not exist: {repo_path}")
 
-    inventory = {
+    inventory: Dict[str, Any] = {
         "repository": os.path.abspath(repo_path),
         "total_files_scanned": 0,
         "languages": {},
@@ -88,7 +88,7 @@ def scan_repository(repo_path: str) -> Dict[str, Any]:
                 try:
                     p_ir = OmniParser.parse_file(file_full)
                     inventory["total_files_scanned"] += 1
-                    
+
                     # Language counts
                     inventory["languages"][p_ir.source_language] = inventory["languages"].get(p_ir.source_language, 0) + 1
                     inventory["frameworks"][p_ir.source_framework] = inventory["frameworks"].get(p_ir.source_framework, 0) + 1

package/tools/output_formatter.py

@@ -58,26 +58,32 @@ class Colors:
 
     @classmethod
     def cyan(cls, text: str) -> str:
+        """Wraps text with ANSI cyan color if color output is enabled."""
         return f"{cls._c(cls.CYAN)}{text}{cls._c(cls.RESET)}"
 
     @classmethod
     def green(cls, text: str) -> str:
+        """Wraps text with ANSI green color if color output is enabled."""
         return f"{cls._c(cls.GREEN)}{text}{cls._c(cls.RESET)}"
 
     @classmethod
     def yellow(cls, text: str) -> str:
+        """Wraps text with ANSI yellow color if color output is enabled."""
         return f"{cls._c(cls.YELLOW)}{text}{cls._c(cls.RESET)}"
 
     @classmethod
     def red(cls, text: str) -> str:
+        """Wraps text with ANSI red color if color output is enabled."""
         return f"{cls._c(cls.RED)}{text}{cls._c(cls.RESET)}"
 
     @classmethod
     def bold(cls, text: str) -> str:
+        """Wraps text with ANSI bold weight if color output is enabled."""
         return f"{cls._c(cls.BOLD)}{text}{cls._c(cls.RESET)}"
 
     @classmethod
     def dim(cls, text: str) -> str:
+        """Wraps text with ANSI dim intensity if color output is enabled."""
         return f"{cls._c(cls.DIM)}{text}{cls._c(cls.RESET)}"
 
 
@@ -85,27 +91,34 @@ class OutputFormatter:
     """Standardized console & machine-readable output renderer."""
 
     def __init__(self, quiet: bool = False, json_mode: bool = False, verbose: bool = False):
+        """Initializes the output formatter with verbosity and mode toggles."""
         self.quiet = quiet
         self.json_mode = json_mode
         self.verbose = verbose
 
     def debug(self, message: str):
+        """Prints a debug message when verbose mode is active."""
         if self.verbose and not self.quiet and not self.json_mode:
             print(f"{Colors.dim('🔍 [DEBUG]')} {message}")
 
     def info(self, message: str):
+        """Alias for info_msg printing informational text."""
         self.info_msg(message)
 
     def warn(self, message: str):
+        """Alias for warn_msg printing warning text."""
         self.warn_msg(message)
 
     def error(self, message: str):
+        """Alias for fail_msg printing failure/error text."""
         self.fail_msg(message)
 
     def success(self, message: str):
+        """Alias for pass_msg printing passing/success text."""
         self.pass_msg(message)
 
     def header(self, title: str):
+        """Renders an eye-catching framed header box for CLI stages."""
         if not self.quiet and not self.json_mode:
             border = "=" * 70
             print(f"\n{Colors.cyan(border)}")
@@ -113,26 +126,32 @@ class OutputFormatter:
             print(f"{Colors.cyan(border)}\n")
 
     def step(self, current: int, total: int, title: str):
+        """Prints a numbered step indicator for multi-phase operations."""
         if not self.quiet and not self.json_mode:
             print(f"{Colors.bold(f'[{current}/{total}]')} {title}")
 
     def pass_msg(self, message: str):
+        """Prints a green checkmark pass badge with the given message."""
         if not self.json_mode:
             print(f"{Colors.green('✅ [PASS]')} {message}")
 
     def fail_msg(self, message: str):
+        """Prints a red cross fail badge with the given message."""
         if not self.json_mode:
             print(f"{Colors.red('❌ [FAIL]')} {message}")
 
     def warn_msg(self, message: str):
+        """Prints a yellow warning badge with the given message."""
         if not self.quiet and not self.json_mode:
             print(f"{Colors.yellow('⚠️  [WARN]')} {message}")
 
     def info_msg(self, message: str):
+        """Prints a cyan informational badge with the given message."""
         if not self.quiet and not self.json_mode:
             print(f"{Colors.cyan('ℹ️  [INFO]')} {message}")
 
     def print_data(self, data: Any, format_type: str = "text"):
+        """Formats and outputs data payload as either indented JSON or raw text."""
         if format_type == "json" or self.json_mode:
             if isinstance(data, (dict, list)):
                 print(json.dumps(data, indent=2, ensure_ascii=False))

package/tools/perf/__init__.py

@@ -0,0 +1,24 @@
+"""
+Synapse Hub — Performance, Stress & Flakiness Profilers (tools.perf)
+---------------------------------------------------------------------
+Domain package grouping all JMeter test plan generators, flakiness
+sentinels, BFCL agent gym benchmarks, and test matrix sharders.
+"""
+
+from tools import (
+    browsergym_eval,
+    db_sandbox,
+    flaky_detector,
+    generate_jmx_plan,
+    matrix_sharder,
+    synapse_qa_bench,
+)
+
+__all__ = [
+    "browsergym_eval",
+    "db_sandbox",
+    "flaky_detector",
+    "generate_jmx_plan",
+    "matrix_sharder",
+    "synapse_qa_bench",
+]

package/tools/pinpoint_failure.py

@@ -58,7 +58,7 @@ def parse_failures(xml_path):
                 if reason_match:
                     reason = reason_match.group(1).strip()
                 else:
-                    lines = [l.strip() for l in combined.split("\n") if l.strip()]
+                    lines = [line.strip() for line in combined.split("\n") if line.strip()]
                     reason = lines[0] if lines else "Unknown Error"
 
                 # Extract Failed Line in Groovy Page / Script

package/tools/project_state.py

@@ -8,9 +8,7 @@ Enforces a strict Rolling Window (< 50 lines, ~200 tokens) to guarantee zero tok
 
 import os
 import sys
-import json
 from datetime import datetime
-from pathlib import Path
 
 # Enforce UTF-8 stdout encoding for Windows console compatibility
 if hasattr(sys.stdout, 'reconfigure'):

package/tools/qa_event_stream.py

@@ -25,7 +25,7 @@ import json
 import hashlib
 import argparse
 from datetime import datetime, timezone
-from typing import Dict, Any, List, Optional, Tuple
+from typing import Dict, Any, Optional
 
 # Enforce UTF-8 stdout encoding
 if hasattr(sys.stdout, 'reconfigure'):

package/tools/repo_map.py

@@ -199,13 +199,13 @@ def build_repo_map(target_repo=None, output_txt=None, output_json=None):
     # Render text map
     timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
     out_lines = [
-        f"# ==============================================================================",
-        f"# ENTERPRISE AUTOMATION REPOSITORY MAP (Aider-Style AST Compression)",
+        "# ==============================================================================",
+        "# ENTERPRISE AUTOMATION REPOSITORY MAP (Aider-Style AST Compression)",
         f"# Generated : {timestamp}",
         f"# Target    : {repo}",
         f"# Scope     : {len(classes)} Classes ({total_raw_lines} source lines, {total_raw_bytes / 1024:.1f} KB)",
-        f"# Purpose   : Token-budgeted index (< 600 tokens) for instant method lookup",
-        f"# ==============================================================================\n"
+        "# Purpose   : Token-budgeted index (< 600 tokens) for instant method lookup",
+        "# ==============================================================================\n"
     ]
 
     total_methods = 0
@@ -294,9 +294,9 @@ def main():
         return 1
 
     stats = build_repo_map(target_repo=target_repo)
-    print(f"\n======================================================================")
-    print(f"       Enterprise Repository Map Compressor (Aider-Style AST Map)           ")
-    print(f"======================================================================")
+    print("\n======================================================================")
+    print("       Enterprise Repository Map Compressor (Aider-Style AST Map)           ")
+    print("======================================================================")
     print(f"  Target Repository       : {stats['target_repo']}")
     print(f"  Indexed Classes         : {stats['classes_count']} Page Classes & Helpers")
     print(f"  Extracted Methods       : {stats['methods_count']} API signatures")
@@ -304,7 +304,7 @@ def main():
     print(f"  Compressed Map Size     : {stats['compressed_bytes'] / 1024:.1f} KB (~{stats['estimated_tokens']} tokens)")
     print(f"  Compression Ratio       : {stats['compression_ratio_pct']:.1f}% reduction")
     print(f"  Artifact Generated      : {stats['output_file']}")
-    print(f"======================================================================\n")
+    print("======================================================================\n")
 
     if args.print:
         with open(stats['output_file'], "r", encoding="utf-8") as f:

package/tools/report/__init__.py

@@ -0,0 +1,32 @@
+"""
+Synapse Hub — Reporting & Telemetry Engines (tools.report)
+----------------------------------------------------------
+Domain package grouping all HTML dashboard, spreadsheet, JTL/Newman
+metric parser, and visual reporting tools.
+"""
+
+from tools import (
+    bug_reporter,
+    dashboard_generator,
+    generate_allure_report,
+    generate_test_reports,
+    jtl_analyzer,
+    md_to_xlsx,
+    newman_analyzer,
+    output_formatter,
+    telemetry_correlator,
+    welcome_page,
+)
+
+__all__ = [
+    "bug_reporter",
+    "dashboard_generator",
+    "generate_allure_report",
+    "generate_test_reports",
+    "jtl_analyzer",
+    "md_to_xlsx",
+    "newman_analyzer",
+    "output_formatter",
+    "telemetry_correlator",
+    "welcome_page",
+]

package/tools/reversible_sandbox.py

@@ -17,11 +17,10 @@ Reference:
 
 import os
 import sys
-import json
 import shlex
 import subprocess
 from dataclasses import dataclass, field
-from typing import List, Optional, Callable, Dict, Any
+from typing import List, Optional, Dict, Any
 
 # Enforce UTF-8 stdout encoding for Windows console compatibility
 if hasattr(sys.stdout, 'reconfigure'):

package/tools/safety_firewall.py

@@ -245,7 +245,7 @@ def detect_action_loop(action_history: List[str], repeat_threshold: int = 4) ->
     """
     Detects infinite action loops and repeating cycle patterns among agent tool calls.
     Inspired by agentblazo/blazo deterministic detection rules.
-    
+
     Checks:
       1. Consecutive identical actions (>= repeat_threshold)
       2. 2-action repeating cycle: [A, B, A, B]
@@ -411,7 +411,7 @@ def main():
             if all_authorized:
                 print(f"\n✅ All actions cleared by Safety Firewall{' (Dry-Run)' if args.dry_run else ''}.\n")
             else:
-                print(f"\n❌ Pre-execution Blocked: Destructive actions intercepted without --force or ALLOW_DESTRUCTIVE=1.\n")
+                print("\n❌ Pre-execution Blocked: Destructive actions intercepted without --force or ALLOW_DESTRUCTIVE=1.\n")
 
         return 0 if all_authorized else 1
 

package/tools/senior_code_review.py

@@ -28,7 +28,7 @@ import re
 import json
 import subprocess
 import argparse
-from typing import Dict, List, Any, Optional, Tuple
+from typing import Dict, List, Any, Tuple
 
 if hasattr(sys.stdout, 'reconfigure'):
     try:
@@ -83,7 +83,7 @@ def get_git_diff(repo_dir: str, target: str = "uncommitted") -> str:
             check=True
         )
         return res.stdout
-    except Exception as e:
+    except Exception:
         return ""
 
 

package/tools/setup_project.py

@@ -24,7 +24,6 @@ import json
 import shutil
 import argparse
 from pathlib import Path
-from datetime import datetime
 
 # Enforce UTF-8 stdout encoding for Windows console compatibility
 if hasattr(sys.stdout, 'reconfigure'):
@@ -39,9 +38,8 @@ HUB_ROOT = os.path.abspath(os.path.join(SCRIPT_DIR, ".."))
 TEMPLATES_DIR = os.path.join(HUB_ROOT, "templates")
 sys.path.insert(0, SCRIPT_DIR)
 
-import analyze_project
-import verify_all
-import project_state
+import analyze_project  # noqa: E402
+import project_state  # noqa: E402
 
 GREEN = "\033[92m"
 RED = "\033[91m"
@@ -412,7 +410,7 @@ def inject_antigravity_global_plugin():
                 try:
                     os.unlink(dst)
                 except OSError:
-                    unlinked = False
+                    _ = False
             if sys.platform == "win32":
                 try:
                     import _winapi
@@ -420,7 +418,7 @@ def inject_antigravity_global_plugin():
                         _winapi.CreateJunction(src, dst)
                         return
                 except (OSError, ImportError, AttributeError):
-                    junction_created = False
+                    _ = False
             shutil.copytree(src, dst, dirs_exist_ok=True, ignore=shutil.ignore_patterns("__pycache__", "*.pyc", "*.tmp"))
 
         sync_dir(os.path.join(HUB_ROOT, ".agents", "skills"), os.path.join(target_plugin_dir, "skills"))
@@ -612,26 +610,26 @@ def run_setup(target_repo, dry_run=False, profile="auto", no_global=True, no_git
     if dry_run:
         print(f"Operational Mode   : {YELLOW}DRY-RUN (Simulating without modifying files on disk){RESET}\n")
     else:
-        print(f"Operational Mode   : APPLY CHANGES\n")
+        print("Operational Mode   : APPLY CHANGES\n")
 
     if dry_run:
         print(f"{YELLOW}[DRY-RUN PREVIEW]{RESET}")
         print(f"  • Profile: {profile.upper()}")
         print(f"  • Would generate: {os.path.join(target_repo, 'PROJECT_AI_GUIDE.md')}")
-        print(f"  • Would deploy AI bridges: .cursor/rules/synapse-qa.mdc, .github/copilot-instructions.md, .windsurfrules")
+        print("  • Would deploy AI bridges: .cursor/rules/synapse-qa.mdc, .github/copilot-instructions.md, .windsurfrules")
         print(f"  • Would install pre-push hook: {os.path.join(target_repo, '.git', 'hooks', 'pre-push')}")
-        print(f"  • Would initialize: Central Agent Memory (~/.agent_memory/global_cache.db)")
+        print("  • Would initialize: Central Agent Memory (~/.agent_memory/global_cache.db)")
         print(f"\n{GREEN}✅ Dry-run completed successfully. Zero changes written to disk.{RESET}\n")
         return 0
 
     # 2. Ensure PROJECT_AI_GUIDE.md & PROJECT_STATE.md
     print(f"{BOLD}[1/5] Checking Project AI Guide & State Anchor...{RESET}")
-    guide_created = ensure_project_ai_guide(target_repo, stack_info, profile=profile)
+    ensure_project_ai_guide(target_repo, stack_info, profile=profile)
     project_state.init_state(target_repo)
 
     # 3. Deploy Universal AI Bridges (Cursor, Claude Code, GitHub Copilot, Windsurf)
     print(f"\n{BOLD}[2/5] Deploying Universal AI Bridges (Cursor, Claude, Copilot, Windsurf)...{RESET}")
-    bridges_deployed = install_universal_ai_bridges(target_repo)
+    install_universal_ai_bridges(target_repo)
 
     # 4. Inject Antigravity Global Plugin
     plugin_injected = False
@@ -687,7 +685,7 @@ def run_setup(target_repo, dry_run=False, profile="auto", no_global=True, no_git
     print(f"  Target Framework    : {stack_info['framework']}")
     print(f"  Active Profile      : {profile.upper()}")
     print(f"  AI Project Guide    : {os.path.join(target_repo, 'PROJECT_AI_GUIDE.md')}")
-    print(f"  Universal Bridges   : Cursor (.cursor/rules), Claude Code, Copilot, Windsurf")
+    print("  Universal Bridges   : Cursor (.cursor/rules), Claude Code, Copilot, Windsurf")
     print(f"  Antigravity Plugin  : {'ACTIVE (~/.gemini/config/plugins/synapse-hub)' if plugin_injected else 'STANDALONE'}")
     print(f"  AST Method Map      : {os.path.join(target_repo, 'repo_map.txt')}")
     print(f"  Health Report       : {os.path.join(target_repo, 'PROJECT_HEALTH_REPORT.md')}")

package/tools/skill_collision_guard.py

@@ -23,8 +23,8 @@ import sys
 import re
 import math
 import json
+from typing import Dict, List, Tuple, Any
 import argparse
-from typing import Dict, List, Tuple
 from collections import Counter
 
 # Enforce UTF-8 stdout encoding for Windows console compatibility
@@ -136,7 +136,7 @@ class SkillCollisionGuard:
         fallback_name = os.path.basename(os.path.dirname(path))
         return fallback_name, ""
 
-    def audit(self) -> Tuple[bool, List[Dict[str, any]]]:
+    def audit(self) -> Tuple[bool, List[Dict[str, Any]]]:
         """
         Computes pairwise similarity.
         Returns (is_clean, report_items).
@@ -211,7 +211,7 @@ def run_guard(skills_dir: str = ".agents/skills", threshold: float = 0.75, warn_
         print("=" * 70 + "\n")
         return 1
 
-    print(f"\n✅ [PASS] 0 routing collisions detected. All skill descriptions uniquely segmented.\n")
+    print("\n✅ [PASS] 0 routing collisions detected. All skill descriptions uniquely segmented.\n")
     print("=" * 70 + "\n")
     return 0
 

package/tools/skill_vault.py

@@ -22,7 +22,7 @@ import json
 import re
 import difflib
 import argparse
-from dataclasses import dataclass, asdict
+from dataclasses import dataclass
 from typing import List, Optional, Dict, Any, Set
 
 # Enforce UTF-8 stdout encoding for Windows console compatibility
@@ -101,6 +101,15 @@ class PageClassPrimitive:
     tags: str = ""            # Comma-separated domain tags, e.g. "auth,sso,login"
 
 
+class ManagedConnection(sqlite3.Connection):
+    """SQLite connection that automatically commits/rollbacks and closes on context exit."""
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        try:
+            super().__exit__(exc_type, exc_val, exc_tb)
+        finally:
+            self.close()
+
+
 class SkillVault:
     """Persistent library of verified, self-contained Page Class methods."""
 
@@ -113,8 +122,8 @@ class SkillVault:
         self.db_path = db_path
         self._init_schema()
 
-    def _get_connection(self) -> sqlite3.Connection:
-        conn = sqlite3.connect(self.db_path)
+    def _get_connection(self) -> ManagedConnection:
+        conn = sqlite3.connect(self.db_path, factory=ManagedConnection)
         conn.row_factory = sqlite3.Row
         return conn
 

package/tools/skillspector.py

@@ -42,17 +42,15 @@ Usage:
 from __future__ import annotations
 
 import ast
-import fnmatch
 import hashlib
 import json
 import os
 import re
 import sys
-import unicodedata
 from dataclasses import dataclass, field
 from enum import Enum
 from pathlib import Path
-from typing import Any, Dict, List, Optional, Set, Tuple
+from typing import Any, Dict, List, Tuple
 
 # Enforce UTF-8 stdout encoding for Windows console compatibility
 if hasattr(sys.stdout, "reconfigure"):
@@ -529,9 +527,9 @@ def scan_text_patterns(file_path: str, content: str) -> List[Finding]:
     # Line number offset indexing
     line_offsets = []
     curr = 0
-    for l in lines:
+    for line_str in lines:
         line_offsets.append(curr)
-        curr += len(l)
+        curr += len(line_str)
 
     def get_line_num(char_idx: int) -> int:
         for idx, offset in enumerate(line_offsets):
@@ -925,7 +923,7 @@ def scan_file(file_path: str) -> List[Finding]:
     try:
         with open(file_path, "r", encoding="utf-8", errors="ignore") as f:
             content = f.read()
-    except Exception as e:
+    except Exception:
         return []
 
     findings: List[Finding] = []
@@ -1013,7 +1011,7 @@ def format_terminal(report: ScanReport) -> str:
     out.append(f"{BOLD}{CYAN}======================================================================{RESET}")
     out.append(f"📁 Target Scope   : {report.target_path}")
     out.append(f"📄 Scanned Files  : {report.scanned_files}")
-    out.append(f"🛡️  Engine Source  : NVIDIA/SkillSpector Spec (71 Patterns, 17 Categories)")
+    out.append("🛡️  Engine Source  : NVIDIA/SkillSpector Spec (71 Patterns, 17 Categories)")
 
     rec_color = GREEN if report.recommendation == Recommendation.SAFE else (YELLOW if report.recommendation == Recommendation.CAUTION else RED)
     out.append(f"\n{BOLD}🎯 AUDIT VERDICT :{RESET} {rec_color}{BOLD}{report.recommendation.value}{RESET}")

package/tools/smart_visual_masker.py

@@ -7,11 +7,9 @@ Automatically disables dynamic CSS animations, freezes SVG spinners,
 and masks fluctuating UI elements (timestamps, clocks, avatars, ad banners).
 """
 
-import os
-import re
 import json
 import argparse
-from typing import List, Dict, Any, Tuple
+from typing import List, Optional
 
 
 class SmartVisualMasker:
@@ -56,13 +54,13 @@ class SmartVisualMasker:
         return cls.ANTI_FLAKE_CSS.strip()
 
     @classmethod
-    def generate_playwright_ts_options(cls, additional_selectors: List[str] = None) -> str:
+    def generate_playwright_ts_options(cls, additional_selectors: Optional[List[str]] = None) -> str:
         """
         Generates Playwright TypeScript assertion options with masking and disabled animations.
         """
         selectors = cls.DEFAULT_MASK_SELECTORS + (additional_selectors or [])
         locators_ts = ",\n    ".join([f"page.locator('{sel}')" for sel in selectors])
-        
+
         return f"""await expect(page).toHaveScreenshot('visual-baseline.png', {{
   animations: 'disabled',
   caret: 'hide',
@@ -74,7 +72,7 @@ class SmartVisualMasker:
 }});"""
 
     @classmethod
-    def generate_browser_mask_script(cls, selectors: List[str] = None) -> str:
+    def generate_browser_mask_script(cls, selectors: Optional[List[str]] = None) -> str:
         """
         Generates JavaScript snippet to run inside the live browser
         to immediately freeze DOM animations and paint solid black masks

package/tools/spec_drift_sentinel.py

@@ -206,7 +206,6 @@ def compute_drift(spec_criteria: List[Dict[str, Any]], code_files: List[Tuple[st
         all_code_actions.extend([(file_path, a) for a in actions])
         combined_code += "\n" + content
 
-    combined_code_lower = combined_code.lower()
     code_tokens = tokenize_text(combined_code)
 
     covered_criteria = []
@@ -289,7 +288,7 @@ def generate_markdown_report(result: Dict[str, Any], spec_file: str, code_path:
     md.append("> Generated autonomously by Synapse-Hub `tools/spec_drift_sentinel.py`  ")
     md.append(f"> **Specification:** `{spec_file}` | **Code Target:** `{code_path}`  \n")
     md.append("---")
-    
+
     status_icon = "✅" if result["passed"] else "❌"
     md.append(f"## 📊 Executive Summary: {status_icon} [{result['status']}]")
     md.append(f"- **Alignment Score:** `{result['alignment_score']}%` (Pass threshold: >= 80% & zero Deficit Drift)")

package/tools/swe_qa_aci.py

@@ -216,8 +216,8 @@ class SweQaAci:
             f.write(new_content)
 
         # Diff summary formatting
-        target_lines = [f"- {l}" for l in norm_target.splitlines()]
-        replacement_lines = [f"+ {l}" for l in norm_replacement.splitlines()]
+        target_lines = [f"- {line}" for line in norm_target.splitlines()]
+        replacement_lines = [f"+ {line}" for line in norm_replacement.splitlines()]
         diff_summary = "\n".join(target_lines + replacement_lines)
 
         return {