air_test 0.1.6.0 → 0.1.6.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ad53fd406fa863853dea5408851219dee4651ed0f36565eea406e0e1ac8218a2
-  data.tar.gz: 04c60aa2b2a9db1203440e26f4d95f166826dc887865d997f9e94fe7b132bf54
+  metadata.gz: 3e04796d0b80ac35cf63aa0d65fab417c7f1b2c793f953108be1779129489cba
+  data.tar.gz: 9e31c0266c59d7963c70cdc3d2158b92e12814a32be15d065f062f1026485884
 SHA512:
-  metadata.gz: 6bfe5096f73ad09e186863a51e279ab5e415d2dd3b3e09be7441fdd581634097152d249d5fe51fc802115b80081a12e25b65a93245a14694f75b1e0ca6dcbfdf
-  data.tar.gz: 67b13d6c175daf0360e7987e4432cd5eeb09e417bb9d2f9c3cf832926eb652be77cd14daea8dc27dd62a7284bca50aea58ef07dacc7da2546f08bc2bac7be765
+  metadata.gz: e6ce0f69bc475ed1ef913fac555f125c131dd49aef39f9165fffd05c8288b16d5013dfb38b41f9ed7d4119f81ba270f7b8af3ea08c4faf9c18543d8f719d5559
+  data.tar.gz: e4311d1981fb6289d81275619461490ac2d4ee2f1c47982fa51166dafb7e48047b4519a648d44e68c398462fe3887b63923bc326a1b72993f38c7748b542cf31

data/README.md

@@ -1,10 +1,15 @@
 # air_test
 
-Automate the generation of Turnip/RSpec specs from Notion tickets, create branches, commits, pushes, and GitHub Pull Requests—all with a single Rake command.
+Automate the generation of Turnip/RSpec specs from Notion tickets, create branches, commits, pushes, and GitHub Pull Requests—all with a single command.
 
 ## 🚀 Features
 
-- Fetches Notion tickets (Gherkin format)
+- **Multi-platform support**: Works with Notion, Jira, and Monday.com
+- **Interactive CLI**: Choose which tickets to process
+- **Search and filtering**: Find tickets by keyword
+- **Dry-run mode**: Preview changes before applying them
+- **Flexible PR creation**: Generate specs with or without automatic PRs
+- Fetches tickets (Gherkin format)
 - Parses and extracts features/scenarios
 - Generates Turnip/RSpec spec files and matching step definitions
 - Creates a dedicated branch, commits, pushes
@@ -31,9 +36,96 @@ bundle install
 
 ---
 
+## 🛠 Quick Start
+
+### 1. Initialize Configuration
+
+Set up your project configuration interactively:
+
+```sh
+air_test init
+```
+
+This will:
+- Ask which ticketing tool you use (Notion, Jira, or Monday)
+- Configure your preferences (auto PR creation, dev assignee, etc.)
+- Create `.airtest.yml` configuration file
+- Create example environment file
+- Set up necessary directories
+
+For silent setup with defaults:
+```sh
+air_test init --silent
+```
+
+### 2. Set Environment Variables
+
+Copy the example environment file and fill in your tokens:
+
+```sh
+cp .env.air_test.example .env
+# Edit .env with your actual tokens
+```
+
+### 3. Generate Specs
+
+#### Interactive Mode (Recommended)
+```sh
+air_test generate --interactive
+```
+Shows you a list of available tickets and lets you choose which ones to process.
+
+#### Search and Filter
+```sh
+air_test generate --search "webhook"
+```
+Only processes tickets containing "webhook" in the title or content.
+
+#### Preview Mode
+```sh
+air_test generate --dry-run
+```
+Shows what would be generated without creating files or PRs.
+
+#### Disable PR Creation
+```sh
+air_test generate --no-pr
+```
+Generates spec files locally without creating Pull Requests.
+
+---
+
 ## ⚙️ Configuration
 
-Create an initializer in your Rails project:  
+### CLI Configuration (`.airtest.yml`)
+
+The `air_test init` command creates a `.airtest.yml` file with your preferences:
+
+```yaml
+tool: notion                    # Your ticketing tool (notion/jira/monday)
+auto_pr: 'yes'                  # Enable auto PR creation
+dev_assignee: 'your-name'       # Default dev assignee
+interactive_mode: 'yes'         # Enable interactive mode by default
+notion:
+  token: ENV["NOTION_TOKEN"]
+  database_id: ENV["NOTION_DATABASE_ID"]
+jira:
+  token: ENV["JIRA_TOKEN"]
+  project_id: ENV["JIRA_PROJECT_ID"]
+  domain: ENV["JIRA_DOMAIN"]
+  email: ENV["JIRA_EMAIL"]
+monday:
+  token: ENV["MONDAY_TOKEN"]
+  board_id: ENV["MONDAY_BOARD_ID"]
+  domain: ENV["MONDAY_DOMAIN"]
+github:
+  token: ENV["GITHUB_BOT_TOKEN"]
+  repo: 'your-org/your-repo'
+```
+
+### Rails Initializer (Optional)
+
+For Rails projects, you can also create an initializer:  
 `config/initializers/air_test.rb`
 
 ```ruby
@@ -45,17 +137,15 @@ AirTest.configure do |config|
 end
 ```
 
