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

package/.claude/hooks/update-adr-decision.py

@@ -0,0 +1,236 @@
+#!/usr/bin/env python3
+"""
+ADR Decision Updater Hook
+
+Updates Architecture Decision Records when user makes a decision during interview.
+Changes status from PROPOSED to ACCEPTED and records the decision with reasoning.
+
+Hook Type: PostToolUse (matcher: AskUserQuestion)
+
+Flow:
+1. Interview phase presents options to user (referencing ADR)
+2. User selects an option
+3. Hook detects the answer relates to a PROPOSED ADR
+4. Updates ADR with decision, reasoning, and consequences
+5. Updates registry with decision
+"""
+
+import json
+import os
+import re
+from datetime import datetime
+from pathlib import Path
+
+
+def load_config():
+    """Load ADR configuration"""
+    project_dir = os.environ.get("CLAUDE_PROJECT_DIR", ".")
+
+    config_file = Path(project_dir) / ".claude" / "hustle-build-defaults.json"
+    if config_file.exists():
+        try:
+            config = json.loads(config_file.read_text())
+            return config.get("adr", {})
+        except Exception:
+            pass
+
+    return {"enabled": True}
+
+
+def load_registry():
+    """Load current registry"""
+    project_dir = os.environ.get("CLAUDE_PROJECT_DIR", ".")
+    registry_file = Path(project_dir) / ".claude" / "registry.json"
+
+    if registry_file.exists():
+        try:
+            return json.loads(registry_file.read_text())
+        except Exception:
+            pass
+    return {}
+
+
+def save_registry(registry):
+    """Save registry"""
+    project_dir = os.environ.get("CLAUDE_PROJECT_DIR", ".")
+    registry_file = Path(project_dir) / ".claude" / "registry.json"
+    registry_file.parent.mkdir(parents=True, exist_ok=True)
+    registry_file.write_text(json.dumps(registry, indent=2))
+
+
+def find_matching_adr(question_text, answer_text, registry):
+    """
+    Find a PROPOSED ADR that matches the question/answer.
+    Matches based on category keywords in question and answer options.
+    """
+    adrs = registry.get("adrs", {})
+
+    for adr_key, adr in adrs.items():
+        if adr.get("status") != "proposed":
+            continue
+
+        category = adr.get("category", "")
+        options = adr.get("options_considered", [])
+
+        # Check if question mentions the category
+        if category.lower() in question_text.lower():
+            # Check if answer matches one of the options
+            for opt in options:
+                if opt.lower() in answer_text.lower():
+                    return adr_key, adr, opt
+
+        # Check if answer directly matches an option
+        for opt in options:
+            if opt.lower() in answer_text.lower():
+                # Verify category is relevant to question
+                category_keywords = {
+                    "database": ["database", "storage", "data", "db"],
+                    "auth": ["auth", "authentication", "login", "security"],
+                    "cache": ["cache", "caching", "performance"],
+                    "hosting": ["host", "deploy", "platform"],
+                    "state": ["state", "store", "management"],
+                    "styling": ["style", "css", "design", "ui"],
+                }
+                keywords = category_keywords.get(category, [category])
+                if any(kw in question_text.lower() for kw in keywords):
+                    return adr_key, adr, opt
+
+    return None, None, None
+
+
+def update_adr_file(adr, decision):
+    """Update the ADR markdown file with the decision"""
+    project_dir = os.environ.get("CLAUDE_PROJECT_DIR", ".")
+    adr_file = Path(project_dir) / adr.get("file", "")
+
+    if not adr_file.exists():
+        return False
+
+    content = adr_file.read_text()
+
+    # Update status
+    content = re.sub(
+        r"\*\*Status:\*\* PROPOSED",
+        "**Status:** ACCEPTED",
+        content
+    )
+
+    # Update decision section
+    decision_section = f"""## Decision
+
+We will use **{decision.title()}** based on user selection during interview.
+
+**Reasoning:** User prioritized this option based on project requirements.
+"""
+
+    content = re.sub(
+        r"## Decision\n\n_Pending user selection during interview phase\._",
+        decision_section,
+        content
+    )
+
+    # Update consequences section
+    consequences_section = f"""## Consequences
+
+### Positive
+- Decision has been made, enabling implementation to proceed
+- Choice aligns with user's stated requirements
+
+### Negative
+- Alternative options were not selected (may revisit if requirements change)
+
+### Implementation Notes
+- Proceed with {decision.title()} integration
+- Update environment variables as needed
+- Follow {decision.title()} best practices
+"""
+
+    content = re.sub(
+        r"## Consequences\n\n_To be documented after decision is made\._",
+        consequences_section,
+        content
+    )
+
+    # Add decision timestamp
+    content = content.replace(
+        "_This ADR was auto-generated during research.",
+        f"_Decision recorded: {datetime.now().strftime('%Y-%m-%d %H:%M')}_\n\n_This ADR was auto-generated during research."
+    )
+
+    adr_file.write_text(content)
+    return True
+
+
+def main():
+    # Get tool info
+    tool_name = os.environ.get("CLAUDE_TOOL_NAME", "")
+    tool_output = os.environ.get("CLAUDE_TOOL_OUTPUT", "")
+    tool_input = os.environ.get("CLAUDE_TOOL_INPUT", "{}")
+
+    # Only process AskUserQuestion results
+    if tool_name != "AskUserQuestion":
+        print(json.dumps({"continue": True}))
+        return
+
+    # Load config
+    config = load_config()
+    if not config.get("enabled", True):
+        print(json.dumps({"continue": True}))
+        return
+
+    # Parse question and answer
+    try:
+        input_data = json.loads(tool_input)
+        questions = input_data.get("questions", [])
+        if not questions:
+            print(json.dumps({"continue": True}))
+            return
+
+        question_text = questions[0].get("question", "")
+    except Exception:
+        question_text = ""
+
+    # The answer is in tool_output
+    answer_text = tool_output
+
+    if not question_text or not answer_text:
+        print(json.dumps({"continue": True}))
+        return
+
+    # Load registry and find matching ADR
+    registry = load_registry()
+    adr_key, adr, decision = find_matching_adr(question_text, answer_text, registry)
+
+    if not adr_key:
+        print(json.dumps({"continue": True}))
+        return
+
+    # Update ADR file
+    update_adr_file(adr, decision)
+
+    # Update registry
+    registry["adrs"][adr_key]["status"] = "accepted"
+    registry["adrs"][adr_key]["decision"] = decision
+    registry["adrs"][adr_key]["phase"] = "interview"
+    registry["adrs"][adr_key]["decided_at"] = datetime.now().isoformat()
+    save_registry(registry)
+
+    # Notify about ADR update
+    result = {
+        "continue": True,
+        "additionalContext": f"""## ADR Updated
+
+**ADR-{adr.get('number', 0):04d}: {adr.get('title', '')}** has been updated.
+
+- **Status:** PROPOSED → ACCEPTED
+- **Decision:** {decision.title()}
+- **File:** {adr.get('file', '')}
+
+This decision is now recorded for future reference.
+"""
+    }
+    print(json.dumps(result))
+
+
+if __name__ == "__main__":
+    main()

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

@@ -0,0 +1,161 @@
+#!/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()