rubik 0.3.4 → 0.3.5

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

@@ -110,99 +110,124 @@ module Rubik
           end
         end
 
+        private_class_method def self.handle_list_models(ctx)
+          mode = ctx.config.fetch("router.mode", "auto")
+          def_spec = ctx.config.model_spec(:default)
+          fast_spec = ctx.config.model_spec(:fast)
+          adv_spec = ctx.config.model_spec(:advanced)
+
+          def_limit = ctx.llm_registry.context_limit_for(def_spec["provider"], def_spec["name"])
+          fast_limit = ctx.llm_registry.context_limit_for(fast_spec["provider"], fast_spec["name"])
+          adv_limit = ctx.llm_registry.context_limit_for(adv_spec["provider"], adv_spec["name"])
+
+          def_ep = def_spec["endpoint"] || def_spec["host"] || "cloud"
+          fast_ep = fast_spec["endpoint"] || fast_spec["host"] || "cloud"
+          adv_ep = adv_spec["endpoint"] || adv_spec["host"] || "cloud"
+
+          ctx.out.puts "Model Router Configuration (Mode: #{mode}):"
+          ctx.out.puts "  • default  : #{def_spec['provider']}/#{def_spec['name']} [Context: #{def_limit} tokens] (#{def_ep})"
+          ctx.out.puts "  • fast     : #{fast_spec['provider']}/#{fast_spec['name']} [Context: #{fast_limit} tokens] (#{fast_ep})"
+          ctx.out.puts "  • advanced : #{adv_spec['provider']}/#{adv_spec['name']} [Context: #{adv_limit} tokens] (#{adv_ep})"
+          ctx.out.puts "Global Config  : #{ctx.config.global_config_path}"
+          ctx.out.puts "Project Config : #{ctx.config.project_config_path}"
+        end
+
+        private_class_method def self.handle_route_command(clean_args, ctx, scope)
+          mode = clean_args[1].to_s.downcase
+          if ["auto", "manual"].include?(mode)
+            res = ctx.config.set("router.mode", mode, persist: scope)
+            return if Base.report_persist_failure(ctx, res, scope)
+
+            ctx.out.puts "Router mode set to #{mode} [#{Base.scope_label(scope)}]."
+          else
+            ctx.out.puts "Usage: !model route <auto|manual>"
+          end
+        end
+
+        private_class_method def self.handle_add_model(clean_args, ctx, scope)
+          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: !model add <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 provider first via !provider add."
+            else
+              Base.report_persist_failure(ctx, res, scope)
+            end
+          end
+        end
+
+        private_class_method def self.handle_context_command(clean_args, ctx, scope)
+          if clean_args.size == 2 && clean_args[1] =~ /^\d+$/
+            def_spec = ctx.config.model_spec(:default)
+            update_context_limit(ctx, scope, def_spec["provider"], def_spec["name"],
+                                 clean_args[1].to_i, "default model #{def_spec['provider']}/#{def_spec['name']}")
+          elsif clean_args.size == 3 && ["default", "fast", "advanced"].include?(clean_args[1].downcase) && clean_args[2] =~ /^\d+$/
+            role = clean_args[1].downcase.to_sym
+            spec = ctx.config.model_spec(role)
+            update_context_limit(ctx, scope, spec["provider"], spec["name"],
+                                 clean_args[2].to_i, "#{role} model #{spec['provider']}/#{spec['name']}")
+          elsif clean_args.size == 4 && clean_args[3] =~ /^\d+$/
+            update_context_limit(ctx, scope, clean_args[1].downcase, clean_args[2],
+                                 clean_args[3].to_i, "#{clean_args[1].downcase}/#{clean_args[2]}")
+          else
+            ctx.out.puts "Usage: !model context <limit> | !model context <default|fast|advanced> <limit> | " \
+                         "!model context <provider> <model> <limit> [--project|--global]"
+          end
+        end
+
+        private_class_method def self.handle_set_role_command(clean_args, ctx, scope)
+          role = clean_args[1].to_s.downcase
+          model_args = clean_args[2..]
+          if model_args.nil? || model_args.empty?
+            ctx.out.puts "Usage: !model set <default|fast|advanced> [<provider>] <model_name> [--project|--global]"
+          else
+            prov, mod = parse_model_args(model_args, ctx)
+            res = ctx.config.set_model_spec(role, provider: prov, name: mod, persist: scope)
+            ctx.resync_llm_route!
+            return if Base.report_persist_failure(ctx, res, scope)
+
+            limit = ctx.llm_registry.context_limit_for(prov, mod)
+            ctx.out.puts "Set model role '#{role}' to #{prov}/#{mod} [Context: #{limit} tokens] [#{Base.scope_label(scope)}]."
+          end
+        end
+
+        private_class_method def self.handle_switch_default_model(clean_args, ctx, scope)
+          prov, mod = parse_model_args(clean_args, ctx)
+          res = ctx.config.set_model_spec(:default, provider: prov, name: mod, persist: scope)
+          ctx.resync_llm_route!
+          return if Base.report_persist_failure(ctx, res, scope)
+
+          limit = ctx.llm_registry.context_limit_for(prov, mod)
+          ctx.out.puts "Switched default model to #{prov}/#{mod} [Context: #{limit} tokens] [#{Base.scope_label(scope)}]."
+        end
+
         private_class_method def self.register_model_command(shell)
           shell.register_command("model",
                                  audience: :both,
                                  description: "Switch or view LLM provider/model roles (default, fast, advanced) with auto-persistence") do |args, ctx|
             scope, clean_args = Base.parse_scope(args)
