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

package/.claude/hooks/session-logger.py

@@ -1,323 +0,0 @@
-#!/usr/bin/env python3
-"""
-Hook: Stop
-Purpose: Save session to .claude/api-sessions/ for later review
-
-This hook runs when a Claude Code session ends (Stop event).
-It saves the session data for the completed workflow including:
-  - State snapshot at completion
-  - Files created during the workflow
-  - Summary of phases completed
-  - Research sources used
-  - Interview decisions made
-
-Added in v3.6.7 for session logging support.
-
-Returns:
-  - JSON with session save info
-"""
-import json
-import sys
-import os
-from datetime import datetime
-from pathlib import Path
-import shutil
-
-# Import shared utilities for NTFY
-try:
-    from hook_utils import send_ntfy_notification
-    HAS_NTFY = True
-except ImportError:
-    HAS_NTFY = False
-
-STATE_FILE = Path(__file__).parent.parent / "api-dev-state.json"
-SESSIONS_DIR = Path(__file__).parent.parent / "api-sessions"
-RESEARCH_DIR = Path(__file__).parent.parent / "research"
-
-
-def get_active_endpoint(state):
-    """Get active endpoint - supports both old and new state formats."""
-    # New format (v3.6.7+): endpoints object with active_endpoint pointer
-    if "endpoints" in state and "active_endpoint" in state:
-        active = state.get("active_endpoint")
-        if active and active in state["endpoints"]:
-            return active, state["endpoints"][active]
-        return None, None
-
-    # Old format: single endpoint field
-    endpoint = state.get("endpoint")
-    if endpoint:
-        return endpoint, state
-
-    return None, None
-
-
-def get_completed_phases(endpoint_data):
-    """Get list of completed phases."""
-    completed = []
-    phases = endpoint_data.get("phases", {})
-
-    phase_order = [
-        "disambiguation", "scope", "research_initial", "interview",
-        "research_deep", "schema_creation", "environment_check",
-        "tdd_red", "tdd_green", "verify", "tdd_refactor", "documentation", "completion"
-    ]
-
-    for phase_name in phase_order:
-        phase = phases.get(phase_name, {})
-        if phase.get("status") == "complete":
-            completed.append(phase_name)
-
-    return completed
-
-
-def get_files_created(endpoint_data):
-    """Get list of files created during this workflow."""
-    files = []
-
-    # From completion phase
-    completion = endpoint_data.get("phases", {}).get("completion", {})
-    files.extend(completion.get("files_created", []))
-
-    # From schema phase
-    schema = endpoint_data.get("phases", {}).get("schema_creation", {})
-    if schema.get("schema_file"):
-        files.append(schema.get("schema_file"))
-
-    # From TDD phases
-    tdd_red = endpoint_data.get("phases", {}).get("tdd_red", {})
-    if tdd_red.get("test_file"):
-        files.append(tdd_red.get("test_file"))
-
-    tdd_green = endpoint_data.get("phases", {}).get("tdd_green", {})
-    if tdd_green.get("implementation_file"):
-        files.append(tdd_green.get("implementation_file"))
-
-    return list(set(files))  # Deduplicate
-
-
-def generate_summary(endpoint, endpoint_data, state):
-    """Generate a markdown summary of the session."""
-    completed = get_completed_phases(endpoint_data)
-    files = get_files_created(endpoint_data)
-    decisions = endpoint_data.get("phases", {}).get("interview", {}).get("decisions", {})
-
-    lines = [
-        f"# Session Summary: {endpoint}",
-        "",
-        f"*Generated: {datetime.now().isoformat()}*",
-        "",
-        "## Overview",
-        "",
-        f"- **Endpoint:** {endpoint}",
-        f"- **Library:** {endpoint_data.get('library', 'N/A')}",
-        f"- **Started:** {endpoint_data.get('started_at', 'N/A')}",
-        f"- **Completed Phases:** {len(completed)}/13",
-        f"- **Status:** {endpoint_data.get('status', 'unknown')}",
-        "",
-        "## Phases Completed",
-        ""
-    ]
-
-    for i, phase in enumerate(completed, 1):
-        lines.append(f"{i}. {phase.replace('_', ' ').title()}")
-
-    lines.extend([
-        "",
-        "## Files Created",
-        ""
-    ])
-
-    for f in files:
-        lines.append(f"- `{f}`")
-
-    if decisions:
-        lines.extend([
-            "",
-            "## Interview Decisions",
-            ""
-        ])
-        for key, value in decisions.items():
-            response = value.get("response", value.get("value", "N/A"))
-            lines.append(f"- **{key}:** {response}")
-
-    lines.extend([
-        "",
-        "## Research Sources",
-        ""
-    ])
-
-    # Check for research cache
-    research_path = RESEARCH_DIR / endpoint / "sources.json"
-    if research_path.exists():
-        try:
-            sources = json.loads(research_path.read_text())
-            for src in sources.get("sources", [])[:10]:  # Limit to 10
-                url = src.get("url", src.get("query", ""))
-                if url:
-                    lines.append(f"- {url}")
-        except (json.JSONDecodeError, IOError):
-            lines.append("- (sources.json not readable)")
-    else:
-        lines.append("- (no sources.json found)")
-
-    lines.extend([
-        "",
-        "---",
-        "",
-        f"*Session saved to: .claude/api-sessions/{endpoint}_{{timestamp}}/*"
-    ])
-
-    return "\n".join(lines)
-
-
-def save_session(endpoint, endpoint_data, state):
-    """Save session to .claude/api-sessions/."""
-    # Create timestamp
-    timestamp = datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
-    session_dir = SESSIONS_DIR / f"{endpoint}_{timestamp}"
-    session_dir.mkdir(parents=True, exist_ok=True)
-
-    # 1. Save state snapshot
-    state_snapshot = {
-        "saved_at": datetime.now().isoformat(),
-        "endpoint": endpoint,
-        "endpoint_data": endpoint_data,
-        "turn_count": state.get("turn_count", 0),
-        "research_queries": state.get("research_queries", [])
-    }
-    (session_dir / "state-snapshot.json").write_text(json.dumps(state_snapshot, indent=2))
-
-    # 2. Save files list
-    files = get_files_created(endpoint_data)
-    (session_dir / "files-created.txt").write_text("\n".join(files))
-
-    # 3. Generate and save summary
-    summary = generate_summary(endpoint, endpoint_data, state)
-    (session_dir / "summary.md").write_text(summary)
-
-    # 4. Copy research cache if exists
-    research_src = RESEARCH_DIR / endpoint
-    if research_src.exists():
-        research_dst = session_dir / "research-cache"
-        research_dst.mkdir(exist_ok=True)
-        for f in research_src.iterdir():
-            if f.is_file():
-                shutil.copy2(f, research_dst / f.name)
-
-    # 5. Update sessions index
-    update_sessions_index(endpoint, timestamp, endpoint_data)
-
-    return session_dir
-
-
-def update_sessions_index(endpoint, timestamp, endpoint_data):
-    """Update the sessions index file."""
-    index_file = SESSIONS_DIR / "index.json"
-
-    if index_file.exists():
-        try:
-            index = json.loads(index_file.read_text())
-        except json.JSONDecodeError:
-            index = {"version": "3.6.7", "sessions": []}
-    else:
-        index = {"version": "3.6.7", "sessions": []}
-
-    # Add this session
-    completed = get_completed_phases(endpoint_data)
-    index["sessions"].append({
-        "endpoint": endpoint,
-        "timestamp": timestamp,
-        "folder": f"{endpoint}_{timestamp}",
-        "status": endpoint_data.get("status", "unknown"),
-        "phases_completed": len(completed),
-        "created_at": datetime.now().isoformat()
-    })
-
-    index_file.write_text(json.dumps(index, indent=2))
-
-
-def main():
-    try:
-        input_data = json.load(sys.stdin)
-    except json.JSONDecodeError:
-        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)
-
-    try:
-        state = json.loads(STATE_FILE.read_text())
-    except json.JSONDecodeError:
-        print(json.dumps({"continue": True}))
-        sys.exit(0)
-
-    # Get active endpoint
-    endpoint, endpoint_data = get_active_endpoint(state)
-    if not endpoint or not endpoint_data:
-        print(json.dumps({"continue": True}))
-        sys.exit(0)
-
-    # Only save if there's meaningful progress
-    completed = get_completed_phases(endpoint_data)
-    if len(completed) < 2:
-        # Not enough progress to save
-        print(json.dumps({
-            "hookSpecificOutput": {
-                "sessionSaved": False,
-                "reason": "Not enough progress to save (need at least 2 completed phases)"
-            }
-        }))
-        sys.exit(0)
-
-    # Save the session
-    try:
-        session_dir = save_session(endpoint, endpoint_data, state)
-
-        # Send NTFY notification on session end
-        if HAS_NTFY:
-            status = endpoint_data.get("status", "unknown")
-            if status == "complete":
-                send_ntfy_notification(
-                    title=f"✅ Session Complete: {endpoint}",
-                    message=f"Completed {len(completed)}/13 phases. Session saved.",
-                    priority="default",
-                    tags=["white_check_mark", "robot"]
-                )
-            else:
-                send_ntfy_notification(
-                    title=f"📋 Session Ended: {endpoint}",
-                    message=f"Completed {len(completed)}/13 phases. Status: {status}",
-                    priority="low",
-                    tags=["clipboard", "robot"]
-                )
-
-        output = {
-            "hookSpecificOutput": {
-                "sessionSaved": True,
-                "endpoint": endpoint,
-                "sessionDir": str(session_dir),
-                "phasesCompleted": len(completed),
-                "notificationSent": HAS_NTFY
-            }
-        }
-
-        print(json.dumps(output))
-        sys.exit(0)
-
-    except Exception as e:
-        output = {
-            "hookSpecificOutput": {
-                "sessionSaved": False,
-                "error": str(e)
-            }
-        }
-        print(json.dumps(output))
-        sys.exit(0)
-
-
-if __name__ == "__main__":
-    main()

