hokipoki 0.6.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ed4df53728ff68f28ed85980d403bf9d88334ab640b9c21d4dba872829809828
-  data.tar.gz: 4df94c5a23b270a76594dbdc2b7388c7e72c50c5923f28c0c52de442dd1c3d92
+  metadata.gz: 4fdce824f42ae5123c16881e6750eea924cff8b6b2cd498f4329050411994d18
+  data.tar.gz: 8b150ca5b979b06b4265db8c0cdb873045dece1d85b39ac440b436919a096bd0
 SHA512:
-  metadata.gz: f8303c679e50d81757ae0333a223ed6ffe3101422a4dcee69617cfbcb26ed110181e9030f0a304ede648748562b6e4c51c9dcf13a3508c8f99a077767d91f4ce
-  data.tar.gz: 81bb03656528100088575379a7246c468cb61a56318c46d614ced1c4fca0a50d2d6531f20faf9fd70a1b25e5c4158fad023074f9a6c2ee88366176a3973cde9e
+  metadata.gz: '018c838374788cbd86af2fafe917568925b59cf6e137026c35326b4f2d137a4fe585939367c5c7935ac1e5719bd026a8ebe909742be45a45cf9e28a23b303bf9'
+  data.tar.gz: 216d2b1790a380a03e68c7895e450442679c00cb766226c3dc5c84d3cc0f442c2e18e4332d76a8463e7c5ae2438e753bce140767ef7bd722a91892a16973507e

data/bin/gemini_refiner

