claude-all-hands 1.0.1 → 1.0.3

package/.claude/hooks/scripts/enforce_planning.py

@@ -1,118 +0,0 @@
-#!/usr/bin/env python3
-"""UserPromptSubmit hook - enforces planning workflow based on plan status."""
-
-import json
-import subprocess
-import sys
-from pathlib import Path
-
-
-def get_envoy_path() -> Path:
-    """Get path to envoy CLI."""
-    cwd = Path.cwd()
-    return cwd / ".claude" / "envoy" / "envoy"
-
-
-def get_current_branch() -> str:
-    """Get current git branch name."""
-    result = subprocess.run(
-        ["git", "rev-parse", "--abbrev-ref", "HEAD"],
-        capture_output=True,
-        text=True,
-    )
-    if result.returncode == 0:
-        return result.stdout.strip()
-    return ""
-
-
-def is_direct_mode_branch() -> bool:
-    """Check if current branch is a direct-mode branch (no planning)."""
-    branch = get_current_branch()
-    direct_branches = {"main", "master", "develop", "staging", "production"}
-    if branch in direct_branches:
-        return True
-    if branch.startswith("quick/"):
-        return True
-    return False
-
-
-def get_plan_status() -> dict:
-    """Get current plan status via envoy."""
-    envoy = get_envoy_path()
-    if not envoy.exists():
-        return {"error": "envoy not found"}
-
-    result = subprocess.run(
-        [str(envoy), "plans", "frontmatter"],
-        capture_output=True,
-        text=True,
-    )
-
-    if result.returncode != 0:
-        return {"error": result.stderr}
-
-    try:
-        data = json.loads(result.stdout)
-        return data.get("data", {})
-    except json.JSONDecodeError:
-        return {"error": "invalid json"}
-
-
-def is_worker_subprocess() -> bool:
-    """Check if running inside a parallel worker subprocess."""
-    import os
-    depth = os.environ.get("PARALLEL_WORKER_DEPTH", "0")
-    try:
-        return int(depth) > 0
-    except ValueError:
-        return False
-
-
-def main():
-    try:
-        input_data = json.load(sys.stdin)
-    except (json.JSONDecodeError, EOFError):
-        return
-
-    # Worker subprocess - return hint about injected plan file
-    if is_worker_subprocess():
-        print("Worker subprocess: /plan disabled. Use injected plan at .claude/plans/<branch>/plan.md")
-        return
-
-    # Early return for direct mode branches (skip envoy call)
-    if is_direct_mode_branch():
-        return
-
-    # Get plan status
-    plan_data = get_plan_status()
-
-    # Direct mode from envoy (fallback check)
-    if plan_data.get("mode") == "direct":
-        return
-
-    # No plan exists yet
-    if not plan_data.get("exists"):
-        print("No plan file. Run /plan to create one.")
-        return
-
-    frontmatter = plan_data.get("frontmatter", {})
-    status = frontmatter.get("status", "draft")
-    plan_path = plan_data.get("path", "")
-
-    if status == "draft":
-        print("PLANNING REQUIRED: Plan status is draft.")
-        print(f"Plan file: {plan_path}")
-        print("Run /plan to begin planning workflow.")
-        print("To skip planning this session, decline when prompted.")
-
-    elif status == "active":
-        print(f"Plan status: active | Plan file: {plan_path}")
-        print("IMPORTANT: If this prompt is NOT related to the current plan, you MUST run /plan to challenge the user to follow workflow best practices.")
-
-    elif status == "deactivated":
-        # User opted out - no enforcement, silent pass
-        return
-
-
-if __name__ == "__main__":
-    main()

package/.claude/hooks/scripts/enforce_rg.py

