konpeito 0.2.4 → 0.3.0

data/lib/konpeito/cli/fmt_command.rb

@@ -1,60 +1,46 @@
 # frozen_string_literal: true
 
-require_relative "../formatter/formatter"
-
 module Konpeito
   module Commands
-    # Fmt command - format Ruby source files with built-in Prism-based formatter
+    # Fmt command - format Ruby source files via RuboCop
     class FmtCommand < BaseCommand
       def self.command_name
         "fmt"
       end
 
       def self.description
-        "Format Ruby source files"
+        "Format Ruby source files (via RuboCop)"
       end
 
       def run
         parse_options!
 
-        @files = args.empty? ? find_ruby_files : args
+        rubocop_args = build_rubocop_args
+        success = system("bundle", "exec", "rubocop", *rubocop_args)
+        exit 1 unless success
+      end
 
-        if @files.empty?
-          $stderr.puts "No Ruby files found to format."
-          return
-        end
+      # Visible for testing
+      def build_rubocop_args
+        rubocop_args = []
 
-        emit("Formatting", "#{@files.size} file(s)...") unless options[:quiet]
-
-        changed = 0
-        unchanged = 0
-        errored = 0
-
-        @files.each do |file|
-          result = format_file(file)
-          case result
-          when :changed
-            changed += 1
-          when :unchanged
-            unchanged += 1
-          when :error
-            errored += 1
-          end
+        if options[:check]
+          # Check mode: report violations without modifying files
+        else
+          # Default: auto-correct
+          rubocop_args << "-A"
         end
 
-        unless options[:quiet]
-          parts = []
-          parts << "#{changed} changed" if changed > 0
-          parts << "#{unchanged} unchanged" if unchanged > 0
-          parts << "#{errored} error(s)" if errored > 0
-          emit("Finished", parts.join(", "))
-        end
+        rubocop_args << "--format" << "quiet" if options[:quiet]
+        rubocop_args << "--no-color" unless options[:color]
 
-        if options[:check] && changed > 0
-          exit 1
+        options[:exclude].each do |pattern|
+          rubocop_args << "--exclude" << pattern
         end
 
-        exit 1 if errored > 0
+        rubocop_args.concat(args) unless args.empty?
+
+        rubocop_args
       end
 
       protected
@@ -64,7 +50,6 @@ module Konpeito
           verbose: false,
           color: $stderr.tty?,
           check: false,
-          diff: false,
           quiet: false,
           exclude: []
         }
@@ -75,9 +60,8 @@ module Konpeito
           options[:check] = true
         end
 
-        opts.on("--diff", "Show what would change (unified diff)") do
-          options[:diff] = true
-          options[:check] = true  # diff implies check
+        opts.on("--diff", "Check formatting without modifying files (alias for --check)") do
+          options[:check] = true
         end
 
         opts.on("-q", "--quiet", "Suppress non-error output") do
@@ -99,101 +83,9 @@ module Konpeito
             konpeito fmt                               Format all Ruby files
             konpeito fmt src/main.rb                   Format specific file
             konpeito fmt --check                       Check without modifying
-            konpeito fmt --diff                        Show what would change
+            konpeito fmt --diff                        Check without modifying (alias)
         BANNER
       end
