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

package/hooks/ntfy-on-question.py

@@ -0,0 +1,240 @@
+#!/usr/bin/env python3
+"""
+NTFY notification hook for AskUserQuestion.
+
+Sends a push notification via NTFY when a question is asked,
+allowing the user to be notified on their phone/desktop.
+
+Hook Type: PostToolUse (matcher: AskUserQuestion)
+"""
+
+import json
+import os
+import sys
+from pathlib import Path
+
+try:
+    import requests
+    HAS_REQUESTS = True
+except ImportError:
+    HAS_REQUESTS = False
+
+
+def load_state():
+    """Load workflow state for context"""
+    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:
+            return json.loads(build_state.read_text())
+        except Exception:
+            pass
+
+    # Check api-dev state
+    api_state = Path(project_dir) / ".claude" / "api-dev-state.json"
+    if api_state.exists():
+        try:
+            return json.loads(api_state.read_text())
+        except Exception:
+            pass
+
+    return {}
+
+
+def get_ntfy_config():
+    """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
+        env_file = Path(project_dir) / ".env"
+
+        if env_file.exists():
+            try:
+                for line in env_file.read_text().splitlines():
+                    if line.startswith("NTFY_TOPIC="):
+                        topic = line.split("=", 1)[1].strip().strip('"\'')
+                    elif line.startswith("NTFY_SERVER="):
+                        server = line.split("=", 1)[1].strip().strip('"\'')
+            except Exception:
+                pass
+
+    return topic, server
+
+
+def send_notification(topic, server, title, message, priority="default", tags=None):
+    """Send notification via NTFY"""
+    if not HAS_REQUESTS:
+        # Fallback to curl
+        import subprocess
+        try:
+            headers = ["-H", f"Title: {title}", "-H", f"Priority: {priority}"]
+            if tags:
+                headers.extend(["-H", f"Tags: {','.join(tags)}"])
+
+            subprocess.run(
+                ["curl", "-s", "-d", message, *headers, f"{server}/{topic}"],
+                capture_output=True,
+                timeout=5
+            )
+            return True
+        except Exception:
+            return False
+
+    try:
+        headers = {
+            "Title": title,
+            "Priority": priority,
+        }
+        if tags:
+            headers["Tags"] = ",".join(tags)
+
+        response = requests.post(
+            f"{server}/{topic}",
+            data=message.encode("utf-8"),
+            headers=headers,
+            timeout=5
+        )
+        return response.status_code == 200
+    except Exception:
+        return False
+
+
+def extract_question_summary(tool_input):
+    """Extract question summary from tool input"""
+    try:
+        data = json.loads(tool_input)
+        questions = data.get("questions", [])
+
+        if not questions:
+            return None, None
+
+        # Get first question
+        q = questions[0]
+        header = q.get("header", "Question")
+        question = q.get("question", "")
+        options = q.get("options", [])
+
+        # Truncate question for notification
+        if len(question) > 100:
+            question = question[:97] + "..."
+
+        # Add option count
+        option_text = f" ({len(options)} options)"
+
+        return header, question + option_text
+    except Exception:
+        return None, None
+
+
+def main():
+    tool_input = os.environ.get("CLAUDE_TOOL_INPUT", "{}")
+
+    # Check if in auto mode (skip notification in auto mode)
+    state = load_state()
+    if state.get("mode") == "auto":
+        # In auto mode, questions are auto-answered
+        # Only notify on errors, not questions
+        print(json.dumps({"continue": True}))
+        return
+
+    # Get NTFY config
+    topic, server = get_ntfy_config()
+
+    if not topic:
+        # NTFY not configured, skip
+        print(json.dumps({"continue": True}))
+        return
+
+    # Extract question info
+    header, message = extract_question_summary(tool_input)
+
+    if not header or not message:
+        print(json.dumps({"continue": True}))
+        return
+
+    # Build context for notification
+    workflow = state.get("workflow", "")
+    endpoint = state.get("active_endpoint") or state.get("active_element") or ""
+    phase = ""
+
+    # Find current phase
+    phases = state.get("phases", {})
+    for phase_name, phase_data in phases.items():
+        if phase_data.get("status") == "in_progress":
+            phase = phase_name.replace("_", " ").title()
+            break
+
+    # Build title
+    title_parts = ["Hustle Dev"]
+    if workflow:
+        title_parts.append(workflow)
+    if endpoint:
+        title_parts.append(endpoint)
+    title = " - ".join(title_parts)
+
+    # Build message
+    full_message = f"{header}: {message}"
+    if phase:
+        full_message = f"[{phase}] {full_message}"
+
+    # Determine priority
+    priority = "default"
+    tags = ["question", "hustle"]
+
+    # Higher priority for blocking questions
+    if "required" in message.lower() or "must" in message.lower():
+        priority = "high"
+        tags.append("warning")
+
+    # Send notification
+    success = send_notification(topic, server, title, full_message, priority, tags)
+
+    # Log notification
+    if success:
+        project_dir = os.environ.get("CLAUDE_PROJECT_DIR", ".")
+        logs_dir = Path(project_dir) / ".claude" / "workflow-logs"
+        logs_dir.mkdir(parents=True, exist_ok=True)
+
+        log_file = logs_dir / "ntfy-log.json"
+        try:
+            if log_file.exists():
+                log = json.loads(log_file.read_text())
+            else:
+                log = {"notifications": []}
+
+            from datetime import datetime
+            log["notifications"].append({
+                "timestamp": datetime.now().isoformat(),
+                "title": title,
+                "message": full_message,
+                "workflow": workflow,
+                "endpoint": endpoint
+            })
+
+            log_file.write_text(json.dumps(log, indent=2))
+        except Exception:
+            pass
+
+    print(json.dumps({"continue": True}))
+
+
+if __name__ == "__main__":
+    main()

package/hooks/orchestrator-completion.py

@@ -0,0 +1,313 @@
+#!/usr/bin/env python3
+"""
+Orchestrator completion hook.
+
+After a Skill completes, this hook updates the orchestration state
+and determines the next workflow to execute.
+
+Hook Type: PostToolUse (matcher: Skill)
+"""
+
+import json
+import os
+from pathlib import Path
+from datetime import datetime
+
+try:
+    import requests
+    HAS_REQUESTS = True
+except ImportError:
+    HAS_REQUESTS = False
+
+
+def load_build_state():
+    """Load hustle-build orchestration state"""
+    project_dir = os.environ.get("CLAUDE_PROJECT_DIR", ".")
+    state_file = Path(project_dir) / ".claude" / "hustle-build-state.json"
+
+    if state_file.exists():
+        try:
+            return json.loads(state_file.read_text())
+        except Exception:
+            pass
+    return None
+
+
+def save_build_state(state):
+    """Save hustle-build orchestration state"""
+    project_dir = os.environ.get("CLAUDE_PROJECT_DIR", ".")
+    state_file = Path(project_dir) / ".claude" / "hustle-build-state.json"
+
+    try:
+        state_file.write_text(json.dumps(state, indent=2))
+        return True
+    except Exception:
+        return False
+
+
+def load_api_state():
+    """Load api-dev state to check completion"""
+    project_dir = os.environ.get("CLAUDE_PROJECT_DIR", ".")
+    state_file = Path(project_dir) / ".claude" / "api-dev-state.json"
+
+    if state_file.exists():
+        try:
+            return json.loads(state_file.read_text())
+        except Exception:
+            pass
+    return {}
+
+
+def get_skill_name(tool_input):
+    """Extract skill name from tool input"""
+    try:
+        data = json.loads(tool_input)
+        return data.get("skill", "")
+    except Exception:
+        return ""
+
+
+def check_workflow_complete(api_state):
+    """Check if the current workflow completed successfully"""
+    phases = api_state.get("phases", {})
+
+    # Check if documentation phase is complete (last phase)
+    doc_phase = phases.get("documentation", {})
+    if doc_phase.get("status") == "complete":
+        return True
+
+    # Alternative: check verification
+    verify_phase = phases.get("verify", {})
+    if verify_phase.get("status") == "complete":
+        return True
+
+    return False
+
+
+def find_next_workflow(build_state):
+    """Find the next pending workflow based on dependencies"""
+    decomposition = build_state.get("decomposition", {})
+    completed_names = set()
+
+    # Collect completed workflow names
+    for wf_type in ["apis", "components", "combined_apis", "pages"]:
+        workflows = decomposition.get(wf_type, [])
+        for wf in workflows:
+            if wf.get("status") == "complete":
+                completed_names.add(wf.get("name"))
+
+    # Find first pending workflow with satisfied dependencies
+    for wf_type in ["apis", "components", "combined_apis", "pages"]:
+        workflows = decomposition.get(wf_type, [])
+        for wf in workflows:
+            if wf.get("status") != "pending":
+                continue
+
+            # Check dependencies
+            deps = wf.get("depends_on", [])
+            if all(dep in completed_names for dep in deps):
+                return wf, wf_type
+
+    return None, None
+
+
+def send_ntfy(title, message, priority="default"):
+    """Send NTFY notification"""
+    topic = os.environ.get("NTFY_TOPIC")
+    server = os.environ.get("NTFY_SERVER", "https://ntfy.sh")
+
+    if not topic:
+        return
+
+    try:
+        if HAS_REQUESTS:
+            requests.post(
+                f"{server}/{topic}",
+                data=message.encode("utf-8"),
+                headers={"Title": title, "Priority": priority, "Tags": "hustle,check"},
+                timeout=5
+            )
+        else:
+            import subprocess
+            subprocess.run(
+                ["curl", "-s", "-d", message, "-H", f"Title: {title}", f"{server}/{topic}"],
+                capture_output=True,
+                timeout=5
+            )
+    except Exception:
+        pass
+
+
+def main():
+    tool_input = os.environ.get("CLAUDE_TOOL_INPUT", "{}")
+    tool_result = os.environ.get("CLAUDE_TOOL_RESULT", "")
+
+    # Get skill that completed
+    skill_name = get_skill_name(tool_input)
+
+    # Check if this is a workflow skill
+    workflow_skills = [
+        "api-create", "hustle-ui-create", "hustle-ui-create-page",
+        "hustle-combine", "cycle"
+    ]
+
+    if skill_name not in workflow_skills:
+        print(json.dumps({"continue": True}))
+        return
+
+    # Check if we're in an orchestrated build
+    build_state = load_build_state()
+
+    if not build_state or build_state.get("status") != "in_progress":
+        print(json.dumps({"continue": True}))
+        return
+
+    # Check if the workflow completed successfully
+    api_state = load_api_state()
+    workflow_complete = check_workflow_complete(api_state)
+
+    # Get active workflow info
+    active = build_state.get("active_sub_workflow", {})
+    active_name = active.get("name")
+    active_type = active.get("type")
+
+    # Update workflow status
+    decomposition = build_state.get("decomposition", {})
+
+    if workflow_complete and active_name:
+        # Mark workflow as complete
+        for wf_type in ["apis", "components", "combined_apis", "pages"]:
+            workflows = decomposition.get(wf_type, [])
+            for wf in workflows:
+                if wf.get("name") == active_name:
+                    wf["status"] = "complete"
+                    wf["completed_at"] = datetime.now().isoformat()
+
+        # Add to completed list
+        if "completed_sub_workflows" not in build_state:
+            build_state["completed_sub_workflows"] = []
+
+        build_state["completed_sub_workflows"].append({
+            "type": active_type,
+            "name": active_name,
+            "completed_at": datetime.now().isoformat()
+        })
+
+    # Find next workflow
+    next_wf, next_type = find_next_workflow(build_state)
+
+    if next_wf:
+        # Set next as active
+        build_state["active_sub_workflow"] = {
+            "type": next_type.rstrip("s"),
+            "name": next_wf.get("name"),
+            "workflow_id": f"wf-{len(build_state.get('completed_sub_workflows', []))+1:03d}"
+        }
+
+        # Mark as in progress
+        next_wf["status"] = "in_progress"
+        next_wf["started_at"] = datetime.now().isoformat()
+
+        save_build_state(build_state)
+
+        # Determine which skill to run
+        skill_mapping = {
+            "api": "/api-create",
+            "component": "/hustle-ui-create",
+            "combined_api": "/hustle-combine api",
+            "page": "/hustle-ui-create-page"
+        }
+
+        next_skill = skill_mapping.get(next_type.rstrip("s"), "/api-create")
+        next_name = next_wf.get("name")
+
+        context = f"""
+## Workflow Complete: {active_name}
+
+The [{active_type}] **{active_name}** workflow has completed.
+
+### Next Workflow: [{next_type}] {next_name}
+
+Run: `{next_skill} {next_name}`
+
+Progress: {len(build_state.get('completed_sub_workflows', []))}/{sum(len(decomposition.get(t, [])) for t in decomposition)} complete
+"""
+
+        result = {
+            "continue": True,
+            "additionalContext": context
+        }
+
+    else:
+        # All workflows complete!
+        build_state["status"] = "complete"
+        build_state["completed_at"] = datetime.now().isoformat()
+        build_state["active_sub_workflow"] = None
+
+        save_build_state(build_state)
+
+        # Send completion notification
+        completed_count = len(build_state.get("completed_sub_workflows", []))
+        build_id = build_state.get("build_id", "unknown")
+
+        send_ntfy(
+            "Hustle Build Complete!",
+            f"All {completed_count} workflows finished.\nReview: /hustle-build-review {build_id}",
+            "high"
+        )
+
+        context = f"""
+## BUILD COMPLETE
+
+All workflows have finished successfully!
+
+**Build ID:** {build_id}
+**Total Workflows:** {completed_count}
+**Duration:** {calculate_duration(build_state)}
+
+### Created Elements:
+{format_created_elements(build_state)}
+
+### Next Steps:
+- `/hustle-build-review {build_id}` - Review all decisions and results
+- `/commit` - Commit all changes
+- `/pr` - Create pull request
+
+Visit `/hustle-dev-dashboard` to see all created elements.
+"""
+
+        result = {
+            "continue": True,
+            "additionalContext": context
+        }
+
+    print(json.dumps(result))
+
+
+def calculate_duration(build_state):
+    """Calculate build duration"""
+    try:
+        started = datetime.fromisoformat(build_state.get("created_at", ""))
+        ended = datetime.fromisoformat(build_state.get("completed_at", datetime.now().isoformat()))
+        duration = ended - started
+        minutes = int(duration.total_seconds() / 60)
+        return f"{minutes} minutes"
+    except Exception:
+        return "Unknown"
+
+
+def format_created_elements(build_state):
+    """Format list of created elements"""
+    completed = build_state.get("completed_sub_workflows", [])
+    lines = []
+
+    for wf in completed:
+        wf_type = wf.get("type", "unknown")
+        name = wf.get("name", "unnamed")
+        lines.append(f"  - [{wf_type}] {name}")
+
+    return "\n".join(lines) if lines else "  None"
+
+
+if __name__ == "__main__":
+    main()