synapse-hub 2.0.0 → 2.1.0

package/tools/bump_version.py

@@ -0,0 +1,211 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+tools/bump_version.py — Atomic Universal Version Bumper for Synapse Hub
+
+Synchronizes version numbers across all polyglot targets in a single command:
+  1. package.json (NPM)
+  2. pyproject.toml (Python/Poetry/PEP 621)
+  3. skills_manifest.json (Skill Catalog Index)
+  4. tools/cli.py (Agent-QA CLI)
+  5. tools/mcp_server.py (MCP Protocol Server)
+  6. tools/browser_helpers.js (In-Browser CDP Helper)
+  7. tools/mcp_excel_server.ps1 (PowerShell MCP Service)
+  8. docs/ARCHITECTURE.md (Architecture Specifications)
+  9. README.md (Bilingual Documentation & Badges)
+
+Usage:
+  python3 tools/bump_version.py patch                  # 2.0.1 -> 2.0.2
+  python3 tools/bump_version.py minor                  # 2.0.1 -> 2.1.0
+  python3 tools/bump_version.py major                  # 2.0.1 -> 3.0.0
+  python3 tools/bump_version.py 2.0.5                  # Explicit version
+  python3 tools/bump_version.py patch --commit         # Bump + git commit
+  python3 tools/bump_version.py patch --commit --push  # Bump + commit + git push + tag
+  python3 tools/bump_version.py patch --dry-run        # Preview only
+"""
+
+import sys
+import os
+import re
+import json
+import argparse
+import subprocess
+
+REPO_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+
+def parse_semver(v_str: str):
+    m = re.match(r"^(\d+)\.(\d+)\.(\d+)(.*)$", v_str.strip())
+    if not m:
+        raise ValueError(f"Invalid semver: '{v_str}'. Must follow major.minor.patch[-suffix]")
+    return int(m.group(1)), int(m.group(2)), int(m.group(3)), m.group(4)
+
+def calculate_next_version(current: str, action: str) -> str:
+    major, minor, patch, suffix = parse_semver(current)
+    action = action.lower()
+    if action == "patch":
+        return f"{major}.{minor}.{patch + 1}"
+    elif action == "minor":
+        return f"{major}.{minor + 1}.0"
+    elif action == "major":
+        return f"{major + 1}.0.0"
+    else:
+        # Validate that action itself is a valid semver
+        parse_semver(action)
+        return action
+
+def get_current_version() -> str:
+    pkg_file = os.path.join(REPO_ROOT, "package.json")
+    with open(pkg_file, "r", encoding="utf-8") as f:
+        data = json.load(f)
+    return data.get("version", "2.0.0")
+
+def update_json_root_version(rel_path: str, new_ver: str, dry_run: bool = False) -> bool:
+    full_path = os.path.join(REPO_ROOT, rel_path)
+    if not os.path.exists(full_path):
+        print(f"  [WARN] File not found: {rel_path}")
+        return False
+
+    with open(full_path, "r", encoding="utf-8") as f:
+        data = json.load(f)
+
+    old_ver = data.get("version")
+    if old_ver == new_ver:
+        print(f"  [SKIP] {rel_path} already at v{new_ver}")
+        return False
+
+    data["version"] = new_ver
+    if not dry_run:
+        with open(full_path, "w", encoding="utf-8", newline="\n") as f:
+            json.dump(data, f, indent=2, ensure_ascii=False)
+            f.write("\n")
+        print(f"  [UPDATED] {rel_path} (root version {old_ver} -> {new_ver})")
+    else:
+        print(f"  [DRY-RUN] Would update {rel_path} (root version {old_ver} -> {new_ver})")
+    return True
+
+def update_file(rel_path: str, pattern: str, replacement: str, dry_run: bool = False) -> bool:
+    full_path = os.path.join(REPO_ROOT, rel_path)
+    if not os.path.exists(full_path):
+        print(f"  [WARN] File not found: {rel_path}")
+        return False
+
+    with open(full_path, "r", encoding="utf-8") as f:
+        content = f.read()
+
+    new_content, count = re.subn(pattern, replacement, content)
+    if count == 0:
+        print(f"  [SKIP] No pattern match in {rel_path}")
+        return False
+
+    if not dry_run:
+        with open(full_path, "w", encoding="utf-8", newline="\n") as f:
+            f.write(new_content)
+        print(f"  [UPDATED] {rel_path} ({count} occurrence{'s' if count > 1 else ''})")
+    else:
+        print(f"  [DRY-RUN] Would update {rel_path} ({count} occurrence{'s' if count > 1 else ''})")
+    return True
+
+def run_tests() -> bool:
+    print("\n🔍 Running verification suite...")
+    cmd = [sys.executable, "-m", "unittest", "discover", "tests", "-p", "test_*.py"]
+    res = subprocess.run(cmd, cwd=REPO_ROOT)
+    if res.returncode != 0:
+        print("❌ Unit tests failed! Aborting release.")
+        return False
+    print("✅ All unit tests PASSED.")
+
+    verify_script = os.path.join(REPO_ROOT, "tools", "verify_all.py")
+    res_verify = subprocess.run([sys.executable, verify_script], cwd=REPO_ROOT)
+    if res_verify.returncode != 0:
+        print("❌ Quality Gates failed! Aborting release.")
+        return False
+    print("✅ 8 Quality Gates DoD PASSED.")
+    return True
+
+def git_commit_and_tag(version: str, push: bool = False):
+    print(f"\n📦 Creating Git commit and tag v{version}...")
+    subprocess.run(["git", "add", "-A"], cwd=REPO_ROOT, check=True)
+    subprocess.run(["git", "commit", "-m", f"chore(release): bump version to v{version}"], cwd=REPO_ROOT, check=True)
+    subprocess.run(["git", "tag", f"v{version}"], cwd=REPO_ROOT, check=True)
+    print(f"✅ Git commit and tag v{version} created.")
+
+    if push:
+        print(f"🚀 Pushing commit and tags to remote origin...")
+        subprocess.run(["git", "push", "origin", "HEAD", "--tags"], cwd=REPO_ROOT, check=True)
+        print(f"✅ Remote origin synchronized.")
+
+def main():
+    parser = argparse.ArgumentParser(description="Atomic Universal Version Bumper for Synapse Hub")
+    parser.add_argument("action", nargs="?", default="patch", help="patch | minor | major | <explicit_version> (default: patch)")
+    parser.add_argument("--dry-run", action="store_true", help="Preview version changes without writing files")
+    parser.add_argument("--no-test", action="store_true", help="Skip running test suite after bumping")
+    parser.add_argument("--commit", action="store_true", help="Auto-commit changes with conventional message")
+    parser.add_argument("--tag", action="store_true", help="Create Git tag v<version>")
+    parser.add_argument("--push", action="store_true", help="Push commit and tags to Git remote")
+
+    args = parser.parse_args()
+
+    current_ver = get_current_version()
+    new_ver = calculate_next_version(current_ver, args.action)
+
+    print("======================================================================")
+    print("       SYNAPSE HUB — ATOMIC UNIVERSAL VERSION BUMPER                  ")
+    print("======================================================================")
+    print(f"  Current Version : {current_ver}")
+    print(f"  Target Version  : {new_ver} ({args.action})")
+    print(f"  Mode            : {'DRY RUN (Preview)' if args.dry_run else 'APPLY CHANGES'}")
+    print("======================================================================")
+
+    # 1. package.json
+    update_json_root_version("package.json", new_ver, args.dry_run)
+
+    # 2. pyproject.toml
+    update_file("pyproject.toml", r'(version\s*=\s*")[^"]+(")', rf"\g<1>{new_ver}\g<2>", args.dry_run)
+
+    # 3. skills_manifest.json
+    update_json_root_version("skills_manifest.json", new_ver, args.dry_run)
+
+    # 4. tools/cli.py
+    update_file("tools/cli.py", r'(version\s*=\s*")[^"]+(")', rf"\g<1>{new_ver}\g<2>", args.dry_run)
+
+    # 5. tools/mcp_server.py
+    update_file("tools/mcp_server.py", r'(SERVER_VERSION\s*=\s*")[^"]+(")', rf"\g<1>{new_ver}\g<2>", args.dry_run)
+
+    # 6. tools/browser_helpers.js
+    update_file("tools/browser_helpers.js", r"(__version === ')[^']+(')", rf"\g<1>{new_ver}\g<2>", args.dry_run)
+    update_file("tools/browser_helpers.js", r"(__version:\s*')[^']+(')", rf"\g<1>{new_ver}\g<2>", args.dry_run)
+
+    # 7. tools/mcp_excel_server.ps1
+    update_file("tools/mcp_excel_server.ps1", r'(version\s*=\s*")[^"]+(")', rf"\g<1>{new_ver}\g<2>", args.dry_run)
+
+    # 8. docs/ARCHITECTURE.md
+    update_file("docs/ARCHITECTURE.md", r'(>\s*\*\*Version:\*\*\s*`)[^`]+(`)', rf"\g<1>{new_ver}\g<2>", args.dry_run)
+
+    # 9. README.md (Documentation headings and mermaid badges)
+    update_file("README.md", r'(Phiên bản Hub:\*\*\s*`v)[^`]+(`)', rf"\g<1>{new_ver}\g<2>", args.dry_run)
+    update_file("README.md", r'(Hub Version:\*\*\s*`v)[^`]+(`)', rf"\g<1>{new_ver}\g<2>", args.dry_run)
+    update_file("README.md", r'(Intelligence Core v)[^")\]]+', rf"\g<1>{new_ver}", args.dry_run)
+
+    if args.dry_run:
+        print("\n[INFO] Dry-run completed. No files modified on disk.")
+        return
+
+    # Tests verification
+    if not args.no_test:
+        if not run_tests():
+            sys.exit(1)
+
+    # Git operations
+    if args.commit or args.push:
+        git_commit_and_tag(new_ver, push=args.push)
+
+    print("\n======================================================================")
+    print(f"🎉 VERSION BUMP COMPLETE: v{current_ver} ➔ v{new_ver}")
+    print("======================================================================")
+    print("Next steps:")
+    print(f"  • Publish to NPM : npm publish")
+    print(f"  • Or Git Push    : git push origin HEAD --tags")
+    print("======================================================================")
+
+if __name__ == "__main__":
+    main()

package/tools/cache_resolver.py

@@ -225,6 +225,22 @@ def init_db(seed=True, target_db=None):
                 created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
             )
         """)
