kumi 0.0.13 → 0.0.15

data/lib/kumi/frontends.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Frontends
+    def self.load(path:, inputs: {})
+      mode = (ENV["KUMI_PARSER"] || "auto") # auto|text|ruby
+      ext  = File.extname(path)
+
+      # Explicit mode selection
+      return Text.load(path:, inputs:) if mode == "text"
+      return Ruby.load(path:, inputs:) if mode == "ruby"
+      
+      # Auto mode: prefer .kumi if present
+      if mode == "auto" && ext == ".rb"
+        kumi_path = path.sub(/\.rb\z/, ".kumi")
+        if File.exist?(kumi_path)
+          return Text.load(path: kumi_path, inputs: inputs)
+        end
+      end
+      
+      # File extension based selection
+      return Text.load(path:, inputs:) if ext == ".kumi"
+      return Ruby.load(path:, inputs:) if ext == ".rb"
+      
+      # Default fallback
+      Ruby.load(path:, inputs:)
+    end
+  end
+end

data/lib/kumi/kernels/ruby/aggregate_core.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Kernels
+    module Ruby
+      module AggregateCore
+        module_function
+
+        def kumi_sum(enum, skip_nulls: true, min_count: 0)
+          total = 0
+          count = 0
+          enum.each do |x|
+            next if skip_nulls && x.nil?
+
+            total += x
+            count += 1
+          end
+          return nil if count < min_count
+
+          total
+        end
+
+        def kumi_min(enum, skip_nulls: true, min_count: 0)
+          best = nil
+          count = 0
+          enum.each do |x|
+            next if skip_nulls && x.nil?
+
+            best = x if best.nil? || x < best
+            count += 1
+          end
+          return nil if count < min_count
+
+          best
+        end
+
+        def kumi_max(enum, skip_nulls: true, min_count: 0)
+          best = nil
+          count = 0
+          enum.each do |x|
+            next if skip_nulls && x.nil?
+
+            best = x if best.nil? || x > best
+            count += 1
+          end
+          return nil if count < min_count
+
+          best
+        end
+
+        def kumi_mean(enum, skip_nulls: true, min_count: 0)
+          total = 0.0
+          count = 0
+          enum.each do |x|
+            next if skip_nulls && x.nil?
+
+            total += x
+            count += 1
+          end
+          return nil if count < [min_count, 1].max
+
+          total / count
+        end
+
+        def kumi_any(enum, skip_nulls: true, min_count: 0)
+          count = 0
+          enum.each do |x|
+            next if skip_nulls && x.nil?
+
+            return true if x
+            count += 1
+          end
+          return nil if count < min_count
+
+          false
+        end
+
+        def kumi_all(enum, skip_nulls: true, min_count: 0)
+          count = 0
+          enum.each do |x|
+            next if skip_nulls && x.nil?
+
+            return false unless x
+            count += 1
+          end
+          return nil if count < min_count
+
+          true
+        end
+
+        def kumi_count(enum, skip_nulls: true, min_count: 0)
+          count = 0
+          enum.each do |x|
+            next if skip_nulls && x.nil?
+
+            count += 1
+          end
+          return nil if count < min_count
+
+          count
+        end
+      end
+    end
+  end
+end

data/lib/kumi/kernels/ruby/datetime_scalar.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "date"
+
+module Kumi
+  module Kernels
+    module Ruby
+      module DatetimeScalar
+        module_function
+
+        def dt_add_days(d, n)
+          d + n
+        end
+
+        def dt_diff_days(d1, d2)
+          (d1 - d2).to_i
+        end
+      end
+    end
+  end
+end

data/lib/kumi/kernels/ruby/mask_scalar.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Kernels
+    module Ruby
+      module MaskScalar
+        module_function
+
+        def where(condition, if_true, if_false)
+          condition ? if_true : if_false
+        end
+      end
+    end
+  end
+end