-
-            if clean_args.empty? || clean_args.first.downcase == "list"
-              mode = ctx.config.fetch("router.mode", "auto")
-              def_spec = ctx.config.model_spec(:default)
-              fast_spec = ctx.config.model_spec(:fast)
-              adv_spec = ctx.config.model_spec(:advanced)
-
-              def_limit = ctx.llm_registry.context_limit_for(def_spec["provider"], def_spec["name"])
-              fast_limit = ctx.llm_registry.context_limit_for(fast_spec["provider"], fast_spec["name"])
-              adv_limit = ctx.llm_registry.context_limit_for(adv_spec["provider"], adv_spec["name"])
-
-              def_ep = def_spec["endpoint"] || def_spec["host"] || "cloud"
-              fast_ep = fast_spec["endpoint"] || fast_spec["host"] || "cloud"
-              adv_ep = adv_spec["endpoint"] || adv_spec["host"] || "cloud"
-
-              ctx.out.puts "Model Router Configuration (Mode: #{mode}):"
-              ctx.out.puts "  • default  : #{def_spec['provider']}/#{def_spec['name']} [Context: #{def_limit} tokens] (#{def_ep})"
-              ctx.out.puts "  • fast     : #{fast_spec['provider']}/#{fast_spec['name']} [Context: #{fast_limit} tokens] (#{fast_ep})"
-              ctx.out.puts "  • advanced : #{adv_spec['provider']}/#{adv_spec['name']} [Context: #{adv_limit} tokens] (#{adv_ep})"
-              ctx.out.puts "Global Config  : #{ctx.config.global_config_path}"
-              ctx.out.puts "Project Config : #{ctx.config.project_config_path}"
-            elsif clean_args.first.downcase == "route"
-              mode = clean_args[1].to_s.downcase
-              if ["auto", "manual"].include?(mode)
-                res = ctx.config.set("router.mode", mode, persist: scope)
-                next if Base.report_persist_failure(ctx, res, scope)
-
-                ctx.out.puts "Router mode set to #{mode} [#{Base.scope_label(scope)}]."
-              else
-                ctx.out.puts "Usage: !model route <auto|manual>"
-              end
-            elsif clean_args.first.downcase == "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: !model add <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 provider first via !provider add."
-                else
-                  Base.report_persist_failure(ctx, res, scope)
-                end
-              end
-            elsif ["context", "limit"].include?(clean_args.first.downcase)
-              if clean_args.size == 2 && clean_args[1] =~ /^\d+$/
-                def_spec = ctx.config.model_spec(:default)
-                update_context_limit(ctx, scope, def_spec["provider"], def_spec["name"],
-                                     clean_args[1].to_i, "default model #{def_spec['provider']}/#{def_spec['name']}")
-              elsif clean_args.size == 3 && ["default", "fast", "advanced"].include?(clean_args[1].downcase) && clean_args[2] =~ /^\d+$/
-                role = clean_args[1].downcase.to_sym
-                spec = ctx.config.model_spec(role)
-                update_context_limit(ctx, scope, spec["provider"], spec["name"],
-                                     clean_args[2].to_i, "#{role} model #{spec['provider']}/#{spec['name']}")
-              elsif clean_args.size == 4 && clean_args[3] =~ /^\d+$/
-                update_context_limit(ctx, scope, clean_args[1].downcase, clean_args[2],
-                                     clean_args[3].to_i, "#{clean_args[1].downcase}/#{clean_args[2]}")
-              else
-                ctx.out.puts "Usage: !model context <limit> | !model context <default|fast|advanced> <limit> | " \
-                             "!model context <provider> <model> <limit> [--project|--global]"
-              end
-            elsif clean_args.first.downcase == "set"
-              role = clean_args[1].to_s.downcase
-              model_args = clean_args[2..]
-              if model_args.nil? || model_args.empty?
-                ctx.out.puts "Usage: !model set <default|fast|advanced> [<provider>] <model_name> [--project|--global]"
-              else
-                prov, mod = parse_model_args(model_args, ctx)
-                res = ctx.config.set_model_spec(role, provider: prov, name: mod, persist: scope)
-                ctx.resync_llm_route!
-                next if Base.report_persist_failure(ctx, res, scope)
-
-                limit = ctx.llm_registry.context_limit_for(prov, mod)
-                ctx.out.puts "Set model role '#{role}' to #{prov}/#{mod} [Context: #{limit} tokens] [#{Base.scope_label(scope)}]."
-              end
+            subcmd = clean_args.first&.downcase
+
+            if clean_args.empty? || subcmd == "list"
+              handle_list_models(ctx)
+            elsif subcmd == "route"
+              handle_route_command(clean_args, ctx, scope)
+            elsif subcmd == "add"
+              handle_add_model(clean_args, ctx, scope)
+            elsif ["context", "limit"].include?(subcmd)
+              handle_context_command(clean_args, ctx, scope)
+            elsif subcmd == "set"
+              handle_set_role_command(clean_args, ctx, scope)
             else