@@ -1,34 +0,0 @@
-#!/usr/bin/env python3
-"""PreToolUse hook: block grep/find and suggest rg (only if rg available)."""
-import json
-import re
-import shutil
-import sys
-
-RULES = [
-    (r"\bgrep\b(?!.*\|)", "Ensure you use Bash with 'rg <pattern>' (ripgrep) instead of grep."),
-    (r"\bfind\s+\S+\s+-name\b", "Ensure you use Bash with 'rg --files -g \"<pattern>\" <path>' instead of find -name."),
-]
-
-data = json.load(sys.stdin)
-command = data.get("tool_input", {}).get("command", "")
-
-if not command:
-    sys.exit(0)
-
-# Check for grep/find patterns
-for pattern, message in RULES:
-    if re.search(pattern, command):
-        # Only enforce if rg is available
-        if shutil.which("rg"):
-            print(json.dumps({
-                "hookSpecificOutput": {
-                    "hookEventName": "PreToolUse",
-                    "permissionDecision": "deny",
-                    "permissionDecisionReason": message
-                }
-            }))
-            sys.exit(0)
-        break
-
-sys.exit(0)

package/.claude/hooks/scripts/validate_skill.py

@@ -1,81 +0,0 @@
-#!/usr/bin/env python3
-"""PostToolUse hook: validate SKILL.md files on edit."""
-import json
-import re
-import sys
-from pathlib import Path
-
-
-def parse_frontmatter(content):
-    """Parse YAML frontmatter from content."""
-    if not content.startswith("---"):
-        return None
-    parts = content.split("---", 2)
-    if len(parts) < 3:
-        return None
-    result = {}
-    for line in parts[1].strip().split("\n"):
-        if ":" in line:
-            key, _, value = line.partition(":")
-            result[key.strip()] = value.strip().strip('"').strip("'")
-    return result
-
-
-def validate_skill_file(file_path):
-    """Validate a SKILL.md file. Returns list of errors."""
-    errors = []
-
-    if not file_path.exists():
-        return errors
-
-    try:
-        content = file_path.read_text()
-    except Exception as e:
-        errors.append(f"Error reading file: {e}")
-        return errors
-
-    fm = parse_frontmatter(content)
-    if fm is None:
-        errors.append("Missing or invalid YAML frontmatter")
-        return errors
-
-    # Validate name
-    if "name" not in fm:
-        errors.append("Missing 'name' field in frontmatter")
-    else:
-        n = fm["name"]
-        if len(n) > 64:
-            errors.append(f"'name' exceeds 64 chars ({len(n)})")
-        if not re.match(r"^[a-z0-9]+(-[a-z0-9]+)*$", n):
-            errors.append(f"'name' must be kebab-case: '{n}'")
-
-    # Validate description
-    if "description" not in fm:
-        errors.append("Missing 'description' field in frontmatter")
-    elif len(fm["description"]) > 1024:
-        errors.append(f"'description' exceeds 1024 chars ({len(fm['description'])})")
-
-    return errors
-
-
-data = json.load(sys.stdin)
-file_path = data.get("tool_input", {}).get("file_path", "")
-
-if not file_path:
-    sys.exit(0)
-
-# Only validate skill files
-if "/skills/" not in file_path and not file_path.endswith("SKILL.md"):
-    sys.exit(0)
-
-# Only validate SKILL.md files specifically
-if not file_path.endswith("SKILL.md"):
-    sys.exit(0)
-
-errors = validate_skill_file(Path(file_path))
-
-if errors:
-    print("❌ SKILL.md Validation Failed:", file=sys.stderr)
-    for error in errors:
-        print(f"  • {error}", file=sys.stderr)
-    sys.exit(2)

package/.claude/skills/claude-envoy-curation/SKILL.md

