rubik 0.1.0

data/lib/rubik/config/store.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "yaml/store"
+require "fileutils"
+
+module Rubik
+  class Config
+    module Store
+      def global_config_path
+        File.join(@home_dir, ".rubik", "config.yml")
+      end
+
+      def project_config_path
+        dot_rubik_config = File.join(@root_dir, ".rubik", "config.yml")
+        return dot_rubik_config if File.exist?(dot_rubik_config)
+
+        root_rubik_yml = File.join(@root_dir, "rubik.yml")
+        return root_rubik_yml if File.exist?(root_rubik_yml)
+
+        dot_rubik_config
+      end
+
+      def store_for(scope = :project)
+        scope_sym = scope.to_s.downcase.to_sym
+        path = case scope_sym
+               when :project
+                 project_config_path
+               when :global
+                 global_config_path
+               else
+                 scope.to_s
+               end
+
+        @stores ||= {}
+        @stores[path] ||= begin
+          begin
+            FileUtils.mkdir_p(File.dirname(path))
+          rescue SystemCallError => e
+            warn "[WARN] Failed to create config directory #{File.dirname(path)}: #{e.message}" if ENV["RUBIK_DEBUG"]
+          end
+          YAML::Store.new(path, true)
+        end
+      end
+
+      def transaction(scope = :project, read_only: false, &)
+        store = store_for(scope)
+        store.transaction(read_only, &)
+      end
+
+      # Persists configuration to the targeted scope (:global or :project) on disk.
+      # Semantics of deep_merge: in-memory @data is deep_merged over disk YAML to keep
+      # unmanaged keys, while provider sections ("models"/"model") are overwritten to
+      # clear stale specs. Both source and merged data undergo schema validation.
+      # `deletions` are dot-paths removed from the merged snapshot after the merge —
+      # deep_merge deliberately keeps disk-only keys, so a nested delete must be
+      # replayed here or the disk copy would resurrect it.
+      def save!(scope = :global, deletions: [])
+        return self if scope.nil? || scope == false || scope.to_s.downcase == "session" || scope.to_s.downcase == "none"
+
+        scope_sym = scope.to_s.downcase.to_sym == :project ? :project : :global
+        target_path = scope_sym == :project ? project_config_path : global_config_path
+        begin
+          FileUtils.mkdir_p(File.dirname(target_path))
+        rescue SystemCallError
+          nil
+        end
+        store = store_for(scope_sym)
+
+        validation_error = nil
+        store.transaction do
+          # Read existing data on disk
+          existing = store.roots.to_h { |k| [k, store[k]] }
+          merged = deep_merge(existing, deep_stringify_keys(@data))
+
+          # Explicitly overwrite model and role specs so stale keys from prior providers are not retained
+          if @data["models"].is_a?(Hash)
+            merged["models"] ||= {}
+            @data["models"].each do |r_name, r_spec|
+              merged["models"][r_name.to_s] = deep_dup(r_spec)
+            end
+          end
+          merged["model"] = deep_dup(@data["model"]) if @data["model"].is_a?(Hash)
+
+          # Replay nested deletions so validate_schema sees what will be written.
+          # A blocked path means the deletion cannot reach disk and would
+          # silently resurrect on the next load — fail the save like a
+          # schema violation.
+          unapplied = Array(deletions).select { |path| deep_delete(merged, path) == :blocked }
+          validation_error = "could not apply deletion(s): #{unapplied.join(', ')}" if unapplied.any?
+
+          # Schema validation
+          unless validation_error
+            begin
+              validate_schema(@data)
+              validate_schema(merged)
+            rescue ArgumentError => e
+              validation_error = e.message
+            end
+          end
+          store.abort if validation_error
+
+          # Remove deleted roots
+          (store.roots - merged.keys).each { |r| store.delete(r) }
+
+          # Save merged entries
+          merged.each { |k, v| store[k] = v }
+        end
+
+        if validation_error
+          { ok: false, error: validation_error }
+        else
+          if File.exist?(target_path)
+            begin
+              File.chmod(0o600, target_path)
+            rescue
+              nil
+            end
+          end
+          { ok: true, path: target_path, scope: scope_sym }
+        end
+      rescue StandardError => e
+        { ok: false, error: e.message }
+      end
+
+      private
+
+      def ensure_rubik_directories
+        rubik_home = File.join(@home_dir, ".rubik")
+        ["snapshots", "sessions", "commands", "tools"].each do |sub|
+          FileUtils.mkdir_p(File.join(rubik_home, sub))
+        end
+      rescue SystemCallError => e
+        @warnings << "Could not create ~/.rubik directory: #{e.message}"
+      end
+
+      def load_yaml(path)
+        return {} unless File.exist?(path)
+
+        store = store_for(path)
+        data = store.transaction(true) do
+          store.roots.to_h { |root| [root, store[root]] }
+        end
+        data.is_a?(Hash) ? deep_stringify_keys(data) : {}
+      rescue Psych::Exception, SystemCallError => e
+        # Psych::Exception, not just SyntaxError: YAML::Store#load safe_loads
+        # without aliases or Date, so a hand-edited "x: 2026-01-01" raises
+        # Psych::DisallowedClass and must still boot with defaults + warning.
+        warn_msg = "Cannot load config because #{e.message}. To fix, verify valid YAML syntax in #{path}."
+        @warnings << warn_msg
+        {}
+      end
+    end
+  end
+end

