hokipoki 0.1.0 → 0.1.2

data/lib/hokipoki/intelligence/unified_orchestrator.rb

@@ -1,395 +0,0 @@
-# frozen_string_literal: true
-
-require 'singleton'
-
-module Hokipoki
-  module Intelligence
-    # Unified Intelligence Orchestrator
-    # Revolutionary consolidation of 37+ services into one unified template-driven system
-    # This replaces: SmartRetrievalEngine, ClaudeIntelligenceService, IntelligentParasiteService,
-    # BrainManager, HybridVectorService, and 32+ other services
-    class UnifiedOrchestrator
-      include Singleton
-
-      def initialize
-        @logger = Rails.logger
-        @template_registry = TemplateRegistry.instance
-        @performance_tracker = nil # Lazy load
-        @security_audit = nil # Lazy load
-        @initialized = false
-      end
-
-      # Main entry point - replaces all service-specific method calls
-      def process_intelligence_request(request_type, input_data, options = {})
-        ensure_initialized!
-
-        request_id = generate_request_id
-        start_time = Time.current
-
-        @logger.info "🧠 UNIFIED: Processing #{request_type} request [#{request_id}]"
-
-        begin
-          # STEP 1: Route to appropriate template based on request type
-          template = route_to_template(request_type, input_data, options)
-
-          unless template
-            return handle_no_template_available(request_type, input_data, request_id)
-          end
-
-          # STEP 2: Process using template-driven intelligence
-          result = process_with_template(template, input_data, options.merge(start_time: start_time), request_id)
-
-          # STEP 3: Track performance and learn
-          track_performance_and_learn(template, result, start_time, request_id)
-
-          @logger.info "✅ UNIFIED: Completed #{request_type} request [#{request_id}] in #{(Time.current - start_time).round(3)}s"
-          result
-
-        rescue => e
-          @logger.error "❌ UNIFIED: Request failed [#{request_id}]: #{e.message}"
-          handle_processing_error(e, request_type, input_data, request_id)
-        end
-      end
-
-      # Smart retrieval (replaces SmartRetrievalEngine)
-      def retrieve_targeted_facts(query, token_budget: 1500, intent: 'auto')
-        process_intelligence_request('smart_retrieval', {
-          query: query,
-          token_budget: token_budget,
-          intent: intent == 'auto' ? analyze_query_intent(query) : intent
-        })
-      end
-
-      # Claude interaction processing (replaces ClaudeIntelligenceService)
-      def process_claude_interaction(interaction_data)
-        process_intelligence_request('claude_intelligence', interaction_data)
-      end
-
-      # Parasite management (replaces IntelligentParasiteService)
-      def create_intelligent_parasite(parasite_config)
-        process_intelligence_request('parasite_creation', parasite_config)
-      end
-
-      # Brain management (replaces BrainManager)
-      def switch_brain(brain_name, context = {})
-        process_intelligence_request('brain_management', {
-          action: 'switch',
-          brain_name: brain_name,
-          context: context
-        })
-      end
-
-      # Get system status (replaces multiple monitoring services)
-      def get_system_status
-        ensure_initialized!
-
-        {
-          unified_orchestrator: 'operational',
-          active_templates: template_count,
-          recent_performance: recent_performance_summary,
-          cache_status: get_cache_status,
-          template_health: assess_template_health
-        }
-      end
-
-      private
-
-      def ensure_initialized!
-        return if @initialized
-
-        @template_registry = TemplateRegistry.instance
-        @performance_tracker = load_performance_tracker
-        @security_audit = load_security_audit
-        @initialized = true
-      end
-
-      def route_to_template(request_type, input_data, options)
-        # Find the best template for this request type
-        template_name = map_request_to_template(request_type)
-
-        if template_name
-          template = @template_registry.find_template_by_name(template_name)
-          return template if template
-        end
-
-        # Fallback: find by keywords and semantic similarity
-        @template_registry.find_optimal_template(
-          build_search_query(request_type, input_data),
-          { type: infer_template_type(request_type) }
-        )
-      end
-
-      def map_request_to_template(request_type)
-        template_mapping = {
-          'smart_retrieval' => 'smart_retrieval_engine_template',
-          'claude_intelligence' => 'claude_intelligence_service_template',
-          'parasite_creation' => 'intelligent_parasite_service_template',
-          'brain_management' => 'brain_manager_template',
-          'hybrid_search' => 'hybrid_vector_service_template',
-          'context_building' => 'dynamic_context_builder_template',
-          'fact_extraction' => 'atomic_fact_extractor_template',
-          'pattern_compliance' => 'pattern_compliance_checker_template',
-          'vector_embedding' => 'vector_embedding_patterns_template',
-          'token_management' => 'token_budget_manager_template',
-          'quality_assessment' => 'quality_metrics_template',
-          'performance_tracking' => 'performance_tracker_template'
-        }
-
-        template_mapping[request_type]
-      end
-
-      def process_with_template(template, input_data, options, request_id)
-        # Pre-process input using template patterns
-        processed_input = preprocess_input_with_template(template, input_data, options)
-
-        # Execute template-driven processing
-        execution_result = execute_template_logic(template, processed_input)
-
-        # Post-process result using template patterns
-        final_result = postprocess_result_with_template(template, execution_result, options)
-
-        # Add metadata
-        final_result.merge({
-          template_used: template.name,
-          template_version: template.version,
-          request_id: request_id,
-          processing_time_ms: ((Time.current.to_f - options[:start_time].to_f) * 1000).round(2)
-        })
-      end
-
-      def execute_template_logic(template, processed_input)
-        # This is where the actual template logic would be executed
-        # For now, we'll implement basic logic for each template type
-        case template.template_type
-        when 'service'
-          execute_service_template(template, processed_input)
-        when 'parasite'
-          execute_parasite_template(template, processed_input)
-        when 'utility'
-          execute_utility_template(template, processed_input)
-        else
-          { result: "Template execution not implemented for type: #{template.template_type}" }
-        end
-      end
-
-      def execute_service_template(template, input)
-        # Basic service template execution
-        case template.name
-        when /smart_retrieval/
-          execute_smart_retrieval(input)
-        when /claude_intelligence/
-          execute_claude_intelligence(input)
-        when /brain_manager/
-          execute_brain_management(input)
-        else
-          { result: "Service template execution", input: input }
-        end
-      end
-
-      def execute_smart_retrieval(input)
-        query = input.dig(:validated_input, :query) || input[:query]
-        token_budget = input.dig(:validated_input, :token_budget) || 1500
-
-        # Simplified smart retrieval logic
-        if defined?(SmartRetrievalEngine)
-          facts = SmartRetrievalEngine.new.retrieve_targeted_facts(query, token_budget: token_budget)
-          { facts: facts, context: "Context: #{facts}" }
-        else
-          { facts: ["Vector intelligence pattern for: #{query}"], context: "Context: Vector intelligence pattern" }
-        end
-      end
-
-      def execute_claude_intelligence(input)
-        { insights: ['Intelligence processing complete'], learning_data: input }
-      end
-
-      def execute_brain_management(input)
-        action = input.dig(:validated_input, :action) || input[:action]
-        brain_name = input.dig(:validated_input, :brain_name) || input[:brain_name]
-
-        { action_completed: action, brain: brain_name, status: 'switched' }
-      end
-
-      def execute_parasite_template(template, input)
-        { parasite_generated: true, template: template.name }
-      end
-
-      def execute_utility_template(template, input)
-        { utility_result: true, template: template.name }
-      end
-
-      def preprocess_input_with_template(template, input_data, options)
-        {
-          raw_input: input_data,
-          template_context: {
-            name: template.name,
-            type: template.template_type
-          },
-          validated_input: input_data
-        }
-      end
-
-      def postprocess_result_with_template(template, execution_result, options)
-        {
-          result: execution_result,
-          template_metadata: {
-            template_name: template.name,
-            template_type: template.template_type,
-            usage_count: template.usage_count
-          }
-        }
-      end
-
-      def track_performance_and_learn(template, result, start_time, request_id)
-        return unless @performance_tracker
-
-        execution_time_ms = ((Time.current - start_time) * 1000).round(2)
-
-        performance_data = {
-          execution_time_ms: execution_time_ms,
-          success: determine_success_from_result(result),
-          template_id: template.id,
-          request_id: request_id
-        }
-
-        @performance_tracker.track_execution(template.id, performance_data)
-      end
-
-      def handle_no_template_available(request_type, input_data, request_id)
-        @logger.warn "⚠️  UNIFIED: No template found for request type '#{request_type}' [#{request_id}]"
-
-        # Fallback to direct processing using legacy method
-        fallback_result = execute_legacy_fallback(request_type, input_data)
-
-        {
-          result: fallback_result,
-          template_used: 'legacy_fallback',
-          request_id: request_id,
-          warning: 'No template available, used legacy fallback'
-        }
-      end
-
-      def handle_processing_error(error, request_type, input_data, request_id)
-        @security_audit&.log_security_event('processing_error', {
-          error_message: error.message,
-          request_type: request_type,
-          request_id: request_id
-        })
-
-        {
-          success: false,
-          error: error.message,
-          request_type: request_type,
-          request_id: request_id,
-          fallback_available: legacy_fallback_available?(request_type)
-        }
-      end
-
-      def execute_legacy_fallback(request_type, input_data)
-        case request_type
-        when 'smart_retrieval'
-          query = input_data[:query] || input_data.to_s
-          { facts: ["Vector intelligence for: #{query}"], context: "Context: Vector intelligence" }
-        when 'claude_intelligence'
-          { insights: ['Basic processing complete'], learning_data: {} }
-        when 'parasite_creation'
-          { parasite_code: '# Basic parasite fallback', instructions: 'Manual setup required' }
-        else
-          { message: 'Legacy fallback executed', data: input_data }
-        end
-      end
-
-      def build_search_query(request_type, input_data)
-        base_query = request_type.gsub('_', ' ')
-
-        if input_data.is_a?(Hash)
-          additional_terms = []
-          additional_terms << input_data[:query] if input_data[:query]
-          additional_terms << input_data[:intent] if input_data[:intent]
-          additional_terms << input_data[:action] if input_data[:action]
-
-          "#{base_query} #{additional_terms.join(' ')}"
-        else
-          "#{base_query} #{input_data}"
-        end
-      end
-
-      def infer_template_type(request_type)
-        type_mapping = {
-          'smart_retrieval' => 'service',
-          'claude_intelligence' => 'service',
-          'parasite_creation' => 'parasite',
-          'brain_management' => 'utility'
-        }
-
-        type_mapping[request_type] || 'service'
-      end
-
-      def analyze_query_intent(query)
-        return 'implementation' if query.match?(/how to|implement|create|build|fix|debug|error/i)
-        return 'definition' if query.match?(/what is|define|explain|meaning|concept/i)
-        return 'frontend' if query.match?(/css|style|html|frontend|design/i)
-        return 'commands' if query.match?(/command|run|execute|bash|terminal/i)
-        return 'reference' if query.match?(/example|show me|sample|demo/i)
-        'general'
-      end
-
-      def generate_request_id
-        "unified_#{Time.current.to_i}_#{SecureRandom.hex(4)}"
-      end
-
-      def get_cache_status
-        begin
-          return 'unavailable' unless defined?(Redis)
-          Redis.new(Hokipoki.config.redis_config).ping == 'PONG' ? 'operational' : 'unavailable'
-        rescue
-          'unavailable'
-        end
-      end
-
-      def template_count
-        @template_registry.active_template_count rescue 0
-      end
-
-      def recent_performance_summary
-        return {} unless @performance_tracker
-        @performance_tracker.get_system_dashboard(1.hour) rescue {}
-      end
-
-      def assess_template_health
-        total = template_count
-        return { status: 'no_templates' } if total == 0
-
-        {
-          total_templates: total,
-          health_status: total > 0 ? 'healthy' : 'needs_attention'
-        }
-      end
-
-      def determine_success_from_result(result)
-        return true if result.is_a?(Hash) && result[:success] == true
-        return false if result.is_a?(Hash) && result[:success] == false
-        return false if result.is_a?(Hash) && result[:error]
-        true
-      end
-
-      def legacy_fallback_available?(request_type)
-        ['smart_retrieval', 'claude_intelligence', 'parasite_creation'].include?(request_type)
-      end
-
-      def load_performance_tracker
-        return nil unless Hokipoki.config.enable_template_optimization
-        # Would load actual performance tracker
-        nil
-      end
-
-      def load_security_audit
-        return nil unless Hokipoki.config.audit_logging
-        require_relative '../security/audit_service'
-        Security::AuditService.instance
-      rescue LoadError
-        nil
-      end
-    end
-  end
-end

