kumi 0.0.31 → 0.0.33

data/lib/kumi/dev/golden/result.rb

@@ -71,22 +71,28 @@ module Kumi
       end
 
       class SchemaTestResult
-        attr_reader :schema_name, :test_results, :error
+        attr_reader :schema_name, :test_results, :error, :skipped, :skip_reason
 
-        def initialize(schema_name:, test_results: [], error: nil)
+        def initialize(schema_name:, test_results: [], error: nil, skipped: false, skip_reason: nil)
           @schema_name = schema_name
           @test_results = test_results
           @error = error
+          @skipped = skipped
+          @skip_reason = skip_reason
         end
 
         def passed?
-          error.nil? && test_results.all?(&:passed?)
+          skipped? || (error.nil? && test_results.all?(&:passed?))
         end
 
         def failed?
           !passed?
         end
 
+        def skipped?
+          skipped
+        end
+
         def passed_count
           test_results.count(&:passed?)
         end

data/lib/kumi/dev/golden/runtime_test.rb

@@ -17,6 +17,15 @@ module Kumi
         end
 
         def run(base_dir)
+          # Skip JavaScript runtime tests for schemas with imports (requires generated shared modules)
+          if language == :javascript && has_imports?(base_dir)
+            return SchemaTestResult.new(
+              schema_name: schema_name,
+              skipped: true,
+              skip_reason: "JavaScript runtime testing for schemas with imports requires generated shared modules"
+            )
+          end
+
           expected_outputs = load_expected_outputs(base_dir)
           actual_outputs = execute_schema(base_dir, expected_outputs.keys)
 
@@ -43,6 +52,12 @@ module Kumi
 
         private
 
+        def has_imports?(base_dir)
+          schema_file = File.join(base_dir, "schema.kumi")
+          return false unless File.exist?(schema_file)
+          File.read(schema_file).match?(/\bimport\s+/)
+        end
+
         def load_expected_outputs(base_dir)
           expected_file = File.join(base_dir, "expected.json")
           JSON.parse(File.read(expected_file))
@@ -72,7 +87,7 @@ module Kumi
           module_name = code.match(/module (Kumi::Compiled::\S+)/)[1]
           eval(code)
           module_const = Object.const_get(module_name)
-          instance = module_const.from(input_data)
+          instance = Kumi::CompiledSchemaWrapper.new(module_const, input_data)
 
           decl_names.to_h { |name| [name, instance[name.to_sym]] }
         end

data/lib/kumi/dev/golden.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
-require "fileutils"
-require "json"
-require "open3"
+require_relative "../schema"
 
 require_relative "golden/representation"
 require_relative "golden/result"
@@ -15,11 +13,19 @@ require_relative "golden/suite"
 module Kumi
   module Dev
     module Golden
+      # Precompile shared schemas so __kumi_syntax_tree__ is available for imports
+      def self.precompile_schemas!
+        if defined?(Kumi::TestSharedSchemas)
+          Kumi::TestSharedSchemas.constants.each do |const|
+            mod = Kumi::TestSharedSchemas.const_get(const)
+            mod.runner if mod.is_a?(Module) && mod.respond_to?(:runner)
+          end
+        end
+      end
+
       module_function
 
-      def list
-        suite.list
-      end
+      def list = suite.list
 
       def update!(*names)
         names = [names].flatten.compact
@@ -44,14 +50,10 @@ module Kumi
         names = names_arg.any? ? names_arg : suite.send(:schema_names)
 
         ruby_names = suite.send(:filter_testable_schemas, names, :ruby)
-        ruby_results = ruby_names.map do |schema_name|
-          RuntimeTest.new(schema_name, :ruby).run(suite.send(:schema_dir, schema_name))
-        end
+        ruby_results = ruby_names.map { |n| RuntimeTest.new(n, :ruby).run(suite.send(:schema_dir, n)) }
 
         js_names = suite.send(:filter_testable_schemas, names, :javascript)
-        js_results = js_names.map do |schema_name|
-          RuntimeTest.new(schema_name, :javascript).run(suite.send(:schema_dir, schema_name))
-        end
+        js_results = js_names.map { |n| RuntimeTest.new(n, :javascript).run(suite.send(:schema_dir, n)) }
 
         Reporter.new.report_runtime_tests(ruby: ruby_results, javascript: js_results)
       end
@@ -59,20 +61,16 @@ module Kumi
       def test_codegen!(*names_arg)
         names_arg = [names_arg].flatten.compact
         names = names_arg.any? ? names_arg : suite.send(:schema_names)
