@stackmemoryai/stackmemory 0.3.16 → 0.3.18

package/scripts/claude-worktree-manager.sh

@@ -0,0 +1,323 @@
+#!/bin/bash
+
+# Enhanced Claude Worktree Manager with Sandbox & Chrome Support
+# Handles multiple Claude instances with isolation and safety features
+
+set -e
+
+# Configuration
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+WORKTREE_SETUP_SCRIPT="${SCRIPT_DIR}/claude-worktree-setup.sh"
+CLAUDE_CONFIG_DIR="${HOME}/.claude"
+SANDBOX_MODE="${CLAUDE_SANDBOX:-false}"
+CHROME_MODE="${CLAUDE_CHROME:-false}"
+
+# Source the main worktree setup
+source "$WORKTREE_SETUP_SCRIPT"
+
+# Enhanced ga() function for Claude with worktree support
+ga_claude() {
+    local branch_base="$1"
+    local task="${2:-development}"
+    local flags="${3:-}"
+    
+    if [[ -z "$branch_base" ]]; then
+        echo "Usage: ga_claude <branch-name> [task] [flags]"
+        echo "Flags: --sandbox, --chrome, --both"
+        return 1
+    fi
+    
+    # Parse flags
+    local use_sandbox=false
+    local use_chrome=false
+    
+    case "$flags" in
+        --sandbox)
+            use_sandbox=true
+            ;;
+        --chrome)
+            use_chrome=true
+            ;;
+        --both)
+            use_sandbox=true
+            use_chrome=true
+            ;;
+    esac
+    
+    # Create the worktree
+    claude_worktree_create "$branch_base" "$task"
+    
+    # Get the created worktree path
+    local timestamp=$(date +%Y%m%d-%H%M%S)
+    local branch="claude-${branch_base}-${timestamp}-${CLAUDE_INSTANCE_ID}"
+    local repo_name="$(basename "$PWD")"
+    local worktree_path="${WORKTREE_BASE_DIR}${repo_name}--${branch}"
+    
+    # Create instance-specific config
+    create_instance_config "$worktree_path" "$use_sandbox" "$use_chrome"
+    
+    # Launch Claude with appropriate flags
+    launch_claude_instance "$worktree_path" "$use_sandbox" "$use_chrome"
+}
+
+# Enhanced gd() function for Claude worktrees
+gd_claude() {
+    local current_dir="$(basename "$PWD")"
+    
+    if [[ "$current_dir" == *"--claude-"* ]]; then
+        if gum confirm "Remove Claude worktree and branch?"; then
+            local branch="${current_dir#*--}"
+            cd ..
+            claude_worktree_remove "$branch"
+        fi
+    else
+        echo "Not in a Claude worktree directory"
+        return 1
+    fi
+}
+
+# Create instance-specific configuration
+create_instance_config() {
+    local worktree_path="$1"
+    local use_sandbox="$2"
+    local use_chrome="$3"
+    
+    local config_file="${worktree_path}/.claude-instance.json"
+    
+    cat > "$config_file" <<EOF
+{
+    "instance_id": "${CLAUDE_INSTANCE_ID}",
+    "worktree_path": "${worktree_path}",
+    "sandbox_enabled": ${use_sandbox},
+    "chrome_enabled": ${use_chrome},
+    "created": "$(date -u +%Y-%m-%dT%H:%M:%SZ)",
+    "restrictions": {
+        "file_access": [
+            "${worktree_path}/**",
+            "${HOME}/.claude/**"
+        ],
+        "network_access": ${use_sandbox},
+        "chrome_automation": ${use_chrome}
+    }
+}
+EOF
+    
+    echo "Instance config created: $config_file"
+}
+
+# Launch Claude instance with appropriate configuration
+launch_claude_instance() {
+    local worktree_path="$1"
+    local use_sandbox="$2"
+    local use_chrome="$3"
+    
+    local claude_cmd="claude"
+    local launch_args=""
+    
+    # Build launch command
+    if [[ "$use_sandbox" == "true" ]]; then
+        launch_args="${launch_args} --sandbox"
+        echo "🔒 Sandbox mode enabled - file and network restrictions active"
+    fi
+    
+    if [[ "$use_chrome" == "true" ]]; then
+        launch_args="${launch_args} --chrome"
+        echo "🌐 Chrome mode enabled - browser automation available"
+    fi
+    
+    # Set working directory
+    cd "$worktree_path"
+    
+    # Export environment variables
+    export CLAUDE_INSTANCE_ID
+    export CLAUDE_WORKTREE_PATH="$worktree_path"
+    
+    echo
+    echo "Launching Claude instance:"
+    echo "  Working directory: $worktree_path"
+    echo "  Instance ID: $CLAUDE_INSTANCE_ID"
+    echo "  Command: ${claude_cmd}${launch_args}"
+    echo
+    
+    # Launch Claude (uncomment when ready to use)
+    # exec ${claude_cmd}${launch_args}
+}
+
+# Monitor active Claude instances
+claude_instance_monitor() {
+    echo "=== Active Claude Instances ==="
+    echo
+    
+    local instance_count=0
+    
+    git worktree list --porcelain | while IFS= read -r line; do
+        if [[ "$line" == worktree* ]]; then
+            local path="${line#worktree }"
+            local config_file="${path}/.claude-instance.json"
+            
+            if [[ -f "$config_file" ]]; then
+                ((instance_count++))
+                echo "Instance #${instance_count}:"
+                
+                local instance_id=$(grep '"instance_id"' "$config_file" | cut -d'"' -f4)
+                local sandbox=$(grep '"sandbox_enabled"' "$config_file" | cut -d':' -f2 | tr -d ' ,')
+                local chrome=$(grep '"chrome_enabled"' "$config_file" | cut -d':' -f2 | tr -d ' ,')
+                local created=$(grep '"created"' "$config_file" | cut -d'"' -f4)
+                
+                echo "  ID: $instance_id"
+                echo "  Path: $path"
+                echo "  Sandbox: $sandbox"
+                echo "  Chrome: $chrome"
+                echo "  Created: $created"
+                
+                # Check for activity (modified files in last hour)
+                local recent_files=$(find "$path" -type f -mmin -60 2>/dev/null | wc -l)
+                if [[ $recent_files -gt 0 ]]; then
+                    echo "  Status: Active (${recent_files} files modified in last hour)"
+                else
+                    echo "  Status: Idle"
+                fi
+                echo
+            fi
+        fi
+    done
+    
+    if [[ $instance_count -eq 0 ]]; then
+        echo "No active Claude instances found"
+    else
+        echo "Total active instances: $instance_count"
+    fi
+}
+
+# Create isolated sandbox for Claude instance
+create_claude_sandbox() {
+    local branch_base="$1"
+    local sandbox_dir="/tmp/claude-sandbox-${CLAUDE_INSTANCE_ID}"
+    
+    echo "Creating isolated sandbox at: $sandbox_dir"
+    
+    # Create sandbox structure
+    mkdir -p "$sandbox_dir"/{workspace,config,cache}
+    
+    # Create sandbox configuration
+    cat > "$sandbox_dir/sandbox.conf" <<EOF
+# Claude Sandbox Configuration
+SANDBOX_ID=${CLAUDE_INSTANCE_ID}
+WORKSPACE=${sandbox_dir}/workspace
+CONFIG=${sandbox_dir}/config
+CACHE=${sandbox_dir}/cache
+NETWORK_RESTRICTED=true
+FILE_ACCESS_RESTRICTED=true
+ALLOWED_PATHS=(
+    "${sandbox_dir}/workspace"
+    "${HOME}/.claude/readonly"
+)
+EOF
+    
+    # Clone repository to sandbox
+    git clone . "$sandbox_dir/workspace" --no-hardlinks
+    
+    # Create worktree in sandbox
+    cd "$sandbox_dir/workspace"
+    git checkout -b "sandbox-${branch_base}-${CLAUDE_INSTANCE_ID}"
+    
+    echo "Sandbox created successfully"
+    echo "To enter sandbox: cd $sandbox_dir/workspace"
+}
+
+# Cleanup sandboxes
+cleanup_claude_sandboxes() {
+    local days="${1:-1}"
+    
+    echo "Cleaning up Claude sandboxes older than ${days} days..."
+    
+    find /tmp -maxdepth 1 -name "claude-sandbox-*" -type d -mtime +${days} -exec rm -rf {} \; 2>/dev/null || true
+    
+    echo "Sandbox cleanup completed"
+}
+
+# Merge work from Claude worktree back to main branch
+claude_worktree_merge() {
+    local current_branch=$(git rev-parse --abbrev-ref HEAD)
+    
+    if [[ ! "$current_branch" == claude-* ]]; then
+        echo "Not in a Claude worktree branch"
+        return 1
+    fi
+    
+    echo "Preparing to merge Claude work back to main branch..."
+    
+    # Ensure everything is committed
+    if [[ -n $(git status --porcelain) ]]; then
+        echo "You have uncommitted changes. Please commit them first."
+        return 1
+    fi
+    
+    # Interactive rebase to clean up commits
+    if gum confirm "Clean up commits before merging?"; then
+        git rebase -i origin/main || git rebase -i origin/master
+    fi
+    
+    # Create PR or merge directly
+    if gum confirm "Create pull request?"; then
+        gh pr create --fill
+    else
+        # Switch to main branch
+        git checkout main || git checkout master
+        git merge "$current_branch" --no-ff
+        echo "Merged $current_branch to main"
+        
+        if gum confirm "Delete the Claude worktree?"; then
+            claude_worktree_remove "$current_branch"
+        fi
+    fi
+}
+
+# Aliases for convenience
+alias cw='claude_worktree_create'
+alias cwl='claude_worktree_list'
+alias cwr='claude_worktree_remove'
+alias cwc='claude_worktree_cleanup'
+alias cws='claude_worktree_sync'
+alias cwm='claude_worktree_merge'
+alias cim='claude_instance_monitor'
+
+# Export functions for use in subshells
+export -f ga_claude
+export -f gd_claude
+export -f claude_worktree_create
+export -f claude_worktree_list
+export -f claude_worktree_remove
+export -f claude_worktree_cleanup
+export -f claude_worktree_sync
+export -f claude_worktree_merge
+export -f claude_instance_monitor
+export -f create_claude_sandbox
+export -f cleanup_claude_sandboxes
+
+# Show help if no arguments
+if [[ "$#" -eq 0 ]]; then
+    echo "Claude Worktree Manager with Sandbox & Chrome Support"
+    echo
+    echo "Quick Start:"
+    echo "  ga_claude <branch> [task] [--sandbox|--chrome|--both]"
+    echo "  gd_claude                  - Remove current Claude worktree"
+    echo
+    echo "Commands:"
+    echo "  cw <branch> [task]         - Create worktree"
+    echo "  cwl                        - List worktrees"
+    echo "  cwr [branch]               - Remove worktree"
+    echo "  cwc [days]                 - Cleanup old worktrees"
+    echo "  cws                        - Sync with main"
+    echo "  cwm                        - Merge back to main"
+    echo "  cim                        - Monitor instances"
+    echo
+    echo "Sandbox Commands:"
+    echo "  create_claude_sandbox <branch>  - Create isolated sandbox"
+    echo "  cleanup_claude_sandboxes [days] - Clean old sandboxes"
+    echo
+    echo "Examples:"
+    echo "  ga_claude feature-auth 'Add authentication' --sandbox"
+    echo "  ga_claude ui-update 'Update UI components' --chrome"
+    echo "  ga_claude complex-task 'Major refactor' --both"
+fi

