n2b 0.5.1 → 2.0.0

data/lib/n2b/cli.rb

@@ -1,5 +1,3 @@
-require_relative 'jira_client' # For N2B::JiraClient
-
 module N2B
   class CLI < Base
     def self.run(args)
@@ -16,281 +14,27 @@ module N2B
       config = get_config(reconfigure: @options[:config], advanced_flow: @options[:advanced_config])
       user_input = @args.join(' ') # All remaining args form user input/prompt addition
 
-      if @options[:diff]
-        handle_diff_analysis(config)
-      elsif user_input.empty? # No input text after options
-        puts "Enter your natural language command:"
-        input_text = $stdin.gets.chomp
-        process_natural_language_command(input_text, config)
-      else # Natural language command
+      # Diff functionality has been removed from N2B::CLI
+      # if @options[:diff]
+      #   handle_diff_analysis(config)
+      # els
+      if user_input.empty? # No input text after options
+        # If config mode was chosen, it's handled by get_config.
+        # If not, and no input, prompt for it.
+        unless @options[:config] # Don't prompt if only -c or --advanced-config was used
+          puts "Enter your natural language command (or type 'exit' or 'quit'):"
+          input_text = $stdin.gets.chomp
+          exit if ['exit', 'quit'].include?(input_text.downcase)
+          process_natural_language_command(input_text, config)
+        end
+      else # Natural language command provided as argument
         process_natural_language_command(user_input, config)
       end
     end
 
     protected
 