-        testable_names = suite.send(:filter_testable_schemas, names, :ruby)
-        results = testable_names.map do |schema_name|
-          RuntimeTest.new(schema_name, :ruby).run(suite.send(:schema_dir, schema_name))
-        end
+        testable = suite.send(:filter_testable_schemas, names, :ruby)
+        results = testable.map { |n| RuntimeTest.new(n, :ruby).run(suite.send(:schema_dir, n)) }
         Reporter.new.report_runtime_tests(ruby: results)
       end
 
       def test_js_codegen!(*names_arg)
         names_arg = [names_arg].flatten.compact
         names = names_arg.any? ? names_arg : suite.send(:schema_names)
-        testable_names = suite.send(:filter_testable_schemas, names, :javascript)
-        results = testable_names.map do |schema_name|
-          RuntimeTest.new(schema_name, :javascript).run(suite.send(:schema_dir, schema_name))
-        end
+        testable = suite.send(:filter_testable_schemas, names, :javascript)
+        results = testable.map { |n| RuntimeTest.new(n, :javascript).run(suite.send(:schema_dir, n)) }
         Reporter.new.report_runtime_tests(javascript: results)
       end
 

data/lib/kumi/dev/golden_schema_modules.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# Base module for golden schema imports
+# Shared schemas from golden/_shared/ should be required separately
+# before using any schemas that import from GoldenSchemas
+
+module GoldenSchemas
+end

data/lib/kumi/dev/golden_schema_wrapper.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Dev
+    # Wraps golden test schemas as importable Ruby modules
+    # Allows golden schemas to import from other golden schemas
+    #
+    # Usage:
+    #   tax_schema = GoldenSchemaWrapper.load('golden/tax_rate/schema.kumi')
+    #   Schemas::Tax = GoldenSchemaWrapper.as_module(tax_schema, 'Schemas::Tax')
+    #
+    #   # Now other schemas can: import :calculate_tax, from: Schemas::Tax
+    class GoldenSchemaWrapper
+      # Load a golden schema from a .kumi file
+      def self.load(path)
+        full_path = File.expand_path(path)
+        raise "Schema file not found: #{full_path}" unless File.exist?(full_path)
+
+        content = File.read(full_path)
+        # Parse using the standard parser
+        root = Kumi::Core::RubyParser::Dsl.build_syntax_tree { instance_eval(content) }
+        root
+      end
+
+      # Wrap a schema root in a module that can be used for imports
+      # Creates: module_const with kumi_schema_instance method
+      def self.as_module(schema_root, const_path)
+        # Create nested module structure: Schemas::Tax, Schemas::Payment, etc
+        parts = const_path.split("::")
+        module_name = parts.pop
+        parent_path = parts.empty? ? "Object" : parts.join("::")
+
+        # Get or create parent module
+        parent = if parent_path == "Object"
+          Object
+        else
+          parts.inject(Object) do |mod, part|
+            if mod.const_defined?(part, false)
+              mod.const_get(part)
+            else
+              new_mod = Module.new
+              mod.const_set(part, new_mod)
+              new_mod
+            end
+          end
+        end
+
+        # Analyze the schema to get metadata
+        analyzed_state = analyze_schema(schema_root)
+        input_metadata = extract_input_metadata(schema_root)
+
+        # Create the schema module
+        schema_module = Module.new do
+          define_singleton_method :kumi_schema_instance do
+            @instance ||= create_instance(schema_root, analyzed_state, input_metadata)
+          end
+
+          define_singleton_method :create_instance do |root, state, meta|
+            schema_obj = Object.new
+            def schema_obj.root
+              @root_ast
+            end
+
+            def schema_obj.input_metadata
+              @input_metadata
+            end
+
+            def schema_obj.analyzed_state
+              @analyzed_state
+            end
+
+            schema_obj.instance_variable_set(:@root_ast, root)
+            schema_obj.instance_variable_set(:@input_metadata, meta)
+            schema_obj.instance_variable_set(:@analyzed_state, state)
+            schema_obj
+          end
+        end
+
+        parent.const_set(module_name, schema_module)
+        schema_module
+      end
+
+      private
+
+      def self.analyze_schema(schema_root)
+        # Run full analysis on the schema
+        registry = Kumi::RegistryV2.load
+        state = Kumi::Core::Analyzer::AnalysisState.new({})
+        state = state.with(:registry, registry)
+        errors = []
+
+        # Run DEFAULT_PASSES
+        Kumi::Analyzer::DEFAULT_PASSES.each do |pass_class|
+          pass = pass_class.new(schema_root, state)
+          state = pass.run(errors)
+          raise "Analysis failed: #{errors.map(&:to_s).join(', ')}" unless errors.empty?
+        end
+
+        state
+      end
+
+      def self.extract_input_metadata(schema_root)
+        metadata = {}
+        return metadata unless schema_root.inputs
+
+        schema_root.inputs.each do |input_decl|
+          metadata[input_decl.name] = {
+            type: input_decl.type_spec&.kind || :any
+          }
+        end
+
+        metadata
+      end
+    end
+  end
+end