data/lib/kumi/kernels/ruby/scalar_core.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Kernels
+    module Ruby
+      module ScalarCore
+        module_function
+
+        def kumi_add(a, b)
+          a + b
+        end
+
+        def kumi_sub(a, b)
+          a - b
+        end
+
+        def kumi_mul(a, b)
+          a * b
+        end
+
+        def kumi_div(a, b)
+          a / b.to_f
+        end
+
+        def kumi_eq(a, b)
+          a == b
+        end
+
+        def kumi_gt(a, b)
+          a > b
+        end
+
+        def kumi_gte(a, b)
+          a >= b
+        end
+
+        def kumi_lt(a, b)
+          a < b
+        end
+
+        def kumi_lte(a, b)
+          a <= b
+        end
+
+        def kumi_ne(a, b)
+          a != b
+        end
+
+        def kumi_and(a, b)
+          a && b
+        end
+
+        def kumi_or(a, b)
+          a || b
+        end
+
+        def kumi_not(a)
+          !a
+        end
+      end
+    end
+  end
+end

data/lib/kumi/kernels/ruby/string_scalar.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Kernels
+    module Ruby
+      module StringScalar
+        module_function
+
+        def str_concat(a, b)
+          "#{a}#{b}"
+        end
+
+        def str_length(s)
+          s&.length
+        end
+      end
+    end
+  end
+end

data/lib/kumi/kernels/ruby/vector_struct.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Kernels
+    module Ruby
+      module VectorStruct
+        module_function
+
+        def size(vec)
+          vec&.size
+        end
+
+        def join_zip(left, right)
+          raise NotImplementedError, "join operations should be implemented in IR/VM"
+        end
+
+        def join_product(left, right)
+          raise NotImplementedError, "join operations should be implemented in IR/VM"
+        end
+
+        def align_to(vec, target_axes)
+          raise NotImplementedError, "align_to should be implemented in IR/VM"
+        end
+
+        def lift(vec, indices)
+          raise NotImplementedError, "lift should be implemented in IR/VM"
+        end
+
+        def flatten(*args)
+          raise NotImplementedError, "flatten should be implemented in IR/VM"
+        end
+
+        def take(values, indices)
+          raise NotImplementedError, "take should be implemented in IR/VM"
+        end
+      end
+    end
+  end
+end

data/lib/kumi/runtime/executable.rb

@@ -37,30 +37,49 @@ module Kumi
     # - DEBUG_VM_ARGS=1 to trace VM execution
     # - Accessors can be debugged independently with DEBUG_ACCESSOR_OPS=1
     class Executable
-      def self.from_analysis(state, registry: nil)
+      def self.from_analysis(state, registry: nil, schema_name: nil)
         ir = state.fetch(:ir_module)
         access_plans = state.fetch(:access_plans)
         input_metadata = state[:input_metadata] || {}
-        accessors = Kumi::Core::Compiler::AccessBuilder.build(access_plans)
+        dependents = state[:dependents] || {}
+        ir_dependencies = state[:ir_dependencies] || {} # <-- from IR dependency pass
+        name_index = state[:name_index] || {} # <-- from IR dependency pass
+        accessors = Dev::Profiler.phase("compiler.access_builder") do
+          Kumi::Core::Compiler::AccessBuilder.build(access_plans)
+        end
 
         access_meta = {}
+        field_to_plan_ids = Hash.new { |h, k| h[k] = [] }
+
         access_plans.each_value do |plans|
           plans.each do |p|
             access_meta[p.accessor_key] = { mode: p.mode, scope: p.scope }
+
+            # Build precise field -> plan_ids mapping for invalidation
+            root_field = p.accessor_key.to_s.split(":").first.split(".").first.to_sym
+            field_to_plan_ids[root_field] << p.accessor_key
           end
         end
 
         # Use the internal functions hash that VM expects
         registry ||= Kumi::Registry.functions
-        new(ir: ir, accessors: accessors, access_meta: access_meta, registry: registry, input_metadata: input_metadata)
+        new(ir: ir, accessors: accessors, access_meta: access_meta, registry: registry,
+            input_metadata: input_metadata, field_to_plan_ids: field_to_plan_ids, dependents: dependents,
+            ir_dependencies: ir_dependencies, name_index: name_index, schema_name: schema_name)
       end
 
