synapse-hub 2.7.0 → 3.0.1

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.1"
 
 MCP_TOOLS = [
     {
@@ -474,13 +473,15 @@ def _handle_pull_alm_story(arguments: Dict[str, Any]) -> str:
 
 def _handle_report_alm_defect(arguments: Dict[str, Any]) -> str:
     bridge = tms_sync_bridge.TMSBridge()
+    raw_screenshot = arguments.get("screenshot_path", "")
+    safe_screenshot = _validate_safe_path(raw_screenshot) if raw_screenshot else ""
     ticket = bridge.report_defect(
         project_key=arguments["project_key"],
         test_case_id=arguments["test_case_id"],
         summary=arguments["summary"],
         error_message=arguments["error_message"],
         stack_trace=arguments.get("stack_trace", ""),
-        screenshot_path=arguments.get("screenshot_path", "")
+        screenshot_path=safe_screenshot
     )
     return json.dumps(ticket, indent=2)
 
@@ -518,7 +519,8 @@ def _handle_convert_traffic_session(arguments: Dict[str, Any]) -> str:
 
 def _handle_resolve_visual_som_coordinates(arguments: Dict[str, Any]) -> str:
     helper = visual_som_helper.VisualSoMHelper()
-    img = arguments.get("image_path", "screenshot.png")
+    raw_img = arguments.get("image_path", "screenshot.png")
+    img = _validate_safe_path(raw_img)
     lbl = arguments.get("target_label")
     mid = arguments.get("mark_id")
     marked_img, marks_map = helper.generate_som_overlay(img, [])
@@ -527,7 +529,7 @@ def _handle_resolve_visual_som_coordinates(arguments: Dict[str, Any]) -> str:
 
 
 def _handle_compile_gherkin_suite(arguments: Dict[str, Any]) -> str:
-    target = arguments["target"]
+    target = _validate_safe_path(arguments["target"])
     res = gherkin_suite.compile_feature(target) if os.path.isfile(target) else gherkin_suite.run(target)
     if isinstance(res, int):
         return json.dumps({"exit_code": res, "detail": "see reports/gherkin_suite_report.json"}, indent=2)
@@ -599,7 +601,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

@@ -22,11 +22,11 @@ import os
 import re
 import sys
 import json
+import ast
 import shlex
 import html as html_lib
 import argparse
 import subprocess
-import tempfile
 from pathlib import Path
 from typing import List, Dict, Any, Tuple
 
@@ -60,11 +60,12 @@ MUTATION_RULES = [
     (r"\breturn\s+true\b", "return false", "Return Value Inversion (return true -> return false)"),
     (r"\breturn\s+false\b", "return true", "Return Value Inversion (return false -> return true)"),
     (r"\breturn\s+0\b", "return -1", "Return Value Shift (return 0 -> return -1)"),
+    (r"\s\?\?\s", " || ", "Nullish Coalescing Inversion (?? -> ||)"),
 ]
 
 # Action statement pattern for Statement Deletion Mutants
 ACTION_STATEMENT_PATTERN = re.compile(
-    r'\.(click|submit|save|update|delete|send|fill|press|type|execute)\s*\(',
+    r'\.(click|submit|save|update|delete|send|fill|press|type|execute|check|uncheck|hover|dragTo|selectOption|clear|focus|setInputFiles)\s*\(',
     re.IGNORECASE
 )
 
@@ -75,7 +76,12 @@ ASSERTION_PATTERN = re.compile(
 
 # Tautological / fake assertions that do not test application logic
 TAUTOLOGY_PATTERN = re.compile(
-    r'(?:assert\s+(?:true|1\s*==\s*1)\b|assert\s+([a-zA-Z_]\w*)\s*==\s*\1\b|assertEquals\s*\(\s*([a-zA-Z_]\w*)\s*,\s*\2\s*\)|expect\s*\(\s*([a-zA-Z_]\w*)\s*\)\.toBe\s*\(\s*\3\s*\)|assertTrue\s*\(\s*true\s*\))',
+    r'(?:assert\s+(?:true|1\s*==\s*1)\b'
+    r'|\bassert\s+([a-zA-Z0-9_\.]+(?:\([^)]*\))?)\s*==\s*\1\b'
+    r'|\bassert\s+(?:len\s*\([^)]*\)|[a-zA-Z0-9_\.]+\.(?:length|size\(\)))\s*(?:>=\s*0|>\s*-(?:1|0))\b'
+    r'|assertEquals\s*\(\s*([a-zA-Z_]\w*)\s*,\s*\1\s*\)'
+    r'|expect\s*\(\s*([a-zA-Z_]\w*)\s*\)\.toBe\s*\(\s*\1\s*\)'
+    r'|assertTrue\s*\(\s*true\s*\))',
     re.IGNORECASE
 )
 
@@ -260,9 +266,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 +277,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):
@@ -302,6 +308,10 @@ def evaluate_mutants_statically(code: str, mutants: List[Dict[str, Any]]) -> Tup
 
         # Case 1: Mutation directly in an assertion statement
         if ASSERTION_PATTERN.search(snippet):
+            if TAUTOLOGY_PATTERN.search(snippet):
+                m["status"] = "SURVIVED"
+                m["reason"] = "Mutant in tautological/dummy assertion - cannot kill mutant without genuine assertion logic"
+                continue
             m["status"] = "KILLED"
             m["reason"] = "Direct assertion mutation caught by verification condition"
             killed_count += 1
@@ -325,6 +335,13 @@ def evaluate_mutants_statically(code: str, mutants: List[Dict[str, Any]]) -> Tup
                     tgt = asgn.group(1)
                     if any(re.search(rf'\b{re.escape(t)}\b', l_code) for t in dataflow_tokens):
                         dataflow_tokens.add(tgt)
+                destruct = re.match(r'^\s*(?:(?:const|let|var|val)\s+)?[\{\(]([^\}\)]+)[\}\)]\s*=', l_code)
+                if destruct:
+                    vars_in_destruct = [v.strip().split(':')[0].strip() for v in destruct.group(1).split(',') if v.strip()]
+                    if any(re.search(rf'\b{re.escape(t)}\b', l_code) for t in dataflow_tokens):
+                        for v in vars_in_destruct:
+                            if re.match(r'^[a-zA-Z_][a-zA-Z0-9_]*$', v):
+                                dataflow_tokens.add(v)
 
             # Check if any assertion references the variables mutated in this logic branch or downstream dataflow
             has_variable_link = any(any(re.search(rf'\b{re.escape(tok)}\b', a_text) for tok in dataflow_tokens) for _, a_text in downstream)
@@ -489,9 +506,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()
@@ -634,17 +651,17 @@ def main():
         print(format_junit(report))
     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======================================================================")
+        mode_desc = f"LIVE DYNAMIC RUNNER (cmd: '{args.test_cmd}')" if report.get("mode") == "DYNAMIC" else "STATIC HEURISTIC (fast heuristic assertion sensitivity scan; pass --test-cmd for dynamic run)"
+        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:

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