rubyn-code 0.2.2 → 0.3.0

data/lib/rubyn_code/tools/edit_file.rb

@@ -7,11 +7,15 @@ module RubynCode
   module Tools
     class EditFile < Base
       TOOL_NAME = 'edit_file'
-      DESCRIPTION = 'Performs exact string replacement in a file. Fails if old_text is not found or is ambiguous.'
+      DESCRIPTION = 'Performs exact string replacement in a file. ' \
+                    'Fails if old_text is not found or is ambiguous.'
       PARAMETERS = {
-        path: { type: :string, required: true, description: 'Path to the file to edit' },
-        old_text: { type: :string, required: true, description: 'The exact text to find and replace' },
-        new_text: { type: :string, required: true, description: 'The replacement text' },
+        path: { type: :string, required: true,
+                description: 'Path to the file to edit' },
+        old_text: { type: :string, required: true,
+                    description: 'The exact text to find and replace' },
+        new_text: { type: :string, required: true,
+                    description: 'The replacement text' },
         replace_all: { type: :boolean, required: false, default: false,
                        description: 'Replace all occurrences (default: false)' }
       }.freeze
@@ -22,25 +26,77 @@ module RubynCode
         resolved = read_file_safely(path)
         content = File.read(resolved)
 
-        occurrences = content.scan(old_text).length
+        validate_occurrences!(path, content, old_text, replace_all)
 
-        raise Error, "old_text not found in #{path}. No changes made." if occurrences.zero?
+        new_content = apply_replacement(content, old_text, new_text, replace_all)
+        File.write(resolved, new_content)
 
-        if !replace_all && occurrences > 1
-          raise Error,
-                "old_text found #{occurrences} times in #{path}. Use replace_all: true to replace all, or provide a more specific old_text."
-        end
+        format_diff_result(path, content, old_text, new_text, replace_all)
+      end
 
-        new_content = if replace_all
-                        content.gsub(old_text, new_text)
-                      else
-                        content.sub(old_text, new_text)
-                      end
+      private
 
-        File.write(resolved, new_content)
+      def validate_occurrences!(path, content, old_text, replace_all)
+        count = content.scan(old_text).length
+
+        raise Error, "old_text not found in #{path}. No changes made." if count.zero?
+
+        return if replace_all || count == 1
+
+        raise Error,
+              "old_text found #{count} times in #{path}. " \
+              'Use replace_all: true or provide more specific old_text.'
+      end
+
+      def apply_replacement(content, old_text, new_text, replace_all)
+        replace_all ? content.gsub(old_text, new_text) : content.sub(old_text, new_text)
+      end
+
+      CONTEXT_LINES = 3 # rubocop:disable Lint/UselessConstantScoping
+
+      def format_diff_result(path, original, old_text, new_text, replace_all)
+        count = replace_all ? original.scan(old_text).length : 1
+        lines = diff_header(path, count, original, old_text)
+        lines.concat(diff_body(original, old_text, new_text))
+        lines.join("\n")
+      end
+
+      def diff_header(path, count, original, old_text)
+        line_num = find_line_number(original, old_text)
+        header = ["Edited #{path} (#{count} replacement#{'s' if count > 1})"]
+        header << "  @@ line #{line_num} @@" if line_num
+        header
+      end
+
+      def diff_body(original, old_text, new_text)
+        lines = context_before(original, old_text)
+        old_text.lines.each { |l| lines << "  - #{l.chomp}" }
+        new_text.lines.each { |l| lines << "  + #{l.chomp}" }
+        lines.concat(context_after(original, old_text))
+      end
+
+      def context_before(content, text)
+        idx = content.index(text)
+        return [] unless idx
+
+        before = content[0...idx].lines.last(CONTEXT_LINES)
+        before.map { |l| "    #{l.chomp}" }
+      end
+
+      def context_after(content, text)
+        idx = content.index(text)
+        return [] unless idx
+
+        after_start = idx + text.length
+        after = content[after_start..].lines.first(CONTEXT_LINES)
+        after.map { |l| "    #{l.chomp}" }
+      end
+
+      def find_line_number(content, text)
+        idx = content.index(text)
+        return nil unless idx
 
-        replaced_count = replace_all ? occurrences : 1
-        "Successfully replaced #{replaced_count} occurrence#{'s' if replaced_count > 1} in #{path}"
+        content[0...idx].count("\n") + 1
       end
     end
 

