n2b 0.5.1 → 2.0.0

data/lib/n2b/jira_client.rb

@@ -2,6 +2,7 @@ require 'net/http'
 require 'uri'
 require 'json'
 require 'base64'
+require_relative 'template_engine'
 
 module N2B
   class JiraClient
@@ -67,19 +68,44 @@ module N2B
 
       puts "Updating Jira ticket #{ticket_key} with analysis comment..."
 
+      # Generate comment using template system
+      template_comment = generate_templated_comment(comment)
+
+      if debug_mode?
+        puts "🔍 DEBUG: Generated template comment (#{template_comment.length} chars):"
+        puts "--- TEMPLATE COMMENT START ---"
+        puts template_comment
+        puts "--- TEMPLATE COMMENT END ---"
+      end
+
       # 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)
       }
 
+      if debug_mode?
+        puts "🔍 DEBUG: Formatted ADF comment body:"
+        puts "--- ADF BODY START ---"
+        puts JSON.pretty_generate(comment_body)
+        puts "--- ADF BODY END ---"
+      end
+
       # Make the API call to add a comment
       path = "/rest/api/3/issue/#{ticket_key}/comment"
+      puts "🔍 DEBUG: Making API request to: #{path}" if debug_mode?
+
       _response = make_api_request('POST', path, comment_body)
 
       puts "✅ Successfully added comment to Jira ticket #{ticket_key}"
       true
     rescue JiraApiError => e
       puts "❌ Failed to update Jira ticket #{ticket_key}: #{e.message}"
+      if debug_mode?
+        puts "🔍 DEBUG: Full error details:"
+        puts "  - Ticket key: #{ticket_key}"
+        puts "  - Template comment length: #{template_comment&.length || 'nil'}"
+        puts "  - Comment body keys: #{comment_body&.keys || 'nil'}"
+      end
       false
     end
 
@@ -396,28 +422,543 @@ module N2B
       end
     end
 
-    private
+    def generate_templated_comment(comment_data)
+      # Handle structured hash data from format_analysis_for_jira
+      if comment_data.is_a?(Hash) && comment_data.key?(:implementation_summary)
+        return generate_structured_comment(comment_data)
+      end
 