data/lib/rubik/config.rb

@@ -0,0 +1,216 @@
+# frozen_string_literal: true
+
+require_relative "config/defaults"
+require_relative "config/deep_ops"
+require_relative "config/store"
+require_relative "config/model_catalog"
+
+module Rubik
+  class Config
+    include Defaults
+    include DeepOps
+    include Store
+    include ModelCatalog
+
+    DEFAULT_CONFIG = Defaults::DEFAULT_CONFIG
+
+    attr_reader :data, :warnings, :root_dir, :home_dir
+    attr_accessor :event_bus
+
+    def initialize(root_dir: Dir.pwd, home_dir: nil)
+      @root_dir = File.expand_path(root_dir)
+      effective_home = home_dir || (if Rubik.const_defined?(:Platform)
+                                      Rubik::Platform.home_dir
+                                    else
+                                      begin
+                                        Dir.home
+                                      rescue ArgumentError
+                                        (ENV["USERPROFILE"] || ENV["HOME"] || ".")
+                                      end
+                                    end)
+      @home_dir = File.expand_path(effective_home)
+      @warnings = []
+      @stores = {}
+      @listeners = []
+      @event_bus = nil
+      ensure_rubik_directories
+      @data = load_merged_config
+    end
+
+    def on_change(prefix = nil, &block)
+      return proc {} unless block_given?
+
+      norm_prefix = prefix&.to_s&.sub(/\.\z/, "")
+      entry = { prefix: norm_prefix, callback: block }
+      @listeners << entry
+      proc { @listeners.delete(entry) }
+    end
+
+    # Retrieves a configuration value by dot-separated key path.
+    def fetch(key, default = nil)
+      keys = key.to_s.split(".")
+      keys.reduce(@data) do |acc, k|
+        return default unless acc.is_a?(Hash) && acc.key?(k)
+
+        acc[k]
+      end
+    end
+
+    def [](key)
+      fetch(key)
+    end
+
+    # Sets a configuration value at a dot-separated key path, optionally
+    # persisting to disk. Returns the persist outcome — {ok: true, path:,
+    # scope:} after a disk write, {ok: true} for session-only changes,
+    # {ok: false, error:, reason: :persist_failed} when the write failed —
+    # so callers report honestly instead of assuming success.
+    def set(key, value, persist: nil)
+      old_val = fetch(key)
+      typed_val = parse_scalar_value(value)
+      keys = key.to_s.split(".")
+      last_key = keys.pop
+      target = keys.reduce(@data) do |acc, k|
+        acc[k] ||= {}
+        acc[k]
+      end
+      target[last_key] = typed_val
+
+      res = persisting?(persist) ? persist_result(save!(persist)) : { ok: true }
+      res[:reason] = :persist_failed unless res[:ok]
+      notify_change(key, typed_val, old_val) if old_val != typed_val
+      res
+    end
+
+    # Removes the dot-path key from configuration, persisting like set.
+    # Deleting an absent key is a successful no-op. Returns the persist
+    # outcome (see set); notifies no listener — deletion callers refresh
+    # the runtime explicitly.
+    def delete(key, persist: nil)
+      blocked = deep_delete(@data, key) == :blocked
+      return { ok: false, error: "cannot delete '#{key}': path traverses a non-hash value" } if blocked
+
+      res = persisting?(persist) ? persist_result(save!(persist, deletions: [key])) : { ok: true }
+      res[:reason] = :persist_failed unless res[:ok]
+      res
+    end
+
+    # True only for scopes save! writes to disk; nil/false/:session/"session"/
+    # "none" (downcased — save! itself is case-sensitive, this is not) never
+    # touch disk. Public so consumers wiring persist guards agree with Config.
+    def persisting?(scope)
+      return false if scope.nil? || scope == false
+
+      !["session", "none"].include?(scope.to_s.downcase)
+    end
+
+    def parse_scalar_value(val)
+      return val unless val.is_a?(String)
+
+      trimmed = val.strip
+      case trimmed.downcase
+      when "true" then true
+      when "false" then false
+      when "nil", "null" then nil
+      else
+        if (trimmed.start_with?("[") && trimmed.end_with?("]")) || (trimmed.start_with?("{") && trimmed.end_with?("}"))
+          begin
+            parsed = YAML.safe_load(trimmed, permitted_classes: [Symbol], aliases: true)
+            return parsed if parsed.is_a?(Array) || parsed.is_a?(Hash)
+          rescue Psych::Exception
+            # The whole safe_load failure family: SyntaxError for malformed
+            # input, DisallowedClass for e.g. "[2026-01-01]" (Date unpermitted),
+            # Alias errors — all mean "not a typed collection" → raw string.
+          end
+        end
+
+        if trimmed =~ /^-?\d+$/
+          trimmed.to_i
+        elsif trimmed =~ /^-?\d+\.\d+$/
+          trimmed.to_f
+        else
+          val
+        end
+      end
+    end
+
+    def model_spec(role = :default)
+      role_str = role.to_s.downcase
+      spec = fetch("models.#{role_str}")
+      return spec if spec.is_a?(Hash) && spec["provider"] && spec["name"]
+
+      {
+        "provider" => fetch("model.provider", "ollama"),
+        "name" => fetch("model.name", "qwen2.5-coder:7b"),
+        "endpoint" => fetch("model.endpoint") || fetch("model.host", "http://localhost:11434")
+      }
+    end
+
+    def verbosity
+      fetch("ui.verbosity") || fetch("agent.verbosity", "normal")
+    end
+
+    def verbosity_level
+      case verbosity.to_s.downcase.strip
+      when "quiet", "0" then 0
+      when "verbose", "2" then 2
+      when "debug", "trace", "3" then 3
+      else 1
+      end
+    end
+
+    private
+
+    # save! returns itself for no-write scopes; persist outcomes are hashes.
+    def persist_result(res)
+      res.is_a?(Hash) ? res : { ok: true }
+    end
+
+    def notify_change(key, new_val, old_val)
+      key_str = key.to_s
+      @listeners.dup.each do |entry|
+        prefix = entry[:prefix]
+        matches = prefix.nil? || prefix.empty? || key_str == prefix || key_str.start_with?("#{prefix}.")
+        next unless matches
+
+        begin
+          entry[:callback].call(key_str, new_val, old_val)
+        rescue StandardError => e
+          warn "[WARN] Config listener failed for '#{key_str}': #{e.message}"
+          @event_bus&.emit(:config_listener_error, key: key_str, error: e.message)
+        end
+      end
+      @event_bus&.emit(:config_changed, key: key_str, value: new_val, old_val: old_val)
+    end
+
+    def load_merged_config
+      global_file = global_config_path
+      project_file = project_config_path
+
+      global_config = load_yaml(global_file)
+      project_config = load_yaml(project_file)
+
+      merged = deep_merge(deep_dup(DEFAULT_CONFIG), global_config)
+      merged = deep_merge(merged, project_config)
+
+      # If global or project config explicitly defines model roles, ensure stale default hosts are not retained
+      [global_config, project_config].each do |cfg|
+        next unless cfg.is_a?(Hash)
+
+        if cfg["models"].is_a?(Hash)
+          cfg["models"].each do |role, spec|
+            if spec.is_a?(Hash) && spec["provider"] && spec["name"]
+              merged["models"] ||= {}
+              merged["models"][role.to_s] = deep_dup(spec)
+            end
+          end
+        end
+
+        merged["model"] = deep_dup(cfg["model"]) if cfg["model"].is_a?(Hash) && cfg["model"]["provider"] && cfg["model"]["name"]
+      end
+
+      validate_schema(merged)
+      merged
+    end
+  end
+end