data/lib/kumi/dev/support/kumi_runner.mjs

@@ -1,6 +1,7 @@
 // run_kumi_direct.mjs
 import fs from "fs";
 import path from "path";
+import { fileURLToPath } from 'url';
 
 async function main() {
   try {
@@ -16,6 +17,23 @@ async function main() {
       process.exit(2);
     }
 
+    // Setup global namespace for imported schemas
+    const sharedDir = path.resolve(path.dirname(modulePath), '../../_shared');
+    globalThis.GoldenSchemas = {};
+
+    // Load all available shared schema modules
+    const sharedSchemas = ['tax', 'discount', 'compound'];
+    for (const schemaName of sharedSchemas) {
+      try {
+        const module = await import(path.resolve(sharedDir, `${schemaName}_javascript.mjs`));
+        // Convert snake_case to PascalCase for class name
+        const className = schemaName.split('_').map(w => w.charAt(0).toUpperCase() + w.slice(1)).join('');
+        globalThis.GoldenSchemas[className] = module[className];
+      } catch (e) {
+        // Shared modules may not exist for all schemas
+      }
+    }
+
     const mod = await import(modulePath);
     const input = JSON.parse(fs.readFileSync(inputPath, "utf-8"));
 

data/lib/kumi/schema.rb

@@ -5,6 +5,38 @@ require "digest"
 require "fileutils"
 
 module Kumi
+  # Thin wrapper providing backward-compatible interface for pure module functions.
+  # The compiled module now contains only module-level functions (def self._name(input)),
+  # but users expect an instance-like interface with .from(), .update(), [].
+  # This wrapper bridges that gap.
+  class CompiledSchemaWrapper
+    def initialize(compiled_module, input_data)
+      @compiled_module = compiled_module
+      @input = input_data
+    end
+
+    def [](declaration_name)
+      method_name = "_#{declaration_name}"
+      unless @compiled_module.respond_to?(method_name)
+        raise KeyError, "Unknown declaration: #{declaration_name}"
+      end
+      @compiled_module.public_send(method_name, @input)
+    end
+
+    def update(new_input)
+      @input = @input.merge(new_input)
+      self
+    end
+
+    def from(new_input)
+      CompiledSchemaWrapper.new(@compiled_module, new_input)
+    end
+
+    private
+
+    attr_reader :compiled_module, :input
+  end
+
   # This module is the main entry point for users of the Kumi DSL.
   # When a user module `extend`s this, it gains the `schema` block method
   # and the `from` class method to execute the compiled logic.
@@ -34,12 +66,12 @@ module Kumi
     def runner
       ensure_compiled!
 
-      __kumi_compiled_module__.from({})
+      CompiledSchemaWrapper.new(__kumi_compiled_module__, {})
     end
 
     def from(input_data)
       ensure_compiled!
-      __kumi_compiled_module__.from(input_data)
+      CompiledSchemaWrapper.new(__kumi_compiled_module__, input_data)
     end
 
     def write_source(file_path, platform: :ruby)
@@ -94,6 +126,16 @@ module Kumi
         # to mix in the compiled methods (_total_payroll, etc.) and the instance
         # method `__kumi_compiled_module__`.
         @__kumi_compiled_module__ = Kumi::Compiled.const_get(schema_digest)
+
+        # Create a wrapper module with the compiled functions available as instance methods.
+        # This allows them to be extended as singleton methods on the schema module.
+        # This enables schema imports to work: GoldenSchemas::Tax._tax({amount: 100})
+        wrapper = Module.new
+        @__kumi_compiled_module__.singleton_methods(false).each do |method_name|
+          wrapper.define_method(method_name, @__kumi_compiled_module__.method(method_name).to_proc)
+        end
+        self.extend(wrapper)
+
         @kumi_compiled = true
       end
     end

data/lib/kumi/support/lir_printer.rb

@@ -71,17 +71,17 @@ module Kumi
           "#{res}load_field #{only(ins.inputs)}[#{fmt_key(key)}]#{stamp(ins)}"
         when :KernelCall
           fn = ins.attributes[:fn]
-          "#{res}call #{fn}(#{list(ins.inputs)})#{stamp(ins)}"
+          "#{res}call #{fn}(#{list_with_immediates(ins)})#{stamp(ins)}"
         when :Select
-          c, t, f = ins.inputs
-          "#{res}select #{fmt_reg(c)}, #{fmt_reg(t)}, #{fmt_reg(f)}#{stamp(ins)}"
+          c, t, f = resolved_inputs(ins)
+          "#{res}select #{c}, #{t}, #{f}#{stamp(ins)}"
         when :DeclareAccumulator
           "#{res}decl_acc#{stamp(ins)}"
         when :Accumulate
           acc = fmt_reg(ins.result_register)
           fn   = ins.attributes[:fn]
-          v    = only(ins.inputs)
-          "#{res}acc_add #{fn}(#{acc}, #{fmt_reg(v)})#{stamp(ins)}"
+          v    = resolved_inputs(ins).first
+          "#{res}acc_add #{fn}(#{acc}, #{v})#{stamp(ins)}"
         when :LoadAccumulator
           acc = ins.inputs.first or raise "No accumulator bound"
           "#{res}acc_load #{fmt_reg(acc)}#{stamp(ins)}"
@@ -141,3 +141,19 @@ module Kumi
     end
   end
 end
+      def resolved_inputs(ins)
+        inputs = Array(ins.inputs)
+        imm_queue = Array(ins.immediates)
+
+        inputs.map do |input|
+          if input == :__immediate_placeholder__
+            fmt_lit(imm_queue.shift)
+          else
+            fmt_reg(input)
+          end
+        end
+      end
+
+      def list_with_immediates(ins)
+        resolved_inputs(ins).join(", ")
+      end

data/lib/kumi/support/nast_printer.rb

@@ -80,6 +80,17 @@ module Kumi
           lines << indent(print_node(node.value, depth + 1), depth + 1)
           lines << indent(")", depth)
           lines.join("\n")
+        when Kumi::Core::NAST::ImportCall
+          if node.args.empty?
+            "(ImportCall :#{node.fn_name})"
+          else
+            lines = ["(ImportCall :#{node.fn_name}"]
+            node.input_mapping_keys.zip(node.args).each do |key, arg|
+              lines << indent("(#{key} #{print_node(arg, depth + 1)})", depth + 1)
+            end
+            lines << indent(")", depth)
+            lines.join("\n")
+          end
         else
           node.inspect
         end

data/lib/kumi/support/s_expression_printer.rb

@@ -26,6 +26,7 @@ module Kumi
         when Kumi::Syntax::DeclarationReference then visit_declaration_reference(node)
         when Kumi::Syntax::Literal then visit_literal(node)
         when Kumi::Syntax::HashExpression then visit_hash_expression(node)
+        when Kumi::Syntax::ImportCall then visit_import_call(node)
         else visit_generic(node)
         end
       end
@@ -127,6 +128,14 @@ module Kumi
         "(HashExpression\n#{indent_str(2)}#{pairs}\n#{indent_str})"
       end
 
+      def visit_import_call(node)
+        pairs = node.input_mapping.map do |key, value|
+          "(#{key} #{child_printer.visit(value)})"
+        end.join("\n#{indent_str(2)}")
+
+        "(ImportCall :#{node.fn_name}\n#{indent_str(2)}#{pairs}\n#{indent_str})"
+      end
+
       def visit_generic(node)
         class_name = node.class.name&.split("::")&.last || node.class.to_s
 

data/lib/kumi/support/snast_printer.rb

@@ -95,6 +95,12 @@ module Kumi
         when NAST::Pair
           value = format_concise(node.value, indent_level + 1)
           "#{indent}(Pair #{node.key}\n#{value}\n#{indent}) #{stamp_str}"
+        when NAST::ImportCall
+          header = "(ImportCall :#{node.fn_name}"
+          args = node.input_mapping_keys.zip(node.args).map do |key, arg|
+            format_concise(arg, indent_level + 1).sub(/^\s+/, "#{indent}  (#{key} ").tap { |s| s << ")" }
+          end.join("\n")
+          "#{indent}#{header}\n#{args}\n#{indent}) #{stamp_str}"
         else
           "#{indent}(UnknownNode: #{node.class})"
         end

data/lib/kumi/syntax/import_call.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Syntax
+    ImportCall = Struct.new(:fn_name, :input_mapping, :loc) do
+      include Node
+
+      def children = input_mapping.values
+    end
+  end
+end

data/lib/kumi/syntax/import_declaration.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Syntax
+    ImportDeclaration = Struct.new(:names, :module_ref, :loc) do
+      include Node
+
+      def children = []
+    end
+  end
+end

data/lib/kumi/syntax/root.rb

@@ -4,10 +4,10 @@ module Kumi
   module Syntax
     # Represents the root of the Abstract Syntax Tree.
     # It holds all the top-level declarations parsed from the source.
-    Root = Struct.new(:inputs, :values, :traits) do
+    Root = Struct.new(:inputs, :values, :traits, :imports) do
       include Node
 
-      def children = [inputs, values, traits]
+      def children = [inputs, values, traits, imports]
 
       def digest
         # The digest must be stable and depend on anything that could change the

data/lib/kumi/test_shared_schemas/compound.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Kumi
+  module TestSharedSchemas
+    module Compound
+      extend Kumi::Schema
+
+      schema do
+        input do
+          decimal :principal
+          decimal :rate
+          integer :years
+        end
+
+        value :annual_interest, input.principal * input.rate
+        value :total_interest, annual_interest * input.years
+        value :final_amount, input.principal + total_interest
+      end
+    end
+  end
+end

data/lib/kumi/test_shared_schemas/discount.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Kumi
+  module TestSharedSchemas
+    module Discount
+      extend Kumi::Schema
+
+      schema do
+        input do
+          decimal :price
+          decimal :rate
+        end
+
+        value :discounted, input.price * (1.0 - input.rate)
+        value :savings, input.price * input.rate
+      end
+    end
+  end
+end

data/lib/kumi/test_shared_schemas/price.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Kumi
+  module TestSharedSchemas
+    module Price
+      extend Kumi::Schema
+
+      schema do
+        input do
+          decimal :base_price
+          decimal :discount_rate
+        end
+
+        value :discounted, input.base_price * (1.0 - input.discount_rate)
+        value :discount_amount, input.base_price * input.discount_rate
+      end
+    end
+  end
+end

data/lib/kumi/test_shared_schemas/subtotal.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Kumi
+  module TestSharedSchemas
+    module Subtotal
+      extend Kumi::Schema
+
+      schema do
+        input do
+          array :items do
+            hash :item do
+              integer :quantity
+              integer :unit_price
+            end
+          end
+        end
+
+        value :subtotal, fn(:sum, input.items.item.quantity * input.items.item.unit_price)
+      end
+    end
+  end
+end

data/lib/kumi/test_shared_schemas/tax.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Kumi
+  module TestSharedSchemas
+    module Tax
+      extend Kumi::Schema
+
+      schema do
+        input do
+          decimal :amount
+        end
+
+        value :tax, input.amount * 0.15
+        value :total, input.amount + tax
+      end
+    end
+  end
+end

data/lib/kumi/version.rb

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

data/lib/kumi.rb

@@ -4,9 +4,9 @@ require "zeitwerk"
 require "mutex_m"
 # require "pry" # COMMENT AFTER DEBUGGING
 
-loader = Zeitwerk::Loader.for_gem
-loader.ignore("#{__dir__}/kumi-cli")
-loader.inflector.inflect(
+AUTOLOADER = Zeitwerk::Loader.for_gem
+AUTOLOADER.ignore("#{__dir__}/kumi-cli")
+AUTOLOADER.inflector.inflect(
   "assemble_irv2_pass" => "AssembleIRV2Pass",
   "ast_emitter" => "ASTEmitter",
   "attach_terminal_info_pass" => "AttachTerminalInfoPass",
@@ -36,7 +36,7 @@ loader.inflector.inflect(
   "ruby_ast" => "RubyAST",
   "vm" => "VM"
 )
-loader.setup
+AUTOLOADER.setup
 
 module Kumi
   # Provides access to the singleton configuration object.
@@ -60,4 +60,19 @@ module Kumi
   # A namespace for dynamically created compiled modules.
   module Compiled
   end
+
+  # Load shared schemas only when explicitly requested (for golden tests)
+  def self.load_shared_schemas!
+    # Ensure JIT compilation mode for schemas being loaded
+    Kumi.configure { |c| c.compilation_mode = :jit }
+
+    AUTOLOADER.eager_load_dir("#{__dir__}/kumi/test_shared_schemas")
+    # Populate GoldenSchemas module (already defined in golden_schema_modules.rb)
+    Kumi::TestSharedSchemas.constants.each do |const|
+      GoldenSchemas.const_set(const, Kumi::TestSharedSchemas.const_get(const)) unless GoldenSchemas.const_defined?(const)
+    end
+  end
 end
+
+# Load golden schema module base
+require_relative "kumi/dev/golden_schema_modules"