rubyn-code 0.3.0 → 0.4.0

data/lib/rubyn_code/auth/token_store.rb

@@ -7,7 +7,7 @@ require 'time'
 
 module RubynCode
   module Auth
-    module TokenStore
+    module TokenStore # rubocop:disable Metrics/ModuleLength -- single-responsibility credential store
       EXPIRY_BUFFER_SECONDS = 300 # 5 minutes
       KEYCHAIN_SERVICE = 'Claude Code-credentials'
 
@@ -21,25 +21,44 @@ module RubynCode
         end
 
         # Load API key for a given provider. Anthropic uses the full fallback chain.
+        # Other providers: stored key → env var.
         def load_for_provider(provider)
           return load if provider == 'anthropic'
 
+          stored = load_provider_key(provider)
+          return { access_token: stored, type: :api_key, source: :stored } if stored
+
           env_key = resolve_env_key(provider)
           api_key = ENV.fetch(env_key, nil)
           api_key&.empty? == false ? { access_token: api_key, type: :api_key, source: :env } : nil
         end
 
-        def save(access_token:, refresh_token:, expires_at:)
+        # Store an API key for a provider in tokens.yml (encrypted at rest).
+        def save_provider_key(provider, key)
           ensure_directory!
+          data = load_tokens_file || {}
+          data['provider_keys'] ||= {}
+          data['provider_keys'][provider.to_s] = KeyEncryption.encrypt(key)
+          write_tokens_file(data)
+        end
 
-          data = {
-            'access_token' => access_token,
-            'refresh_token' => refresh_token,
-            'expires_at' => expires_at.is_a?(Time) ? expires_at.iso8601 : expires_at.to_s
-          }
+        # Retrieve a stored API key for a provider (decrypted transparently).
+        def load_provider_key(provider)
+          data = load_tokens_file
+          value = data&.dig('provider_keys', provider.to_s)
+          return nil unless value
 
-          File.write(tokens_path, YAML.dump(data))
-          File.chmod(0o600, tokens_path)
+          migrate_plaintext_key!(data, provider, value) unless KeyEncryption.encrypted?(value)
+          KeyEncryption.decrypt(value)
+        end
+
+        def save(access_token:, refresh_token:, expires_at:)
+          ensure_directory!
+          data = load_tokens_file || {}
+          data['access_token'] = access_token
+          data['refresh_token'] = refresh_token
+          data['expires_at'] = expires_at.is_a?(Time) ? expires_at.iso8601 : expires_at.to_s
+          write_tokens_file(data)
           data
         end
 
@@ -118,6 +137,28 @@ module RubynCode
           { access_token: api_key, refresh_token: nil, expires_at: nil, type: :api_key, source: :env }
         end
 
+        def write_tokens_file(data)
+          File.write(tokens_path, YAML.dump(data))
+          File.chmod(0o600, tokens_path)
+        end
+
+        # Auto-encrypt a plaintext key from a pre-encryption install.
+        def migrate_plaintext_key!(data, provider, plaintext)
+          data['provider_keys'][provider.to_s] = KeyEncryption.encrypt(plaintext)
+          write_tokens_file(data)
+        rescue StandardError
+          nil # don't break reads if migration fails
+        end
+
+        def load_tokens_file
+          return nil unless File.exist?(tokens_path)
+
+          data = YAML.safe_load_file(tokens_path, permitted_classes: [Time])
+          data.is_a?(Hash) ? data : nil
+        rescue Psych::SyntaxError, Errno::EACCES
+          nil
+        end
+
         def tokens_path = Config::Defaults::TOKENS_FILE
 
         def ensure_directory!

data/lib/rubyn_code/autonomous/daemon.rb

@@ -14,8 +14,9 @@ module RubynCode
     #
     # Unlike the REPL, the daemon runs a full Agent::Loop per task — meaning
     # it can read files, write code, run specs, and use every tool available.
-    class Daemon
+    class Daemon # rubocop:disable Metrics/ClassLength -- daemon lifecycle + retry + audit + cost
       LIFECYCLE_STATES = %i[spawned working idle shutting_down stopped].freeze
+      MAX_TASK_RETRIES = 3
 
       attr_reader :agent_name, :role, :state, :runs_completed, :total_cost
 
