rubyn-code 0.1.0 → 0.2.0

data/lib/rubyn_code/cli/repl.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "readline"
+require 'reline'
 
 module RubynCode
   module CLI
@@ -14,13 +14,19 @@ module RubynCode
         @running = true
         @session_id = session_id
         @permission_tier = yolo ? :unrestricted : :allow_read
+        @plan_mode = false
 
-        setup_readline!
         setup_components!
+        setup_command_registry!
+        setup_readline!
       end
 
       def run
+        @version_check = VersionCheck.new(renderer: @renderer)
+        @version_check.start
+
         @renderer.welcome
+        @version_check.notify
 
         at_exit { shutdown! }
 
@@ -43,7 +49,7 @@ module RubynCode
             end
             @last_interrupt = now
             puts
-            @renderer.info("Press Ctrl-C again to exit, or type /quit")
+            @renderer.info('Press Ctrl-C again to exit, or type /quit')
           end
         end
 
@@ -52,6 +58,8 @@ module RubynCode
 
       private
 
+      # ── Component Setup ──────────────────────────────────────────────
+
       def setup_components!
         ensure_home_dir!
         @db = DB::Connection.instance
@@ -80,7 +88,7 @@ module RubynCode
         @tool_executor.db = @db
         @sub_agent_tool_count = 0
         @in_sub_agent = false
