install.php

<?php
/**
 * Cursor Rules Installer Script.
 * 
 * This script downloads and installs Cursor rules into your project's .cursor/rules directory.
 * It provides interactive prompts to select which rule sets to install based on project type.
 * 
 * CLI Options:
 * --web-stack, -w: Install core, web, and Drupal rules
 * --python, -p: Install core and Python rules
 * --all, -a: Install all rule sets
 * --core, -c: Install only core rules
 * --custom: Enable selective installation (interactive)
 * --tags: Filter rules by tag expression (e.g., "language:php category:security")
 * --help, -h: Display help information
 * --quiet, -q: Suppress verbose output
 * --yes, -y: Automatically confirm all prompts
 */

declare(strict_types=1);

// Define constants.
define('CURSOR_RULES_VERSION', '1.1.0');
define('CURSOR_RULES_DIR', '.cursor/rules');
define('CURSOR_DIR', '.cursor');
define('CURSOR_COMMANDS_DIR', '.cursor/commands');

const COLORS = [
    'red' => "\033[0;31m",
    'green' => "\033[0;32m",
    'yellow' => "\033[1;33m",
    'blue' => "\033[0;34m",
    'magenta' => "\033[0;35m",
    'cyan' => "\033[0;36m",
    'white' => "\033[1;37m",
    'reset' => "\033[0m",
];

// Define tag presets for common use cases
const TAG_PRESETS = [
    'web' => 'language:javascript OR language:html OR language:css OR language:php',
    'frontend' => 'language:javascript OR language:html OR language:css',
    'drupal' => 'framework:drupal',
    'react' => 'framework:react',
    'vue' => 'framework:vue',
    'python' => 'language:python',
    'security' => 'category:security',
    'owasp' => 'standard:owasp-top10',
    'a11y' => 'category:accessibility',
    // New language-specific security presets
    'php-security' => 'language:php category:security',
    'js-security' => 'language:javascript category:security',
    'python-security' => 'language:python category:security',
    'drupal-security' => 'framework:drupal category:security',
    'php-owasp' => 'language:php standard:owasp-top10',
    'js-owasp' => 'language:javascript standard:owasp-top10',
    'python-owasp' => 'language:python standard:owasp-top10',
    'drupal-owasp' => 'framework:drupal standard:owasp-top10',
];

// Command files bundled with the installer.
const COMMAND_FILES = [
    'behat-drevops.md',
    'drupal-lint.md',
    'gh-issue-create.md',
    'gh-issue-resolve.md',
    'npm-audit-fix.md',
    'pr-assess.md',
    'pr-draft.md',
    'pr-resolve.md',
    'security-scan.md',
    'security-verify.md',
    'session-summary.md',
    'speckit.analyze.md',
    'speckit.checklist.md',
    'speckit.clarify.md',
    'speckit.constitution.md',
    'speckit.implement.md',
    'speckit.plan.md',
    'speckit.specify.md',
    'speckit.tasks.md',
];

