hokipoki 0.1.2 → 0.1.3

data/lib/hokipoki/claude/parasite.rb

@@ -0,0 +1,333 @@
+# frozen_string_literal: true
+
+module Hokipoki
+  module Claude
+    # Claude Parasite - Intelligent Claude CLI integration with HiveMind
+    # Automatically injects vector intelligence context into Claude conversations
+    class Parasite
+      include Singleton
+
+      def initialize
+        @logger = Rails.logger
+        @feedback = Feedback::DisplayManager.instance
+        @connection_manager = ConnectionManager.instance
+        @injection_stats = {
+          total_injections: 0,
+          successful_injections: 0,
+          failed_injections: 0,
+          total_tokens_saved: 0
+        }
+      end
+
+      # Auto-load when Claude CLI starts
+      def self.auto_load!
+        instance.ensure_connection!
+        instance.display_startup_message
+        instance
+      end
+
+      # Check if should inject context for this request
+      def should_inject?(user_message, request_context = {})
+        return false unless @connection_manager.connected?
+        return false if simple_greeting?(user_message)
+        return false if user_message.length < 10
+
+        # Smart injection logic based on content analysis
+        programming_related?(user_message) ||
+        question_asking?(user_message) ||
+        implementation_request?(user_message)
+      end
+
+      # Get injection strategy for this request
+      def injection_strategy(user_message, request_context = {})
+        intent = analyze_intent(user_message)
+        token_budget = calculate_token_budget(user_message, intent)
+
+        {
+          max_tokens: token_budget,
+          style: :contextual_intelligence,
+          intent: intent,
+          compression: true,
+          priority: determine_priority(intent),
+          bypass_cache: emergency_request?(user_message)
+        }
+      end
+
+      # Craft the injection content
+      def craft_injection(user_message, original_messages, strategy = {})
+        return original_messages unless @connection_manager.connected?
+
+        @feedback.debug_info('injection', "analyzing message for context injection")
+
+        begin
+          # Get vector intelligence for the query
+          @feedback.pulling_from_hive_mind('context')
+          facts = retrieve_vector_intelligence(user_message, strategy)
+
+          if facts.present?
+            # Create intelligence-enhanced system message
+            system_message = build_system_message(facts, strategy)
+
+            # Calculate token savings
+            tokens_saved = estimate_tokens_saved(facts, user_message)
+
+            # Track successful injection
+            track_injection_success(user_message, facts, strategy, tokens_saved)
+
+            @feedback.total_tokens_saved(tokens_saved, @injection_stats[:total_tokens_saved])
+
+            # Add system message to conversation
+            [system_message] + original_messages
+          else
+            # No relevant context found, return original
+            @feedback.debug_info('injection', 'no relevant context found')
+            track_injection_attempt(user_message, 'no_context_found')
+            original_messages
+          end
+
+        rescue => e
+          @feedback.operation_error('injection', e.message)
+          @logger.error "🦠 Claude Parasite injection failed: #{e.message}"
+          track_injection_failure(user_message, e)
+          original_messages
+        end
+      end
+
+      # Display parasite status
+      def display_status
+        puts "\n#{Pastel.new.cyan.bold('🦠 Claude Parasite Status')}"
+        puts "   Status: #{connection_status_display}"
+        puts "   Total Injections: #{@injection_stats[:total_injections]}"
+        puts "   Success Rate: #{success_rate}%"
+        puts "   Tokens Saved: #{@injection_stats[:total_tokens_saved]}"
+        puts "   Connection: #{@connection_manager.connected? ? '🟢 Online' : '🔴 Offline'}"
+      end
+
+      # Get parasite statistics
+      def statistics
+        @injection_stats.merge({
+          success_rate: success_rate,
+          connection_status: @connection_manager.connected?,
+          last_injection: @last_injection_time,
+          uptime: calculate_uptime
+        })
+      end
+
+      # Ensure connection to HiveMind
+      def ensure_connection!
+        unless @connection_manager.connected?
+          @connection_manager.establish_connection!
+        end
+      end
+
+      # Display startup message when Claude loads
+      def display_startup_message
+        pastel = Pastel.new
+
+        puts "\n#{pastel.green.bold('🧠 HiveMind is now connected!')}"
+        puts pastel.cyan("   🦠 Claude Parasite: Active")
+        puts pastel.cyan("   📊 Vector Intelligence: Online")
+        puts pastel.cyan("   ⚡ Smart Context Injection: Enabled")
+
+        if @connection_manager.connected?
+          db_status = @connection_manager.connection_status
+          puts pastel.dim("   📈 Vector DB: #{db_status[:vector_db_status][:document_count]} documents ready")
+        end
+
+        puts pastel.yellow("\n💡 Your Claude responses are now enhanced with project-specific intelligence!")
+        puts pastel.dim("   The parasite will automatically inject relevant context from your vector database.\n")
+      end
+
+      private
+
+      def simple_greeting?(message)
+        greetings = %w[hi hello hey thanks thank you yes no ok okay sure]
+        message.downcase.strip.split.all? { |word| greetings.include?(word) }
+      end
+
+      def programming_related?(message)
+        programming_keywords = %w[
+          code function method class variable api database
+          implement create build debug fix error bug
+          css html javascript react vue angular rails ruby python
+          sql query table model controller view
+          git github commit push pull merge
+          deploy server docker kubernetes aws
+        ]
+
+        message.downcase.split.any? { |word| programming_keywords.include?(word) }
+      end
+
+      def question_asking?(message)
+        question_patterns = [
+          /\bhow\s+(do|can|to)\b/i,
+          /\bwhat\s+(is|are|does|should)\b/i,
+          /\bwhere\s+(is|are|do|should)\b/i,
+          /\bwhy\s+(is|are|does|should)\b/i,
+          /\bwhen\s+(is|are|do|should)\b/i,
+          /\bwhich\s+(is|are|should)\b/i,
+          /\?$/
+        ]
+
+        question_patterns.any? { |pattern| message.match?(pattern) }
+      end
+
+      def implementation_request?(message)
+        implementation_keywords = %w[
+          implement create build make generate add
+          show example tutorial guide step
+          help setup configure install
+        ]
+
+        message.downcase.split.any? { |word| implementation_keywords.include?(word) }
+      end
+
+      def analyze_intent(message)
+        return :debugging if message.match?(/\b(error|bug|fix|debug|problem|issue|broken)\b/i)
+        return :implementation if message.match?(/\b(implement|create|build|make|add)\b/i)
+        return :learning if message.match?(/\b(how|what|why|explain|understand|learn)\b/i)
+        return :reference if message.match?(/\b(example|show|demo|sample|reference)\b/i)
+        return :optimization if message.match?(/\b(optimize|improve|better|faster|performance)\b/i)
+
+        :general
+      end
+
+      def calculate_token_budget(message, intent)
+        base_budget = case intent
+        when :debugging then 2000      # More context for debugging
+        when :implementation then 1800  # Good context for implementation
+        when :learning then 1500       # Standard context for learning
+        when :reference then 1200      # Less context for references
+        when :optimization then 1600   # Moderate context for optimization
+        else 1000                      # Minimal context for general
+        end
+
+        # Adjust based on message length
+        if message.length > 200
+          base_budget += 500
+        elsif message.length < 50
+          base_budget -= 300
+        end
+
+        [base_budget, 3000].min # Cap at 3000 tokens
+      end
+
+      def determine_priority(intent)
+        case intent
+        when :debugging then :high
+        when :implementation then :high
+        when :optimization then :medium
+        when :learning then :medium
+        when :reference then :low
+        else :low
+        end
+      end
+
+      def emergency_request?(message)
+        emergency_keywords = %w[urgent emergency critical broken down error fatal]
+        message.downcase.split.any? { |word| emergency_keywords.include?(word) }
+      end
+
+      def retrieve_vector_intelligence(message, strategy)
+        token_budget = strategy[:max_tokens] || 1500
+
+        # Use HokiPoki's smart retrieval with intent analysis
+        Hokipoki.retrieve_facts(
+          message,
+          token_budget: token_budget,
+          intent: strategy[:intent] || 'auto'
+        )
+      end
+
+      def build_system_message(facts, strategy)
+        intent = strategy[:intent] || :general
+
+        system_content = case intent
+        when :debugging
+          "Context for debugging: #{facts}\n\nFocus on identifying issues and providing solutions."
+        when :implementation
+          "Implementation context: #{facts}\n\nProvide concrete code examples and step-by-step guidance."
+        when :learning
+          "Learning context: #{facts}\n\nExplain concepts clearly with examples."
+        when :reference
+          "Reference information: #{facts}\n\nProvide accurate documentation and examples."
+        when :optimization
+          "Optimization context: #{facts}\n\nSuggest performance improvements and best practices."
+        else
+          "Context: #{facts}"
+        end
+
+        {
+          'role' => 'system',
+          'content' => system_content
+        }
+      end
+
+      def track_injection_success(message, facts, strategy, tokens_saved = nil)
+        @injection_stats[:total_injections] += 1
+        @injection_stats[:successful_injections] += 1
+
+        # Use provided tokens saved or estimate
+        estimated_tokens = tokens_saved || (facts.length / 4)
+        @injection_stats[:total_tokens_saved] += estimated_tokens
+
+        @last_injection_time = Time.current
+
+        @logger.info "🦠 Claude Parasite: Context injected successfully (#{estimated_tokens} tokens)"
+      end
+
+      def estimate_tokens_saved(facts, user_message)
+        # Estimate tokens saved by providing specific context vs generic response
+        context_tokens = facts.length / 4
+        baseline_tokens = user_message.length * 0.6 # Rough estimate of generic response
+        savings = [baseline_tokens - context_tokens, 0].max.round
+        savings
+      end
+
+      def track_injection_attempt(message, reason)
+        @injection_stats[:total_injections] += 1
+        @logger.debug "🦠 Claude Parasite: Injection attempted but skipped (#{reason})"
+      end
+
+      def track_injection_failure(message, error)
+        @injection_stats[:total_injections] += 1
+        @injection_stats[:failed_injections] += 1
+        @logger.error "🦠 Claude Parasite: Injection failed - #{error.message}"
+      end
+
+      def success_rate
+        return 0 if @injection_stats[:total_injections] == 0
+
+        (@injection_stats[:successful_injections].to_f / @injection_stats[:total_injections] * 100).round(1)
+      end
+
+      def connection_status_display
+        if @connection_manager.connected?
+          Pastel.new.green('🟢 Connected')
+        else
+          Pastel.new.red('🔴 Disconnected')
+        end
+      end
+
+      def calculate_uptime
+        return 'N/A' unless @connection_manager.instance_variable_get(:@connection_time)
+
+        uptime_seconds = Time.current - @connection_manager.instance_variable_get(:@connection_time)
+        format_uptime(uptime_seconds)
+      end
+
+      def format_uptime(seconds)
+        hours = (seconds / 3600).to_i
+        minutes = ((seconds % 3600) / 60).to_i
+
+        if hours > 0
+          "#{hours}h #{minutes}m"
+        elsif minutes > 0
+          "#{minutes}m"
+        else
+          "#{seconds.to_i}s"
+        end
+      end
+    end
+  end
+end

