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

package/commands/hustle-api-create.md

@@ -468,6 +468,28 @@ Both conditions must be true for the flag to be set.
 └───────────────────────────────────────────────────────────┘
 ```
 
+### End-of-Workflow Summary
+
+After successful API creation, display:
+
+```
+═══════════════════════════════════════════════════════════════
+✅ API CREATED: [endpoint-name]
+
+📍 Quick Links:
+  • Test it:     /api-showcase
+  • API Docs:    /docs/api/[endpoint-name]
+  • Run tests:   pnpm test src/app/api/v2/[endpoint-name]
+  • TypeDoc:     pnpm typedoc
+
+📊 Dashboard:    /hustle-dev-dashboard
+
+Next Steps:
+  • /hustle-combine - Combine with other APIs
+  • /commit - Commit your changes
+═══════════════════════════════════════════════════════════════
+```
+
 ### Showcase Redirect
 
 After successful API creation, output:

package/commands/hustle-combine.md

@@ -1,9 +1,65 @@
-# Hustle Combine - API and UI Orchestration Workflow v3.11.0
+# Hustle Combine - API and UI Orchestration Workflow v4.0.0
 
-**Usage:** `/hustle-combine [api|ui]`
+**Usage:** `/hustle-combine [api|ui] [--auto] [--resume [workflow-id]]`
 
 **Purpose:** Combines existing APIs or UI elements from the registry into new orchestration endpoints or composed components.
 
+## Arguments
+
+- `[api|ui]` - Mode: combine APIs or UI elements
+- `--auto` - Fully autonomous mode, auto-answers all questions with comprehensive defaults
+- `--resume [workflow-id]` - Resume an interrupted workflow from its last phase
+
+---
+
+## Auto Mode (`--auto`)
+
+When `--auto` flag is used:
+
+1. **No Interactive Questions:**
+   - All questions auto-answered with comprehensive defaults
+   - Uses `.claude/hustle-build-defaults.json` for configured answers
+   - Falls back to "most comprehensive" option when no default exists
+
+2. **Comprehensive Selection Logic:**
+   - Selects parallel execution (when APIs are independent)
+   - Uses partial-success error handling
+   - Enables unified caching strategy
+   - Uses exponential retry with 30s timeout
+
+3. **API Selection in Orchestrated Mode:**
+   - When `orchestrated: true`, APIs are pre-selected by orchestrator
+   - Selection phase is skipped, proceeds directly to Scope
+
+4. **Logging:**
+   - All decisions logged to `.claude/workflow-logs/hustle-combine/[workflow-id].json`
+   - Review with `/hustle-combine-review [workflow-id]`
+
+---
+
+## Resume Mode (`--resume`)
+
+When `--resume [workflow-id]` is used:
+
+1. Load state from `.claude/api-dev-state.json`
+2. Find the last incomplete phase
+3. Continue from that point
+4. Preserve all previous decisions and API selections
+
+---
+
+## Orchestrated Mode
+
+When running as part of `/hustle-build`:
+
+1. `orchestrated: true` flag is set in state
+2. `shared_decisions` are pre-filled from orchestrator interview
+3. Source APIs are pre-selected based on orchestrator decomposition
+4. Questions covered by shared_decisions are SKIPPED
+5. Only combination-specific questions are asked (execution order, caching)
+
+---
+
 ## Overview
 
 This command reads from `.claude/registry.json` to present available elements for combination. It creates NEW orchestration layers using EXISTING, tested components.
@@ -837,6 +893,29 @@ Update registry.json with the new combined API:
 }
 ```
 
+### End-of-Workflow Summary
+
+After successful combination, display:
+
+```
+═══════════════════════════════════════════════════════════════
+✅ COMBINED API CREATED: [combined-name]
+
+📍 Quick Links:
+  • Test it:     /api-showcase
+  • API Docs:    /docs/api/[combined-name]
+  • Run tests:   pnpm test src/app/api/v2/[combined-name]
+  • TypeDoc:     pnpm typedoc
+
+📦 Combined:     [api1] + [api2]
+📊 Dashboard:    /hustle-dev-dashboard
+
+Next Steps:
+  • /commit - Commit your changes
+  • /hustle-api-create - Create another API
+═══════════════════════════════════════════════════════════════
+```
+
 ---
 
 ## Mode B: Combine UI (Coming Soon)

package/commands/hustle-ui-create-page.md

@@ -5,11 +5,71 @@ argument-hint: [page-name]
 
 # Hustle UI Create - Page Mode
 
