synapse-hub 0.0.0-stage → 2.0.0

package/tools/pinpoint_failure.py

@@ -0,0 +1,88 @@
+#!/usr/bin/env python3
+"""
+Fast Zero-Token Failure Pinpointer for Katalon & Jenkins Reports.
+Scans the latest Reports/**/JUnit_Report.xml, extracts failed Test Cases,
+exact failed lines in Groovy/Script, and the root-cause exception.
+Outputs < 100 tokens.
+
+Usage:
+    python3 tools/pinpoint_failure.py
+    python3 tools/pinpoint_failure.py path/to/JUnit_Report.xml
+"""
+import os
+import sys
+import glob
+import xml.etree.ElementTree as ET
+import re
+
+def find_latest_report():
+    reports = glob.glob("Reports/**/JUnit_Report.xml", recursive=True)
+    if not reports:
+        return None
+    reports.sort(key=lambda x: os.path.getmtime(x), reverse=True)
+    return reports[0]
+
+def parse_failures(xml_path):
+    if not os.path.exists(xml_path):
+        print(f"Error: {xml_path} does not exist.")
+        return []
+
+    tree = ET.parse(xml_path)
+    root = tree.getroot()
+    failures = []
+
+    suites = [root] if root.tag == "testsuite" else root.findall("testsuite")
+
+    for suite in suites:
+        for tc in suite.findall("testcase"):
+            tc_name = tc.get("name", "Unknown")
+            tc_time = tc.get("time", "0")
+            fail = tc.find("failure")
+            err = tc.find("error")
+            target = fail if fail is not None else err
+
+            if target is not None:
+                msg = target.get("message", "")
+                text = target.text or ""
+                combined = (msg + "\n" + text).replace("&#xa;", "\n")
+
+                # Extract Root Cause Reason
+                reason_match = re.search(r"Reason:\s*(.+?)(?=\n\s*at|\Z)", combined, re.DOTALL)
+                if reason_match:
+                    reason = reason_match.group(1).strip()
+                else:
+                    lines = [l.strip() for l in combined.split("\n") if l.strip()]
+                    reason = lines[0] if lines else "Unknown Error"
+
+                # Extract Failed Line in Groovy Page / Script
+                Enterprise_lines = re.findall(r"(?:Enterprise\.pages\.[\w]+|TC-[\w\s\u00C0-\u1EF9]+|Script\d+)\.groovy:\d+|(?:TC-[\w\s\u00C0-\u1EF9]+:\d+)", combined)
+
+                failures.append({
+                    "tc": tc_name.split("/")[-1],
+                    "time": f"{float(tc_time):.1f}s",
+                    "reason": reason.split("\n")[0][:180],
+                    "failed_at": Enterprise_lines[:2] if Enterprise_lines else ["See JUnit report"]
+                })
+
+    return failures
+
+def main():
+    xml_path = sys.argv[1] if len(sys.argv) > 1 else find_latest_report()
+    if not xml_path:
+        print("No JUnit_Report.xml found in Reports/.")
+        sys.exit(0)
+
+    print(f"=== Report: {xml_path} ===")
+    failures = parse_failures(xml_path)
+    if not failures:
+        print("✅ 100% PASSED: Zero failures found in report.")
+        return
+
+    print(f"❌ Found {len(failures)} Failed Test Case(s):")
+    for i, f in enumerate(failures, 1):
+        print(f"[{i}] {f['tc']} ({f['time']})")
+        print(f"    Cause: {f['reason']}")
+        print(f"    Line:  {', '.join(f['failed_at'])}")
+
+if __name__ == "__main__":
+    main()

package/tools/project_state.py

