hokipoki 0.1.2 → 0.1.3

data/lib/hokipoki/claude/auto_loader.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+module Hokipoki
+  module Claude
+    # Auto Loader - Automatically loads Claude integration when Claude CLI is detected
+    # Runs ACTIVATE_10X_CLAUDE.sh and establishes HiveMind connection
+    class AutoLoader
+      class << self
+        # Check if Claude CLI is running and auto-load if needed
+        def auto_load_if_claude_detected!
+          return unless claude_cli_detected?
+          return if already_loaded?
+
+          load_claude_integration!
+        end
+
+        # Force load Claude integration
+        def force_load!
+          load_claude_integration!
+        end
+
+        # Check if Claude CLI is currently running
+        def claude_cli_detected?
+          # Check for Claude CLI process
+          claude_processes = `ps aux | grep -i claude | grep -v grep`.strip
+
+          # Check for Claude CLI environment variables
+          claude_env_vars = ENV.keys.select { |key| key.include?('CLAUDE') }
+
+          # Check for Claude CLI in the current shell context
+          in_claude_session = ENV['CLAUDE_SESSION'] == 'true' ||
+                             ENV['_'] =~ /claude/ ||
+                             $PROGRAM_NAME =~ /claude/
+
+          claude_processes.present? || claude_env_vars.any? || in_claude_session
+        end
+
+        # Check if already loaded to avoid double-loading
+        def already_loaded?
+          @loaded ||= false
+        end
+
+        private
+
+        def load_claude_integration!
+          return if @loaded
+
+          puts "\n🔍 Claude CLI detected - Initializing HiveMind connection..."
+
+          begin
+            # Step 1: Run ACTIVATE_10X_CLAUDE.sh if available
+            run_activation_script
+
+            # Step 2: Load Claude parasite
+            load_claude_parasite
+
+            # Step 3: Establish connection
+            establish_connection
+
+            # Step 4: Display success message
+            display_success_message
+
+            @loaded = true
+
+          rescue => e
+            display_error_message(e)
+            false
+          end
+        end
+
+        def run_activation_script
+          script_paths = [
+            Rails.root.join('ACTIVATE_10X_CLAUDE.sh'),
+            Rails.root.join('bin', 'ACTIVATE_10X_CLAUDE.sh'),
+            './ACTIVATE_10X_CLAUDE.sh'
+          ]
+
+          script_path = script_paths.find { |path| File.exist?(path) }
+
+          if script_path
+            puts "🔧 Running #{File.basename(script_path)}..."
+
+            # Ensure script is executable
+            File.chmod(0755, script_path) if File.exist?(script_path)
+
+            # Run script in background to avoid blocking
+            pid = spawn("cd #{Rails.root} && #{script_path} > /tmp/hokipoki_activation.log 2>&1")
+
+            # Wait a moment for script to start
+            sleep(1)
+
+            # Check if script is still running or completed successfully
+            begin
+              Process.waitpid(pid, Process::WNOHANG)
+              puts "✓ Activation script initiated"
+            rescue Errno::ECHILD
+              puts "✓ Activation script completed"
+            end
+          else
+            puts "ℹ️ ACTIVATE_10X_CLAUDE.sh not found, skipping activation script"
+          end
+        end
+
+        def load_claude_parasite
+          puts "🦠 Loading Claude parasite..."
+
+          # Require Claude modules
+          require_relative 'connection_manager'
+          require_relative 'parasite'
+
+          # Auto-load the parasite
+          Claude::Parasite.auto_load!
+
+          puts "✓ Claude parasite loaded"
+        end
+
+        def establish_connection
+          puts "🔗 Establishing HiveMind connection..."
+
+          # Get connection manager and establish connection
+          connection_manager = Claude::ConnectionManager.instance
+          connection_manager.establish_connection!
+
+          puts "✓ HiveMind connection established"
+        end
+
+        def display_success_message
+          pastel = Pastel.new
+
+          puts pastel.green.bold("\n🎉 Claude ↔ HiveMind Integration Active!")
+          puts pastel.cyan("   🧠 Vector intelligence: Online")
+          puts pastel.cyan("   🦠 Smart context injection: Enabled")
+          puts pastel.cyan("   ⚡ Auto-enhancement: Ready")
+
+          puts pastel.yellow("\n💡 Your Claude responses are now supercharged!")
+          puts pastel.dim("   Every query will be enhanced with relevant project context.\n")
+        end
+
+        def display_error_message(error)
+          pastel = Pastel.new
+
+          puts pastel.red.bold("\n❌ Claude Integration Failed")
+          puts pastel.red("   Error: #{error.message}")
+          puts pastel.yellow("\n🔧 Quick Fix:")
+          puts pastel.dim("   Run: rails g hive_mind:install --claude")
+          puts ""
+        end
+      end
+    end
+  end
+end
+
+# Auto-load when Rails starts if Claude is detected
+if defined?(Rails) && Rails.env.development?
+  Rails.application.config.after_initialize do
+    # Small delay to ensure everything is loaded
+    Thread.new do
+      sleep(2) # Give Rails time to fully initialize
+      Hokipoki::Claude::AutoLoader.auto_load_if_claude_detected!
+    end
+  end
+end

