n2b 0.2.4 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bf304be008b27bf4336085ec39f75fc8ac5207c6e17d442d5129a366795629eb
-  data.tar.gz: f436a7dc4a59f2840b023d7e406aa5fa2aa02dee7ebb10f48c982efaaf489546
+  metadata.gz: 644455363c88bf95c4ab4f21121ed6b8f56a591fb32bd1a8fa9f8f36d981e515
+  data.tar.gz: f899199e26524f38f88e4416217616c048e588c1f54becb228261b07ffcda3d1
 SHA512:
-  metadata.gz: 770f49a5df340f3f9eae3f9072eafcbd9e8de6e2a5a227da3a96c67ebb22ca998411d1098921a375a9203fe446593ac8b15cfc3b6c6e6d13503a48957fed29c9
-  data.tar.gz: 88720e0bae3adf499830681214c142ea96787f3fbae01fcfe276593ce3860f65127783293cf2c1c993725747ad54165e260473f84d172fb290490165cd587708
+  metadata.gz: 2b3cfcba02a3c41017737317df2d932e1ff053c2d470c529a3158ccba11696ccf09367369f4530de78fc7669cc26795a3dad8abe49a26da0f5a8f836758baf4d
+  data.tar.gz: f664e6b0e9099aecc969e7d46a71b7cf7da0bf1238e9fbf203f445bed9d7073c2a643cce09a3a50fc1ce666805505c7e8d6222817a207fd3b4ec9491c8fcd4e4

data/README.md

@@ -6,10 +6,15 @@ 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
 
 ## Installation
 
@@ -56,29 +61,16 @@ n2rscrum "Create a user authentication system"
 
 ## Configuration
 
-Create a config file at `~/.n2b/config.yml` with your API keys. You can also use a custom config file by setting the `N2B_CONFIG_FILE` environment variable:
+Create a config file at `~/.n2b/config.yml` with your API keys:
 
-```bash
-export N2B_CONFIG_FILE=/path/to/your/config.yml
-```
-
-Example config file:
 ```yaml
-llm: claude  # or openai, gemini
+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
-gemini:
-  key: your-google-api-key
-  model: gemini-flash # uses gemini-2.0-flash model
-```
-
-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
@@ -148,6 +140,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
 
@@ -165,6 +160,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
@@ -253,4 +324,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/cli.rb

@@ -11,12 +11,191 @@ module N2B
 
     def execute
       config = get_config(reconfigure: @options[:config])
-      input_text = @args.join(' ')
-      if input_text.empty?
+      user_input = @args.join(' ') # All remaining args form user input/prompt addition
+
+      if @options[:diff]
+        handle_diff_analysis(config)
+      elsif user_input.empty? # No input text after options
         puts "Enter your natural language command:"
         input_text = $stdin.gets.chomp