@@ -0,0 +1,169 @@
+#!/usr/bin/env python3
+"""
+Enterprise Project State Machine & Token-Capped Memory Anchor
+--------------------------------------------------------------
+Maintains persistent execution state across long-running AI sessions and Antigravity context compaction.
+Enforces a strict Rolling Window (< 50 lines, ~200 tokens) to guarantee zero token bloat.
+"""
+
+import os
+import sys
+import json
+from datetime import datetime
+from pathlib import Path
+
+# Enforce UTF-8 stdout encoding for Windows console compatibility
+if hasattr(sys.stdout, 'reconfigure'):
+    try:
+        sys.stdout.reconfigure(encoding='utf-8')
+        sys.stderr.reconfigure(encoding='utf-8')
+    except Exception:
+        pass
+
+SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+HUB_ROOT = os.path.abspath(os.path.join(SCRIPT_DIR, ".."))
+TEMPLATES_DIR = os.path.join(HUB_ROOT, "templates")
+
+
+def resolve_state_file(target_dir):
+    return os.path.join(target_dir, "PROJECT_STATE.md")
+
+
+def init_state(target_dir, goal="Initial Autonomous Setup"):
+    """Initializes PROJECT_STATE.md if missing, strictly capped to < 50 lines."""
+    state_file = resolve_state_file(target_dir)
+    if os.path.exists(state_file):
+        return state_file
+
+    project_name = os.path.basename(os.path.abspath(target_dir))
+    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+
+    content = f"""# Project Execution State (`PROJECT_STATE.md`)
+
+- **Project:** `{project_name}`
+- **Last Sync:** `{timestamp}`
+- **Overall Status:** `READY`
+
+## 1. Active Goal
+- {goal}
+
+## 2. Task Checklist (Rolling Window - Max 8 active items)
+- [x] Initialized project state anchor
+- [ ] Ready for feature or test automation
+
+## 3. Active Watchpoints & Healing (Max 3 items)
+- Target Suite / Script: `[None]`
+- Failing Locator / Line: `[None]`
+
+## 4. Quality Verification
+- 7 Quality Gates: `READY`
+- Clean POM Integrity: `VERIFIED`
+"""
+    with open(state_file, "w", encoding="utf-8") as f:
+        f.write(content)
+    return state_file
+
+
+def update_state(target_dir, goal=None, completed_task=None, pending_task=None, watchpoint=None, gate_status=None):
+    """Updates state in-place while pruning old entries to guarantee < 50 lines (~200 tokens)."""
+    state_file = resolve_state_file(target_dir)
+    if not os.path.exists(state_file):
+        init_state(target_dir, goal or "Active Task")
+
+    with open(state_file, "r", encoding="utf-8") as f:
+        lines = [line.rstrip() for line in f.readlines()]
+
+    project_name = os.path.basename(os.path.abspath(target_dir))
+    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+
+    # Parse existing tasks
+    existing_tasks = []
+    current_goal = goal or "Continue autonomous QA workflow"
+    current_watchpoints = []
+    current_gate = gate_status or "READY"
+
+    in_tasks = False
+    in_watch = False
+
+    for line in lines:
+        if line.startswith("## 1. Active Goal"):
+            in_tasks = False
+            in_watch = False
+        elif line.startswith("## 2. Task Checklist"):
+            in_tasks = True
+            in_watch = False
+            continue
+        elif line.startswith("## 3. Active Watchpoints"):
+            in_tasks = False
+            in_watch = True
+            continue
+        elif line.startswith("## 4. Quality Verification"):
+            in_tasks = False
+            in_watch = False
+            continue
+
+        if in_tasks and line.strip().startswith("- ["):
+            existing_tasks.append(line.strip())
+        elif in_watch and line.strip().startswith("- "):
+            current_watchpoints.append(line.strip())
+        elif line.startswith("- **Last Sync:**") and not goal:
+            pass
+
+    if completed_task:
+        existing_tasks.append(f"- [x] {completed_task}")
+    if pending_task:
+        existing_tasks.append(f"- [ ] {pending_task}")
+    if watchpoint:
+        current_watchpoints = [f"- Focus: {watchpoint}"]
+
+    # Rolling window cap: Keep maximum 8 task items (purge oldest completed tasks)
+    if len(existing_tasks) > 8:
+        # Keep pending tasks and the most recent completed ones
+        pending = [t for t in existing_tasks if t.startswith("- [ ]")]
+        completed = [t for t in existing_tasks if t.startswith("- [x]")]
+        # Keep up to 4 completed and remaining pending
+        completed = completed[-4:]
+        existing_tasks = completed + pending
+        existing_tasks = existing_tasks[-8:]
+
+    # Reconstruct compact markdown (< 40 lines)
+    tasks_block = "\n".join(existing_tasks) if existing_tasks else "- [ ] Standby for instructions"
+    watch_block = "\n".join(current_watchpoints[:3]) if current_watchpoints else "- Target Suite / Script: `[None]`\n- Failing Locator / Line: `[None]`"
+
+    content = f"""# Project Execution State (`PROJECT_STATE.md`)
+
+- **Project:** `{project_name}`
+- **Last Sync:** `{timestamp}`
+- **Overall Status:** `IN_PROGRESS`
+
+## 1. Active Goal
+- {current_goal}
+
+## 2. Task Checklist (Rolling Window - Max 8 active items)
+{tasks_block}
+
+## 3. Active Watchpoints & Healing (Max 3 items)
+{watch_block}
+
+## 4. Quality Verification
+- 7 Quality Gates: `{current_gate}`
+- Clean POM Integrity: `VERIFIED`
+"""
+    with open(state_file, "w", encoding="utf-8") as f:
+        f.write(content)
+    return state_file
+
+
+def read_state(target_dir):
+    """Reads state file if exists, returning condensed text."""
+    state_file = resolve_state_file(target_dir)
+    if not os.path.exists(state_file):
+        return None
+    with open(state_file, "r", encoding="utf-8") as f:
+        return f.read()
+
+
+if __name__ == "__main__":
+    target = sys.argv[1] if len(sys.argv) > 1 else os.getcwd()
+    sf = init_state(target)
+    print(f"Project state anchor initialized at: {sf}")

