konpeito 0.1.0

data/lib/konpeito/cli/build_command.rb

@@ -0,0 +1,220 @@
+# frozen_string_literal: true
+
+module Konpeito
+  module Commands
+    # Build command - compiles Ruby source to native code
+    class BuildCommand < BaseCommand
+      def self.command_name
+        "build"
+      end
+
+      def self.description
+        "Compile Ruby source to native code (CRuby extension)"
+      end
+
+      def run
+        parse_options!
+
+        if args.empty?
+          error("No source file specified. Usage: konpeito build <source.rb>")
+        end
+
+        source_file = args.first
+
+        unless File.exist?(source_file)
+          error("File not found: #{source_file}")
+        end
+
+        compile(source_file)
+      end
+
+      protected
+
+      def default_options
+        {
+          output: config.build_output,
+          format: config.build_format,
+          verbose: false,
+          rbs_paths: config.rbs_paths.dup,
+          require_paths: config.require_paths.dup,
+          color: $stderr.tty?,
+          debug: config.debug?,
+          profile: config.profile?,
+          incremental: config.incremental?,
+          clean_cache: false,
+          inline_rbs: false,
+          target: :native,
+          run_after: false,
+          emit_ir: false,
+          classpath: nil,
+          library: false,
+          stats: false,
+          quiet: false
+        }
+      end
+
+      def setup_option_parser(opts)
+        opts.on("-o", "--output FILE", "Output file name") do |file|
+          options[:output] = file
+        end
+
+        opts.on("-f", "--format FORMAT", %i[cruby_ext standalone],
+                "Output format (cruby_ext, standalone)") do |format|
+          options[:format] = format
+        end
+
+        opts.on("-g", "--debug", "Generate debug info (DWARF) for lldb/gdb") do
+          options[:debug] = true
+        end
+
+        opts.on("-p", "--profile", "Enable profiling (function call counts and timing)") do
+          options[:profile] = true
+        end
+
+        opts.on("-I", "--require-path PATH", "Add require search path (can be used multiple times)") do |path|
+          options[:require_paths] << path
+        end
+
+        opts.on("--rbs FILE", "RBS type definition file (can be used multiple times)") do |file|
+          options[:rbs_paths] << file
+        end
+
+        opts.on("--incremental", "Enable incremental compilation (cache unchanged files)") do
+          options[:incremental] = true
+        end
+
+        opts.on("--clean-cache", "Clear compilation cache before building") do
+          options[:clean_cache] = true
+        end
+
+        opts.on("--inline", "Use inline RBS annotations (# @rbs, #:) from Ruby source") do
+          options[:inline_rbs] = true
+        end
+
+        opts.on("--target TARGET", %i[native jvm], "Target platform (native, jvm)") do |target|
+          options[:target] = target
+        end
+
+        opts.on("--run", "Run the compiled program after building") do
+          options[:run_after] = true
+        end
+
+        opts.on("--emit-ir", "Emit intermediate representation for debugging") do
+          options[:emit_ir] = true
+        end
+
+        opts.on("--classpath PATH", "Add external JARs/directories to classpath (colon-separated)") do |path|
+          options[:classpath] = path
+        end
+
+        opts.on("--lib", "Build as library JAR (no Main-Class, JVM target only)") do
+          options[:library] = true
+        end
+
+        opts.on("--stats", "Show optimization statistics") do
+          options[:stats] = true
+        end
+
+        opts.on("-q", "--quiet", "Suppress non-error output") do
+          options[:quiet] = true
+        end
+
+        super
+      end
+
+      def banner
+        <<~BANNER.chomp
+          Usage: konpeito build [options] <source.rb>
+
+          Examples:
+            konpeito build src/main.rb                 Compile to CRuby extension
+            konpeito build --target jvm src/main.rb    Compile to JAR
+            konpeito build --stats src/main.rb         Show optimization stats
+            konpeito build -g src/main.rb              With debug info (DWARF)
+            konpeito build --run src/main.rb           Build and run immediately
+        BANNER
+      end
+
+      private
+
+      def compile(source_file)
+        output_file = options[:output] || default_output_name(source_file, format: options[:format],
+                                                                          target: options[:target])
+
+        # Auto-add lib/*.jar to classpath for JVM target
+        classpath = options[:classpath]
+        if options[:target] == :jvm
+          lib_jars = Dir.glob("lib/*.jar")
+          unless lib_jars.empty?
+            lib_cp = lib_jars.join(Platform.classpath_separator)
+            classpath = classpath ? "#{classpath}#{Platform.classpath_separator}#{lib_cp}" : lib_cp
+          end
+        end
+
+        target_label = options[:target] == :jvm ? "jvm" : "native"
+        emit("Compiling", "#{source_file} (#{target_label})") unless options[:quiet]
+
+        compiler = Compiler.new(
+          source_file: source_file,
+          output_file: output_file,
+          format: options[:format],
+          verbose: options[:verbose],
+          rbs_paths: options[:rbs_paths],
+          require_paths: options[:require_paths],
+          debug: options[:debug],
+          profile: options[:profile],
+          incremental: options[:incremental],
+          clean_cache: options[:clean_cache],
+          inline_rbs: options[:inline_rbs],
+          target: options[:target],
+          run_after: options[:run_after],
+          emit_ir: options[:emit_ir],
+          classpath: classpath,
+          library: options[:library]
+        )
+
+        compiler.compile
+        display_diagnostics(compiler.diagnostics)
+
+        if compiler.diagnostics.any?(&:error?)
+          error_count = compiler.diagnostics.count(&:error?)
+          emit_error("Failed", "with #{error_count} error(s)") unless options[:quiet]
+          exit 1
+        end
+
+        unless options[:quiet]
+          stats = compiler.compile_stats
+
+          # Show optimization stats if --stats
+          if options[:stats] && stats
+            resolved_msg = "#{stats.resolved_files} file(s)"
+            resolved_msg += ", #{stats.rbs_count} RBS definition(s)" if stats.rbs_count > 0
+            emit("Resolved", resolved_msg)
+
+            opt_parts = []
+            opt_parts << "#{stats.specializations} specialization(s)" if stats.specializations > 0
+            opt_parts << "#{stats.inlined} inlined" if stats.inlined > 0
+            opt_parts << "#{stats.hoisted} hoisted" if stats.hoisted > 0
+            emit("Optimized", opt_parts.join(", ")) unless opt_parts.empty?
+          end
+
+          # Show finished line with timing and size
+          if stats
+            duration_str = "%.2fs" % stats.duration_s
+            size_str = File.exist?(output_file) ? " (#{format_size(File.size(output_file))})" : ""
+            emit("Finished", "in #{duration_str} -> #{output_file}#{size_str}")
+          end
+        end
+      rescue Konpeito::DependencyError => e
+        display_dependency_error(e)
+        exit 1
+      rescue Konpeito::ParseError => e
+        $stderr.puts "Error: #{e.message}"
+        exit 1
+      rescue Konpeito::Error => e
+        $stderr.puts "Error: #{e.message}"
+        exit 1
+      end
+    end
+  end
+end

