kumi 0.0.18 → 0.0.20

data/data/functions/core/arithmetic.yaml

@@ -0,0 +1,50 @@
+functions:
+  - id: core.abs
+    kind: elementwise
+    params: [{ name: number }]
+    dtype: "same_as(number)"
+    aliases: ["abs"]
+
+  - id: core.add
+    kind: elementwise  
+    params: [{ name: left_operand }, { name: right_operand }]
+    dtype: "promote(left_operand,right_operand)"
+    aliases: ["add"]
+
+  - id: core.sub
+    kind: elementwise
+    params: [{ name: left_operand }, { name: right_operand }] 
+    dtype: "promote(left_operand,right_operand)"
+    aliases: ["sub", "subtract"]
+
+  - id: core.mul
+    kind: elementwise
+    params: [{ name: left_operand }, { name: right_operand }]
+    dtype: "promote(left_operand,right_operand)"
+    aliases: ["mul", "multiply"]
+
+  - id: core.pow
+    kind: elementwise
+    params: [{ name: base }, { name: exponent }]
+    dtype: "promote(base,exponent)"
+    aliases: ["pow", "power"]
+
+  - id: core.div
+    kind: elementwise  
+    params: [{ name: left_operand }, { name: right_operand }]
+    dtype: "float"
+    aliases: ["div", "divide"]
+
+  - id: core.mod
+    kind: elementwise
+    params:
+      - { name: left_operand}
+      - { name: right_operand}
+    dtype: "promote(left_operand,right_operand)"
+    aliases: ["mod", "modulo", "%"]
+
+  - id: core.clamp
+    kind: elementwise
+    params: [{name: x},{name: lo},{name: hi}]
+    dtype: "same_as(x)"
+    aliases: ["clamp"]

data/data/functions/core/boolean.yaml

@@ -0,0 +1,18 @@
+functions:
+  - id: core.and
+    kind: elementwise
+    params: [{ name: left_operand }, { name: right_operand }]
+    dtype: "boolean"
+    aliases : ["and", "&"]
+
+  - id: core.or
+    kind: elementwise
+    params: [{ name: left_operand }, { name: right_operand }]
+    dtype: "boolean"
+    aliases : ["or", "|"]
+
+  - id: core.not
+    kind: elementwise
+    params: [{ name: operand }]
+    dtype: "boolean"
+    aliases : ["not", "!"]

data/data/functions/core/comparison.yaml

@@ -0,0 +1,42 @@
+functions:
+  - id: core.gte
+    kind: elementwise
+    params: [{ name: left_operand }, { name: right_operand }]
+    dtype: "boolean"
+    aliases : ["gte", "ge", "greater_than_or_equal", ">="]
+    folding_class_method: gte
+
+  - id: core.gt
+    kind: elementwise
+    params: [{ name: left_operand }, { name: right_operand }]
+    dtype: "boolean"
+    aliases : ["gt", "greater_than", ">"]
+    folding_class_method: gt
+
+  - id: core.lte
+    kind: elementwise
+    params: [{ name: left_operand }, { name: right_operand }]
+    dtype: "boolean"
+    aliases : ["lte", "le", "less_than_or_equal", "<="]
+    folding_class_method: lte
+
+  - id: core.lt
+    kind: elementwise
+    params: [{ name: left_operand }, { name: right_operand }]
+    dtype: "boolean"
+    aliases : ["lt", "less_than", "<"]
+    folding_class_method: lt
+
+  - id: core.eq
+    kind: elementwise  
+    params: [{ name: left_operand }, { name: right_operand }]
+    dtype: "boolean"
+    aliases : ["eq", "equal", "=="]
+    folding_class_method: eq
+
+  - id: core.neq
+    kind: elementwise
+    params: [{ name: left_operand }, { name: right_operand }]
+    dtype: "boolean"
+    aliases : ["neq", "not_equal", "!="]
+    folding_class_method: neq

data/data/functions/core/constructor.yaml