-Make sure your environment variables are set (in `.env`, your shell, or your CI/CD).
-
 ---
 
-## 📝 Creating Notion Tickets with Gherkin Format
+## 📝 Creating Tickets with Gherkin Format
 
-To ensure that your Notion tickets are compatible with the air_test automation, follow these guidelines when creating your tickets:
+To ensure that your tickets are compatible with the air_test automation, follow these guidelines when creating your tickets:
 
-### 1. Create a New Page in Notion
+### 1. Create a New Page/Ticket
 
-- Start by creating a new page in your Notion workspace for each ticket.
+- Start by creating a new page in your Notion workspace, Jira issue, or Monday.com item for each ticket.
 
 ### 2. Use the Gherkin Syntax
 
@@ -68,68 +158,117 @@ To ensure that your Notion tickets are compatible with the air_test automation,
 
 ### 3. Example Structure
 
-Here’s an example of how to structure a ticket in Notion:
+Here's an example of how to structure a ticket:
 
+```
 Feature: User Login
 Scenario: Successful login with valid credentials
 Given the user is on the login page
 When the user enters valid credentials
 Then the user should be redirected to the dashboard
+
 Scenario: Unsuccessful login with invalid credentials
 Given the user is on the login page
 When the user enters invalid credentials
 Then an error message should be displayed
+```
 
 ### 4. Additional Tips
 
 - Ensure that each ticket is clearly titled and contains all necessary scenarios.
-- Use bullet points or toggle lists in Notion to organize multiple scenarios under a single feature.
+- Use bullet points or toggle lists to organize multiple scenarios under a single feature.
 - Make sure to keep the Gherkin syntax consistent across all tickets for better parsing.
 
-By following these guidelines, you can create Notion tickets that are ready to be parsed by the air_test automation tool.
-
 ---
 
-## 🛠 Usage
+## 🛠 CLI Commands
+
+### `air_test init [--silent]`
+Initialize AirTest configuration for your project.
 
-Run the automated workflow from your Rails project terminal:
+**Options:**
+- `--silent`: Use default values without prompts
 
+**Examples:**
 ```sh
-bundle exec rake air_test:generate_specs_from_notion
+air_test init                    # Interactive setup
+air_test init --silent          # Silent setup with defaults
 ```
 
-- This will:
-  - Fetch Notion tickets
-  - Generate Turnip/RSpec specs and step files
-  - Create a branch, commit, push
-  - Open a Pull Request on GitHub with a rich template
+### `air_test generate [options]`
+Generate specs from tickets with advanced filtering and selection.
 
----
+**Options:**
+- `--interactive`: Interactive ticket selection
+- `--search "keyword"`: Search tickets by keyword
+- `--dry-run`: Preview changes without creating files
+- `--no-pr`: Disable PR creation
 
-## 📋 Requirements
+**Examples:**
+```sh
+air_test generate                    # Process all ready tickets
+air_test generate --interactive     # Choose tickets interactively
+air_test generate --search "webhook" --dry-run
+air_test generate --no-pr           # Generate files only, no PRs
+```
 
-- A Notion API token with access to your database
-- A GitHub token with push and PR creation rights
-- A configured remote git repository (`git remote -v`)
-- The folders `spec/features` and `spec/steps` (created automatically if needed)
+### `air_test create-pr --ticket-id ID`
+Create a Pull Request for a specific ticket (coming soon).
+
+**Examples:**
+```sh
+air_test create-pr --ticket-id 123
+```
+
+### `air_test help`
+Show help information and usage examples.
 
 ---
 
-## 📝 Example .env
+## 📋 Requirements
 
+### Environment Variables
+
+#### For Notion:
 ```
 NOTION_TOKEN=secret_xxx
 NOTION_DATABASE_ID=xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
 GITHUB_BOT_TOKEN=ghp_xxx
 ```
 