-
-      private
-
-      def find_ruby_files
-        default_exclude = ["vendor/", ".bundle/", ".konpeito_cache/", "tools/"]
-        all_exclude = default_exclude + options[:exclude]
-
-        Dir.glob("**/*.rb").reject do |f|
-          all_exclude.any? { |pat| f.start_with?(pat) || File.fnmatch?(pat, f) }
-        end
-      end
-
-      def format_file(file)
-        unless File.exist?(file)
-          $stderr.puts "Warning: #{file} not found, skipping"
-          return :error
-        end
-
-        source = File.read(file)
-        formatter = Formatter::Formatter.new(source, filepath: file)
-        formatted = formatter.format
-
-        if source == formatted
-          return :unchanged
-        end
-
-        if options[:diff]
-          show_diff(file, source, formatted)
-          emit("Formatted", file) unless options[:quiet]
-          return :changed
-        end
-
-        if options[:check]
-          emit_warn("Unformatted", file) unless options[:quiet]
-          return :changed
-        end
-
-        # Write formatted content
-        File.write(file, formatted)
-        emit("Formatted", file) unless options[:quiet]
-        :changed
-      rescue => e
-        $stderr.puts "Error formatting #{file}: #{e.message}"
-        :error
-      end
-
-      def show_diff(file, original, formatted)
-        orig_lines = original.lines
-        fmt_lines = formatted.lines
-
-        # Simple unified diff
-        $stdout.puts "--- #{file}"
-        $stdout.puts "+++ #{file} (formatted)"
-
-        # Find differing regions
-        max_len = [orig_lines.size, fmt_lines.size].max
-        i = 0
-        while i < max_len
-          if orig_lines[i] != fmt_lines[i]
-            # Find the end of this diff hunk
-            hunk_start = i
-            while i < max_len && orig_lines[i] != fmt_lines[i]
-              i += 1
-            end
-            hunk_end = i
-
-            # Context
-            ctx_start = [hunk_start - 3, 0].max
-            ctx_end = [hunk_end + 3, max_len].min
-
-            $stdout.puts "@@ -#{ctx_start + 1},#{hunk_end - ctx_start} +#{ctx_start + 1},#{hunk_end - ctx_start} @@"
-
-            (ctx_start...ctx_end).each do |j|
-              if j >= hunk_start && j < hunk_end
-                if j < orig_lines.size && orig_lines[j]
-                  line = orig_lines[j].chomp
-                  $stdout.puts options[:color] ? "\e[31m-#{line}\e[0m" : "-#{line}"
-                end
-                if j < fmt_lines.size && fmt_lines[j]
-                  line = fmt_lines[j].chomp
-                  $stdout.puts options[:color] ? "\e[32m+#{line}\e[0m" : "+#{line}"
-                end
-              else
-                line = (orig_lines[j] || fmt_lines[j] || "").chomp
-                $stdout.puts " #{line}"
-              end
-            end
-          else
-            i += 1
-          end
-        end
-      end
     end
   end
 end

data/lib/konpeito/cli/run_command.rb

@@ -48,6 +48,7 @@ module Konpeito
           classpath: nil,
           rbs_paths: config.rbs_paths.dup,
           require_paths: config.require_paths.dup,
+          inline_rbs: false,
           lib: false
         }
       end
@@ -69,6 +70,10 @@ module Konpeito
           options[:require_paths] << path
         end
 
+        opts.on("--inline", "Use inline RBS annotations (# @rbs, #:) from Ruby source") do
+          options[:inline_rbs] = true
+        end
+
         super
       end
 
@@ -78,6 +83,7 @@ module Konpeito
 
           Examples:
             konpeito run src/main.rb                   Build and run (native)
+            konpeito run --inline src/main.rb          Build and run with inline RBS
             konpeito run --target jvm src/main.rb      Build and run (JVM)
         BANNER
       end
@@ -104,11 +110,16 @@ module Konpeito
       def run_native(source_file)
         require "tmpdir"
 
-        output_file = File.join(Dir.tmpdir, "konpeito_run_#{File.basename(source_file, '.rb')}#{Platform.shared_lib_extension}")
+        # Use a subdirectory to avoid conflicts, but keep the basename matching
+        # the Init_ function name (Ruby requires Init_<basename> to match the filename)
+        @run_tmpdir = File.join(Dir.tmpdir, "konpeito_run_#{Process.pid}")
+        FileUtils.mkdir_p(@run_tmpdir)
+        output_file = File.join(@run_tmpdir, "#{File.basename(source_file, '.rb')}#{Platform.shared_lib_extension}")
 
         build_args = ["-o", output_file]
         build_args << "-v" if options[:verbose]
         build_args << "--no-color" unless options[:color]
+        build_args << "--inline" if options[:inline_rbs]
         options[:rbs_paths].each { |p| build_args << "--rbs" << p }
         options[:require_paths].each { |p| build_args << "-I" << p }
         build_args << source_file
@@ -116,9 +127,11 @@ module Konpeito
         Commands::BuildCommand.new(build_args, config: config).run
 
         emit("Running", output_file)
-        system("ruby", "-r", output_file, "-e", "")
+        # Run without Bundler environment so the compiled extension can load
+        # any installed gem (not just those in the current Gemfile)
+        run_without_bundler("ruby", "-r", output_file, "-e", "")
       ensure
