anvil-dev-framework 0.1.6

package/scripts/anvil

@@ -0,0 +1,822 @@
+#!/bin/bash
+
+#
+# Anvil Development Framework CLI
+#
+# Usage: anvil init [options]
+#
+# Scaffolds new projects with Anvil Framework configuration.
+#
+
+set -e
+
+# Version
+VERSION="1.3.0"
+
+# Colors
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+CYAN='\033[0;36m'
+BOLD='\033[1m'
+NC='\033[0m' # No Color
+
+# Determine anvil home directory
+if [ -n "$ANVIL_HOME" ]; then
+    ANVIL_DIR="$ANVIL_HOME"
+else
+    # Default to where this script lives
+    SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+    ANVIL_DIR="$(dirname "$SCRIPT_DIR")"
+fi
+
+# Default options
+DRY_RUN=false
+FORCE=false
+TEMPLATE="generic"
+WITH_LINEAR=false
+WITH_CODE_REVIEW=false
+NO_HOOKS=false
+NO_TTS=false
+NO_MEMORY=false
+NO_STATUSLINE=false
+TARGET_DIR="$(pwd)"
+
+# Show help
+show_help() {
+    cat << EOF
+${BOLD}Anvil Development Framework CLI${NC}
+
+${BOLD}USAGE${NC}
+    anvil init [options]
+    anvil --help
+    anvil --version
+
+${BOLD}COMMANDS${NC}
+    init        Initialize Anvil in the current directory
+
+${BOLD}OPTIONS${NC}
+    --template <type>    Project template: saas, api-python, generic (default: generic)
+    --with-linear        Run /linear-setup after initialization
+    --with-code-review   Enable code review integration in config
+    --no-tts             Disable TTS voice announcements
+    --no-memory          Disable claude-mem context loading
+    --no-statusline      Disable custom statusline display
+    --no-hooks           Skip ALL hooks (includes safety hooks - use with caution)
+    --force              Overwrite existing files (backs up first)
+    --dry-run            Show what would be created without making changes
+    --help, -h           Show this help message
+    --version, -v        Show version number
+
+${BOLD}HOOK OPTIONS${NC}
+    By default, all hooks and statusline are installed including:
+    - Safety hooks (rm -rf protection, .env protection)
+    - TTS voice announcements
+    - Claude-mem context loading
+    - Custom statusline (model, context%, branch, issue, phase, cost)
+
+    Use --no-tts, --no-memory, or --no-statusline to selectively disable
+    features while keeping safety hooks active. Only use --no-hooks if you
+    want a completely minimal setup without any hook protections.
+
+${BOLD}EXAMPLES${NC}
+    anvil init                           # Full init with all features
+    anvil init --template saas           # SaaS stack (Next.js + Supabase + Vercel)
+    anvil init --template api-python     # Python API (FastAPI + PostgreSQL)
+    anvil init --with-linear             # Full setup with Linear integration
+    anvil init --with-code-review        # Enable code review in config
+    anvil init --no-tts                  # Without voice announcements
+    anvil init --no-memory               # Without context loading
+    anvil init --no-statusline           # Without custom statusline
+    anvil init --no-tts --no-memory      # Safety hooks only
+    anvil init --no-hooks                # Minimal setup (no safety hooks!)
+    anvil init --dry-run                 # Preview changes
+
+${BOLD}ENVIRONMENT${NC}
+    ANVIL_HOME    Path to Anvil framework installation (auto-detected if not set)
+
+EOF
+}
+
+# Show version
+show_version() {
+    echo "anvil version $VERSION"
+}
+
+# Log functions
+log_info() {
+    echo -e "${BLUE}$1${NC}"
+}
+
+log_success() {
+    echo -e "  ${GREEN}✓${NC} $1"
+}
+
+log_skip() {
+    echo -e "  ${YELLOW}⊘${NC} $1"
+}
+
+log_warn() {
+    echo -e "  ${YELLOW}⚠${NC} $1"
+}
+
+log_error() {
+    echo -e "${RED}Error: $1${NC}" >&2
+}
+
+log_dry() {
+    echo -e "  ${CYAN}[DRY RUN]${NC} Would create: $1"
+}
+
+# Create directory (respects dry-run)
+create_dir() {
+    local dir="$1"
+    if [ "$DRY_RUN" = true ]; then
+        log_dry "$dir/"
+    else
+        mkdir -p "$dir"
+        log_success "$dir/"
+    fi
+}
+
+# Copy file (respects dry-run and force)
+copy_file() {
+    local src="$1"
+    local dest="$2"
+    local display_name="$3"
+
+    if [ "$DRY_RUN" = true ]; then
+        if [ -f "$dest" ] && [ "$FORCE" = false ]; then
+            log_dry "$display_name (exists, would skip)"
+        else
+            log_dry "$display_name"
+        fi
+        return
+    fi
+
+    if [ -f "$dest" ] && [ "$FORCE" = false ]; then
+        log_skip "$display_name (exists, use --force to overwrite)"
+        return
+    fi
+
+    # Backup if force and file exists
+    if [ -f "$dest" ] && [ "$FORCE" = true ]; then
+        backup_dir="$TARGET_DIR/.claude/.backup"
+        mkdir -p "$backup_dir"
+        cp "$dest" "$backup_dir/$(basename "$dest").$(date +%Y%m%d%H%M%S)"
+        log_info "Backed up existing $display_name"
+    fi
+
+    cp "$src" "$dest"
+    log_success "$display_name"
+}
+
+# Create symlink (respects dry-run)
+create_symlink() {
+    local src="$1"
+    local dest="$2"
+    local display_name="$3"
+
+    if [ "$DRY_RUN" = true ]; then
+        log_dry "$display_name → $src"
+        return
+    fi
+
+    # Remove existing symlink or file
+    if [ -L "$dest" ] || [ -f "$dest" ]; then
+        if [ "$FORCE" = true ]; then
+            rm -f "$dest"
+        else
+            log_skip "$display_name (exists)"
+            return
+        fi
+    fi
+
+    ln -s "$src" "$dest"
+    log_success "$display_name → $(basename "$src")"
+}
+
+# Check if Anvil is already initialized
+check_existing() {
+    if [ -d "$TARGET_DIR/.claude" ]; then
+        if [ "$FORCE" = false ]; then
+            log_error "Existing Anvil configuration found at $TARGET_DIR/.claude/"
+            echo ""
+            echo "Use --force to overwrite (existing files will be backed up to .claude/.backup/)"
+            echo "Use --dry-run to preview what would change"
+            exit 1
+        fi
+    fi
+}
+
+# Generate settings.local.json based on flags
+generate_settings() {
+    local settings_file="$TARGET_DIR/.claude/settings.local.json"
+
+    if [ "$DRY_RUN" = true ]; then
+        if [ "$NO_HOOKS" = true ]; then
+            log_dry "settings.local.json (minimal - no hooks)"
+        elif [ "$NO_TTS" = true ] && [ "$NO_MEMORY" = true ]; then
+            log_dry "settings.local.json (safety hooks only)"
+        elif [ "$NO_TTS" = true ]; then
+            log_dry "settings.local.json (no TTS)"
+        elif [ "$NO_MEMORY" = true ]; then
+            log_dry "settings.local.json (no memory)"
+        else
+            log_dry "settings.local.json (full)"
+        fi
+        return
+    fi
+
+    if [ -f "$settings_file" ] && [ "$FORCE" = false ]; then
+        log_skip "settings.local.json (exists)"
+        return
+    fi
+
+    # Build session_start command based on flags
+    local session_cmd="uv run .claude/hooks/session_start.py"
+    if [ "$NO_MEMORY" = false ]; then
+        session_cmd="$session_cmd --load-context"
+    fi
+    session_cmd="$session_cmd --register-agent"
+    if [ "$NO_TTS" = false ]; then
+        session_cmd="$session_cmd --announce"
+    fi
+
+    # Build pre_tool_use command based on flags
+    local pre_cmd="uv run .claude/hooks/pre_tool_use.py"
+    if [ "$NO_TTS" = false ]; then
+        pre_cmd="$pre_cmd --announce"
+    fi
+
+    # Build post_tool_use command based on flags
+    local post_cmd="uv run .claude/hooks/post_tool_use.py"
+    if [ "$NO_TTS" = false ]; then
+        post_cmd="$post_cmd --announce"
+    fi
+
+    # Build subagent_start command
+    local subagent_start_cmd="uv run .claude/hooks/subagent_start.py --log --inject-context"
+
+    # Build subagent_stop command based on flags
+    local subagent_stop_cmd="uv run .claude/hooks/subagent_stop.py"
+    if [ "$NO_TTS" = false ]; then
+        subagent_stop_cmd="$subagent_stop_cmd --announce"
+    fi
+
+    # Build permission_request command (always log, safety checks always active)
+    local permission_cmd="uv run .claude/hooks/permission_request.py --log"
+
+    # Build statusLine section (unless disabled)
+    local statusline_section=""
+    if [ "$NO_STATUSLINE" = false ]; then
+        statusline_section=',
+  "statusLine": {
+    "type": "command",
+    "command": "bash .claude/hooks/statusline.sh"
+  }'
+    fi
+
+    # Write the settings file
+    cat > "$settings_file" << SETTINGS_EOF
+{
+  "permissions": {
+    "allow": [],
+    "deny": []
+  },
+  "hooks": {
+    "SessionStart": [
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "$session_cmd"
+          }
+        ]
+      }
+    ],
+    "PreToolUse": [
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "$pre_cmd"
+          }
+        ]
+      }
+    ],
+    "PostToolUse": [
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "$post_cmd"
+          }
+        ]
+      }
+    ],
+    "SubagentStart": [
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "$subagent_start_cmd"
+          }
+        ]
+      }
+    ],
+    "SubagentStop": [
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "$subagent_stop_cmd"
+          }
+        ]
+      }
+    ],
+    "PermissionRequest": [
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "$permission_cmd"
+          }
+        ]
+      }
+    ]
+  }$statusline_section
+}
+SETTINGS_EOF
+
+    # Determine what mode was used
+    if [ "$NO_TTS" = true ] && [ "$NO_MEMORY" = true ]; then
+        log_success "settings.local.json (safety hooks only)"
+    elif [ "$NO_TTS" = true ]; then
+        log_success "settings.local.json (no TTS)"
+    elif [ "$NO_MEMORY" = true ]; then
+        log_success "settings.local.json (no memory)"
+    else
+        log_success "settings.local.json (full)"
+    fi
+}
+
+# Generate minimal settings (no hooks at all)
+generate_minimal_settings() {
+    local settings_file="$TARGET_DIR/.claude/settings.local.json"
+
+    if [ "$DRY_RUN" = true ]; then
+        log_dry "settings.local.json (minimal - no hooks)"
+        return
+    fi
+
+    if [ -f "$settings_file" ] && [ "$FORCE" = false ]; then
+        log_skip "settings.local.json (exists)"
+        return
+    fi
+
+    cat > "$settings_file" << 'SETTINGS_EOF'
+{
+  "permissions": {
+    "allow": [],
+    "deny": []
+  }
+}
+SETTINGS_EOF
+    log_success "settings.local.json (minimal)"
+}
+
+# Generate anvil.config.json for framework settings
+generate_anvil_config() {
+    local config_file="$TARGET_DIR/.claude/anvil.config.json"
+
+    if [ "$DRY_RUN" = true ]; then
+        if [ "$WITH_CODE_REVIEW" = true ]; then
+            log_dry "anvil.config.json (with code review)"
+        else
+            log_dry "anvil.config.json (framework settings)"
+        fi
+        return
+    fi
+
+    if [ -f "$config_file" ] && [ "$FORCE" = false ]; then
+        log_skip "anvil.config.json (exists)"
+        return
+    fi
+
+    if [ "$WITH_CODE_REVIEW" = true ]; then
+        cat > "$config_file" << 'CONFIG_EOF'
+{
+  "version": "1.1",
+  "autoRetro": false,
+  "autoHealthcheck": false,
+  "codeReview": {
+    "enabled": true,
+    "tool": "coderabbit",
+    "command": "coderabbit --prompt-only",
+    "enforcement": "soft"
+  }
+}
+CONFIG_EOF
+        log_success "anvil.config.json (with code review)"
+    else
+        cat > "$config_file" << 'CONFIG_EOF'
+{
+  "version": "1.1",
+  "autoRetro": false,
+  "autoHealthcheck": false,
+  "codeReview": {
+    "enabled": false,
+    "tool": "coderabbit",
+    "command": "coderabbit --prompt-only",
+    "enforcement": "soft"
+  }
+}
+CONFIG_EOF
+        log_success "anvil.config.json"
+    fi
+}
+
+# Update .gitignore with Anvil-specific exclusions
+update_gitignore() {
+    local gitignore_file="$TARGET_DIR/.gitignore"
+    local anvil_marker="# Anvil Framework"
+    local anvil_state_entry=".claude/anvil-state.json"
+
+    if [ "$DRY_RUN" = true ]; then
+        if [ -f "$gitignore_file" ]; then
+            log_dry ".gitignore (add anvil-state.json)"
+        else
+            log_dry ".gitignore (create with anvil-state.json)"
+        fi
+        return
+    fi
+
+    # Check if entry already exists
+    if [ -f "$gitignore_file" ] && grep -q "$anvil_state_entry" "$gitignore_file" 2>/dev/null; then
+        log_skip ".gitignore (anvil-state.json already present)"
+        return
+    fi
+
+    # Add the Anvil section to .gitignore
+    if [ -f "$gitignore_file" ]; then
+        # Append to existing file
+        echo "" >> "$gitignore_file"
+        echo "$anvil_marker" >> "$gitignore_file"
+        echo "$anvil_state_entry" >> "$gitignore_file"
+        log_success ".gitignore (added anvil-state.json)"
+    else
+        # Create new file
+        cat > "$gitignore_file" << GITIGNORE_EOF
+$anvil_marker
+$anvil_state_entry
+GITIGNORE_EOF
+        log_success ".gitignore (created with anvil-state.json)"
+    fi
+}
+
+# Main init function
+do_init() {
+    echo ""
+    echo -e "${BOLD}${BLUE}Anvil Development Framework${NC} ${CYAN}v${VERSION}${NC}"
+    echo "══════════════════════════════════════"
+    echo ""
+
+    if [ "$DRY_RUN" = true ]; then
+        echo -e "${CYAN}[DRY RUN MODE] No changes will be made${NC}"
+        echo ""
+    fi
+
+    # Validate Anvil installation
+    if [ ! -d "$ANVIL_DIR/project" ]; then
+        log_error "Anvil framework not found at $ANVIL_DIR"
+        echo "Set ANVIL_HOME environment variable to your Anvil installation path"
+        exit 1
+    fi
+
+    # Show configuration
+    log_info "Template: $TEMPLATE"
+    log_info "Target: $TARGET_DIR"
+
+    # Show hooks status
+    if [ "$NO_HOOKS" = true ]; then
+        echo -e "${YELLOW}Hooks: DISABLED (no safety protections!)${NC}"
+    else
+        local hooks_status="enabled"
+        local hooks_details=""
+        if [ "$NO_TTS" = true ]; then
+            hooks_details="${hooks_details}, no TTS"
+        fi
+        if [ "$NO_MEMORY" = true ]; then
+            hooks_details="${hooks_details}, no memory"
+        fi
+        if [ -n "$hooks_details" ]; then
+            hooks_status="enabled (${hooks_details:2})"  # Remove leading ", "
+        fi
+        log_info "Hooks: $hooks_status"
+    fi
+    echo ""
+
+    # Safety warning for --no-hooks
+    if [ "$NO_HOOKS" = true ]; then
+        echo -e "${YELLOW}════════════════════════════════════════${NC}"
+        echo -e "${YELLOW}  ⚠️  WARNING: Safety hooks disabled!${NC}"
+        echo -e "${YELLOW}════════════════════════════════════════${NC}"
+        echo ""
+        echo "Without hooks, you lose these protections:"
+        echo "  • rm -rf command blocking"
+        echo "  • .env file access prevention"
+        echo "  • TTS voice announcements"
+        echo "  • Claude-mem context loading"
+        echo ""
+        echo "Consider using --no-tts or --no-memory instead"
+        echo "to keep safety protections while disabling features."
+        echo ""
+    fi
+
+    # Check for existing installation (unless force)
+    check_existing
+
+    # Create directory structure
+    log_info "Creating directory structure..."
+    create_dir "$TARGET_DIR/.claude"
+    create_dir "$TARGET_DIR/.claude/specs/current"
+    create_dir "$TARGET_DIR/.claude/specs/archive"
+    create_dir "$TARGET_DIR/.claude/changes"
+    create_dir "$TARGET_DIR/.claude/handoffs"
+    create_dir "$TARGET_DIR/.claude/docs"
+    create_dir "$TARGET_DIR/.claude/examples"
+    create_dir "$TARGET_DIR/.claude/commands"
+    create_dir "$TARGET_DIR/.claude/agents"
+    create_dir "$TARGET_DIR/.claude/retros"
+    create_dir "$TARGET_DIR/.claude/rules"
+
+    # Create hooks directory only if hooks enabled
+    if [ "$NO_HOOKS" = false ]; then
+        create_dir "$TARGET_DIR/.claude/hooks"
+        create_dir "$TARGET_DIR/.claude/hooks/utils"
+        create_dir "$TARGET_DIR/.claude/hooks/utils/tts"
+    fi
+
+    echo ""
+
+    # Copy templates
+    log_info "Installing templates..."
+
+    # CLAUDE.md - use template-specific version if available
+    TEMPLATE_DIR="$ANVIL_DIR/project/templates/$TEMPLATE"
+    if [ -f "$TEMPLATE_DIR/CLAUDE.md" ]; then
+        copy_file "$TEMPLATE_DIR/CLAUDE.md" "$TARGET_DIR/.claude/CLAUDE.md" "CLAUDE.md ($TEMPLATE template)"
+    elif [ -f "$ANVIL_DIR/project/CLAUDE.md.template" ]; then
+        copy_file "$ANVIL_DIR/project/CLAUDE.md.template" "$TARGET_DIR/.claude/CLAUDE.md" "CLAUDE.md (generic)"
+    fi
+
+    # Shared templates
+    if [ -f "$ANVIL_DIR/project/constitution.md.template" ]; then
+        copy_file "$ANVIL_DIR/project/constitution.md.template" "$TARGET_DIR/.claude/constitution.md" "constitution.md"
+    fi
+
+    if [ -f "$ANVIL_DIR/project/product.md.template" ]; then
+        copy_file "$ANVIL_DIR/project/product.md.template" "$TARGET_DIR/.claude/product.md" "product.md"
+    fi
+
+    if [ -f "$ANVIL_DIR/project/coordination.md.template" ]; then
+        copy_file "$ANVIL_DIR/project/coordination.md.template" "$TARGET_DIR/.claude/coordination.md" "coordination.md"
+    fi
+
+    # Copy rules templates
+    if [ -d "$ANVIL_DIR/project/rules" ]; then
+        for rules_file in "$ANVIL_DIR/project/rules"/*.md; do
+            if [ -f "$rules_file" ]; then
+                BASENAME=$(basename "$rules_file")
+                copy_file "$rules_file" "$TARGET_DIR/.claude/rules/$BASENAME" "rules/$BASENAME"
+            fi
+        done
+    fi
+
+    echo ""
+
+    # Install hooks via symlinks (unless --no-hooks)
+    if [ "$NO_HOOKS" = false ]; then
+        log_info "Installing hooks (symlinks)..."
+
+        # Symlink hook files
+        if [ -d "$ANVIL_DIR/project/hooks" ]; then
+            for hook_file in "$ANVIL_DIR/project/hooks"/*.py; do
+                if [ -f "$hook_file" ]; then
+                    BASENAME=$(basename "$hook_file")
+                    create_symlink "$hook_file" "$TARGET_DIR/.claude/hooks/$BASENAME" "hooks/$BASENAME"
+                fi
+            done
+
+            # Symlink TTS utilities (even if --no-tts, in case user changes mind later)
+            if [ -d "$ANVIL_DIR/project/hooks/utils/tts" ]; then
+                for tts_file in "$ANVIL_DIR/project/hooks/utils/tts"/*.py; do
+                    if [ -f "$tts_file" ]; then
+                        BASENAME=$(basename "$tts_file")
+                        create_symlink "$tts_file" "$TARGET_DIR/.claude/hooks/utils/tts/$BASENAME" "hooks/utils/tts/$BASENAME"
+                    fi
+                done
+            fi
+        fi
+
+        echo ""
+
+        # Install test harnesses (symlinks)
+        log_info "Installing test harnesses (symlinks)..."
+        create_dir "$TARGET_DIR/.claude/tests"
+        if [ -d "$ANVIL_DIR/project/tests" ]; then
+            for test_file in "$ANVIL_DIR/project/tests"/*.sh; do
+                if [ -f "$test_file" ]; then
+                    BASENAME=$(basename "$test_file")
+                    create_symlink "$test_file" "$TARGET_DIR/.claude/tests/$BASENAME" "tests/$BASENAME"
+                fi
+            done
+            # Also symlink the README
+            if [ -f "$ANVIL_DIR/project/tests/README.md" ]; then
+                create_symlink "$ANVIL_DIR/project/tests/README.md" "$TARGET_DIR/.claude/tests/README.md" "tests/README.md"
+            fi
+        fi
+
+        echo ""
+
+        # Create settings.local.json with hook configurations
+        log_info "Creating settings.local.json..."
+        generate_settings
+    else
+        # Minimal settings without hooks
+        log_info "Creating minimal settings.local.json (no hooks)..."
+        generate_minimal_settings
+    fi
+
+    # Create anvil.config.json for framework settings
+    log_info "Creating anvil.config.json..."
+    generate_anvil_config
+
+    # Update .gitignore with Anvil exclusions
+    log_info "Updating .gitignore..."
+    update_gitignore
+
+    echo ""
+
+    # Install commands via symlinks (from global/commands/)
+    log_info "Installing commands (symlinks)..."
+    if [ -d "$ANVIL_DIR/global/commands" ]; then
+        for cmd_file in "$ANVIL_DIR/global/commands"/*.md; do
+            if [ -f "$cmd_file" ]; then
+                BASENAME=$(basename "$cmd_file")
+                create_symlink "$cmd_file" "$TARGET_DIR/.claude/commands/$BASENAME" "commands/$BASENAME"
+            fi
+        done
+    fi
+
+    echo ""
+
+    # Summary
+    if [ "$DRY_RUN" = true ]; then
+        echo ""
+        echo -e "${CYAN}[DRY RUN] No changes made${NC}"
+        echo "Run without --dry-run to apply these changes"
+    else
+        echo ""
+        echo -e "${GREEN}════════════════════════════════════════${NC}"
+        echo -e "${GREEN}  Anvil initialized successfully!${NC}"
+        echo -e "${GREEN}════════════════════════════════════════${NC}"
+        echo ""
+        echo "Project configured at: $TARGET_DIR/.claude/"
+        echo ""
+        echo -e "${BOLD}Next steps:${NC}"
+        echo "  1. Edit .claude/CLAUDE.md with your project details"
+        echo "  2. Review .claude/constitution.md principles"
+        echo "  3. Fill out .claude/product.md"
+        if [ "$NO_HOOKS" = false ]; then
+            if [ "$NO_TTS" = true ] && [ "$NO_MEMORY" = true ]; then
+                echo "  4. Safety hooks active (TTS and memory disabled)"
+            elif [ "$NO_TTS" = true ]; then
+                echo "  4. Hooks ready (TTS disabled, memory enabled)"
+            elif [ "$NO_MEMORY" = true ]; then
+                echo "  4. Hooks ready (TTS enabled, memory disabled)"
+            else
+                echo "  4. Hooks ready - TTS and memory enabled"
+            fi
+        else
+            echo -e "  4. ${YELLOW}No hooks installed - consider adding safety hooks${NC}"
+        fi
+        echo ""
+        echo "To start using Anvil, open Claude Code and run /orient"
+
+        # Linear setup if requested
+        if [ "$WITH_LINEAR" = true ]; then
+            echo ""
+            log_info "Linear integration requested..."
+            if [ -f "$ANVIL_DIR/project/linear.yaml.template" ]; then
+                copy_file "$ANVIL_DIR/project/linear.yaml.template" "$TARGET_DIR/.claude/linear.yaml" "linear.yaml"
+            fi
+            echo ""
+            echo -e "${YELLOW}Run /linear-setup in Claude Code to configure your Linear team${NC}"
+        fi
+    fi
+
+    echo ""
+}
+
+# Parse arguments
+parse_args() {
+    while [[ $# -gt 0 ]]; do
+        case $1 in
+            init)
+                COMMAND="init"
+                shift
+                ;;
+            --template)
+                if [[ -z "$2" || "$2" == -* ]]; then
+                    log_error "Option --template requires an argument"
+                    echo "Valid templates: saas, api-python, generic"
+                    echo "Usage: anvil init --template <template>"
+                    exit 1
+                fi
+                TEMPLATE="$2"
+                if [[ ! "$TEMPLATE" =~ ^(saas|api-python|generic)$ ]]; then
+                    log_error "Invalid template: $TEMPLATE"
+                    echo "Valid templates: saas, api-python, generic"
+                    exit 1
+                fi
+                shift 2
+                ;;
+            --with-linear)
+                WITH_LINEAR=true
+                shift
+                ;;
+            --with-code-review)
+                WITH_CODE_REVIEW=true
+                shift
+                ;;
+            --no-hooks)
+                NO_HOOKS=true
+                shift
+                ;;
+            --no-tts)
+                NO_TTS=true
+                shift
+                ;;
+            --no-memory)
+                NO_MEMORY=true
+                shift
+                ;;
+            --no-statusline)
+                NO_STATUSLINE=true
+                shift
+                ;;
+            --force)
+                FORCE=true
+                shift
+                ;;
+            --dry-run)
+                DRY_RUN=true
+                shift
+                ;;
+            --help|-h)
+                show_help
+                exit 0
+                ;;
+            --version|-v)
+                show_version
+                exit 0
+                ;;
+            *)
+                log_error "Unknown option: $1"
+                echo "Run 'anvil --help' for usage"
+                exit 1
+                ;;
+        esac
+    done
+}
+
+# Main
+main() {
+    if [ $# -eq 0 ]; then
+        show_help
+        exit 0
+    fi
+
+    parse_args "$@"
+
+    case $COMMAND in
+        init)
+            do_init
+            ;;
+        *)
+            show_help
+            exit 0
+            ;;
+    esac
+}
+
+main "$@"