rubyn-code 0.2.2 → 0.3.0

data/lib/rubyn_code/autonomous/idle_poller.rb

@@ -35,9 +35,9 @@ module RubynCode
           return :shutdown if monotonic_now >= deadline
 
           # Messages always take priority over tasks.
-          return :resume if has_pending_messages?
+          return :resume if pending_messages?
 
-          return :resume if has_claimable_task?
+          return :resume if claimable_task?
 
           remaining = deadline - monotonic_now
           return :shutdown if remaining <= 0
@@ -76,7 +76,7 @@ module RubynCode
       private
 
       # @return [Boolean]
-      def has_pending_messages?
+      def pending_messages?
         messages = @mailbox.pending_for(@agent_name)
         messages.is_a?(Array) ? !messages.empty? : false
       rescue StandardError
@@ -84,7 +84,7 @@ module RubynCode
       end
 
       # @return [Boolean]
-      def has_claimable_task?
+      def claimable_task?
         rows = @task_manager.db.query(<<~SQL).to_a
           SELECT 1 FROM tasks
           WHERE status = 'pending'

data/lib/rubyn_code/autonomous/task_claimer.rb

@@ -15,47 +15,9 @@ module RubynCode
       # @return [Tasks::Task, nil] the claimed task, or nil if none available
       def self.call(task_manager:, agent_name:)
         db = task_manager.db
-
-        # Atomically claim the first eligible task. The WHERE conditions
-        # ensure that only pending tasks with no current owner are touched,
-        # avoiding race conditions with other agents.
-        db.execute(<<~SQL, [agent_name])
-          UPDATE tasks
-          SET owner = ?,
-              status = 'in_progress',
-              updated_at = datetime('now')
-          WHERE id = (
-            SELECT id FROM tasks
-            WHERE status = 'pending'
-              AND (owner IS NULL OR owner = '')
-            ORDER BY priority DESC, created_at ASC
-            LIMIT 1
-          )
-          AND status = 'pending'
-          AND (owner IS NULL OR owner = '')
-        SQL
-
-        # Fetch the task we just claimed. Using owner + status filters
-        # ensures we only retrieve a task that *this* agent successfully
-        # claimed (another agent cannot have flipped it in between).
-        rows = db.query(<<~SQL, [agent_name]).to_a
-          SELECT id, session_id, title, description, status,
-                 priority, owner, result, metadata, created_at, updated_at
-          FROM tasks
-          WHERE owner = ?
-            AND status = 'in_progress'
-          ORDER BY updated_at DESC
-          LIMIT 1
-        SQL
-
-        return nil if rows.empty?
-
-        row = rows.first
-        build_task(row)
+        claim_next_pending_task(db, agent_name)
+        fetch_claimed_task(db, agent_name)
       rescue StandardError => e
-        # If anything goes wrong (e.g. task was already claimed between
-        # our SELECT and UPDATE, or a constraint violation) we treat it
-        # as "no work available" rather than crashing the daemon.
         RubynCode.logger.warn("TaskClaimer: failed to claim task: #{e.message}") if RubynCode.respond_to?(:logger)
         nil
       end
@@ -63,6 +25,40 @@ module RubynCode
       class << self
         private
 
+        def claim_next_pending_task(db, agent_name)
+          db.execute(<<~SQL, [agent_name])
+            UPDATE tasks
+            SET owner = ?,
+                status = 'in_progress',
+                updated_at = datetime('now')
+            WHERE id = (
+              SELECT id FROM tasks
+              WHERE status = 'pending'
+                AND (owner IS NULL OR owner = '')
+              ORDER BY priority DESC, created_at ASC
+              LIMIT 1
+            )
+            AND status = 'pending'
+            AND (owner IS NULL OR owner = '')
+          SQL
+        end
+
+        def fetch_claimed_task(db, agent_name)
+          rows = db.query(<<~SQL, [agent_name]).to_a
+            SELECT id, session_id, title, description, status,
+                   priority, owner, result, metadata, created_at, updated_at
+            FROM tasks
+            WHERE owner = ?
+              AND status = 'in_progress'
+            ORDER BY updated_at DESC
+            LIMIT 1
+          SQL
+
+          return nil if rows.empty?
+
+          build_task(rows.first)
+        end
+
         # @param row [Hash] a database row hash
         # @return [Tasks::Task]
         def build_task(row)

