rubyn-code 0.1.0

data/lib/rubyn_code/context/manual_compact.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require "json"
+require "fileutils"
+
+module RubynCode
+  module Context
+    # LLM-driven summarization triggered explicitly by the user or agent via the
+    # /compact command. Identical to AutoCompact but supports an optional custom
+    # focus prompt so the user can steer what gets preserved.
+    module ManualCompact
+      BASE_INSTRUCTION = <<~PROMPT
+        You are a context compaction assistant. Summarize the following conversation transcript for continuity. Cover exactly three areas:
+
+        1) **What was accomplished** - completed tasks, files changed, problems solved
+        2) **Current state** - what the user/agent is working on right now, any pending actions
+        3) **Key decisions made** - architectural choices, user preferences, constraints established
+
+        Be concise but preserve all details needed to continue the work seamlessly. Use bullet points.
+      PROMPT
+
+      MAX_TRANSCRIPT_CHARS = 80_000
+
+      # Compacts the conversation by summarizing it through the LLM.
+      #
+      # @param messages [Array<Hash>] current conversation messages
+      # @param llm_client [#chat] an LLM client that responds to #chat
+      # @param transcript_dir [String, nil] directory to save full transcript before compaction
+      # @param focus [String, nil] optional user-supplied focus prompt to guide summarization
+      # @return [Array<Hash>] new messages array containing only the summary
+      def self.call(messages, llm_client:, transcript_dir: nil, focus: nil)
+        save_transcript(messages, transcript_dir) if transcript_dir
+
+        transcript_text = serialize_tail(messages, MAX_TRANSCRIPT_CHARS)
+        instruction = build_instruction(focus)
+        summary = request_summary(transcript_text, instruction, llm_client)
+
+        [{ role: "user", content: "[Context compacted — manual]\n\n#{summary}" }]
+      end
+
+      def self.build_instruction(focus)
+        return BASE_INSTRUCTION if focus.nil? || focus.strip.empty?
+
+        "#{BASE_INSTRUCTION}\nAdditional focus: #{focus}"
+      end
+
+      def self.save_transcript(messages, dir)
+        FileUtils.mkdir_p(dir)
+        timestamp = Time.now.strftime("%Y%m%d_%H%M%S")
+        path = File.join(dir, "transcript_manual_#{timestamp}.json")
+        File.write(path, JSON.pretty_generate(messages))
+        path
+      end
+
+      def self.serialize_tail(messages, max_chars)
+        json = JSON.generate(messages)
+        return json if json.length <= max_chars
+
+        json[-max_chars..]
+      end
+
+      def self.request_summary(transcript_text, instruction, llm_client)
+        summary_messages = [
+          {
+            role: "user",
+            content: "#{instruction}\n\n---\n\n#{transcript_text}"
+          }
+        ]
+
+        options = {}
+        options[:model] = "claude-sonnet-4-20250514" if llm_client.respond_to?(:chat)
+
+        response = llm_client.chat(messages: summary_messages, **options)
+
+        case response
+        when String then response
+        when Hash then response[:content] || response["content"] || response.to_s
+        else
+          response.respond_to?(:text) ? response.text : response.to_s
+        end
+      end
+
+      private_class_method :build_instruction, :save_transcript,
+                           :serialize_tail, :request_summary
+    end
+  end
+end

