konpeito 0.1.0

data/lib/konpeito/cache/cache_manager.rb

@@ -0,0 +1,230 @@
+# frozen_string_literal: true
+
+require "digest"
+require "json"
+require "fileutils"
+
+module Konpeito
+  module Cache
+    # Manages compilation cache for incremental builds.
+    # Caches AST and type inference results per file.
+    class CacheManager
+      MANIFEST_FILE = "manifest.json"
+      AST_DIR = "ast"
+      TYPES_DIR = "types"
+
+      attr_reader :cache_dir, :dependency_graph
+
+      def initialize(cache_dir: ".konpeito_cache")
+        @cache_dir = File.expand_path(cache_dir)
+        @manifest = nil
+        @dependency_graph = nil
+        @dirty = false
+
+        ensure_cache_dirs
+        load_manifest
+      end
+
+      # Calculate SHA256 hash of file content
+      def file_hash(path)
+        return nil unless File.exist?(path)
+
+        Digest::SHA256.file(path).hexdigest
+      end
+
+      # Check if a file needs recompilation
+      def needs_recompile?(path)
+        path = normalize_path(path)
+        current_hash = file_hash(path)
+        return true unless current_hash
+
+        cached_hash = @manifest["files"][path]&.dig("hash")
+        current_hash != cached_hash
+      end
+
+      # Get cached AST for a file
+      def get_ast(path)
+        path = normalize_path(path)
+        return nil if needs_recompile?(path)
+
+        ast_file = ast_cache_path(path)
+        return nil unless File.exist?(ast_file)
+
+        begin
+          Marshal.load(File.binread(ast_file))
+        rescue StandardError
+          nil
+        end
+      end
+
+      # Store AST in cache
+      def put_ast(path, ast)
+        path = normalize_path(path)
+        ast_file = ast_cache_path(path)
+
+        FileUtils.mkdir_p(File.dirname(ast_file))
+        File.binwrite(ast_file, Marshal.dump(ast))
+
+        update_file_entry(path)
+      end
+
+      # Get cached type inference results
+      def get_types(path)
+        path = normalize_path(path)
+        return nil if needs_recompile?(path)
+
+        types_file = types_cache_path(path)
+        return nil unless File.exist?(types_file)
+
+        begin
+          Marshal.load(File.binread(types_file))
+        rescue StandardError
+          nil
+        end
+      end
+
+      # Store type inference results
+      def put_types(path, data)
+        path = normalize_path(path)
+        types_file = types_cache_path(path)
+
+        FileUtils.mkdir_p(File.dirname(types_file))
+        File.binwrite(types_file, Marshal.dump(data))
+
+        update_file_entry(path)
+      end
+
+      # Invalidate cache for a file and all its dependents
+      def invalidate(path)
+        path = normalize_path(path)
+
+        # Get all affected files
+        affected = [path] + @dependency_graph.get_all_dependents(path)
+
+        affected.each do |file|
+          invalidate_single(file)
+        end
+
+        @dirty = true
+      end
+
+      # Register a dependency
+      def add_dependency(from, to)
+        @dependency_graph.add_dependency(from, to)
+        @dirty = true
+      end
+
+      # Clear dependencies for a file (called before re-analyzing)
+      def clear_dependencies(path)
+        @dependency_graph.clear_dependencies(path)
+        @dirty = true
+      end
+
+      # Get files that need recompilation given changed files
+      def get_recompile_order(changed_paths)
+        @dependency_graph.invalidation_order(changed_paths)
+      end
+
+      # Clear all cache
+      def clean!
+        FileUtils.rm_rf(@cache_dir)
+        ensure_cache_dirs
+        @manifest = create_empty_manifest
+        @dependency_graph = DependencyGraph.new
+        @dirty = true
+        save_manifest
+      end
+
+      # Save manifest to disk
+      def save_manifest
+        return unless @dirty
+
+        @manifest["dependency_graph"] = @dependency_graph.to_h
+        @manifest["updated_at"] = Time.now.iso8601
+
+        manifest_path = File.join(@cache_dir, MANIFEST_FILE)
+        File.write(manifest_path, JSON.pretty_generate(@manifest))
+        @dirty = false
+      end
+
+      # Get all cached files
+      def cached_files
+        @manifest["files"].keys
+      end
+
+      # Check if cache exists and is valid
+      def cache_exists?
+        File.exist?(File.join(@cache_dir, MANIFEST_FILE))
+      end
+
+      private
+
+      def normalize_path(path)
+        File.expand_path(path)
+      end
+
+      def ensure_cache_dirs
+        FileUtils.mkdir_p(@cache_dir)
+        FileUtils.mkdir_p(File.join(@cache_dir, AST_DIR))
+        FileUtils.mkdir_p(File.join(@cache_dir, TYPES_DIR))
+      end
+
+      def load_manifest
+        manifest_path = File.join(@cache_dir, MANIFEST_FILE)
+
+        if File.exist?(manifest_path)
+          begin
+            data = JSON.parse(File.read(manifest_path))
+            @manifest = data
+            @dependency_graph = DependencyGraph.from_h(data["dependency_graph"])
+          rescue JSON::ParserError
+            @manifest = create_empty_manifest
+            @dependency_graph = DependencyGraph.new
+          end
+        else
+          @manifest = create_empty_manifest
+          @dependency_graph = DependencyGraph.new
+        end
+      end
+
+      def create_empty_manifest
+        {
+          "version" => Konpeito::VERSION,
+          "created_at" => Time.now.iso8601,
+          "updated_at" => Time.now.iso8601,
+          "files" => {},
+          "dependency_graph" => {}
+        }
+      end
+
+      def update_file_entry(path)
+        @manifest["files"][path] = {
+          "hash" => file_hash(path),
+          "cached_at" => Time.now.iso8601
+        }
+        @dirty = true
+      end
+
+      def invalidate_single(path)
+        @manifest["files"].delete(path)
+
+        # Remove cached files
+        ast_file = ast_cache_path(path)
+        types_file = types_cache_path(path)
+
+        FileUtils.rm_f(ast_file)
+        FileUtils.rm_f(types_file)
+      end
+
+      def ast_cache_path(path)
+        hash = Digest::SHA256.hexdigest(path)
+        File.join(@cache_dir, AST_DIR, "#{hash}.ast")
+      end
+
+      def types_cache_path(path)
+        hash = Digest::SHA256.hexdigest(path)
+        File.join(@cache_dir, TYPES_DIR, "#{hash}.types")
+      end
+    end
+  end
+end