+
+        # 4. Flaky Test Historical Telemetry & Quarantine Matrix
+        cursor.execute("""
+            CREATE TABLE IF NOT EXISTS test_telemetry (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                test_id TEXT NOT NULL,
+                run_timestamp TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                status TEXT NOT NULL,
+                is_retry INTEGER DEFAULT 0,
+                duration_ms REAL DEFAULT 0.0,
+                error_signature TEXT DEFAULT '',
+                context TEXT DEFAULT ''
+            )
+        """)
+        cursor.execute("CREATE INDEX IF NOT EXISTS idx_telemetry_test_id ON test_telemetry (test_id)")
+        cursor.execute("CREATE INDEX IF NOT EXISTS idx_telemetry_timestamp ON test_telemetry (run_timestamp)")
         conn.commit()
 
         # Migrate existing solutions from local DB if initializing global DB for the first time
@@ -667,6 +683,72 @@ def query_lessons(context_or_keyword, limit=2):
         return top_results
 
 
+@retry_on_locked()
+def record_test_telemetry(test_id, status, is_retry=0, duration_ms=0.0, error_signature="", context="", target_db=None):
+    """
+    Records an individual test execution into persistent SQLite telemetry.
+    Used for computing 30-day historical flakiness index and auto-quarantine decisions.
+    """
+    init_db(seed=True, target_db=target_db)
+    current_db = target_db or DB_FILE
+    with get_db(current_db) as conn:
+        cursor = conn.cursor()
+        cursor.execute("""
+            INSERT INTO test_telemetry (test_id, status, is_retry, duration_ms, error_signature, context)
+            VALUES (?, ?, ?, ?, ?, ?)
+        """, (test_id, status.upper(), int(is_retry), float(duration_ms), error_signature, context))
+        conn.commit()
+        return True
+
+
+def get_flaky_telemetry(days=30, min_runs=2, threshold=0.15, target_db=None):
+    """
+    Queries historical test telemetry and calculates the Flaky Ratio across the given window.
+    Flaky Ratio = (retry_pass_count + fail_then_pass_transitions) / total_runs.
+    """
+    init_db(seed=True, target_db=target_db)
+    current_db = target_db or DB_FILE
+    with get_db(current_db) as conn:
+        cursor = conn.cursor()
+        cursor.execute("""
+            SELECT 
+                test_id,
+                COUNT(*) as total_runs,
+                SUM(CASE WHEN status = 'PASS' THEN 1 ELSE 0 END) as pass_count,
+                SUM(CASE WHEN status = 'FAIL' THEN 1 ELSE 0 END) as fail_count,
+                SUM(CASE WHEN status = 'PASS' AND is_retry = 1 THEN 1 ELSE 0 END) as retry_pass_count,
+                AVG(duration_ms) as avg_duration_ms
+            FROM test_telemetry
+            WHERE run_timestamp >= datetime('now', '-' || ? || ' days')
+            GROUP BY test_id
+            HAVING total_runs >= ?
+        """, (days, min_runs))
+        rows = cursor.fetchall()
+        candidates = []
+        for r in rows:
+            total = r["total_runs"]
+            retry_passes = r["retry_pass_count"] or 0
+            fails = r["fail_count"] or 0
+            passes = r["pass_count"] or 0
+            # If test both passes and fails across runs, or passes on retry
+            flaky_events = retry_passes + (1 if fails > 0 and passes > 0 else 0)
+            flaky_ratio = round(min(1.0, flaky_events / max(1, total)), 3)
+            quarantine = flaky_ratio >= threshold and passes > 0
+
+            candidates.append({
+                "test_id": r["test_id"],
+                "total_runs": total,
+                "pass_count": passes,
+                "fail_count": fails,
+                "retry_pass_count": retry_passes,
+                "flaky_ratio": flaky_ratio,
+                "avg_duration_ms": round(r["avg_duration_ms"] or 0.0, 1),
+                "quarantine_recommended": quarantine
+            })
+        candidates.sort(key=lambda x: x["flaky_ratio"], reverse=True)
+        return candidates
+
+
 def get_stats():
     init_db(seed=True)
     with get_db() as conn:
