rubyn-code 0.2.2 → 0.4.0

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,128 @@ 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 --ide              Start IDE server (VS Code extension)
+          rubyn-code --permission-mode MODE  Set permission mode (default, accept_edits, plan_only, auto, dont_ask, bypass)
+          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, '--skip-setup' => :skip_setup, '--ide' => :ide }.freeze
+      VALUE_FLAGS = { '--permission-mode' => :permission_mode }.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 :ide     then run_ide
+        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[:command] = :ide if options[:ide]
+        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
+        elsif VALUE_FLAGS.key?(arg)
+          options[VALUE_FLAGS[arg]] = argv[idx + 1]
+          idx += 1
+        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
 
-      # 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 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
+
+      def default_daemon_options
+        {
           max_runs: 100,
           max_cost: 10.0,
           idle_timeout: 60,
@@ -86,33 +143,31 @@ module RubynCode
           agent_name: "golem-#{SecureRandom.hex(4)}",
           role: 'autonomous coding agent'
         }
+      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_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
+
+      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
@@ -141,11 +196,17 @@ module RubynCode
         puts response
       end
 
+      def run_ide
+        mode = resolve_permission_mode
+        IDE::Server.new(permission_mode: mode).run
+      end
+
       def run_daemon
         DaemonRunner.new(@options).run
       end
 
       def run_repl
+        maybe_first_run!
         REPL.new(
           session_id: @options[:session_id],
           project_root: Dir.pwd,
@@ -153,41 +214,25 @@ module RubynCode
         ).run
       end
 
+      def maybe_first_run!
+        return unless FirstRun.needed?
+        return if FirstRun.skipped?(skip_flag: @options[:skip_setup])
+
+        FirstRun.new.run
+      end
+
+      def resolve_permission_mode
+        if @options[:permission_mode]
+          @options[:permission_mode].to_sym
+        elsif @options[:yolo]
+          :bypass
+        else
+          :default
+        end
+      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/doctor.rb

@@ -14,6 +14,9 @@ module RubynCode
           check_auth
           check_skills
           check_project
+          check_mcp
+          check_codebase_index
+          check_skill_catalog
         ].freeze
 
         def execute(_args, ctx)
@@ -97,6 +100,76 @@ module RubynCode
           ['Project detected', true, "#{type} at #{ctx.project_root}"]
         end
 
+        def check_mcp(ctx)
+          config_path = File.join(ctx.project_root, MCP::Config::CONFIG_FILENAME)
+          return ['MCP connectivity', false, 'mcp.json not found'] unless File.exist?(config_path)
+
+          servers = MCP::Config.load(ctx.project_root)
+          return ['MCP connectivity', false, 'no servers configured'] if servers.empty?
+
+          reachable = servers.count { |s| mcp_server_reachable?(s) }
+          detail = "#{reachable}/#{servers.size} servers reachable"
+          ['MCP connectivity', reachable == servers.size, detail]
+        rescue StandardError => e
+          ['MCP connectivity', false, e.message]
+        end
+
+        def mcp_server_reachable?(server)
+          command = server[:command]
+          return false if command.nil? || command.empty?
+
+          # Check if the command binary exists on PATH
+          system("command -v #{command} > /dev/null 2>&1")
+        end
+
+        def check_codebase_index(ctx)
+          index_path = File.join(ctx.project_root, Index::CodebaseIndex::INDEX_DIR,
+                                 Index::CodebaseIndex::INDEX_FILE)
+          return ['Codebase index', false, 'index not found'] unless File.exist?(index_path)
+
+          mtime = File.mtime(index_path)
+          age_hours = ((Time.now - mtime) / 3600).round(1)
+          stale = age_hours > 24
+          detail = "#{age_hours}h old#{' (stale — consider reindexing)' if stale}"
+          ['Codebase index', !stale, detail]
+        rescue StandardError => e
+          ['Codebase index', false, e.message]
+        end
+
+        def check_skill_catalog(ctx)
+          catalog = ctx.skill_loader.catalog
+          entries = catalog.available
+          return ['Skill catalog', false, 'no skills found'] if entries.empty?
+
+          malformed = count_malformed_skills(catalog.skills_dirs)
+          detail = "#{entries.size} skills loaded"
+          detail += ", #{malformed} malformed" if malformed.positive?
+          ['Skill catalog', malformed.zero?, detail]
+        rescue StandardError => e
+          ['Skill catalog', false, e.message]
+        end
+
+        def count_malformed_skills(skills_dirs)
+          count = 0
+          skills_dirs.each do |dir|
+            next unless File.directory?(dir)
+
+            Dir.glob(File.join(dir, '**/*.md')).each do |path|
+              count += 1 unless valid_skill_file?(path)
+            end
+          end
+          count
+        end
+
+        def valid_skill_file?(path)
+          content = File.read(path, 1024, encoding: 'UTF-8')
+                        .encode('UTF-8', invalid: :replace, undef: :replace, replace: '')
+          doc = Skills::Document.parse(content, filename: path)
+          !doc.name.nil? && !doc.name.empty?
+        rescue StandardError
+          false
+        end
+
         def detect_project_type(root)
           return 'Rails' if File.exist?(File.join(root, 'config', 'application.rb'))
           return 'Ruby' if File.exist?(File.join(root, 'Rakefile'))

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

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module CLI
+    module Commands
+      class Mcp < Base
+        def self.command_name = '/mcp'
+        def self.description = 'MCP server status'
+
+        def execute(_args, ctx)
+          configs = load_configs(ctx.project_root)
+
+          if configs.empty?
+            ctx.renderer.info('No MCP servers configured.')
+            puts '  Add servers to .rubyn-code/mcp.json — see docs/MCP.md for details.'
+            return
+          end
+
+          ctx.renderer.info("MCP servers (#{configs.size}):")
+          puts
+
+          configs.each { |cfg| render_server(cfg) }
+        end
+
+        private
+
+        def load_configs(project_root)
+          MCP::Config.load(project_root)
+        end
+
+        def render_server(cfg)
+          client = build_client(cfg)
+          status, tool_count = probe_server(client)
+          icon = status_icon(status)
+          tools_label = tool_count ? " (#{tool_count} tools)" : ''
+
+          puts "  #{icon} #{cfg[:name]} [#{status}]#{tools_label}"
+          render_transport_info(cfg)
+        ensure
+          client&.disconnect! if client&.connected?
+        end
+
+        def build_client(cfg)
+          MCP::Client.from_config(cfg)
+        end
+
+        def probe_server(client)
+          client.connect!
+          tool_count = client.tools.size
+          [:connected, tool_count]
+        rescue StandardError
+          [:error, nil]
+        end
+
+        def render_transport_info(cfg)
+          if cfg[:url]
+            puts "    transport: SSE  url: #{cfg[:url]}"
+          else
+            puts "    transport: stdio  command: #{cfg[:command]} #{cfg[:args].join(' ')}".rstrip
+          end
+        end
+
+        def status_icon(status)
+          case status
+          when :connected then green('*')
+          when :error     then red('x')
+          else yellow('?')
+          end
+        end
+
+        def green(text)  = "\e[32m#{text}\e[0m"
+        def red(text)    = "\e[31m#{text}\e[0m"
+        def yellow(text) = "\e[33m#{text}\e[0m"
+      end
+    end
+  end
+end