+        process_natural_language_command(input_text, config)
+      else # Natural language command
+        process_natural_language_command(user_input, config)
+      end
+    end
+
+    protected
+
+    def handle_diff_analysis(config)
+      vcs_type = get_vcs_type
+      if vcs_type == :none
+        puts "Error: Not a git or hg repository."
+        exit 1
+      end
+
+      # Get requirements file from parsed options
+      requirements_filepath = @options[:requirements]
+      user_prompt_addition = @args.join(' ') # All remaining args are user prompt addition
+
+      requirements_content = nil
+      if requirements_filepath
+        unless File.exist?(requirements_filepath)
+          puts "Error: Requirements file not found: #{requirements_filepath}"
+          exit 1
+        end
+        requirements_content = File.read(requirements_filepath)
+      end
+
+      diff_output = execute_vcs_diff(vcs_type, @options[:branch])
+      analyze_diff(diff_output, config, user_prompt_addition, requirements_content)
+    end
+
+    def get_vcs_type
+      if Dir.exist?(File.join(Dir.pwd, '.git'))
+        :git
+      elsif Dir.exist?(File.join(Dir.pwd, '.hg'))
+        :hg
+      else
+        :none
+      end
+    end
+
+    def execute_vcs_diff(vcs_type, branch_option = nil)
+      case vcs_type
+      when :git
+        if branch_option
+          target_branch = branch_option == 'auto' ? detect_git_default_branch : branch_option
+          if target_branch
+            # Validate that the target branch exists
+            unless validate_git_branch_exists(target_branch)
+              puts "Error: Branch '#{target_branch}' does not exist."
+              puts "Available branches:"
+              puts `git branch -a`.lines.map(&:strip).reject(&:empty?)
+              exit 1
+            end
+
+            puts "Comparing current branch against '#{target_branch}'..."
+            `git diff #{target_branch}...HEAD`
+          else
+            puts "Could not detect default branch, falling back to HEAD diff..."
+            `git diff HEAD`
+          end
+        else
+          `git diff HEAD`
+        end
+      when :hg
+        if branch_option
+          target_branch = branch_option == 'auto' ? detect_hg_default_branch : branch_option
+          if target_branch
+            # Validate that the target branch exists
+            unless validate_hg_branch_exists(target_branch)
+              puts "Error: Branch '#{target_branch}' does not exist."
+              puts "Available branches:"
+              puts `hg branches`.lines.map(&:strip).reject(&:empty?)
+              exit 1
+            end
+
+            puts "Comparing current branch against '#{target_branch}'..."
+            `hg diff -r #{target_branch}`
+          else
+            puts "Could not detect default branch, falling back to standard diff..."
+            `hg diff`
+          end
+        else
+          `hg diff`
+        end
+      else
+        "" # Should not happen if get_vcs_type logic is correct and checked before calling
+      end
+    end
+
+    def detect_git_default_branch
+      # Try multiple methods to detect the default branch
+
+      # Method 1: Check origin/HEAD symbolic ref
+      result = `git symbolic-ref refs/remotes/origin/HEAD 2>/dev/null`.strip
+      if $?.success? && !result.empty?
+        return result.split('/').last
+      end
+
+      # Method 2: Check remote show origin
+      result = `git remote show origin 2>/dev/null | grep "HEAD branch"`.strip
+      if $?.success? && !result.empty?
+        match = result.match(/HEAD branch:\s*(\w+)/)
+        return match[1] if match
+      end
+
+      # Method 3: Check if common default branches exist
+      ['main', 'master'].each do |branch|
+        result = `git rev-parse --verify origin/#{branch} 2>/dev/null`
+        if $?.success?
+          return branch
+        end
       end
 
+      # Method 4: Fallback - check local branches
+      ['main', 'master'].each do |branch|
+        result = `git rev-parse --verify #{branch} 2>/dev/null`
+        if $?.success?
+          return branch
+        end
+      end
+
+      # If all else fails, return nil
+      nil
+    end
+
+    def detect_hg_default_branch
+      # Method 1: Check current branch (if it's 'default', that's the main branch)
+      result = `hg branch 2>/dev/null`.strip
+      if $?.success? && result == 'default'
+        return 'default'
+      end
+
+      # Method 2: Look for 'default' branch in branch list
+      result = `hg branches 2>/dev/null`
+      if $?.success? && result.include?('default')
+        return 'default'
+      end
+
+      # Method 3: Check if there are any branches at all
+      result = `hg branches 2>/dev/null`.strip
+      if $?.success? && !result.empty?
+        # Get the first branch (usually the main one)
+        first_branch = result.lines.first&.split&.first
+        return first_branch if first_branch
+      end
+
+      # Fallback to 'default' (standard hg main branch name)
+      'default'
+    end
+
+    def validate_git_branch_exists(branch)
+      # Check if branch exists locally
+      result = `git rev-parse --verify #{branch} 2>/dev/null`
+      return true if $?.success?
+
+      # Check if branch exists on remote
+      result = `git rev-parse --verify origin/#{branch} 2>/dev/null`
+      return true if $?.success?
+
+      false
+    end
+
+    def validate_hg_branch_exists(branch)
+      # Check if branch exists in hg branches
+      result = `hg branches 2>/dev/null`
+      if $?.success?
+        return result.lines.any? { |line| line.strip.start_with?(branch) }
+      end
+
+      # If we can't list branches, assume it exists (hg is more permissive)
+      true
+    end
+
+    private
+
+    def process_natural_language_command(input_text, config)
       bash_commands = call_llm(input_text, config)
 
       puts "\nTranslated #{get_user_shell} Commands:"
@@ -24,10 +203,10 @@ module N2B
       puts bash_commands['commands']
       puts "------------------------"
       if bash_commands['explanation']
-        puts "Explanation:" 
+        puts "Explanation:"
         puts bash_commands['explanation']
         puts "------------------------"
