hokipoki 0.5.1 → 0.7.0

data/lib/hokipoki/cli/gemini_status_monitor.rb

@@ -0,0 +1,220 @@
+module Hokipoki
+  module CLI
+    class GeminiStatusMonitor
+      def self.show
+        puts "🎯 Starting Gemini Refinement Dashboard..."
+        sleep(1)
+
+        loop do
+          clear_screen
+          display_header
+          display_stats
+          display_current_work
+          display_activity_log
+          display_controls
+          sleep(2)
+        end
+      rescue Interrupt
+        puts "\n\n👋 Gemini refinement dashboard stopped."
+        cleanup_temp_files
+        exit(0)
+      end
+
+      private
+
+      def self.clear_screen
+        system('clear') || system('cls')
+      end
+
+      def self.display_header
+        puts "╔═══════════════════════════════════════════════════════╗"
+        puts "║      🧠 GEMINI VECTOR REFINEMENT DASHBOARD           ║"
+        puts "╚═══════════════════════════════════════════════════════╝"
+        puts ""
+      end
+
+      def self.display_stats
+        stats = fetch_refinement_stats
+
+        puts "📊 REFINEMENT STATS"
+        puts "─────────────────────────────────────"
+        puts "  Total Vectors:     #{stats[:total_vectors]}"
+        puts "  Refined:          #{stats[:refined_count]} ✅"
+        puts "  Pending:          #{stats[:pending_count]} ⏳"
+        puts "  Processing Rate:  #{stats[:rate]}/min"
+        puts "  Last Updated:     #{Time.current.strftime('%H:%M:%S')}"
+        puts ""
+      end
+
+      def self.display_current_work
+        current = fetch_current_refinement
+
+        if current
+          puts "🔄 CURRENTLY REFINING"
+          puts "─────────────────────────────────────"
+          puts "  Vector ID: #{current[:id]}"
+          puts "  Content:   #{truncate_text(current[:content], 60)}"
+          puts "  Progress:  #{progress_bar(current[:progress])}"
+          puts ""
+        else
+          puts "💤 IDLE - Waiting for vectors to refine..."
+          puts ""
+        end
+      end
+
+      def self.display_activity_log
+        puts "📜 RECENT ACTIVITY"
+        puts "─────────────────────────────────────"
+
+        logs = recent_logs
+        if logs.empty?
+          puts "  🔍 No recent activity - system initializing..."
+        else
+          logs.last(5).each do |log|
+            icon = case log[:status]
+                   when 'success' then '✅'
+                   when 'error' then '❌'
+                   when 'processing' then '🔄'
+                   else '📝'
+                   end
+            puts "  #{icon} [#{log[:time]}] #{log[:message]}"
+          end
+        end
+        puts ""
+      end
+
+      def self.display_controls
+        puts "🎮 CONTROLS"
+        puts "─────────────────────────────────────"
+        puts "  Ctrl+C: Stop dashboard and exit"
+        puts "  Dashboard auto-refreshes every 2 seconds"
+        puts ""
+      end
+
+      def self.fetch_refinement_stats
+        begin
+          if defined?(Rails) && defined?(HiveMindDocument)
+            total = HiveMindDocument.count
+            refined = HiveMindDocument.where(refined: true).count
+            pending = total - refined
+
+            # Calculate processing rate from recent activity
+            rate = calculate_processing_rate
+
+            {
+              total_vectors: total,
+              refined_count: refined,
+              pending_count: pending,
+              rate: rate
+            }
+          else
+            {
+              total_vectors: 0,
+              refined_count: 0,
+              pending_count: 0,
+              rate: 0
+            }
+          end
+        rescue => e
+          {
+            total_vectors: "Error",
+            refined_count: "Error",
+            pending_count: "Error",
+            rate: 0
+          }
+        end
+      end
+
+      def self.fetch_current_refinement
+        begin
+          # Check if there's a current refinement status
+          status_file = '/tmp/gemini_current_refinement.json'
+          if File.exist?(status_file)
+            current_data = JSON.parse(File.read(status_file))
+            return {
+              id: current_data['id'],
+              content: current_data['content'],
+              progress: current_data['progress'] || 0
+            }
+          end
+        rescue => e
+          # Ignore errors, just return nil
+        end
+
+        nil
+      end
+
+      def self.recent_logs
+        begin
+          log_file = '/tmp/gemini_status.log'
+          return [] unless File.exist?(log_file)
+
+          File.readlines(log_file).map do |line|
+            next nil if line.strip.empty?
+
+            parts = line.strip.split(' - ', 3)
+            next nil if parts.length < 3
+
+            {
+              time: parts[0],
+              status: parts[1],
+              message: parts[2]
+            }
+          end.compact
+        rescue => e
+          []
+        end
+      end
+
+      def self.calculate_processing_rate
+        begin
+          logs = recent_logs
+          successful_logs = logs.select { |log| log[:status] == 'success' }
+
+          # Count successes in last 5 minutes
+          five_min_ago = Time.current - 5.minutes
+          recent_successes = successful_logs.select do |log|
+            begin
+              log_time = Time.parse(log[:time])
+              log_time > five_min_ago
+            rescue
+              false
+            end
+          end
+
+          # Convert to per-minute rate
+          (recent_successes.count * 12) / 10.0 # Approximate rate per minute
+        rescue => e
+          0
+        end
+      end
+
+      def self.progress_bar(percent)
+        return "[░░░░░░░░░░░░░░░░░░░░] 0%" if percent.nil? || percent == 0
+
+        filled = '█' * (percent / 5).to_i
+        empty = '░' * (20 - (percent / 5).to_i)
+        "[#{filled}#{empty}] #{percent}%"
+      end
+
+      def self.truncate_text(text, length)
+        return "" if text.nil?
+        text.length > length ? "#{text[0..length-3]}..." : text
+      end
+
+      def self.cleanup_temp_files
+        temp_files = [
+          '/tmp/gemini_status.fifo',
+          '/tmp/gemini_refined_vectors.fifo',
+          '/tmp/gemini_current_refinement.json'
+        ]
+
+        temp_files.each do |file|
+          File.delete(file) if File.exist?(file)
+        rescue
+          # Ignore cleanup errors
+        end
+      end
+    end
+  end
+end