@@ -32,14 +33,17 @@ module RubynCode
       # @param on_state_change [Proc, nil] callback invoked with (old_state, new_state)
       # @param on_task_complete [Proc, nil] callback invoked with (task, result_text)
       # @param on_task_error [Proc, nil] callback invoked with (task, error)
+      # @param session_persistence [Memory::SessionPersistence, nil] optional audit trail persistence
       def initialize( # rubocop:disable Metrics/ParameterLists
         agent_name:, role:, llm_client:, project_root:, task_manager:, mailbox:,
         max_runs: 100, max_cost: 10.0, poll_interval: 5, idle_timeout: 60,
-        on_state_change: nil, on_task_complete: nil, on_task_error: nil
+        on_state_change: nil, on_task_complete: nil, on_task_error: nil,
+        session_persistence: nil
       )
         assign_core_attrs(agent_name:, role:, llm_client:, project_root:, task_manager:, mailbox:)
         assign_limits(max_runs:, max_cost:, poll_interval:, idle_timeout:)
         assign_callbacks_and_state(on_state_change, on_task_complete, on_task_error)
+        @session_persistence = session_persistence
       end
 
       # Enters the work-idle-work cycle. Blocks the calling thread until
@@ -153,16 +157,18 @@ module RubynCode
         agent_loop = build_agent_loop
         result_text = agent_loop.send_message(build_work_prompt(task))
 
-        # Accumulate cost from the budget enforcer
-        track_cost_from_enforcer(agent_loop)
+        # Accumulate cost via CostCalculator using actual token counts
+        track_cost_from_context_manager(agent_loop)
 
         # Mark the task as completed with the agent's result.
         @task_manager.complete(task.id, result: result_text)
+
+        # Persist conversation as an audit trail
+        persist_session_audit(task, agent_loop)
+
         @on_task_complete&.call(task, result_text)
       rescue StandardError => e
-        # On failure, release the task so another agent (or retry) can pick it up.
-        @task_manager.update(task.id, status: 'pending', owner: nil, result: "Error: #{e.message}")
-        @on_task_error&.call(task, e)
+        handle_task_error(task, e)
       end
 
       # Builds a fresh Agent::Loop wired with all the real tools.
@@ -192,19 +198,116 @@ module RubynCode
         )
       end
 
-      # Accumulates cost tracked by the Agent::Loop's context manager.
+      # Computes USD cost from the context manager's token counts using
+      # Observability::CostCalculator. The old approach checked for a
+      # `total_cost` method that never existed on Context::Manager, so
+      # @total_cost was always 0.0 and the max_cost safety limit never fired.
       #
       # @param agent_loop [Agent::Loop]
       # @return [void]
-      def track_cost_from_enforcer(agent_loop)
-        # The context manager tracks token usage; we extract cost if available.
-        # This is best-effort — the daemon's own total_cost is an approximation.
+      def track_cost_from_context_manager(agent_loop)
         cm = agent_loop.instance_variable_get(:@context_manager)
-        return unless cm.respond_to?(:total_cost)
+        return unless cm
+
+        tokens = extract_token_counts(cm)
+        return if tokens.values.all?(&:zero?)
+
+        model = @llm_client.respond_to?(:model) ? @llm_client.model : 'claude-sonnet-4-6'
+        @total_cost += Observability::CostCalculator.calculate(model: model, **tokens)
+      rescue StandardError
+        # Non-critical — cost tracking is best-effort
+      end
+
+      # @param context_mgr [Context::Manager]
+      # @return [Hash] :input_tokens, :output_tokens
+      def extract_token_counts(context_mgr)
+        {
+          input_tokens: context_mgr.respond_to?(:total_input_tokens) ? context_mgr.total_input_tokens.to_i : 0,
+          output_tokens: context_mgr.respond_to?(:total_output_tokens) ? context_mgr.total_output_tokens.to_i : 0
+        }
+      end
+
+      # Handles a task error with retry backoff. Increments the retry count
+      # in the task's metadata. After MAX_TASK_RETRIES, marks the task as
+      # failed instead of releasing it back to pending.
+      #
+      # @param task [Tasks::Task]
+      # @param error [StandardError]
+      # @return [void]
+      def handle_task_error(task, error)
+        retry_count = extract_retry_count(task) + 1
+
+        metadata = build_retry_metadata(task, retry_count)
+        if retry_count >= MAX_TASK_RETRIES
+          @task_manager.update(
+            task.id,
+            status: 'failed',
+            owner: nil,
+            result: "Failed after #{retry_count} retries. Last error: #{error.message}",
+            metadata: JSON.generate(metadata)
+          )
+        else
+          @task_manager.update(
+            task.id,
+            status: 'pending',
+            owner: nil,
+            result: "Error (retry #{retry_count}/#{MAX_TASK_RETRIES}): #{error.message}",
+            metadata: JSON.generate(metadata)
+          )
+        end
+        @on_task_error&.call(task, error)
+      end
 
