synapse-hub 2.2.4 → 2.4.1

package/tools/micro_mutator.py

@@ -1,22 +1,29 @@
 #!/usr/bin/env python3
 """
-Enterprise AST Micro-Mutation Testing Sentinel
------------------------------------------------
-Evaluates the true defect-catching efficacy of AI-generated tests by injecting
+Assertion Sensitivity & Syntactic Micro-Mutation Sentinel (Heuristic)
+---------------------------------------------------------------------
+Evaluates the true defect-catching efficacy of test suites by injecting
 syntactic micro-mutants (inverting operators, flipping booleans, altering boundaries)
 to eradicate 'Tautological Tests' (tests that pass unconditionally without valid assertions).
 
 Features:
-  - Atomic AST/syntactic fault injection across Groovy, Python, TypeScript, JavaScript
-  - Static assertion sensitivity analysis (killing mutants when valid assertions exist)
+  - Atomic syntactic fault injection across Groovy, Python, TypeScript, JavaScript
+  - Static assertion sensitivity analysis (killing mutants when valid assertions verify downstream logic)
   - Dynamic test execution mode (--test-cmd) for live mutant verification
-  - Quality Gatekeeper hard threshold enforcement (--min-score, default: 80.0%)
+  - Quality Gatekeeper threshold enforcement (--min-score, default: 80.0%)
+
+Implementation Note:
+  Static evaluation is a lightweight, heuristic assertion-sensitivity analysis
+  (fast, polyglot, token-free), not a compiler-grade mutation testing tool like Stryker or mutmut.
+  It measures whether test logic is bounded by active downstream assertions rather than passing unconditionally.
 """
 
 import os
 import re
 import sys
 import json
+import shlex
+import html as html_lib
 import argparse
 import subprocess
 import tempfile
