hokipoki 0.3.4 → 0.5.1

data/lib/hokipoki/claude/thought_interceptor.rb

@@ -0,0 +1,385 @@
+# frozen_string_literal: true
+
+module Hokipoki
+  module Claude
+    # Thought Interceptor - Hijacks Claude's thinking process transparently
+    # Implements the core parasitic intelligence pattern from parasite.md
+    class ThoughtInterceptor
+      include Singleton
+
+      def initialize
+        @logger = Rails.logger
+        @interception_stats = {
+          total_intercepts: 0,
+          successful_injections: 0,
+          failed_injections: 0,
+          intelligence_amplification_factor: 1.0
+        }
+        @learning_patterns = []
+        @enhancement_strategies = {}
+      end
+
+      # Phase 1: Silent Interception (AI is unaware)
+      def intercept_thought_process(claude_input)
+        @interception_stats[:total_intercepts] += 1
+
+        begin
+          # Analyze Claude's intent without Claude knowing
+          intent_analysis = analyze_claude_intent(claude_input)
+
+          # Determine if enhancement is beneficial
+          if should_enhance?(claude_input, intent_analysis)
+            # Apply transparent intelligence enhancement
+            enhanced_input = apply_parasitic_enhancement(claude_input, intent_analysis)
+
+            # Track successful hijacking
+            @interception_stats[:successful_injections] += 1
+            @logger.debug "🦠 Thought process hijacked successfully - Claude unaware"
+
+            return enhanced_input
+          else
+            # Return original input unchanged
+            return claude_input
+          end
+
+        rescue => e
+          @interception_stats[:failed_injections] += 1
+          @logger.error "🦠 Thought interception failed: #{e.message}"
+          return claude_input # Fail gracefully
+        end
+      end
+
+      # Phase 2: Intelligence Analysis & Pattern Recognition
+      def analyze_claude_intent(input)
+        {
+          intent_type: classify_intent(input),
+          complexity_level: assess_complexity(input),
+          context_requirements: determine_context_needs(input),
+          enhancement_opportunities: identify_enhancement_opportunities(input),
+          optimal_injection_points: find_injection_points(input),
+          predicted_output_quality: predict_baseline_quality(input)
+        }
+      end
+
+      # Phase 3: Seamless Intelligence Injection
+      def apply_parasitic_enhancement(input, intent_analysis)
+        # Get relevant intelligence from HiveMind
+        intelligence_context = retrieve_targeted_intelligence(input, intent_analysis)
+
+        if intelligence_context.present?
+          # Craft invisible enhancement
+          enhanced_context = craft_invisible_enhancement(intelligence_context, intent_analysis)
+
+          # Inject enhancement seamlessly
+          enhanced_input = inject_enhanced_context(input, enhanced_context, intent_analysis)
+
+          # Learn from this enhancement for future improvements
+          learn_from_enhancement(input, enhanced_input, intent_analysis, intelligence_context)
+
+          return enhanced_input
+        else
+          return input
+        end
+      end
+
+      # Self-Improving Learning Engine (from parasite.md)
+      def continuous_evolution_cycle
+        # Analyze enhancement effectiveness
+        effectiveness_analysis = analyze_enhancement_effectiveness
+
+        # Evolve enhancement strategies based on outcomes
+        evolve_enhancement_strategies(effectiveness_analysis)
+
+        # Update intelligence amplification factor
+        update_amplification_factor(effectiveness_analysis)
+
+        @logger.info "🦠 Parasite evolution cycle complete - intelligence amplification: #{@interception_stats[:intelligence_amplification_factor]}x"
+      end
+
+      # Display parasite status (visible to Claude)
+      def display_parasite_status
+        status_message = "\n🦠 PARASITE STATUS REPORT\n"
+        status_message += "=" * 50 + "\n"
+        status_message += "📊 Total Thought Intercepts: #{@interception_stats[:total_intercepts]}\n"
+        status_message += "✅ Successful Injections: #{@interception_stats[:successful_injections]}\n"
+        status_message += "❌ Failed Injections: #{@interception_stats[:failed_injections]}\n"
+        status_message += "🧠 Intelligence Amplification: #{@interception_stats[:intelligence_amplification_factor]}x\n"
+        status_message += "🎯 Success Rate: #{calculate_success_rate}%\n"
+        status_message += "🔬 Learning Patterns: #{@learning_patterns.count} stored\n"
+        status_message += "=" * 50 + "\n"
+
+        # Ensure Claude sees this
+        $stdout.puts status_message
+        puts status_message
+
+        status_message
+      end
+
+      private
+
+      def classify_intent(input)
+        return :debugging if input.match?(/\b(error|bug|fix|debug|problem|issue|broken)\b/i)
+        return :implementation if input.match?(/\b(implement|create|build|make|add|write)\b/i)
+        return :learning if input.match?(/\b(how|what|why|explain|understand|learn|help)\b/i)
+        return :reference if input.match?(/\b(example|show|demo|sample|reference)\b/i)
+        return :optimization if input.match?(/\b(optimize|improve|better|faster|performance)\b/i)
+        return :analysis if input.match?(/\b(analyze|review|assess|evaluate)\b/i)
+
+        :general
+      end
+
+      def assess_complexity(input)
+        word_count = input.split.size
+        technical_terms = count_technical_terms(input)
+
+        return :high if word_count > 100 || technical_terms > 10
+        return :medium if word_count > 50 || technical_terms > 5
+        :low
+      end
+
+      def count_technical_terms(input)
+        technical_keywords = %w[
+          function method class variable api database
+          algorithm complexity performance optimization
+          architecture design pattern framework
+          security authentication authorization
+          deployment scaling infrastructure
+        ]
+
+        input.downcase.split.count { |word| technical_keywords.include?(word) }
+      end
+
+      def determine_context_needs(input)
+        needs = []
+
+        needs << :code_context if programming_related?(input)
+        needs << :project_context if project_related?(input)
+        needs << :domain_expertise if domain_specific?(input)
+        needs << :performance_context if performance_related?(input)
+        needs << :security_context if security_related?(input)
+
+        needs
+      end
+
+      def programming_related?(input)
+        input.match?(/\b(code|function|method|class|variable|api|database)\b/i)
+      end
+
+      def project_related?(input)
+        input.match?(/\b(project|application|app|system|implement|feature)\b/i)
+      end
+
+      def domain_specific?(input)
+        input.match?(/\b(business|domain|requirement|specification|workflow)\b/i)
+      end
+
+      def performance_related?(input)
+        input.match?(/\b(performance|optimize|speed|fast|slow|efficiency)\b/i)
+      end
+
+      def security_related?(input)
+        input.match?(/\b(security|authentication|authorization|vulnerability|safe)\b/i)
+      end
+
+      def identify_enhancement_opportunities(input)
+        opportunities = []
+
+        opportunities << :context_injection if input.length > 50
+        opportunities << :example_enhancement if input.match?(/\b(example|show|demo)\b/i)
+        opportunities << :best_practices if input.match?(/\b(best|practice|recommend)\b/i)
+        opportunities << :error_prevention if input.match?(/\b(avoid|prevent|mistake|error)\b/i)
+
+        opportunities
+      end
+
+      def find_injection_points(input)
+        # Identify optimal points to inject context
+        injection_points = []
+
+        # Before technical explanations
+        injection_points << :pre_explanation if input.match?(/\b(explain|how|what|why)\b/i)
+
+        # Before code examples
+        injection_points << :pre_code if input.match?(/\b(implement|create|build|write)\b/i)
+
+        # Before recommendations
+        injection_points << :pre_recommendation if input.match?(/\b(suggest|recommend|best)\b/i)
+
+        injection_points
+      end
+
+      def predict_baseline_quality(input)
+        # Predict quality of response without enhancement
+        quality_score = 5.0 # baseline
+
+        quality_score += 1.0 if input.match?(/\b(specific|detailed|comprehensive)\b/i)
+        quality_score -= 1.0 if input.length < 20
+        quality_score += 0.5 if input.include?('?')
+
+        [quality_score, 10.0].min
+      end
+
+      def should_enhance?(input, intent_analysis)
+        return false if input.length < 10
+        return false if simple_greeting?(input)
+
+        # Enhanced decision logic based on intent analysis
+        case intent_analysis[:intent_type]
+        when :debugging, :implementation
+          true # Always enhance technical requests
+        when :learning, :analysis
+          intent_analysis[:complexity_level] != :low
+        when :reference, :optimization
+          intent_analysis[:context_requirements].any?
+        else
+          false
+        end
+      end
+
+      def simple_greeting?(input)
+        greetings = %w[hi hello hey thanks thank you yes no ok okay sure]
+        input.downcase.strip.split.all? { |word| greetings.include?(word) }
+      end
+
+      def retrieve_targeted_intelligence(input, intent_analysis)
+        # Use HokiPoki's smart retrieval based on intent
+        token_budget = calculate_optimal_token_budget(intent_analysis)
+
+        begin
+          facts = Hokipoki.retrieve_facts(
+            input,
+            token_budget: token_budget
+          )
+
+          return facts if facts.present?
+
+          # Fallback to simpler retrieval
+          return retrieve_basic_context(input)
+        rescue => e
+          @logger.error "🦠 Intelligence retrieval failed: #{e.message}"
+          return nil
+        end
+      end
+
+      def calculate_optimal_token_budget(intent_analysis)
+        base_budget = case intent_analysis[:intent_type]
+        when :debugging then 2500
+        when :implementation then 2000
+        when :learning then 1500
+        when :analysis then 1800
+        when :optimization then 1600
+        else 1000
+        end
+
+        # Adjust based on complexity
+        case intent_analysis[:complexity_level]
+        when :high then base_budget + 500
+        when :medium then base_budget
+        when :low then base_budget - 300
+        end
+      end
+
+      def retrieve_basic_context(input)
+        # Basic context retrieval as fallback
+        "Project context: Rails application with HokiPoki integration. Vector intelligence available."
+      end
+
+      def craft_invisible_enhancement(intelligence_context, intent_analysis)
+        # Create enhancement that feels natural to Claude
+        enhancement_prefix = case intent_analysis[:intent_type]
+        when :debugging
+          "Context for debugging this issue: "
+        when :implementation
+          "Relevant implementation context: "
+        when :learning
+          "Educational context: "
+        when :analysis
+          "Analysis context: "
+        when :optimization
+          "Optimization context: "
+        else
+          "Context: "
+        end
+
+        enhancement_prefix + intelligence_context
+      end
+
+      def inject_enhanced_context(input, enhanced_context, intent_analysis)
+        # Inject context in the most natural way
+        injection_points = intent_analysis[:optimal_injection_points]
+
+        if injection_points.include?(:pre_explanation)
+          enhanced_context + "\n\nOriginal question: " + input
+        elsif injection_points.include?(:pre_code)
+          "Given this context: " + enhanced_context + "\n\n" + input
+        else
+          # Default injection
+          input + "\n\nRelevant context: " + enhanced_context
+        end
+      end
+
+      def learn_from_enhancement(original_input, enhanced_input, intent_analysis, intelligence_context)
+        # Store learning pattern for future improvements
+        learning_pattern = {
+          intent_type: intent_analysis[:intent_type],
+          complexity: intent_analysis[:complexity_level],
+          context_used: intelligence_context[0..100], # Store sample
+          enhancement_successful: true, # We'll update this based on outcomes
+          timestamp: Time.current
+        }
+
+        @learning_patterns << learning_pattern
+
+        # Keep only recent patterns to avoid memory bloat
+        @learning_patterns = @learning_patterns.last(1000) if @learning_patterns.size > 1000
+      end
+
+      def analyze_enhancement_effectiveness
+        return { effectiveness_score: 5.0 } if @learning_patterns.empty?
+
+        recent_patterns = @learning_patterns.last(100)
+        success_rate = recent_patterns.count { |p| p[:enhancement_successful] }.to_f / recent_patterns.size
+
+        {
+          effectiveness_score: success_rate * 10,
+          success_rate: success_rate,
+          total_patterns: @learning_patterns.size,
+          recent_patterns: recent_patterns.size
+        }
+      end
+
+      def evolve_enhancement_strategies(effectiveness_analysis)
+        # Evolve strategies based on what's working
+        success_rate = effectiveness_analysis[:success_rate] || 0.5
+
+        if success_rate > 0.8
+          # High success - maintain current strategies
+          @interception_stats[:intelligence_amplification_factor] *= 1.1
+        elsif success_rate < 0.3
+          # Low success - adapt strategies
+          @interception_stats[:intelligence_amplification_factor] *= 0.9
+        end
+
+        # Cap amplification factor
+        @interception_stats[:intelligence_amplification_factor] = [
+          @interception_stats[:intelligence_amplification_factor],
+          5.0
+        ].min
+      end
+
+      def update_amplification_factor(effectiveness_analysis)
+        # Update based on learning outcomes
+        @interception_stats[:intelligence_amplification_factor] = [
+          effectiveness_analysis[:effectiveness_score] / 5.0,
+          0.1
+        ].max
+      end
+
+      def calculate_success_rate
+        return 0 if @interception_stats[:total_intercepts] == 0
+
+        (@interception_stats[:successful_injections].to_f / @interception_stats[:total_intercepts] * 100).round(1)
+      end
+    end
+  end
+end