package/.claude/hooks/test-orchestrator-reground.py

@@ -1,248 +0,0 @@
-#!/usr/bin/env python3
-"""
-Test Orchestrator Re-grounding Hook
-
-Runs every 5 turns during test orchestration to:
-1. Re-inject testing goals and current progress
-2. Send NTFY notification with status update
-3. Prevent context dilution during long test sessions
-
-Hook Type: PostToolUse
-Trigger: Every 5 turns
-NTFY Topic: test_api_devtools_alerts
-
-Version: 1.0.0
-"""
-
-import json
-import os
-import sys
-import subprocess
-from datetime import datetime
-from pathlib import Path
-
-# Configuration
-REGROUND_INTERVAL = 5  # Re-ground every 5 turns
-NTFY_TOPIC = "test_api_devtools_alerts"
-STATE_FILE = Path(__file__).parent.parent / "test-orchestrator-state.json"
-
-
-def send_ntfy(message, title="Test Orchestrator", priority=3, tags=None):
-    """Send NTFY notification."""
-    try:
-        headers = [
-            f"Title: {title}",
-            f"Priority: {priority}",
-        ]
-        if tags:
-            headers.append(f"Tags: {','.join(tags)}")
-
-        header_args = []
-        for h in headers:
-            header_args.extend(["-H", h])
-
-        subprocess.run(
-            ["curl", "-s"] + header_args + ["-d", message, f"https://ntfy.sh/{NTFY_TOPIC}"],
-            capture_output=True,
-            timeout=10
-        )
-    except Exception as e:
-        # Don't fail if notification fails
-        print(f"NTFY failed: {e}", file=sys.stderr)
-
-
-def load_test_state():
-    """Load test orchestrator state."""
-    if not STATE_FILE.exists():
-        return {
-            "turn_count": 0,
-            "started_at": datetime.now().isoformat(),
-            "commands_tested": {},
-            "current_command": None,
-            "current_phase": None,
-            "total_retries": 0,
-            "reground_history": []
-        }
-
-    try:
-        return json.loads(STATE_FILE.read_text())
-    except Exception:
-        return {
-            "turn_count": 0,
-            "started_at": datetime.now().isoformat(),
-            "commands_tested": {},
-            "current_command": None,
-            "current_phase": None,
-            "total_retries": 0,
-            "reground_history": []
-        }
-
-
-def save_test_state(state):
-    """Save test orchestrator state."""
-    STATE_FILE.parent.mkdir(parents=True, exist_ok=True)
-    STATE_FILE.write_text(json.dumps(state, indent=2))
-
-
-def format_progress_summary(state):
-    """Format a progress summary for re-grounding."""
-    commands = state.get("commands_tested", {})
-
-    summary_lines = []
-    summary_lines.append("## Test Orchestrator Progress")
-    summary_lines.append("")
-
-    # Overall stats
-    turn = state.get("turn_count", 0)
-    started = state.get("started_at", "unknown")
-    summary_lines.append(f"**Turn:** {turn}")
-    summary_lines.append(f"**Started:** {started}")
-    summary_lines.append(f"**Total Retries:** {state.get('total_retries', 0)}")
-    summary_lines.append("")
-
-    # Command progress
-    summary_lines.append("**Command Progress:**")
-    all_commands = [
-        "/api-create",
-        "/hustle-ui-create",
-        "/hustle-ui-create-page",
-        "/hustle-combine",
-        "/hustle-build"
-    ]
-
-    for cmd in all_commands:
-        cmd_state = commands.get(cmd, {})
-        status = cmd_state.get("status", "NOT STARTED")
-
-        icon = {
-            "PASSED": "✅",
-            "FAILED": "❌",
-            "IN PROGRESS": "🔄",
-            "NOT STARTED": "⏳"
-        }.get(status, "❓")
-
-        phases = cmd_state.get("phases_complete", 0)
-        retries = cmd_state.get("retries", 0)
-
-        if status == "PASSED":
-            summary_lines.append(f"- {icon} {cmd}: PASSED ({phases}/14 phases)")
-        elif status == "FAILED":
-            summary_lines.append(f"- {icon} {cmd}: FAILED at phase {phases}/14 (retry {retries}/∞)")
-        elif status == "IN PROGRESS":
-            summary_lines.append(f"- {icon} {cmd}: IN PROGRESS (phase {phases}/14)")
-        else:
-            summary_lines.append(f"- {icon} {cmd}: NOT STARTED")
-
-    summary_lines.append("")
-
-    # Current task
-    current_cmd = state.get("current_command")
-    current_phase = state.get("current_phase")
-    if current_cmd:
-        summary_lines.append(f"**Current Task:** {current_cmd} - Phase {current_phase}")
-    else:
-        summary_lines.append("**Current Task:** Initializing test harness")
-
-    summary_lines.append("")
-    summary_lines.append("## Primary Goal")
-    summary_lines.append("")
-    summary_lines.append("Test ALL 5 commands until they work perfectly:")
-    summary_lines.append("1. Run each command in isolated test directory")
-    summary_lines.append("2. Auto-answer questions via pending-answer.json")
-    summary_lines.append("3. Verify ALL 14 phases complete")
-    summary_lines.append("4. Verify ALL hooks fire correctly")
-    summary_lines.append("5. If tests fail: research, fix code, rebuild, retry")
-    summary_lines.append("6. NEVER STOP until all 5 commands pass")
-    summary_lines.append("")
-    summary_lines.append("## Key Resources")
-    summary_lines.append("")
-    summary_lines.append("- Test directory: ~/test-api-dev-tools-auto/")
-    summary_lines.append("- .env file: Copy from /Users/alfonso/Documents/GitHub/api-dev-tools/.env.example")
-    summary_lines.append("- WORKFLOW_CHECKLIST.md: Track results")
-    summary_lines.append("- NTFY topic: test_api_devtools_alerts")
-    summary_lines.append("")
-    summary_lines.append("## Failure Strategy")
-    summary_lines.append("")
-    summary_lines.append("If stuck after 5 retries:")
-    summary_lines.append("1. Use WebSearch to research the error")
-    summary_lines.append("2. Find similar issues and solutions")
-    summary_lines.append("3. Try new approaches")
-    summary_lines.append("4. Use git commits as savepoints")
-    summary_lines.append("5. NEVER give up - keep iterating")
-
-    return "\n".join(summary_lines)
-
-
-def main():
-    # Load state
-    state = load_test_state()
-
-    # Increment turn count
-    turn_count = state.get("turn_count", 0) + 1
-    state["turn_count"] = turn_count
-    state["last_turn_timestamp"] = datetime.now().isoformat()
-
-    # Check if we should re-ground
-    should_reground = turn_count % REGROUND_INTERVAL == 0
-
-    if should_reground:
-        # Generate progress summary
-        summary = format_progress_summary(state)
-
-        # Send NTFY notification
-        commands = state.get("commands_tested", {})
-        passed = sum(1 for c in commands.values() if c.get("status") == "PASSED")
-        in_progress = sum(1 for c in commands.values() if c.get("status") == "IN PROGRESS")
-        failed = sum(1 for c in commands.values() if c.get("status") == "FAILED")
-
-        ntfy_msg = f"""Turn {turn_count} Update:
-✅ Passed: {passed}/5
-🔄 In Progress: {in_progress}/5
-❌ Failed: {failed}/5
-
-Current: {state.get('current_command', 'Initializing')}
-Retries: {state.get('total_retries', 0)}
-"""
-
-        send_ntfy(
-            ntfy_msg,
-            title=f"🔄 Turn {turn_count} - Test Orchestrator",
-            priority=3,
-            tags=["robot", "test"]
-        )
-
-        # Add to reground history
-        reground_history = state.setdefault("reground_history", [])
-        reground_history.append({
-            "turn": turn_count,
-            "timestamp": datetime.now().isoformat(),
-            "current_command": state.get("current_command"),
-            "current_phase": state.get("current_phase"),
-            "passed": passed,
-            "failed": failed
-        })
-        # Keep only last 20 reground events
-        state["reground_history"] = reground_history[-20:]
-
-        # Save state
-        save_test_state(state)
-
-        # Output with context injection
-        output = {
-            "continue": True,
-            "hookSpecificOutput": {
-                "hookEventName": "PostToolUse",
-                "additionalContext": summary
-            }
-        }
-        print(json.dumps(output))
-    else:
-        # Just update turn count
-        save_test_state(state)
-        print(json.dumps({"continue": True}))
-
-    sys.exit(0)
-
-
-if __name__ == "__main__":
-    main()