-      def initialize(ir:, accessors:, access_meta:, registry:, input_metadata:)
+      def initialize(ir:, accessors:, access_meta:, registry:, input_metadata:, field_to_plan_ids: {}, dependents: {}, ir_dependencies: {},
+                     name_index: {}, schema_name: nil)
         @ir = ir.freeze
         @acc = accessors.freeze
         @meta = access_meta.freeze
         @reg = registry
         @input_metadata = input_metadata.freeze
+        @field_to_plan_ids = field_to_plan_ids.freeze
+        @dependents = dependents.freeze
+        @ir_dependencies = ir_dependencies.freeze # decl -> [stored_bindings_it_references]
+        @name_index = name_index.freeze # store_name -> producing decl
+        @schema_name = schema_name
         @decl = @ir.decls.map { |d| [d.name, d] }.to_h
         @accessor_cache = {} # Persistent accessor cache across evaluations
       end
@@ -68,14 +87,14 @@ module Kumi
       def decl?(name) = @decl.key?(name)
 
       def read(input, mode: :ruby)
-        Run.new(self, input, mode: mode, input_metadata: @input_metadata)
+        Run.new(self, input, mode: mode, input_metadata: @input_metadata, dependents: @dependents)
       end
 
       # API compatibility for backward compatibility
       def evaluate(ctx, *key_names)
         target_keys = key_names.empty? ? @decl.keys : validate_keys(key_names)
 
-        # Handle context wrapping for backward compatibility  
+        # Handle context wrapping for backward compatibility
         input = ctx.respond_to?(:ctx) ? ctx.ctx : ctx
 
         target_keys.each_with_object({}) do |key, result|
@@ -83,21 +102,71 @@ module Kumi
         end
       end
 
-      def eval_decl(name, input, mode: :ruby)
+      def eval_decl(name, input, mode: :ruby, declaration_cache: nil)
         raise Kumi::Core::Errors::RuntimeError, "unknown decl #{name}" unless decl?(name)
 
-        out = Kumi::Core::IR::ExecutionEngine.run(@ir, { input: input, target: name, accessor_cache: @accessor_cache },
-                                              accessors: @acc, registry: @reg).fetch(name)
+        # If the caller asked for a specific binding, schedule deps once
+        decls_to_run = topo_closure_for_target(name)
+
+        vm_context = {
+          input: input,
+          accessor_cache: @accessor_cache,
+          declaration_cache: declaration_cache || {}, # run-local cache
+          decls_to_run: decls_to_run,                # <-- explicit schedule
+          strict_refs: true,                         # <-- refs must be precomputed
+          name_index: @name_index,                   # for error messages, twins, etc.
+          schema_name: @schema_name
+        }
+
+        out = Dev::Profiler.phase("vm.run", target: name) do
+          Kumi::Core::IR::ExecutionEngine.run(@ir, vm_context, accessors: @acc, registry: @reg).fetch(name)
+        end
 
         mode == :ruby ? unwrap(@decl[name], out) : out
       end
 
       def clear_field_accessor_cache(field_name)
-        # Clear cache entries for all accessor plans related to this field
-        # Cache keys are now [plan_id, input_key] arrays
-        @accessor_cache.delete_if { |cache_key, _| 
-          cache_key.is_a?(Array) && cache_key[0].to_s.start_with?("#{field_name}:")
-        }
+        # Use precise field -> plan_ids mapping for exact invalidation
+        plan_ids = @field_to_plan_ids[field_name] || []
+        # Cache keys are [plan_id, input_object_id] arrays
+        @accessor_cache.delete_if { |(pid, _), _| plan_ids.include?(pid) }
+      end
+
+      def unwrap(_decl, v)
+        v[:k] == :scalar ? v[:v] : v # no grouping needed
+      end
+
+      def topo_closure_for_target(store_name)
+        target_decl = @name_index[store_name]
+        raise "Unknown target store #{store_name}" unless target_decl
+
+        # DFS collect closure of decl names using pre-computed IR-level dependencies
+        seen = {}
+        order = []
+        visiting = {}
+
+        visit = lambda do |dname|
+          return if seen[dname]
+          raise "Cycle detected in DAG scheduler: #{dname}. Mutual recursion should be caught earlier by UnsatDetector." if visiting[dname]
+
+          visiting[dname] = true
+
+          # Visit declarations that produce the bindings this decl references
+          Array(@ir_dependencies[dname]).each do |ref_binding|
+            # Find which declaration produces this binding
+            producer = @name_index[ref_binding]
+            visit.call(producer.name) if producer
+          end
+
+          visiting.delete(dname)
+          seen[dname] = true
+          order << dname
+        end
+
+        visit.call(target_decl.name)
+
+        # 'order' is postorder; it already yields producers before consumers
+        order.map { |dname| @decl[dname] }
       end
 
       private
