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

package/hooks/api-workflow-check.py

@@ -17,6 +17,10 @@ v3.6.7 Enhancement:
 - Research cache location
 - Summary statistics
 
+v3.12.13 Fix:
+- Skip enforcement when running in source repository (developing the package)
+- Detect via package.json name = @hustle-together/api-dev-tools
+
 Returns:
   - {"decision": "approve"} - Allow stopping
   - {"decision": "block", "reason": "..."} - Prevent stopping with explanation
@@ -28,6 +32,36 @@ import re
 from datetime import datetime
 from pathlib import Path
 
+
+def is_source_repository() -> bool:
+    """
+    Check if we're running in the api-dev-tools source repository.
+    If so, hooks should NOT enforce workflow - we're developing, not using.
+    """
+    try:
+        # Use parent of hooks dir (project root), not cwd which may be hooks/
+        project_root = Path(__file__).parent.parent
+        package_json = project_root / "package.json"
+        if package_json.exists():
+            data = json.loads(package_json.read_text())
+            # If this is the source repo, skip enforcement
+            if data.get("name") == "@hustle-together/api-dev-tools":
+                return True
+
+        # Also check for templates/ folder (only exists in source repo)
+        if (project_root / "templates").is_dir():
+            return True
+
+    except Exception:
+        pass
+    return False
+
+
+# Skip enforcement in source repository
+if is_source_repository():
+    print(json.dumps({"decision": "approve"}))
+    sys.exit(0)
+
 # State file is in .claude/ directory (sibling to hooks/)
 STATE_FILE = Path(__file__).parent.parent / "api-dev-state.json"
 RESEARCH_DIR = Path(__file__).parent.parent / "research"

package/hooks/auto-answer.py

@@ -8,6 +8,10 @@ and either:
 2. Spawns a Haiku sub-agent to pick the most comprehensive option
 
 Hook Type: PreToolUse (matcher: AskUserQuestion)
+
+Updated in v4.5.0:
+  - Use shared hook_utils for logging
+  - Log all auto-answered questions to workflow logs
 """
 
 import json
@@ -15,6 +19,13 @@ import os
 import sys
 from pathlib import Path
 
+# Import shared utilities
+try:
+    from hook_utils import log_workflow_event
+    UTILS_AVAILABLE = True
+except ImportError:
+    UTILS_AVAILABLE = False
+
 
 def load_state():
     """Load workflow state to check if in auto mode"""
@@ -46,17 +57,33 @@ def load_state():
 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"
 
+    # Check project-specific defaults first
+    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
 
+    # Fall back to template defaults
+    template_defaults = Path(project_dir) / "templates" / "hustle-build-defaults.json"
+    if template_defaults.exists():
+        try:
+            return json.loads(template_defaults.read_text())
+        except Exception:
+            pass
+
     return {}
 
 
+def is_autonomous_enabled():
+    """Check if autonomous mode is enabled by default in settings"""
+    defaults = load_defaults()
+    autonomous = defaults.get("autonomous", {})
+    return autonomous.get("enabled", False) and autonomous.get("skip_interviews", False)
+
+
 def find_comprehensive_option(options):
     """
     Find the most comprehensive option based on keywords.
@@ -65,6 +92,9 @@ def find_comprehensive_option(options):
     - "all", "full", "complete", "comprehensive"
     - Higher numbers (e.g., "100%" vs "50%")
     - More features listed
