@teevee98/synapse-hub 3.8.5 → 3.9.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/NOTICE +48 -0
- package/README.en.md +2 -2
- package/README.md +2 -2
- package/agentskills.json +1 -1
- package/docs/ARCHITECTURE.en.md +5 -1
- package/docs/ARCHITECTURE.md +5 -1
- package/docs/adopted-ecosystem-tools.md +37 -0
- package/docs/diagrams/clean_pom.svg +48 -0
- package/docs/diagrams/fsm_flow.svg +78 -0
- package/package.json +1 -1
- package/plugin.json +1 -1
- package/skills_manifest.json +1 -1
- package/synapse.config.json +1 -1
- package/tools/__init__.py +1 -1
- package/tools/browser_helpers.js +2 -2
- package/tools/build_consolidated_report.py +1640 -0
- package/tools/cli.py +3 -3
- package/tools/dashboard_generator.py +6 -6
- package/tools/diagram_architect.py +220 -0
- package/tools/distill_log.py +31 -0
- package/tools/git_worktree_manager.py +185 -0
- package/tools/humanize_linter.py +4 -0
- package/tools/interview_story.py +25 -2
- package/tools/mcp_docx_server.py +1 -1
- package/tools/mcp_excel_server.py +1 -1
- package/tools/mcp_server.py +1 -1
- package/tools/mechanical_ui_gate.py +242 -0
- package/tools/pairwise_generator.py +175 -0
- package/tools/repo_map.py +1 -1
- package/tools/runaway_stopper.py +178 -0
- package/tools/ui_server.py +1 -1
- package/tools/update_sentinel.py +3 -3
- package/tools/verify_all.py +15 -0
- package/tools/welcome_page.py +1 -1
|
@@ -0,0 +1,242 @@
|
|
|
1
|
+
#!/usr/bin/env python3
|
|
2
|
+
# -*- coding: utf-8 -*-
|
|
3
|
+
"""
|
|
4
|
+
tools/mechanical_ui_gate.py — Headless Chrome Mechanical Layout & Contrast Gate
|
|
5
|
+
Inspired by Leonxlnx's taste-skill (gate.mjs & consistency.mjs).
|
|
6
|
+
Enforces mechanical finish criteria on rendered HTML and UI components:
|
|
7
|
+
zero horizontal overflow spills, WCAG AA contrast (>= 4.5:1), valid interactive
|
|
8
|
+
tap targets, and zero empty/unstyled placeholder divs.
|
|
9
|
+
100% UTF-8 No BOM.
|
|
10
|
+
"""
|
|
11
|
+
|
|
12
|
+
import sys
|
|
13
|
+
import os
|
|
14
|
+
import re
|
|
15
|
+
import json
|
|
16
|
+
import argparse
|
|
17
|
+
from typing import Dict, List, Any, Optional, Tuple
|
|
18
|
+
|
|
19
|
+
# Enforce UTF-8 stdout encoding
|
|
20
|
+
if hasattr(sys.stdout, "reconfigure"):
|
|
21
|
+
try:
|
|
22
|
+
sys.stdout.reconfigure(encoding="utf-8")
|
|
23
|
+
sys.stderr.reconfigure(encoding="utf-8")
|
|
24
|
+
except Exception:
|
|
25
|
+
pass
|
|
26
|
+
|
|
27
|
+
def parse_css_color(color_str: str) -> Optional[Tuple[int, int, int]]:
|
|
28
|
+
c = color_str.strip().lower()
|
|
29
|
+
named = {
|
|
30
|
+
"white": (255, 255, 255),
|
|
31
|
+
"black": (0, 0, 0),
|
|
32
|
+
"red": (255, 0, 0),
|
|
33
|
+
"green": (0, 128, 0),
|
|
34
|
+
"blue": (0, 0, 255),
|
|
35
|
+
"yellow": (255, 255, 0),
|
|
36
|
+
"cyan": (0, 255, 255),
|
|
37
|
+
"magenta": (255, 0, 255),
|
|
38
|
+
"gray": (128, 128, 128),
|
|
39
|
+
"grey": (128, 128, 128),
|
|
40
|
+
}
|
|
41
|
+
if c in named:
|
|
42
|
+
return named[c]
|
|
43
|
+
if c.startswith("#"):
|
|
44
|
+
h = c[1:]
|
|
45
|
+
if len(h) == 3:
|
|
46
|
+
return (int(h[0]*2, 16), int(h[1]*2, 16), int(h[2]*2, 16))
|
|
47
|
+
elif len(h) == 6:
|
|
48
|
+
return (int(h[0:2], 16), int(h[2:4], 16), int(h[4:6], 16))
|
|
49
|
+
m = re.match(r'rgba?\s*\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)', c)
|
|
50
|
+
if m:
|
|
51
|
+
return (int(m.group(1)), int(m.group(2)), int(m.group(3)))
|
|
52
|
+
return None
|
|
53
|
+
|
|
54
|
+
def calc_relative_luminance(rgb: Tuple[int, int, int]) -> float:
|
|
55
|
+
def ch(val: int) -> float:
|
|
56
|
+
v = val / 255.0
|
|
57
|
+
return v / 12.92 if v <= 0.03928 else ((v + 0.055) / 1.055) ** 2.4
|
|
58
|
+
return 0.2126 * ch(rgb[0]) + 0.7152 * ch(rgb[1]) + 0.0722 * ch(rgb[2])
|
|
59
|
+
|
|
60
|
+
def calc_contrast_ratio(rgb1: Tuple[int, int, int], rgb2: Tuple[int, int, int]) -> float:
|
|
61
|
+
l1 = calc_relative_luminance(rgb1)
|
|
62
|
+
l2 = calc_relative_luminance(rgb2)
|
|
63
|
+
return (max(l1, l2) + 0.05) / (min(l1, l2) + 0.05)
|
|
64
|
+
|
|
65
|
+
class MechanicalUIGate:
|
|
66
|
+
def __init__(self, min_contrast: float = 4.5):
|
|
67
|
+
self.min_contrast = min_contrast
|
|
68
|
+
|
|
69
|
+
def audit_html_content(self, html_text: str, filename: str = "inline.html") -> Dict[str, Any]:
|
|
70
|
+
"""Performs static DOM and structural mechanical checks on HTML content."""
|
|
71
|
+
findings = []
|
|
72
|
+
|
|
73
|
+
# 1. Check for empty interactive elements (buttons, links without accessible text or aria-label)
|
|
74
|
+
empty_button_re = re.compile(r'<button\b(?![^>]*\baria-label=)[^>]*>\s*</button>', re.IGNORECASE)
|
|
75
|
+
for m in empty_button_re.finditer(html_text):
|
|
76
|
+
findings.append({
|
|
77
|
+
"id": "empty-button",
|
|
78
|
+
"severity": "FAIL",
|
|
79
|
+
"message": "Found button element with zero inner text and no aria-label.",
|
|
80
|
+
"snippet": m.group(0)[:80]
|
|
81
|
+
})
|
|
82
|
+
|
|
83
|
+
empty_link_re = re.compile(r'<a\b(?![^>]*\baria-label=)[^>]*>\s*</a>', re.IGNORECASE)
|
|
84
|
+
for m in empty_link_re.finditer(html_text):
|
|
85
|
+
findings.append({
|
|
86
|
+
"id": "empty-anchor",
|
|
87
|
+
"severity": "FAIL",
|
|
88
|
+
"message": "Found <a> link element with zero inner text and no aria-label.",
|
|
89
|
+
"snippet": m.group(0)[:80]
|
|
90
|
+
})
|
|
91
|
+
|
|
92
|
+
# 2. Check for missing viewport meta tag (causes layout overflow on mobile)
|
|
93
|
+
if "<meta" in html_text.lower() and "viewport" not in html_text.lower():
|
|
94
|
+
findings.append({
|
|
95
|
+
"id": "missing-viewport",
|
|
96
|
+
"severity": "FAIL",
|
|
97
|
+
"message": "Missing <meta name='viewport'> tag, resulting in mobile rendering breakage.",
|
|
98
|
+
"snippet": "<meta ...>"
|
|
99
|
+
})
|
|
100
|
+
|
|
101
|
+
# 3. Check for inline fixed-width overflows (e.g. style='width: 1400px' or style='min-width: 1200px' without max-width)
|
|
102
|
+
fixed_overflow_re = re.compile(r'style=[\'"][^\'"]*?(?:min-)?width:\s*(\d{4,})px', re.IGNORECASE)
|
|
103
|
+
for m in fixed_overflow_re.finditer(html_text):
|
|
104
|
+
px_val = int(m.group(1))
|
|
105
|
+
if px_val > 1000 and "max-width" not in m.group(0):
|
|
106
|
+
findings.append({
|
|
107
|
+
"id": "overflow-fixed-width",
|
|
108
|
+
"severity": "WARN",
|
|
109
|
+
"message": f"Fixed width {px_val}px without max-width: 100% may cause viewport horizontal scroll.",
|
|
110
|
+
"snippet": m.group(0)[:80]
|
|
111
|
+
})
|
|
112
|
+
|
|
113
|
+
# 4. Check for unhandled AI slop tags / comments
|
|
114
|
+
ai_comment_re = re.compile(r'<!--\s*(?:AI-generated|TODO: add content|Placeholder|Generated by)\b[^-]*?-->', re.IGNORECASE)
|
|
115
|
+
for m in ai_comment_re.finditer(html_text):
|
|
116
|
+
findings.append({
|
|
117
|
+
"id": "ai-placeholder-comment",
|
|
118
|
+
"severity": "FAIL",
|
|
119
|
+
"message": "Found unresolved AI placeholder comment.",
|
|
120
|
+
"snippet": m.group(0)[:80]
|
|
121
|
+
})
|
|
122
|
+
|
|
123
|
+
# 5. Check for heading hierarchy skip (e.g. h1 directly followed by h4 without h2 or h3)
|
|
124
|
+
headings = re.findall(r'<h([1-6])\b', html_text, re.IGNORECASE)
|
|
125
|
+
levels = [int(h) for h in headings]
|
|
126
|
+
for i in range(len(levels) - 1):
|
|
127
|
+
if levels[i+1] > levels[i] + 1:
|
|
128
|
+
findings.append({
|
|
129
|
+
"id": "heading-order-skipped",
|
|
130
|
+
"severity": "WARN",
|
|
131
|
+
"message": f"Skipped heading level: h{levels[i]} followed directly by h{levels[i+1]}.",
|
|
132
|
+
"snippet": f"h{levels[i]} -> h{levels[i+1]}"
|
|
133
|
+
})
|
|
134
|
+
|
|
135
|
+
# 6. Check for low contrast inline styles (WCAG AA min_contrast, default 4.5:1)
|
|
136
|
+
style_matches = re.finditer(r'style=[\'"]([^\'"]+)[\'"]', html_text, re.IGNORECASE)
|
|
137
|
+
for sm in style_matches:
|
|
138
|
+
s_text = sm.group(1)
|
|
139
|
+
fg_m = re.search(r'(?:^|;)\s*color:\s*([^;]+)', s_text, re.IGNORECASE)
|
|
140
|
+
bg_m = re.search(r'(?:^|;)\s*background(?:-color)?:\s*([^;]+)', s_text, re.IGNORECASE)
|
|
141
|
+
if fg_m and bg_m:
|
|
142
|
+
fg_col = parse_css_color(fg_m.group(1))
|
|
143
|
+
bg_col = parse_css_color(bg_m.group(1))
|
|
144
|
+
if fg_col and bg_col:
|
|
145
|
+
ratio = calc_contrast_ratio(fg_col, bg_col)
|
|
146
|
+
if ratio < self.min_contrast:
|
|
147
|
+
findings.append({
|
|
148
|
+
"id": "low-contrast-text",
|
|
149
|
+
"severity": "FAIL",
|
|
150
|
+
"message": f"Color contrast ratio {ratio:.2f}:1 fails WCAG AA minimum ({self.min_contrast}:1).",
|
|
151
|
+
"snippet": sm.group(0)[:80]
|
|
152
|
+
})
|
|
153
|
+
|
|
154
|
+
fails = [f for f in findings if f["severity"] == "FAIL"]
|
|
155
|
+
warns = [f for f in findings if f["severity"] == "WARN"]
|
|
156
|
+
|
|
157
|
+
return {
|
|
158
|
+
"file": filename,
|
|
159
|
+
"passed": len(fails) == 0,
|
|
160
|
+
"fail_count": len(fails),
|
|
161
|
+
"warn_count": len(warns),
|
|
162
|
+
"findings": findings
|
|
163
|
+
}
|
|
164
|
+
|
|
165
|
+
def audit_file(self, file_path: str) -> Dict[str, Any]:
|
|
166
|
+
if not os.path.exists(file_path):
|
|
167
|
+
return {
|
|
168
|
+
"file": file_path,
|
|
169
|
+
"passed": False,
|
|
170
|
+
"error": f"File not found: {file_path}",
|
|
171
|
+
"findings": []
|
|
172
|
+
}
|
|
173
|
+
try:
|
|
174
|
+
with open(file_path, "r", encoding="utf-8", errors="ignore") as f:
|
|
175
|
+
content = f.read()
|
|
176
|
+
return self.audit_html_content(content, filename=file_path)
|
|
177
|
+
except Exception as e:
|
|
178
|
+
return {
|
|
179
|
+
"file": file_path,
|
|
180
|
+
"passed": False,
|
|
181
|
+
"error": str(e),
|
|
182
|
+
"findings": []
|
|
183
|
+
}
|
|
184
|
+
|
|
185
|
+
def main():
|
|
186
|
+
parser = argparse.ArgumentParser(description="Mechanical layout and UI quality gate checker.")
|
|
187
|
+
parser.add_argument("paths", nargs="*", help="HTML files or directories to audit.")
|
|
188
|
+
parser.add_argument("--json", action="store_true", help="Output JSON format.")
|
|
189
|
+
args = parser.parse_args()
|
|
190
|
+
|
|
191
|
+
gate = MechanicalUIGate()
|
|
192
|
+
target_files = []
|
|
193
|
+
|
|
194
|
+
if not args.paths:
|
|
195
|
+
# Default scan in reports/ or templates/
|
|
196
|
+
for root in ["reports", "templates"]:
|
|
197
|
+
if os.path.exists(root):
|
|
198
|
+
for dirpath, _, files in os.walk(root):
|
|
199
|
+
for f in files:
|
|
200
|
+
if f.endswith(".html"):
|
|
201
|
+
target_files.append(os.path.join(dirpath, f))
|
|
202
|
+
else:
|
|
203
|
+
for p in args.paths:
|
|
204
|
+
if os.path.isdir(p):
|
|
205
|
+
for dirpath, _, files in os.walk(p):
|
|
206
|
+
for f in files:
|
|
207
|
+
if f.endswith(".html"):
|
|
208
|
+
target_files.append(os.path.join(dirpath, f))
|
|
209
|
+
elif os.path.isfile(p):
|
|
210
|
+
target_files.append(p)
|
|
211
|
+
|
|
212
|
+
if not target_files:
|
|
213
|
+
print("[MECHANICAL UI GATE] No HTML files provided or found. Exiting clean.", file=sys.stderr)
|
|
214
|
+
sys.exit(0)
|
|
215
|
+
|
|
216
|
+
results = [gate.audit_file(f) for f in target_files]
|
|
217
|
+
total_fails = sum(r.get("fail_count", 0) for r in results)
|
|
218
|
+
total_warns = sum(r.get("warn_count", 0) for r in results)
|
|
219
|
+
all_passed = total_fails == 0
|
|
220
|
+
|
|
221
|
+
if args.json:
|
|
222
|
+
print(json.dumps({
|
|
223
|
+
"overall_passed": all_passed,
|
|
224
|
+
"total_files": len(results),
|
|
225
|
+
"total_fails": total_fails,
|
|
226
|
+
"total_warns": total_warns,
|
|
227
|
+
"results": results
|
|
228
|
+
}, indent=2))
|
|
229
|
+
else:
|
|
230
|
+
status_sym = "✅ PASS" if all_passed else "❌ FAIL"
|
|
231
|
+
print(f"[MECHANICAL UI GATE] {status_sym} — Checked {len(results)} files | Fails: {total_fails} | Warnings: {total_warns}")
|
|
232
|
+
for r in results:
|
|
233
|
+
if not r["passed"] or r.get("warn_count", 0) > 0:
|
|
234
|
+
print(f" File: {r['file']}")
|
|
235
|
+
for f in r.get("findings", []):
|
|
236
|
+
print(f" - [{f['severity']}] {f['id']}: {f['message']}")
|
|
237
|
+
|
|
238
|
+
if not all_passed:
|
|
239
|
+
sys.exit(1)
|
|
240
|
+
|
|
241
|
+
if __name__ == "__main__":
|
|
242
|
+
main()
|
|
@@ -0,0 +1,175 @@
|
|
|
1
|
+
#!/usr/bin/env python3
|
|
2
|
+
# -*- coding: utf-8 -*-
|
|
3
|
+
"""
|
|
4
|
+
tools/pairwise_generator.py — Pairwise (2-Way) Combinatorial Test Case Generator
|
|
5
|
+
Inspired by Composio / pypict combinatorial testing patterns.
|
|
6
|
+
Generates minimal test execution matrices covering 100% of 2-way parameter pairs,
|
|
7
|
+
reducing test case bloat by 80-90% while guaranteeing pairwise boundary coverage.
|
|
8
|
+
100% UTF-8 No BOM.
|
|
9
|
+
"""
|
|
10
|
+
|
|
11
|
+
import sys
|
|
12
|
+
import json
|
|
13
|
+
import argparse
|
|
14
|
+
import itertools
|
|
15
|
+
from typing import Dict, List, Any, Set, Tuple
|
|
16
|
+
|
|
17
|
+
# Enforce UTF-8 stdout encoding
|
|
18
|
+
if hasattr(sys.stdout, "reconfigure"):
|
|
19
|
+
try:
|
|
20
|
+
sys.stdout.reconfigure(encoding="utf-8")
|
|
21
|
+
sys.stderr.reconfigure(encoding="utf-8")
|
|
22
|
+
except Exception:
|
|
23
|
+
pass
|
|
24
|
+
|
|
25
|
+
def generate_all_pairs(parameters: Dict[str, List[Any]]) -> Set[Tuple[Tuple[str, Any], Tuple[str, Any]]]:
|
|
26
|
+
"""Generates all 2-way parameter value pairs."""
|
|
27
|
+
param_keys = sorted(parameters.keys())
|
|
28
|
+
all_pairs: Set[Tuple[Tuple[str, Any], Tuple[str, Any]]] = set()
|
|
29
|
+
|
|
30
|
+
for i in range(len(param_keys)):
|
|
31
|
+
for j in range(i + 1, len(param_keys)):
|
|
32
|
+
p1 = param_keys[i]
|
|
33
|
+
p2 = param_keys[j]
|
|
34
|
+
for v1 in parameters[p1]:
|
|
35
|
+
for v2 in parameters[p2]:
|
|
36
|
+
# Canonical ordered pair
|
|
37
|
+
pair = ((p1, v1), (p2, v2))
|
|
38
|
+
all_pairs.add(pair)
|
|
39
|
+
return all_pairs
|
|
40
|
+
|
|
41
|
+
def score_candidate(candidate: Dict[str, Any], uncovered_pairs: Set[Tuple[Tuple[str, Any], Tuple[str, Any]]]) -> int:
|
|
42
|
+
"""Calculates how many uncovered pairs a complete candidate test case satisfies."""
|
|
43
|
+
keys = sorted(candidate.keys())
|
|
44
|
+
count = 0
|
|
45
|
+
for i in range(len(keys)):
|
|
46
|
+
for j in range(i + 1, len(keys)):
|
|
47
|
+
p1, p2 = keys[i], keys[j]
|
|
48
|
+
pair = ((p1, candidate[p1]), (p2, candidate[p2]))
|
|
49
|
+
if pair in uncovered_pairs:
|
|
50
|
+
count += 1
|
|
51
|
+
return count
|
|
52
|
+
|
|
53
|
+
def generate_pairwise(parameters: Dict[str, List[Any]]) -> List[Dict[str, Any]]:
|
|
54
|
+
"""
|
|
55
|
+
Greedy Pairwise (IPOG-inspired) test suite generation.
|
|
56
|
+
Guarantees 100% pairwise coverage of parameter combinations.
|
|
57
|
+
"""
|
|
58
|
+
if not parameters or any(len(v) == 0 for v in parameters.values()):
|
|
59
|
+
return []
|
|
60
|
+
|
|
61
|
+
param_keys = sorted(parameters.keys())
|
|
62
|
+
if len(param_keys) == 1:
|
|
63
|
+
# Single parameter: return each value
|
|
64
|
+
p = param_keys[0]
|
|
65
|
+
return [{p: v} for v in parameters[p]]
|
|
66
|
+
|
|
67
|
+
uncovered_pairs = generate_all_pairs(parameters)
|
|
68
|
+
total_pairs = len(uncovered_pairs)
|
|
69
|
+
test_cases: List[Dict[str, Any]] = []
|
|
70
|
+
|
|
71
|
+
# Sort parameters by domain size descending for faster coverage
|
|
72
|
+
sorted_keys = sorted(param_keys, key=lambda k: len(parameters[k]), reverse=True)
|
|
73
|
+
|
|
74
|
+
while uncovered_pairs:
|
|
75
|
+
# Pick the pair with highest priority
|
|
76
|
+
target_pair = next(iter(uncovered_pairs))
|
|
77
|
+
p1, v1 = target_pair[0]
|
|
78
|
+
p2, v2 = target_pair[1]
|
|
79
|
+
|
|
80
|
+
# Initialize candidate with this pair
|
|
81
|
+
candidate: Dict[str, Any] = {p1: v1, p2: v2}
|
|
82
|
+
|
|
83
|
+
# Greedily assign remaining parameters to maximize pair coverage
|
|
84
|
+
for key in sorted_keys:
|
|
85
|
+
if key in candidate:
|
|
86
|
+
continue
|
|
87
|
+
|
|
88
|
+
best_val = parameters[key][0]
|
|
89
|
+
best_score = -1
|
|
90
|
+
|
|
91
|
+
for val in parameters[key]:
|
|
92
|
+
temp_cand = dict(candidate)
|
|
93
|
+
temp_cand[key] = val
|
|
94
|
+
# Count pairs this assignment would cover with already-fixed params
|
|
95
|
+
score = 0
|
|
96
|
+
for fixed_key, fixed_val in candidate.items():
|
|
97
|
+
p_a, v_a = (key, val) if key < fixed_key else (fixed_key, fixed_val)
|
|
98
|
+
p_b, v_b = (fixed_key, fixed_val) if key < fixed_key else (key, val)
|
|
99
|
+
if ((p_a, v_a), (p_b, v_b)) in uncovered_pairs:
|
|
100
|
+
score += 1
|
|
101
|
+
if score > best_score:
|
|
102
|
+
best_score = score
|
|
103
|
+
best_val = val
|
|
104
|
+
|
|
105
|
+
candidate[key] = best_val
|
|
106
|
+
|
|
107
|
+
# Ensure all keys are populated
|
|
108
|
+
for key in param_keys:
|
|
109
|
+
if key not in candidate:
|
|
110
|
+
candidate[key] = parameters[key][0]
|
|
111
|
+
|
|
112
|
+
# Remove covered pairs from uncovered set
|
|
113
|
+
for i in range(len(param_keys)):
|
|
114
|
+
for j in range(i + 1, len(param_keys)):
|
|
115
|
+
k1, k2 = param_keys[i], param_keys[j]
|
|
116
|
+
pair = ((k1, candidate[k1]), (k2, candidate[k2]))
|
|
117
|
+
uncovered_pairs.discard(pair)
|
|
118
|
+
|
|
119
|
+
test_cases.append(candidate)
|
|
120
|
+
|
|
121
|
+
return test_cases
|
|
122
|
+
|
|
123
|
+
def main():
|
|
124
|
+
parser = argparse.ArgumentParser(description="Generate pairwise (2-way) combinatorial test suites.")
|
|
125
|
+
parser.add_argument("--params", "-p", help="JSON string or file path containing parameter domains.")
|
|
126
|
+
parser.add_argument("--json", action="store_true", help="Output JSON format.")
|
|
127
|
+
args = parser.parse_args()
|
|
128
|
+
|
|
129
|
+
if not args.params:
|
|
130
|
+
# Default sample parameters
|
|
131
|
+
sample_params = {
|
|
132
|
+
"browser": ["chromium", "firefox", "webkit"],
|
|
133
|
+
"viewport": ["desktop_1920x1080", "mobile_390x844"],
|
|
134
|
+
"user_role": ["admin", "editor", "viewer"],
|
|
135
|
+
"auth_state": ["logged_in", "anonymous"]
|
|
136
|
+
}
|
|
137
|
+
params = sample_params
|
|
138
|
+
else:
|
|
139
|
+
try:
|
|
140
|
+
if args.params.startswith("{"):
|
|
141
|
+
params = json.loads(args.params)
|
|
142
|
+
else:
|
|
143
|
+
with open(args.params, "r", encoding="utf-8") as f:
|
|
144
|
+
params = json.load(f)
|
|
145
|
+
except Exception as e:
|
|
146
|
+
print(f"Error parsing parameters: {e}", file=sys.stderr)
|
|
147
|
+
sys.exit(1)
|
|
148
|
+
|
|
149
|
+
all_pairs = generate_all_pairs(params)
|
|
150
|
+
cases = generate_pairwise(params)
|
|
151
|
+
full_combinations = 1 if params else 0
|
|
152
|
+
for k, v in params.items():
|
|
153
|
+
full_combinations *= len(v)
|
|
154
|
+
|
|
155
|
+
reduction = round((1.0 - len(cases) / full_combinations) * 100, 1) if full_combinations > 0 else 0.0
|
|
156
|
+
|
|
157
|
+
if args.json:
|
|
158
|
+
print(json.dumps({
|
|
159
|
+
"total_full_permutations": full_combinations,
|
|
160
|
+
"pairwise_test_count": len(cases),
|
|
161
|
+
"total_2way_pairs": len(all_pairs),
|
|
162
|
+
"reduction_pct": reduction,
|
|
163
|
+
"test_cases": cases
|
|
164
|
+
}, indent=2))
|
|
165
|
+
else:
|
|
166
|
+
print(f"[PAIRWISE GENERATOR] Parameters: {len(params)} | Total Permutations: {full_combinations}")
|
|
167
|
+
print(f" Optimized Pairwise Cases: {len(cases)} (Covering {len(all_pairs)} 2-way interactions)")
|
|
168
|
+
print(f" Reduction: {reduction}% test case reduction!")
|
|
169
|
+
print("\nGenerated Test Matrix:")
|
|
170
|
+
for idx, tc in enumerate(cases, 1):
|
|
171
|
+
formatted = ", ".join(f"{k}={v}" for k, v in tc.items())
|
|
172
|
+
print(f" TC-{idx:02d}: {formatted}")
|
|
173
|
+
|
|
174
|
+
if __name__ == "__main__":
|
|
175
|
+
main()
|
package/tools/repo_map.py
CHANGED
|
@@ -421,7 +421,7 @@ def build_repo_map(target_repo=None, output_txt=None, output_json=None):
|
|
|
421
421
|
|
|
422
422
|
total_methods = 0
|
|
423
423
|
for cls in classes:
|
|
424
|
-
display_path = cls["rel_path"]
|
|
424
|
+
display_path = cls["rel_path"].replace("\\", "/")
|
|
425
425
|
if display_path.startswith("examples/"):
|
|
426
426
|
display_path = display_path[len("examples/"):]
|
|
427
427
|
ext_str = f" extends {cls['extends']}" if (cls["extends"] and cls["extends"] != "BasePage") else ""
|
|
@@ -0,0 +1,178 @@
|
|
|
1
|
+
#!/usr/bin/env python3
|
|
2
|
+
# -*- coding: utf-8 -*-
|
|
3
|
+
"""
|
|
4
|
+
tools/runaway_stopper.py — Agent Runaway & Token Loop Sentinel
|
|
5
|
+
Inspired by Garry Tan's gstack (R70/R91 runaway stopper) adapted for Synapse Hub.
|
|
6
|
+
Prevents runaway subagent threads, context window blowout, and infinite loops.
|
|
7
|
+
100% UTF-8 No BOM.
|
|
8
|
+
"""
|
|
9
|
+
|
|
10
|
+
import sys
|
|
11
|
+
import os
|
|
12
|
+
import json
|
|
13
|
+
import argparse
|
|
14
|
+
from typing import Dict, List, Any, Optional
|
|
15
|
+
|
|
16
|
+
# Enforce UTF-8 stdout encoding
|
|
17
|
+
if hasattr(sys.stdout, "reconfigure"):
|
|
18
|
+
try:
|
|
19
|
+
sys.stdout.reconfigure(encoding="utf-8")
|
|
20
|
+
sys.stderr.reconfigure(encoding="utf-8")
|
|
21
|
+
except Exception:
|
|
22
|
+
pass
|
|
23
|
+
|
|
24
|
+
DEFAULT_THRESHOLDS = {
|
|
25
|
+
"max_turns": 30,
|
|
26
|
+
"warn_turns": 20,
|
|
27
|
+
"max_tokens": 150000,
|
|
28
|
+
"warn_tokens": 100000,
|
|
29
|
+
"max_repeated_calls": 3,
|
|
30
|
+
"empty_turn_threshold": 4,
|
|
31
|
+
}
|
|
32
|
+
|
|
33
|
+
class RunawaySentinel:
|
|
34
|
+
def __init__(self, thresholds: Optional[Dict[str, int]] = None):
|
|
35
|
+
self.thresholds = dict(DEFAULT_THRESHOLDS)
|
|
36
|
+
if thresholds:
|
|
37
|
+
self.thresholds.update(thresholds)
|
|
38
|
+
|
|
39
|
+
def evaluate_transcript(self, turns: List[Dict[str, Any]]) -> Dict[str, Any]:
|
|
40
|
+
"""
|
|
41
|
+
Evaluates a list of turn records:
|
|
42
|
+
turn = {
|
|
43
|
+
"turn_index": int,
|
|
44
|
+
"tool_name": str,
|
|
45
|
+
"command": str,
|
|
46
|
+
"tokens_est": int,
|
|
47
|
+
"has_error": bool,
|
|
48
|
+
"output_length": int
|
|
49
|
+
}
|
|
50
|
+
"""
|
|
51
|
+
turn_count = len(turns)
|
|
52
|
+
total_tokens = sum(t.get("tokens_est", 0) for t in turns)
|
|
53
|
+
flags = []
|
|
54
|
+
verdict = "OK"
|
|
55
|
+
|
|
56
|
+
# 1. Turn budget check
|
|
57
|
+
if turn_count >= self.thresholds["max_turns"]:
|
|
58
|
+
flags.append({
|
|
59
|
+
"severity": "CRITICAL",
|
|
60
|
+
"type": "TURN_LIMIT_EXCEEDED",
|
|
61
|
+
"message": f"Turn count ({turn_count}) exceeded maximum threshold ({self.thresholds['max_turns']})."
|
|
62
|
+
})
|
|
63
|
+
verdict = "STOP"
|
|
64
|
+
elif turn_count >= self.thresholds["warn_turns"]:
|
|
65
|
+
flags.append({
|
|
66
|
+
"severity": "WARNING",
|
|
67
|
+
"type": "TURN_LIMIT_WARNING",
|
|
68
|
+
"message": f"Turn count ({turn_count}) approached warning threshold ({self.thresholds['warn_turns']})."
|
|
69
|
+
})
|
|
70
|
+
if verdict == "OK":
|
|
71
|
+
verdict = "WARN"
|
|
72
|
+
|
|
73
|
+
# 2. Token budget check
|
|
74
|
+
if total_tokens >= self.thresholds["max_tokens"]:
|
|
75
|
+
flags.append({
|
|
76
|
+
"severity": "CRITICAL",
|
|
77
|
+
"type": "TOKEN_BUDGET_EXCEEDED",
|
|
78
|
+
"message": f"Estimated token usage ({total_tokens:,}) exceeded budget ({self.thresholds['max_tokens']:,})."
|
|
79
|
+
})
|
|
80
|
+
verdict = "STOP"
|
|
81
|
+
elif total_tokens >= self.thresholds["warn_tokens"]:
|
|
82
|
+
flags.append({
|
|
83
|
+
"severity": "WARNING",
|
|
84
|
+
"type": "TOKEN_BUDGET_WARNING",
|
|
85
|
+
"message": f"Estimated token usage ({total_tokens:,}) reached warning limit ({self.thresholds['warn_tokens']:,})."
|
|
86
|
+
})
|
|
87
|
+
if verdict == "OK":
|
|
88
|
+
verdict = "WARN"
|
|
89
|
+
|
|
90
|
+
# 3. Repeated identical tool call loop detection
|
|
91
|
+
recent_commands = [
|
|
92
|
+
(t.get("command") or t.get("tool_name") or t.get("tool") or t.get("name") or "")
|
|
93
|
+
for t in turns
|
|
94
|
+
if (t.get("command") or t.get("tool_name") or t.get("tool") or t.get("name"))
|
|
95
|
+
]
|
|
96
|
+
if len(recent_commands) >= self.thresholds["max_repeated_calls"]:
|
|
97
|
+
last_cmd = recent_commands[-1]
|
|
98
|
+
repeat_count = 1
|
|
99
|
+
for cmd in reversed(recent_commands[:-1]):
|
|
100
|
+
if cmd == last_cmd and last_cmd:
|
|
101
|
+
repeat_count += 1
|
|
102
|
+
else:
|
|
103
|
+
break
|
|
104
|
+
if repeat_count >= self.thresholds["max_repeated_calls"]:
|
|
105
|
+
flags.append({
|
|
106
|
+
"severity": "CRITICAL",
|
|
107
|
+
"type": "TOOL_LOOP_DETECTED",
|
|
108
|
+
"message": f"Command repeated {repeat_count} consecutive times: '{last_cmd[:60]}...'"
|
|
109
|
+
})
|
|
110
|
+
verdict = "STOP"
|
|
111
|
+
|
|
112
|
+
# 4. Consecutive empty turns detection
|
|
113
|
+
empty_turns = 0
|
|
114
|
+
for t in reversed(turns):
|
|
115
|
+
if t.get("output_length", 1) == 0 and not t.get("tool_name"):
|
|
116
|
+
empty_turns += 1
|
|
117
|
+
else:
|
|
118
|
+
break
|
|
119
|
+
if empty_turns >= self.thresholds["empty_turn_threshold"]:
|
|
120
|
+
flags.append({
|
|
121
|
+
"severity": "CRITICAL",
|
|
122
|
+
"type": "EMPTY_TURNS_LOOP",
|
|
123
|
+
"message": f"Detected {empty_turns} consecutive empty turns without progress."
|
|
124
|
+
})
|
|
125
|
+
verdict = "STOP"
|
|
126
|
+
|
|
127
|
+
return {
|
|
128
|
+
"verdict": verdict,
|
|
129
|
+
"turn_count": turn_count,
|
|
130
|
+
"total_tokens_est": total_tokens,
|
|
131
|
+
"flags": flags,
|
|
132
|
+
"is_runaway": verdict == "STOP",
|
|
133
|
+
}
|
|
134
|
+
|
|
135
|
+
def main():
|
|
136
|
+
parser = argparse.ArgumentParser(description="Evaluate agent sessions for runaway token consumption and loops.")
|
|
137
|
+
parser.add_argument("--transcript", "-t", help="Path to JSON file containing turn list.")
|
|
138
|
+
parser.add_argument("--turns", type=int, default=0, help="Direct turn count to evaluate.")
|
|
139
|
+
parser.add_argument("--tokens", type=int, default=0, help="Direct token estimate to evaluate.")
|
|
140
|
+
parser.add_argument("--json", action="store_true", help="Output results in JSON format.")
|
|
141
|
+
args = parser.parse_args()
|
|
142
|
+
|
|
143
|
+
sentinel = RunawaySentinel()
|
|
144
|
+
|
|
145
|
+
if args.transcript and os.path.exists(args.transcript):
|
|
146
|
+
with open(args.transcript, "r", encoding="utf-8") as f:
|
|
147
|
+
turns = json.load(f)
|
|
148
|
+
elif args.turns > 0 or args.tokens > 0:
|
|
149
|
+
if args.turns == 0 and args.tokens > 0:
|
|
150
|
+
turns = [{"turn_index": 0, "tokens_est": args.tokens}]
|
|
151
|
+
else:
|
|
152
|
+
turn_count = max(1, args.turns)
|
|
153
|
+
per_turn_tokens = args.tokens // turn_count
|
|
154
|
+
turns = [{"turn_index": i, "tokens_est": per_turn_tokens} for i in range(turn_count)]
|
|
155
|
+
else:
|
|
156
|
+
# Default mock evaluation
|
|
157
|
+
turns = []
|
|
158
|
+
|
|
159
|
+
result = sentinel.evaluate_transcript(turns)
|
|
160
|
+
|
|
161
|
+
if args.json:
|
|
162
|
+
print(json.dumps(result, indent=2, ensure_ascii=False))
|
|
163
|
+
else:
|
|
164
|
+
print(f"[RUNAWAY STOPPER] Verdict: {result['verdict']}")
|
|
165
|
+
print(f" Turns Evaluated: {result['turn_count']}")
|
|
166
|
+
print(f" Estimated Tokens: {result['total_tokens_est']:,}")
|
|
167
|
+
if result["flags"]:
|
|
168
|
+
print(" Flags Detected:")
|
|
169
|
+
for flag in result["flags"]:
|
|
170
|
+
print(f" - [{flag['severity']}] {flag['type']}: {flag['message']}")
|
|
171
|
+
else:
|
|
172
|
+
print(" Status: Clean - zero loops or budget overruns detected.")
|
|
173
|
+
|
|
174
|
+
if result["is_runaway"]:
|
|
175
|
+
sys.exit(1)
|
|
176
|
+
|
|
177
|
+
if __name__ == "__main__":
|
|
178
|
+
main()
|
package/tools/ui_server.py
CHANGED
|
@@ -236,7 +236,7 @@ class SynapseUiHandler(BaseHTTPRequestHandler):
|
|
|
236
236
|
if path == "/api/status":
|
|
237
237
|
active_target = JOB_MANAGER.target_dir or REPO_ROOT
|
|
238
238
|
self.send_json(200, {
|
|
239
|
-
"version": "3.
|
|
239
|
+
"version": "3.9.0",
|
|
240
240
|
"status": "ONLINE",
|
|
241
241
|
"os": sys.platform,
|
|
242
242
|
"workspace": active_target,
|
package/tools/update_sentinel.py
CHANGED
|
@@ -65,7 +65,7 @@ def get_local_version():
|
|
|
65
65
|
try:
|
|
66
66
|
with open(pkg_file, "r", encoding="utf-8") as f:
|
|
67
67
|
data = json.load(f)
|
|
68
|
-
return data.get("version", "3.
|
|
68
|
+
return data.get("version", "3.9.0")
|
|
69
69
|
except (OSError, json.JSONDecodeError):
|
|
70
70
|
data = {}
|
|
71
71
|
|
|
@@ -74,11 +74,11 @@ def get_local_version():
|
|
|
74
74
|
try:
|
|
75
75
|
with open(manifest_file, "r", encoding="utf-8") as f:
|
|
76
76
|
data = json.load(f)
|
|
77
|
-
return data.get("version", "3.
|
|
77
|
+
return data.get("version", "3.9.0")
|
|
78
78
|
except (OSError, json.JSONDecodeError):
|
|
79
79
|
data = {}
|
|
80
80
|
|
|
81
|
-
return "3.
|
|
81
|
+
return "3.9.0"
|
|
82
82
|
|
|
83
83
|
|
|
84
84
|
def fetch_remote_version():
|
package/tools/verify_all.py
CHANGED
|
@@ -1006,6 +1006,21 @@ def gate_9_skill_collision(repo_root, mode="AUTO"):
|
|
|
1006
1006
|
safe_print(res.stderr)
|
|
1007
1007
|
return False
|
|
1008
1008
|
print("[PASS] 100% Verified: 0 skill description and rule collisions detected (similarity < 0.75).")
|
|
1009
|
+
|
|
1010
|
+
# Run Mechanical UI Finish Gate (Leonxlnx taste-skill pattern)
|
|
1011
|
+
mech_script = os.path.join(SCRIPT_DIR, "mechanical_ui_gate.py")
|
|
1012
|
+
if not os.path.exists(mech_script):
|
|
1013
|
+
mech_script = os.path.join(repo_root, "tools", "mechanical_ui_gate.py")
|
|
1014
|
+
if os.path.exists(mech_script):
|
|
1015
|
+
try:
|
|
1016
|
+
m_res = subprocess.run([sys.executable, mech_script], stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, encoding="utf-8", errors="replace", timeout=30.0)
|
|
1017
|
+
if m_res.returncode == 0:
|
|
1018
|
+
print("[PASS] Mechanical UI Finish Gate: Layout, contrast, and interactive elements verified.")
|
|
1019
|
+
else:
|
|
1020
|
+
safe_print(f"[WARN] Mechanical UI Finish Gate non-zero exit: {m_res.stderr.strip()[:100]}")
|
|
1021
|
+
except (OSError, subprocess.SubprocessError) as m_err:
|
|
1022
|
+
safe_print(f"[WARN] Mechanical UI Finish Gate execution error: {m_err}")
|
|
1023
|
+
|
|
1009
1024
|
return True
|
|
1010
1025
|
|
|
1011
1026
|
|
package/tools/welcome_page.py
CHANGED
|
@@ -47,7 +47,7 @@ def get_hub_metadata() -> Dict[str, Any]:
|
|
|
47
47
|
"""Retrieves version and catalog count from skills_manifest.json."""
|
|
48
48
|
manifest_path = os.path.join(HUB_ROOT, "skills_manifest.json")
|
|
49
49
|
meta = {
|
|
50
|
-
"version": "3.
|
|
50
|
+
"version": "3.9.0",
|
|
51
51
|
"totalSkills": 42,
|
|
52
52
|
"author": "Thế Vị (@TeeVee98)",
|
|
53
53
|
"repo": "https://github.com/TeeVee98/Synapse-Hub"
|