code_healer 0.1.18 → 0.1.20

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a88b89f7bf244566728987fa8a20b3db2d6ee1e6b0a249956c06907441eb5a13
-  data.tar.gz: 349d7d045fa176d54454d7d42ae354369001eddeee2764cedf9f82c62bf4a49f
+  metadata.gz: c54944cc1cad8a6a188bbf5b5a50a216b0719046339b59eccc12447aff916582
+  data.tar.gz: f190123758f3d4b73a7c7f53ccf8b275347819e5a7b60008085a62a79c239751
 SHA512:
-  metadata.gz: 50dd2dc5f4af17274e9854ea43581a794b55d88d50e2fbc2ffbde5c450dfadc9801929454d4f0f4f34d523c16bb7921f5c060c273d43448f300f8ab3d25e2ad5
-  data.tar.gz: b7f287a9b342cd8ad8e110c4eb480ac7c7f1dbc2b8fc753b272e32ff767eabe8d947b1c790c65cbe9eb13fdac2701aad91ff23ed2c228b53f7729cefbbe36a84
+  metadata.gz: 050def7293a77fb6204fb51f9fc5640caf036903b765c34be1b9c9163300e1034ae880ad3855d92480df40fe813c4590df6c1a86b812d80c9e541b8d7df8d9ef
+  data.tar.gz: 1d2874cf1817fdf4825d189f666c5fd9e9a300966892118dd79e254a4b528251d8cb85e587525735a3749f07ad75711e1ac1cdd444f30ba0c76852d4d4f62504

data/CHANGELOG.md

@@ -5,7 +5,35 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [Unreleased]
+## [0.1.20] - 2025-08-27
+
+### Added
+- **Confluence MCP Integration**: Added direct Confluence MCP tools for business context fetching (optional usage)
+- **Flexible MCP Usage**: Enhanced prompts to optionally use Confluence MCP tools when available
+- **Non-interactive MCP**: Fixed Claude Terminal flags to avoid manual approval prompts
+- **Business Context Strategy**: Added `confluence_only` strategy for focused Confluence documentation usage
+
+### Fixed
+- **MCP Tool Access**: Removed restrictive tool flags that blocked MCP tool usage
+- **Debug Logging**: Cleaned up unnecessary MCP debugging logs from initialization and job startup
+- **Command Optimization**: Fixed Claude Terminal command flags for proper MCP integration
+
+### Changed
+- **Prompt Strategy**: Updated business context prompts to optionally use MCP tools when available
+- **Initialization**: Streamlined gem startup without MCP availability checks
+- **Dependencies**: Maintained `httparty` for MCP API integration while removing debug overhead
+
+## [0.1.19] - 2025-08-21
+
+### Fixed
+- **Critical Git Operations Duplication**: Fixed duplicate Git operations between evolution handler and workspace manager.
+- **Branch Detection**: Fixed automatic detection of repository's default branch (master vs main).
+- **Configuration Loading**: Fixed pr_target_branch configuration loading from both git section and root level.
+- **Workspace Isolation**: Improved Git operations to occur only in isolated workspace, preventing conflicts.
+
+### Changed
+- **Evolution Handler**: Removed duplicate Git operations to prevent conflicts with workspace manager.
+- **Setup Script**: Enhanced with automatic branch detection and better configuration structure.
 
 ## [0.1.18] - 2025-08-21
 

data/bin/start_claude_session

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+
+# Start Claude Terminal with code_healer_session for MCP tools access
+# This session will be used by CodeHealer for healing jobs
+
+puts "🚀 Starting Claude Terminal with code_healer_session for MCP tools..."
+puts "This session will be used by CodeHealer for healing jobs with Jira/Confluence access"
+puts ""
+puts "Session name: code_healer_session"
+puts "MCP tools: Jira, Confluence, and other Atlassian integrations"
+puts ""
+puts "Keep this terminal open while running healing jobs!"
+puts "=" * 60
+
+# Start Claude Terminal with the session
+exec "claude --session code_healer_session"

data/code_healer.gemspec

@@ -60,6 +60,8 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency 'activesupport', '>= 6.0.0'
   spec.add_runtime_dependency 'actionpack', '>= 6.0.0'
   spec.add_runtime_dependency 'activemodel', '>= 6.0.0'
