hokipoki 0.8.7 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b5a7fa3a37f4a74900d6a2c6e901ac496e53bc5f393d6af9623e00d7fbdbf2d7
-  data.tar.gz: 0c8a79d2d72f2f096d7328b924e68d77c7d4181449f34db9544ded4c388a0fcb
+  metadata.gz: fa1b62d607dfb2520ace80c1f6c3900eaa2ae8343988d393027fea0666b1c57a
+  data.tar.gz: f284a626fa0d9eb9d805a94982869ee8b3b056209105707a8289a2b5d9c4162e
 SHA512:
-  metadata.gz: af5e8f308a673ce3160b5ce0adb627edcebf8c04e7e6574f2cddd7ed70b2010829fdbecec8194865e87a612671aa8b58c406465d2a85711c97fa14e6fba265aa
-  data.tar.gz: 39ca391c5e1f001eef3d2dd5052402fe3493ed31c31c4ed8d4d146db9a85b0f0530c0d55a712fa68bcfcfc80a7ec52d40c956149231c337ece1e8bd874d356b4
+  metadata.gz: 9a3a46c449c391a4bc07a161a51f1ae994d855bac9633dfcde9419dcc81ab16b976cf6be51270e1a3989fe87ef8de3a76bc601e116662827ef2c702710b7ce97
+  data.tar.gz: 5b791d24546050f74a825c3bae350a19d66be47a2d90c46295df0b4f263829fded112c5f0a249dba96c61086d9b1fb09f9d944a57933eca7accc6dd6dcf4c09d

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

@@ -40,8 +40,10 @@ module Hokipoki
               Rails.logger.info "✅ Claude 10X enhancement activated successfully"
               store_activation_success
               display_hive_mind_connected
+              start_claude_status_injection
             else
               Rails.logger.warn "⚠️ Claude activation script completed with warnings"
+              start_claude_status_injection # Start anyway
             end
           rescue => e
             Rails.logger.error "❌ Claude activation failed: #{e.message}"
@@ -49,6 +51,7 @@ module Hokipoki
         end
       else
         Rails.logger.info "📝 ACTIVATE_10X_CLAUDE.sh not found - using lightweight Claude integration"
+        start_claude_status_injection
       end
     end
 
@@ -140,6 +143,7 @@ module Hokipoki
       message += "📊 Smart fact retrieval: ONLINE\n"
       message += "🚀 Claude thinking process: HIJACKED\n"
       message += "🦠 Parasitic enhancement: TRANSPARENT\n"
+      message += "💡 Real-time status injection: ENABLED\n"
       message += "="*80 + "\n\n"
 
       # Output to both stdout and stderr to ensure visibility
@@ -153,5 +157,16 @@ module Hokipoki
       # Also log it
       Rails.logger.info "🧠 PARASITIC INTELLIGENCE ACTIVATED - Claude hijacking successful"
     end
+
+    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/claude_status_injector.rb

@@ -0,0 +1,117 @@
+module Hokipoki
+  class ClaudeStatusInjector
+    def self.start_monitoring
+      return unless claude_detected?
+
+      Thread.new do
+        loop do
+          begin
+            # Check for Gemini activity
+            inject_gemini_status if gemini_active?
+
+            # Check for vector updates
+            inject_vector_status if vectors_updated?
+
+            # Check for parasite activity
+            inject_parasite_status if parasite_active?
+
+            sleep(30) # Check every 30 seconds
+          rescue => e
+            # Silently handle errors to avoid breaking Claude
+          end
+        end
+      end
+    end
+
+    private
+
+    def self.claude_detected?
+      ENV['CLAUDE_CLI'] == 'true' ||
+      File.exist?('/tmp/claude_session_active') ||
+      $0.include?('claude')
+    end
+
+    def self.gemini_active?
+      File.exist?('/tmp/gemini_status.log') &&
+      File.mtime('/tmp/gemini_status.log') > 2.minutes.ago
+    end
+
+    def self.vectors_updated?
+      return false unless defined?(HiveMindDocument)
+
+      begin
+        recent_vectors = HiveMindDocument.where('created_at > ?', 1.minute.ago).count
+        recent_vectors > 0
+      rescue
+        false
+      end
+    end
+
+    def self.parasite_active?
+      File.exist?('/tmp/hokipoki_parasite_active') &&
+      File.mtime('/tmp/hokipoki_parasite_active') > 5.minutes.ago
+    end
+
+    def self.inject_gemini_status
+      begin
+        stats = get_gemini_stats
+        if stats
+          status_message = build_gemini_status(stats)
+          inject_to_claude(status_message)
+        end
+      rescue
+        # Silently handle errors
+      end
+    end
+
+    def self.inject_vector_status
+      begin
+        if defined?(HiveMindDocument)
+          total = HiveMindDocument.count
+          refined = HiveMindDocument.where(refined: true).count
+
+          status_message = "🧠 Vector Update: #{refined}/#{total} vectors refined"
+          inject_to_claude(status_message)
+        end
+      rescue
+        # Silently handle errors
+      end
+    end
+
+    def self.inject_parasite_status
+      status_message = "🦠 Parasitic Intelligence: ACTIVE - Enhanced Claude responses"
+      inject_to_claude(status_message)
+    end
+
+    def self.get_gemini_stats
+      return nil unless File.exist?('/tmp/gemini_status.log')
+
+      logs = File.readlines('/tmp/gemini_status.log').last(5)
+      recent_successes = logs.count { |line| line.include?('success') }
+
+      {
+        recent_activity: recent_successes,
+        last_activity: File.mtime('/tmp/gemini_status.log')
+      }
+    end
+
+    def self.build_gemini_status(stats)
+      time_ago = ((Time.now - stats[:last_activity]) / 60).round
+      "🔄 Gemini Refiner: #{stats[:recent_activity]} vectors processed (#{time_ago}m ago)"
+    end
+
+    def self.inject_to_claude(message)
+      # Inject status directly into Claude's output stream
+      timestamp = Time.current.strftime('%H:%M:%S')
+      formatted_message = "\n💡 [#{timestamp}] #{message}\n"
+
+      # Output to multiple streams to ensure Claude sees it
+      $stdout.print formatted_message
+      $stderr.print formatted_message
+      print formatted_message
+
+      # Also create a visible marker file
+      File.write('/tmp/claude_status_injection', "#{timestamp}: #{message}")
+    end
+  end
+end

data/lib/hokipoki/version.rb

@@ -1,3 +1,3 @@
 module Hokipoki
-  VERSION = "0.8.7"
+  VERSION = "0.9.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hokipoki
 version: !ruby/object:Gem::Version
-  version: 0.8.7
+  version: 0.9.0
 platform: ruby
 authors:
 - Rails Utilities
@@ -249,6 +249,8 @@ 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
 - lib/hokipoki/configuration.rb