-        @total_cost += cm.total_cost.to_f
+      # @param task [Tasks::Task]
+      # @return [Integer]
+      def extract_retry_count(task)
+        meta = parse_task_metadata(task)
+        (meta[:retry_count] || meta['retry_count'] || 0).to_i
+      end
+
+      # @param task [Tasks::Task]
+      # @param retry_count [Integer]
+      # @return [Hash]
+      def build_retry_metadata(task, retry_count)
+        meta = parse_task_metadata(task)
+        meta.merge(retry_count: retry_count)
+      end
+
+      # @param task [Tasks::Task]
+      # @return [Hash]
+      def parse_task_metadata(task)
+        raw = task.metadata
+        case raw
+        when Hash then raw
+        when String then JSON.parse(raw, symbolize_names: true)
+        else {}
+        end
+      rescue JSON::ParserError
+        {}
+      end
+
+      # Persists the agent's conversation as a session audit trail after
+      # completing a task, so there's a record of what the daemon did.
+      #
+      # @param task [Tasks::Task]
+      # @param agent_loop [Agent::Loop]
+      # @return [void]
+      def persist_session_audit(task, agent_loop)
+        return unless @session_persistence
+
+        conversation = agent_loop.instance_variable_get(:@conversation)
+        return unless conversation.respond_to?(:messages)
+
+        session_id = "daemon-#{@agent_name}-#{task.id}"
+        @session_persistence.save_session(
+          session_id: session_id,
+          project_path: @project_root,
+          messages: conversation.messages,
+          title: "Daemon: #{task.title}",
+          metadata: { agent_name: @agent_name, task_id: task.id, task_title: task.title }
+        )
       rescue StandardError
-        # Non-critical
+        # Non-critical — audit persistence is best-effort
       end
 
       # ── Idle phase ───────────────────────────────────────────────

data/lib/rubyn_code/autonomous/idle_poller.rb

@@ -53,26 +53,6 @@ module RubynCode
         @interrupted = true
       end
 
-      # Re-injects the agent's identity message when the conversation
-      # context has been compressed (i.e. the messages array is very short).
-      # This ensures the agent still knows who it is after compaction.
-      #
-      # @param messages [Array<Hash>] the current conversation messages
-      # @param identity [String] the identity/system prompt to re-inject
-      # @param threshold [Integer] message count below which re-injection triggers (default 3)
-      # @return [void]
-      def self.reinject_identity(messages, identity:, threshold: 3)
-        return if messages.length >= threshold
-        return if identity.nil? || identity.empty?
-
-        # Only re-inject if the identity is not already present as the
-        # first user message.
-        first_user = messages.find { |m| m[:role] == 'user' }
-        return if first_user && first_user[:content].to_s.include?(identity[0, 100])
-
-        messages.unshift({ role: 'user', content: identity })
-      end
-
       private
 
       # @return [Boolean]

data/lib/rubyn_code/autonomous/task_claimer.rb

@@ -6,16 +6,19 @@ module RubynCode
     # Uses optimistic locking to handle race conditions when multiple
     # agents attempt to claim the same task concurrently.
     module TaskClaimer
