@paulojalowyj/openkit 0.1.1

package/.opencode/scripts/auto_preview.py

@@ -0,0 +1,100 @@
+#!/usr/bin/env python3
+"""
+Auto Preview - OpenKit
+==============================
+Manages (start/stop/status) the local development environment using Docker Compose.
+
+Usage:
+    python .opencode/scripts/auto_preview.py start
+    python .opencode/scripts/auto_preview.py stop
+    python .opencode/scripts/auto_preview.py status
+"""
+
+import argparse
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+
+def get_project_root():
+    return Path(".").resolve()
+
+
+def get_docker_compose_file(root):
+    # Prefer dev config
+    dev_config = root / "docker-compose.dev.yml"
+    if dev_config.exists():
+        return "docker-compose.dev.yml"
+
+    # Fallback to standard
+    std_config = root / "docker-compose.yml"
+    if std_config.exists():
+        return "docker-compose.yml"
+
+    return None
+
+
+def run_docker_command(cmd_args, root_path):
+    compose_file = get_docker_compose_file(root_path)
+    if not compose_file:
+        print(" No docker-compose.dev.yml or docker-compose.yml found in root.")
+        sys.exit(1)
+
+    base_cmd = ["docker", "compose", "-f", compose_file]
+    full_cmd = base_cmd + cmd_args
+
+    try:
+        subprocess.run(full_cmd, cwd=str(root_path), check=True)
+    except subprocess.CalledProcessError as e:
+        print(f" Docker command failed: {e}")
+        sys.exit(1)
+    except FileNotFoundError:
+        print(" Docker not found. Please verify it is installed and in your PATH.")
+        sys.exit(1)
+
+
+def start_server():
+    root = get_project_root()
+    print(" Starting development environment (detached)...")
+    # Up detached
+    run_docker_command(["up", "-d"], root)
+    print(" Environment started.")
+    print(" Frontend: http://localhost:5173 (likely)")
+    print(" Backend:  http://localhost:8000 (likely)")
+
+
+def stop_server():
+    root = get_project_root()
+    print(" Stopping development environment...")
+    run_docker_command(["stop"], root)  # Just stop, don't remove containers usually
+    print(" Environment stopped.")
+
+
+def status_server():
+    root = get_project_root()
+    print("\n=== Docker Compose Status ===")
+    run_docker_command(["ps"], root)
+    print("=============================\n")
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("action", choices=["start", "stop", "status"])
+    # Port argument is ignored in Docker mode as ports are defined in compose
+    parser.add_argument(
+        "port", nargs="?", default="3000", help="Ignored in Docker mode"
+    )
+
+    args = parser.parse_args()
+
+    if args.action == "start":
+        start_server()
+    elif args.action == "stop":
+        stop_server()
+    elif args.action == "status":
+        status_server()
+
+
+if __name__ == "__main__":
+    main()

package/.opencode/scripts/checklist.py