data/lib/konpeito/cache/dependency_graph.rb

@@ -0,0 +1,192 @@
+# frozen_string_literal: true
+
+module Konpeito
+  module Cache
+    # Tracks file dependencies for incremental compilation.
+    # Maintains both forward (file -> dependencies) and reverse (file -> dependents) graphs.
+    class DependencyGraph
+      def initialize
+        @forward = {}   # path -> Set of paths this file depends on
+        @reverse = {}   # path -> Set of paths that depend on this file
+      end
+
+      # Add a dependency: from depends on to
+      # Example: main.rb requires utils.rb -> add_dependency("main.rb", "utils.rb")
+      def add_dependency(from, to)
+        from = normalize_path(from)
+        to = normalize_path(to)
+
+        @forward[from] ||= Set.new
+        @forward[from] << to
+
+        @reverse[to] ||= Set.new
+        @reverse[to] << from
+      end
+
+      # Get all files that depend on the given path (direct dependents only)
+      def get_direct_dependents(path)
+        path = normalize_path(path)
+        @reverse[path]&.to_a || []
+      end
+
+      # Get all files that depend on the given path (transitively)
+      def get_all_dependents(path)
+        path = normalize_path(path)
+        result = Set.new
+        queue = [path]
+
+        while queue.any?
+          current = queue.shift
+          dependents = @reverse[current] || Set.new
+
+          dependents.each do |dep|
+            unless result.include?(dep)
+              result << dep
+              queue << dep
+            end
+          end
+        end
+
+        result.to_a
+      end
+
+      # Get all dependencies of the given path (what this file depends on)
+      def get_dependencies(path)
+        path = normalize_path(path)
+        @forward[path]&.to_a || []
+      end
+
+      # Given a set of changed files, return all files that need recompilation
+      # in dependency order (dependencies before dependents)
+      def invalidation_order(changed_paths)
+        changed_paths = changed_paths.map { |p| normalize_path(p) }
+
+        # Collect all affected files (changed + their dependents)
+        affected = Set.new(changed_paths)
+        changed_paths.each do |path|
+          get_all_dependents(path).each { |dep| affected << dep }
+        end
+
+        # Topological sort: dependencies before dependents
+        topological_sort(affected.to_a)
+      end
+
+      # Check if path has any registered dependencies
+      def has_dependencies?(path)
+        path = normalize_path(path)
+        @forward.key?(path) && @forward[path].any?
+      end
+
+      # Remove a file from the graph
+      def remove(path)
+        path = normalize_path(path)
+
+        # Remove from forward graph
+        if @forward[path]
+          @forward[path].each do |dep|
+            @reverse[dep]&.delete(path)
+          end
+          @forward.delete(path)
+        end
+
+        # Remove from reverse graph
+        if @reverse[path]
+          @reverse[path].each do |dependent|
+            @forward[dependent]&.delete(path)
+          end
+          @reverse.delete(path)
+        end
+      end
+
+      # Clear all dependencies for a file (but keep dependents)
+      def clear_dependencies(path)
+        path = normalize_path(path)
+
+        if @forward[path]
+          @forward[path].each do |dep|
+            @reverse[dep]&.delete(path)
+          end
+          @forward[path] = Set.new
+        end
+      end
+
+      # Clear all data
+      def clear!
+        @forward.clear
+        @reverse.clear
+      end
+
+      # Serialize to hash for persistence
+      def to_h
+        {
+          "forward" => @forward.transform_values(&:to_a),
+          "reverse" => @reverse.transform_values(&:to_a)
+        }
+      end
+
+      # Deserialize from hash
+      def self.from_h(data)
+        graph = new
+        return graph unless data
+
+        (data["forward"] || {}).each do |path, deps|
+          graph.instance_variable_get(:@forward)[path] = Set.new(deps)
+        end
+        (data["reverse"] || {}).each do |path, deps|
+          graph.instance_variable_get(:@reverse)[path] = Set.new(deps)
+        end
+        graph
+      end
+
+      # Get all known files
+      def all_files
+        (@forward.keys + @reverse.keys).uniq
+      end
+
+      private
+
+      def normalize_path(path)
+        File.expand_path(path)
+      end
+
+      # Topological sort using Kahn's algorithm
+      # Returns files in dependency order: dependencies before dependents
+      def topological_sort(files)
+        return files if files.empty?
+
+        # Build in-degree map (only for files in our set)
+        # in_degree[file] = number of dependencies of file that are also in our set
+        in_degree = {}
+        files.each { |f| in_degree[f] = 0 }
+
+        files.each do |file|
+          (@forward[file] || Set.new).each do |dep|
+            # file depends on dep, so file has an incoming edge from dep
+            # Increment in_degree for file (not dep) so dependencies come first
+            in_degree[file] += 1 if in_degree.key?(dep)
+          end
+        end
+
+        # Start with files that have no dependencies (in-degree 0)
+        queue = files.select { |f| in_degree[f] == 0 }
+        result = []
+
+        while queue.any?
+          current = queue.shift
+          result << current
+
+          (@reverse[current] || Set.new).each do |dependent|
+            next unless in_degree.key?(dependent)
+
+            in_degree[dependent] -= 1
+            queue << dependent if in_degree[dependent] == 0
+          end
+        end
+
+        # If there are remaining files, there's a cycle - add them anyway
+        remaining = files - result
+        result + remaining
+      end
+    end
+  end
+end

