code_healer 0.1.18 → 0.1.20

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/pull_request_creator.rb

@@ -27,7 +27,7 @@ module CodeHealer
           puts "Creating pull request for branch: #{branch_name}"
           
           # Get target branch from configuration
-          target_branch = ConfigManager.pr_target_branch || 'main'
+          target_branch = ConfigManager.pr_target_branch
           puts "📋 Target branch for PR: #{target_branch}"
           
           pr = client.create_pull_request(

data/lib/code_healer/setup.rb

@@ -252,11 +252,51 @@ 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:"
 branch_prefix = ask_for_input("Enter branch prefix for healing branches (default: evolve):", default: "evolve")
-pr_target_branch = ask_for_input("Enter target branch for pull requests (default: main):", default: "main")
+
+# Detect the actual default branch from git
+default_branch = "main"
+if system("git rev-parse --verify master >/dev/null 2>&1")
+  default_branch = "master"
+elsif system("git rev-parse --verify main >/dev/null 2>&1")
+  default_branch = "main"
+end
+
+puts "🔍 Detected default branch: #{default_branch}"
+pr_target_branch = ask_for_input("Enter target branch for pull requests (default: #{default_branch}):", default: default_branch)
 
 # Code Heal Directory Configuration
 puts
@@ -297,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:"
@@ -364,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
@@ -426,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:
@@ -442,7 +576,9 @@ create_file_with_content('.env', env_content, dry_run: options[:dry_run])
       auto_push: true
       branch_prefix: "#{branch_prefix}"
       commit_message_template: 'Fix {{class_name}}\#\#{{method_name}}: {{error_type}}'
-      pr_target_branch: "#{pr_target_branch}"
+    
+    # Pull Request target branch (for backward compatibility)
+    pr_target_branch: "#{pr_target_branch}"
     
     # Pull Request Configuration
     pull_request:
@@ -450,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"
     
@@ -578,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.18"
+  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