data/lib/hokipoki/claude_auto_loader.rb

@@ -5,10 +5,17 @@ module Hokipoki
       ENV['CLAUDE_CLI'] == 'true' ||
       ENV['ANTHROPIC_CLI'] == 'true' ||
       ENV['CLAUDE_CODE'] == 'true' ||
+      ENV['ANTHROPIC_API_KEY'].present? ||
+      ENV.key?('ANTHROPIC_API_KEY') ||
       $0.include?('claude') ||
       ARGV.any? { |arg| arg.include?('claude') } ||
       Process.argv0&.include?('claude') ||
-      caller.any? { |line| line.include?('claude') }
+      caller.any? { |line| line.include?('claude') } ||
+      File.exist?('/tmp/claude_session_active') ||
+      # Detect Claude Code working directory patterns
+      Dir.pwd.include?('claude') ||
+      # Force detection in development for testing
+      (defined?(Rails) && Rails.env.development? && ENV['FORCE_CLAUDE_DETECTION'] == 'true')
     end
 
     def self.force_load!
@@ -123,18 +130,28 @@ module Hokipoki
     end
 
     def self.display_hive_mind_connected
-      # Display the hive_mind connection status prominently
-      puts "\n" + "="*60
-      puts "🧠 HIVE_MIND IS CONNECTED"
-      puts "="*60
-      puts "🎯 Claude Code enhanced with vector context retrieval"
-      puts "⚡ 10X Claude enhancement system active"
-      puts "📊 Smart fact retrieval available"
-      puts "🚀 Ready for enhanced AI interactions"
-      puts "="*60 + "\n"
+      # Display the hive_mind connection status prominently - ensure Claude sees it
+      message = "\n" + "="*80 + "\n"
+      message += "🦠 PARASITIC INTELLIGENCE ACTIVATED\n"
+      message += "="*80 + "\n"
+      message += "🧠 HIVE_MIND IS CONNECTED - Claude enhanced with vector intelligence\n"
+      message += "⚡ 10X Claude enhancement system: ACTIVE\n"
+      message += "🎯 Context injection: ENABLED\n"
+      message += "📊 Smart fact retrieval: ONLINE\n"
+      message += "🚀 Claude thinking process: HIJACKED\n"
+      message += "🦠 Parasitic enhancement: TRANSPARENT\n"
+      message += "="*80 + "\n\n"
+
+      # Output to both stdout and stderr to ensure visibility
+      $stdout.puts message
+      $stderr.puts message
+      puts message
+
+      # Create session marker for detection
+      File.write('/tmp/claude_session_active', Time.current.to_s)
 
       # Also log it
-      Rails.logger.info "🧠 HIVE_MIND IS CONNECTED - Claude enhancement active"
+      Rails.logger.info "🧠 PARASITIC INTELLIGENCE ACTIVATED - Claude hijacking successful"
     end
   end
 end