rubyn-code 0.5.0 → 0.7.0

data/lib/rubyn_code/memory/session_persistence.rb

@@ -7,39 +7,41 @@ module RubynCode
   module Memory
     # Saves and restores full conversation sessions to SQLite, enabling
     # session continuity across process restarts and session browsing.
-    class SessionPersistence
+    class SessionPersistence # rubocop:disable Metrics/ClassLength -- session CRUD + incremental message journal
       # @param db [DB::Connection] database connection
       def initialize(db)
         @db = db
+        # Per-session journal bookkeeping: how many messages are already
+        # persisted and their object identities, so append-only saves can be
+        # detected without comparing message contents.
+        @journal_state = {}
         ensure_table
       end
 
       # Persists a complete session snapshot.
       #
+      # Hot-path friendly: when the messages array has only grown since the
+      # last save for this session, the new messages are appended to the
+      # messages journal table instead of rewriting the whole JSON blob.
+      # The blob is only rewritten when history was replaced (compaction,
+      # undo, resume) or on the first save of a process.
+      #
       # @param attrs [Hash] session attributes:
       #   :session_id, :project_path, :messages (required);
       #   :title, :model, :metadata (optional)
       # @return [void]
       def save_session(session_id:, project_path:, messages:, **opts)
-        now = Time.now.utc.strftime('%Y-%m-%d %H:%M:%S')
-        messages_json = JSON.generate(messages)
-        meta_json = JSON.generate(opts.fetch(:metadata, {}))
-        title = opts[:title]
-        model = opts[:model]
-
-        insert_params = [session_id, project_path, title, model, messages_json, 'active', meta_json, now, now]
-        update_params = [messages_json, title, model, meta_json, now]
-
-        @db.execute(<<~SQL, insert_params + update_params)
-          INSERT INTO sessions (id, project_path, title, model, messages, status, metadata, created_at, updated_at)
-          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
-          ON CONFLICT(id) DO UPDATE SET
-            messages = ?,
-            title = COALESCE(?, title),
-            model = COALESCE(?, model),
-            metadata = ?,
-            updated_at = ?
-        SQL
+        if appendable?(session_id, messages)
+          append_to_journal(session_id, messages, opts)
+        else
+          snapshot_session(session_id, project_path, messages, opts)
+        end
+        remember_journal_state(session_id, messages)
+      rescue StandardError
+        # Journal append can fail (e.g. role CHECK constraint on legacy
+        # schemas) — fall back to a full snapshot.
+        snapshot_session(session_id, project_path, messages, opts)
+        remember_journal_state(session_id, messages)
       end
 
       # Loads a session by ID.
@@ -54,8 +56,10 @@ module RubynCode
         return nil if rows.empty?
 
         row = rows.first