data/lib/rubyn_code/context/micro_compact.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module Context
+    # Zero-cost compression that runs every turn. Replaces old tool results
+    # (except the most recent N) with short placeholders to reduce token count
+    # without losing conversational continuity.
+    module MicroCompact
+      PLACEHOLDER_TEMPLATE = "[Previous: used %<tool_name>s]"
+      MIN_CONTENT_LENGTH = 100
+
+      # Mutates +messages+ in place, replacing old tool_result content with
+      # compact placeholders.
+      #
+      # @param messages [Array<Hash>] the conversation messages array
+      # @param keep_recent [Integer] number of most-recent tool results to preserve
+      # @param preserve_tools [Array<String>] tool names whose results are never compacted
+      # @return [Integer] count of compacted tool results
+      def self.call(messages, keep_recent: 3, preserve_tools: ["read_file"])
+        tool_result_refs = collect_tool_results(messages)
+        return 0 if tool_result_refs.size <= keep_recent
+
+        tool_name_index = build_tool_name_index(messages)
+        candidates = tool_result_refs[0..-(keep_recent + 1)]
+        compacted = 0
+
+        candidates.each do |ref|
+          block = ref[:block]
+          content = extract_content(block)
+          next if content.nil? || content.length < MIN_CONTENT_LENGTH
+
+          tool_name = resolve_tool_name(block, tool_name_index)
+          next if preserve_tools.include?(tool_name)
+
+          placeholder = format(PLACEHOLDER_TEMPLATE, tool_name: tool_name || "tool")
+          replace_content!(block, placeholder)
+          compacted += 1
+        end
+
+        compacted
+      end
+
+      # Collects all tool_result content blocks across user messages, preserving
+      # encounter order so the most recent ones can be kept intact.
+      #
+      # @return [Array<Hash>] each entry has :message, :block, :index keys
+      def self.collect_tool_results(messages)
+        refs = []
+
+        messages.each do |msg|
+          next unless msg[:role] == "user" && msg[:content].is_a?(Array)
+
+          msg[:content].each_with_index do |block, idx|
+            next unless tool_result_block?(block)
+
+            refs << { message: msg, block: block, index: idx }
+          end
+        end
+
+        refs
+      end
+
+      # Builds a lookup from tool_use_id to tool name by scanning assistant
+      # messages for tool_use blocks.
+      #
+      # @return [Hash{String => String}]
+      def self.build_tool_name_index(messages)
+        index = {}
+
+        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
+        end
+
+        index
+      end
+
+      def self.tool_result_block?(block)
+        case block
+        when Hash
+          block_type(block) == "tool_result"
+        when LLM::ToolResultBlock
+          true
+        else
+          false
+        end
+      end
+
+      def self.block_type(hash)
+        hash[:type] || hash["type"]
+      end
+
+      def self.extract_content(block)
+        case block
+        when Hash
+          val = block[:content] || block["content"]
+          val.is_a?(String) ? val : val.to_s
+        when LLM::ToolResultBlock
+          block.content.to_s
+        end
+      end
+
+      def self.resolve_tool_name(block, index)
+        tool_use_id = case block
+                      when Hash then block[:tool_use_id] || block["tool_use_id"]
+                      when LLM::ToolResultBlock then block.tool_use_id
+                      end
+
+        index[tool_use_id]
+      end
+
+      def self.replace_content!(block, placeholder)
+        case block
+        when Hash
+          key = block.key?(:content) ? :content : "content"
+          block[key] = placeholder
+        end
+        # Note: Data.define instances are frozen; for ToolResultBlock objects
+        # we rely on messages being stored as hashes in the conversation array.
+      end
+
+      private_class_method :collect_tool_results, :build_tool_name_index,
+                           :tool_result_block?, :block_type, :extract_content,
+                           :resolve_tool_name, :replace_content!
+    end
+  end
+end