@@ -0,0 +1,32 @@
+functions:
+# length is probably in the wrong place 
+  - id: core.length
+    kind: elementwise
+    params: [{ name: collection, dtype: string }]
+    dtype: "integer"
+    aliases: ["length", "len", "size"]
+    folding_class_method: length
+
+  - id: core.array_size
+    kind: elementwise
+    params: [{ name: collection, dtype: array }]
+    dtype: "integer"
+    aliases: ["array_size","size"]
+    folding_class_method: length
+
+  - id: core.at
+    kind: elementwise
+    params: 
+      - { name: collection }
+      - { name: index, dtype: integer }
+    dtype: "element_of(collection)"
+    aliases: ["at", "get", "[]"]
+    folding_class_method: at
+
+  - id: core.hash_fetch
+    kind: elementwise
+    params: 
+      - { name: key, dtype: hash }
+    dtype: "value_of(key)" # TODO, we can calculate,
+    aliases: ["fetch"]
+    folding_class_method: "[]"

data/data/functions/core/select.yaml

@@ -0,0 +1,7 @@
+functions:
+  - id: __select__
+    kind: elementwise
+    params: [{ name: condition_mask }, { name: value_when_true }, { name: value_when_false }]
+    dtype: "same_as(value_when_true)"
+    aliases: ["select", "if"]
+    folding_class_method: select

data/data/functions/core/stencil.yaml

@@ -0,0 +1,21 @@
+functions:
+  - id: roll
+    kind: elementwise
+    params: [{ name: source }, { name: offset }] 
+    dtype: "same_as(source)"
+    options:
+      policy: wrap          # wrap|clamp
+      axis_offset: 0
+
+  - id: shift
+    kind: elementwise
+    params: [{ name: source }, { name: offset }]
+    dtype: "same_as(source)"
+    options:
+      policy: zero          # zero|clamp
+      axis_offset: 0
+
+  - id: index
+    kind: elementwise
+    params: [{name: index_name, dtype: string }]
+    dtype: integer

data/data/functions/core/string.yaml

@@ -0,0 +1,19 @@
+functions:
+  - id: core.concat
+    kind: elementwise
+    params: [{ name: left_string }, { name: right_string }]
+    dtype: "string"
+    aliases: ["concat"]
+
+  - id: core.upcase
+    kind: elementwise
+    params: [{ name: string }]
+    dtype: "string"
+    aliases: ["upcase"]
+
+  - id: core.downcase
+    kind: elementwise
+    params: [{ name: string }]
+    dtype: "string"
+    aliases: ["downcase"]
+    

data/data/kernels/javascript/agg/boolean.yaml

@@ -0,0 +1,12 @@
+kernels:
+  - id: any:javascript:v1
+    fn: agg.any
+    inline: "= $0 || $1"
+    identity:
+      boolean: false
+
+  - id: all:javascript:v1
+    fn: agg.all
+    inline: "= $0 && $1"
+    identity:
+      boolean: true

data/data/kernels/javascript/agg/numeric.yaml

@@ -0,0 +1,27 @@
+kernels:
+  - id: agg.sum:javascript:v1
+    fn: agg.sum
+    inline: "+= $1"
+    fold_inline: "= $0.reduce((a, b) => a + b, 0)"
+    identity:
+      float: 0.0
+      integer: 0
+
+  - id: agg.count:javascript:v1
+    fn: agg.count
+    inline: "+= 1"
+    fold_inline: "= $0.length"
+    identity:
+      any: 0
+
+  - id: agg.min:javascript:v1
+    fn: agg.min
+    # Handles first element being null/undefined
+    inline: "= ($0 === null || $1 < $0) ? $1 : $0"
+    fold_inline: "= Math.min(...$0)"
+
+  - id: agg.max:javascript:v1
+    fn: agg.max
+    # Handles first element being null/undefined
+    inline: "= ($0 === null || $1 > $0) ? $1 : $0"
+    fold_inline: "= Math.max(...$0)"

data/data/kernels/javascript/agg/string.yaml

@@ -0,0 +1,5 @@
+kernels:
+  - id: agg.join:javascript:v1
+    fn: agg.join
+    inline: "+= $1"
+    fold_inline: "= $0.join('')"

data/data/kernels/javascript/core/arithmetic.yaml