data/lib/rubik/context/git_info.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require "open3"
+require "shellwords"
+
+module Rubik
+  module Context
+    class GitInfo
+      attr_reader :root_dir
+
+      def initialize(root_dir: Dir.pwd, process_runner: nil)
+        @root_dir = File.expand_path(root_dir)
+        @process_runner = process_runner || method(:default_runner)
+      end
+
+      def git_repo?
+        !git_dir.nil?
+      end
+
+      def active_branch
+        dir = git_dir
+        return nil unless dir
+
+        head_file = File.join(dir, "HEAD")
+        return nil unless File.exist?(head_file)
+
+        content = Rubik::Platform.read_text(head_file).strip
+        return nil if content.empty?
+
+        if content.start_with?("ref: refs/heads/")
+          content.sub("ref: refs/heads/", "")
+        else
+          content[0..6]
+        end
+      rescue SystemCallError, ArgumentError
+        # ArgumentError: expand_path over hostile .git-file content (NUL, bad tilde)
+        nil
+      end
+
+      def status
+        return { git: false } unless git_repo?
+
+        out, code = run_git("status --porcelain")
+        return { git: false } unless code.zero?
+
+        dirty = !out.strip.empty?
+        {
+          git: true,
+          branch: active_branch,
+          dirty: dirty
+        }
+      end
+
+      private
+
+      # The .git entry can be a directory (normal clone) or a FILE holding
+      # "gitdir: <path>" (linked worktree / submodule). Returns the directory
+      # that owns HEAD either way, or nil when the root is not a checkout.
+      def git_dir
+        dot_git = File.join(@root_dir, ".git")
+        if File.directory?(dot_git)
+          dot_git
+        elsif File.file?(dot_git)
+          target = Rubik::Platform.read_text(dot_git).strip.delete_prefix("gitdir:").strip
+          File.expand_path(target, @root_dir) unless target.empty?
+        end
+      rescue SystemCallError, ArgumentError
+        nil
+      end
+
+      def default_runner(cmd)
+        args = cmd.is_a?(Array) ? cmd : Shellwords.split(cmd.to_s)
+        out, status = Open3.capture2e("git", "-C", @root_dir, *args)
+        [out, status.exitstatus || 1]
+      rescue StandardError
+        ["", 1]
+      end
+
+      def run_git(cmd)
+        @process_runner.call(cmd)
+      end
+    end
+  end
+end