-        FileUtils.rm_f(output_file) if output_file && File.exist?(output_file)
+        FileUtils.rm_rf(@run_tmpdir) if @run_tmpdir && Dir.exist?(@run_tmpdir)
       end
 
       def build_classpath
@@ -135,10 +148,23 @@ module Konpeito
         parts.reject(&:empty?).join(Platform.classpath_separator)
       end
 
+      # Run a command without Bundler's environment restrictions.
+      # When konpeito is invoked via `bundle exec`, child processes inherit
+      # BUNDLE_GEMFILE/RUBYOPT which restrict gem access. The compiled extension
+      # may require gems not in the current Gemfile.
+      def run_without_bundler(*cmd)
+        if defined?(Bundler) && Bundler.respond_to?(:with_unbundled_env)
+          Bundler.with_unbundled_env { system(*cmd) }
+        else
+          system(*cmd)
+        end
+      end
+
       def build_jvm_args(source_file, classpath)
         build_args = ["--target", "jvm"]
         build_args << "-v" if options[:verbose]
         build_args << "--no-color" unless options[:color]
+        build_args << "--inline" if options[:inline_rbs]
         build_args += ["--classpath", classpath] unless classpath.empty?
         options[:rbs_paths].each { |p| build_args << "--rbs" << p }
         options[:require_paths].each { |p| build_args << "-I" << p }

data/lib/konpeito/cli.rb

@@ -5,7 +5,6 @@ require_relative "cli/config"
 require_relative "cli/base_command"
 require_relative "cli/build_command"
 require_relative "cli/check_command"
-require_relative "cli/lsp_command"
 require_relative "cli/init_command"
 require_relative "cli/fmt_command"
 require_relative "cli/test_command"
@@ -13,6 +12,7 @@ require_relative "cli/watch_command"
 require_relative "cli/run_command"
 require_relative "cli/deps_command"
 require_relative "cli/doctor_command"
+require_relative "cli/completion_command"
 
 module Konpeito
   # Main CLI router - dispatches to subcommands
@@ -21,13 +21,13 @@ module Konpeito
       "build" => Commands::BuildCommand,
       "run" => Commands::RunCommand,
       "check" => Commands::CheckCommand,
-      "lsp" => Commands::LspCommand,
       "init" => Commands::InitCommand,
       "fmt" => Commands::FmtCommand,
       "test" => Commands::TestCommand,
       "watch" => Commands::WatchCommand,
       "deps" => Commands::DepsCommand,
-      "doctor" => Commands::DoctorCommand
+      "doctor" => Commands::DoctorCommand,
+      "completion" => Commands::CompletionCommand
     }.freeze
 
     attr_reader :args
@@ -62,6 +62,10 @@ module Konpeito
       else
         # Unknown command
         $stderr.puts "Unknown command: #{command_name}"
+        suggestion = find_similar_command(command_name)
+        $stderr.puts "  Did you mean: #{suggestion}?" if suggestion
+        $stderr.puts ""
+        $stderr.puts "Available commands: #{COMMANDS.keys.join(', ')}"
         $stderr.puts "Run 'konpeito --help' for usage information."
         exit 1
       end
@@ -69,6 +73,43 @@ module Konpeito
 
     private
 
+    def find_similar_command(input)
+      best = nil
+      best_distance = Float::INFINITY
+
+      COMMANDS.each_key do |name|
+        # Prefix match (e.g. "b" -> "build")
+        return name if name.start_with?(input) && input.length >= 1
+
+        d = levenshtein(input, name)
+        if d < best_distance && d <= 2
+          best_distance = d
+          best = name
+        end
+      end
+      best
+    end
+
+    def levenshtein(a, b)
+      m = a.length
+      n = b.length
+      return n if m == 0
+      return m if n == 0
+
+      d = Array.new(m + 1) { |i| i }
+      (1..n).each do |j|
+        prev = d[0]
+        d[0] = j
+        (1..m).each do |i|
+          cost = a[i - 1] == b[j - 1] ? 0 : 1
+          temp = d[i]
+          d[i] = [d[i] + 1, d[i - 1] + 1, prev + cost].min
+          prev = temp
+        end
+      end
+      d[m]
+    end
+
     def run_command(command_name, command_args)
       command_class = COMMANDS[command_name]
       config = Commands::Config.new
