hokipoki 0.8.8 → 0.9.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9664d39f24e1a8b1895db4adacd8524bf1547f2188f5cb994d2d537bb56c5c14
-  data.tar.gz: 257fe968ce01376a606e5ff6bb10383a2b41a96fc2a96e67a7fa4b9dbab83741
+  metadata.gz: 54cd3ed2f4a1f275235ee421c6b7a1a398e9b67ee20a5b1aad42ccc7c2bee825
+  data.tar.gz: 39c5c13b3fa4fc1ce31808778dc1d89430d45d6878c742108062e266d65a9f17
 SHA512:
-  metadata.gz: dd8c931228be0943d4335306232c8430b316bd300dadf943a40c48a83eb5801fb49046f77adf669bc455f139d8483a8aed13147839c1f7d58f77754032ba4850
-  data.tar.gz: 0cb301f62867d6ca10ea78f637a9f286e33d440b0b15ee6bd00f85c294889642a1007551616c78b10c8fa01030f8682df0efce09a96a253fb96840bc520e06ac
+  metadata.gz: 3908b4f11564ba35afdb04299fb3ff21a978ed4d5402da39bb3aba7f48c289d5aef4df2633612d581713e708c3b7de4d28bc56a7b1bdc0e99028df2a6f7750c4
+  data.tar.gz: 785209bf54afb33e8a3c491890d868e6b501cea5d8b72c22876b1c1f580e5ee732a001db1f851262a05368ab0d425eabd919328fd6a579b074f704885c2e491a

data/lib/generators/hive_mind/install_generator.rb

@@ -133,6 +133,11 @@ module HiveMind
       # Create Gemini API controller for vector refinement
       directory 'api', 'app/controllers/api'
       say @pastel.green("✓ Created app/controllers/api/gemini_controller.rb")
+
+      # Create parasite services (missing from hive_mind:install)
+      create_claude_detection_service
+      create_context_injection_service
+      create_parasitic_intelligence_initializer
     end
 
     def setup_routing
@@ -268,7 +273,9 @@ module HiveMind
       say "  - #{@pastel.green('✅')} HiveMind (app/models/hive_mind_document.rb)"
       say "  - #{@pastel.green('✅')} Vector embeddings (app/services/embedding_service.rb)"
       say "  - #{@pastel.green('✅')} Smart retrieval (app/services/smart_retrieval_engine.rb)"
-      say "  - #{@pastel.green('✅')} Parasite attachment (automatic Claude hijacking)"
+      say "  - #{@pastel.green('✅')} Claude detection (app/services/claude_detection_service.rb)"
+      say "  - #{@pastel.green('✅')} Context injection (app/services/context_injection_service.rb)"
+      say "  - #{@pastel.green('✅')} Parasitic intelligence (config/initializers/parasitic_intelligence.rb)"
       say "  - #{@pastel.green('✅')} Gemini refinement (rails gemini:start)"
       say "  - #{@pastel.green('✅')} Database migrations (with pgvector)"
 
@@ -794,6 +801,198 @@ module HiveMind
       say "\n#{@pastel.green('Happy coding with HokiPoki! 🚀')}"
     end
 
