kumi 0.0.9 → 0.0.11

data/lib/kumi/syntax/hash_expression.rb

@@ -2,10 +2,10 @@
 
 module Kumi
   module Syntax
-      HashExpression = Struct.new(:pairs) do
-        include Node
+    HashExpression = Struct.new(:pairs) do
+      include Node
 
-        def children = pairs.flatten
-      end
+      def children = pairs.flatten
+    end
   end
 end

data/lib/kumi/syntax/input_declaration.rb

@@ -2,11 +2,12 @@
 
 module Kumi
   module Syntax
-      # For field metadata declarations inside input blocks
-      InputDeclaration = Struct.new(:name, :domain, :type, :children) do
-        include Node
+    # For field metadata declarations inside input blocks
+    InputDeclaration = Struct.new(:name, :domain, :type, :children, :access_mode) do
+      include Node
 
-        def children = self[:children] || []
-      end
+      def children = self[:children] || []
+      def access_mode = self[:access_mode]
+    end
   end
 end

data/lib/kumi/syntax/input_element_reference.rb

@@ -2,11 +2,11 @@
 
 module Kumi
   module Syntax
-      # For field usage/reference in expressions (input.field_name)
-      InputElementReference = Struct.new(:path) do
-        include Node
+    # For field usage/reference in expressions (input.field_name)
+    InputElementReference = Struct.new(:path) do
+      include Node
 
-        def children = []
-      end
+      def children = []
+    end
   end
 end

data/lib/kumi/syntax/input_reference.rb

@@ -2,11 +2,11 @@
 
 module Kumi
   module Syntax
-      # For field usage/reference in expressions (input.field_name)
-      InputReference = Struct.new(:name) do
-        include Node
+    # For field usage/reference in expressions (input.field_name)
+    InputReference = Struct.new(:name) do
+      include Node
 
-        def children = []
-      end
+      def children = []
+    end
   end
 end

data/lib/kumi/syntax/literal.rb

@@ -2,10 +2,10 @@
 
 module Kumi
   module Syntax
-      Literal = Struct.new(:value) do
-        include Node
+    Literal = Struct.new(:value) do
+      include Node
 
-        def children = []
-      end
+      def children = []
+    end
   end
 end

data/lib/kumi/syntax/location.rb

@@ -0,0 +1,5 @@
+module Kumi
+  module Syntax
+    Location = Struct.new(:file, :line, :column, keyword_init: true)
+  end
+end

data/lib/kumi/syntax/node.rb

@@ -2,45 +2,44 @@
 
 module Kumi
   module Syntax
-      # A struct to hold standardized source location information.
-      Location = Struct.new(:file, :line, :column, keyword_init: true)
+    # A struct to hold standardized source location information.
 
-      # Base module included by all AST nodes to provide a standard
-      # interface for accessing source location information..
-      module Node
-        attr_accessor :loc
+    # Base module included by all AST nodes to provide a standard
+    # interface for accessing source location information..
+    module Node
+      attr_accessor :loc
 
-        def initialize(*args, loc: nil, **kwargs)
-          @loc = loc
-          super(*args, **kwargs)
-          freeze
-        end
+      def initialize(*args, loc: nil, **kwargs)
+        @loc = loc
+        super(*args, **kwargs)
+        freeze
+      end
 
-        def ==(other)
-          other.is_a?(self.class) &&
-            # for Struct-based nodes
-            (if respond_to?(:members)
-               members.all? { |m| self[m] == other[m] }
-             else
-               instance_variables.reject { |iv| iv == :@loc }
-                                          .all? do |iv|
-                 instance_variable_get(iv) ==
-                                              other.instance_variable_get(iv)
-               end
+      def ==(other)
+        other.is_a?(self.class) &&
+          # for Struct-based nodes
+          (if respond_to?(:members)
+             members.all? { |m| self[m] == other[m] }
+           else
+             instance_variables.reject { |iv| iv == :@loc }
+                                        .all? do |iv|
+               instance_variable_get(iv) ==
+                                            other.instance_variable_get(iv)
              end
-            )
-        end
-        alias eql? ==
+           end
+          )
+      end
+      alias eql? ==
 