data/lib/rubyn_code/background/worker.rb

@@ -93,91 +93,79 @@ module RubynCode
       private
 
       def execute_job(job_id, command, timeout_seconds)
-        stdout, stderr, = nil
-        final_status = :completed
-
-        begin
-          stdin_io, stdout_io, stderr_io, wait_thr = Open3.popen3(command, chdir: @project_root)
-          stdin_io.close
-          out_buf = +''
-          err_buf = +''
-          out_reader = Thread.new do
-            out_buf << stdout_io.read
-          rescue StandardError
-            nil
-          end
-          err_reader = Thread.new do
-            err_buf << stderr_io.read
-          rescue StandardError
-            nil
-          end
+        stdout, stderr, final_status = run_process(command, timeout_seconds)
 
-          unless wait_thr.join(timeout_seconds)
-            begin
-              Process.kill('TERM', wait_thr.pid)
-            rescue StandardError
-              nil
-            end
-            sleep 0.1
-            begin
-              Process.kill('KILL', wait_thr.pid)
-            rescue StandardError
-              nil
-            end
-            wait_thr.join(5)
-            out_reader.join(2)
-            err_reader.join(2)
-            [stdout_io, stderr_io].each do |io|
-              io.close
-            rescue StandardError
-              nil
-            end
-            raise Timeout::Error
-          end
+        result = build_result(stdout, stderr)
+        completed_job = finalize_job(job_id, command, final_status, result)
 
-          out_reader.join(5)
-          err_reader.join(5)
-          [stdout_io, stderr_io].each do |io|
-            io.close
-          rescue StandardError
-            nil
-          end
+        @notifier.push({
+                         type: :job_completed, job_id: job_id,
+                         status: final_status, result: result,
+                         duration: completed_job.duration
+                       })
+      end
+
+      def run_process(command, timeout_seconds)
+        stdin_io, stdout_io, stderr_io, wait_thr = Open3.popen3(command, chdir: @project_root)
+        stdin_io.close
+        io_state = { stdout_io: stdout_io, stderr_io: stderr_io }
+        out_reader, err_reader, out_buf, err_buf = start_readers(stdout_io, stderr_io)
+        io_state.merge!(out_reader: out_reader, err_reader: err_reader)
+
+        handle_wait(wait_thr, timeout_seconds, io_state)
+
+        status = wait_thr.value.success? ? :completed : :error
+        [out_buf, err_buf, status]
+      rescue Timeout::Error
+        [nil, "Command timed out after #{timeout_seconds} seconds", :timeout]
+      rescue StandardError => e
+        [nil, e.message, :error]
+      end
 
-          stdout = out_buf
-          stderr = err_buf
-          process_status = wait_thr.value
-          final_status = process_status.success? ? :completed : :error
-        rescue Timeout::Error
-          final_status = :timeout
-          stdout = nil
-          stderr = "Command timed out after #{timeout_seconds} seconds"
-        rescue StandardError => e
-          final_status = :error
-          stdout = nil
-          stderr = e.message
+      def start_readers(stdout_io, stderr_io)
+        out_buf = +''
+        err_buf = +''
+        out_reader = Thread.new { out_buf << stdout_io.read rescue nil } # rubocop:disable Style/RescueModifier
+        err_reader = Thread.new { err_buf << stderr_io.read rescue nil } # rubocop:disable Style/RescueModifier
+        [out_reader, err_reader, out_buf, err_buf]
+      end
+
+      def handle_wait(wait_thr, timeout_seconds, io_state)
+        unless wait_thr.join(timeout_seconds)
+          kill_process(wait_thr)
+          cleanup_io(io_state)
+          raise Timeout::Error
         end
 