-      end 
+      end
 
       if @options[:execute]
         puts "Press Enter to execute these commands, or Ctrl+C to cancel."
@@ -38,9 +217,258 @@ module N2B
       end
     end
 
-    private
+    def build_diff_analysis_prompt(diff_output, user_prompt_addition = "", requirements_content = nil)
+      default_system_prompt = <<-SYSTEM_PROMPT.strip
+You are a senior software developer reviewing a code diff.
+Your task is to provide a constructive and detailed analysis of the changes.
+Focus on identifying potential bugs, suggesting improvements in code quality, style, performance, and security.
+Also, provide a concise summary of the changes.
 
-    
+IMPORTANT: When referring to specific issues or improvements, always include:
+- The exact file path (e.g., "lib/n2b/cli.rb")
+- The specific line numbers or line ranges (e.g., "line 42" or "lines 15-20")
+- The exact code snippet you're referring to when possible
+
+This helps users quickly locate and understand the issues you identify.
+
+SPECIAL FOCUS ON TEST COVERAGE:
+Pay special attention to whether the developer has provided adequate test coverage for the changes:
+- Look for new test files or modifications to existing test files
+- Check if new functionality has corresponding tests
+- Evaluate if edge cases and error conditions are tested
+- Assess if the tests are meaningful and comprehensive
+- Note any missing test coverage that should be added
+
+NOTE: In addition to the diff, you will also receive the current code context around the changed areas.
+This provides better understanding of the surrounding code and helps with more accurate analysis.
+The user may provide additional instructions or specific requirements below.
+SYSTEM_PROMPT
+
+      user_instructions_section = ""
+      unless user_prompt_addition.to_s.strip.empty?
+        user_instructions_section = "User Instructions:\n#{user_prompt_addition.strip}\n\n"
+      end
+
+      requirements_section = ""
+      if requirements_content && !requirements_content.to_s.strip.empty?
+        requirements_section = <<-REQUIREMENTS_BLOCK
+CRITICAL REQUIREMENTS EVALUATION:
+You must carefully evaluate whether the code changes meet the following requirements from the ticket/task.
+For each requirement, explicitly state whether it is:
+- ✅ IMPLEMENTED: The requirement is fully satisfied by the changes
+- ⚠️ PARTIALLY IMPLEMENTED: The requirement is partially addressed but needs more work
+- ❌ NOT IMPLEMENTED: The requirement is not addressed by these changes
+- 🔍 UNCLEAR: Cannot determine from the diff whether the requirement is met
+
+--- BEGIN REQUIREMENTS ---
+#{requirements_content.strip}
+--- END REQUIREMENTS ---
+
+REQUIREMENTS_BLOCK
+      end
+
+      analysis_intro = "Analyze the following diff based on the general instructions above and these specific requirements (if any):"
+
+      # Extract context around changed lines
+      context_sections = extract_code_context_from_diff(diff_output)
+      context_info = ""
+      unless context_sections.empty?
+        context_info = "\n\nCurrent Code Context (for better analysis):\n"
+        context_sections.each do |file_path, sections|
+          context_info += "\n--- #{file_path} ---\n"
+          sections.each do |section|
+            context_info += "Lines #{section[:start_line]}-#{section[:end_line]}:\n"
+            context_info += "```\n#{section[:content]}\n```\n\n"
+          end
+        end
+      end
+
+      json_instruction = <<-JSON_INSTRUCTION.strip
+CRITICAL: Return ONLY a valid JSON object with the keys "summary", "errors" (as a list of strings), "improvements" (as a list of strings), "test_coverage" (as a string), and "requirements_evaluation" (as a string, only if requirements were provided).
+Do not include any explanatory text before or after the JSON.
+Each error and improvement should include specific file paths and line numbers.
+
+Example format:
+{
+  "summary": "Brief description of the changes",
+  "errors": [
+    "lib/example.rb line 42: Potential null pointer exception when accessing user.name without checking if user is nil",
+    "src/main.js lines 15-20: Missing error handling for async operation"
+  ],
+  "improvements": [
+    "lib/example.rb line 30: Consider using a constant for the magic number 42",
+    "src/utils.py lines 5-10: This method could be simplified using list comprehension"
+  ],
+  "test_coverage": "Good: New functionality in lib/example.rb has corresponding tests in test/example_test.rb. Missing: No tests for error handling edge cases in the new validation method.",
+  "requirements_evaluation": "✅ IMPLEMENTED: User authentication feature is fully implemented in auth.rb. ⚠️ PARTIALLY IMPLEMENTED: Error handling is present but lacks specific error codes. ❌ NOT IMPLEMENTED: Email notifications are not addressed in this diff."
+}
+JSON_INSTRUCTION
+
+      full_prompt = [
+        default_system_prompt,
+        user_instructions_section,
+        requirements_section,
+        analysis_intro,
+        "Diff:\n```\n#{diff_output}\n```",
+        context_info,
+        json_instruction
+      ].select { |s| s && !s.empty? }.join("\n\n") # Join non-empty sections with double newlines
+
+      full_prompt
+    end
+
+    def analyze_diff(diff_output, config, user_prompt_addition = "", requirements_content = nil)
+      prompt = build_diff_analysis_prompt(diff_output, user_prompt_addition, requirements_content)
+      analysis_json_str = call_llm_for_diff_analysis(prompt, config)
+
+      begin
+        # Try to extract JSON from response that might have text before it
+        json_content = extract_json_from_response(analysis_json_str)
+        analysis_result = JSON.parse(json_content)
+
+        puts "\nCode Diff Analysis:"
+        puts "-------------------"
+        puts "Summary:"
+        puts analysis_result['summary'] || "No summary provided."
+        puts "\nPotential Errors:"
+        errors_list = analysis_result['errors']
+        errors_list = [errors_list] if errors_list.is_a?(String) && !errors_list.empty?
+        errors_list = [] if errors_list.nil? || (errors_list.is_a?(String) && errors_list.empty?)
+        puts errors_list.any? ? errors_list.map{|err| "- #{err}"}.join("\n") : "No errors identified."
+
+        puts "\nSuggested Improvements:"
+        improvements_list = analysis_result['improvements']
+        improvements_list = [improvements_list] if improvements_list.is_a?(String) && !improvements_list.empty?
+        improvements_list = [] if improvements_list.nil? || (improvements_list.is_a?(String) && improvements_list.empty?)
+        puts improvements_list.any? ? improvements_list.map{|imp| "- #{imp}"}.join("\n") : "No improvements suggested."
+
+        puts "\nTest Coverage Assessment:"
+        test_coverage = analysis_result['test_coverage']
+        puts test_coverage && !test_coverage.to_s.strip.empty? ? test_coverage : "No test coverage assessment provided."
+
+        # Show requirements evaluation if requirements were provided
+        requirements_eval = analysis_result['requirements_evaluation']
+        if requirements_eval && !requirements_eval.to_s.strip.empty?
+          puts "\nRequirements Evaluation:"
+          puts requirements_eval
+        end
+        puts "-------------------"
+      rescue JSON::ParserError => e # Handles cases where the JSON string (even fallback) is malformed
+        puts "Critical Error: Failed to parse JSON response for diff analysis: #{e.message}"
+        puts "Raw response was: #{analysis_json_str}"
+      end
+    end
+
+    def extract_json_from_response(response)
+      # First try to parse the response as-is
+      begin
+        JSON.parse(response)
+        return response
+      rescue JSON::ParserError
+        # If that fails, try to find JSON within the response
+      end
+
+      # Look for JSON object starting with { and ending with }
+      json_start = response.index('{')
+      return response unless json_start
+
+      # Find the matching closing brace
+      brace_count = 0
+      json_end = nil
+      (json_start...response.length).each do |i|
+        case response[i]
+        when '{'
+          brace_count += 1
+        when '}'
+          brace_count -= 1
+          if brace_count == 0
+            json_end = i
+            break
+          end
+        end
+      end
+
+      return response unless json_end
+
+      response[json_start..json_end]
+    end
+
+    def extract_code_context_from_diff(diff_output)
+      context_sections = {}
+      current_file = nil
+
+      diff_output.each_line do |line|
+        line = line.chomp
+
+        # Parse file headers (e.g., "diff --git a/lib/n2b/cli.rb b/lib/n2b/cli.rb")
+        if line.start_with?('diff --git')
+          # Extract file path from "diff --git a/path b/path"
+          match = line.match(/diff --git a\/(.+) b\/(.+)/)
+          current_file = match[2] if match # Use the "b/" path (new file)
+        elsif line.start_with?('+++')
+          # Alternative way to get file path from "+++ b/path"
+          match = line.match(/\+\+\+ b\/(.+)/)
+          current_file = match[1] if match
+        elsif line.start_with?('@@') && current_file
+          # Parse hunk header (e.g., "@@ -10,7 +10,8 @@")
+          match = line.match(/@@ -(\d+),?\d* \+(\d+),?\d* @@/)
+          if match
+            old_start = match[1].to_i
+            new_start = match[2].to_i
+
+            # Use the new file line numbers for context
+            context_start = [new_start - 5, 1].max  # 5 lines before, but not less than 1
+            context_end = new_start + 10  # 10 lines after the start
+
+            # Read the actual file content
+            if File.exist?(current_file)
+              file_lines = File.readlines(current_file)
+              # Adjust end to not exceed file length
+              context_end = [context_end, file_lines.length].min
+
+              if context_start <= file_lines.length
+                context_content = file_lines[(context_start-1)...context_end].map.with_index do |content, idx|
+                  line_num = context_start + idx
+                  "#{line_num.to_s.rjust(4)}: #{content.rstrip}"
+                end.join("\n")
+
+                context_sections[current_file] ||= []
+                context_sections[current_file] << {
+                  start_line: context_start,
+                  end_line: context_end,
+                  content: context_content
+                }
+              end
+            end
+          end
+        end
+      end
+
+      context_sections
+    end
+
+    def call_llm_for_diff_analysis(prompt, config)
+      begin
+        llm_service_name = config['llm']
+        llm = case llm_service_name
+              when 'openai'
+                N2M::Llm::OpenAi.new(config)
+              when 'claude'
+                N2M::Llm::Claude.new(config)
+              when 'gemini'
+                N2M::Llm::Gemini.new(config)
+              else
+                # Should not happen if config is validated, but as a safeguard:
+                raise N2B::Error, "Unsupported LLM service: #{llm_service_name}"
+              end
+
+        response_json_str = llm.analyze_code_diff(prompt) # Call the new dedicated method
+        response_json_str
+      rescue N2B::LlmApiError => e # This catches errors from analyze_code_diff
+        puts "Error communicating with the LLM: #{e.message}"
+        return '{"summary": "Error: Could not analyze diff due to LLM API error.", "errors": [], "improvements": []}'
+      end
+    end
     
     def append_to_llm_history_file(commands)
       File.open(HISTORY_FILE, 'a') do |file|
