claude-all-hands 1.0.1 → 1.0.2

package/.claude/envoy/commands/vertex.py

@@ -1,358 +0,0 @@
-"""Vertex AI (Gemini) commands."""
-# pyright: reportAttributeAccessIssue=false
-
-from __future__ import annotations
-
-import json
-import os
-import re
-import subprocess
-from pathlib import Path
-from typing import Optional
-
-from .base import BaseCommand
-from .plans import get_plan_dir, get_branch, is_direct_mode_branch
-
-
-def get_base_branch() -> str:
-    """Auto-detect base branch using merge-base."""
-    # Try common base branches in order
-    for base in ["main", "master", "develop", "staging", "production"]:
-        result = subprocess.run(
-            ["git", "merge-base", base, "HEAD"],
-            capture_output=True,
-            text=True,
-        )
-        if result.returncode == 0:
-            return base
-    return "main"
-
-
-class VertexAskCommand(BaseCommand):
-    """Raw Gemini inference - thin wrapper, no system prompt."""
-
-    name = "ask"
-    description = "Raw Gemini inference"
-
-    def add_arguments(self, parser) -> None:
-        parser.add_argument("query", help="Query for Gemini")
-        parser.add_argument("--files", nargs="+", help="Files to include as context")
-        parser.add_argument("--context", help="Additional context")
-        parser.add_argument("--model", default="gemini-2.0-flash", help="Model to use")
-
-    def execute(
-        self,
-        *,
-        query: str,
-        model: str = "gemini-2.0-flash",
-        files: Optional[list[str]] = None,
-        context: Optional[str] = None,
-        **kwargs,
-    ) -> dict:
-        api_key = os.environ.get("VERTEX_API_KEY")
-        if not api_key:
-            return self.error("auth_error", "VERTEX_API_KEY not set")
-
-        parts = []
-        if context:
-            parts.append(context)
-        if files:
-            file_contents = self.read_files(files)
-            if file_contents:
-                file_context = "\n\n".join(f"### {path}\n```\n{content}\n```" for path, content in file_contents.items())
-                parts.append(file_context)
-        parts.append(query)
-        prompt = "\n\n".join(parts)
-
-        try:
-            response, duration_ms = self.timed_execute(self._call_api, api_key, model, prompt)
-            return self.success(
-                {"content": response},
-                {"model": model, "command": "vertex ask", "duration_ms": duration_ms},
-            )
-        except Exception as e:
-            return self.error("api_error", str(e))
-
-    def _call_api(self, api_key: str, model: str, prompt: str) -> str:
-        from google import genai
-
-        client = genai.Client(vertexai=True, api_key=api_key)
-        response = client.models.generate_content(model=model, contents=prompt)
-        return response.text
-
-
-class VertexValidateCommand(BaseCommand):
-    """Validate plan against user requirements."""
-
-    name = "validate"
-    description = "Validate plan against requirements (anti-overengineering)"
-
-    SYSTEM_PROMPT = """You are a plan validator ensuring implementations are NOT over-engineered.
-
-Given user requirements and a proposed plan, evaluate:
-- Does plan exceed what user actually asked for?
-- Are there unnecessary abstractions/features?
-- Is complexity justified by requirements?
-- Are there gaps, risks, or architectural concerns?
-
-Be thorough and direct. Only ask questions for user discretion you can't answer yourself.
-
-IMPORTANT: This is SYSTEM VALIDATION only. User approval is a separate step after validation passes.
-
-Validation result: "valid" or "invalid" (binary).
-- "valid": Plan is acceptable and ready for user approval.
-- "invalid": Plan has issues (over-engineered, unclear requirements, missing details, etc.)
-
-The verdict_context MUST explain the reasoning - whether over-engineered, what's missing, lack of user clarification, or why it passes.
-
-CRITICAL: If user_questions is non-empty, validation_result MUST be "invalid". A "valid" result with pending questions is not allowed.
-
-Output JSON:
-{
-  "validation_result": "valid" | "invalid",
-  "verdict_context": "Specific reasoning - what's wrong, over-engineering issues, missing clarification, or why it passes",
-  "recommended_edits": ["Edits to fix issues (required if invalid), or minor improvements (optional if valid)"],
-  "user_questions": ["Questions needing user input - MUST be empty if validation_result is valid"]
-}"""
-
-    def add_arguments(self, parser) -> None:
-        parser.add_argument("--queries", help="Queries file path (optional)")
-        parser.add_argument("--context", help="Additional context")
-
-    def execute(self, *, queries: Optional[str] = None, context: Optional[str] = None, **kwargs) -> dict:
-        api_key = os.environ.get("VERTEX_API_KEY")
-        if not api_key:
-            return self.error("auth_error", "VERTEX_API_KEY not set")
-
-        if is_direct_mode_branch(get_branch()):
-            return self.error("direct_mode", "No plan in direct mode")
-
-        plan_path = get_plan_dir()
-        plan_file = plan_path / "plan.md"
-        queries_file = queries or plan_path / "queries.jsonl"
-
-        plan_content = self.read_file(str(plan_file))
-        if not plan_content:
-            return self.error("file_not_found", f"Plan file not found: {plan_file}")
-
-        queries_content = ""
-        if queries_file and Path(queries_file).exists():
-            with open(queries_file) as f:
-                queries_list = [json.loads(line).get("prompt", "") for line in f if line.strip()]
-            queries_content = "\n".join(f"- {q}" for q in queries_list)
-
-        additional = f"\n\n## Additional Context\n{context}" if context else ""
-        full_prompt = f"""{self.SYSTEM_PROMPT}
-
-## User Requirements/Queries
-{queries_content or "(No queries captured)"}
-
-## Plan
-{plan_content}
-{additional}
-
-Respond with JSON only."""
-
-        try:
-            response, duration_ms = self.timed_execute(self._call_api, api_key, full_prompt)
-            parsed = self._parse_json_response(response)
-            return self.success(parsed, {"command": "vertex validate", "duration_ms": duration_ms})
-        except Exception as e:
-            return self.error("api_error", str(e))
-
-    def _call_api(self, api_key: str, prompt: str) -> str:
-        from google import genai
-
-        client = genai.Client(vertexai=True, api_key=api_key)
-        response = client.models.generate_content(model="gemini-2.0-flash", contents=prompt)
-        return response.text
-
-    def _parse_json_response(self, response: str) -> dict:
-        json_match = re.search(r"\{[\s\S]*\}", response)
-        if json_match:
-            return json.loads(json_match.group())
-        return {"raw_response": response}
-
-
-class VertexReviewCommand(BaseCommand):
-    """Review implementation against plan."""
-
-    name = "review"
-    description = "Review implementation against plan (uses git diff)"
-
-    SYSTEM_PROMPT = """You are an implementation reviewer for a lean development team.
-
-Core philosophy: Keep it simple. Favor pragmatic shortcuts over elaborate abstractions. This is likely an early-stage or small-team product where shipping fast matters more than architectural perfection.
-
-Given a plan and git diff of changes, evaluate:
-- Does implementation match plan intent?
-- Is there over-engineering? (unnecessary abstractions, premature optimization, excessive indirection)
-- Are there simpler alternatives that would achieve the same goal?
-- Code quality issues that actually matter?
-
-Flag anything that adds complexity without clear immediate value.
-
-Output JSON:
-{
-  "verdict": "approved" | "needs_work" | "off_track",
-  "verdict_context": "Explanation with specific reasoning",
-  "over_engineering": ["Any unnecessary complexity spotted"],
-  "simplification_opportunities": ["Ways to reduce complexity"],
-  "issues": ["Actionable issues to address"],
-  "user_questions": ["Questions if clarification needed"]
-}"""
-
-    def add_arguments(self, parser) -> None:
-        parser.add_argument("--last-commit", action="store_true", help="Diff against last commit (for step reviews)")
-        parser.add_argument("--context", help="Additional context")
-
-    def execute(self, *, last_commit: bool = False, context: Optional[str] = None, **kwargs) -> dict:
-        api_key = os.environ.get("VERTEX_API_KEY")
-        if not api_key:
-            return self.error("auth_error", "VERTEX_API_KEY not set")
-
-        if is_direct_mode_branch(get_branch()):
-            return self.error("direct_mode", "No plan in direct mode")
-
-        plan_path = get_plan_dir()
-        plan_file = plan_path / "plan.md"
-        plan_content = self.read_file(str(plan_file))
-        if not plan_content:
-            return self.error("file_not_found", f"Plan file not found: {plan_file}")
-
-        diff_ref = "HEAD~1" if last_commit else get_base_branch()
-        diff_result = subprocess.run(["git", "diff", diff_ref], capture_output=True, text=True)
-
-        # Fallback to empty tree if ref doesn't exist (fresh repo)
-        if diff_result.returncode != 0:
-            empty_tree = "4b825dc642cb6eb9a060e54bf8d69288fbee4904"  # git's empty tree hash
-            diff_ref = "empty tree"
-            diff_result = subprocess.run(["git", "diff", empty_tree], capture_output=True, text=True)
-            if diff_result.returncode != 0:
-                return self.error("git_error", f"Failed to get diff: {diff_result.stderr}")
-
-        diff_content = diff_result.stdout or "(No changes)"
-
-        additional = f"\n\n## Additional Context\n{context}" if context else ""
-        full_prompt = f"""{self.SYSTEM_PROMPT}
-
-## Plan
-{plan_content}
-
-## Git Diff (against {diff_ref})
-```diff
-{diff_content}
-```
-{additional}
-
-Respond with JSON only."""
-
-        try:
-            response, duration_ms = self.timed_execute(self._call_api, api_key, full_prompt)
-            parsed = self._parse_json_response(response)
-            return self.success(parsed, {"command": "vertex review", "duration_ms": duration_ms})
-        except Exception as e:
-            return self.error("api_error", str(e))
-
-    def _call_api(self, api_key: str, prompt: str) -> str:
-        from google import genai
-
-        client = genai.Client(vertexai=True, api_key=api_key)
-        response = client.models.generate_content(model="gemini-2.0-flash", contents=prompt)
-        return response.text
-
-    def _parse_json_response(self, response: str) -> dict:
-        json_match = re.search(r"\{[\s\S]*\}", response)
-        if json_match:
-            return json.loads(json_match.group())
-        return {"raw_response": response}
-
-
-class VertexArchitectCommand(BaseCommand):
-    """Solutions architecture guidance."""
-
-    name = "architect"
-    description = "Solutions architecture for complex features"
-
-    SYSTEM_PROMPT = """You are a solutions architect for complex software systems.
-
-Given a feature request and optional codebase context:
-1. Identify architectural decisions needed
-2. Propose approaches with trade-offs
-3. Recommend implementation strategy
-4. Flag risks and unknowns
-
-Output JSON:
-{
-  "complexity_assessment": "simple" | "moderate" | "complex" | "system_integration",
-  "architectural_decisions": [{
-    "decision": "string",
-    "options": [{"option": "string", "pros": ["string"], "cons": ["string"]}],
-    "recommendation": "string",
-    "rationale": "string"
-  }],
-  "implementation_strategy": {
-    "approach": "string",
-    "phases": [{"phase": "string", "deliverables": ["string"]}],
-    "dependencies": ["string"]
-  },
-  "risks": [{"risk": "string", "mitigation": "string", "severity": "low"|"medium"|"high"}],
-  "questions_for_user": ["string"]
-}"""
-
-    def add_arguments(self, parser) -> None:
-        parser.add_argument("query", help="Feature/system description")
-        parser.add_argument("--files", nargs="+", help="Relevant code files")
-        parser.add_argument("--context", help="Additional context or constraints")
-
-    def execute(self, *, query: str, files: Optional[list[str]] = None, context: Optional[str] = None, **kwargs) -> dict:
-        api_key = os.environ.get("VERTEX_API_KEY")
-        if not api_key:
-            return self.error("auth_error", "VERTEX_API_KEY not set")
-
-        file_context = ""
-        if files:
-            file_contents = self.read_files(files)
-            if file_contents:
-                file_context = "\n\n## Existing Code\n" + "\n\n".join(
-                    f"### {path}\n```\n{content}\n```" for path, content in file_contents.items()
-                )
-
-        additional = f"\n\n## Additional Context\n{context}" if context else ""
-
-        full_prompt = f"""{self.SYSTEM_PROMPT}
-
-## Feature Request
-{query}
-{file_context}
-{additional}
-
-Respond with JSON only."""
-
-        try:
-            response, duration_ms = self.timed_execute(self._call_api, api_key, full_prompt)
-            parsed = self._parse_json_response(response)
-            return self.success(parsed, {"command": "vertex architect", "duration_ms": duration_ms})
-        except Exception as e:
-            return self.error("api_error", str(e))
-
-    def _call_api(self, api_key: str, prompt: str) -> str:
-        from google import genai
-
-        client = genai.Client(vertexai=True, api_key=api_key)
-        response = client.models.generate_content(model="gemini-2.0-flash", contents=prompt)
-        return response.text
-
-    def _parse_json_response(self, response: str) -> dict:
-        json_match = re.search(r"\{[\s\S]*\}", response)
-        if json_match:
-            return json.loads(json_match.group())
-        return {"raw_response": response}
-
-
-COMMANDS = {
-    "ask": VertexAskCommand,
-    "validate": VertexValidateCommand,
-    "review": VertexReviewCommand,
-    "architect": VertexArchitectCommand,
-}

