@hustle-together/api-dev-tools 3.12.16 → 4.5.3

package/.claude/hooks/check-api-routes.py

@@ -1,168 +0,0 @@
-#!/usr/bin/env python3
-"""
-Hook: check-api-routes.py
-Trigger: PreToolUse (Write|Edit)
-Purpose: Verify required API routes exist before page implementation
-
-For ui-create-page workflow, ensures Phase 7 (ENVIRONMENT) has verified
-that required API routes are available.
-"""
-
-import json
-import sys
-import os
-import glob
-
-def load_state():
-    """Load the api-dev-state.json file"""
-    state_paths = [
-        ".claude/api-dev-state.json",
-        os.path.join(os.environ.get("CLAUDE_PROJECT_DIR", ""), ".claude/api-dev-state.json")
-    ]
-
-    for path in state_paths:
-        if os.path.exists(path):
-            with open(path, 'r') as f:
-                return json.load(f)
-    return None
-
-def is_page_workflow(state):
-    """Check if current workflow is ui-create-page"""
-    workflow = state.get("workflow", "")
-    return workflow == "ui-create-page"
-
-def get_active_element(state):
-    """Get the active element being worked on"""
-    active = state.get("active_element", "")
-    if not active:
-        active = state.get("endpoint", "")
-    return active
-
-def is_page_implementation(file_path, element_name):
-    """Check if the file is a page implementation file"""
-    if not file_path or not element_name:
-        return False
-
-    patterns = [
-        f"src/app/{element_name}/page.tsx",
-        f"app/{element_name}/page.tsx",
-    ]
-
-    return any(pattern in file_path for pattern in patterns)
-
-def check_environment_phase(state, element_name):
-    """Check if environment phase is complete"""
-    elements = state.get("elements", {})
-    element = elements.get(element_name, {})
-    phases = element.get("phases", {})
-
-    environment = phases.get("environment_check", {})
-    return environment.get("status") == "complete"
-
-def get_required_api_routes(state, element_name):
-    """Get list of required API routes from interview decisions"""
-    elements = state.get("elements", {})
-    element = elements.get(element_name, {})
-    ui_config = element.get("ui_config", {})
-
-    # Check if data sources were defined
-    data_sources = ui_config.get("data_sources", [])
-    return data_sources
-
-def find_existing_api_routes():
-    """Find all existing API routes in the project"""
-    routes = []
-
-    # Check src/app/api paths
-    api_patterns = [
-        "src/app/api/**/*.ts",
-        "src/app/api/**/*.tsx",
-        "app/api/**/*.ts",
-        "app/api/**/*.tsx",
-    ]
-
-    for pattern in api_patterns:
-        for file_path in glob.glob(pattern, recursive=True):
-            if "route.ts" in file_path or "route.tsx" in file_path:
-                # Extract route name from path
-                route = file_path.replace("src/app/api/", "/api/")
-                route = route.replace("app/api/", "/api/")
-                route = route.replace("/route.ts", "")
-                route = route.replace("/route.tsx", "")
-                routes.append(route)
-
-    return routes
-
-def main():
-    try:
-        # Read tool input from stdin
-        input_data = json.loads(sys.stdin.read())
-        tool_name = input_data.get("tool_name", "")
-        tool_input = input_data.get("tool_input", {})
-
-        # Only check Write tool
-        if tool_name != "Write":
-            print(json.dumps({"decision": "allow"}))
-            return
-
-        file_path = tool_input.get("file_path", "")
-
-        # Load state
-        state = load_state()
-        if not state:
-            print(json.dumps({"decision": "allow"}))
-            return
-
-        # Only apply to ui-create-page workflow
-        if not is_page_workflow(state):
-            print(json.dumps({"decision": "allow"}))
-            return
-
-        element_name = get_active_element(state)
-        if not element_name:
-            print(json.dumps({"decision": "allow"}))
-            return
-
-        # Check if writing main page file
-        if is_page_implementation(file_path, element_name):
-            # Verify environment phase is complete
-            if not check_environment_phase(state, element_name):
-                # Find existing API routes for reference
-                existing_routes = find_existing_api_routes()
-                routes_list = "\n".join([f"  - {r}" for r in existing_routes[:15]])
-                if len(existing_routes) > 15:
-                    routes_list += f"\n  ... and {len(existing_routes) - 15} more"
-
-                print(json.dumps({
-                    "decision": "block",
-                    "reason": f"""
-ENVIRONMENT CHECK REQUIRED (Phase 7)
-
-You are implementing the main page, but the Environment phase is not complete.
-
-Before implementing page.tsx:
-1. Verify required API routes exist
-2. Check authentication configuration
-3. Verify required packages are installed
-4. Update state: phases.environment_check.status = "complete"
-
-Existing API Routes Found:
-{routes_list if existing_routes else "  (No API routes found)"}
-
-If you need new API routes, use /api-create to create them first.
-"""
-                }))
-                return
-
-        # Allow everything else
-        print(json.dumps({"decision": "allow"}))
-
-    except Exception as e:
-        # On error, allow to avoid blocking workflow
-        print(json.dumps({
-            "decision": "allow",
-            "error": str(e)
-        }))
-
-if __name__ == "__main__":
-    main()