+        blob_messages = parse_json_array(row['messages'])
+        blob_messages += journal_messages(session_id) if blob_messages.is_a?(Array)
         {
-          messages: parse_json_array(row['messages']),
+          messages: blob_messages,
           metadata: parse_json_hash(row['metadata']),
           title: row['title'],
           model: row['model'],
@@ -103,6 +107,7 @@ module RubynCode
         params << session_id
 
         @db.execute("UPDATE sessions SET #{sets.join(', ')} WHERE id = ?", params)
+        clear_journal(session_id) if attrs.key?(:messages)
       end
 
       # Deletes a session permanently.
@@ -110,6 +115,7 @@ module RubynCode
       # @param session_id [String]
       # @return [void]
       def delete_session(session_id)
+        clear_journal(session_id)
         @db.execute('DELETE FROM sessions WHERE id = ?', [session_id])
       end
 
@@ -118,6 +124,109 @@ module RubynCode
 
       private
 
+      # ── Incremental persistence ───────────────────────────────────────
+
+      # True when this process has already persisted a prefix of +messages+
+      # for the session and the prefix is unchanged, so only the tail needs
+      # to be written. Compares object identities — compaction/undo/resume
+      # replace message objects, which forces a snapshot.
+      def appendable?(session_id, messages)
+        state = @journal_state[session_id]
+        return false unless state
+        return false if messages.size < state[:count]
+
+        messages.first(state[:count]).map(&:object_id) == state[:ids]
+      end
+
+      def remember_journal_state(session_id, messages)
+        @journal_state[session_id] = {
+          count: messages.size,
+          ids: messages.map(&:object_id)
+        }
+      end
+
+      # Appends the not-yet-persisted tail of +messages+ to the journal
+      # table and touches the session row.
+      def append_to_journal(session_id, messages, opts)
+        new_messages = messages[@journal_state[session_id][:count]..] || []
+        now = Time.now.utc.strftime('%Y-%m-%d %H:%M:%S')
+
+        @db.transaction do
+          new_messages.each do |msg|
+            @db.execute(
+              'INSERT INTO messages (session_id, role, content, created_at) VALUES (?, ?, ?, ?)',
+              [session_id, msg[:role] || msg['role'], JSON.generate(msg), now]
+            )
+          end
+          touch_session(session_id, opts, now)
+        end
+      end
+
+      def touch_session(session_id, opts, now)
+        meta_json = opts.key?(:metadata) ? JSON.generate(opts[:metadata]) : nil
+        @db.execute(<<~SQL, [opts[:title], opts[:model], meta_json, now, session_id])
+          UPDATE sessions SET
+            title = COALESCE(?, title),
+            model = COALESCE(?, model),
+            metadata = COALESCE(?, metadata),
+            updated_at = ?
+          WHERE id = ?
+        SQL
+      end
+
+      # Writes the full messages blob and clears any journaled tail —
+      # the blob becomes the single source of truth again.
+      def snapshot_session(session_id, project_path, messages, opts)
+        now = Time.now.utc.strftime('%Y-%m-%d %H:%M:%S')
+        messages_json = JSON.generate(messages)
+        meta_json = JSON.generate(opts.fetch(:metadata, {}))
+        title = opts[:title]
+        model = opts[:model]
+
+        insert_params = [session_id, project_path, title, model, messages_json, 'active', meta_json, now, now]
+        update_params = [messages_json, title, model, meta_json, now]
+
+        @db.transaction do
+          @db.execute(<<~SQL, insert_params + update_params)
+            INSERT INTO sessions (id, project_path, title, model, messages, status, metadata, created_at, updated_at)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+            ON CONFLICT(id) DO UPDATE SET
+              messages = ?,
+              title = COALESCE(?, title),
+              model = COALESCE(?, model),
+              metadata = ?,
+              updated_at = ?
+          SQL
+          @db.execute('DELETE FROM messages WHERE session_id = ?', [session_id])
+        end
+      end
+
+      # Journaled messages appended after the last blob snapshot, in insert order.
+      def journal_messages(session_id)
+        rows = @db.query(
+          'SELECT content FROM messages WHERE session_id = ? ORDER BY id',
+          [session_id]
+        ).to_a
+        rows.filter_map { |row| parse_journal_row(row['content']) }
+      rescue StandardError
+        []
+      end
+
+      def parse_journal_row(raw)
+        return nil unless raw.is_a?(String)
+
+        JSON.parse(raw, symbolize_names: true)
+      rescue JSON::ParserError
+        nil
+      end
+
+      def clear_journal(session_id)
+        @journal_state.delete(session_id)
+        @db.execute('DELETE FROM messages WHERE session_id = ?', [session_id])
+      rescue StandardError
+        nil
+      end
+
       def build_list_filters(project_path, status)
         conditions = []
         params = []
@@ -161,6 +270,11 @@ module RubynCode
       end
 
       def ensure_table
+        ensure_sessions_table
+        ensure_messages_table
+      end
+
+      def ensure_sessions_table
         @db.execute(<<~SQL)
           CREATE TABLE IF NOT EXISTS sessions (
             id TEXT PRIMARY KEY,
@@ -182,6 +296,30 @@ module RubynCode
         # Column already exists — safe to continue
       end
 
+      # Journal table for incrementally persisted messages. Mirrors
+      # db/migrations/002_create_messages.sql for databases that predate it.
+      def ensure_messages_table
+        @db.execute(<<~SQL)
+          CREATE TABLE IF NOT EXISTS messages (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            session_id TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
+            role TEXT NOT NULL CHECK(role IN ('system','user','assistant')),
+            content TEXT,
+            tool_calls TEXT,
+            tool_use_id TEXT,
+            tool_name TEXT,
+            token_count INTEGER,
+            is_compacted INTEGER NOT NULL DEFAULT 0,
+            created_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ','now'))
+          )
+        SQL
+        @db.execute('CREATE INDEX IF NOT EXISTS idx_messages_session ON messages(session_id)')
+      rescue StandardError
+        # Table creation is best-effort — save_session falls back to
+        # full snapshots when the journal is unavailable.
+        nil
+      end
+
       # @param raw [String, Array, nil]
       # @return [Array]
       def parse_json_array(raw)

data/lib/rubyn_code/observability/cost_calculator.rb

@@ -9,7 +9,9 @@ module RubynCode
     module CostCalculator
       # Per-million-token rates: { model_prefix => [input_rate, output_rate] }
       PRICING = {
-        # Anthropic — Claude 4.6
+        # Anthropic — Claude 5 / 4.8 / 4.6
+        'claude-fable-5' => [10.00, 50.00],
+        'claude-opus-4-8' => [5.00, 25.00],
         'claude-haiku-4-5' => [1.00, 5.00],
         'claude-sonnet-4-6' => [3.00, 15.00],
         'claude-opus-4-6' => [15.00, 75.00],

data/lib/rubyn_code/output/diff_renderer.rb

@@ -4,10 +4,15 @@ require 'pastel'
 
 module RubynCode
   module Output
-    class DiffRenderer
+    class DiffRenderer # rubocop:disable Metrics/ClassLength -- LCS diff computation + hunk grouping + rendering
       # Immutable value object representing a single hunk in a unified diff.
       Hunk = Data.define(:old_start, :old_count, :new_start, :new_count, :lines)
 
+      # The LCS table is O(N×M) in time and memory. Beyond this many cells
+      # (after prefix/suffix trimming) the middle section is rendered as a
+      # plain delete-all/add-all block instead of a minimal diff.
+      MAX_LCS_CELLS = 1_000_000
+
       # Represents a single diff line with its type and content.
       DiffLine = Data.define(:type, :content) do
         def addition? = type == :add
@@ -79,11 +84,59 @@ module RubynCode
 
       # Computes unified-diff hunks using the Myers diff algorithm (simple LCS approach).
       def compute_hunks(old_lines, new_lines)
-        lcs_table = build_lcs_table(old_lines, new_lines)
-        raw_diff = backtrack_diff(lcs_table, old_lines, new_lines)
+        raw_diff = build_diff_ops(old_lines, new_lines)
         group_into_hunks(raw_diff, old_lines, new_lines)
       end
 
+      # Strips common prefix/suffix lines before running the quadratic LCS —
+      # for the typical "small edit in a large file" case this shrinks the
+      # table from O(file²) to O(change²) — then re-offsets the middle ops
+      # back to absolute line indices.
+      def build_diff_ops(old_lines, new_lines)
+        prefix = common_prefix_length(old_lines, new_lines)
+        suffix = common_suffix_length(old_lines, new_lines, prefix)
+
+        old_mid = old_lines[prefix...(old_lines.size - suffix)]
+        new_mid = new_lines[prefix...(new_lines.size - suffix)]
+
+        ops = Array.new(prefix) { |i| [:equal, i, i] }
+        middle_diff_ops(old_mid, new_mid).each do |op, old_idx, new_idx|
+          ops << [op, old_idx && (old_idx + prefix), new_idx && (new_idx + prefix)]
+        end
+        suffix.times do |i|
+          ops << [:equal, old_lines.size - suffix + i, new_lines.size - suffix + i]
+        end
+        ops
+      end
+
+      def middle_diff_ops(old_mid, new_mid)
+        return oversized_diff_ops(old_mid, new_mid) if old_mid.size * new_mid.size > MAX_LCS_CELLS
+
+        table = build_lcs_table(old_mid, new_mid)
+        backtrack_diff(table, old_mid, new_mid)
+      end
+
+      # Fallback for diffs too large for the LCS table: treat the whole
+      # middle section as replaced.
+      def oversized_diff_ops(old_mid, new_mid)
+        Array.new(old_mid.size) { |i| [:delete, i, nil] } +
+          Array.new(new_mid.size) { |i| [:add, nil, i] }
+      end
+
+      def common_prefix_length(old_lines, new_lines)
+        max = [old_lines.size, new_lines.size].min
+        count = 0
+        count += 1 while count < max && old_lines[count] == new_lines[count]
+        count
+      end
+
+      def common_suffix_length(old_lines, new_lines, prefix)
+        max = [old_lines.size, new_lines.size].min - prefix
+        count = 0
+        count += 1 while count < max && old_lines[-1 - count] == new_lines[-1 - count]
+        count
+      end
+
       # Builds the LCS length table for two arrays of lines.
       def build_lcs_table(old_lines, new_lines)
         row_count = old_lines.size
@@ -110,6 +163,8 @@ module RubynCode
 
       # Backtracks through the LCS table to produce a sequence of diff operations.
       # Returns an array of [:equal, :delete, :add] paired with line indices.
+      # Ops are collected in reverse (backtracking walks end-to-start) and
+      # flipped once at the end — unshift per op would be O(n²).
       def backtrack_diff(table, old_lines, new_lines)
         result = []
         old_idx = old_lines.size
@@ -119,18 +174,18 @@ module RubynCode
           old_idx, new_idx = backtrack_step(result, table, old_lines, new_lines, old_idx, new_idx)
         end
 
-        result
+        result.reverse!
       end
 
       def backtrack_step(result, table, old_lines, new_lines, old_idx, new_idx) # rubocop:disable Metrics/ParameterLists -- LCS backtrack step requires all state
         if lines_match?(old_lines, new_lines, old_idx, new_idx)
-          result.unshift([:equal, old_idx - 1, new_idx - 1])
+          result << [:equal, old_idx - 1, new_idx - 1]
           [old_idx - 1, new_idx - 1]
         elsif new_idx.positive? && (old_idx.zero? || table[old_idx][new_idx - 1] >= table[old_idx - 1][new_idx])
-          result.unshift([:add, nil, new_idx - 1])
+          result << [:add, nil, new_idx - 1]
           [old_idx, new_idx - 1]
         else
-          result.unshift([:delete, old_idx - 1, nil])
+          result << [:delete, old_idx - 1, nil]
           [old_idx - 1, new_idx]
         end
       end

data/lib/rubyn_code/skills/auto_suggest.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'digest'
 require 'json'
 require_relative 'gemfile_parser'
 
@@ -10,14 +11,43 @@ module RubynCode
     # On session start, parses the Gemfile, queries the registry for matching
     # packs, and shows a one-time suggestion. Tracks shown suggestions in
     # `.rubyn-code/suggested.json` to avoid repeating.
+    #
+    # The registry lookup runs in a background thread (see #start) and
+    # responses are cached in `.rubyn-code/suggestions_cache.json` keyed by
+    # the Gemfile's gem list, so session start never blocks on the network.
     class AutoSuggest
       SUGGESTED_FILE = 'suggested.json'
+      CACHE_FILE = 'suggestions_cache.json'
+      CACHE_TTL = 86_400 # 24 hours
+      FETCH_TIMEOUT = 3
 
       # @param project_root [String]
       # @param registry_client [RegistryClient]
       def initialize(project_root:, registry_client: nil)
         @project_root = project_root
-        @client = registry_client || RegistryClient.new
+        @client = registry_client || RegistryClient.new(timeout: FETCH_TIMEOUT)
+        @thread = nil
+      end
+
+      # Kicks off the suggestion check in a background thread.
+      # Call `pending_message` later to collect the result without blocking.
+      def start
+        @thread = Thread.new { @message = check }
+        @thread.abort_on_exception = false
+      end
+
+      # Non-blocking: returns the suggestion message once the background
+      # check has finished, nil while it's still running or after the
+      # message has already been consumed.
+      #
+      # @return [String, nil]
+      def pending_message
+        return nil unless @thread
+        return nil if @thread.alive?
+
+        message = @message
+        @message = nil
+        message
       end
 
       # Check for suggestable packs and return a display message if any.
@@ -75,11 +105,49 @@ module RubynCode
       end
 
       def fetch_suggestions(gems)
-        @client.fetch_suggestions(gems)
+        cached = read_suggestions_cache(gems)
+        return cached if cached
+
+        suggestions = @client.fetch_suggestions(gems)
+        write_suggestions_cache(gems, suggestions)
+        suggestions
       rescue RegistryError
         []
       end
 
+      def read_suggestions_cache(gems)
+        path = cache_path
+        return nil unless File.exist?(path)
+
+        data = JSON.parse(File.read(path))
+        return nil unless data['gemfile_hash'] == gemfile_hash(gems)
+        return nil if (Time.now.to_i - data['fetched_at'].to_i) > CACHE_TTL
+
+        suggestions = data['suggestions']
+        suggestions.is_a?(Array) ? suggestions : nil
+      rescue StandardError
+        nil
+      end
+
+      def write_suggestions_cache(gems, suggestions)
+        FileUtils.mkdir_p(File.dirname(cache_path))
+        File.write(cache_path, JSON.pretty_generate(
+                                 'gemfile_hash' => gemfile_hash(gems),
+                                 'fetched_at' => Time.now.to_i,
+                                 'suggestions' => suggestions
+                               ))
+      rescue StandardError
+        # Best effort — caching failures must never break suggestions
+      end
+
+      def gemfile_hash(gems)
+        Digest::SHA256.hexdigest(gems.sort.join(','))
+      end
+
+      def cache_path
+        File.join(@project_root, '.rubyn-code', CACHE_FILE)
+      end
+
       def filter_shown(suggestions)
         state = load_state
         shown = Array(state['shown'])

data/lib/rubyn_code/skills/registry_client.rb

@@ -17,8 +17,9 @@ module RubynCode
 
       attr_reader :base_url
 
-      def initialize(base_url: nil)
+      def initialize(base_url: nil, timeout: TIMEOUT_SECONDS)
         @base_url = base_url || ENV.fetch('RUBYN_REGISTRY_URL', DEFAULT_BASE_URL)
+        @timeout = timeout
       end
 
       # List all available packs (returns flat array for CLI commands).
@@ -138,8 +139,8 @@ module RubynCode
         @connection ||= Faraday.new(url: base_url) do |f|
           f.request :url_encoded
           f.response :raise_error
-          f.options.timeout = TIMEOUT_SECONDS
-          f.options.open_timeout = TIMEOUT_SECONDS
+          f.options.timeout = @timeout
+          f.options.open_timeout = @timeout
           f.headers['Accept'] = 'application/json'
           f.headers['User-Accept'] = USER_ACCEPT_HEADER
           f.headers['User-Agent'] = "rubyn-code/#{RubynCode::VERSION}"

data/lib/rubyn_code/sub_agents/agent_type.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module SubAgents
+    # A sub-agent type: the built-in `explore`/`worker`, or a user-defined
+    # agent loaded from .rubyn-code/agents/*.md. Captures everything
+    # spawn_agent needs to run it — display name, system prompt, the tool
+    # allowlist (nil = access-based default), access level, and turn budget.
+    AgentType = Data.define(:name, :description, :system_prompt, :tool_names, :access, :max_iterations) do
+      # @return [Boolean] read-only agents may only call read-risk tools
+      def read_only? = access == :read
+
+      # @return [Boolean]
+      def custom? = !%w[explore worker].include?(name)
+    end
+  end
+end

data/lib/rubyn_code/sub_agents/catalog.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+module RubynCode
+  module SubAgents
+    # Resolves sub-agent types by name. Ships the built-in `explore` and
+    # `worker` agents and discovers user-defined ones from markdown files,
+    # mirroring Claude Code's `.claude/agents/*.md`:
+    #
+    #   <project>/.rubyn-code/agents/*.md   (project-local, takes priority)
+    #   ~/.rubyn-code/agents/*.md           (user-global)
+    #
+    # Frontmatter (all optional except a sensible default name):
+    #   name: reviewer
+    #   description: Reviews a diff for bugs
+    #   tools: read_file, grep, glob, bash   # omit → access-based default set
+    #   access: read                         # read | write (default: write)
+    # The markdown body becomes the agent's system prompt.
+    class Catalog
+      FRONTMATTER = /\A---\s*\n(.+?\n)---\s*\n(.*)\z/m
+      NAME = /\A[a-z0-9][a-z0-9_-]*\z/i
+
+      BASE_PROMPT = 'You are a Rubyn sub-agent. Complete your task efficiently and ' \
+                    'return a clear summary of what you found or did.'
+      EXPLORE_PROMPT = "#{BASE_PROMPT}\nYou have read-only access. Search, read files, and analyze. " \
+                       'Do NOT attempt to write or modify anything.'.freeze
+      WORKER_PROMPT = "#{BASE_PROMPT}\nYou have full read/write access. Make the changes needed, " \
+                      'run tests if appropriate, and report what you did.'.freeze
+
+      def initialize(project_root: nil, home_dir: Config::Defaults::HOME_DIR)
+        @project_root = project_root
+        @home_dir = home_dir
+        @custom = load_custom
+      end
+
+      # @param name [String, Symbol]
+      # @return [AgentType, nil]
+      def get(name)
+        key = name.to_s
+        builtin[key] || @custom[key]
+      end
+
+      # @return [Array<AgentType>] all known agents (built-ins first)
+      def all
+        builtin.values + @custom.values
+      end
+
+      # @return [Array<String>]
+      def custom_names = @custom.keys
+
+      private
+
+      def builtin
+        {
+          'explore' => AgentType.new(
+            name: 'explore', description: 'Read-only research/reading agent',
+            system_prompt: EXPLORE_PROMPT, tool_names: nil, access: :read,
+            max_iterations: Config::Defaults::MAX_EXPLORE_AGENT_ITERATIONS
+          ),
+          'worker' => AgentType.new(
+            name: 'worker', description: 'Full read/write coding agent',
+            system_prompt: WORKER_PROMPT, tool_names: nil, access: :write,
+            max_iterations: Config::Defaults::MAX_SUB_AGENT_ITERATIONS
+          )
+        }
+      end
+
+      def load_custom
+        dirs = [
+          @project_root && File.join(@project_root, '.rubyn-code', 'agents'),
+          File.join(@home_dir, 'agents')
+        ].compact
+
+        dirs.flat_map { |dir| load_dir(dir) }
+            .each_with_object({}) { |agent, acc| acc[agent.name] ||= agent }
+      end
+
+      def load_dir(dir)
+        return [] unless Dir.exist?(dir)
+
+        Dir.glob(File.join(dir, '*.md')).filter_map { |path| build(path) }
+      end
+
+      def build(path)
+        frontmatter, body = parse(File.read(path))
+        name = (frontmatter['name'] || File.basename(path, '.md')).to_s.strip
+        return nil unless name.match?(NAME) && !builtin.key?(name)
+
+        access = frontmatter['access'].to_s.downcase == 'read' ? :read : :write
+        desc = frontmatter['description'].to_s
+        AgentType.new(
+          name: name,
+          description: desc.empty? ? "Custom agent: #{name}" : desc,
+          system_prompt: body.empty? ? BASE_PROMPT : body,
+          tool_names: parse_tools(frontmatter['tools']),
+          access: access,
+          max_iterations: default_iterations(access)
+        )
+      rescue StandardError => e
+        RubynCode::Debug.warn("Failed to load custom agent #{path}: #{e.message}")
+        nil
+      end
+
+      def parse(content)
+        match = FRONTMATTER.match(content)
+        return [{}, content.to_s.strip] unless match
+
+        [YAML.safe_load(match[1]) || {}, match[2].to_s.strip]
+      end
+
+      def parse_tools(value)
+        case value
+        when Array then value.map(&:to_s)
+        when String then value.split(/[,\s]+/).reject(&:empty?)
+        end
+      end
+
+      def default_iterations(access)
+        access == :read ? Config::Defaults::MAX_EXPLORE_AGENT_ITERATIONS : Config::Defaults::MAX_SUB_AGENT_ITERATIONS
+      end
+    end
+  end
+end