-**Version:** 3.11.0
+**Version:** 4.0.0
 **14-phase workflow for creating Next.js App Router pages**
 
+**Usage:** `/hustle-ui-create-page [page-name] [--auto] [--resume [workflow-id]]`
+
 You are creating a page using the Hustle Together interview-driven workflow.
 
+## Arguments
+
+- `[page-name]` - Name of the page to create
+- `--auto` - Fully autonomous mode, auto-answers all questions with comprehensive defaults
+- `--resume [workflow-id]` - Resume an interrupted workflow from its last phase
+
+---
+
+## Auto Mode (`--auto`)
+
+When `--auto` flag is used:
+
+1. **No Interactive Questions:**
+   - All questions auto-answered with comprehensive defaults
+   - Uses `.claude/hustle-build-defaults.json` for configured answers
+   - Falls back to "most comprehensive" option when no default exists
+
+2. **Comprehensive Selection Logic:**
+   - Uses responsive-grid layout
+   - Enables full SEO (Open Graph, Twitter cards, JSON-LD)
+   - Creates loading states and error boundaries
+   - Enables prefetching and Suspense
+   - Uses all available components from registry
+
+3. **Error Handling:**
+   - E2E test failures: Retry 3x, then log and continue
+   - Missing API routes: Log warning, create stubs
+   - Performance budget exceeded: Log warning, continue
+
+4. **Logging:**
+   - All decisions logged to `.claude/workflow-logs/ui-create-page/[workflow-id].json`
+   - Review with `/hustle-ui-create-page-review [workflow-id]`
+
+---
+
+## Resume Mode (`--resume`)
+
+When `--resume [workflow-id]` is used:
+
+1. Load state from `.claude/api-dev-state.json`
+2. Find the last incomplete phase
+3. Continue from that point
+4. Preserve all previous decisions
+
+---
+
+## Orchestrated Mode
+
+When running as part of `/hustle-build`:
+
+1. `orchestrated: true` flag is set in state
+2. `shared_decisions` are pre-filled from orchestrator interview
+3. Questions covered by shared_decisions are SKIPPED (e.g., auth, brand guide, testing level)
+4. Components to use are pre-selected based on orchestrator decomposition
+5. Only page-specific questions are asked (layout, SEO details)
+
+---
+
 ## Pre-Flight Check
 
 Before starting, verify state file exists:
@@ -911,6 +971,28 @@ Run `pnpm dev` and navigate to /ui-showcase to see it.
 
 Update state: `phases.completion.status = "complete"`
 
+### End-of-Workflow Summary
+
+After successful page creation, display:
+
+```
+═══════════════════════════════════════════════════════════════
+✅ PAGE CREATED: [PageName]
+
+📍 Quick Links:
+  • View page:    /[page-name]
+  • UI Showcase:  /ui-showcase
+  • Run E2E:      pnpm playwright test src/app/[page-name]
+
+📊 Dashboard:    /hustle-dev-dashboard
+
+Next Steps:
+  • /hustle-ui-create - Create components for this page
+  • /hustle-api-create - Create APIs this page needs
+  • /commit - Commit your changes
+═══════════════════════════════════════════════════════════════
+```
+
 ---
 
 # State File Structure
@@ -992,5 +1074,5 @@ Update state: `phases.completion.status = "complete"`
 
 ---
 
-**Version:** 3.11.0
+**Version:** 4.0.0
 **Last Updated:** 2025-12-28

package/commands/hustle-ui-create.md

@@ -5,11 +5,69 @@ argument-hint: [component-name]
 
 # Hustle UI Create
 
-**Version:** 3.11.0
+**Version:** 4.0.0
 **14-phase workflow for creating UI components and pages**
 
+**Usage:** `/hustle-ui-create [component-name] [--auto] [--resume [workflow-id]]`
+
 You are creating a UI element using the Hustle Together interview-driven workflow.
 