// Main function to install cursor rules.
function install_cursor_rules(array $options = []): bool {
  // Default options.
  $default_options = [
    'debug' => false,
    'copy_only' => false,
    'destination' => CURSOR_RULES_DIR,
    'web_stack' => false,
    'python' => false,
    'javascript' => false,
    'tags' => false,
    'tag-preset' => false,
    'ignore-files' => 'yes',
    'all' => false,
    'core' => false,
    'yes' => false,
    'help' => false,
    'commands' => 'auto',
  ];

  // Merge options.
  $options = array_merge($default_options, $options);

  // Determine if STDIN is available for interactive prompts.
  $stdin_available = false;
  if (function_exists('stream_isatty') && defined('STDIN')) {
    $stdin_available = @stream_isatty(STDIN);
  }
  $scripted_input = getenv('CURSOR_INSTALLER_INPUT');
  if (!$stdin_available && $scripted_input !== false && $scripted_input !== '') {
    $stdin_available = true;
  }

  // Show help if requested.
  if ($options['help']) {
    show_help();
    return true;
  }

  // Check for conflicting options.
  $option_count = 0;
  if ($options['web_stack']) $option_count++;
  if ($options['python']) $option_count++;
  if ($options['javascript']) $option_count++;
  if ($options['all']) $option_count++;
  if ($options['core']) $option_count++;
  if ($options['tags']) $option_count++;
  if ($options['tag-preset']) $option_count++;
  
  if ($option_count > 1) {
    echo "Error: Conflicting options. Please choose only one installation type.\n";
    echo "Run with --help for usage information.\n";
    return false;
  }

  // Debug mode.
  if ($options['debug']) {
    echo "Debug mode enabled\n";
    echo "Options: " . print_r($options, true) . "\n";
  }

  // Create destination directory if it doesn't exist.
  if (!is_dir($options['destination'])) {
    if (!mkdir($options['destination'], 0755, true)) {
      echo "Error: Failed to create directory: {$options['destination']}\n";
      return false;
    }

    if ($options['debug']) {
      echo "Created directory: {$options['destination']}\n";
    }
  }

  // Create .cursor directory if it doesn't exist.
  $cursor_dir = dirname($options['destination']);
  if ($cursor_dir !== '.' && !is_dir($cursor_dir)) {
    if (!mkdir($cursor_dir, 0755, true)) {
      echo "Error: Failed to create .cursor directory.\n";
      return false;
    }
  }

  // Define available rules.
  $core_rules = [
    'cursor-rules.mdc',
    'git-commit-standards.mdc',
    'github-actions-standards.mdc',
    'improve-cursorrules-efficiency.mdc',
    'pull-request-changelist-instructions.mdc',
    'readme-maintenance-standards.mdc',
    'testing-guidelines.mdc',
  ];

  $web_stack_rules = [
    'accessibility-standards.mdc',
    'api-standards.mdc',
    'build-optimization.mdc',
    'code-generation-standards.mdc',
    'debugging-standards.mdc',
    'docker-compose-standards.mdc',
    'drupal-authentication-failures.mdc',
    'drupal-broken-access-control.mdc',
    'drupal-cryptographic-failures.mdc',
    'drupal-database-standards.mdc',
    'drupal-file-permissions.mdc',
    'drupal-injection.mdc',
    'drupal-insecure-design.mdc',
    'drupal-integrity-failures.mdc',
    'drupal-logging-failures.mdc',
    'drupal-security-misconfiguration.mdc',
    'drupal-ssrf.mdc',
    'drupal-vulnerable-components.mdc',
    'generic_bash_style.mdc',
    'javascript-performance.mdc',
    'javascript-standards.mdc',
    'lagoon-docker-compose-standards.mdc',
    'lagoon-yml-standards.mdc',
    'multi-agent-coordination.mdc',
    'node-dependencies.mdc',
    'php-drupal-best-practices.mdc',
    'php-drupal-development-standards.mdc',
    'project-definition-template.mdc',
    'react-patterns.mdc',
    'security-practices.mdc',
    'secret-detection.mdc',
    'tailwind-standards.mdc',
    'tests-documentation-maintenance.mdc',
    'third-party-integration.mdc',
    'vortex-cicd-standards.mdc',
    'vortex-scaffold-standards.mdc',
    'vue-best-practices.mdc',
    'behat-steps.mdc',
    'behat-ai-guide.mdc',
  ];

  $python_rules = [
    'python-broken-access-control.mdc',
    'python-cryptographic-failures.mdc',
    'python-injection.mdc',
    'python-insecure-design.mdc',
    'python-security-misconfiguration.mdc',
    'python-vulnerable-outdated-components.mdc',
    'python-authentication-failures.mdc',
    'python-integrity-failures.mdc',
    'python-logging-monitoring-failures.mdc',
    'python-ssrf.mdc',
    'security-practices.mdc',
  ];
  
  $javascript_rules = [
    'javascript-broken-access-control.mdc',
    'javascript-cryptographic-failures.mdc',
    'javascript-injection.mdc',
    'javascript-insecure-design.mdc',
    'javascript-security-misconfiguration.mdc',
    'javascript-vulnerable-outdated-components.mdc',
    'javascript-identification-authentication-failures.mdc',
    'javascript-software-data-integrity-failures.mdc',
    'javascript-security-logging-monitoring-failures.mdc',
    'javascript-server-side-request-forgery.mdc',
  ];
  
  // Determine which rules to install.
  $rules_to_install = [];

  // Handle tag-based filtering
  if ($options['tags'] || $options['tag-preset']) {
    $tag_expression = $options['tags'] ?: TAG_PRESETS[$options['tag-preset']] ?? '';
    
    if (empty($tag_expression)) {
      echo "Error: Invalid tag preset '{$options['tag-preset']}'\n";
      echo "Available presets: " . implode(', ', array_keys(TAG_PRESETS)) . "\n";
      return false;
    }
    
    echo "Installing rules matching tag expression: $tag_expression\n";
    
    // When using tags, we need to check all available rules
    $rules_to_install = array_merge($core_rules, $web_stack_rules, $python_rules, $javascript_rules);
    
    if ($options['debug']) {
      echo "Will filter " . count($rules_to_install) . " rules based on tags\n";
    }
  } else {
    // Interactive mode if no specific option is selected and not in auto-yes mode and STDIN is available
    if ($option_count === 0 && !$options['yes'] && $stdin_available) {
      echo "Welcome to Cursor Rules Installer v" . CURSOR_RULES_VERSION . "\n\n";
      echo "Please select which rules to install:\n";
      echo "1) Core rules only\n";
      echo "2) Web stack rules (PHP, Drupal, etc.)\n";
      echo "3) Python rules\n";
      echo "4) JavaScript security rules (OWASP Top 10)\n";
      echo "5) All rules\n";
      echo "6) Tag-based installation (advanced)\n";
      echo "7) Install .cursorignore files\n";
      echo "8) Exit\n";

      $valid_choice = false;
      while (!$valid_choice) {
        echo "\nEnter your choice (1-8): ";
        $choice = read_stdin_line();

        switch ($choice) {
          case '1':
            $rules_to_install = $core_rules;
            $valid_choice = true;
            echo "Installing core rules...\n";
            break;
          case '2':
            $rules_to_install = array_merge($core_rules, $web_stack_rules);
            $valid_choice = true;
            echo "Installing web stack rules...\n";
            if ($options['debug']) {
              echo "Selected " . count($rules_to_install) . " rules to install (" . count($core_rules) . " core + " . count($web_stack_rules) . " web stack)\n";
            }
            break;
          case '3':
            $rules_to_install = array_merge($core_rules, $python_rules);
            $valid_choice = true;
            echo "Installing Python rules...\n";
            if ($options['debug']) {
              echo "Selected " . count($rules_to_install) . " rules to install (" . count($core_rules) . " core + " . count($python_rules) . " python)\n";
            }
            break;
          case '4':
            $rules_to_install = array_merge($core_rules, $javascript_rules);
            $valid_choice = true;
            echo "Installing JavaScript security rules...\n";
            if ($options['debug']) {
              echo "Selected " . count($rules_to_install) . " rules to install (" . count($core_rules) . " core + " . count($javascript_rules) . " JavaScript)\n";
            }
            break;
          case '5':
            $rules_to_install = array_merge($core_rules, $web_stack_rules, $python_rules, $javascript_rules);
            $valid_choice = true;
            echo "Installing all rules...\n";
            if ($options['debug']) {
              echo "Selected " . count($rules_to_install) . " rules to install (" . count($core_rules) . " core + " . count($web_stack_rules) . " web stack + " . count($python_rules) . " python + " . count($javascript_rules) . " JavaScript)\n";
            }
            break;
          case '6':
            // Tag-based installation
            echo "Available tag presets:\n";
            foreach (TAG_PRESETS as $preset => $expression) {
              echo "  - $preset: $expression\n";
            }
            echo "\nEnter tag preset name or custom tag expression: ";
            $tag_input = read_stdin_line();
            
            if (array_key_exists($tag_input, TAG_PRESETS)) {
              $tag_expression = TAG_PRESETS[$tag_input];
            } else {
              $tag_expression = $tag_input;
            }
            
            echo "Installing rules matching: $tag_expression\n";
            $rules_to_install = array_merge($core_rules, $web_stack_rules, $python_rules, $javascript_rules);
            $options['tags'] = $tag_expression;
            $valid_choice = true;
            break;
          case '7':
            // Install only .cursorignore files
            $rules_to_install = [];
            $options['ignore-files'] = true;
            $valid_choice = true;
            echo "Installing .cursorignore files...\n";
            break;
          case '8':
            echo "Installation cancelled.\n";
            return true;
          default:
            echo "Invalid choice. Please enter a number between 1 and 8.\n";
        }
      }
    } else if ($option_count === 0 && !$stdin_available) {
      // If STDIN is not available (e.g., when piped through curl), default to core rules
      echo "⚠️ Interactive mode not available when using curl piping (STDIN is already in use).\n";
      echo "Defaulting to core rules installation.\n\n";
      echo "For interactive installation with prompts, use the two-step process instead:\n";
      echo "1. curl -s https://raw.githubusercontent.com/ivangrynenko/cursor-rules/main/install.php -o install.php\n";
      echo "2. php install.php\n\n";
      echo "For specific options without interactive mode, use:\n";
      echo "curl -s https://raw.githubusercontent.com/ivangrynenko/cursor-rules/main/install.php | php -- --help\n\n";
      $rules_to_install = $core_rules;
    } else if ($options['all']) {
      $rules_to_install = array_merge($core_rules, $web_stack_rules, $python_rules, $javascript_rules);
    } elseif ($options['web_stack']) {
      $rules_to_install = array_merge($core_rules, $web_stack_rules, $javascript_rules);
    } elseif ($options['python']) {
      $rules_to_install = array_merge($core_rules, $python_rules);
    } elseif ($options['javascript']) {
      $rules_to_install = array_merge($core_rules, $javascript_rules);
    } elseif ($options['core']) {
      $rules_to_install = $core_rules;
    } else {
      // Default to core rules if no option specified and in auto-yes mode.
      $rules_to_install = $core_rules;
    }
  }

  // Determine command installation targets.
  $commands_option = strtolower((string)($options['commands'] ?? 'auto'));
  $command_targets = [];

  switch ($commands_option) {
    case 'skip':
    case 'none':
    case 'no':
      $command_targets = [];
      $commands_option = 'skip';
      break;
    case 'home':
      $command_targets = ['home'];
      break;
    case 'project':
      $command_targets = ['project'];
      break;
    case 'both':
    case 'all':
      $command_targets = ['home', 'project'];
      $commands_option = 'both';
      break;
    default:
      // Interactive prompt when auto and we can ask the user.
      if ($options['yes'] || !$stdin_available) {
        $command_targets = ['project'];
        $commands_option = 'project';
      } else {
        echo "\nCursor slash commands provide ready-to-use prompts for the Cursor agent.\n";
        echo "Install slash commands as part of this setup? (Y/n): ";
        $response = strtolower(read_stdin_line());
        if ($response === 'n' || $response === 'no') {
          $command_targets = [];
          $commands_option = 'skip';
        } else {
          echo "\nWhere should the commands be installed?\n";
          echo "  1) User home directory (~/.cursor/commands)\n";
          echo "  2) Project directory (" . CURSOR_COMMANDS_DIR . ")\n";
          echo "  3) Both locations\n";
          echo "Enter choice (1-3) [default: 2]: ";
          $location_choice = read_stdin_line();
          if ($location_choice === '') {
            $location_choice = '2';
          }
          switch ($location_choice) {
            case '1':
              $command_targets = ['home'];
              $commands_option = 'home';
              break;
            case '3':
              $command_targets = ['home', 'project'];
              $commands_option = 'both';
              break;
            case '2':
            default:
              $command_targets = ['project'];
              $commands_option = 'project';
              break;
          }
        }
      }
  }

  $command_targets = array_values(array_unique($command_targets));
  $should_install_commands = count($command_targets) > 0;

  // Persist the normalized command option for later use.
  $options['commands'] = $commands_option;
  $commands_temp_dir = null;
  $command_install_summary = [];


  // Define possible source directories.
  $possible_source_dirs = [
    __DIR__ . '/.cursor/rules',
    dirname(__FILE__) . '/.cursor/rules',
    realpath(__DIR__ . '/../.cursor/rules'),
    getcwd() . '/.cursor/rules',
  ];

  // Filter out false values (realpath returns false if path doesn't exist)
  $possible_source_dirs = array_filter($possible_source_dirs, function($dir) {
    return $dir !== false;
  });

  // Check if we're in the cloned repo root
  if (file_exists(__DIR__ . '/.cursor/rules')) {
    // We're likely in the root of the cloned repository
    $possible_source_dirs[] = __DIR__ . '/.cursor/rules';
  }

  // Validate source directory has the rules we need
  function is_valid_source_dir($dir, $rule_files) {
    if (!is_dir($dir)) {
      return false;
    }

    // Check if at least half of the expected rule files exist
    $found_files = 0;
    $min_files = max(1, intval(count($rule_files) * 0.5));

    if (isset($options['debug']) && $options['debug']) {
      echo "Checking if directory is valid source: $dir\n";
      echo "Looking for at least $min_files of " . count($rule_files) . " rule files\n";
    }

    foreach ($rule_files as $file) {
      if (file_exists($dir . '/' . $file)) {
        $found_files++;
        if (isset($options['debug']) && $options['debug']) {
          echo "  Found rule file: $file\n";
        }
        if ($found_files >= $min_files) {
          return true;
        }
      }
    }

    if (isset($options['debug']) && $options['debug']) {
      echo "  Found only $found_files files, need at least $min_files\n";
    }

    return false;
  }

  // Add debug output for rules to install
  if ($options['debug']) {
    echo "\nRules to install (" . count($rules_to_install) . " total):\n";
    foreach ($rules_to_install as $index => $rule) {
      echo ($index + 1) . ". $rule\n";
    }
    echo "\n";
  }

  // Remove duplicates from rules to install
  $rules_to_install = array_unique($rules_to_install);

  // If copy_only option is set, skip the source directory check.
  if ($options['copy_only']) {
    echo "Copy-only mode enabled. Skipping source directory check.\n";
    return true;
  }

  // Try to download rules from GitHub if no local source is found
  $github_source = 'https://raw.githubusercontent.com/ivangrynenko/cursor-rules/main/.cursor/rules/';
  $temp_dir = sys_get_temp_dir() . '/cursor-rules-' . uniqid();

  // Find a valid source directory
  $source_dir = null;
  foreach ($possible_source_dirs as $dir) {
    if (is_valid_source_dir($dir, $rules_to_install)) {
      $source_dir = $dir;
      if ($options['debug']) {
        echo "Found valid source directory: $dir\n";
      }
      break;
    }
  }

  // If no local source found, try to download from GitHub
  if ($source_dir === null) {
    if ($options['debug']) {
      echo "No local source found, attempting to download from GitHub...\n";
    }

    if (!mkdir($temp_dir, 0755, true)) {
      echo "Error: Failed to create temporary directory.\n";
      return false;
    }

    $download_success = true;

    // Download all rules that need to be installed
    if ($options['debug']) {
      echo "Downloading " . count($rules_to_install) . " rules from GitHub...\n";
    }

    foreach ($rules_to_install as $rule_file) {
      $url = $github_source . $rule_file;
      $content = @file_get_contents($url);

      if ($content === false) {
        if ($options['debug']) {
          echo "Failed to download: $rule_file\n";
        }
        $download_success = false;
        continue;
      }

      file_put_contents($temp_dir . '/' . $rule_file, $content);
      if ($options['debug']) {
        echo "Downloaded: $rule_file\n";
      }
    }

    // Verify we have at least the core rules
    if (is_valid_source_dir($temp_dir, $rules_to_install)) {
      $source_dir = $temp_dir;
      if ($options['debug']) {
        echo "Successfully downloaded rules from GitHub to: $temp_dir\n";
      }
    } else {
      // Clean up temp directory
      @rmdir($temp_dir);

      echo "Error: Could not download rules from GitHub. Please check your internet connection or try again later.\n";
      echo "Alternatively, you can manually download the rules from https://github.com/ivangrynenko/cursor-rules\n";
      return false;
    }
  }
  
  // Final check to ensure we have a valid source directory
  if ($source_dir === null) {
    echo "Error: Could not find source directory containing rule files.\n";
    if ($options['debug']) {
      echo "Tried the following directories:\n";
      foreach ($possible_source_dirs as $dir) {
        echo "  - $dir\n";
      }
    }
    return false;
  }

  $destination_dir = $options['destination'];

  // Ensure destination directory is not the same as source directory
  if (realpath($source_dir) === realpath($destination_dir)) {
    if ($options['debug']) {
      echo "Source and destination directories are the same, downloading from GitHub instead...\n";
    }

    // Create a temporary directory for downloading rules
    $temp_dir = sys_get_temp_dir() . '/cursor-rules-' . uniqid();
    if (!mkdir($temp_dir, 0755, true)) {
      echo "Error: Failed to create temporary directory.\n";
      return false;
    }

    $download_success = true;
    $github_source = 'https://raw.githubusercontent.com/ivangrynenko/cursor-rules/main/.cursor/rules/';

    // Download all rules that need to be installed
    if ($options['debug']) {
      echo "Downloading " . count($rules_to_install) . " rules from GitHub...\n";
    }

    foreach ($rules_to_install as $rule_file) {
      $url = $github_source . $rule_file;
      $content = @file_get_contents($url);

      if ($content === false) {
        if ($options['debug']) {
          echo "Failed to download: $rule_file\n";
        }

        // Check if the file exists locally in the destination directory
        if (file_exists($destination_dir . '/' . $rule_file)) {
          if ($options['debug']) {
            echo "File exists locally, will use local copy: $rule_file\n";
          }
          // Copy the local file to the temp directory
          copy($destination_dir . '/' . $rule_file, $temp_dir . '/' . $rule_file);
        }
        continue;
      }

      file_put_contents($temp_dir . '/' . $rule_file, $content);
      if ($options['debug']) {
        echo "Downloaded: $rule_file\n";
      }
    }

    // Verify we have at least the core rules
    if (is_valid_source_dir($temp_dir, $rules_to_install)) {
      $source_dir = $temp_dir;
      if ($options['debug']) {
        echo "Successfully downloaded rules from GitHub to: $temp_dir\n";
      }
    } else {
      // Clean up temp directory
      @rmdir($temp_dir);

      echo "Error: Could not download rules from GitHub. Please check your internet connection or try again later.\n";
      echo "Alternatively, you can manually download the rules from https://github.com/ivangrynenko/cursor-rules\n";
      return false;
    }
  }

  $copied_count = 0;
  $failed_count = 0;
  $filtered_count = 0;
  
  if ($options['debug']) {
    echo "Source directory: $source_dir\n";
    echo "Destination directory: $destination_dir\n";
    echo "Rules to install: " . count($rules_to_install) . "\n";
  }

  foreach ($rules_to_install as $rule_file) {
    $source_file = $source_dir . '/' . $rule_file;
    $dest_file = $destination_dir . '/' . $rule_file;
    
    // Skip this rule if tag filtering is enabled and the rule doesn't match
    if (($options['tags'] || $options['tag-preset']) && !rule_matches_tag_filter($source_file, $options)) {
      if ($options['debug']) {
        echo "Skipping due to tag filter: $rule_file\n";
      }
      $filtered_count++;
      continue;
    }
    
    if (file_exists($source_file)) {
      if (copy($source_file, $dest_file)) {
        $copied_count++;
        if ($options['debug']) {
          echo "Copied: $rule_file\n";
        }
      } else {
        $failed_count++;
        echo "Failed to copy: $rule_file\n";
      }
    } else {
      if ($options['debug']) {
        echo "Source file not found: $source_file\n";
      }
    }
  }

  if ($options['debug']) {
    echo "Copied $copied_count files, failed to copy $failed_count files.\n";
  }
  
  // Show summary of tag filtering if enabled
  if (($options['tags'] || $options['tag-preset']) && $filtered_count > 0) {
    echo "Filtered out $filtered_count rules based on tag criteria.\n";
  }
  
  // Inform the user if we're updating existing rules
  if (isset($temp_dir) && strpos($source_dir, $temp_dir) === 0 && is_dir($destination_dir)) {
    echo "Updated existing Cursor Rules with the latest version.\n";
  }

  // Clean up temporary directory if it was created
  if (isset($temp_dir) && strpos($source_dir, $temp_dir) === 0) {
    if ($options['debug']) {
      echo "Cleaning up temporary directory: $temp_dir\n";
    }

    // Remove all files in the temp directory
    $files = glob($temp_dir . '/*');
    foreach ($files as $file) {
      @unlink($file);
    }

    // Remove the directory
    @rmdir($temp_dir);
  }

  // Install slash commands if requested.
  $commands_source_dir = null;
  if ($should_install_commands) {
    if ($options['debug']) {
      echo "Preparing to install slash commands...\n";
    }

    $commands_source_candidates = [];
    if (!empty($source_dir)) {
      $commands_source_candidates[] = dirname($source_dir) . '/commands';
    }
    $env_commands_source = getenv('CURSOR_COMMAND_SOURCE') ?: getenv('CURSOR_COMMANDS_SOURCE');
    if (!empty($env_commands_source)) {
      $commands_source_candidates[] = rtrim($env_commands_source, DIRECTORY_SEPARATOR);
    }
    $commands_source_candidates[] = __DIR__ . '/.cursor/commands';
    $commands_source_candidates[] = realpath(__DIR__ . '/../.cursor/commands');
    $commands_source_candidates[] = getcwd() . '/.cursor/commands';
    $commands_source_candidates = array_values(array_filter(array_unique($commands_source_candidates)));

    foreach ($commands_source_candidates as $candidate) {
      if ($candidate && is_valid_commands_source_dir($candidate)) {
        $commands_source_dir = $candidate;
        if ($options['debug']) {
          echo "Using commands source: $candidate\n";
        }
        break;
      }
    }

    if ($commands_source_dir === null) {
      $commands_temp_dir = sys_get_temp_dir() . '/cursor-commands-' . uniqid();
      if (!mkdir($commands_temp_dir, 0755, true)) {
        echo "Warning: Failed to create temporary directory for commands. Skipping command installation.\n";
        $command_install_summary[] = [
          'target' => 'all',
          'status' => 'failed',
          'details' => 'temporary directory creation failed',
        ];
      } else {
        $commands_github_source = 'https://raw.githubusercontent.com/ivangrynenko/cursor-rules/main/.cursor/commands/';
        $downloaded_commands = 0;
        foreach (COMMAND_FILES as $command_file) {
          $url = $commands_github_source . $command_file;
          $content = @file_get_contents($url);
          if ($content === false) {
            if ($options['debug']) {
              echo "Failed to download command file: $command_file\n";
            }
            continue;
          }

          $dest_path = $commands_temp_dir . '/' . $command_file;
          $dest_dir = dirname($dest_path);
          if (!is_dir($dest_dir) && !mkdir($dest_dir, 0755, true)) {
            if ($options['debug']) {
              echo "Failed to create directory for $dest_path\n";
            }
            continue;
          }

          if (file_put_contents($dest_path, $content) !== false) {
            $downloaded_commands++;
          }
        }

        if ($downloaded_commands > 0) {
          $commands_source_dir = $commands_temp_dir;
          if ($options['debug']) {
            echo "Downloaded $downloaded_commands command file(s) to $commands_temp_dir\n";
          }
        } else {
          echo "Warning: Could not download command files from GitHub. Skipping command installation.\n";
          $command_install_summary[] = [
            'target' => 'all',
            'status' => 'failed',
            'details' => 'download failed',
          ];
        }
      }
    }

    if ($commands_source_dir !== null) {
      foreach ($command_targets as $target) {
        if ($target === 'home') {
          $home_dir = get_user_home_directory();
          if ($home_dir === null) {
            echo "Warning: Could not determine the user home directory. Skipping home command installation.\n";
            $command_install_summary[] = [
              'target' => 'home',
              'status' => 'skipped',
              'details' => 'home directory unavailable',
            ];
            continue;
          }
          $destination_commands_dir = rtrim($home_dir, DIRECTORY_SEPARATOR) . DIRECTORY_SEPARATOR . '.cursor/commands';
        } else {
          $destination_commands_dir = dirname($options['destination']) . '/commands';
        }

        $source_real = realpath($commands_source_dir);
        $dest_real = realpath($destination_commands_dir);

        if ($dest_real !== false && $source_real !== false && $dest_real === $source_real) {
          if ($options['debug']) {
            echo "Commands already present at {$destination_commands_dir}; skipping copy.\n";
          }
          $command_install_summary[] = [
            'target' => $target,
            'status' => 'existing',
            'details' => 'source and destination are identical',
          ];
          continue;
        }

        if (!is_dir($destination_commands_dir) && !mkdir($destination_commands_dir, 0755, true)) {
          echo "Warning: Failed to create command directory at {$destination_commands_dir}.\n";
          $command_install_summary[] = [
            'target' => $target,
            'status' => 'failed',
            'details' => 'destination directory creation failed',
          ];
          continue;
        }

        $copied_commands = copy_directory_recursive($commands_source_dir, $destination_commands_dir);
        if ($copied_commands >= 0) {
          if ($options['debug']) {
            echo "Installed {$copied_commands} command file(s) to {$destination_commands_dir}\n";
          }
          $command_install_summary[] = [
            'target' => $target,
            'status' => 'installed',
            'details' => $destination_commands_dir,
            'count' => $copied_commands,
          ];
        } else {
          echo "Warning: Failed to copy command files to {$destination_commands_dir}.\n";
          $command_install_summary[] = [
            'target' => $target,
            'status' => 'failed',
            'details' => 'copy operation failed',
          ];
        }
      }
    }
  } else {
    if ($options['debug']) {
      echo "Skipping slash command installation per user selection.\n";
    }
    $command_install_summary[] = [
      'target' => 'all',
      'status' => 'skipped',
      'details' => 'user opted out',
    ];
  }

  $command_summary_lines = summarise_command_installation($command_install_summary);
  
  // Handle .cursorignore files installation
  $ignore_files_option = $options['ignore-files'];
  $should_install_ignore_files = false;
  
  if ($ignore_files_option === 'yes' || $ignore_files_option === 'y') {
    $should_install_ignore_files = true;
  } else if ($ignore_files_option === 'ask' || $ignore_files_option === 'a') {
    if (function_exists('stream_isatty') && stream_isatty(STDIN)) {
      echo "\nWould you like to install recommended .cursorignore files? (Y/n): ";
      $response = strtolower(read_stdin_line());
      $should_install_ignore_files = ($response === '' || $response === 'y' || $response === 'yes');
    } else {
      // Default to yes if we can't ask interactively
      $should_install_ignore_files = true;
    }
  }
  
  if ($should_install_ignore_files) {
    $ignore_files_dir = dirname(__FILE__) . '/.cursor/ignore-files';
    
    // Try GitHub if local files don't exist
    if (!is_dir($ignore_files_dir)) {
      $ignore_files_dir = $source_dir . '/../ignore-files';
    }
    
    if (is_dir($ignore_files_dir)) {
      $ignore_files = ['.cursorignore', '.cursorindexingignore'];
      $copied_ignore_count = 0;
      
      foreach ($ignore_files as $ignore_file) {
        $source_ignore = $ignore_files_dir . '/' . $ignore_file;
        $dest_ignore = dirname($options['destination']) . '/../' . $ignore_file;
        
        if (file_exists($source_ignore)) {
          if (file_exists($dest_ignore)) {
            if ($options['debug']) {
              echo "$ignore_file already exists, skipping...\n";
            }
          } else {
            if (copy($source_ignore, $dest_ignore)) {
              $copied_ignore_count++;
              if ($options['debug']) {
                echo "Copied: $ignore_file\n";
              }
            }
          }
        }
      }
      
      if ($copied_ignore_count > 0) {
        echo "Installed $copied_ignore_count ignore file(s) to help improve Cursor AI performance.\n";
      }
    } else {
      // Try to download from GitHub
      $github_ignore_base = 'https://raw.githubusercontent.com/ivangrynenko/cursor-rules/main/';
      $ignore_files = ['.cursorignore', '.cursorindexingignore'];
      $downloaded_ignore_count = 0;
      
      foreach ($ignore_files as $ignore_file) {
        $dest_ignore = dirname($options['destination']) . '/../' . $ignore_file;
        
        if (file_exists($dest_ignore)) {
          if ($options['debug']) {
            echo "$ignore_file already exists, skipping...\n";
          }
          continue;
        }
        
        $url = $github_ignore_base . $ignore_file;
        $content = @file_get_contents($url);
        
        if ($content !== false) {
          if (file_put_contents($dest_ignore, $content)) {
            $downloaded_ignore_count++;
            if ($options['debug']) {
              echo "Downloaded and installed: $ignore_file\n";
            }
          }
        }
      }
      
      if ($downloaded_ignore_count > 0) {
        echo "Downloaded and installed $downloaded_ignore_count ignore file(s) to help improve Cursor AI performance.\n";
      }
    }
  }
  
  // Optionally generate a project-local AGENTS.md summarising installed rules.
  // Write if absent; overwrite only when --yes was passed.
  try {
    $project_root = getcwd();
    $agents_md_path = $project_root . '/AGENTS.md';

    $should_write_agents = !file_exists($agents_md_path) || !empty($options['yes']);

    if ($should_write_agents) {
      // Prepare bundle definitions for grouping in AGENTS.md
      $bundle_map = [
        'Core' => $core_rules,
        'Web Stack' => $web_stack_rules,
        'Python' => $python_rules,
        'JavaScript Security' => $javascript_rules,
      ];

      $lines = [];
      $lines[] = '# Cursor Agents Guide (Installed Rules)';
      $lines[] = '';
      $lines[] = 'This file is generated by the installer to index the rules currently installed in this project. It links to the authoritative `.cursor/rules/*.mdc` files.';
      $lines[] = '';

      // Installation summary
      $lines[] = '## Installation Summary';
      if ($options['all']) {
        $lines[] = '- Installation type: All rules (core, web stack, Python, JavaScript)';
      } elseif ($options['web_stack']) {
        $lines[] = '- Installation type: Web stack (includes core and JavaScript security)';
      } elseif ($options['python']) {
        $lines[] = '- Installation type: Python (includes core)';
      } elseif ($options['javascript']) {
        $lines[] = '- Installation type: JavaScript security (includes core)';
      } elseif ($options['core']) {
        $lines[] = '- Installation type: Core only';
      } elseif ($options['tags'] || $options['tag-preset']) {
        $tag_expression = $options['tags'] ?: (TAG_PRESETS[$options['tag-preset']] ?? '');
        $lines[] = '- Installation type: Tag-based selection';
        if (!empty($tag_expression)) {
          $lines[] = "- Tag expression: `{$tag_expression}`";
        }
      } else {
        $lines[] = '- Installation type: Default (core)';
      }
      if (($options['tags'] || $options['tag-preset']) && isset($filtered_count)) {
        $lines[] = "- Filtered out: {$filtered_count} rules (did not match tags)";
      }
      $lines[] = '';
      $lines[] = 'For installation methods and options, see `README.md`. For tag taxonomy, see `TAG_STANDARDS.md`.';
      $lines[] = '';

      if (!empty($command_summary_lines)) {
        $lines[] = '## Slash Commands';
        foreach ($command_summary_lines as $cmd_line) {
          $lines[] = "- {$cmd_line}";
        }
        $lines[] = '';
      }

      // Bundles present
      $lines[] = '## Installed Bundles';
      $any_bundle_listed = false;
      foreach ($bundle_map as $bundle_name => $bundle_rules) {
        $installed_subset = array_values(array_intersect($rules_to_install, $bundle_rules));
        if (count($installed_subset) > 0) {
          $lines[] = "- {$bundle_name}";
          $any_bundle_listed = true;
        }
      }
      if (!$any_bundle_listed) {
        $lines[] = '- Core';
      }
      $lines[] = '';

      // Grouped rule links
      $lines[] = '## Installed Rules';
      foreach ($bundle_map as $bundle_name => $bundle_rules) {
        $installed_subset = array_values(array_intersect($rules_to_install, $bundle_rules));
        if (count($installed_subset) === 0) {
          continue;
        }
        $lines[] = "### {$bundle_name}";
        foreach ($installed_subset as $rule_file) {
          $lines[] = "- [.cursor/rules/{$rule_file}](.cursor/rules/{$rule_file})";
        }
        $lines[] = '';
      }

      // Fallback: if some rules were not mapped (shouldn't happen), list them
      $all_mapped = array_unique(array_merge(...array_values($bundle_map)));
      $unmapped = array_values(array_diff($rules_to_install, $all_mapped));
      if (count($unmapped) > 0) {
        $lines[] = '### Other';
        foreach ($unmapped as $rule_file) {
          $lines[] = "- [.cursor/rules/{$rule_file}](.cursor/rules/{$rule_file})";
        }
        $lines[] = '';
      }

      $content = implode("\n", $lines) . "\n";
      @file_put_contents($agents_md_path, $content);

      if ($options['debug']) {
        echo "Generated AGENTS.md at: {$agents_md_path}\n";
      }
    } else {
      if ($options['debug']) {
        echo "AGENTS.md exists and --yes not set; skipping generation.\n";
      }
    }
  } catch (\Throwable $e) {
    // Non-fatal: continue even if AGENTS.md generation fails
    if ($options['debug']) {
      echo "Warning: Failed to generate AGENTS.md (" . $e->getMessage() . ")\n";
    }
  }

  // Create UPDATE.md file to track version
  $cursor_parent_dir = dirname($options['destination']);
  $update_file_path = $cursor_parent_dir . '/UPDATE.md';
  
  $update_content = "# Cursor Rules Installation\n\n";
  $update_content .= "**Version:** " . CURSOR_RULES_VERSION . "\n";
  $update_content .= "**Installation Date:** " . date('Y-m-d H:i:s T') . "\n";
  $update_content .= "**Rules Installed:** " . $copied_count . " files\n";
  if (!empty($command_summary_lines)) {
    $update_content .= "**Commands:** " . implode(' | ', $command_summary_lines) . "\n";
  }
  $update_content .= "\n";
  
  if (($options['tags'] || $options['tag-preset']) && $filtered_count > 0) {
    $tag_expression = $options['tags'] ?: (TAG_PRESETS[$options['tag-preset']] ?? '');
    $update_content .= "**Tag Filter:** $tag_expression\n";
    $update_content .= "**Filtered Out:** $filtered_count rules\n\n";
  }
  
  $update_content .= "## Installation Type\n";
  if ($options['all']) {
    $update_content .= "- All rules (core, web stack, Python, JavaScript)\n";
  } elseif ($options['web_stack']) {
    $update_content .= "- Web stack rules (core, web, Drupal, JavaScript)\n";
  } elseif ($options['python']) {
    $update_content .= "- Python rules (core + Python security)\n";
  } elseif ($options['javascript']) {
    $update_content .= "- JavaScript rules (core + JavaScript security)\n";
  } elseif ($options['core']) {
    $update_content .= "- Core rules only\n";
  } elseif ($options['tags'] || $options['tag-preset']) {
    $update_content .= "- Tag-based installation\n";
  } else {
    $update_content .= "- Core rules (default)\n";
  }
  
  $update_content .= "\n## Source\n";
  $update_content .= "Rules downloaded from: https://github.com/ivangrynenko/cursor-rules\n";
  
  if (file_put_contents($update_file_path, $update_content)) {
    if ($options['debug']) {
      echo "Created UPDATE.md file at: $update_file_path\n";
    }
  } else {
    echo "Warning: Failed to create UPDATE.md file\n";
  }

  if ($commands_temp_dir !== null && is_dir($commands_temp_dir)) {
    delete_directory_recursive($commands_temp_dir);
  }
  
  return true;
}