+  spec.add_runtime_dependency 'httparty', '~> 0.21.0', '>= 0.21.0'
+
 
   # Development dependencies
   spec.add_development_dependency "bundler", ">= 2.0.0"

data/config/code_healer.yml.example

@@ -49,7 +49,39 @@ claude_code:
 business_context:
   enabled: true
   
-  # Define business rules for specific classes
+  # Business Context Strategy
+  strategy: "jira_mcp"  # Options: "jira_mcp", "markdown", "hybrid"
+  
+  # Jira MCP Configuration (when strategy is "jira_mcp" or "hybrid")
+  jira_mcp:
+    enabled: true
+    project_key: "DGTL"  # Your Jira project key
+    search_tickets_on_error: true
+    include_business_rules: true
+    system_prompt: |
+      When fixing code, ALWAYS check Jira MCP for business context:
+      1. Search for tickets about the class/method you're fixing
+      2. Use Jira requirements to ensure your fix follows business rules
+      3. Reference specific Jira tickets in your explanation
+      4. Make sure fixes align with business requirements
+  
+  # Markdown Configuration (when strategy is "markdown" or "hybrid")
+  markdown:
+    enabled: true
+    search_paths:
+      - "docs/business_rules.md"
+      - "docs/requirements.md"
+      - "business_requirements/"
+    include_patterns:
+      - "*.md"
+      - "*.txt"
+  
+  # Hybrid Configuration (when strategy is "hybrid")
+  hybrid:
+    priority: ["jira_mcp", "markdown"]  # Which source to check first
+    combine_results: true  # Merge results from both sources
+  
+  # Define business rules for specific classes (fallback when MCP unavailable)
   User:
     domain: "User Management"
     key_rules:

data/lib/code_healer/business_context_manager.rb

@@ -177,8 +177,44 @@ module CodeHealer
       end
       
     def build_claude_code_prompt(error, class_name, method_name, file_path)
-        # Load business context from markdown files
-        business_context = load_business_context_from_markdown_simple
+        # Get business context based on configured strategy
+        business_context = case CodeHealer::ConfigManager.business_context_strategy
+        when 'confluence_only'
+          "## Business Context Instructions:\n" \
+          "OPTIONAL: You can use Confluence MCP tools to enhance business context if available.\n\n" \
+          "1. If Confluence MCP is available:\n" \
+          "   - Search for PRDs/specs related to '#{class_name}' / '#{method_name}'.\n" \
+          "   - Query terms: '#{class_name}', '#{method_name}', 'business rules', 'validation patterns'.\n" \
+          "   - Apply any found documentation to your fix.\n\n" \
+          "2. If Confluence MCP is not available:\n" \
+          "   - Proceed with standard business logic and error handling practices.\n" \
+          "   - Use common validation patterns and best practices.\n\n" \
+          "Note: MCP usage is optional - proceed with or without it."
+        when 'claude_atlassian_mcp'
+          "## Business Context Instructions:\n" \
+          "OPTIONAL: You can use Atlassian MCP tools to enhance business context if available.\n\n" \
+          "1. **If Jira MCP is available:**\n" \
+          "   - Search for tickets related to '#{class_name}' or '#{method_name}'\n" \
+          "   - Look for bug reports, requirements, or business rules\n" \
+          "   - Apply any found ticket context to your fix\n\n" \
+          "2. **If Confluence MCP is available:**\n" \
+          "   - Search for PRDs, technical specs, or business process docs\n" \
+          "   - Look for domain-specific business rules related to '#{class_name}'\n" \
+          "   - Apply any found documentation to your fix\n\n" \
+          "3. **If MCP tools are not available:**\n" \
+          "   - Proceed with standard business logic and error handling practices\n" \
+          "   - Use common validation patterns and best practices\n\n" \
+          "Note: MCP usage is optional - proceed with or without it."
+        when 'jira_mcp'
+          # Use Jira MCP context
+          get_jira_business_context(class_name)
+        when 'markdown'
+          # Use markdown files
+          load_business_context_from_markdown_simple
+        else
+          # Default fallback
+          load_business_context_from_markdown_simple
+        end
         
         prompt = <<~PROMPT
           I have a Ruby on Rails application with an error that needs fixing.