data/lib/hokipoki/license_validator.rb

@@ -1,296 +0,0 @@
-# frozen_string_literal: true
-
-require 'net/http'
-require 'json'
-require 'digest'
-
-module Hokipoki
-  class LicenseValidator
-    class LicenseError < Hokipoki::Error; end
-
-    # Enterprise customer license keys (add your customers here)
-    VALID_LICENSES = [
-      'hoki-2024-enterprise-abc123def456',
-      'hoki-2024-startup-789xyz012',
-      'hoki-2024-development-dev001',
-      # Add more customer license keys as needed
-    ].freeze
-
-    VALIDATION_ENDPOINT = 'https://api.hokipoki.ai/validate_license'
-
-    class << self
-      # Main validation method called on gem initialization
-      def validate!
-        return true if Rails.env.test? # Skip validation in test environment
-
-        license_key = get_license_key
-
-        unless valid_license?(license_key)
-          handle_invalid_license(license_key)
-        end
-
-        log_license_usage(license_key)
-        true
-      end
-
-      # Validate license without raising errors (for status checks)
-      def valid_license?(license_key)
-        return false if license_key.blank?
-
-        # Check local license list first (faster)
-        return true if local_license_valid?(license_key)
-
-        # Check with remote validation service
-        remote_license_valid?(license_key)
-      end
-
-      # Get comprehensive license status
-      def license_status
-        license_key = get_license_key
-
-        {
-          license_key: mask_license_key(license_key),
-          valid: valid_license?(license_key),
-          type: determine_license_type(license_key),
-          expires_at: get_license_expiry(license_key),
-          features: get_licensed_features(license_key),
-          last_validated: get_last_validation_time
-        }
-      end
-
-      # Check if specific feature is licensed
-      def feature_licensed?(feature_name)
-        license_key = get_license_key
-        return false unless valid_license?(license_key)
-
-        licensed_features = get_licensed_features(license_key)
-        licensed_features.include?(feature_name.to_s)
-      end
-
-      private
-
-      def get_license_key
-        # Priority order: ENV var, Rails credentials, config file
-        ENV['HOKIPOKI_LICENSE_KEY'] ||
-        rails_credentials_license_key ||
-        config_file_license_key ||
-        nil
-      end
-
-      def rails_credentials_license_key
-        return nil unless defined?(Rails) && Rails.application&.credentials
-
-        Rails.application.credentials.hokipoki_license_key ||
-        Rails.application.credentials.dig(:hokipoki, :license_key)
-      end
-
-      def config_file_license_key
-        return nil unless defined?(Rails)
-
-        config_path = Rails.root.join('config', 'hokipoki_license.yml')
-        return nil unless File.exist?(config_path)
-
-        config = YAML.load_file(config_path)
-        config.dig(Rails.env, 'license_key')
-      rescue
-        nil
-      end
-
-      def local_license_valid?(license_key)
-        VALID_LICENSES.include?(license_key) ||
-        development_license?(license_key)
-      end
-
-      def development_license?(license_key)
-        # Allow development licenses in development/test environments
-        return false unless Rails.env.development? || Rails.env.test?
-
-        license_key&.start_with?('hoki-dev-') ||
-        license_key == 'development'
-      end
-
-      def remote_license_valid?(license_key)
-        return false if offline_mode?
-
-        begin
-          response = make_validation_request(license_key)
-
-          if response.is_a?(Net::HTTPSuccess)
-            result = JSON.parse(response.body)
-            cache_validation_result(license_key, result)
-            result['valid'] == true
-          else
-            # Fall back to cached result if remote is unavailable
-            use_cached_validation(license_key)
-          end
-        rescue => e
-          Rails.logger&.warn "HokiPoki license validation failed: #{e.message}"
-          use_cached_validation(license_key)
-        end
-      end
-
-      def make_validation_request(license_key)
-        uri = URI(VALIDATION_ENDPOINT)
-        http = Net::HTTP.new(uri.host, uri.port)
-        http.use_ssl = uri.scheme == 'https'
-        http.read_timeout = 5 # 5 second timeout
-
-        request = Net::HTTP::Post.new(uri)
-        request['Content-Type'] = 'application/json'
-        request['User-Agent'] = "HokiPoki-Gem/#{VERSION}"
-
-        request.body = {
-          license_key: license_key,
-          gem_version: VERSION,
-          rails_version: Rails::VERSION::STRING,
-          hostname: Socket.gethostname,
-          timestamp: Time.current.iso8601
-        }.to_json
-
-        http.request(request)
-      end
-
-      def cache_validation_result(license_key, result)
-        return unless defined?(Rails)
-
-        cache_key = "hokipoki_license_#{Digest::SHA256.hexdigest(license_key)}"
-
-        if defined?(Rails.cache)
-          Rails.cache.write(cache_key, result, expires_in: 24.hours)
-        end
-      end
-
-      def use_cached_validation(license_key)
-        return false unless defined?(Rails.cache)
-
-        cache_key = "hokipoki_license_#{Digest::SHA256.hexdigest(license_key)}"
-        cached_result = Rails.cache.read(cache_key)
-
-        cached_result&.dig('valid') == true
-      end
-
-      def handle_invalid_license(license_key)
-        error_message = if license_key.blank?
-          "HokiPoki license key is missing. Please set HOKIPOKI_LICENSE_KEY environment variable."
-        else
-          "Invalid HokiPoki license key: #{mask_license_key(license_key)}"
-        end
-
-        error_message += "\n\nTo obtain a license key:"
-        error_message += "\n  • Enterprise: Contact team@hokipoki.ai"
-        error_message += "\n  • Development: Use 'hoki-dev-development' for testing"
-        error_message += "\n  • Documentation: https://hokipoki.ai/docs/licensing"
-
-        Rails.logger&.error error_message
-
-        if Rails.env.production?
-          raise LicenseError, error_message
-        else
-          Rails.logger&.warn "⚠️  #{error_message}"
-        end
-      end
-
-      def log_license_usage(license_key)
-        return unless valid_license?(license_key)
-
-        Rails.logger&.info "✅ HokiPoki license validated: #{mask_license_key(license_key)}"
-
-        # Send usage analytics (non-blocking)
-        Thread.new { send_usage_analytics(license_key) } unless offline_mode?
-      end
-
-      def send_usage_analytics(license_key)
-        return if Rails.env.test?
-
-        analytics_data = {
-          license_key_hash: Digest::SHA256.hexdigest(license_key),
-          gem_version: VERSION,
-          rails_version: Rails::VERSION::STRING,
-          ruby_version: RUBY_VERSION,
-          usage_timestamp: Time.current.iso8601,
-          features_used: get_active_features
-        }
-
-        # Send to analytics endpoint (non-blocking, best effort)
-        begin
-          uri = URI('https://analytics.hokipoki.ai/usage')
-          http = Net::HTTP.new(uri.host, uri.port)
-          http.use_ssl = true
-          http.read_timeout = 3
-
-          request = Net::HTTP::Post.new(uri)
-          request['Content-Type'] = 'application/json'
-          request.body = analytics_data.to_json
-
-          http.request(request)
-        rescue
-          # Silently fail - analytics should never break the application
-        end
-      end
-
-      def mask_license_key(license_key)
-        return 'nil' if license_key.blank?
-        return license_key if license_key.length < 8
-
-        "#{license_key[0..3]}...#{license_key[-4..-1]}"
-      end
-
-      def determine_license_type(license_key)
-        return 'none' if license_key.blank?
-
-        case license_key
-        when /^hoki-2024-enterprise/
-          'enterprise'
-        when /^hoki-2024-startup/
-          'startup'
-        when /^hoki-dev/
-          'development'
-        when 'development'
-          'development'
-        else
-          'unknown'
-        end
-      end
-
-      def get_license_expiry(license_key)
-        # Extract expiry from license key or query remote service
-        # For now, return a default expiry
-        1.year.from_now.iso8601
-      end
-
-      def get_licensed_features(license_key)
-        license_type = determine_license_type(license_key)
-
-        case license_type
-        when 'enterprise'
-          %w[parasites forge security behavioral_analysis workshop_interface multi_llm_orchestration]
-        when 'startup'
-          %w[parasites security behavioral_analysis]
-        when 'development'
-          %w[parasites forge security behavioral_analysis workshop_interface multi_llm_orchestration]
-        else
-          %w[basic_vector_search]
-        end
-      end
-
-      def get_last_validation_time
-        return nil unless defined?(Rails.cache)
-
-        Rails.cache.read('hokipoki_last_validation') || 'never'
-      end
-
-      def get_active_features
-        features = []
-        features << 'parasites' if Hokipoki.config.enable_parasites
-        features << 'forge' if Hokipoki.config.enable_forge
-        features << 'security' if Hokipoki.config.enable_security
-        features << 'behavioral_analysis' if Hokipoki.config.enable_behavioral_analysis
-        features
-      end
-
-      def offline_mode?
-        Hokipoki.config.offline_mode rescue false
-      end
-    end
-  end
-end