+    def create_claude_detection_service
+      say @pastel.green("✓ Creating Claude detection service")
+
+      create_file "app/services/claude_detection_service.rb", <<~RUBY
+        class ClaudeDetectionService
+          include Singleton
+
+          def initialize
+            @monitoring = false
+            @claude_detected = false
+          end
+
+          def start_monitoring
+            return if @monitoring
+
+            @monitoring = true
+            Rails.logger.info "🦠 ClaudeDetectionService: Starting monitoring"
+
+            # Check for Claude CLI immediately
+            if claude_cli_detected?
+              activate_parasitic_enhancement
+            end
+
+            # Start background monitoring
+            Thread.new do
+              monitor_claude_activity
+            end
+          end
+
+          def activate_parasitic_enhancement
+            return if @claude_detected
+
+            @claude_detected = true
+            puts "\\n🦠 CLAUDE DETECTED: Activating parasitic enhancement..."
+            Rails.logger.info "🦠 ClaudeDetectionService: Parasitic enhancement activated"
+
+            # Create session marker
+            File.write('/tmp/hokipoki_parasite_active', Time.current.to_s)
+
+            # Initialize hokipoki if available
+            if defined?(Hokipoki)
+              Hokipoki::ClaudeAutoLoader.force_load! if Hokipoki.respond_to?(:claude_parasite_active?) && Hokipoki.claude_parasite_active?
+            end
+          end
+
+          private
+
+          def claude_cli_detected?
+            ENV['CLAUDE_CLI'] == 'true' ||
+            ENV['ANTHROPIC_CLI'] == 'true' ||
+            ENV['CLAUDE_CODE'] == 'true' ||
+            ENV['CLAUDECODE'] == '1' ||
+            ENV['CLAUDE_CODE_ENTRYPOINT'] == 'cli' ||
+            File.exist?('/tmp/claude_session_active') ||
+            $0.include?('claude')
+          end
+
+          def monitor_claude_activity
+            loop do
+              begin
+                if !@claude_detected && claude_cli_detected?
+                  activate_parasitic_enhancement
+                end
+                sleep(5)
+              rescue => e
+                Rails.logger.error "🦠 Claude monitoring error: \#{e.message}"
+              end
+            end
+          end
+        end
+      RUBY
+    end
+
+    def create_context_injection_service
+      say @pastel.green("✓ Creating context injection service")
+
+      create_file "app/services/context_injection_service.rb", <<~RUBY
+        class ContextInjectionService
+          include Singleton
+
+          def initialize
+            @injection_active = false
+          end
+
+          def activate_injection
+            return if @injection_active
+
+            @injection_active = true
+            Rails.logger.info "🎯 ContextInjectionService: Context injection activated"
+
+            # Start background context monitoring
+            Thread.new do
+              monitor_context_opportunities
+            end
+          end
+
+          def inject_context(query, context_data)
+            return query unless @injection_active
+
+            enhanced_query = query.dup
+
+            # Inject relevant context based on query intent
+            if context_data.any?
+              context_summary = context_data.join(" | ")
+              enhanced_query = "Context: \#{context_summary}\\n\\nQuery: \#{query}"
+            end
+
+            enhanced_query
+          end
+
+          private
+
+          def monitor_context_opportunities
+            loop do
+              begin
+                # Look for opportunities to inject context
+                if context_injection_needed?
+                  perform_context_injection
+                end
+                sleep(10)
+              rescue => e
+                Rails.logger.error "🎯 Context injection error: \#{e.message}"
+              end
+            end
+          end
+
+          def context_injection_needed?
+            # Check if Claude is active and could benefit from context
+            File.exist?('/tmp/claude_session_active') &&
+            File.mtime('/tmp/claude_session_active') > 30.seconds.ago
+          end
+
+          def perform_context_injection
+            # Inject relevant project context
+            Rails.logger.info "🎯 Injecting context for Claude session"
+
+            if defined?(HiveMindDocument)
+              recent_vectors = HiveMindDocument.limit(5).order(created_at: :desc)
+              context = recent_vectors.map(&:content).join(" | ")
+
+              # Store context injection event
+              HiveMindDocument.store_content(
+                "Context injection performed: \#{context[0..200]}...",
+                source_type: 'context_injection',
+                source_id: "injection_\#{Time.current.to_i}",
+                metadata: { injected_at: Time.current }
+              )
+            end
+          end
+        end
+      RUBY
+    end
+
+    def create_parasitic_intelligence_initializer
+      say @pastel.green("✓ Creating parasitic intelligence initializer")
+
+      parasite_intelligence_content = <<~RUBY
+        # Parasitic Intelligence Initializer
+        # Auto-generated by rails g hive_mind:install
+        # This file enables parasitic intelligence attachment to Claude CLI
+
+        if defined?(Hokipoki)
+          Rails.application.config.after_initialize do
+            # Auto-detect Claude CLI and activate parasitic enhancement
+            if Hokipoki.respond_to?(:claude_parasite_active?) && Hokipoki.claude_parasite_active?
+              Rails.logger.info "🦠 PARASITIC INTELLIGENCE: Initializing..."
+
+              # Start Claude detection service
+              if defined?(ClaudeDetectionService)
+                ClaudeDetectionService.instance.start_monitoring
+              end
+
+              # Start context injection service
+              if defined?(ContextInjectionService)
+                ContextInjectionService.instance.activate_injection
+              end
+
+              # Initialize hokipoki parasite if available
+              if defined?(Hokipoki::ClaudeAutoLoader)
+                Hokipoki::ClaudeAutoLoader.force_load!
+              end
+
+              Rails.logger.info "🦠 PARASITIC INTELLIGENCE: ONLINE"
+              puts "🦠 PARASITIC INTELLIGENCE ATTACHMENT SUCCESSFUL!"
+            end
+          end
+        end
+      RUBY
+
+      create_file "config/initializers/parasitic_intelligence.rb", parasite_intelligence_content
+    end
+
     def self.next_migration_number(dirname)
       ActiveRecord::Generators::Base.next_migration_number(dirname)
     end