@@ -195,7 +231,7 @@ module CodeHealer
           #{error.backtrace&.join("\n") || "No backtrace available"}
           ```
           
-          ## Business Context (from requirements):
+          ## Business Context:
           #{business_context}
           
           ## Instructions:
@@ -262,6 +298,24 @@ module CodeHealer
         prompt.strip
       end
       
+      def get_jira_business_context(class_name)
+        # Get Jira business context using MCP tools
+        begin
+          # This would integrate with Jira MCP tools
+          # For now, return instructions to use Jira MCP
+          "## Jira Business Context Instructions:\n" \
+          "Use Jira MCP tools to fetch business context:\n" \
+          "1. Search for tickets related to '#{class_name}'\n" \
+          "2. Look for business requirements and rules\n" \
+          "3. Apply the context to your fix\n" \
+          "4. Reference specific Jira tickets in your explanation"
+        rescue => e
+          "## Jira Business Context:\n" \
+          "Unable to fetch Jira context: #{e.message}\n" \
+          "Please use Jira MCP tools manually to get business context."
+        end
+      end
+      
       private
       
       def load_business_context_from_markdown_simple

data/lib/code_healer/claude_code_evolution_handler.rb

@@ -31,8 +31,9 @@ module CodeHealer
             reload_modified_files
             
             # 🚀 Trigger Git operations (commit, push, PR creation)
-            puts "🔄 Starting Git operations..."
-            trigger_git_operations(error, class_name, method_name, file_path)
+            # Note: Git operations are now handled by the isolated workspace manager
+            # to prevent duplication and ensure proper isolation
+            puts "🔄 Git operations will be handled by isolated workspace manager..."
             
             return true
           else
@@ -109,31 +110,30 @@ module CodeHealer
       def build_claude_command(prompt, config)
         # Escape prompt for shell
         escaped_prompt = prompt.gsub("'", "'\"'\"'")
-        
-        # Build command template
+    
+        # Build command template for MCP tools access
         command_template = config['command_template'] || "claude --code '{prompt}'"
-        
+    
         # Replace placeholder
         command = command_template.gsub('{prompt}', escaped_prompt)
-        
-        # Add additional options if configured
+    
+        # [rest of your existing code remains the same]
         if config['include_tests'] && !CodeHealer::ConfigManager.demo_mode?
           command += " --append-system-prompt 'Include tests when fixing the code'"
         else
           command += " --append-system-prompt 'Do NOT create or modify tests'"
         end
-        
+    
         if config['max_file_changes']
           command += " --append-system-prompt 'Limit changes to #{config['max_file_changes']} files maximum'"
         end
-        
-        # Add file editing permissions
+    
         command += " --permission-mode acceptEdits --allowedTools Edit"
-        
-        # Add current directory access but advise not to scan everything
+        command += " --append-system-prompt 'Optionally use Confluence MCP tools if available to enhance business context, but proceed regardless.'"
         command += " --add-dir . --append-system-prompt 'Do not scan the whole repo; open only files explicitly referenced.'"
-        
-        command
+    
+        # Return combined command
+        mcp_setup + command
       end
       
       def reload_modified_files
@@ -193,6 +193,8 @@ module CodeHealer
         puts "📝 Evolution attempt logged to #{log_file}"
       end
       
+
+      
       def trigger_git_operations(error, class_name, method_name, file_path)
         puts "🚀 Triggering Git operations for Claude Code evolution..."
         

data/lib/code_healer/config_manager.rb

@@ -107,6 +107,57 @@ module CodeHealer
         config['business_context'] || {}
       end
 
+      # Business Context Strategy Configuration
+      def business_context_strategy
+        business_context_settings['strategy'] || 'markdown'
+      end
+
+      def use_jira_mcp?
+        business_context_strategy == 'jira_mcp' || business_context_strategy == 'hybrid'
+      end
+
+      def use_markdown_context?
+        business_context_strategy == 'markdown' || business_context_strategy == 'hybrid'
+      end
+
+      def use_hybrid_context?
+        business_context_strategy == 'hybrid'
+      end
+
+      def jira_mcp_settings
+        business_context_settings['jira_mcp'] || {}
+      end
+
+      def markdown_settings
+        business_context_settings['markdown'] || {}
+      end
+
+      def hybrid_settings
+        business_context_settings['hybrid'] || {}
+      end
+
+      def jira_mcp_enabled?
+        use_jira_mcp? && jira_mcp_settings['enabled'] != false
+      end
+
+      def markdown_enabled?
+        use_markdown_context? && markdown_settings['enabled'] != false
+      end
+
+      def jira_mcp_system_prompt
+        jira_mcp_settings['system_prompt'] || default_jira_mcp_prompt
+      end
+
+      def default_jira_mcp_prompt
+        <<~PROMPT
+          When fixing code, ALWAYS check Jira MCP for business context:
+          1. Search for tickets about the class/method you're fixing
+          2. Use Jira requirements to ensure your fix follows business rules
+          3. Reference specific Jira tickets in your explanation
+          4. Make sure fixes align with business requirements
+        PROMPT
+      end
+
       # API Configuration
       def api_settings
         config['api'] || {}
@@ -189,7 +240,8 @@ module CodeHealer
       end
 
       def pr_target_branch
-        git_settings['pr_target_branch'] || 'main'
+        # Check both git section and root level for backward compatibility
+        git_settings['pr_target_branch'] || config['pr_target_branch'] || 'main'
       end
 
       def commit_message_template

data/lib/code_healer/evolution_job.rb

@@ -25,7 +25,7 @@ class EvolutionJob
           healing_branch = CodeHealer::HealingWorkspaceManager.create_healing_branch(
             Rails.root.to_s, 
             workspace_path, 
-            CodeHealer::ConfigManager.git_settings['pr_target_branch'] || 'main'
+            CodeHealer::ConfigManager.pr_target_branch
           )
           
           if healing_branch

data/lib/code_healer/healing_job.rb

@@ -1,4 +1,5 @@
 require 'sidekiq'
+require 'open3'
 
 module CodeHealer
   class HealingJob
@@ -9,6 +10,8 @@ module CodeHealer
     def perform(*args)
       puts "🚀 [HEALING_JOB] Starting job with args: #{args.inspect}"
       
+
+      
       # Support both legacy and new invocation styles
       error, class_name, method_name, evolution_method, backtrace = parse_args(args)
       
@@ -68,7 +71,7 @@ module CodeHealer
             healing_branch = CodeHealer::HealingWorkspaceManager.create_healing_branch(
               Rails.root.to_s,
               workspace_path,
-              CodeHealer::ConfigManager.git_settings['pr_target_branch'] || 'main'
+              CodeHealer::ConfigManager.pr_target_branch
             )
             git_time_ms = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - git_started_at) * 1000).round
 
@@ -127,6 +130,47 @@ module CodeHealer
     end
 
     private
+    
+    def log_mcp_tools_availability
+      puts "🔍 [HEALING_JOB] Checking MCP tools availability..."
+      
+      begin
+        # Check if Claude has MCP tools available
+        mcp_check_command = "claude --print 'List all available MCP tools' --output-format text"
+        stdout, stderr, status = Open3.capture3(mcp_check_command)
+        
+        if status.success?
+          puts "✅ [HEALING_JOB] Claude Terminal is available"
+          
+          # Extract MCP tools from output
+          if stdout.include?("MCP tools available") || stdout.include?("mcp__")
+            puts "🔧 [HEALING_JOB] MCP tools detected in Claude Terminal"
+            
+            # Log specific MCP tools if found
+            if stdout.include?("mcp__atlassian")
+              puts "   - Atlassian MCP tools: Available"
+              puts "   - Jira integration: Available"
+              puts "   - Confluence integration: Available"
+            end
+            
+            if stdout.include?("mcp__")
+              puts "   - Other MCP tools: Available"
+            end
+          else
+            puts "⚠️  [HEALING_JOB] No MCP tools detected in Claude Terminal"
+            puts "💡 Make sure Claude Terminal has MCP tools configured"
+          end
+        else
+          puts "❌ [HEALING_JOB] Claude Terminal is not available"
+          puts "💡 Make sure Claude Terminal is installed and accessible"
+        end
+      rescue => e
+        puts "⚠️  [HEALING_JOB] Could not check MCP tools: #{e.message}"
+        puts "💡 Make sure Claude Terminal is properly installed"
+      end
+      
+      puts "🔍 [HEALING_JOB] MCP tools check complete"
+    end
 
     def parse_args(args)
       # Formats supported:

data/lib/code_healer/mcp_server.rb

@@ -18,7 +18,9 @@ module CodeHealer
           tools: [
             ErrorAnalysisTool,
             CodeFixTool,
-            ContextAnalysisTool
+            ContextAnalysisTool,
+            JIRAIntegrationTool,  # Add Jira integration tool
+            ConfluenceIntegrationTool  # Add Confluence integration tool
           ],
           server_context: {
             codebase_context: @codebase_context,
@@ -237,13 +239,231 @@ module CodeHealer
       end
       
       def get_business_context(class_name)
-        {
+        base_context = {
           domain: determine_business_domain(class_name),
           criticality: assess_business_criticality(class_name),
           regulatory_requirements: identify_regulatory_requirements(class_name),
           sla_requirements: get_sla_requirements(class_name),
           user_impact: assess_user_impact(class_name)
         }
+        
+        # Get business context based on configured sources
+        business_context = get_configured_business_context(class_name)
+        base_context.merge!(business_context)
+        
+        base_context
+      end
+
+      def get_configured_business_context(class_name)
+        context = {}
+        
+        # Get business context based on configured strategy
+        case CodeHealer::ConfigManager.business_context_strategy
+        when 'jira_mcp'
+          if CodeHealer::ConfigManager.jira_mcp_enabled?
+            context[:strategy] = 'jira_mcp'
+            context[:instructions] = CodeHealer::ConfigManager.jira_mcp_system_prompt
+            context[:project_key] = CodeHealer::ConfigManager.jira_mcp_settings['project_key']
+          end
+        when 'markdown'
+          if CodeHealer::ConfigManager.markdown_enabled?
+            markdown_context = get_markdown_business_context(class_name)
+            context[:strategy] = 'markdown'
+            context[:markdown_context] = markdown_context
+          end
+        when 'hybrid'
+          # Combine both approaches
+          context[:strategy] = 'hybrid'
+          if CodeHealer::ConfigManager.jira_mcp_enabled?
+            context[:jira_mcp_instructions] = CodeHealer::ConfigManager.jira_mcp_system_prompt
+            context[:project_key] = CodeHealer::ConfigManager.jira_mcp_settings['project_key']
+          end
+          if CodeHealer::ConfigManager.markdown_enabled?
+            markdown_context = get_markdown_business_context(class_name)
+            context[:markdown_context] = markdown_context
+          end
+        end
+        
+        context
+      end
+      
+      def get_jira_business_context(class_name)
+        return {} unless defined?(JIRAIntegrationTool)
+        
+        begin
+          # Use MCP tool to get Jira context
+          result = JIRAIntegrationTool.call(
+            action: "search_tickets",
+            search_query: "#{class_name} business rules requirements",
+            project_key: get_default_jira_project_key,
+            server_context: {}
+          )
+          
+          if result && result.content.any?
+            data = JSON.parse(result.content.first[:text])
+            return {} if data['error']
+            
+            # Extract business context from Jira tickets
+            {
+              related_tickets: data['tickets']&.first(3) || [],
+              business_rules: extract_business_rules_from_tickets(data['tickets']),
+              requirements: extract_requirements_from_tickets(data['tickets'])
+            }
+          end
+        rescue => e
+          puts "⚠️  Failed to get Jira business context: #{e.message}"
+        end
+        
+        {}
+      end
+      
+      def get_default_jira_project_key
+        # Extract from environment or use default
+        ENV['JIRA_PROJECT_KEY'] || 'DGTL'
+      end
+      
+      def extract_business_rules_from_tickets(tickets)
+        return [] unless tickets
+        
+        tickets.flat_map do |ticket|
+          # Extract business rules from ticket summary, description, labels
+          rules = []
+          rules << ticket['summary'] if ticket['summary']&.include?('rule')
+          rules << ticket['summary'] if ticket['summary']&.include?('policy')
+          rules << ticket['summary'] if ticket['summary']&.include?('requirement')
+          rules
+        end.compact.uniq
+      end
+      
+      def extract_requirements_from_tickets(tickets)
+        return [] unless tickets
+        
+        tickets.flat_map do |ticket|
+          # Extract business context from ticket content
+          requirements = []
+          requirements << ticket['summary'] if ticket['summary']&.include?('requirement')
+          requirements << ticket['summary'] if ticket['summary']&.include?('should')
+          requirements << ticket['summary'] if ticket['summary']&.include?('need')
+          requirements
+        end.compact.uniq
+      end
+
+      # Public method for Claude Terminal to access Confluence business context
+      def get_confluence_business_context(class_name)
+        return {} unless defined?(ConfluenceIntegrationTool)
+        
+        begin
+          # Use MCP tool to get Confluence context
+          result = ConfluenceIntegrationTool.call(
+            action: "search_documents",
+            search_query: "#{class_name} PRD requirements business rules",
+            space_key: get_default_confluence_space_key,
+            server_context: {}
+          )
+          
+          if result && result.content.any?
+            data = JSON.parse(result.content.first[:text])
+            return {} if data['error']
+            
+            # Extract business context from Confluence documents
+            {
+              related_documents: data['documents']&.first(3) || [],
+              prd_content: extract_prd_content(data['documents']),
+              business_processes: extract_business_processes(data['documents'])
+            }
+          end
+        rescue => e
+          puts "⚠️  Failed to get Confluence business context: #{e.message}"
+        end
+        
+        {}
+      end
+
+      # Public method for Claude Terminal to get Confluence space key
+      def get_default_confluence_space_key
+        # Extract from environment or use default
+        ENV['CONFLUENCE_SPACE_KEY'] || 'DGTL'
+      end
+
+      # Public method for Claude Terminal to extract PRD content
+      def extract_prd_content(documents)
+        return [] unless documents
+        
+        documents.flat_map do |doc|
+          # Extract PRD content from document title, content, labels
+          content = []
+          content << doc['title'] if doc['title']&.include?('PRD')
+          content << doc['title'] if doc['title']&.include?('Product Requirements')
+          content << doc['title'] if doc['title']&.include?('Requirements')
+          content << doc['content']&.truncate(200) if doc['content']
+          content
+        end.compact.uniq
+      end
+
+      # Public method for Claude Terminal to extract business processes
+      def extract_business_processes(documents)
+        return [] unless documents
+        
+        documents.flat_map do |doc|
+          # Extract business process information from document content
+          processes = []
+          processes << doc['title'] if doc['title']&.include?('Process')
+          processes << doc['title'] if doc['title']&.include?('Workflow')
+          processes << doc['title'] if doc['title']&.include?('Procedure')
+          processes << doc['content']&.truncate(200) if doc['content']
+          processes
+        end.compact.uniq
+      end
+
+      # Public method for Claude Terminal to access Markdown business context
+      def get_markdown_business_context(class_name)
+        return {} unless CodeHealer::ConfigManager.use_markdown_context?
+        
+        begin
+          # Load from existing markdown business context
+          markdown_context = load_business_requirements_from_markdown
+          
+          if markdown_context.any?
+            {
+              markdown_files: markdown_context['markdown_requirements'] || [],
+              business_rules: extract_business_rules_from_markdown(markdown_context),
+              requirements: extract_requirements_from_markdown(markdown_context)
+            }
+          end
+        rescue => e
+          puts "⚠️  Failed to get Markdown business context: #{e.message}"
+        end
+        
+        {}
+      end
+
+      # Public method for Claude Terminal to extract business rules from markdown
+      def extract_business_rules_from_markdown(markdown_context)
+        return [] unless markdown_context['markdown_requirements']
+        
+        markdown_context['markdown_requirements'].flat_map do |file_info|
+          content = file_info[:content]
+          rules = []
+          rules << content if content.include?('rule')
+          rules << content if content.include?('policy')
+          rules << content if content.include?('requirement')
+          rules
+        end.compact.uniq
+      end
+
+      # Public method for Claude Terminal to extract requirements from markdown
+      def extract_requirements_from_markdown(markdown_context)
+        return [] unless markdown_context['markdown_requirements']
+        
+        markdown_context['markdown_requirements'].flat_map do |file_info|
+          content = file_info[:content]
+          requirements = []
+          requirements << content if content.include?('requirement')
+          requirements << content if content.include?('must')
+          requirements << content if content.include?('should')
+          requirements << content if content.include?('need')
+          requirements
+        end.compact.uniq
       end
       
       def get_evolution_history(class_name, method_name)