@@ -56,10 +484,11 @@ module N2B
     end
     
     def call_llm(prompt, config)
-      
-      llm = config['llm'] == 'openai' ?   N2M::Llm::OpenAi.new(config) : N2M::Llm::Claude.new(config)
-      
-      content = <<-EOF 
+      begin # Added begin for LlmApiError rescue
+        llm = config['llm'] == 'openai' ?   N2M::Llm::OpenAi.new(config) : N2M::Llm::Claude.new(config)
+
+        # This content is specific to bash command generation
+      content = <<-EOF
               Translate the following natural language command to bash commands: #{prompt}\n\nProvide only the #{get_user_shell} commands for #{ get_user_os }. the commands should be separated by newlines. 
               #{' the user is in directory'+Dir.pwd if config['privacy']['send_current_directory']}. 
               #{' the user sent past requests to you and got these answers '+read_llm_history_file if config['privacy']['send_llm_history'] }
@@ -70,10 +499,33 @@ module N2B
               EOF
     
            
-      answer = llm.make_request(content)
+      response_json_str = llm.make_request(content)
 
-      append_to_llm_history_file("#{prompt}\n#{answer}")
-      answer
+      append_to_llm_history_file("#{prompt}\n#{response_json_str}") # Storing the raw JSON string
+      # The original call_llm was expected to return a hash after JSON.parse,
+      # but it was actually returning the string. Let's assume it should return a parsed Hash.
+      # However, the calling method `process_natural_language_command` accesses it like `bash_commands['commands']`
+      # which implies it expects a Hash. Let's ensure call_llm returns a Hash.
+      # This internal JSON parsing is for the *content* of a successful LLM response.
+      # The LlmApiError for network/auth issues should be caught before this.
+      begin
+        # Check if response_json_str is already a Hash (parsed JSON)
+        if response_json_str.is_a?(Hash)
+          response_json_str
+        else
+          parsed_response = JSON.parse(response_json_str)
+          parsed_response
+        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
     end
     
     def get_user_shell