@@ -683,6 +765,9 @@ def get_stats():
         cursor.execute("SELECT COUNT(*) as total_lessons FROM lessons_learned")
         total_lessons = cursor.fetchone()["total_lessons"] or 0
 
+        cursor.execute("SELECT COUNT(*) as total_telemetry FROM test_telemetry")
+        total_telemetry = cursor.fetchone()["total_telemetry"] or 0
+
         cursor.execute("SELECT error_signature, module_name, hit_count FROM healing_cache ORDER BY hit_count DESC")
         top_solutions = [dict(r) for r in cursor.fetchall()]
 
@@ -691,6 +776,7 @@ def get_stats():
             "total_hits": total_hits,
             "total_failed_fixes": total_failed,
             "total_lessons_learned": total_lessons,
+            "total_telemetry_records": total_telemetry,
             "estimated_tokens_saved": saved_tokens,
             "solutions": top_solutions
         }
@@ -736,6 +822,21 @@ def main():
     lesson_get_parser.add_argument("--context", required=True, help="Page, flow, or error keyword to match")
     lesson_get_parser.add_argument("--limit", type=int, default=2, help="Number of lessons to retrieve (default: 2)")
 
+    # Record-Telemetry command (Historical Telemetry)
+    telem_record_parser = subparsers.add_parser("record-telemetry", help="Record individual test run outcome into telemetry")
+    telem_record_parser.add_argument("--test-id", required=True, help="Test case identifier or class#method")
+    telem_record_parser.add_argument("--status", required=True, choices=["PASS", "FAIL"], help="Execution status")
+    telem_record_parser.add_argument("--retry", type=int, default=0, help="Whether this run was an automated retry (1 or 0)")
+    telem_record_parser.add_argument("--duration", type=float, default=0.0, help="Run duration in ms")
+    telem_record_parser.add_argument("--error", default="", help="Error signature if failed")
+    telem_record_parser.add_argument("--context", default="", help="Environment or workflow context")
+
+    # Get-Flaky command (Historical Flakiness Query)
+    flaky_get_parser = subparsers.add_parser("get-flaky", help="Query historical flaky test candidates from telemetry")
+    flaky_get_parser.add_argument("--days", type=int, default=30, help="Lookback window in days (default: 30)")
+    flaky_get_parser.add_argument("--min-runs", type=int, default=2, help="Minimum runs required (default: 2)")
+    flaky_get_parser.add_argument("--threshold", type=float, default=0.15, help="Flaky ratio threshold for quarantine (default: 0.15)")
+
     # Stats command
     subparsers.add_parser("stats", help="View memory cache statistics (Positive & Negative)")
 