-        result = build_result(stdout, stderr)
-        completed_at = Time.now
+        cleanup_io(io_state)
+      end
+
+      def cleanup_io(io_state)
+        cleanup_readers(io_state[:out_reader], io_state[:err_reader],
+                        io_state[:stdout_io], io_state[:stderr_io])
+      end
+
+      def kill_process(wait_thr)
+        Process.kill('TERM', wait_thr.pid) rescue nil # rubocop:disable Style/RescueModifier
+        sleep 0.1
+        Process.kill('KILL', wait_thr.pid) rescue nil # rubocop:disable Style/RescueModifier
+        wait_thr.join(5)
+      end
+
+      def cleanup_readers(out_reader, err_reader, stdout_io, stderr_io)
+        out_reader.join(5)
+        err_reader.join(5)
+        [stdout_io, stderr_io].each { |io| io.close rescue nil } # rubocop:disable Style/RescueModifier
+      end
 
-        completed_job = @mutex.synchronize do
+      def finalize_job(job_id, command, final_status, result)
+        @mutex.synchronize do
           @jobs[job_id] = Job.new(
-            id: job_id,
-            command: command,
-            status: final_status,
-            result: result,
-            started_at: @jobs[job_id].started_at,
-            completed_at: completed_at
+            id: job_id, command: command, status: final_status,
+            result: result, started_at: @jobs[job_id].started_at,
+            completed_at: Time.now
           )
         end
-
-        @notifier.push({
-                         type: :job_completed,
-                         job_id: job_id,
-                         status: final_status,
-                         result: result,
-                         duration: completed_job.duration
-                       })
       end
 
       def build_result(stdout, stderr)

data/lib/rubyn_code/cli/app.rb

@@ -14,71 +14,120 @@ module RubynCode
 
       def run
         RubynCode::Debug.enable! if @options[:debug]
-
-        case @options[:command]
-        when :version
-          puts "rubyn-code #{RubynCode::VERSION}"
-        when :auth
-          run_auth
-        when :setup
-          run_setup
-        when :help
-          display_help
-        when :run
-          run_single_prompt(@options[:prompt])
-        when :daemon
-          run_daemon
-        when :repl
-          run_repl
-        end
+        dispatch_command(@options[:command])
       end
 
+      HELP_TEXT = <<~HELP
+        rubyn-code - Ruby & Rails Agentic Coding Assistant
+
+        Usage:
+          rubyn-code                    Start interactive REPL
+          rubyn-code -p "prompt"        Run a single prompt and exit
+          rubyn-code --resume [ID]      Resume a previous session
+          rubyn-code --setup            Pin rubyn-code to bypass rbenv/rvm
+          rubyn-code --auth             Authenticate with Claude
+          rubyn-code --version          Show version
+          rubyn-code --help             Show this help
+
+        Daemon Mode:
+          rubyn-code daemon             Start autonomous daemon (GOLEM)
+          rubyn-code daemon --name NAME Agent name (default: golem-<random>)
+          rubyn-code daemon --role ROLE Agent role description
+          rubyn-code daemon --max-runs N     Max tasks before shutdown (default: 100)
+          rubyn-code daemon --max-cost N     Max USD spend before shutdown (default: 10.0)
+          rubyn-code daemon --idle-timeout N Seconds idle before shutdown (default: 60)
+          rubyn-code daemon --poll-interval N Seconds between polls (default: 5)
+
+        Interactive Commands:
+          /help          Show available commands
+          /quit          Exit
+          /compact       Compress context
+          /cost          Show usage costs
+          /tasks         List tasks
+          /skill [name]  Load or list skills
+
+        Environment:
+          Config:  ~/.rubyn-code/config.yml
+          Data:    ~/.rubyn-code/rubyn_code.db
+          Tokens:  ~/.rubyn-code/tokens.yml
+      HELP
+
+      SIMPLE_FLAGS = {
+        '--version' => :version, '-v' => :version,
+        '--help' => :help, '-h' => :help,
+        '--auth' => :auth, '--setup' => :setup
+      }.freeze
+      BOOLEAN_FLAGS = { '--yolo' => :yolo, '--debug' => :debug }.freeze
+      DAEMON_INT_FLAGS = { '--max-runs' => :max_runs, '--idle-timeout' => :idle_timeout,
+                           '--poll-interval' => :poll_interval }.freeze
+      DAEMON_STR_FLAGS = { '--name' => :agent_name, '--role' => :role }.freeze
+
       private
 