data/lib/hokipoki/configuration.rb

@@ -2,12 +2,64 @@
 
 module Hokipoki
   class Configuration
-    attr_accessor :hive_mind_enabled,
+    attr_accessor :enabled,
+                  :environment,
+                  :auth_type,
+                  :auth_password,
+                  :vector_storage,
+                  :vector_db_path,
+                  :parasite_mode,
+                  :claude_detection,
+                  :visible_output,
+                  :max_context_tokens,
+                  :max_response_tokens,
+                  :total_token_budget,
+                  :template_compression,
+                  :atomic_facts,
+                  :compression_target,
+                  :encryption_key,
+                  :vector_encryption,
+                  :github_client_id,
+                  :github_client_secret,
+                  :debug_mode,
+                  :verbose_logging,
+                  :hive_mind_enabled,
                   :claude_parasite_enabled,
                   :redis_url
 
     def initialize
-      # Simple configuration for lightweight HiveMind
+      # Core settings
+      @enabled = true
+      @environment = 'development'
+
+      # Authentication settings
+      @auth_type = 'simple'
+      @auth_password = 'Qweasd@300117903'
+
+      # Vector database settings
+      @vector_storage = :sqlite
+      @vector_db_path = File.expand_path('~/.hokipoki/vectors.db')
+
+      # Parasite settings
+      @parasite_mode = :auto_detect
+      @claude_detection = :enhanced
+      @visible_output = true
+
+      # Token budget management
+      @max_context_tokens = 1500
+      @max_response_tokens = 1000
+      @total_token_budget = 3000
+
+      # Compression settings
+      @template_compression = true
+      @atomic_facts = true
+      @compression_target = 0.75
+
+      # Development settings
+      @debug_mode = false
+      @verbose_logging = false
+
+      # Legacy settings
       @hive_mind_enabled = false # Will be true after installation
       @claude_parasite_enabled = true
       @redis_url = ENV.fetch('REDIS_URL', 'redis://localhost:6379/0')

