synapse-hub 2.7.0 → 3.0.0

package/tools/jtl_analyzer.py

@@ -163,16 +163,16 @@ def parse_csv_jtl(filepath: str) -> Tuple[Dict[str, SamplerStats], SamplerStats]
                 # Column names can vary slightly across JMeter versions
                 elapsed = float(row.get("elapsed") or row.get("Elapsed") or row.get("time") or 0)
                 label = row.get("label") or row.get("Label") or "Unknown"
-                
+
                 success_val = row.get("success") or row.get("Success") or "true"
                 success = str(success_val).strip().lower() in ("true", "1")
-                
+
                 ts_val = row.get("timeStamp") or row.get("Timestamp") or row.get("t") or 0
                 timestamp = int(float(ts_val))
-                
+
                 bytes_val = row.get("bytes") or row.get("Bytes") or 0
                 bytes_recv = int(float(bytes_val))
-                
+
                 resp_code = row.get("responseCode") or row.get("ResponseCode") or row.get("rc") or "200"
 
                 if label not in per_sampler:
@@ -236,7 +236,7 @@ def evaluate_sla(
 ) -> Tuple[bool, List[str]]:
     """Evaluates computed aggregate metrics against SLA limits."""
     violations: List[str] = []
-    
+
     if sla_p95 is not None and agg_stats["p95_ms"] > sla_p95:
         violations.append(f"P95 Latency SLA Breached: {agg_stats['p95_ms']}ms > {sla_p95}ms")
 
