code_healer 0.1.19 → 0.1.20

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c459c5cc71ce5eb54b3a1798f45698c8910c71de4c9359aca6ebe143c90c9b2a
-  data.tar.gz: e521d7a05da6c0653efa4845c4d2e3770569331c699afb5a72b0df5fa7d70d90
+  metadata.gz: c54944cc1cad8a6a188bbf5b5a50a216b0719046339b59eccc12447aff916582
+  data.tar.gz: f190123758f3d4b73a7c7f53ccf8b275347819e5a7b60008085a62a79c239751
 SHA512:
-  metadata.gz: 72c3f09042c407fa37e82e88bae86a3df5fe6c0dd5ad4db832dfa69fe5531da9c2b60e4b5ae2c9e871d97a7b1b0603e205ebda328d4bcf1b88bf2b04c5df3322
-  data.tar.gz: defe95f38e8783909646739c05dc77ac8745847d13a00090fd8665027e506cb423eb367a4cb9ff05c5214594041ab3ba8ba9fe0f590f1231931bd3f28ecf0467
+  metadata.gz: 050def7293a77fb6204fb51f9fc5640caf036903b765c34be1b9c9163300e1034ae880ad3855d92480df40fe813c4590df6c1a86b812d80c9e541b8d7df8d9ef
+  data.tar.gz: 1d2874cf1817fdf4825d189f666c5fd9e9a300966892118dd79e254a4b528251d8cb85e587525735a3749f07ad75711e1ac1cdd444f30ba0c76852d4d4f62504

data/CHANGELOG.md

@@ -5,7 +5,23 @@ 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
 

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

@@ -110,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
@@ -194,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'] || {}

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)
       
@@ -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)

data/lib/code_healer/mcp_tools.rb

@@ -1,3 +1,6 @@
+require 'httparty'
+require 'cgi'
+
 module CodeHealer
   # Tool for analyzing errors with context
   class ErrorAnalysisTool < MCP::Tool
@@ -1522,9 +1525,14 @@ module CodeHealer
       return { error: "Ticket ID required" } unless ticket_id
       
       begin