data/lib/hokipoki/claude/connection_manager.rb

@@ -0,0 +1,382 @@
+# frozen_string_literal: true
+
+require 'pastel'
+require 'tty-spinner'
+
+module Hokipoki
+  module Claude
+    # Claude Connection Manager
+    # Handles Claude CLI integration, vector DB connection, and user feedback
+    class ConnectionManager
+      include Singleton
+
+      def initialize
+        @pastel = Pastel.new
+        @logger = Rails.logger
+        @connected = false
+        @connection_time = nil
+      end
+
+      # Main connection method called when Claude starts
+      def establish_connection!
+        return if @connected
+
+        display_connection_banner
+
+        spinner = TTY::Spinner.new("[:spinner] #{@pastel.yellow('Connecting to HiveMind vector database...')}", format: :dots)
+        spinner.auto_spin
+
+        begin
+          # Step 1: Check vector database connection
+          check_vector_database!
+
+          # Step 2: Run activation script
+          run_activation_script!
+
+          # Step 3: Verify parasite activation
+          verify_claude_parasite!
+
+          # Step 4: Test vector retrieval
+          test_vector_retrieval!
+
+          spinner.stop(@pastel.green('✓'))
+          display_success_message
+
+          @connected = true
+          @connection_time = Time.current
+
+          # Send connection analytics
+          track_connection_event('connected')
+
+        rescue => e
+          spinner.stop(@pastel.red('✗'))
+          display_error_message(e)
+          track_connection_event('failed', error: e.message)
+          raise e
+        end
+      end
+
+      # Check if connected to HiveMind
+      def connected?
+        @connected && vector_database_accessible?
+      end
+
+      # Get connection status
+      def connection_status
+        {
+          connected: connected?,
+          connection_time: @connection_time,
+          vector_db_status: vector_database_status,
+          parasite_status: claude_parasite_status,
+          last_retrieval: last_vector_retrieval_time,
+          system_health: system_health_check
+        }
+      end
+
+      # Display connection info in terminal
+      def display_connection_info
+        if connected?
+          puts @pastel.green.bold("\n🧠 HiveMind Status: CONNECTED")
+          puts @pastel.cyan("   📊 Vector Database: #{vector_database_status[:status]}")
+          puts @pastel.cyan("   🦠 Claude Parasite: #{claude_parasite_status[:status]}")
+          puts @pastel.cyan("   ⚡ Last Retrieval: #{format_time(last_vector_retrieval_time)}")
+          puts @pastel.cyan("   🔗 Connected Since: #{format_time(@connection_time)}")
+        else
+          puts @pastel.red.bold("\n🚫 HiveMind Status: DISCONNECTED")
+          puts @pastel.yellow("   Run: rails g hive_mind:install --claude")
+        end
+      end
+
+      # Disconnect from HiveMind
+      def disconnect!
+        @connected = false
+        @connection_time = nil
+        track_connection_event('disconnected')
+        puts @pastel.yellow("\n🔌 HiveMind disconnected")
+      end
+
+      # Test vector retrieval with feedback
+      def test_vector_retrieval(query = "test connection")
+        return false unless connected?
+
+        begin
+          result = Hokipoki.retrieve_facts(query, token_budget: 500)
+
+          if result.present?
+            puts @pastel.green("✓ Vector retrieval test successful")
+            puts @pastel.dim("  Query: #{query}")
+            puts @pastel.dim("  Result: #{result[0..100]}...")
+            update_last_retrieval_time
+            true
+          else
+            puts @pastel.yellow("⚠ Vector retrieval returned empty results")
+            false
+          end
+        rescue => e
+          puts @pastel.red("✗ Vector retrieval test failed: #{e.message}")
+          false
+        end
+      end
+
+      private
+
+      def display_connection_banner
+        puts "\n#{@pastel.cyan.bold('🚀 HokiPoki HiveMind Connection')}"
+        puts @pastel.dim("   Initializing Claude ↔ Vector Database integration...")
+      end
+
+      def check_vector_database!
+        # Check PostgreSQL connection
+        unless ActiveRecord::Base.connection.active?
+          raise ConnectionError, "PostgreSQL database not accessible"
+        end
+
+        # Check pgvector extension
+        unless pgvector_available?
+          raise ConnectionError, "pgvector extension not installed"
+        end
+
+        # Check if documents table exists
+        unless ActiveRecord::Base.connection.table_exists?('documents')
+          raise ConnectionError, "Vector database not initialized. Run: rails db:migrate"
+        end
+
+        puts @pastel.green("   ✓ Vector database accessible")
+      end
+
+      def run_activation_script!
+        script_path = Rails.root.join('ACTIVATE_10X_CLAUDE.sh')
+
+        if File.exist?(script_path)
+          puts @pastel.cyan("   🔧 Running ACTIVATE_10X_CLAUDE.sh...")
+
+          # Make sure script is executable
+          File.chmod(0755, script_path)
+
+          # Run the script and capture output
+          result = system("cd #{Rails.root} && ./ACTIVATE_10X_CLAUDE.sh > /dev/null 2>&1")
+
+          if result
+            puts @pastel.green("   ✓ Activation script completed successfully")
+          else
+            puts @pastel.yellow("   ⚠ Activation script completed with warnings")
+          end
+        else
+          puts @pastel.yellow("   ⚠ ACTIVATE_10X_CLAUDE.sh not found, skipping...")
+        end
+      end
+
+      def verify_claude_parasite!
+        # Check if Claude parasite is available
+        if claude_parasite_available?
+          puts @pastel.green("   ✓ Claude parasite loaded and ready")
+        else
+          puts @pastel.yellow("   ⚠ Claude parasite not found, generating...")
+          generate_claude_parasite!
+        end
+      end
+
+      def generate_claude_parasite!
+        parasite_result = Hokipoki.generate_parasite(
+          tool: 'claude_cli',
+          model: 'claude',
+          context_type: 'programming',
+          injection_style: 'natural',
+          behavioral_optimization: true,
+          auto_activate: true
+        )
+
+        if parasite_result[:success]
+          puts @pastel.green("   ✓ Claude parasite generated successfully")
+        else
+          raise ConnectionError, "Failed to generate Claude parasite: #{parasite_result[:error]}"
+        end
+      end
+
+      def test_vector_retrieval!
+        test_query = "hokipoki vector database connection test"
+        result = Hokipoki.retrieve_facts(test_query, token_budget: 300)
+
+        if result.present?
+          puts @pastel.green("   ✓ Vector retrieval operational")
+          update_last_retrieval_time
+        else
+          puts @pastel.yellow("   ⚠ Vector retrieval test returned empty (database may be empty)")
+        end
+      end
+
+      def display_success_message
+        puts "\n#{@pastel.green.bold('🎉 HiveMind Connection Established!')}"
+        puts @pastel.cyan("   🧠 Vector database: Ready")
+        puts @pastel.cyan("   🦠 Claude parasite: Active")
+        puts @pastel.cyan("   ⚡ Intelligence engine: Online")
+        puts @pastel.cyan("   🔗 Claude CLI: Connected")
+
+        puts "\n#{@pastel.yellow.bold('💡 Quick Commands:')}"
+        puts @pastel.dim("   Test retrieval: Hokipoki.retrieve_facts('your query')")
+        puts @pastel.dim("   System status:  Hokipoki.system_status")
+        puts @pastel.dim("   Connection info: display_connection_info")
+
+        puts "\n#{@pastel.magenta('Happy coding with enhanced AI intelligence! 🚀')}\n"
+      end
+
+      def display_error_message(error)
+        puts "\n#{@pastel.red.bold('❌ HiveMind Connection Failed')}"
+        puts @pastel.red("   Error: #{error.message}")
+
+        puts "\n#{@pastel.yellow.bold('🔧 Troubleshooting:')}"
+        puts @pastel.dim("   1. Ensure PostgreSQL is running")
+        puts @pastel.dim("   2. Run: rails db:migrate")
+        puts @pastel.dim("   3. Check: rails g hive_mind:install --claude")
+        puts @pastel.dim("   4. Verify license: echo $HOKIPOKI_LICENSE_KEY")
+        puts ""
+      end
+
+      def pgvector_available?
+        ActiveRecord::Base.connection.execute(
+          "SELECT 1 FROM pg_extension WHERE extname = 'vector'"
+        ).any?
+      rescue
+        false
+      end
+
+      def claude_parasite_available?
+        # Check if Claude parasite exists in database
+        return false unless defined?(Hokipoki::CustomParasite)
+
+        Hokipoki::CustomParasite.for_tool_and_model('claude_cli', 'claude').active.any?
+      rescue
+        false
+      end
+
+      def vector_database_accessible?
+        return false unless defined?(ActiveRecord::Base)
+
+        ActiveRecord::Base.connection.active? &&
+        ActiveRecord::Base.connection.table_exists?('documents')
+      rescue
+        false
+      end
+
+      def vector_database_status
+        if vector_database_accessible?
+          document_count = Document.count rescue 0
+          {
+            status: 'online',
+            document_count: document_count,
+            last_check: Time.current
+          }
+        else
+          {
+            status: 'offline',
+            document_count: 0,
+            last_check: Time.current
+          }
+        end
+      end
+
+      def claude_parasite_status
+        if claude_parasite_available?
+          parasite = Hokipoki::CustomParasite.for_tool_and_model('claude_cli', 'claude').active.first
+          {
+            status: 'active',
+            name: parasite&.name,
+            last_used: parasite&.last_used_at,
+            success_rate: parasite&.success_rate
+          }
+        else
+          {
+            status: 'inactive',
+            name: nil,
+            last_used: nil,
+            success_rate: 0
+          }
+        end
+      end
+
+      def last_vector_retrieval_time
+        Rails.cache.read('hokipoki_last_vector_retrieval') || 'never'
+      end
+
+      def update_last_retrieval_time
+        Rails.cache.write('hokipoki_last_vector_retrieval', Time.current, expires_in: 24.hours)
+      end
+
+      def system_health_check
+        {
+          database: vector_database_accessible? ? 'healthy' : 'unhealthy',
+          redis: redis_accessible? ? 'healthy' : 'unhealthy',
+          license: license_valid? ? 'valid' : 'invalid',
+          overall: overall_health_status
+        }
+      end
+
+      def redis_accessible?
+        return false unless defined?(Redis)
+
+        Redis.new(Hokipoki.config.redis_config).ping == 'PONG'
+      rescue
+        false
+      end
+
+      def license_valid?
+        Hokipoki::LicenseValidator.valid_license?(
+          ENV['HOKIPOKI_LICENSE_KEY']
+        )
+      end
+
+      def overall_health_status
+        health = system_health_check
+        if health[:database] == 'healthy' && health[:license] == 'valid'
+          'healthy'
+        else
+          'degraded'
+        end
+      end
+
+      def track_connection_event(event_type, metadata = {})
+        return unless Rails.env.production?
+
+        event_data = {
+          event: "claude_connection_#{event_type}",
+          timestamp: Time.current.iso8601,
+          user_id: ENV['USER'] || 'unknown',
+          hostname: Socket.gethostname,
+          rails_env: Rails.env,
+          gem_version: Hokipoki::VERSION,
+          metadata: metadata
+        }
+
+        # Log locally
+        Rails.logger.info "🔗 Claude Connection Event: #{event_data.to_json}"
+
+        # Send to analytics (non-blocking)
+        Thread.new { send_analytics_event(event_data) }
+      end
+
+      def send_analytics_event(event_data)
+        return unless Hokipoki.config.audit_logging
+
+        begin
+          # Send to your analytics endpoint
+          HTTP.timeout(3).post(
+            'https://analytics.hokipoki.ai/events',
+            json: event_data,
+            headers: { 'Content-Type': 'application/json' }
+          )
+        rescue
+          # Silently fail - analytics should never break the application
+        end
+      end
+
+      def format_time(time)
+        return 'never' unless time
+        return time if time.is_a?(String)
+
+        time.strftime('%H:%M:%S')
+      end
+
+      class ConnectionError < Hokipoki::Error; end
+    end
+  end
+end