@@ -817,6 +918,33 @@ def main():
                     print(f"   ✅ Proven Fix  : {l.get('successful_fix') or 'N/A'}")
         print("==================================================")
 
+    elif args.command == "record-telemetry":
+        ok = record_test_telemetry(
+            args.test_id,
+            args.status,
+            is_retry=args.retry,
+            duration_ms=args.duration,
+            error_signature=args.error,
+            context=args.context
+        )
+        if ok:
+            print(f"📊 [TELEMETRY RECORDED] {args.test_id} -> {args.status} (Retry={args.retry}, {args.duration}ms)")
+
+    elif args.command == "get-flaky":
+        flaky_list = get_flaky_telemetry(days=args.days, min_runs=args.min_runs, threshold=args.threshold)
+        print("==================================================")
+        print(f"📈 [HISTORICAL FLAKINESS TELEMETRY ({args.days} Days)]")
+        print("==================================================")
+        if not flaky_list:
+            print("  (Zero flaky tests detected above threshold. Suite is stable.)")
+        else:
+            for item in flaky_list:
+                status_icon = "🚨 [QUARANTINE]" if item["quarantine_recommended"] else "ℹ️ [OBSERVE]"
+                print(f"{status_icon} {item['test_id']}")
+                print(f"   Runs: {item['total_runs']} | Passes: {item['pass_count']} | Fails: {item['fail_count']} | Retry Passes: {item['retry_pass_count']}")
+                print(f"   Flaky Ratio: {item['flaky_ratio']*100:.1f}% | Avg Duration: {item['avg_duration_ms']}ms")
+        print("==================================================")
+
     elif args.command == "stats":
         stats = get_stats()
         print("==================================================")