data/lib/rubyn_code/db/connection.rb

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+require "sqlite3"
+require "monitor"
+require "fileutils"
+
+module RubynCode
+  module DB
+    # Manages a singleton SQLite3 database connection with WAL mode,
+    # foreign keys, and thread-safe access.
+    class Connection
+      include MonitorMixin
+
+      class << self
+        # Returns the singleton Connection instance, optionally initializing
+        # it with the given database path on first call.
+        #
+        # @param path [String] path to the SQLite3 database file
+        # @return [Connection]
+        def instance(path = nil)
+          @mutex ||= Mutex.new
+          @mutex.synchronize do
+            if @instance.nil?
+              path ||= Config::Defaults::DB_FILE
+              FileUtils.mkdir_p(File.dirname(path))
+              @instance = new(path)
+            end
+            @instance
+          end
+        end
+
+        # Executes a write statement (INSERT, UPDATE, DELETE, DDL).
+        #
+        # @param sql [String] the SQL statement
+        # @param params [Array] bind parameters
+        # @return [void]
+        def execute(sql, params = [])
+          instance.execute(sql, params)
+        end
+
+        # Executes a read query and returns rows as hashes.
+        #
+        # @param sql [String] the SQL query
+        # @param params [Array] bind parameters
+        # @return [Array<Hash>]
+        def query(sql, params = [])
+          instance.query(sql, params)
+        end
+
+        # Wraps a block in a database transaction with automatic
+        # commit/rollback semantics. Supports nested calls via SAVEPOINTs.
+        #
+        # @yield the block to execute within the transaction
+        # @return [Object] the return value of the block
+        def transaction(&block)
+          instance.transaction(&block)
+        end
+
+        # Tears down the singleton instance. Intended for test cleanup.
+        #
+        # @return [void]
+        def reset!
+          @mutex ||= Mutex.new
+          @mutex.synchronize do
+            if @instance
+              @instance.close
+              @instance = nil
+            end
+          end
+        end
+      end
+
+      # @param path [String] path to the SQLite3 database file
+      def initialize(path)
+        super() # MonitorMixin
+        @path = path
+        @db = SQLite3::Database.new(path)
+        @transaction_depth = 0
+        configure_connection
+      end
+
+      # Executes a write statement with bind parameters.
+      #
+      # @param sql [String]
+      # @param params [Array]
+      # @return [void]
+      def execute(sql, params = [])
+        synchronize do
+          @db.execute(sql, params)
+        end
+      end
+
+      # Executes a read query and returns all matching rows.
+      #
+      # @param sql [String]
+      # @param params [Array]
+      # @return [Array<Hash>]
+      def query(sql, params = [])
+        synchronize do
+          @db.execute(sql, params)
+        end
+      end
+
+      # Wraps a block in a transaction. Nested calls use SAVEPOINTs
+      # to avoid SQLite "cannot start a transaction within a transaction" errors.
+      #
+      # @yield the block to execute
+      # @return [Object] the block's return value
+      def transaction
+        synchronize do
+          if @transaction_depth.zero?
+            begin_top_level_transaction
+          else
+            begin_savepoint
+          end
+
+          @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
+        end
+      end
+
+      # Closes the underlying database connection.
+      #
+      # @return [void]
+      def close
+        synchronize do
+          @db.close unless @db.closed?
+        end
+      end
+
+      # Returns whether the connection is open.
+      #
+      # @return [Boolean]
+      def open?
+        !@db.closed?
+      end
+
+      private
+
+      def configure_connection
+        @db.results_as_hash = true
+        @db.execute("PRAGMA journal_mode = WAL")
+        @db.execute("PRAGMA foreign_keys = ON")
+        @db.execute("PRAGMA busy_timeout = 5000")
+        @db.execute("PRAGMA synchronous = NORMAL")
+        @db.execute("PRAGMA cache_size = -20000") # 20 MB
+      end
+
+      def begin_top_level_transaction
+        @db.execute("BEGIN IMMEDIATE")
+      end
+
+      def begin_savepoint
+        @db.execute("SAVEPOINT sp_#{@transaction_depth + 1}")
+      end
+    end
+  end
+end

data/lib/rubyn_code/db/migrator.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module DB
+    # Reads SQL migration files from db/migrations/, tracks applied versions
+    # in a schema_migrations table, and applies new migrations in order.
+    class Migrator
+      # @return [String] absolute path to the migrations directory
+      MIGRATIONS_DIR = File.expand_path("../../../db/migrations", __dir__).freeze
+
+      # @param connection [Connection] the database connection to migrate
+      def initialize(connection)
+        @connection = connection
+        ensure_schema_migrations_table
+      end
+
+      # Applies all pending migrations in version order.
+      #
+      # @return [Array<Integer>] list of newly applied migration versions
+      def migrate!
+        pending = pending_migrations
+        return [] if pending.empty?
+
+        applied = []
+        pending.each do |version, path|
+          apply_migration(version, path)
+          applied << version
+        end
+        applied
+      end
+
+      # Returns migration versions that have not yet been applied.
+      #
+      # @return [Array<Array(Integer, String)>] pairs of [version, file_path]
+      def pending_migrations
+        applied = applied_versions
+        available_migrations.reject { |version, _| applied.include?(version) }
+      end
+
+      # Returns the set of already-applied migration versions.
+      #
+      # @return [Set<Integer>]
+      def applied_versions
+        rows = @connection.query(
+          "SELECT version FROM schema_migrations ORDER BY version"
+        ).to_a
+        rows.map { |row| row["version"] }.to_set
+      end
+
+      # Returns the current schema version (highest applied migration).
+      #
+      # @return [Integer, nil]
+      def current_version
+        row = @connection.query(
+          "SELECT MAX(version) AS max_version FROM schema_migrations"
+        ).to_a.first
+        row && row["max_version"]
+      end
+
+      # Lists all available migration files sorted by version.
+      #
+      # @return [Array<Array(Integer, String)>] pairs of [version, file_path]
+      def available_migrations
+        pattern = File.join(MIGRATIONS_DIR, "*.sql")
+        Dir.glob(pattern)
+           .map { |path| parse_migration_file(path) }
+           .compact
+           .sort_by(&:first)
+      end
+
+      private
+
+      def ensure_schema_migrations_table
+        @connection.execute(<<~SQL)
+          CREATE TABLE IF NOT EXISTS schema_migrations (
+            version INTEGER PRIMARY KEY,
+            applied_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ','now'))
+          )
+        SQL
+      end
+
+      def apply_migration(version, path)
+        sql = File.read(path)
+        @connection.transaction do
+          # Execute each statement separately (SQLite doesn't support multi-statement execute)
+          split_statements(sql).each do |statement|
+            @connection.execute(statement)
+          end
+          @connection.execute(
+            "INSERT INTO schema_migrations (version) VALUES (?)", [version]
+          )
+        end
+      end
+
+      # Splits a SQL file into individual statements, handling semicolons
+      # inside string literals and ignoring empty/comment-only fragments.
+      #
+      # @param sql [String]
+      # @return [Array<String>]
+      def split_statements(sql)
+        statements = []
+        current = +""
+        in_block = false
+
+        sql.each_line do |line|
+          stripped = line.strip
+
+          # Track BEGIN/END blocks (e.g., triggers)
+          in_block = true if stripped.match?(/\bBEGIN\b/i) && !stripped.match?(/\ABEGIN\s+(IMMEDIATE|DEFERRED|EXCLUSIVE)/i)
+          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
+        end
+
+        # Handle any remaining content
+        remainder = current.strip.chomp(";").strip
+        statements << remainder unless remainder.empty?
+
+        statements
+      end
+
+      # Extracts the version number and name from a migration filename.
+      #
+      # @param path [String]
+      # @return [Array(Integer, String), nil]
+      def parse_migration_file(path)
+        basename = File.basename(path, ".sql")
+        match = basename.match(/\A(\d+)_/)
+        return nil unless match
+
+        version = match[1].to_i
+        [version, path]
+      end
+    end
+  end
+end