@@ -105,6 +146,7 @@ module Konpeito
       puts "  konpeito test                         Run tests"
       puts "  konpeito fmt                          Format source files"
       puts "  konpeito doctor                       Check environment"
+      puts "  konpeito completion zsh               Generate shell completions"
       puts ""
       puts "Legacy mode (backwards compatible):"
       puts "  konpeito source.rb                     Same as: konpeito build source.rb"
@@ -171,7 +213,6 @@ module Konpeito
         require_paths: [],
         color: $stderr.tty?,
         debug: false,
-        lsp: false,
         profile: false,
         incremental: false,
         clean_cache: false
@@ -181,12 +222,6 @@ module Konpeito
     def run
       parse_options!
 
-      # Start LSP server if requested
-      if options[:lsp]
-        Commands::LspCommand.new([], config: Commands::Config.new).run
-        return
-      end
-
       if args.empty?
         puts "Usage: konpeito [options] <source.rb>"
         puts "Run 'konpeito --help' for more information."
@@ -272,10 +307,6 @@ module Konpeito
           options[:color] = false
         end
 
-        opts.on("--lsp", "Start Language Server Protocol server") do
-          options[:lsp] = true
-        end
-
         opts.on("--incremental", "Enable incremental compilation (cache unchanged files)") do
           options[:incremental] = true
         end

data/lib/konpeito/codegen/builtin_methods.rb

@@ -44,6 +44,22 @@ module Konpeito
 
         # String hash - exported (useful for Hash key optimization)
         hash: { c_func: "rb_str_hash", arity: 0, return_type: :Integer, conv: :simple },