-    def handle_diff_analysis(config)
-      vcs_type = get_vcs_type
-      if vcs_type == :none
-        puts "Error: Not a git or hg repository."
-        exit 1
-      end
-
-      # Get requirements file from parsed options
-      requirements_filepath = @options[:requirements]
-      user_prompt_addition = @args.join(' ') # All remaining args are user prompt addition
-
-      # Jira Ticket Information
-      jira_ticket = @options[:jira_ticket]
-      jira_update_flag = @options[:jira_update] # true, false, or nil
-
-      requirements_content = nil # Initialize requirements_content
-
-      if jira_ticket
-        puts "Jira ticket specified: #{jira_ticket}"
-        if config['jira'] && config['jira']['domain'] && config['jira']['email'] && config['jira']['api_key']
-          begin
-            jira_client = N2B::JiraClient.new(config) # Pass the whole config
-            puts "Fetching Jira ticket details..."
-            # If a requirements file is also provided, the Jira ticket will take precedence.
-            # Or, we could append/prepend. For now, Jira overwrites.
-            requirements_content = jira_client.fetch_ticket(jira_ticket)
-            puts "Successfully fetched Jira ticket details."
-            # The fetched content is now in requirements_content and will be passed to analyze_diff
-          rescue N2B::JiraClient::JiraApiError => e
-            puts "Error fetching Jira ticket: #{e.message}"
-            puts "Proceeding with diff analysis without Jira ticket details."
-          rescue ArgumentError => e # Catches missing Jira config in JiraClient.new
-            puts "Jira configuration error: #{e.message}"
-            puts "Please ensure Jira is configured correctly using 'n2b -c'."
-            puts "Proceeding with diff analysis without Jira ticket details."
-          rescue StandardError => e
-            puts "An unexpected error occurred while fetching Jira ticket: #{e.message}"
-            puts "Proceeding with diff analysis without Jira ticket details."
-          end
-        else
-          puts "Jira configuration is missing or incomplete in N2B settings."
-          puts "Please configure Jira using 'n2b -c' to fetch ticket details."
-          puts "Proceeding with diff analysis without Jira ticket details."
-        end
-        # Handling of jira_update_flag can be done elsewhere, e.g., after analysis
-        if jira_update_flag == true
-          puts "Note: Jira ticket update (--jira-update) is flagged."
-          # Actual update logic will be separate
-        elsif jira_update_flag == false
-          puts "Note: Jira ticket will not be updated (--jira-no-update)."
-        end
-      end
-
-      # Load requirements from file if no Jira ticket was fetched or if specifically desired even with Jira.
-      # Current logic: Jira fetch, if successful, populates requirements_content.
-      # If Jira not specified, or fetch failed, try to load from file.
-      if requirements_content.nil? && requirements_filepath
-        if File.exist?(requirements_filepath)
-          puts "Loading requirements from file: #{requirements_filepath}"
-          requirements_content = File.read(requirements_filepath)
-        else
-          puts "Error: Requirements file not found: #{requirements_filepath}"
-          # Decide if to exit or proceed. For now, proceed.
-          puts "Proceeding with diff analysis without file-based requirements."
-        end
-      elsif requirements_content && requirements_filepath
-        puts "Note: Both Jira ticket and requirements file were provided. Using Jira ticket content for analysis."
-      end
-
-      diff_output = execute_vcs_diff(vcs_type, @options[:branch])
-      analysis_result = analyze_diff(diff_output, config, user_prompt_addition, requirements_content) # Store the result
-
-      # --- Jira Update Logic ---
-      if jira_ticket && analysis_result && !analysis_result.empty?
-        # Check if Jira config is valid for updating
-        if config['jira'] && config['jira']['domain'] && config['jira']['email'] && config['jira']['api_key']
-          jira_comment_data = format_analysis_for_jira(analysis_result)
-          proceed_with_update = false
-
-          if jira_update_flag == true # --jira-update used
-            proceed_with_update = true
-          elsif jira_update_flag.nil? # Neither --jira-update nor --jira-no-update used
-            puts "\nWould you like to update Jira ticket #{jira_ticket} with this analysis? (y/n)"
-            user_choice = $stdin.gets.chomp.downcase
-            proceed_with_update = user_choice == 'y'
-          end # If jira_update_flag is false, proceed_with_update remains false
-
-          if proceed_with_update
-            begin
-              # Re-instantiate JiraClient or use an existing one if available and in scope
-              # For safety and simplicity here, re-instantiate with current config.
-              update_jira_client = N2B::JiraClient.new(config)
-              puts "Updating Jira ticket #{jira_ticket}..."
-              if update_jira_client.update_ticket(jira_ticket, jira_comment_data)
-                puts "Jira ticket #{jira_ticket} updated successfully."
-              else
-                # update_ticket currently returns true/false, but might raise error for http issues
-                puts "Failed to update Jira ticket #{jira_ticket}. The client did not report an error, but the update may not have completed."
-              end
-            rescue N2B::JiraClient::JiraApiError => e
-              puts "Error updating Jira ticket: #{e.message}"
-            rescue ArgumentError => e # From JiraClient.new if config is suddenly invalid
-              puts "Jira configuration error before update: #{e.message}"
-            rescue StandardError => e
-              puts "An unexpected error occurred while updating Jira ticket: #{e.message}"
-            end
-          else
-            puts "Jira ticket update skipped."
-          end
-        else
-          puts "Jira configuration is missing or incomplete. Cannot proceed with Jira update."
-        end
-      elsif jira_ticket && (analysis_result.nil? || analysis_result.empty?)
-        puts "Skipping Jira update as analysis result was empty or not generated."
-      end
-      # --- End of Jira Update Logic ---
-
-      analysis_result # Return analysis_result from handle_diff_analysis
-    end
-
-    def get_vcs_type
-      if Dir.exist?(File.join(Dir.pwd, '.git'))
-        :git
-      elsif Dir.exist?(File.join(Dir.pwd, '.hg'))
-        :hg
-      else
-        :none
-      end
-    end
-
-    def execute_vcs_diff(vcs_type, branch_option = nil)
-      case vcs_type
-      when :git
-        if branch_option
-          target_branch = branch_option == 'auto' ? detect_git_default_branch : branch_option
-          if target_branch
-            # Validate that the target branch exists
-            unless validate_git_branch_exists(target_branch)
-              puts "Error: Branch '#{target_branch}' does not exist."
-              puts "Available branches:"
-              puts `git branch -a`.lines.map(&:strip).reject(&:empty?)
-              exit 1
-            end
-
-            puts "Comparing current branch against '#{target_branch}'..."
-            `git diff #{target_branch}...HEAD`
-          else
-            puts "Could not detect default branch, falling back to HEAD diff..."
-            `git diff HEAD`
-          end
-        else
-          `git diff HEAD`
-        end
-      when :hg
-        if branch_option
-          target_branch = branch_option == 'auto' ? detect_hg_default_branch : branch_option
-          if target_branch
-            # Validate that the target branch exists
-            unless validate_hg_branch_exists(target_branch)
-              puts "Error: Branch '#{target_branch}' does not exist."
-              puts "Available branches:"
-              puts `hg branches`.lines.map(&:strip).reject(&:empty?)
-              exit 1
-            end
-
-            puts "Comparing current branch against '#{target_branch}'..."
-            `hg diff -r #{target_branch}`
-          else
-            puts "Could not detect default branch, falling back to standard diff..."
-            `hg diff`
-          end
-        else
-          `hg diff`
-        end
-      else
-        "" # Should not happen if get_vcs_type logic is correct and checked before calling
-      end
-    end
-
-    def detect_git_default_branch
-      # Try multiple methods to detect the default branch
-
-      # Method 1: Check origin/HEAD symbolic ref
-      result = `git symbolic-ref refs/remotes/origin/HEAD 2>/dev/null`.strip
-      if $?.success? && !result.empty?
-        return result.split('/').last
-      end
-
-      # Method 2: Check remote show origin
-      result = `git remote show origin 2>/dev/null | grep "HEAD branch"`.strip
-      if $?.success? && !result.empty?
-        match = result.match(/HEAD branch:\s*(\w+)/)
-        return match[1] if match
-      end
-
-      # Method 3: Check if common default branches exist
-      ['main', 'master'].each do |branch|
-        result = `git rev-parse --verify origin/#{branch} 2>/dev/null`
-        if $?.success?
-          return branch
-        end
-      end
-
-      # Method 4: Fallback - check local branches
-      ['main', 'master'].each do |branch|
-        result = `git rev-parse --verify #{branch} 2>/dev/null`
-        if $?.success?
-          return branch
-        end
-      end
-
-      # If all else fails, return nil
-      nil
-    end
-
-    def detect_hg_default_branch
-      # Method 1: Check current branch (if it's 'default', that's the main branch)
-      result = `hg branch 2>/dev/null`.strip
-      if $?.success? && result == 'default'
-        return 'default'
-      end
-
-      # Method 2: Look for 'default' branch in branch list
-      result = `hg branches 2>/dev/null`
-      if $?.success? && result.include?('default')
-        return 'default'
-      end
-
-      # Method 3: Check if there are any branches at all
-      result = `hg branches 2>/dev/null`.strip
-      if $?.success? && !result.empty?
-        # Get the first branch (usually the main one)
-        first_branch = result.lines.first&.split&.first
-        return first_branch if first_branch
-      end
-
-      # Fallback to 'default' (standard hg main branch name)
-      'default'
-    end
-
-    def validate_git_branch_exists(branch)
-      # Check if branch exists locally
-      _result = `git rev-parse --verify #{branch} 2>/dev/null`
-      return true if $?.success?
-
-      # Check if branch exists on remote
-      _result = `git rev-parse --verify origin/#{branch} 2>/dev/null`
-      return true if $?.success?
-
-      false
-    end
-
-    def validate_hg_branch_exists(branch)
-      # Check if branch exists in hg branches
-      result = `hg branches 2>/dev/null`
-      if $?.success?
-        return result.lines.any? { |line| line.strip.start_with?(branch) }
-      end
-
-      # If we can't list branches, assume it exists (hg is more permissive)
-      true
-    end
+    # All diff-related methods like handle_diff_analysis, get_vcs_type, etc., are removed.
 
     private
 
