rubyn-code 0.2.2 → 0.4.0

data/lib/rubyn_code/context/manual_compact.rb

@@ -68,7 +68,7 @@ module RubynCode
         ]
 
         options = {}
-        options[:model] = 'claude-sonnet-4-20250514' if llm_client.respond_to?(:chat)
+        options[:model] = 'claude-sonnet-4-6' if llm_client.respond_to?(:chat)
 
         response = llm_client.chat(messages: summary_messages, **options)
 

data/lib/rubyn_code/context/micro_compact.rb

@@ -22,22 +22,27 @@ module RubynCode
 
         tool_name_index = build_tool_name_index(messages)
         candidates = tool_result_refs[0..-(keep_recent + 1)]
-        compacted = 0
+        compact_candidates(candidates, tool_name_index, preserve_tools)
+      end
 
+      def self.compact_candidates(candidates, tool_name_index, preserve_tools)
+        compacted = 0
         candidates.each do |ref|
-          block = ref[:block]
-          content = extract_content(block)
-          next if content.nil? || content.length < MIN_CONTENT_LENGTH
+          compacted += 1 if compact_single_ref(ref, tool_name_index, preserve_tools)
+        end
+        compacted
+      end
 
-          tool_name = resolve_tool_name(block, tool_name_index)
-          next if preserve_tools.include?(tool_name)
+      def self.compact_single_ref(ref, tool_name_index, preserve_tools) # rubocop:disable Naming/PredicateMethod -- returns boolean but is an action method
+        block = ref[:block]
+        content = extract_content(block)
+        return false if content.nil? || content.length < MIN_CONTENT_LENGTH
 
-          placeholder = format(PLACEHOLDER_TEMPLATE, tool_name: tool_name || 'tool')
-          replace_content!(block, placeholder)
-          compacted += 1
-        end
+        tool_name = resolve_tool_name(block, tool_name_index)
+        return false if preserve_tools.include?(tool_name)
 
-        compacted
+        replace_content!(block, format(PLACEHOLDER_TEMPLATE, tool_name: tool_name || 'tool'))
+        true
       end
 
       # Collects all tool_result content blocks across user messages, preserving
@@ -70,19 +75,23 @@ module RubynCode
         messages.each do |msg|
           next unless msg[:role] == 'assistant' && msg[:content].is_a?(Array)
 
-          msg[:content].each do |block|
-            case block
-            when Hash
-              index[block[:id] || block['id']] = block[:name] || block['name'] if block_type(block) == 'tool_use'
-            when LLM::ToolUseBlock
-              index[block.id] = block.name
-            end
-          end
+          msg[:content].each { |block| index_tool_use(index, block) }
         end
 
         index
       end
 
+      def self.index_tool_use(index, block)
+        case block
+        when Hash
+          return unless block_type(block) == 'tool_use'
+
+          index[block[:id] || block['id']] = block[:name] || block['name']
+        when LLM::ToolUseBlock
+          index[block.id] = block.name
+        end
+      end
+
       def self.tool_result_block?(block)
         case block
         when Hash
@@ -128,6 +137,7 @@ module RubynCode
       end
 
       private_class_method :collect_tool_results, :build_tool_name_index,
+                           :index_tool_use, :compact_candidates, :compact_single_ref,
                            :tool_result_block?, :block_type, :extract_content,
                            :resolve_tool_name, :replace_content!
     end

data/lib/rubyn_code/context/schema_filter.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module Context
+    # Extracts only the relevant table definitions from db/schema.rb
+    # based on which models are currently in context. Loading the full
+    # schema for a large Rails app can be 5-10K tokens; filtering to
+    # relevant tables typically reduces this to 200-500 tokens.
+    module SchemaFilter
+      TABLE_PATTERN = /create_table\s+"([^"]+)"/
+      END_PATTERN = /\A\s+end\s*\z/
+
+      class << self
+        # Returns schema definitions for only the specified table names.
+        #
+        # @param schema_path [String] path to db/schema.rb
+        # @param table_names [Array<String>] table names to include
+        # @return [String] filtered schema content
+        def filter(schema_path, table_names:)
+          return '' if table_names.empty?
+          return '' unless File.exist?(schema_path)
+
+          lines = File.readlines(schema_path)
+          extract_tables(lines, table_names.to_set(&:to_s))
+        end
+
+        # Derives table names from model class names using Rails conventions.
+        #
+        # @param model_names [Array<String>] e.g., ["User", "OrderItem"]
+        # @return [Array<String>] e.g., ["users", "order_items"]
+        def tableize(model_names)
+          model_names.map { |name| "#{name.gsub(/([a-z])([A-Z])/, '\1_\2').downcase}s" }
+        end
+
+        # Convenience: filter schema by model names instead of table names.
+        def filter_for_models(schema_path, model_names:)
+          tables = tableize(model_names)
+          filter(schema_path, table_names: tables)
+        end
+
+        private
+
+        def extract_tables(lines, table_set)
+          result = []
+          capturing = false
+
+          lines.each do |line|
+            match = TABLE_PATTERN.match(line)
+            capturing = true if match && table_set.include?(match[1])
+
+            result << line if capturing
+
+            if capturing && END_PATTERN.match?(line)
+              capturing = false
+              result << "\n"
+            end
+          end
+
+          result.join
+        end
+      end
+    end
+  end
+end