@@ -1,162 +0,0 @@
----
-name: claude-envoy-curation
-description: Use when adding new external tool integrations to claude-envoy (replaces MCP servers). Contains command patterns and auto-discovery requirements.
----
-
-<objective>
-Extend claude-envoy with new commands for external tool integrations. claude-envoy replaces MCP servers as the standard way to connect Claude Code agents to external APIs and services.
-</objective>
-
-<quick_start>
-1. Run `.claude/envoy/envoy info` to see current commands
-2. Read `.claude/envoy/commands/base.py` for BaseCommand interface
-3. Create new module in `.claude/envoy/commands/{group}.py`
-4. Export via `COMMANDS = {"cmd": Class}` dict
-5. Test with `.claude/envoy/envoy {group} {command} --help`
-</quick_start>
-
-<success_criteria>
-- Command appears in `.claude/envoy/envoy info` output
-- `--help` shows proper usage
-- Returns valid JSON with `status` field
-- Handles errors gracefully with `self.error()`
-</success_criteria>
-
-<constraints>
-- All commands MUST output JSON to stdout
-- Python 3.9 compat: use `Optional[]` not `|`, add `from __future__ import annotations`
-- Opinionated defaults: minimize exposed params, hardcode sensible values
-- No breaking changes to existing command signatures
-</constraints>
-
-<workflow>
-## Architecture
-
-```
-.claude/envoy/
-├── envoy              # Bash wrapper (auto-creates venv, loads .env)
-├── envoy.py           # CLI with auto-discovery
-├── commands/          # Command modules (auto-discovered)
-│   ├── base.py        # BaseCommand class
-│   └── {group}.py     # COMMANDS = {"cmd": Class, ...}
-└── requirements.txt
-```
-
-## Adding a Command
-
-### 1. Read existing patterns
-
-```bash
-# See current commands
-.claude/envoy/envoy info
-
-# Read base class
-cat .claude/envoy/commands/base.py
-
-# Read example module
-cat .claude/envoy/commands/perplexity.py
-```
-
-### 2. Create or edit command module
-
-In `.claude/envoy/commands/{group}.py`:
-
-```python
-from __future__ import annotations
-from typing import Optional
-from .base import BaseCommand
-
-class MyCommand(BaseCommand):
-    name = "mycommand"
-    description = "What it does"
-
-    def add_arguments(self, parser) -> None:
-        parser.add_argument("query", help="Required arg")
-        parser.add_argument("--optional", help="Optional flag")
-
-    def execute(self, *, query: str, optional: Optional[str] = None, **kwargs) -> dict:
-        # Implementation
-        return self.success({"result": "..."})
-
-# Auto-discovered by envoy.py
-COMMANDS = {
-    "mycommand": MyCommand,
-}
-```
-
-### 3. Add dependencies
-
-If new packages needed, add to `.claude/envoy/requirements.txt` and delete `.claude/envoy/.venv/` to trigger reinstall.
-</workflow>
-
-<validation>
-## Testing
-
-```bash
-# Test command
-.claude/envoy/envoy {group} {command} "test"
-
-# Verify registration
-.claude/envoy/envoy info
-
-# Check help
-.claude/envoy/envoy {group} {command} --help
-```
-
-## Checklist
-- [ ] Command registered in `COMMANDS` dict
-- [ ] `name` and `description` class attributes set
-- [ ] `add_arguments()` defines CLI interface
-- [ ] `execute()` returns `self.success()` or `self.error()`
-- [ ] Dependencies added to requirements.txt if needed
-</validation>
-
-<examples>
-## Base Command Helpers
-
-```python
-self.success(data, metadata=None)  # Return success response
-self.error(type, message, suggestion=None)  # Return error response
-self.read_file(path)  # Read file, returns None if not found
-self.read_files(paths)  # Read multiple files
-self.timed_execute(func, *args)  # Returns (result, duration_ms)
-self.timeout_ms  # From ENVOY_TIMEOUT_MS env var
-```
-
-## Command Module Template
-
-```python
-from __future__ import annotations
-from typing import Optional
-from .base import BaseCommand
-
-class SearchCommand(BaseCommand):
-    name = "search"
-    description = "Search external API"
-
-    def add_arguments(self, parser) -> None:
-        parser.add_argument("query", help="Search query")
-        parser.add_argument("--max-results", type=int, default=5, help="Result limit")
-
-    def execute(self, *, query: str, max_results: int = 5, **kwargs) -> dict:
-        try:
-            results = self._call_api(query, max_results)
-            return self.success({"results": results})
-        except Exception as e:
-            return self.error("api_error", str(e))
-
-COMMANDS = {
-    "search": SearchCommand,
-}
-```
-</examples>
-
-<anti_patterns>
-| Anti-Pattern | Problem | Correct Approach |
-|--------------|---------|------------------|
-| Print instead of return | Output not parseable | Always `return self.success()/self.error()` |
-| Use `str \| None` syntax | Python 3.9 incompatible | Use `Optional[str]` with future annotations |
-| Expose all API params | Overwhelming interface | Hardcode sensible defaults |
-| Skip COMMANDS dict | Command not discovered | Always export via COMMANDS |
-| Modify existing signatures | Breaks dependent skills | Add new params with defaults only |
-</anti_patterns>