@@ -316,32 +60,9 @@ module N2B
       end
     end
 
-    def build_diff_analysis_prompt(diff_output, user_prompt_addition = "", requirements_content = nil)
-      default_system_prompt = <<-SYSTEM_PROMPT.strip
-You are a senior software developer reviewing a code diff.
-Your task is to provide a constructive and detailed analysis of the changes.
-Focus on identifying potential bugs, suggesting improvements in code quality, style, performance, and security.
-Also, provide a concise summary of the changes.
-
-IMPORTANT: When referring to specific issues or improvements, always include:
-- The exact file path (e.g., "lib/n2b/cli.rb")
-- The specific line numbers or line ranges (e.g., "line 42" or "lines 15-20")
-- The exact code snippet you're referring to when possible
-
-This helps users quickly locate and understand the issues you identify.
-
-SPECIAL FOCUS ON TEST COVERAGE:
-Pay special attention to whether the developer has provided adequate test coverage for the changes:
-- Look for new test files or modifications to existing test files
-- Check if new functionality has corresponding tests
-- Evaluate if edge cases and error conditions are tested
-- Assess if the tests are meaningful and comprehensive
-- Note any missing test coverage that should be added
-
-NOTE: In addition to the diff, you will also receive the current code context around the changed areas.
-This provides better understanding of the surrounding code and helps with more accurate analysis.
-The user may provide additional instructions or specific requirements below.
-SYSTEM_PROMPT
+    def build_diff_analysis_prompt(diff_output, user_prompt_addition = "", requirements_content = nil, config = {})
+      default_system_prompt_path = resolve_template_path('diff_system_prompt', config)
+      default_system_prompt = File.read(default_system_prompt_path).strip
 
       user_instructions_section = ""
       unless user_prompt_addition.to_s.strip.empty?