data/lib/hokipoki/vector_engine.rb

@@ -30,30 +30,53 @@ module Hokipoki
 
     # Main API - Retrieve intelligent facts with template generation
     def retrieve_facts(query, token_budget: 1500)
+      start_time = Time.current
       $stdout.puts "🧠 VECTOR ENGINE: Analyzing query intent..."
+      $stdout.puts "💰 Token Budget: #{token_budget} tokens"
 
       begin
         # 1. Analyze query intent with multiple dimensions
+        show_progress_bar("Analyzing intent", 0.2)
         intent = analyze_query_intent(query)
         $stdout.puts "  🎯 Intent detected: #{intent}"
 
         # 2. Extract technical keywords
+        show_progress_bar("Extracting keywords", 0.4)
         keywords = extract_technical_keywords(query)
-        $stdout.puts "  📝 Keywords: #{keywords.join(', ')}"
+        $stdout.puts "  📝 Keywords (#{keywords.length}): #{keywords.join(', ')}"
 
         # 3. Find matching template vectors
+        show_progress_bar("Searching vectors", 0.6)
         matching_vectors = find_matching_vectors(keywords, intent)
         $stdout.puts "  🔍 Found #{matching_vectors.length} matching vectors"
 
         if matching_vectors.any?
           # 4. Generate content from templates
+          show_progress_bar("Generating content", 0.8)
           generated_content = generate_content_from_vectors(matching_vectors, intent, keywords)
+          original_tokens = estimate_tokens(generated_content)
 
           # 5. Apply token budget management
+          show_progress_bar("Optimizing tokens", 0.9)
           final_content = apply_token_budget(generated_content, token_budget)
+          final_tokens = estimate_tokens(final_content)
+
+          # Calculate savings
+          tokens_saved = original_tokens - final_tokens
+          compression_percent = tokens_saved > 0 ? ((tokens_saved.to_f / original_tokens) * 100).round(1) : 0
+
+          show_progress_bar("Complete", 1.0)
+          elapsed_time = ((Time.current - start_time) * 1000).round(1)
 
           @stats[:successful_retrievals] += 1
-          $stdout.puts "  ✅ Content generated (#{estimate_tokens(final_content)} tokens)"
+          @stats[:total_tokens_saved] = (@stats[:total_tokens_saved] || 0) + tokens_saved
+
+          # Enhanced success display
+          $stdout.puts "  ✅ RETRIEVAL SUCCESSFUL!"
+          $stdout.puts "     📊 Original: #{original_tokens} tokens → Final: #{final_tokens} tokens"
+          $stdout.puts "     💰 Tokens Saved: #{tokens_saved} (#{compression_percent}% compression)"
+          $stdout.puts "     ⚡ Processing Time: #{elapsed_time}ms"
+          $stdout.puts "     🧠 Vectors Used: #{matching_vectors.length}/#{@stats[:total_vectors]}"
 
           # Learn from successful retrieval
           learn_from_success(query, keywords, intent, final_content)
@@ -61,10 +84,20 @@ module Hokipoki
           return [final_content]
         else
           # Fallback to template-based generation
-          $stdout.puts "  ⚠️ No vectors found, using template fallback"
+          show_progress_bar("Fallback mode", 0.8)
           fallback_content = generate_fallback_content(query, intent, keywords)