-    def format_comment_as_adf(comment_data)
-      # If comment_data is a string (legacy), convert to simple ADF
+      # Prepare template data from the analysis results
+      template_data = prepare_template_data(comment_data)
+
+      # 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 generate_structured_comment(data)
+      # Generate a properly formatted comment from structured analysis data
+      git_info = extract_git_info
+      timestamp = Time.now.strftime("%Y-%m-%d %H:%M UTC")
+
+      comment_parts = []
+
+      # Header
+      comment_parts << "*N2B Code Analysis Report*"
+      comment_parts << ""
+
+      # Implementation Summary (always expanded)
+      comment_parts << "*Implementation Summary:*"
+      comment_parts << (data[:implementation_summary] || "Unknown")
+      comment_parts << ""
+
+      # Custom message if provided (also expanded)
+      if data[:custom_analysis_focus] && !data[:custom_analysis_focus].empty?
+        comment_parts << "*Custom Analysis Focus:*"
+        comment_parts << data[:custom_analysis_focus]
+        comment_parts << ""
+      end
+
+      comment_parts << "---"
+      comment_parts << ""
+
+      # Automated Analysis Findings
+      comment_parts << "*Automated Analysis Findings:*"
+      comment_parts << ""
+
+      # Critical Issues (collapsed by default)
+      critical_issues = classify_issues_by_severity(data[:issues] || [], 'CRITICAL')
+      if critical_issues.any?
+        comment_parts << "{expand:🚨 Critical Issues (Must Fix Before Merge)}"
+        critical_issues.each { |issue| comment_parts << "☐ #{issue}" }
+        comment_parts << "{expand}"
+      else
+        comment_parts << "✅ No critical issues found"
+      end
+      comment_parts << ""
+
+      # Important Issues (collapsed by default)
+      important_issues = classify_issues_by_severity(data[:issues] || [], 'IMPORTANT')
+      if important_issues.any?
+        comment_parts << "{expand:⚠️ Important Issues (Should Address)}"
+        important_issues.each { |issue| comment_parts << "☐ #{issue}" }
+        comment_parts << "{expand}"
+      else
+        comment_parts << "✅ No important issues found"
+      end
+      comment_parts << ""
+
+      # Suggested Improvements (collapsed by default)
+      if data[:improvements] && data[:improvements].any?
+        comment_parts << "{expand:💡 Suggested Improvements (Nice to Have)}"
+        data[:improvements].each { |improvement| comment_parts << "☐ #{improvement}" }
+        comment_parts << "{expand}"
+      else
+        comment_parts << "✅ No specific improvements suggested"
+      end
+      comment_parts << ""
+
+      # Test Coverage Assessment
+      comment_parts << "{expand:🧪 Test Coverage Assessment}"
+      if data[:test_coverage] && !data[:test_coverage].empty?
+        comment_parts << "*Overall Assessment:* #{data[:test_coverage]}"
+      else
+        comment_parts << "*Overall Assessment:* Not assessed"
+      end
+      comment_parts << "{expand}"
+      comment_parts << ""
+
+      # Missing Test Coverage
+      comment_parts << "*Missing Test Coverage:*"
+      comment_parts << "☐ No specific missing tests identified"
+      comment_parts << ""
+
+      # Requirements Evaluation
+      comment_parts << "*📋 Requirements Evaluation:*"
+      if data[:requirements_evaluation] && !data[:requirements_evaluation].empty?
+        comment_parts << "#{data[:requirements_evaluation]}"
+      else
+        comment_parts << "🔍 *UNCLEAR:* Requirements not provided or assessed"
+      end
+      comment_parts << ""
+
+      comment_parts << "---"
+      comment_parts << ""
+
+      # Footer with metadata (simplified)
+      comment_parts << "Analysis completed on #{timestamp} | Branch: #{git_info[:branch]}"
+
+      comment_parts.join("\n")
+    end
+
+    def classify_issues_by_severity(issues, target_severity)
+      return [] unless issues.is_a?(Array)
+
+      issues.select do |issue|
+        severity = classify_error_severity(issue)
+        severity == target_severity
+      end
+    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)
+      # Return the config that was passed during initialization
+      # This is used for template resolution and other configuration needs
+      @config
+    end
+
+    def convert_markdown_to_adf(markdown_text)
+      content = []
+      lines = markdown_text.split("\n")
+      current_paragraph = []
+      current_expand = nil
+      expand_content = []
+
+      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
+
+          # Start collecting expand content
+          expand_title = $1.strip
+          current_expand = {
+            "type" => "expand",
+            "attrs" => { "title" => expand_title },
+            "content" => []
+          }
+          expand_content = []
+        when /^\{expand\}$/  # Jira expand end
+          # End of expand section - add collected content
+          if current_expand
+            current_expand["content"] = expand_content
+            content << current_expand if expand_content.any?  # Only add if has content
+            current_expand = nil
+            expand_content = []
+          end
+        when /^☐\s+(.+)$/  # Unchecked checkbox
+          # Flush current paragraph
+          if current_paragraph.any?
+            paragraph = create_paragraph(current_paragraph.join(" "))
+            if current_expand
+              expand_content << paragraph
+            else
+              content << paragraph
+            end
+            current_paragraph = []
+          end
+
+          # Convert checkbox to simple paragraph (no bullet points)
+          checkbox_paragraph = create_paragraph("☐ " + $1.strip)
+
+          if current_expand
+            expand_content << checkbox_paragraph
+          else
+            content << checkbox_paragraph
+          end
+        when /^☑\s+(.+)$/  # Checked checkbox
+          # Flush current paragraph
+          if current_paragraph.any?
+            paragraph = create_paragraph(current_paragraph.join(" "))
+            if current_expand
+              expand_content << paragraph
+            else
+              content << paragraph
+            end
+            current_paragraph = []
+          end
+
+          # Convert checkbox to simple paragraph (no bullet points)
+          checkbox_paragraph = create_paragraph("☑ " + $1.strip)
+
+          if current_expand
+            expand_content << checkbox_paragraph
+          else
+            content << checkbox_paragraph
+          end
+        when /^---$/  # Horizontal rule
+          # Flush current paragraph
+          if current_paragraph.any?
+            paragraph = create_paragraph(current_paragraph.join(" "))
+            if current_expand
+              expand_content << paragraph
+            else
+              content << paragraph
+            end
+            current_paragraph = []
+          end
+
+          rule = { "type" => "rule" }
+          if current_expand
+            expand_content << rule
+          else
+            content << rule
+          end
+        when ""  # Empty line
+          # Flush current paragraph
+          if current_paragraph.any?
+            paragraph = create_paragraph(current_paragraph.join(" "))
+            if current_expand
+              expand_content << paragraph
+            else
+              content << paragraph
+            end
+            current_paragraph = []
+          end
+        else  # Regular text
+          # Skip empty or whitespace-only content
+          unless line.strip.empty? || line.strip == "{}"
+            current_paragraph << line
+          end
+        end
+      end
+
+      # Flush any remaining paragraph
+      if current_paragraph.any?
+        paragraph = create_paragraph(current_paragraph.join(" "))
+        if current_expand
+          expand_content << paragraph
+        else
+          content << paragraph
+        end
+      end
+
+      # Close any remaining expand section
+      if current_expand && expand_content.any?
+        current_expand["content"] = expand_content
+        content << current_expand
+      end
+
+      # Ensure we have at least one content element
+      if content.empty?
+        content << create_paragraph("Analysis completed.")
+      end
+
+      {
+        "type" => "doc",
+        "version" => 1,
+        "content" => content
+      }
+    end
+
+    def create_paragraph(text)
+      {
+        "type" => "paragraph",
+        "content" => [
+          {
+            "type" => "text",
+            "text" => text
+          }
+        ]
+      }
+    end
+
+    private
+
+    def debug_mode?
+      ENV['N2B_DEBUG'] == 'true'
+    end
+
+    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
       content = []
 