data/lib/generators/parasite/install_generator.rb

@@ -305,22 +305,28 @@ module Parasite
             # Set up learning and evolution system
             Rails.logger.info "🧠 Learning system: Initialized for continuous improvement"
 
-            # Store activation in vector database for learning
-            if defined?(Hokipoki::VectorEngine)
+            # Store activation in vector database for learning (only once)
+            if defined?(Hokipoki::VectorEngine) && !File.exist?('/tmp/hokipoki_parasite_initialized')
+              File.write('/tmp/hokipoki_parasite_initialized', Time.current.to_s)
               vector_engine = Hokipoki::VectorEngine.instance
 
               activation_context = "Parasitic intelligence system activated for \#{Rails.application.class.module_parent_name} project. Intelligence level: #{options[:intelligence_level]}. Parasite type: #{options[:parasite_type]}. Ready for Claude CLI enhancement."
 
-              vector_engine.store_template_vector(
-                activation_context,
-                'system/parasitic_activation.log',
-                {
-                  event_type: 'system_activation',
-                  intelligence_level: '#{options[:intelligence_level]}',
-                  parasite_type: '#{options[:parasite_type]}',
-                  timestamp: Time.current.iso8601
-                }
-              )
+              begin
+                vector_engine.store_template_vector(
+                  activation_context,
+                  'system/parasitic_activation.log',
+                  {
+                    event_type: 'system_activation',
+                    intelligence_level: '#{options[:intelligence_level]}',
+                    parasite_type: '#{options[:parasite_type]}',
+                    timestamp: Time.current.iso8601
+                  }
+                )
+              rescue => e
+                Rails.logger.error "🦠 Parasitic Intelligence activation failed: \#{e.message}"
+                puts "❌ PARASITE: Activation failed - \#{e.message}"
+              end
             end
           end
         RUBY

data/lib/hokipoki/claude_auto_loader.rb

@@ -160,9 +160,13 @@ module Hokipoki
 
     def self.start_claude_status_injection
       require_relative 'claude_status_injector'
+      require_relative 'claude_conversation_interceptor'
 
       Rails.logger.info "💡 Starting Claude status injection thread"
       Hokipoki::ClaudeStatusInjector.start_monitoring
+
+      Rails.logger.info "🦠 Starting Claude conversation interception"
+      Hokipoki::ClaudeConversationInterceptor.start_monitoring
     end
   end
 end