+          fallback_tokens = estimate_tokens(fallback_content)
+
+          show_progress_bar("Complete", 1.0)
+          elapsed_time = ((Time.current - start_time) * 1000).round(1)
 
           @stats[:failed_retrievals] += 1
+
+          $stdout.puts "  ⚠️ FALLBACK MODE ACTIVATED"
+          $stdout.puts "     📊 Fallback Content: #{fallback_tokens} tokens"
+          $stdout.puts "     ⚡ Processing Time: #{elapsed_time}ms"
+          $stdout.puts "     🔄 Recommendation: Add more vectors for better results"
+
           return [fallback_content]
         end
 
@@ -518,6 +551,102 @@ module Hokipoki
       $stdout.puts "💾 Database: #{@db_path}"
       $stdout.puts "📊 Ready for parasitic intelligence operations"
     end
+
+    # Enhanced progress bar with visual feedback
+    def show_progress_bar(task, progress)
+      bar_width = 20
+      filled = (progress * bar_width).round
+      empty = bar_width - filled
+
+      bar = "█" * filled + "░" * empty
+      percentage = (progress * 100).round(1)
+
+      $stdout.puts "  🔄 #{task.ljust(18)} [#{bar}] #{percentage}%"
+      sleep(0.1) # Brief pause for visual effect
+    end
+
+    # Enhanced statistics with token savings and performance metrics
+    def enhanced_statistics
+      stats = statistics
+      total_operations = @stats[:successful_retrievals] + @stats[:failed_retrievals]
+
+      avg_tokens_saved = total_operations > 0 ?
+        ((@stats[:total_tokens_saved] || 0).to_f / total_operations).round(1) : 0
+
+      total_tokens_saved = @stats[:total_tokens_saved] || 0
+
+      {
+        total_vectors: stats[:total_vectors],
+        success_rate: stats[:success_rate],
+        average_compression: stats[:average_compression],
+        total_operations: total_operations,
+        successful_retrievals: @stats[:successful_retrievals],
+        failed_retrievals: @stats[:failed_retrievals],
+        total_tokens_saved: total_tokens_saved,
+        avg_tokens_saved_per_operation: avg_tokens_saved,
+        cache_size: stats[:cache_size],
+        database_size: stats[:database_size],
+        learning_patterns: stats[:learning_patterns]
+      }
+    end
+
+    # Display comprehensive system status with token savings
+    def display_enhanced_status
+      stats = enhanced_statistics
+
+      $stdout.puts "\n🧠 ENHANCED VECTOR ENGINE STATUS"
+      $stdout.puts "=" * 50
+      $stdout.puts "📊 PERFORMANCE METRICS:"
+      $stdout.puts "   🔢 Total Vectors: #{stats[:total_vectors]}"
+      $stdout.puts "   ✅ Success Rate: #{stats[:success_rate]}%"
+      $stdout.puts "   🗜️ Avg Compression: #{stats[:average_compression]}%"
+      $stdout.puts "   🔄 Total Operations: #{stats[:total_operations]}"
+      $stdout.puts ""
+      $stdout.puts "💰 TOKEN SAVINGS:"
+      $stdout.puts "   💎 Total Saved: #{stats[:total_tokens_saved]} tokens"
+      $stdout.puts "   📈 Avg Per Operation: #{stats[:avg_tokens_saved_per_operation]} tokens"
+      $stdout.puts "   💵 Estimated Cost Savings: $#{(stats[:total_tokens_saved] * 0.00002).round(4)}"
+      $stdout.puts ""
+      $stdout.puts "🔧 SYSTEM STATUS:"
+      $stdout.puts "   💾 Cache Size: #{stats[:cache_size]} entries"
+      $stdout.puts "   📁 Database Size: #{(stats[:database_size] / 1024.0).round(2)} KB"
+      $stdout.puts "   🧠 Learning Patterns: #{stats[:learning_patterns]}"
+      $stdout.puts "   ⚡ Status: #{stats[:total_operations] > 0 ? 'ACTIVE' : 'READY'}"
+      $stdout.puts "=" * 50
+    end
+
+    # Display real-time retrieval metrics during operation
+    def display_retrieval_progress(operation, details = {})
+      timestamp = Time.current.strftime("%H:%M:%S.%L")
+
+      case operation
+      when :start
+        $stdout.puts "\n⏱️ [#{timestamp}] RETRIEVAL SESSION STARTED"
+        $stdout.puts "   🎯 Query: \"#{details[:query]}\""
+        $stdout.puts "   💰 Token Budget: #{details[:token_budget]} tokens"
+
+      when :intent_analysis
+        $stdout.puts "   🧠 [#{timestamp}] Intent Analysis: #{details[:intent]}"
+
+      when :keyword_extraction
+        $stdout.puts "   📝 [#{timestamp}] Keywords (#{details[:count]}): #{details[:keywords]}"
+
+      when :vector_search
+        $stdout.puts "   🔍 [#{timestamp}] Vector Search: #{details[:matches]} matches found"
+
+      when :content_generation
+        $stdout.puts "   ⚙️ [#{timestamp}] Content Generation: #{details[:original_tokens]} tokens"
+
+      when :optimization
+        $stdout.puts "   🎯 [#{timestamp}] Token Optimization: #{details[:final_tokens]} tokens"
+        $stdout.puts "   💰 Tokens Saved: #{details[:tokens_saved]} (#{details[:compression_percent]}%)"
+
+      when :complete
+        elapsed = details[:elapsed_time]
+        $stdout.puts "   ✅ [#{timestamp}] COMPLETE (#{elapsed}ms total)"
+        $stdout.puts "   📊 Final Efficiency: #{details[:efficiency_score]}%"
+      end
+    end
   end
 end
 