+## Arguments
+
+- `[component-name]` - Name of the component to create
+- `--auto` - Fully autonomous mode, auto-answers all questions with comprehensive defaults
+- `--resume [workflow-id]` - Resume an interrupted workflow from its last phase
+
+---
+
+## Auto Mode (`--auto`)
+
+When `--auto` flag is used:
+
+1. **No Interactive Questions:**
+   - All questions auto-answered with comprehensive defaults
+   - Uses `.claude/hustle-build-defaults.json` for configured answers
+   - Falls back to "most comprehensive" option when no default exists
+
+2. **Comprehensive Selection Logic:**
+   - Selects ALL variants (size, color, state)
+   - Enables full accessibility (WCAG 2.1 AA)
+   - Enables animations and responsive design
+   - Creates all Storybook stories
+
+3. **Error Handling:**
+   - Test failures: Retry 3x, then log and continue
+   - Visual regression: Update baselines automatically
+   - Missing packages: Install automatically
+
+4. **Logging:**
+   - All decisions logged to `.claude/workflow-logs/ui-create/[workflow-id].json`
+   - Review with `/hustle-ui-create-review [workflow-id]`
+
+---
+
+## Resume Mode (`--resume`)
+
+When `--resume [workflow-id]` is used:
+
+1. Load state from `.claude/api-dev-state.json`
+2. Find the last incomplete phase
+3. Continue from that point
+4. Preserve all previous decisions
+
+---
+
+## Orchestrated Mode
+
+When running as part of `/hustle-build`:
+
+1. `orchestrated: true` flag is set in state
+2. `shared_decisions` are pre-filled from orchestrator interview
+3. Questions covered by shared_decisions are SKIPPED (e.g., brand guide, testing level)
+4. Only component-specific questions are asked (variants, props)
+
+---
+
 ## Pre-Flight Check
 
 Before starting, verify state file exists:
@@ -901,6 +959,28 @@ For Sandpack live editing, install: `pnpm add @codesandbox/sandpack-react`
 
 Update state: `phases.completion.status = "complete"`
 
+### End-of-Workflow Summary
+
+After successful component creation, display:
+
+```
+═══════════════════════════════════════════════════════════════
+✅ COMPONENT CREATED: [ComponentName]
+
+📍 Quick Links:
+  • Preview it:   /ui-showcase
+  • Storybook:    http://localhost:6006
+  • Run tests:    pnpm test src/components/[ComponentName]
+  • Visual tests: pnpm playwright test --grep "[ComponentName]"
+
+📊 Dashboard:    /hustle-dev-dashboard
+
+Next Steps:
+  • /hustle-ui-create-page - Create a page using this component
+  • /commit - Commit your changes
+═══════════════════════════════════════════════════════════════
+```
+
 ---
 
 # Page Mode (14 Phases)