@@ -0,0 +1,32 @@
+kernels:
+  - id: abs:javascript:v1
+    fn: core.abs
+    inline: "= Math.abs($0)"
+
+  - id: mod:javascript:v1
+    fn: core.mod
+    inline: "= (($0 % $1) + $1) % $1"
+
+  - id: add:javascript:v1
+    fn: core.add
+    inline: "= $0 + $1"
+
+  - id: sub:javascript:v1
+    fn: core.sub
+    inline: "= $0 - $1"
+
+  - id: mul:javascript:v1
+    fn: core.mul
+    inline: "= $0 * $1"
+
+  - id: pow:javascript:v1
+    fn: core.pow
+    inline: "= Math.pow($0, $1)"
+
+  - id: div:javascript:v1
+    fn: core.div
+    inline: "= $0 / $1"
+
+  - id: clamp:javascript:v1
+    fn: core.clamp
+    inline: "= Math.min(Math.max($0, $1), $2)"

data/data/kernels/javascript/core/boolean.yaml

@@ -0,0 +1,12 @@
+kernels:
+  - id: not:javascript:v1
+    fn: core.not
+    inline: "= !$0"
+
+  - id: and:javascript:v1
+    fn: core.and
+    inline: "= $0 && $1"
+
+  - id: or:javascript:v1
+    fn: core.or
+    inline: "= $0 || $1"

data/data/kernels/javascript/core/comparison.yaml

@@ -0,0 +1,24 @@
+kernels:
+  - id: eq:javascript:v1
+    fn: core.eq
+    inline: "= $0 == $1"
+
+  - id: gt:javascript:v1
+    fn: core.gt
+    inline: "= $0 > $1"
+
+  - id: lt:javascript:v1
+    fn: core.lt
+    inline: "= $0 < $1"
+
+  - id: lte:javascript:v1
+    fn: core.lte
+    inline: "= $0 <= $1"
+
+  - id: gte:javascript:v1
+    fn: core.gte
+    inline: "= $0 >= $1"
+
+  - id: neq:javascript:v1
+    fn: core.neq
+    inline: "= $0 != $1"

data/data/kernels/javascript/core/constructor.yaml

@@ -0,0 +1,15 @@
+kernels:
+  - id: length:javascript:v1
+    fn: core.length
+    inline: "= $0.length"
+    fold_inline: "= $0.length"
+
+  - id: array_size:javascript:v1
+    fn: core.array_size
+    inline: "= $0.length"
+    fold_inline: "= $0.length"
+
+  - id: at:javascript:v1
+    fn: core.at
+    inline: "= $0[$1]"        # assumes non-negative integer index
+

data/data/kernels/javascript/core/select.yaml

@@ -0,0 +1,7 @@
+kernels:
+  - id: select:javascript:v1
+    fn: __select__
+    # The ternary operator is identical in Ruby and JS, so an inline template
+    # isn't strictly necessary as the LIR `select` op can generate it directly.
+    # But for completeness, an `impl` would be:
+    impl: "(condition, true_val, false_val) => condition ? true_val : false_val"

data/data/kernels/javascript/core/string.yaml

@@ -0,0 +1,12 @@
+kernels:
+  - id: concat:javascript:v1
+    fn: core.concat
+    inline: "= String($0) + String($1)"
+
+  - id: upcase:javascript:v1
+    fn: core.upcase
+    inline: "= $0.toUpperCase()"
+
+  - id: downcase:javascript:v1
+    fn: core.downcase
+    inline: "= $0.toLowerCase()"

data/data/kernels/ruby/agg/boolean.yaml

@@ -0,0 +1,18 @@
+kernels:
+  - id: any:ruby:v1
+    fn: agg.any
+    impl: "(a, b)\n  a || b"
+    inline: "= $0 || $1"
+    # The identity for a boolean OR reduction is `false`.
+    # `any?` of an empty list is correctly `false`.
+    identity:
+      boolean: false
+
+  - id: all:ruby:v1
+    fn: agg.all
+    impl: "(a, b)\n  a && b"
+    inline: "= $0 && $1"
+    # The identity for a boolean AND reduction is `true`.
+    # `all?` of an empty list is correctly `true`.
+    identity:
+      boolean: true

data/data/kernels/ruby/agg/numeric.yaml

