n2b 0.5.0 → 0.7.1

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
@@ -111,6 +114,75 @@ module N2B
       end
     end
 
+    def extract_requirements_from_description(description_string)
+      extracted_lines = []
+      in_requirements_section = false
+
+      # Headers that trigger requirement extraction. Case-insensitive.
+      # Jira often uses h1, h2, etc. for headers, or bold text.
+      # We'll look for lines that *start* with these, possibly after Jira's header markup like "hN. "
+      # Or common text like "Acceptance Criteria:", "Requirements:"
+      # Also include comment-specific implementation keywords
+      requirement_headers_regex = /^(h[1-6]\.\s*)?(Requirements|Acceptance Criteria|Tasks|Key Deliverables|Scope|User Stories|Implementation|Testing|Technical|Additional|Clarification|Comment \d+)/i
+
+      # Regex to identify common list item markers
+      _list_item_regex = /^\s*[\*\-\+]\s+/ # Unused but kept for potential future use
+      # Regex for lines that look like section headers (to stop capturing)
+      # This is a simple heuristic: a line with a few words, ending with a colon, or Jira hN. style
+      section_break_regex = /^(h[1-6]\.\s*)?\w+(\s+\w+){0,3}:?\s*$/i
+
+
+      description_string.to_s.each_line do |line| # Handle nil description_string
+        stripped_line = line.strip
+
+        if stripped_line.match?(requirement_headers_regex)
+          in_requirements_section = true
+          # Add the header itself to the extracted content if desired, or just use it as a trigger
+          # For now, let's add the line to give context.
+          extracted_lines << stripped_line
+          next # Move to the next line
+        end
+
+        if in_requirements_section
+          # If we encounter another significant header, stop capturing this section
+          # (unless it's another requirements header, which is fine)
+          if stripped_line.match?(section_break_regex) && !stripped_line.match?(requirement_headers_regex)
+            # Check if this new header is one of the requirement types. If so, continue.
+            # Otherwise, break. This logic is simplified: if it's any other header, stop.
+            is_another_req_header = false # Placeholder for more complex logic if needed
+            requirement_headers_regex.match(stripped_line) { is_another_req_header = true }
+
+            unless is_another_req_header
+              in_requirements_section = false # Stop capturing
+              # Potentially add a separator if concatenating multiple distinct sections later
+              # extracted_lines << "---"
+              next # Don't include this new non-req header in current section
+            else
+              # It's another requirement-related header, so add it and continue
+              extracted_lines << stripped_line
+              next
+            end
+          end
+
+          # Capture list items or general text within the section
+          # For now, we are quite inclusive of lines within a detected section.
+          # We could be more strict and only take list_item_regex lines,
+          # but often text paragraphs under a heading are relevant too.
+          extracted_lines << stripped_line unless stripped_line.empty?
+        end
+      end
+
+      if extracted_lines.empty?
+        # Fallback: return the entire description if no specific sections found
+        return description_string.to_s.strip # Handle nil and strip
+      else
+        # Join extracted lines and clean up excessive newlines
+        # Replace 3+ newlines with 2, and 2+ newlines with 2 (effectively max 2 newlines)
+        # Also, strip leading/trailing whitespace from the final result.
+        return extracted_lines.join("\n").gsub(/\n{3,}/, "\n\n").gsub(/\n{2,}/, "\n\n").strip
+      end
+    end
+
     private
 
     def process_ticket_data(ticket_data, comments_data)
@@ -327,95 +399,383 @@ module N2B
       end
     end
 
-    def extract_requirements_from_description(description_string)
-      extracted_lines = []
-      in_requirements_section = false
+    def generate_templated_comment(comment_data)
+      # Prepare template data from the analysis results
+      template_data = prepare_template_data(comment_data)
 
-      # Headers that trigger requirement extraction. Case-insensitive.
-      # Jira often uses h1, h2, etc. for headers, or bold text.
-      # We'll look for lines that *start* with these, possibly after Jira's header markup like "hN. "
-      # Or common text like "Acceptance Criteria:", "Requirements:"
-      # Also include comment-specific implementation keywords
-      requirement_headers_regex = /^(h[1-6]\.\s*)?(Requirements|Acceptance Criteria|Tasks|Key Deliverables|Scope|User Stories|Implementation|Testing|Technical|Additional|Clarification|Comment \d+)/i
+      # 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)
 
-      # Regex to identify common list item markers
-      _list_item_regex = /^\s*[\*\-\+]\s+/ # Unused but kept for potential future use
-      # Regex for lines that look like section headers (to stop capturing)
-      # This is a simple heuristic: a line with a few words, ending with a colon, or Jira hN. style
-      section_break_regex = /^(h[1-6]\.\s*)?\w+(\s+\w+){0,3}:?\s*$/i
+      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 {
+          '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
 
-      description_string.to_s.each_line do |line| # Handle nil description_string
-        stripped_line = line.strip
+      # 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
+        }
 