@@ -165,15 +617,27 @@ module N2B
     
 
     def parse_options
-      options = { execute: false, config: nil }
+      options = { execute: false, config: nil, diff: false, requirements: nil, branch: nil }
 
-      OptionParser.new do |opts|
+      parser = OptionParser.new do |opts|
         opts.banner = "Usage: n2b [options] [natural language command]"
 
         opts.on('-x', '--execute', 'Execute the commands after confirmation') do
           options[:execute] = true
         end
 
+        opts.on('-d', '--diff', 'Analyze git/hg diff with AI') do
+          options[:diff] = true
+        end
+
+        opts.on('-b', '--branch [BRANCH]', 'Compare against branch (default: auto-detect main/master)') do |branch|
+          options[:branch] = branch || 'auto'
+        end
+
+        opts.on('-r', '--requirements FILE', 'Requirements file for diff analysis') do |file|
+          options[:requirements] = file
+        end
+
         opts.on('-h', '--help', 'Print this help') do
           puts opts
           exit
@@ -182,7 +646,24 @@ module N2B
         opts.on('-c', '--config', 'Configure the API key and model') do
           options[:config] = true
         end
-      end.parse!(@args)
+      end
+
+      begin
+        parser.parse!(@args)
+      rescue OptionParser::InvalidOption => e
+        puts "Error: #{e.message}"
+        puts ""
+        puts parser.help
+        exit 1
+      end
+
+      # Validate option combinations
+      if options[:branch] && !options[:diff]
+        puts "Error: --branch option can only be used with --diff"
+        puts ""
+        puts parser.help
+        exit 1
+      end
 
       options
     end