@@ -0,0 +1,29 @@
+kernels:
+  - id: agg.sum:ruby:v1
+    fn: agg.sum
+    inline: "+= $1"
+    impl: "(a,b)\n  a + b"
+    fold_inline: "= $0.sum"
+    identity: 
+      float: 0.0
+      integer: 0
+      
+  - id: agg.count:ruby:v1
+    fn: agg.count
+    inline: "+= 1"
+    impl: "(a,_b)\n  a + 1"
+    fold_inline: "= $0.count"
+    identity:
+      any: 0
+
+  - id: agg.min:ruby:v1
+    fn: agg.min
+    inline: "= $1 if $1 < $0" 
+    impl: "(a, b)\n  a < b ? a : b"
+    fold_inline: "= $0.min"
+
+  - id: agg.max:ruby:v1
+    fn: agg.max
+    inline: "= $1 if $1 > $0" 
+    impl: "(a, b)\n  a > b ? a : b"
+    fold_inline: "= $0.max"

data/data/kernels/ruby/agg/string.yaml

@@ -0,0 +1,5 @@
+kernels:
+  - id: agg.join:ruby:v1
+    fn: agg.join
+    inline: "+= $1"
+    fold_inline: "= $0.join"

data/data/kernels/ruby/core/arithmetic.yaml

@@ -0,0 +1,38 @@
+kernels:
+  - id: abs:ruby:v1
+    fn: core.abs
+    inline: "= $0.abs"
+  
+  - id: mod.ruby:v1
+    fn: core.mod
+    inline: "= $0 % $1"
+  
+  - id: add:ruby:v1
+    fn: core.add
+    inline: "= $0 + $1"
+    impl: "(a, b)\n  a + b"
+
+  - id: sub:ruby:v1
+    fn: core.sub
+    inline: "= $0 - $1"
+    impl: "(a, b)\n  a - b"
+
+  - id: mul:ruby:v1
+    fn: core.mul
+    inline: "= $0 * $1"
+    impl: "(a, b)\n  a * b"
+
+  - id: pow:ruby:v1
+    fn: core.pow
+    inline: "= $0 ** $1"
+    impl: "(a, b)\n  a ** b"
+
+  - id: div:ruby:v1
+    fn: core.div
+    inline: "= $0 / $1.to_f"
+    impl: "(a, b)\n  a / b.to_f"
+  
+  - id: clamp:ruby:v1
+    fn: core.clamp
+    inline: "= [[ $0, $1 ].max, $2 ].min"
+    impl: "(x, lo, hi)\n  [[x, lo].max, hi].min"

data/data/kernels/ruby/core/boolean.yaml

@@ -0,0 +1,15 @@
+kernels:
+  - id: not:ruby:v1
+    fn: core.not
+    inline: "= !$0"
+    impl: "(a)\n  !a"
+
+  - id: and:ruby:v1
+    fn: core.and
+    inline: "= $0 && $1"
+    impl: "(a, b)\n  a && b"
+
+  - id: or:ruby:v1
+    fn: core.or
+    inline: "= $0 || $1"
+    impl: "(a, b)\n  a || b"

data/data/kernels/ruby/core/comparison.yaml

@@ -0,0 +1,30 @@
+kernels:
+  - id: eq:ruby:v1
+    fn: core.eq
+    inline: "= $0 == $1"
+    impl: "(a, b)\n  a == b"
+  
+  - id: gt:ruby:v1
+    fn: core.gt
+    inline: "= $0 > $1"
+    impl: "(a, b)\n  a > b"
+
+  - id: lt:ruby:v1
+    fn: core.lt
+    inline: "= $0 < $1"
+    impl: "(a, b)\n  a < b"
+
+  - id: lte:ruby:v1
+    fn: core.lte
+    inline: "= $0 <= $1"
+    impl: "(a, b)\n  a <= b"
+  
+  - id: gte:ruby:v1
+    fn: core.gte
+    inline: "= $0 >= $1"
+    impl: "(a, b)\n  a >= b"
+
+  - id: neq:ruby:v1
+    fn: core.neq
+    inline: "= $0 != $1"
+    impl: "(a, b)\n  a != b"

data/data/kernels/ruby/core/constructor.yaml

@@ -0,0 +1,17 @@
+kernels:
+  - id: length:ruby:v1
+    fn: core.length
+    impl: "(collection)\n  collection.size"
+    inline: "= $0.length"
+    fold_inline: "= $0.length"
+
+  - id: size:ruby:v1
+    fn: core.array_size
+    impl: "(collection)\n  collection.size"
+    inline: "= $0.length"
+    fold_inline: "= $0.length"
+
+  - id: at:ruby:v1
+    fn: core.at
+    inline: "= $0[$1]"        # assumes non-negative integer index
+

