tribunal-kit 4.0.1 → 4.3.0

package/.agent/scripts/deep_compress.py

@@ -1,202 +0,0 @@
-#!/usr/bin/env python3
-"""
-deep_compress.py - Deep surgical compression for .agent/ markdown files (skills, agents, workflows).
-Targets: repetitive boilerplate, verbose code comments, redundant example sections.
-Safe: never removes H1/H2 headers, never removes HALLUCINATION TRAP lines, never removes code blocks entirely.
-"""
-
-import os, re, sys
-
-BASE_DIRS = ['.agent/skills', '.agent/agents', '.agent/workflows']
-
-# ─── SECTION REMOVAL ─────────────────────────────────────────────────────────
-# These are globally covered by GEMINI.md — strip from all files
-
-REMOVE_SECTIONS = [
-    r'(?ms)^## 🏛️ Tribunal Integration.*?(?=^## |\Z)',
-    r'(?ms)^## Tribunal Integration.*?(?=^## |\Z)',
-    r'(?ms)^### ✅ Pre-Flight Self-Audit.*?(?=^### |^## |\Z)',
-    r'(?ms)^## Pre-Flight Self-Audit.*?(?=^## |\Z)',
-    r'(?ms)^## Cross-Workflow Navigation.*?(?=^## |\Z)',
-    r'(?ms)^## LLM Traps.*?(?=^## |\Z)',
-    r'(?ms)^## VBC Protocol.*?(?=^## |\Z)',
-    r'(?ms)^## Output Format\n```[\s\S]*?```\n',
-    r'(?ms)^## 🤖 LLM-Specific Traps.*?(?=^## |\Z)',    # covered in GEMINI.md
-]
-
-# ─── VERBOSE COMMENT REMOVAL IN CODE BLOCKS ──────────────────────────────────
-# Removes lines that just restate the concept being shown — pure padding
-
-VERBOSE_COMMENT_PATTERNS = [
-    # e.g. "// Any HTML or SVG element can be prefixed with `motion.`"
-    r"(?m)^(\s*)//\s*(?:Any HTML or SVG element|motion\.div, motion\.span|The MAGIC of|This is the key performance|The pattern that|Compound components share|Note that children|The action receives|Children inherit the|Import first|Parent controls when|It's always motion)\b[^\n]*\n",
-    # e.g. "# TypedDict gives you autocomplete..."
-    r"(?m)^(\s*)#\s*(?:TypedDict gives you|Usage:|Note:|Return user|Return None|Automatically)\b[^\n]*\n",
-    # Obvious standalone "// Usage:" label inside code blocks
-    r"(?m)^\s*//\s*Usage:\s*\n(?=\s*[<{])",
-    r"(?m)^\s*#\s*Usage:\s*\n(?=\s*[{])",
-    # "// When server responds..." style obvious follow-on comment
-    r"(?m)^\s*//\s*When (?:server responds|a component|React can interrupt|the React Compiler)[^\n]*\n",
-]
-
-# ─── CHATTY SENTENCE REMOVAL BEFORE FIRST CODE BLOCK ─────────────────────────
-# Removes motivational opener sentences: "X is a paradigm shift. If you..."
-
-def strip_chatty_openers(content):
-    """Remove 2-3 sentence filler paragraphs between H1 and first ---"""
-    return re.sub(
-        r'(^# .+\n)\n.{60,}\n.{30,}\n(?:\n---)',
-        r'\1\n---',
-        content,
-        flags=re.MULTILINE
-    )
-
-# ─── COLLAPSE NESTED IDENTICAL EXAMPLES ──────────────────────────────────────
-# Many files have "// Legacy" vs "// Modern" comments — compress to 1 block
-
-def compress_legacy_modern_blocks(content):
-    """Convert // LEGACY + // MODERN dual examples into compact diff-style"""
-    # Pattern: code block with ❌ LEGACY followed immediately by ✅ MODERN
-    pattern = re.compile(
-        r'```(\w+)\n((?:.*\n)*?.*// ❌ LEGACY[^\n]*\n(?:.*\n)*?)```\n\n```\w+\n((?:.*\n)*?.*// ✅ MODERN[^\n]*\n(?:.*\n)*?)```',
-        re.MULTILINE
-    )
-    # Only compress if the whole block is < 30 lines total
-    def compress(m):
-        total_lines = m.group(2).count('\n') + m.group(3).count('\n')
-        if total_lines > 28:
-            return m.group(0)  # too big to safely merge — leave alone
-        lang = m.group(1)
-        legacy = m.group(2).strip()
-        modern = m.group(3).strip()
-        return f'```{lang}\n// ❌ LEGACY\n{legacy}\n\n// ✅ MODERN\n{modern}\n```'
-    return pattern.sub(compress, content)
-
-# ─── STRIP EMPTY COMMENT LINES ───────────────────────────────────────────────
-def strip_empty_comments(content):
-    """Remove lines that are ONLY // or #"""
-    content = re.sub(r'(?m)^\s*//\s*$\n', '', content)
-    content = re.sub(r'(?m)^\s*#\s*$\n', '', content)
-    return content
-
-# ─── TRIM REPEATED RULES (dedup consecutive bullet points in same section) ───
-def dedup_bullet_points(content):
-    """Remove exact duplicate bullet point lines (often copy-pasted across sections)."""
-    lines = content.split('\n')
-    seen_bullets = {}
-    output = []
-    for i, line in enumerate(lines):
-        stripped = line.strip()
-        if stripped.startswith(('✅', '❌', '- ✅', '- ❌')):
-            if stripped in seen_bullets and i - seen_bullets[stripped] < 80:
-                continue  # skip duplicate within 80 lines
-            seen_bullets[stripped] = i
-        output.append(line)
-    return '\n'.join(output)
-
-# ─── COLLAPSE BLANKS ─────────────────────────────────────────────────────────
-def collapse_blanks(content):
-    return re.sub(r'\n{3,}', '\n\n', content)
-
-# ─── REMOVE REDUNDANT IMPORTS IN COMMENTS ────────────────────────────────────
-# Some files have // import { x } from "y" repeated in every example
-
-def compress_import_repetition(content):
-    """If same import line appears in 3+ separate code blocks, add a note and strip repetitions."""
-    import_line = re.compile(r'import \{[^}]+\} from "[^"]+";')
-    matches = import_line.findall(content)
-    freq = {}
-    for m in matches:
-        freq[m] = freq.get(m, 0) + 1
-    
-    for imp, count in freq.items():
-        if count >= 4:
-            # First occurrence: keep it. Subsequent ones: replace with comment
-            first_done = [False]
-            def replacer(m, imp=imp, first_done=first_done):
-                if m.group(0) == imp:
-                    if not first_done[0]:
-                        first_done[0] = True
-                        return m.group(0)
-                    return f'// {imp}  ← (already imported above)'
-                return m.group(0)
-            content = import_line.sub(replacer, content)
-    return content
-
-# ─── MAIN PIPELINE ──────────────────────────────────────────────────────────
-
-def compress_file(path):
-    with open(path, 'r', encoding='utf-8', errors='ignore') as f:
-        original = f.read()
-    
-    content = original
-    
-    # 1. Strip global boilerplate sections
-    for pattern in REMOVE_SECTIONS:
-        content = re.sub(pattern, '', content)
-    
-    # 2. Strip chatty openers
-    content = strip_chatty_openers(content)
-    
-    # 3. Compress legacy/modern dual blocks
-    content = compress_legacy_modern_blocks(content)
-    
-    # 4. Verbose inline code comment removal
-    for pattern in VERBOSE_COMMENT_PATTERNS:
-        content = re.sub(pattern, '', content)
-    
-    # 5. Strip empty comment lines
-    content = strip_empty_comments(content)
-    
-    # 6. Deduplicate bullet points
-    content = dedup_bullet_points(content)
-    
-    # 7. Collapse 3+ blank lines
-    content = collapse_blanks(content)
-    
-    # Write back only if changed
-    if content.strip() != original.strip():
-        with open(path, 'w', encoding='utf-8') as f:
-            f.write(content.strip() + '\n')
-    
-    return len(original), len(content)
-
-def main():
-    total_orig = 0
-    total_new = 0
-    file_results = []
-    
-    for base in BASE_DIRS:
-        if not os.path.exists(base):
-            continue
-        for root, _, files in os.walk(base):
-            for fname in files:
-                if fname.endswith('.md'):
-                    path = os.path.join(root, fname)
-                    orig, new = compress_file(path)
-                    total_orig += orig
-                    total_new += new
-                    saved = orig - new
-                    if saved > 200:
-                        rel = os.path.relpath(path, '.')
-                        file_results.append((saved, rel))
-    
-    file_results.sort(reverse=True)
-    
-    saved_total = total_orig - total_new
-    pct = saved_total / total_orig * 100 if total_orig else 0
-    
-    print(f"\n{'='*58}")
-    print(f"  Deep Compression Complete")
-    print(f"{'='*58}")
-    print(f"  Original : {total_orig:,} bytes ({total_orig//1024}KB)")
-    print(f"  After    : {total_new:,} bytes ({total_new//1024}KB)")
-    print(f"  Saved    : {saved_total:,} bytes ({saved_total//1024}KB) — {pct:.1f}%")
-    print(f"\n  Top savings:")
-    for saved, path in file_results[:20]:
-        skill = '/'.join(path.replace('\\','/').split('/')[-2:])
-        print(f"    -{saved//1024:2}KB  {skill}")
-    print()
-
-if __name__ == '__main__':
-    main()