@@ -0,0 +1,354 @@
+#!/usr/bin/env ruby
+
+# Gemini Vector Refinement Engine
+# This script runs in a separate terminal and handles vector refinement
+
+require 'json'
+require 'net/http'
+require 'uri'
+require 'time'
+
+class GeminiRefiner
+  def initialize
+    @base_url = 'http://localhost:3000'
+    @template_file = '/tmp/gemini_refinement_template.json'
+    @status_file = '/tmp/gemini_status.log'
+    @current_refinement_file = '/tmp/gemini_current_refinement.json'
+    @batch_size = 10
+    @sleep_interval = 5
+    @refinement_count = 0
+    @start_time = Time.now
+
+    setup_logging
+    load_template
+  end
+
+  def start
+    display_startup_banner
+    check_connectivity
+
+    log_status('info', 'Gemini refinement engine started')
+    puts "🔄 Starting refinement loop..."
+    puts ""
+
+    main_refinement_loop
+  rescue Interrupt
+    puts "\n\n👋 Gemini refinement engine shutting down..."
+    cleanup
+    exit(0)
+  rescue => e
+    log_status('error', "Critical error: #{e.message}")
+    puts "❌ Critical error: #{e.message}"
+    exit(1)
+  end
+
+  private
+
+  def setup_logging
+    # Initialize log file
+    File.write(@status_file, "")
+  end
+
+  def load_template
+    if File.exist?(@template_file)
+      @template = JSON.parse(File.read(@template_file))
+      puts "📋 Template loaded from #{@template_file}"
+    else
+      puts "⚠️  Template file not found, using defaults"
+      @template = default_template
+    end
+  end
+
+  def display_startup_banner
+    puts "╔═══════════════════════════════════════════════╗"
+    puts "║        🧠 GEMINI REFINEMENT ENGINE           ║"
+    puts "╚═══════════════════════════════════════════════╝"
+    puts ""
+    puts "🎯 Configuration:"
+    puts "   Endpoint:     #{@base_url}/api/gemini"
+    puts "   Batch Size:   #{@batch_size} vectors"
+    puts "   Interval:     #{@sleep_interval} seconds"
+    puts "   Template:     #{@template_file}"
+    puts ""
+  end
+
+  def check_connectivity
+    puts "📡 Testing connectivity..."
+
+    begin
+      uri = URI("#{@base_url}/api/gemini/health_check")
+      response = Net::HTTP.get_response(uri)
+
+      if response.code == '200'
+        puts "   ✅ API endpoint: Connected"
+      else
+        puts "   ⚠️  API endpoint: #{response.code} #{response.message}"
+      end
+    rescue => e
+      puts "   ❌ API endpoint: Connection failed (#{e.message})"
+      puts ""
+      puts "🔧 Troubleshooting:"
+      puts "   - Make sure Rails server is running: rails server"
+      puts "   - Check if the forge_generator app is accessible"
+      puts ""
+      exit(1)
+    end
+
+    # Test Gemini CLI (mock for now)
+    if has_gemini_cli?
+      puts "   ✅ Gemini CLI: Available"
+    else
+      puts "   ⚠️  Gemini CLI: Using mock refinement"
+    end
+
+    puts ""
+  end
+
+  def main_refinement_loop
+    loop do
+      begin
+        # Fetch unrefined vectors
+        vectors = fetch_unrefined_vectors
+
+        if vectors && vectors.any?
+          puts "📥 Received #{vectors.count} vectors for refinement"
+
+          # Process each vector
+          refined_vectors = []
+          vectors.each_with_index do |vector, index|
+            refined = refine_vector(vector, index + 1, vectors.count)
+            refined_vectors << refined if refined
+          end
+
+          # Submit refined vectors
+          if refined_vectors.any?
+            submit_refined_vectors(refined_vectors)
+            @refinement_count += refined_vectors.count
+
+            # Update stats display
+            display_current_stats
+          end
+        else
+          puts "💤 No vectors to refine... waiting #{@sleep_interval}s"
+          clear_current_refinement
+        end
+
+        sleep(@sleep_interval)
+
+      rescue => e
+        log_status('error', "Refinement loop error: #{e.message}")
+        puts "❌ Error in refinement loop: #{e.message}"
+        puts "   Retrying in #{@sleep_interval} seconds..."
+        sleep(@sleep_interval)
+      end
+    end
+  end
+
+  def fetch_unrefined_vectors
+    uri = URI("#{@base_url}/api/gemini/unrefined_vectors?batch_size=#{@batch_size}")
+    response = Net::HTTP.get_response(uri)
+
+    if response.code == '200'
+      data = JSON.parse(response.body)
+      data['vectors']
+    else
+      log_status('error', "Failed to fetch vectors: #{response.code}")
+      nil
+    end
+  rescue => e
+    log_status('error', "Network error fetching vectors: #{e.message}")
+    nil
+  end
+
+  def refine_vector(vector, current_index, total_count)
+    vector_id = vector['id']
+    content = vector['content']
+
+    puts "🔄 [#{current_index}/#{total_count}] Refining vector ##{vector_id}..."
+
+    # Update current refinement status
+    update_current_refinement(vector_id, content, current_index, total_count)
+
+    # Perform refinement (mock implementation for now)
+    refined_data = perform_gemini_refinement(content)
+
+    log_status('success', "Refined vector ##{vector_id} (#{refined_data[:keywords]&.count || 0} keywords)")
+
+    {
+      'id' => vector_id,
+      'chunks' => refined_data[:chunks],
+      'keywords' => refined_data[:keywords],
+      'generators' => refined_data[:generators]
+    }
+  rescue => e
+    log_status('error', "Failed to refine vector ##{vector_id}: #{e.message}")
+    puts "   ❌ Error refining vector ##{vector_id}: #{e.message}"
+    nil
+  end
+
+  def perform_gemini_refinement(content)
+    # Mock refinement implementation
+    # In real implementation, this would call Gemini API
+
+    words = content.split
+    chunks = []
+    keywords = []
+
+    # Simple chunking (50 words max)
+    words.each_slice(50) do |chunk_words|
+      chunk_text = chunk_words.join(' ')
+      chunks << chunk_text
+
+      # Extract keywords (simple implementation)
+      chunk_keywords = extract_keywords(chunk_text)
+      keywords.concat(chunk_keywords)
+    end
+
+    # Create generators
+    generators = create_generators(keywords, chunks)
+
+    {
+      chunks: chunks,
+      keywords: keywords.uniq,
+      generators: generators
+    }
+  end
+
+  def extract_keywords(text)
+    # Simple keyword extraction (mock)
+    words = text.downcase.split(/\W+/)
+
+    # Filter meaningful words (longer than 3 chars, not common words)
+    common_words = %w[the and for are but not you all can had her was one our out day get has him how its may new now old see two way who boy did man its can all]
+
+    meaningful_words = words.select do |word|
+      word.length > 3 && !common_words.include?(word)
+    end
+
+    # Return top 5 most frequent
+    meaningful_words.tally.sort_by { |_, count| -count }.first(5).map(&:first)
+  end
+
+  def create_generators(keywords, chunks)
+    generators = []
+
+    # Create one generator per chunk with its keywords
+    chunks.each_with_index do |chunk, index|
+      chunk_keywords = keywords.sample(3) # Use 3 random keywords
+
+      generators << {
+        'trigger' => chunk_keywords,
+        'template' => "Based on the context: #{chunk.truncate(100)}",
+        'confidence' => 0.7 + (rand * 0.3) # Random confidence 0.7-1.0
+      }
+    end
+
+    generators
+  end
+
+  def submit_refined_vectors(refined_vectors)
+    uri = URI("#{@base_url}/api/gemini/submit_refined")
+
+    http = Net::HTTP.new(uri.host, uri.port)
+    request = Net::HTTP::Post.new(uri)
+    request['Content-Type'] = 'application/json'
+    request.body = { vectors: refined_vectors }.to_json
+
+    response = http.request(request)
+
+    if response.code == '200'
+      puts "✅ Successfully submitted #{refined_vectors.count} refined vectors"
+      log_status('success', "Submitted #{refined_vectors.count} refined vectors")
+    else
+      puts "⚠️  Submission warning: #{response.code} #{response.message}"
+      log_status('error', "Submission failed: #{response.code}")
+    end
+  rescue => e
+    puts "❌ Failed to submit refined vectors: #{e.message}"
+    log_status('error', "Submission error: #{e.message}")
+  end
+
+  def update_current_refinement(vector_id, content, current, total)
+    progress = ((current.to_f / total) * 100).round
+
+    current_data = {
+      'id' => vector_id,
+      'content' => content,
+      'progress' => progress,
+      'current' => current,
+      'total' => total,
+      'updated_at' => Time.now.iso8601
+    }
+
+    File.write(@current_refinement_file, current_data.to_json)
+  rescue
+    # Ignore file write errors
+  end
+
+  def clear_current_refinement
+    File.delete(@current_refinement_file) if File.exist?(@current_refinement_file)
+  rescue
+    # Ignore file delete errors
+  end
+
+  def display_current_stats
+    runtime = Time.now - @start_time
+    rate = @refinement_count / (runtime / 60.0) # per minute
+
+    puts ""
+    puts "📊 Session Stats:"
+    puts "   Refined:     #{@refinement_count} vectors"
+    puts "   Runtime:     #{(runtime / 60).round(1)} minutes"
+    puts "   Rate:        #{rate.round(1)}/min"
+    puts ""
+  end
+
+  def log_status(level, message)
+    timestamp = Time.now.strftime('%H:%M:%S')
+    log_entry = "#{timestamp} - #{level} - #{message}"
+
+    File.open(@status_file, 'a') do |f|
+      f.puts log_entry
+    end
+  rescue
+    # Ignore logging errors
+  end
+
+  def has_gemini_cli?
+    system('which gemini > /dev/null 2>&1') ||
+    system('which google-ai > /dev/null 2>&1') ||
+    ENV['GEMINI_API_KEY'] || ENV['GOOGLE_API_KEY']
+  end
+
+  def default_template
+    {
+      'mode' => 'vector_refinement',
+      'instructions' => {
+        'primary' => 'Refine each vector into atomic facts with keywords',
+        'chunking' => {
+          'max_words' => 50,
+          'create_generators' => true,
+          'keyword_density' => '3-5 per chunk'
+        }
+      }
+    }
+  end
+
+  def cleanup
+    clear_current_refinement
+    log_status('info', 'Gemini refinement engine stopped')
+  end
+end
+
+# String truncate method
+class String
+  def truncate(length)
+    self.length > length ? "#{self[0..length-3]}..." : self
+  end unless method_defined?(:truncate)
+end
+
+# Start the refiner
+if __FILE__ == $0
+  refiner = GeminiRefiner.new
+  refiner.start
+end