-        # Simulate JIRA API call - in production, this would use actual JIRA REST API
-        if simulate_jira_available?
-          ticket_data = simulate_jira_ticket(ticket_id)
+        # Try real JIRA API first, fallback to simulation if it fails
+        if jira_api_available?
+          ticket_data = get_real_jira_ticket(ticket_id)
+          
+          if ticket_data[:error]
+            puts "⚠️  Real JIRA API failed, falling back to simulation: #{ticket_data[:error]}"
+            ticket_data = simulate_jira_ticket(ticket_id)
+          end
           
           {
             ticket_id: ticket_id,
@@ -1590,8 +1598,13 @@ module CodeHealer
       return { error: "Project key required" } unless project_key
       
       begin
-        if simulate_jira_available?
-          project_data = simulate_jira_project(project_key)
+        if jira_api_available?
+          project_data = get_real_jira_project(project_key)
+          
+          if project_data[:error]
+            puts "⚠️  Real JIRA API failed, falling back to simulation: #{project_data[:error]}"
+            project_data = simulate_jira_project(project_key)
+          end
           
           {
             project_key: project_key,
@@ -1845,6 +1858,378 @@ module CodeHealer
         priority_distribution: { "High": 20, "Medium": 60, "Low": 20 }
       }
     end
+
+    # Real JIRA API integration methods
+    def self.jira_api_available?
+      # Check if JIRA configuration is available
+      ENV['JIRA_URL'] && ENV['JIRA_USERNAME'] && ENV['JIRA_API_TOKEN']
+    end
+
+    def self.jira_api_call(endpoint, method = :get, body = nil)
+      return { error: "JIRA configuration not available" } unless jira_api_available?
+      
+      begin
+        url = "#{ENV['JIRA_URL']}/rest/api/2#{endpoint}"
+        auth = { username: ENV['JIRA_USERNAME'], password: ENV['JIRA_API_TOKEN'] }
+        
+        options = {
+          basic_auth: auth,
+          headers: { 'Content-Type' => 'application/json' }
+        }
+        
+        case method
+        when :get
+          response = HTTParty.get(url, options)
+        when :post
+          response = HTTParty.post(url, options.merge(body: body.to_json))
+        when :put
+          response = HTTParty.put(url, options.merge(body: body.to_json))
+        else
+          return { error: "Unsupported HTTP method: #{method}" }
+        end
+        
+        if response.success?
+          JSON.parse(response.body)
+        else
+          { error: "JIRA API error: #{response.code} - #{response.body}" }
+        end
+      rescue => e
+        { error: "JIRA API call failed: #{e.message}" }
+      end
+    end
+
+    def self.get_real_jira_ticket(ticket_id)
+      endpoint = "/issue/#{ticket_id}"
+      response = jira_api_call(endpoint)
+      
+      return response if response['error']
+      
+      # Transform Jira API response to our format
+      {
+        id: response['key'],
+        summary: response['fields']['summary'],
+        description: response['fields']['description'],
+        status: response['fields']['status']['name'],
+        priority: response['fields']['priority']['name'],
+        assignee: response['fields']['assignee']&.dig('emailAddress'),
+        reporter: response['fields']['reporter']&.dig('emailAddress'),
+        created: response['fields']['created'],
+        updated: response['fields']['updated'],
+        issue_type: response['fields']['issuetype']['name'],
+        project: response['fields']['project']['key'],
+        components: response['fields']['components']&.map { |c| c['name'] } || [],
+        labels: response['fields']['labels'] || [],
+        comments: response['fields']['comment']&.dig('comments')&.map { |c| 
+          { author: c['author']['emailAddress'], body: c['body'], created: c['created'] }
+        } || [],
+        attachments: response['fields']['attachment']&.map { |a| a['filename'] } || [],
+        related_issues: [], # Jira doesn't provide this directly
+        time_tracking: {
+          original_estimate: response['fields']['timeoriginalestimate'],
+          time_spent: response['fields']['timespent'],
+          remaining_estimate: response['fields']['timeestimate']
+        }
+      }
+    end
+
+    def self.get_real_jira_search(query, project_key, issue_type, status, assignee)
+      jql_parts = []
+      jql_parts << "project = #{project_key}" if project_key
+      jql_parts << "issuetype = #{issue_type}" if issue_type
+      jql_parts << "status = #{status}" if status
+      jql_parts << "assignee = #{assignee}" if assignee
+      jql_parts << "text ~ \"#{query}\"" if query
+      
+      jql = jql_parts.join(" AND ")
+      endpoint = "/search?jql=#{CGI.escape(jql)}&maxResults=10"
+      
+      response = jira_api_call(endpoint)
+      return [] if response['error']
+      
+      response['issues']&.map do |issue|
+        {
+          id: issue['key'],
+          summary: issue['fields']['summary'],
+          status: issue['fields']['status']['name'],
+          priority: issue['fields']['priority']['name'],
+          assignee: issue['fields']['assignee']&.dig('emailAddress'),
+          issue_type: issue['fields']['issuetype']['name'],
+          created: issue['fields']['created'],
+          updated: issue['fields']['updated']
+        }
+      end || []
+    end
+
+    def self.get_real_jira_project(project_key)
+      endpoint = "/project/#{project_key}"
+      response = jira_api_call(endpoint)
+      
+      return response if response['error']
+      
+      {
+        key: response['key'],
+        name: response['name'],
+        description: response['description'],
+        lead: response['lead']['emailAddress'],
+        url: "#{ENV['JIRA_URL']}/browse/#{project_key}",
+        components: response['components']&.map { |c| c['name'] } || [],
+        issue_types: response['issueTypes']&.map { |it| it['name'] } || [],
+        statuses: response['statuses']&.map { |s| s['name'] } || [],
+        versions: response['versions']&.map { |v| v['name'] } || [],
+        permissions: response['permissions'] || []
+      }
+    end
+
+    # Fallback to simulation if real API fails
+    def self.simulate_jira_available?
+      # Check if JIRA configuration is available
+      ENV['JIRA_URL'] && ENV['JIRA_USERNAME'] && ENV['JIRA_API_TOKEN']
+    end
+  end
+
+  # Tool for Confluence integration and business context retrieval
+  class ConfluenceIntegrationTool < MCP::Tool
+    description "Integrates with Confluence to retrieve PRDs, business requirements, and documentation for business context"
+    input_schema(
+      properties: {
+        action: { type: "string", enum: ["search_documents", "get_document", "get_space_info", "search_prd"] },
+        search_query: { type: "string" },
+        space_key: { type: "string" },
+        document_id: { type: "string" },
+        server_context: { type: "object" }
+      },
+      required: ["action"]
+    )
+    annotations(
+      title: "Confluence Integration Tool",
+      read_only_hint: true,
+      destructive_hint: false,
+      idempotent_hint: true,
+      open_world_hint: false
+    )
+
+    def self.call(action:, search_query: nil, space_key: nil, document_id: nil, server_context:)
+      case action
+      when "search_documents"
+        search_confluence_documents(search_query, space_key)
+      when "get_document"
+        get_confluence_document(document_id)
+      when "get_space_info"
+        get_confluence_space_info(space_key)
+      when "search_prd"
+        search_prd_documents(search_query, space_key)
+      else
+        MCP::Tool::Response.new([{ type: "text", text: { error: "Unknown action: #{action}" }.to_json }])
+      end
+    end
+
+    private
+
+    def self.search_confluence_documents(query, space_key)
+      if confluence_api_available?
+        get_real_confluence_search(query, space_key)
+      else
+        simulate_confluence_search(query, space_key)
+      end
+    end
+
+    def self.get_confluence_document(document_id)
+      if confluence_api_available?
+        get_real_confluence_document(document_id)
+      else
+        simulate_confluence_document(document_id)
+      end
+    end
+
+    def self.get_confluence_space_info(space_key)
+      if confluence_api_available?
+        get_real_confluence_space_info(space_key)
+      else
+        simulate_confluence_space_info(space_key)
+      end
+    end
+
+    def self.search_prd_documents(query, space_key)
+      if confluence_api_available?
+        get_real_confluence_prd_search(query, space_key)
+      else
+        simulate_confluence_prd_search(query, space_key)
+      end
+    end
+
+    # Real Confluence API calls
+    def self.confluence_api_available?
+      ENV['CONFLUENCE_URL'] && ENV['CONFLUENCE_USERNAME'] && ENV['CONFLUENCE_API_TOKEN']
+    end
+
+    def self.confluence_api_call(endpoint, params = {})
+      return nil unless confluence_api_available?
+
+      url = "#{ENV['CONFLUENCE_URL']}/rest/api#{endpoint}"
+      auth = { username: ENV['CONFLUENCE_USERNAME'], password: ENV['CONFLUENCE_API_TOKEN'] }
+      
+      begin
+        response = HTTParty.get(url, basic_auth: auth, query: params)
+        response.success? ? response.parsed_response : nil
+      rescue => e
+        puts "⚠️  Confluence API call failed: #{e.message}"
+        nil
+      end
+    end
+
+    def self.get_real_confluence_search(query, space_key)
+      params = {
+        cql: "space = #{space_key} AND text ~ \"#{query}\"",
+        limit: 10,
+        expand: "content"
+      }
+      
+      data = confluence_api_call('/content/search', params)
+      return { error: "Failed to search Confluence" } unless data
+
+      documents = data['results']&.map do |result|
+        {
+          id: result['id'],
+          title: result['title'],
+          type: result['type'],
+          space_key: result['space']['key'],
+          url: "#{ENV['CONFLUENCE_URL']}/wiki#{result['_links']['webui']}",
+          content: result['excerpt'] || result['title'],
+          labels: result['metadata']&.dig('labels', 'results')&.map { |l| l['name'] } || []
+        }
+      end || []
+
+      MCP::Tool::Response.new([{ type: "text", text: { documents: documents }.to_json }])
+    end
+
+    def self.get_real_confluence_document(document_id)
+      data = confluence_api_call("/content/#{document_id}")
+      return { error: "Failed to get document" } unless data
+
+      document = {
+        id: data['id'],
+        title: data['title'],
+        type: data['type'],
+        space_key: data['space']['key'],
+        url: "#{ENV['CONFLUENCE_URL']}/wiki#{data['_links']['webui']}",
+        content: data['body']&.dig('storage', 'value') || data['title'],
+        labels: data['metadata']&.dig('labels', 'results')&.map { |l| l['name'] } || []
+      }
+
+      MCP::Tool::Response.new([{ type: "text", text: { document: document }.to_json }])
+    end
+
+    def self.get_real_confluence_space_info(space_key)
+      data = confluence_api_call("/space/#{space_key}")
+      return { error: "Failed to get space info" } unless data
+
+      space_info = {
+        key: data['key'],
+        name: data['name'],
+        type: data['type'],
+        description: data['description'],
+        url: "#{ENV['CONFLUENCE_URL']}/wiki/spaces/#{space_key}",
+        permissions: data['permissions'] || []
+      }
+
+      MCP::Tool::Response.new([{ type: "text", text: { space: space_info }.to_json }])
+    end
+
+    def self.get_real_confluence_prd_search(query, space_key)
+      params = {
+        cql: "space = #{space_key} AND (text ~ \"PRD\" OR text ~ \"Product Requirements\" OR text ~ \"#{query}\")",
+        limit: 5,
+        expand: "content"
+      }
+      
+      data = confluence_api_call('/content/search', params)
+      return { error: "Failed to search PRD documents" } unless data
+
+      prd_documents = data['results']&.map do |result|
+        {
+          id: result['id'],
+          title: result['title'],
+          type: result['type'],
+          space_key: result['space']['key'],
+          url: "#{ENV['CONFLUENCE_URL']}/wiki#{result['_links']['webui']}",
+          content: result['excerpt'] || result['title'],
+          is_prd: result['title'].include?('PRD') || result['title'].include?('Product Requirements'),
+          labels: result['metadata']&.dig('labels', 'results')&.map { |l| l['name'] } || []
+        }
+      end || []
+
+      MCP::Tool::Response.new([{ type: "text", text: { documents: prd_documents }.to_json }])
+    end
+
+    # Simulation methods for when Confluence API is not available
+    def self.simulate_confluence_search(query, space_key)
+      documents = [
+        {
+          id: "sim-1",
+          title: "Business Rules for #{space_key}",
+          type: "page",
+          space_key: space_key,
+          url: "https://confluence.example.com/wiki/spaces/#{space_key}/pages/sim-1",
+          content: "Simulated business rules document for #{space_key} project",
+          labels: ["business-rules", "requirements"]
+        },
+        {
+          id: "sim-2",
+          title: "Process Documentation",
+          type: "page",
+          space_key: space_key,
+          url: "https://confluence.example.com/wiki/spaces/#{space_key}/pages/sim-2",
+          content: "Simulated process documentation for #{space_key}",
+          labels: ["process", "workflow"]
+        }
+      ]
+
+      MCP::Tool::Response.new([{ type: "text", text: { documents: documents }.to_json }])
+    end
+
+    def self.simulate_confluence_document(document_id)
+      document = {
+        id: document_id,
+        title: "Simulated Confluence Document",
+        type: "page",
+        space_key: "DGTL",
+        url: "https://confluence.example.com/wiki/spaces/DGTL/pages/#{document_id}",
+        content: "This is a simulated Confluence document content for testing purposes.",
+        labels: ["simulated", "test"]
+      }
+
+      MCP::Tool::Response.new([{ type: "text", text: { document: document }.to_json }])
+    end
+
+    def self.simulate_confluence_space_info(space_key)
+      space_info = {
+        key: space_key,
+        name: "#{space_key} Project Space",
+        type: "global",
+        description: "Simulated Confluence space for #{space_key} project",
+        url: "https://confluence.example.com/wiki/spaces/#{space_key}",
+        permissions: ["view", "edit", "create"]
+      }
+
+      MCP::Tool::Response.new([{ type: "text", text: { space: space_info }.to_json }])
+    end
+
+    def self.simulate_confluence_prd_search(query, space_key)
+      prd_documents = [
+        {
+          id: "prd-1",
+          title: "Product Requirements Document - #{space_key}",
+          type: "page",
+          space_key: space_key,
+          url: "https://confluence.example.com/wiki/spaces/#{space_key}/pages/prd-1",
+          content: "Simulated PRD for #{space_key} project with requirements and business rules",
+          is_prd: true,
+          labels: ["PRD", "requirements", "product"]
+        }
+      ]
+
+      MCP::Tool::Response.new([{ type: "text", text: { documents: prd_documents }.to_json }])
+    end
   end
 
   # Tool for intelligent context analysis and runtime decision making

data/lib/code_healer/setup.rb

@@ -252,6 +252,36 @@ github_token = ask_for_input("Enter your GitHub personal access token (or press
 github_repo = ask_for_input("Enter your GitHub repository (username/repo or full URL):")
 github_repo_url = normalize_repository_url(github_repo, github_token)
 
+# Jira Configuration
+puts
+puts "🎫 Jira Configuration:"
+puts "Configure Jira integration for business context during healing operations."
+puts "Get your API token at: https://id.atlassian.com/manage-profile/security/api-tokens"
+puts
+
+enable_jira = ask_for_yes_no("Enable Jira integration for business context?", default: false)
+
+if enable_jira
+  jira_url = ask_for_input("Enter your Jira instance URL (e.g., https://your-company.atlassian.net):")
+  jira_username = ask_for_input("Enter your Jira username/email:")
+  jira_api_token = ask_for_input("Enter your Jira API token:")
+  jira_project_key = ask_for_input("Enter your default Jira project key (e.g., DGTL):")
+  
+  # Validate Jira configuration
+  puts "🔍 Validating Jira configuration..."
+  if jira_url && jira_username && jira_api_token && jira_project_key
+    puts "✅ Jira configuration provided"
+  else
+    puts "⚠️  Incomplete Jira configuration - integration will be disabled"
+    enable_jira = false
+  end
+else
+  jira_url = ""
+  jira_username = ""
+  jira_api_token = ""
+  jira_project_key = ""
+end
+
 # Git Branch Configuration
 puts
 puts "🌿 Git Branch Configuration:"
@@ -307,6 +337,60 @@ puts
 puts "💼 Business Context Setup:"
 create_business_context = ask_for_yes_no("Would you like to create a business context file?", default: true)
 
+# Business Context Strategy Configurationy
+puts
+puts "🔍 Business Context Strategy Configuration:"
+puts "Choose how CodeHealer should get business context:"
+puts "1. Jira MCP (Claude Terminal uses its own Jira MCP)"
+puts "2. Markdown files (docs/business_rules.md)"
+puts "3. Hybrid (both Jira MCP and Markdown)"
+puts
+
+business_context_strategy = ask_for_input("Enter business context strategy (1/2/3 or jira_mcp/markdown/hybrid):", default: "jira_mcp")
+business_context_strategy = case business_context_strategy.downcase
+                           when "1", "jira_mcp"
+                             "jira_mcp"
+                           when "2", "markdown"
+                             "markdown"
+                           when "3", "hybrid"
+                             "hybrid"
+                           else
+                             "jira_mcp"
+                           end
+
+# Configure Confluence if selected
+enable_confluence = false
+confluence_url = ""
+confluence_username = ""
+confluence_api_token = ""
+confluence_space_key = ""
+
+if business_context_source == "confluence" || business_context_source == "hybrid"
+  puts
+  puts "📚 Confluence Configuration:"
+  puts "Configure Confluence integration for PRDs and documentation."
+  puts "Get your API token at: https://id.atlassian.com/manage-profile/security/api-tokens"
+  puts
+  
+  enable_confluence = ask_for_yes_no("Enable Confluence integration for business context?", default: false)
+  
+  if enable_confluence
+    confluence_url = ask_for_input("Enter your Confluence instance URL (e.g., https://your-company.atlassian.net/wiki):")
+    confluence_username = ask_for_input("Enter your Confluence username/email:")
+    confluence_api_token = ask_for_input("Enter your Confluence API token:")
+    confluence_space_key = ask_for_input("Enter your Confluence space key (e.g., DGTL):")
+    
+    # Validate Confluence configuration
+    puts "🔍 Validating Confluence configuration..."
+    if confluence_url && confluence_username && confluence_api_token && confluence_space_key
+      puts "✅ Confluence configuration provided"
+    else
+      puts "⚠️  Incomplete Confluence configuration - integration will be disabled"
+      enable_confluence = false
+    end
+  end
+end
+
 # Evolution Strategy Configuration
 puts
 puts "🧠 Evolution Strategy Configuration:"
@@ -374,6 +458,18 @@ puts
     GITHUB_TOKEN=#{github_token}
     GITHUB_REPOSITORY=#{github_repo}
     
+    # Jira Configuration
+    JIRA_URL=#{jira_url}
+    JIRA_USERNAME=#{jira_username}
+    JIRA_API_TOKEN=#{jira_api_token}
+    JIRA_PROJECT_KEY=#{jira_project_key}
+    
+    # Confluence Configuration
+    CONFLUENCE_URL=#{confluence_url}
+    CONFLUENCE_USERNAME=#{confluence_username}
+    CONFLUENCE_API_TOKEN=#{confluence_api_token}
+    CONFLUENCE_SPACE_KEY=#{confluence_space_key}
+    
     # Optional: Redis Configuration
     REDIS_URL=redis://localhost:6379/0
   ENV
@@ -436,8 +532,36 @@ create_file_with_content('.env', env_content, dry_run: options[:dry_run])
     # Business Context Configuration
     business_context:
       enabled: true
-      sources:
-        - "docs/business_rules.md"
+      strategy: "#{business_context_strategy}"
+      
+      # Jira MCP Configuration
+      jira_mcp:
+        enabled: #{business_context_strategy == 'jira_mcp' || business_context_strategy == 'hybrid'}
+        project_key: "#{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
+      markdown:
+        enabled: #{business_context_strategy == 'markdown' || business_context_strategy == 'hybrid'}
+        search_paths:
+          - "docs/business_rules.md"
+          - "docs/requirements.md"
+          - "business_requirements/"
+        include_patterns:
+          - "*.md"
+          - "*.txt"
+      
+      # Hybrid Configuration
+      hybrid:
+        priority: ["jira_mcp", "markdown"]
+        combine_results: true
     
     # OpenAI API configuration
     api:
@@ -462,6 +586,16 @@ create_file_with_content('.env', env_content, dry_run: options[:dry_run])
       auto_create: true
       labels:
         - "auto-fix"
+    
+    # Jira Integration Configuration
+    jira:
+      enabled: #{enable_jira}
+      url: "#{jira_url}"
+      username: "#{jira_username}"
+      project_key: "#{jira_project_key}"
+      business_context_enabled: #{enable_jira}
+      search_tickets_on_error: true
+      include_ticket_details: true
         - "self-evolving"
         - "bug-fix"
     
@@ -590,6 +724,11 @@ puts "   - All features are pre-configured and ready to use"
   puts "🌍 Environment Variables:"
   puts "   - Add 'gem \"dotenv-rails\"' to your Gemfile for automatic .env loading"
   puts "   - Or export variables manually: export GITHUB_TOKEN=your_token"
+  if enable_jira
+    puts "   - Jira integration: export JIRA_URL=#{jira_url}"
+    puts "   - Jira credentials: export JIRA_USERNAME=#{jira_username}"
+    puts "   - Jira project: export JIRA_PROJECT_KEY=#{jira_project_key}"
+  end
   puts "   - Or load .env file in your application.rb: load '.env' if File.exist?('.env')"
   puts
   puts "CodeHealer will now automatically detect and heal errors in your application!"

data/lib/code_healer/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module CodeHealer
-  VERSION = "0.1.19"
+  VERSION = "0.1.20"
 end

data/lib/code_healer.rb

@@ -8,12 +8,13 @@ require 'openai'
 require 'sidekiq'
 require 'git'
 require 'octokit'
+require 'open3'
 
 # CodeHealer - AI-Powered Code Healing and Self-Repair System
 module CodeHealer
   class Error < StandardError; end
   
-  # Your code goes here...
+
 end
 
 # Autoload all the main classes
@@ -88,5 +89,7 @@ if defined?(Rails)
         puts "⚠️ Claude preload failed: #{e.message}"
       end
     end
+    
+
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: code_healer
 version: !ruby/object:Gem::Version
-  version: 0.1.19
+  version: 0.1.20
 platform: ruby
 authors:
 - Deepan Kumar
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-08-21 00:00:00.000000000 Z
+date: 2025-08-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -160,6 +160,26 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 6.0.0
+- !ruby/object:Gem::Dependency
+  name: httparty
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.21.0
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.21.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.21.0
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.21.0
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -348,6 +368,7 @@ files:
 - DASHBOARD_README.md
 - GEM_SUMMARY.md
 - README.md
+- bin/start_claude_session
 - code_healer.gemspec
 - config/code_healer.yml.example
 - config/routes.rb