-        def hash
-          values = if respond_to?(:members)
-                     members.map { |m| self[m] }
-                   else
-                     instance_variables.reject { |iv| iv == :@loc }
-                                       .map { |iv| instance_variable_get(iv) }
-                   end
-          [self.class, *values].hash
-        end
+      def hash
+        values = if respond_to?(:members)
+                   members.map { |m| self[m] }
+                 else
+                   instance_variables.reject { |iv| iv == :@loc }
+                                     .map { |iv| instance_variable_get(iv) }
+                 end
+        [self.class, *values].hash
       end
+    end
   end
 end

data/lib/kumi/syntax/root.rb

@@ -2,12 +2,12 @@
 
 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, :attributes, :traits) do
-        include Node
+    # 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
+      include Node
 
-        def children = [inputs, attributes, traits]
-      end
+      def children = [inputs, values, traits]
+    end
   end
 end

data/lib/kumi/syntax/trait_declaration.rb

@@ -2,10 +2,10 @@
 
 module Kumi
   module Syntax
-      TraitDeclaration = Struct.new(:name, :expression) do
-        include Node
+    TraitDeclaration = Struct.new(:name, :expression) do
+      include Node
 
-        def children = [expression]
-      end
+      def children = [expression]
+    end
   end
 end

data/lib/kumi/syntax/value_declaration.rb

@@ -2,10 +2,10 @@
 
 module Kumi
   module Syntax
-      ValueDeclaration = Struct.new(:name, :expression) do
-        include Node
+    ValueDeclaration = Struct.new(:name, :expression) do
+      include Node
 
-        def children = [expression]
-      end
+      def children = [expression]
+    end
   end
 end

data/lib/kumi/version.rb

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

data/lib/kumi.rb

@@ -5,22 +5,13 @@ require "zeitwerk"
 
 loader = Zeitwerk::Loader.for_gem
 loader.ignore("#{__dir__}/kumi-cli")
+loader.inflector.inflect(
+  "lower_to_ir_pass" => "LowerToIRPass",
+  "vm" => "VM",
+  "ir" => "IR",
+  'ir_dump' => 'IRDump',
+)
 loader.setup
 
 module Kumi
-  extend Schema
-
-  def self.inspector_from_schema
-    Inspector.new(@__syntax_tree__, @__analyzer_result__, @__compiled_schema__)
-  end
-
-  def self.reset!
-    @__syntax_tree__ = nil
-    @__analyzer_result__ = nil
-    @__compiled_schema__ = nil
-    @__schema_metadata__ = nil
-  end
-
-  # Reset on require to avoid state leakage in tests
-  reset!
 end

data/scripts/analyze_broadcast_methods.rb

@@ -0,0 +1,68 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "json"
+
+coverage_file = "coverage/.resultset.json"
+
+unless File.exist?(coverage_file)
+  puts "❌ No coverage data found. Run tests first:"
+  puts "   COVERAGE=true bundle exec rspec"
+  exit 1
+end
+
+data = JSON.parse(File.read(coverage_file))
+coverage = data.values.first["coverage"]
+
+broadcast_file = coverage.find { |file, _| file.include?("broadcast_detector.rb") }
+
+if broadcast_file
+  file_path, line_data = broadcast_file
+  lines = line_data["lines"]
+  
+  puts "🔍 BroadcastDetector Coverage Analysis:"
+  puts "File: #{File.basename(file_path)}"
+  
+  total_lines = lines.count { |hits| !hits.nil? }
+  covered_lines = lines.count { |hits| hits && hits > 0 }
+  coverage_percent = (covered_lines.to_f / total_lines * 100).round(1)
+  
+  puts "Coverage: #{coverage_percent}% (#{covered_lines}/#{total_lines} lines)"
+  
+  # Find uncovered method definitions
+  file_content = File.read(file_path)
+  uncovered_methods = []
+  covered_methods = []
+  
+  file_content.lines.each_with_index do |line, i|
+    if line.match?(/^\s*def\s+(\w+)/)
+      method_name = line.match(/^\s*def\s+(\w+)/)[1]
+      line_hits = lines[i]
+      
+      if line_hits.nil?
+        # Line not tracked
+      elsif line_hits == 0
+        uncovered_methods << "#{method_name} (line #{i+1})"
+      else
+        covered_methods << "#{method_name} (line #{i+1})"
+      end
+    end
+  end
+  
+  puts "\n📊 Method Coverage Summary:"
+  puts "  Total methods: #{covered_methods.length + uncovered_methods.length}"
+  puts "  Covered methods: #{covered_methods.length}"
+  puts "  Uncovered methods: #{uncovered_methods.length}"
+  
+  if uncovered_methods.any?
+    puts "\n🚨 Uncovered methods (potential dead code):"
+    uncovered_methods.each { |m| puts "    - #{m}" }
+  end
+  
+  if covered_methods.any?
+    puts "\n✅ Covered methods:"
+    covered_methods.each { |m| puts "    - #{m}" }
+  end
+else
+  puts "❌ BroadcastDetector file not found in coverage data"
+end