+#### For Jira:
+```
+JIRA_TOKEN=your_jira_token
+JIRA_PROJECT_ID=your_project_id
+JIRA_DOMAIN=your_domain.atlassian.net
+JIRA_EMAIL=your_email@example.com
+GITHUB_BOT_TOKEN=ghp_xxx
+```
+
+#### For Monday.com:
+```
+MONDAY_TOKEN=your_monday_token
+MONDAY_BOARD_ID=your_board_id
+MONDAY_DOMAIN=your_domain.monday.com
+GITHUB_BOT_TOKEN=ghp_xxx
+```
+
+### System Requirements
+
+- A ticketing tool API token with access to your tickets
+- A GitHub token with push and PR creation rights
+- A configured remote git repository (`git remote -v`)
+- The folders `spec/features` and `spec/steps` (created automatically if needed)
+
 ---
 
 ## 🆘 Troubleshooting
 
-- **Notion or GitHub authentication error**: check your tokens.
-- **PR not created**: make sure the branch contains commits different from `main`.
-- **Permission issues**: ensure the GitHub bot has access to the repo.
+- **Configuration not found**: Run `air_test init` to set up configuration
+- **Authentication error**: Check your API tokens in environment variables
+- **No tickets found**: Verify your ticketing tool configuration and permissions
+- **PR not created**: Make sure the branch contains commits different from `main`
+- **Permission issues**: Ensure the GitHub bot has access to the repo
 
 ---
 
@@ -142,5 +281,3 @@ GITHUB_BOT_TOKEN=ghp_xxx
 
 **Need an integration example or install script?**  
 Open an issue or contact me!
-
----

data/exe/air_test

@@ -2,65 +2,72 @@
 # frozen_string_literal: true
 
 require "fileutils"
+require_relative "../lib/air_test/cli"
 
+# Color constants
 GREEN = "\e[32m"
 YELLOW = "\e[33m"
 RED = "\e[31m"
 CYAN = "\e[36m"
 RESET = "\e[0m"
 
-puts "#{CYAN}🚀 Initializing AirTest for your Rails project...#{RESET}\n"
+def show_help
+  puts <<~HELP
+    #{CYAN}AirTest CLI - Test Generation Tool#{RESET}
 
-initializer_path = "config/initializers/air_test.rb"
-if File.exist?(initializer_path)
-  puts "#{YELLOW}⚠️  #{initializer_path} already exists. Skipping.#{RESET}"
-else
-  FileUtils.mkdir_p(File.dirname(initializer_path))
-  File.write(initializer_path, <<~RUBY)
-    AirTest.configure do |config|
-      config.notion_token = ENV['NOTION_TOKEN']
-      config.notion_database_id = ENV['NOTION_DATABASE_ID']
-      config.github_token = ENV['GITHUB_BOT_TOKEN']
-      config.repo = 'your-org/your-repo' # format: 'organization/repo_name'
-    end
-  RUBY
-  puts "#{GREEN}✅ Created #{initializer_path}#{RESET}"
-end
+    Usage: air_test [command] [options]
 
-["spec/features", "spec/steps"].each do |dir|
-  if Dir.exist?(dir)
-    puts "#{YELLOW}⚠️  #{dir} already exists. Skipping.#{RESET}"
-  else
-    FileUtils.mkdir_p(dir)
-    puts "#{GREEN}✅ Created #{dir}/#{RESET}"
-  end
-end
+    Commands:
+      init [--silent]           Initialize AirTest configuration
+      generate [options]        Generate specs from tickets
+      create-pr [options]       Create PR for specific ticket
+      help                      Show this help message
 
-example_env = ".env.air_test.example"
-if File.exist?(example_env)
-  puts "#{YELLOW}⚠️  #{example_env} already exists. Skipping.#{RESET}"
-else
-  File.write(example_env, <<~ENV)
-    NOTION_TOKEN=your_notion_token
-    NOTION_DATABASE_ID=your_notion_database_id
-    GITHUB_BOT_TOKEN=your_github_token
-  ENV
-  puts "#{GREEN}✅ Created #{example_env}#{RESET}"
+    Generate Options:
+      --interactive             Interactive ticket selection
+      --search "keyword"        Search tickets by keyword
+      --dry-run                Preview changes without creating files
+      --no-pr                  Disable PR creation
+
+    Create PR Options:
+      --ticket-id ID           Ticket ID to create PR for
+
+    Global Options:
+      --silent                 Run in silent mode (use defaults)
+      --help                   Show this help message
+
+    Examples:
+      air_test init                    # Interactive initialization
+      air_test init --silent           # Silent initialization with defaults
+      air_test generate --interactive  # Interactive ticket selection
+      air_test generate --search "webhook" --dry-run
+      air_test create-pr --ticket-id 3 # Create PR for ticket #3
+      air_test help                    # Show this help
+  HELP
 end
 