/**
 * Check if a rule file matches the tag filter expression.
 * 
 * @param string $file_path Path to the rule file
 * @param array $options Installation options containing tag filters
 * @return bool True if the rule matches the filter, false otherwise
 */
function rule_matches_tag_filter($file_path, $options) {
  if (!file_exists($file_path)) {
    return false;
  }
  
  $content = file_get_contents($file_path);
  
  // Extract tags from the metadata section
  $tags = [];
  if (preg_match('/metadata:\s*\n(?:[^\n]*\n)*?\s*tags:\s*\n((?:\s*-\s*[^\n]+\n)+)/m', $content, $matches)) {
    $tag_lines = explode("\n", trim($matches[1]));
    foreach ($tag_lines as $line) {
      if (preg_match('/^\s*-\s*(.+)$/', $line, $tag_match)) {
        $tags[] = trim($tag_match[1]);
      }
    }
  }
  
  if (empty($tags)) {
    return false;
  }
  
  // Get the tag expression
  $tag_expression = $options['tags'] ?: (TAG_PRESETS[$options['tag-preset']] ?? '');
  
  // Parse and evaluate the tag expression
  return evaluate_tag_expression($tag_expression, $tags);
}

/**
 * Evaluate a tag expression against a set of tags.
 * 
 * Supports:
 * - Simple tags: "language:php"
 * - AND operations: "language:php category:security" (space-separated)
 * - OR operations: "language:php OR language:javascript"
 * 
 * @param string $expression The tag expression to evaluate
 * @param array $tags The tags to check against
 * @return bool True if the expression matches, false otherwise
 */