package/.claude/skills/claude-envoy-usage/SKILL.md

@@ -1,46 +0,0 @@
----
-name: claude-envoy-usage
-description: Use when building skills that need external tool access (APIs, LLMs, web). claude-envoy replaces MCP servers with agent-scoped integrations.
----
-
-<objective>
-Access external tools via claude-envoy. Self-documenting system - discover available commands dynamically before use.
-</objective>
-
-<quick_start>
-```bash
-# Discover available commands
-.claude/envoy/envoy info
-
-# Get help for command group
-.claude/envoy/envoy <group> --help
-
-# Get help for specific command
-.claude/envoy/envoy <group> <command> --help
-```
-</quick_start>
-
-<success_criteria>
-- Commands discovered via `envoy info` before use
-- JSON response parsed correctly (`status`, `data` fields)
-- File contents passed via envoy (not loaded into Claude context)
-</success_criteria>
-
-<constraints>
-- Always discover commands dynamically - don't assume availability
-- All commands return JSON: `{"status": "success|error", "data": {...}}`
-</constraints>
-
-<workflow>
-### Integration Process
-1. Run `.claude/envoy/envoy info` to see available command groups
-2. Run `--help` on relevant commands to learn arguments
-3. Include specific invocations in skill workflow sections
-4. Parse JSON response - all commands return `{"status": "success|error", "data": {...}}`
-
-### Context Preservation
-envoy reads files directly and passes to external LLMs. Claude only receives JSON output, keeping file contents out of context window.
-
-### When to Extend
-If needed functionality doesn't exist, use the `claude-envoy-curation` skill to add new commands.
-</workflow>

package/.claude/skills/command-development/SKILL.md