-              prov, mod = parse_model_args(clean_args, ctx)
-              res = ctx.config.set_model_spec(:default, provider: prov, name: mod, persist: scope)
-              ctx.resync_llm_route!
-              next if Base.report_persist_failure(ctx, res, scope)
-
-              limit = ctx.llm_registry.context_limit_for(prov, mod)
-              ctx.out.puts "Switched default model to #{prov}/#{mod} [Context: #{limit} tokens] [#{Base.scope_label(scope)}]."
+              handle_switch_default_model(clean_args, ctx, scope)
             end
           end
         end

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

@@ -16,6 +16,14 @@ module Rubik
         USAGE_AUTOAPPLY = "Usage: !autoapply <manual | on_test | on_finish | always | status> [--project|--global]"
 
         def self.register(shell)
+          register_diff_command(shell)
+          register_apply_command(shell)
+          register_undo_command(shell)
+          register_rollback_command(shell)
+          register_autoapply_command(shell)
+        end
+
+        private_class_method def self.register_diff_command(shell)
           shell.register_command(
             "diff",
             description: "Preview unapplied buffer changes (staged edits that are NOT yet on disk). " \
@@ -23,111 +31,137 @@ module Rubik
                          "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
+          ) { |args, ctx| handle_diff(args, ctx) }
+        end
 
+        private_class_method def self.register_apply_command(shell)
           shell.register_command("apply", description: "Apply dirty buffer changes to disk") do |args, ctx|
-            target_path = args.first
-            begin
-              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
-            rescue Rubik::Buffer::ApplyFailedError => e
-              # Partial apply (issue #146): the report names what DID reach
-              # disk before the failure — a mixed outcome must not be
-              # presented as a plain success or a plain failure.
-              lines = Rubik::Buffer::ApplyContract.failure_lines(e, sync: ->(paths) { ctx.sync_context_and_ast(paths) })
-              ctx.out.puts "❌ #{lines.first}"
-              lines[1..].each { |line| ctx.out.puts line }
-            end
+            handle_apply(args, ctx)
           end
+        end
 
+        private_class_method def self.register_undo_command(shell)
           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
+            handle_undo(ctx)
           end
+        end
 
+        private_class_method def self.register_rollback_command(shell)
           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
+            handle_rollback(args, ctx)
           end
+        end
 
+        private_class_method def self.register_autoapply_command(shell)
           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)}]."
+            handle_autoapply(args, ctx)
+          end
+        end
+
+        private_class_method def self.handle_diff(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
-              ctx.out.puts USAGE_AUTOAPPLY
+              Rubik::UI::DiffViewer.render(ctx, theme, diff_text)
             end
           end
         end
+
+        private_class_method def self.handle_apply(args, ctx)
+          target_path = args.first
+          begin
+            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
+          rescue Rubik::Buffer::ApplyFailedError => e
+            # Partial apply (issue #146): the report names what DID reach
+            # disk before the failure — a mixed outcome must not be
+            # presented as a plain success or a plain failure.
+            lines = Rubik::Buffer::ApplyContract.failure_lines(e, sync: ->(paths) { ctx.sync_context_and_ast(paths) })
+            ctx.out.puts "❌ #{lines.first}"
+            lines[1..].each { |line| ctx.out.puts line }
+          end
+        end
+
+        private_class_method def self.handle_undo(ctx)
+          if ctx.snapshot_store.undo(ctx.buffer_manager)
+            ctx.out.puts "Undo successful."
+          else
+            ctx.out.puts "No snapshots to undo."
+          end
+        end
+
+        private_class_method def self.handle_rollback(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
+
+        private_class_method def self.handle_autoapply(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)
+            return 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