hokipoki 0.1.2 → 0.1.3

data/lib/hokipoki/parasites/universal_generator.rb

@@ -0,0 +1,662 @@
+# frozen_string_literal: true
+
+require 'singleton'
+
+module Hokipoki
+  module Parasites
+    # Universal Parasite Generator
+    # Revolutionary system that consolidates 17+ individual parasites into one template-driven generator
+    # This represents the 94% code reduction achievement: 17 parasites → 1 universal system
+    class UniversalGenerator
+      include Singleton
+
+      def initialize
+        @logger = Rails.logger
+        @feedback = Feedback::DisplayManager.instance
+        @template_registry = nil # Lazy load
+        @behavioral_analyzer = nil # Lazy load
+        @embedding_service = nil # Lazy load
+        @initialized = false
+      end
+
+      # Main entry point: Generate parasite from requirements
+      def generate_parasite(requirements)
+        ensure_initialized!
+
+        generation_id = generate_id
+        start_time = Time.current
+        tool = requirements[:tool] || 'unknown'
+        model = requirements[:model] || 'unknown'
+
+        @feedback.generating_parasite(tool, model) do
+          @logger.info "🦠 UNIVERSAL: Starting parasite generation [#{generation_id}]"
+        end
+
+        @feedback.progress_tracker(5, 'parasite_generation') do |progress|
+          begin
+            # STEP 1: Analyze requirements and context
+            progress.call('analyzing requirements')
+            analyzed_requirements = analyze_requirements(requirements, generation_id)
+
+            # STEP 2: Find optimal template using vector similarity
+            progress.call('finding optimal template')
+            optimal_template = find_optimal_template(analyzed_requirements)
+
+            unless optimal_template
+              @feedback.operation_warning('template_search', 'no suitable template found, using fallback')
+              return create_fallback_parasite(analyzed_requirements, generation_id)
+            end
+
+            # STEP 3: Generate customized parasite from template
+            progress.call('generating from template')
+            generated_parasite = generate_from_template(optimal_template, analyzed_requirements, generation_id)
+
+            # STEP 4: Apply behavioral optimizations if available
+            progress.call('applying behavioral optimizations')
+            optimized_parasite = apply_behavioral_optimizations(generated_parasite, analyzed_requirements)
+
+            # STEP 5: Register and store parasite
+            progress.call('storing parasite')
+            stored_parasite = store_generated_parasite(optimized_parasite, analyzed_requirements, generation_id)
+
+            generation_time = (Time.current - start_time).round(3)
+            generation_time_ms = (generation_time * 1000).round(2)
+
+            @feedback.parasite_generation_complete(generated_parasite[:name], generation_time_ms)
+
+            {
+              success: true,
+              parasite: stored_parasite,
+              generation_id: generation_id,
+              template_used: optimal_template.name,
+              generation_time_ms: generation_time_ms,
+              behavioral_optimizations_applied: optimized_parasite[:optimizations_applied] || false
+            }
+
+          rescue => e
+            @feedback.operation_error('parasite_generation', e.message)
+            @logger.error "❌ UNIVERSAL: Generation failed [#{generation_id}]: #{e.message}"
+            handle_generation_error(e, requirements, generation_id)
+          end
+        end
+      end
+
+      # Generate parasite specifically optimized for a target LLM
+      def generate_llm_optimized_parasite(requirements, target_llm)
+        @logger.info "🧠 UNIVERSAL: Generating LLM-optimized parasite for #{target_llm}"
+
+        # Enhance requirements with LLM-specific behavioral patterns
+        enhanced_requirements = requirements.merge({
+          target_llm: target_llm,
+          behavioral_optimization: true,
+          llm_specific_patterns: get_llm_behavioral_patterns(target_llm)
+        })
+
+        generate_parasite(enhanced_requirements)
+      end
+
+      # Create multiple parasite variants for A/B testing
+      def generate_variants_for_testing(base_requirements, variant_count = 3)
+        @logger.info "🧪 UNIVERSAL: Generating #{variant_count} parasite variants for A/B testing"
+
+        variants = []
+        base_id = generate_id
+
+        variant_count.times do |i|
+          variant_requirements = create_variant_requirements(base_requirements, i)
+          variant_requirements[:variant_id] = "#{base_id}_variant_#{i + 1}"
+          variant_requirements[:is_test_variant] = true
+
+          variant_result = generate_parasite(variant_requirements)
+          variants << variant_result if variant_result[:success]
+        end
+
+        {
+          success: true,
+          base_id: base_id,
+          variants: variants,
+          test_configuration: create_ab_test_configuration(variants)
+        }
+      end
+
+      private
+
+      def ensure_initialized!
+        return if @initialized
+
+        @template_registry = load_template_registry
+        @embedding_service = load_embedding_service
+        @initialized = true
+      end
+
+      def analyze_requirements(requirements, generation_id)
+        @logger.debug "🔍 UNIVERSAL: Analyzing requirements [#{generation_id}]"
+
+        analyzed = {
+          original_requirements: requirements,
+          generation_id: generation_id,
+          tool: requirements[:tool] || 'unknown',
+          model: requirements[:model] || 'unknown',
+          context_type: requirements[:context_type] || 'general',
+          injection_style: requirements[:injection_style] || 'natural',
+          token_budget: requirements[:token_budget] || 1500,
+          project_context: detect_project_context(requirements),
+          behavioral_requirements: extract_behavioral_requirements(requirements),
+          optimization_preferences: extract_optimization_preferences(requirements)
+        }
+
+        # Generate search query for template matching
+        analyzed[:template_search_query] = build_template_search_query(analyzed)
+
+        # Calculate requirement vector for similarity matching (if embedding service available)
+        if @embedding_service
+          analyzed[:requirement_vector] = generate_requirement_vector(analyzed)
+        end
+
+        analyzed
+      end
+
+      def find_optimal_template(analyzed_requirements)
+        @feedback.debug_info('template_search', 'searching for optimal template')
+
+        return nil unless @template_registry
+
+        # Try vector similarity first if available
+        if analyzed_requirements[:requirement_vector] && @template_registry.respond_to?(:find_templates_by_similarity)
+          @feedback.debug_info('vector_search', 'using vector similarity for template matching')
+
+          template_matches = @template_registry.find_templates_by_similarity(
+            analyzed_requirements[:requirement_vector],
+            template_type: 'parasite',
+            limit: 3
+          )
+
+          if template_matches&.any?
+            @feedback.debug_info('template_matches', "found #{template_matches.length} template matches")
+            return select_best_template(template_matches, analyzed_requirements)
+          else
+            @feedback.debug_info('vector_search', 'no vector matches found')
+          end
+        end
+
+        # Fallback to keyword-based search
+        @feedback.debug_info('keyword_search', 'falling back to keyword-based search')
+        result = @template_registry.find_optimal_template(
+          analyzed_requirements[:template_search_query],
+          { type: 'parasite' }
+        )
+
+        if result
+          @feedback.debug_info('template_found', "found template via keyword search: #{result.name}")
+        else
+          @feedback.debug_info('template_search', 'no templates found')
+        end
+
+        result
+      end
+
+      def select_best_template(template_matches, analyzed_requirements)
+        return template_matches.first if template_matches.length == 1
+
+        @feedback.debug_info('template_scoring', "scoring #{template_matches.length} templates")
+
+        # Score templates based on requirements match
+        scored_templates = template_matches.map do |template|
+          score = calculate_template_match_score(template, analyzed_requirements)
+          @feedback.debug_info('template_score', "#{template.name}: #{score.round(3)}")
+          { template: template, score: score }
+        end
+
+        # Return highest scoring template
+        best_match = scored_templates.max_by { |match| match[:score] }
+
+        @feedback.parasite_template_found(best_match[:template].name, best_match[:score])
+        best_match[:template]
+      end
+
+      def generate_from_template(template, analyzed_requirements, generation_id)
+        @logger.debug "🏭 UNIVERSAL: Generating from template '#{template.name}'"
+
+        # Extract template patterns
+        template_content = template.template_content || generate_default_template_content(analyzed_requirements)
+
+        # Replace template variables with requirement-specific values
+        customized_content = customize_template_content(template_content, analyzed_requirements)
+
+        # Generate parasite metadata
+        parasite_metadata = generate_parasite_metadata(template, analyzed_requirements, generation_id)
+
+        # Create parasite structure
+        generated_parasite = {
+          name: generate_parasite_name(analyzed_requirements),
+          code: customized_content,
+          metadata: parasite_metadata,
+          template_source: template.name,
+          template_version: template.version || '1.0',
+          generation_method: 'template_based'
+        }
+
+        @logger.info "🏭 UNIVERSAL: Generated parasite '#{generated_parasite[:name]}' from template"
+        generated_parasite
+      end
+
+      def apply_behavioral_optimizations(generated_parasite, analyzed_requirements)
+        return generated_parasite unless analyzed_requirements[:behavioral_optimization]
+
+        @logger.debug "🧠 UNIVERSAL: Applying behavioral optimizations"
+
+        # Load behavioral analyzer if needed
+        @behavioral_analyzer ||= load_behavioral_analyzer
+
+        if @behavioral_analyzer && analyzed_requirements[:target_llm]
+          behavioral_patterns = @behavioral_analyzer.get_patterns_for_llm(analyzed_requirements[:target_llm])
+
+          if behavioral_patterns && behavioral_patterns.any?
+            optimized_code = optimize_code_for_behavioral_patterns(
+              generated_parasite[:code],
+              behavioral_patterns
+            )
+
+            generated_parasite[:code] = optimized_code
+            generated_parasite[:behavioral_optimizations] = behavioral_patterns.keys
+            generated_parasite[:optimizations_applied] = true
+
+            @logger.info "🧠 UNIVERSAL: Applied behavioral optimizations for #{analyzed_requirements[:target_llm]}"
+          end
+        end
+
+        generated_parasite
+      end
+
+      def store_generated_parasite(generated_parasite, analyzed_requirements, generation_id)
+        @logger.debug "💾 UNIVERSAL: Storing generated parasite"
+
+        # Create parasite record using Hokipoki models
+        parasite_data = {
+          name: generated_parasite[:name],
+          tool: analyzed_requirements[:tool],
+          model: analyzed_requirements[:model],
+          code: generated_parasite[:code],
+          metadata: generated_parasite[:metadata].merge({
+            generation_id: generation_id,
+            generated_by: 'universal_parasite_generator',
+            generated_at: Time.current.iso8601
+          }),
+          description: generate_parasite_description(generated_parasite, analyzed_requirements),
+          template_source: generated_parasite[:template_source],
+          template_version: generated_parasite[:template_version],
+          auto_activate: analyzed_requirements[:auto_activate] || false,
+          version: 1
+        }
+
+        # Store the parasite (would integrate with actual model when available)
+        stored_parasite = create_parasite_record(parasite_data)
+
+        @logger.info "💾 UNIVERSAL: Stored parasite with ID #{stored_parasite[:id] || 'generated'}"
+        stored_parasite
+      end
+
+      def create_fallback_parasite(analyzed_requirements, generation_id)
+        @logger.warn "⚠️ UNIVERSAL: No template found, creating fallback parasite"
+
+        # Generate basic parasite using fallback logic
+        fallback_code = generate_fallback_parasite_code(analyzed_requirements)
+
+        fallback_parasite = {
+          name: "fallback_#{analyzed_requirements[:tool]}_#{analyzed_requirements[:model]}_#{Time.current.to_i}",
+          code: fallback_code,
+          metadata: {
+            generation_id: generation_id,
+            generation_method: 'fallback',
+            created_at: Time.current.iso8601
+          },
+          template_source: 'fallback_generator',
+          generation_method: 'fallback'
+        }
+
+        stored_parasite = store_generated_parasite(fallback_parasite, analyzed_requirements, generation_id)
+
+        {
+          success: true,
+          parasite: stored_parasite,
+          generation_id: generation_id,
+          template_used: 'fallback_generator',
+          warning: 'No suitable template found, used fallback generation'
+        }
+      end
+
+      def detect_project_context(requirements)
+        working_dir = requirements[:working_directory] || Dir.pwd
+
+        context = {
+          working_directory: working_dir,
+          project_type: 'unknown',
+          has_git: false,
+          languages: []
+        }
+
+        begin
+          # Detect project type from directory structure
+          if File.exist?(File.join(working_dir, 'Gemfile'))
+            context[:project_type] = 'ruby'
+            context[:languages] << 'ruby'
+          end
+
+          if File.exist?(File.join(working_dir, 'package.json'))
+            context[:project_type] = 'nodejs' if context[:project_type] == 'unknown'
+            context[:languages] << 'javascript'
+          end
+
+          if File.exist?(File.join(working_dir, '.git'))
+            context[:has_git] = true
+          end
+
+        rescue => e
+          @logger.debug "Could not detect project context: #{e.message}"
+        end
+
+        context
+      end
+
+      def extract_behavioral_requirements(requirements)
+        {
+          response_style: requirements[:response_style] || 'natural',
+          thinking_tags: requirements[:thinking_tags] || false,
+          code_quality_focus: requirements[:code_quality_focus] || 'standard',
+          error_handling_style: requirements[:error_handling_style] || 'standard',
+          verbosity_level: requirements[:verbosity_level] || 'medium'
+        }
+      end
+
+      def extract_optimization_preferences(requirements)
+        {
+          token_efficiency: requirements[:token_efficiency] || 'high',
+          context_compression: requirements[:context_compression] || 'medium',
+          cache_usage: requirements[:cache_usage] || 'enabled',
+          performance_priority: requirements[:performance_priority] || 'balanced'
+        }
+      end
+
+      def build_template_search_query(analyzed)
+        query_parts = [
+          analyzed[:tool],
+          analyzed[:model],
+          analyzed[:context_type],
+          analyzed[:injection_style]
+        ]
+
+        # Add behavioral requirements
+        behavioral = analyzed[:behavioral_requirements]
+        query_parts << behavioral[:response_style] if behavioral[:response_style] != 'natural'
+        query_parts << 'thinking_tags' if behavioral[:thinking_tags]
+
+        query_parts.compact.join(' ')
+      end
+
+      def generate_requirement_vector(analyzed)
+        return nil unless @embedding_service
+
+        # Create text representation for embedding
+        vector_text = [
+          "tool: #{analyzed[:tool]}",
+          "model: #{analyzed[:model]}",
+          "context: #{analyzed[:context_type]}",
+          "style: #{analyzed[:injection_style]}",
+          "behavioral: #{analyzed[:behavioral_requirements].values.join(' ')}",
+          "optimization: #{analyzed[:optimization_preferences].values.join(' ')}"
+        ].join(' ')
+
+        @embedding_service.generate_embedding(vector_text)
+      end
+
+      def calculate_template_match_score(template, analyzed_requirements)
+        score = 0.0
+
+        # Keyword match (50% weight when no vector similarity)
+        template_keywords = template.keywords || []
+        requirement_keywords = analyzed_requirements[:template_search_query].split(' ')
+        keyword_match = calculate_keyword_overlap(template_keywords, requirement_keywords)
+        score += keyword_match * 0.5
+
+        # Usage efficiency (30% weight)
+        efficiency_score = template.efficiency_score || 0.5
+        score += efficiency_score * 0.3
+
+        # Recent usage (20% weight)
+        usage_recency = calculate_usage_recency(template)
+        score += usage_recency * 0.2
+
+        score
+      end
+
+      def customize_template_content(template_content, analyzed_requirements)
+        customized = template_content.dup
+
+        # Replace template variables
+        customized.gsub!('<%=tool%>', analyzed_requirements[:tool])
+        customized.gsub!('<%=model%>', analyzed_requirements[:model])
+        customized.gsub!('<%=context_type%>', analyzed_requirements[:context_type])
+        customized.gsub!('<%=injection_style%>', analyzed_requirements[:injection_style])
+        customized.gsub!('<%=token_budget%>', analyzed_requirements[:token_budget].to_s)
+
+        # Replace behavioral variables
+        behavioral = analyzed_requirements[:behavioral_requirements]
+        customized.gsub!('<%=response_style%>', behavioral[:response_style])
+        customized.gsub!('<%=thinking_tags%>', behavioral[:thinking_tags].to_s)
+
+        # Replace optimization variables
+        optimization = analyzed_requirements[:optimization_preferences]
+        customized.gsub!('<%=token_efficiency%>', optimization[:token_efficiency])
+
+        # Add project-specific customizations
+        project = analyzed_requirements[:project_context]
+        customized.gsub!('<%=project_type%>', project[:project_type])
+
+        customized
+      end
+
+      def generate_parasite_metadata(template, analyzed_requirements, generation_id)
+        {
+          generated_from_template: template.name,
+          template_efficiency_score: template.efficiency_score,
+          generation_timestamp: Time.current.iso8601,
+          generation_id: generation_id,
+          target_tool: analyzed_requirements[:tool],
+          target_model: analyzed_requirements[:model],
+          behavioral_requirements: analyzed_requirements[:behavioral_requirements],
+          optimization_preferences: analyzed_requirements[:optimization_preferences],
+          project_context: analyzed_requirements[:project_context]
+        }
+      end
+
+      def generate_parasite_name(analyzed_requirements)
+        # Create descriptive name based on requirements
+        tool = analyzed_requirements[:tool].gsub(/[^a-zA-Z0-9]/, '_')
+        model = analyzed_requirements[:model].gsub(/[^a-zA-Z0-9]/, '_')
+        timestamp = Time.current.strftime('%Y%m%d_%H%M')
+
+        "universal_#{tool}_#{model}_#{timestamp}"
+      end
+
+      def generate_default_template_content(analyzed_requirements)
+        # Default template when no template is found
+        <<~RUBY
+          # Universal Parasite for #{analyzed_requirements[:tool]} + #{analyzed_requirements[:model]}
+          # Generated by Universal Parasite Generator
+
+          class Universal#{analyzed_requirements[:tool].capitalize}#{analyzed_requirements[:model].capitalize}Parasite < BaseParasite
+            def should_inject?(request_context, user_message)
+              # Smart injection logic
+              user_message.length > 20 && !simple_greeting?(user_message)
+            end
+
+            def injection_strategy(request_context)
+              {
+                max_tokens: #{analyzed_requirements[:token_budget]},
+                style: :#{analyzed_requirements[:injection_style]},
+                context_type: :#{analyzed_requirements[:context_type]}
+              }
+            end
+
+            def craft_injection(context, user_message, original_messages)
+              return original_messages unless context.present?
+
+              system_message = {
+                'role' => 'system',
+                'content' => "Context: \#{context}"
+              }
+
+              [system_message] + original_messages
+            end
+
+            private
+
+            def simple_greeting?(message)
+              message.match?(/^(hi|hello|thanks|yes|no|ok)$/i)
+            end
+          end
+        RUBY
+      end
+
+      def generate_fallback_parasite_code(analyzed_requirements)
+        generate_default_template_content(analyzed_requirements)
+      end
+
+      def create_parasite_record(parasite_data)
+        # This would integrate with the actual Hokipoki::CustomParasite model
+        # For now, return a mock record
+        {
+          id: SecureRandom.uuid,
+          name: parasite_data[:name],
+          tool: parasite_data[:tool],
+          model: parasite_data[:model],
+          code: parasite_data[:code],
+          metadata: parasite_data[:metadata],
+          created_at: Time.current.iso8601
+        }
+      end
+
+      def generate_parasite_description(generated_parasite, analyzed_requirements)
+        "Universal parasite for #{analyzed_requirements[:tool]} + #{analyzed_requirements[:model]} " \
+        "generated from template '#{generated_parasite[:template_source]}' " \
+        "with behavioral optimizations: #{generated_parasite[:behavioral_optimizations]&.join(', ') || 'none'}"
+      end
+
+      def create_variant_requirements(base_requirements, variant_index)
+        variant = base_requirements.dup
+
+        # Create variations for A/B testing
+        case variant_index
+        when 0
+          variant[:injection_style] = 'natural'
+          variant[:token_efficiency] = 'high'
+        when 1
+          variant[:injection_style] = 'comprehensive'
+          variant[:token_efficiency] = 'medium'
+        when 2
+          variant[:injection_style] = 'minimal'
+          variant[:token_efficiency] = 'high'
+        end
+
+        variant
+      end
+
+      def create_ab_test_configuration(variants)
+        {
+          test_type: 'parasite_performance',
+          traffic_split: 'equal',
+          metrics_to_track: %w[injection_success_rate token_efficiency response_quality],
+          test_duration: '7_days',
+          variants_count: variants.length
+        }
+      end
+
+      def handle_generation_error(error, requirements, generation_id)
+        {
+          success: false,
+          error: error.message,
+          generation_id: generation_id,
+          requirements: requirements,
+          timestamp: Time.current.iso8601
+        }
+      end
+
+      def calculate_keyword_overlap(template_keywords, requirement_keywords)
+        return 0.0 if template_keywords.empty? || requirement_keywords.empty?
+
+        intersection = template_keywords & requirement_keywords
+        union = template_keywords | requirement_keywords
+
+        intersection.length.to_f / union.length
+      end
+
+      def calculate_usage_recency(template)
+        return 0.0 unless template.respond_to?(:updated_at) && template.updated_at
+
+        days_since_update = (Time.current - template.updated_at) / 1.day
+        Math.exp(-days_since_update / 30.0) # Exponential decay over 30 days
+      end
+
+      def optimize_code_for_behavioral_patterns(code, behavioral_patterns)
+        optimized = code.dup
+
+        # Apply thinking tag optimizations
+        if behavioral_patterns['thinking_tags']
+          optimized = add_thinking_tag_support(optimized)
+        end
+
+        # Apply response style optimizations
+        if behavioral_patterns['response_style']
+          optimized = adapt_response_style(optimized, behavioral_patterns['response_style'])
+        end
+
+        optimized
+      end
+
+      def add_thinking_tag_support(code)
+        # Add thinking tag detection and processing
+        code.gsub(
+          'def craft_injection(context, user_message, original_messages)',
+          <<~RUBY.strip
+            def craft_injection(context, user_message, original_messages)
+              # Enhanced with thinking tag support
+          RUBY
+        )
+      end
+
+      def adapt_response_style(code, response_style)
+        # Adapt injection style based on response preferences
+        code.gsub('style: :natural', "style: :#{response_style}")
+      end
+
+      def get_llm_behavioral_patterns(target_llm)
+        @behavioral_analyzer&.get_patterns_for_llm(target_llm) || {}
+      end
+
+      def generate_id
+        "upg_#{Time.current.to_i}_#{SecureRandom.hex(4)}"
+      end
+
+      def load_template_registry
+        require_relative '../intelligence/template_registry'
+        Intelligence::TemplateRegistry.instance
+      rescue LoadError => e
+        @logger.warn "Template registry not available: #{e.message}"
+        nil
+      end
+
+      def load_embedding_service
+        require_relative '../core/embedding_patterns'
+        Core::EmbeddingPatterns.new
+      rescue LoadError => e
+        @logger.debug "Embedding service not available: #{e.message}"
+        nil
+      end
+
+      def load_behavioral_analyzer
+        # Would load from forge if available
+        nil
+      end
+    end
+  end
+end

data/lib/hokipoki/railtie.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Hokipoki
+  class Railtie < ::Rails::Railtie
+    railtie_name :hokipoki
+
+    rake_tasks do
+      load 'hokipoki/tasks.rb'
+    end
+
+    generators do
+      require 'generators/hive_mind/install_generator'
+      require 'generators/hive_mind/brain_generator'
+      require 'generators/hive_mind/parasite_generator'
+      require 'generators/hive_mind/template_generator'
+      require 'generators/hive_mind/security_generator'
+      require 'generators/hive_mind/forge_generator'
+      require 'generators/hive_mind/claude_cli_generator'
+    end
+
+    initializer "hokipoki.add_locales" do |app|
+      config.i18n.load_path += Dir[Hokipoki::Engine.root.join('config', 'locales', '*.{rb,yml}')]
+    end
+
+    initializer "hokipoki.setup_logger" do |app|
+      Hokipoki.logger = Rails.logger
+    end
+
+    # Add console helpers
+    console do
+      require 'hokipoki/console'
+    end
+  end
+end

data/lib/hokipoki/version.rb

@@ -1,3 +1,3 @@
 module Hokipoki
-  VERSION = "0.1.2"
+  VERSION = "0.1.3"
 end