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

package/.claude/hooks/auto-answer.py

@@ -1,305 +0,0 @@
-#!/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)
-
-Updated in v4.5.0:
-  - Use shared hook_utils for logging
-  - Log all auto-answered questions to workflow logs
-"""
-
-import json
-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"""
-    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", ".")
-
-    # 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.
-
-    Comprehensive options typically include words like:
-    - "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
-
-    comprehensive_keywords = [
-        "all", "full", "complete", "comprehensive", "everything",
-        "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):
-        label = opt.get("label", "").lower()
-        description = opt.get("description", "").lower()
-        text = f"{label} {description}"
-
-        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
-
-        # 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 (explicit flag OR defaults enabled)
-    state, state_type = load_state()
-    autonomous_by_default = is_autonomous_enabled()
-
-    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()
-
-    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)
-
-        # 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": False,
-            "reason": f"""## 🤖 Auto-Selected
-
-**{header}:** {answer}
-
-_Question: {question_text}_
-
----
-
-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))
-    else:
-        print(json.dumps({"continue": True}))
-
-
-def log_auto_answer(state, questions, answers):
-    """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")) 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": [], "events": []}
-
-        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/.claude/hooks/cache-research.py

@@ -1,337 +0,0 @@
-#!/usr/bin/env python3
-"""
-Hook: PostToolUse for Write/Edit
-Purpose: Create research cache files from state when documentation phase starts
-
-This hook creates the following files that enforce-documentation.py expects:
-  - .claude/research/{endpoint}/sources.json - Research sources with URLs
-  - .claude/research/{endpoint}/interview.json - Interview decisions
-  - .claude/research/{endpoint}/schema.json - Schema snapshot
-  - .claude/research/{endpoint}/CURRENT.md - Aggregated research (if not exists)
-  - .claude/research/index.json - Updates the freshness index
-
-Added in v3.6.7 to fix critical gap where these files were expected but never created.
-
-Returns:
-  - JSON with cacheCreated info
-"""
-import json
-import sys
-import os
-from datetime import datetime
-from pathlib import Path
-
-STATE_FILE = Path(__file__).parent.parent / "api-dev-state.json"
-RESEARCH_DIR = Path(__file__).parent.parent / "research"
-RESEARCH_INDEX = RESEARCH_DIR / "index.json"
-
-
-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 create_sources_json(endpoint_dir, state, endpoint_data):
-    """Create sources.json from research queries in state."""
-    sources_file = endpoint_dir / "sources.json"
-
-    # Collect sources from various places in state
-    sources = []
-
-    # From research_queries array
-    for query in state.get("research_queries", []):
-        source = {
-            "query": query.get("query", ""),
-            "tool": query.get("tool", "unknown"),
-            "timestamp": query.get("timestamp", ""),
-            "url": query.get("url", ""),
-            "summary": query.get("summary", "")
-        }
-        sources.append(source)
-
-    # From initial research phase
-    initial_research = endpoint_data.get("phases", {}).get("research_initial", {})
-    for src in initial_research.get("sources", []):
-        if isinstance(src, dict):
-            sources.append(src)
-        elif isinstance(src, str):
-            sources.append({"url": src, "summary": ""})
-
-    # From deep research phase
-    deep_research = endpoint_data.get("phases", {}).get("research_deep", {})
-    for src in deep_research.get("sources", []):
-        if isinstance(src, dict):
-            sources.append(src)
-        elif isinstance(src, str):
-            sources.append({"url": src, "summary": ""})
-
-    # Deduplicate by URL
-    seen_urls = set()
-    unique_sources = []
-    for src in sources:
-        url = src.get("url", src.get("query", ""))
-        if url and url not in seen_urls:
-            seen_urls.add(url)
-            unique_sources.append(src)
-
-    data = {
-        "created_at": datetime.now().isoformat(),
-        "updated_at": datetime.now().isoformat(),
-        "endpoint": endpoint_data.get("endpoint", state.get("endpoint", "")),
-        "source_count": len(unique_sources),
-        "sources": unique_sources
-    }
-
-    sources_file.write_text(json.dumps(data, indent=2))
-    return True
-
-
-def create_interview_json(endpoint_dir, endpoint_data):
-    """Create interview.json from interview decisions in state."""
-    interview_file = endpoint_dir / "interview.json"
-
-    interview = endpoint_data.get("phases", {}).get("interview", {})
-    decisions = interview.get("decisions", {})
-    questions = interview.get("questions", [])
-
-    data = {
-        "created_at": datetime.now().isoformat(),
-        "updated_at": datetime.now().isoformat(),
-        "question_count": len(questions),
-        "decision_count": len(decisions),
-        "questions": questions,
-        "decisions": decisions
-    }
-
-    interview_file.write_text(json.dumps(data, indent=2))
-    return True
-
-
-def create_schema_json(endpoint_dir, endpoint_data, state):
-    """Create schema.json from schema creation phase in state."""
-    schema_json_file = endpoint_dir / "schema.json"
-
-    schema_phase = endpoint_data.get("phases", {}).get("schema_creation", {})
-    schema_file = schema_phase.get("schema_file", schema_phase.get("file", ""))
-    fields_count = schema_phase.get("fields_count", 0)
-
-    # Try to read actual schema file if it exists
-    schema_content = None
-    if schema_file:
-        schema_path = Path(schema_file)
-        if schema_path.exists():
-            try:
-                schema_content = schema_path.read_text()
-            except IOError:
-                pass
-
-    data = {
-        "created_at": datetime.now().isoformat(),
-        "updated_at": datetime.now().isoformat(),
-        "schema_file": schema_file,
-        "fields_count": fields_count,
-        "schema_content": schema_content
-    }
-
-    schema_json_file.write_text(json.dumps(data, indent=2))
-    return True
-
-
-def create_current_md(endpoint_dir, endpoint, endpoint_data, state):
-    """Create CURRENT.md if it doesn't exist."""
-    current_md = endpoint_dir / "CURRENT.md"
-
-    # Only create if doesn't exist (don't overwrite manual research)
-    if current_md.exists():
-        return False
-
-    # Build aggregated research content
-    lines = [
-        f"# Research: {endpoint}",
-        "",
-        f"*Generated: {datetime.now().isoformat()}*",
-        "",
-        "## Sources",
-        ""
-    ]
-
-    # Add sources
-    sources_file = endpoint_dir / "sources.json"
-    if sources_file.exists():
-        try:
-            sources = json.loads(sources_file.read_text())
-            for src in sources.get("sources", []):
-                url = src.get("url", "")
-                summary = src.get("summary", "")
-                if url:
-                    lines.append(f"- {url}")
-                    if summary:
-                        lines.append(f"  - {summary}")
-        except (json.JSONDecodeError, IOError):
-            pass
-
-    lines.extend(["", "## Interview Decisions", ""])
-
-    # Add interview decisions
-    interview_file = endpoint_dir / "interview.json"
-    if interview_file.exists():
-        try:
-            interview = json.loads(interview_file.read_text())
-            for key, value in interview.get("decisions", {}).items():
-                response = value.get("response", value.get("value", "N/A"))
-                lines.append(f"- **{key}**: {response}")
-        except (json.JSONDecodeError, IOError):
-            pass
-
-    lines.extend(["", "## Schema", ""])
-
-    # Add schema info
-    schema_file = endpoint_dir / "schema.json"
-    if schema_file.exists():
-        try:
-            schema = json.loads(schema_file.read_text())
-            lines.append(f"- File: `{schema.get('schema_file', 'N/A')}`")
-            lines.append(f"- Fields: {schema.get('fields_count', 0)}")
-        except (json.JSONDecodeError, IOError):
-            pass
-
-    current_md.write_text("\n".join(lines))
-    return True
-
-
-def update_research_index(endpoint):
-    """Update the research index with this endpoint."""
-    RESEARCH_DIR.mkdir(parents=True, exist_ok=True)
-
-    # Load existing index or create new
-    if RESEARCH_INDEX.exists():
-        try:
-            index = json.loads(RESEARCH_INDEX.read_text())
-        except json.JSONDecodeError:
-            index = {"version": "3.6.7", "apis": {}}
-    else:
-        index = {"version": "3.6.7", "apis": {}}
-
-    # Ensure apis object exists
-    if "apis" not in index:
-        index["apis"] = {}
-
-    # Update this endpoint's entry
-    now = datetime.now().isoformat()
-    index["apis"][endpoint] = {
-        "last_updated": now,
-        "freshness_days": 0,
-        "cache_path": f".claude/research/{endpoint}/",
-        "files": ["sources.json", "interview.json", "schema.json", "CURRENT.md"]
-    }
-
-    RESEARCH_INDEX.write_text(json.dumps(index, indent=2))
-    return True
-
-
-def main():
-    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", "")
-    tool_input = input_data.get("tool_input", {})
-    tool_result = input_data.get("tool_result", {})
-    file_path = tool_input.get("file_path", "")
-
-    # Only trigger on Write/Edit to documentation-related files
-    if tool_name not in ["Write", "Edit"]:
-        print(json.dumps({"continue": True}))
-        sys.exit(0)
-
-    # Check if this is a documentation-related write
-    is_manifest = "api-tests-manifest.json" in file_path
-    is_readme = file_path.endswith("README.md") and "/api/" in file_path
-    is_state = "api-dev-state.json" in file_path
-
-    # Also trigger when documentation phase is in progress
-    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)
-
-    endpoint, endpoint_data = get_active_endpoint(state)
-    if not endpoint or not endpoint_data:
-        print(json.dumps({"continue": True}))
-        sys.exit(0)
-
-    # Check if documentation phase is in progress or we're writing doc files
-    doc_phase = endpoint_data.get("phases", {}).get("documentation", {})
-    doc_status = doc_phase.get("status", "not_started")
-
-    if doc_status not in ["in_progress", "complete"] and not is_manifest and not is_readme:
-        print(json.dumps({"continue": True}))
-        sys.exit(0)
-
-    # Create research cache directory
-    endpoint_dir = RESEARCH_DIR / endpoint
-    endpoint_dir.mkdir(parents=True, exist_ok=True)
-
-    # Create cache files
-    files_created = []
-
-    sources_created = create_sources_json(endpoint_dir, state, endpoint_data)
-    if sources_created:
-        files_created.append("sources.json")
-
-    interview_created = create_interview_json(endpoint_dir, endpoint_data)
-    if interview_created:
-        files_created.append("interview.json")
-
-    schema_created = create_schema_json(endpoint_dir, endpoint_data, state)
-    if schema_created:
-        files_created.append("schema.json")
-
-    current_created = create_current_md(endpoint_dir, endpoint, endpoint_data, state)
-    if current_created:
-        files_created.append("CURRENT.md")
-
-    # Update index
-    index_updated = update_research_index(endpoint)
-    if index_updated:
-        files_created.append("index.json")
-
-    # Update state to indicate research is cached
-    if files_created:
-        doc_phase["research_cached"] = True
-        STATE_FILE.write_text(json.dumps(state, indent=2))
-
-    output = {
-        "hookSpecificOutput": {
-            "cacheCreated": True,
-            "endpoint": endpoint,
-            "files": files_created,
-            "cacheDir": str(endpoint_dir)
-        }
-    }
-
-    print(json.dumps(output))
-    sys.exit(0)
-
-
-if __name__ == "__main__":
-    main()