@@ -1,206 +0,0 @@
----
-name: command-development
-description: Use when user asks to "create a slash command", "add a command", "write custom command", or needs guidance on command frontmatter, dynamic arguments, or bash execution.
----
-
-<objective>
-Guide creation of Claude Code slash commands with proper structure, frontmatter, and dynamic features. Commands are Markdown files containing prompts that Claude executes when invoked, providing reusability and quick access to complex workflows.
-</objective>
-
-<quick_start>
-1. Create `.claude/commands/command-name.md`
-2. Add frontmatter if needed (description, allowed-tools, argument-hint)
-3. Write prompt body with dynamic arguments (`$1`, `$ARGUMENTS`, `@file`)
-4. Test with `/command-name [args]`
-</quick_start>
-
-<success_criteria>
-- Command file exists in correct location with `.md` extension
-- Frontmatter valid YAML (if present)
-- Dynamic arguments work as expected
-- Tool restrictions appropriate for command scope
-</success_criteria>
-
-<constraints>
-- Commands are instructions FOR Claude, not messages TO users
-- Be restrictive with tools: `Bash(git:*)` not `Bash(*)`
-- Descriptions under 60 characters
-- Single responsibility per command
-</constraints>
-
-## Command Locations
-
-| Type | Location | Scope | Label |
-|------|----------|-------|-------|
-| Project | `.claude/commands/` | Shared with team | (project) |
-| Personal | `~/.claude/commands/` | All your projects | (user) |
-| Plugin | `plugin/commands/` | Plugin users | (plugin-name) |
-
-Project commands take precedence over personal commands with same name.
-
-## File Format
-
-**Minimal command** (no frontmatter):
-```markdown
-Review this code for security vulnerabilities including:
-- SQL injection
-- XSS attacks
-- Authentication issues
-```
-
-**With frontmatter**:
-```markdown
----
-description: Review code for security issues
-allowed-tools: Read, Grep, Bash(git:*)
-model: sonnet
-argument-hint: [file-path]
----
-
-Review @$1 for security vulnerabilities...
-```
-
-## YAML Frontmatter Fields
-
-| Field | Purpose | Default |
-|-------|---------|---------|
-| `description` | Brief description for `/help` | First line of prompt |
-| `allowed-tools` | Tools command can use | Inherits from conversation |
-| `model` | Model to use (sonnet/opus/haiku) | Inherits from conversation |
-| `argument-hint` | Document expected arguments | None |
-| `disable-model-invocation` | Prevent SlashCommand tool from calling | false |
-
-For detailed field specifications, see `references/frontmatter-reference.md`.
-
-## Dynamic Arguments
-
-### $ARGUMENTS - All arguments
-
-```markdown
----
-argument-hint: [issue-number]
----
-Fix issue #$ARGUMENTS following coding standards.
-```
-
-Usage: `/fix-issue 123 high-priority` expands `$ARGUMENTS` to "123 high-priority"
-
-### Positional - $1, $2, $3...
-
-```markdown
----
-argument-hint: [pr-number] [priority] [assignee]
----
-Review PR #$1 with priority $2, assign to $3.
-```
-
-## File References
-
-Use `@` prefix to include file contents:
-
-```markdown
-# Static reference
-Review @src/utils/helpers.js for issues.
-
-# Dynamic with argument
-Generate docs for @$1
-```
-
-## Bash Execution
-
-Execute bash commands inline with exclamation-backtick syntax. Requires `allowed-tools` with Bash.
-
-```markdown
----
-allowed-tools: Bash(git:*)
----
-
-Current branch: !`git branch --show-current`
-Recent commits: !`git log --oneline -5`
-Status: !`git status --short`
-
-Review changes and suggest commit message.
-```
-
-**Tool patterns**:
-- `Bash(git:*)` - Only git commands
-- `Bash(npm:*)` - Only npm commands
-- `Bash(kubectl:*), Bash(helm:*)` - Multiple specific tools
-
-## Command Organization
-
-### Flat (5-15 commands)
-
-```
-.claude/commands/
-├── build.md
-├── test.md
-├── deploy.md
-└── review.md
-```
-
-### Namespaced (15+ commands)
-
-```
-.claude/commands/
-├── ci/
-│   ├── build.md    # /build (project:ci)
-│   └── test.md     # /test (project:ci)
-├── git/
-│   ├── commit.md   # /commit (project:git)
-│   └── pr.md       # /pr (project:git)
-└── docs/
-    └── generate.md # /generate (project:docs)
-```
-
-<examples>
-
-### Read-Only Analysis
-```markdown
----
-allowed-tools: Read, Grep
----
-Analyze code without modifications...
-```
-
-### Git Operations
-```markdown
----
-allowed-tools: Bash(git:*)
----
-!`git status`
-Analyze and suggest...
-```
-
-### File Comparison
-```markdown
-Compare @$1 with @$2 and identify differences...
-```
-
-### User Interaction (AskUserQuestion)
-```markdown
----
-description: Deploy with environment selection
----
-
-Use AskUserQuestion to confirm deployment:
-
-Question: "Deploy to which environment?"
-Options:
-1. Development - Lower risk, fast iteration
-2. Staging - Pre-production testing
-3. Production - Live deployment (requires approval)
-
-After user selection, proceed with deployment to chosen environment.
-```
-
-</examples>
-
-## Additional Resources
-
-### Reference Files
-- **`references/frontmatter-reference.md`** - Complete field specifications and constraints
-
-### Examples
-- **`examples/simple-commands.md`** - Basic command patterns
-- **`examples/plugin-commands.md`** - Plugin-specific patterns with ${CLAUDE_PLUGIN_ROOT}