data/lib/konpeito/cli/check_command.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module Konpeito
+  module Commands
+    # Check command - type check only (no code generation)
+    class CheckCommand < BaseCommand
+      def self.command_name
+        "check"
+      end
+
+      def self.description
+        "Type check Ruby source (no code generation)"
+      end
+
+      def run
+        parse_options!
+
+        if args.empty?
+          error("No source file specified. Usage: konpeito check <source.rb>")
+        end
+
+        source_file = args.first
+
+        unless File.exist?(source_file)
+          error("File not found: #{source_file}")
+        end
+
+        type_check(source_file)
+      end
+
+      protected
+
+      def default_options
+        {
+          verbose: false,
+          rbs_paths: config.rbs_paths.dup,
+          require_paths: config.require_paths.dup,
+          color: $stderr.tty?
+        }
+      end
+
+      def setup_option_parser(opts)
+        opts.on("-I", "--require-path PATH", "Add require search path (can be used multiple times)") do |path|
+          options[:require_paths] << path
+        end
+
+        opts.on("--rbs FILE", "RBS type definition file (can be used multiple times)") do |file|
+          options[:rbs_paths] << file
+        end
+
+        super
+      end
+
+      def banner
+        <<~BANNER.chomp
+          Usage: konpeito check [options] <source.rb>
+
+          Examples:
+            konpeito check src/main.rb                 Type check source file
+            konpeito check --rbs sig/types.rbs src/main.rb  With explicit RBS
+        BANNER
+      end
+
+      private
+
+      def type_check(source_file)
+        emit("Checking", source_file)
+
+        compiler = Compiler.new(
+          source_file: source_file,
+          output_file: nil,
+          format: :cruby_ext,
+          verbose: options[:verbose],
+          rbs_paths: options[:rbs_paths],
+          require_paths: options[:require_paths]
+        )
+
+        compiler.type_check
+        display_diagnostics(compiler.diagnostics)
+
+        if compiler.diagnostics.any?(&:error?)
+          error_count = compiler.diagnostics.count(&:error?)
+          emit_error("Failed", "with #{error_count} error(s)")
+          exit 1
+        end
+
+        stats = compiler.compile_stats
+        if stats
+          duration_str = "%.2fs" % stats.duration_s
+          emit("Finished", "type check in #{duration_str} (no errors)")
+        end
+      rescue Konpeito::DependencyError => e
+        display_dependency_error(e)
+        exit 1
+      rescue Konpeito::ParseError => e
+        $stderr.puts "Error: #{e.message}"
+        exit 1
+      rescue Konpeito::Error => e
+        $stderr.puts "Error: #{e.message}"
+        exit 1
+      end
+    end
+  end
+end