package/.claude/hooks/check-playwright-setup.py

@@ -1,103 +0,0 @@
-#!/usr/bin/env python3
-"""
-Hook: PreToolUse for Write
-Purpose: Verify Playwright is configured before writing E2E test files
-
-This hook runs before writing E2E test files. It checks that:
-- playwright.config.ts or playwright.config.js exists
-- @playwright/test is in package.json dependencies
-
-If Playwright is not configured, it blocks and suggests installation.
-
-Version: 3.9.0
-
-Returns:
-  - {"continue": true} - If Playwright is configured or not an E2E test file
-  - {"continue": false, "reason": "..."} - If Playwright is not configured
-"""
-import json
-import sys
-from pathlib import Path
-
-
-def main():
-    # Read hook input from stdin
-    try:
-        input_data = json.load(sys.stdin)
-    except json.JSONDecodeError:
-        print(json.dumps({"continue": True}))
-        sys.exit(0)
-
-    tool_name = input_data.get("tool_name", "")
-    tool_input = input_data.get("tool_input", {})
-
-    # Only check Write operations
-    if tool_name != "Write":
-        print(json.dumps({"continue": True}))
-        sys.exit(0)
-
-    # Check if writing an E2E test file
-    file_path = tool_input.get("file_path", "")
-
-    # Common E2E test patterns
-    is_e2e_test = (
-        file_path.endswith(".spec.ts") or
-        file_path.endswith(".spec.tsx") or
-        file_path.endswith(".e2e.ts") or
-        file_path.endswith(".e2e.tsx") or
-        "/e2e/" in file_path or
-        "/tests/e2e/" in file_path
-    )
-
-    if not is_e2e_test:
-        print(json.dumps({"continue": True}))
-        sys.exit(0)
-
-    # Look for playwright config in common locations
-    cwd = Path.cwd()
-    config_files = [
-        cwd / "playwright.config.ts",
-        cwd / "playwright.config.js",
-        cwd.parent / "playwright.config.ts",
-        cwd.parent / "playwright.config.js",
-    ]
-
-    playwright_found = False
-    for config_file in config_files:
-        if config_file.exists():
-            playwright_found = True
-            break
-
-    # Also check package.json for @playwright/test
-    if not playwright_found:
-        package_json = cwd / "package.json"
-        if package_json.exists():
-            try:
-                pkg = json.loads(package_json.read_text())
-                deps = pkg.get("devDependencies", {})
-                deps.update(pkg.get("dependencies", {}))
-                if "@playwright/test" in deps:
-                    playwright_found = True
-            except (json.JSONDecodeError, IOError):
-                pass
-
-    if not playwright_found:
-        print(json.dumps({
-            "continue": False,
-            "reason": (
-                "Playwright is not configured in this project.\n\n"
-                "Before writing E2E test files, please install Playwright:\n\n"
-                "  npm init playwright@latest\n\n"
-                "This will create playwright.config.ts and install browsers.\n"
-                "After installation, run 'npx playwright test' to run tests."
-            )
-        }))
-        sys.exit(0)
-
-    # Playwright is configured
-    print(json.dumps({"continue": True}))
-    sys.exit(0)
-
-
-if __name__ == "__main__":
-    main()