data/scripts/analyze_cascade_methods.rb

@@ -0,0 +1,74 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "json"
+
+coverage_file = "coverage/.resultset.json"
+target_file = "cascade_executor_builder.rb"
+
+unless File.exist?(coverage_file)
+  puts "❌ No coverage data found. Run tests first"
+  exit 1
+end
+
+data = JSON.parse(File.read(coverage_file))
+coverage = data.values.first["coverage"]
+
+file_entry = coverage.find { |file, _| file.include?(target_file) }
+
+if file_entry
+  file_path, line_data = file_entry
+  lines = line_data["lines"]
+  
+  puts "🔍 CascadeExecutorBuilder Method Coverage:"
+  puts "=" * 50
+  
+  file_content = File.read(file_path)
+  methods = []
+  
+  file_content.lines.each_with_index do |line, i|
+    if line.match?(/^\s*def\s+/)
+      method_match = line.match(/^\s*def\s+(self\.)?(\w+)/)
+      if method_match
+        method_name = method_match[2]
+        is_class_method = !method_match[1].nil?
+        line_hits = lines[i]
+        
+        status = if line_hits.nil?
+                   "⚪ NOT TRACKED"
+                 elsif line_hits == 0
+                   "🚨 UNCOVERED"
+                 else
+                   "✅ COVERED (#{line_hits} hits)"
+                 end
+        
+        prefix = is_class_method ? "self." : ""
+        methods << {
+          name: "#{prefix}#{method_name}",
+          line: i + 1,
+          hits: line_hits,
+          status: status
+        }
+      end
+    end
+  end
+  
+  methods.each do |method|
+    printf "  %-25s (line %3d) %s\n", method[:name], method[:line], method[:status]
+  end
+  
+  uncovered = methods.select { |m| m[:hits] == 0 }
+  covered = methods.select { |m| m[:hits] && m[:hits] > 0 }
+  
+  puts "\n📊 Summary:"
+  puts "  Total methods: #{methods.length}"
+  puts "  Covered: #{covered.length}"
+  puts "  Uncovered: #{uncovered.length}"
+  
+  if uncovered.any?
+    puts "\n🚨 Uncovered methods (potential dead code):"
+    uncovered.each { |m| puts "    #{m[:name]} (line #{m[:line]})" }
+  end
+else
+  puts "❌ #{target_file} not found in coverage data"
+end

data/scripts/check_broadcasting_coverage.rb

@@ -0,0 +1,51 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "json"
+
+coverage_file = "coverage/.resultset.json"
+
+unless File.exist?(coverage_file)
+  puts "❌ No coverage data found. Run tests first"
+  exit 1
+end
+
+data = JSON.parse(File.read(coverage_file))
+coverage = data.values.first["coverage"]
+
+broadcasting_files = [
+  "cascade_executor_builder.rb",
+  "vectorized_function_builder.rb", 
+  "nested_structure_utils.rb",
+  "broadcast_detector.rb"
+]
+
+puts "🔍 Broadcasting Files Coverage:"
+puts "=" * 60
+
+broadcasting_files.each do |filename|
+  file_entry = coverage.find { |file, _| file.include?(filename) }
+  
+  if file_entry
+    file_path, line_data = file_entry
+    lines = line_data["lines"]
+    
+    total_lines = lines.count { |hits| !hits.nil? }
+    covered_lines = lines.count { |hits| hits && hits > 0 }
+    coverage_percent = total_lines > 0 ? (covered_lines.to_f / total_lines * 100).round(1) : 0
+    
+    status = if coverage_percent == 0
+               "🚨 DEAD"
+             elsif coverage_percent < 20
+               "🔴 LOW"  
+             elsif coverage_percent < 50
+               "🟡 MEDIUM"
+             else
+               "✅ GOOD"
+             end
+    
+    printf "%-35s %s %6.1f%% (%d/%d lines)\n", filename, status, coverage_percent, covered_lines, total_lines
+  else
+    printf "%-35s ❌ NOT FOUND\n", filename
+  end
+end