package/tools/cli.py

@@ -25,7 +25,7 @@ sys.path.insert(0, SCRIPT_DIR)
 
 def cmd_version(args):
     manifest_path = os.path.join(REPO_ROOT, "skills_manifest.json")
-    version = "2.0.0"
+    version = "2.1.0"
     if os.path.exists(manifest_path):
         try:
             import json
@@ -257,6 +257,30 @@ def cmd_decouple_config(args):
     sys.exit(decouple_main())
 
 
+def cmd_fuzz_api(args):
+    from api_fuzzer import main as fuzz_main
+    sys.argv = [sys.argv[0]] + (sys.argv[2:] if len(sys.argv) > 2 else [])
+    sys.exit(fuzz_main())
+
+
+def cmd_som(args):
+    from visual_som_helper import main as som_main
+    sys.argv = [sys.argv[0]] + (sys.argv[2:] if len(sys.argv) > 2 else [])
+    sys.exit(som_main())
+
+
+def cmd_export_postman(args):
+    from export_postman_collection import main as postman_main
+    sys.argv = [sys.argv[0]] + (sys.argv[2:] if len(sys.argv) > 2 else [])
+    sys.exit(postman_main())
+
+
+def cmd_generate_jmx(args):
+    from generate_jmx_plan import main as jmx_main
+    sys.argv = [sys.argv[0]] + (sys.argv[2:] if len(sys.argv) > 2 else [])
+    sys.exit(jmx_main())
+
+
 def main():
     parser = argparse.ArgumentParser(
         prog="agent-qa",
@@ -385,6 +409,22 @@ def main():
     p_decouple.add_argument("--out-dir", default=None, help="Output directory for config profiles")
     p_decouple.set_defaults(func=cmd_decouple_config)
 
+    # fuzz-api
+    p_fuzz = subparsers.add_parser("fuzz-api", help="Autonomous API Fuzzing & Chaos Breaker (bắn mutation payloads, bắt 500, DB leak, SLA breach)")
+    p_fuzz.set_defaults(func=cmd_fuzz_api)
+
+    # som (Visual Grounding for Canvas / GIS)
+    p_som = subparsers.add_parser("som", help="Multimodal Vision Grounding & Set-of-Marks (SoM) for Canvas/GIS without DOM")
+    p_som.set_defaults(func=cmd_som)
+
+    # export-postman
+    p_postman = subparsers.add_parser("export-postman", help="Export OpenAPI / Swagger / HAR to Postman Collection v2.1.0 with auto-asserts")
+    p_postman.set_defaults(func=cmd_export_postman)
+
+    # generate-jmx
+    p_jmx = subparsers.add_parser("generate-jmx", help="Generate Apache JMeter 5.x Test Plan XML (.jmx) from OpenAPI / Postman / HAR")
+    p_jmx.set_defaults(func=cmd_generate_jmx)
+
     args, unknown = parser.parse_known_args()
     if getattr(args, "offline", False):
         os.environ["AGENT_QA_OFFLINE"] = "1"