data/lib/hokipoki/cli/gemini_connector.rb

@@ -0,0 +1,107 @@
+module Hokipoki
+  module CLI
+    class GeminiConnector
+      def self.start
+        puts "🚀 Starting Gemini Vector Refinement Engine..."
+        puts ""
+
+        # 1. Create refinement template
+        create_refinement_template
+
+        # 2. Create communication pipes
+        setup_communication_pipes
+
+        # 3. Open new terminal with Gemini
+        terminal_cmd = build_terminal_command
+        puts "📡 Opening Gemini terminal..."
+        system(terminal_cmd)
+
+        # 4. Start monitoring dashboard in current terminal
+        sleep(2) # Give terminal time to open
+        puts "🎯 Starting refinement dashboard..."
+        puts ""
+        show_refinement_dashboard
+      end
+
+      private
+
+      def self.create_refinement_template
+        template = {
+          mode: "vector_refinement",
+          instructions: {
+            primary: "Refine each vector into atomic facts with keywords",
+            chunking: {
+              max_words: 50,
+              create_generators: true,
+              keyword_density: "3-5 per chunk"
+            },
+            output_format: {
+              chunks: "array of atomic facts",
+              keywords: "array of trigger words",
+              generators: "keyword → response patterns"
+            }
+          },
+          endpoint: "http://localhost:3000/api/gemini/unrefined_vectors",
+          submit_endpoint: "http://localhost:3000/api/gemini/submit_refined",
+          batch_size: 10,
+          interval: 5
+        }
+
+        File.write('/tmp/gemini_refinement_template.json', template.to_json)
+      end
+
+      def self.setup_communication_pipes
+        # Create named pipes for communication
+        system("mkfifo /tmp/gemini_status.fifo 2>/dev/null || true")
+        system("mkfifo /tmp/gemini_refined_vectors.fifo 2>/dev/null || true")
+
+        # Create status file
+        File.write('/tmp/gemini_status.log', "")
+      end
+
+      def self.build_terminal_command
+        # Get the gem's bin directory
+        gem_bin_path = File.expand_path('../../../../bin/gemini_refiner', __FILE__)
+
+        gemini_script = <<~SCRIPT
+          clear
+          echo "═══════════════════════════════════════════════"
+          echo "    🧠 GEMINI VECTOR REFINEMENT ENGINE"
+          echo "═══════════════════════════════════════════════"
+          echo ""
+          echo "📡 Connecting to HiveMind at http://localhost:3000"
+          echo "🎯 Template: /tmp/gemini_refinement_template.json"
+          echo "⚡ Starting refinement loop..."
+          echo ""
+
+          # Run the gemini refiner script
+          #{gem_bin_path}
+        SCRIPT
+
+        # Write script to temp file
+        script_path = '/tmp/start_gemini_refiner.sh'
+        File.write(script_path, gemini_script)
+        system("chmod +x #{script_path}")
+
+        # Open in new terminal (works on macOS and Linux)
+        if RUBY_PLATFORM =~ /darwin/
+          # macOS
+          "osascript -e 'tell app \"Terminal\" to do script \"#{script_path}\"'"
+        elsif ENV['DISPLAY']
+          # Linux with GUI
+          "gnome-terminal -- bash -c \"#{script_path}; exec bash\" || xterm -e \"#{script_path}; exec bash\""
+        else
+          # Fallback - run in background and show message
+          puts "⚠️  GUI terminal not available. Run this in a separate terminal:"
+          puts "   #{script_path}"
+          return "echo 'Run #{script_path} in separate terminal'"
+        end
+      end
+
+      def self.show_refinement_dashboard
+        require_relative 'gemini_status_monitor'
+        GeminiStatusMonitor.show
+      end
+    end
+  end
+end

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/version.rb

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