data/lib/rubyn_code/tools/executor.rb

@@ -3,30 +3,27 @@
 module RubynCode
   module Tools
     class Executor
-      attr_reader :project_root
-      attr_accessor :llm_client, :background_worker, :on_agent_status, :db
+      attr_reader :project_root, :output_compressor, :file_cache
+      attr_accessor :llm_client, :background_worker, :on_agent_status, :db, :ask_user_callback
 
       def initialize(project_root:)
         @project_root = File.expand_path(project_root)
         @injections = {}
+        @output_compressor = OutputCompressor.new
+        @file_cache = FileCache.new
         Registry.load_all!
       end
 
-      def execute(tool_name, params)
-        tool_class = Registry.get(tool_name)
-        tool = tool_class.new(project_root: project_root)
-
-        # Inject dependencies for tools that need them
-        inject_dependencies(tool, tool_name)
+      def execute(tool_name, params) # rubocop:disable Metrics/AbcSize -- maps tool errors to results
+        # File cache intercept: serve cached reads, invalidate on writes
+        cached = try_file_cache(tool_name, params)
+        return cached if cached
 
-        symbolized = params.transform_keys(&:to_sym)
-        # Filter to only params the tool's execute method accepts — LLM may send extra keys
-        allowed = tool.method(:execute).parameters
-                      .select { |type, _| %i[key keyreq].include?(type) }
-                      .map(&:last)
-        filtered = allowed.empty? ? symbolized : symbolized.slice(*allowed)
-        result = tool.execute(**filtered)
-        tool.truncate(result.to_s)
+        tool = build_tool(tool_name)
+        filtered = filter_params(tool, params)
+        raw = tool.truncate(tool.execute(**filtered).to_s)
+        update_file_cache(tool_name, filtered, raw)
+        @output_compressor.compress(tool_name, raw)
       rescue ToolNotFoundError => e
         error_result("Tool error: #{e.message}")
       rescue PermissionDeniedError => e
@@ -45,20 +42,73 @@ module RubynCode
 
       private
 
-      def inject_dependencies(tool, tool_name)
+      def build_tool(tool_name)
+        tool_class = Registry.get(tool_name)
+        tool = tool_class.new(project_root: project_root)
+        inject_dependencies(tool, tool_name)
+        tool
+      end
+
+      def filter_params(tool, params)
+        symbolized = params.transform_keys(&:to_sym)
+        allowed = tool.method(:execute).parameters
+                      .select { |type, _| %i[key keyreq].include?(type) } # rubocop:disable Style/HashSlice
+                      .map(&:last)
+        allowed.empty? ? symbolized : symbolized.slice(*allowed)
+      end
+
+      def inject_dependencies(tool, tool_name) # rubocop:disable Metrics/CyclomaticComplexity -- tool-specific dependency injection
         case tool_name
-        when 'spawn_agent'
-          tool.llm_client = @llm_client if tool.respond_to?(:llm_client=)
-          tool.on_status = @on_agent_status if tool.respond_to?(:on_status=)
-        when 'spawn_teammate'
-          tool.llm_client = @llm_client if tool.respond_to?(:llm_client=)
-          tool.on_status = @on_agent_status if tool.respond_to?(:on_status=)
-          tool.db = @db if tool.respond_to?(:db=)
+        when 'spawn_agent', 'spawn_teammate'
+          inject_agent_deps(tool)
+          tool.db = @db if tool_name == 'spawn_teammate' && tool.respond_to?(:db=)
         when 'background_run'
           tool.background_worker = @background_worker if tool.respond_to?(:background_worker=)
+        when 'ask_user'
+          tool.prompt_callback = @ask_user_callback if tool.respond_to?(:prompt_callback=)
         end
       end
 
+      def inject_agent_deps(tool)
+        tool.llm_client = @llm_client if tool.respond_to?(:llm_client=)
+        tool.on_status = @on_agent_status if tool.respond_to?(:on_status=)
+      end
+
+      # Serve read_file from cache if the file hasn't changed.
+      def try_file_cache(tool_name, params)
+        return nil unless tool_name == 'read_file'
+
+        path = resolve_cache_path(params)
+        return nil unless path && @file_cache.cached?(path)
+
+        result = @file_cache.read(path)
+        result[:content]
+      rescue StandardError
+        nil
+      end
+
+      # Cache read_file results; invalidate on write_file/edit_file.
+      def update_file_cache(tool_name, params, _raw)
+        path = resolve_cache_path(params)
+        return unless path
+
+        case tool_name
+        when 'read_file' then @file_cache.read(path) # populates cache
+        when 'write_file', 'edit_file' then @file_cache.on_write(path)
+        end
+      rescue StandardError
+        nil
+      end
+
+      def resolve_cache_path(params)
+        p = params[:path] || params['path']
+        return nil unless p
+
+        File.expand_path(p, @project_root)
+      rescue StandardError
+        nil
+      end
+
       def error_result(message)
         message
       end

