rubik 0.1.0

data/lib/rubik/repl/commands/agent_providers.rb

@@ -0,0 +1,232 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "../../llm"
+
+module Rubik
+  module REPL
+    module Commands
+      # Domain handler for LLM Providers and Endpoint management (Plan 60 D-6).
+      module AgentProviders
+        extend Base
+
+        # Whole-command synopsis: shared by the spine registration (usage:)
+        # and the unknown-subcommand fallback branch, so the two cannot drift.
+        USAGE_PROVIDER = "Usage: !provider <list | add <name> <type> <endpoint> | add-model <provider> <model> | " \
+                         "set-context <provider> <model> <limit> | remove-model <provider> <model> | " \
+                         "set <provider> <field> <val> | remove <name>> [--project|--global]"
+
+        def self.register(shell)
+          register_provider_command(shell)
+          register_providers_command(shell)
+        end
+
+        private_class_method def self.register_provider_command(shell)
+          shell.register_command("provider",
+                                 description: "Manage LLM providers and models: list | add <name> [type] <url> [--key=...] [--model=...] " \
+                                              "| add-model <provider> <model> [--context=LIMIT] | remove-model <provider> <model> | " \
+                                              "set <provider> <field> <val> | remove <provider>",
+                                 usage: USAGE_PROVIDER) do |args, ctx|
+            scope, clean_args = Base.parse_scope(args)
+            sub = clean_args.first&.downcase || "list"
+
+            case sub
+            when "list", "ls", "status"
+              render_provider_catalog(ctx)
+            when "add"
+              p_name = clean_args[1]&.downcase
+              arg2 = clean_args[2]
+              arg3 = clean_args[3]
+
+              p_type = "openai_compatible"
+              p_endpoint = nil
+
+              if arg2 && (arg2.start_with?("http://") || arg2.start_with?("https://"))
+                p_endpoint = arg2
+              elsif arg2 && arg3
+                p_type = arg2.downcase
+                p_endpoint = arg3
+              end
+
+              if p_name.nil? || p_name.empty? || p_endpoint.nil? || p_endpoint.empty?
+                ctx.out.puts "Usage: !provider add <name> [type] <endpoint_url> " \
+                             "[--key=API_KEY | --key-env=ENV_VAR] [--model=NAME] [--context=LIMIT] [--project|--global]"
+              elsif !p_endpoint.start_with?("http://") && !p_endpoint.start_with?("https://")
+                ctx.out.puts "Error: Endpoint must be a valid HTTP/HTTPS URL (starting with http:// or https://). " \
+                             "Received: '#{p_endpoint}'\nUsage: !provider add <name> [type] <endpoint_url> " \
+                             "[--key=API_KEY | --key-env=ENV_VAR] [--model=NAME] [--context=LIMIT] [--project|--global]"
+              else
+                key_arg = clean_args.find { |a| a.start_with?("--key=") || a.start_with?("--api-key=") }
+                key_env_arg = clean_args.find { |a| a.start_with?("--key-env=") }
+                model_arg = clean_args.find { |a| a.start_with?("--model=") }
+                context_arg = clean_args.find { |a| a.start_with?("--context=") }
+
+                api_key = key_arg&.split("=", 2)&.last
+                key_env = key_env_arg&.split("=", 2)&.last
+                m_name = model_arg ? model_arg.split("=", 2).last : "default"
+                c_limit = context_arg ? context_arg.split("=", 2).last.to_i : 32_768
+
+                normalized_endpoint = if ["openai_compatible", "openai"].include?(p_type)
+                                        Rubik::LLM::OpenAICompatibleProvider.normalize_endpoint(p_endpoint)
+                                      else
+                                        p_endpoint
+                                      end
+
+                p_spec = {
+                  "type" => p_type,
+                  "endpoint" => normalized_endpoint,
+                  "api_key" => api_key,
+                  "api_key_env" => key_env,
+                  "models" => [
+                    { "name" => m_name, "context_limit" => c_limit }
+                  ]
+                }.compact
+
+                res = ctx.config.set("providers.#{p_name}", p_spec, persist: scope)
+                ctx.refresh_llm_registry!
+                next if Base.report_persist_failure(ctx, res, scope)
+
+                ctx.out.puts "Successfully added provider '#{p_name}' (#{p_type} -> #{normalized_endpoint}) " \
+                             "with model '#{m_name}' [#{Base.scope_label(scope)}]."
+              end
+            when "add-model", "model-add"
+              p_name = clean_args[1]&.downcase
+              m_name = clean_args[2]
+              if p_name.nil? || p_name.empty? || m_name.nil? || m_name.empty?
+                ctx.out.puts "Usage: !provider add-model <provider_name> <model_name> [--context=LIMIT] [--project|--global]"
+              else
+                context_arg = clean_args.find { |a| a.start_with?("--context=") }
+                c_limit = context_arg ? context_arg.split("=", 2).last.to_i : 32_768
+
+                res = ctx.config.upsert_provider_model(p_name, m_name, context_limit: c_limit, persist: scope)
+                ctx.refresh_llm_registry!
+                if res[:ok]
+                  ctx.out.puts "Added model '#{m_name}' (#{c_limit} tokens) to provider '#{p_name}' [#{Base.scope_label(scope)}]."
+                elsif res[:reason] == :unknown_provider
+                  ctx.out.puts "Provider '#{p_name}' not found. Add it first via !provider add."
+                else
+                  Base.report_persist_failure(ctx, res, scope)
+                end
+              end
+            when "remove-model", "model-remove", "model-rm"
+              p_name = clean_args[1]&.downcase
+              m_name = clean_args[2]
+              if p_name.nil? || p_name.empty? || m_name.nil? || m_name.empty?
+                ctx.out.puts "Usage: !provider remove-model <provider_name> <model_name> [--project|--global]"
+              else
+                res = ctx.config.remove_provider_model(p_name, m_name, persist: scope)
+                ctx.refresh_llm_registry!
+                if res[:ok]
+                  ctx.out.puts "Removed model '#{m_name}' from provider '#{p_name}' [#{Base.scope_label(scope)}]."
+                elsif res[:reason] == :unknown_provider
+                  ctx.out.puts "Provider '#{p_name}' not found."
+                else
+                  Base.report_persist_failure(ctx, res, scope)
+                end
+              end
+            when "set"
+              p_name = clean_args[1]&.downcase
+              field = clean_args[2]&.downcase
+              val = clean_args[3]
+              if p_name.nil? || p_name.empty? || field.nil? || val.nil?
+                ctx.out.puts "Usage: !provider set <name> <endpoint|key|key-env|type|stream|stream_timeout|open_timeout|tool_native|num_ctx> <value> [--project|--global]"
+              else
+                p_spec = ctx.config.provider_spec(p_name)
+                if p_spec.nil?
+                  ctx.out.puts "Provider '#{p_name}' not found."
+                else
+                  case field
+                  when "key", "api_key"
+                    p_spec["api_key"] = val
+                  when "key-env", "key_env", "api_key_env"
+                    p_spec["api_key_env"] = val
+                  when "endpoint", "url", "host"
+                    if !val.start_with?("http://") && !val.start_with?("https://")
+                      ctx.out.puts "Error: Endpoint must be a valid HTTP/HTTPS URL (starting with http:// or https://). Received: '#{val}'"
+                      next
+                    end
+                    p_spec["endpoint"] = val
+                  when "type"
+                    p_spec["type"] = val
+                  else
+                    # Free-form fields (stream, tool_native, num_ctx, ...) are
+                    # typed through parse_scalar_value so "false" becomes a
+                    # real false — a raw "false" String is truthy in Ruby and
+                    # would silently re-enable the flag it means to disable.
+                    p_spec[field] = ctx.config.parse_scalar_value(val)
+                  end
+
+                  res = ctx.config.set("providers.#{p_name}", p_spec, persist: scope)
+                  ctx.refresh_llm_registry!
+                  next if Base.report_persist_failure(ctx, res, scope)
+
+                  ctx.out.puts "Updated provider '#{p_name}' field '#{field}' to '#{val}' [#{Base.scope_label(scope)}]."
+                end
+              end
+            when "remove", "rm", "delete"
+              p_name = clean_args[1]&.downcase
+              if p_name.nil? || p_name.empty?
+                ctx.out.puts "Usage: !provider remove <name> [--project|--global]"
+              else
+                res = ctx.config.remove_provider(p_name, persist: scope)
+                ctx.refresh_llm_registry!
+                if res[:ok]
+                  ctx.out.puts "Removed provider '#{p_name}' [#{Base.scope_label(scope)}]."
+                elsif res[:reason] == :unknown_provider
+                  ctx.out.puts "Provider '#{p_name}' not found."
+                else
+                  Base.report_persist_failure(ctx, res, scope)
+                end
+              end
+            when "set-context", "context", "limit"
+              p_name = clean_args[1]&.downcase
+              m_name = clean_args[2]
+              limit_val = clean_args[3]&.to_i
+              if p_name.nil? || p_name.empty? || m_name.nil? || m_name.empty? || limit_val.nil? || limit_val <= 0
+                ctx.out.puts "Usage: !provider set-context <provider> <model> <limit_in_tokens> [--project|--global]"
+              else
+                res = ctx.config.upsert_provider_model(p_name, m_name, context_limit: limit_val, persist: scope)
+                ctx.refresh_llm_registry!
+                if res[:ok]
+                  ctx.out.puts "Updated context limit for model '#{m_name}' on provider '#{p_name}' to #{limit_val} tokens [#{Base.scope_label(scope)}]."
+                elsif res[:reason] == :unknown_provider
+                  ctx.out.puts "Provider '#{p_name}' not found."
+                else
+                  Base.report_persist_failure(ctx, res, scope)
+                end
+              end
+            else
+              ctx.out.puts USAGE_PROVIDER
+            end
+          end
+        end
+
+        private_class_method def self.register_providers_command(shell)
+          shell.register_command("providers", description: "List all configured LLM providers, endpoints, and models", audience: :both) do |_args, ctx|
+            render_provider_catalog(ctx)
+          end
+        end
+
+        # Shared rendering for !provider list (human) and !providers (agent):
+        # same catalog, same pixels — only the audience differs. Pinned
+        # byte-for-byte by TestProviderCatalogRender.
+        private_class_method def self.render_provider_catalog(ctx)
+          cat = ctx.llm_registry.catalog
+          ctx.out.puts "=== Configured LLM Providers & Models ==="
+          cat.each do |p_name, info|
+            ctx.out.puts "\n• Provider: #{p_name.upcase} (#{info[:type]})"
+            ctx.out.puts "  Endpoint: #{info[:endpoint]}"
+            if info[:models].empty?
+              ctx.out.puts "  Models  : (Default / dynamically requested via model name)"
+            else
+              ctx.out.puts "  Models  :"
+              info[:models].each do |m|
+                ctx.out.puts "    - #{m[:name].ljust(35)} [Context: #{m[:context_limit]} tokens]"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubik/repl/commands/base.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Rubik
+  module REPL
+    module Commands
+      module Base
+        def self.parse_scope(args)
+          scope = if args.include?("--project") || args.include?("-p")
+                    :project
+                  elsif args.include?("--global") || args.include?("-g")
+                    :global
+                  else
+                    :session
+                  end
+          clean_args = args.reject { |a| ["--project", "-p", "--global", "-g", "--session", "-s"].include?(a) }
+          [scope, clean_args]
+        end
+
+        def self.scope_label(scope)
+          case scope
+          when :project
+            "Project level (.rubik/config.yml)"
+          when :global
+            "System level (~/.rubik/config.yml)"
+          else
+            "Session only"
+          end
+        end
+
+        # One honest line for a failed disk write; returns true when it fired
+        # so callers can step past their success report. The in-memory change
+        # stands — only persistence failed.
+        def self.report_persist_failure(ctx, res, scope)
+          return false if res.nil? || res[:ok]
+
+          ctx.out.puts "Error: could not save to #{scope_label(scope)}: #{res[:error]} " \
+                       "(change kept for this session only)."
+          true
+        end
+
+        def parse_scope(args)
+          Base.parse_scope(args)
+        end
+
+        def report_persist_failure(ctx, res, scope)
+          Base.report_persist_failure(ctx, res, scope)
+        end
+
+        def scope_label(scope)
+          Base.scope_label(scope)
+        end
+      end
+    end
+  end
+end