package/scripts/claude-worktree-monitor.sh

@@ -0,0 +1,371 @@
+#!/bin/bash
+
+# Claude Worktree Monitor & Cleanup Service
+# Monitors active worktrees, manages resources, and prevents conflicts
+
+set -e
+
+# Configuration
+MONITOR_INTERVAL="${CLAUDE_MONITOR_INTERVAL:-300}" # 5 minutes
+LOG_DIR="${HOME}/.claude/logs"
+LOCK_DIR=".claude-worktree-locks"
+MAX_ACTIVE_WORKTREES="${MAX_ACTIVE_WORKTREES:-5}"
+AUTO_CLEANUP_DAYS="${AUTO_CLEANUP_DAYS:-7}"
+
+# Colors
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m'
+
+# Initialize logging
+init_logging() {
+    mkdir -p "$LOG_DIR"
+    local log_file="${LOG_DIR}/monitor-$(date +%Y%m%d).log"
+    exec 1> >(tee -a "$log_file")
+    exec 2>&1
+}
+
+# Log with timestamp
+log_message() {
+    echo "[$(date '+%Y-%m-%d %H:%M:%S')] $1"
+}
+
+# Check worktree health
+check_worktree_health() {
+    local worktree_path="$1"
+    local branch="$2"
+    local health_status="healthy"
+    local issues=()
+    
+    # Check if directory exists
+    if [[ ! -d "$worktree_path" ]]; then
+        issues+=("Directory missing")
+        health_status="critical"
+        return 1
+    fi
+    
+    cd "$worktree_path" 2>/dev/null || {
+        issues+=("Cannot access directory")
+        health_status="critical"
+        return 1
+    }
+    
+    # Check git status
+    if ! git status &>/dev/null; then
+        issues+=("Git repository corrupted")
+        health_status="critical"
+    fi
+    
+    # Check for merge conflicts
+    if git diff --name-only --diff-filter=U | grep -q .; then
+        issues+=("Has merge conflicts")
+        health_status="warning"
+    fi
+    
+    # Check disk usage
+    local disk_usage=$(du -sh . 2>/dev/null | cut -f1)
+    local disk_usage_mb=$(du -sm . 2>/dev/null | cut -f1)
+    if [[ $disk_usage_mb -gt 1000 ]]; then
+        issues+=("High disk usage: ${disk_usage}")
+        health_status="warning"
+    fi
+    
+    # Check for stale lock files
+    local lock_file="${LOCK_DIR}/${branch}.lock"
+    if [[ -f "$lock_file" ]]; then
+        local lock_age_hours=$(( ($(date +%s) - $(stat -f %m "$lock_file" 2>/dev/null || stat -c %Y "$lock_file" 2>/dev/null)) / 3600 ))
+        if [[ $lock_age_hours -gt 24 ]]; then
+            issues+=("Stale lock file (${lock_age_hours}h old)")
+            health_status="warning"
+        fi
+    fi
+    
+    # Return health report
+    if [[ ${#issues[@]} -gt 0 ]]; then
+        echo -e "${YELLOW}Health: ${health_status}${NC}"
+        for issue in "${issues[@]}"; do
+            echo "  - $issue"
+        done
+    else
+        echo -e "${GREEN}Health: healthy${NC}"
+    fi
+    
+    cd - > /dev/null
+}
+
+# Monitor active worktrees
+monitor_worktrees() {
+    log_message "Starting worktree monitoring cycle"
+    
+    local active_count=0
+    local total_disk_usage=0
+    local worktree_data=()
+    
+    echo -e "${BLUE}=== Claude Worktree Status ===${NC}"
+    echo "Time: $(date '+%Y-%m-%d %H:%M:%S')"
+    echo
+    
+    # Collect worktree information
+    git worktree list --porcelain | while IFS= read -r line; do
+        if [[ "$line" == worktree* ]]; then
+            local path="${line#worktree }"
+            local dirname="$(basename "$path")"
+            
+            # Check if this is a Claude worktree
+            if [[ "$dirname" == *"--claude-"* ]]; then
+                ((active_count++))
+                local branch="${dirname#*--}"
+                
+                echo -e "${YELLOW}Worktree ${active_count}: ${dirname}${NC}"
+                echo "  Path: $path"
+                
+                # Check health
+                check_worktree_health "$path" "$branch"
+                
+                # Check activity
+                if [[ -d "$path" ]]; then
+                    local last_modified=$(find "$path" -type f -name "*.ts" -o -name "*.tsx" -o -name "*.js" -o -name "*.jsx" 2>/dev/null | xargs stat -f %m 2>/dev/null | sort -n | tail -1)
+                    if [[ -n "$last_modified" ]]; then
+                        local age_minutes=$(( ($(date +%s) - $last_modified) / 60 ))
+                        if [[ $age_minutes -lt 60 ]]; then
+                            echo -e "  Activity: ${GREEN}Active (${age_minutes}m ago)${NC}"
+                        elif [[ $age_minutes -lt 1440 ]]; then
+                            echo -e "  Activity: ${YELLOW}Idle ($(( age_minutes / 60 ))h ago)${NC}"
+                        else
+                            echo -e "  Activity: ${RED}Stale ($(( age_minutes / 1440 ))d ago)${NC}"
+                        fi
+                    fi
+                    
+                    # Disk usage
+                    local disk_mb=$(du -sm "$path" 2>/dev/null | cut -f1)
+                    total_disk_usage=$((total_disk_usage + disk_mb))
+                    echo "  Disk usage: ${disk_mb}MB"
+                fi
+                echo
+            fi
+        fi
+    done
+    
+    # Summary
+    echo -e "${BLUE}=== Summary ===${NC}"
+    echo "Active worktrees: $active_count / $MAX_ACTIVE_WORKTREES"
+    echo "Total disk usage: ${total_disk_usage}MB"
+    
+    # Warnings
+    if [[ $active_count -ge $MAX_ACTIVE_WORKTREES ]]; then
+        echo -e "${RED}WARNING: Maximum worktree limit reached!${NC}"
+        echo "Consider running: ./claude-worktree-cleanup.sh"
+    fi
+    
+    if [[ $total_disk_usage -gt 5000 ]]; then
+        echo -e "${YELLOW}WARNING: High total disk usage (${total_disk_usage}MB)${NC}"
+    fi
+    
+    log_message "Monitoring cycle completed: ${active_count} active worktrees, ${total_disk_usage}MB total"
+}
+
+# Auto-cleanup old worktrees
+auto_cleanup() {
+    log_message "Running auto-cleanup for worktrees older than ${AUTO_CLEANUP_DAYS} days"
+    
+    local cleaned_count=0
+    
+    git worktree list --porcelain | while IFS= read -r line; do
+        if [[ "$line" == worktree* ]]; then
+            local path="${line#worktree }"
+            local dirname="$(basename "$path")"
+            
+            if [[ "$dirname" == *"--claude-"* ]]; then
+                local branch="${dirname#*--}"
+                local lock_file="${LOCK_DIR}/${branch}.lock"
+                
+                # Check age
+                if [[ -f "$lock_file" ]]; then
+                    local created=$(grep '"created"' "$lock_file" | cut -d'"' -f4)
+                    local created_timestamp=$(date -d "$created" +%s 2>/dev/null || date -j -f "%Y-%m-%dT%H:%M:%SZ" "$created" +%s 2>/dev/null)
+                    local current_timestamp=$(date +%s)
+                    local age_days=$(( (current_timestamp - created_timestamp) / 86400 ))
+                    
+                    if [[ $age_days -gt $AUTO_CLEANUP_DAYS ]]; then
+                        # Check if idle
+                        local last_modified=$(find "$path" -type f -newer "$lock_file" 2>/dev/null | head -1)
+                        if [[ -z "$last_modified" ]]; then
+                            log_message "Auto-removing old idle worktree: $dirname (${age_days} days old)"
+                            git worktree remove "$path" --force 2>/dev/null && ((cleaned_count++))
+                            rm -f "$lock_file"
+                        fi
+                    fi
+                fi
+            fi
+        fi
+    done
+    
+    if [[ $cleaned_count -gt 0 ]]; then
+        log_message "Auto-cleanup completed: removed ${cleaned_count} old worktrees"
+    fi
+}
+
+# Conflict detection
+detect_conflicts() {
+    local conflicts=()
+    local branches=()
+    
+    # Collect all Claude branches
+    git worktree list --porcelain | while IFS= read -r line; do
+        if [[ "$line" == branch* ]] && [[ "$line" == *"claude-"* ]]; then
+            branches+=("${line#branch refs/heads/}")
+        fi
+    done
+    
+    # Check for potential conflicts
+    for ((i=0; i<${#branches[@]}; i++)); do
+        for ((j=i+1; j<${#branches[@]}; j++)); do
+            local branch1="${branches[i]}"
+            local branch2="${branches[j]}"
+            
+            # Check if branches modify same files
+            local common_files=$(comm -12 \
+                <(git diff --name-only "origin/main...$branch1" 2>/dev/null | sort) \
+                <(git diff --name-only "origin/main...$branch2" 2>/dev/null | sort))
+            
+            if [[ -n "$common_files" ]]; then
+                conflicts+=("${branch1} ↔ ${branch2}: $(echo "$common_files" | wc -l) common files")
+            fi
+        done
+    done
+    
+    if [[ ${#conflicts[@]} -gt 0 ]]; then
+        echo -e "${RED}=== Potential Conflicts Detected ===${NC}"
+        for conflict in "${conflicts[@]}"; do
+            echo "  - $conflict"
+        done
+        echo
+    fi
+}
+
+# Resource usage report
+resource_report() {
+    echo -e "${BLUE}=== Resource Usage Report ===${NC}"
+    echo "Generated: $(date '+%Y-%m-%d %H:%M:%S')"
+    echo
+    
+    # CPU usage by git processes
+    local git_cpu=$(ps aux | grep '[g]it' | awk '{sum+=$3} END {print sum}')
+    echo "Git processes CPU usage: ${git_cpu:-0}%"
+    
+    # Memory usage
+    local git_mem=$(ps aux | grep '[g]it' | awk '{sum+=$4} END {print sum}')
+    echo "Git processes memory usage: ${git_mem:-0}%"
+    
+    # Disk I/O (if iostat available)
+    if command -v iostat &>/dev/null; then
+        echo "Disk I/O:"
+        iostat -d 1 2 | tail -n +4 | head -2
+    fi
+    
+    # Network connections (git remote operations)
+    local git_connections=$(netstat -an 2>/dev/null | grep -c ':22\|:443' || echo "0")
+    echo "Active git network connections: $git_connections"
+    echo
+}
+
+# Daemon mode
+run_daemon() {
+    log_message "Starting Claude Worktree Monitor daemon (PID: $$)"
+    
+    # Create PID file
+    echo $$ > "${HOME}/.claude/monitor.pid"
+    
+    # Trap signals for clean shutdown
+    trap 'log_message "Daemon shutting down"; rm -f "${HOME}/.claude/monitor.pid"; exit 0' SIGTERM SIGINT
+    
+    while true; do
+        monitor_worktrees
+        detect_conflicts
+        resource_report
+        
+        # Run auto-cleanup once per day
+        if [[ $(date +%H:%M) == "03:00" ]]; then
+            auto_cleanup
+        fi
+        
+        sleep "$MONITOR_INTERVAL"
+    done
+}
+
+# Stop daemon
+stop_daemon() {
+    if [[ -f "${HOME}/.claude/monitor.pid" ]]; then
+        local pid=$(cat "${HOME}/.claude/monitor.pid")
+        if kill -0 "$pid" 2>/dev/null; then
+            kill "$pid"
+            echo "Monitor daemon stopped (PID: $pid)"
+        else
+            echo "Monitor daemon not running"
+        fi
+        rm -f "${HOME}/.claude/monitor.pid"
+    else
+        echo "No monitor daemon found"
+    fi
+}
+
+# Main command handler
+main() {
+    local command="${1:-monitor}"
+    
+    case "$command" in
+        monitor)
+            monitor_worktrees
+            detect_conflicts
+            ;;
+        daemon|start)
+            if [[ -f "${HOME}/.claude/monitor.pid" ]] && kill -0 "$(cat "${HOME}/.claude/monitor.pid")" 2>/dev/null; then
+                echo "Monitor daemon already running (PID: $(cat "${HOME}/.claude/monitor.pid"))"
+            else
+                init_logging
+                run_daemon &
+                echo "Monitor daemon started (PID: $!)"
+            fi
+            ;;
+        stop)
+            stop_daemon
+            ;;
+        status)
+            if [[ -f "${HOME}/.claude/monitor.pid" ]] && kill -0 "$(cat "${HOME}/.claude/monitor.pid")" 2>/dev/null; then
+                echo "Monitor daemon running (PID: $(cat "${HOME}/.claude/monitor.pid"))"
+            else
+                echo "Monitor daemon not running"
+            fi
+            ;;
+        cleanup)
+            auto_cleanup
+            ;;
+        report)
+            resource_report
+            ;;
+        conflicts)
+            detect_conflicts
+            ;;
+        *)
+            echo "Claude Worktree Monitor"
+            echo
+            echo "Usage: $0 [command]"
+            echo
+            echo "Commands:"
+            echo "  monitor   - Run monitoring check once (default)"
+            echo "  daemon    - Start monitoring daemon"
+            echo "  stop      - Stop monitoring daemon"
+            echo "  status    - Check daemon status"
+            echo "  cleanup   - Run auto-cleanup"
+            echo "  report    - Generate resource report"
+            echo "  conflicts - Detect potential conflicts"
+            ;;
+    esac
+}
+
+# Run if executed directly
+if [[ "${BASH_SOURCE[0]}" == "${0}" ]]; then
+    main "$@"
+fi