data/lib/rubik/context/git_lister.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "open3"
+
+module Rubik
+  module Context
+    # Fast file listing via `git ls-files` (C-speed walk + gitignore handling).
+    # Returns nil whenever git cannot answer (not a repo, spawn failure) so
+    # the caller falls back to its own walker — a missing git must degrade,
+    # never raise. Spawn is call-scoped: no persistent process, thread, or
+    # listener is kept alive.
+    module GitLister
+      module_function
+
+      # @return [Array<String>, nil] POSIX-style paths relative to root_dir,
+      #   or nil when git is unusable.
+      def files(root_dir)
+        out, _err, status = Open3.capture3(
+          "git", "-C", root_dir.to_s,
+          "ls-files", "-z", "--cached", "--others", "--exclude-standard"
+        )
+        return nil unless status.success?
+
+        out.split("\x00", -1).reject(&:empty?).map { |p| p.tr("\\", "/") }.uniq
+      rescue StandardError
+        nil
+      end
+
+      # Switch resolution shared with the scanner: ENV beats config, anything
+      # other than "off" (auto/on/unknown) attempts the fast path first.
+      def enabled?(config_value, env: ENV)
+        mode = env["RUBIK_NATIVE"] || config_value || "auto"
+        mode.to_s.strip.downcase != "off"
+      end
+    end
+  end
+end