-      def parse_options(argv) # rubocop:disable Metrics/MethodLength,Metrics/CyclomaticComplexity
+      def dispatch_command(command) # rubocop:disable Metrics/CyclomaticComplexity -- unavoidable dispatch switch
+        case command
+        when :version then puts "rubyn-code #{RubynCode::VERSION}"
+        when :auth    then run_auth
+        when :setup   then run_setup
+        when :help    then display_help
+        when :run     then run_single_prompt(@options[:prompt])
+        when :daemon  then run_daemon
+        when :repl    then run_repl
+        end
+      end
+
+      def parse_options(argv)
         options = { command: :repl }
+        idx = 0
+        while idx < argv.length
+          idx = parse_single_option(argv, idx, options)
+          idx += 1
+        end
+        options
+      end
 
-        i = 0
-        while i < argv.length
-          case argv[i]
-          when '--version', '-v'
-            options[:command] = :version
-          when '--help', '-h'
-            options[:command] = :help
-          when '--auth'
-            options[:command] = :auth
-          when '--resume', '-r'
-            options[:session_id] = argv[i + 1]
-            i += 1
-          when '-p', '--prompt'
-            options[:command] = :run
-            options[:prompt] = argv[i + 1]
-            i += 1
-          when '--yolo'
-            options[:yolo] = true
-          when '--debug'
-            options[:debug] = true
-          when '--setup'
-            options[:command] = :setup
-          when 'daemon'
-            options[:command] = :daemon
-            parse_daemon_options!(argv, i + 1, options)
-            break
-          end
-          i += 1
+      # -- option parser
+      def parse_single_option(argv, idx, options)
+        arg = argv[idx]
+        if SIMPLE_FLAGS.key?(arg)
+          options[:command] = SIMPLE_FLAGS[arg]
+        elsif BOOLEAN_FLAGS.key?(arg)
+          options[BOOLEAN_FLAGS[arg]] = true
+        else
+          idx = parse_value_option(argv, idx, options)
         end
+        idx
+      end
 
-        options
+      def parse_value_option(argv, idx, options)
+        case argv[idx]
+        when '--resume', '-r'
+          options[:session_id] = argv[idx + 1]
+          idx + 1
+        when '-p', '--prompt'
+          options[:command] = :run
+          options[:prompt] = argv[idx + 1]
+          idx + 1
+        when 'daemon'
+          options[:command] = :daemon
+          parse_daemon_options!(argv, idx + 1, options)
+          argv.length - 1
+        else
+          idx
+        end
+      end
+
+      def parse_daemon_options!(argv, start, options)
+        options[:daemon] = default_daemon_options
+        idx = start
+        while idx < argv.length
+          idx = parse_single_daemon_option(argv, idx, options)
+          idx += 1
+        end
       end
 