-      # Finds the first ready (pending, unowned) task, claims it for the
-      # given agent, and returns the updated Task. Returns nil if no work
-      # is available.
+      MAX_RETRIES = 3
+
+      # Finds the first ready (pending, unowned) task that hasn't exceeded
+      # max retries, claims it for the given agent, and returns the updated
+      # Task. Returns nil if no work is available.
       #
       # @param task_manager [#db, #update_task, #list_tasks] task persistence layer
       # @param agent_name [String] unique identifier of the claiming agent
+      # @param max_retries [Integer] maximum retry count before skipping a task
       # @return [Tasks::Task, nil] the claimed task, or nil if none available
-      def self.call(task_manager:, agent_name:)
+      def self.call(task_manager:, agent_name:, max_retries: MAX_RETRIES)
         db = task_manager.db
-        claim_next_pending_task(db, agent_name)
+        claim_next_pending_task(db, agent_name, max_retries)
         fetch_claimed_task(db, agent_name)
       rescue StandardError => e
         RubynCode.logger.warn("TaskClaimer: failed to claim task: #{e.message}") if RubynCode.respond_to?(:logger)
@@ -25,17 +28,20 @@ module RubynCode
       class << self
         private
 
-        def claim_next_pending_task(db, agent_name)
-          db.execute(<<~SQL, [agent_name])
+        def claim_next_pending_task(db, agent_name, max_retries)
+          db.execute(<<~SQL, [agent_name, max_retries])
             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
+              SELECT t.id FROM tasks t
+              WHERE t.status = 'pending'
+                AND (t.owner IS NULL OR t.owner = '')
+                AND COALESCE(
+                  json_extract(t.metadata, '$.retry_count'), 0
+                ) < ?
+              ORDER BY t.priority DESC, t.created_at ASC
               LIMIT 1
             )
             AND status = 'pending'

data/lib/rubyn_code/cli/app.rb

@@ -26,6 +26,8 @@ module RubynCode
           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
 
@@ -57,7 +59,8 @@ module RubynCode
         '--help' => :help, '-h' => :help,
         '--auth' => :auth, '--setup' => :setup
       }.freeze
-      BOOLEAN_FLAGS = { '--yolo' => :yolo, '--debug' => :debug }.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
@@ -71,6 +74,7 @@ module RubynCode
         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
@@ -83,6 +87,7 @@ module RubynCode
           idx = parse_single_option(argv, idx, options)
           idx += 1
         end
+        options[:command] = :ide if options[:ide]
         options
       end
 
@@ -93,6 +98,9 @@ module RubynCode
           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
@@ -188,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,
@@ -200,6 +214,23 @@ 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_TEXT
       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

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

@@ -68,7 +68,28 @@ module RubynCode
           current = client.model
           ctx.renderer.info("Provider: #{provider}")
           ctx.renderer.info("Current model: #{current}")
-          show_available(ctx)
+          ctx.renderer.info("Available: #{client.models.join(', ')}")
+          show_other_providers(provider, ctx)
+          ctx.renderer.info('Tip: /model provider:model to switch providers (e.g., /model openai:gpt-4o)')
+        end
+
+        def show_other_providers(current_provider, ctx)
+          others = other_provider_entries(current_provider)
+          return if others.empty?
+
+          ctx.renderer.info('')
+          ctx.renderer.info('Other providers:')
+          others.each { |label| ctx.renderer.info("  #{label}") }
+        end
+
+        def other_provider_entries(current_provider)
+          providers = Config::Settings.new.data['providers']
+          return [] unless providers.is_a?(Hash)
+
+          providers.reject { |name, _| name == current_provider }.map do |name, cfg|
+            models = extract_config_models(cfg)
+            models.empty? ? name : "#{name}: #{models.join(', ')}"
+          end
         end
 
         def show_available(ctx)
@@ -85,9 +106,18 @@ module RubynCode
           case provider
           when 'anthropic' then LLM::Adapters::Anthropic::AVAILABLE_MODELS
           when 'openai' then LLM::Adapters::OpenAI::AVAILABLE_MODELS
-          else []
+          else
+            cfg = Config::Settings.new.provider_config(provider)
+            extract_config_models(cfg)
           end
         end
+
+        def extract_config_models(cfg)
+          raw = cfg&.dig('models')
+          return [] unless raw
+
+          raw.is_a?(Hash) ? raw.values : Array(raw)
+        end
       end
     end
   end