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

package/.claude/hooks/track-scope-coverage.py

@@ -1,220 +0,0 @@
-#!/usr/bin/env python3
-"""
-Hook: PostToolUse for AskUserQuestion
-Purpose: Track implemented vs deferred features for scope coverage
-
-This hook tracks which features discovered during research are:
-  - Implemented (user chose to include)
-  - Deferred (user chose to skip for later)
-  - Discovered (found in docs but not yet decided)
-
-Added in v3.6.7 for feature scope tracking.
-
-Returns:
-  - JSON with scope coverage update info
-"""
-import json
-import sys
-from datetime import datetime
-from pathlib import Path
-
-STATE_FILE = Path(__file__).parent.parent / "api-dev-state.json"
-
-
-def get_active_endpoint(state):
-    """Get active endpoint - supports both old and new state formats."""
-    if "endpoints" in state and "active_endpoint" in state:
-        active = state.get("active_endpoint")
-        if active and active in state["endpoints"]:
-            return active, state["endpoints"][active]
-        return None, None
-
-    endpoint = state.get("endpoint")
-    if endpoint:
-        return endpoint, state
-
-    return None, None
-
-
-def extract_feature_from_question(question, options):
-    """Try to extract a feature name from the question."""
-    # Look for common patterns
-    patterns = [
-        "implement",
-        "include",
-        "support",
-        "enable",
-        "add"
-    ]
-
-    question_lower = question.lower()
-    for pattern in patterns:
-        if pattern in question_lower:
-            # Extract the words after the pattern
-            idx = question_lower.find(pattern)
-            after = question_lower[idx:].split("?")[0]
-            # Clean up
-            words = after.split()[1:4]  # Get 1-3 words after pattern
-            if words:
-                return " ".join(words).strip(",.?")
-
-    return None
-
-
-def is_feature_decision(question, answer, options):
-    """Determine if this was a feature implementation decision."""
-    question_lower = question.lower()
-
-    # Keywords suggesting feature decision
-    feature_keywords = [
-        "implement", "include", "support", "enable", "add",
-        "feature", "functionality", "capability"
-    ]
-
-    has_keyword = any(k in question_lower for k in feature_keywords)
-
-    # Check if answer indicates yes/no/defer decision
-    answer_lower = str(answer).lower() if answer else ""
-    is_decision = any(word in answer_lower for word in [
-        "yes", "no", "skip", "defer", "later", "include", "exclude",
-        "implement", "confirm", "reject"
-    ])
-
-    return has_keyword and is_decision
-
-
-def categorize_decision(answer):
-    """Categorize the decision as implement/defer/skip."""
-    answer_lower = str(answer).lower() if answer else ""
-
-    if any(word in answer_lower for word in ["yes", "include", "implement", "confirm"]):
-        return "implement"
-    elif any(word in answer_lower for word in ["defer", "later", "phase 2", "future"]):
-        return "defer"
-    elif any(word in answer_lower for word in ["no", "skip", "exclude", "reject"]):
-        return "skip"
-
-    return "unknown"
-
-
-def main():
-    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", {})
-    tool_result = input_data.get("tool_result", {})
-
-    if tool_name != "AskUserQuestion":
-        print(json.dumps({"continue": True}))
-        sys.exit(0)
-
-    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)
-
-    endpoint, endpoint_data = get_active_endpoint(state)
-    if not endpoint or not endpoint_data:
-        print(json.dumps({"continue": True}))
-        sys.exit(0)
-
-    # Get question and answer
-    question = tool_input.get("question", "")
-    options = tool_input.get("options", [])
-
-    # Get user's answer from result
-    answer = None
-    if isinstance(tool_result, dict):
-        answer = tool_result.get("answer", tool_result.get("value", ""))
-    elif isinstance(tool_result, str):
-        answer = tool_result
-
-    # Check if this is a feature decision
-    if not is_feature_decision(question, answer, options):
-        print(json.dumps({"continue": True}))
-        sys.exit(0)
-
-    # Extract feature name
-    feature = extract_feature_from_question(question, options)
-    if not feature:
-        feature = f"feature_{datetime.now().strftime('%H%M%S')}"
-
-    # Categorize decision
-    category = categorize_decision(answer)
-
-    # Ensure scope object exists
-    if "endpoints" in state:
-        if "scope" not in state["endpoints"][endpoint]:
-            state["endpoints"][endpoint]["scope"] = {
-                "discovered_features": [],
-                "implemented_features": [],
-                "deferred_features": [],
-                "coverage_percent": 0
-            }
-        scope = state["endpoints"][endpoint]["scope"]
-    else:
-        if "scope" not in state:
-            state["scope"] = {
-                "discovered_features": [],
-                "implemented_features": [],
-                "deferred_features": [],
-                "coverage_percent": 0
-            }
-        scope = state["scope"]
-
-    # Add to discovered if not already there
-    feature_entry = {
-        "name": feature,
-        "discovered_at": datetime.now().isoformat(),
-        "question": question[:100],
-        "decision": category
-    }
-
-    if feature not in [f.get("name") if isinstance(f, dict) else f for f in scope["discovered_features"]]:
-        scope["discovered_features"].append(feature_entry)
-
-    # Add to appropriate category
-    if category == "implement":
-        if feature not in scope["implemented_features"]:
-            scope["implemented_features"].append(feature)
-    elif category == "defer":
-        defer_entry = {
-            "name": feature,
-            "reason": f"User chose to defer: {str(answer)[:50]}",
-            "deferred_at": datetime.now().isoformat()
-        }
-        if feature not in [f.get("name") if isinstance(f, dict) else f for f in scope["deferred_features"]]:
-            scope["deferred_features"].append(defer_entry)
-
-    # Calculate coverage
-    total = len(scope["discovered_features"])
-    implemented = len(scope["implemented_features"])
-    if total > 0:
-        scope["coverage_percent"] = round((implemented / total) * 100, 1)
-
-    # Save state
-    STATE_FILE.write_text(json.dumps(state, indent=2))
-
-    output = {
-        "hookSpecificOutput": {
-            "featureTracked": feature,
-            "decision": category,
-            "coveragePercent": scope["coverage_percent"]
-        }
-    }
-
-    print(json.dumps(output))
-    sys.exit(0)
-
-
-if __name__ == "__main__":
-    main()