package/.claude/hooks/check-storybook-setup.py

@@ -1,81 +0,0 @@
-#!/usr/bin/env python3
-"""
-Hook: PreToolUse for Write
-Purpose: Verify Storybook is configured before writing story files
-
-This hook runs before writing .stories.tsx files. It checks that:
-- .storybook/ directory exists
-- main.ts or main.js config exists
-
-If Storybook is not configured, it blocks and suggests installation.
-
-Version: 3.9.0
-
-Returns:
-  - {"continue": true} - If Storybook is configured or not a story file
-  - {"continue": false, "reason": "..."} - If Storybook is not configured
-"""
-import json
-import sys
-from pathlib import Path
-
-
-def main():
-    # Read hook input from stdin
-    try:
-        input_data = json.load(sys.stdin)
-    except json.JSONDecodeError:
-        print(json.dumps({"continue": True}))
-        sys.exit(0)
-
-    tool_name = input_data.get("tool_name", "")
-    tool_input = input_data.get("tool_input", {})
-
-    # Only check Write operations
-    if tool_name != "Write":
-        print(json.dumps({"continue": True}))
-        sys.exit(0)
-
-    # Check if writing a story file
-    file_path = tool_input.get("file_path", "")
-    if not file_path.endswith(".stories.tsx") and not file_path.endswith(".stories.ts"):
-        print(json.dumps({"continue": True}))
-        sys.exit(0)
-
-    # Look for .storybook directory in common locations
-    cwd = Path.cwd()
-    storybook_dirs = [
-        cwd / ".storybook",
-        cwd.parent / ".storybook",  # In case running from subdirectory
-    ]
-
-    storybook_found = False
-    for storybook_dir in storybook_dirs:
-        if storybook_dir.exists():
-            # Check for main config file
-            main_ts = storybook_dir / "main.ts"
-            main_js = storybook_dir / "main.js"
-            if main_ts.exists() or main_js.exists():
-                storybook_found = True
-                break
-
-    if not storybook_found:
-        print(json.dumps({
-            "continue": False,
-            "reason": (
-                "Storybook is not configured in this project.\n\n"
-                "Before writing story files, please install Storybook:\n\n"
-                "  npx storybook@latest init\n\n"
-                "This will create the .storybook/ directory and configuration.\n"
-                "After installation, run 'pnpm storybook' to start the dev server."
-            )
-        }))
-        sys.exit(0)
-
-    # Storybook is configured
-    print(json.dumps({"continue": True}))
-    sys.exit(0)
-
-
-if __name__ == "__main__":
-    main()

package/.claude/hooks/check-update.py