@@ -382,35 +103,8 @@ REQUIREMENTS_BLOCK
         end
       end
 
-      json_instruction = <<-JSON_INSTRUCTION.strip
-CRITICAL: Return ONLY a valid JSON object.
-Do not include any explanatory text before or after the JSON.
-Each error and improvement should include specific file paths and line numbers.
-
-The JSON object must contain the following keys:
-- "summary": (string) Brief overall description of the changes.
-- "ticket_implementation_summary": (string) A concise summary of what was implemented or achieved in relation to the ticket's goals, based *only* on the provided diff. This is for developer status updates and Jira comments.
-- "errors": (list of strings) Potential bugs or issues found.
-- "improvements": (list of strings) Suggestions for code quality, style, performance, or security.
-- "test_coverage": (string) Assessment of test coverage for the changes.
-- "requirements_evaluation": (string, include only if requirements were provided in the prompt) Evaluation of how the changes meet the provided requirements.
-
-Example format:
-{
-  "summary": "Refactored the user authentication module and added password complexity checks.",
-  "ticket_implementation_summary": "Implemented the core logic for user password updates and strengthened security by adding complexity validation as per the ticket's primary goal. Some UI elements are pending.",
-  "errors": [
-    "lib/example.rb line 42: Potential null pointer exception when accessing user.name without checking if user is nil.",
-    "src/main.js lines 15-20: Missing error handling for async operation."
-  ],
-  "improvements": [
-    "lib/example.rb line 30: Consider using a constant for the magic number 42.",
-    "src/utils.py lines 5-10: This method could be simplified using list comprehension."
-  ],
-  "test_coverage": "Good: New functionality in lib/example.rb has corresponding tests in test/example_test.rb. Missing: No tests for error handling edge cases in the new validation method.",
-  "requirements_evaluation": "✅ IMPLEMENTED: User authentication feature is fully implemented in auth.rb. ⚠️ PARTIALLY IMPLEMENTED: Error handling is present but lacks specific error codes. ❌ NOT IMPLEMENTED: Email notifications are not addressed in this diff."
-}
-JSON_INSTRUCTION
+      json_instruction_path = resolve_template_path('diff_json_instruction', config)
+      json_instruction = File.read(json_instruction_path).strip
 
       full_prompt = [
         default_system_prompt,
@@ -426,7 +120,7 @@ JSON_INSTRUCTION
     end
 
     def analyze_diff(diff_output, config, user_prompt_addition = "", requirements_content = nil)
-      prompt = build_diff_analysis_prompt(diff_output, user_prompt_addition, requirements_content)
+      prompt = build_diff_analysis_prompt(diff_output, user_prompt_addition, requirements_content, config)
       analysis_json_str = call_llm_for_diff_analysis(prompt, config)
 
       begin
@@ -500,6 +194,19 @@ JSON_INSTRUCTION
       improvements.map(&:strip).reject(&:empty?)
     end
 
+    def format_analysis_for_github(analysis_result)
+      return "No analysis result available." if analysis_result.nil? || analysis_result.empty?
+
+      {
+        implementation_summary: analysis_result['ticket_implementation_summary']&.strip,
+        technical_summary: analysis_result['summary']&.strip,
+        issues: format_issues_for_adf(analysis_result['errors']),
+        improvements: format_improvements_for_adf(analysis_result['improvements']),
+        test_coverage: analysis_result['test_coverage']&.strip,
+        requirements_evaluation: analysis_result['requirements_evaluation']&.strip
+      }
+    end
+
     def extract_json_from_response(response)
       # First try to parse the response as-is
       begin
@@ -588,40 +295,6 @@ JSON_INSTRUCTION
       context_sections
     end
 
-    def call_llm_for_diff_analysis(prompt, config)
-      begin
-        llm_service_name = config['llm']
-        llm = case llm_service_name
-              when 'openai'
-                N2M::Llm::OpenAi.new(config)
-              when 'claude'
-                N2M::Llm::Claude.new(config)
-              when 'gemini'
-                N2M::Llm::Gemini.new(config)
-              when 'openrouter'
-                N2M::Llm::OpenRouter.new(config)
-              when 'ollama'
-                N2M::Llm::Ollama.new(config)
-              else
-                # Should not happen if config is validated, but as a safeguard:
-                raise N2B::Error, "Unsupported LLM service: #{llm_service_name}"
-              end
-
-        response_json_str = llm.analyze_code_diff(prompt) # Call the new dedicated method
-        response_json_str
-      rescue N2B::LlmApiError => e # This catches errors from analyze_code_diff
-        puts "Error communicating with the LLM: #{e.message}"
-
-        # Check if it might be a model-related error
-        if e.message.include?('model') || e.message.include?('Model') || e.message.include?('invalid') || e.message.include?('not found')
-          puts "\nThis might be due to an invalid or unsupported model configuration."
-          puts "Run 'n2b -c' to reconfigure your model settings."
-        end
-
-        return '{"summary": "Error: Could not analyze diff due to LLM API error.", "errors": [], "improvements": []}'
-      end
-    end
-    
     def append_to_llm_history_file(commands)
       File.open(HISTORY_FILE, 'a') do |file|
         file.puts(commands)
@@ -640,19 +313,19 @@ JSON_INSTRUCTION
         llm_service_name = config['llm']
         llm = case llm_service_name
               when 'openai'
-                N2M::Llm::OpenAi.new(config)
+                N2B::Llm::OpenAi.new(config)
               when 'claude'
-                N2M::Llm::Claude.new(config)
+                N2B::Llm::Claude.new(config)
               when 'gemini'
-                N2M::Llm::Gemini.new(config)
+                N2B::Llm::Gemini.new(config)
               when 'openrouter'
-                N2M::Llm::OpenRouter.new(config)
+                N2B::Llm::OpenRouter.new(config)
               when 'ollama'
-                N2M::Llm::Ollama.new(config)
+                N2B::Llm::Ollama.new(config)
               else
                 # Fallback or error, though config validation should prevent this
                 puts "Warning: Unsupported LLM service '#{llm_service_name}' configured. Falling back to Claude."
-                N2M::Llm::Claude.new(config)
+                N2B::Llm::Claude.new(config)
               end
 
         # This content is specific to bash command generation
@@ -667,23 +340,37 @@ JSON_INSTRUCTION
               EOF
     
            
-      response_json_str = llm.make_request(content)
-
-      append_to_llm_history_file("#{prompt}\n#{response_json_str}") # Storing the raw JSON string
-      # The original call_llm was expected to return a hash after JSON.parse,
-      # but it was actually returning the string. Let's assume it should return a parsed Hash.
-      # However, the calling method `process_natural_language_command` accesses it like `bash_commands['commands']`
-      # which implies it expects a Hash. Let's ensure call_llm returns a Hash.
-      # This internal JSON parsing is for the *content* of a successful LLM response.
-      # The LlmApiError for network/auth issues should be caught before this.
+      puts "🤖 AI is generating commands..."
+      response = make_request_with_spinner(llm, content)
+
+      # Handle both Hash (from JSON mode providers) and String responses
+      if response.is_a?(Hash)
+        # Already parsed by the LLM provider
+        parsed_response = response
+        response_str = response.to_json # For history logging
+      else
+        # String response that needs parsing
+        response_str = response
         begin
-          parsed_response = JSON.parse(response_json_str)
-          parsed_response
+          parsed_response = JSON.parse(response_str)
         rescue JSON::ParserError => e
-          puts "Error parsing LLM response JSON for command generation: #{e.message}"
-          # This is a fallback for when the LLM response *content* is not valid JSON.
-          { "commands" => ["echo 'Error: LLM returned invalid JSON content.'"], "explanation" => "The response from the language model was not valid JSON." }
+          puts "⚠️  Invalid JSON detected, attempting automatic repair..."
+          repaired_response = attempt_json_repair_for_commands(response_str, llm)
+
+          if repaired_response
+            puts "✅ JSON repair successful!"
+            parsed_response = repaired_response
+          else
+            puts "❌ JSON repair failed"
+            puts "Error parsing LLM response JSON for command generation: #{e.message}"
+            # This is a fallback for when the LLM response *content* is not valid JSON.
+            parsed_response = { "commands" => ["echo 'Error: LLM returned invalid JSON content.'"], "explanation" => "The response from the language model was not valid JSON." }
+          end
         end
+      end
+
+      append_to_llm_history_file("#{prompt}\n#{response_str}") # Storing the response for history
+      parsed_response
       rescue N2B::LlmApiError => e
         puts "Error communicating with the LLM: #{e.message}"
 
@@ -784,63 +471,116 @@ JSON_INSTRUCTION
       end
       system("history -r") # Attempt to reload history in current session
     end
-    
+
+    def resolve_template_path(template_key, config)
+      user_path = config.dig('templates', template_key) if config.is_a?(Hash)
+      return user_path if user_path && File.exist?(user_path)
+
+      File.expand_path(File.join(__dir__, 'templates', "#{template_key}.txt"))
+    end
+
+    def make_request_with_spinner(llm, content)
+      spinner_chars = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏']
+      spinner_thread = Thread.new do
+        i = 0
+        while true
+          print "\r⠿ #{spinner_chars[i % spinner_chars.length]} Processing..."
+          $stdout.flush
+          sleep(0.1)
+          i += 1
+        end
+      end
+
+      begin
+        result = llm.make_request(content)
+        spinner_thread.kill
+        print "\r#{' ' * 25}\r"  # Clear the spinner line
+        puts "✅ Commands generated!"
+        result
+      rescue => e
+        spinner_thread.kill
+        print "\r#{' ' * 25}\r"  # Clear the spinner line
+        raise e
+      end
+    end
+
+    def attempt_json_repair_for_commands(malformed_response, llm)
+      repair_prompt = <<~PROMPT
+        The following response was supposed to be valid JSON with keys "commands" (array) and "explanation" (string), but it has formatting issues. Please fix it and return ONLY the corrected JSON:
+
+        Original response:
+        #{malformed_response}
+
+        Requirements:
+        - Must be valid JSON
+        - Must have "commands" key with array of command strings
+        - Must have "explanation" key with explanation text
+        - Return ONLY the JSON, no other text
+
+        Fixed JSON:
+      PROMPT
+
+      begin
+        puts "🔧 Asking AI to fix the JSON..."
+        repaired_json_str = llm.make_request(repair_prompt)
+
+        # Handle both Hash and String responses
+        if repaired_json_str.is_a?(Hash)
+          repaired_response = repaired_json_str
+        else
+          repaired_response = JSON.parse(repaired_json_str)
+        end
+
+        # Validate the repaired response structure
+        if repaired_response.is_a?(Hash) && repaired_response.key?('commands') && repaired_response.key?('explanation')
+          return repaired_response
+        else
+          return nil
+        end
+      rescue JSON::ParserError, StandardError
+        return nil
+      end
+    end
+
 
     def parse_options
       options = {
         execute: false,
         config: nil,
-        diff: false,
-        requirements: nil,
-        branch: nil,
-        jira_ticket: nil,
-        jira_update: nil, # Using nil as default, true for --jira-update, false for --jira-no-update
-        advanced_config: false # New option for advanced configuration flow
+        # diff: false, # Removed
+        # requirements: nil, # Removed
+        # branch: nil, # Removed
+        # jira_ticket: nil, # Removed
+        # jira_update: nil, # Removed
+        advanced_config: false
       }
 
       parser = OptionParser.new do |opts|
         opts.banner = "Usage: n2b [options] [natural language command]"
 
-        opts.on('-x', '--execute', 'Execute the commands after confirmation') do
+        opts.on('-x', '--execute', 'Execute the translated commands after confirmation.') do
           options[:execute] = true
         end
 
-        opts.on('-d', '--diff', 'Analyze git/hg diff with AI') do
-          options[:diff] = true
-        end
-
-        opts.on('-b', '--branch [BRANCH]', 'Compare against branch (default: auto-detect main/master)') do |branch|
-          options[:branch] = branch || 'auto'
-        end
-
-        opts.on('-r', '--requirements FILE', 'Requirements file for diff analysis') do |file|
-          options[:requirements] = file
-        end
+        # Removed options: -d, --diff, -b, --branch, -r, --requirements, -j, --jira, --jira-update, --jira-no-update
 
-        opts.on('-j', '--jira JIRA_ID_OR_URL', 'Jira ticket ID or URL for context or update') do |jira|
-          options[:jira_ticket] = jira
-        end
-
-        opts.on('--jira-update', 'Update the linked Jira ticket (requires -j)') do
-          options[:jira_update] = true
+        opts.on('-c', '--config', 'Configure N2B (API key, model, privacy settings, etc.).') do
+          options[:config] = true
         end
 
-        opts.on('--jira-no-update', 'Do not update the linked Jira ticket (requires -j)') do
-          options[:jira_update] = false
+        opts.on('--advanced-config', 'Access advanced configuration options.') do
+          options[:advanced_config] = true
+          options[:config] = true # --advanced-config implies -c
         end
 
-        opts.on('-h', '--help', 'Print this help') do
+        opts.on_tail('-h', '--help', 'Show this help message.') do
           puts opts
           exit
         end
 
-        opts.on('-c', '--config', 'Configure the API key and model') do
-          options[:config] = true
-        end
-
-        opts.on('--advanced-config', 'Access advanced configuration options including Jira and privacy settings') do
-          options[:advanced_config] = true
-          options[:config] = true # Forcing config mode if advanced is chosen
+        opts.on_tail('-v', '--version', 'Show version.') do
+          puts "n2b version #{N2B::VERSION}" # Assuming N2B::VERSION is defined
+          exit
         end
       end
 
@@ -851,36 +591,14 @@ JSON_INSTRUCTION
         puts ""
         puts parser.help
         exit 1
-      end
-
-      # Validate option combinations
-      if options[:branch] && !options[:diff]
-        puts "Error: --branch option can only be used with --diff"
-        puts ""
-        puts parser.help
-        exit 1
-      end
-
-      if options[:jira_update] == true && options[:jira_ticket].nil?
-        puts "Error: --jira-update option requires a Jira ticket to be specified with -j or --jira."
-        puts ""
-        puts parser.help
-        exit 1
-      end
-
-      if options[:jira_update] == false && options[:jira_ticket].nil?
-        puts "Error: --jira-no-update option requires a Jira ticket to be specified with -j or --jira."
+      rescue OptionParser::MissingArgument => e
+        puts "Error: #{e.message}"
         puts ""
         puts parser.help
         exit 1
       end
 
-      if options[:jira_update] == true && options[:jira_update] == false
-        puts "Error: --jira-update and --jira-no-update are mutually exclusive."
-        puts ""
-        puts parser.help
-        exit 1
-      end
+      # Removed validation logic for diff/jira related options
 
       options
     end