function evaluate_tag_expression($expression, $tags) {
  // Handle OR operations
  if (stripos($expression, ' OR ') !== false) {
    $or_parts = array_map('trim', explode(' OR ', $expression));
    foreach ($or_parts as $part) {
      if (evaluate_tag_expression($part, $tags)) {
        return true;
      }
    }
    return false;
  }
  
  // Handle AND operations (space-separated)
  $and_parts = array_filter(array_map('trim', explode(' ', $expression)));
  foreach ($and_parts as $required_tag) {
    $found = false;
    foreach ($tags as $tag) {
      if ($tag === $required_tag || stripos($tag, $required_tag) !== false) {
        $found = true;
        break;
      }
    }
    if (!$found) {
      return false;
    }
  }
  
  return true;
}

/**
 * Determine if the provided directory contains command files.
 *
 * @param string $dir
 * @return bool
 */
function is_valid_commands_source_dir($dir) {
  if ($dir === false || !is_dir($dir)) {
    return false;
  }

  $found = 0;
  foreach (COMMAND_FILES as $command_file) {
    if (file_exists(rtrim($dir, DIRECTORY_SEPARATOR) . DIRECTORY_SEPARATOR . $command_file)) {
      $found++;
      if ($found >= 3) {
        return true;
      }
    }
  }

  return $found > 0;
}