+
+        # String repeat - exported
+        :* => { c_func: "rb_str_times", arity: 1, return_type: :String, conv: :simple },
+
+        # String freeze - exported
+        freeze: { c_func: "rb_str_freeze", arity: 0, return_type: :String, conv: :simple },
+
+        # String replace - exported
+        replace: { c_func: "rb_str_replace", arity: 1, return_type: :String, conv: :simple },
+
+        # String succ/next - exported
+        succ: { c_func: "rb_str_succ", arity: 0, return_type: :String, conv: :simple },
+        next: { c_func: "rb_str_succ", arity: 0, return_type: :String, conv: :simple },
+
+        # String inspect - exported
+        inspect: { c_func: "rb_str_inspect", arity: 0, return_type: :String, conv: :simple },
       },
 
       Array: {

data/lib/konpeito/codegen/cruby_backend.rb

@@ -65,7 +65,7 @@ module Konpeito
           unless @debug
             FileUtils.rm_f(obj_file)
           end
-          FileUtils.rm_f(init_c_file)
+          # FileUtils.rm_f(init_c_file)  # DEBUG: keep for inspection
           FileUtils.rm_f(init_obj_file)
           FileUtils.rm_f(profile_c_file) if profile_c_file
           FileUtils.rm_f(profile_obj_file) if profile_obj_file
@@ -241,11 +241,32 @@ module Konpeito
           lines << ""
         end
 
-        # Load stdlib dependencies first
+        # Load stdlib/gem dependencies first
+        # Use rb_funcallv(rb_cObject, ...) instead of rb_require() or rb_funcallv(rb_mKernel, ...)
+        # rb_require() bypasses RubyGems gem activation entirely.
+        # rb_funcallv(rb_mKernel, ...) calls the Kernel singleton method which also
+        # fails to activate gems. rb_funcallv(rb_cObject, ...) calls require as an
+        # instance method on Object (which includes Kernel), going through RubyGems'
+        # full gem activation path.
         unless @stdlib_requires.empty?
-          lines << "    /* Load stdlib dependencies */"
+          lines << "    /* Load dependencies */"
+          lines << "    {"
+          lines << "        ID require_id = rb_intern(\"require\");"
           @stdlib_requires.each do |lib_name|
-            lines << "    rb_require(\"#{lib_name}\");"
+            lines << "        {"
+            lines << "            VALUE args[] = { rb_str_new_cstr(\"#{lib_name}\") };"
+            lines << "            rb_funcallv(rb_cObject, require_id, 1, args);"
+            lines << "        }"
+          end
+          lines << "    }"
+          lines << ""
+        end
+
+        # Load runtime native extensions (require_relative pointing to .bundle/.so)
+        unless @runtime_native_extensions.empty?
+          lines << "    /* Load runtime native extensions */"
+          @runtime_native_extensions.each do |ext|
+            lines << "    rb_require(\"#{ext[:path]}\");"
           end
           lines << ""
         end
@@ -266,7 +287,15 @@ module Konpeito
 
             # Use -1 arity for variadic functions
             arity = llvm_generator.variadic_functions[mangled_name] ? -1 : func.params.size - 1
-            lines << "    rb_define_method(#{module_var}, \"#{method_name}\", #{mangled_name}, #{arity});"
+
+            if module_def.module_function_methods&.include?(method_name)
+              # module_function: available as both public module method AND private instance method
+              lines << "    rb_define_module_function(#{module_var}, \"#{method_name}\", #{mangled_name}, #{arity});"
+            elsif module_def.private_methods&.include?(method_name)
+              lines << "    rb_define_private_method(#{module_var}, \"#{method_name}\", #{mangled_name}, #{arity});"
+            else
+              lines << "    rb_define_method(#{module_var}, \"#{method_name}\", #{mangled_name}, #{arity});"
+            end
           end
 
           # Register singleton methods (def self.method)
@@ -292,6 +321,25 @@ module Konpeito
           end
         end
 
+        # Execute top-level include/extend/prepend before class definitions
+        # so that constants from included modules are available for superclass resolution
+        # (e.g., `include Kumiki; class CounterComponent < Component`)
+        unless hir.toplevel_includes.empty?
+          lines << "    /* Top-level include/extend/prepend */"
+          hir.toplevel_includes.each do |kind, module_name|
+            module_expr = "rb_const_get(rb_cObject, rb_intern(\"#{module_name}\"))"
+            case kind
+            when :include
+              lines << "    rb_include_module(rb_cObject, #{module_expr});"
+            when :extend
+              lines << "    rb_extend_object(rb_cObject, #{module_expr});"
+            when :prepend
+              lines << "    rb_prepend_module(rb_cObject, #{module_expr});"
+            end
+          end
+          lines << ""
+        end
+
         # Define NativeClasses with TypedData allocator
         native_classes.each do |class_name, class_type|
           lines.concat(generate_native_class_init(class_name, class_type))
@@ -429,6 +477,16 @@ module Konpeito
           lines << "    rb_define_private_method(rb_cObject, \"#{func_def.name}\", #{mangled_name}, #{arity});"
         end
 
+        # Call top-level entry point if present.
+        # rb_vm_top_self() is not exported from libruby in Ruby 4.0; use rb_cObject instead.
+        # Top-level calls like module_function/private/public/include on Object are semantically
+        # equivalent to the same calls on the main object for our purposes.
+        has_main = hir.functions.any? { |f| f.name == "__main__" && !f.owner_class && !f.owner_module }
+        if has_main
+          lines << "    /* Run top-level code */"
+          lines << "    rn___main__(rb_cObject);"
+        end
+
         lines << "}"
         lines << ""
 
@@ -939,10 +997,22 @@ module Konpeito
         end
 
         if @rbs_loader
+          stdlib_ui_dir = File.expand_path("../stdlib/ui", __dir__)
+
           @rbs_loader.all_ffi_libraries.each do |lib_name|
+            link_name = lib_name.sub(/^lib/, "")
+
+            # On macOS the UI runtime ships as a Ruby .bundle (loadable module),
+            # not as a .dylib.  Bundles cannot be used as -l link targets; their
+            # symbols are resolved at runtime via -undefined dynamic_lookup, so
+            # we simply skip the -l flag for them.
+            bundle_path = File.join(stdlib_ui_dir, "#{link_name}.bundle")
+            if File.exist?(bundle_path) && RbConfig::CONFIG["host_os"] =~ /darwin/
+              next
+            end
+
             # Convert library name to linker flag
             # "libm" -> "-lm", "libfoo" -> "-lfoo", "foo" -> "-lfoo"
-            link_name = lib_name.sub(/^lib/, "")
             flags << "-l#{link_name}"
           end
         end