package/tools/repo_map.json

@@ -0,0 +1,12 @@
+{
+  "generated_at": "2026-10-29 19:59:47",
+  "target_repository": "/Users/phungcao/Documents/Agent Skill",
+  "classes_count": 0,
+  "methods_count": 0,
+  "source_lines": 0,
+  "raw_bytes": 0,
+  "compressed_bytes": 442,
+  "compression_ratio_pct": -44100.0,
+  "estimated_tokens": 110,
+  "classes": []
+}

package/tools/repo_map.py

@@ -0,0 +1,277 @@
+#!/usr/bin/env python3
+"""
+Enterprise Repository Map Compressor (Inspired by Aider-AI/aider)
+-----------------------------------------------------------
+Extracts an ultra-compact, token-budgeted AST map of all Page Classes and Helpers.
+Compresses hundreds of kilobytes of Groovy source code into a clean ~150-line summary.
+Enables AI Agents to discover all available methods and signatures with < 600 tokens.
+Supports dynamic target repository resolution (CLI flag, CWD auto-detect, ENV var).
+Saves a persistent in-place copy (repo_map.txt) inside the target project directory.
+"""
+
+import os
+import sys
+import re
+import json
+import argparse
+from datetime import datetime
+
+SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+HUB_ROOT = os.path.abspath(os.path.join(SCRIPT_DIR, ".."))
+OUTPUT_TXT = os.path.join(SCRIPT_DIR, "repo_map.txt")
+OUTPUT_JSON = os.path.join(SCRIPT_DIR, "repo_map.json")
+
+# Regex patterns for Groovy classes and methods
+CLASS_PATTERN = re.compile(r'^\s*(?:public\s+)?class\s+(\w+)(?:\s+extends\s+(\w+))?', re.MULTILINE)
+METHOD_PATTERN = re.compile(
+    r'^\s*(?:@\w+\s+)*(?:public\s+|protected\s+|private\s+)?(?:static\s+)?(?:def\s+|void\s+|[\w<>\[\],]+\s+)?(\w+)\s*\(([^)]*)\)\s*(?:throws\s+[\w,\s]+)?\s*\{',
+    re.MULTILINE
+)
+DOC_PATTERN = re.compile(r'/\*\*(.*?)\*/', re.DOTALL)
+
+
+def resolve_target_repo(cli_target=None, cli_repo=None):
+    """
+    Resolves the target repository path for repo mapping:
+    1. Explicit CLI flag: --repo / --path or positional target.
+    2. Environment variable: TARGET_PROJECT_DIR.
+    3. Current Working Directory (if different from Hub and has Keywords/ or Scripts/).
+    4. Default fallback: QA Hub root (parent of tools/).
+    """
+    chosen = cli_repo or cli_target
+    if chosen:
+        resolved = os.path.abspath(chosen)
+        if not os.path.exists(resolved):
+            raise FileNotFoundError(f"Target repository path not found: {resolved}")
+        return resolved
+
+    env_dir = os.environ.get("TARGET_PROJECT_DIR")
+    if env_dir and os.path.exists(env_dir):
+        return os.path.abspath(env_dir)
+
+    cwd = os.path.abspath(os.getcwd())
+    if cwd.lower() != HUB_ROOT.lower():
+        if os.path.exists(os.path.join(cwd, "Keywords")) or os.path.exists(os.path.join(cwd, "Scripts")):
+            return cwd
+
+    return HUB_ROOT
+
+
+def extract_class_info(file_path, repo_root=None):
+    """Parses a Groovy file and extracts class name, parent, and exported methods."""
+    with open(file_path, "r", encoding="utf-8", errors="ignore") as f:
+        content = f.read()
+
+    base_root = repo_root or HUB_ROOT
+    try:
+        rel_path = os.path.relpath(file_path, base_root)
+    except ValueError:
+        rel_path = os.path.abspath(file_path)
+
+    class_match = CLASS_PATTERN.search(content)
+    if not class_match:
+        return None
+
+    class_name = class_match.group(1)
+    extends_name = class_match.group(2) or ""
+
+    methods = []
+    control_keywords = {"if", "for", "while", "switch", "catch", "synchronized"}
+
+    lines = content.splitlines()
+    for idx, line in enumerate(lines):
+        line_clean = line.strip()
+        if not line_clean or line_clean.startswith("//") or line_clean.startswith("/*") or line_clean.startswith("*"):
+            continue
+
+        # If '=' appears before '(', it's a variable assignment / constant declaration, not a method
+        if "=" in line_clean:
+            eq_pos = line_clean.find("=")
+            paren_pos = line_clean.find("(")
+            if paren_pos != -1 and eq_pos < paren_pos:
+                continue
+
+        # Must have parentheses and end with '{' or next line starts with '{'
+        if "(" in line_clean and ")" in line_clean:
+            has_brace = line_clean.endswith("{") or (idx + 1 < len(lines) and lines[idx + 1].strip().startswith("{"))
+            if has_brace:
+                # Match method definition: modifiers + return type + name + (params)
+                m = re.search(r'(?:public\s+|protected\s+|private\s+|static\s+|def\s+|void\s+|[\w<>\[\],]+\s+)+([a-zA-Z_]\w*)\s*\(([^)]*)\)', line_clean)
+                if m:
+                    name = m.group(1)
+                    params = m.group(2).strip()
+                    if name not in control_keywords and name != class_name:
+                        # Extract preceding single-line comment if any
+                        comment = ""
+                        if idx > 0 and lines[idx - 1].strip().startswith("//"):
+                            comment = lines[idx - 1].strip().lstrip("/ ").strip()
+                        methods.append({
+                            "name": name,
+                            "params": re.sub(r'\s+', ' ', params),
+                            "comment": comment
+                        })
+
+    # Deduplicate methods preserving order
+    seen = set()
+    unique_methods = []
+    for meth in methods:
+        sig = f"{meth['name']}({meth['params']})"
+        if sig not in seen:
+            seen.add(sig)
+            unique_methods.append(meth)
+
+    return {
+        "rel_path": rel_path,
+        "class_name": class_name,
+        "extends": extends_name,
+        "raw_size_bytes": len(content.encode("utf-8")),
+        "line_count": len(lines),
+        "methods": unique_methods
+    }
+
+
+def build_repo_map(target_repo=None, output_txt=None, output_json=None):
+    """Scans Keywords in target_repo and builds the condensed repo map."""
+    repo = target_repo or resolve_target_repo()
+    txt_dest = output_txt or OUTPUT_TXT
+    json_dest = output_json or OUTPUT_JSON
+
+    classes = []
+    total_raw_bytes = 0
+    total_raw_lines = 0
+
+    keywords_dir = os.path.join(repo, "Keywords")
+
+    if os.path.isdir(keywords_dir):
+        for root, dirs, files in os.walk(keywords_dir):
+            for fname in sorted(files):
+                if fname.endswith(".groovy"):
+                    full_path = os.path.join(root, fname)
+                    info = extract_class_info(full_path, repo_root=repo)
+                    if info:
+                        classes.append(info)
+                        total_raw_bytes += info["raw_size_bytes"]
+                        total_raw_lines += info["line_count"]
+
+    # Sort classes: BasePage first, then alphabetical
+    classes.sort(key=lambda c: (0 if c["class_name"] == "BasePage" else 1, c["class_name"]))
+
+    # Render text map
+    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    out_lines = [
+        f"# ==============================================================================",
+        f"# ENTERPRISE AUTOMATION REPOSITORY MAP (Aider-Style AST Compression)",
+        f"# Generated : {timestamp}",
+        f"# Target    : {repo}",
+        f"# Scope     : {len(classes)} Classes ({total_raw_lines} source lines, {total_raw_bytes / 1024:.1f} KB)",
+        f"# Purpose   : Token-budgeted index (< 600 tokens) for instant method lookup",
+        f"# ==============================================================================\n"
+    ]
+
+    total_methods = 0
+    for cls in classes:
+        ext_str = f" extends {cls['extends']}" if cls['extends'] else ""
+        out_lines.append(f"{cls['rel_path']} ({cls['line_count']} lines)")
+        out_lines.append(f"  class {cls['class_name']}{ext_str}:")
+        for m in cls["methods"]:
+            total_methods += 1
+            cmt = f" # {m['comment']}" if m['comment'] else ""
+            out_lines.append(f"    def {m['name']}({m['params']}){cmt}")
+        out_lines.append("")
+
+    rendered_text = "\n".join(out_lines)
+    compressed_bytes = len(rendered_text.encode("utf-8"))
+    ratio = (1.0 - (compressed_bytes / max(1, total_raw_bytes))) * 100
+    est_tokens = len(rendered_text) // 4
+
+    # 1. Save to primary destination (tools/repo_map.txt in Hub)
+    os.makedirs(os.path.dirname(txt_dest), exist_ok=True)
+    with open(txt_dest, "w", encoding="utf-8") as f:
+        f.write(rendered_text)
+
+    os.makedirs(os.path.dirname(json_dest), exist_ok=True)
+    with open(json_dest, "w", encoding="utf-8") as f:
+        json.dump({
+            "generated_at": timestamp,
+            "target_repository": repo,
+            "classes_count": len(classes),
+            "methods_count": total_methods,
+            "source_lines": total_raw_lines,
+            "raw_bytes": total_raw_bytes,
+            "compressed_bytes": compressed_bytes,
+            "compression_ratio_pct": round(ratio, 2),
+            "estimated_tokens": est_tokens,
+            "classes": classes
+        }, f, indent=2, ensure_ascii=False)
+
+    # 2. Save a persistent copy directly into target repository root (for AI self-contained inspection)
+    if os.path.abspath(repo).lower() != os.path.abspath(HUB_ROOT).lower():
+        try:
+            target_txt = os.path.join(repo, "repo_map.txt")
+            with open(target_txt, "w", encoding="utf-8") as f:
+                f.write(rendered_text)
+            target_json = os.path.join(repo, "repo_map.json")
+            with open(target_json, "w", encoding="utf-8") as f:
+                json.dump({
+                    "generated_at": timestamp,
+                    "target_repository": repo,
+                    "classes_count": len(classes),
+                    "methods_count": total_methods,
+                    "source_lines": total_raw_lines,
+                    "raw_bytes": total_raw_bytes,
+                    "compressed_bytes": compressed_bytes,
+                    "compression_ratio_pct": round(ratio, 2),
+                    "estimated_tokens": est_tokens,
+                    "classes": classes
+                }, f, indent=2, ensure_ascii=False)
+        except Exception:
+            pass
+
+    return {
+        "target_repo": repo,
+        "classes_count": len(classes),
+        "methods_count": total_methods,
+        "source_lines": total_raw_lines,
+        "raw_bytes": total_raw_bytes,
+        "compressed_bytes": compressed_bytes,
+        "compression_ratio_pct": ratio,
+        "estimated_tokens": est_tokens,
+        "output_file": txt_dest
+    }
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Enterprise Repository Map Compressor")
+    parser.add_argument("target", nargs="?", default=None, help="Target repository containing Keywords/")
+    parser.add_argument("--repo", "--path", dest="repo_path", default=None, help="Target repository path")
+    parser.add_argument("--print", action="store_true", help="Print repository map to console")
+    args = parser.parse_args()
+
+    try:
+        target_repo = resolve_target_repo(cli_target=args.target, cli_repo=args.repo_path)
+    except FileNotFoundError as e:
+        print(f"❌ Error: {e}")
+        return 1
+
+    stats = build_repo_map(target_repo=target_repo)
+    print(f"\n======================================================================")
+    print(f"       Enterprise Repository Map Compressor (Aider-Style AST Map)           ")
+    print(f"======================================================================")
+    print(f"  Target Repository       : {stats['target_repo']}")
+    print(f"  Indexed Classes         : {stats['classes_count']} Page Classes & Helpers")
+    print(f"  Extracted Methods       : {stats['methods_count']} API signatures")
+    print(f"  Source Lines Processed  : {stats['source_lines']:,} lines ({stats['raw_bytes'] / 1024:.1f} KB)")
+    print(f"  Compressed Map Size     : {stats['compressed_bytes'] / 1024:.1f} KB (~{stats['estimated_tokens']} tokens)")
+    print(f"  Compression Ratio       : {stats['compression_ratio_pct']:.1f}% reduction")
+    print(f"  Artifact Generated      : {stats['output_file']}")
+    print(f"======================================================================\n")
+
+    if args.print:
+        with open(stats['output_file'], "r", encoding="utf-8") as f:
+            print(f.read())
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/tools/repo_map.txt

@@ -0,0 +1,7 @@
+# ==============================================================================
+# ENTERPRISE AUTOMATION REPOSITORY MAP (Aider-Style AST Compression)
+# Generated : 2026-10-29 19:59:47
+# Target    : /Users/phungcao/Documents/Agent Skill
+# Scope     : 0 Classes (0 source lines, 0.0 KB)
+# Purpose   : Token-budgeted index (< 600 tokens) for instant method lookup
+# ==============================================================================