data/lib/hokipoki/configuration.rb

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+module Hokipoki
+  class Configuration
+    attr_accessor :vector_dimensions,
+                  :lm_studio_url,
+                  :embedding_model,
+                  :enable_parasites,
+                  :enable_forge,
+                  :enable_behavioral_analysis,
+                  :enable_template_optimization,
+                  :template_caching,
+                  :token_budget_default,
+                  :context_compression,
+                  :offline_mode,
+                  :api_authentication,
+                  :audit_logging,
+                  :encrypted_logging,
+                  :rate_limiting,
+                  :default_brain,
+                  :auto_brain_switching,
+                  :universal_parasite_generation,
+                  :auto_optimization,
+                  :cross_parasite_learning,
+                  :workshop_interface,
+                  :background_processing,
+                  :multi_llm_orchestration,
+                  :redis_url,
+                  :cache_ttl,
+                  :max_retries
+
+    def initialize
+      # === CORE SETTINGS ===
+      @vector_dimensions = 768
+      @lm_studio_url = ENV.fetch('LM_STUDIO_URL', 'http://localhost:1236')
+      @embedding_model = ENV.fetch('EMBEDDING_MODEL', 'text-embedding-nomic-embed-text-v1.5')
+
+      # === COMPONENT ACTIVATION ===
+      @enable_parasites = ENV.fetch('HOKIPOKI_ENABLE_PARASITES', 'true') == 'true'
+      @enable_forge = ENV.fetch('HOKIPOKI_ENABLE_FORGE', 'false') == 'true'
+      @enable_behavioral_analysis = ENV.fetch('HOKIPOKI_ENABLE_BEHAVIORAL_ANALYSIS', 'true') == 'true'
+      @enable_template_optimization = ENV.fetch('HOKIPOKI_ENABLE_TEMPLATE_OPTIMIZATION', 'true') == 'true'
+
+      # === PERFORMANCE ===
+      @template_caching = ENV.fetch('HOKIPOKI_TEMPLATE_CACHING', 'true') == 'true'
+      @token_budget_default = ENV.fetch('HOKIPOKI_TOKEN_BUDGET_DEFAULT', '1500').to_i
+      @context_compression = ENV.fetch('HOKIPOKI_CONTEXT_COMPRESSION', 'true') == 'true'
+      @offline_mode = ENV.fetch('HOKIPOKI_OFFLINE_MODE', 'false') == 'true'
+      @cache_ttl = ENV.fetch('HOKIPOKI_CACHE_TTL', '3600').to_i # 1 hour default
+      @max_retries = ENV.fetch('HOKIPOKI_MAX_RETRIES', '3').to_i
+
+      # === SECURITY ===
+      @api_authentication = ENV.fetch('HOKIPOKI_API_AUTHENTICATION', 'true') == 'true'
+      @audit_logging = ENV.fetch('HOKIPOKI_AUDIT_LOGGING', 'true') == 'true'
+      @encrypted_logging = ENV.fetch('HOKIPOKI_ENCRYPTED_LOGGING', 'false') == 'true'
+      @rate_limiting = ENV.fetch('HOKIPOKI_RATE_LIMITING', 'true') == 'true'
+
+      # === BRAINS CONFIGURATION ===
+      @default_brain = ENV.fetch('HOKIPOKI_DEFAULT_BRAIN', 'default_brain')
+      @auto_brain_switching = ENV.fetch('HOKIPOKI_AUTO_BRAIN_SWITCHING', 'true') == 'true'
+
+      # === PARASITE SYSTEM ===
+      @universal_parasite_generation = ENV.fetch('HOKIPOKI_UNIVERSAL_PARASITE_GENERATION', 'true') == 'true'
+      @auto_optimization = ENV.fetch('HOKIPOKI_AUTO_OPTIMIZATION', 'true') == 'true'
+      @cross_parasite_learning = ENV.fetch('HOKIPOKI_CROSS_PARASITE_LEARNING', 'true') == 'true'
+
+      # === FORGE CONFIGURATION ===
+      @workshop_interface = ENV.fetch('HOKIPOKI_WORKSHOP_INTERFACE', 'true') == 'true'
+      @background_processing = ENV.fetch('HOKIPOKI_BACKGROUND_PROCESSING', 'sidekiq').to_sym
+      @multi_llm_orchestration = ENV.fetch('HOKIPOKI_MULTI_LLM_ORCHESTRATION', 'true') == 'true'
+
+      # === REDIS CONFIGURATION ===
+      @redis_url = ENV.fetch('REDIS_URL', 'redis://localhost:6379/0')
+    end
+
+    def validate!
+      errors = []
+
+      errors << "vector_dimensions must be positive" if vector_dimensions <= 0
+      errors << "token_budget_default must be positive" if token_budget_default <= 0
+      errors << "lm_studio_url must be a valid URL" unless valid_url?(lm_studio_url)
+      errors << "redis_url must be a valid URL" unless valid_url?(redis_url)
+      errors << "cache_ttl must be positive" if cache_ttl <= 0
+      errors << "max_retries must be non-negative" if max_retries < 0
+
+      unless %i[sidekiq resque delayed_job].include?(background_processing)
+        errors << "background_processing must be one of: sidekiq, resque, delayed_job"
+      end
+
+      raise ConfigurationError, "Configuration errors: #{errors.join(', ')}" if errors.any?
+
+      true
+    end
+
+    def redis_config
+      {
+        url: redis_url,
+        timeout: 5,
+        reconnect_attempts: max_retries
+      }
+    end
+
+    def lm_studio_config
+      {
+        url: lm_studio_url,
+        timeout: 30,
+        retries: max_retries,
+        embedding_model: embedding_model
+      }
+    end
+
+    def vector_config
+      {
+        dimensions: vector_dimensions,
+        distance_metric: 'cosine',
+        index_type: 'hnsw'
+      }
+    end
+
+    def security_config
+      {
+        api_authentication: api_authentication,
+        audit_logging: audit_logging,
+        encrypted_logging: encrypted_logging,
+        rate_limiting: rate_limiting
+      }
+    end
+
+    def parasite_config
+      {
+        enabled: enable_parasites,
+        universal_generation: universal_parasite_generation,
+        auto_optimization: auto_optimization,
+        cross_learning: cross_parasite_learning,
+        behavioral_analysis: enable_behavioral_analysis
+      }
+    end
+
+    def forge_config
+      {
+        enabled: enable_forge,
+        workshop_interface: workshop_interface,
+        background_processing: background_processing,
+        multi_llm_orchestration: multi_llm_orchestration
+      }
+    end
+
+    def intelligence_config
+      {
+        template_optimization: enable_template_optimization,
+        template_caching: template_caching,
+        context_compression: context_compression,
+        token_budget_default: token_budget_default,
+        offline_mode: offline_mode
+      }
+    end
+
+    def brain_config
+      {
+        default_brain: default_brain,
+        auto_switching: auto_brain_switching
+      }
+    end
+
+    # Environment helpers
+    def development?
+      Rails.env.development? if defined?(Rails)
+    end
+
+    def production?
+      Rails.env.production? if defined?(Rails)
+    end
+
+    def test?
+      Rails.env.test? if defined?(Rails)
+    end
+
+    private
+
+    def valid_url?(url)
+      uri = URI.parse(url)
+      uri.is_a?(URI::HTTP) || uri.is_a?(URI::HTTPS)
+    rescue URI::InvalidURIError
+      false
+    end
+  end
+end

