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

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

@@ -0,0 +1,224 @@
+#!/usr/bin/env python3
+"""
+Hook: PostToolUse for Write/Edit
+Purpose: Auto-create UI Showcase page when first component/page is created
+         and auto-populate showcase data from registry.
+
+This hook monitors for new component or page registrations. When the first
+UI element is added to registry.json, it creates the UI Showcase page
+at src/app/ui-showcase/ if it doesn't exist.
+
+Also generates src/app/ui-showcase/data.json from registry for auto-population.
+
+Version: 3.10.0
+
+Returns:
+  - {"continue": true} - Always continues
+  - May include "notify" about showcase creation
+"""
+import json
+import sys
+from pathlib import Path
+import shutil
+from datetime import datetime
+
+# 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 generate_showcase_data(registry, cwd):
+    """Generate showcase data file from registry for auto-population.
+
+    Creates src/app/ui-showcase/data.json with component/page listings.
+    """
+    components = registry.get("components", {})
+    pages = registry.get("pages", {})
+
+    showcase_data = {
+        "version": "3.10.0",
+        "generated_at": datetime.now().isoformat(),
+        "components": [],
+        "pages": []
+    }
+
+    # Process components
+    for name, comp in components.items():
+        showcase_data["components"].append({
+            "id": name,
+            "name": comp.get("name", name),
+            "description": comp.get("description", ""),
+            "type": comp.get("type", "atom"),
+            "path": comp.get("path", f"src/components/{name}/{name}.tsx"),
+            "storybook_url": comp.get("storybook_url", f"/?path=/story/{name.lower()}--default"),
+            "variants": comp.get("variants", []),
+            "props": list(comp.get("props", {}).keys()) if isinstance(comp.get("props"), dict) else [],
+            "created_at": comp.get("created_at", ""),
+            "status": comp.get("status", "ready")
+        })
+
+    # Process pages
+    for name, page in pages.items():
+        showcase_data["pages"].append({
+            "id": name,
+            "name": page.get("name", name),
+            "description": page.get("description", ""),
+            "route": page.get("route", f"/{name}"),
+            "page_type": page.get("page_type", "landing"),
+            "path": page.get("path", f"src/app/{name}/page.tsx"),
+            "requires_auth": page.get("requires_auth", False),
+            "data_sources": page.get("data_sources", []),
+            "created_at": page.get("created_at", ""),
+            "status": page.get("status", "ready")
+        })
+
+    # Write data file
+    data_file = cwd / "src" / "app" / "ui-showcase" / "data.json"
+    data_file.parent.mkdir(parents=True, exist_ok=True)
+    data_file.write_text(json.dumps(showcase_data, indent=2))
+
+    return str(data_file.relative_to(cwd))
+
+
+def copy_showcase_templates(cwd):
+    """Copy UI showcase templates to src/app/ui-showcase/."""
+    # Source templates (installed by CLI)
+    templates_dir = Path(__file__).parent.parent / "templates" / "ui-showcase"
+    shared_templates_dir = Path(__file__).parent.parent / "templates" / "shared"
+
+    # Destination
+    showcase_dir = cwd / "src" / "app" / "ui-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"),
+        ("UIShowcase.tsx", "_components/UIShowcase.tsx"),
+        ("PreviewCard.tsx", "_components/PreviewCard.tsx"),
+        ("PreviewModal.tsx", "_components/PreviewModal.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 UI workflows
+    if workflow not in ["ui-create-component", "ui-create-page"]:
+        print(json.dumps({"continue": True}))
+        sys.exit(0)
+
+    # Check if completion phase is complete
+    active_element = state.get("active_element", "")
+    elements = state.get("elements", {})
+
+    if active_element and active_element in elements:
+        phases = elements[active_element].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" / "ui-showcase" / "page.tsx"
+
+    if showcase_page.exists():
+        print(json.dumps({"continue": True}))
+        sys.exit(0)
+
+    # Check if we have components or pages 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)
+
+    components = registry.get("components", {})
+    pages = registry.get("pages", {})
+
+    # Create showcase if we have at least one component or page
+    if components or pages:
+        created_files = copy_showcase_templates(cwd)
+
+        # Always update data.json from registry
+        data_file = generate_showcase_data(registry, cwd)
+
+        if created_files:
+            print(json.dumps({
+                "continue": True,
+                "notify": f"Created UI Showcase at /ui-showcase ({len(created_files)} files) + data.json"
+            }))
+        else:
+            # Just updated data.json
+            print(json.dumps({
+                "continue": True,
+                "notify": f"Updated UI Showcase data ({len(components)} components, {len(pages)} pages)"
+            }))
+    else:
+        print(json.dumps({"continue": True}))
+
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()

package/.claude/settings.local.json

@@ -6,7 +6,13 @@
       "Bash(npm version:*)",
       "Bash(git add:*)",
       "Bash(git commit:*)",
-      "Bash(tree:*)"
+      "Bash(tree:*)",
+      "Bash(python3:*)",
+      "Bash(ls:*)",
+      "Bash(git checkout:*)",
+      "Bash(git pull:*)",
+      "Bash(git stash:*)",
+      "Bash(npm view:*)"
     ]
   }
 }

