n2b 0.5.1 → 0.7.1

data/lib/n2b/cli.rb

@@ -316,32 +316,9 @@ module N2B
       end
     end
 
-    def build_diff_analysis_prompt(diff_output, user_prompt_addition = "", requirements_content = nil)
-      default_system_prompt = <<-SYSTEM_PROMPT.strip
-You are a senior software developer reviewing a code diff.
-Your task is to provide a constructive and detailed analysis of the changes.
-Focus on identifying potential bugs, suggesting improvements in code quality, style, performance, and security.
-Also, provide a concise summary of the changes.
-
-IMPORTANT: When referring to specific issues or improvements, always include:
-- The exact file path (e.g., "lib/n2b/cli.rb")
-- The specific line numbers or line ranges (e.g., "line 42" or "lines 15-20")
-- The exact code snippet you're referring to when possible
-
-This helps users quickly locate and understand the issues you identify.
-
-SPECIAL FOCUS ON TEST COVERAGE:
-Pay special attention to whether the developer has provided adequate test coverage for the changes:
-- Look for new test files or modifications to existing test files
-- Check if new functionality has corresponding tests
-- Evaluate if edge cases and error conditions are tested
-- Assess if the tests are meaningful and comprehensive
-- Note any missing test coverage that should be added
-
-NOTE: In addition to the diff, you will also receive the current code context around the changed areas.
-This provides better understanding of the surrounding code and helps with more accurate analysis.
-The user may provide additional instructions or specific requirements below.
-SYSTEM_PROMPT
+    def build_diff_analysis_prompt(diff_output, user_prompt_addition = "", requirements_content = nil, config = {})
+      default_system_prompt_path = resolve_template_path('diff_system_prompt', config)
+      default_system_prompt = File.read(default_system_prompt_path).strip
 
       user_instructions_section = ""
       unless user_prompt_addition.to_s.strip.empty?
@@ -382,35 +359,8 @@ REQUIREMENTS_BLOCK
         end
       end
 