-puts "\n🔎 Checking environment variables..."
-missing = []
-%w[NOTION_TOKEN NOTION_DATABASE_ID GITHUB_BOT_TOKEN].each do |var|
-  if ENV[var].nil? || ENV[var].empty?
-    puts "#{YELLOW}⚠️  #{var} is not set!#{RESET}"
-    missing << var
+def main
+  command = ARGV[0]
+  silent = ARGV.include?('--silent')
+
+  case command
+  when 'init'
+    cli = AirTest::CLI.new
+    cli.init(silent: silent)
+  when 'generate'
+    cli = AirTest::CLI.new
+    cli.generate(ARGV[1..-1])
+  when 'create-pr'
+    cli = AirTest::CLI.new
+    cli.create_pr(ARGV[1..-1])
+  when 'help', '--help', '-h', nil
+    show_help
   else
-    puts "#{GREEN}✅ #{var} is set#{RESET}"
+    puts "#{RED}❌ Unknown command: #{command}#{RESET}"
+    puts "Run 'air_test help' for usage information."
+    exit 1
   end
 end
 
-puts "\n✨ All set! Next steps:"
-puts "  1. Fill in your config/initializers/air_test.rb"
-puts "  2. Add your tokens to .env or your environment"
-puts "  3. Run: bundle exec rake air_test:generate_specs_from_notion"
-puts "\nHappy testing! 🎉"
+# Run the CLI
+main

data/lib/air_test/cli.rb