data/lib/rubyn_code/tools/file_cache.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module Tools
+    # Session-scoped file cache that serves previously-read file contents
+    # when the file has not been modified since the last read. Invalidates
+    # automatically when Rubyn writes or edits a file, or when mtime changes.
+    class FileCache
+      CHARS_PER_TOKEN = 4
+
+      Entry = Data.define(:content, :mtime, :token_count, :read_count, :cache_hits)
+
+      attr_reader :cache
+
+      def initialize
+        @cache = {}
+      end
+
+      # Returns cached content if the file hasn't changed, otherwise reads
+      # from disk and caches the result.
+      #
+      # @param path [String] absolute file path
+      # @return [Hash] { content:, source: :cache|:disk, tokens_saved: }
+      def read(path)
+        current_mtime = File.mtime(path)
+        cached = @cache[path]
+
+        if cached && cached.mtime == current_mtime
+          bump_hits(path)
+          { content: cached.content, source: :cache, tokens_saved: cached.token_count }
+        else
+          content = File.read(path)
+          token_count = estimate_tokens(content)
+          @cache[path] = Entry.new(
+            content: content, mtime: current_mtime,
+            token_count: token_count, read_count: 1, cache_hits: 0
+          )
+          { content: content, source: :disk, tokens_saved: 0 }
+        end
+      end
+
+      # Removes a path from the cache. Called when Rubyn writes/edits the file.
+      def invalidate(path)
+        @cache.delete(path)
+      end
+
+      # Alias for use as a write hook.
+      def on_write(path)
+        invalidate(path)
+      end
+
+      # Returns true if the given path is currently cached and fresh.
+      def cached?(path)
+        return false unless @cache.key?(path)
+
+        @cache[path].mtime == File.mtime(path)
+      rescue Errno::ENOENT
+        @cache.delete(path)
+        false
+      end
+
+      # Clears the entire cache.
+      def clear!
+        @cache.clear
+      end
+
+      # Returns aggregate statistics about cache performance.
+      def stats
+        total_reads = @cache.values.sum(&:read_count)
+        total_hits = @cache.values.sum(&:cache_hits)
+        tokens_saved = @cache.values.sum { |e| e.cache_hits * e.token_count }
+        hit_rate = total_reads.positive? ? total_hits.to_f / (total_reads + total_hits) : 0.0
+
+        {
+          entries: @cache.size,
+          total_reads: total_reads,
+          cache_hits: total_hits,
+          hit_rate: hit_rate.round(3),
+          tokens_saved: tokens_saved
+        }
+      end
+
+      private
+
+      def bump_hits(path)
+        old = @cache[path]
+        @cache[path] = old.with(cache_hits: old.cache_hits + 1)
+      end
+
+      def estimate_tokens(content)
+        (content.bytesize.to_f / CHARS_PER_TOKEN).ceil
+      end
+    end
+  end
+end

data/lib/rubyn_code/tools/git_commit.rb

@@ -58,21 +58,23 @@ module RubynCode
       def create_commit(message)
         stdout, stderr, status = safe_capture3('git', 'commit', '-m', message, chdir: project_root)
 
-        unless status.success?
-          return 'Nothing to commit — working tree is clean.' if stderr.include?('nothing to commit')
+        return handle_commit_failure(stdout, stderr) unless status.success?
 
-          raise Error, "Commit failed: #{stderr.strip}"
-        end
+        format_commit_output(stdout)
+      end
 
-        # Extract the commit hash from the output
-        commit_hash = extract_commit_hash
-        branch = current_branch
+      def handle_commit_failure(stdout, stderr)
+        output = "#{stdout}\n#{stderr}"
+        return 'Nothing to commit — working tree is clean.' if output.include?('nothing to commit')
 