-      json_instruction = <<-JSON_INSTRUCTION.strip
-CRITICAL: Return ONLY a valid JSON object.
-Do not include any explanatory text before or after the JSON.
-Each error and improvement should include specific file paths and line numbers.
-
-The JSON object must contain the following keys:
-- "summary": (string) Brief overall description of the changes.
-- "ticket_implementation_summary": (string) A concise summary of what was implemented or achieved in relation to the ticket's goals, based *only* on the provided diff. This is for developer status updates and Jira comments.
-- "errors": (list of strings) Potential bugs or issues found.
-- "improvements": (list of strings) Suggestions for code quality, style, performance, or security.
-- "test_coverage": (string) Assessment of test coverage for the changes.
-- "requirements_evaluation": (string, include only if requirements were provided in the prompt) Evaluation of how the changes meet the provided requirements.
-
-Example format:
-{
-  "summary": "Refactored the user authentication module and added password complexity checks.",
-  "ticket_implementation_summary": "Implemented the core logic for user password updates and strengthened security by adding complexity validation as per the ticket's primary goal. Some UI elements are pending.",
-  "errors": [
-    "lib/example.rb line 42: Potential null pointer exception when accessing user.name without checking if user is nil.",
-    "src/main.js lines 15-20: Missing error handling for async operation."
-  ],
-  "improvements": [
-    "lib/example.rb line 30: Consider using a constant for the magic number 42.",
-    "src/utils.py lines 5-10: This method could be simplified using list comprehension."
-  ],
-  "test_coverage": "Good: New functionality in lib/example.rb has corresponding tests in test/example_test.rb. Missing: No tests for error handling edge cases in the new validation method.",
-  "requirements_evaluation": "✅ IMPLEMENTED: User authentication feature is fully implemented in auth.rb. ⚠️ PARTIALLY IMPLEMENTED: Error handling is present but lacks specific error codes. ❌ NOT IMPLEMENTED: Email notifications are not addressed in this diff."
-}
-JSON_INSTRUCTION
+      json_instruction_path = resolve_template_path('diff_json_instruction', config)
+      json_instruction = File.read(json_instruction_path).strip
 
       full_prompt = [
         default_system_prompt,
@@ -426,7 +376,7 @@ JSON_INSTRUCTION
     end
 
     def analyze_diff(diff_output, config, user_prompt_addition = "", requirements_content = nil)
-      prompt = build_diff_analysis_prompt(diff_output, user_prompt_addition, requirements_content)
+      prompt = build_diff_analysis_prompt(diff_output, user_prompt_addition, requirements_content, config)
       analysis_json_str = call_llm_for_diff_analysis(prompt, config)
 
       begin
@@ -607,7 +557,8 @@ JSON_INSTRUCTION
                 raise N2B::Error, "Unsupported LLM service: #{llm_service_name}"
               end
 
-        response_json_str = llm.analyze_code_diff(prompt) # Call the new dedicated method
+        puts "🔍 AI is analyzing your code diff..."
+        response_json_str = analyze_diff_with_spinner(llm, prompt)
         response_json_str
       rescue N2B::LlmApiError => e # This catches errors from analyze_code_diff
         puts "Error communicating with the LLM: #{e.message}"
@@ -667,23 +618,37 @@ JSON_INSTRUCTION
               EOF
     
            
-      response_json_str = llm.make_request(content)
-
-      append_to_llm_history_file("#{prompt}\n#{response_json_str}") # Storing the raw JSON string
-      # The original call_llm was expected to return a hash after JSON.parse,
-      # but it was actually returning the string. Let's assume it should return a parsed Hash.
-      # However, the calling method `process_natural_language_command` accesses it like `bash_commands['commands']`
-      # which implies it expects a Hash. Let's ensure call_llm returns a Hash.
-      # This internal JSON parsing is for the *content* of a successful LLM response.
-      # The LlmApiError for network/auth issues should be caught before this.
+      puts "🤖 AI is generating commands..."
+      response = make_request_with_spinner(llm, content)
+
+      # Handle both Hash (from JSON mode providers) and String responses
+      if response.is_a?(Hash)
+        # Already parsed by the LLM provider
+        parsed_response = response
+        response_str = response.to_json # For history logging
+      else
+        # String response that needs parsing
+        response_str = response
         begin
-          parsed_response = JSON.parse(response_json_str)
-          parsed_response
+          parsed_response = JSON.parse(response_str)
         rescue JSON::ParserError => e
-          puts "Error parsing LLM response JSON for command generation: #{e.message}"
-          # This is a fallback for when the LLM response *content* is not valid JSON.
-          { "commands" => ["echo 'Error: LLM returned invalid JSON content.'"], "explanation" => "The response from the language model was not valid JSON." }
+          puts "⚠️  Invalid JSON detected, attempting automatic repair..."
+          repaired_response = attempt_json_repair_for_commands(response_str, llm)
+
+          if repaired_response
+            puts "✅ JSON repair successful!"
+            parsed_response = repaired_response
+          else
+            puts "❌ JSON repair failed"
+            puts "Error parsing LLM response JSON for command generation: #{e.message}"
+            # This is a fallback for when the LLM response *content* is not valid JSON.
+            parsed_response = { "commands" => ["echo 'Error: LLM returned invalid JSON content.'"], "explanation" => "The response from the language model was not valid JSON." }
+          end
         end
+      end
+
+      append_to_llm_history_file("#{prompt}\n#{response_str}") # Storing the response for history
+      parsed_response
       rescue N2B::LlmApiError => e
         puts "Error communicating with the LLM: #{e.message}"
 
@@ -784,7 +749,102 @@ JSON_INSTRUCTION
       end
       system("history -r") # Attempt to reload history in current session
     end
-    
+
+    def resolve_template_path(template_key, config)
+      user_path = config.dig('templates', template_key) if config.is_a?(Hash)
+      return user_path if user_path && File.exist?(user_path)
+
+      File.expand_path(File.join(__dir__, 'templates', "#{template_key}.txt"))
+    end
+
+    def make_request_with_spinner(llm, content)
+      spinner_chars = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏']
+      spinner_thread = Thread.new do
+        i = 0
+        while true
+          print "\r⠿ #{spinner_chars[i % spinner_chars.length]} Processing..."
+          $stdout.flush
+          sleep(0.1)
+          i += 1
+        end
+      end
+
+      begin
+        result = llm.make_request(content)
+        spinner_thread.kill
+        print "\r#{' ' * 25}\r"  # Clear the spinner line
+        puts "✅ Commands generated!"
+        result
+      rescue => e
+        spinner_thread.kill
+        print "\r#{' ' * 25}\r"  # Clear the spinner line
+        raise e
+      end
+    end
+
+    def analyze_diff_with_spinner(llm, prompt)
+      spinner_chars = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏']
+      spinner_thread = Thread.new do
+        i = 0
+        while true
+          print "\r🔍 #{spinner_chars[i % spinner_chars.length]} Analyzing diff..."
+          $stdout.flush
+          sleep(0.1)
+          i += 1
+        end
+      end
+
+      begin
+        result = llm.analyze_code_diff(prompt)
+        spinner_thread.kill
+        print "\r#{' ' * 30}\r"  # Clear the spinner line
+        puts "✅ Diff analysis complete!"
+        result
+      rescue => e
+        spinner_thread.kill
+        print "\r#{' ' * 30}\r"  # Clear the spinner line
+        raise e
+      end
+    end
+
+    def attempt_json_repair_for_commands(malformed_response, llm)
+      repair_prompt = <<~PROMPT
+        The following response was supposed to be valid JSON with keys "commands" (array) and "explanation" (string), but it has formatting issues. Please fix it and return ONLY the corrected JSON:
+
+        Original response:
+        #{malformed_response}
+
+        Requirements:
+        - Must be valid JSON
+        - Must have "commands" key with array of command strings
+        - Must have "explanation" key with explanation text
+        - Return ONLY the JSON, no other text
+
+        Fixed JSON:
+      PROMPT
+
+      begin
+        puts "🔧 Asking AI to fix the JSON..."
+        repaired_json_str = llm.make_request(repair_prompt)
+
+        # Handle both Hash and String responses
+        if repaired_json_str.is_a?(Hash)
+          repaired_response = repaired_json_str
+        else
+          repaired_response = JSON.parse(repaired_json_str)
+        end
+
+        # Validate the repaired response structure
+        if repaired_response.is_a?(Hash) && repaired_response.key?('commands') && repaired_response.key?('explanation')
+          return repaired_response
+        else
+          return nil
+        end
+      rescue JSON::ParserError, StandardError
+        return nil
+      end
+    end
+
 
     def parse_options
       options = {
@@ -834,6 +894,11 @@ JSON_INSTRUCTION
           exit
         end
 
+        opts.on('-v', '--version', 'Show version') do
+          puts "n2b version #{N2B::VERSION}"
+          exit
+        end
+
         opts.on('-c', '--config', 'Configure the API key and model') do
           options[:config] = true
         end

data/lib/n2b/jira_client.rb

@@ -67,9 +67,12 @@ module N2B
 
       puts "Updating Jira ticket #{ticket_key} with analysis comment..."
 
+      # Generate comment using template system
+      template_comment = generate_templated_comment(comment)
+
       # Prepare the comment body in Jira's Atlassian Document Format (ADF)
       comment_body = {
-        "body" => format_comment_as_adf(comment)
+        "body" => format_comment_as_adf(template_comment)
       }
 
       # Make the API call to add a comment
@@ -396,26 +399,383 @@ module N2B
       end
     end
 
-    private
+    def generate_templated_comment(comment_data)
+      # Prepare template data from the analysis results
+      template_data = prepare_template_data(comment_data)
 
-    def format_comment_as_adf(comment_data)
-      # If comment_data is a string (legacy), convert to simple ADF
+      # Load and render template
+      config = get_config(reconfigure: false, advanced_flow: false)
+      template_path = resolve_template_path('jira_comment', config)
+      template_content = File.read(template_path)
+
+      engine = N2B::TemplateEngine.new(template_content, template_data)
+      engine.render
+    end
+
+    def prepare_template_data(comment_data)
+      # Handle both string and hash inputs
       if comment_data.is_a?(String)
+        # For simple string comments, create a basic template data structure
+        git_info = extract_git_info
         return {
-          "type" => "doc",
-          "version" => 1,
-          "content" => [
-            {
-              "type" => "paragraph",
-              "content" => [
-                {
-                  "type" => "text",
-                  "text" => comment_data
-                }
-              ]
-            }
-          ]
+          'implementation_summary' => comment_data,
+          'critical_errors' => [],
+          'important_errors' => [],
+          'improvements' => [],
+          'missing_tests' => [],
+          'requirements' => [],
+          'test_coverage_summary' => "No specific test coverage analysis available",
+          'timestamp' => Time.now.strftime("%Y-%m-%d %H:%M UTC"),
+          'branch_name' => git_info[:branch],
+          'files_changed' => git_info[:files_changed],
+          'lines_added' => git_info[:lines_added],
+          'lines_removed' => git_info[:lines_removed],
+          'critical_errors_empty' => true,
+          'important_errors_empty' => true,
+          'improvements_empty' => true,
+          'missing_tests_empty' => true
+        }
+      end
+
+      # Handle hash input (structured analysis data)
+      # Extract and classify errors by severity
+      errors = comment_data[:issues] || comment_data['issues'] || []
+      critical_errors = []
+      important_errors = []
+      low_errors = []
+
+      errors.each do |error|
+        severity = classify_error_severity(error)
+        file_ref = extract_file_reference(error)
+
+        error_item = {
+          'file_reference' => file_ref,
+          'description' => clean_error_description(error),
+          'severity' => severity
         }
+
+        case severity
+        when 'CRITICAL'
+          critical_errors << error_item
+        when 'IMPORTANT'
+          important_errors << error_item
+        else
+          low_errors << error_item
+        end
+      end
+
+      # Process improvements
+      improvements = (comment_data[:improvements] || comment_data['improvements'] || []).map do |improvement|
+        {
+          'file_reference' => extract_file_reference(improvement),
+          'description' => clean_error_description(improvement)
+        }
+      end
+
+      # Process missing tests
+      missing_tests = extract_missing_tests(comment_data[:test_coverage] || comment_data['test_coverage'] || "")
+
+      # Process requirements
+      requirements = extract_requirements_status(comment_data[:requirements_evaluation] || comment_data['requirements_evaluation'] || "")
+
+      # Get git/hg info
+      git_info = extract_git_info
+
+      {
+        'implementation_summary' => comment_data[:implementation_summary] || comment_data['implementation_summary'] || "Code analysis completed",
+        'critical_errors' => critical_errors,
+        'important_errors' => important_errors,
+        'improvements' => improvements,
+        'missing_tests' => missing_tests,
+        'requirements' => requirements,
+        'test_coverage_summary' => comment_data[:test_coverage] || comment_data['test_coverage'] || "No specific test coverage analysis available",
+        'timestamp' => Time.now.strftime("%Y-%m-%d %H:%M UTC"),
+        'branch_name' => git_info[:branch],
+        'files_changed' => git_info[:files_changed],
+        'lines_added' => git_info[:lines_added],
+        'lines_removed' => git_info[:lines_removed],
+        'critical_errors_empty' => critical_errors.empty?,
+        'important_errors_empty' => important_errors.empty?,
+        'improvements_empty' => improvements.empty?,
+        'missing_tests_empty' => missing_tests.empty?
+      }
+    end
+
+    def classify_error_severity(error_text)
+      text = error_text.downcase
+      case text
+      when /security|sql injection|xss|csrf|vulnerability|exploit|attack/
+        'CRITICAL'
+      when /performance|n\+1|timeout|memory leak|slow query|bottleneck/
+        'IMPORTANT'
+      when /error|exception|bug|fail|crash|break/
+        'IMPORTANT'
+      when /style|convention|naming|format|indent|space/
+        'LOW'
+      else
+        'IMPORTANT'
+      end
+    end
+
+    def extract_file_reference(text)
+      # Parse various file reference formats
+      if match = text.match(/(\S+\.(?:rb|js|py|java|cpp|c|h|ts|jsx|tsx|php|go|rs|swift|kt))(?:\s+(?:line|lines?)\s+(\d+(?:-\d+)?)|:(\d+(?:-\d+)?)|\s*\(line\s+(\d+)\))?/i)
+        file = match[1]
+        line = match[2] || match[3] || match[4]
+        line ? "*#{file}:#{line}*" : "*#{file}*"
+      else
+        "*General*"
+      end
+    end
+
+    def clean_error_description(text)
+      # Remove file references from description to avoid duplication
+      text.gsub(/\S+\.(?:rb|js|py|java|cpp|c|h|ts|jsx|tsx|php|go|rs|swift|kt)(?:\s+(?:line|lines?)\s+\d+(?:-\d+)?|:\d+(?:-\d+)?|\s*\(line\s+\d+\))?:?\s*/i, '').strip
+    end
+
+    def extract_missing_tests(test_coverage_text)
+      # Extract test-related items from coverage analysis
+      missing_tests = []
+
+      # Look for common patterns indicating missing tests
+      test_coverage_text.scan(/(?:missing|need|add|require).*?test.*?(?:\.|$)/i) do |match|
+        missing_tests << { 'description' => match.strip }
+      end
+
+      # If no specific missing tests found, create generic ones based on coverage
+      if missing_tests.empty? && test_coverage_text.include?('%')
+        if coverage_match = test_coverage_text.match(/(\d+)%/)
+          coverage = coverage_match[1].to_i
+          if coverage < 80
+            missing_tests << { 'description' => "Increase test coverage from #{coverage}% to target 80%+" }
+          end
+        end
+      end
+
+      missing_tests
+    end
+
+    def extract_requirements_status(requirements_text)
+      requirements = []
+
+      # Split by lines and process each line
+      requirements_text.split("\n").each do |line|
+        line = line.strip
+        next if line.empty?
+
+        # Parse requirements with status indicators - order matters for regex matching
+        if match = line.match(/(✅|⚠️|❌|🔍)?\s*(PARTIALLY\s+IMPLEMENTED|NOT\s+IMPLEMENTED|IMPLEMENTED|UNCLEAR)?:?\s*(.+)/i)
+          status_emoji, status_text, description = match.captures
+        status = case
+                when status_text&.include?('PARTIALLY')
+                  'PARTIALLY_IMPLEMENTED'
+                when status_text&.include?('NOT')
+                  'NOT_IMPLEMENTED'
+                when status_emoji == '✅' || (status_text&.include?('IMPLEMENTED') && !status_text&.include?('NOT') && !status_text&.include?('PARTIALLY'))
+                  'IMPLEMENTED'
+                when status_emoji == '⚠️'
+                  'PARTIALLY_IMPLEMENTED'
+                when status_emoji == '❌'
+                  'NOT_IMPLEMENTED'
+                else
+                  'UNCLEAR'
+                end
+
+          requirements << {
+            'status' => status,
+            'description' => description.strip,
+            'status_icon' => status_emoji || (status == 'IMPLEMENTED' ? '✅' : status == 'PARTIALLY_IMPLEMENTED' ? '⚠️' : status == 'NOT_IMPLEMENTED' ? '❌' : '🔍')
+          }
+        end
+      end
+
+      requirements
+    end
+
+    def extract_git_info
+      begin
+        if File.exist?('.git')
+          branch = `git branch --show-current 2>/dev/null`.strip
+          branch = 'unknown' if branch.empty?
+
+          # Get diff stats
+          diff_stats = `git diff --stat HEAD~1 2>/dev/null`.strip
+          files_changed = diff_stats.scan(/(\d+) files? changed/).flatten.first || "0"
+          lines_added = diff_stats.scan(/(\d+) insertions?/).flatten.first || "0"
+          lines_removed = diff_stats.scan(/(\d+) deletions?/).flatten.first || "0"
+        elsif File.exist?('.hg')
+          branch = `hg branch 2>/dev/null`.strip
+          branch = 'default' if branch.empty?
+
+          # Get diff stats for hg
+          diff_stats = `hg diff --stat 2>/dev/null`.strip
+          files_changed = diff_stats.lines.count.to_s
+          lines_added = "0"  # hg diff --stat doesn't show +/- easily
+          lines_removed = "0"
+        else
+          branch = 'unknown'
+          files_changed = "0"
+          lines_added = "0"
+          lines_removed = "0"
+        end
+      rescue
+        branch = 'unknown'
+        files_changed = "0"
+        lines_added = "0"
+        lines_removed = "0"
+      end
+
+      {
+        branch: branch,
+        files_changed: files_changed,
+        lines_added: lines_added,
+        lines_removed: lines_removed
+      }
+    end
+
+    def resolve_template_path(template_key, config)
+      user_path = config.dig('templates', template_key) if config.is_a?(Hash)
+      return user_path if user_path && File.exist?(user_path)
+
+      File.expand_path(File.join(__dir__, 'templates', "#{template_key}.txt"))
+    end
+
+    def get_config(reconfigure: false, advanced_flow: false)
+      # This should match the config loading from the main CLI
+      # For now, return empty hash - will be enhanced when config system is unified
+      {}
+    end
+
+    def convert_markdown_to_adf(markdown_text)
+      content = []
+      lines = markdown_text.split("\n")
+      current_paragraph = []
+
+      lines.each do |line|
+        case line
+        when /^\*(.+)\*$/  # Bold headers like *N2B Code Analysis Report*
+          # Flush current paragraph
+          if current_paragraph.any?
+            content << create_paragraph(current_paragraph.join(" "))
+            current_paragraph = []
+          end
+
+          content << {
+            "type" => "heading",
+            "attrs" => { "level" => 2 },
+            "content" => [
+              {
+                "type" => "text",
+                "text" => $1.strip,
+                "marks" => [{ "type" => "strong" }]
+              }
+            ]
+          }
+        when /^=+$/  # Separator lines
+          # Skip separator lines
+        when /^\{expand:(.+)\}$/  # Jira expand start
+          # Flush current paragraph
+          if current_paragraph.any?
+            content << create_paragraph(current_paragraph.join(" "))
+            current_paragraph = []
+          end
+
+          # Create expand section
+          expand_title = $1.strip
+          content << {
+            "type" => "expand",
+            "attrs" => { "title" => expand_title },
+            "content" => []
+          }
+        when /^\{expand\}$/  # Jira expand end
+          # End of expand section - handled by the expand start
+        when /^☐\s+(.+)$/  # Unchecked checkbox
+          # Flush current paragraph
+          if current_paragraph.any?
+            content << create_paragraph(current_paragraph.join(" "))
+            current_paragraph = []
+          end
+
+          content << {
+            "type" => "taskList",
+            "content" => [
+              {
+                "type" => "taskItem",
+                "attrs" => { "state" => "TODO" },
+                "content" => [
+                  create_paragraph($1.strip)
+                ]
+              }
+            ]
+          }
+        when /^☑\s+(.+)$/  # Checked checkbox
+          # Flush current paragraph
+          if current_paragraph.any?
+            content << create_paragraph(current_paragraph.join(" "))
+            current_paragraph = []
+          end
+
+          content << {
+            "type" => "taskList",
+            "content" => [
+              {
+                "type" => "taskItem",
+                "attrs" => { "state" => "DONE" },
+                "content" => [
+                  create_paragraph($1.strip)
+                ]
+              }
+            ]
+          }
+        when /^---$/  # Horizontal rule
+          # Flush current paragraph
+          if current_paragraph.any?
+            content << create_paragraph(current_paragraph.join(" "))
+            current_paragraph = []
+          end
+
+          content << { "type" => "rule" }
+        when ""  # Empty line
+          # Flush current paragraph
+          if current_paragraph.any?
+            content << create_paragraph(current_paragraph.join(" "))
+            current_paragraph = []
+          end
+        else  # Regular text
+          current_paragraph << line
+        end
+      end
+
+      # Flush any remaining paragraph
+      if current_paragraph.any?
+        content << create_paragraph(current_paragraph.join(" "))
+      end
+
+      {
+        "type" => "doc",
+        "version" => 1,
+        "content" => content
+      }
+    end
+
+    def create_paragraph(text)
+      {
+        "type" => "paragraph",
+        "content" => [
+          {
+            "type" => "text",
+            "text" => text
+          }
+        ]
+      }
+    end
+
+    private
+
+    def format_comment_as_adf(comment_data)
+      # If comment_data is a string (from template), convert to simple ADF
+      if comment_data.is_a?(String)
+        return convert_markdown_to_adf(comment_data)
       end
 
       # If comment_data is structured (new format), build proper ADF