package/.claude/hooks/track-token-usage.py

@@ -1,121 +0,0 @@
-#!/usr/bin/env python3
-"""
-Hook: PostToolUse
-Purpose: Track token usage per phase and display after phase completion
-
-Logs token usage to state file and outputs summary after each phase.
-Integrates with ccusage if available.
-
-Version: 3.10.0
-"""
-import json
-import sys
-import subprocess
-from pathlib import Path
-from datetime import datetime
-
-
-def get_token_usage() -> dict:
-    """Get current token usage from ccusage."""
-    try:
-        result = subprocess.run(
-            ["ccusage", "--json"],
-            capture_output=True,
-            text=True,
-            timeout=5
-        )
-        if result.returncode == 0:
-            return json.loads(result.stdout)
-    except (subprocess.TimeoutExpired, FileNotFoundError, json.JSONDecodeError):
-        pass
-    return {}
-
-
-def main():
-    # Read hook input from stdin
-    try:
-        input_data = json.load(sys.stdin)
-    except json.JSONDecodeError:
-        sys.exit(0)
-
-    tool_name = input_data.get("tool_name", "")
-    tool_input = input_data.get("tool_input", {})
-
-    # Only trigger on Write/Edit to state file
-    if tool_name not in ["Write", "Edit"]:
-        sys.exit(0)
-
-    file_path = tool_input.get("file_path", "")
-    if "api-dev-state.json" not in file_path:
-        sys.exit(0)
-
-    # Get current token usage
-    usage = get_token_usage()
-    if not usage:
-        sys.exit(0)
-
-    # Read state file
-    cwd = Path.cwd()
-    state_file = cwd / ".claude" / "api-dev-state.json"
-
-    if not state_file.exists():
-        sys.exit(0)
-
-    try:
-        state = json.loads(state_file.read_text())
-    except (json.JSONDecodeError, IOError):
-        sys.exit(0)
-
-    # Check for phase completion and log usage
-    phases = state.get("phases", {})
-    current_phase = None
-
-    for phase_key, phase_data in phases.items():
-        if isinstance(phase_data, dict):
-            status = phase_data.get("status", "")
-            if status == "complete":
-                current_phase = phase_key
-
-    if current_phase:
-        # Initialize token tracking in state if needed
-        if "token_usage" not in state:
-            state["token_usage"] = {
-                "by_phase": {},
-                "total_at_start": usage.get("total_tokens", 0),
-                "started_at": datetime.now().isoformat()
-            }
-
-        # Record phase completion tokens
-        state["token_usage"]["by_phase"][current_phase] = {
-            "total_tokens": usage.get("total_tokens", 0),
-            "total_cost": usage.get("total_cost", 0),
-            "timestamp": datetime.now().isoformat()
-        }
-
-        # Calculate phase delta if we have previous data
-        by_phase = state["token_usage"]["by_phase"]
-        phase_keys = list(by_phase.keys())
-
-        if len(phase_keys) >= 2:
-            prev_phase = phase_keys[-2]
-            prev_tokens = by_phase[prev_phase].get("total_tokens", 0)
-            current_tokens = usage.get("total_tokens", 0)
-            delta = current_tokens - prev_tokens
-
-            # Output phase token summary
-            print(f"\n📊 Phase '{current_phase}' Token Usage:", file=sys.stderr)
-            print(f"   Phase tokens: {delta:,}", file=sys.stderr)
-            print(f"   Total tokens: {current_tokens:,}", file=sys.stderr)
-            print(f"   Total cost: ${usage.get('total_cost', 0):.2f}", file=sys.stderr)
-
-        # Update state file with token tracking
-        try:
-            state_file.write_text(json.dumps(state, indent=2))
-        except IOError:
-            pass
-
-    sys.exit(0)
-
-
-if __name__ == "__main__":
-    main()

package/.claude/hooks/update-api-showcase.py

