hokipoki 0.3.4 → 0.5.0

data/lib/hokipoki/template_store.rb

@@ -0,0 +1,425 @@
+# frozen_string_literal: true
+
+module Hokipoki
+  # Template Store - Dynamic content generation from compressed templates
+  # Implements the "SECRET SAUCE" 75% compression breakthrough
+  class TemplateStore
+
+    # Content templates for dynamic generation
+    TEMPLATES = {
+      # Ruby/Rails templates
+      'active_record_model' => <<~TEMPLATE,
+        ActiveRecord model context: {{model_name}} with associations and validations.
+        Key methods: {{methods}}. Attributes: {{attributes}}.
+        Best practices: Use strong parameters, validate input, follow Rails conventions.
+        Common patterns: belongs_to, has_many, validates presence/uniqueness.
+      TEMPLATE
+
+      'rails_controller' => <<~TEMPLATE,
+        Rails controller context: {{controller_name}} handling {{actions}}.
+        Key methods: {{methods}}. Security: Use strong parameters, authenticate users.
+        RESTful actions: index, show, new, create, edit, update, destroy.
+        Response formats: render, redirect_to, respond_with.
+      TEMPLATE
+
+      'ruby_class' => <<~TEMPLATE,
+        Ruby class context: {{class_name}} with methods {{methods}}.
+        Object-oriented design: Use single responsibility principle.
+        Error handling: Rescue specific exceptions, provide meaningful messages.
+        Testing: Write unit tests, use dependency injection.
+      TEMPLATE
+
+      # Frontend templates
+      'javascript_code' => <<~TEMPLATE,
+        JavaScript context: {{js_concepts}}. Modern practices: use const/let, arrow functions.
+        Async patterns: Promises, async/await for API calls.
+        DOM manipulation: querySelector, addEventListener for interactions.
+        Debugging: Use console.log, browser dev tools, proper error handling.
+      TEMPLATE
+
+      'css_styles' => <<~TEMPLATE,
+        CSS styling context: {{css_classes}} for {{elements}}.
+        Layout: Flexbox for 1D, Grid for 2D layouts. Responsive design with media queries.
+        Performance: Minimize specificity, avoid !important, use CSS custom properties.
+        Modern CSS: Use logical properties, container queries, CSS Grid.
+      TEMPLATE
+
+      'erb_template' => <<~TEMPLATE,
+        ERB template context: {{template_type}} rendering {{data}}.
+        Security: Use <%= %> for output, <% %> for logic, sanitize user input.
+        Helpers: Use Rails helpers, extract complex logic to helpers.
+        Performance: Avoid N+1 queries, use partials for reusable components.
+      TEMPLATE
+
+      # Testing templates
+      'test_spec' => <<~TEMPLATE,
+        Testing context: {{test_type}} for {{subject}}.
+        Structure: Arrange-Act-Assert pattern. Use descriptive test names.
+        Mocking: Stub external dependencies, test behavior not implementation.
+        Coverage: Test happy path, edge cases, error conditions.
+      TEMPLATE
+
+      # Documentation templates
+      'documentation' => <<~TEMPLATE,
+        Documentation context: {{doc_type}} for {{topic}}.
+        Structure: Clear headings, code examples, usage instructions.
+        Content: What it does, how to use it, common gotchas.
+        Maintenance: Keep examples current, explain the why not just what.
+      TEMPLATE
+
+      # Database templates
+      'database_migration' => <<~TEMPLATE,
+        Database migration context: {{migration_type}} for {{table_name}}.
+        Safety: Use reversible migrations, test rollbacks.
+        Performance: Add indexes for queries, avoid large data changes.
+        Best practices: One concept per migration, use change method when possible.
+      TEMPLATE
+
+      # Configuration templates
+      'configuration' => <<~TEMPLATE,
+        Configuration context: {{config_type}} settings for {{environment}}.
+        Security: Use environment variables for secrets, validate configuration.
+        Organization: Group related settings, document required values.
+        Deployment: Different configs per environment, version control safe values.
+      TEMPLATE
+
+      # Error/debugging templates
+      'error_analysis' => <<~TEMPLATE,
+        Error analysis: {{error_type}} in {{context}}.
+        Common causes: {{likely_causes}}.
+        Debugging steps: Check logs, verify configuration, test incrementally.
+        Prevention: Input validation, error handling, monitoring.
+      TEMPLATE
+
+      # Implementation guidance templates
+      'implementation_guide' => <<~TEMPLATE,
+        Implementation guide for {{feature}} using {{technologies}}.
+        Approach: Start simple, iterate, test early and often.
+        Architecture: Follow MVC pattern, separate concerns, use design patterns.
+        Code quality: Readable code, meaningful names, appropriate abstractions.
+      TEMPLATE
+    }.freeze
+
+    def initialize
+      @generation_cache = {}
+      @template_usage_stats = Hash.new(0)
+    end
+
+    # Generate content from template with keywords and context
+    def generate_content(template_type, keywords:, intent:, params: {})
+      $stdout.puts "  🏭 TEMPLATE: Generating #{template_type} content"
+
+      # Track template usage
+      @template_usage_stats[template_type] += 1
+
+      # Check cache first
+      cache_key = build_cache_key(template_type, keywords, intent, params)
+      cached_content = @generation_cache[cache_key]
+
+      if cached_content
+        $stdout.puts "    💨 Cache hit for #{template_type}"
+        return cached_content
+      end
+
+      # Generate new content
+      generated_content = case template_type
+      when 'active_record_model'
+        generate_activerecord_content(keywords, intent, params)
+      when 'rails_controller'
+        generate_controller_content(keywords, intent, params)
+      when 'ruby_class'
+        generate_ruby_class_content(keywords, intent, params)
+      when 'javascript_code'
+        generate_javascript_content(keywords, intent, params)
+      when 'css_styles'
+        generate_css_content(keywords, intent, params)
+      when 'erb_template'
+        generate_erb_content(keywords, intent, params)
+      when 'test_spec'
+        generate_test_content(keywords, intent, params)
+      when 'documentation'
+        generate_documentation_content(keywords, intent, params)
+      when 'database_migration'
+        generate_migration_content(keywords, intent, params)
+      when 'configuration'
+        generate_configuration_content(keywords, intent, params)
+      else
+        generate_generic_content(template_type, keywords, intent, params)
+      end
+
+      # Cache generated content
+      @generation_cache[cache_key] = generated_content
+
+      # Clean cache if it gets too large
+      clean_cache_if_needed
+
+      $stdout.puts "    ✅ Generated #{template_type} (#{generated_content.length} chars)"
+      generated_content
+    end
+
+    # Get template statistics
+    def statistics
+      {
+        templates_available: TEMPLATES.size,
+        cache_size: @generation_cache.size,
+        most_used_template: @template_usage_stats.max_by { |k, v| v }&.first,
+        total_generations: @template_usage_stats.values.sum
+      }
+    end
+
+    private
+
+    def generate_activerecord_content(keywords, intent, params)
+      model_keywords = keywords.select { |k| k.start_with?('class_', 'method_') }
+      model_name = extract_model_name(model_keywords)
+      methods = extract_methods(model_keywords)
+
+      template = TEMPLATES['active_record_model']
+      template.gsub('{{model_name}}', model_name)
+              .gsub('{{methods}}', methods.join(', '))
+              .gsub('{{attributes}}', infer_attributes(keywords).join(', '))
+    end
+
+    def generate_controller_content(keywords, intent, params)
+      controller_keywords = keywords.select { |k| k.start_with?('class_', 'method_') }
+      controller_name = extract_controller_name(controller_keywords)
+      actions = extract_controller_actions(controller_keywords)
+
+      template = TEMPLATES['rails_controller']
+      template.gsub('{{controller_name}}', controller_name)
+              .gsub('{{actions}}', actions.join(', '))
+              .gsub('{{methods}}', actions.join(', '))
+    end
+
+    def generate_ruby_class_content(keywords, intent, params)
+      class_keywords = keywords.select { |k| k.start_with?('class_', 'method_') }
+      class_name = extract_class_name(class_keywords)
+      methods = extract_methods(class_keywords)
+
+      template = TEMPLATES['ruby_class']
+      template.gsub('{{class_name}}', class_name)
+              .gsub('{{methods}}', methods.join(', '))
+    end
+
+    def generate_javascript_content(keywords, intent, params)
+      js_concepts = keywords.select { |k| k.include?('js') || k.include?('javascript') || k.include?('function') }
+
+      template = TEMPLATES['javascript_code']
+      template.gsub('{{js_concepts}}', js_concepts.join(', '))
+    end
+
+    def generate_css_content(keywords, intent, params)
+      css_keywords = keywords.select { |k| k.start_with?('css_') }
+      css_classes = css_keywords.map { |k| k.sub('css_', '') }
+      elements = infer_css_elements(css_classes)
+
+      template = TEMPLATES['css_styles']
+      template.gsub('{{css_classes}}', css_classes.join(', '))
+              .gsub('{{elements}}', elements.join(', '))
+    end
+
+    def generate_erb_content(keywords, intent, params)
+      template_type = infer_erb_template_type(keywords)
+      data_keywords = keywords.reject { |k| k.start_with?('css_', 'tech_') }
+
+      template = TEMPLATES['erb_template']
+      template.gsub('{{template_type}}', template_type)
+              .gsub('{{data}}', data_keywords.join(', '))
+    end
+
+    def generate_test_content(keywords, intent, params)
+      test_type = infer_test_type(keywords)
+      subject = infer_test_subject(keywords)
+
+      template = TEMPLATES['test_spec']
+      template.gsub('{{test_type}}', test_type)
+              .gsub('{{subject}}', subject)
+    end
+
+    def generate_documentation_content(keywords, intent, params)
+      doc_type = infer_documentation_type(keywords)
+      topic = keywords.reject { |k| k.include?('tech_') }.join(' ')
+
+      template = TEMPLATES['documentation']
+      template.gsub('{{doc_type}}', doc_type)
+              .gsub('{{topic}}', topic)
+    end
+
+    def generate_migration_content(keywords, intent, params)
+      migration_type = infer_migration_type(keywords)
+      table_name = infer_table_name(keywords)
+
+      template = TEMPLATES['database_migration']
+      template.gsub('{{migration_type}}', migration_type)
+              .gsub('{{table_name}}', table_name)
+    end
+
+    def generate_configuration_content(keywords, intent, params)
+      config_type = infer_config_type(keywords)
+      environment = infer_environment(keywords)
+
+      template = TEMPLATES['configuration']
+      template.gsub('{{config_type}}', config_type)
+              .gsub('{{environment}}', environment)
+    end
+
+    def generate_generic_content(template_type, keywords, intent, params)
+      # Fallback for unknown template types
+      relevant_keywords = keywords.first(5)
+
+      case intent
+      when :implementation
+        "Implementation guidance for #{template_type}: #{relevant_keywords.join(', ')}. Follow established patterns, write tests, consider edge cases."
+      when :debugging
+        "Debugging #{template_type}: Check #{relevant_keywords.join(', ')}. Verify configuration, check logs, test incrementally."
+      when :learning
+        "Learning about #{template_type}: Key concepts include #{relevant_keywords.join(', ')}. Start with documentation, practice with examples."
+      when :optimization
+        "Optimizing #{template_type}: Focus on #{relevant_keywords.join(', ')}. Profile first, optimize bottlenecks, measure results."
+      else
+        "Context for #{template_type}: #{relevant_keywords.join(', ')}. Apply best practices and follow conventions."
+      end
+    end
+
+    # Helper methods for extracting semantic information from keywords
+
+    def extract_model_name(keywords)
+      model_keyword = keywords.find { |k| k.start_with?('class_') }
+      model_keyword ? model_keyword.sub('class_', '').capitalize : 'Model'
+    end
+
+    def extract_controller_name(keywords)
+      controller_keyword = keywords.find { |k| k.start_with?('class_') && k.include?('controller') }
+      controller_keyword ? controller_keyword.sub('class_', '').capitalize : 'Controller'
+    end
+
+    def extract_class_name(keywords)
+      class_keyword = keywords.find { |k| k.start_with?('class_') }
+      class_keyword ? class_keyword.sub('class_', '').capitalize : 'Class'
+    end
+
+    def extract_methods(keywords)
+      method_keywords = keywords.select { |k| k.start_with?('method_') }
+      method_keywords.map { |k| k.sub('method_', '') }.first(5)
+    end
+
+    def extract_controller_actions(keywords)
+      method_keywords = extract_methods(keywords)
+      rest_actions = %w[index show new create edit update destroy]
+      actions = method_keywords & rest_actions
+      actions.any? ? actions : method_keywords.first(3)
+    end
+
+    def infer_attributes(keywords)
+      # Infer model attributes from keywords
+      attribute_hints = keywords.select { |k|
+        k.match?(/name|title|email|description|content|status|type|id/)
+      }
+      attribute_hints.any? ? attribute_hints.first(3) : ['name', 'description']
+    end
+
+    def infer_css_elements(css_classes)
+      # Map CSS classes to likely HTML elements
+      element_mapping = {
+        'btn' => 'button',
+        'card' => 'div',
+        'container' => 'div',
+        'nav' => 'nav',
+        'header' => 'header',
+        'footer' => 'footer',
+        'form' => 'form',
+        'input' => 'input',
+        'text' => 'span'
+      }
+
+      css_classes.map { |cls|
+        element_mapping.find { |key, _| cls.include?(key) }&.last || 'div'
+      }.uniq
+    end
+
+    def infer_erb_template_type(keywords)
+      return 'layout' if keywords.any? { |k| k.include?('layout') }
+      return 'partial' if keywords.any? { |k| k.include?('partial') }
+      return 'form' if keywords.any? { |k| k.include?('form') }
+      'view'
+    end
+
+    def infer_test_type(keywords)
+      return 'unit test' if keywords.any? { |k| k.include?('unit') }
+      return 'integration test' if keywords.any? { |k| k.include?('integration') }
+      return 'system test' if keywords.any? { |k| k.include?('system') }
+      'spec'
+    end
+
+    def infer_test_subject(keywords)
+      class_keywords = keywords.select { |k| k.start_with?('class_') }
+      method_keywords = keywords.select { |k| k.start_with?('method_') }
+
+      if class_keywords.any?
+        class_keywords.first.sub('class_', '')
+      elsif method_keywords.any?
+        method_keywords.first.sub('method_', '')
+      else
+        'component'
+      end
+    end
+
+    def infer_documentation_type(keywords)
+      return 'API documentation' if keywords.any? { |k| k.include?('api') }
+      return 'user guide' if keywords.any? { |k| k.include?('guide') }
+      return 'tutorial' if keywords.any? { |k| k.include?('tutorial') }
+      'technical documentation'
+    end
+
+    def infer_migration_type(keywords)
+      return 'create table' if keywords.any? { |k| k.include?('create') }
+      return 'add column' if keywords.any? { |k| k.include?('add') }
+      return 'modify table' if keywords.any? { |k| k.include?('change') }
+      'database change'
+    end
+
+    def infer_table_name(keywords)
+      table_hints = keywords.select { |k|
+        k.match?(/users|posts|articles|products|orders|customers/)
+      }
+      table_hints.first || 'table'
+    end
+
+    def infer_config_type(keywords)
+      return 'database config' if keywords.any? { |k| k.include?('database') }
+      return 'application config' if keywords.any? { |k| k.include?('application') }
+      return 'environment config' if keywords.any? { |k| k.include?('environment') }
+      'configuration'
+    end
+
+    def infer_environment(keywords)
+      return 'production' if keywords.any? { |k| k.include?('production') }
+      return 'development' if keywords.any? { |k| k.include?('development') }
+      return 'test' if keywords.any? { |k| k.include?('test') }
+      'environment'
+    end
+
+    def build_cache_key(template_type, keywords, intent, params)
+      # Create a stable cache key
+      key_parts = [
+        template_type,
+        keywords.sort.join('_'),
+        intent.to_s,
+        params.sort_by { |k, v| k.to_s }.to_h.to_s
+      ]
+
+      Digest::MD5.hexdigest(key_parts.join('|'))
+    end
+
+    def clean_cache_if_needed
+      # Keep cache size reasonable
+      if @generation_cache.size > 500
+        # Remove oldest entries (simple LRU approximation)
+        keys_to_remove = @generation_cache.keys.first(100)
+        keys_to_remove.each { |key| @generation_cache.delete(key) }
+
+        $stdout.puts "    🧹 Cache cleaned: removed #{keys_to_remove.size} old entries"
+      end
+    end
+  end
+end