data/lib/tasks/gemini.rake

@@ -0,0 +1,194 @@
+namespace :gemini do
+  desc "Start Gemini vector refinement engine in new terminal"
+  task :start => :environment do
+    require_relative '../hokipoki/cli/gemini_connector'
+
+    puts "🚀 GEMINI VECTOR REFINEMENT SYSTEM"
+    puts "═══════════════════════════════════════"
+    puts ""
+    puts "📋 Pre-flight checks:"
+
+    # Check if Rails is available
+    if defined?(Rails)
+      puts "  ✅ Rails environment loaded"
+    else
+      puts "  ❌ Rails not available"
+      exit(1)
+    end
+
+    # Check if HiveMindDocument model exists
+    if defined?(HiveMindDocument)
+      doc_count = HiveMindDocument.count rescue 0
+      puts "  ✅ HiveMindDocument available (#{doc_count} vectors)"
+    else
+      puts "  ⚠️  HiveMindDocument not available (will work but no data)"
+    end
+
+    # Check if Rails server is running
+    begin
+      require 'net/http'
+      response = Net::HTTP.get_response(URI('http://localhost:3000/'))
+      puts "  ✅ Rails server running on port 3000"
+    rescue
+      puts "  ⚠️  Rails server not detected on port 3000"
+      puts "     Starting Rails server in background..."
+
+      # Try to start Rails server in background
+      Thread.new do
+        system("cd #{Rails.root} && rails server -d")
+      end
+      sleep(3)
+    end
+
+    puts ""
+    puts "🎯 Starting Gemini refinement system..."
+    puts ""
+
+    # Start the Gemini connector
+    Hokipoki::CLI::GeminiConnector.start
+  end
+
+  desc "Show Gemini refinement status"
+  task :status => :environment do
+    require_relative '../hokipoki/cli/gemini_status_monitor'
+
+    puts "🔍 GEMINI REFINEMENT STATUS"
+    puts "═══════════════════════════════════════"
+    puts ""
+
+    # Show current status without the interactive dashboard
+    stats = fetch_quick_stats
+
+    puts "📊 Quick Stats:"
+    puts "  Total Vectors:     #{stats[:total_vectors]}"
+    puts "  Refined:          #{stats[:refined_count]} ✅"
+    puts "  Pending:          #{stats[:pending_count]} ⏳"
+    puts ""
+
+    # Check if Gemini process is running
+    gemini_running = system('pgrep -f "gemini_refiner" > /dev/null')
+    if gemini_running
+      puts "🔄 Gemini refiner: RUNNING"
+    else
+      puts "💤 Gemini refiner: STOPPED"
+      puts ""
+      puts "   To start: rails gemini:start"
+    end
+
+    puts ""
+    puts "   For live dashboard: rails gemini:start"
+  end
+
+  desc "Stop Gemini refinement engine"
+  task :stop => :environment do
+    puts "🛑 Stopping Gemini refinement engine..."
+
+    # Kill Gemini processes
+    system('pkill -f "gemini_refiner"')
+
+    # Clean up temp files
+    temp_files = [
+      '/tmp/gemini_status.fifo',
+      '/tmp/gemini_refined_vectors.fifo',
+      '/tmp/gemini_current_refinement.json',
+      '/tmp/gemini_refinement_template.json',
+      '/tmp/gemini_status.log',
+      '/tmp/start_gemini_refiner.sh'
+    ]
+
+    temp_files.each do |file|
+      File.delete(file) if File.exist?(file)
+    rescue
+      # Ignore cleanup errors
+    end
+
+    puts "✅ Gemini refinement engine stopped"
+    puts "🧹 Temporary files cleaned up"
+  end
+
+  desc "Test Gemini API connection"
+  task :test => :environment do
+    puts "🧪 GEMINI API CONNECTION TEST"
+    puts "═══════════════════════════════════════"
+    puts ""
+
+    # Test basic connectivity
+    begin
+      require 'net/http'
+      require 'json'
+
+      # Test unrefined vectors endpoint
+      puts "📡 Testing API endpoints..."
+
+      uri = URI('http://localhost:3000/api/gemini/unrefined_vectors')
+      response = Net::HTTP.get_response(uri)
+
+      if response.code == '200'
+        puts "  ✅ Unrefined vectors endpoint: OK"
+        data = JSON.parse(response.body)
+        puts "     Found #{data['vectors']&.count || 0} vectors"
+      else
+        puts "  ❌ Unrefined vectors endpoint: FAILED (#{response.code})"
+      end
+
+    rescue => e
+      puts "  ❌ API test failed: #{e.message}"
+      puts ""
+      puts "  🔧 Troubleshooting:"
+      puts "     - Make sure Rails server is running: rails server"
+      puts "     - Check if API routes are configured"
+    end
+
+    # Test Gemini CLI availability
+    puts ""
+    puts "🔍 Testing Gemini CLI..."
+
+    if system('which gemini > /dev/null 2>&1')
+      puts "  ✅ Gemini CLI found"
+
+      # Test Gemini API key
+      if ENV['GEMINI_API_KEY'] || ENV['GOOGLE_API_KEY']
+        puts "  ✅ API key configured"
+      else
+        puts "  ⚠️  API key not found in environment"
+        puts "     Set GEMINI_API_KEY or GOOGLE_API_KEY"
+      end
+    else
+      puts "  ❌ Gemini CLI not found"
+      puts "     Install with: npm install -g @google/generative-ai"
+    end
+
+    puts ""
+    puts "🎯 Test complete!"
+  end
+
+  private
+
+  def fetch_quick_stats
+    begin
+      if defined?(HiveMindDocument)
+        total = HiveMindDocument.count
+        refined = HiveMindDocument.where(refined: true).count
+        pending = total - refined
+
+        {
+          total_vectors: total,
+          refined_count: refined,
+          pending_count: pending
+        }
+      else
+        {
+          total_vectors: 0,
+          refined_count: 0,
+          pending_count: 0
+        }
+      end
+    rescue => e
+      {
+        total_vectors: "Error",
+        refined_count: "Error",
+        pending_count: "Error"
+      }
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hokipoki
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Rails Utilities
@@ -209,11 +209,13 @@ description: A collection of utilities and enhancements for Rails applications i
   database optimizations, background processing helpers, and developer tools.
 email:
 - utilities@example.com
-executables: []
+executables:
+- gemini_refiner
 extensions: []
 extra_rdoc_files: []
 files:
 - LICENSE
+- bin/gemini_refiner
 - lib/generators/hive_mind/install_generator.rb
 - lib/generators/hive_mind/start_generator.rb
 - lib/generators/hive_mind/templates/create_hive_mind_documents.rb
@@ -232,6 +234,8 @@ files:
 - lib/hokipoki/claude/parasite.rb
 - lib/hokipoki/claude/thought_interceptor.rb
 - lib/hokipoki/claude_auto_loader.rb
+- lib/hokipoki/cli/gemini_connector.rb
+- lib/hokipoki/cli/gemini_status_monitor.rb
 - lib/hokipoki/configuration.rb
 - lib/hokipoki/console.rb
 - lib/hokipoki/engine.rb
@@ -247,6 +251,7 @@ files:
 - lib/hokipoki/template_store.rb
 - lib/hokipoki/vector_engine.rb
 - lib/hokipoki/version.rb
+- lib/tasks/gemini.rake
 homepage: https://github.com/rails-utilities/hokipoki
 licenses:
 - Proprietary