@@ -0,0 +1,552 @@
+# frozen_string_literal: true
+
+require 'yaml'
+require 'tty-prompt'
+require 'fileutils'
+require_relative '../air_test'
+
+module AirTest
+  class CLI
+    def initialize
+      @prompt = TTY::Prompt.new
+      load_env_files
+    end
+
+    def init(silent: false)
+      puts "#{CYAN}🚀 Initializing AirTest for your Rails project...#{RESET}\n"
+
+      if silent
+        # Set default values for silent mode
+        config = {
+          tool: 'notion',
+          auto_pr: 'no',
+          dev_assignee: 'default_assignee',
+          interactive_mode: 'no'
+        }
+      else
+        # Interactive prompts
+        config = prompt_for_configuration
+      end
+
+      # Create configuration files
+      create_airtest_yml(config)
+      create_initializer_file
+      create_env_example_file(config[:tool])
+      create_directories
+
+      # Check environment variables
+      check_environment_variables(config[:tool])
+
+      puts "\n✨ All set! Next steps:"
+      puts "  1. Fill in your config/initializers/air_test.rb"
+      puts "  2. Add your tokens to .env or your environment"
+      puts "  3. Run: bundle exec rake air_test:generate_specs_from_notion"
+      puts "\nHappy testing! 🎉"
+    end
+
+    def generate(args)
+      puts "#{CYAN}🔍 Generating specs from tickets...#{RESET}\n"
+      
+      # Parse arguments
+      options = parse_generate_options(args)
+      
+      # Load configuration
+      config = load_configuration
+      
+      # Validate configuration
+      validate_configuration(config)
+      
+      # Initialize AirTest configuration
+      initialize_airtest_config(config)
+      
+      # Fetch tickets based on tool
+      tickets = fetch_tickets(config, options)
+      
+      if tickets.empty?
+        puts "#{YELLOW}⚠️  No tickets found matching your criteria.#{RESET}"
+        return
+      end
+      
+      # Handle interactive selection or search results
+      selected_tickets = select_tickets(tickets, options)
+      
+      if selected_tickets.empty?
+        puts "#{YELLOW}⚠️  No tickets selected.#{RESET}"
+        return
+      end
+      
+      # Process selected tickets
+      process_tickets(selected_tickets, config, options)
+    end
+
+    def create_pr(args)
+      puts "#{CYAN}🚀 Creating Pull Request...#{RESET}\n"
+      # TODO: Implement create_pr functionality
+      puts "#{YELLOW}⚠️  create-pr command not yet implemented.#{RESET}"
+    end
+
+    private
+
+    def parse_generate_options(args)
+      options = {
+        interactive: false,
+        search: nil,
+        dry_run: false,
+        no_pr: false
+      }
+      
+      args.each_with_index do |arg, index|
+        case arg
+        when '--interactive'
+          options[:interactive] = true
+        when '--search'
+          options[:search] = args[index + 1] if args[index + 1]
+        when '--dry-run'
+          options[:dry_run] = true
+        when '--no-pr'
+          options[:no_pr] = true
+        end
+      end
+      
+      options
+    end
+
+    def load_configuration
+      unless File.exist?('.airtest.yml')
+        puts "#{RED}❌ Configuration file .airtest.yml not found.#{RESET}"
+        puts "Run 'air_test init' first to set up configuration."
+        exit 1
+      end
+      
+      YAML.load_file('.airtest.yml')
+    end
+
+    def validate_configuration(config)
+      tool = config['tool']
+      puts "#{GREEN}✅ Using #{tool.capitalize} as ticketing tool#{RESET}"
+      
+      # Check required environment variables
+      missing_vars = []
+      case tool
+      when 'notion'
+        %w[NOTION_TOKEN NOTION_DATABASE_ID].each do |var|
+          missing_vars << var if ENV[var].nil? || ENV[var].empty?
+        end
+      when 'jira'
+        %w[JIRA_TOKEN JIRA_PROJECT_ID JIRA_DOMAIN JIRA_EMAIL].each do |var|
+          missing_vars << var if ENV[var].nil? || ENV[var].empty?
+        end
+      when 'monday'
+        %w[MONDAY_TOKEN MONDAY_BOARD_ID MONDAY_DOMAIN].each do |var|
+          missing_vars << var if ENV[var].nil? || ENV[var].empty?
+        end
+      end
+      
+      # Always check for GitHub token
+      missing_vars << 'GITHUB_BOT_TOKEN' if ENV['GITHUB_BOT_TOKEN'].nil? || ENV['GITHUB_BOT_TOKEN'].empty?
+      
+      if missing_vars.any?
+        puts "#{RED}❌ Missing required environment variables: #{missing_vars.join(', ')}#{RESET}"
+        puts "Please set these variables in your .env file or environment."
+        exit 1
+      end
+    end
+
+    def initialize_airtest_config(config)
+      # Initialize AirTest configuration with values from config file
+      AirTest.configure do |airtest_config|
+        case config['tool']
+        when 'notion'
+          airtest_config.notion[:token] = config['notion']['token']
+          airtest_config.notion[:database_id] = config['notion']['database_id']
+        when 'jira'
+          airtest_config.jira[:token] = config['jira']['token']
+          airtest_config.jira[:project_id] = config['jira']['project_id']
+          airtest_config.jira[:domain] = config['jira']['domain']
+          airtest_config.jira[:email] = config['jira']['email']
+        when 'monday'
+          airtest_config.monday[:token] = config['monday']['token']
+          airtest_config.monday[:board_id] = config['monday']['board_id']
+          airtest_config.monday[:domain] = config['monday']['domain']
+        end
+        
+        airtest_config.github[:token] = config['github']['token']
+        airtest_config.repo = config['github']['repo']
+        airtest_config.tool = config['tool']
+      end
+    end
+
+    def fetch_tickets(config, options)
+      tool = config['tool']
+      puts "#{CYAN}📋 Fetching tickets from #{tool.capitalize}...#{RESET}"
+      
+      # Use the existing Runner to fetch tickets
+      runner = AirTest::Runner.new
+      parser = runner.instance_variable_get(:@parser)
+      
+      # Fetch all tickets (we'll filter them later)
+      all_tickets = parser.fetch_tickets(limit: 100)
+      
+      # Filter by search if specified
+      if options[:search]
+        all_tickets = all_tickets.select { |ticket| 
+          title = parser.extract_ticket_title(ticket)
+          title.downcase.include?(options[:search].downcase)
+        }
+      end
+      
+      # Filter by status (only "Ready" or "Not started" tickets)
+      all_tickets.select { |ticket| 
+        # This depends on the parser implementation
+        # For now, we'll assume all tickets are ready
+        true
+      }
+    end
+
+    def select_tickets(tickets, options)
+      if options[:interactive]
+        select_tickets_interactive(tickets)
+      else
+        # In non-interactive mode, process all tickets
+        tickets
+      end
+    end
+
+    def select_tickets_interactive(tickets)
+      puts "\n#{CYAN}Found #{tickets.length} ready tickets:#{RESET}"
+      tickets.each_with_index do |ticket, index|
+        parser = AirTest::Runner.new.instance_variable_get(:@parser)
+        title = parser.extract_ticket_title(ticket)
+        ticket_id = parser.extract_ticket_id(ticket)
+        puts "[#{index + 1}] #{title} (ID: #{ticket_id})"
+      end
+      
+      puts "\nEnter numbers (comma-separated) to select tickets, or 'all' for all tickets:"
+      
+      begin
+        selection = @prompt.ask("Selection") do |q|
+          q.default "all"
+          q.required true
+        end
+        
+        if selection.nil? || selection.strip.empty?
+          puts "#{YELLOW}⚠️  No selection made, processing all tickets#{RESET}"
+          return tickets
+        end
+        
+        if selection.downcase.strip == "all"
+          puts "#{GREEN}✅ Selected all #{tickets.length} tickets#{RESET}"
+          return tickets
+        end
+        
+        selected_indices = selection.split(',').map(&:strip).map(&:to_i)
+        selected_tickets = selected_indices.map { |i| tickets[i - 1] }.compact
+        
+        if selected_tickets.empty?
+          puts "#{YELLOW}⚠️  Invalid selection, processing all tickets#{RESET}"
+          return tickets
+        end
+        
+        puts "#{GREEN}✅ Selected #{selected_tickets.length} tickets#{RESET}"
+        selected_tickets
+        
+      rescue => e
+        puts "#{YELLOW}⚠️  Error with interactive selection: #{e.message}#{RESET}"
+        puts "#{YELLOW}⚠️  Processing all tickets instead#{RESET}"
+        return tickets
+      end
+    end
+
+    def process_tickets(tickets, config, options)
+      puts "\n#{CYAN}🔄 Processing #{tickets.length} tickets...#{RESET}"
+      
+      # Initialize the runner
+      runner = AirTest::Runner.new
+      parser = runner.instance_variable_get(:@parser)
+      
+      tickets.each do |ticket|
+        ticket_id = parser.extract_ticket_id(ticket)
+        title = parser.extract_ticket_title(ticket)
+        url = parser.extract_ticket_url(ticket)
+        
+        puts "\n#{YELLOW}📝 Processing: #{title} (ID: #{ticket_id})#{RESET}"
+        
+        if options[:dry_run]
+          preview_ticket_processing(ticket, config, parser)
+        else
+          process_single_ticket(ticket, config, options, runner, parser)
+        end
+      end
+      
+      puts "\n#{GREEN}✅ Processing complete!#{RESET}"
+    end
+
+    def preview_ticket_processing(ticket, config, parser)
+      ticket_id = parser.extract_ticket_id(ticket)
+      title = parser.extract_ticket_title(ticket)
+      url = parser.extract_ticket_url(ticket)
+      
+      puts "  📋 Ticket ID: #{ticket_id}"
+      puts "  📝 Title: #{title}"
+      puts "  🔗 URL: #{url}"
+      puts "  🔧 Tool: #{config['tool'].capitalize}"
+      puts "  👤 Dev Assignee: #{config['dev_assignee']}"
+      puts "  🌿 Branch: air_test/#{ticket_id}-#{title.downcase.gsub(/[^a-z0-9]+/, '-').gsub(/^-|-$/, '')}"
+      puts "  📄 Files to create:"
+      puts "    - spec/features/[feature_slug]_fdr#{ticket_id}.rb"
+      puts "    - spec/steps/[feature_slug]_fdr#{ticket_id}_steps.rb"
+      puts "  🔗 PR Title: #{title}"
+    end
+
+    def process_single_ticket(ticket, config, options, runner, parser)
+      ticket_id = parser.extract_ticket_id(ticket)
+      title = parser.extract_ticket_title(ticket)
+      url = parser.extract_ticket_url(ticket)
+      
+      # Parse ticket content
+      parsed_data = parser.parse_ticket_content(ticket["id"])
+      
+      unless parsed_data && parsed_data[:feature] && !parsed_data[:feature].empty?
+        puts "  ⚠️  Skipping ticket #{ticket_id} due to missing or empty feature."
+        return
+      end
+      
+      # Generate spec files
+      spec_generator = runner.instance_variable_get(:@spec)
+      spec_path = spec_generator.generate_spec_from_parsed_data(ticket_id, parsed_data)
+      step_path = spec_generator.generate_step_definitions_for_spec(spec_path)
+      
+      puts "  ✅ Generated spec files for #{title}"
+      
+      # Handle Git operations and PR creation
+      unless options[:no_pr]
+        files_to_commit = [spec_path]
+        files_to_commit << step_path if step_path
+        
+        github_client = runner.instance_variable_get(:@github)
+        branch = "air_test/#{ticket_id}-#{title.downcase.gsub(/[^a-z0-9]+/, '-').gsub(/^-|-$/, '')}"
+        
+        has_changes = github_client.commit_and_push_branch(branch, files_to_commit, "Add specs for #{config['tool'].capitalize} ticket #{ticket_id}")
+        
+        if has_changes
+          # Create PR
+          scenarios_md = parsed_data[:scenarios].map.with_index(1) do |sc, _i|
+            steps = sc[:steps]&.map { |step| "      - #{step}" }&.join("\n")
+            "  - [ ] #{sc[:title]}\n#{steps}"
+          end.join("\n")
+          
+          pr_body = <<~MD
+            - **Story #{config['tool'].capitalize} :** #{url}
+            - **Feature** : #{parsed_data[:feature]}
+            - **Scénarios** :
+          #{scenarios_md}
+            - **Want to help us improve airtest?**
+            Leave feedback [here](http://bit.ly/4o5rinU)
+            or [join the community](https://discord.gg/ggnBvhtw7E)
+          MD
+          
+          pr = github_client.create_pull_request(branch, title, pr_body)
+          if pr
+            puts "  🔗 Created PR: #{pr.html_url}"
+          else
+            puts "  ⚠️  Failed to create PR"
+          end
+        else
+          puts "  ⚠️  No changes detected, PR not created."
+        end
+      else
+        puts "  ⚠️  PR creation disabled (--no-pr flag)"
+      end
+    end
+
+    def prompt_for_configuration
+      tool = @prompt.select("Which ticketing tool do you use?", %w[notion jira monday], default: 'notion')
+      auto_pr = @prompt.select("Enable auto PR creation by default?", %w[yes no], default: 'no')
+      dev_assignee = @prompt.ask("Default dev assignee name?", default: 'default_assignee')
+      interactive_mode = @prompt.select("Enable interactive mode by default?", %w[yes no], default: 'no')
+      
+      {
+        tool: tool,
+        auto_pr: auto_pr,
+        dev_assignee: dev_assignee,
+        interactive_mode: interactive_mode
+      }
+    end
+
+    def create_airtest_yml(config)
+      airtest_yml_path = '.airtest.yml'
+      
+      if File.exist?(airtest_yml_path)
+        puts "#{YELLOW}⚠️  #{airtest_yml_path} already exists. Skipping.#{RESET}"
+        return
+      end
+
+      yaml_content = {
+        'tool' => config[:tool],
+        'auto_pr' => config[:auto_pr],
+        'dev_assignee' => config[:dev_assignee],
+        'interactive_mode' => config[:interactive_mode],
+        'notion' => {
+          'token' => ENV['NOTION_TOKEN'] || 'your_notion_token',
+          'database_id' => ENV['NOTION_DATABASE_ID'] || 'your_notion_database_id'
+        },
+        'jira' => {
+          'token' => ENV['JIRA_TOKEN'] || 'your_jira_token',
+          'project_id' => ENV['JIRA_PROJECT_ID'] || 'your_jira_project_id',
+          'domain' => ENV['JIRA_DOMAIN'] || 'your_jira_domain',
+          'email' => ENV['JIRA_EMAIL'] || 'your_jira_email'
+        },
+        'monday' => {
+          'token' => ENV['MONDAY_TOKEN'] || 'your_monday_token',
+          'board_id' => ENV['MONDAY_BOARD_ID'] || 'your_monday_board_id',
+          'domain' => ENV['MONDAY_DOMAIN'] || 'your_monday_domain'
+        },
+        'github' => {
+          'token' => ENV['GITHUB_BOT_TOKEN'] || 'your_github_token',
+          'repo' => ENV['REPO'] || 'your-org/your-repo'
+        }
+      }
+
+      File.write(airtest_yml_path, yaml_content.to_yaml)
+      puts "#{GREEN}✅ Created #{airtest_yml_path}#{RESET}"
+    end
+
+    def create_initializer_file
+      initializer_path = "config/initializers/air_test.rb"
+      
+      if File.exist?(initializer_path)
+        puts "#{YELLOW}⚠️  #{initializer_path} already exists. Skipping.#{RESET}"
+        return
+      end
+
+      FileUtils.mkdir_p(File.dirname(initializer_path))
+      File.write(initializer_path, <<~RUBY)
+        AirTest.configure do |config|
+          config.notion_token = ENV['NOTION_TOKEN']
+          config.notion_database_id = ENV['NOTION_DATABASE_ID']
+          config.github_token = ENV['GITHUB_BOT_TOKEN']
+          config.repo = 'your-org/your-repo' # format: 'organization/repo_name'
+        end
+      RUBY
+      puts "#{GREEN}✅ Created #{initializer_path}#{RESET}"
+    end
+
+    def create_env_example_file(tool)
+      example_env = ".env.air_test.example"
+      
+      if File.exist?(example_env)
+        puts "#{YELLOW}⚠️  #{example_env} already exists. Skipping.#{RESET}"
+        return
+      end
+
+      env_content = case tool
+      when 'notion'
+        <<~ENV
+          NOTION_TOKEN=your_notion_token
+          NOTION_DATABASE_ID=your_notion_database_id
+          GITHUB_BOT_TOKEN=your_github_token
+        ENV
+      when 'jira'
+        <<~ENV
+          JIRA_TOKEN=your_jira_token
+          JIRA_PROJECT_ID=your_jira_project_id
+          JIRA_DOMAIN=your_jira_domain
+          JIRA_EMAIL=your_jira_email
+          GITHUB_BOT_TOKEN=your_github_token
+        ENV
+      when 'monday'
+        <<~ENV
+          MONDAY_TOKEN=your_monday_token
+          MONDAY_BOARD_ID=your_monday_board_id
+          MONDAY_DOMAIN=your_monday_domain
+          GITHUB_BOT_TOKEN=your_github_token
+        ENV
+      end
+
+      File.write(example_env, env_content)
+      puts "#{GREEN}✅ Created #{example_env}#{RESET}"
+    end
+
+    def create_directories
+      ["spec/features", "spec/steps"].each do |dir|
+        if Dir.exist?(dir)
+          puts "#{YELLOW}⚠️  #{dir} already exists. Skipping.#{RESET}"
+        else
+          FileUtils.mkdir_p(dir)
+          puts "#{GREEN}✅ Created #{dir}/#{RESET}"
+        end
+      end
+    end
+
+    def check_environment_variables(tool)
+      puts "\n🔎 Checking environment variables..."
+      missing = []
+      
+      case tool
+      when 'notion'
+        %w[NOTION_TOKEN NOTION_DATABASE_ID GITHUB_BOT_TOKEN].each do |var|
+          if ENV[var].nil? || ENV[var].empty?
+            puts "#{YELLOW}⚠️  #{var} is not set!#{RESET}"
+            missing << var
+          else
+            puts "#{GREEN}✅ #{var} is set#{RESET}"
+          end
+        end
+      when 'jira'
+        %w[JIRA_TOKEN JIRA_PROJECT_ID JIRA_DOMAIN JIRA_EMAIL GITHUB_BOT_TOKEN].each do |var|
+          if ENV[var].nil? || ENV[var].empty?
+            puts "#{YELLOW}⚠️  #{var} is not set!#{RESET}"
+            missing << var
+          else
+            puts "#{GREEN}✅ #{var} is set#{RESET}"
+          end
+        end
+      when 'monday'
+        %w[MONDAY_TOKEN MONDAY_BOARD_ID MONDAY_DOMAIN GITHUB_BOT_TOKEN].each do |var|
+          if ENV[var].nil? || ENV[var].empty?
+            puts "#{YELLOW}⚠️  #{var} is not set!#{RESET}"
+            missing << var
+          else
+            puts "#{GREEN}✅ #{var} is set#{RESET}"
+          end
+        end
+      end
+    end
+
+    private
+
+    def load_env_files
+      # Try to load .env files in order of preference
+      env_files = ['.env.airtest', '.env']
+      
+      env_files.each do |env_file|
+        if File.exist?(env_file)
+          load_env_file(env_file)
+          puts "#{GREEN}✅ Loaded environment variables from #{env_file}#{RESET}" if ENV['AIRTEST_DEBUG']
+          break
+        end
+      end
+    end
+
+    def load_env_file(file_path)
+      File.readlines(file_path).each do |line|
+        line.strip!
+        next if line.empty? || line.start_with?('#')
+        
+        if line.include?('=')
+          key, value = line.split('=', 2)
+          ENV[key.strip] = value.strip.gsub(/^["']|["']$/, '') # Remove quotes
+        end
+      end
+    rescue => e
+      puts "#{YELLOW}⚠️  Warning: Could not load #{file_path}: #{e.message}#{RESET}" if ENV['AIRTEST_DEBUG']
+    end
+
+    # Color constants
+    GREEN = "\e[32m"
+    YELLOW = "\e[33m"
+    RED = "\e[31m"
+    CYAN = "\e[36m"
+    RESET = "\e[0m"
+  end
+end 

data/lib/air_test/notion_ticket_parser.rb

@@ -187,7 +187,7 @@ module AirTest
           end
           if %w[heading_1 heading_2 heading_3].include?(block_type)
             heading_text = text.strip
-            in_steps = heading_text.downcase.include?("feature")) || heading_text.downcase.include?("scenario")
+            in_steps = heading_text.downcase.include?("feature") || heading_text.downcase.include?("scenario")
           elsif %w[paragraph bulleted_list_item numbered_list_item].include?(block_type)
             steps << text if in_steps && !text.empty? && !text.strip.downcase.start_with?("scenario:")
           end

data/lib/air_test/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module AirTest
-  VERSION = "0.1.6.0"
+  VERSION = "0.1.6.2"
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: air_test
 version: !ruby/object:Gem::Version
-  version: 0.1.6.0
+  version: 0.1.6.2
 platform: ruby
 authors:
 - julien bouland
 bindir: exe
 cert_chain: []
-date: 2025-07-28 00:00:00.000000000 Z
+date: 2025-07-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -51,6 +51,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '7.0'
+- !ruby/object:Gem::Dependency
+  name: tty-prompt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.23'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.23'
 description: Automate the generation of Turnip/RSpec specs from Notion tickets, create
   branches, commits, pushes, and GitHub Pull Requests. All with a single Rake command.
 email:
@@ -69,6 +83,7 @@ files:
 - Rakefile
 - exe/air_test
 - lib/air_test.rb
+- lib/air_test/cli.rb
 - lib/air_test/configuration.rb
 - lib/air_test/engine.rb
 - lib/air_test/github_client.rb