n2b 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 698bca4814bd42e8587efb9d278ce1cb090b3ea23afd645c9c082b1c277ea22d
-  data.tar.gz: c7ec9715a8b5807b1ea5eb90e448fd70767fdc3e6ace987e1b123e29ee37dd33
+  metadata.gz: 58382cb632f67e6ad3ca031c71a2c53bd5cd477ea32963d89f0d253d8b43bbeb
+  data.tar.gz: facb990aad05d93cac662fdbf60075ad3606dd43083f408a8e0d60d5940df359
 SHA512:
-  metadata.gz: 7d00b68b8e2925b63d4bf6b2e4842a18034e2dc318686d55261480c2612f47f8574379df85ae166670a721aa6bd41406d08323cddb0ebd831e3777dc1773ca1a
-  data.tar.gz: e7b3621fcf9051d433ca0fba961b12d348b03f9d73981d641b252b4a4223b8edfec0f8ee438f6c603382ca62c1cf4679e9960f6c40f16b84c644d6939290dbe5
+  metadata.gz: 8dd53c35513bf7071c5aecb7f724ebc44f522a166ef1ca8dc4aecfda3f9cd801dd7d85bce6762a4fc8bd5e1a98aa87eaa9e8080db3302a17d5875f8010b90867
+  data.tar.gz: 866846f2c517fe7dcee27172640151b1d6e567161b473a7c5a39c3894df15ea25b43e2278b24fd783f93c5eac8f507e7d331a85ef5fc5084990f89c227c19485

data/README.md

@@ -6,10 +6,24 @@ N2B (Natural Language to Bash & Ruby) is a Ruby gem that leverages AI to convert
 
 ## Features
 
-- Convert natural language to bash commands
-- Generate Ruby code from natural language instructions
-- Analyze Errbit errors and generate detailed reports
-- Create formatted Scrum tickets from errors
+- **🤖 Natural Language to Commands**: Convert natural language to bash commands
+- **💎 Ruby Code Generation**: Generate Ruby code from natural language instructions
+- **🔍 AI-Powered Diff Analysis**: Analyze git/hg diffs with comprehensive code review
+- **📋 Requirements Compliance**: Check if code changes meet specified requirements
+- **🧪 Test Coverage Assessment**: Evaluate test coverage for code changes
+- **🌿 Branch Comparison**: Compare changes against any branch (main/master/default)
+- **🛠️ VCS Support**: Full support for both Git and Mercurial repositories
+- **📊 Errbit Integration**: Analyze Errbit errors and generate detailed reports
+- **🎫 Scrum Tickets**: Create formatted Scrum tickets from errors
+
+### 🆕 **New in v0.4.0: Flexible Model Configuration**
+
+- **🎯 Multiple LLM Providers**: Claude, OpenAI, Gemini, OpenRouter, Ollama
+- **🔧 Custom Models**: Use any model name - fine-tunes, beta models, custom deployments
+- **📋 Suggested Models**: Curated lists of latest models with easy selection
+- **🚀 Latest Models**: OpenAI O3/O4 series, Gemini 2.5, updated OpenRouter models
+- **🔄 Backward Compatible**: Existing configurations continue working seamlessly
+- **⚡ No Restrictions**: Direct API model names accepted without validation
 
 ## Installation
 
@@ -56,16 +70,74 @@ n2rscrum "Create a user authentication system"
 
 ## Configuration
 
-Create a config file at `~/.n2b/config.yml` with your API keys:
+N2B now features a **flexible model configuration system** that supports both suggested models and custom model names across all providers.
 