data/lib/hokipoki/version.rb

@@ -1,3 +1,3 @@
 module Hokipoki
-  VERSION = "0.5.1"
+  VERSION = "0.7.0"
 end

data/lib/hokipoki.rb

@@ -313,6 +313,16 @@ module Hokipoki
     def reset!
       self.configuration = nil
     end
+
+    # Quick status check command
+    def status
+      display_immediate_status
+    end
+
+    # Quick connection status
+    def connection_status
+      display_connection_status
+    end
   end
 end
 
@@ -321,14 +331,159 @@ if defined?(Rails)
   require_relative "hokipoki/railtie"
 
   # Force Claude activation on Rails startup if detected
-  Rails.application.config.after_initialize do
+  if Rails.application
+    Rails.application.config.after_initialize do
     # Small delay to ensure everything is loaded
     Thread.new do
       sleep(1) # Give Rails time to initialize
       if Hokipoki.claude_parasite_active?
         $stdout.puts "🦠 FORCE ACTIVATION: Claude CLI detected during Rails startup"
         ClaudeAutoLoader.force_load!
+
+        # Start persistent status monitor
+        Hokipoki.start_persistent_status_monitor
       end
     end
   end
+  end
+end
+
+# Persistent Status Monitoring System
+module Hokipoki
+  class << self
+    def start_persistent_status_monitor
+      return if @status_monitor_running
+
+      @status_monitor_running = true
+      @last_status_display = Time.current
+
+      Thread.new do
+        loop do
+          display_connection_status if should_display_status?
+          sleep(30) # Check every 30 seconds
+        end
+      rescue => e
+        Rails.logger.error "Hokipoki status monitor error: #{e.message}" if defined?(Rails)
+      end
+    end
+
+    def display_connection_status
+      status = get_detailed_status
+      timestamp = Time.current.strftime("%H:%M:%S")
+
+      # Always visible status line
+      status_line = "[#{timestamp}] "
+
+      if status[:hive_mind_connected]
+        status_line += "🧠 HIVE_MIND: CONNECTED | "
+      else
+        status_line += "⚠️ HIVE_MIND: DISCONNECTED | "
+      end
+
+      if status[:parasite_active]
+        status_line += "🦠 PARASITE: INTERCEPTING | "
+      else
+        status_line += "🔄 PARASITE: STANDBY | "
+      end
+
+      if status[:token_savings_active]
+        status_line += "💰 SAVINGS: #{status[:total_tokens_saved]} tokens"
+      else
+        status_line += "💰 SAVINGS: READY"
+      end
+
+      $stdout.puts status_line
+      @last_status_display = Time.current
+    end
+
+    def should_display_status?
+      return true if @last_status_display.nil?
+      Time.current - @last_status_display > 60 # Every minute when Claude is active
+    end
+
+    def get_detailed_status
+      {
+        hive_mind_connected: hive_mind_connected?,
+        parasite_active: claude_parasite_active?,
+        token_savings_active: token_savings_active?,
+        total_tokens_saved: get_total_tokens_saved,
+        rails_server_running: rails_server_running?
+      }
+    end
+
+    def hive_mind_connected?
+      return false unless defined?(Rails) && Rails.application
+
+      begin
+        # Check if HiveMindDocument model exists and database is accessible
+        defined?(HiveMindDocument) && HiveMindDocument.table_exists?
+      rescue => e
+        false
+      end
+    end
+
+    def token_savings_active?
+      return false unless defined?(VectorEngine)
+
+      begin
+        engine = VectorEngine.instance
+        stats = engine.statistics
+        stats[:successful_retrievals] > 0
+      rescue => e
+        false
+      end
+    end
+
+    def get_total_tokens_saved
+      return 0 unless defined?(VectorEngine)
+
+      begin
+        engine = VectorEngine.instance
+        stats = engine.enhanced_statistics
+        stats[:total_tokens_saved] || 0
+      rescue => e
+        0
+      end
+    end
+
+    def rails_server_running?
+      return false unless defined?(Rails)
+
+      begin
+        # Simple check - if we can access Rails application, server is likely running
+        Rails.application.present?
+      rescue => e
+        false
+      end
+    end
+
+    # Enhanced status for immediate display
+    def display_immediate_status
+      $stdout.puts "\n🔍 HOKIPOKI SYSTEM STATUS"
+      $stdout.puts "=" * 50
+
+      status = get_detailed_status
+
+      $stdout.puts "🚀 SERVICES:"
+      $stdout.puts "   #{status[:rails_server_running] ? '🟢' : '🔴'} Rails Server: #{status[:rails_server_running] ? 'RUNNING' : 'STOPPED'}"
+      $stdout.puts "   #{status[:hive_mind_connected] ? '🟢' : '🔴'} HiveMind: #{status[:hive_mind_connected] ? 'CONNECTED' : 'DISCONNECTED'}"
+      $stdout.puts "   #{status[:parasite_active] ? '🟢' : '🔴'} Parasite: #{status[:parasite_active] ? 'ACTIVE' : 'INACTIVE'}"
+
+      $stdout.puts "\n💰 PERFORMANCE:"
+      $stdout.puts "   🎯 Token Savings: #{status[:token_savings_active] ? 'ACTIVE' : 'READY'}"
+      $stdout.puts "   💎 Total Saved: #{status[:total_tokens_saved]} tokens"
+      $stdout.puts "   💵 Cost Savings: $#{(status[:total_tokens_saved] * 0.00002).round(4)}"
+
+      $stdout.puts "\n🎯 CLAUDE ENHANCEMENT: #{all_systems_operational?(status) ? 'MAXIMUM' : 'LIMITED'}"
+      $stdout.puts "=" * 50
+
+      status
+    end
+
+    private
+
+    def all_systems_operational?(status)
+      status[:hive_mind_connected] && status[:parasite_active] && status[:rails_server_running]
+    end
+  end
 end