data/lib/n2b/errors.rb

@@ -0,0 +1,7 @@
+module N2B
+  class Error < StandardError
+  end
+
+  class LlmApiError < Error
+  end
+end

data/lib/n2b/llm/claude.rb

@@ -31,12 +31,12 @@ module N2M
         end
         # check for errors
         if response.code != '200'
-          puts "Error: #{response.code} #{response.message}"
-          puts response.body
-          exit 1
+          raise N2B::LlmApiError.new("LLM API Error: #{response.code} #{response.message} - #{response.body}")
         end
         answer = JSON.parse(response.body)['content'].first['text'] 
         begin 
+          # The llm_response.json file is likely for debugging and can be kept or removed.
+          # For this refactoring, I'll keep it as it doesn't affect the error handling logic.
           File.open('llm_response.json', 'w') do |f|
             f.write(answer)
           end
@@ -46,16 +46,54 @@ module N2M
           # gsub all \n with \\n that are inside "
           # 
           answer.gsub!(/"([^"]*)"/) { |match| match.gsub(/\n/, "\\n") }
+          # The llm_response.json file is likely for debugging and can be kept or removed.
           File.open('llm_response.json', 'w') do |f|
             f.write(answer)
           end
           answer = JSON.parse(answer)
         rescue JSON::ParserError
-          puts "Error parsing JSON: #{answer}"
-          answer = { 'explanation' => answer}
+          # This specific JSON parsing error is about the LLM's *response content*, not an API error.
+          # It should probably be handled differently, but the subtask is about LlmApiError.
+          # For now, keeping existing behavior for this part.
+          puts "Error parsing JSON from LLM response: #{answer}" # Clarified error message
+          answer = { 'explanation' => answer} # Default fallback
         end
         answer
       end