package/.agent/scripts/dependency_analyzer.py

@@ -1,247 +0,0 @@
-#!/usr/bin/env python3
-"""
-dependency_analyzer.py — Dependency health checker for the Tribunal Agent Kit.
-
-Analyzes project dependencies for:
-  - Unused packages (in package.json but never imported)
-  - Phantom imports (imported but not in package.json)
-  - npm audit / pip-audit results
-  - Duplicate/overlapping packages
-
-Usage:
-  python .agent/scripts/dependency_analyzer.py .
-  python .agent/scripts/dependency_analyzer.py . --audit
-  python .agent/scripts/dependency_analyzer.py . --check-unused
-"""
-
-import os
-import sys
-import re
-import json
-import subprocess
-import argparse
-from pathlib import Path
-
-RED = "\033[91m"
-GREEN = "\033[92m"
-YELLOW = "\033[93m"
-BLUE = "\033[94m"
-BOLD = "\033[1m"
-RESET = "\033[0m"
-
-SOURCE_EXTENSIONS = {".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"}
-SKIP_DIRS = {"node_modules", ".git", "dist", "build", ".next", ".agent", "__pycache__"}
-
-# Built-in Node.js modules that don't require packages
-NODE_BUILTINS = {
-    "fs", "path", "os", "crypto", "http", "https", "url", "util",
-    "stream", "events", "child_process", "cluster", "net", "dns",
-    "tls", "readline", "zlib", "buffer", "querystring", "string_decoder",
-    "assert", "perf_hooks", "worker_threads", "timers", "v8",
-    "node:fs", "node:path", "node:os", "node:crypto", "node:http",
-    "node:https", "node:url", "node:util", "node:stream", "node:events",
-    "node:child_process", "node:net", "node:dns", "node:tls",
-    "node:readline", "node:zlib", "node:buffer", "node:assert",
-    "node:perf_hooks", "node:worker_threads", "node:timers",
-}
-
-
-def header(title: str) -> None:
-    print(f"\n{BOLD}{BLUE}━━━ {title} ━━━{RESET}")
-
-
-def ok(msg: str) -> None:
-    print(f"  {GREEN}✅ {msg}{RESET}")
-
-
-def fail(msg: str) -> None:
-    print(f"  {RED}❌ {msg}{RESET}")
-
-
-def warn(msg: str) -> None:
-    print(f"  {YELLOW}⚠️  {msg}{RESET}")
-
-
-def skip(msg: str) -> None:
-    print(f"  {YELLOW}⏭️  {msg}{RESET}")
-
-
-def load_package_json(project_root: str) -> dict | None:
-    """Load and return package.json contents."""
-    pkg_path = Path(project_root) / "package.json"
-    if not pkg_path.exists():
-        return None
-    try:
-        with open(pkg_path) as f:
-            return json.load(f)
-    except (json.JSONDecodeError, IOError):
-        return None
-
-
-def extract_imports(project_root: str) -> set[str]:
-    """Extract all external package imports from source files."""
-    imports: set[str] = set()
-    import_patterns = [
-        re.compile(r'(?:import|export)\s+.*?\s+from\s+["\']([^"\'\.][^"\']*)["\']'),
-        re.compile(r'require\s*\(\s*["\']([^"\'\.][^"\']*)["\']'),
-        re.compile(r'import\s*\(\s*["\']([^"\'\.][^"\']*)["\']'),
-    ]
-
-    for root, dirs, files in os.walk(project_root):
-        dirs[:] = [d for d in dirs if d not in SKIP_DIRS]
-        for filename in files:
-            ext = Path(filename).suffix
-            if ext not in SOURCE_EXTENSIONS:
-                continue
-            filepath = os.path.join(root, filename)
-            try:
-                with open(filepath, "r", encoding="utf-8", errors="ignore") as f:
-                    content = f.read()
-                for pattern in import_patterns:
-                    for match in pattern.finditer(content):
-                        pkg = match.group(1)
-                        # Normalize scoped packages: @scope/pkg/subpath → @scope/pkg
-                        if pkg.startswith("@"):
-                            parts = pkg.split("/")
-                            pkg = "/".join(parts[:2]) if len(parts) >= 2 else pkg
-                        else:
-                            pkg = pkg.split("/")[0]
-                        imports.add(pkg)
-            except (IOError, PermissionError):
-                pass
-
-    return imports
-
-
-def check_unused(pkg: dict, used_imports: set[str]) -> list[str]:
-    """Find packages listed in package.json but never imported."""
-    all_deps = set(pkg.get("dependencies", {}).keys()) | set(pkg.get("devDependencies", {}).keys())
-    # Some packages are used implicitly (build tools, configs, types)
-    implicit_packages = {
-        "typescript", "eslint", "prettier", "vitest", "jest", "ts-node",
-        "@types/node", "@types/react", "tailwindcss", "postcss", "autoprefixer",
-        "nodemon", "tsx", "vite", "next", "webpack", "babel", "@babel/core",
-    }
-    checkable = all_deps - implicit_packages
-    # Also skip @types/ packages — they're type-only
-    checkable = {d for d in checkable if not d.startswith("@types/")}
-
-    unused = checkable - used_imports
-    return sorted(unused)
-
-
-def check_phantom(pkg: dict, used_imports: set[str]) -> list[str]:
-    """Find packages imported but not listed in package.json."""
-    all_deps = set(pkg.get("dependencies", {}).keys()) | set(pkg.get("devDependencies", {}).keys())
-    external_imports = used_imports - NODE_BUILTINS
-    phantom = external_imports - all_deps
-    return sorted(phantom)
-
-
-def run_npm_audit(project_root: str) -> bool:
-    """Run npm audit and report results."""
-    try:
-        result = subprocess.run(
-            ["npm", "audit", "--json"],
-            cwd=project_root,
-            capture_output=True,
-            text=True,
-            timeout=60,
-        )
-        try:
-            audit_data = json.loads(result.stdout)
-            vulns = audit_data.get("metadata", {}).get("vulnerabilities", {})
-            critical = vulns.get("critical", 0)
-            high = vulns.get("high", 0)
-            moderate = vulns.get("moderate", 0)
-            low = vulns.get("low", 0)
-
-            if critical + high > 0:
-                fail(f"npm audit: {critical} critical, {high} high, {moderate} moderate, {low} low")
-                return False
-            elif moderate + low > 0:
-                warn(f"npm audit: {moderate} moderate, {low} low vulnerabilities")
-                return True
-            else:
-                ok("npm audit — no known vulnerabilities")
-                return True
-        except (json.JSONDecodeError, KeyError):
-            if result.returncode == 0:
-                ok("npm audit — clean")
-                return True
-            fail("npm audit returned errors")
-            return False
-    except FileNotFoundError:
-        skip("npm not installed — skipping audit")
-        return True
-    except subprocess.TimeoutExpired:
-        fail("npm audit timed out after 60s")
-        return False
-
-
-def main() -> None:
-    parser = argparse.ArgumentParser(
-        description="Tribunal dependency analyzer — checks for unused, phantom, and vulnerable packages"
-    )
-    parser.add_argument("path", help="Project root directory")
-    parser.add_argument("--audit", action="store_true", help="Also run npm audit / pip-audit")
-    parser.add_argument("--check-unused", action="store_true", help="Only check for unused dependencies")
-    args = parser.parse_args()
-
-    project_root = os.path.abspath(args.path)
-    if not os.path.isdir(project_root):
-        fail(f"Directory not found: {project_root}")
-        sys.exit(1)
-
-    print(f"{BOLD}Tribunal — dependency_analyzer.py{RESET}")
-    print(f"Project: {project_root}")
-
-    pkg = load_package_json(project_root)
-    if not pkg:
-        skip("No package.json found — dependency analysis requires a Node.js project")
-        sys.exit(0)
-
-    issues = 0
-
-    # Extract imports from source code
-    used_imports = extract_imports(project_root)
-    print(f"\n  Found {len(used_imports)} unique external imports in source code")
-
-    # Phantom imports (imported but not in package.json)
-    if not args.check_unused:
-        header("Phantom Imports (not in package.json)")
-        phantom = check_phantom(pkg, used_imports)
-        if phantom:
-            for p in phantom:
-                fail(f"'{p}' is imported but not in package.json — possible hallucination")
-            issues += len(phantom)
-        else:
-            ok("All imports found in package.json")
-
-    # Unused dependencies
-    header("Unused Dependencies")
-    unused = check_unused(pkg, used_imports)
-    if unused:
-        for u in unused:
-            warn(f"'{u}' is in package.json but never imported — may be unused")
-    else:
-        ok("No obviously unused dependencies found")
-
-    # npm audit
-    if args.audit:
-        header("Vulnerability Audit")
-        if not run_npm_audit(project_root):
-            issues += 1
-
-    # Summary
-    print(f"\n{BOLD}━━━ Dependency Analysis Summary ━━━{RESET}")
-    if issues == 0:
-        ok("All dependency checks passed")
-    else:
-        fail(f"{issues} issue(s) found — review above")
-
-    sys.exit(1 if issues > 0 else 0)
-
-
-if __name__ == "__main__":
-    main()