package/.claude/test-auto-answer-bot.py

@@ -0,0 +1,183 @@
+#!/usr/bin/env python3
+"""
+Auto-Answer Bot for Test Orchestration
+
+Monitors .claude/current-question.json in test directory and automatically
+answers questions by writing to .claude/pending-answer.json.
+
+This enables autonomous testing by auto-selecting "comprehensive" options
+without manual intervention.
+
+Usage:
+    python test-auto-answer-bot.py <test_directory>
+
+Example:
+    python test-auto-answer-bot.py ~/test-api-dev-tools-auto
+
+Version: 1.0.0
+"""
+
+import json
+import sys
+import time
+from pathlib import Path
+from datetime import datetime
+
+# Configuration
+POLL_INTERVAL = 2  # seconds
+MAX_WAIT_TIME = 3600  # 1 hour max
+AFFIRMATIVE_KEYWORDS = [
+    "comprehensive", "all", "yes", "proceed", "continue",
+    "recommended", "auto", "defaults", "use auto", "use defaults"
+]
+
+
+def find_best_answer(question_data):
+    """
+    Find the best answer for a question.
+
+    Strategy:
+    1. Look for options with affirmative keywords (comprehensive, all, yes, etc.)
+    2. If multiple match, prefer first one
+    3. If none match, select first option
+
+    Args:
+        question_data: Parsed question data from current-question.json
+
+    Returns:
+        dict: Answer data with selected option
+    """
+    questions = question_data.get("questions", [])
+
+    if not questions:
+        return None
+
+    # For now, handle first question (can extend to handle multiple)
+    first_q = questions[0]
+    options = first_q.get("options", [])
+
+    if not options:
+        return None
+
+    # Find option with affirmative keyword
+    selected_index = 0
+    selected_label = None
+
+    for i, opt in enumerate(options):
+        label = opt.get("label", "") if isinstance(opt, dict) else str(opt)
+        label_lower = label.lower()
+
+        # Check for affirmative keywords
+        for keyword in AFFIRMATIVE_KEYWORDS:
+            if keyword in label_lower:
+                selected_index = i
+                selected_label = label
+                break
+
+        if selected_label:
+            break
+
+    # If no affirmative found, use first option
+    if not selected_label:
+        first_opt = options[0]
+        selected_label = first_opt.get("label", "") if isinstance(first_opt, dict) else str(first_opt)
+
+    return {
+        "question_id": first_q.get("id", "question"),
+        "question": first_q.get("question", ""),
+        "header": first_q.get("header", "Question"),
+        "answer": selected_label,
+        "option_index": selected_index,
+        "phase": question_data.get("phase", "unknown"),
+        "status": "submitted",
+        "submitted_at": datetime.now().isoformat(),
+        "auto_answered": True,
+        "answers": {
+            first_q.get("header", "Question"): selected_label
+        }
+    }
+
+
+def watch_and_answer(test_dir):
+    """
+    Watch for questions and auto-answer them.
+
+    Args:
+        test_dir: Path to test directory
+    """
+    test_path = Path(test_dir).expanduser()
+    question_file = test_path / ".claude" / "current-question.json"
+    answer_file = test_path / ".claude" / "pending-answer.json"
+
+    print(f"Auto-Answer Bot started")
+    print(f"Monitoring: {question_file}")
+    print(f"Writing answers to: {answer_file}")
+    print(f"Poll interval: {POLL_INTERVAL}s")
+    print()
+
+    start_time = time.time()
+    answered_count = 0
+
+    while True:
+        # Check timeout
+        if time.time() - start_time > MAX_WAIT_TIME:
+            print(f"Max wait time ({MAX_WAIT_TIME}s) exceeded. Exiting.")
+            break
+
+        # Check for question
+        if question_file.exists():
+            try:
+                # Read question
+                question_data = json.loads(question_file.read_text())
+
+                # Skip if already answered recently
+                if answer_file.exists():
+                    answer_data = json.loads(answer_file.read_text())
+                    answer_time = answer_data.get("submitted_at", "")
+                    question_time = question_data.get("created_at", "")
+
+                    # If answer is newer than question, skip
+                    if answer_time > question_time:
+                        time.sleep(POLL_INTERVAL)
+                        continue
+
+                # Find best answer
+                answer_data = find_best_answer(question_data)
+
+                if answer_data:
+                    # Write answer
+                    answer_file.parent.mkdir(parents=True, exist_ok=True)
+                    answer_file.write_text(json.dumps(answer_data, indent=2))
+
+                    answered_count += 1
+                    print(f"[{datetime.now().strftime('%H:%M:%S')}] Answered question #{answered_count}")
+                    print(f"  Question: {answer_data.get('question', '')[:80]}...")
+                    print(f"  Answer: {answer_data.get('answer', '')}")
+                    print(f"  Phase: {answer_data.get('phase', 'unknown')}")
+                    print()
+
+                    # Clear the question file
+                    question_file.unlink()
+
+            except Exception as e:
+                print(f"Error processing question: {e}")
+
+        time.sleep(POLL_INTERVAL)
+
+    print(f"Bot finished. Answered {answered_count} questions.")
+
+
+def main():
+    if len(sys.argv) < 2:
+        print("Usage: python test-auto-answer-bot.py <test_directory>")
+        print()
+        print("Example:")
+        print("  python test-auto-answer-bot.py ~/test-api-dev-tools-auto")
+        sys.exit(1)
+
+    test_dir = sys.argv[1]
+    watch_and_answer(test_dir)
+
+
+if __name__ == "__main__":
+    main()