/**
 * Recursively copy a directory.
 *
 * @param string $source
 * @param string $destination
 * @return int Number of files copied, or -1 on failure.
 */
function copy_directory_recursive($source, $destination) {
  if (!is_dir($source)) {
    return -1;
  }

  $iterator = new RecursiveIteratorIterator(
    new RecursiveDirectoryIterator($source, FilesystemIterator::SKIP_DOTS),
    RecursiveIteratorIterator::SELF_FIRST
  );

  $copied = 0;

  foreach ($iterator as $item) {
    $target_path = $destination . DIRECTORY_SEPARATOR . $iterator->getSubPathName();

    if ($item->isDir()) {
      if (!is_dir($target_path) && !mkdir($target_path, 0755, true)) {
        return -1;
      }
    } else {
      $target_dir = dirname($target_path);
      if (!is_dir($target_dir) && !mkdir($target_dir, 0755, true)) {
        return -1;
      }
      if (!copy($item->getPathname(), $target_path)) {
        return -1;
      }
      $copied++;
    }
  }

  return $copied;
}

/**
 * Recursively delete a directory.
 *
 * @param string $directory
 * @return void
 */
function delete_directory_recursive($directory) {
  if (!is_dir($directory)) {
    return;
  }

  $iterator = new RecursiveIteratorIterator(
    new RecursiveDirectoryIterator($directory, FilesystemIterator::SKIP_DOTS),
    RecursiveIteratorIterator::CHILD_FIRST
  );

  foreach ($iterator as $fileinfo) {
    if ($fileinfo->isDir()) {
      @rmdir($fileinfo->getPathname());
    } else {
      @unlink($fileinfo->getPathname());
    }
  }

  @rmdir($directory);
}

