rubyn-code 0.2.2 → 0.3.0

data/lib/rubyn_code/cli/repl_lifecycle.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module CLI
+    # Session persistence, shutdown, and learning extraction for the REPL.
+    module ReplLifecycle
+      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! \u270C\uFE0F",
+        "Writing instincts to disk... Don't forget me! 💾",
+        "at_exit { puts 'Thanks for coding with Rubyn!' } 🎸"
+      ].freeze
+
+      private
+
+      def current_session_id
+        @current_session_id ||= SecureRandom.hex(16)
+      end
+
+      def save_session!
+        @session_persistence.save_session(
+          session_id: current_session_id,
+          project_path: @project_root,
+          messages: @conversation.messages,
+          model: Config::Defaults::DEFAULT_MODEL
+        )
+      end
+
+      def resume_session!
+        data = @session_persistence.load_session(@session_id)
+        return unless data
+
+        @conversation.replace!(data[:messages])
+        @renderer.info("Resumed session #{@session_id[0..7]}")
+      end
+
+      def shutdown!
+        return if @shutdown_complete
+
+        @shutdown_complete = true
+        @spinner.stop
+        puts
+        @renderer.info(GOODBYE_MESSAGES.sample)
+        @renderer.info('Saving session...')
+        save_session!
+        @background_worker&.shutdown!
+        extract_learnings_if_needed
+        decay_instincts
+        @renderer.info("Session saved. Rubyn out. \u270C\uFE0F")
+      rescue StandardError
+        # Best effort on shutdown
+      end
+
+      def extract_learnings_if_needed
+        return unless @conversation.length > 5
+
+        @renderer.info('Extracting learnings from this session...')
+        Learning::Extractor.call(@conversation.messages, llm_client: @llm_client, project_path: @project_root)
+        @renderer.success('Instincts saved.')
+      rescue StandardError => e
+        RubynCode::Debug.warn("Instinct extraction skipped: #{e.message}")
+      end
+
+      def decay_instincts
+        Learning::InstinctMethods.decay_all(DB::Connection.instance, project_path: @project_root)
+      rescue StandardError
+        # Silent — decay is best-effort
+      end
+    end
+  end
+end

data/lib/rubyn_code/cli/repl_setup.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module CLI
+    # Infrastructure and service setup for the REPL.
+    module ReplSetup # rubocop:disable Metrics/ModuleLength -- REPL setup requires many service initializations
+      private
+
+      def setup_components!
+        setup_infrastructure!
+        setup_services!
+        setup_executor_callbacks!
+        setup_hooks!
+        setup_agent_loop!
+      end
+
+      def setup_infrastructure!
+        ensure_home_dir!
+        @db = DB::Connection.instance
+        DB::Migrator.new(@db).migrate!
+        @auth = ensure_auth!
+      end
+
+      def setup_services!
+        setup_core_services!
+        setup_auxiliary_services!
+      end
+
+      def setup_core_services!
+        @llm_client = LLM::Client.new
+        @conversation = Agent::Conversation.new
+        @tool_executor = Tools::Executor.new(project_root: @project_root)
+        @context_manager = Context::Manager.new(llm_client: @llm_client)
+        @hook_registry = Hooks::Registry.new
+        @hook_runner = Hooks::Runner.new(registry: @hook_registry)
+        @stall_detector = Agent::LoopDetector.new
+      end
+
+      def setup_auxiliary_services!
+        @deny_list = Permissions::DenyList.new
+        @budget_enforcer = Observability::BudgetEnforcer.new(@db, session_id: current_session_id)
+        @background_worker = Background::Worker.new(project_root: @project_root)
+        @skill_loader = Skills::Loader.new(Skills::Catalog.new(skill_dirs))
+        @session_persistence = Memory::SessionPersistence.new(@db)
+      end
+
+      def setup_executor_callbacks!
+        @tool_executor.llm_client = @llm_client
+        @tool_executor.background_worker = @background_worker
+        @tool_executor.db = @db
+        @tool_executor.ask_user_callback = build_ask_user_callback
+        @sub_agent_tool_count = 0
+        @in_sub_agent = false
+        @tool_executor.on_agent_status = build_agent_status_callback
+      end
+
+      def build_ask_user_callback
+        ->(question) { prompt_user_for_answer(question) }
+      end
+
+      def prompt_user_for_answer(question)
+        @spinner.stop
+        @renderer.warning('Rubyn is asking:')
+        puts "  #{question}"
+        print '  > '
+        $stdout.flush
+        answer = Reline.readline('', false)&.strip
+        answer.nil? || answer.empty? ? '[no response]' : answer
+      end
+
+      def build_agent_status_callback
+        ->(type, msg) { handle_agent_status(type, msg) }
+      end
+
+      def handle_agent_status(type, msg)
+        case type
+        when :started
+          @spinner.stop
+          @in_sub_agent = true
+          @sub_agent_tool_count = 0
+          @renderer.info(msg)
+          @spinner.start_sub_agent
+        when :tool
+          @sub_agent_tool_count += 1
+          @spinner.stop
+          @spinner.start_sub_agent(@sub_agent_tool_count)
+        when :done
+          @spinner.stop
+          @in_sub_agent = false
+          @renderer.success(msg)
+        end
+      end
+
+      def setup_hooks!
+        Hooks::BuiltIn.register_all!(@hook_registry)
+        Hooks::UserHooks.load!(@hook_registry, project_root: @project_root)
+      end
+
+      def setup_agent_loop!
+        @agent_loop = Agent::Loop.new(
+          llm_client: @llm_client, tool_executor: @tool_executor,
+          context_manager: @context_manager, hook_runner: @hook_runner,
+          conversation: @conversation, permission_tier: @permission_tier,
+          deny_list: @deny_list, budget_enforcer: @budget_enforcer,
+          background_manager: @background_worker, stall_detector: @stall_detector,
+          on_tool_call: ->(name, params) { handle_on_tool_call(name, params) },
+          on_tool_result: ->(name, result, _is_error = false) { handle_on_tool_result(name, result) },
+          on_text: ->(text) { handle_on_text(text) },
+          skill_loader: @skill_loader, project_root: @project_root
+        )
+      end
+
+      def ensure_home_dir!
+        FileUtils.mkdir_p(Config::Defaults::HOME_DIR)
+      end
+
+      def ensure_auth!
+        provider = Config::Defaults::DEFAULT_PROVIDER
+        tokens = Auth::TokenStore.load_for_provider(provider)
+
+        if tokens
+          source = tokens.fetch(:source, :unknown)
+          @renderer.info("Authenticated via #{source}") if source == :keychain
+          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.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 << project_skills if Dir.exist?(project_skills)
+        user_skills = File.join(Config::Defaults::HOME_DIR, 'skills')
+        dirs << user_skills if Dir.exist?(user_skills)
+        dirs
+      end
+    end
+  end
+end

