n2b 0.3.1 → 0.5.0

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,139 @@
+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 - validate it first
+        if is_valid_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
+        else
+          puts "Invalid model name '#{input}'. Model names should be meaningful (at least 3 characters, no single letters)."
+          puts "Using default model instead."
+          return resolve_model(provider, default)
+        end
+      end
+    end
+
+    private
+
+    def self.is_valid_model_name?(input)
+      return false if input.nil? || input.empty?
+
+      # Reject single characters (like 'y', 'n', etc.)
+      return false if input.length == 1
+
+      # Reject very short inputs that are likely not model names
+      return false if input.length < 3
+
+      # Reject common boolean/confirmation inputs
+      return false if %w[y n yes no true false].include?(input.downcase)
+
+      # Reject inputs that are just numbers
+      return false if input.match?(/^\d+$/)
+
+      # Accept anything else as potentially valid
+      true
+    end
+  end
+end

data/lib/n2b/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: n2b
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.5.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
@@ -64,22 +64,28 @@ extra_rdoc_files: []
 files:
 - README.md
 - bin/n2b
+- bin/n2b-test-jira
 - 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/jira_client.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:
 - MIT
 metadata:
-  homepage_uri: https://github.com/stefan-kp/n2b
   source_code_uri: https://github.com/stefan-kp/n2b
   changelog_uri: https://github.com/stefan-kp/n2b/blob/main/CHANGELOG.md
+  documentation_uri: https://github.com/stefan-kp/n2b/blob/main/README.md
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -95,7 +101,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.