/**
 * Determine the home directory of the current user.
 *
 * @return string|null
 */
function get_user_home_directory() {
  $home = getenv('HOME') ?: ($_SERVER['HOME'] ?? null);

  if (!$home && strtoupper(substr(PHP_OS, 0, 3)) === 'WIN') {
    $home = getenv('USERPROFILE');
    if (!$home) {
      $drive = getenv('HOMEDRIVE');
      $path = getenv('HOMEPATH');
      if ($drive && $path) {
        $home = $drive . $path;
      }
    }
  }

  return $home ?: null;
}

/**
 * Convert command installation targets to human-readable labels.
 *
 * @param string $target
 * @return string
 */
function command_target_label($target) {
  switch ($target) {
    case 'home':
      return 'home (~/.cursor/commands)';
    case 'project':
      return 'project (.cursor/commands)';
    default:
      return $target;
  }
}

/**
 * Summarise command installation results into human-readable lines.
 *
 * @param array $summary
 * @return array
 */
function summarise_command_installation(array $summary) {
  $groups = [
    'installed' => [],
    'existing' => [],
    'skipped' => [],
    'failed' => [],
  ];

  $notes = [];

  foreach ($summary as $entry) {
    $status = $entry['status'] ?? '';
    $target = $entry['target'] ?? '';
    $details = $entry['details'] ?? '';

    if ($target === 'all') {
      $notes[] = ucfirst($status) . ($details ? " ({$details})" : '');
      continue;
    }

    if (isset($groups[$status])) {
      $groups[$status][] = command_target_label($target);
    } else {
      $notes[] = ucfirst($status) . ' (' . command_target_label($target) . ')';
    }

    if (in_array($status, ['failed', 'skipped'], true) && $details) {
      $notes[] = ucfirst($status) . ' ' . command_target_label($target) . ': ' . $details;
    }
  }

  $lines = [];

  if (!empty($groups['installed'])) {
    $lines[] = 'Installed: ' . implode(', ', array_unique($groups['installed']));
  }

  if (!empty($groups['existing'])) {
    $lines[] = 'Already present: ' . implode(', ', array_unique($groups['existing']));
  }

  if (!empty($groups['skipped'])) {
    $lines[] = 'Skipped: ' . implode(', ', array_unique($groups['skipped']));
  }

  if (!empty($groups['failed'])) {
    $lines[] = 'Failed: ' . implode(', ', array_unique($groups['failed']));
  }

  foreach (array_unique($notes) as $note) {
    if ($note !== '') {
      $lines[] = $note;
    }
  }

  if (empty($lines)) {
    $lines[] = 'No commands were installed.';
  }

  return $lines;
}