-        @tool_executor.on_agent_status = ->(type, msg) {
+        @tool_executor.on_agent_status = lambda { |type, msg|
           case type
           when :started
             @spinner.stop
@@ -113,7 +121,7 @@ module RubynCode
           budget_enforcer: @budget_enforcer,
           background_manager: @background_worker,
           stall_detector: @stall_detector,
-          on_tool_call: ->(name, params) {
+          on_tool_call: lambda { |name, params|
             @spinner.stop
             unless @streaming_first_chunk
               @stream_formatter&.flush
@@ -123,69 +131,138 @@ module RubynCode
             end
             @renderer.tool_call(name, params)
           },
-          on_tool_result: ->(name, result, is_error) {
-            unless @in_sub_agent
-              @renderer.tool_result(name, result)
-            end
-            @streaming_first_chunk = true
-            @spinner.start unless @in_sub_agent
+          on_tool_result: lambda { |name, result, _is_error = false|
+            @renderer.tool_result(name, result)
+            @spinner.start
           },
-          on_text: ->(text) {
+          on_text: lambda { |text|
+            @spinner.stop
             if @streaming_first_chunk
-              @spinner.stop
+              @stream_formatter = StreamFormatter.new
+              puts
               @streaming_first_chunk = false
-              @stream_formatter ||= StreamFormatter.new(@renderer)
             end
-            @spinner.stop if @spinner.spinning?
-            @stream_formatter.feed(text)
+            @stream_formatter&.feed(text)
           },
           skill_loader: @skill_loader,
           project_root: @project_root
         )
+      end
 
-        resume_session! if @session_id
+      # ── Command Registry ─────────────────────────────────────────────
+
+      def setup_command_registry!
+        @command_registry = Commands::Registry.new
+
+        # Register all commands
+        [
+          Commands::Help,
+          Commands::Quit,
+          Commands::Compact,
+          Commands::Cost,
+          Commands::Clear,
+          Commands::Undo,
+          Commands::Tasks,
+          Commands::Budget,
+          Commands::Skill,
+          Commands::Version,
+          Commands::Review,
+          Commands::Resume,
+          Commands::Spawn,
+          Commands::Doctor,
+          Commands::Tokens,
+          Commands::Plan,
+          Commands::ContextInfo,
+          Commands::Diff,
+          Commands::Model
+        ].each { |cmd| @command_registry.register(cmd) }
+
+        # Give Help access to the registry for listing commands
+        Commands::Help.registry = @command_registry
+
+        # Update input handler to use registry for parsing
+        @input_handler = InputHandler.new(command_registry: @command_registry)
       end
 
+      # ── Command Dispatch ─────────────────────────────────────────────
+
       def handle_command(command)
         case command.action
         when :quit
           @running = false
         when :message
           handle_message(command.args.first)
-        when :compact
-          handle_compact(command.args.first)
-        when :cost
-          handle_cost
-        when :clear
-          system("clear")
-        when :undo
-          @conversation.undo_last!
-          @renderer.info("Last exchange removed.")
-        when :help
-          display_help
-        when :tasks
-          handle_tasks
-        when :budget
-          handle_budget(command.args.first)
-        when :skill
-          handle_skill(command.args.first)
-        when :version
-          @renderer.info("Rubyn Code v#{RubynCode::VERSION}")
-        when :review
-          handle_review(command.args)
-        when :spawn_teammate
-          handle_spawn_teammate(command.args)
-        when :resume
-          handle_resume(command.args.first)
         when :empty
           nil
         when :list_commands
           display_commands
         when :unknown_command
           @renderer.warning("Unknown command: #{command.args.first}. Type / to see available commands.")
+        when :slash_command
+          dispatch_slash_command(command.args[0], command.args[1..])
         end
       end
 
+      def dispatch_slash_command(name, args)
+        ctx = build_context
+        result = @command_registry.dispatch(name, args, ctx)
+
+        case result
+        when :quit
+          @running = false
+        when :unknown
+          @renderer.warning("Unknown command: #{name}. Type / to see available commands.")
+        when Hash
+          handle_command_result(result)
+        end
+      end
+
+      def build_context
+        Commands::Context.new(
+          renderer: @renderer,
+          conversation: @conversation,
+          agent_loop: @agent_loop,
+          context_manager: @context_manager,
+          budget_enforcer: @budget_enforcer,
+          llm_client: @llm_client,
+          db: @db,
+          session_id: current_session_id,
+          project_root: @project_root,
+          skill_loader: @skill_loader,
+          session_persistence: @session_persistence,
+          background_worker: @background_worker,
+          permission_tier: @permission_tier,
+          plan_mode: @plan_mode,
+          message_handler: method(:handle_message)
+        )
+      end
+
+      # Handle structured results from commands that need to mutate REPL state
+      def handle_command_result(result)
+        case result
+        in { action: :set_budget, amount: Float => amount }
+          @budget_enforcer = Observability::BudgetEnforcer.new(
+            @db,
+            session_id: current_session_id,
+            session_limit: amount
+          )
+        in { action: :set_plan_mode, enabled: true | false => enabled }
+          @plan_mode = enabled
+          @agent_loop.plan_mode = enabled if @agent_loop.respond_to?(:plan_mode=)
+        in { action: :set_session_id, session_id: String => sid }
+          @session_id = sid
+        in { action: :set_model, model: String => model }
+          @llm_client.model = model if @llm_client.respond_to?(:model=)
+          @renderer.info("Model set to #{model}")
+        in { action: :spawn_teammate, name: String => name, role: String => role }
+          spawn_teammate(name, role)
+        else
+          # Unknown result hash — ignore
+        end
+      end
+
+      # ── Message Handling ─────────────────────────────────────────────
+
       def handle_message(input)
         @spinner.start
         @streaming_first_chunk = true
@@ -210,105 +287,9 @@ module RubynCode
         @renderer.error("Error: #{e.message}")
       end
 
-      def handle_compact(focus = nil)
-        @spinner.start("Compacting context...")
-        compactor = Context::Compactor.new(llm_client: @llm_client)
-        new_messages = compactor.manual_compact!(@conversation.messages, focus: focus)
-        @conversation.replace!(new_messages)
-        @spinner.success
-        @renderer.info("Context compacted. #{@conversation.length} messages remaining.")
-      end
-
-      def handle_cost
-        @renderer.cost_summary(
-          session_cost: @budget_enforcer.session_cost,
-          daily_cost: @budget_enforcer.daily_cost,
-          tokens: {
-            input: @context_manager.total_input_tokens,
-            output: @context_manager.total_output_tokens
-          }
-        )
-      end
-
-      def handle_tasks
-        task_manager = Tasks::Manager.new(@db)
-        tasks = task_manager.list
-        if tasks.empty?
-          @renderer.info("No tasks.")
-        else
-          tasks.each do |t|
-            status_color = case t[:status]
-                           when "completed" then :green
-                           when "in_progress" then :yellow
-                           when "blocked" then :red
-                           else :white
-                           end
-            puts "  [#{t[:status]}] #{t[:title]} (#{t[:id][0..7]})"
-          end
-        end
-      end
-
-      def handle_budget(amount)
-        if amount
-          @budget_enforcer = Observability::BudgetEnforcer.new(
-            @db,
-            session_id: current_session_id,
-            session_limit: amount.to_f
-          )
-          @renderer.info("Session budget set to $#{amount}")
-        else
-          @renderer.info("Remaining budget: $#{'%.4f' % @budget_enforcer.remaining_budget}")
-        end
-      end
-
-      def handle_skill(name)
-        if name
-          content = @skill_loader.load(name)
-          @renderer.info("Loaded skill: #{name}")
-          @conversation.add_user_message("<skill>#{content}</skill>")
-        else
-          @renderer.info("Available skills:")
-          puts @skill_loader.descriptions_for_prompt
-        end
-      end
-
-      def handle_resume(session_id)
-        if session_id
-          data = @session_persistence.load_session(session_id)
-          if data
-            @conversation.replace!(data[:messages])
-            @session_id = session_id
-            @renderer.info("Resumed session #{session_id[0..7]}")
-          else
-            @renderer.error("Session not found: #{session_id}")
-          end
-        else
-          sessions = @session_persistence.list_sessions(project_path: @project_root, limit: 10)
-          if sessions.empty?
-            @renderer.info("No previous sessions.")
-          else
-            sessions.each do |s|
-              puts "  #{s[:id][0..7]} | #{s[:title] || 'untitled'} | #{s[:created_at]}"
-            end
-          end
-        end
-      end
-
-      def handle_review(args)
-        base = args[0] || "main"
-        focus = args[1] || "all"
-        handle_message("Use the review_pr tool to review my current branch against #{base}. Focus: #{focus}. Load relevant best practice skills for any issues you find.")
-      end
-
-      def handle_spawn_teammate(args)
-        name = args[0]
-        unless name
-          @renderer.error("Usage: /spawn <name> [role]")
-          return
-        end
-
-        role = args[1] || "coder"
+      # ── Teammate Handling ────────────────────────────────────────────
 
+      def spawn_teammate(name, role)
         mailbox = Teams::Mailbox.new(@db)
         manager = Teams::Manager.new(@db, mailbox: mailbox)
         teammate = manager.spawn(name: name, role: role)
@@ -350,62 +331,46 @@ module RubynCode
           sleep 5
         end
       rescue StandardError => e
-        $stderr.puts "[Teammate #{teammate.name}] Error: #{e.message}" if ENV["RUBYN_DEBUG"]
+        RubynCode::Debug.agent("Teammate #{teammate.name} error: #{e.message}")
       end
 
+      # ── Display ──────────────────────────────────────────────────────
+
       def display_commands
-        @renderer.info("Available commands:")
-        CLI::InputHandler::SLASH_COMMANDS.each do |cmd, action|
-          puts "  #{cmd.ljust(15)} #{action}"
+        @renderer.info('Available commands:')
+        @command_registry.visible_commands.each do |cmd_class|
+          names = cmd_class.all_names.join(', ')
+          puts "  #{names.ljust(25)} #{cmd_class.description}"
         end
-        puts ""
+        puts
       end
 
-      def display_help
-        puts <<~HELP
-          Commands:
-            /help          Show this help message
-            /quit          Exit Rubyn Code
-            /compact       Compress conversation context
-            /cost          Show token usage and costs
-            /clear         Clear the terminal
-            /undo          Remove last exchange
-            /tasks         List all tasks
-            /budget [amt]  Show or set session budget
-            /skill [name]  Load a skill or list available skills
-            /resume [id]   Resume a session or list recent sessions
-            /version       Show version
-
-          Tips:
-            - Use @filename to include file contents in your message
-            - End a line with \\ for multiline input
-        HELP
-      end
+      # ── Readline ─────────────────────────────────────────────────────
 
       def setup_readline!
-        slash_commands = CLI::InputHandler::SLASH_COMMANDS.keys
+        completions = @command_registry.completions
 
-        Readline.completion_proc = proc do |input|
-          if input.start_with?("/")
-            slash_commands.select { |c| c.start_with?(input) }
+        Reline.completion_proc = proc do |input|
+          if input.start_with?('/')
+            completions.select { |c| c.start_with?(input) }
           else
             []
           end
         end
-        Readline.completion_append_character = " "
+        Reline.completion_append_character = ' '
       end
 
       def read_input
         lines = []
-        prompt_str = lines.empty? ? @renderer.prompt : "  ... "
+        prompt_str = lines.empty? ? @renderer.prompt : '  ... '
 
         loop do
-          line = Readline.readline(prompt_str, true)
+          line = Reline.readline(prompt_str, true)
           return nil if line.nil?
 
           if @input_handler.multiline?(line)
             lines << @input_handler.strip_continuation(line)
-            prompt_str = "  ... "
+            prompt_str = '  ... '
           else
             lines << line
             break
@@ -415,9 +380,11 @@ module RubynCode
         lines.join("\n")
       end
 
+      # ── Utilities ────────────────────────────────────────────────────
+
       def ensure_home_dir!
         dir = Config::Defaults::HOME_DIR
-        FileUtils.mkdir_p(dir) unless Dir.exist?(dir)
+        FileUtils.mkdir_p(dir)
       end
 
       def ensure_auth!
@@ -428,25 +395,25 @@ module RubynCode
           return true
         end
 
-        @renderer.error("No valid authentication found.")
-        @renderer.info("Options:")
-        @renderer.info("  1. Run Claude Code once to authenticate (Rubyn Code reads the keychain token)")
-        @renderer.info("  2. Set ANTHROPIC_API_KEY environment variable")
+        @renderer.error('No valid authentication found.')
+        @renderer.info('Options:')
+        @renderer.info('  1. Run Claude Code once to authenticate (Rubyn Code reads the keychain token)')
+        @renderer.info('  2. Set ANTHROPIC_API_KEY environment variable')
         @renderer.info("  3. Run 'rubyn-code --auth' to enter an API key")
         exit(1)
       end
 
       def skill_dirs
-        dirs = [File.expand_path("../../../skills", __dir__)]
-        project_skills = File.join(@project_root, ".rubyn-code", "skills")
+        dirs = [File.expand_path('../../../skills', __dir__)]
+        project_skills = File.join(@project_root, '.rubyn-code', 'skills')
         dirs << project_skills if Dir.exist?(project_skills)
-        user_skills = File.join(Config::Defaults::HOME_DIR, "skills")
+        user_skills = File.join(Config::Defaults::HOME_DIR, 'skills')
         dirs << user_skills if Dir.exist?(user_skills)
         dirs
       end
 
       def current_session_id
-        @session_id ||= SecureRandom.hex(16)
+        @current_session_id ||= SecureRandom.hex(16)
       end
 
       def save_session!
@@ -467,14 +434,14 @@ module RubynCode
       end
 
       GOODBYE_MESSAGES = [
-        "Freezing strings and saving memories... See ya! 💎",
-        "Memoizing this session... Until next time! 🧠",
-        "Committing learnings to memory... Later! 🤙",
-        "Saving state, yielding control... Bye for now! 👋",
-        "Session.save! && Rubyn.sleep... Catch you later! 😴",
-        "GC.start on this session... Stay Ruby, friend! ✌️",
+        'Freezing strings and saving memories... See ya! 💎',
+        'Memoizing this session... Until next time! 🧠',
+        'Committing learnings to memory... Later! 🤙',
+        'Saving state, yielding control... Bye for now! 👋',
+        'Session.save! && Rubyn.sleep... Catch you later! 😴',
+        "GC.start on this session... Stay Ruby, friend! ✌\uFE0F",
         "Writing instincts to disk... Don't forget me! 💾",
-        "at_exit { puts 'Thanks for coding with Rubyn!' } 🎸",
+        "at_exit { puts 'Thanks for coding with Rubyn!' } 🎸"
       ].freeze
 
       def shutdown!
@@ -485,21 +452,21 @@ module RubynCode
         puts
         @renderer.info(GOODBYE_MESSAGES.sample)
 
-        @renderer.info("Saving session...")
+        @renderer.info('Saving session...')
         save_session!
         @background_worker&.shutdown!
 
         if @conversation.length > 5
           begin
-            @renderer.info("Extracting learnings from this session...")
+            @renderer.info('Extracting learnings from this session...')
             Learning::Extractor.call(
               @conversation.messages,
               llm_client: @llm_client,
               project_path: @project_root
             )
-            @renderer.success("Instincts saved.")
+            @renderer.success('Instincts saved.')
           rescue StandardError => e
-            @renderer.warning("Instinct extraction skipped: #{e.message}") if ENV["RUBYN_DEBUG"]
+            RubynCode::Debug.warn("Instinct extraction skipped: #{e.message}")
           end
         end
 
@@ -510,7 +477,7 @@ module RubynCode
           # Silent — decay is best-effort
         end
 
-        @renderer.info("Session saved. Rubyn out. ✌️")
+        @renderer.info("Session saved. Rubyn out. ✌\uFE0F")
       rescue StandardError
         # Best effort on shutdown
       end

data/lib/rubyn_code/cli/setup.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+
+module RubynCode
+  module CLI
+    # Installs a pinned launcher that bypasses rbenv/rvm version switching.
+    #
+    # When rubyn-code is installed as a gem, RubyGems generates a wrapper in
+    # the Ruby version's bin dir (e.g. ~/.rbenv/versions/3.4.5/bin/rubyn-code)
+    # with a shebang pointing to the correct Ruby. However, rbenv's shim at
+    # ~/.rbenv/shims/rubyn-code intercepts the command and re-resolves Ruby
+    # based on .ruby-version in the current directory — which breaks rubyn-code
+    # when you cd into a project using a different Ruby.
+    #
+    # This setup creates a launcher in ~/.local/bin (which typically appears
+    # before ~/.rbenv/shims in PATH) that calls the gem wrapper directly,
+    # bypassing the shim entirely.
+    class Setup
+      INSTALL_DIR = File.expand_path('~/.local/bin')
+      LAUNCHER_NAME = 'rubyn-code'
+
+      def self.run
+        new.run
+      end
+
+      def run
+        gem_wrapper = find_gem_wrapper
+        unless gem_wrapper
+          warn 'Error: Could not find the rubyn-code gem wrapper.'
+          warn 'Make sure rubyn-code is installed: gem install rubyn-code'
+          exit 1
+        end
+
+        pinned_ruby = extract_ruby_from_wrapper(gem_wrapper)
+        unless pinned_ruby
+          warn "Error: Could not determine Ruby path from #{gem_wrapper}"
+          exit 1
+        end
+
+        launcher_path = File.join(INSTALL_DIR, LAUNCHER_NAME)
+
+        FileUtils.mkdir_p(INSTALL_DIR)
+        write_launcher(launcher_path, gem_wrapper, pinned_ruby)
+        File.chmod(0o755, launcher_path)
+
+        puts "Installed pinned launcher to #{launcher_path}"
+        puts "  Ruby:   #{pinned_ruby}"
+        puts "  Wrapper: #{gem_wrapper}"
+        puts
+
+        verify_path(launcher_path)
+      end
+
+      private
+
+      def find_gem_wrapper
+        # The gem wrapper lives in the same bin dir as the current Ruby
+        ruby_bin = RbConfig::CONFIG['bindir']
+        candidate = File.join(ruby_bin, LAUNCHER_NAME)
+        return candidate if File.exist?(candidate)
+
+        # Fallback: search gem paths
+        Gem.path.each do |gem_path|
+          bin = File.join(gem_path, 'bin', LAUNCHER_NAME)
+          return bin if File.exist?(bin)
+        end
+
+        nil
+      end
+
+      def extract_ruby_from_wrapper(wrapper_path)
+        first_line = File.open(wrapper_path, &:readline).strip
+        if first_line.start_with?('#!')
+          ruby_path = first_line.sub(/\A#!\s*/, '')
+          return ruby_path if File.executable?(ruby_path)
+        end
+
+        # Fallback to the Ruby running this process
+        RbConfig.ruby
+      rescue EOFError
+        nil
+      end
+
+      def write_launcher(path, gem_wrapper, pinned_ruby)
+        File.write(path, <<~BASH)
+          #!/usr/bin/env bash
+          # Rubyn Code launcher — pinned to Ruby #{File.basename(File.dirname(pinned_ruby, 2))}
+          # Generated by: rubyn-code --setup
+          # Bypasses rbenv/rvm so rubyn-code works in any project.
+          #
+          # To regenerate: rubyn-code --setup
+          # To remove:     rm #{path}
+          exec "#{gem_wrapper}" "$@"
+        BASH
+      end
+
+      def verify_path(launcher_path)
+        install_dir = File.dirname(launcher_path)
+        path_dirs = ENV['PATH'].split(File::PATH_SEPARATOR)
+        shim_index = path_dirs.index { |d| d.include?('rbenv/shims') || d.include?('rvm') }
+        install_index = path_dirs.index(install_dir)
+
+        if install_index.nil?
+          puts "Warning: #{install_dir} is not in your PATH."
+          puts 'Add this to your shell profile:'
+          puts "  export PATH=\"#{install_dir}:$PATH\""
+        elsif shim_index && install_index > shim_index
+          puts "Warning: #{install_dir} comes AFTER rbenv shims in PATH."
+          puts 'Move it before the shims in your shell profile so it takes priority.'
+        else
+          puts "PATH looks good — #{install_dir} takes priority over version manager shims."
+        end
+      end
+    end
+  end
+end