data/scripts/find_dead_code.rb

@@ -0,0 +1,114 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "json"
+
+class SimpleDeadCodeFinder
+  COVERAGE_JSON = "coverage/.resultset.json"
+
+  def run
+    unless File.exist?(COVERAGE_JSON)
+      puts "❌ No coverage data found. Run tests first:"
+      puts "   COVERAGE=true bundle exec rspec"
+      exit 1
+    end
+
+    puts "🔍 Analyzing SimpleCov data for dead code..."
+
+    coverage_data = JSON.parse(File.read(COVERAGE_JSON))
+    coverage = coverage_data.values.first["coverage"]
+
+    find_dead_files(coverage)
+    find_low_coverage_files(coverage)
+
+    puts "\n💡 Next steps:"
+    puts "   1. Open coverage/index.html to see detailed line-by-line coverage"
+    puts "   2. Review uncovered files to see if they can be removed"
+    puts "   3. Look at uncovered methods in low-coverage files"
+  end
+
+  private
+
+  def find_dead_files(coverage)
+    puts "\n🚨 COMPLETELY UNCOVERED FILES (potential dead code):"
+    puts "=" * 60
+
+    dead_files = []
+
+    coverage.each do |file, line_data|
+      next unless file.include?("/lib/")
+
+      # Extract lines array from SimpleCov format
+      lines = line_data["lines"]
+      next unless lines
+
+      total_lines = lines.count { |hits| !hits.nil? }
+      covered_lines = lines.count { |hits| hits && hits > 0 }
+
+      if total_lines > 0 && covered_lines == 0
+        relative_path = file.sub("#{Dir.pwd}/", "")
+        dead_files << relative_path
+      end
+    end
+
+    if dead_files.empty?
+      puts "✅ No completely uncovered files found!"
+    else
+      puts "Found #{dead_files.length} completely uncovered files:"
+      dead_files.sort.each { |f| puts "  📄 #{f}" }
+
+      puts "\n⚠️  These files are candidates for removal, but verify:"
+      puts "   • Check if they're loaded via autoloading/zeitwerk"
+      puts "   • Look for usage in examples/ or external code"
+      puts "   • Consider if they're part of public API"
+    end
+  end
+
+  def find_low_coverage_files(coverage)
+    puts "\n🔍 LOW COVERAGE FILES (<20% - check for dead methods):"
+    puts "=" * 20
+
+    low_coverage = []
+
+    coverage.each do |file, line_data|
+      next unless file.include?("/lib/")
+
+      # Extract lines array from SimpleCov format
+      lines = line_data["lines"]
+      next unless lines
+
+      total_lines = lines.count { |hits| !hits.nil? }
+      covered_lines = lines.count { |hits| hits && hits > 0 }
+
+      next if total_lines == 0
+
+      coverage_percent = (covered_lines.to_f / total_lines * 100)
+
+      next unless coverage_percent > 0 && coverage_percent < 20
+
+      relative_path = file.sub("#{Dir.pwd}/", "")
+      low_coverage << {
+        file: relative_path,
+        percent: coverage_percent,
+        covered: covered_lines,
+        total: total_lines
+      }
+    end
+
+    if low_coverage.empty?
+      puts "✅ No files with very low coverage found!"
+    else
+      low_coverage.sort_by { |f| f[:percent] }.each do |info|
+        printf "  📄 %-50s %5.1f%% (%d/%d lines)\n",
+               info[:file], info[:percent], info[:covered], info[:total]
+      end
+
+      puts "\n💡 These files likely contain dead methods:"
+      puts "   • Open coverage/index.html and click on these files"
+      puts "   • Red lines are uncovered - potential dead code"
+      puts "   • Look for entire uncovered methods/classes"
+    end
+  end
+end
+
+SimpleDeadCodeFinder.new.run if __FILE__ == $0