data/lib/konpeito/cache.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Konpeito
+  module Cache
+    autoload :CacheManager, "konpeito/cache/cache_manager"
+    autoload :DependencyGraph, "konpeito/cache/dependency_graph"
+  end
+end

data/lib/konpeito/cli/base_command.rb

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+require "optparse"
+
+module Konpeito
+  module Commands
+    # Base class for all CLI commands
+    class BaseCommand
+      attr_reader :args, :options, :config
+
+      def initialize(args, config: nil)
+        @args = args.dup
+        @config = config || Config.new
+        @options = default_options
+      end
+
+      # Override in subclasses
+      def run
+        raise NotImplementedError, "Subclasses must implement #run"
+      end
+
+      # Override in subclasses to provide command name
+      def self.command_name
+        raise NotImplementedError, "Subclasses must implement .command_name"
+      end
+
+      # Override in subclasses to provide command description
+      def self.description
+        raise NotImplementedError, "Subclasses must implement .description"
+      end
+
+      protected
+
+      # Override in subclasses
+      def default_options
+        {
+          verbose: false,
+          color: $stderr.tty?
+        }
+      end
+
+      # Override in subclasses
+      def setup_option_parser(opts)
+        opts.on("-v", "--verbose", "Verbose output") do
+          options[:verbose] = true
+        end
+
+        opts.on("--no-color", "Disable colored output") do
+          options[:color] = false
+        end
+
+        opts.on("-h", "--help", "Show this help") do
+          puts opts
+          exit
+        end
+      end
+
+      def parse_options!
+        parser = OptionParser.new do |opts|
+          opts.banner = banner
+          opts.separator ""
+          opts.separator "Options:"
+          setup_option_parser(opts)
+        end
+
+        parser.parse!(args)
+      end
+
+      def banner
+        "Usage: konpeito #{self.class.command_name} [options]"
+      end
+
+      def puts_verbose(message)
+        puts message if options[:verbose]
+      end
+
+      # Cargo-style structured output: right-aligned tag + message
+      # Output goes to $stderr so stdout remains clean for program output
+      def emit(tag, message)
+        if options[:color]
+          $stderr.puts "  \e[1;32m%12s\e[0m %s" % [tag, message]
+        else
+          $stderr.puts "  %12s %s" % [tag, message]
+        end
+      end
+
+      # Emit a warning line
+      def emit_warn(tag, message)
+        if options[:color]
+          $stderr.puts "  \e[1;33m%12s\e[0m %s" % [tag, message]
+        else
+          $stderr.puts "  %12s %s" % [tag, message]
+        end
+      end
+
+      # Emit an error line
+      def emit_error(tag, message)
+        if options[:color]
+          $stderr.puts "  \e[1;31m%12s\e[0m %s" % [tag, message]
+        else
+          $stderr.puts "  %12s %s" % [tag, message]
+        end
+      end
+
+      # Format a file size for display
+      def format_size(bytes)
+        if bytes >= 1024 * 1024
+          "%.1f MB" % (bytes / (1024.0 * 1024))
+        elsif bytes >= 1024
+          "%d KB" % (bytes / 1024)
+        else
+          "%d B" % bytes
+        end
+      end
+
+      def error(message)
+        $stderr.puts "Error: #{message}"
+        exit 1
+      end
+
+      def display_diagnostics(diagnostics)
+        return if diagnostics.empty?
+
+        renderer = Diagnostics::DiagnosticRenderer.new(
+          color: options[:color],
+          io: $stderr
+        )
+        renderer.render_all(diagnostics)
+      end
+
+      def display_dependency_error(error)
+        renderer = Diagnostics::DiagnosticRenderer.new(
+          color: options[:color],
+          io: $stderr
+        )
+
+        if error.cycle
+          span = if error.from_file
+            Diagnostics::SourceSpan.new(
+              file_path: error.from_file,
+              start_line: 1,
+              start_column: 0
+            )
+          end
+          diagnostic = Diagnostics::Diagnostic.circular_dependency(
+            cycle: error.cycle,
+            span: span
+          )
+          renderer.render(diagnostic)
+        elsif error.missing_file
+          span = if error.from_file
+            Diagnostics::SourceSpan.new(
+              file_path: error.from_file,
+              start_line: error.line || 1,
+              start_column: 0,
+              source: error.from_file && File.exist?(error.from_file) ? File.read(error.from_file) : nil
+            )
+          end
+          diagnostic = Diagnostics::Diagnostic.file_not_found(
+            path: error.missing_file,
+            span: span
+          )
+          renderer.render(diagnostic)
+        else
+          $stderr.puts "Error: #{error.message}"
+        end
+      end
+
+      def default_output_name(source_file, format: :cruby_ext, target: :native)
+        base = File.basename(source_file, ".rb")
+
+        if target == :jvm
+          "#{base}.jar"
+        else
+          case format
+          when :cruby_ext
+            "#{base}#{Platform.shared_lib_extension}"
+          when :standalone
+            base
+          else
+            "#{base}#{Platform.shared_lib_extension}"
+          end
+        end
+      end
+    end
+  end
+end