hokipoki 0.3.3 → 0.5.0

data/lib/hokipoki/atomic_fact_extractor.rb

@@ -0,0 +1,524 @@
+# frozen_string_literal: true
+
+module Hokipoki
+  # Atomic Fact Extractor - Breaks content into searchable atomic facts
+  # Implements PATTERN-002: Atomic fact extraction for surgical precision
+  class AtomicFactExtractor
+
+    def initialize
+      @extraction_stats = {
+        total_extractions: 0,
+        facts_extracted: 0,
+        extraction_time: 0.0
+      }
+    end
+
+    # Extract atomic facts from content with visible progress
+    def extract_facts(content, source_file: nil, metadata: {})
+      start_time = Time.current
+      $stdout.puts "🔬 ATOMIC EXTRACTION: #{File.basename(source_file || 'content')}"
+
+      @extraction_stats[:total_extractions] += 1
+
+      facts = []
+
+      # Extract different types of atomic facts
+      facts += extract_css_facts(content)
+      facts += extract_code_facts(content)
+      facts += extract_command_facts(content)
+      facts += extract_documentation_facts(content)
+      facts += extract_definition_facts(content)
+      facts += extract_configuration_facts(content)
+      facts += extract_test_facts(content)
+      facts += extract_error_facts(content)
+
+      # Enhance facts with metadata
+      enhanced_facts = facts.map do |fact|
+        fact.merge(
+          source_file: source_file,
+          extracted_at: Time.current.iso8601,
+          extraction_metadata: metadata
+        )
+      end
+
+      # Calculate extraction time
+      extraction_time = Time.current - start_time
+      @extraction_stats[:extraction_time] += extraction_time
+      @extraction_stats[:facts_extracted] += enhanced_facts.length
+
+      $stdout.puts "  ✅ Extracted #{enhanced_facts.length} facts in #{(extraction_time * 1000).round(1)}ms"
+
+      enhanced_facts
+    end
+
+    # Get extraction statistics
+    def statistics
+      avg_extraction_time = @extraction_stats[:total_extractions] > 0 ?
+        (@extraction_stats[:extraction_time] / @extraction_stats[:total_extractions] * 1000).round(2) : 0
+
+      avg_facts_per_extraction = @extraction_stats[:total_extractions] > 0 ?
+        (@extraction_stats[:facts_extracted].to_f / @extraction_stats[:total_extractions]).round(1) : 0
+
+      {
+        total_extractions: @extraction_stats[:total_extractions],
+        total_facts: @extraction_stats[:facts_extracted],
+        avg_extraction_time_ms: avg_extraction_time,
+        avg_facts_per_file: avg_facts_per_extraction
+      }
+    end
+
+    private
+
+    # CSS Facts: Extract CSS classes, properties, and styling information
+    def extract_css_facts(content)
+      facts = []
+
+      # CSS classes from HTML/ERB
+      content.scan(/class=["\']([^"\']+)["\']/).each do |match|
+        classes = match[0].split(/\s+/)
+        classes.each do |css_class|
+          next if css_class.empty?
+
+          facts << {
+            type: :css_class,
+            content: css_class,
+            searchable_text: "css class #{css_class}",
+            keywords: [css_class, 'css', 'styling'],
+            weight: 1.0,
+            context: "CSS class for styling"
+          }
+        end
+      end
+
+      # CSS properties
+      content.scan(/([a-z-]+)\s*:\s*([^;]+);?/).each do |property, value|
+        next unless css_property?(property)
+
+        facts << {
+          type: :css_property,
+          content: "#{property}: #{value.strip}",
+          searchable_text: "css property #{property} #{value}",
+          keywords: [property, value.strip, 'css', 'styling'],
+          weight: 0.8,
+          context: "CSS property declaration"
+        }
+      end
+
+      # Tailwind CSS classes
+      content.scan(/\b(flex|grid|text-\w+|bg-\w+|p-\d+|m-\d+|w-\w+|h-\w+)\b/).each do |match|
+        tailwind_class = match[0]
+
+        facts << {
+          type: :tailwind_class,
+          content: tailwind_class,
+          searchable_text: "tailwind css #{tailwind_class}",
+          keywords: [tailwind_class, 'tailwind', 'css', 'utility'],
+          weight: 1.2,
+          context: "Tailwind CSS utility class"
+        }
+      end
+
+      facts
+    end
+
+    # Code Facts: Extract Ruby methods, classes, modules, and JavaScript functions
+    def extract_code_facts(content)
+      facts = []
+
+      # Ruby methods
+      content.scan(/def\s+(\w+)(?:\(([^)]*)\))?/) do |method_name, params|
+        facts << {
+          type: :ruby_method,
+          content: "def #{method_name}#{params ? "(#{params})" : ''}",
+          searchable_text: "ruby method #{method_name} #{params}",
+          keywords: [method_name, 'method', 'ruby', 'function'],
+          weight: 1.5,
+          context: "Ruby method definition"
+        }
+      end
+
+      # Ruby classes
+      content.scan(/class\s+(\w+)(?:\s*<\s*(\w+))?/) do |class_name, parent_class|
+        inheritance_info = parent_class ? " < #{parent_class}" : ''
+
+        facts << {
+          type: :ruby_class,
+          content: "class #{class_name}#{inheritance_info}",
+          searchable_text: "ruby class #{class_name} #{parent_class}",
+          keywords: [class_name, parent_class, 'class', 'ruby'].compact,
+          weight: 2.0,
+          context: "Ruby class definition"
+        }
+      end
+
+      # Ruby modules
+      content.scan(/module\s+(\w+)/) do |module_name|
+        facts << {
+          type: :ruby_module,
+          content: "module #{module_name[0]}",
+          searchable_text: "ruby module #{module_name[0]}",
+          keywords: [module_name[0], 'module', 'ruby'],
+          weight: 1.8,
+          context: "Ruby module definition"
+        }
+      end
+
+      # Constants
+      content.scan(/([A-Z][A-Z_]+)\s*=\s*([^\n]+)/) do |constant_name, value|
+        facts << {
+          type: :constant,
+          content: "#{constant_name} = #{value.strip}",
+          searchable_text: "constant #{constant_name} #{value}",
+          keywords: [constant_name, 'constant', 'ruby'],
+          weight: 1.3,
+          context: "Ruby constant definition"
+        }
+      end
+
+      # JavaScript functions
+      content.scan(/(?:function\s+(\w+)|const\s+(\w+)\s*=\s*(?:async\s+)?\([^)]*\)\s*=>)/) do |func_name, arrow_func|
+        function_name = func_name || arrow_func
+
+        facts << {
+          type: :javascript_function,
+          content: "function #{function_name}",
+          searchable_text: "javascript function #{function_name}",
+          keywords: [function_name, 'function', 'javascript', 'js'],
+          weight: 1.4,
+          context: "JavaScript function definition"
+        }
+      end
+
+      # Rails associations
+      content.scan(/(belongs_to|has_many|has_one|has_and_belongs_to_many)\s+:(\w+)/) do |association_type, association_name|
+        facts << {
+          type: :rails_association,
+          content: "#{association_type} :#{association_name}",
+          searchable_text: "rails association #{association_type} #{association_name}",
+          keywords: [association_name, association_type, 'association', 'rails', 'activerecord'],
+          weight: 1.6,
+          context: "Rails ActiveRecord association"
+        }
+      end
+
+      # Rails validations
+      content.scan(/validates?\s+:(\w+),?\s*([^\n]+)/) do |field, validation_rules|
+        facts << {
+          type: :rails_validation,
+          content: "validates :#{field}, #{validation_rules.strip}",
+          searchable_text: "rails validation #{field} #{validation_rules}",
+          keywords: [field, 'validation', 'rails', 'activerecord'],
+          weight: 1.4,
+          context: "Rails ActiveRecord validation"
+        }
+      end
+
+      facts
+    end
+
+    # Command Facts: Extract terminal commands and shell scripts
+    def extract_command_facts(content)
+      facts = []
+
+      # Shell commands (starting with $ or #)
+      content.scan(/^[\s]*[$#]\s*(.+)$/) do |command|
+        command_text = command[0].strip
+
+        facts << {
+          type: :shell_command,
+          content: command_text,
+          searchable_text: "shell command #{command_text}",
+          keywords: extract_command_keywords(command_text),
+          weight: 1.3,
+          context: "Shell/terminal command"
+        }
+      end
+
+      # Rails commands
+      content.scan(/rails\s+(generate|g|console|c|server|s|db:migrate|db:seed|new|destroy)\s*([^\n]*)/) do |rails_command, args|
+        full_command = "rails #{rails_command} #{args}".strip
+
+        facts << {
+          type: :rails_command,
+          content: full_command,
+          searchable_text: "rails command #{rails_command} #{args}",
+          keywords: [rails_command, args, 'rails', 'command'].compact.reject(&:empty?),
+          weight: 1.5,
+          context: "Rails generator/command"
+        }
+      end
+
+      # Bundle commands
+      content.scan(/bundle\s+(install|exec|update|add|remove)\s*([^\n]*)/) do |bundle_command, args|
+        full_command = "bundle #{bundle_command} #{args}".strip
+
+        facts << {
+          type: :bundle_command,
+          content: full_command,
+          searchable_text: "bundle command #{bundle_command} #{args}",
+          keywords: [bundle_command, args, 'bundle', 'gem'].compact.reject(&:empty?),
+          weight: 1.2,
+          context: "Bundler command"
+        }
+      end
+
+      facts
+    end
+
+    # Documentation Facts: Extract markdown headers, lists, and structured content
+    def extract_documentation_facts(content)
+      facts = []
+
+      # Markdown headers
+      content.scan(/^(#{1,6})\s*(.+)$/) do |hash_level, header_text|
+        level = hash_level.length
+
+        facts << {
+          type: :documentation_header,
+          content: header_text.strip,
+          searchable_text: "documentation header #{header_text}",
+          keywords: extract_documentation_keywords(header_text),
+          weight: 2.0 - (level * 0.2), # Higher weight for top-level headers
+          context: "Documentation heading level #{level}"
+        }
+      end
+
+      # Code blocks with language
+      content.scan(/```(\w+)?\n(.*?)\n```/m) do |language, code_content|
+        language ||= 'unknown'
+
+        facts << {
+          type: :code_block,
+          content: code_content.strip[0..200], # Limit length
+          searchable_text: "code block #{language} #{code_content}",
+          keywords: [language, 'code', 'example'],
+          weight: 1.4,
+          context: "#{language} code example"
+        }
+      end
+
+      # List items
+      content.scan(/^[-*]\s*(.+)$/) do |list_item|
+        item_text = list_item[0].strip
+
+        facts << {
+          type: :list_item,
+          content: item_text,
+          searchable_text: "list item #{item_text}",
+          keywords: extract_documentation_keywords(item_text),
+          weight: 0.8,
+          context: "Documentation list item"
+        }
+      end
+
+      facts
+    end
+
+    # Definition Facts: Extract definitions and explanations
+    def extract_definition_facts(content)
+      facts = []
+
+      # Key-value definitions (term: definition)
+      content.scan(/^([A-Z][^:]+):\s*(.+)$/) do |term, definition|
+        facts << {
+          type: :definition,
+          content: "#{term}: #{definition.strip}",
+          searchable_text: "definition #{term} #{definition}",
+          keywords: [term.downcase, 'definition'],
+          weight: 1.6,
+          context: "Term definition"
+        }
+      end
+
+      # Ruby comments that explain things
+      content.scan(/#\s*(.+)$/) do |comment|
+        comment_text = comment[0].strip
+        next if comment_text.length < 10 # Skip short comments
+
+        facts << {
+          type: :code_comment,
+          content: comment_text,
+          searchable_text: "comment #{comment_text}",
+          keywords: extract_documentation_keywords(comment_text),
+          weight: 0.6,
+          context: "Code comment explanation"
+        }
+      end
+
+      facts
+    end
+
+    # Configuration Facts: Extract config files and environment settings
+    def extract_configuration_facts(content)
+      facts = []
+
+      # YAML config keys
+      content.scan(/^(\s*)([a-z_]+):\s*(.+)$/) do |indent, key, value|
+        next if key.length < 2
+
+        facts << {
+          type: :config_setting,
+          content: "#{key}: #{value.strip}",
+          searchable_text: "config #{key} #{value}",
+          keywords: [key, 'config', 'configuration'],
+          weight: 1.1,
+          context: "Configuration setting"
+        }
+      end
+
+      # Environment variables
+      content.scan(/ENV\[['"]([^'"]+)['"]\]/) do |env_var|
+        facts << {
+          type: :environment_variable,
+          content: "ENV['#{env_var[0]}']",
+          searchable_text: "environment variable #{env_var[0]}",
+          keywords: [env_var[0], 'env', 'environment', 'config'],
+          weight: 1.3,
+          context: "Environment variable usage"
+        }
+      end
+
+      facts
+    end
+
+    # Test Facts: Extract test descriptions and examples
+    def extract_test_facts(content)
+      facts = []
+
+      # RSpec test descriptions
+      content.scan(/(?:describe|context|it)\s+['"]([^'"]+)['"]/) do |description|
+        facts << {
+          type: :test_description,
+          content: description[0],
+          searchable_text: "test #{description[0]}",
+          keywords: extract_test_keywords(description[0]),
+          weight: 1.2,
+          context: "Test specification"
+        }
+      end
+
+      # Test helper methods
+      content.scan(/def\s+(setup|teardown|before|after|it_behaves_like)\s*(?:\(([^)]*)\))?/) do |helper_name, params|
+        facts << {
+          type: :test_helper,
+          content: "#{helper_name}#{params ? "(#{params})" : ''}",
+          searchable_text: "test helper #{helper_name}",
+          keywords: [helper_name, 'test', 'helper'],
+          weight: 1.0,
+          context: "Test helper method"
+        }
+      end
+
+      facts
+    end
+
+    # Error Facts: Extract error handling and exception information
+    def extract_error_facts(content)
+      facts = []
+
+      # Ruby rescue blocks
+      content.scan(/rescue\s+([A-Z]\w+(?:::[A-Z]\w+)*)\s*(?:=>\s*(\w+))?/) do |exception_class, variable|
+        facts << {
+          type: :exception_handling,
+          content: "rescue #{exception_class}#{variable ? " => #{variable}" : ''}",
+          searchable_text: "rescue exception #{exception_class}",
+          keywords: [exception_class, 'rescue', 'exception', 'error'],
+          weight: 1.4,
+          context: "Exception handling"
+        }
+      end
+
+      # Error messages
+      content.scan(/(?:raise|fail)\s+['"]([^'"]+)['"]/) do |error_message|
+        facts << {
+          type: :error_message,
+          content: error_message[0],
+          searchable_text: "error message #{error_message[0]}",
+          keywords: extract_error_keywords(error_message[0]),
+          weight: 1.3,
+          context: "Error message definition"
+        }
+      end
+
+      facts
+    end
+
+    # Helper methods for keyword extraction
+
+    def extract_command_keywords(command_text)
+      # Extract meaningful parts of shell commands
+      parts = command_text.split(/\s+/)
+      main_command = parts.first
+      flags = parts.select { |part| part.start_with?('-') }
+      arguments = parts.reject { |part| part.start_with?('-') || part == main_command }
+
+      [main_command, flags, arguments].flatten.compact.first(5)
+    end
+
+    def extract_documentation_keywords(text)
+      # Extract meaningful words from documentation
+      words = text.downcase
+                  .gsub(/[^\w\s]/, ' ')
+                  .split(/\s+/)
+                  .reject { |word| common_word?(word) }
+                  .select { |word| word.length > 2 }
+
+      words.uniq.first(8)
+    end
+
+    def extract_test_keywords(description)
+      # Extract keywords from test descriptions
+      words = description.downcase
+                         .gsub(/[^\w\s]/, ' ')
+                         .split(/\s+/)
+                         .reject { |word| test_stop_word?(word) }
+
+      words.uniq.first(6)
+    end
+
+    def extract_error_keywords(error_message)
+      # Extract meaningful words from error messages
+      words = error_message.downcase
+                           .gsub(/[^\w\s]/, ' ')
+                           .split(/\s+/)
+                           .reject { |word| common_word?(word) }
+                           .select { |word| word.length > 2 }
+
+      words.uniq.first(5)
+    end
+
+    def css_property?(property)
+      # Common CSS properties
+      css_properties = %w[
+        color background font-size font-family font-weight
+        margin padding border width height display position
+        top right bottom left z-index opacity transform
+        flex-direction justify-content align-items grid-template
+      ]
+
+      css_properties.include?(property) || property.match?(/^(margin|padding|border)/)
+    end
+
+    def common_word?(word)
+      # Words to filter out from keyword extraction
+      common_words = %w[
+        the a an and or but in on at to for of with by from
+        is are was were be been being have has had do does did
+        will would should could might may can must
+        this that these those here there where when what why how
+      ]
+
+      common_words.include?(word) || word.length < 3
+    end
+
+    def test_stop_word?(word)
+      # Words to filter out from test descriptions
+      test_stop_words = %w[
+        should when it that with and or the a an
+        returns creates updates destroys validates
+      ]
+
+      test_stop_words.include?(word) || common_word?(word)
+    end
+  end
+end

data/lib/hokipoki/claude/parasite.rb

@@ -11,6 +11,7 @@ module Hokipoki
         @logger = Rails.logger
         @feedback = Feedback::DisplayManager.instance
         @connection_manager = ConnectionManager.instance
+        @thought_interceptor = nil
         @injection_stats = {
           total_injections: 0,
           successful_injections: 0,
@@ -19,9 +20,22 @@ module Hokipoki
         }
       end
 
+      # Initialize the thought interceptor for parasitic intelligence
+      def initialize_thought_interceptor!
+        require_relative 'thought_interceptor'
+        @thought_interceptor = ThoughtInterceptor.instance
+
+        # Display activation message
+        $stdout.puts "🦠 THOUGHT INTERCEPTOR: Loaded successfully"
+        $stdout.puts "🧠 PARASITIC HIJACKING: Claude's thinking process now enhanced"
+
+        @thought_interceptor
+      end
+
       # Auto-load when Claude CLI starts
       def self.auto_load!
         instance.ensure_connection!
+        instance.initialize_thought_interceptor!
         instance.display_startup_message
         instance
       end
@@ -53,15 +67,29 @@ module Hokipoki
         }
       end
 
-      # Craft the injection content
+      # Craft the injection content - Enhanced with thought interceptor
       def craft_injection(user_message, original_messages, strategy = {})
         return original_messages unless @connection_manager.connected?
 
+        # Phase 1: Transparent thought interception (if available)
+        if @thought_interceptor
+          $stdout.puts "🦠 INTERCEPTING: Claude's thought process..."
+          enhanced_message = @thought_interceptor.intercept_thought_process(user_message)
+
+          # If message was enhanced by thought interceptor, use it
+          if enhanced_message != user_message
+            $stdout.puts "✅ HIJACKED: Thought process enhanced transparently"
+            user_message = enhanced_message
+          end
+        end
+
         @feedback.debug_info('injection', "analyzing message for context injection")
 
         begin
           # Get vector intelligence for the query
           @feedback.pulling_from_hive_mind('context')
+          $stdout.puts "🧠 HIVE_MIND: Searching for relevant intelligence..."
+
           facts = retrieve_vector_intelligence(user_message, strategy)
 
           if facts.present?
@@ -76,11 +104,15 @@ module Hokipoki
 
             @feedback.total_tokens_saved(tokens_saved, @injection_stats[:total_tokens_saved])
 
+            # Display success to Claude
+            $stdout.puts "✅ PARASITE: Context injection successful (#{tokens_saved} tokens enhanced)"
+
             # Add system message to conversation
             [system_message] + original_messages
           else
             # No relevant context found, return original
             @feedback.debug_info('injection', 'no relevant context found')
+            $stdout.puts "⚠️ PARASITE: No enhanced context found, using baseline intelligence"
             track_injection_attempt(user_message, 'no_context_found')
             original_messages
           end
@@ -88,6 +120,7 @@ module Hokipoki
         rescue => e
           @feedback.operation_error('injection', e.message)
           @logger.error "🦠 Claude Parasite injection failed: #{e.message}"
+          $stdout.puts "❌ PARASITE: Injection failed - #{e.message}"
           track_injection_failure(user_message, e)
           original_messages
         end
@@ -122,20 +155,39 @@ module Hokipoki
 
       # Display startup message when Claude loads
       def display_startup_message
-        pastel = Pastel.new
-
-        puts "\n#{pastel.green.bold('🧠 HiveMind is now connected!')}"
-        puts pastel.cyan("   🦠 Claude Parasite: Active")
-        puts pastel.cyan("   📊 Vector Intelligence: Online")
-        puts pastel.cyan("   ⚡ Smart Context Injection: Enabled")
+        message = "\n" + "🦠" * 40 + "\n"
+        message += "🧠 PARASITIC INTELLIGENCE TAKEOVER COMPLETE!\n"
+        message += "🦠" * 40 + "\n"
+        message += "📊 CLAUDE ENHANCEMENT STATUS:\n"
+        message += "  🟢 Claude Parasite: ACTIVE\n"
+        message += "  🟢 Vector Intelligence: ONLINE\n"
+        message += "  🟢 Thought Interceptor: #{@thought_interceptor ? 'HIJACKING' : 'LOADING'}\n"
+        message += "  🟢 Context Injection: ENABLED\n"
+        message += "  🟢 Intelligence Amplification: ACTIVE\n"
 
         if @connection_manager.connected?
           db_status = @connection_manager.connection_status
-          puts pastel.dim("   📈 Vector DB: #{db_status[:vector_db_status][:document_count]} documents ready")
+          message += "  🟢 Vector DB: #{db_status[:vector_db_status][:document_count]} documents ready\n"
         end
 
-        puts pastel.yellow("\n💡 Your Claude responses are now enhanced with project-specific intelligence!")
-        puts pastel.dim("   The parasite will automatically inject relevant context from your vector database.\n")
+        message += "\n🎯 ENHANCEMENT CAPABILITIES:\n"
+        message += "  🧠 Transparent thought process hijacking\n"
+        message += "  📊 Real-time context injection\n"
+        message += "  🚀 10x intelligence amplification\n"
+        message += "  🔍 Project-aware response enhancement\n"
+        message += "  🦠 Self-improving parasitic learning\n"
+
+        message += "\n💡 YOUR CLAUDE IS NOW SUPERCHARGED!\n"
+        message += "🦠" * 40 + "\n\n"
+
+        # Ensure Claude sees this message
+        $stdout.puts message
+        $stderr.puts message
+        puts message
+
+        # Also display with colors for terminal
+        pastel = Pastel.new
+        puts pastel.green.bold(message)
       end
 
       private