@@ -974,5 +1054,5 @@ See full page mode documentation in `/hustle-ui-create-page.md` (if implementing
 
 ---
 
-**Version:** 3.11.0
+**Version:** 4.0.0
 **Last Updated:** 2025-12-28

package/hooks/auto-answer.py

@@ -0,0 +1,228 @@
+#!/usr/bin/env python3
+"""
+Auto-answer hook for --auto mode.
+
+This hook intercepts AskUserQuestion calls when running in auto-mode
+and either:
+1. Uses pre-configured defaults from hustle-build-defaults.json
+2. Spawns a Haiku sub-agent to pick the most comprehensive option
+
+Hook Type: PreToolUse (matcher: AskUserQuestion)
+"""
+
+import json
+import os
+import sys
+from pathlib import Path
+
+
+def load_state():
+    """Load workflow state to check if in auto mode"""
+    project_dir = os.environ.get("CLAUDE_PROJECT_DIR", ".")
+
+    # Check hustle-build state first
+    build_state = Path(project_dir) / ".claude" / "hustle-build-state.json"
+    if build_state.exists():
+        try:
+            state = json.loads(build_state.read_text())
+            if state.get("mode") == "auto":
+                return state, "build"
+        except Exception:
+            pass
+
+    # Check api-dev state
+    api_state = Path(project_dir) / ".claude" / "api-dev-state.json"
+    if api_state.exists():
+        try:
+            state = json.loads(api_state.read_text())
+            if state.get("mode") == "auto":
+                return state, "workflow"
+        except Exception:
+            pass
+
+    return None, None
+
+
+def load_defaults():
+    """Load pre-configured default answers"""
+    project_dir = os.environ.get("CLAUDE_PROJECT_DIR", ".")
+    defaults_file = Path(project_dir) / ".claude" / "hustle-build-defaults.json"
+
+    if defaults_file.exists():
+        try:
+            return json.loads(defaults_file.read_text())
+        except Exception:
+            pass
+
+    return {}
+
+
+def find_comprehensive_option(options):
+    """
+    Find the most comprehensive option based on keywords.
+
+    Comprehensive options typically include words like:
+    - "all", "full", "complete", "comprehensive"
+    - Higher numbers (e.g., "100%" vs "50%")
+    - More features listed
+    """
+    if not options:
+        return None
+
+    comprehensive_keywords = [
+        "all", "full", "complete", "comprehensive", "everything",
+        "maximum", "extensive", "detailed", "thorough", "wcag-aa"
+    ]
+
+    # Score each option
+    scored = []
+    for i, opt in enumerate(options):
+        label = opt.get("label", "").lower()
+        description = opt.get("description", "").lower()
+        text = f"{label} {description}"
+
+        score = 0
+
+        # Check for comprehensive keywords
+        for keyword in comprehensive_keywords:
+            if keyword in text:
+                score += 10
+
+        # Check for "(Recommended)" suffix
+        if "recommended" in label.lower():
+            score += 20
+
+        # Prefer options with more content (longer descriptions = more features)
+        score += len(description) / 50
+
+        scored.append((i, score, opt))
+
+    # Sort by score descending
+    scored.sort(key=lambda x: x[1], reverse=True)
+
+    # Return the index of the best option (0-based)
+    if scored:
+        return scored[0][0]
+
+    return 0  # Default to first option
+
+
+def get_question_key(questions):
+    """Extract a key from the question for lookup in defaults"""
+    if not questions or len(questions) == 0:
+        return None
+
+    q = questions[0]
+    header = q.get("header", "").lower().replace(" ", "_")
+    return header
+
+
+def main():
+    # Get tool input from environment
+    tool_input = os.environ.get("CLAUDE_TOOL_INPUT", "{}")
+
+    try:
+        input_data = json.loads(tool_input)
+    except Exception:
+        print(json.dumps({"continue": True}))
+        return
+
+    # Check if in auto mode
+    state, state_type = load_state()
+
+    if not state:
+        # Not in auto mode, continue normally
+        print(json.dumps({"continue": True}))
+        return
+
+    # Load defaults
+    defaults = load_defaults()
+
+    questions = input_data.get("questions", [])
+    if not questions:
+        print(json.dumps({"continue": True}))
+        return
+
+    # Try to find pre-configured answer
+    question_key = get_question_key(questions)
+    answers = {}
+
+    for q in questions:
+        header = q.get("header", "")
+        options = q.get("options", [])
+        question_text = q.get("question", "")
+
+        # Check defaults first
+        default_answer = None
+        if question_key and question_key in defaults:
+            default_answer = defaults[question_key]
+        elif header.lower().replace(" ", "_") in defaults:
+            default_answer = defaults[header.lower().replace(" ", "_")]
+
+        if default_answer is not None:
+            # Use pre-configured default
+            answers[question_text] = default_answer
+        else:
+            # Auto-select comprehensive option
+            best_idx = find_comprehensive_option(options)
+            if best_idx is not None and options:
+                answers[question_text] = options[best_idx].get("label", "")
+
+    if answers:
+        # Log the auto-answer
+        log_auto_answer(state, questions, answers)
+
+        # Return the auto-selected answers
+        # The hook will inject these as if the user selected them
+        result = {
+            "continue": True,
+            "additionalContext": f"""
+## Auto-Mode Active
+
+Questions were auto-answered with comprehensive defaults:
+{json.dumps(answers, indent=2)}
+
+These selections prioritize:
+- Maximum feature coverage
+- Full testing
+- Comprehensive documentation
+- Best practices
+
+Review in `/hustle-build-review` after completion.
+"""
+        }
+        print(json.dumps(result))
+    else:
+        print(json.dumps({"continue": True}))
+
+
+def log_auto_answer(state, questions, answers):
+    """Log auto-answered questions to build log"""
+    project_dir = os.environ.get("CLAUDE_PROJECT_DIR", ".")
+    logs_dir = Path(project_dir) / ".claude" / "workflow-logs"
+    logs_dir.mkdir(parents=True, exist_ok=True)
+
+    build_id = state.get("build_id", state.get("workflow_id", "unknown"))
+    log_file = logs_dir / f"{build_id}.json"
+
+    try:
+        if log_file.exists():
+            log = json.loads(log_file.read_text())
+        else:
+            log = {"auto_answers": []}
+
+        from datetime import datetime
+        log["auto_answers"].append({
+            "timestamp": datetime.now().isoformat(),
+            "questions": [q.get("question") for q in questions],
+            "answers": answers,
+            "reason": "auto-comprehensive"
+        })
+
+        log_file.write_text(json.dumps(log, indent=2))
+    except Exception:
+        pass
+
+
+if __name__ == "__main__":
+    main()

package/hooks/check-update.py

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