@@ -736,8 +1277,26 @@ module N2B
       request['Content-Type'] = 'application/json'
       request['Accept'] = 'application/json'
 
+      if debug_mode?
+        puts "🔍 DEBUG: Making #{method} request to: #{full_url}"
+        puts "🔍 DEBUG: Request headers: Content-Type=#{request['Content-Type']}, Accept=#{request['Accept']}"
+        if body
+          puts "🔍 DEBUG: Request body size: #{body.to_json.length} bytes"
+          puts "🔍 DEBUG: Request body preview: #{body.to_json[0..500]}#{'...' if body.to_json.length > 500}"
+        end
+      end
+
       response = http.request(request)
 
+      if debug_mode?
+        puts "🔍 DEBUG: Response code: #{response.code} #{response.message}"
+        if response.body && !response.body.empty?
+          # Force UTF-8 encoding to handle character encoding issues
+          response_body = response.body.force_encoding('UTF-8')
+          puts "🔍 DEBUG: Response body: #{response_body}"
+        end
+      end
+
       unless response.is_a?(Net::HTTPSuccess)
         error_message = "Jira API Error: #{response.code} #{response.message}"
         error_message += " - #{response.body}" if response.body && !response.body.empty?

data/lib/n2b/llm/claude.rb

@@ -1,6 +1,6 @@
 require_relative '../model_config'
 
-module N2M
+module N2B
   module Llm
     class Claude
       API_URI = URI.parse('https://api.anthropic.com/v1/messages')
@@ -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
             }
           ]