data/lib/rubyn_code/db/connection.rb

@@ -106,34 +106,11 @@ module RubynCode
       #
       # @yield the block to execute
       # @return [Object] the block's return value
-      def transaction
+      def transaction(&block)
         synchronize do
-          if @transaction_depth.zero?
-            begin_top_level_transaction
-          else
-            begin_savepoint
-          end
-
+          @transaction_depth.zero? ? begin_top_level_transaction : begin_savepoint
           @transaction_depth += 1
-          begin
-            result = yield
-            if @transaction_depth == 1
-              @db.execute('COMMIT')
-            else
-              @db.execute("RELEASE SAVEPOINT sp_#{@transaction_depth}")
-            end
-            result
-          rescue StandardError => e
-            if @transaction_depth == 1
-              @db.execute('ROLLBACK')
-            else
-              @db.execute("ROLLBACK TO SAVEPOINT sp_#{@transaction_depth}")
-              @db.execute("RELEASE SAVEPOINT sp_#{@transaction_depth}")
-            end
-            raise e
-          ensure
-            @transaction_depth -= 1
-          end
+          execute_transaction_body(&block)
         end
       end
 
@@ -171,6 +148,34 @@ module RubynCode
       def begin_savepoint
         @db.execute("SAVEPOINT sp_#{@transaction_depth + 1}")
       end
+
+      def execute_transaction_body
+        result = yield
+        commit_or_release
+        result
+      rescue StandardError => e
+        rollback_or_release
+        raise e
+      ensure
+        @transaction_depth -= 1
+      end
+
+      def commit_or_release
+        if @transaction_depth == 1
+          @db.execute('COMMIT')
+        else
+          @db.execute("RELEASE SAVEPOINT sp_#{@transaction_depth}")
+        end
+      end
+
+      def rollback_or_release
+        if @transaction_depth == 1
+          @db.execute('ROLLBACK')
+        else
+          @db.execute("ROLLBACK TO SAVEPOINT sp_#{@transaction_depth}")
+          @db.execute("RELEASE SAVEPOINT sp_#{@transaction_depth}")
+        end
+      end
     end
   end
 end

data/lib/rubyn_code/db/migrator.rb

@@ -38,7 +38,7 @@ module RubynCode
       # @return [Array<Array(Integer, String)>] pairs of [version, file_path]
       def pending_migrations
         applied = applied_versions
-        available_migrations.reject { |version, _| applied.include?(version) }
+        available_migrations.reject { |version, _| applied.include?(version) } # rubocop:disable Style/HashExcept
       end
 
       # Returns the set of already-applied migration versions.
@@ -67,16 +67,16 @@ module RubynCode
       def available_migrations
         all = Dir.glob(File.join(MIGRATIONS_DIR, '*'))
                  .select { |path| path.end_with?('.sql', '.rb') }
-                 .map { |path| parse_migration_file(path) }
-                 .compact
+                 .filter_map { |path| parse_migration_file(path) }
 
-        # Deduplicate: if both .rb and .sql exist for the same version, prefer .rb
+        deduplicate_migrations(all)
+      end
+
+      def deduplicate_migrations(all)
         by_version = {}
         all.each do |version, path|
-          existing = by_version[version]
-          by_version[version] = [version, path] if existing.nil? || path.end_with?('.rb')
+          by_version[version] = [version, path] if !by_version[version] || path.end_with?('.rb')
         end
-
         by_version.values.sort_by(&:first)
       end
 