/**
 * Safely read a trimmed line from STDIN.
 *
 * @return string
 */
function read_stdin_line() {
  static $scripted_inputs = null;

  if ($scripted_inputs === null) {
    $env = getenv('CURSOR_INSTALLER_INPUT');
    if ($env !== false && $env !== '') {
      $normalized = str_replace(["\r\n", "\r"], "\n", $env);
      $normalized = str_replace([',', ';', '|'], "\n", $normalized);
      $scripted_inputs = explode("\n", $normalized);
    } else {
      $scripted_inputs = [];
    }
  }

  if (!empty($scripted_inputs)) {
    $value = array_shift($scripted_inputs);
    return trim((string) $value);
  }

  if (!defined('STDIN') || !is_resource(STDIN)) {
    return '';
  }

  $line = @fgets(STDIN);
  if ($line === false) {
    return '';
  }

  return trim($line);
}

/**
 * Display help information.
 */
function show_help(): void {
  echo "Cursor Rules Installer v" . CURSOR_RULES_VERSION . "\n";
  echo "Usage: php install.php [options]\n\n";
  echo "Options:\n";
  echo "  --help, -h           Show this help message\n";
  echo "  --debug              Enable debug mode\n";
  echo "  --copy-only          Only copy files, don't perform additional setup\n";
  echo "  --destination=DIR    Specify destination directory (default: .cursor/rules)\n";
  echo "  --web-stack, --ws    Install web stack rules (PHP, Drupal, JavaScript, etc.)\n";
  echo "  --python, -p         Install Python rules\n";
  echo "  --all, -a            Install all rules\n";
  echo "  --core, -c           Install core rules only\n";
  echo "  --yes, -y            Automatically answer yes to all prompts\n";
  echo "  --tags=EXPR          Install rules matching tag expression (e.g., \"language:php category:security\")\n";
  echo "  --tag-preset=NAME    Use a predefined tag preset\n";
  echo "  --ignore-files=OPT   Control .cursorignore file installation (yes/no/ask, default: yes)\n";
  echo "  --commands=OPT       Control slash command installation (project|home|both|skip; default installs to project)\n";
  echo "  --skip-commands      Skip installing slash commands (alias for --commands=skip)\n";
  echo "\nTag Presets:\n";
  foreach (TAG_PRESETS as $name => $expression) {
    echo "  $name: $expression\n";
  }
  echo "\nExamples:\n";
  echo "  php install.php --tags \"language:javascript category:security\"\n";
  echo "  php install.php --tag-preset php-security\n";
  echo "  php install.php --web-stack --ignore-files=no\n";
}

