hyraft 0.1.0.alpha1

data/lib/hyraft/compiler/javascript_library.rb

@@ -0,0 +1,281 @@
+# lib/hyraft/compiler/javascript_library.rb
+require_relative 'javascript_obfuscator'
+
+module Hyraft
+  module Compiler
+    class JavaScriptLibrary
+      # Store the original clean version
+      CLEAN_LIBRARIES = {
+        'lib/neonpulse' => <<~JAVASCRIPT
+        /* NeonPulse Library  */
+        (() => {
+          'use strict';
+          
+          class NeonPulse {
+            #signals = new Map();
+            #outputs = new Map();
+            #processors = new Map();
+            #forms = new Map();
+
+            constructor() {
+              this.#initialize();
+            }
+
+            #initialize = () => {
+              const readyHandler = () => {
+                this.#connectOutputs();
+                this.#connectForms();
+              };
+
+              document.readyState === 'loading' 
+                ? document.addEventListener('DOMContentLoaded', readyHandler)
+                : readyHandler();
+            };
+
+            #connectOutputs = () => {
+              const signalElements = [...document.querySelectorAll('[data-neon]')];
+              const actionElements = [...document.querySelectorAll('[data-pulse]')];
+
+              signalElements.forEach(element => {
+                const signalName = element.dataset.neon;
+                const property = element.dataset.property || 'textContent';
+                
+                if (!this.#outputs.has(signalName)) {
+                  this.#outputs.set(signalName, []);
+                }
+                this.#outputs.get(signalName).push({ element, property });
+                
+                const signal = this.#signals.get(signalName);
+                signal && this.#updateElement(element, signal.value, property);
+              });
+
+              actionElements.forEach(element => {
+                const [processor, action] = element.dataset.pulse?.split('.') ?? [];
+                const eventType = element.dataset.event || 'click';
+
+                element.addEventListener(eventType, event => {
+                  window[processor]?.[action]?.(event);
+                });
+              });
+            };
+
+            #connectForms = () => {
+              const formElements = [...document.querySelectorAll('form[data-neon-form]')];
+
+              formElements.forEach(form => {
+                const formName = form.dataset.neonForm;
+                const [processor, action] = form.dataset.submit?.split('.') ?? [];
+
+                if (processor && action) {
+                  form.addEventListener('submit', event => {
+                    event.preventDefault();
+                    event.stopPropagation();
+                    window[processor]?.[action]?.(this.#getFormData(form), event);
+                  });
+
+                  this.#forms.set(formName, form);
+                }
+
+                this.#bindFormInputs(form);
+              });
+            };
+
+            #bindFormInputs = form => {
+              const inputs = form.querySelectorAll('input, textarea, select');
+
+              inputs.forEach(input => {
+                const signalName = input.dataset.neon;
+                if (!signalName || !this.#signals.has(signalName)) return;
+
+                const signal = this.#signals.get(signalName);
+
+                // Set initial value from signal
+                if (!['checkbox', 'radio'].includes(input.type)) {
+                  input.value = signal.value ?? '';
+                }
+
+                // Bind input events to update signals
+                input.addEventListener('input', () => {
+                  if (input.type === 'checkbox') {
+                    signal.value = input.checked;
+                  } else if (input.type === 'radio') {
+                    if (input.checked) signal.value = input.value;
+                  } else {
+                    signal.value = input.value;
+                  }
+                });
+
+                // Bind signal changes to update input
+                const unwatch = this.watch(signalName, newValue => {
+                  if (input.type === 'checkbox') {
+                    input.checked = !!newValue;
+                  } else if (input.type === 'radio') {
+                    input.checked = (input.value === newValue);
+                  } else {
+                    input.value = newValue ?? '';
+                  }
+                });
+
+                // Store unwatch function for cleanup
+                if (!this.#forms.has('_watchers')) {
+                  this.#forms.set('_watchers', new Map());
+                }
+                this.#forms.get('_watchers').set(input, unwatch);
+              });
+            };
+
+            #getFormData = form => {
+              const formData = {};
+              const inputs = form.querySelectorAll('input, textarea, select');
+
+              inputs.forEach(input => {
+                const name = input.name || input.id;
+                if (!name) return;
+
+                if (input.type === 'checkbox') {
+                  formData[name] = input.checked;
+                } else if (input.type === 'radio') {
+                  if (input.checked) formData[name] = input.value;
+                } else if (input.type === 'select-multiple') {
+                  formData[name] = [...input.selectedOptions].map(opt => opt.value);
+                } else {
+                  formData[name] = input.value;
+                }
+              });
+
+              return formData;
+            };
+
+            #emitSignal = signalName => {
+              const connectedElements = this.#outputs.get(signalName);
+              const signal = this.#signals.get(signalName);
+              
+              connectedElements?.forEach(({ element, property }) => {
+                this.#updateElement(element, signal.value, property);
+              });
+            };
+
+            #updateElement = (element, value, property) => {
+              if (!element) return;
+              
+              const updates = {
+                class: () => element.className = value,
+                style: () => element.style.cssText = value,
+                value: () => {
+                  if (element.tagName === 'INPUT' || element.tagName === 'TEXTAREA') {
+                    element.value = value;
+                  }
+                }
+              };
+
+              updates[property]?.() ?? (element[property] = value);
+            };
+
+            // Public API
+            neon = (signalName, initialValue) => {
+              const proxy = new Proxy({ value: initialValue }, {
+                set: (target, property, value) => {
+                  const success = Reflect.set(target, property, value);
+                  if (success && property === 'value') {
+                    this.#emitSignal(signalName);
+                  }
+                  return success;
+                }
+              });
+              
+              this.#signals.set(signalName, proxy);
+              return proxy;
+            };
+
+            pulse = (name, actions) => {
+              const boundActions = Object.fromEntries(
+                Object.entries(actions).map(([key, value]) => [
+                  key,
+                  typeof value === 'function' ? value.bind(actions) : value
+                ])
+              );
+              
+              window[name] = boundActions;
+              return boundActions;
+            };
+
+            neonBatch = signalsObj => {
+              const results = {};
+              Object.keys(signalsObj).forEach(key => {
+                results[key] = this.neon(key, signalsObj[key]);
+              });
+              return results;
+            };
+
+            watch = (signalName, callback) => {
+              const signal = this.#signals.get(signalName);
+              if (!signal) return;
+              
+              let previousValue = signal.value;
+              const watcher = setInterval(() => {
+                if (signal.value !== previousValue) {
+                  callback(signal.value, previousValue);
+                  previousValue = signal.value;
+                }
+              }, 100);
+              
+              return () => clearInterval(watcher);
+            };
+
+            form = (formName, initialData) => {
+              const formData = this.neonBatch(initialData ?? {});
+              return formData;
+            };
+
+            submit = (formName, handler) => {
+              const form = this.#forms.get(formName);
+              if (form && handler) {
+                form.addEventListener('submit', event => {
+                  event.preventDefault();
+                  const formData = this.#getFormData(form);
+                  handler(formData, event);
+                });
+              }
+            };
+
+            cleanup = () => {
+              if (this.#forms.has('_watchers')) {
+                this.#forms.get('_watchers').forEach(unwatch => {
+                  typeof unwatch === 'function' && unwatch();
+                });
+              }
+            };
+          }
+
+          window.neonPulse = new NeonPulse();
+          // console.log('🚀 NeonPulse activated);
+        })();
+        JAVASCRIPT
+      }
+
+      def self.get(library_name, obfuscation_method: :multi_layer)
+        clean_code = CLEAN_LIBRARIES[library_name]
+        return nil unless clean_code
+        
+        case obfuscation_method
+        when :split_and_reassemble
+          JavaScriptObfuscator.split_and_reassemble(clean_code)
+        when :multi_layer
+          JavaScriptObfuscator.multi_layer_obfuscation(clean_code)
+        when :none
+          clean_code
+        else
+          JavaScriptObfuscator.multi_layer_obfuscation(clean_code)
+        end
+      end
+
+      def self.available_libraries
+        CLEAN_LIBRARIES.keys
+      end
+      
+      def self.obfuscation_methods
+        [:multi_layer, :split_and_reassemble, :none]
+      end
+    end
+  end
+end

data/lib/hyraft/compiler/javascript_obfuscator.rb

@@ -0,0 +1,141 @@
+# lib/hyraft/compiler/javascript_obfuscator.rb
+require 'json'
+
+module Hyraft
+  module Compiler
+    class JavaScriptObfuscator
+      class << self
+        # Method 4: Split and Reassemble
+        def split_and_reassemble(js_code, parts: 8)
+          return '' unless js_code && !js_code.strip.empty?
+          
+          # Calculate chunk size
+          chunk_size = (js_code.length.to_f / parts).ceil
+          # Split into chunks
+          chunks = js_code.chars.each_slice(chunk_size).map(&:join)
+          
+          # Convert to JSON for JavaScript array
+          chunks_js = chunks.to_json
+          
+          <<~JAVASCRIPT
+          (function(){
+            try {
+              var c=#{chunks_js};
+              var s=c.join('');
+              var e=document.createElement('script');
+              e.textContent=s;
+              document.head.appendChild(e);
+            } catch(err) {
+              console.error('Script load failed:', err);
+            }
+          })();
+          JAVASCRIPT
+        end
+
+        # Method 10: Multi-Layer Obfuscation
+        def multi_layer_obfuscation(js_code)
+          return '' unless js_code && !js_code.strip.empty?
+          
+          obfuscated = js_code.dup
+          
+          # Layer 1: Remove comments and extra whitespace
+          obfuscated = remove_comments_and_whitespace(obfuscated)
+          
+          # Layer 2: Safe variable renaming (EXCLUDE neonPulse)
+          obfuscated = rename_variables(obfuscated)
+          
+          # Layer 3: String obfuscation
+          obfuscated = obfuscate_strings(obfuscated)
+          
+          # Layer 4: Number obfuscation
+          obfuscated = obfuscate_numbers(obfuscated)
+          
+          # Layer 5: Split into chunks and reassemble
+          final_js = split_and_reassemble(obfuscated, parts: 6)
+          
+          final_js
+        end
+        
+        private
+        
+        def remove_comments_and_whitespace(code)
+          # Remove block comments
+          code.gsub!(/\/\*[\s\S]*?\*\//, '')
+          # Remove line comments
+          code.gsub!(/\/\/[^\n\r]*/, '')
+          # Collapse multiple whitespace
+          code.gsub!(/\s+/, ' ')
+          # Remove spaces around operators
+          code.gsub!(/\s*([=+\-*\/&|^!<>?{}();:,])\s*/, '\1')
+          # Remove multiple semicolons
+          code.gsub!(/;\s*;/, ';')
+          code.strip
+        end
+        
+        def rename_variables(code)
+          # Safe renaming - EXCLUDE neonPulse from renaming
+          renames = {
+            'NeonPulse' => 'NP',           # Rename class internally
+            # 'neonPulse' => 'np',         # DON'T rename the global instance
+            'signalName' => 'sN', 
+            'initialValue' => 'iV',
+            'element' => 'el',
+            'property' => 'pr',
+            'formData' => 'fD',
+            'callback' => 'cb',
+            'handler' => 'hd',
+            'processor' => 'pc',
+            'action' => 'ac',
+            'event' => 'ev'
+          }
+          
+          renames.each do |original, replacement|
+            code.gsub!(/\b#{original}\b/, replacement)
+          end
+          
+          code
+        end
+        
+        def obfuscate_strings(code)
+          # Obfuscate double-quoted strings
+          code.gsub!(/"([^"\\]*(\\.[^"\\]*)*)"/) do |match|
+            content = $1
+            # Mix of hex and unicode escapes
+            obfuscated_content = content.chars.map.with_index { |c, i| 
+              if i % 3 == 0
+                "\\x#{c.ord.to_s(16)}"
+              elsif i % 3 == 1
+                "\\u#{c.ord.to_s(16).rjust(4, '0')}"
+              else
+                c
+              end
+            }.join
+            "\"#{obfuscated_content}\""
+          end
+          
+          code
+        end
+        
+        def obfuscate_numbers(code)
+          # Convert some numbers to expressions
+          code.gsub!(/\b(\d+)\b/) do |match|
+            num = $1.to_i
+            if num > 5 && num < 100
+              case rand(4)
+              when 0 then "(#{num - 1} + 1)"
+              when 1 then "(#{num * 2} / 2)"
+              when 2 then "(#{num} * 1)"
+              when 3 then "0x#{num.to_s(16)}"
+              else match
+              end
+            else
+              match
+            end
+          end
+          
+          code
+        end
+      end
+    end
+  end
+end

data/lib/hyraft/compiler/parser.rb

@@ -0,0 +1,27 @@
+# lib/hyraft/compiler/parser.rb
+module Hyraft
+  module Compiler
+    class HyraftParser
+      def initialize(template)
+        @template = template
+      end
+
+      def parse
+        {
+          metadata: extract('metadata','html'),
+          metas:    extract('metas','html'),  
+          displayer: extract('displayer','html'),
+          transmuter: extract('transmuter','rb'),
+          manifestor: extract('manifestor','js'),
+          styles: @template.scan(/<style\s+src="([^"]+)"\s*\/?>/).flatten
+        }
+      end
+
+      private
+
+      def extract(tag, lang)
+        @template[/<#{tag}\s+#{lang}>(.*?)<\/#{tag}>/m, 1]&.strip
+      end
+    end
+  end
+end

data/lib/hyraft/compiler/renderer.rb

@@ -0,0 +1,217 @@
+# lib/hyraft/compiler/renderer.rb
+require_relative 'javascript_library'
+require_relative 'html_purifier'  
+
+module Hyraft
+  module Compiler
+    class HyraftRenderer
+      include HtmlPurifier
+
+
+      def initialize(obfuscation_method: :multi_layer)
+        @obfuscation_method = obfuscation_method
+      end
+
+      def render(layout, parsed, locals = {})
+        locals&.each { |k, v| instance_variable_set("@#{k}", v) }
+        
+        # Initialize required JS storage
+        @required_js = []
+        
+        # Process requires from metadata FIRST
+        if parsed[:metadata]
+          metadata_content = parsed[:metadata].to_s
+
+          # Extract and process requires
+          requires = extract_requires(metadata_content)
+          requires.each { |file_path| load_required_file(file_path) }
+          # Remove requires from metadata for final rendering
+          parsed[:metadata] = remove_requires(metadata_content)
+        end
+
+        if parsed[:transmuter]
+          transmuter_code = parsed[:transmuter]
+          processed_transmuter = convert_html_tags(transmuter_code)
+          instance_eval(processed_transmuter)
+        end
+
+        content = render_displayer(parsed[:displayer].to_s)
+        styles = (parsed[:styles] || []).map { |s| "<link rel='stylesheet' href='#{s}'>" }.join
+        
+        # Combine required JS with main manifestor - IN CORRECT ORDER
+        all_js = []
+        all_js += @required_js if @required_js  # Required libraries first
+        
+        # Add main manifestor code (no obfuscation for app code by default)
+        if parsed[:manifestor] && !parsed[:manifestor].strip.empty?
+          all_js << parsed[:manifestor]
+        end
+        
+        # Combine all JavaScript
+        js_content = all_js.join("\n")
+        js = js_content.strip.empty? ? '' : "<script>#{js_content}</script>"
+        
+        metas = render_displayer(parsed[:metadata].to_s)
+
+        result = layout.dup
+        inject_title(result, find_title(metas))
+        inject_metas(result, metas)
+        result.gsub!('<hyraft styles="css">', styles)
+             .gsub!('<hyraft content="hyraft">', content)
+             .gsub!('<hyraft script="javascript">', js)
+        result
+      end
+
+
+      
+
+
+
+      
+      private
+
+      def extract_requires(metadata_content)
+        requires = []
+        metadata_content.scan(/<require\s+file="([^"]+)"\s*\/>/) do |match|
+          requires << match.first
+        end
+        requires
+      end
+
+      def remove_requires(metadata_content)
+        metadata_content.gsub(/<require\s+file="[^"]+"\s*\/>/, '')
+      end
+
+      def load_required_file(relative_path)
+        # Clean the library name (remove .hyr extension if present)
+        clean_name = relative_path.gsub(/\.hyr$/, '')
+        
+        # Get the obfuscated library code
+        js_code = JavaScriptLibrary.get(clean_name, obfuscation_method: @obfuscation_method)
+        
+        if js_code
+          @required_js ||= []
+          @required_js << js_code
+        else
+          # If not found in JavaScriptLibrary, fall back to file system search
+          full_path = find_required_file_anywhere(relative_path)
+          
+          if full_path && File.exist?(full_path)
+            content = File.read(full_path)
+            parsed_required = parse_content(content)
+            
+            # Process transmuter from required files (for Ruby code)
+            if parsed_required[:transmuter] && !parsed_required[:transmuter].strip.empty?
+              required_transmuter = convert_html_tags(parsed_required[:transmuter])
+              instance_eval(required_transmuter)
+            end
+            
+            # Store manifestor content from required files (for JavaScript)
+            if parsed_required[:manifestor] && !parsed_required[:manifestor].strip.empty?
+              @required_js ||= []
+              # Apply obfuscation to file-based libraries too
+              file_js = parsed_required[:manifestor]
+              obfuscated_file_js = case @obfuscation_method
+                                  when :split_and_reassemble
+                                    JavaScriptObfuscator.split_and_reassemble(file_js)
+                                  when :multi_layer
+                                    JavaScriptObfuscator.multi_layer_obfuscation(file_js)
+                                  else
+                                    file_js
+                                  end
+              @required_js << obfuscated_file_js
+            end
+          else
+            puts "WARNING: Required file not found: #{relative_path}"
+            puts "Available built-in libraries: #{JavaScriptLibrary.available_libraries.join(', ')}"
+          end
+        end
+      end
+
+      def find_required_file_anywhere(relative_path)
+        # Remove .hyr extension if present
+        clean_path = relative_path.gsub(/\.hyr$/, '')
+        
+        # Search pattern: adapter-intake/*/display/**/{relative_path}.hyr
+        search_pattern = File.join(ROOT, 'adapter-intake', '*', 'display', '**', "#{clean_path}.hyr")
+        matching_files = Dir.glob(search_pattern)
+        
+        matching_files.first # Return first match
+      end
+
+      def parse_content(content)
+        sections = {
+          metadata: content[/<metadata[^>]*>(.*?)<\/metadata>/m, 1],
+          displayer: content[/<displayer[^>]*>(.*?)<\/displayer>/m, 1],
+          transmuter: content[/<transmuter[^>]*>(.*?)<\/transmuter>/m, 1],
+          manifestor: content[/<manifestor[^>]*>(.*?)<\/manifestor>/m, 1],
+          styles: content.scan(/<style\s+src="([^"]+)"\s*\/?>/).flatten 
+        }
+        sections
+      end
+
+
+      
+
+      def convert_html_tags(code)
+        code.gsub(/<html>([\s\S]*?)<\/html>/) do |match|
+          content = $1.strip
+          
+          lines = content.split("\n")
+          indented_content = lines.map { |line| "  #{line}" }.join("\n")
+          "<<~HTML\n#{indented_content}\nHTML"
+        end
+      end
+
+      def render_displayer(html)
+        html.gsub(/\[\.\s*(\w+)\s*\.\]/) { respond_to?($1) ? send($1).to_s : "[.#{$1}.]" }
+            .gsub(/<([\w-]+)(\s+[^>]*)?\s*\/>/) do |match|
+              tag = $1
+              attr_str = $2
+              render_component(tag, attr_str)
+            end
+      end
+
+      def render_component(tag, attr_str)
+        method_name = "display_#{tag.tr('-', '_')}"
+        attrs = parse_attributes(attr_str.to_s)
+        
+        if respond_to?(method_name)
+          return send(method_name, **attrs)
+        end
+        
+        attr_html = attrs.map { |k,v| "#{k}='#{v}'" }.join(' ')
+        "<div class='#{tag}' #{attr_html}>#{attrs[:name] || tag}</div>"
+      end
+
+      def parse_attributes(str) 
+        return {} if str.nil? || str.empty?
+        str.scan(/(\w+)="(.*?)"/).to_h { |k,v| [k.to_sym, v] }
+      end
+
+      def find_title(metas)
+        metas[/\<title\>(.*?)\<\/title\>/m, 1] || 
+        (instance_variable_defined?(:@page_title) && @page_title) ||
+        (page_title if respond_to?(:page_title))
+      end
+
+      def inject_title(result, title)
+        return unless title
+        result.sub!(/<title>.*<\/title>/m, "<title>#{title}</title>") || 
+        result.sub!('</head>', "  <title>#{title}</title>\n</head>")
+      end
+
+      def inject_metas(result, metas)
+        return if metas.empty?
+        
+        if result.include?('<hyraft meta="tags">')
+          result.gsub!('<hyraft meta="tags">', metas)
+        elsif result.include?('<hyraft styles="css">')
+          result.sub!('<hyraft styles="css">', "#{metas}\n<hyraft styles=\"css\">")
+        else
+          result.sub!('</head>', "#{metas}\n</head>")
+        end
+      end
+    end
+  end
+end

data/lib/hyraft/engine/circuit.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Hyraft
+  class Circuit
+    def initialize(ports = {})
+      @ports = ports
+    end
+
+    # Magic: Automatically route custom methods to execute
+    def method_missing(method, *args, &block)
+      if respond_to_missing?(method)
+        execute(operation: method, params: args.first || {})
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(method, include_private = false)
+      # Check if it's a public method defined in the subclass OR
+      # if the execute method can handle it
+      self.class.public_method_defined?(method) || can_handle_operation?(method)
+    end
+
+    def execute(input = {})
+      raise NotImplementedError, "Circuits must implement execute method"
+    end
+
+    private
+
+    def can_handle_operation?(operation)
+      # Subclasses should override this to return true for operations they handle
+      false
+    end
+  end
+end