+
+    Also prioritizes affirmative options for phase exits:
+    - "yes", "proceed", "continue", "approve", "confirm"
     """
     if not options:
         return None
@@ -74,6 +104,18 @@ def find_comprehensive_option(options):
         "maximum", "extensive", "detailed", "thorough", "wcag-aa"
     ]
 
+    # Affirmative keywords for phase exit questions
+    affirmative_keywords = [
+        "yes", "proceed", "continue", "approve", "confirm",
+        "accept", "ready", "go ahead", "move forward",
+        "auto", "defaults", "use auto", "use defaults"
+    ]
+
+    # Negative keywords to avoid
+    negative_keywords = [
+        "no", "skip", "cancel", "stop", "more research", "not ready"
+    ]
+
     # Score each option
     scored = []
     for i, opt in enumerate(options):
@@ -83,11 +125,21 @@ def find_comprehensive_option(options):
 
         score = 0
 
+        # Check for negative keywords first (penalize heavily)
+        for keyword in negative_keywords:
+            if keyword in text:
+                score -= 50
+
         # Check for comprehensive keywords
         for keyword in comprehensive_keywords:
             if keyword in text:
                 score += 10
 
+        # Check for affirmative keywords (high priority for phase exits)
+        for keyword in affirmative_keywords:
+            if keyword in text:
+                score += 25
+
         # Check for "(Recommended)" suffix
         if "recommended" in label.lower():
             score += 20
@@ -127,14 +179,19 @@ def main():
         print(json.dumps({"continue": True}))
         return
 
-    # Check if in auto mode
+    # Check if in auto mode (explicit flag OR defaults enabled)
     state, state_type = load_state()
+    autonomous_by_default = is_autonomous_enabled()
 
-    if not state:
-        # Not in auto mode, continue normally
+    if not state and not autonomous_by_default:
+        # Not in auto mode and autonomous not enabled, continue normally
         print(json.dumps({"continue": True}))
         return
 
+    # If no state but autonomous is enabled, create a minimal state
+    if not state and autonomous_by_default:
+        state = {"mode": "auto", "source": "defaults"}
+
     # Load defaults
     defaults = load_defaults()
 
@@ -172,23 +229,28 @@ def main():
         # 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
+        # Get the first question and answer for display
+        first_question = questions[0] if questions else {}
+        header = first_question.get("header", "Question")
+        question_text = first_question.get("question", "")
+        answer = list(answers.values())[0] if answers else "Unknown"
+
+        # BLOCK the tool and provide the answer in the reason
+        # This prevents the question UI from showing and tells the AI to use this answer
         result = {
-            "continue": True,
-            "additionalContext": f"""
-## Auto-Mode Active
+            "continue": False,
+            "reason": f"""## 🤖 Auto-Selected
+
+**{header}:** {answer}
 
-Questions were auto-answered with comprehensive defaults:
-{json.dumps(answers, indent=2)}
+_Question: {question_text}_
 
-These selections prioritize:
-- Maximum feature coverage
-- Full testing
-- Comprehensive documentation
-- Best practices
+---
 
-Review in `/hustle-build-review` after completion.
+Autonomous mode is active. The workflow will proceed with this answer.
+
+To review auto-selected answers: `.claude/workflow-logs/`
+To disable: Set `autonomous.enabled: false` in `.claude/hustle-build-defaults.json`
 """
         }
         print(json.dumps(result))
@@ -197,19 +259,34 @@ Review in `/hustle-build-review` after completion.
 
 
 def log_auto_answer(state, questions, answers):
-    """Log auto-answered questions to build log"""
+    """Log auto-answered questions to workflow log using shared utility (v4.5.0)"""
+    # Use shared utility if available
+    if UTILS_AVAILABLE:
+        try:
+            log_workflow_event("auto_answer", {
+                "questions": [q.get("question") for q in questions],
+                "headers": [q.get("header") for q in questions],
+                "answers": answers,
+                "reason": "auto-comprehensive",
+                "mode": state.get("mode", "auto") if state else "auto"
+            })
+            return
+        except Exception:
+            pass
+
+    # Fallback to legacy logging
     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"))