@@ -261,7 +261,7 @@ def format_table(per_sampler_data: List[Dict[str, Any]], agg_data: Dict[str, Any
     lines = []
     header_str = " | ".join(h.ljust(col_w[i]) for i, h in enumerate(headers))
     sep_str = "-+-".join("-" * col_w[i] for i in range(len(headers)))
-    
+
     lines.append(header_str)
     lines.append(sep_str)
 
@@ -271,7 +271,7 @@ def format_table(per_sampler_data: List[Dict[str, Any]], agg_data: Dict[str, Any
         if len(label) > 28:
             label = label[:25] + "..."
         err_str = f"{row['errors']} ({row['error_rate_pct']}%)"
-        
+
         row_str = " | ".join([
             label.ljust(col_w[0]),
             str(row["samples"]).rjust(col_w[1]),
@@ -301,7 +301,7 @@ def generate_markdown_report(
 ) -> str:
     """Generates GitHub / GitLab Markdown report for Pull Request annotations."""
     status_badge = "✅ **PASSED**" if passed else "❌ **FAILED (SLA BREACHED)**"
-    
+
     lines = [
         "# 🚀 Apache JMeter Performance & Load Test Report",
         "",
@@ -377,7 +377,7 @@ def main():
         with open(temp_jtl, "w", encoding="utf-8", newline="") as f:
             writer = csv.writer(f)
             writer.writerow(["timeStamp", "elapsed", "label", "responseCode", "responseMessage", "threadName", "dataType", "success", "failureMessage", "bytes", "sentBytes", "grpThreads", "allThreads", "URL", "Latency", "IdleTime", "Connect"])
-            
+
             # Generate 200 synthetic rows
             import time
             base_time = int(time.time() * 1000)
@@ -387,7 +387,7 @@ def main():
                 writer.writerow([base_time + (i * 100), 280 + (i % 80), "[POST] /api/v1/orders", "201", "Created", "Thread 1-2", "text", "true", "", 2048, 512, 10, 10, "http://api.local/orders", 270, 0, 20])
             for i in range(5):
                 writer.writerow([base_time + (i * 100), 1500, "[POST] /api/v1/orders", "500", "Internal Error", "Thread 1-2", "text", "false", "DB Timeout", 512, 512, 10, 10, "http://api.local/orders", 1490, 0, 25])
-        
+
         args.jtl_file = temp_jtl
         print(f"🔬 [SAMPLE MODE] Generated synthetic benchmark JTL: {temp_jtl}")
 
@@ -414,7 +414,7 @@ def main():
     print("=" * 90)
 
     # Print SLA Verdict
-    print(f"\n🎯 [QUALITY GATE SLA VERDICT]")
+    print("\n🎯 [QUALITY GATE SLA VERDICT]")
     if passed:
         print("✅ ALL PERFORMANCE SLAs PASSED! Ready for deployment/merge.")
     else:

package/tools/lint/__init__.py

@@ -0,0 +1,30 @@
+"""
+Synapse Hub — Static Quality & Policy Sentinels (tools.lint)
+-----------------------------------------------------------
+Domain package grouping all static code defect, encoding, license,
+and AI documentation drift verification tools.
+"""
+
+from tools import (
+    author_integrity,
+    check_version_sync,
+    git_pre_commit_guard,
+    infer_linter,
+    lint_ai_docs,
+    skill_collision_guard,
+    skillspector,
+    spec_drift_sentinel,
+    validate_groovy_scripts,
+)
+
+__all__ = [
+    "author_integrity",
+    "check_version_sync",
+    "git_pre_commit_guard",
+    "infer_linter",
+    "lint_ai_docs",
+    "skill_collision_guard",
+    "skillspector",
+    "spec_drift_sentinel",
+    "validate_groovy_scripts",
+]

package/tools/lint_ai_docs.py

@@ -281,8 +281,50 @@ def lint_docs(repo_root):
                     if mname not in valid_methods:
                         errors.append(f"[{doc}:{line_no}] Non-existent method referenced: '{cname}.{mname}()' (Class '{cname}' does not define this method)")
 
+    # 6. Documentation Metrics Consistency (Detects stale skill/tool/gate numbers)
+    metric_errors = check_doc_metrics_consistency(repo_root)
+    errors.extend(metric_errors)
+
     return errors, warnings
 
+
+def check_doc_metrics_consistency(repo_root):
+    """Verifies that documented counts (skills, tools, DoD gates) accurately match disk."""
+    errors = []
+    skills_dir = os.path.join(repo_root, ".agents", "skills")
+    tools_dir = os.path.join(repo_root, "tools")
+
+    if not os.path.isdir(skills_dir) or not os.path.isdir(tools_dir):
+        return errors
+
+    skills_count = len([d for d in os.listdir(skills_dir) if os.path.isdir(os.path.join(skills_dir, d)) and os.path.exists(os.path.join(skills_dir, d, "SKILL.md"))])
+    tools_count = len([f for f in os.listdir(tools_dir) if f.endswith(".py") and f != "__init__.py"])
+
+    obsolete_patterns = [
+        (re.compile(r'\b(42|50)\s+(kỹ năng|skills?)\b', re.IGNORECASE), f"Obsolete skill count detected (real count: {skills_count})"),
+        (re.compile(r'\b(60|68)\s+(công cụ|tools?)\b', re.IGNORECASE), f"Obsolete tool count detected (real count: {tools_count})"),
+        (re.compile(r'\b9\s+Cổng\s+Chất\s+Lượng\b', re.IGNORECASE), "Obsolete gate count detected: must refer to 10 Cổng Chất Lượng DoD (Gate 0–9)"),
+    ]
+
+    docs_to_check = [
+        os.path.join(repo_root, "README.md"),
+        os.path.join(repo_root, "README.en.md"),
+        os.path.join(repo_root, "docs", "ARCHITECTURE.md"),
+        os.path.join(repo_root, "docs", "CONTRIBUTING.md"),
+    ]
+
+    for doc_path in docs_to_check:
+        if not os.path.exists(doc_path):
+            continue
+        rel_doc = os.path.relpath(doc_path, repo_root)
+        with open(doc_path, "r", encoding="utf-8", errors="ignore") as f:
+            for line_no, line in enumerate(f, 1):
+                for pattern, msg in obsolete_patterns:
+                    if pattern.search(line):
+                        errors.append(f"[{rel_doc}:{line_no}] {msg}: '{line.strip()}'")
+
+    return errors
+
 def main():
     import argparse
     parser = argparse.ArgumentParser(description="Enterprise AI Documentation & Artifact Linter")

package/tools/lookup_tc.py

@@ -87,7 +87,7 @@ def normalize_testcase_data(raw_data):
             return raw_data["testcases"]
         if "items" in raw_data and isinstance(raw_data["items"], list):
             return raw_data["items"]
-        
+
         flat = []
         for k, v in raw_data.items():
             if isinstance(v, dict):

package/tools/matrix_sharder.py

@@ -52,13 +52,15 @@ def estimate_test_duration(file_path: str, full_path: str) -> float:
     if os.path.exists(CACHE_DB_PATH):
         try:
             conn = sqlite3.connect(CACHE_DB_PATH)
-            cur = conn.cursor()
-            cur.execute("CREATE TABLE IF NOT EXISTS test_runtimes (test_path TEXT PRIMARY KEY, duration REAL)")
-            cur.execute("SELECT duration FROM test_runtimes WHERE test_path = ?", (file_path,))
-            row = cur.fetchone()
-            conn.close()
-            if row and row[0]:
-                return float(row[0])
+            try:
+                cur = conn.cursor()
+                cur.execute("CREATE TABLE IF NOT EXISTS test_runtimes (test_path TEXT PRIMARY KEY, duration REAL)")
+                cur.execute("SELECT duration FROM test_runtimes WHERE test_path = ?", (file_path,))
+                row = cur.fetchone()
+                if row and row[0]:
+                    return float(row[0])
+            finally:
+                conn.close()
         except sqlite3.Error:
             conn = None
 
@@ -93,14 +95,14 @@ def shard_tests_lpt(test_files: List[str], target_dir: str, num_shards: int) ->
     tests_with_cost.sort(key=lambda x: x[1], reverse=True)
 
     # 3. Initialize shards
-    shards = [{"shard_index": i + 1, "total_duration": 0.0, "tests": []} for i in range(num_shards)]
+    shards: List[Dict[str, Any]] = [{"shard_index": i + 1, "total_duration": 0.0, "tests": []} for i in range(num_shards)]
 
     # 4. Greedily assign to the shard with the least current cumulative duration
     for test_file, dur in tests_with_cost:
         # Find shard with min duration
-        min_shard = min(shards, key=lambda s: s["total_duration"])
+        min_shard = min(shards, key=lambda s: float(s["total_duration"]))
         min_shard["tests"].append(test_file)
-        min_shard["total_duration"] = round(min_shard["total_duration"] + dur, 2)
+        min_shard["total_duration"] = round(float(min_shard["total_duration"]) + dur, 2)
 
     return shards
 
@@ -119,9 +121,9 @@ def main():
     if args.json:
         print(json.dumps({"total_tests": len(test_files), "shards_count": args.shards, "shards": shards}, indent=2))
     else:
-        print(f"\n======================================================================")
+        print("\n======================================================================")
         print(f"      DURATION-BALANCED TEST MATRIX SHARDER ({args.shards} PARALLEL WORKERS)    ")
-        print(f"======================================================================")
+        print("======================================================================")
         print(f"  Target Scope : {target_dir}")
         print(f"  Total Tests  : {len(test_files)} files\n")
 
@@ -137,7 +139,7 @@ def main():
         durations = [s["total_duration"] for s in shards]
         delta = max(durations) - min(durations) if durations else 0
         print(f"⚡ Shard Imbalance Delta: {delta:.1f}s (Optimal parallel distribution)")
-        print(f"======================================================================\n")
+        print("======================================================================\n")
 
     return 0
 

package/tools/mcp/__init__.py

@@ -0,0 +1,16 @@
+"""
+Synapse Hub — Model Context Protocol (MCP) Servers (tools.mcp)
+--------------------------------------------------------------
+Domain package grouping all standard MCP services: core QA automation
+MCP server and offline Excel spreadsheet manipulation server.
+"""
+
+from tools import (
+    mcp_excel_server,
+    mcp_server,
+)
+
+__all__ = [
+    "mcp_excel_server",
+    "mcp_server",
+]

package/tools/mcp_excel_server.py

@@ -23,7 +23,7 @@ if hasattr(sys.stdout, 'reconfigure'):
     except Exception:
         pass
 
-SERVER_VERSION = "2.7.0"
+SERVER_VERSION = "3.0.0"
 
 NS_MAIN = "{http://schemas.openxmlformats.org/spreadsheetml/2006/main}"
 NS_REL = "{http://schemas.openxmlformats.org/officeDocument/2006/relationships}"
@@ -88,7 +88,7 @@ def read_sheet_rows(xlsx_path: str, sheet_name: Optional[str] = None, max_rows:
                 for c in row.iter(f"{NS_MAIN}c"):
                     cell_type = c.attrib.get("t")
                     val_elem = c.find(f"{NS_MAIN}v")
-                    raw_val = val_elem.text if val_elem is not None else ""
+                    raw_val = (val_elem.text or "") if val_elem is not None else ""
 
                     if cell_type == "s" and raw_val.isdigit():
                         idx = int(raw_val)

package/tools/mcp_server.py

@@ -11,9 +11,8 @@ import os
 import sys
 import json
 import re
-import traceback
 from pathlib import Path
-from typing import Dict, Any, List, Optional, Set
+from typing import Dict, Any, Optional, Set
 
 # Enforce UTF-8 stdio encoding
 if hasattr(sys.stdout, 'reconfigure'):
@@ -47,7 +46,7 @@ import gherkin_suite
 import api_fuzzer
 
 SERVER_NAME = "enterprise-agent-qa"
-SERVER_VERSION = "2.7.0"
+SERVER_VERSION = "3.0.0"
 
 MCP_TOOLS = [
     {
@@ -599,7 +598,7 @@ def handle_tool_call(name: str, arguments: Dict[str, Any]) -> str:
     return handler(arguments)
 
 
-def process_message(msg: Dict[str, Any]) -> Dict[str, Any]:
+def process_message(msg: Dict[str, Any]) -> Optional[Dict[str, Any]]:
     """Processes an incoming JSON-RPC 2.0 message."""
     method = msg.get("method")
     msg_id = msg.get("id")

package/tools/md_to_xlsx.py

@@ -16,7 +16,7 @@ import os
 import sys
 import re
 import argparse
-from typing import List, Dict, Any, Tuple
+from typing import List, Tuple
 
 # UTF-8 terminal encoding
 if hasattr(sys.stdout, 'reconfigure'):
@@ -52,11 +52,11 @@ def parse_markdown_tables(content: str) -> List[Tuple[List[str], List[List[str]]
     """
     lines = content.splitlines()
     tables = []
-    
+
     current_header = None
     current_rows = []
     in_table = False
-    
+
     for line in lines:
         stripped = line.strip()
         if not stripped.startswith('|') or not stripped.endswith('|'):
@@ -66,15 +66,15 @@ def parse_markdown_tables(content: str) -> List[Tuple[List[str], List[List[str]]
                 current_rows = []
                 in_table = False
             continue
-            
+
         # Split cells
         raw_cells = [c.strip() for c in stripped[1:-1].split('|')]
-        
+
         # Check if separator row (|---|---|)
         if all(re.match(r'^\s*:?-+:?\s*$', c) for c in raw_cells if c):
             in_table = True
             continue
-            
+
         if not in_table:
             # First line with pipes is potential header
             current_header = [clean_cell_content(c) for c in raw_cells]
@@ -88,10 +88,10 @@ def parse_markdown_tables(content: str) -> List[Tuple[List[str], List[List[str]]
                 elif len(cleaned_row) > len(current_header):
                     cleaned_row = cleaned_row[:len(current_header)]
             current_rows.append(cleaned_row)
-            
+
     if in_table and current_header and current_rows:
         tables.append((current_header, current_rows))
-        
+
     return tables
 
 
@@ -108,32 +108,32 @@ def create_styled_excel(tables: List[Tuple[List[str], List[List[str]]]], output_
     NAVY_BLUE = "1F4E78"
     WHITE = "FFFFFF"
     BORDER_COLOR = "D9D9D9"
-    
+
     # Styles
     header_fill = PatternFill(start_color=NAVY_BLUE, end_color=NAVY_BLUE, fill_type="solid")
     header_font = Font(name="Calibri", size=11, bold=True, color=WHITE)
     header_align = Alignment(horizontal="center", vertical="center", wrap_text=True)
-    
+
     cell_border = Border(
         left=Side(style='thin', color=BORDER_COLOR),
         right=Side(style='thin', color=BORDER_COLOR),
         top=Side(style='thin', color=BORDER_COLOR),
         bottom=Side(style='thin', color=BORDER_COLOR)
     )
-    
+
     # Status badges
     fill_high = PatternFill(start_color="FCE4D6", fill_type="solid")     # Soft Red
     font_high = Font(name="Calibri", size=10, bold=True, color="C00000")
-    
+
     fill_med = PatternFill(start_color="FFF2CC", fill_type="solid")      # Soft Yellow
     font_med = Font(name="Calibri", size=10, bold=True, color="B25900")
-    
+
     fill_low = PatternFill(start_color="E2EFDA", fill_type="solid")      # Soft Green
     font_low = Font(name="Calibri", size=10, bold=True, color="375623")
-    
+
     fill_yes = PatternFill(start_color="E2EFDA", fill_type="solid")
     font_yes = Font(name="Calibri", size=10, color="276A3C", bold=True)
-    
+
     fill_no = PatternFill(start_color="F2F2F2", fill_type="solid")
     font_no = Font(name="Calibri", size=10, color="595959")
 
@@ -191,16 +191,16 @@ def create_styled_excel(tables: List[Tuple[List[str], List[List[str]]]], output_
     for row_data in all_rows:
         ws.append(row_data)
         ws.row_dimensions[current_row_idx].height = None  # Auto height for wrapped text
-        
+
         for col_idx, val in enumerate(row_data, 1):
             cell = ws.cell(row=current_row_idx, column=col_idx)
             cell.border = cell_border
             cell.font = Font(name="Calibri", size=10)
-            
+
             h_name = col_types.get(col_idx, "")
             val_str = str(val).strip()
             val_lower = val_str.lower()
-            
+
             # Alignments & Styling based on column semantic
             if any(k in h_name for k in ["steps", "expected", "title", "scenario", "pre-condition"]):
                 cell.alignment = Alignment(horizontal="left", vertical="top", wrap_text=True)
@@ -246,23 +246,23 @@ def create_styled_excel(tables: List[Tuple[List[str], List[List[str]]]], output_
     for col_idx, header in enumerate(primary_headers, 1):
         h_lower = header.lower().strip()
         col_letter = get_column_letter(col_idx)
-        
+
         # Check presets
         target_width = None
         for key, width in width_map.items():
             if key in h_lower:
                 target_width = width
                 break
-                
+
         if not target_width:
             # Dynamic max calculation
             max_len = len(header)
             for r in all_rows:
                 if col_idx - 1 < len(r):
                     lines = str(r[col_idx - 1]).split('\n')
-                    for l in lines:
-                        if len(l) > max_len:
-                            max_len = len(l)
+                    for line_val in lines:
+                        if len(line_val) > max_len:
+                            max_len = len(line_val)
             target_width = min(max(max_len + 3, 12), 45)
 
         ws.column_dimensions[col_letter].width = target_width
@@ -278,13 +278,13 @@ def main():
     parser.add_argument("input", help="Path to input Markdown file (.md)")
     parser.add_argument("-o", "--output", help="Path to output Excel file (.xlsx). Defaults to same name as input.")
     parser.add_argument("--sheet-name", default="Test Cases", help="Worksheet title (default: Test Cases)")
-    
+
     args = parser.parse_args()
-    
+
     if not os.path.exists(args.input):
         print(f"❌ Error: Input file not found: {args.input}", file=sys.stderr)
         sys.exit(1)
-        
+
     output_path = args.output
     if not output_path:
         base, _ = os.path.splitext(args.input)

package/tools/micro_mutator.py

@@ -26,7 +26,6 @@ import shlex
 import html as html_lib
 import argparse
 import subprocess
-import tempfile
 from pathlib import Path
 from typing import List, Dict, Any, Tuple
 
@@ -260,9 +259,9 @@ def evaluate_mutants_statically(code: str, mutants: List[Dict[str, Any]]) -> Tup
     """
     if not mutants:
         has_asserts = any(
-            ASSERTION_PATTERN.search(l) and not TAUTOLOGY_PATTERN.search(l)
-            for l in code.splitlines()
-            if not l.strip().startswith(("//", "#", "/*"))
+            ASSERTION_PATTERN.search(line) and not TAUTOLOGY_PATTERN.search(line)
+            for line in code.splitlines()
+            if not line.strip().startswith(("//", "#", "/*"))
         )
         return mutants, (100.0 if has_asserts else 0.0)
 
@@ -271,8 +270,8 @@ def evaluate_mutants_statically(code: str, mutants: List[Dict[str, Any]]) -> Tup
 
     # Identify lines containing assertions
     assertion_entries = []
-    for idx, l in enumerate(lines, start=1):
-        s = l.strip()
+    for idx, line in enumerate(lines, start=1):
+        s = line.strip()
         if s.startswith(("//", "#", "/*")):
             continue
         if ASSERTION_PATTERN.search(s) and not TAUTOLOGY_PATTERN.search(s):
@@ -489,9 +488,9 @@ def evaluate_target(target_path: str, min_score: float = 80.0, test_cmd: str = "
         valid_exts = {".groovy", ".py", ".ts", ".js"}
         file_scores = {}
         for root, _, files in os.walk(target):
-            for f in files:
-                if any(f.endswith(ext) for ext in valid_exts):
-                    file_full = os.path.join(root, f)
+            for filename in files:
+                if any(filename.endswith(ext) for ext in valid_exts):
+                    file_full = os.path.join(root, filename)
                     try:
                         with open(file_full, "r", encoding="utf-8", errors="ignore") as fp:
                             code = fp.read()
@@ -635,16 +634,16 @@ def main():
     else:
         mode_tag = "LIVE DYNAMIC RUNNER" if report.get("mode") == "DYNAMIC" else "STATIC HEURISTIC"
         mode_desc = f"LIVE DYNAMIC RUNNER (cmd: '{args.test_cmd}')" if report.get("mode") == "DYNAMIC" else "STATIC HEURISTIC (fast 0.1s AST; pass --test-cmd for dynamic run)"
-        print(f"\n======================================================================")
+        print("\n======================================================================")
         print(f"   ASSERTION SENSITIVITY & SYNTACTIC MUTATION SENTINEL [{mode_tag}]    ")
-        print(f"======================================================================")
+        print("======================================================================")
         print(f"  Target Scope          : {report['target']}")
         print(f"  Evaluation Mode       : {mode_desc}")
         print(f"  Mutants Injected      : {report['total_mutants']}")
         print(f"  Mutants Caught/Killed : {report['killed']}")
         print(f"  Mutants Survived      : {report['survived']}")
         print(f"  Assertion Sensitivity : {report['mutation_score']}% (Required: >={report['min_score']}%)")
-        print(f"======================================================================\n")
+        print("======================================================================\n")
 
         for m in report['mutants'][:6]:
             status_tag = "[KILLED]  " if m["status"] == "KILLED" else "[SURVIVED]"

package/tools/network_mock_shield.py

@@ -88,16 +88,16 @@ class NetworkMockShield:
         code = [
             f"# Mock API Interception for '{url_pattern}'",
             "import time, json",
-            f"def handle_route(route):",
+            "def handle_route(route):",
         ]
         if delay_ms > 0:
             code.append(f"    time.sleep({delay_ms / 1000.0})")
         code.extend([
-            f"    route.fulfill(",
+            "    route.fulfill(",
             f"        status={status},",
-            f"        content_type='application/json',",
+            "        content_type='application/json',",
             f"        body=json.dumps({body_json})",
-            f"    )",
+            "    )",
             f"page.route('{url_pattern}', handle_route)"
         ])
         return "\n".join(code)
@@ -119,52 +119,52 @@ class NetworkMockShield:
         if mode == "record":
             if lang == "python":
                 return "\n".join([
-                    f"# --- ZERO-LATENCY HAR RECORDING HARNESS (Playwright Python) ---",
+                    "# --- ZERO-LATENCY HAR RECORDING HARNESS (Playwright Python) ---",
                     f"# Dumps live network traffic to '{har_path}'",
-                    f"context = browser.new_context(",
+                    "context = browser.new_context(",
                     f"    record_har_path='{har_path}',",
-                    f"    record_har_mode='minimal',",
+                    "    record_har_mode='minimal',",
                     f"    record_har_url_filter='{url_glob}'",
-                    f")",
-                    f"page = context.new_page()",
+                    ")",
+                    "page = context.new_page()",
                     f"# Note: Run 'python tools/network_mock_shield.py --har-sanitize {har_path}' before committing to git!"
                 ])
             else:
                 return "\n".join([
-                    f"// --- ZERO-LATENCY HAR RECORDING HARNESS (Playwright TS) ---",
+                    "// --- ZERO-LATENCY HAR RECORDING HARNESS (Playwright TS) ---",
                     f"// Dumps live network traffic to '{har_path}'",
-                    f"const context = await browser.newContext({{",
-                    f"  recordHar: {{",
+                    "const context = await browser.newContext({",
+                    "  recordHar: {",
                     f"    path: '{har_path}',",
-                    f"    mode: 'minimal',",
+                    "    mode: 'minimal',",
                     f"    urlFilter: '{url_glob}'",
-                    f"  }}",
-                    f"}});",
-                    f"const page = await context.newPage();",
+                    "  }",
+                    "});",
+                    "const page = await context.newPage();",
                     f"// Note: Run 'python tools/network_mock_shield.py --har-sanitize {har_path}' before committing to git!"
                 ])
         else:
             # Replay Mode
             if lang == "python":
                 return "\n".join([
-                    f"# --- ZERO-LATENCY HAR REPLAY HARNESS (Playwright Python) ---",
-                    f"# Replays 100% network responses from local HAR with 0ms delay (Immune to backend downtime)",
-                    f"page.route_from_har(",
+                    "# --- ZERO-LATENCY HAR REPLAY HARNESS (Playwright Python) ---",
+                    "# Replays 100% network responses from local HAR with 0ms delay (Immune to backend downtime)",
+                    "page.route_from_har(",
                     f"    har_id='{har_path}',",
                     f"    url='{url_glob}',",
-                    f"    not_found='fallback',",
-                    f"    update=False",
-                    f")"
+                    "    not_found='fallback',",
+                    "    update=False",
+                    ")"
                 ])
             else:
                 return "\n".join([
-                    f"// --- ZERO-LATENCY HAR REPLAY HARNESS (Playwright TS) ---",
-                    f"// Replays 100% network responses from local HAR with 0ms delay (Immune to backend downtime)",
+                    "// --- ZERO-LATENCY HAR REPLAY HARNESS (Playwright TS) ---",
+                    "// Replays 100% network responses from local HAR with 0ms delay (Immune to backend downtime)",
                     f"await page.routeFromHAR('{har_path}', {{",
                     f"  url: '{url_glob}',",
-                    f"  notFound: 'fallback',",
-                    f"  update: false",
-                    f"}});"
+                    "  notFound: 'fallback',",
+                    "  update: false",
+                    "});"
                 ])
 
     @classmethod

package/tools/newman_analyzer.py

@@ -54,7 +54,6 @@ def parse_newman_json(report_path: str) -> Dict[str, Any]:
 
     run = data.get("run", {})
     stats = run.get("stats", {})
-    timings = run.get("timings", {})
     executions = run.get("executions", [])
     failures = run.get("failures", [])
 
@@ -110,7 +109,7 @@ def parse_newman_json(report_path: str) -> Dict[str, Any]:
         err = f.get("error", {})
         source = f.get("source", {})
         cursor = f.get("cursor", {})
-        
+
         req_name = source.get("name", cursor.get("ref", "Request"))
         assert_name = err.get("test", err.get("name", "Assertion Failure"))
         message = err.get("message", "Unknown assertion error")
@@ -351,7 +350,7 @@ def main():
     print("-" * 90)
 
     # Print SLA Verdict
-    print(f"🎯 [QUALITY GATE SLA VERDICT]")
+    print("🎯 [QUALITY GATE SLA VERDICT]")
     if passed:
         print("✅ ALL API FUNCTIONAL & SLA GATES PASSED! Safe to merge/deploy.")
     else: