kumi 0.0.4 → 0.0.6

data/lib/kumi/cli.rb

@@ -0,0 +1,449 @@
+# frozen_string_literal: true
+
+require "json"
+require "yaml"
+require "optparse"
+require "irb"
+
+module Kumi
+  module CLI
+    class Application
+      def initialize
+        @options = {
+          interactive: false,
+          schema_file: nil,
+          input_file: nil,
+          output_format: :pretty,
+          keys: [],
+          explain: false
+        }
+      end
+
+      def run(args = ARGV)
+        parse_options(args)
+
+        if @options[:interactive]
+          start_repl
+        elsif @options[:schema_file]
+          execute_schema_file
+        else
+          show_help_and_exit
+        end
+      rescue StandardError => e
+        puts "Error: #{e.message}"
+        exit 1
+      end
+
+      private
+
+      def parse_options(args)
+        parser = OptionParser.new do |opts|
+          opts.banner = "Usage: kumi [options]"
+          opts.separator ""
+          opts.separator "Options:"
+
+          opts.on("-i", "--interactive", "Start interactive REPL mode") do
+            @options[:interactive] = true
+          end
+
+          opts.on("-f", "--file FILE", "Load schema from Ruby file") do |file|
+            @options[:schema_file] = file
+          end
+
+          opts.on("-d", "--data FILE", "Load input data from JSON/YAML file") do |file|
+            @options[:input_file] = file
+          end
+
+          opts.on("-k", "--keys KEY1,KEY2", Array, "Extract specific keys (comma-separated)") do |keys|
+            @options[:keys] = keys.map(&:to_sym)
+          end
+
+          opts.on("-e", "--explain KEY", "Explain how a specific key is computed") do |key|
+            @options[:explain] = key.to_sym
+          end
+
+          opts.on("-o", "--format FORMAT", %i[pretty json yaml], "Output format: pretty, json, yaml") do |format|
+            @options[:output_format] = format
+          end
+
+          opts.on("-h", "--help", "Show this help message") do
+            puts opts
+            exit
+          end
+        end
+
+        parser.parse!(args)
+      end
+
+      def show_help_and_exit
+        puts <<~HELP
+          Kumi CLI - Declarative decision modeling for Ruby
+
+          Usage:
+            kumi -i                              # Start interactive mode
+            kumi -f schema.rb -d data.json       # Execute schema with data
+            kumi -f schema.rb -k key1,key2       # Extract specific keys
+            kumi -f schema.rb -e key_name        # Explain computation
+
+          Examples:
+            # Interactive mode for rapid testing
+            kumi -i
+
+            # Execute schema file with JSON data
+            kumi -f my_schema.rb -d input.json
+
+            # Get specific values in JSON format
+            kumi -f my_schema.rb -d input.yaml -k salary,bonus -o json
+
+            # Debug a specific computation
+            kumi -f my_schema.rb -d input.json -e total_compensation
+
+          For more information, see: https://github.com/amuta/kumi
+        HELP
+        exit
+      end
+
+      def start_repl
+        puts "🚀 Kumi Interactive REPL"
+        puts "Type 'help' for commands, 'exit' to quit"
+        puts
+
+        repl = InteractiveREPL.new
+        repl.start
+      end
+
+      def execute_schema_file
+        schema_module = load_schema_file(@options[:schema_file])
+        input_data = load_input_data(@options[:input_file])
+
+        runner = schema_module.from(input_data)
+
+        if @options[:explain]
+          result = schema_module.explain(input_data, @options[:explain])
+          puts result
+        elsif @options[:keys].any?
+          result = runner.slice(*@options[:keys])
+          output_result(result)
+        else
+          # Show available keys if no specific keys requested
+          puts "Schema loaded successfully!"
+          available_bindings = schema_module.__compiled_schema__.bindings.keys
+          puts "Available keys: #{available_bindings.join(', ')}"
+          puts "Use -k to extract specific keys or -e to explain computations"
+        end
+      end
+
+      def load_schema_file(file_path)
+        raise "Schema file not found: #{file_path}" unless File.exist?(file_path)
+
+        # Load the file and extract the module
+        require_relative File.expand_path(file_path)
+
+        # Find the module name from the file
+        module_name = extract_module_name_from_file(file_path)
+
+        raise "Could not find module extending Kumi::Schema in #{file_path}" unless module_name
+
+        # Get the module constant
+        schema_module = Object.const_get(module_name)
+
+        raise "Module #{module_name} does not have a compiled schema" unless schema_module.__compiled_schema__
+
+        schema_module
+      end
+
+      def extract_module_name_from_file(file_path)
+        content = File.read(file_path)
+
+        # Look for "module ModuleName" pattern
+        if (match = content.match(/^\s*module\s+(\w+)/))
+          match[1]
+        end
+      end
+
+      def load_input_data(file_path)
+        return {} unless file_path
+
+        raise "Input file not found: #{file_path}" unless File.exist?(file_path)
+
+        case File.extname(file_path).downcase
+        when ".json"
+          JSON.parse(File.read(file_path), symbolize_names: true)
+        when ".yml", ".yaml"
+          YAML.safe_load_file(file_path, symbolize_names: true)
+        else
+          raise "Unsupported input file format. Use .json or .yaml"
+        end
+      end
+
+      def output_result(result)
+        case @options[:output_format]
+        when :json
+          puts JSON.pretty_generate(result)
+        when :yaml
+          puts result.to_yaml
+        else
+          output_pretty(result)
+        end
+      end
+
+      def output_pretty(result)
+        case result
+        when Hash
+          result.each do |key, value|
+            puts "#{key}: #{format_value(value)}"
+          end
+        when Kumi::Explain::Result
+          puts "Explanation for: #{result.key}"
+          puts "Value: #{format_value(result.value)}"
+          puts
+          puts "Computation trace:"
+          result.trace.each do |step|
+            puts "  #{step[:operation]} -> #{format_value(step[:result])}"
+          end
+        else
+          puts format_value(result)
+        end
+      end
+
+      def format_value(value)
+        case value
+        when String
+          value.inspect
+        when Numeric
+          value.is_a?(Float) ? value.round(2) : value
+        when Array, Hash
+          value.inspect
+        else
+          value.to_s
+        end
+      end
+    end
+
+    class InteractiveREPL
+      def initialize
+        @schema_module = nil
+        @runner = nil
+        @input_data = {}
+      end
+
+      def start
+        loop do
+          print "kumi> "
+          input = gets&.chomp
+          break if input.nil? || input == "exit"
+
+          execute_command(input)
+        end
+        puts "Goodbye!"
+      end
+
+      private
+
+      def execute_command(input)
+        case input.strip
+        when "help"
+          show_help
+        when /^schema\s+(.+)/
+          load_schema_command(::Regexp.last_match(1))
+        when /^data\s+(.+)/
+          load_data_command(::Regexp.last_match(1))
+        when /^set\s+(\w+)\s+(.+)/
+          set_data_command(::Regexp.last_match(1), ::Regexp.last_match(2))
+        when /^get\s+(.+)/
+          get_value_command(::Regexp.last_match(1))
+        when /^explain\s+(.+)/
+          explain_command(::Regexp.last_match(1))
+        when /^slice\s+(.+)/
+          slice_command(::Regexp.last_match(1))
+        when "keys"
+          show_keys
+        when "clear"
+          clear_data
+        when ""
+          # ignore empty input
+        else
+          puts "Unknown command. Type 'help' for available commands."
+        end
+      rescue StandardError => e
+        puts "Error: #{e.message}"
+        puts e.backtrace.first if ENV["DEBUG"]
+      end
+
+      def show_help
+        puts <<~HELP
+          Available commands:
+
+          Schema management:
+            schema <file>          Load schema from Ruby file
+            schema { ... }         Define schema inline (experimental)
+
+          Data management:
+            data <file>           Load input data from JSON/YAML file
+            set <key> <value>     Set individual input value
+            clear                 Clear all input data
+
+          Evaluation:
+            get <key>             Get computed value for key
+            explain <key>         Show detailed computation trace
+            slice <key1,key2>     Get multiple values
+            keys                  Show available keys
+
+          General:
+            help                  Show this help
+            exit                  Exit REPL
+
+          Examples:
+            schema examples/tax_2024.rb
+            data test_input.json
+            get total_tax
+            explain effective_rate
+            slice income,deductions,total_tax
+        HELP
+      end
+
+      def load_schema_command(file_path)
+        file_path = file_path.strip.gsub(/^["']|["']$/, "") # Remove quotes
+
+        unless File.exist?(file_path)
+          puts "Schema file not found: #{file_path}"
+          return
+        end
+
+        @schema_module = Module.new
+        @schema_module.extend(Kumi::Schema)
+
+        schema_content = File.read(file_path)
+        @schema_module.module_eval(schema_content, file_path)
+
+        puts "✅ Schema loaded from #{file_path}"
+        refresh_runner
+      rescue StandardError => e
+        puts "❌ Failed to load schema: #{e.message}"
+      end
+
+      def load_data_command(file_path)
+        file_path = file_path.strip.gsub(/^["']|["']$/, "") # Remove quotes
+
+        unless File.exist?(file_path)
+          puts "Data file not found: #{file_path}"
+          return
+        end
+
+        case File.extname(file_path).downcase
+        when ".json"
+          @input_data = JSON.parse(File.read(file_path), symbolize_names: true)
+        when ".yml", ".yaml"
+          @input_data = YAML.safe_load_file(file_path, symbolize_names: true)
+        else
+          puts "Unsupported file format. Use .json or .yaml"
+          return
+        end
+
+        puts "✅ Data loaded from #{file_path}"
+        puts "Keys: #{@input_data.keys.join(', ')}"
+        refresh_runner
+      rescue StandardError => e
+        puts "❌ Failed to load data: #{e.message}"
+      end
+
+      def set_data_command(key, value)
+        # Try to parse value as JSON first, then as literal
+        parsed_value = begin
+          JSON.parse(value)
+        rescue JSON::ParserError
+          # If not valid JSON, treat as string unless it looks like a number/boolean
+          case value
+          when /^\d+$/ then value.to_i
+          when /^\d+\.\d+$/ then value.to_f
+          when "true" then true
+          when "false" then false
+          else value
+          end
+        end
+
+        @input_data[key.to_sym] = parsed_value
+        puts "✅ Set #{key} = #{parsed_value.inspect}"
+        refresh_runner
+      end
+
+      def get_value_command(key)
+        ensure_runner_ready
+
+        key_sym = key.strip.to_sym
+        result = @runner[key_sym]
+        puts "#{key_sym}: #{format_value(result)}"
+      rescue StandardError => e
+        puts "❌ Error getting #{key}: #{e.message}"
+      end
+
+      def explain_command(key)
+        ensure_runner_ready
+
+        key_sym = key.strip.to_sym
+        puts @schema_module.explain(@input_data, key_sym)
+      rescue StandardError => e
+        puts "❌ Error explaining #{key}: #{e.message}"
+      end
+
+      def slice_command(keys_str)
+        ensure_runner_ready
+
+        keys = keys_str.split(",").map { |k| k.strip.to_sym }
+        result = @runner.slice(*keys)
+
+        result.each do |key, value|
+          puts "#{key}: #{format_value(value)}"
+        end
+      rescue StandardError => e
+        puts "❌ Error getting slice: #{e.message}"
+      end
+
+      def show_keys
+        if @schema_module
+          available_bindings = @schema_module.__compiled_schema__.bindings.keys
+          puts "Available keys: #{available_bindings.join(', ')}"
+        else
+          puts "No schema loaded. Use 'schema <file>' to load a schema."
+        end
+      end
+
+      def clear_data
+        @input_data = {}
+        @runner = nil
+        puts "✅ Input data cleared"
+      end
+
+      def ensure_runner_ready
+        raise "No schema loaded. Use 'schema <file>' to load a schema." unless @schema_module
+
+        return if @runner
+
+        raise "No runner available. Load data with 'data <file>' or set values with 'set <key> <value>'"
+      end
+
+      def refresh_runner
+        return unless @schema_module
+
+        @runner = @schema_module.from(@input_data)
+        puts "✅ Runner refreshed with current data"
+      rescue StandardError => e
+        puts "⚠️  Runner refresh failed: #{e.message}"
+        @runner = nil
+      end
+
+      def format_value(value)
+        case value
+        when String
+          value.inspect
+        when Numeric
+          value.is_a?(Float) ? value.round(2) : value
+        when Array, Hash
+          value.inspect
+        else
+          value.to_s
+        end
+      end
+    end
+  end
+end

data/lib/kumi/compiler.rb

@@ -14,9 +14,27 @@ module Kumi
         compile_field(expr)
       end
 
+      def compile_element_field_reference(expr)
+        path = expr.path
+
+        lambda do |ctx|
+          # Start with the top-level collection from the context.
+          collection = ctx[path.first]
+
+          # Recursively map over the nested collections.
+          # The `dig_and_map` helper will handle any level of nesting.
+          dig_and_map(collection, path[1..])
+        end
+      end
+
+
       def compile_binding_node(expr)
-        fn = @bindings[expr.name].last
-        ->(ctx) { fn.call(ctx) }
+        name = expr.name
+        # Handle forward references in cycles by deferring binding lookup to runtime
+        lambda do |ctx|
+          fn = @bindings[name].last
+          fn.call(ctx)
+        end
       end
 
       def compile_list(expr)
@@ -27,28 +45,102 @@ module Kumi
       def compile_call(expr)
         fn_name = expr.fn_name
         arg_fns = expr.args.map { |a| compile_expr(a) }
-        ->(ctx) { invoke_function(fn_name, arg_fns, ctx, expr.loc) }
+        
+        # Check if this is a vectorized operation
+        if vectorized_operation?(expr)
+          ->(ctx) { invoke_vectorized_function(fn_name, arg_fns, ctx, expr.loc) }
+        else
+          ->(ctx) { invoke_function(fn_name, arg_fns, ctx, expr.loc) }
+        end
       end
 
       def compile_cascade(expr)
-        pairs = expr.cases.map { |c| [compile_expr(c.condition), compile_expr(c.result)] }
-        lambda do |ctx|
-          pairs.each { |cond, res| return res.call(ctx) if cond.call(ctx) }
-          nil
+        # Check if current declaration is vectorized
+        broadcast_meta = @analysis.state[:broadcast_metadata]
+        is_vectorized = @current_declaration && broadcast_meta&.dig(:vectorized_operations, @current_declaration)
+        
+        
+        # For vectorized cascades, we need to transform conditions that use all?
+        if is_vectorized
+          pairs = expr.cases.map do |c|
+            condition_fn = transform_vectorized_condition(c.condition)
+            result_fn = compile_expr(c.result)
+            [condition_fn, result_fn]
+          end
+        else
+          pairs = expr.cases.map { |c| [compile_expr(c.condition), compile_expr(c.result)] }
+        end
+        
+        if is_vectorized
+          lambda do |ctx|
+            # This cascade can be vectorized - check if we actually need to at runtime
+            # Evaluate all conditions and results to check for arrays
+            cond_results = pairs.map { |cond, _res| cond.call(ctx) }
+            res_results = pairs.map { |_cond, res| res.call(ctx) }
+            
+            # Check if any conditions or results are arrays (vectorized)
+            has_vectorized_data = (cond_results + res_results).any? { |v| v.is_a?(Array) }
+            
+            if has_vectorized_data
+              # Apply element-wise cascade evaluation
+              array_length = cond_results.find { |v| v.is_a?(Array) }&.length || 
+                           res_results.find { |v| v.is_a?(Array) }&.length || 1
+              
+              (0...array_length).map do |i|
+                pairs.each_with_index do |(cond, res), pair_idx|
+                  cond_val = cond_results[pair_idx].is_a?(Array) ? cond_results[pair_idx][i] : cond_results[pair_idx]
+                  
+                  if cond_val
+                    res_val = res_results[pair_idx].is_a?(Array) ? res_results[pair_idx][i] : res_results[pair_idx]
+                    break res_val
+                  end
+                end || nil
+              end
+            else
+              # All data is scalar - use regular cascade evaluation
+              pairs.each_with_index do |(cond, res), pair_idx|
+                return res_results[pair_idx] if cond_results[pair_idx]
+              end
+              nil
+            end
+          end
+        else
+          lambda do |ctx|
+            pairs.each { |cond, res| return res.call(ctx) if cond.call(ctx) }
+            nil
+          end
         end
       end
+
+      def transform_vectorized_condition(condition_expr)
+        # If this is fn(:all?, [trait_ref]), extract the trait_ref for vectorized cascades
+        if condition_expr.is_a?(Kumi::Syntax::CallExpression) && 
+           condition_expr.fn_name == :all? && 
+           condition_expr.args.length == 1
+          
+          arg = condition_expr.args.first
+          if arg.is_a?(Kumi::Syntax::ArrayExpression) && arg.elements.length == 1
+            trait_ref = arg.elements.first
+            return compile_expr(trait_ref)
+          end
+        end
+        
+        # Otherwise compile normally
+        compile_expr(condition_expr)
+      end
     end
 
     include ExprCompilers
 
     # Map node classes to compiler methods
     DISPATCH = {
-      Syntax::TerminalExpressions::Literal => :compile_literal,
-      Syntax::TerminalExpressions::FieldRef => :compile_field_node,
-      Syntax::TerminalExpressions::Binding => :compile_binding_node,
-      Syntax::Expressions::ListExpression => :compile_list,
-      Syntax::Expressions::CallExpression => :compile_call,
-      Syntax::Expressions::CascadeExpression => :compile_cascade
+      Kumi::Syntax::Literal => :compile_literal,
+      Kumi::Syntax::InputReference => :compile_field_node,
+      Kumi::Syntax::InputElementReference => :compile_element_field_reference,
+      Kumi::Syntax::DeclarationReference => :compile_binding_node,
+      Kumi::Syntax::ArrayExpression => :compile_list,
+      Kumi::Syntax::CallExpression => :compile_call,
+      Kumi::Syntax::CascadeExpression => :compile_cascade
     }.freeze
 
     def self.compile(schema, analyzer:)
@@ -79,10 +171,30 @@ module Kumi
       @schema.traits.each     { |t| @index[t.name] = t }
     end
 
+    def dig_and_map(collection, path_segments)
+      return collection unless collection.is_a?(Array)
+
+      current_segment = path_segments.first
+      remaining_segments = path_segments[1..]
+
+      collection.map do |element|
+        value = element[current_segment]
+
+        # If there are more segments, recurse. Otherwise, return the value.
+        if remaining_segments.empty?
+          value
+        else
+          dig_and_map(value, remaining_segments)
+        end
+      end
+    end
+
     def compile_declaration(decl)
-      kind = decl.is_a?(Syntax::Declarations::Trait) ? :trait : :attr
-      fn   = compile_expr(decl.expression)
+      @current_declaration = decl.name
+      kind = decl.is_a?(Kumi::Syntax::TraitDeclaration) ? :trait : :attr
+      fn = compile_expr(decl.expression)
       @bindings[decl.name] = [kind, fn]
+      @current_declaration = nil
     end
 
     # Dispatch to the appropriate compile_* method
@@ -91,7 +203,6 @@ module Kumi
       send(method, expr)
     end
 
-    # Existing helpers unchanged
     def compile_field(node)
       name = node.name
       loc  = node.loc
@@ -103,6 +214,73 @@ module Kumi
       end
     end
 
+    def vectorized_operation?(expr)
+      # Check if this operation uses vectorized inputs
+      broadcast_meta = @analysis.state[:broadcast_metadata]
+      return false unless broadcast_meta
+      
+      # Reduction functions are NOT vectorized operations - they consume arrays
+      if FunctionRegistry.reducer?(expr.fn_name)
+        return false
+      end
+      
+      expr.args.any? do |arg|
+        case arg
+        when Kumi::Syntax::InputElementReference
+          broadcast_meta[:array_fields]&.key?(arg.path.first)
+        when Kumi::Syntax::DeclarationReference
+          broadcast_meta[:vectorized_operations]&.key?(arg.name)
+        else
+          false
+        end
+      end
+    end
+    
+    
+    def invoke_vectorized_function(name, arg_fns, ctx, loc)
+      # Evaluate arguments
+      values = arg_fns.map { |fn| fn.call(ctx) }
+      
+      # Check if any argument is vectorized (array)
+      has_vectorized_args = values.any? { |v| v.is_a?(Array) }
+      
+      if has_vectorized_args
+        # Apply function with broadcasting to all vectorized arguments
+        vectorized_function_call(name, values)
+      else
+        # All arguments are scalars - regular function call
+        fn = FunctionRegistry.fetch(name)
+        fn.call(*values)
+      end
+    rescue StandardError => e
+      enhanced_message = "Error calling fn(:#{name}) at #{loc}: #{e.message}"
+      runtime_error = Errors::RuntimeError.new(enhanced_message)
+      runtime_error.set_backtrace(e.backtrace)
+      runtime_error.define_singleton_method(:cause) { e }
+      raise runtime_error
+    end
+    
+    def vectorized_function_call(fn_name, values)
+      # Get the function from registry
+      fn = FunctionRegistry.fetch(fn_name)
+      
+      # Find array dimensions for broadcasting
+      array_values = values.select { |v| v.is_a?(Array) }
+      return fn.call(*values) if array_values.empty?
+      
+      # All arrays should have the same length (validation could be added)
+      array_length = array_values.first.size
+      
+      # Broadcast and apply function element-wise
+      (0...array_length).map do |i|
+        element_args = values.map do |v|
+          v.is_a?(Array) ? v[i] : v  # Broadcast scalars
+        end
+        fn.call(*element_args)
+      end
+    end
+    
+
     def invoke_function(name, arg_fns, ctx, loc)
       fn = FunctionRegistry.fetch(name)
       values = arg_fns.map { |fn| fn.call(ctx) }