data/lib/rubyn_code/db/schema.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module DB
+    # Provides schema introspection helpers and version checking
+    # for the database.
+    class Schema
+      # @param connection [Connection] the database connection
+      def initialize(connection)
+        @connection = connection
+      end
+
+      # Returns the current schema version (highest applied migration).
+      #
+      # @return [Integer, nil] the version number, or nil if no migrations applied
+      def current_version
+        row = @connection.query(
+          "SELECT MAX(version) AS max_version FROM schema_migrations"
+        ).to_a.first
+        row && row["max_version"]
+      rescue StandardError
+        nil
+      end
+
+      # Returns all applied migration versions in order.
+      #
+      # @return [Array<Integer>]
+      def applied_versions
+        @connection.query(
+          "SELECT version FROM schema_migrations ORDER BY version"
+        ).to_a.map { |row| row["version"] }
+      rescue StandardError
+        []
+      end
+
+      # Checks whether a specific migration version has been applied.
+      #
+      # @param version [Integer]
+      # @return [Boolean]
+      def version_applied?(version)
+        rows = @connection.query(
+          "SELECT 1 FROM schema_migrations WHERE version = ?", [version]
+        ).to_a
+        !rows.empty?
+      rescue StandardError
+        false
+      end
+
+      # Returns a list of table names in the database (excluding internal SQLite tables).
+      #
+      # @return [Array<String>]
+      def tables
+        @connection.query(
+          "SELECT name FROM sqlite_master WHERE type = 'table' " \
+          "AND name NOT LIKE 'sqlite_%' ORDER BY name"
+        ).to_a.map { |row| row["name"] }
+      end
+
+      # Returns column information for the given table.
+      #
+      # @param table_name [String]
+      # @return [Array<Hash>] each hash has keys: cid, name, type, notnull, dflt_value, pk
+      def columns(table_name)
+        @connection.query("PRAGMA table_info(#{quote_identifier(table_name)})").to_a
+      end
+
+      # Returns index information for the given table.
+      #
+      # @param table_name [String]
+      # @return [Array<Hash>]
+      def indexes(table_name)
+        @connection.query("PRAGMA index_list(#{quote_identifier(table_name)})").to_a
+      end
+
+      # Checks whether a given table exists in the database.
+      #
+      # @param table_name [String]
+      # @return [Boolean]
+      def table_exists?(table_name)
+        rows = @connection.query(
+          "SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = ?",
+          [table_name]
+        ).to_a
+        !rows.empty?
+      end
+
+      # Returns true if the schema is up to date with all available migrations.
+      #
+      # @param migrator [Migrator]
+      # @return [Boolean]
+      def up_to_date?(migrator)
+        migrator.pending_migrations.empty?
+      end
+
+      private
+
+      # Safely quotes a SQL identifier to prevent injection.
+      #
+      # @param name [String]
+      # @return [String]
+      def quote_identifier(name)
+        "\"#{name.gsub('"', '""')}\""
+      end
+    end
+  end
+end