data/lib/rubik/context/index.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+require "pathname"
+require_relative "scanner"
+
+module Rubik
+  module Context
+    class Index
+      attr_reader :root_dir, :files, :languages, :last_scan_time, :scanner
+
+      def initialize(root_dir: Dir.pwd, scanner: nil, additional_roots: [], includes: [], excludes: [], native: nil)
+        @root_dir = File.expand_path(root_dir)
+        # Serialises mutations to @files / @languages. The index is driven both
+        # by synchronous REPL turns and by an async background AST indexer, so
+        # without a shared lock concurrent incremental_scan / update_file /
+        # full_scan / detect_languages calls race on the same hash (ruby/ruby#
+        # 17006) and can corrupt it. Scanning itself is not changed — only the
+        # shared-state mutation is made thread-safe.
+        @mutex = Mutex.new
+        @scanner = scanner || Scanner.new(
+          root_dir: @root_dir,
+          additional_roots: additional_roots,
+          includes: includes,
+          excludes: excludes,
+          native: native
+        )
+        @files = {}
+        @languages = []
+        @last_scan_time = nil
+      end
+
+      def update_file_filters(includes: nil, excludes: nil)
+        @scanner.custom_includes = Array(includes).compact unless includes.nil?
+        @scanner.custom_excludes = Array(excludes).compact unless excludes.nil?
+        full_scan
+      end
+
+      def additional_roots
+        @scanner.additional_roots
+      end
+
+      def additional_roots=(roots)
+        @scanner.additional_roots = roots
+      end
+
+      def full_scan
+        start_time = Time.now
+        files = @scanner.scan
+        languages = @scanner.detect_languages(files)
+        @mutex.synchronize do
+          @files = files
+          @languages = languages
+          @last_scan_time = Time.now - start_time
+        end
+        @files
+      end
+
+      def incremental_scan
+        start_time = Time.now
+        snapshot = @mutex.synchronize { @files }
+        new_scan = @scanner.scan(snapshot)
+        old_files = snapshot
+
+        added = []
+        modified = []
+        deleted = []
+        unchanged = []
+
+        new_scan.each do |rel_path, info|
+          if old_files.key?(rel_path)
+            old_info = old_files[rel_path]
+            if old_info[:mtime] != info[:mtime] || old_info[:size] != info[:size] || old_info[:hash] != info[:hash]
+              modified << rel_path
+            else
+              unchanged << rel_path
+            end
+          else
+            added << rel_path
+          end
+        end
+
+        old_files.each_key do |rel_path|
+          deleted << rel_path unless new_scan.key?(rel_path)
+        end
+
+        languages = @scanner.detect_languages(new_scan)
+        @mutex.synchronize do
+          @files = new_scan
+          @languages = languages
+          @last_scan_time = Time.now - start_time
+        end
+
+        {
+          added: added,
+          modified: modified,
+          deleted: deleted,
+          unchanged: unchanged
+        }
+      end
+
+      def update_file(rel_path)
+        full_path = File.expand_path(rel_path, @root_dir)
+        unless File.file?(full_path)
+          return @mutex.synchronize do
+            @files.delete(rel_path)
+            false
+          end
+        end
+
+        info = @scanner.inspect_file(rel_path, full_path)
+        @mutex.synchronize do
+          old_info = @files[rel_path]
+          if old_info.nil? || old_info[:hash] != info[:hash]
+            @files[rel_path] = info
+            @languages = @scanner.detect_languages(@files)
+            true
+          else
+            false
+          end
+        end
+      end
+
+      def status_summary
+        @mutex.synchronize do
+          {
+            file_count: @files.size,
+            languages: @languages,
+            last_scan_time_sec: @last_scan_time&.round(4)
+          }
+        end
+      end
+    end
+  end
+end