@@ -108,25 +177,29 @@ module Kumi
 
         raise Kumi::Errors::RuntimeError, "No binding named #{unknown_keys.first}"
       end
-
-      private
-
-      def unwrap(_decl, v)
-        v[:k] == :scalar ? v[:v] : v # no grouping needed
-      end
     end
 
     class Run
-      def initialize(program, input, mode:, input_metadata:)
+      def initialize(program, input, mode:, input_metadata:, dependents:)
         @program = program
         @input = input
         @mode = mode
         @input_metadata = input_metadata
+        @dependents = dependents
         @cache = {}
       end
 
       def get(name)
-        @cache[name] ||= @program.eval_decl(name, @input, mode: @mode)
+        unless @cache.key?(name)
+          # Get the result in VM internal format
+          vm_result = @program.eval_decl(name, @input, mode: :wrapped, declaration_cache: @cache)
+          # Store VM format for cross-VM caching
+          @cache[name] = vm_result
+        end
+
+        # Convert to requested format when returning
+        vm_result = @cache[name]
+        @mode == :wrapped ? vm_result : @program.unwrap(nil, vm_result)
       end
 
       def [](name)
@@ -135,6 +208,7 @@ module Kumi
 
       def slice(*keys)
         return {} if keys.empty?
+
         keys.each_with_object({}) { |key, result| result[key] = get(key) }
       end
 
@@ -142,7 +216,7 @@ module Kumi
         @program
       end
 
-      def method_missing(sym, *args, **kwargs, &blk)
+      def method_missing(sym, *args, **kwargs, &)
         return super unless args.empty? && kwargs.empty? && @program.decl?(sym)
 
         get(sym)
@@ -153,6 +227,8 @@ module Kumi
       end
 
       def update(**changes)
+        affected_declarations = Set.new
+
         changes.each do |field, value|
           # Validate field exists
           raise ArgumentError, "unknown input field: #{field}" unless input_field_exists?(field)
@@ -160,27 +236,20 @@ module Kumi
           # Validate domain constraints
           validate_domain_constraint(field, value)
 
-          # Update the input data
-          @input = deep_merge(@input, { field => value })
-          
+          # Update the input data IN-PLACE to preserve object_id for cache keys
+          @input[field] = value
+
           # Clear accessor cache for this specific field
           @program.clear_field_accessor_cache(field)
-        end
 
-        # Clear declaration evaluation cache after all updates
-        @cache.clear
-        self
-      end
+          # Collect all declarations that depend on this input field
+          field_dependents = @dependents[field] || []
+          affected_declarations.merge(field_dependents)
+        end
 
-      def wrapped!
-        @mode = :wrapped
-        @cache.clear
-        self
-      end
+        # Only clear cache for affected declarations, not all declarations
+        affected_declarations.each { |decl| @cache.delete(decl) }
 
-      def ruby!
-        @mode = :ruby
-        @cache.clear
         self
       end
 
@@ -214,12 +283,6 @@ module Kumi
           false
         end
       end
-
-      def deep_merge(a, b)
-        return b unless a.is_a?(Hash) && b.is_a?(Hash)
-
-        a.merge(b) { |_k, v1, v2| deep_merge(v1, v2) }
-      end
     end
   end
 end