package/.claude/test-completion-detector.py

@@ -0,0 +1,263 @@
+#!/usr/bin/env python3
+"""
+Test Completion Detector
+
+Programmatically verifies that a workflow completed successfully by checking:
+1. All 14 phases marked as "complete" in api-dev-state.json
+2. All expected artifacts exist (route.ts, schema.ts, tests, README)
+3. All hooks logged in workflow-logs/
+4. Tests pass (if test files exist)
+
+Usage:
+    python test-completion-detector.py <test_directory> <command_type>
+
+Example:
+    python test-completion-detector.py ~/test-api-dev-tools-auto api-create
+
+Returns:
+    Exit code 0 if complete, 1 if incomplete, 2 if error
+    Prints JSON with detailed status
+
+Version: 1.0.0
+"""
+
+import json
+import sys
+from pathlib import Path
+from datetime import datetime
+
+
+def load_state(test_dir):
+    """Load api-dev-state.json."""
+    state_file = Path(test_dir) / ".claude" / "api-dev-state.json"
+
+    if not state_file.exists():
+        return None
+
+    try:
+        return json.loads(state_file.read_text())
+    except Exception as e:
+        print(f"Error loading state: {e}", file=sys.stderr)
+        return None
+
+
+def check_phases_complete(state):
+    """Check if all 14 phases are marked complete."""
+    required_phases = [
+        "disambiguation",
+        "scope",
+        "research_initial",
+        "interview",
+        "research_deep",
+        "schema_creation",
+        "environment_check",
+        "tdd_red",
+        "tdd_green",
+        "verify",
+        "code_review",
+        "tdd_refactor",
+        "documentation",
+        "completion"
+    ]
+
+    phases = state.get("phases", {})
+    incomplete_phases = []
+
+    for phase_name in required_phases:
+        phase_data = phases.get(phase_name, {})
+        status = phase_data.get("status", "not_started")
+
+        if status != "complete":
+            # Special case: research_deep can be skipped if comprehensive docs found
+            if phase_name == "research_deep" and status == "skipped":
+                continue
+
+            # Special case: code_review can be partial if no API key
+            if phase_name == "code_review" and status == "partial":
+                continue
+
+            incomplete_phases.append({
+                "phase": phase_name,
+                "status": status,
+                "reason": phase_data.get("incomplete_reason", "Unknown")
+            })
+
+    return {
+        "complete": len(incomplete_phases) == 0,
+        "total_phases": len(required_phases),
+        "complete_phases": len(required_phases) - len(incomplete_phases),
+        "incomplete": incomplete_phases
+    }
+
+
+def check_artifacts_exist(test_dir, command_type, state):
+    """Check if all expected artifacts exist."""
+    endpoint = state.get("endpoint", "unknown")
+    missing_artifacts = []
+    found_artifacts = []
+
+    # Define expected artifacts by command type
+    if command_type == "api-create":
+        expected = {
+            f"src/app/api/v2/{endpoint}/route.ts": "API route handler",
+            f"src/app/api/v2/{endpoint}/schema.ts": "Zod schema definitions",
+            f"src/app/api/v2/{endpoint}/__tests__/{endpoint}.api.test.ts": "API tests",
+            f"src/app/api/v2/{endpoint}/README.md": "API documentation"
+        }
+    elif command_type == "hustle-ui-create":
+        component_name = state.get("component_name", endpoint)
+        expected = {
+            f"src/components/{component_name}/{component_name}.tsx": "Component file",
+            f"src/components/{component_name}/{component_name}.test.tsx": "Component tests",
+            f"src/components/{component_name}/{component_name}.stories.tsx": "Storybook story"
+        }
+    elif command_type == "hustle-ui-create-page":
+        page_route = state.get("page_route", endpoint)
+        expected = {
+            f"src/app/{page_route}/page.tsx": "Page file",
+            f"e2e/{page_route}.spec.ts": "E2E tests"
+        }
+    elif command_type == "hustle-combine":
+        expected = {
+            f"src/app/api/v2/{endpoint}/route.ts": "Combined API route",
+            f"src/app/api/v2/{endpoint}/schema.ts": "Combined schema",
+            f"src/app/api/v2/{endpoint}/__tests__/{endpoint}.api.test.ts": "Integration tests"
+        }
+    elif command_type == "hustle-build":
+        # Build creates multiple artifacts - check decomposition
+        expected = {}  # Will be checked differently
+    else:
+        return {
+            "complete": False,
+            "error": f"Unknown command type: {command_type}"
+        }
+
+    # Check each artifact
+    test_path = Path(test_dir)
+    for artifact_path, description in expected.items():
+        full_path = test_path / artifact_path
+        if full_path.exists():
+            found_artifacts.append({"path": artifact_path, "description": description})
+        else:
+            missing_artifacts.append({"path": artifact_path, "description": description})
+
+    return {
+        "complete": len(missing_artifacts) == 0,
+        "found": found_artifacts,
+        "missing": missing_artifacts
+    }
+
+
+def check_registry_updated(test_dir, command_type):
+    """Check if registry.json was updated."""
+    registry_file = Path(test_dir) / ".claude" / "registry.json"
+
+    if not registry_file.exists():
+        return {"complete": False, "reason": "Registry file missing"}
+
+    try:
+        registry = json.loads(registry_file.read_text())
+
+        # Check if there are entries
+        if command_type == "api-create":
+            apis = registry.get("apis", [])
+            if len(apis) == 0:
+                return {"complete": False, "reason": "No APIs in registry"}
+        elif command_type == "hustle-ui-create":
+            components = registry.get("components", [])
+            if len(components) == 0:
+                return {"complete": False, "reason": "No components in registry"}
+        elif command_type == "hustle-ui-create-page":
+            pages = registry.get("pages", [])
+            if len(pages) == 0:
+                return {"complete": False, "reason": "No pages in registry"}
+
+        return {"complete": True}
+
+    except Exception as e:
+        return {"complete": False, "reason": f"Error reading registry: {e}"}
+
+
+def check_workflow_logs(test_dir):
+    """Check if workflow events were logged."""
+    logs_dir = Path(test_dir) / ".claude" / "workflow-logs"
+
+    if not logs_dir.exists():
+        return {"complete": False, "reason": "Workflow logs directory missing"}
+
+    log_files = list(logs_dir.glob("*.json"))
+
+    if len(log_files) == 0:
+        return {"complete": False, "reason": "No workflow log files found"}
+
+    return {
+        "complete": True,
+        "log_files": [str(f.name) for f in log_files]
+    }
+
+
+def main():
+    if len(sys.argv) < 3:
+        print(json.dumps({
+            "error": "Usage: python test-completion-detector.py <test_directory> <command_type>"
+        }))
+        sys.exit(2)
+
+    test_dir = Path(sys.argv[1]).expanduser()
+    command_type = sys.argv[2]
+
+    if not test_dir.exists():
+        print(json.dumps({
+            "error": f"Test directory does not exist: {test_dir}"
+        }))
+        sys.exit(2)
+
+    # Load state
+    state = load_state(test_dir)
+
+    if not state:
+        print(json.dumps({
+            "complete": False,
+            "error": "Could not load api-dev-state.json"
+        }))
+        sys.exit(1)
+
+    # Run all checks
+    phases_check = check_phases_complete(state)
+    artifacts_check = check_artifacts_exist(test_dir, command_type, state)
+    registry_check = check_registry_updated(test_dir, command_type)
+    logs_check = check_workflow_logs(test_dir)
+
+    # Overall result
+    all_complete = (
+        phases_check["complete"] and
+        artifacts_check["complete"] and
+        registry_check["complete"] and
+        logs_check["complete"]
+    )
+
+    result = {
+        "complete": all_complete,
+        "timestamp": datetime.now().isoformat(),
+        "test_directory": str(test_dir),
+        "command_type": command_type,
+        "endpoint": state.get("endpoint", "unknown"),
+        "checks": {
+            "phases": phases_check,
+            "artifacts": artifacts_check,
+            "registry": registry_check,
+            "logs": logs_check
+        }
+    }
+
+    print(json.dumps(result, indent=2))
+
+    # Exit code based on result
+    if all_complete:
+        sys.exit(0)
+    else:
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()