-        lines = ["Committed on branch: #{branch}"]
-        lines << "Commit: #{commit_hash}" if commit_hash
+        raise Error, "Commit failed: #{stderr.strip.empty? ? stdout.strip : stderr.strip}"
+      end
+
+      def format_commit_output(stdout)
+        lines = ["Committed on branch: #{current_branch}"]
+        lines << "Commit: #{extract_commit_hash}" if extract_commit_hash
         lines << ''
         lines << stdout.strip
-
         lines.join("\n")
       end
 

data/lib/rubyn_code/tools/git_log.rb

@@ -18,26 +18,28 @@ module RubynCode
 
       def execute(count: 20, branch: nil)
         validate_git_repo!
+        stdout = run_git_log(count.to_i.clamp(1, 200), branch)
+        format_log_output(stdout, branch)
+      end
 
-        count = [[count.to_i, 1].max, 200].min
+      private
 
+      def run_git_log(count, branch)
         cmd = ['git', 'log', '--oneline', "-#{count}"]
         cmd << branch unless branch.nil? || branch.strip.empty?
 
         stdout, stderr, status = safe_capture3(*cmd, chdir: project_root)
-
         raise Error, "git log failed: #{stderr.strip}" unless status.success?
 
-        if stdout.strip.empty?
-          'No commits found.'
-        else
-          current = current_branch
-          header = "Commit history#{branch ? " (#{branch})" : " (#{current})"}:\n\n"
-          truncate("#{header}#{stdout}", max: 50_000)
-        end
+        stdout
       end
 
-      private
+      def format_log_output(stdout, branch)
+        return 'No commits found.' if stdout.strip.empty?
+
+        display_branch = branch || current_branch
+        truncate("Commit history (#{display_branch}):\n\n#{stdout}", max: 50_000)
+      end
 
       def validate_git_repo!
         _, _, status = safe_capture3('git', 'rev-parse', '--is-inside-work-tree', chdir: project_root)

data/lib/rubyn_code/tools/glob.rb

@@ -9,29 +9,45 @@ module RubynCode
       TOOL_NAME = 'glob'
       DESCRIPTION = 'File pattern matching. Returns sorted list of file paths matching the glob pattern.'
       PARAMETERS = {
-        pattern: { type: :string, required: true, description: "Glob pattern (e.g. '**/*.rb', 'app/**/*.erb')" },
-        path: { type: :string, required: false, description: 'Directory to search in (defaults to project root)' }
+        pattern: {
+          type: :string, required: true,
+          description: "Glob pattern (e.g. '**/*.rb', 'app/**/*.erb')"
+        },
+        path: {
+          type: :string, required: false,
+          description: 'Directory to search in (defaults to project root)'
+        }
       }.freeze
       RISK_LEVEL = :read
       REQUIRES_CONFIRMATION = false
 
       def execute(pattern:, path: nil)
-        search_dir = path ? safe_path(path) : project_root
-
-        raise Error, "Directory not found: #{path || project_root}" unless File.directory?(search_dir)
-
+        search_dir = resolve_search_dir(path)
         full_pattern = File.join(search_dir, pattern)
         matches = Dir.glob(full_pattern, File::FNM_DOTMATCH).sort
 
         matches
           .select { |f| File.file?(f) }
-          .reject { |f| (File.basename(f).start_with?('.') && File.basename(f) == '.') || File.basename(f) == '..' }
+          .reject { |f| dot_entry?(f) }
           .map { |f| relative_to_root(f) }
           .join("\n")
       end
 
       private
 
+      def resolve_search_dir(path)
+        search_dir = path ? safe_path(path) : project_root
+
+        raise Error, "Directory not found: #{path || project_root}" unless File.directory?(search_dir)
+
+        search_dir
+      end
+
+      def dot_entry?(file)
+        basename = File.basename(file)
+        ['.', '..'].include?(basename)
+      end
+
       def relative_to_root(absolute_path)
         absolute_path.delete_prefix("#{project_root}/")
       end

data/lib/rubyn_code/tools/grep.rb

@@ -7,7 +7,8 @@ module RubynCode
   module Tools
     class Grep < Base
       TOOL_NAME = 'grep'
-      DESCRIPTION = 'Searches file contents using regular expressions. Returns matching lines with file paths and line numbers.'
+      DESCRIPTION = 'Searches file contents using regular expressions. ' \
+                    'Returns matching lines with file paths and line numbers.'
       PARAMETERS = {
         pattern: { type: :string, required: true, description: 'Regular expression pattern to search for' },
         path: { type: :string, required: false,

data/lib/rubyn_code/tools/load_skill.rb

@@ -7,9 +7,11 @@ module RubynCode
   module Tools
     class LoadSkill < Base
       TOOL_NAME = 'load_skill'
-      DESCRIPTION = 'Loads a skill document into the conversation context. Use /skill-name or provide the skill name.'
+      DESCRIPTION = 'Loads a best-practice skill document into context. ' \
+                    'Pass the skill name (e.g. "shared-examples", "adapter", "request-specs").'
       PARAMETERS = {
-        name: { type: :string, required: true, description: 'Name of the skill to load' }
+        name: { type: :string, required: true,
+                description: 'Skill name, e.g. "adapter", "shared-examples", "request-specs"' }
       }.freeze
       RISK_LEVEL = :read
       REQUIRES_CONFIRMATION = false
@@ -20,18 +22,23 @@ module RubynCode
       end
 
       def execute(name:)
+        # Strip leading slash — LLM sometimes sends /skill-name
+        cleaned = name.to_s.sub(%r{\A/+}, '').strip
+        return 'Error: skill name required' if cleaned.empty?
+
         loader = @skill_loader || default_loader
-        loader.load(name)
+        loader.load(cleaned)
       end
 
       private
 
       def default_loader
         skills_dirs = [
-          File.join(project_root, '.rubyn', 'skills'),
-          File.join(Dir.home, '.rubyn', 'skills')
+          File.expand_path('../../../skills', __dir__), # bundled gem skills
+          File.join(project_root, '.rubyn-code', 'skills'), # project skills
+          File.join(Dir.home, '.rubyn-code', 'skills') # global user skills
         ]
-        catalog = Skills::Catalog.new(skills_dirs)
+        catalog = Skills::Catalog.new(skills_dirs.select { |d| Dir.exist?(d) })
         Skills::Loader.new(catalog)
       end
     end

data/lib/rubyn_code/tools/memory_search.rb

@@ -14,7 +14,8 @@ module RubynCode
         query: { type: :string, required: true, description: 'Search query for finding relevant memories' },
         tier: { type: :string, required: false, description: 'Filter by memory tier: short, medium, or long' },
         category: { type: :string, required: false,
-                    description: 'Filter by category: code_pattern, user_preference, project_convention, error_resolution, or decision' },
+                    description: 'Filter by category: code_pattern, user_preference, ' \
+                                 'project_convention, error_resolution, or decision' },
         limit: { type: :integer, required: false, description: 'Maximum number of results to return (default 10)' }
       }.freeze
       RISK_LEVEL = :read
@@ -49,21 +50,21 @@ module RubynCode
       # @return [String]
       def format_results(records)
         lines = ["Found #{records.size} memor#{records.size == 1 ? 'y' : 'ies'}:\n"]
-
-        records.each_with_index do |record, idx|
-          lines << "--- Memory #{idx + 1} ---"
-          lines << "ID: #{record.id}"
-          lines << "Tier: #{record.tier} | Category: #{record.category || 'none'}"
-          lines << "Relevance: #{format('%.2f', record.relevance_score)} | Accessed: #{record.access_count} times"
-          lines << "Created: #{record.created_at}"
-          lines << ''
-          lines << record.content
-          lines << ''
-        end
-
+        records.each_with_index { |record, idx| lines.concat(format_single_memory(record, idx)) }
         lines.join("\n")
       end
 
+      def format_single_memory(record, idx)
+        [
+          "--- Memory #{idx + 1} ---",
+          "ID: #{record.id}",
+          "Tier: #{record.tier} | Category: #{record.category || 'none'}",
+          "Relevance: #{format('%.2f', record.relevance_score)} | Accessed: #{record.access_count} times",
+          "Created: #{record.created_at}",
+          '', record.content, ''
+        ]
+      end
+
       # Lazily resolves a Memory::Search instance from the project root.
       #
       # @return [Memory::Search]

data/lib/rubyn_code/tools/memory_write.rb

@@ -15,7 +15,8 @@ module RubynCode
         tier: { type: :string, required: false,
                 description: 'Memory retention tier: short, medium (default), or long' },
         category: { type: :string, required: false,
-                    description: 'Category: code_pattern, user_preference, project_convention, error_resolution, or decision' }
+                    description: 'Category: code_pattern, user_preference, ' \
+                                 'project_convention, error_resolution, or decision' }
       }.freeze
       RISK_LEVEL = :read # Memory is internal — no user approval needed