+
+      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).
+        uri = URI.parse('https://api.anthropic.com/v1/messages')
+        request = Net::HTTP::Post.new(uri)
+        request.content_type = 'application/json'
+        request['X-API-Key'] = @config['access_key']
+        request['anthropic-version'] = '2023-06-01'
+
+        request.body = JSON.dump({
+          "model" => MODELS[@config['model']],
+          "max_tokens" => @config['max_tokens'] || 1024, # Allow overriding max_tokens from config
+          "messages" => [
+            {
+              "role" => "user", # The entire prompt is passed as a single user message
+              "content" => prompt_content
+            }
+          ]
+        })
+
+        response = Net::HTTP.start(uri.hostname, 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. CLI's call_llm_for_diff_analysis will handle parsing.
+        # The Claude API for messages returns the analysis in response.body['content'].first['text']
+        # which should itself be a JSON string as per our prompt's instructions.
+        JSON.parse(response.body)['content'].first['text']
+      end
     end 
   end
 end

data/lib/n2b/llm/gemini.rb

@@ -35,10 +35,7 @@ module N2M
 
         # check for errors
         if response.code != '200'
-          puts "Error: #{response.code} #{response.message}"
-          puts response.body
-          puts "Config: #{@config.inspect}"
-          exit 1
+          raise N2B::LlmApiError.new("LLM API Error: #{response.code} #{response.message} - #{response.body}")
         end
 
         parsed_response = JSON.parse(response.body)
@@ -64,6 +61,43 @@ module N2M
         end
         answer
       end
+
+      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
+        uri = URI.parse("#{API_URI}/#{model}:generateContent?key=#{@config['access_key']}")
+
+        request = Net::HTTP::Post.new(uri)
+        request.content_type = 'application/json'
+
+        request.body = JSON.dump({
+          "contents" => [{
+            "parts" => [{
+              "text" => prompt_content # The entire prompt is passed as text
+            }]
+          }],
+          # Gemini specific: Ensure JSON output if possible via generationConfig
+          # However, the primary method is instructing it within the prompt itself.
+          # "generationConfig": {
+          #   "responseMimeType": "application/json", # This might be too restrictive or not always work as expected
+          # }
+        })
+
+        response = Net::HTTP.start(uri.hostname, 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
+
+        parsed_response = JSON.parse(response.body)
+        # Return the raw JSON string. CLI's call_llm_for_diff_analysis will handle parsing.
+        # The Gemini API returns the analysis in parsed_response['candidates'].first['content']['parts'].first['text']
+        # which should itself be a JSON string as per our prompt's instructions.
+        parsed_response['candidates'].first['content']['parts'].first['text']
+      end
     end
   end
 end 

data/lib/n2b/llm/open_ai.rb

@@ -33,9 +33,7 @@ module N2M
 
         # check for errors
         if response.code != '200'
-          puts "Error: #{response.code} #{response.message}"
-          puts response.body
-          exit 1
+          raise N2B::LlmApiError.new("LLM API Error: #{response.code} #{response.message} - #{response.body}")
         end
         answer = JSON.parse(response.body)['choices'].first['message']['content']
         begin
@@ -47,6 +45,38 @@ module N2M
         end
         answer
       end
+
+      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).
+        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']],
+          "response_format" => { "type" => "json_object" }, # Crucial for OpenAI to return JSON
+          "messages" => [
+            {
+              "role" => "user", # The entire prompt is passed as a single user message
+              "content" => prompt_content
+            }
+          ],
+          "max_tokens" => @config['max_tokens'] || 1500 # Allow overriding, ensure it's enough 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. CLI's call_llm_for_diff_analysis will handle parsing.
+        # OpenAI with json_object mode should return the JSON directly in 'choices'.first.message.content
+        JSON.parse(response.body)['choices'].first['message']['content']
+      end
     end
   end
 end

data/lib/n2b/version.rb

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

data/lib/n2b.rb

@@ -9,12 +9,12 @@ require 'n2b/version'
 require 'n2b/llm/claude'
 require 'n2b/llm/open_ai'
 require 'n2b/llm/gemini'
+require 'n2b/errors' # Load custom errors
 require 'n2b/base'
 require 'n2b/cli'
 
 require 'n2b/irb'
 
 module N2B
-  class Error < StandardError; end
-
+  # Error class is now defined in n2b/errors.rb
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: n2b
 version: !ruby/object:Gem::Version
-  version: 0.2.4
+  version: 0.3.1
 platform: ruby
 authors:
 - Stefan Nothegger
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-03-21 00:00:00.000000000 Z
+date: 2025-06-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -67,6 +67,7 @@ files:
 - lib/n2b.rb
 - lib/n2b/base.rb
 - lib/n2b/cli.rb
+- lib/n2b/errors.rb
 - lib/n2b/irb.rb
 - lib/n2b/llm/claude.rb
 - lib/n2b/llm/gemini.rb
@@ -94,7 +95,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.3
+rubygems_version: 3.5.22
 signing_key:
 specification_version: 4
 summary: Convert natural language to bash commands or ruby code and help with debugging.