data/lib/rubyn_code/cli/setup.rb

@@ -83,15 +83,19 @@ module RubynCode
       end
 
       def write_launcher(path, gem_wrapper, pinned_ruby)
+        ruby_version = File.basename(File.dirname(pinned_ruby, 2))
         File.write(path, <<~BASH)
           #!/usr/bin/env bash
-          # Rubyn Code launcher — pinned to Ruby #{File.basename(File.dirname(pinned_ruby, 2))}
+          # Rubyn Code launcher — pinned to Ruby #{ruby_version}
           # Generated by: rubyn-code --setup
           # Bypasses rbenv/rvm so rubyn-code works in any project.
           #
+          # Uses the pinned Ruby directly (not /usr/bin/env ruby) to avoid
+          # rbenv resolving to a different Ruby based on .ruby-version.
+          #
           # To regenerate: rubyn-code --setup
           # To remove:     rm #{path}
-          exec "#{gem_wrapper}" "$@"
+          exec "#{pinned_ruby}" "#{gem_wrapper}" "$@"
         BASH
       end
 

data/lib/rubyn_code/cli/stream_formatter.rb

@@ -58,80 +58,64 @@ module RubynCode
       def process_line(line)
         stripped = line.rstrip
 
-        # Code block toggle
         if stripped.match?(/\A\s*```/)
-          if @in_code_block
-            # Closing fence — render the buffered code
-            render_code_block
-            @in_code_block = false
-            @code_lang = nil
-          else
-            # Opening fence
-            @in_code_block = true
-            @code_lang = stripped.match(/```(\w*)/)[1]
-            @code_lang = 'ruby' if @code_lang.empty?
-            @code_buffer = +''
-            $stdout.puts @pastel.dim("  ┌─ #{@code_lang}")
-          end
-          return
+          toggle_code_block(stripped)
+        elsif @in_code_block
+          @code_buffer << line
+        else
+          $stdout.print format_line(line)
+          $stdout.flush
         end
+      end
 
+      def toggle_code_block(stripped)
         if @in_code_block
-          @code_buffer << line
-          return
+          render_code_block
+          @in_code_block = false
+          @code_lang = nil
+        else
+          open_code_block(stripped)
         end
+      end
 