package/.agent/scripts/lint_runner.py

@@ -1,188 +0,0 @@
-#!/usr/bin/env python3
-"""
-lint_runner.py — Standalone lint runner for the Tribunal Agent Kit.
-
-Detects and runs available linters in the project:
-  - ESLint (JS/TS)
-  - Prettier (formatting)
-  - Ruff / Flake8 (Python)
-
-Usage:
-  python .agent/scripts/lint_runner.py .
-  python .agent/scripts/lint_runner.py . --fix
-  python .agent/scripts/lint_runner.py . --files src/index.ts src/utils.ts
-"""
-
-import os
-import sys
-import subprocess
-import argparse
-from pathlib import Path
-
-RED = "\033[91m"
-GREEN = "\033[92m"
-YELLOW = "\033[93m"
-BLUE = "\033[94m"
-BOLD = "\033[1m"
-RESET = "\033[0m"
-
-
-def header(title: str) -> None:
-    print(f"\n{BOLD}{BLUE}━━━ {title} ━━━{RESET}")
-
-
-def ok(msg: str) -> None:
-    print(f"  {GREEN}✅ {msg}{RESET}")
-
-
-def fail(msg: str) -> None:
-    print(f"  {RED}❌ {msg}{RESET}")
-
-
-def skip(msg: str) -> None:
-    print(f"  {YELLOW}⏭️  {msg}{RESET}")
-
-
-def run_linter(label: str, cmd: list[str], cwd: str) -> bool:
-    """Run a linter command and return True if it passes."""
-    try:
-        result = subprocess.run(
-            cmd, cwd=cwd, capture_output=True, text=True, timeout=120
-        )
-        if result.returncode == 0:
-            ok(f"{label} — clean")
-            return True
-        fail(f"{label} — issues found")
-        output = (result.stdout + result.stderr).strip()
-        if output:
-            for line in output.split("\n")[:15]:
-                print(f"    {line}")
-            total_lines = len(output.split("\n"))
-            if total_lines > 15:
-                print(f"    ... and {total_lines - 15} more lines")
-        return False
-    except FileNotFoundError:
-        skip(f"{label} — tool not installed")
-        return True
-    except subprocess.TimeoutExpired:
-        fail(f"{label} — timed out after 120s")
-        return False
-
-
-def detect_linters(project_root: str) -> dict[str, bool]:
-    """Detect which linters are available in the project."""
-    root = Path(project_root)
-    available: dict[str, bool] = {}
-
-    # JS/TS linters
-    pkg_json = root / "package.json"
-    if pkg_json.exists():
-        available["eslint"] = any(
-            (root / f).exists()
-            for f in [".eslintrc", ".eslintrc.js", ".eslintrc.json", ".eslintrc.yml", "eslint.config.js", "eslint.config.mjs"]
-        ) or pkg_json.exists()  # ESLint can be configured in package.json too
-        available["prettier"] = any(
-            (root / f).exists()
-            for f in [".prettierrc", ".prettierrc.js", ".prettierrc.json", "prettier.config.js"]
-        )
-
-    # Python linters
-    available["ruff"] = (root / "pyproject.toml").exists() or (root / "ruff.toml").exists()
-    available["flake8"] = (root / ".flake8").exists() or (root / "setup.cfg").exists()
-
-    return available
-
-
-def main() -> None:
-    parser = argparse.ArgumentParser(
-        description="Tribunal lint runner — detects and runs available linters"
-    )
-    parser.add_argument("path", help="Project root directory")
-    parser.add_argument("--fix", action="store_true", help="Auto-fix issues where supported")
-    parser.add_argument("--files", nargs="*", help="Specific files to lint (instead of entire project)")
-    args = parser.parse_args()
-
-    project_root = os.path.abspath(args.path)
-    if not os.path.isdir(project_root):
-        fail(f"Directory not found: {project_root}")
-        sys.exit(1)
-
-    print(f"{BOLD}Tribunal — lint_runner.py{RESET}")
-    print(f"Project: {project_root}")
-
-    available = detect_linters(project_root)
-    if not any(available.values()):
-        skip("No linter configuration detected in this project")
-        sys.exit(0)
-
-    failures = 0
-    file_args = args.files or []
-
-    # ESLint
-    if available.get("eslint"):
-        header("ESLint")
-        cmd = ["npx", "eslint"]
-        if args.fix:
-            cmd.append("--fix")
-        if file_args:
-            cmd.extend(file_args)
-        else:
-            cmd.extend([".", "--max-warnings=0"])
-        if not run_linter("ESLint", cmd, project_root):
-            failures += 1
-
-    # Prettier
-    if available.get("prettier"):
-        header("Prettier")
-        cmd = ["npx", "prettier"]
-        if args.fix:
-            cmd.extend(["--write", "."])
-        else:
-            cmd.extend(["--check", "."])
-        if file_args:
-            cmd = ["npx", "prettier", "--write" if args.fix else "--check"] + file_args
-        if not run_linter("Prettier", cmd, project_root):
-            failures += 1
-
-    # Ruff (Python)
-    if available.get("ruff"):
-        header("Ruff (Python)")
-        cmd = ["ruff", "check"]
-        if args.fix:
-            cmd.append("--fix")
-        if file_args:
-            cmd.extend(file_args)
-        else:
-            cmd.append(".")
-        if not run_linter("Ruff", cmd, project_root):
-            failures += 1
-
-    # Flake8 (Python fallback)
-    if available.get("flake8") and not available.get("ruff"):
-        header("Flake8 (Python)")
-        cmd = ["flake8"]
-        if file_args:
-            cmd.extend(file_args)
-        else:
-            cmd.append(".")
-        if not run_linter("Flake8", cmd, project_root):
-            failures += 1
-
-    # TypeScript type check (always run if package.json exists)
-    if Path(project_root, "package.json").exists():
-        header("TypeScript")
-        if not run_linter("tsc --noEmit", ["npx", "tsc", "--noEmit"], project_root):
-            failures += 1
-
-    # Summary
-    print(f"\n{BOLD}━━━ Lint Summary ━━━{RESET}")
-    if failures == 0:
-        ok("All linters passed")
-    else:
-        fail(f"{failures} linter(s) reported issues")
-
-    sys.exit(1 if failures > 0 else 0)
-
-
-if __name__ == "__main__":
-    main()