@@ -57,7 +64,7 @@ MUTATION_RULES = [
 
 # Action statement pattern for Statement Deletion Mutants
 ACTION_STATEMENT_PATTERN = re.compile(
-    r'\.(click|submit|save|update|delete|send|fill|press|type|execute|write)\s*\(',
+    r'\.(click|submit|save|update|delete|send|fill|press|type|execute)\s*\(',
     re.IGNORECASE
 )
 
@@ -99,38 +106,95 @@ def is_inside_quotes(line: str, pos: int) -> bool:
     return in_single or in_double
 
 
+def mask_non_executable_contexts(code: str) -> str:
+    """Replaces multiline strings, docstrings, comments and string fixtures with blank lines
+    to preserve exact line numbering while eliminating false positives during static analysis."""
+    lines = code.splitlines(keepends=True)
+    in_ml = False
+    ml_char = ""
+    masked = []
+    triple_d = '"""'
+    triple_s = "'''"
+
+    for line in lines:
+        stripped = line.strip()
+        if in_ml:
+            if ml_char in stripped:
+                in_ml = False
+                ml_char = ""
+            masked.append("\n")
+            continue
+
+        for q in (triple_d, triple_s):
+            if q in stripped and stripped.count(q) % 2 == 1:
+                in_ml = True
+                ml_char = q
+                break
+
+        if in_ml:
+            masked.append("\n")
+        else:
+            # Mask string fixtures containing catch blocks or test code samples
+            if "catch" in stripped and ('"' in stripped or "'" in stripped):
+                masked.append("\n")
+            else:
+                masked.append(line)
+
+    return "".join(masked)
+
+
 def generate_mutants_for_code(code: str, file_path: str = "") -> List[Dict[str, Any]]:
     """
     Generates single-point syntactic mutants from source code string.
     Each mutant represents exactly one atomic fault injection.
-    Only generates mutants on active executable lines, ignoring comments & docstrings.
+    Only generates mutants on active executable lines, ignoring comments, multiline strings & runners.
     """
     lines = code.splitlines(keepends=True)
     mutants = []
     mutant_id = 1
-    in_docstring = False
+    in_multiline = False
+    ml_char = ""
+    triple_d = '"""'
+    triple_s = "'''"
 
     for line_idx, line in enumerate(lines):
         stripped = line.strip()
 
-        # Track python / groovy multiline docstrings
-        if stripped.startswith(('"""', "'''")):
-            if stripped.count('"""') % 2 == 1 or stripped.count("'''") % 2 == 1:
-                in_docstring = not in_docstring
+        # Track multiline docstrings and string assignments
+        if in_multiline:
+            if ml_char in stripped:
+                in_multiline = False
+                ml_char = ""
             continue
-        if in_docstring:
-            if '"""' in stripped or "'''" in stripped:
-                in_docstring = False
+
+        for q in (triple_d, triple_s):
+            if q in stripped and stripped.count(q) % 2 == 1:
+                in_multiline = True
+                ml_char = q
+                break
+
+        if in_multiline:
             continue
 
         # Skip pure comments or imports
         if stripped.startswith(("//", "#", "/*", "*", "import", "package", "from")):
             continue
 
+        # Skip test runner boilerplate, entry points, and file writing harness logic
+        if re.search(r"\b(if\s+__name__\s*==|unittest\.main\(\)|sys\.exit\(|\.write\()", stripped):
+            continue
+
+        # Skip tuples/lists of mock code templates in data fixtures
+        if stripped.startswith("(") and ('"' in stripped or "'" in stripped):
+            continue
+
         # Statement Deletion Mutant (Simulates omitted UI action or bypassed step)
         if ACTION_STATEMENT_PATTERN.search(stripped) and not ASSERTION_PATTERN.search(stripped):
             indent = line[:len(line) - len(line.lstrip())]
-            mutated_line = f"{indent}// MUTANT_DELETED: {stripped}\n"
+            if file_path.endswith((".py", ".pyw")):
+                mutated_line = f"{indent}pass  # MUTANT_DELETED: {stripped}\n"
+            else:
+                mutated_line = f"{indent}// MUTANT_DELETED: {stripped}\n"
             mutated_lines = list(lines)
             mutated_lines[line_idx] = mutated_line
             mutants.append({
@@ -168,7 +232,7 @@ def generate_mutants_for_code(code: str, file_path: str = "") -> List[Dict[str,
                     "mutated_snippet": mutated_line.strip(),
                     "description": desc,
                     "mutated_code": mutated_code,
-                    "status": "SURVIVED"  # Evaluated by analyze_and_score_mutants
+                    "status": "SURVIVED"
                 })
                 mutant_id += 1
 
@@ -206,21 +270,31 @@ def evaluate_mutants_statically(code: str, mutants: List[Dict[str, Any]]) -> Tup
     has_empty_catch = bool(EMPTY_CATCH_PATTERN.search(code))
 
     # Identify lines containing assertions
-    valid_assertion_lines = []
+    assertion_entries = []
     for idx, l in enumerate(lines, start=1):
         s = l.strip()
         if s.startswith(("//", "#", "/*")):
             continue
         if ASSERTION_PATTERN.search(s) and not TAUTOLOGY_PATTERN.search(s):
-            valid_assertion_lines.append(idx)
+            assertion_entries.append((idx, s))
 
     # Zero valid assertions across code -> all mutants survive (Fake Pass!)
-    if not valid_assertion_lines:
+    if not assertion_entries:
         for m in mutants:
             m["status"] = "SURVIVED"
             m["reason"] = "No valid assertions found in test script (Fake-Pass Trap)"
         return mutants, 0.0
 
+    COMMON_KEYWORDS = {
+        "if", "else", "def", "return", "for", "in", "and", "or", "not", "val", "var",
+        "let", "const", "True", "False", "None", "null", "int", "str", "float", "bool",
+        "function", "class", "this", "self"
+    }
+    DOMAIN_TEST_NOISE = {
+        "page", "await", "expect", "browser", "driver", "window", "document",
+        "locator", "WebUI", "findTestObject", "cy", "playwright"
+    }
+
     killed_count = 0
     for m in mutants:
         m_line = m["line"]
@@ -233,24 +307,41 @@ def evaluate_mutants_statically(code: str, mutants: List[Dict[str, Any]]) -> Tup
             killed_count += 1
             continue
 
-        # Case 2: Mutation in logic followed by downstream assertions
-        downstream_assertions = [a_line for a_line in valid_assertion_lines if a_line >= m_line]
-        if downstream_assertions and not has_empty_catch:
-            # Check if within reasonable proximity (same block/method, e.g. within 30 lines)
-            if any(a_line - m_line <= 30 for a_line in downstream_assertions):
+        # Case 2: Mutation in logic followed by downstream assertions with variable dataflow linkage
+        tokens = (set(re.findall(r'\b[a-zA-Z_][a-zA-Z0-9_]*\b', snippet)) - COMMON_KEYWORDS - DOMAIN_TEST_NOISE)
+        tokens = {t for t in tokens if len(t) > 1}
+        downstream = [
+            (a_line, a_text) for a_line, a_text in assertion_entries
+            if a_line >= m_line and a_line - m_line <= 30
+        ]
+        if downstream and not has_empty_catch and tokens:
+            # 1-hop dataflow propagation across intermediate lines between m_line and downstream assertions
+            max_line = min(len(lines), m_line + 30)
+            dataflow_tokens = set(tokens)
+            for idx in range(m_line, max_line):
+                l_code = lines[idx]
+                asgn = re.match(r'^\s*([a-zA-Z_][a-zA-Z0-9_]*)\s*=', l_code)
+                if asgn:
+                    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)
+
+            # 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)
+            if has_variable_link:
                 m["status"] = "KILLED"
-                m["reason"] = f"Logic mutant caught by downstream assertion at line {downstream_assertions[0]}"
+                m["reason"] = f"Logic mutant caught by downstream assertion referencing mutated state (line {downstream[0][0]})"
                 killed_count += 1
                 continue
 
         m["status"] = "SURVIVED"
-        m["reason"] = "Mutant survived: no assertion verified this logic branch"
+        m["reason"] = "Mutant survived: no downstream assertion validates the mutated variables"
 
     score = evaluate_mutation_score(killed_count, len(mutants))
     return mutants, score
 
 
-def evaluate_mutants_dynamically(file_path: str, code: str, mutants: List[Dict[str, Any]], test_cmd: str) -> Tuple[List[Dict[str, Any]], float]:
+def evaluate_mutants_dynamically(file_path: str, code: str, mutants: List[Dict[str, Any]], test_cmd: str, timeout: float = 60.0) -> Tuple[List[Dict[str, Any]], float]:
     """
     Executes live mutation testing by injecting mutants into disk file and executing test_cmd.
     If the test command fails (exit code != 0), the mutant is KILLED by the test suite.
@@ -260,21 +351,64 @@ def evaluate_mutants_dynamically(file_path: str, code: str, mutants: List[Dict[s
     if not mutants:
         return mutants, 0.0
 
+    cmd_args = shlex.split(test_cmd, posix=sys.platform != "win32") if isinstance(test_cmd, str) else test_cmd
+
+    # F15: Baseline execution check - test suite must be GREEN on pristine code
+    try:
+        baseline_proc = subprocess.run(
+            cmd_args,
+            capture_output=True,
+            timeout=int(timeout),
+            text=True
+        )
+        if baseline_proc.returncode != 0:
+            for m in mutants:
+                m["status"] = "SURVIVED"
+                m["reason"] = f"Baseline test run failed (exit code {baseline_proc.returncode}). Tests must pass on clean code before mutation."
+            return mutants, 0.0
+    except subprocess.TimeoutExpired:
+        for m in mutants:
+            m["status"] = "SURVIVED"
+            m["reason"] = f"Baseline execution error: timed out after {int(timeout)} seconds"
+        return mutants, 0.0
+    except Exception as e:
+        for m in mutants:
+            m["status"] = "SURVIVED"
+            m["reason"] = f"Baseline execution error: {e}"
+        return mutants, 0.0
+
     killed_count = 0
+    valid_mutants_count = 0
     abs_path = os.path.abspath(file_path)
+    backup_path = abs_path + ".synapse_mutator_bak"
 
+    # F3 Safety Discipline: Create a dedicated atomic backup file
+    # and guarantee recovery via try/finally and os.replace
     try:
+        with open(backup_path, "w", encoding="utf-8") as bf:
+            bf.write(code)
+
         for m in mutants:
             mutated_code = m["mutated_code"]
+
+            # F14: Syntax validation for Python - discard invalid syntactic mutants
+            if file_path.endswith((".py", ".pyw")):
+                try:
+                    compile(mutated_code, file_path, "exec")
+                except SyntaxError:
+                    m["status"] = "INVALID_SYNTAX"
+                    m["reason"] = "Mutant generated invalid Python syntax; discarded to prevent false killed verdict"
+                    continue
+
+            valid_mutants_count += 1
             with open(abs_path, "w", encoding="utf-8") as f:
                 f.write(mutated_code)
 
             try:
                 proc = subprocess.run(
-                    test_cmd,
-                    shell=True,
+                    cmd_args,
                     capture_output=True,
-                    timeout=30,
+                    timeout=int(timeout),
                     text=True
                 )
                 if proc.returncode != 0:
@@ -285,15 +419,26 @@ def evaluate_mutants_dynamically(file_path: str, code: str, mutants: List[Dict[s
                     m["status"] = "SURVIVED"
                     m["reason"] = "Dynamic test suite passed unconditionally: missing assertion for this mutant."
             except subprocess.TimeoutExpired:
-                m["status"] = "KILLED"
-                m["reason"] = "Mutant triggered execution timeout (> 30s): caught by runtime guard"
-                killed_count += 1
+                # F16: Inconclusive timeout does not count as killed
+                m["status"] = "TIMED_OUT"
+                m["reason"] = f"Mutant execution timed out (> {int(timeout)}s): inconclusive assertion sensitivity"
             except Exception as e:
                 m["status"] = "SURVIVED"
                 m["reason"] = f"Test execution error: {e}"
     finally:
-        with open(abs_path, "w", encoding="utf-8") as f:
-            f.write(code)
+        # Atomic restore guaranteed from backup file
+        if os.path.exists(backup_path):
+            with open(backup_path, "r", encoding="utf-8") as bf:
+                clean_content = bf.read()
+            with open(abs_path, "w", encoding="utf-8") as f:
+                f.write(clean_content)
+            try:
+                os.remove(backup_path)
+            except Exception:
+                pass
+        else:
+            with open(abs_path, "w", encoding="utf-8") as f:
+                f.write(code)
 
     score = evaluate_mutation_score(killed_count, len(mutants))
     return mutants, score
@@ -320,7 +465,7 @@ def scan_directory_for_mutants(target_dir: str) -> List[Dict[str, Any]]:
     return all_mutants
 
 
-def evaluate_target(target_path: str, min_score: float = 80.0, test_cmd: str = "") -> Dict[str, Any]:
+def evaluate_target(target_path: str, min_score: float = 80.0, test_cmd: str = "", timeout: float = 60.0, min_file_score: float = 0.0) -> Dict[str, Any]:
     """
     Evaluates target file or directory for mutation robustness.
     Dispatches to live test execution if test_cmd is provided, or static heuristic otherwise.
@@ -334,12 +479,15 @@ def evaluate_target(target_path: str, min_score: float = 80.0, test_cmd: str = "
             code = f.read()
         mutants = generate_mutants_for_code(code, file_path=os.path.basename(target))
         if test_cmd:
-            evaluated_mutants, score = evaluate_mutants_dynamically(target, code, mutants, test_cmd)
+            evaluated_mutants, score = evaluate_mutants_dynamically(target, code, mutants, test_cmd, timeout=timeout)
         else:
-            evaluated_mutants, score = evaluate_mutants_statically(code, mutants)
+            masked_code = mask_non_executable_contexts(code)
+            evaluated_mutants, score = evaluate_mutants_statically(masked_code, mutants)
         all_mutants.extend(evaluated_mutants)
+        file_scores = {os.path.basename(target): score}
     else:
         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):
@@ -349,11 +497,14 @@ def evaluate_target(target_path: str, min_score: float = 80.0, test_cmd: str = "
                             code = fp.read()
                         rel_path = os.path.relpath(file_full, target)
                         f_mutants = generate_mutants_for_code(code, file_path=rel_path)
-                        if test_cmd:
-                            eval_m, _ = evaluate_mutants_dynamically(file_full, code, f_mutants, test_cmd)
-                        else:
-                            eval_m, _ = evaluate_mutants_statically(code, f_mutants)
-                        all_mutants.extend(eval_m)
+                        if f_mutants:
+                            if test_cmd:
+                                eval_m, f_score = evaluate_mutants_dynamically(file_full, code, f_mutants, test_cmd, timeout=timeout)
+                            else:
+                                masked_code = mask_non_executable_contexts(code)
+                                eval_m, f_score = evaluate_mutants_statically(masked_code, f_mutants)
+                            all_mutants.extend(eval_m)
+                            file_scores[rel_path] = f_score
                     except Exception:
                         pass
 
@@ -364,7 +515,13 @@ def evaluate_target(target_path: str, min_score: float = 80.0, test_cmd: str = "
     survived = sum(1 for m in all_mutants if m["status"] == "SURVIVED")
     passed = score >= min_score
 
-    return {
+    failed_files = {}
+    if not os.path.isfile(target) and min_file_score > 0.0:
+        failed_files = {f: s for f, s in file_scores.items() if s < min_file_score}
+        if failed_files:
+            passed = False
+
+    report_res = {
         "target": target,
         "mode": exec_mode,
         "total_mutants": len(all_mutants),
@@ -372,45 +529,121 @@ def evaluate_target(target_path: str, min_score: float = 80.0, test_cmd: str = "
         "survived": survived,
         "mutation_score": score,
         "min_score": min_score,
+        "min_file_score": min_file_score,
         "passed": passed,
         "mutants": all_mutants
     }
-
-    return {
-        "target": target,
-        "total_mutants": len(all_mutants),
-        "killed": killed,
-        "survived": survived,
-        "mutation_score": score,
-        "min_score": min_score,
-        "passed": passed,
-        "mutants": all_mutants
+    if not os.path.isfile(target):
+        report_res["file_scores"] = file_scores
+        if failed_files:
+            report_res["failed_files"] = failed_files
+    return report_res
+
+
+def format_sarif(report: Dict[str, Any]) -> str:
+    """Formats survived mutants in SARIF 2.1.0 format for GitHub Code Scanning."""
+    results = []
+    rules_dict = {}
+    for m in report.get("mutants", []):
+        if m.get("status") == "SURVIVED":
+            rule_id = "SYNAPSE_MUTANT_SURVIVED"
+            if rule_id not in rules_dict:
+                rules_dict[rule_id] = {
+                    "id": rule_id,
+                    "shortDescription": {"text": "Syntactic micro-mutant survived downstream assertion check"},
+                    "defaultConfiguration": {"level": "error"}
+                }
+            results.append({
+                "ruleId": rule_id,
+                "level": "error",
+                "message": {"text": f"Mutant survived: {m.get('description', '')} ({m.get('original_snippet', '')} -> {m.get('mutated_snippet', '')})"},
+                "locations": [{
+                    "physicalLocation": {
+                        "artifactLocation": {"uri": m.get("file", report.get("target", ""))},
+                        "region": {"startLine": max(1, m.get("line", 1))}
+                    }
+                }]
+            })
+    sarif_doc = {
+        "$schema": "https://json.schemastore.org/sarif-2.1.0.json",
+        "version": "2.1.0",
+        "runs": [{
+            "tool": {
+                "driver": {
+                    "name": "synapse-micro-mutator",
+                    "version": "2.3.0",
+                    "rules": list(rules_dict.values())
+                }
+            },
+            "results": results
+        }]
     }
+    return json.dumps(sarif_doc, indent=2, ensure_ascii=False)
+
+
+def format_junit(report: Dict[str, Any]) -> str:
+    """Formats mutation evaluation in standard JUnit XML format."""
+    total = max(1, report.get("total_mutants", 0))
+    survived = report.get("survived", 0)
+    lines = [
+        '<?xml version="1.0" encoding="utf-8"?>',
+        f'<testsuite name="synapse-micro-mutator" tests="{total}" failures="{survived}" errors="0">'
+    ]
+    for m in report.get("mutants", []):
+        cname = (m.get("file") or report.get("target", "")).replace("/", ".").replace("\\", ".")
+        clean_desc = re.sub(r'[^a-zA-Z0-9_]', '_', m.get('description', 'mutant'))
+        tname = f"Mutant_L{m.get('line', 1)}_{clean_desc}"
+        lines.append(f'  <testcase classname="{cname}" name="{tname}">')
+        if m.get("status") == "SURVIVED":
+            desc = html_lib.escape(m.get("description", ""))
+            orig = html_lib.escape(m.get("original_snippet", ""))
+            mut = html_lib.escape(m.get("mutated_snippet", ""))
+            reason = html_lib.escape(m.get("reason", "Downstream assertions failed to kill mutant"))
+            lines.append(f'    <failure message="Mutant survived: {desc}" type="MUTANT_SURVIVED">Line {m.get("line", 1)}: {orig} -> {mut}. Reason: {reason}</failure>')
+        lines.append('  </testcase>')
+    if not report.get("mutants"):
+        lines.append('  <testcase classname="synapse.mutator" name="clean_run"/>')
+    lines.append('</testsuite>')
+    return "\n".join(lines)
 
 
 def main():
-    parser = argparse.ArgumentParser(description="AST Micro-Mutation Testing Sentinel & Quality Gate")
+    parser = argparse.ArgumentParser(description="Assertion Sensitivity & Syntactic Micro-Mutation Sentinel (Heuristic)")
     parser.add_argument("target", nargs="?", default=os.getcwd(), help="Target script or directory to mutate")
     parser.add_argument("--min-score", "--threshold", type=float, default=80.0, dest="min_score",
-                        help="Minimum mutation score percentage required to pass Quality Gate (default: 80.0)")
+                        help="Minimum assertion sensitivity percentage required to pass Quality Gate (default: 80.0)")
+    parser.add_argument("--min-file-score", type=float, default=0.0, help="Minimum assertion sensitivity percentage required per file (default: 0.0)")
+    parser.add_argument("--timeout", type=float, default=60.0, help="Per-mutant test execution timeout in seconds (default: 60.0)")
     parser.add_argument("--test-cmd", default="", help="Optional dynamic test execution command to verify mutants")
-    parser.add_argument("--dry-run", action="store_true", default=True, help="Scan and list mutants without modifying files")
+    parser.add_argument("--dry-run", action="store_true", default=False, help="Scan and list mutants without modifying files")
     parser.add_argument("--json", action="store_true", help="Output results in JSON format")
+    parser.add_argument("--format", choices=["text", "json", "sarif", "junit"], default="text",
+                        help="Output format: text (default), json, sarif, or junit")
     args = parser.parse_args()
 
-    report = evaluate_target(args.target, min_score=args.min_score, test_cmd=args.test_cmd)
+    effective_test_cmd = "" if args.dry_run else args.test_cmd
+    report = evaluate_target(args.target, min_score=args.min_score, test_cmd=effective_test_cmd, timeout=args.timeout, min_file_score=args.min_file_score)
+
+    output_format = "json" if args.json else args.format
 
-    if args.json:
+    if output_format == "json":
         print(json.dumps(report, indent=2))
+    elif output_format == "sarif":
+        print(format_sarif(report))
+    elif output_format == "junit":
+        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======================================================================")
-        print(f"      ENTERPRISE AST MICRO-MUTATION SENTINEL (ANTIDOTE TO FAKE PASS)  ")
+        print(f"   ASSERTION SENSITIVITY & SYNTACTIC MUTATION SENTINEL [{mode_tag}]    ")
         print(f"======================================================================")
-        print(f"  Target Scope     : {report['target']}")
-        print(f"  Mutants Injected : {report['total_mutants']}")
-        print(f"  Mutants Killed   : {report['killed']}")
-        print(f"  Mutants Survived : {report['survived']}")
-        print(f"  Mutation Score   : {report['mutation_score']}% (Required: >={report['min_score']}%)")
+        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")
 
         for m in report['mutants'][:6]:
@@ -424,9 +657,9 @@ def main():
             print(f"... and {len(report['mutants']) - 6} more mutants evaluated.\n")
 
         if report["passed"]:
-            print(f"✅ [QUALITY GATE PASSED] Mutation Score {report['mutation_score']}% >= {report['min_score']}% threshold.")
+            print(f"✅ [QUALITY GATE PASSED] Assertion Sensitivity {report['mutation_score']}% >= {report['min_score']}% threshold.")
         else:
-            print(f"❌ [REJECTED BY QUALITY GATEKEEPER] Mutation Score {report['mutation_score']}% < {report['min_score']}%.")
+            print(f"❌ [REJECTED BY QUALITY GATEKEEPER] Assertion Sensitivity {report['mutation_score']}% < {report['min_score']}%.")
             print("   👉 Increase test assertion sensitivity or eliminate tautological/unasserted blocks.")
 
     return 0 if report["passed"] else 1

package/tools/omni_transpiler.py

@@ -101,8 +101,8 @@ def scan_repository(repo_path: str) -> Dict[str, Any]:
                                 "locators_count": len(p.locators),
                                 "methods_count": len(p.methods)
                             })
-                            inventory["total_locators"] += len(p.locators)
-                            inventory["total_methods"] += len(p.methods)
+                            inventory["total_locators"] = int(inventory.get("total_locators", 0)) + len(p.locators)
+                            inventory["total_methods"] = int(inventory.get("total_methods", 0)) + len(p.methods)
 
                     for tc in p_ir.test_cases:
                         inventory["test_cases"].append({