flyee 0.1.0

package/core/scripts/checklist.py

@@ -0,0 +1,243 @@
+#!/usr/bin/env python3
+"""
+Master Checklist Runner - Antigravity Kit
+==========================================
+
+Orchestrates all validation scripts in priority order.
+Use this for incremental validation during development.
+
+Usage:
+    python scripts/checklist.py .                    # Run core checks
+    python scripts/checklist.py . --url <URL>        # Include performance checks
+
+Priority Order:
+    P0: Security Scan (vulnerabilities, secrets)
+    P1: Lint & Type Check (code quality)
+    P2: Schema Validation (if database exists)
+    P3: Test Runner (unit/integration tests)
+    P4: UX Audit (psychology laws, accessibility)
+    P5: SEO Check (meta tags, structure)
+    P6: Performance (lighthouse - requires URL)
+"""
+
+import sys
+import subprocess
+import argparse
+from pathlib import Path
+from typing import List, Tuple, Optional
+
+# ANSI colors for terminal output
+class Colors:
+    HEADER = '\033[95m'
+    BLUE = '\033[94m'
+    CYAN = '\033[96m'
+    GREEN = '\033[92m'
+    YELLOW = '\033[93m'
+    RED = '\033[91m'
+    ENDC = '\033[0m'
+    BOLD = '\033[1m'
+
+def print_header(text: str):
+    print(f"\n{Colors.BOLD}{Colors.CYAN}{'='*60}{Colors.ENDC}")
+    print(f"{Colors.BOLD}{Colors.CYAN}{text.center(60)}{Colors.ENDC}")
+    print(f"{Colors.BOLD}{Colors.CYAN}{'='*60}{Colors.ENDC}\n")
+
+def print_step(text: str):
+    print(f"{Colors.BOLD}{Colors.BLUE}🔄 {text}{Colors.ENDC}")
+
+def print_success(text: str):
+    print(f"{Colors.GREEN}✅ {text}{Colors.ENDC}")
+
+def print_warning(text: str):
+    print(f"{Colors.YELLOW}⚠️  {text}{Colors.ENDC}")
+
+def print_error(text: str):
+    print(f"{Colors.RED}❌ {text}{Colors.ENDC}")
+
+# Define priority-ordered checks (Core mandatory checks)
+CORE_CHECKS = [
+    ("Security Scan", ".agent/skills/vulnerability-scanner/scripts/security_scan.py", True),
+    ("Lint Check", ".agent/skills/lint-and-validate/scripts/lint_runner.py", True),
+]
+
+PERFORMANCE_CHECKS = [
+    ("Lighthouse Audit", ".agent/skills/performance-profiling/scripts/lighthouse_audit.py", True),
+    ("Playwright E2E", ".agent/skills/webapp-testing/scripts/playwright_runner.py", False),
+]
+
+def discover_skill_scripts(project_path: Path) -> List[Tuple[str, str, bool]]:
+    """Dynamically discover 'verify.py' scripts in skills"""
+    skill_scripts = []
+    skills_dir = project_path / ".agent/skills"
+    
+    if not skills_dir.exists():
+        return []
+        
+    for skill_path in skills_dir.iterdir():
+        if skill_path.is_dir():
+            verify_script = skill_path / "scripts/verify.py"
+            if verify_script.exists():
+                name = f"{skill_path.name.replace('-', ' ').title()} Verify"
+                # Relative path from project root
+                rel_path = f".agent/skills/{skill_path.name}/scripts/verify.py"
+                skill_scripts.append((name, rel_path, False))
+                
+    return sorted(skill_scripts)
+
+
+def check_script_exists(script_path: Path) -> bool:
+    """Check if script file exists"""
+    return script_path.exists() and script_path.is_file()
+
+def run_script(name: str, script_path: Path, project_path: str, url: Optional[str] = None) -> dict:
+    """
+    Run a validation script and capture results
+    
+    Returns:
+        dict with keys: name, passed, output, skipped
+    """
+    if not check_script_exists(script_path):
+        print_warning(f"{name}: Script not found, skipping")
+        return {"name": name, "passed": True, "output": "", "skipped": True}
+    
+    print_step(f"Running: {name}")
+    
+    # Build command
+    cmd = ["python", str(script_path), project_path]
+    if url and ("lighthouse" in script_path.name.lower() or "playwright" in script_path.name.lower()):
+        cmd.append(url)
+    
+    # Run script
+    try:
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            timeout=300  # 5 minute timeout
+        )
+        
+        passed = result.returncode == 0
+        
+        if passed:
+            print_success(f"{name}: PASSED")
+        else:
+            print_error(f"{name}: FAILED")
+            if result.stderr:
+                print(f"  Error: {result.stderr[:200]}")
+        
+        return {
+            "name": name,
+            "passed": passed,
+            "output": result.stdout,
+            "error": result.stderr,
+            "skipped": False
+        }
+    
+    except subprocess.TimeoutExpired:
+        print_error(f"{name}: TIMEOUT (>5 minutes)")
+        return {"name": name, "passed": False, "output": "", "error": "Timeout", "skipped": False}
+    
+    except Exception as e:
+        print_error(f"{name}: ERROR - {str(e)}")
+        return {"name": name, "passed": False, "output": "", "error": str(e), "skipped": False}
+
+def print_summary(results: List[dict]):
+    """Print final summary report"""
+    print_header("📊 CHECKLIST SUMMARY")
+    
+    passed_count = sum(1 for r in results if r["passed"] and not r.get("skipped"))
+    failed_count = sum(1 for r in results if not r["passed"] and not r.get("skipped"))
+    skipped_count = sum(1 for r in results if r.get("skipped"))
+    
+    print(f"Total Checks: {len(results)}")
+    print(f"{Colors.GREEN}✅ Passed: {passed_count}{Colors.ENDC}")
+    print(f"{Colors.RED}❌ Failed: {failed_count}{Colors.ENDC}")
+    print(f"{Colors.YELLOW}⏭️  Skipped: {skipped_count}{Colors.ENDC}")
+    print()
+    
+    # Detailed results
+    for r in results:
+        if r.get("skipped"):
+            status = f"{Colors.YELLOW}⏭️ {Colors.ENDC}"
+        elif r["passed"]:
+            status = f"{Colors.GREEN}✅{Colors.ENDC}"
+        else:
+            status = f"{Colors.RED}❌{Colors.ENDC}"
+        
+        print(f"{status} {r['name']}")
+    
+    print()
+    
+    if failed_count > 0:
+        print_error(f"{failed_count} check(s) FAILED - Please fix before proceeding")
+        return False
+    else:
+        print_success("All checks PASSED ✨")
+        return True
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Run Antigravity Kit validation checklist",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  python scripts/checklist.py .                      # Core checks only
+  python scripts/checklist.py . --url http://localhost:3000  # Include performance
+        """
+    )
+    parser.add_argument("project", help="Project path to validate")
+    parser.add_argument("--url", help="URL for performance checks (lighthouse, playwright)")
+    parser.add_argument("--skip-performance", action="store_true", help="Skip performance checks even if URL provided")
+    
+    args = parser.parse_args()
+    
+    project_path = Path(args.project).resolve()
+    
+    if not project_path.exists():
+        print_error(f"Project path does not exist: {project_path}")
+        sys.exit(1)
+    
+    print_header("🚀 ANTIGRAVITY KIT - MASTER CHECKLIST")
+    print(f"Project: {project_path}")
+    print(f"URL: {args.url if args.url else 'Not provided (performance checks skipped)'}")
+    
+    results = []
+    
+    # Run core checks (Priority 0 & 1)
+    print_header("📋 CORE CHECKS")
+    
+    # 1. Run Fixed Core Checks
+    all_checks = list(CORE_CHECKS)
+    
+    # 2. Discover Dynamic Skill Checks
+    dynamic_checks = discover_skill_scripts(project_path)
+    if dynamic_checks:
+        print(f"🔎 Discovered {len(dynamic_checks)} skill verification scripts...")
+        all_checks.extend(dynamic_checks)
+    
+    for name, script_path, required in all_checks:
+        script = project_path / script_path
+        result = run_script(name, script, str(project_path))
+        results.append(result)
+        
+        # If required check fails, stop
+        if required and not result["passed"] and not result.get("skipped"):
+            print_error(f"CRITICAL: {name} failed. Stopping checklist.")
+            print_summary(results)
+            sys.exit(1)
+    
+    # Run performance checks if URL provided
+    if args.url and not args.skip_performance:
+        print_header("⚡ PERFORMANCE CHECKS")
+        for name, script_path, required in PERFORMANCE_CHECKS:
+            script = project_path / script_path
+            result = run_script(name, script, str(project_path), args.url)
+            results.append(result)
+    
+    # Print summary
+    all_passed = print_summary(results)
+    
+    sys.exit(0 if all_passed else 1)
+
+if __name__ == "__main__":
+    main()

package/core/scripts/cost_report.py

@@ -0,0 +1,149 @@
+#!/usr/bin/env python3
+"""
+@flyee Cost Report Generator
+
+Reads .flyee/cost-log.jsonl and generates a summary report.
+
+Usage:
+    python3 cost_report.py                    # Full report
+    python3 cost_report.py --sprint S09       # Sprint-specific
+    python3 cost_report.py --json             # JSON output
+"""
+
+import json
+import sys
+import os
+from collections import defaultdict
+from datetime import datetime
+
+
+def load_cost_log(path=".flyee/cost-log.jsonl"):
+    """Load cost log entries from JSONL file."""
+    if not os.path.exists(path):
+        return []
+    
+    entries = []
+    with open(path, "r") as f:
+        for line in f:
+            line = line.strip()
+            if line:
+                try:
+                    entries.append(json.loads(line))
+                except json.JSONDecodeError:
+                    continue
+    return entries
+
+
+def filter_entries(entries, sprint=None):
+    """Filter entries by sprint if specified."""
+    if sprint:
+        return [e for e in entries if e.get("sprint") == sprint]
+    return entries
+
+
+def generate_report(entries):
+    """Generate cost report from entries."""
+    if not entries:
+        return {"total_cost": 0, "total_ops": 0, "phases": {}, "tasks": {}}
+
+    total_cost = sum(e.get("cost_usd", 0) for e in entries)
+    total_tokens_in = sum(e.get("tokens_in", 0) for e in entries)
+    total_tokens_out = sum(e.get("tokens_out", 0) for e in entries)
+    total_duration = sum(e.get("duration_ms", 0) for e in entries)
+
+    # Group by phase
+    by_phase = defaultdict(lambda: {"cost": 0, "ops": 0, "tasks": set()})
+    for e in entries:
+        phase = e.get("phase", "unknown")
+        by_phase[phase]["cost"] += e.get("cost_usd", 0)
+        by_phase[phase]["ops"] += 1
+        by_phase[phase]["tasks"].add(e.get("task", ""))
+
+    # Group by task
+    by_task = defaultdict(lambda: {"cost": 0, "ops": 0})
+    for e in entries:
+        task = f"{e.get('phase', '?')}/{e.get('task', '?')}"
+        by_task[task]["cost"] += e.get("cost_usd", 0)
+        by_task[task]["ops"] += 1
+
+    # Most expensive tasks
+    expensive = sorted(by_task.items(), key=lambda x: x[1]["cost"], reverse=True)[:5]
+
+    return {
+        "total_cost": total_cost,
+        "total_ops": len(entries),
+        "total_tokens_in": total_tokens_in,
+        "total_tokens_out": total_tokens_out,
+        "total_duration_ms": total_duration,
+        "phases": {k: {"cost": v["cost"], "ops": v["ops"], "tasks": len(v["tasks"])} 
+                   for k, v in by_phase.items()},
+        "most_expensive": [{"task": t, "cost": v["cost"], "ops": v["ops"]} 
+                          for t, v in expensive],
+    }
+
+
+def print_report(report, sprint=None):
+    """Print formatted cost report."""
+    title = f"@flyee Cost Report"
+    if sprint:
+        title += f" — {sprint}"
+
+    print(f"\n{'═' * 50}")
+    print(f"  {title}")
+    print(f"{'═' * 50}\n")
+
+    total = report["total_cost"]
+    ops = report["total_ops"]
+    ti = report.get("total_tokens_in", 0)
+    to = report.get("total_tokens_out", 0)
+
+    print(f"  Total: ${total:.2f}")
+    print(f"  Operations: {ops}")
+    print(f"  Tokens: {ti//1000}K in / {to//1000}K out")
+    print()
+
+    if report["phases"]:
+        print("  Phase breakdown:")
+        print(f"  {'─' * 46}")
+        print(f"  {'Phase':<15} {'Cost':>8} {'Tasks':>6} {'Avg/Task':>10}")
+        print(f"  {'─' * 46}")
+        for phase, data in sorted(report["phases"].items()):
+            avg = data["cost"] / data["tasks"] if data["tasks"] > 0 else 0
+            pct = (data["cost"] / total * 100) if total > 0 else 0
+            print(f"  {phase:<15} ${data['cost']:>6.2f} {data['tasks']:>6} ${avg:>8.2f}")
+        print(f"  {'─' * 46}")
+        print()
+
+    if report["most_expensive"]:
+        print("  Most expensive tasks:")
+        for i, item in enumerate(report["most_expensive"], 1):
+            pct = (item["cost"] / total * 100) if total > 0 else 0
+            print(f"  {i}. {item['task']:<20} ${item['cost']:.2f} ({pct:.0f}%)")
+    
+    print(f"\n{'═' * 50}\n")
+
+
+def main():
+    sprint = None
+    json_output = False
+
+    for arg in sys.argv[1:]:
+        if arg == "--json":
+            json_output = True
+        elif arg.startswith("--sprint"):
+            idx = sys.argv.index(arg)
+            if idx + 1 < len(sys.argv):
+                sprint = sys.argv[idx + 1]
+
+    entries = load_cost_log()
+    filtered = filter_entries(entries, sprint)
+    report = generate_report(filtered)
+
+    if json_output:
+        print(json.dumps(report, indent=2))
+    else:
+        print_report(report, sprint)
+
+
+if __name__ == "__main__":
+    main()