-      # Parses daemon-specific flags from the argv starting at the given index.
-      #
-      # @param argv [Array<String>]
-      # @param start [Integer]
-      # @param options [Hash]
-      # @return [void]
-      def parse_daemon_options!(argv, start, options) # rubocop:disable Metrics/MethodLength,Metrics/CyclomaticComplexity
-        options[:daemon] = {
+      def default_daemon_options
+        {
           max_runs: 100,
           max_cost: 10.0,
           idle_timeout: 60,
@@ -86,33 +135,31 @@ module RubynCode
           agent_name: "golem-#{SecureRandom.hex(4)}",
           role: 'autonomous coding agent'
         }
+      end
+
+      def parse_single_daemon_option(argv, idx, options)
+        case argv[idx]
+        when '--debug'
+          options[:debug] = true
+        else
+          idx = parse_daemon_value_option(argv, idx, options)
+        end
+        idx
+      end
 
-        i = start
-        while i < argv.length
-          case argv[i]
-          when '--max-runs'
-            options[:daemon][:max_runs] = argv[i + 1].to_i
-            i += 1
-          when '--max-cost'
-            options[:daemon][:max_cost] = argv[i + 1].to_f
-            i += 1
-          when '--idle-timeout'
-            options[:daemon][:idle_timeout] = argv[i + 1].to_i
-            i += 1
-          when '--poll-interval'
-            options[:daemon][:poll_interval] = argv[i + 1].to_i
-            i += 1
-          when '--name'
-            options[:daemon][:agent_name] = argv[i + 1]
-            i += 1
-          when '--role'
-            options[:daemon][:role] = argv[i + 1]
-            i += 1
-          when '--debug'
-            options[:debug] = true
-          end
-          i += 1
+      def parse_daemon_value_option(argv, idx, options) # rubocop:disable Metrics/AbcSize -- option dispatch with hash lookup
+        arg = argv[idx]
+        daemon = options[:daemon]
+        if DAEMON_INT_FLAGS.key?(arg)
+          daemon[DAEMON_INT_FLAGS[arg]] = argv[idx + 1].to_i
+        elsif arg == '--max-cost'
+          daemon[:max_cost] = argv[idx + 1].to_f
+        elsif DAEMON_STR_FLAGS.key?(arg)
+          daemon[DAEMON_STR_FLAGS[arg]] = argv[idx + 1]
+        else
+          return idx
         end
+        idx + 1
       end
 
       def run_auth
@@ -154,40 +201,7 @@ module RubynCode
       end
 
       def display_help
-        puts <<~HELP
-          rubyn-code - Ruby & Rails Agentic Coding Assistant
-
-          Usage:
-            rubyn-code                    Start interactive REPL
-            rubyn-code -p "prompt"        Run a single prompt and exit
-            rubyn-code --resume [ID]      Resume a previous session
-            rubyn-code --setup            Pin rubyn-code to bypass rbenv/rvm
-            rubyn-code --auth             Authenticate with Claude
-            rubyn-code --version          Show version
-            rubyn-code --help             Show this help
-
-          Daemon Mode:
-            rubyn-code daemon             Start autonomous daemon (GOLEM)
-            rubyn-code daemon --name NAME Agent name (default: golem-<random>)
-            rubyn-code daemon --role ROLE Agent role description
-            rubyn-code daemon --max-runs N     Max tasks before shutdown (default: 100)
-            rubyn-code daemon --max-cost N     Max USD spend before shutdown (default: 10.0)
-            rubyn-code daemon --idle-timeout N Seconds idle before shutdown (default: 60)
-            rubyn-code daemon --poll-interval N Seconds between polls (default: 5)
-
-          Interactive Commands:
-            /help          Show available commands
-            /quit          Exit
-            /compact       Compress context
-            /cost          Show usage costs
-            /tasks         List tasks
-            /skill [name]  Load or list skills
-
-          Environment:
-            Config:  ~/.rubyn-code/config.yml
-            Data:    ~/.rubyn-code/rubyn_code.db
-            Tokens:  ~/.rubyn-code/tokens.yml
-        HELP
+        puts HELP_TEXT
       end
     end
   end

data/lib/rubyn_code/cli/commands/model.rb

@@ -5,30 +5,87 @@ module RubynCode
     module Commands
       class Model < Base
         def self.command_name = '/model'
-        def self.description = 'Show or switch model (/model [name])'
-
-        KNOWN_MODELS = %w[
-          claude-haiku-4-5
-          claude-sonnet-4-20250514
-          claude-opus-4-20250514
-        ].freeze
+        def self.description = 'Show or switch model (/model [provider:model])'
 
         def execute(args, ctx)
           name = args.first
+          return show_current(ctx) unless name
+
+          provider, model = parse_model_arg(name)
+          switch_model(provider, model, ctx)
+        end
 
-          if name
-            unless KNOWN_MODELS.include?(name)
-              ctx.renderer.warning("Unknown model: #{name}")
-              ctx.renderer.info("Known models: #{KNOWN_MODELS.join(', ')}")
-              return
-            end
+        private
+
+        # Parse "provider:model" or just "model".
+        # Examples:
+        #   "openai:gpt-4o"            → ["openai", "gpt-4o"]
+        #   "claude-sonnet-4-20250514" → [nil, "claude-sonnet-4-20250514"]
+        #   "anthropic:"               → ["anthropic", nil]
+        def parse_model_arg(arg)
+          return [arg.chomp(':'), nil] if arg.end_with?(':')
+          return [Regexp.last_match(1), Regexp.last_match(2)] if arg.match(/\A([^:]+):(.+)\z/)
+
+          [nil, arg]
+        end
 
-            ctx.renderer.info("Model switched to #{name}")
-            { action: :set_model, model: name }
+        def switch_model(provider, model, ctx)
+          if provider
+            switch_provider_and_model(provider, model, ctx)
           else
-            current = Config::Defaults::DEFAULT_MODEL
-            ctx.renderer.info("Current model: #{current}")
-            ctx.renderer.info("Available: #{KNOWN_MODELS.join(', ')}")
+            switch_model_only(model, ctx)
+          end
+        end
+
+        def switch_provider_and_model(provider, model, ctx)
+          validate_model_for_provider!(provider, model, ctx) if model
+          ctx.renderer.info("Switched to provider: #{provider}#{", model: #{model}" if model}")
+          { action: :set_provider, provider: provider, model: model }
+        end
+
+        def switch_model_only(model, ctx)
+          unless known_model?(model, ctx)
+            ctx.renderer.warning("Unknown model: #{model}")
+            show_available(ctx)
+            return
+          end
+
+          ctx.renderer.info("Model switched to #{model}")
+          { action: :set_model, model: model }
+        end
+
+        def validate_model_for_provider!(provider, model, ctx)
+          adapter_models = models_for_provider(provider)
+          return if adapter_models.empty? # Unknown provider — can't validate
+          return if adapter_models.include?(model)
+
+          ctx.renderer.warning("Unknown model '#{model}' for #{provider}. Known: #{adapter_models.join(', ')}")
+        end
+
+        def show_current(ctx)
+          client = ctx.llm_client
+          provider = client.provider_name
+          current = client.model
+          ctx.renderer.info("Provider: #{provider}")
+          ctx.renderer.info("Current model: #{current}")
+          show_available(ctx)
+        end
+
+        def show_available(ctx)
+          client = ctx.llm_client
+          ctx.renderer.info("Available: #{client.models.join(', ')}")
+          ctx.renderer.info('Tip: /model provider:model to switch providers (e.g., /model openai:gpt-4o)')
+        end
+
+        def known_model?(model, ctx)
+          ctx.llm_client.models.include?(model)
+        end
+
+        def models_for_provider(provider)
+          case provider
+          when 'anthropic' then LLM::Adapters::Anthropic::AVAILABLE_MODELS
+          when 'openai' then LLM::Adapters::OpenAI::AVAILABLE_MODELS
+          else []
           end
         end
       end