// If this script is being run directly, execute the installation.
// Also handle execution when piped through curl (PHP_SELF becomes "Standard input code")
if (basename(__FILE__) === basename($_SERVER['PHP_SELF'] ?? '') || 
    ($_SERVER['PHP_SELF'] ?? '') === 'Standard input code') {
  // Default options
  $options = [
    'debug' => false,
    'copy_only' => false,
    'destination' => CURSOR_RULES_DIR,
    'web_stack' => false,
    'python' => false,
    'javascript' => false,
    'all' => false,
    'core' => false,
    'yes' => false,
    'help' => false,
    'tags' => false,
    'tag-preset' => false,
    'ignore-files' => 'yes',
    'commands' => 'auto',
  ];

  // Check for command line arguments
  if (isset($_SERVER['argv']) && is_array($_SERVER['argv']) && count($_SERVER['argv']) > 1) {
    // Process arguments
    $argv_count = count($_SERVER['argv']);
    for ($i = 1; $i < $argv_count; $i++) {
      $arg = $_SERVER['argv'][$i];

      // Process argument
      switch ($arg) {
        case '--debug':
          $options['debug'] = true;
          break;
        case '--copy-only':
          $options['copy_only'] = true;
          break;
        case '--web-stack':
        case '--ws':
        case '-w':
          $options['web_stack'] = true;
          break;
        case '--python':
        case '-p':
          $options['python'] = true;
          break;
        case '--javascript':
        case '-j':
          $options['javascript'] = true;
          break;
        case '--all':
        case '-a':
          $options['all'] = true;
          break;
        case '--core':
        case '-c':
          $options['core'] = true;
          break;
        case '--yes':
        case '-y':
          $options['yes'] = true;
          break;
        case '--help':
        case '-h':
          $options['help'] = true;
          break;
        case '--tags':
          // Get the next argument as the value
          if ($i + 1 < count($_SERVER['argv'])) {
            $options['tags'] = $_SERVER['argv'][$i + 1];
            $i++; // Skip the next argument
          } else {
            echo "Error: --tags requires a value\n";
            exit(1);
          }
          break;
        case '--tag-preset':
          // Get the next argument as the value
          if ($i + 1 < count($_SERVER['argv'])) {
            $options['tag-preset'] = $_SERVER['argv'][$i + 1];
            $i++; // Skip the next argument
          } else {
            echo "Error: --tag-preset requires a value\n";
            exit(1);
          }
          break;
        case '--ignore-files':
          // Get the next argument as the value
          if ($i + 1 < count($_SERVER['argv'])) {
            $value = $_SERVER['argv'][$i + 1];
            if (in_array($value, ['yes', 'no', 'ask', 'y', 'n', 'a'])) {
              $options['ignore-files'] = $value;
              $i++; // Skip the next argument
            } else {
              echo "Warning: Invalid value for --ignore-files. Use yes, no, or ask.\n";
              exit(1);
            }
          } else {
            echo "Error: --ignore-files requires a value\n";
            exit(1);
          }
          break;
        case '--commands':
          if ($i + 1 < count($_SERVER['argv'])) {
            $options['commands'] = strtolower($_SERVER['argv'][$i + 1]);
            $i++;
          } else {
            echo "Error: --commands requires a value (project|home|both|skip)\n";
            exit(1);
          }
          break;
        case '--skip-commands':
        case '--no-commands':
          $options['commands'] = 'skip';
          break;
        default:
          // Check for --destination=DIR format
          if (str_starts_with($arg, '--destination=')) {
            $options['destination'] = substr($arg, 14);
          } else if (str_starts_with($arg, '--tags=')) {
            $options['tags'] = substr($arg, 7);
          } else if (str_starts_with($arg, '--tag-preset=')) {
            $options['tag-preset'] = substr($arg, 13);
          } else if (str_starts_with($arg, '--ignore-files=')) {
            $value = substr($arg, 15);
            if (in_array($value, ['yes', 'no', 'ask', 'y', 'n', 'a'])) {
              $options['ignore-files'] = $value;
            } else {
              echo "Warning: Invalid value for --ignore-files. Use yes, no, or ask.\n";
              exit(1);
            }
          } else if (str_starts_with($arg, '--commands=')) {
            $options['commands'] = strtolower(substr($arg, 11));
          } else {
            echo "Warning: Unknown option '$arg'\n";
            exit(1);
          }
      }
    }
  } else {
    // No arguments provided, check if we should parse from STDIN (for curl | php usage)
    if (!stream_isatty(STDIN)) {
      // We're being piped to, look for arguments after the separator
      list($parsed_options, $option_count) = parseArguments();
      // Merge the parsed options with the defaults
      $options = array_merge($options, $parsed_options);
    }
  }

  // Execute installation
  $success = install_cursor_rules($options);

  // Ask about cleanup if not in auto-yes mode and the file still exists
  if ($success && file_exists(__FILE__) && !$options['yes'] && function_exists('stream_isatty') && stream_isatty(STDIN)) {
    echo "\nWould you like to remove the installer file? (Y/n): ";
    $response = strtolower(read_stdin_line());
    if ($response === '' || $response === 'y' || $response === 'yes') {
      unlink(__FILE__);
      echo "Installer file removed.\n";
    }
  }

  echo "\nInstallation " . ($success ? "completed successfully!" : "failed.") . "\n";
  echo "Cursor AI will now use these rules when working with your codebase.\n";
  
  // Ensure all output is flushed before exit
  if (ob_get_level() > 0) {
    ob_flush();
  }
  flush();
  
  // Close stdin if it's open to prevent hanging
  if (defined('STDIN') && is_resource(STDIN)) {
    fclose(STDIN);
  }

  exit($success ? 0 : 1);
}

/**
 * Parse command line arguments when running through curl pipe.
 * 
 * @return array
 */
function parseArguments() {
  global $argv, $argc;
  
  $options = [
    'debug' => false,
    'copy_only' => false,
    'destination' => CURSOR_RULES_DIR,
    'web_stack' => false,
    'python' => false,
    'javascript' => false,
    'all' => false,
    'core' => false,
    'yes' => false,
    'help' => false,
    'tags' => false,
    'tag-preset' => false,
    'ignore-files' => 'yes',
    'commands' => 'auto',
  ];
  
  $option_count = 0;
  
  // Look for -- separator in argv to handle piped arguments
  // When piped through curl, argv[0] is "Standard input code" and arguments start at argv[1]
  $start_index = 1;
  $found_separator = false;
  for ($i = 1; $i < $argc; $i++) {
    if ($argv[$i] === '--') {
      $start_index = $i + 1;
      $found_separator = true;
      break;
    }
  }
  
  // If no separator found and we're being piped, assume all args after argv[0] are ours
  if (!$found_separator && $argc > 1 && $argv[0] === 'Standard input code') {
    $start_index = 1;
  }
  
  // Process arguments after the separator
  for ($i = $start_index; $i < $argc; $i++) {
    $arg = $argv[$i];
    
    // Skip empty arguments
    if (empty($arg)) {
      continue;
    }
    
    switch ($arg) {
      case '--help':
      case '-h':
        echo "Usage: php install.php [options]\n";
        echo "Options:\n";
        echo "  --help, -h          Show this help message\n";
        echo "  --yes, -y           Automatically answer yes to all prompts\n";
        echo "  --core              Install core rules only\n";
        echo "  --web-stack, --ws   Install web stack rules (includes core rules)\n";
        echo "  --python            Install Python rules (includes core rules)\n";
        echo "  --all               Install all rules\n";
        echo "  --destination=DIR   Install to a custom directory (default: .cursor/rules)\n";
        echo "  --debug             Enable debug output for troubleshooting\n";
        echo "  --tags=EXPR         Install rules matching tag expression\n";
        echo "  --tag-preset=NAME   Use a predefined tag preset\n";
        echo "  --ignore-files=OPT  Control .cursorignore file installation (yes/no/ask)\n";
        echo "  --commands=OPT      Control slash command installation (project|home|both|skip)\n";
        echo "  --skip-commands     Skip installing slash commands\n";
        exit(0);

      case '--yes':
      case '-y':
        $options['yes'] = true;
        break;

      case '--core':
        $options['core'] = true;
        $option_count++;
        break;

      case '--web-stack':
      case '--ws':
        $options['web_stack'] = true;
        $option_count++;
        break;

      case '--python':
        $options['python'] = true;
        $option_count++;
        break;

      case '--all':
        $options['all'] = true;
        $option_count++;
        break;

      case '--debug':
        $options['debug'] = true;
        break;

      case '--commands':
        if ($i + 1 < $argc) {
          $options['commands'] = strtolower($argv[$i + 1]);
          $i++;
        }
        break;

      case '--skip-commands':
      case '--no-commands':
        $options['commands'] = 'skip';
        break;

      default:
        // Check for parameter=value format
        if (strpos($arg, '=') !== false) {
          list($param, $value) = explode('=', $arg, 2);
          switch ($param) {
            case '--destination':
              $options['destination'] = $value;
              break;
            case '--tags':
              $options['tags'] = $value;
              $option_count++;
              break;
            case '--tag-preset':
              $options['tag-preset'] = $value;
              $option_count++;
              break;
            case '--ignore-files':
              if (in_array($value, ['yes', 'no', 'ask', 'y', 'n', 'a'])) {
                $options['ignore-files'] = $value;
              }
              break;
            case '--commands':
              $options['commands'] = strtolower($value);
              break;
          }
        }
        break;
    }
  }

  return [$options, $option_count];
}