@@ -139,33 +139,49 @@ module RubynCode
         in_block = false
 
         sql.each_line do |line|
-          stripped = line.strip
+          in_block, current = process_sql_line(line, statements, current, in_block)
+        end
 
-          # Track BEGIN/END blocks (e.g., triggers)
-          if stripped.match?(/\bBEGIN\b/i) && !stripped.match?(/\ABEGIN\s+(IMMEDIATE|DEFERRED|EXCLUSIVE)/i)
-            in_block = true
-          end
-          current << line
-
-          if in_block
-            if stripped.match?(/\bEND\b\s*;?\s*$/i)
-              in_block = false
-              statements << current.strip.chomp(';')
-              current = +''
-            end
-          elsif stripped.end_with?(';')
-            stmt = current.strip.chomp(';').strip
-            statements << stmt unless stmt.empty? || (stmt.match?(/\A\s*--/) && !stmt.include?("\n"))
-            current = +''
-          end
+        finalize_statements(statements, current)
+      end
+
+      def process_sql_line(line, statements, current, in_block)
+        stripped = line.strip
+        in_block = true if begin_block?(stripped)
+        current << line
+
+        if in_block && stripped.match?(/\bEND\b\s*;?\s*$/i)
+          statements << current.strip.chomp(';')
+          [false, +'']
+        elsif !in_block && stripped.end_with?(';')
+          append_statement(statements, current)
+          [false, +'']
+        else
+          [in_block, current]
         end
+      end
+
+      def begin_block?(stripped)
+        stripped.match?(/\bBEGIN\b/i) &&
+          !stripped.match?(/\ABEGIN\s+(IMMEDIATE|DEFERRED|EXCLUSIVE)/i)
+      end
+
+      def append_statement(statements, current)
+        stmt = current.strip.chomp(';').strip
+        return if stmt.empty? || (stmt.match?(/\A\s*--/) && !stmt.include?("\n"))
 
-        # Handle any remaining content
+        statements << stmt
+      end
+
+      def finalize_statements(statements, current)
         remainder = current.strip.chomp(';').strip
         statements << remainder unless remainder.empty?
 
-        # Filter out comment-only statements
-        statements.reject { |s| s.lines.all? { |l| l.strip.empty? || l.strip.start_with?('--') } }
+        statements.reject { |s| comment_only?(s) }
+      end
+
+      def comment_only?(stmt)
+        stmt.lines.all? { |l| l.strip.empty? || l.strip.start_with?('--') }
       end
 
       # Extracts the version number and name from a migration filename.

data/lib/rubyn_code/hooks/built_in.rb

@@ -25,20 +25,24 @@ module RubynCode
           usage = response[:usage] || response['usage']
           return unless usage
 
-          model          = response[:model] || response['model'] || 'unknown'
-          input_tokens   = usage[:input_tokens] || usage['input_tokens'] || 0
-          output_tokens  = usage[:output_tokens] || usage['output_tokens'] || 0
-          cache_read     = usage[:cache_read_input_tokens] || usage['cache_read_input_tokens'] || 0
-          cache_write    = usage[:cache_creation_input_tokens] || usage['cache_creation_input_tokens'] || 0
+          record_usage(response, usage)
+        end
+
+        private
 
+        def record_usage(response, usage)
           @budget_enforcer.record!(
-            model: model,
-            input_tokens: input_tokens,
-            output_tokens: output_tokens,
-            cache_read_tokens: cache_read,
-            cache_write_tokens: cache_write
+            model: fetch_value(response, :model, 'unknown'),
+            input_tokens: fetch_value(usage, :input_tokens, 0),
+            output_tokens: fetch_value(usage, :output_tokens, 0),
+            cache_read_tokens: fetch_value(usage, :cache_read_input_tokens, 0),
+            cache_write_tokens: fetch_value(usage, :cache_creation_input_tokens, 0)
           )
         end
+
+        def fetch_value(hash, sym_key, default)
+          hash[sym_key] || hash[sym_key.to_s] || default
+        end
       end
 
       # Logs tool calls and their results via the formatter.

data/lib/rubyn_code/hooks/registry.rb

@@ -17,6 +17,10 @@ module RubynCode
         on_stall
         on_error
         on_session_end
+        session_start
+        user_prompt_submit
+        permission_request
+        stop
       ].freeze
 
       Hook = Data.define(:callable, :priority)