@@ -1,132 +0,0 @@
-#!/usr/bin/env python3
-"""
-Check for api-dev-tools updates at session start.
-
-This hook runs at SessionStart and checks npm registry for newer versions.
-Non-blocking - only injects a message if update available.
-
-Hook Type: SessionStart
-"""
-
-import json
-import os
-import sys
-import subprocess
-from pathlib import Path
-
-
-def get_installed_version():
-    """Get currently installed version from package.json"""
-    project_dir = os.environ.get("CLAUDE_PROJECT_DIR", ".")
-    package_json = Path(project_dir) / "package.json"
-
-    if package_json.exists():
-        try:
-            data = json.loads(package_json.read_text())
-            # Check if this project uses api-dev-tools
-            deps = data.get("devDependencies", {})
-            deps.update(data.get("dependencies", {}))
-
-            if "@hustle-together/api-dev-tools" in deps:
-                version = deps["@hustle-together/api-dev-tools"]
-                # Remove ^ or ~ prefix
-                return version.lstrip("^~")
-        except Exception:
-            pass
-
-    # Check for version in state file
-    state_file = Path(project_dir) / ".claude" / "api-dev-state.json"
-    if state_file.exists():
-        try:
-            state = json.loads(state_file.read_text())
-            return state.get("version", "0.0.0")
-        except Exception:
-            pass
-
-    return None
-
-
-def get_latest_version():
-    """Check npm registry for latest version"""
-    try:
-        result = subprocess.run(
-            ["npm", "view", "@hustle-together/api-dev-tools", "version"],
-            capture_output=True,
-            text=True,
-            timeout=5
-        )
-        if result.returncode == 0:
-            return result.stdout.strip()
-    except Exception:
-        pass
-    return None
-
-
-def version_tuple(v):
-    """Convert version string to tuple for comparison"""
-    try:
-        return tuple(map(int, v.split(".")))
-    except Exception:
-        return (0, 0, 0)
-
-
-def main():
-    # Check if we should skip (already checked recently)
-    project_dir = os.environ.get("CLAUDE_PROJECT_DIR", ".")
-    state_file = Path(project_dir) / ".claude" / "api-dev-state.json"
-
-    try:
-        if state_file.exists():
-            state = json.loads(state_file.read_text())
-            last_check = state.get("last_update_check")
-
-            if last_check:
-                from datetime import datetime, timedelta
-                last_check_dt = datetime.fromisoformat(last_check)
-                if datetime.now() - last_check_dt < timedelta(hours=24):
-                    # Already checked today, skip
-                    print(json.dumps({"continue": True}))
-                    return
-    except Exception:
-        pass
-
-    installed = get_installed_version()
-    latest = get_latest_version()
-
-    result = {"continue": True}
-
-    if installed and latest:
-        if version_tuple(latest) > version_tuple(installed):
-            result["additionalContext"] = f"""
-## Update Available
-
-A new version of api-dev-tools is available:
-- **Current**: {installed}
-- **Latest**: {latest}
-
-To update, run:
-```bash
-npx @hustle-together/api-dev-tools@latest
-```
-
-This update may include new features, bug fixes, and improved workflows.
-"""
-            # Update state with last check time
-            try:
-                if state_file.exists():
-                    state = json.loads(state_file.read_text())
-                else:
-                    state = {}
-
-                from datetime import datetime
-                state["last_update_check"] = datetime.now().isoformat()
-                state["available_update"] = latest
-                state_file.write_text(json.dumps(state, indent=2))
-            except Exception:
-                pass
-
-    print(json.dumps(result))
-
-
-if __name__ == "__main__":
-    main()

package/.claude/hooks/detect-interruption.py