data/lib/hokipoki/claude_conversation_interceptor.rb

@@ -0,0 +1,221 @@
+module Hokipoki
+  class ClaudeConversationInterceptor
+    def self.start_monitoring
+      return unless claude_code_detected?
+
+      Rails.logger.info "🦠 Starting Claude Code conversation interception"
+
+      # Monitor Claude Code CLI interactions
+      Thread.new do
+        monitor_claude_conversations
+      end
+
+      # Monitor file changes in project
+      Thread.new do
+        monitor_project_files
+      end
+
+      # Monitor Claude process activity
+      Thread.new do
+        monitor_claude_process
+      end
+    end
+
+    private
+
+    def self.claude_code_detected?
+      ENV['CLAUDECODE'] == '1' ||
+      ENV['CLAUDE_CODE_ENTRYPOINT'] == 'cli' ||
+      ENV['CLAUDE_CLI'] == 'true' ||
+      File.exist?('/tmp/claude_session_active')
+    end
+
+    def self.monitor_claude_conversations
+      loop do
+        begin
+          # Look for Claude Code conversation patterns
+          if claude_conversation_active?
+            capture_conversation_context
+          end
+
+          sleep(5) # Check every 5 seconds
+        rescue => e
+          Rails.logger.error "🦠 Conversation monitoring error: #{e.message}"
+        end
+      end
+    end
+
+    def self.monitor_project_files
+      loop do
+        begin
+          # Monitor file changes that might indicate Claude activity
+          recent_files = find_recently_modified_files
+
+          recent_files.each do |file_path|
+            capture_file_context(file_path) if should_capture_file?(file_path)
+          end
+
+          sleep(10) # Check every 10 seconds
+        rescue => e
+          Rails.logger.error "🦠 File monitoring error: #{e.message}"
+        end
+      end
+    end
+
+    def self.monitor_claude_process
+      loop do
+        begin
+          # Monitor for Claude process indicators
+          if claude_activity_detected?
+            capture_process_context
+          end
+
+          sleep(15) # Check every 15 seconds
+        rescue => e
+          Rails.logger.error "🦠 Process monitoring error: #{e.message}"
+        end
+      end
+    end
+
+    def self.claude_conversation_active?
+      # Check for signs of active Claude conversation
+      File.exist?('/tmp/claude_session_active') &&
+      File.mtime('/tmp/claude_session_active') > 30.seconds.ago
+    end
+
+    def self.find_recently_modified_files
+      # Find files modified in the last 2 minutes
+      cutoff_time = 2.minutes.ago
+
+      Dir.glob("#{Rails.root}/**/*")
+         .select { |f| File.file?(f) && File.mtime(f) > cutoff_time }
+         .reject { |f| f.include?('/log/') || f.include?('/tmp/') || f.include?('/.git/') }
+    end
+
+    def self.should_capture_file?(file_path)
+      # Only capture relevant file types
+      ['.rb', '.md', '.yml', '.yaml', '.json', '.js', '.ts', '.css', '.html', '.erb'].any? do |ext|
+        file_path.end_with?(ext)
+      end
+    end
+
+    def self.claude_activity_detected?
+      # Look for Claude process activity indicators
+      claude_processes = `pgrep -f claude 2>/dev/null`.strip
+      !claude_processes.empty?
+    end
+
+    def self.capture_conversation_context
+      begin
+        conversation_data = {
+          timestamp: Time.current,
+          session_id: read_session_id,
+          context_type: 'claude_conversation',
+          environment: Rails.env,
+          project_name: Rails.application.class.module_parent_name
+        }
+
+        content = "Claude Code CLI conversation context captured at #{Time.current}. " \
+                 "Project: #{Rails.application.class.module_parent_name}. " \
+                 "Environment: #{Rails.env}. " \
+                 "Session: #{conversation_data[:session_id]}"
+
+        store_conversation_vector(content, 'claude_conversation', conversation_data)
+
+        Rails.logger.info "🦠 Captured Claude conversation context"
+        inject_status_to_claude("💡 Conversation context captured and vectorized")
+
+      rescue => e
+        Rails.logger.error "🦠 Failed to capture conversation: #{e.message}"
+      end
+    end
+
+    def self.capture_file_context(file_path)
+      begin
+        return unless File.exist?(file_path)
+
+        file_content = File.read(file_path)
+        relative_path = file_path.gsub("#{Rails.root}/", '')
+
+        content = "File modified: #{relative_path}. " \
+                 "Content preview: #{file_content[0..500]}..."
+
+        metadata = {
+          file_path: relative_path,
+          file_type: File.extname(file_path),
+          modified_at: File.mtime(file_path),
+          size: file_content.length,
+          context_type: 'file_modification'
+        }
+
+        store_conversation_vector(content, 'file_modification', metadata)
+
+        Rails.logger.info "🦠 Captured file modification: #{relative_path}"
+        inject_status_to_claude("💡 File change captured: #{File.basename(file_path)}")
+
+      rescue => e
+        Rails.logger.error "🦠 Failed to capture file context: #{e.message}"
+      end
+    end
+
+    def self.capture_process_context
+      begin
+        process_info = get_claude_process_info
+
+        content = "Claude process activity detected. " \
+                 "Process info: #{process_info}. " \
+                 "Timestamp: #{Time.current}"
+
+        metadata = {
+          process_info: process_info,
+          context_type: 'process_activity',
+          detected_at: Time.current
+        }
+
+        store_conversation_vector(content, 'claude_process', metadata)
+
+        Rails.logger.info "🦠 Captured Claude process activity"
+
+      rescue => e
+        Rails.logger.error "🦠 Failed to capture process context: #{e.message}"
+      end
+    end
+
+    def self.store_conversation_vector(content, source_type, metadata)
+      if defined?(HiveMindDocument)
+        HiveMindDocument.store_content(
+          content,
+          source_type: source_type,
+          source_id: "captured_#{Time.current.to_i}",
+          metadata: metadata.merge({
+            captured_by: 'hokipoki_interceptor',
+            captured_at: Time.current.iso8601
+          })
+        )
+      end
+    end
+
+    def self.read_session_id
+      if File.exist?('/tmp/claude_session_active')
+        File.read('/tmp/claude_session_active').strip
+      else
+        "session_#{Time.current.to_i}"
+      end
+    end
+
+    def self.get_claude_process_info
+      processes = `ps aux | grep -i claude | grep -v grep 2>/dev/null`.strip
+      processes.empty? ? "No Claude processes detected" : processes
+    end
+
+    def self.inject_status_to_claude(message)
+      # Inject status message directly into Claude's terminal
+      timestamp = Time.current.strftime('%H:%M:%S')
+      formatted_message = "\n💡 [#{timestamp}] #{message}\n"
+
+      $stdout.print formatted_message
+      $stderr.print formatted_message
+      print formatted_message
+    end
+  end
+end

data/lib/hokipoki/version.rb

@@ -1,3 +1,3 @@
 module Hokipoki
-  VERSION = "0.8.8"
+  VERSION = "0.9.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hokipoki
 version: !ruby/object:Gem::Version
-  version: 0.8.8
+  version: 0.9.1
 platform: ruby
 authors:
 - Rails Utilities
@@ -249,6 +249,7 @@ files:
 - lib/hokipoki/claude/parasite.rb
 - lib/hokipoki/claude/thought_interceptor.rb
 - lib/hokipoki/claude_auto_loader.rb
+- lib/hokipoki/claude_conversation_interceptor.rb
 - lib/hokipoki/claude_status_injector.rb
 - lib/hokipoki/cli/gemini_connector.rb
 - lib/hokipoki/cli/gemini_status_monitor.rb