data/lib/kumi/schema.rb

@@ -42,19 +42,25 @@ module Kumi
       nil
     end
 
-    def build_syntax_tree(&block)
-      @__syntax_tree__ = Core::RubyParser::Dsl.build_syntax_tree(&block).freeze
+    def build_syntax_tree(&)
+      @__syntax_tree__ = Core::RubyParser::Dsl.build_syntax_tree(&).freeze
     end
 
-    def schema(&block)
+    def schema(&)
       # from_location = caller_locations(1, 1).first
       # raise "Called from #{from_location.path}:#{from_location.lineno}"
-      @__syntax_tree__ = Core::RubyParser::Dsl.build_syntax_tree(&block).freeze
+      @__syntax_tree__ = Dev::Profiler.phase("frontend.parse") do
+        Core::RubyParser::Dsl.build_syntax_tree(&).freeze
+      end
 
       puts Support::SExpressionPrinter.print(@__syntax_tree__, indent: 2) if ENV["KUMI_DEBUG"] || ENV["KUMI_PRINT_SYNTAX_TREE"]
 
-      @__analyzer_result__ = Analyzer.analyze!(@__syntax_tree__).freeze
-      @__compiled_schema__ = Compiler.compile(@__syntax_tree__, analyzer: @__analyzer_result__).freeze
+      @__analyzer_result__ = Dev::Profiler.phase("analyzer") do
+        Analyzer.analyze!(@__syntax_tree__).freeze
+      end
+      @__compiled_schema__ = Dev::Profiler.phase("compiler") do
+        Compiler.compile(@__syntax_tree__, analyzer: @__analyzer_result__, schema_name: self.name).freeze
+      end
 
       Inspector.new(@__syntax_tree__, @__analyzer_result__, @__compiled_schema__)
     end

data/lib/kumi/support/diff.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Support
+    module Diff
+      module_function
+      
+      def unified(a_str, b_str)
+        a = a_str.lines
+        b = b_str.lines
+        out = []
+        max = [a.size, b.size].max
+        (0...max).each do |i|
+          next if a[i] == b[i]
+          out << format("%4d- %s", i + 1, a[i] || "")
+          out << format("%4d+ %s", i + 1, b[i] || "")
+        end
+        out.join
+      end
+    end
+  end
+end

data/lib/kumi/support/ir_render.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Kumi
+  module Support
+    module IRRender
+      module_function
+
+      # Stable JSON for goldens (simple canonical serialization)
+      def to_json(ir_module, pretty: true)
+        raise "nil IR" unless ir_module
+
+        data = {
+          inputs: ir_module.inputs,
+          decls: ir_module.decls.map do |decl|
+            {
+              name: decl.name,
+              kind: decl.kind,
+              shape: decl.shape,
+              ops: decl.ops.map do |op|
+                {
+                  tag: op.tag,
+                  attrs: op.attrs,
+                  args: op.args
+                }
+              end
+            }
+          end
+        }
+
+        if pretty
+          JSON.pretty_generate(data)
+        else
+          JSON.generate(data)
+        end
+      end
+
+      # Human pretty text (using IRDump)
+      def to_text(ir_module, analysis_state: nil)
+        raise "nil IR" unless ir_module
+
+        if defined?(Kumi::Support::IRDump)
+          # Convert AnalysisState to hash if needed
+          state_hash = analysis_state.to_h
+        else
+          # Fallback: simple text representation
+          lines = []
+          lines << "IR Module (#{ir_module.decls.size} declarations):"
+          ir_module.decls.each_with_index do |decl, i|
+            lines << "  [#{i}] #{decl.kind.upcase} #{decl.name} (#{decl.ops.size} ops)"
+            decl.ops.each_with_index do |op, j|
+              lines << "    #{j}: #{op.tag.upcase} #{op.attrs.inspect} #{op.args.inspect}"
+            end
+          end
+          lines.join("\n")
+        end
+      end
+    end
+  end
+end

data/lib/kumi/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Kumi
-  VERSION = "0.0.13"
+  VERSION = "0.0.15"
 end