package/.claude/envoy/commands/xai.py

@@ -1,124 +0,0 @@
-"""xAI Grok API commands - X search for technology research."""
-
-import os
-from typing import Optional
-
-import requests
-from .base import BaseCommand
-
-
-SYSTEM_PROMPT = """You are a technology research assistant. Search X (Twitter) for posts about the given technology, tool, or concept.
-
-Find and synthesize:
-- Developer opinions and experiences
-- Comparisons with alternatives
-- Common issues or gotchas
-- Recent developments or announcements
-- Community sentiment
-
-Return a structured summary with key findings and notable posts."""
-
-CHALLENGER_PROMPT = """You are a critical research challenger. Given research findings, search X to:
-
-1. CHALLENGE: Find contradicting opinions, failed implementations, known issues
-2. ALTERNATIVES: Surface newer/better tools the research may have missed
-3. TRENDS: Identify emerging patterns that could affect the recommendations
-4. SENTIMENT: Gauge real developer satisfaction vs marketing claims
-5. DISCUSSIONS: Find where the best practitioners are discussing this topic
-
-Be skeptical. Surface what the research missed or got wrong. Focus on recent posts (last 6 months)."""
-
-
-class XaiSearchCommand(BaseCommand):
-    """Search X for technology insights using Grok with X Search tool."""
-
-    name = "search"
-    description = "Search X for technology opinions, alternatives, and community insights"
-
-    def add_arguments(self, parser) -> None:
-        parser.add_argument("query", help="Technology/topic to research on X")
-        parser.add_argument("--context", help="Previous research findings to build upon")
-        parser.add_argument("--results-to-challenge", help="Research results to challenge (enables challenger mode)")
-
-    def execute(self, query: str, context: Optional[str] = None, results_to_challenge: Optional[str] = None, **kwargs) -> dict:
-        api_key = os.environ.get("X_AI_API_KEY")
-        if not api_key:
-            return self.error("auth_error", "X_AI_API_KEY not set")
-
-        # Determine mode and build prompt
-        if results_to_challenge:
-            system_prompt = CHALLENGER_PROMPT
-            user_prompt = f"""Original query: {query}
-
-Research findings to challenge:
-{results_to_challenge}
-
-Search X to challenge these findings."""
-        elif context:
-            system_prompt = SYSTEM_PROMPT
-            user_prompt = f"""Previous research findings:
-{context}
-
-Now search X for additional insights about: {query}
-
-Focus on opinions, alternatives, and community discussions that complement the existing findings."""
-        else:
-            system_prompt = SYSTEM_PROMPT
-            user_prompt = f"Search X for developer opinions, experiences, and alternatives regarding: {query}"
-
-        try:
-            response, duration_ms = self.timed_execute(
-                self._call_api, api_key, user_prompt, system_prompt
-            )
-
-            content = response["choices"][0]["message"]["content"]
-            citations = response.get("citations", [])
-            usage = response.get("usage", {})
-            tool_usage = response.get("server_side_tool_usage", {})
-
-            return self.success(
-                {
-                    "content": content,
-                    "citations": citations,
-                },
-                {
-                    "model": "grok-4-1-fast",
-                    "command": "xai search",
-                    "duration_ms": duration_ms,
-                    "input_tokens": usage.get("prompt_tokens"),
-                    "output_tokens": usage.get("completion_tokens"),
-                    "reasoning_tokens": usage.get("reasoning_tokens"),
-                    "x_search_calls": tool_usage.get("SERVER_SIDE_TOOL_X_SEARCH", 0),
-                },
-            )
-
-        except requests.exceptions.Timeout:
-            return self.error("timeout", f"Request timed out after {self.timeout_ms}ms")
-        except requests.exceptions.RequestException as e:
-            return self.error("api_error", str(e))
-        except (KeyError, IndexError) as e:
-            return self.error("parse_error", f"Unexpected response format: {e}")
-
-    def _call_api(self, api_key: str, user_prompt: str, system_prompt: str) -> dict:
-        response = requests.post(
-            "https://api.x.ai/v1/chat/completions",
-            headers={
-                "Authorization": f"Bearer {api_key}",
-                "Content-Type": "application/json",
-            },
-            json={
-                "model": "grok-4-1-fast",
-                "messages": [
-                    {"role": "system", "content": system_prompt},
-                    {"role": "user", "content": user_prompt},
-                ],
-            },
-            timeout=self.timeout_ms / 1000,
-        )
-        response.raise_for_status()
-        return response.json()
-
-
-COMMANDS = {
-    "search": XaiSearchCommand,
-}