-        if stripped_line.match?(requirement_headers_regex)
-          in_requirements_section = true
-          # Add the header itself to the extracted content if desired, or just use it as a trigger
-          # For now, let's add the line to give context.
-          extracted_lines << stripped_line
-          next # Move to the next line
+        case severity
+        when 'CRITICAL'
+          critical_errors << error_item
+        when 'IMPORTANT'
+          important_errors << error_item
+        else
+          low_errors << error_item
         end
+      end
 
-        if in_requirements_section
-          # If we encounter another significant header, stop capturing this section
-          # (unless it's another requirements header, which is fine)
-          if stripped_line.match?(section_break_regex) && !stripped_line.match?(requirement_headers_regex)
-            # Check if this new header is one of the requirement types. If so, continue.
-            # Otherwise, break. This logic is simplified: if it's any other header, stop.
-            is_another_req_header = false # Placeholder for more complex logic if needed
-            requirement_headers_regex.match(stripped_line) { is_another_req_header = true }
+      # Process improvements
+      improvements = (comment_data[:improvements] || comment_data['improvements'] || []).map do |improvement|
+        {
+          'file_reference' => extract_file_reference(improvement),
+          'description' => clean_error_description(improvement)
+        }
+      end
 
-            unless is_another_req_header
-              in_requirements_section = false # Stop capturing
-              # Potentially add a separator if concatenating multiple distinct sections later
-              # extracted_lines << "---"
-              next # Don't include this new non-req header in current section
-            else
-              # It's another requirement-related header, so add it and continue
-              extracted_lines << stripped_line
-              next
-            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
 
-          # Capture list items or general text within the section
-          # For now, we are quite inclusive of lines within a detected section.
-          # We could be more strict and only take list_item_regex lines,
-          # but often text paragraphs under a heading are relevant too.
-          extracted_lines << stripped_line unless stripped_line.empty?
+      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
 
-      if extracted_lines.empty?
-        # Fallback: return the entire description if no specific sections found
-        return description_string.to_s.strip # Handle nil and strip
-      else
-        # Join extracted lines and clean up excessive newlines
-        # Replace 3+ newlines with 2, and 2+ newlines with 2 (effectively max 2 newlines)
-        # Also, strip leading/trailing whitespace from the final result.
-        return extracted_lines.join("\n").gsub(/\n{3,}/, "\n\n").gsub(/\n{2,}/, "\n\n").strip
+      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 (legacy), convert to simple ADF
+      # If comment_data is a string (from template), convert to simple ADF
       if comment_data.is_a?(String)
-        return {
-          "type" => "doc",
-          "version" => 1,
-          "content" => [
-            {
-              "type" => "paragraph",
-              "content" => [
-                {
-                  "type" => "text",
-                  "text" => comment_data
-                }
-              ]
-            }
-          ]
-        }
+        return convert_markdown_to_adf(comment_data)
       end
 
       # If comment_data is structured (new format), build proper ADF

data/lib/n2b/llm/claude.rb

@@ -32,7 +32,7 @@ module N2M
           "messages" => [
             {
               "role" => "user",
-              "content" => content 
+              "content" => content
             }
           ]
         })
@@ -44,29 +44,16 @@ module N2M
         if response.code != '200'
           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
-          # remove everything before the first { and after the last }
-          
+        answer = JSON.parse(response.body)['content'].first['text']
+        begin
           answer = answer.sub(/.*?\{(.*)\}.*/m, '{\1}') unless answer.start_with?('{')
-          # 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
           # 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
+          puts "Error parsing JSON from LLM response: #{answer}"
           answer = { 'explanation' => answer} # Default fallback
         end
         answer
@@ -83,10 +70,10 @@ module N2M
 
         request.body = JSON.dump({
           "model" => get_model_name,
-          "max_tokens" => @config['max_tokens'] || 1024, # Allow overriding max_tokens from config
+          "max_tokens" => @config['max_tokens'] || 1024,
           "messages" => [
             {
-              "role" => "user", # The entire prompt is passed as a single user message
+              "role" => "user",
               "content" => prompt_content
             }
           ]

data/lib/n2b/llm/gemini.rb

@@ -34,7 +34,10 @@ module N2M
             "parts" => [{
               "text" => content
             }]
-          }]
+          }],
+          "generationConfig" => {
+            "responseMimeType" => "application/json"
+          }
         })
 
         response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
@@ -82,14 +85,12 @@ module N2M
         request.body = JSON.dump({
           "contents" => [{
             "parts" => [{
-              "text" => prompt_content # The entire prompt is passed as text
+              "text" => prompt_content
             }]
           }],
-          # 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
-          # }
+          "generationConfig" => {
+            "responseMimeType" => "application/json"
+          }
         })
 
         response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|

data/lib/n2b/llm/ollama.rb

@@ -88,7 +88,7 @@ module N2M
         # 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,
+          "model" => get_model_name,
           "messages" => [
             {
               "role" => "user",