thachvd-kit 1.0.0

package/scripts/checklist.py

@@ -0,0 +1,217 @@
+#!/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_CHECKS = [
+    ("Security Scan", ".agent/skills/vulnerability-scanner/scripts/security_scan.py", True),
+    ("Lint Check", ".agent/skills/lint-and-validate/scripts/lint_runner.py", True),
+    ("Schema Validation", ".agent/skills/database-design/scripts/schema_validator.py", False),
+    ("Test Runner", ".agent/skills/testing-patterns/scripts/test_runner.py", False),
+    ("UX Audit", ".agent/skills/frontend-design/scripts/ux_audit.py", False),
+    ("SEO Check", ".agent/skills/seo-fundamentals/scripts/seo_checker.py", False),
+]
+
+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 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
+    print_header("📋 CORE CHECKS")
+    for name, script_path, required in CORE_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/scripts/init.py

@@ -0,0 +1,403 @@
+#!/usr/bin/env python3
+"""
+thachvd-kit — Project Init Wizard
+Generates PROJECT_CONTEXT.md and optional platform config files.
+
+Usage:
+    python scripts/init.py                    # Interactive wizard
+    python scripts/init.py --platform all    # Also generate CLAUDE.md
+    python scripts/init.py --platform claude  # Only CLAUDE.md
+"""
+
+import sys
+import os
+import argparse
+from pathlib import Path
+from datetime import datetime
+
+# ─── Color helpers ──────────────────────────────────────────────────────────
+
+def c(text, code): return f"\033[{code}m{text}\033[0m" if sys.stdout.isatty() else text
+def bold(t): return c(t, "1")
+def green(t): return c(t, "32")
+def cyan(t): return c(t, "36")
+def yellow(t): return c(t, "33")
+def dim(t): return c(t, "2")
+
+# ─── Input helpers ───────────────────────────────────────────────────────────
+
+def ask(prompt, default="", choices=None):
+    """Prompt user for input with optional default and choices."""
+    display_default = f" [{dim(default)}]" if default else ""
+    if choices:
+        print(f"\n  {cyan('Options:')} {', '.join(choices)}")
+    value = input(f"  {bold('→')} {prompt}{display_default}: ").strip()
+    return value if value else default
+
+def ask_multi(prompt, choices, default=None):
+    """Prompt for comma-separated selection from choices."""
+    print(f"\n  {cyan('Available:')} {', '.join(f'{i+1}) {c}' for i, c in enumerate(choices))}")
+    raw = input(f"  {bold('→')} {prompt} (numbers or names, comma-separated) [{dim(default or 'none')}]: ").strip()
+    if not raw:
+        return default or []
+    selected = []
+    for part in raw.replace(",", " ").split():
+        part = part.strip()
+        if part.isdigit():
+            idx = int(part) - 1
+            if 0 <= idx < len(choices):
+                selected.append(choices[idx])
+        elif part in choices:
+            selected.append(part)
+        else:
+            selected.append(part)  # allow free-text
+    return selected
+
+def ask_bool(prompt, default=True):
+    """Yes/no prompt."""
+    default_str = "Y/n" if default else "y/N"
+    val = input(f"  {bold('→')} {prompt} [{dim(default_str)}]: ").strip().lower()
+    if not val:
+        return default
+    return val.startswith("y")
+
+def section(title):
+    print(f"\n{bold(cyan('━━ ' + title + ' '))}")
+
+# ─── Skill resolver ──────────────────────────────────────────────────────────
+
+LANG_SKILLS = {
+    "typescript": ["nodejs-best-practices", "api-design"],
+    "javascript": ["nodejs-best-practices", "api-design"],
+    "python":     ["python-patterns"],
+    "go":         ["golang-patterns", "golang-testing"],
+    "php":        ["laravel-patterns", "laravel-security", "laravel-tdd"],
+    "rust":       ["rust-pro"],
+    "java":       ["api-design"],
+    "swift":      ["mobile-design"],
+    "kotlin":     ["mobile-design"],
+    "csharp":     ["api-design"],
+}
+
+FRAMEWORK_SKILLS = {
+    "vue":           ["frontend-design", "tailwind-patterns"],
+    "react":         ["nextjs-react-expert", "frontend-design"],
+    "next":          ["nextjs-react-expert", "frontend-design"],
+    "nuxt":          ["frontend-design"],
+    "svelte":        ["frontend-design"],
+    "laravel":       ["laravel-patterns", "laravel-security", "laravel-tdd"],
+    "express":       ["nodejs-best-practices", "api-design"],
+    "fastapi":       ["python-patterns", "api-design"],
+    "django":        ["python-patterns", "api-design"],
+    "gin":           ["golang-patterns", "golang-testing"],
+    "fiber":         ["golang-patterns", "golang-testing"],
+    "tauri":         ["rust-pro", "mobile-design"],
+    "flutter":       ["mobile-design"],
+    "react-native":  ["mobile-design"],
+}
+
+INFRA_SKILLS = {
+    "docker": ["docker-patterns"],
+    "aws":    ["deployment-procedures", "docker-patterns"],
+    "gcp":    ["deployment-procedures", "docker-patterns"],
+    "azure":  ["deployment-procedures", "docker-patterns"],
+    "vercel": ["deployment-procedures"],
+}
+
+def resolve_skills(data):
+    skills = set()
+    lang = data.get("primary_language", "").lower()
+    if lang in LANG_SKILLS:
+        skills.update(LANG_SKILLS[lang])
+    for fw in data.get("frameworks", []):
+        fw_lower = fw.lower()
+        for key, vals in FRAMEWORK_SKILLS.items():
+            if key in fw_lower:
+                skills.update(vals)
+    for infra in data.get("infrastructure", []):
+        infra_lower = infra.lower()
+        for key, vals in INFRA_SKILLS.items():
+            if key in infra_lower:
+                skills.update(vals)
+    skills.update(["clean-code", "systematic-debugging"])
+    return sorted(skills)
+
+def resolve_agent_table(data):
+    rows = []
+    frameworks = [f.lower() for f in data.get("frameworks", [])]
+    lang = data.get("primary_language", "").lower()
+
+    # Determine frontend agent
+    frontend_fws = [f for f in frameworks if f in ["vue", "react", "next", "nuxt", "svelte", "angular"]]
+    if frontend_fws:
+        fe_skills = []
+        for fw in frontend_fws:
+            fe_skills.extend(FRAMEWORK_SKILLS.get(fw, []))
+        rows.append(("Frontend UI", "frontend-specialist", ", ".join(set(fe_skills[:3]))))
+
+    # Backend
+    be_skills = list(LANG_SKILLS.get(lang, ["api-design"]))
+    backend_fws = [f for f in frameworks if f in ["laravel", "express", "fastapi", "django", "gin", "fiber"]]
+    for fw in backend_fws:
+        be_skills.extend(FRAMEWORK_SKILLS.get(fw, []))
+    rows.append(("Backend API", "backend-specialist", ", ".join(set(be_skills[:3]))))
+
+    # Mobile/Desktop
+    mobile_fws = [f for f in frameworks if f in ["tauri", "flutter", "react-native"]]
+    if mobile_fws:
+        mobile_skills = []
+        for fw in mobile_fws:
+            mobile_skills.extend(FRAMEWORK_SKILLS.get(fw, []))
+        rows.append(("Mobile / Desktop", "mobile-developer", ", ".join(set(mobile_skills[:3]))))
+
+    # DevOps
+    if data.get("uses_docker") or data.get("cloud"):
+        rows.append(("DevOps / Infra", "devops-engineer", "docker-patterns, deployment-procedures"))
+
+    rows.append(("Debug", "debugger", "systematic-debugging"))
+    rows.append(("Security", "security-auditor", "vulnerability-scanner"))
+    rows.append(("Planning", "project-planner", "brainstorming, plan-writing"))
+    return rows
+
+# ─── Generators ──────────────────────────────────────────────────────────────
+
+def generate_project_context(data):
+    frameworks = data.get("frameworks", [])
+    infrastructure = data.get("infrastructure", [])
+    agent_table = resolve_agent_table(data)
+    auto_skills = resolve_skills(data)
+
+    agent_rows = "\n".join(
+        f"| {task} | `{agent}` | {skills} |"
+        for task, agent, skills in agent_table
+    )
+
+    return f"""# PROJECT_CONTEXT.md
+# Generated by thachvd-kit init wizard on {datetime.now().strftime('%Y-%m-%d')}
+# Edit freely — this is your project's brain.
+
+## Project
+
+- **Name:** {data['project_name']}
+- **Description:** {data['description']}
+- **Type:** {data['project_type']}
+
+---
+
+## Stack
+
+```yaml
+stack:
+  primary_language: {data['primary_language']}
+  frameworks: [{', '.join(frameworks)}]
+  database: {data.get('database', 'none')}
+  infrastructure: [{', '.join(infrastructure)}]
+  package_manager: {data.get('package_manager', 'auto-detect')}
+  test_framework: {data.get('test_framework', 'auto-detect')}
+```
+
+---
+
+## Agent Routing
+
+| Task Type | Agent | Primary Skills |
+|-----------|-------|----------------|
+{agent_rows}
+
+---
+
+## Auto-Resolved Skills
+
+Based on your stack, these skills will be loaded automatically:
+
+```
+{chr(10).join('- ' + s for s in auto_skills)}
+```
+
+---
+
+## Project Conventions
+
+- **Max file size:** {data.get('max_file_lines', '300')} lines (then modularize)
+- **Code style:** {data.get('code_style', 'project-standard')}
+
+---
+
+## Architecture Notes
+
+{data.get('architecture_notes', '<!-- Add architecture notes, key decisions, patterns used -->')}
+
+---
+
+## Current Phase
+
+- **Done:** {data.get('done_phases', '—')}
+- **In Progress:** {data.get('current_phase', 'Initial setup')}
+- **Next:** {data.get('next_phase', '—')}
+
+---
+
+## Known Issues / Tasks
+
+{data.get('known_issues', '<!-- Add known issues or pending tasks -->')}
+"""
+
+def generate_claude_md(data):
+    """Generate CLAUDE.md for Claude Code / Codex compatibility."""
+    return f"""# CLAUDE.md — {data['project_name']}
+# Generated by thachvd-kit. See PROJECT_CONTEXT.md for full stack info.
+# Cross-platform: Claude Code · Codex · OpenCode
+
+## Project
+{data['description']}
+Stack: {data['primary_language']} | {', '.join(data.get('frameworks', []))}
+
+## Rules
+- Read PROJECT_CONTEXT.md first for stack details and agent routing.
+- Follow skills in .claude/skills/ (or skills/ if using Antigravity).
+- Tests are mandatory. Verify before claiming done.
+- Max {data.get('max_file_lines', '300')} lines per file.
+
+## Key Skills
+- Plan: `plan-writing` → `executing-plans`
+- Review: `requesting-code-review` / `receiving-code-review`
+- Quality: `clean-code`, `verification-before-completion`
+- Workflow: `subagent-driven-development`, `finishing-a-development-branch`
+
+## Commands
+- `/plan` — Create implementation plan
+- `/debug` — Systematic debugging
+- `/test` — Run test suite
+- `/deploy` — Deploy checklist
+
+See PROJECT_CONTEXT.md for full agent routing table.
+"""
+
+# ─── Main wizard ─────────────────────────────────────────────────────────────
+
+def main():
+    parser = argparse.ArgumentParser(description="thachvd-kit project init wizard")
+    parser.add_argument("--platform", choices=["antigravity", "claude", "all"], default="antigravity",
+                        help="Which platform config to generate (default: antigravity)")
+    parser.add_argument("--yes", "-y", action="store_true", help="Use defaults without prompting")
+    args = parser.parse_args()
+
+    print(f"""
+{bold(cyan('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'))}
+  {bold('thachvd-kit')} — Project Init Wizard
+  Generates PROJECT_CONTEXT.md for smart agent routing
+{bold(cyan('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'))}
+""")
+
+    # Check if PROJECT_CONTEXT.md already exists
+    output_path = Path("PROJECT_CONTEXT.md")
+    if output_path.exists() and not args.yes:
+        overwrite = ask_bool(f"{yellow('PROJECT_CONTEXT.md already exists. Overwrite?')}", default=False)
+        if not overwrite:
+            print(f"\n  {yellow('Aborted.')} Existing PROJECT_CONTEXT.md unchanged.\n")
+            sys.exit(0)
+
+    data = {}
+
+    # ── Project Info ──────────────────────────────────────────────────────
+    section("Project Info")
+    data["project_name"] = ask("Project name", default=Path.cwd().name)
+    data["description"]  = ask("Short description", default="A software project")
+    data["project_type"] = ask("Project type",
+        default="web-app",
+        choices=["web-app", "api", "mobile", "desktop", "cli", "library", "fullstack"])
+
+    # ── Tech Stack ────────────────────────────────────────────────────────
+    section("Tech Stack")
+
+    LANGUAGES = ["typescript", "javascript", "python", "go", "php", "rust", "java", "swift", "kotlin", "csharp", "c", "cpp"]
+    data["primary_language"] = ask("Primary language",
+        default="typescript",
+        choices=LANGUAGES)
+
+    FRAMEWORKS = ["vue", "react", "next", "nuxt", "svelte", "angular",
+                  "laravel", "express", "fastapi", "django", "gin", "fiber", "nestjs",
+                  "tauri", "flutter", "react-native",
+                  "none"]
+    frameworks = ask_multi("Frameworks (select all that apply)", FRAMEWORKS, default=None)
+    data["frameworks"] = frameworks or []
+
+    DATABASES = ["postgres", "mysql", "sqlite", "mongodb", "redis", "dynamodb", "supabase", "prisma", "none"]
+    data["database"] = ask("Database / ORM", default="postgres", choices=DATABASES)
+
+    PACKAGE_MANAGERS = ["npm", "pnpm", "yarn", "bun", "pip", "uv", "poetry", "go mod", "cargo", "composer", "auto-detect"]
+    data["package_manager"] = ask("Package manager", default="auto-detect", choices=PACKAGE_MANAGERS)
+
+    # ── Infrastructure ────────────────────────────────────────────────────
+    section("Infrastructure")
+
+    data["uses_docker"] = ask_bool("Uses Docker / Docker Compose?", default=True)
+    CLOUDS = ["aws", "gcp", "azure", "vercel", "fly", "railway", "digitalocean", "none"]
+    cloud = ask("Cloud provider", default="none", choices=CLOUDS)
+    data["cloud"] = cloud
+
+    infrastructure = []
+    if data["uses_docker"]: infrastructure.append("docker")
+    if cloud != "none": infrastructure.append(cloud)
+    data["infrastructure"] = infrastructure
+
+    CI_CD = ["github-actions", "gitlab-ci", "circleci", "jenkins", "none"]
+    data["ci_cd"] = ask("CI/CD", default="github-actions", choices=CI_CD)
+
+    # ── Testing ───────────────────────────────────────────────────────────
+    section("Testing")
+
+    TEST_FRAMEWORKS = ["jest", "vitest", "pytest", "go test", "phpunit", "pest", "rspec", "junit", "auto-detect"]
+    data["test_framework"] = ask("Test framework", default="auto-detect", choices=TEST_FRAMEWORKS)
+
+    # ── Conventions ───────────────────────────────────────────────────────
+    section("Coding Conventions")
+
+    data["max_file_lines"] = ask("Max lines per file before splitting", default="300")
+    data["code_style"]     = ask("Code style / linter", default="project-standard",
+        choices=["eslint", "prettier", "ruff", "gofmt", "pint", "standard", "project-standard"])
+
+    # ── Optional fields ───────────────────────────────────────────────────
+    section("Architecture (Optional — press Enter to skip)")
+
+    data["architecture_notes"] = ask("Key architecture notes", default="<!-- Add notes -->")
+    data["current_phase"]      = ask("Current phase", default="Initial setup")
+    data["next_phase"]         = ask("Next planned phase", default="—")
+    data["known_issues"]       = ask("Known issues / tasks", default="<!-- None yet -->")
+
+    # ── Generate files ────────────────────────────────────────────────────
+    section("Generating Files")
+
+    # PROJECT_CONTEXT.md (always)
+    context_content = generate_project_context(data)
+    output_path.write_text(context_content, encoding="utf-8")
+    print(f"  {green('✓')} {bold('PROJECT_CONTEXT.md')} generated")
+
+    # CLAUDE.md (for Claude Code / Codex)
+    if args.platform in ("claude", "all"):
+        claude_path = Path("CLAUDE.md")
+        claude_path.write_text(generate_claude_md(data), encoding="utf-8")
+        print(f"  {green('✓')} {bold('CLAUDE.md')} generated (Claude Code / Codex)")
+
+    # Summary
+    auto_skills = resolve_skills(data)
+    print(f"""
+{bold(green('━━ Done! ━━'))}
+
+  {bold('Project:')} {data['project_name']}
+  {bold('Stack:')}   {data['primary_language']} | {', '.join(data['frameworks']) or 'no framework'}
+  {bold('Infra:')}   {', '.join(data['infrastructure']) or 'none'}
+
+  {bold('Auto-resolved skills:')}
+{chr(10).join(f'    · {s}' for s in auto_skills)}
+
+  {bold('Next steps:')}
+    1. Review {bold('PROJECT_CONTEXT.md')} and add architecture notes
+    2. Open project in your AI editor (Antigravity / Claude Code / Codex)
+    3. The agent will read PROJECT_CONTEXT.md on session start
+
+{dim('  Tip: Run with --platform all to also generate CLAUDE.md')}
+""")
+
+if __name__ == "__main__":
+    main()