data/lib/rubik/repl/commands/buffer.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Rubik
+  module REPL
+    module Commands
+      module Buffer
+        extend Base
+
+        # Whole-command synopses: shared by the spine registration (usage:)
+        # and the empty-args / fallback branches that print them, so the two
+        # cannot drift.
+        USAGE_ROLLBACK = "Usage: !rollback <snapshot_id>"
+        USAGE_AUTOAPPLY = "Usage: !autoapply <manual | on_test | on_finish | always | status> [--project|--global]"
+
+        def self.register(shell)
+          shell.register_command(
+            "diff",
+            description: "Preview unapplied buffer changes (staged edits that are NOT yet on disk). " \
+                         "Scope: buffer only — never shows committed/git history. " \
+                         "For ground-truth file content, use read_file; for git history, use run_command with git. " \
+                         "(colorized viewer on terminals)",
+            audience: :both
+          ) do |args, ctx|
+            theme = ctx.theme
+            target_path = args.first
+            if target_path && !target_path.empty?
+              rel = begin
+                ctx.buffer_manager.sanitize_path(target_path)
+              rescue
+                target_path
+              end
+              if ctx.buffer_manager.dirty_files.key?(rel)
+                full_path = File.expand_path(rel, ctx.buffer_manager.root_dir)
+                orig_content = File.exist?(full_path) ? File.read(full_path) : ""
+                new_content = ctx.buffer_manager.read(rel) || ""
+                Rubik::UI::DiffViewer.render(ctx, theme, Rubik::Buffer::Diff.unified_diff(rel, orig_content, new_content))
+              else
+                ctx.out.puts "No unapplied buffer changes for '#{target_path}'."
+              end
+            else
+              diff_text = ctx.buffer_manager.diff_all
+              if diff_text.empty?
+                ctx.out.puts "No unapplied buffer changes."
+              else
+                Rubik::UI::DiffViewer.render(ctx, theme, diff_text)
+              end
+            end
+          end
+
+          shell.register_command("apply", description: "Apply dirty buffer changes to disk") do |args, ctx|
+            target_path = args.first
+            if target_path && !target_path.empty?
+              applied = ctx.buffer_manager.apply!(target_path)
+              conflicts = ctx.buffer_manager.last_conflicts || []
+              if applied.empty? && conflicts.empty?
+                ctx.out.puts "No unapplied buffer changes for '#{target_path}'."
+              else
+                ctx.sync_context_and_ast(applied) unless applied.empty?
+                ctx.out.puts "Applied changes to file: #{applied.first}" unless applied.empty?
+              end
+            else
+              applied = ctx.buffer_manager.apply!
+              conflicts = ctx.buffer_manager.last_conflicts || []
+              if applied.empty? && conflicts.empty?
+                ctx.out.puts "No unapplied buffer changes."
+              else
+                ctx.sync_context_and_ast(applied) unless applied.empty?
+                ctx.out.puts "Applied changes to #{applied.size} file(s): #{applied.join(', ')}" unless applied.empty?
+              end
+            end
+            conflicts.each do |c|
+              ctx.out.puts "[CONFLICT] #{c}: disk content changed since last read — skipped to prevent data loss. Re-read the file to resolve."
+            end
+          end
+
+          shell.register_command("undo", description: "Revert the last snapshot", audience: :both) do |_args, ctx|
+            if ctx.snapshot_store.undo(ctx.buffer_manager)
+              ctx.out.puts "Undo successful."
+            else
+              ctx.out.puts "No snapshots to undo."
+            end
+          end
+
+          shell.register_command("rollback", description: "Rollback to a specific snapshot ID", usage: USAGE_ROLLBACK, audience: :both) do |args, ctx|
+            sid = args.first
+            if sid.nil? || sid.empty?
+              ctx.out.puts USAGE_ROLLBACK
+            elsif ctx.snapshot_store.rollback(sid, ctx.buffer_manager)
+              ctx.out.puts "Rollback to snapshot #{sid} successful."
+            else
+              ctx.out.puts "Snapshot #{sid} not found."
+            end
+          end
+
+          shell.register_command("autoapply",
+                                 description: "Get or set buffer auto-apply policy (manual|on_test|on_finish|always)",
+                                 usage: USAGE_AUTOAPPLY, audience: :both) do |args, ctx|
+            scope, clean_args = Base.parse_scope(args)
+            sub = clean_args.first&.downcase
+
+            if sub.nil? || sub == "status"
+              cur = ctx.config.fetch("buffer.auto_apply", "manual")
+              can_m = ctx.config.fetch("buffer.model_can_apply", true)
+              ctx.out.puts "Buffer Auto-Apply Policy:"
+              ctx.out.puts "  • Mode             : #{cur} (manual | on_test | on_finish | always)"
+              ctx.out.puts "  • Model Can Apply  : #{can_m}"
+              ctx.out.puts "  • Prompt Indicator : #{ctx.config.fetch('buffer.prompt_indicator', true)}"
+              ctx.out.puts "  • Reminder Interval: #{ctx.config.fetch('buffer.reminder_interval', 3)} turns"
+            elsif ["manual", "on_test", "on_finish", "always"].include?(sub)
+              res = ctx.config.set("buffer.auto_apply", sub, persist: scope)
+              next if Base.report_persist_failure(ctx, res, scope)
+
+              ctx.out.puts "Buffer auto-apply policy set to '#{sub}' [#{Base.scope_label(scope)}]."
+            else
+              ctx.out.puts USAGE_AUTOAPPLY
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubik/repl/commands/dmesg.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Rubik
+  module REPL
+    module Commands
+      # REPL bang command (!dmesg) for inspecting kernel event ring buffer (Plan 102).
+      module Dmesg
+        extend Base
+
+        USAGE_DMESG = "Usage: !dmesg [-n <count>] [-l <level>] [-s <subsystem>] [--since <seq>] [clear]"
+
+        def self.register(shell)
+          handler = lambda do |args, ctx|
+            dmesg = resolve_dmesg(ctx)
+            unless dmesg
+              ctx.out.puts "Kernel dmesg ring buffer is not available."
+              return
+            end
+
+            if args.include?("clear") || args.include?("-c") || args.include?("--clear")
+              dmesg.clear!
+              ctx.out.puts "Kernel dmesg buffer cleared."
+              return
+            end
+
+            opts = parse_args(args)
+            records = dmesg.tail(opts[:limit], level: opts[:level], subsystem: opts[:subsystem], since_seq: opts[:since_seq])
+
+            if records.empty?
+              ctx.out.puts "Kernel dmesg log buffer is empty."
+            else
+              ctx.out.puts dmesg.formatted(records, color: false)
+            end
+          end
+
+          shell.register_command(
+            "dmesg",
+            description: "Display or filter kernel event ring buffer",
+            usage: USAGE_DMESG,
+            audience: :both,
+            &handler
+          )
+        end
+
+        def self.resolve_dmesg(ctx)
+          if ctx.respond_to?(:dmesg) && ctx.dmesg
+            ctx.dmesg
+          elsif ctx.respond_to?(:runtime_manager) && ctx.runtime_manager&.context
+            ctx.runtime_manager.context.get(:dmesg)
+          end
+        end
+
+        def self.parse_args(args)
+          opts = { limit: 50, level: nil, subsystem: nil, since_seq: nil }
+          i = 0
+          while i < args.size
+            arg = args[i]
+            case arg
+            when "-n", "--limit", "--count"
+              i += 1
+              opts[:limit] = args[i].to_i if args[i]
+            when "-l", "--level"
+              i += 1
+              opts[:level] = args[i] if args[i]
+            when "-s", "--subsystem"
+              i += 1
+              opts[:subsystem] = args[i] if args[i]
+            when "--since"
+              i += 1
+              opts[:since_seq] = args[i].to_i if args[i]
+            when /\A-n(\d+)\z/
+              opts[:limit] = ::Regexp.last_match(1).to_i
+            when /\A-l(.+)\z/
+              opts[:level] = ::Regexp.last_match(1)
+            when /\A-s(.+)\z/
+              opts[:subsystem] = ::Regexp.last_match(1)
+            end
+            i += 1
+          end
+          opts
+        end
+      end
+    end
+  end
+end