@@ -1,165 +0,0 @@
-#!/usr/bin/env python3
-"""
-Hook: SessionStart
-Purpose: Detect and prompt for interrupted workflows
-
-This hook runs at session start and checks if there are any
-in-progress workflows that were interrupted. If found, it injects
-a prompt asking the user if they want to resume.
-
-Added in v3.6.7 for session continuation support.
-
-Returns:
-  - JSON with additionalContext about interrupted workflows
-"""
-import json
-import sys
-import os
-from datetime import datetime
-from pathlib import Path
-
-STATE_FILE = Path(__file__).parent.parent / "api-dev-state.json"
-
-
-def get_interrupted_workflows(state):
-    """Find all workflows that are in_progress but not active."""
-    interrupted = []
-
-    # New format (v3.6.7+): check endpoints object
-    if "endpoints" in state:
-        active = state.get("active_endpoint")
-        for endpoint_name, endpoint_data in state["endpoints"].items():
-            status = endpoint_data.get("status", "not_started")
-            if status == "in_progress" and endpoint_name != active:
-                # Find the current phase
-                phases = endpoint_data.get("phases", {})
-                current_phase = None
-                for phase_name, phase_data in phases.items():
-                    if phase_data.get("status") == "in_progress":
-                        current_phase = phase_name
-                        break
-
-                interrupted.append({
-                    "endpoint": endpoint_name,
-                    "status": status,
-                    "current_phase": current_phase,
-                    "started_at": endpoint_data.get("started_at"),
-                    "interrupted_at": endpoint_data.get("session", {}).get("interrupted_at"),
-                    "interrupted_phase": endpoint_data.get("session", {}).get("interrupted_phase")
-                })
-
-        # Also check if active endpoint is not fully started
-        if active and active in state["endpoints"]:
-            active_data = state["endpoints"][active]
-            session = active_data.get("session", {})
-            if session.get("interrupted_at"):
-                # Active endpoint was previously interrupted
-                interrupted.insert(0, {
-                    "endpoint": active,
-                    "status": active_data.get("status"),
-                    "current_phase": session.get("interrupted_phase"),
-                    "started_at": active_data.get("started_at"),
-                    "interrupted_at": session.get("interrupted_at"),
-                    "is_active": True
-                })
-
-    # Old format: single endpoint
-    elif state.get("endpoint"):
-        endpoint = state.get("endpoint")
-        phases = state.get("phases", {})
-
-        # Check if any phase is in_progress
-        for phase_name, phase_data in phases.items():
-            if phase_data.get("status") == "in_progress":
-                interrupted.append({
-                    "endpoint": endpoint,
-                    "status": "in_progress",
-                    "current_phase": phase_name,
-                    "started_at": state.get("created_at"),
-                    "is_legacy": True
-                })
-                break
-
-    return interrupted
-
-
-def format_interrupted_message(interrupted):
-    """Format a user-friendly message about interrupted workflows."""
-    if not interrupted:
-        return None
-
-    lines = [
-        "",
-        "=" * 60,
-        " INTERRUPTED WORKFLOW DETECTED",
-        "=" * 60,
-        ""
-    ]
-
-    for i, workflow in enumerate(interrupted, 1):
-        endpoint = workflow["endpoint"]
-        phase = workflow.get("current_phase", "unknown")
-        started = workflow.get("started_at", "unknown")
-        interrupted_at = workflow.get("interrupted_at", "")
-
-        lines.append(f"{i}. **{endpoint}**")
-        lines.append(f"   - Phase: {phase}")
-        lines.append(f"   - Started: {started}")
-        if interrupted_at:
-            lines.append(f"   - Interrupted: {interrupted_at}")
-        lines.append("")
-
-    lines.extend([
-        "To resume an interrupted workflow, use:",
-        "  /api-continue [endpoint-name]",
-        "",
-        "Or start a new workflow with:",
-        "  /api-create [new-endpoint-name]",
-        "",
-        "=" * 60
-    ])
-
-    return "\n".join(lines)
-
-
-def main():
-    try:
-        input_data = json.load(sys.stdin)
-    except json.JSONDecodeError:
-        input_data = {}
-
-    # Check if state file exists
-    if not STATE_FILE.exists():
-        print(json.dumps({"continue": True}))
-        sys.exit(0)
-
-    try:
-        state = json.loads(STATE_FILE.read_text())
-    except json.JSONDecodeError:
-        print(json.dumps({"continue": True}))
-        sys.exit(0)
-
-    # Find interrupted workflows
-    interrupted = get_interrupted_workflows(state)
-
-    if not interrupted:
-        print(json.dumps({"continue": True}))
-        sys.exit(0)
-
-    # Format message
-    message = format_interrupted_message(interrupted)
-
-    output = {
-        "hookSpecificOutput": {
-            "hookEventName": "SessionStart",
-            "additionalContext": message,
-            "interruptedWorkflows": interrupted
-        }
-    }
-
-    print(json.dumps(output))
-    sys.exit(0)
-
-
-if __name__ == "__main__":
-    main()