n2b 0.3.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 644455363c88bf95c4ab4f21121ed6b8f56a591fb32bd1a8fa9f8f36d981e515
-  data.tar.gz: f899199e26524f38f88e4416217616c048e588c1f54becb228261b07ffcda3d1
+  metadata.gz: 58382cb632f67e6ad3ca031c71a2c53bd5cd477ea32963d89f0d253d8b43bbeb
+  data.tar.gz: facb990aad05d93cac662fdbf60075ad3606dd43083f408a8e0d60d5940df359
 SHA512:
-  metadata.gz: 2b3cfcba02a3c41017737317df2d932e1ff053c2d470c529a3158ccba11696ccf09367369f4530de78fc7669cc26795a3dad8abe49a26da0f5a8f836758baf4d
-  data.tar.gz: f664e6b0e9099aecc969e7d46a71b7cf7da0bf1238e9fbf203f445bed9d7073c2a643cce09a3a50fc1ce666805505c7e8d6222817a207fd3b4ec9491c8fcd4e4
+  metadata.gz: 8dd53c35513bf7071c5aecb7f724ebc44f522a166ef1ca8dc4aecfda3f9cd801dd7d85bce6762a4fc8bd5e1a98aa87eaa9e8080db3302a17d5875f8010b90867
+  data.tar.gz: 866846f2c517fe7dcee27172640151b1d6e567161b473a7c5a39c3894df15ea25b43e2278b24fd783f93c5eac8f507e7d331a85ef5fc5084990f89c227c19485

data/README.md

@@ -16,6 +16,15 @@ N2B (Natural Language to Bash & Ruby) is a Ruby gem that leverages AI to convert
 - **📊 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
 
 ```bash
@@ -61,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.
+
+### Quick Setup
 
-```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
+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
@@ -119,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`.
 

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

@@ -457,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}"
@@ -466,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
@@ -485,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
@@ -508,24 +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
-        # Check if response_json_str is already a Hash (parsed JSON)
-        if response_json_str.is_a?(Hash)
-          response_json_str
-        else
+        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 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
+      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

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.1"
+  VERSION = "0.4.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: n2b
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  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.