-```yaml
-llm: claude  # or openai
-claude:
-  key: your-anthropic-api-key
-  model: claude-3-opus-20240229 # or opus, haiku, sonnet
-openai:
-  key: your-openai-api-key
-  model: gpt-4 # or gpt-3.5-turbo
+### Quick Setup
+
+Run the configuration command to get started:
+
+```bash
+n2b -c
+```
+
+This will guide you through:
+- Selecting your preferred LLM provider (Claude, OpenAI, Gemini, OpenRouter, Ollama)
+- Choosing from suggested models or entering custom model names
+- Setting up API keys
+- Configuring privacy settings
+
+### Supported Models
+
+#### 🤖 **Claude** (Default: sonnet)
+- `haiku` → claude-3-haiku-20240307
+- `sonnet` → claude-3-sonnet-20240229
+- `sonnet35` → claude-3-5-sonnet-20240620
+- `sonnet37` → claude-3-7-sonnet-20250219
+- `sonnet40` → claude-sonnet-4-20250514
+- **Custom models**: Any Claude model name
+
+#### 🧠 **OpenAI** (Default: gpt-4o-mini)
+- `gpt-4o` → gpt-4o
+- `gpt-4o-mini` → gpt-4o-mini
+- `o3` → o3 (Latest reasoning model)
+- `o3-mini` → o3-mini
+- `o3-mini-high` → o3-mini-high
+- `o4` → o4
+- `o4-mini` → o4-mini
+- `o4-mini-high` → o4-mini-high
+- **Custom models**: Any OpenAI model name
+
+#### 🔮 **Gemini** (Default: gemini-2.5-flash)
+- `gemini-2.5-flash` → gemini-2.5-flash-preview-05-20
+- `gemini-2.5-pro` → gemini-2.5-pro-preview-05-06
+- **Custom models**: Any Gemini model name
+
+#### 🌐 **OpenRouter** (Default: deepseek-v3)
+- `deepseek-v3` → deepseek-v3-0324
+- `deepseek-r1-llama-8b` → deepseek-r1-distill-llama-8b
+- `llama-3.3-70b` → llama-3.3-70b-instruct
+- `llama-3.3-8b` → llama-3.3-8b-instruct
+- `wayfinder-large` → wayfinder-large-70b-llama-3.3
+- **Custom models**: Any OpenRouter model name
+
+#### 🦙 **Ollama** (Default: llama3)
+- `llama3` → llama3
+- `mistral` → mistral
+- `codellama` → codellama
+- `qwen` → qwen2.5
+- **Custom models**: Any locally available Ollama model
+
+### Custom Configuration File
+
+You can use a custom config file by setting the `N2B_CONFIG_FILE` environment variable:
+
+```bash
+export N2B_CONFIG_FILE=/path/to/your/config.yml
+```
+
+You can also set the history file location using the `N2B_HISTORY_FILE` environment variable:
+```bash
+export N2B_HISTORY_FILE=/path/to/your/history
 ```
 
 ## Quick Example N2B
@@ -114,16 +186,38 @@ input_string.to_s.scan(/[\/\w.-]+\.rb(?=\s|:|$)/)
 Install the gem by running:
 gem install n2b
 
-## Configuration
+## Enhanced Model Selection
 
-Before using n2b, you need to configure it with your Claude API key and preferences. Run:
-n2b -c
+N2B v0.4.0 introduces a **flexible model configuration system**:
+
+### Interactive Model Selection
+
+When you run `n2b -c`, you'll see an enhanced interface:
+
+```
+Choose a model for openai:
+1. gpt-4o (gpt-4o)
+2. gpt-4o-mini (gpt-4o-mini) [default]
+3. o3 (o3)
+4. o3-mini (o3-mini)
+5. o3-mini-high (o3-mini-high)
+6. o4 (o4)
+7. o4-mini (o4-mini)
+8. o4-mini-high (o4-mini-high)
+9. custom (enter your own model name)
+
+Enter choice (1-9) or model name [gpt-4o-mini]: 9
+Enter custom model name: gpt-5-preview
+✓ Using custom model: gpt-5-preview
+```
+
+### Key Features
 
-This will prompt you to enter:
-- Your Claude API or OpenAI key
-- Preferred  model (e.g. haiku, sonnet, or sonnet35)
-- Privacy settings (whether to send shell history, past requests, current directory)
-- Whether to append generated commands to your shell history
+- **🎯 Suggested Models**: Curated list of latest models for each provider
+- **🔧 Custom Models**: Enter any model name for fine-tunes, beta models, etc.
+- **🔄 Backward Compatible**: Existing configurations continue working
+- **🚀 Latest Models**: Access to newest OpenAI O-series, Gemini 2.5, etc.
+- **⚡ No Validation**: Direct API model names accepted - let the API handle errors
 
 Configuration is stored in `~/.n2b/config.yml`.
 
@@ -135,6 +229,9 @@ n2b [options] your natural language instruction
 
 Options:
 - `-x` or `--execute`: Execute the generated commands after confirmation
+- `-d` or `--diff`: Analyze git/hg diff with AI-powered code review
+- `-b` or `--branch [BRANCH]`: Compare against specific branch (auto-detects main/master/default)
+- `-r` or `--requirements FILE`: Requirements file for compliance checking
 - `-c` or `--config`: Reconfigure the tool
 - `-h` or `--help`: Display help information
 
@@ -152,6 +249,82 @@ Examples:
 
 ```n2b -c  ```
 
+## 🔍 AI-Powered Diff Analysis
+
+N2B provides comprehensive AI-powered code review for your git and mercurial repositories.
+
+### Basic Diff Analysis
+
+```bash
+# Analyze uncommitted changes
+n2b --diff
+
+# Analyze changes against specific branch
+n2b --diff --branch main
+n2b --diff --branch feature/auth
+
+# Auto-detect default branch (main/master/default)
+n2b --diff --branch
+
+# Short form
+n2b -d -b main
+```
+
+### Requirements Compliance Checking
+
+```bash
+# Check if changes meet requirements
+n2b --diff --requirements requirements.md
+n2b -d -r req.md
+
+# Combine with branch comparison
+n2b --diff --branch main --requirements requirements.md
+```
+
+### What You Get
+
+The AI analysis provides:
+
+- **📝 Summary**: Clear overview of what changed
+- **🚨 Potential Errors**: Bugs, security issues, logic problems with exact file/line references
+- **💡 Suggested Improvements**: Code quality, performance, style recommendations
+- **🧪 Test Coverage Assessment**: Evaluation of test completeness and quality
+- **📋 Requirements Evaluation**: Compliance check with clear status indicators:
+  - ✅ **IMPLEMENTED**: Requirement fully satisfied
+  - ⚠️ **PARTIALLY IMPLEMENTED**: Needs more work
+  - ❌ **NOT IMPLEMENTED**: Not addressed
+  - 🔍 **UNCLEAR**: Cannot determine from diff
+
+### Example Output
+
+```
+Code Diff Analysis:
+-------------------
+Summary:
+Added user authentication with JWT tokens and password validation.
+
+Potential Errors:
+- lib/auth.rb line 42: Password validation allows weak passwords
+- controllers/auth_controller.rb lines 15-20: Missing rate limiting for login attempts
+
+Suggested Improvements:
+- lib/auth.rb line 30: Consider using bcrypt for password hashing
+- spec/auth_spec.rb: Add tests for edge cases and security scenarios
+
+Test Coverage Assessment:
+Good: Basic authentication flow is tested. Missing: No tests for password validation edge cases, JWT expiration handling, or security attack scenarios.
+
+Requirements Evaluation:
+✅ IMPLEMENTED: User login/logout functionality fully working
+⚠️ PARTIALLY IMPLEMENTED: Password strength requirements present but not comprehensive
+❌ NOT IMPLEMENTED: Two-factor authentication not addressed in this diff
+-------------------
+```
+
+### Supported Version Control Systems
+
+- **Git**: Full support with auto-detection of main/master branches
+- **Mercurial (hg)**: Full support with auto-detection of default branch
 
 n2r in ruby or rails console
 n2r "your question", files:['file1.rb', 'file2.rb'], exception: AnError
@@ -240,4 +413,4 @@ The generated tickets include:
 - Acceptance criteria
 - Story point estimate
 - Priority level
-- Reference to the original Errbit URL
+- Reference to the original Errbit URL# Test change

data/lib/n2b/base.rb

@@ -1,3 +1,5 @@
+require_relative 'model_config'
+
 module N2B
   class Base
 
@@ -14,42 +16,86 @@ module N2B
     
     def get_config( reconfigure: false)
       config = load_config
-      api_key = ENV['CLAUDE_API_KEY'] || config['access_key']
-      model = config['model'] || 'sonnet35'
+      api_key = ENV['CLAUDE_API_KEY'] || config['access_key'] # This will be used as default or for existing configs
+      model = config['model'] # Model will be handled per LLM
   
-      if api_key.nil? || api_key == '' ||  reconfigure
-        print "choose a language model to use (1:claude, 2:openai, 3:gemini) #{ config['llm'] }: "
+      if api_key.nil? || api_key == '' || config['llm'].nil? || reconfigure # Added config['llm'].nil? to force config if llm type isn't set
+        print "choose a language model to use (1:claude, 2:openai, 3:gemini, 4:openrouter, 5:ollama) #{ config['llm'] }: "
         llm = $stdin.gets.chomp
-        llm = config['llm'] if llm.empty?
-        unless ['claude', 'openai', 'gemini', '1', '2', '3'].include?(llm)
-          puts "Invalid language model. Choose from: claude, openai, gemini"
+        llm = config['llm'] if llm.empty? && !config['llm'].nil? # Keep current if input is empty and current exists
+
+        unless ['claude', 'openai', 'gemini', 'openrouter', 'ollama', '1', '2', '3', '4', '5'].include?(llm)
+          puts "Invalid language model. Choose from: claude, openai, gemini, openrouter, ollama, or 1-5"
           exit 1
         end
         llm = 'claude' if llm == '1'
         llm = 'openai' if llm == '2'
         llm = 'gemini' if llm == '3'
-        llm_class = case llm
-                   when 'openai'
-                     N2M::Llm::OpenAi
-                   when 'gemini'
-                     N2M::Llm::Gemini
-                   else
-                     N2M::Llm::Claude
-                   end
-
-        print "Enter your #{llm} API key: #{ api_key.nil? || api_key.empty? ? '' : '(leave blank to keep the current key '+api_key[0..10]+'...)' }"
-        api_key = $stdin.gets.chomp 
-        api_key = config['access_key'] if api_key.empty?
-        print "Choose a model (#{ llm_class::MODELS.keys }, #{ llm_class::MODELS.keys.first } default): "
-        model = $stdin.gets.chomp 
-        model = llm_class::MODELS.keys.first if model.empty?
+        llm = 'openrouter' if llm == '4'
+        llm = 'ollama' if llm == '5'
+
+        # Set default LLM if needed
+        if llm.nil? || llm.empty?
+          llm = 'claude'
+        end
+
         config['llm'] = llm
-        config['access_key'] = api_key
-        config['model'] = model
-        unless llm_class::MODELS.keys.include?(model)
-          puts "Invalid model. Choose from: #{llm_class::MODELS.keys.join(', ')}"
-          exit 1
+
+        if llm == 'ollama'
+          # Ollama specific configuration
+          puts "Ollama typically runs locally and doesn't require an API key."
+
+          # Use new model configuration system
+          current_model = config['model']
+          model = N2B::ModelConfig.get_model_choice(llm, current_model)
+
+          # Configure Ollama API URL
+          current_ollama_api_url = config['ollama_api_url'] || N2M::Llm::Ollama::DEFAULT_OLLAMA_API_URI
+          print "Enter Ollama API base URL (default: #{current_ollama_api_url}): "
+          ollama_api_url_input = $stdin.gets.chomp
+          config['ollama_api_url'] = ollama_api_url_input.empty? ? current_ollama_api_url : ollama_api_url_input
+          config.delete('access_key') # Remove access_key if switching to ollama
+        else
+          # Configuration for API key based LLMs (Claude, OpenAI, Gemini, OpenRouter)
+          current_api_key = config['access_key'] # Use existing key from config as default
+          print "Enter your #{llm} API key: #{ current_api_key.nil? || current_api_key.empty? ? '' : '(leave blank to keep the current key)' }"
+          api_key_input = $stdin.gets.chomp
+          config['access_key'] = api_key_input if !api_key_input.empty?
+          config['access_key'] = current_api_key if api_key_input.empty? && !current_api_key.nil? && !current_api_key.empty?
+
+          # Ensure API key is present if not Ollama
+          if config['access_key'].nil? || config['access_key'].empty?
+            puts "API key is required for #{llm}."
+            exit 1
+          end
+
+          # Use new model configuration system
+          current_model = config['model']
+          model = N2B::ModelConfig.get_model_choice(llm, current_model)
+
+          if llm == 'openrouter'
+            current_site_url = config['openrouter_site_url'] || ""
+            print "Enter your OpenRouter Site URL (optional, for HTTP-Referer header, current: #{current_site_url}): "
+            openrouter_site_url_input = $stdin.gets.chomp
+            config['openrouter_site_url'] = openrouter_site_url_input.empty? ? current_site_url : openrouter_site_url_input
+
+            current_site_name = config['openrouter_site_name'] || ""
+            print "Enter your OpenRouter Site Name (optional, for X-Title header, current: #{current_site_name}): "
+            openrouter_site_name_input = $stdin.gets.chomp
+            config['openrouter_site_name'] = openrouter_site_name_input.empty? ? current_site_name : openrouter_site_name_input
+          end
         end
+
+        config['model'] = model # Store selected model for all types
+
+        # Ensure privacy settings are initialized if not present
+        config['privacy'] ||= {}
+        # Set defaults for any privacy settings that are nil
+        config['privacy']['send_shell_history'] = false if config['privacy']['send_shell_history'].nil?
+        config['privacy']['send_llm_history'] = true if config['privacy']['send_llm_history'].nil?
+        config['privacy']['send_current_directory'] = true if config['privacy']['send_current_directory'].nil?
+        config['append_to_shell_history'] = false if config['append_to_shell_history'].nil?
+
         puts "configure privacy settings directly in the config file #{CONFIG_FILE}"
         config['privacy'] ||= {} 
         config['privacy']['send_shell_history'] = false

data/lib/n2b/cli.rb

@@ -46,7 +46,7 @@ module N2B
         requirements_content = File.read(requirements_filepath)
       end
 
-      diff_output = execute_vcs_diff(vcs_type)
+      diff_output = execute_vcs_diff(vcs_type, @options[:branch])
       analyze_diff(diff_output, config, user_prompt_addition, requirements_content)
     end
 
@@ -60,17 +60,139 @@ module N2B
       end
     end
 
-    def execute_vcs_diff(vcs_type)
+    def execute_vcs_diff(vcs_type, branch_option = nil)
       case vcs_type
       when :git
-        `git diff HEAD`
+        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
-        `hg diff`
+        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
+
     private
 
     def process_natural_language_command(input_text, config)
@@ -335,6 +457,10 @@ JSON_INSTRUCTION
                 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}"
@@ -344,6 +470,13 @@ JSON_INSTRUCTION
         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
@@ -363,7 +496,23 @@ JSON_INSTRUCTION
     
     def call_llm(prompt, config)
       begin # Added begin for LlmApiError rescue
-        llm = config['llm'] == 'openai' ?   N2M::Llm::OpenAi.new(config) : N2M::Llm::Claude.new(config)
+        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
+                # 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)
+              end
 
         # This content is specific to bash command generation
       content = <<-EOF
@@ -386,19 +535,26 @@ JSON_INSTRUCTION
       # 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.
-      begin
-        parsed_response = JSON.parse(response_json_str)
-        parsed_response
-      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." }
-      end
-    rescue N2B::LlmApiError => e
-      puts "Error communicating with the LLM: #{e.message}"
-      # This is the fallback for LlmApiError (network, auth, etc.)
-      { "commands" => ["echo 'LLM API error occurred. Please check your configuration and network.'"], "explanation" => "Failed to connect to the LLM." }
-    end
+        begin
+          parsed_response = JSON.parse(response_json_str)
+          parsed_response
+        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." }
+        end
+      rescue N2B::LlmApiError => e
+        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
+
+        # This is the fallback for LlmApiError (network, auth, etc.)
+        { "commands" => ["echo 'LLM API error occurred. Please check your configuration and network.'"], "explanation" => "Failed to connect to the LLM." }
+      end
     end
     
     def get_user_shell
@@ -490,7 +646,7 @@ JSON_INSTRUCTION
     
 
     def parse_options
-      options = { execute: false, config: nil, diff: false, requirements: nil }
+      options = { execute: false, config: nil, diff: false, requirements: nil, branch: nil }
 
       parser = OptionParser.new do |opts|
         opts.banner = "Usage: n2b [options] [natural language command]"
@@ -503,6 +659,10 @@ JSON_INSTRUCTION
           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
@@ -526,6 +686,14 @@ JSON_INSTRUCTION
         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
+
       options
     end
   end

data/lib/n2b/config/models.yml

@@ -0,0 +1,47 @@
+# N2B Model Configuration
+# Format: display_name -> api_model_name
+# Users can select from suggested models or enter custom model names
+
+claude:
+  suggested:
+    haiku: "claude-3-haiku-20240307"
+    sonnet: "claude-3-sonnet-20240229" 
+    sonnet35: "claude-3-5-sonnet-20240620"
+    sonnet37: "claude-3-7-sonnet-20250219"
+    sonnet40: "claude-sonnet-4-20250514"
+  default: "sonnet"
+
+openai:
+  suggested:
+    gpt-4o: "gpt-4o"
+    gpt-4o-mini: "gpt-4o-mini"
+    o3: "o3"
+    o3-mini: "o3-mini"
+    o3-mini-high: "o3-mini-high"
+    o4: "o4"
+    o4-mini: "o4-mini"
+    o4-mini-high: "o4-mini-high"
+  default: "gpt-4o-mini"
+
+gemini:
+  suggested:
+    gemini-2.5-flash: "gemini-2.5-flash-preview-05-20"
+    gemini-2.5-pro: "gemini-2.5-pro-preview-05-06"
+  default: "gemini-2.5-flash"
+
+openrouter:
+  suggested:
+    deepseek-v3: "deepseek-v3-0324"
+    deepseek-r1-llama-8b: "deepseek-r1-distill-llama-8b"
+    llama-3.3-70b: "llama-3.3-70b-instruct"
+    llama-3.3-8b: "llama-3.3-8b-instruct"
+    wayfinder-large: "wayfinder-large-70b-llama-3.3"
+  default: "deepseek-v3"
+
+ollama:
+  suggested:
+    llama3: "llama3"
+    mistral: "mistral"
+    codellama: "codellama"
+    qwen: "qwen2.5"
+  default: "llama3"

data/lib/n2b/llm/claude.rb

@@ -1,13 +1,24 @@
+require_relative '../model_config'
+
 module N2M
   module Llm
     class Claude
       API_URI = URI.parse('https://api.anthropic.com/v1/messages')
-      MODELS = { 'haiku' =>  'claude-3-haiku-20240307', 'sonnet' => 'claude-3-sonnet-20240229', 'sonnet35' => 'claude-3-5-sonnet-20240620', "sonnet37" => "claude-3-7-sonnet-20250219" }
 
       def initialize(config)
         @config = config
       end
 
+      def get_model_name
+        # Resolve model name using the centralized configuration
+        model_name = N2B::ModelConfig.resolve_model('claude', @config['model'])
+        if model_name.nil? || model_name.empty?
+          # Fallback to default if no model specified
+          model_name = N2B::ModelConfig.resolve_model('claude', N2B::ModelConfig.default_model('claude'))
+        end
+        model_name
+      end
+
       def make_request( content)
         uri = URI.parse('https://api.anthropic.com/v1/messages')
         request = Net::HTTP::Post.new(uri)
@@ -16,7 +27,7 @@ module N2M
         request['anthropic-version'] = '2023-06-01'
       
         request.body = JSON.dump({
-          "model" => MODELS[@config['model']],
+          "model" => get_model_name,
           "max_tokens" => 1024,
           "messages" => [
             {
@@ -71,7 +82,7 @@ module N2M
         request['anthropic-version'] = '2023-06-01'
 
         request.body = JSON.dump({
-          "model" => MODELS[@config['model']],
+          "model" => get_model_name,
           "max_tokens" => @config['max_tokens'] || 1024, # Allow overriding max_tokens from config
           "messages" => [
             {

data/lib/n2b/llm/gemini.rb

@@ -1,21 +1,29 @@
 require 'net/http'
 require 'json'
 require 'uri'
+require_relative '../model_config'
 
 module N2M
   module Llm
     class Gemini
       API_URI = URI.parse('https://generativelanguage.googleapis.com/v1beta/models')
-      MODELS = { 
-        'gemini-flash' => 'gemini-2.0-flash'
-      }
 
       def initialize(config)
         @config = config
       end
 
+      def get_model_name
+        # Resolve model name using the centralized configuration
+        model_name = N2B::ModelConfig.resolve_model('gemini', @config['model'])
+        if model_name.nil? || model_name.empty?
+          # Fallback to default if no model specified
+          model_name = N2B::ModelConfig.resolve_model('gemini', N2B::ModelConfig.default_model('gemini'))
+        end
+        model_name
+      end
+
       def make_request(content)
-        model = MODELS[@config['model']] || 'gemini-flash'
+        model = get_model_name
         uri = URI.parse("#{API_URI}/#{model}:generateContent?key=#{@config['access_key']}")
         
         request = Net::HTTP::Post.new(uri)
@@ -65,7 +73,7 @@ module N2M
       def analyze_code_diff(prompt_content)
         # This method assumes prompt_content is the full, ready-to-send prompt
         # including all instructions for the LLM (system message, diff, user additions, JSON format).
-        model = MODELS[@config['model']] || 'gemini-flash' # Or a specific model for analysis if different
+        model = get_model_name
         uri = URI.parse("#{API_URI}/#{model}:generateContent?key=#{@config['access_key']}")
 
         request = Net::HTTP::Post.new(uri)

data/lib/n2b/llm/ollama.rb

@@ -0,0 +1,129 @@
+require 'net/http'
+require 'json'
+require 'uri'
+require_relative '../model_config'
+
+module N2M
+  module Llm
+    class Ollama
+      # Default API URI for Ollama. This might need to be configurable later.
+      DEFAULT_OLLAMA_API_URI = 'http://localhost:11434/api/chat'
+
+      def initialize(config)
+        @config = config
+        # Allow overriding the Ollama API URI from config if needed
+        @api_uri = URI.parse(@config['ollama_api_url'] || DEFAULT_OLLAMA_API_URI)
+      end
+
+      def get_model_name
+        # Resolve model name using the centralized configuration
+        model_name = N2B::ModelConfig.resolve_model('ollama', @config['model'])
+        if model_name.nil? || model_name.empty?
+          # Fallback to default if no model specified
+          model_name = N2B::ModelConfig.resolve_model('ollama', N2B::ModelConfig.default_model('ollama'))
+        end
+        model_name
+      end
+
+      def make_request(prompt_content)
+        request = Net::HTTP::Post.new(@api_uri)
+        request.content_type = 'application/json'
+
+        # Ollama expects the model name directly in the request body.
+        # It also expects the full message history.
+        request.body = JSON.dump({
+          "model" => get_model_name,
+          "messages" => [
+            {
+              "role" => "user",
+              "content" => prompt_content
+            }
+          ],
+          "stream" => false # Ensure we get the full response, not a stream
+          # "format" => "json" # For some Ollama versions/models to enforce JSON output
+        })
+
+        begin
+          response = Net::HTTP.start(@api_uri.hostname, @api_uri.port, use_ssl: @api_uri.scheme == 'https') do |http|
+            # Set timeouts: open_timeout for connection, read_timeout for waiting for response
+            http.open_timeout = 5 # seconds
+            http.read_timeout = 120 # seconds
+            http.request(request)
+          end
+        rescue Net::OpenTimeout, Net::ReadTimeout => e
+          raise N2B::LlmApiError.new("Ollama API Error: Timeout connecting or reading from Ollama at #{@api_uri}: #{e.message}")
+        rescue Errno::ECONNREFUSED => e
+          raise N2B::LlmApiError.new("Ollama API Error: Connection refused at #{@api_uri}. Is Ollama running? #{e.message}")
+        end
+
+
+        if response.code != '200'
+          raise N2B::LlmApiError.new("Ollama API Error: #{response.code} #{response.message} - #{response.body}")
+        end
+
+        # Ollama's chat response structure is slightly different. The message is in `message.content`.
+        raw_response_body = JSON.parse(response.body)
+        answer_content = raw_response_body['message']['content']
+
+        begin
+          # Attempt to parse the answer_content as JSON
+          # This is for n2b's expectation of JSON with 'commands' and 'explanation'
+          parsed_answer = JSON.parse(answer_content)
+          if parsed_answer.is_a?(Hash) && parsed_answer.key?('commands')
+            parsed_answer
+          else
+            # If the content itself is valid JSON but not the expected structure, wrap it.
+             { 'commands' => [answer_content], 'explanation' => 'Response from LLM (JSON content).' }
+          end
+        rescue JSON::ParserError
+          # If answer_content is not JSON, wrap it in the n2b expected structure
+          { 'commands' => [answer_content], 'explanation' => answer_content }
+        end
+      end
+
+      def analyze_code_diff(prompt_content)
+        request = Net::HTTP::Post.new(@api_uri)
+        request.content_type = 'application/json'
+
+        # The prompt_content for diff analysis should instruct the LLM to return JSON.
+        # For Ollama, you can also try adding "format": "json" to the request if the model supports it.
+        request_body = {
+          "model" => @config['model'] || MODELS.keys.first,
+          "messages" => [
+            {
+              "role" => "user",
+              "content" => prompt_content # This prompt must ask for JSON output
+            }
+          ],
+          "stream" => false
+        }
+        # Some Ollama models/versions might respect a "format": "json" parameter
+        # request_body["format"] = "json" # Uncomment if you want to try this
+
+        request.body = JSON.dump(request_body)
+
+        begin
+          response = Net::HTTP.start(@api_uri.hostname, @api_uri.port, use_ssl: @api_uri.scheme == 'https') do |http|
+            http.open_timeout = 5
+            http.read_timeout = 180 # Potentially longer for analysis
+            http.request(request)
+          end
+        rescue Net::OpenTimeout, Net::ReadTimeout => e
+          raise N2B::LlmApiError.new("Ollama API Error (analyze_code_diff): Timeout for #{@api_uri}: #{e.message}")
+        rescue Errno::ECONNREFUSED => e
+          raise N2B::LlmApiError.new("Ollama API Error (analyze_code_diff): Connection refused at #{@api_uri}. Is Ollama running? #{e.message}")
+        end
+
+
+        if response.code != '200'
+          raise N2B::LlmApiError.new("Ollama API Error (analyze_code_diff): #{response.code} #{response.message} - #{response.body}")
+        end
+
+        # Return the raw JSON string from the LLM's response content.
+        # The calling method (call_llm_for_diff_analysis in cli.rb) will parse this.
+        raw_response_body = JSON.parse(response.body)
+        raw_response_body['message']['content']
+      end
+    end
+  end
+end

data/lib/n2b/llm/open_ai.rb

@@ -1,24 +1,34 @@
 require 'net/http'
 require 'json'
 require 'uri'
+require_relative '../model_config'
 
 module N2M
   module Llm
     class OpenAi
       API_URI = URI.parse('https://api.openai.com/v1/chat/completions')
-      MODELS = { 'gpt-4o' =>  'gpt-4o','gpt-4o-mini'=>'gpt-4o-mini', 'gpt-35' => 'gpt-3.5-turbo-1106' }
 
       def initialize(config)
         @config = config
       end
 
+      def get_model_name
+        # Resolve model name using the centralized configuration
+        model_name = N2B::ModelConfig.resolve_model('openai', @config['model'])
+        if model_name.nil? || model_name.empty?
+          # Fallback to default if no model specified
+          model_name = N2B::ModelConfig.resolve_model('openai', N2B::ModelConfig.default_model('openai'))
+        end
+        model_name
+      end
+
       def make_request(content)
         request = Net::HTTP::Post.new(API_URI)
         request.content_type = 'application/json'
         request['Authorization'] = "Bearer #{@config['access_key']}"
 
         request.body = JSON.dump({
-          "model" => MODELS[@config['model']],
+          "model" => get_model_name,
           response_format: { type: 'json_object' },
           "messages" => [
             {
@@ -54,7 +64,7 @@ module N2M
         request['Authorization'] = "Bearer #{@config['access_key']}"
 
         request.body = JSON.dump({
-          "model" => MODELS[@config['model']],
+          "model" => get_model_name,
           "response_format" => { "type" => "json_object" }, # Crucial for OpenAI to return JSON
           "messages" => [
             {

data/lib/n2b/llm/open_router.rb

@@ -0,0 +1,116 @@
+require 'net/http'
+require 'json'
+require 'uri'
+require_relative '../model_config'
+
+module N2M
+  module Llm
+    class OpenRouter
+      API_URI = URI.parse('https://openrouter.ai/api/v1/chat/completions')
+
+      def initialize(config)
+        @config = config
+        @api_key = @config['access_key']
+        @site_url = @config['openrouter_site_url'] || '' # Optional: Read from config
+        @site_name = @config['openrouter_site_name'] || ''   # Optional: Read from config
+      end
+
+      def get_model_name
+        # Resolve model name using the centralized configuration
+        model_name = N2B::ModelConfig.resolve_model('openrouter', @config['model'])
+        if model_name.nil? || model_name.empty?
+          # Fallback to default if no model specified
+          model_name = N2B::ModelConfig.resolve_model('openrouter', N2B::ModelConfig.default_model('openrouter'))
+        end
+        model_name
+      end
+
+      def make_request(prompt_content)
+        request = Net::HTTP::Post.new(API_URI)
+        request.content_type = 'application/json'
+        request['Authorization'] = "Bearer #{@api_key}"
+
+        # Add OpenRouter specific headers
+        request['HTTP-Referer'] = @site_url unless @site_url.empty?
+        request['X-Title'] = @site_name unless @site_name.empty?
+
+        request.body = JSON.dump({
+          "model" => get_model_name,
+          "messages" => [
+            {
+              "role" => "user",
+              "content" => prompt_content
+            }
+          ]
+          # TODO: Consider adding max_tokens, temperature, etc. from @config if needed
+        })
+
+        response = Net::HTTP.start(API_URI.hostname, API_URI.port, use_ssl: true) do |http|
+          http.request(request)
+        end
+
+        if response.code != '200'
+          raise N2B::LlmApiError.new("LLM API Error: #{response.code} #{response.message} - #{response.body}")
+        end
+
+        # Assuming OpenRouter returns a similar structure to OpenAI for chat completions
+        answer_content = JSON.parse(response.body)['choices'].first['message']['content']
+
+        begin
+          # Attempt to parse the answer as JSON, as expected by the calling CLI's process_natural_language_command
+          parsed_answer = JSON.parse(answer_content)
+          # Ensure it has the 'commands' and 'explanation' structure if it's for n2b's command generation
+          # This might need adjustment based on how `make_request` is used.
+          # If it's just for generic requests, this parsing might be too specific.
+          # For now, mirroring the OpenAI class's attempt to parse JSON from the content.
+          if parsed_answer.is_a?(Hash) && parsed_answer.key?('commands')
+            parsed_answer
+          else
+            # If the content itself isn't the JSON structure n2b expects,
+            # but is valid JSON, return it. Otherwise, wrap it.
+            # This part needs to be robust based on actual OpenRouter responses.
+            { 'commands' => [answer_content], 'explanation' => 'Response from LLM.' } # Fallback
+          end
+        rescue JSON::ParserError
+          # If the content isn't JSON, wrap it in the expected structure for n2b
+          { 'commands' => [answer_content], 'explanation' => answer_content }
+        end
+      end
+
+      def analyze_code_diff(prompt_content)
+        request = Net::HTTP::Post.new(API_URI) # Chat completions endpoint
+        request.content_type = 'application/json'
+        request['Authorization'] = "Bearer #{@api_key}"
+
+        # Add OpenRouter specific headers
+        request['HTTP-Referer'] = @site_url unless @site_url.empty?
+        request['X-Title'] = @site_name unless @site_name.empty?
+
+        # The prompt_content for diff analysis should already instruct the LLM to return JSON.
+        request.body = JSON.dump({
+          "model" => get_model_name,
+          # "response_format" => { "type" => "json_object" }, # Some models on OpenRouter might support this
+          "messages" => [
+            {
+              "role" => "user",
+              "content" => prompt_content # This prompt should ask for JSON output
+            }
+          ],
+          "max_tokens" => @config['max_tokens'] || 2048 # Ensure enough tokens for JSON
+        })
+
+        response = Net::HTTP.start(API_URI.hostname, API_URI.port, use_ssl: true) do |http|
+          http.request(request)
+        end
+
+        if response.code != '200'
+          raise N2B::LlmApiError.new("LLM API Error: #{response.code} #{response.message} - #{response.body}")
+        end
+
+        # Return the raw JSON string from the LLM's response content.
+        # The calling method (call_llm_for_diff_analysis in cli.rb) will parse this.
+        JSON.parse(response.body)['choices'].first['message']['content']
+      end
+    end
+  end
+end

data/lib/n2b/model_config.rb

@@ -0,0 +1,112 @@
+require 'yaml'
+
+module N2B
+  class ModelConfig
+    CONFIG_PATH = File.expand_path('config/models.yml', __dir__)
+    
+    def self.load_models
+      @models ||= YAML.load_file(CONFIG_PATH)
+    rescue => e
+      puts "Warning: Could not load models configuration: #{e.message}"
+      puts "Using fallback model configuration."
+      fallback_models
+    end
+    
+    def self.fallback_models
+      {
+        'claude' => { 'suggested' => { 'sonnet' => 'claude-3-sonnet-20240229' }, 'default' => 'sonnet' },
+        'openai' => { 'suggested' => { 'gpt-4o-mini' => 'gpt-4o-mini' }, 'default' => 'gpt-4o-mini' },
+        'gemini' => { 'suggested' => { 'gemini-flash' => 'gemini-2.0-flash' }, 'default' => 'gemini-flash' },
+        'openrouter' => { 'suggested' => { 'gpt-4o' => 'openai/gpt-4o' }, 'default' => 'gpt-4o' },
+        'ollama' => { 'suggested' => { 'llama3' => 'llama3' }, 'default' => 'llama3' }
+      }
+    end
+    
+    def self.suggested_models(provider)
+      load_models.dig(provider, 'suggested') || {}
+    end
+    
+    def self.default_model(provider)
+      load_models.dig(provider, 'default')
+    end
+    
+    def self.resolve_model(provider, user_input)
+      return nil if user_input.nil? || user_input.empty?
+      
+      suggested = suggested_models(provider)
+      
+      # If user input matches a suggested model key, return the API name
+      if suggested.key?(user_input)
+        suggested[user_input]
+      else
+        # Otherwise, treat as custom model (return as-is)
+        user_input
+      end
+    end
+    
+    def self.display_model_options(provider)
+      suggested = suggested_models(provider)
+      default = default_model(provider)
+      
+      options = []
+      suggested.each_with_index do |(key, api_name), index|
+        default_marker = key == default ? " [default]" : ""
+        options << "#{index + 1}. #{key} (#{api_name})#{default_marker}"
+      end
+      options << "#{suggested.size + 1}. custom (enter your own model name)"
+      
+      options
+    end
+    
+    def self.get_model_choice(provider, current_model = nil)
+      options = display_model_options(provider)
+      suggested = suggested_models(provider)
+      default = default_model(provider)
+      
+      puts "\nChoose a model for #{provider}:"
+      options.each { |option| puts "  #{option}" }
+      
+      current_display = current_model || default
+      print "\nEnter choice (1-#{options.size}) or model name [#{current_display}]: "
+      
+      input = $stdin.gets.chomp
+      
+      # If empty input, use current or default
+      if input.empty?
+        return current_model || resolve_model(provider, default)
+      end
+      
+      # If numeric input, handle menu selection
+      if input.match?(/^\d+$/)
+        choice_num = input.to_i
+        if choice_num >= 1 && choice_num <= suggested.size
+          # Selected a suggested model
+          selected_key = suggested.keys[choice_num - 1]
+          return resolve_model(provider, selected_key)
+        elsif choice_num == suggested.size + 1
+          # Selected custom option
+          print "Enter custom model name: "
+          custom_model = $stdin.gets.chomp
+          if custom_model.empty?
+            puts "Custom model name cannot be empty. Using default."
+            return resolve_model(provider, default)
+          end
+          puts "✓ Using custom model: #{custom_model}"
+          return custom_model
+        else
+          puts "Invalid choice. Using default."
+          return resolve_model(provider, default)
+        end
+      else
+        # Direct model name input
+        resolved = resolve_model(provider, input)
+        if suggested.key?(input)
+          puts "✓ Using suggested model: #{input} (#{resolved})"
+        else
+          puts "✓ Using custom model: #{resolved}"
+        end
+        return resolved
+      end
+    end
+  end
+end

data/lib/n2b/version.rb

@@ -1,4 +1,4 @@
 # lib/n2b/version.rb
 module N2B
-  VERSION = "0.3.0"
+  VERSION = "0.4.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: n2b
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Stefan Nothegger
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-06-04 00:00:00.000000000 Z
+date: 2025-06-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -67,11 +67,15 @@ files:
 - lib/n2b.rb
 - lib/n2b/base.rb
 - lib/n2b/cli.rb
+- lib/n2b/config/models.yml
 - lib/n2b/errors.rb
 - lib/n2b/irb.rb
 - lib/n2b/llm/claude.rb
 - lib/n2b/llm/gemini.rb
+- lib/n2b/llm/ollama.rb
 - lib/n2b/llm/open_ai.rb
+- lib/n2b/llm/open_router.rb
+- lib/n2b/model_config.rb
 - lib/n2b/version.rb
 homepage: https://github.com/stefan-kp/n2b
 licenses:
@@ -95,7 +99,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.22
+rubygems_version: 3.5.3
 signing_key:
 specification_version: 4
 summary: Convert natural language to bash commands or ruby code and help with debugging.