data/lib/hokipoki/engine.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module Hokipoki
+  class Engine < ::Rails::Engine
+    isolate_namespace Hokipoki
+
+    config.generators do |g|
+      g.test_framework :rspec
+      g.fixture_replacement :factory_bot
+    end
+
+    # Auto-load paths
+    config.autoload_paths += Dir[root.join('app', 'models', 'hokipoki')]
+    config.autoload_paths += Dir[root.join('app', 'services', 'hokipoki')]
+    config.autoload_paths += Dir[root.join('app', 'controllers', 'hokipoki')]
+    config.autoload_paths += Dir[root.join('app', 'jobs', 'hokipoki')]
+
+    # Assets
+    config.assets.precompile += %w[hokipoki/dashboard.css hokipoki/workshop.css]
+    config.assets.precompile += %w[hokipoki/dashboard.js hokipoki/parasite_optimizer_controller.js hokipoki/template_manager_controller.js]
+
+    initializer "hokipoki.initialize" do |app|
+      # Initialize Hokipoki configuration
+      Hokipoki.configure unless Hokipoki.configuration
+
+      # Validate configuration in non-test environments
+      unless Rails.env.test?
+        begin
+          Hokipoki.config.validate!
+        rescue Hokipoki::ConfigurationError => e
+          Rails.logger.error "❌ Hokipoki configuration error: #{e.message}"
+          raise e if Rails.env.production?
+        end
+      end
+
+      # Set up Redis connection
+      if Hokipoki.config.redis_url.present?
+        begin
+          $redis ||= Redis.new(Hokipoki.config.redis_config)
+          Rails.logger.info "🔗 Hokipoki: Redis connected at #{Hokipoki.config.redis_url}"
+        rescue => e
+          Rails.logger.error "❌ Hokipoki: Redis connection failed: #{e.message}"
+        end
+      end
+
+      # Initialize core services
+      Rails.application.config.after_initialize do
+        if Hokipoki.config.enable_parasites
+          begin
+            Hokipoki::Parasites::UniversalGenerator.instance
+            Rails.logger.info "🦠 Hokipoki: Universal Parasite Generator initialized"
+          rescue => e
+            Rails.logger.error "❌ Hokipoki: Parasite system initialization failed: #{e.message}"
+          end
+        end
+
+        if Hokipoki.config.enable_template_optimization
+          begin
+            Hokipoki::Intelligence::UnifiedOrchestrator.instance
+            Rails.logger.info "🧠 Hokipoki: Unified Intelligence Orchestrator initialized"
+          rescue => e
+            Rails.logger.error "❌ Hokipoki: Intelligence system initialization failed: #{e.message}"
+          end
+        end
+
+        if Hokipoki.config.enable_forge
+          begin
+            require 'hokipoki/forge/generator_forge'
+            Rails.logger.info "🏭 Hokipoki: Generator Forge initialized"
+          rescue LoadError => e
+            Rails.logger.warn "⚠️ Hokipoki: Forge components not available: #{e.message}"
+          rescue => e
+            Rails.logger.error "❌ Hokipoki: Forge initialization failed: #{e.message}"
+          end
+        end
+
+        # Initialize security audit service
+        if Hokipoki.config.audit_logging
+          begin
+            Hokipoki::Security::AuditService.instance
+            Rails.logger.info "🔒 Hokipoki: Security Audit Service initialized"
+          rescue => e
+            Rails.logger.error "❌ Hokipoki: Security service initialization failed: #{e.message}"
+          end
+        end
+
+        Rails.logger.info "✅ Hokipoki Engine initialized successfully (v#{Hokipoki::VERSION})"
+      end
+    end
+
+    # Add middleware for API authentication
+    initializer "hokipoki.middleware" do |app|
+      if Hokipoki.config.api_authentication
+        require 'hokipoki/security/api_authentication'
+        app.middleware.use Hokipoki::Security::ApiAuthentication
+      end
+    end
+
+    # Configure Sidekiq for background processing
+    initializer "hokipoki.sidekiq" do |app|
+      if defined?(Sidekiq) && Hokipoki.config.background_processing == :sidekiq
+        Sidekiq.configure_server do |config|
+          config.redis = Hokipoki.config.redis_config
+        end
+
+        Sidekiq.configure_client do |config|
+          config.redis = Hokipoki.config.redis_config
+        end
+
+        Rails.logger.info "⚙️ Hokipoki: Sidekiq configured for background processing"
+      end
+    end
+
+    # Add custom rake tasks
+    rake_tasks do
+      load 'tasks/hokipoki.rake'
+    end
+
+    # Generator paths
+    config.generators.templates.unshift File.expand_path('generators/templates', __dir__)
+  end
+end