-        # Regular line — format and print
-        $stdout.print format_line(line)
-        $stdout.flush
+      def open_code_block(stripped)
+        @in_code_block = true
+        @code_lang = stripped.match(/```(\w*)/)[1]
+        @code_lang = 'ruby' if @code_lang.empty?
+        @code_buffer = +''
+        $stdout.puts @pastel.dim("  ┌─ #{@code_lang}")
       end
 
       def render_code_block
         return if @code_buffer.empty?
 
-        lexer = Rouge::Lexer.find(@code_lang || 'ruby') || Rouge::Lexers::PlainText.new
-        highlighted = @rouge_formatter.format(lexer.lex(@code_buffer))
-        border = @pastel.dim('  │ ')
-
-        highlighted.each_line do |l|
-          $stdout.print "#{border}#{l}"
-        end
-        $stdout.puts @pastel.dim('  └─')
-        $stdout.flush
-
+        output_highlighted_code
         @code_buffer = +''
       rescue StandardError
-        # Fallback: print unformatted
         @code_buffer.each_line { |l| $stdout.print "  #{l}" }
         $stdout.puts
         @code_buffer = +''
       end
 
+      def output_highlighted_code
+        lexer = Rouge::Lexer.find(@code_lang || 'ruby') || Rouge::Lexers::PlainText.new
+        highlighted = @rouge_formatter.format(lexer.lex(@code_buffer))
+        border = @pastel.dim('  │ ')
+        highlighted.each_line { |l| $stdout.print "#{border}#{l}" }
+        $stdout.puts @pastel.dim('  └─')
+        $stdout.flush
+      end
+
       def format_line(line)
         stripped = line.rstrip
 
-        # Headers
         case stripped
         when /\A\#{1,6}\s/
-          level = stripped.match(/\A(\#{1,6})\s/)[1].length
-          text = stripped.sub(/\A\#{1,6}\s+/, '')
-          case level
-          when 1 then "#{@pastel.bold.underline(text)}\n"
-          when 2 then "\n#{@pastel.bold(text)}\n"
-          else "#{@pastel.bold(text)}\n"
-          end
-        # Bullet lists
+          format_header(stripped)
         when /\A\s*[-*]\s/
-          indent = stripped.match(/\A(\s*)/)[1]
-          content = stripped.sub(/\A\s*[-*]\s+/, '')
-          "#{indent}  #{@pastel.cyan('•')} #{format_inline(content)}\n"
-        # Numbered lists
+          format_bullet(stripped)
         when /\A\s*\d+\.\s/
-          indent = stripped.match(/\A(\s*)/)[1]
-          num = stripped.match(/(\d+)\./)[1]
-          content = stripped.sub(/\A\s*\d+\.\s+/, '')
-          "#{indent}  #{@pastel.cyan("#{num}.")} #{format_inline(content)}\n"
-        # Horizontal rules
+          format_numbered_item(stripped)
         when /\A-{3,}\z/
           "#{@pastel.dim('─' * 40)}\n"
         else
@@ -139,6 +123,29 @@ module RubynCode
         end
       end
 
+      def format_header(stripped)
+        level = stripped.match(/\A(\#{1,6})\s/)[1].length
+        text = stripped.sub(/\A\#{1,6}\s+/, '')
+        case level
+        when 1 then "#{@pastel.bold.underline(text)}\n"
+        when 2 then "\n#{@pastel.bold(text)}\n"
+        else "#{@pastel.bold(text)}\n"
+        end
+      end
+
+      def format_bullet(stripped)
+        indent = stripped.match(/\A(\s*)/)[1]
+        content = stripped.sub(/\A\s*[-*]\s+/, '')
+        "#{indent}  #{@pastel.cyan('•')} #{format_inline(content)}\n"
+      end
+
+      def format_numbered_item(stripped)
+        indent = stripped.match(/\A(\s*)/)[1]
+        num = stripped.match(/(\d+)\./)[1]
+        content = stripped.sub(/\A\s*\d+\.\s+/, '')
+        "#{indent}  #{@pastel.cyan("#{num}.")} #{format_inline(content)}\n"
+      end
+
       def format_inline(text)
         text
           .gsub(/\*\*(.+?)\*\*/) { @pastel.bold(Regexp.last_match(1)) }

data/lib/rubyn_code/cli/version_check.rb

@@ -50,6 +50,16 @@ module RubynCode
           return
         end
 
+        latest = fetch_latest_version
+        return unless latest
+
+        write_cache(latest)
+        @result = latest
+      rescue StandardError
+        # Silent — never interrupt startup for a version check
+      end
+
+      def fetch_latest_version
         conn = Faraday.new do |f|
           f.options.timeout = 5
           f.options.open_timeout = 3
@@ -57,16 +67,8 @@ module RubynCode
         response = conn.get(RUBYGEMS_API)
         return unless response.success?
 
-        data = JSON.parse(response.body)
-        latest = data['version']
-        return unless latest
-        return unless latest.match?(/\A\d+\.\d+/)
-        return unless Gem::Version.correct?(latest)
-
-        write_cache(latest)
-        @result = latest
-      rescue StandardError
-        # Silent — never interrupt startup for a version check
+        latest = JSON.parse(response.body)['version']
+        latest if latest&.match?(/\A\d+\.\d+/) && Gem::Version.correct?(latest)
       end
 
       def newer?(remote, local)
@@ -79,11 +81,26 @@ module RubynCode
         return nil unless File.exist?(CACHE_FILE)
         return nil if (Time.now - File.mtime(CACHE_FILE)) > CACHE_TTL
 
-        File.read(CACHE_FILE).strip
+        cached = File.read(CACHE_FILE).strip
+        return nil unless valid_version?(cached)
+
+        cached
       rescue StandardError
         nil
       end
 
+      def valid_version?(version)
+        return false unless version&.match?(/\A\d+\.\d+/)
+        return false unless Gem::Version.correct?(version)
+
+        # Sanity: remote shouldn't be more than 10 major versions ahead
+        remote = Gem::Version.new(version)
+        local = Gem::Version.new(RubynCode::VERSION)
+        (remote.segments.first - local.segments.first).abs < 10
+      rescue StandardError
+        false
+      end
+
       def write_cache(version)
         File.write(CACHE_FILE, version)
       rescue StandardError

data/lib/rubyn_code/config/defaults.rb

@@ -10,6 +10,7 @@ module RubynCode
       SESSIONS_DIR = File.join(HOME_DIR, 'sessions')
       MEMORIES_DIR = File.join(HOME_DIR, 'memories')
 
+      DEFAULT_PROVIDER = 'anthropic'
       DEFAULT_MODEL = 'claude-opus-4-6'
       MAX_ITERATIONS = 200
       MAX_SUB_AGENT_ITERATIONS = 200
@@ -38,6 +39,15 @@ module RubynCode
       OAUTH_TOKEN_URL = 'https://claude.ai/oauth/token'
       OAUTH_SCOPES = 'user:read model:read model:write'
 
+      # Known provider configurations: provider name → { env_key:, base_url: (if not default) }
+      PROVIDER_ENV_KEYS = {
+        'anthropic' => 'ANTHROPIC_API_KEY',
+        'openai' => 'OPENAI_API_KEY',
+        'groq' => 'GROQ_API_KEY',
+        'together' => 'TOGETHER_API_KEY',
+        'ollama' => 'OLLAMA_API_KEY'
+      }.freeze
+
       DANGEROUS_PATTERNS = [
         'rm -rf /', 'sudo rm', 'shutdown', 'reboot',
         '> /dev/', 'mkfs', 'dd if=', ':(){:|:&};:'

data/lib/rubyn_code/config/project_profile.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+require 'yaml'
+require 'fileutils'
+
+module RubynCode
+  module Config
+    # Auto-generated project profile that caches detected project stack
+    # information. First session pays the detection cost; subsequent
+    # sessions load a compact ~500-token profile instead of re-exploring.
+    class ProjectProfile
+      PROFILE_FILENAME = 'project_profile.yml'
+
+      DETECTABLE_KEYS = %w[
+        framework ruby_version database test_framework
+        factories auth background_jobs api frontend
+        key_models service_pattern custom_conventions
+      ].freeze
+
+      attr_reader :data, :profile_path
+
+      def initialize(project_root:)
+        @project_root = File.expand_path(project_root)
+        @project_dir = File.join(@project_root, '.rubyn-code')
+        @profile_path = File.join(@project_dir, PROFILE_FILENAME)
+        @data = {}
+      end
+
+      # Load existing profile or return nil if none exists.
+      def load
+        return nil unless File.exist?(@profile_path)
+
+        raw = YAML.safe_load_file(@profile_path, permitted_classes: [Symbol])
+        @data = raw.is_a?(Hash) ? raw : {}
+        self
+      rescue StandardError
+        nil
+      end
+
+      # Detect project stack and save profile.
+      def detect_and_save!
+        @data = {}
+        detect_framework
+        detect_ruby_version
+        detect_database
+        detect_test_framework
+        detect_auth
+        detect_background_jobs
+        detect_api_framework
+        detect_key_models
+        detect_service_pattern
+        save!
+        self
+      end
+
+      # Load if exists, otherwise detect and save.
+      def load_or_detect!
+        load || detect_and_save!
+      end
+
+      # Compact string representation for system prompt injection (~500 tokens).
+      def to_prompt
+        return '' if @data.empty?
+
+        lines = ['Project Profile:']
+        @data.each do |key, value|
+          formatted = value.is_a?(Array) ? value.join(', ') : value.to_s
+          lines << "  #{key}: #{formatted}" unless formatted.empty?
+        end
+        lines.join("\n")
+      end
+
+      # Save the current profile data to disk.
+      def save!
+        FileUtils.mkdir_p(@project_dir)
+        File.write(@profile_path, YAML.dump(@data))
+      end
+
+      # Check if the profile is stale (older than 7 days).
+      def stale?
+        return true unless File.exist?(@profile_path)
+
+        (Time.now - File.mtime(@profile_path)) > 604_800
+      end
+
+      FRAMEWORK_GEMS = { 'rails' => 'rails', 'sinatra' => 'sinatra', 'hanami' => 'hanami' }.freeze
+      API_GEMS = { 'grape' => 'grape', 'graphql' => 'graphql' }.freeze
+      FRONTEND_GEMS = { 'turbo-rails' => 'hotwire', 'react-rails' => 'react' }.freeze
+
+      private
+
+      def detect_framework
+        gemfile = read_file('Gemfile')
+        return unless gemfile
+
+        @data['framework'] = FRAMEWORK_GEMS.each_value.find { |gem| gemfile.include?(gem) } || 'ruby'
+      end
+
+      def detect_ruby_version
+        path = File.join(@project_root, '.ruby-version')
+        @data['ruby_version'] = File.read(path).strip if File.exist?(path)
+      end
+
+      def detect_database
+        gemfile = read_file('Gemfile')
+        return unless gemfile
+
+        @data['database'] = 'postgresql' if gemfile.include?('pg')
+        @data['database'] ||= 'mysql' if gemfile.include?('mysql2')
+        @data['database'] ||= 'sqlite' if gemfile.include?('sqlite3')
+      end
+
+      def detect_test_framework
+        gemfile = read_file('Gemfile')
+        return unless gemfile
+
+        @data['test_framework'] = 'rspec' if gemfile.match?(/['"]rspec['"]/)
+        @data['test_framework'] ||= 'minitest' if gemfile.include?('minitest')
+        @data['factories'] = 'factory_bot' if gemfile.include?('factory_bot')
+      end
+
+      def detect_auth
+        gemfile = read_file('Gemfile')
+        return unless gemfile
+
+        @data['auth'] = 'devise' if gemfile.include?('devise')
+        @data['auth'] ||= 'rodauth' if gemfile.include?('rodauth')
+        @data['auth'] ||= 'clearance' if gemfile.include?('clearance')
+      end
+
+      def detect_background_jobs
+        gemfile = read_file('Gemfile')
+        return unless gemfile
+
+        @data['background_jobs'] = 'sidekiq' if gemfile.include?('sidekiq')
+        @data['background_jobs'] ||= 'good_job' if gemfile.include?('good_job')
+        @data['background_jobs'] ||= 'solid_queue' if gemfile.include?('solid_queue')
+      end
+
+      def detect_api_framework
+        gemfile = read_file('Gemfile')
+        return unless gemfile
+
+        detect_gem_key(gemfile, 'api', API_GEMS)
+        detect_gem_key(gemfile, 'frontend', FRONTEND_GEMS)
+      end
+
+      def detect_gem_key(gemfile, key, gem_map)
+        gem_map.each do |gem_name, value|
+          next if @data[key]
+
+          @data[key] = value if gemfile.include?(gem_name)
+        end
+      end
+
+      def detect_key_models
+        model_dir = File.join(@project_root, 'app', 'models')
+        return unless File.directory?(model_dir)
+
+        models = Dir.glob(File.join(model_dir, '*.rb'))
+                    .map { |f| File.basename(f, '.rb').split('_').map(&:capitalize).join }
+                    .reject { |m| m == 'ApplicationRecord' }
+                    .first(20)
+        @data['key_models'] = models unless models.empty?
+      end
+
+      def detect_service_pattern
+        service_dir = File.join(@project_root, 'app', 'services')
+        return unless File.directory?(service_dir)
+
+        @data['service_pattern'] = 'app/services/**/*_service.rb'
+        conventions = []
+        conventions << 'Service objects implement .call class method'
+        @data['custom_conventions'] = conventions
+      end
+
+      def read_file(relative_path)
+        path = File.join(@project_root, relative_path)
+        File.read(path) if File.exist?(path)
+      rescue StandardError
+        nil
+      end
+    end
+  end
+end