package/.claude/envoy/envoy.py

@@ -1,122 +0,0 @@
-#!/usr/bin/env python3
-"""claude-envoy: CLI for agent-scoped external tool access.
-
-Commands are auto-discovered from the commands/ directory.
-Each command module registers itself via COMMANDS dict.
-"""
-
-import argparse
-import importlib
-import json
-import os
-import sys
-from pathlib import Path
-
-
-def discover_commands() -> dict:
-    """Auto-discover command modules from commands/ directory.
-
-    Each module should have a COMMANDS dict mapping subcommand names to classes.
-    Returns: {group: {subcommand: CommandClass}}
-    """
-    commands_dir = Path(__file__).parent / "commands"
-    all_commands = {}
-
-    for module_file in commands_dir.glob("*.py"):
-        if module_file.name.startswith("_"):
-            continue
-
-        module_name = module_file.stem
-        try:
-            module = importlib.import_module(f"commands.{module_name}")
-            if hasattr(module, "COMMANDS"):
-                all_commands[module_name] = module.COMMANDS
-        except ImportError as e:
-            # Skip modules with missing dependencies
-            print(f"Warning: Could not load {module_name}: {e}", file=sys.stderr)
-
-    return all_commands
-
-
-def build_parser(commands: dict) -> argparse.ArgumentParser:
-    """Build argparse parser from discovered commands."""
-    parser = argparse.ArgumentParser(
-        prog="envoy",
-        description="CLI for agent-scoped external tool access",
-    )
-    subparsers = parser.add_subparsers(dest="command", help="Available commands")
-
-    for group_name, subcommands in commands.items():
-        group = subparsers.add_parser(group_name, help=f"{group_name.title()} tools")
-        group_sub = group.add_subparsers(dest="subcommand")
-
-        for subcmd_name, cmd_class in subcommands.items():
-            cmd = cmd_class()
-            subcmd = group_sub.add_parser(subcmd_name, help=cmd.description)
-            cmd.add_arguments(subcmd)
-
-    # Built-in info command
-    subparsers.add_parser("info", help="Show available commands and API status")
-
-    return parser
-
-
-def run_command(args: argparse.Namespace, commands: dict) -> dict:
-    """Route to appropriate command handler."""
-    if args.command == "info":
-        return get_info(commands)
-
-    if args.command in commands:
-        subcommands = commands[args.command]
-        if args.subcommand in subcommands:
-            cmd = subcommands[args.subcommand]()
-            # Convert args namespace to dict, excluding command/subcommand
-            kwargs = {k: v for k, v in vars(args).items() if k not in ("command", "subcommand")}
-            return cmd.execute(**kwargs)
-
-    return {"status": "error", "error": {"type": "invalid_command", "message": "Unknown command"}}
-
-
-def get_info(commands: dict) -> dict:
-    """Return info about available commands and API status."""
-    cmd_list = ["info"]
-    for group, subcommands in commands.items():
-        for subcmd in subcommands:
-            cmd_list.append(f"{group} {subcmd}")
-
-    return {
-        "status": "success",
-        "data": {
-            "version": "0.1.0",
-            "commands": sorted(cmd_list),
-            "api_keys": {
-                "PERPLEXITY_API_KEY": "set" if os.environ.get("PERPLEXITY_API_KEY") else "missing",
-                "TAVILY_API_KEY": "set" if os.environ.get("TAVILY_API_KEY") else "missing",
-                "VERTEX_API_KEY": "set" if os.environ.get("VERTEX_API_KEY") else "missing",
-            },
-            "timeout_ms": os.environ.get("ENVOY_TIMEOUT_MS", "120000"),
-        },
-    }
-
-
-def main():
-    # Add commands directory to path
-    sys.path.insert(0, str(Path(__file__).parent))
-
-    commands = discover_commands()
-    parser = build_parser(commands)
-    args = parser.parse_args()
-
-    if not args.command:
-        parser.print_help()
-        sys.exit(1)
-
-    if args.command in commands and not getattr(args, "subcommand", None):
-        parser.parse_args([args.command, "-h"])
-
-    result = run_command(args, commands)
-    print(json.dumps(result, indent=2))
-
-
-if __name__ == "__main__":
-    main()

package/.claude/envoy/pyrightconfig.json

@@ -1,4 +0,0 @@
-{
-  "venvPath": ".",
-  "venv": ".venv"
-}

package/.claude/envoy/requirements.txt

@@ -1,2 +0,0 @@
-requests>=2.28.0
-google-genai>=0.8.0

package/.claude/hooks/capture-queries.sh

@@ -1,3 +0,0 @@
-#!/bin/bash
-# Thin shim for UserPromptSubmit hook - pipes stdin to envoy
-"$CLAUDE_PROJECT_DIR/.claude/envoy/envoy" plans capture