@@ -0,0 +1,217 @@
+#!/usr/bin/env python3
+"""
+Master Checklist Runner - OpenKit
+==========================================
+
+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", ".opencode/skills/vulnerability-scanner/scripts/security_scan.py", True),
+    ("Lint Check", ".opencode/skills/lint-and-validate/scripts/lint_runner.py", True),
+    ("Schema Validation", ".opencode/skills/database-design/scripts/schema_validator.py", False),
+    ("Test Runner", ".opencode/skills/testing-patterns/scripts/test_runner.py", False),
+    ("UX Audit", ".opencode/skills/frontend-design/scripts/ux_audit.py", False),
+    ("SEO Check", ".opencode/skills/seo-fundamentals/scripts/seo_checker.py", False),
+]
+
+PERFORMANCE_CHECKS = [
+    ("Lighthouse Audit", ".opencode/skills/performance-profiling/scripts/lighthouse_audit.py", True),
+    ("Playwright E2E", ".opencode/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 = [sys.executable, 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 OpenKit 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(" OPENKIT - 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/.opencode/scripts/session_manager.py

@@ -0,0 +1,225 @@
+#!/usr/bin/env python3
+"""
+Session Manager - OpenKit
+=================================
+Analyzes project state, detects tech stack, tracks file statistics, and provides
+a summary of the current session.
+
+Usage:
+    python .opencode/scripts/session_manager.py status [path]
+    python .opencode/scripts/session_manager.py info [path]
+"""
+
+import argparse
+import json
+import os
+from pathlib import Path
+from typing import Any, Dict, List
+
+
+def get_project_root(path: str) -> Path:
+    return Path(path).resolve()
+
+
+# Since I cannot easily add dependencies, I will use a simple efficient line parser for toml/json if needed,
+# but for robust python parsing, let's assume standard checks or simple text parsing if toml lib is missing.
+# Actually, let's keep it simple and robust with standard library.
+
+
+def analyze_package_json(path: Path) -> Dict[str, Any]:
+    if not path.exists():
+        return {}
+
+    try:
+        with open(path, "r", encoding="utf-8") as f:
+            data = json.load(f)
+
+        deps = data.get("dependencies", {})
+        dev_deps = data.get("devDependencies", {})
+        all_deps = {**deps, **dev_deps}
+
+        stack = []
+        if "next" in all_deps:
+            stack.append("Next.js")
+        elif "react" in all_deps and "vite" in all_deps:
+            stack.append("React (Vite)")
+        elif "react" in all_deps:
+            stack.append("React")
+        elif "vue" in all_deps:
+            stack.append("Vue")
+        elif "svelte" in all_deps:
+            stack.append("Svelte")
+        elif "express" in all_deps:
+            stack.append("Express")
+        elif "nestjs" in all_deps or "@nestjs/core" in all_deps:
+            stack.append("NestJS")
+
+        if "tailwindcss" in all_deps:
+            stack.append("Tailwind CSS")
+        if "prisma" in all_deps:
+            stack.append("Prisma")
+        if "typescript" in all_deps:
+            stack.append("TypeScript")
+        if "@tanstack/react-query" in all_deps:
+            stack.append("TanStack Query")
+
+        return {
+            "name": data.get("name", "unnamed"),
+            "version": data.get("version", "0.0.0"),
+            "stack": stack,
+        }
+    except Exception as e:
+        return {"error": str(e)}
+
+
+def analyze_pyproject_toml(path: Path) -> Dict[str, Any]:
+    if not path.exists():
+        return {}
+
+    try:
+        with open(path, "r", encoding="utf-8") as f:
+            content = f.read()
+
+        stack = []
+        if "fastapi" in content:
+            stack.append("FastAPI")
+        if "flask" in content:
+            stack.append("Flask")
+        if "django" in content:
+            stack.append("Django")
+
+        if "sqlalchemy" in content:
+            stack.append("SQLAlchemy")
+        if "psycopg" in content or "psycopg2" in content:
+            stack.append("PostgreSQL")
+        if "redis" in content:
+            stack.append("Redis")
+        if "celery" in content:
+            stack.append("Celery")
+        if "alembic" in content:
+            stack.append("Alembic")
+        if "pydantic" in content:
+            stack.append("Pydantic")
+
+        return {"stack": stack}
+    except Exception as e:
+        return {"error": str(e)}
+
+
+def get_full_project_info(root: Path) -> Dict[str, Any]:
+    info = {"name": root.name, "path": str(root), "stack": [], "modules": []}
+
+    # Check Frontend
+    fe_pkg = root / "frontend/package.json"
+    if fe_pkg.exists():
+        fe_info = analyze_package_json(fe_pkg)
+        info["stack"].extend(fe_info.get("stack", []))
+    else:
+        # Fallback to root package.json
+        root_pkg = root / "package.json"
+        if root_pkg.exists():
+            root_info = analyze_package_json(root_pkg)
+            info["stack"].extend(root_info.get("stack", []))
+
+    # Check Backend
+    be_toml = root / "backend/pyproject.toml"
+    if be_toml.exists():
+        be_info = analyze_pyproject_toml(be_toml)
+        info["stack"].extend(be_info.get("stack", []))
+
+    # Remove duplicates and sort
+    info["stack"] = sorted(list(set(info["stack"])))
+
+    return info
+
+
+def count_files(root: Path) -> Dict[str, Any]:
+    stats = {"created": 0, "modified": 0, "total": 0}
+    # Simple count for now, comprehensive tracking would require git diff or extensive history
+    exclude = {
+        ".git",
+        "node_modules",
+        ".next",
+        "dist",
+        "build",
+        ".agent",
+        "__pycache__",
+    }
+
+    for root_dir, dirs, files in os.walk(root):
+        dirs[:] = [d for d in dirs if d not in exclude]
+        stats["total"] += len(files)
+
+    return stats
+
+
+def detect_features(root: Path) -> List[str]:
+    # Heuristic: look at folder names in src/ or feature directories
+    features = []
+
+    # Check frontend src
+    src = root / "frontend/src"
+    if src.exists():
+        possible_dirs = ["components", "modules", "features", "app", "pages"]
+        for d in possible_dirs:
+            p = src / d
+            if p.exists() and p.is_dir():
+                for child in p.iterdir():
+                    if child.is_dir():
+                        features.append(f"fe:{child.name}")
+
+    # Check backend app
+    app = root / "backend/app"
+    if app.exists():
+        # Check for modular structure if exists, typically routers or modules
+        for child in app.iterdir():
+            if child.is_dir() and child.name not in ["__pycache__", "core", "tests"]:
+                features.append(f"be:{child.name}")
+
+    return features[:15]  # Limit
+
+
+def print_status(root: Path):
+    info = get_full_project_info(root)
+    stats = count_files(root)
+    features = detect_features(root)
+
+    print("\n=== Project Status ===")
+    print(f"\n Project: {info['name']}")
+    print(f" Path: {info['path']}")
+    print("  Type: Full Stack")
+    print(" Status: Active")
+
+    print("\n Tech Stack:")
+    if info["stack"]:
+        for tech in info["stack"]:
+            print(f"   • {tech}")
+    else:
+        print("   (No specific stack detected)")
+
+    print(f"\n Detected Modules/Features ({len(features)}):")
+    for feat in features:
+        print(f"   • {feat}")
+    if not features:
+        print("   (No distinct feature modules detected)")
+
+    print(f"\n Files: {stats['total']} total files tracked")
+    print("\n====================\n")
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Session Manager")
+    parser.add_argument("command", choices=["status", "info"], help="Command to run")
+    parser.add_argument("path", nargs="?", default=".", help="Project path")
+
+    args = parser.parse_args()
+    root = get_project_root(args.path)
+
+    if args.command == "status":
+        print_status(root)
+    elif args.command == "info":
+        print(json.dumps(get_full_project_info(root), indent=2))
+
+
+if __name__ == "__main__":
+    main()