data/lib/konpeito/cli/config.rb

@@ -0,0 +1,231 @@
+# frozen_string_literal: true
+
+module Konpeito
+  module Commands
+    # Configuration file loader for konpeito.toml
+    class Config
+      CONFIG_FILE_NAME = "konpeito.toml"
+
+      DEFAULT_CONFIG = {
+        "name" => nil,
+        "version" => "0.1.0",
+        "build" => {
+          "output" => nil,
+          "format" => "cruby_ext",
+          "target" => "native",
+          "rbs_paths" => [],
+          "require_paths" => [],
+          "debug" => false,
+          "profile" => false,
+          "incremental" => false
+        },
+        "jvm" => {
+          "classpath" => "",
+          "java_home" => "",
+          "library" => false,
+          "main_class" => ""
+        },
+        "deps" => {
+          "jars" => []
+        },
+        "test" => {
+          "pattern" => "test/**/*_test.rb"
+        },
+        "fmt" => {
+          "indent" => 2
+        },
+        "watch" => {
+          "paths" => ["src", "sig"],
+          "extensions" => ["rb", "rbs"]
+        }
+      }.freeze
+
+      attr_reader :config, :config_path
+
+      def initialize(base_dir = Dir.pwd)
+        @base_dir = base_dir
+        @config_path = find_config_file
+        @config = load_config
+      end
+
+      def [](key)
+        @config[key]
+      end
+
+      def dig(*keys)
+        @config.dig(*keys)
+      end
+
+      def project_name
+        @config["name"] || File.basename(@base_dir)
+      end
+
+      def build_output
+        @config.dig("build", "output")
+      end
+
+      def build_format
+        @config.dig("build", "format")&.to_sym || :cruby_ext
+      end
+
+      def rbs_paths
+        @config.dig("build", "rbs_paths") || []
+      end
+
+      def require_paths
+        @config.dig("build", "require_paths") || []
+      end
+
+      def debug?
+        @config.dig("build", "debug") || false
+      end
+
+      def profile?
+        @config.dig("build", "profile") || false
+      end
+
+      def incremental?
+        @config.dig("build", "incremental") || false
+      end
+
+      def target
+        (@config.dig("build", "target") || "native").to_sym
+      end
+
+      def jvm_classpath
+        @config.dig("jvm", "classpath") || ""
+      end
+
+      def jvm_java_home
+        @config.dig("jvm", "java_home") || ""
+      end
+
+      def jvm_library?
+        @config.dig("jvm", "library") || false
+      end
+
+      def jvm_main_class
+        @config.dig("jvm", "main_class") || ""
+      end
+
+      def deps_jars
+        @config.dig("deps", "jars") || []
+      end
+
+      def test_pattern
+        @config.dig("test", "pattern") || "test/**/*_test.rb"
+      end
+
+      def fmt_indent
+        @config.dig("fmt", "indent") || 2
+      end
+
+      def watch_paths
+        @config.dig("watch", "paths") || ["src", "sig"]
+      end
+
+      def watch_extensions
+        @config.dig("watch", "extensions") || ["rb", "rbs"]
+      end
+
+      def exists?
+        !@config_path.nil?
+      end
+
+      private
+
+      def find_config_file
+        dir = @base_dir
+        loop do
+          config_file = File.join(dir, CONFIG_FILE_NAME)
+          return config_file if File.exist?(config_file)
+
+          parent = File.dirname(dir)
+          break if parent == dir
+
+          dir = parent
+        end
+        nil
+      end
+
+      def load_config
+        return deep_dup(DEFAULT_CONFIG) unless @config_path
+
+        content = File.read(@config_path)
+        parsed = parse_toml(content)
+        deep_merge(deep_dup(DEFAULT_CONFIG), parsed)
+      end
+
+      # Simple TOML parser (supports basic key-value pairs and sections)
+      def parse_toml(content)
+        result = {}
+        current_section = result
+
+        content.each_line do |line|
+          line = line.strip
+
+          # Skip empty lines and comments
+          next if line.empty? || line.start_with?("#")
+
+          # Section header [section]
+          if line.match?(/^\[(.+)\]$/)
+            section_name = line[1..-2]
+            result[section_name] ||= {}
+            current_section = result[section_name]
+          # Key = value
+          elsif line.include?("=")
+            key, value = line.split("=", 2).map(&:strip)
+            current_section[key] = parse_value(value)
+          end
+        end
+
+        result
+      end
+
+      def parse_value(value)
+        case value
+        when /^"(.*)"$/, /^'(.*)'$/
+          # String
+          Regexp.last_match(1)
+        when /^\[(.*)?\]$/
+          # Array
+          content = Regexp.last_match(1)
+          return [] if content.nil? || content.strip.empty?
+
+          content.split(",").map { |v| parse_value(v.strip) }
+        when "true"
+          true
+        when "false"
+          false
+        when /^\d+$/
+          value.to_i
+        when /^\d+\.\d+$/
+          value.to_f
+        else
+          value
+        end
+      end
+
+      def deep_dup(obj)
+        case obj
+        when Hash
+          obj.transform_values { |v| deep_dup(v) }
+        when Array
+          obj.map { |v| deep_dup(v) }
+        else
+          obj.dup rescue obj
+        end
+      end
+
+      def deep_merge(base, override)
+        base.merge(override) do |_key, old_val, new_val|
+          if old_val.is_a?(Hash) && new_val.is_a?(Hash)
+            deep_merge(old_val, new_val)
+          else
+            new_val
+          end
+        end
+      end
+    end
+  end
+end