data/data/kernels/ruby/core/select.yaml

@@ -0,0 +1,4 @@
+kernels:
+  - id: select:ruby:v1
+    fn: core.select
+    impl: "(condition, true_val, false_val)\n  condition ? true_val : false_val"

data/data/kernels/ruby/core/string.yaml

@@ -0,0 +1,15 @@
+kernels:
+  - id: concat:ruby:v1
+    fn: core.concat
+    inline: "= $0.to_s + $1.to_s"
+    impl: |
+      (a, b)
+      a.to_s + b.to_s
+  
+  - id: upcase:ruby:v1
+    fn: core.upcase
+    inline: "= $0.upcase"
+  
+  - id: downcase:ruby:v1
+    fn: core.downcase
+    inline: "= $0.downcase"

data/debug_ordering.rb

@@ -0,0 +1,52 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require_relative 'spec/spec_helper'
+
+include PackTestHelper
+
+schema = <<~KUMI
+  schema do
+    input do
+      array :numbers do
+        integer :value
+      end
+    end
+    
+    value :total, fn(:sum, input.numbers.value)
+  end
+KUMI
+
+pack = pack_for(schema)
+generator = Kumi::Codegen::RubyV3::Generator.new(pack, module_name: "OrderingTest")
+
+generated_code = generator.render
+puts "=== GENERATED CODE ==="
+puts generated_code
+puts "======================"
+
+# Analyze the structure
+lines = generated_code.split("\n")
+while_line_idx = lines.find_index { |line| line.include?("while i0 < arr0.length") }
+end_line_idx = lines.find_index(while_line_idx) { |line| line.strip == "end" }
+
+puts "\n=== ANALYSIS ==="
+puts "While line at index: #{while_line_idx}"
+puts "End line at index: #{end_line_idx}"
+
+if while_line_idx && end_line_idx
+  loop_body_lines = lines[(while_line_idx + 1)...end_line_idx]
+  puts "Loop body lines:"
+  loop_body_lines.each_with_index do |line, i|
+    puts "  #{while_line_idx + 1 + i}: #{line}"
+  end
+  
+  value_access_line = loop_body_lines.find { |line| line.include?('a0["value"]') }
+  acc_add_line = loop_body_lines.find { |line| line.include?("acc_") && line.include?("+=") }
+  
+  puts "\nValue access line: #{value_access_line.inspect}"
+  puts "Acc add line: #{acc_add_line.inspect}"
+else
+  puts "Could not find while loop structure"
+end

data/docs/FORM_SCHEMA.md

@@ -0,0 +1,85 @@
+# Input Form Schema
+
+## Overview
+
+The analyzer generates a minimal JSON schema from input declarations for dynamic form building.
+
+## Access
+
+```ruby
+result = Kumi::Analyzer.analyze!(schema)
+form_schema = result.state[:input_form_schema]
+```
+
+```bash
+bin/kumi analyze schema.kumi --dump input_form_schema
+```
+
+## Schema Structure
+
+### Scalar Fields
+```json
+{
+  "field_name": {
+    "type": "string|integer|float|boolean"
+  }
+}
+```
+
+### Array Fields
+```json
+{
+  "field_name": {
+    "type": "array",
+    "element": { /* recursive field structure */ }
+  }
+}
+```
+
+### Object Fields
+```json
+{
+  "field_name": {
+    "type": "object",
+    "fields": {
+      "nested_field": { /* recursive field structure */ }
+    }
+  }
+}
+```
+
+## Example
+
+**Schema:**
+```kumi
+input items: array {
+  item: hash {
+    name: string
+    price: float
+  }
+}
+input discount: float
+```
+
+**Generated Form Schema:**
+```json
+{
+  "items": {
+    "type": "array",
+    "element": {
+      "type": "object",
+      "fields": {
+        "name": { "type": "string" },
+        "price": { "type": "float" }
+      }
+    }
+  },
+  "discount": {
+    "type": "float"
+  }
+}
+```
+
+## Implementation
+
+The `InputFormSchemaPass` runs after `InputCollector` in the analyzer pipeline and produces a clean schema containing only type information needed for form generation, excluding internal metadata like access modes and navigation steps.