rubik 0.1.0

data/lib/rubik/diagnostics/collector.rb

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+require_relative "entry"
+require_relative "parser"
+
+module Rubik
+  module Diagnostics
+    # Unified Diagnostic Fusion Engine (Plan 57 D-3).
+    # Fuses LSP compiler diagnostics, static analysis / linter outputs, and test
+    # runner error streams into a normalized, deduplicated, priority-ordered model.
+    class Collector
+      SEVERITY_ORDER = { error: 0, warning: 1, info: 2, hint: 3, unknown: 4 }.freeze
+      LSP_SEVERITY_MAP = { 1 => :error, 2 => :warning, 3 => :info, 4 => :hint }.freeze
+
+      attr_reader :root_dir, :lsp_manager
+
+      def initialize(lsp_manager: nil, root_dir: Dir.pwd)
+        @lsp_manager = lsp_manager
+        @root_dir = File.expand_path(root_dir)
+        @entries = []
+        @mutex = Mutex.new
+      end
+
+      # Clears all collected diagnostics
+      def clear!
+        @mutex.synchronize { @entries.clear }
+      end
+
+      # Adds a normalized Entry object
+      def add_entry(entry)
+        return unless entry.is_a?(Entry)
+
+        @mutex.synchronize { @entries << entry }
+      end
+
+      # Adds multiple Entry objects
+      def add_entries(entries)
+        return unless entries.is_a?(Array)
+
+        @mutex.synchronize do
+          entries.each { |e| @entries << e if e.is_a?(Entry) }
+        end
+      end
+
+      # Parses CLI compiler/linter output and adds entries
+      def add_parsed(output, lang: :unknown, source: :compiler) # rubocop:disable Lint/UnusedMethodArgument -- cagiran arayüzüyle uyum için source kwarg'i korunuyor
+        parsed = Parser.parse(output, lang)
+        @mutex.synchronize do
+          parsed.each do |e|
+            rel_file = normalize_rel_path(e.file)
+            @entries << Entry.new(
+              file: rel_file,
+              line: e.line,
+              col: e.col,
+              severity: e.severity || :error,
+              code: e.code,
+              message: e.message,
+              category: e.category,
+              raw_text: e.raw_text
+            )
+          end
+        end
+      end
+
+      # Ingests raw LSP diagnostics from a file path
+      def add_lsp_diagnostics(file_path, lsp_diags)
+        return if lsp_diags.nil? || lsp_diags.empty?
+
+        rel_file = normalize_rel_path(file_path)
+        @mutex.synchronize do
+          lsp_diags.each do |d|
+            start_pos = d.dig("range", "start") || {}
+            line = (start_pos["line"] || 0) + 1
+            col = (start_pos["character"] || 0) + 1
+            sev = LSP_SEVERITY_MAP[d["severity"]] || :error
+            cat = d["severity"] == 1 ? :type : :lint
+
+            @entries << Entry.new(
+              file: rel_file,
+              line: line,
+              col: col,
+              severity: sev,
+              code: d["code"],
+              message: d["message"].to_s.strip,
+              category: cat,
+              raw_text: d.to_s
+            )
+          end
+        end
+      end
+
+      # Harvests live diagnostics from the LSP manager across all active servers
+      def collect_lsp!(manager = @lsp_manager)
+        return [] unless manager.respond_to?(:all_diagnostics)
+
+        all_diags = manager.all_diagnostics
+        all_diags.each do |file_path, diags|
+          add_lsp_diagnostics(file_path, diags)
+        end
+        entries
+      end
+
+      # Returns deduplicated, priority-sorted list of entries
+      def entries(max_limit: 50)
+        @mutex.synchronize do
+          deduped = {}
+          @entries.each do |e|
+            key = [e.file, e.line, e.col, e.message]
+            existing = deduped[key]
+            deduped[key] = e if existing.nil? || SEVERITY_ORDER.fetch(e.severity, 4) < SEVERITY_ORDER.fetch(existing.severity, 4)
+          end
+
+          sorted = deduped.values.sort_by do |e|
+            [
+              SEVERITY_ORDER.fetch(e.severity, 4),
+              e.file.to_s,
+              e.line.to_i,
+              e.col.to_i
+            ]
+          end
+
+          sorted.first(max_limit)
+        end
+      end
+
+      def errors
+        entries.select { |e| e.severity == :error }
+      end
+
+      def warnings
+        entries.select { |e| e.severity == :warning }
+      end
+
+      def empty?
+        entries.empty?
+      end
+
+      def count
+        entries.size
+      end
+
+      def error_count
+        errors.size
+      end
+
+      def warning_count
+        warnings.size
+      end
+
+      # Formats diagnostics as an XML block for LLM prompt context
+      def format_for_context(max_limit: 30)
+        current = entries(max_limit: max_limit)
+        return "" if current.empty?
+
+        lines = ["<diagnostics>"]
+        current.each do |e|
+          loc = e.file ? " file=\"#{e.file}\"" : ""
+          loc += " line=\"#{e.line}\"" if e.line
+          loc += " col=\"#{e.col}\"" if e.col
+          lines << "  <issue severity=\"#{e.severity}\" category=\"#{e.category}\"#{loc}>#{escape_xml(e.message)}</issue>"
+        end
+        lines << "</diagnostics>"
+        lines.join("\n")
+      end
+
+      # Formats diagnostics for terminal/REPL display
+      def format_for_terminal
+        current = entries
+        return "No active compiler or linter diagnostics." if current.empty?
+
+        lines = ["Diagnostic Fusion Summary (#{error_count} error(s), #{warning_count} warning(s)):"]
+        current.each do |e|
+          icon = e.severity == :error ? "❌ [ERROR]" : "⚠️ [WARN]"
+          loc = e.file ? " #{e.file}:#{e.line || 1}" : ""
+          loc += ":#{e.col}" if e.col
+          lines << "  #{icon}#{loc} - #{e.message} (#{e.category})"
+        end
+        lines.join("\n")
+      end
+
+      private
+
+      def escape_xml(str)
+        str.to_s
+           .gsub("&", "&amp;")
+           .gsub("<", "&lt;")
+           .gsub(">", "&gt;")
+           .gsub('"', "&quot;")
+      end
+
+      def normalize_rel_path(path)
+        return nil if path.nil? || path.to_s.empty?
+
+        norm_path = path.to_s.tr("\\", "/")
+        norm_root = @root_dir.to_s.tr("\\", "/")
+        norm_path.sub(%r{^#{Regexp.escape(norm_root)}/}, "")
+      end
+    end
+  end
+end

data/lib/rubik/diagnostics/entry.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Rubik
+  module Diagnostics
+    class Entry
+      CATEGORIES = [:syntax, :type, :undefined_ref, :memory_safety, :test_failure, :lint, :unknown].freeze
+
+      attr_reader :file, :line, :col, :severity, :code, :message, :category, :raw_text
+
+      def initialize(file: nil, line: nil, col: nil, severity: :error, code: nil, message: "", category: :unknown, raw_text: "")
+        @file = file
+        @line = line&.to_i
+        @col = col&.to_i
+        @severity = severity.to_sym
+        @code = code
+        @message = message.to_s.strip
+        @category = CATEGORIES.include?(category.to_sym) ? category.to_sym : :unknown
+        @raw_text = raw_text
+      end
+
+      def to_h
+        {
+          file: @file,
+          line: @line,
+          col: @col,
+          severity: @severity,
+          code: @code,
+          message: @message,
+          category: @category
+        }
+      end
+
+      def format_prompt_snippet(_graph = nil, root_dir = Dir.pwd, buffer_manager = nil)
+        lines = []
+        lines << "Diagnostic [#{@category.upcase}]: #{@message}"
+        lines << "File: #{@file}:#{@line}:#{@col}" if @file && @line
+
+        file_content_str = if buffer_manager && @file
+                             buffer_manager.read(@file)
+                           elsif @file && File.exist?(File.join(root_dir, @file))
+                             File.read(File.join(root_dir, @file))
+                           end
+
+        if file_content_str && @line
+          file_lines = file_content_str.lines
+          start_line = [@line - 10, 0].max
+          end_line = [@line + 10, file_lines.size - 1].min
+
+          lines << "Context Snippet:"
+          (start_line..end_line).each do |idx|
+            prefix = (idx + 1) == @line ? "=> " : "   "
+            lines << "#{prefix}#{idx + 1}: #{file_lines[idx]}"
+          end
+        end
+
+        lines.join("\n")
+      end
+    end
+  end
+end

data/lib/rubik/diagnostics/parser.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require_relative "entry"
+
+module Rubik
+  module Diagnostics
+    class Parser
+      def self.parse(output, lang = :unknown)
+        new.parse(output, lang)
+      end
+
+      def parse(output, lang = :unknown)
+        text = output.to_s
+        return [Entry.new(message: "Empty compiler output", category: :unknown)] if text.strip.empty?
+
+        entries = []
+        entries = case lang.to_sym
+                  when :ruby
+                    parse_ruby(text)
+                  when :go
+                    parse_go(text)
+                  when :rust
+                    parse_rust(text)
+                  when :zig, :c
+                    parse_zig_c(text)
+                  else
+                    parse_generic(text)
+                  end
+
+        entries.empty? ? [Entry.new(message: text, category: :unknown, raw_text: text)] : entries
+      rescue StandardError => e
+        [Entry.new(message: "Parsing failed: #{e.message}\nRaw: #{text}", category: :unknown, raw_text: text)]
+      end
+
+      private
+
+      def parse_ruby(text)
+        entries = []
+        text.each_line do |line|
+          if (m = line.match(/^([^:]+):(\d+): (syntax error, unexpected .*)$/))
+            entries << Entry.new(file: m[1], line: m[2], message: m[3], category: :syntax, raw_text: line)
+          elsif (m = line.match(/Failure:\s*([^\n]+)/))
+            entries << Entry.new(message: m[1], category: :test_failure, raw_text: line)
+          end
+        end
+        entries
+      end
+
+      def parse_go(text)
+        entries = []
+        text.each_line do |line|
+          if (m = line.match(/^([^:]+):(\d+):(\d+):\s*(undefined:\s*.*)$/))
+            entries << Entry.new(file: m[1], line: m[2], col: m[3], message: m[4], category: :undefined_ref, raw_text: line)
+          elsif (m = line.match(/^([^:]+):(\d+):(\d+):\s*(.*)$/))
+            entries << Entry.new(file: m[1], line: m[2], col: m[3], message: m[4], category: :syntax, raw_text: line)
+          end
+        end
+        entries
+      end
+
+      def parse_rust(text)
+        entries = []
+        current_error = nil
+
+        text.each_line do |line|
+          if (m = line.match(/^error\[(E\d+)\]:\s*(.*)$/))
+            current_error = { code: m[1], message: m[2], category: :type }
+          elsif current_error && (m = line.match(/-->\s*([^:]+):(\d+):(\d+)/))
+            entries << Entry.new(
+              file: m[1],
+              line: m[2],
+              col: m[3],
+              code: current_error[:code],
+              message: current_error[:message],
+              category: current_error[:category],
+              raw_text: line
+            )
+            current_error = nil
+          end
+        end
+        entries
+      end
+
+      def parse_zig_c(text)
+        entries = []
+        text.each_line do |line|
+          next unless (m = line.match(/^([^:]+):(\d+):(\d+):\s*error:\s*(.*)$/))
+
+          msg = m[4]
+          cat = msg.include?("undeclared identifier") || msg.include?("use of undeclared") ? :undefined_ref : :syntax
+          entries << Entry.new(file: m[1], line: m[2], col: m[3], message: msg, category: cat, raw_text: line)
+        end
+        entries
+      end
+
+      def parse_generic(text)
+        entries = []
+        text.each_line do |line|
+          if (m = line.match(/^([^:\s]+):(\d+):(?:\d+:)?\s*(.*)$/))
+            entries << Entry.new(file: m[1], line: m[2], message: m[3], category: :unknown, raw_text: line)
+          end
+        end
+        entries
+      end
+    end
+  end
+end

data/lib/rubik/diagnostics.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require_relative "diagnostics/entry"
+require_relative "diagnostics/parser"
+require_relative "diagnostics/collector"
+
+module Rubik
+  module Diagnostics
+  end
+end

data/lib/rubik/event_bus.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require "logger"
+require_relative "kernel/dispatcher"
+
+module Rubik
+  # Event bus facade bridging to Rubik::Kernel::Dispatcher (Plan 103).
+  # Provides deterministic FIFO event processing, Dmesg integration, and fault isolation
+  # while maintaining 100% backward compatibility for subscribe, unsubscribe, emit, and drain!.
+  class EventBus
+    attr_reader :dispatcher
+
+    def initialize(dispatcher: nil, logger: Logger.new($stderr))
+      @logger = logger
+      @dispatcher = dispatcher || Rubik::Kernel::Dispatcher.new(logger: @logger)
+    end
+
+    def dispatcher=(new_dispatcher)
+      return if @dispatcher == new_dispatcher
+
+      old_dispatcher = @dispatcher
+      if old_dispatcher && new_dispatcher && old_dispatcher.respond_to?(:all_subscribers)
+        old_dispatcher.all_subscribers.each do |event_name, procs|
+          procs.each { |pr| new_dispatcher.subscribe(event_name, &pr) }
+        end
+      end
+      @dispatcher = new_dispatcher
+      old_dispatcher&.stop
+    end
+
+    def subscribe(event_name, context: nil, &)
+      @dispatcher.subscribe(event_name, context: context, &)
+    end
+
+    def unsubscribe(event_name, listener)
+      @dispatcher.unsubscribe(event_name, listener)
+    end
+
+    def post(event_name, payload = {}, subsystem: :kernel, level: :info, facility_id: nil, **)
+      @dispatcher.post(event_name, payload, subsystem: subsystem, level: level, facility_id: facility_id, **)
+    end
+
+    def emit(event_name, payload = {}, **)
+      post(event_name, payload, **)
+      drain!
+    end
+
+    def drain!(timeout = 2.0)
+      @dispatcher.sync_drain(timeout)
+    end
+
+    def stop(timeout = 2.0)
+      @dispatcher.stop(timeout)
+    end
+  end
+end

data/lib/rubik/kernel/dispatcher.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+require "monitor"
+
+module Rubik
+  module Kernel
+    # Deterministic sequential FIFO event dispatcher with worker queue (Plan 103).
+    # Backed by Thread::Queue and a dedicated kworker daemon.
+    # Dispatches events sequentially, logs to Dmesg ring buffer, and guarantees
+    # subscriber error isolation.
+    class Dispatcher
+      STOP_MARKER = :__dispatcher_stop__
+
+      Event = Struct.new(:name, :payload, :subsystem, :level, :facility_id, keyword_init: true)
+      Barrier = Struct.new(:queue)
+
+      attr_reader :dmesg, :worker_thread
+
+      def initialize(dmesg: nil, logger: nil)
+        @dmesg = dmesg
+        @logger = logger
+        @queue = Thread::Queue.new
+        @listeners = Hash.new { |h, k| h[k] = [] }
+        @lock = Monitor.new
+        @stopped = false
+        @worker_thread = Thread.new { process_queue }
+        @worker_thread.name = "rubik-kworker" if @worker_thread.respond_to?(:name=)
+      end
+
+      def post(event_name, payload = {}, subsystem: :kernel, level: :info, facility_id: nil, **kwargs)
+        return false if stopped?
+
+        eff_payload = if kwargs.empty?
+                        payload || {}
+                      elsif payload.is_a?(Hash)
+                        payload.merge(kwargs)
+                      else
+                        kwargs
+                      end
+
+        @queue.push(
+          Event.new(
+            name: event_name.to_sym, payload: eff_payload,
+            subsystem: subsystem.to_sym, level: level, facility_id: facility_id
+          )
+        )
+        true
+      end
+
+      def subscribe(event_name, context: nil, &block)
+        return unless block_given?
+
+        @lock.synchronize { @listeners[event_name.to_sym] << block }
+        context.on_dispose { unsubscribe(event_name, block) } if context.respond_to?(:on_dispose)
+        block
+      end
+
+      def unsubscribe(event_name_or_listener, listener = nil)
+        @lock.synchronize do
+          if listener.nil?
+            @listeners.each_value { |list| list.delete(event_name_or_listener) } if event_name_or_listener
+          elsif listener
+            @listeners[event_name_or_listener.to_sym].delete(listener)
+          end
+        end
+        nil
+      end
+
+      def sync_drain(timeout = 2.0)
+        return true if !worker_alive? || Thread.current == @worker_thread
+
+        barrier = Barrier.new(Thread::Queue.new)
+        @queue.push(barrier)
+        !barrier.queue.pop(timeout: timeout).nil?
+      end
+
+      def stop(timeout = 2.0)
+        @lock.synchronize do
+          return true if @stopped
+
+          @stopped = true
+        end
+
+        sync_drain(timeout) unless Thread.current == @worker_thread
+        @queue.push(STOP_MARKER)
+        if @worker_thread && Thread.current != @worker_thread
+          @worker_thread.join(timeout)
+          @worker_thread.kill if @worker_thread.alive?
+          @worker_thread = nil
+        end
+        true
+      end
+      alias dispose stop
+
+      def stopped?
+        @lock.synchronize { @stopped }
+      end
+
+      def alive?
+        !stopped? && worker_alive?
+      end
+
+      def worker_alive?
+        !@worker_thread.nil? && @worker_thread.alive?
+      end
+
+      def subscribers(event_name)
+        @lock.synchronize { @listeners[event_name.to_sym].dup }
+      end
+
+      def all_subscribers
+        @lock.synchronize { @listeners.transform_values(&:dup) }
+      end
+
+      def queue_size
+        @queue.size
+      end
+
+      private
+
+      def process_queue
+        loop do
+          item = @queue.pop
+          break if item == STOP_MARKER
+
+          if item.is_a?(Barrier)
+            item.queue.push(true)
+            next
+          end
+
+          dispatch_event(item)
+        rescue StandardError => e
+          @logger&.error("Dispatcher worker error: #{e.message}")
+        end
+      end
+
+      def dispatch_event(event)
+        log_to_dmesg(event)
+        listeners = @lock.synchronize { @listeners[event.name].dup }
+        listeners.each { |l| invoke_listener(l, event) }
+      end
+
+      def invoke_listener(listener, event)
+        listener.arity.zero? ? listener.call : listener.call(event.payload)
+      rescue StandardError => e
+        begin
+          @dmesg&.log(:kernel, :err, "Subscriber error on #{event.name}: #{e.message}")
+        rescue StandardError
+          nil
+        end
+        @logger&.error("EventBus subscriber error on event '#{event.name}': #{e.message}")
+      end
+
+      def log_to_dmesg(event)
+        return unless @dmesg
+
+        data = event.payload.is_a?(Hash) ? event.payload.dup : { value: event.payload }
+        fac_id = data.delete(:facility_id) || event.facility_id
+        safe_data = {}
+        data.each do |k, v|
+          safe_data[k.to_sym] = v
+        rescue StandardError
+          nil
+        end
+        @dmesg.log(event.subsystem, event.level, "event:#{event.name}", facility_id: fac_id, **safe_data)
+      rescue StandardError => e
+        @logger&.error("Dispatcher dmesg logging error: #{e.message}")
+      end
+    end
+  end
+end