data/lib/konpeito/cli/deps_command.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "fileutils"
+
+module Konpeito
+  module Commands
+    # Deps command - download Maven dependencies
+    class DepsCommand < BaseCommand
+      MAVEN_CENTRAL_BASE = "https://repo1.maven.org/maven2"
+
+      def self.command_name
+        "deps"
+      end
+
+      def self.description
+        "Download JAR dependencies from Maven Central"
+      end
+
+      def run
+        parse_options!
+
+        jars = config.deps_jars
+
+        if jars.empty?
+          puts "No dependencies configured in konpeito.toml [deps] section."
+          puts ""
+          puts "Example:"
+          puts '  [deps]'
+          puts '  jars = ["com.google.code.gson:gson:2.10.1"]'
+          return
+        end
+
+        lib_dir = options[:output_dir]
+        FileUtils.mkdir_p(lib_dir)
+
+        jars.each do |spec|
+          download_jar(spec, lib_dir)
+        end
+
+        puts ""
+        puts "#{jars.size} dependency(ies) downloaded to #{lib_dir}/"
+      end
+
+      protected
+
+      def default_options
+        {
+          verbose: false,
+          color: $stderr.tty?,
+          output_dir: "lib"
+        }
+      end
+
+      def setup_option_parser(opts)
+        opts.on("-d", "--dir DIR", "Output directory (default: lib)") do |dir|
+          options[:output_dir] = dir
+        end
+
+        super
+      end
+
+      def banner
+        <<~BANNER.chomp
+          Usage: konpeito deps [options]
+
+          Examples:
+            konpeito deps                              Download all configured JARs
+            konpeito deps -d vendor/lib                Download to custom directory
+        BANNER
+      end
+
+      private
+
+      def download_jar(spec, lib_dir)
+        parts = spec.split(":")
+        unless parts.size == 3
+          $stderr.puts "Invalid dependency format: #{spec} (expected group:artifact:version)"
+          return
+        end
+
+        group, artifact, version = parts
+        group_path = group.gsub(".", "/")
+        filename = "#{artifact}-#{version}.jar"
+        dest = File.join(lib_dir, filename)
+
+        if File.exist?(dest)
+          puts_verbose "Already downloaded: #{filename}"
+          return
+        end
+
+        url = "#{MAVEN_CENTRAL_BASE}/#{group_path}/#{artifact}/#{version}/#{filename}"
+        puts "Downloading #{spec}..."
+        puts_verbose "  URL: #{url}"
+
+        begin
+          download_file(url, dest)
+          puts "  -> #{dest}"
+        rescue => e
+          $stderr.puts "  Failed to download #{spec}: #{e.message}"
+          FileUtils.rm_f(dest)
+        end
+      end
+
+      def download_file(url, dest)
+        uri = URI(url)
+        max_redirects = 5
+        redirects = 0
+
+        loop do
+          response = Net::HTTP.get_response(uri)
+
+          case response
+          when Net::HTTPSuccess
+            File.binwrite(dest, response.body)
+            return
+          when Net::HTTPRedirection
+            redirects += 1
+            raise "Too many redirects" if redirects > max_redirects
+            uri = URI(response["location"])
+          else
+            raise "HTTP #{response.code}: #{response.message}"
+          end
+        end
+      end
+    end
+  end
+end