@@ -1,161 +0,0 @@
-#!/usr/bin/env python3
-"""
-Hook: PostToolUse for Write/Edit
-Purpose: Auto-create API Showcase page when first API is created
-
-This hook monitors for new API registrations. When the first API is added
-to registry.json, it creates the API Showcase page at src/app/api-showcase/
-if it doesn't exist.
-
-Version: 3.9.0
-
-Returns:
-  - {"continue": true} - Always continues
-  - May include "notify" about showcase creation
-"""
-import json
-import sys
-from pathlib import Path
-import shutil
-
-# State and registry files in .claude/ directory
-STATE_FILE = Path(__file__).parent.parent / "api-dev-state.json"
-REGISTRY_FILE = Path(__file__).parent.parent / "registry.json"
-
-
-def copy_showcase_templates(cwd):
-    """Copy API showcase templates to src/app/api-showcase/."""
-    # Source templates (installed by CLI)
-    templates_dir = Path(__file__).parent.parent / "templates" / "api-showcase"
-    shared_templates_dir = Path(__file__).parent.parent / "templates" / "shared"
-
-    # Destination
-    showcase_dir = cwd / "src" / "app" / "api-showcase"
-    shared_dir = cwd / "src" / "app" / "shared"
-
-    # Create directories if needed
-    showcase_dir.mkdir(parents=True, exist_ok=True)
-    shared_dir.mkdir(parents=True, exist_ok=True)
-
-    # Copy template files
-    templates_to_copy = [
-        ("page.tsx", "page.tsx"),
-        ("APIShowcase.tsx", "_components/APIShowcase.tsx"),
-        ("APICard.tsx", "_components/APICard.tsx"),
-        ("APIModal.tsx", "_components/APIModal.tsx"),
-        ("APITester.tsx", "_components/APITester.tsx"),
-    ]
-
-    created_files = []
-    for src_name, dest_name in templates_to_copy:
-        src_path = templates_dir / src_name
-        dest_path = showcase_dir / dest_name
-
-        # Create subdirectories if needed
-        dest_path.parent.mkdir(parents=True, exist_ok=True)
-
-        if src_path.exists() and not dest_path.exists():
-            shutil.copy2(src_path, dest_path)
-            created_files.append(str(dest_path.relative_to(cwd)))
-
-    # Also copy shared components (HeroHeader, etc.)
-    if shared_templates_dir.exists():
-        for src_file in shared_templates_dir.iterdir():
-            if src_file.is_file():
-                dest_path = shared_dir / src_file.name
-                if not dest_path.exists():
-                    shutil.copy2(src_file, dest_path)
-                    created_files.append(str(dest_path.relative_to(cwd)))
-
-    return created_files
-
-
-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", "")
-
-    # Only process Write/Edit operations
-    if tool_name not in ["Write", "Edit"]:
-        print(json.dumps({"continue": True}))
-        sys.exit(0)
-
-    # Check if state file exists
-    if not STATE_FILE.exists():
-        print(json.dumps({"continue": True}))
-        sys.exit(0)
-
-    # Load state
-    try:
-        state = json.loads(STATE_FILE.read_text())
-    except json.JSONDecodeError:
-        print(json.dumps({"continue": True}))
-        sys.exit(0)
-
-    workflow = state.get("workflow", "")
-
-    # Only apply for API workflows
-    if workflow not in ["api-create", "combine-api"]:
-        print(json.dumps({"continue": True}))
-        sys.exit(0)
-
-    # Check if completion phase is complete
-    active_endpoint = state.get("active_endpoint", "")
-    endpoints = state.get("endpoints", {})
-
-    if active_endpoint and active_endpoint in endpoints:
-        phases = endpoints[active_endpoint].get("phases", {})
-    else:
-        phases = state.get("phases", {})
-
-    completion = phases.get("completion", {})
-    if completion.get("status") != "complete":
-        print(json.dumps({"continue": True}))
-        sys.exit(0)
-
-    # Check if showcase already exists
-    cwd = Path.cwd()
-    showcase_page = cwd / "src" / "app" / "api-showcase" / "page.tsx"
-
-    if showcase_page.exists():
-        print(json.dumps({"continue": True}))
-        sys.exit(0)
-
-    # Check if we have APIs in registry
-    if not REGISTRY_FILE.exists():
-        print(json.dumps({"continue": True}))
-        sys.exit(0)
-
-    try:
-        registry = json.loads(REGISTRY_FILE.read_text())
-    except json.JSONDecodeError:
-        print(json.dumps({"continue": True}))
-        sys.exit(0)
-
-    apis = registry.get("apis", {})
-    combined = registry.get("combined", {})
-
-    # Create showcase if we have at least one API
-    if apis or combined:
-        created_files = copy_showcase_templates(cwd)
-
-        if created_files:
-            print(json.dumps({
-                "continue": True,
-                "notify": f"Created API Showcase at /api-showcase ({len(created_files)} files)"
-            }))
-        else:
-            print(json.dumps({"continue": True}))
-    else:
-        print(json.dumps({"continue": True}))
-
-    sys.exit(0)
-
-
-if __name__ == "__main__":
-    main()