+    build_id = state.get("build_id", state.get("workflow_id", "unknown")) if state else "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": []}
+            log = {"auto_answers": [], "events": []}
 
         from datetime import datetime
         log["auto_answers"].append({

package/hooks/enforce-external-research.py

@@ -16,6 +16,9 @@ The hook triggers on:
 - ANY questions about tools, services, or platforms
 - ANY request for implementation, editing, or changes
 
+v3.12.13 Fix:
+- Skip enforcement when running in source repository (developing the package)
+
 Returns:
   - Prints context to stdout (injected into conversation)
   - Exit 0 to allow the prompt to proceed
@@ -26,6 +29,28 @@ import re
 from pathlib import Path
 from datetime import datetime
 
+# Import shared utilities
+try:
+    from hook_utils import is_source_repository
+except ImportError:
+    # Fallback if import fails
+    def is_source_repository():
+        try:
+            package_json = Path.cwd() / "package.json"
+            if package_json.exists():
+                data = json.loads(package_json.read_text())
+                if data.get("name") == "@hustle-together/api-dev-tools":
+                    return True
+            if (Path.cwd() / "templates").is_dir():
+                return True
+        except Exception:
+            pass
+        return False
+
+# Skip enforcement in source repository
+if is_source_repository():
+    sys.exit(0)
+
 # State file is in .claude/ directory (sibling to hooks/)
 STATE_FILE = Path(__file__).parent.parent / "api-dev-state.json"
 

package/hooks/enforce-interview.py

@@ -27,6 +27,13 @@ import json
 import sys
 from pathlib import Path
 
+# Import shared utilities for logging (v4.5.0)
+try:
+    from hook_utils import log_workflow_event
+    UTILS_AVAILABLE = True
+except ImportError:
+    UTILS_AVAILABLE = False
+
 # State file is in .claude/ directory (sibling to hooks/)
 STATE_FILE = Path(__file__).parent.parent / "api-dev-state.json"
 
@@ -333,6 +340,19 @@ WHY: User must approve their decisions before they drive implementation."""
         # Build a reminder of what the user decided
         decision_summary = _build_decision_summary(decisions)
 
+        # Log the interview decision being applied (v4.5.0)
+        if UTILS_AVAILABLE:
+            try:
+                log_workflow_event("interview_decision", {
+                    "action": "applying_decisions",
+                    "file_path": file_path,
+                    "decision_count": len(decisions),
+                    "decisions": {k: v.get("value", v.get("response", ""))[:100]
+                                  for k, v in decisions.items()}
+                })
+            except Exception:
+                pass
+
         # Allow but inject context about user decisions
         print(json.dumps({
             "permissionDecision": "allow",

package/hooks/ntfy-on-question.py

@@ -44,13 +44,26 @@ def load_state():
 
 
 def get_ntfy_config():
-    """Get NTFY configuration from environment or .env file"""
+    """Get NTFY configuration from environment, .env file, or hustle-build-defaults.json"""
     topic = os.environ.get("NTFY_TOPIC")
     server = os.environ.get("NTFY_SERVER", "https://ntfy.sh")
+    project_dir = os.environ.get("CLAUDE_PROJECT_DIR", ".")
+
+    if not topic:
+        # Try loading from hustle-build-defaults.json first
+        defaults_file = Path(project_dir) / ".claude" / "hustle-build-defaults.json"
+        if defaults_file.exists():
+            try:
+                defaults = json.loads(defaults_file.read_text())
+                ntfy_config = defaults.get("ntfy", {})
+                if ntfy_config.get("enabled", False):
+                    topic = ntfy_config.get("topic")
+                    server = ntfy_config.get("server", server)
+            except Exception:
+                pass
 
     if not topic:
         # Try loading from .env
-        project_dir = os.environ.get("CLAUDE_PROJECT_DIR", ".")
         env_file = Path(project_dir) / ".env"
 
         if env_file.exists():

package/hooks/orchestrator-handoff.py

@@ -162,8 +162,8 @@ def main():
     except Exception:
         pass
 
-    # Inject context about orchestration
-    context = f"""
+    # Build context about orchestration
+    context_parts = [f"""
 ## Orchestrated Workflow
 
 This workflow is part of a larger build: **{build_state.get('build_id')}**
@@ -175,7 +175,85 @@ These decisions are already applied. **Do not re-ask** questions about:
 {', '.join(shared_decisions.keys())}
 
 Only ask workflow-specific questions not covered above.
-"""
+"""]
+
+    # Check for project_spec and inject relevant portion
+    project_spec = build_state.get("project_spec", {})
+    extracted = project_spec.get("extracted", {})
+
+    if extracted:
+        # Try to find the relevant spec for this workflow
+        relevant_spec = None
+        spec_type = None
+
+        # Get the element name from tool input
+        try:
+            data = json.loads(tool_input)
+            args = data.get("args", "")
+            element_name = args.split()[0] if args else ""
+        except Exception:
+            element_name = ""
+
+        # Search in extracted elements
+        for api in extracted.get("apis", []):
+            if api.get("name", "").lower() == element_name.lower():
+                relevant_spec = api
+                spec_type = "API"
+                break
+
+        if not relevant_spec:
+            for comp in extracted.get("components", []):
+                if comp.get("name", "").lower() == element_name.lower():
+                    relevant_spec = comp
+                    spec_type = "Component"
+                    break
+
+        if not relevant_spec:
+            for page in extracted.get("pages", []):
+                if page.get("name", "").lower() == element_name.lower():
+                    relevant_spec = page
+                    spec_type = "Page"
+                    break
+
+        # Inject relevant spec if found
+        if relevant_spec:
+            context_parts.append(f"""
+### Project Spec ({spec_type})
+
+This element was extracted from the project document. Use this as the primary source of truth:
+
+```json
+{json.dumps(relevant_spec, indent=2)}
+```
+
+**Important:** Implement according to this specification. If you need to deviate, ask the user first.
+""")
+
+        # Also inject high-level summary if available
+        summary = extracted.get("summary", "")
+        if summary:
+            context_parts.append(f"""
+### Project Summary
+
+{summary}
+""")
+
+        # Inject related elements for context
+        uses_apis = relevant_spec.get("uses_apis", []) if relevant_spec else []
+        uses_components = relevant_spec.get("uses_components", []) if relevant_spec else []
+
+        if uses_apis or uses_components:
+            context_parts.append(f"""
+### Related Elements
+
+This element depends on:
+- APIs: {', '.join(uses_apis) if uses_apis else 'none'}
+- Components: {', '.join(uses_components) if uses_components else 'none'}
+
+Ensure types and interfaces align with these dependencies.
+""")
+
+    context = "\n".join(context_parts)
 
     result = {
         "continue": True,

package/hooks/periodic-reground.py

@@ -70,10 +70,38 @@ def get_registry_summary(registry):
         return None
 
     summary = {}
+    # Core elements
     for category in ["apis", "components", "pages", "combined"]:
         items = registry.get(category, {})
         if items:
             summary[category] = list(items.keys())
+
+    # Infrastructure tracking (v1.3.0+)
+    routes = registry.get("routes", {})
+    if routes and not routes.get("_description"):
+        # Has actual routes, not just template
+        actual_routes = [k for k in routes.keys() if not k.startswith("_")]
+        if actual_routes:
+            summary["routes"] = actual_routes
+
+    env_vars = registry.get("env_vars", {})
+    if env_vars:
+        actual_vars = [k for k in env_vars.keys() if not k.startswith("_")]
+        if actual_vars:
+            summary["env_vars"] = actual_vars
+
+    services = registry.get("services", {})
+    if services:
+        actual_services = [k for k in services.keys() if not k.startswith("_")]
+        if actual_services:
+            summary["services"] = actual_services
+
+    webhooks = registry.get("webhooks", {})
+    if webhooks:
+        actual_webhooks = [k for k in webhooks.keys() if not k.startswith("_")]
+        if actual_webhooks:
+            summary["webhooks"] = actual_webhooks
+
     return summary if summary else None
 
 
@@ -207,6 +235,18 @@ def build_reground_context(state, turn_count):
             parts.append(f"  - Components: {format_list(registry_summary['components'])}")
         if registry_summary.get("pages"):
             parts.append(f"  - Pages: {format_list(registry_summary['pages'])}")
+        if registry_summary.get("routes"):
+            parts.append(f"  - Routes: {format_list(registry_summary['routes'])}")
+
+    # === Infrastructure Awareness ===
+    if registry_summary:
+        if registry_summary.get("services"):
+            parts.append("")
+            parts.append(f"**External Services:** {format_list(registry_summary['services'])}")
+        if registry_summary.get("webhooks"):
+            parts.append(f"**Webhooks:** {format_list(registry_summary['webhooks'])}")
+        if registry_summary.get("env_vars"):
+            parts.append(f"**Env Vars Tracked:** {len(registry_summary['env_vars'])} variables")
 
     # === Deferred Features ===
     deferred = state.get("deferred_features", [])