rubyn-code 0.2.2 → 0.4.0

data/lib/rubyn_code/tools/executor.rb

@@ -3,30 +3,30 @@
 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,
+                    :codebase_index, :ide_client
 
-      def initialize(project_root:)
+      def initialize(project_root:, ide_client: nil)
         @project_root = File.expand_path(project_root)
+        @ide_client = ide_client
         @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)
+        maybe_update_codebase_index(tool_name, filtered)
+        @output_compressor.compress(tool_name, raw)
       rescue ToolNotFoundError => e
         error_result("Tool error: #{e.message}")
       rescue PermissionDeniedError => e
@@ -43,20 +43,125 @@ module RubynCode
         Registry.tool_definitions
       end
 
+      # Patterns that indicate a bash command writes to a file.
+      BASH_WRITE_PATTERNS = [
+        /(?:>>?)\s*(\S+)/,            # > file  or  >> file
+        /\btee\s+(?:-a\s+)?(\S+)/,    # tee file  or  tee -a file
+        /\bsed\s+-i\S*\s+.*\s(\S+)$/, # sed -i 's/...' file
+        /\bsed\s+-i\S*\s+.*\s(\S+)\s/ # sed -i 's/...' file (mid-command)
+      ].freeze
+
       private
 
-      def inject_dependencies(tool, tool_name)
+      def build_tool(tool_name)
+        tool_class = Registry.get(tool_name)
+        # IDE-aware tools accept an ide_client parameter.
+        if @ide_client && tool_class.method(:new).parameters.any? { |_, name| name == :ide_client }
+          tool = tool_class.new(project_root: project_root, ide_client: @ide_client)
+        else
+          tool = tool_class.new(project_root: project_root)
+        end
+        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.
+      # Also detects bash commands that write to files (redirect, sed -i, tee).
+      def update_file_cache(tool_name, params, _raw)
+        path = resolve_cache_path(params)
+
+        case tool_name
+        when 'read_file'
+          @file_cache.read(path) if path # populates cache
+        when 'write_file', 'edit_file'
+          @file_cache.on_write(path) if path
+        when 'bash'
+          invalidate_bash_write_targets(params)
+        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
+
+      # Trigger an incremental codebase index update after writing a Ruby file.
+      # Non-blocking: if the update fails, log and continue.
+      def maybe_update_codebase_index(tool_name, params)
+        return unless %w[write_file edit_file].include?(tool_name)
+        return unless @codebase_index
+
+        path = resolve_cache_path(params)
+        return unless path&.end_with?('.rb')
+
+        @codebase_index.update!
+      rescue StandardError => e
+        RubynCode::Debug.warn("CodebaseIndex incremental update failed: #{e.message}")
+      end
+
+      # Detect file paths that a bash command may have written to and
+      # invalidate them from the file cache.
+      def invalidate_bash_write_targets(params)
+        command = params[:command] || params['command']
+        return unless command.is_a?(String)
+
+        paths = extract_bash_write_paths(command)
+        paths.each do |p|
+          resolved = File.expand_path(p, @project_root)
+          @file_cache.on_write(resolved)
+        end
+      end
+
+      def extract_bash_write_paths(command)
+        paths = []
+        BASH_WRITE_PATTERNS.each do |pattern|
+          command.scan(pattern) { |match| paths << match[0] if match[0] }
         end
+        paths.uniq
       end
 
       def error_result(message)

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,51 @@ 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)
+      def self.summarize(output, args)
+        pattern = args['pattern'] || args[:pattern] || ''
+        count = output.to_s.strip.empty? ? 0 : output.to_s.lines.count
+        "glob #{pattern} (#{count} files)"
+      end
 
+      def execute(pattern:, path: nil)
+        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,
@@ -19,6 +20,12 @@ module RubynCode
       RISK_LEVEL = :read
       REQUIRES_CONFIRMATION = false
 
+      def self.summarize(output, args)
+        pattern = args['pattern'] || args[:pattern] || ''
+        count = output.to_s.lines.count
+        count.zero? || output.to_s.start_with?('No matches') ? "grep #{pattern} (0 matches)" : "grep #{pattern} (#{count} lines)"
+      end
+
       def execute(pattern:, path: nil, glob_filter: nil, max_results: 50)
         search_path = path ? safe_path(path) : project_root
         regex = Regexp.new(pattern)

data/lib/rubyn_code/tools/ide_diagnostics.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module Tools
+    # Retrieves VS Code diagnostics (errors/warnings from the Problems panel)
+    # via the IDE RPC bridge. Only available when running in IDE mode.
+    class IdeDiagnostics < Base
+      TOOL_NAME = 'ide_diagnostics'
+      DESCRIPTION = 'Get VS Code diagnostics (errors, warnings) for a file or the whole workspace. Only available in IDE mode.'
+      PARAMETERS = {
+        file: {
+          type: 'string',
+          description: 'File path to get diagnostics for. Omit to get all workspace diagnostics.'
+        }
+      }.freeze
+      RISK_LEVEL = :read
+
+      def initialize(project_root:, ide_client: nil)
+        super(project_root: project_root)
+        @ide_client = ide_client
+      end
+
+      def execute(**params)
+        unless @ide_client
+          return 'IDE diagnostics are only available when running inside VS Code.'
+        end
+
+        rpc_params = {}
+        rpc_params[:file] = params[:file] if params[:file]
+
+        result = @ide_client.request('ide/getDiagnostics', rpc_params, timeout: 10)
+        diagnostics = result['diagnostics'] || []
+
+        return 'No diagnostics found.' if diagnostics.empty?
+
+        lines = diagnostics.map do |d|
+          severity = d['severity']&.upcase || 'INFO'
+          source = d['source'] ? " (#{d['source']})" : ''
+          "#{severity}: #{d['file']}:#{d['line']} — #{d['message']}#{source}"
+        end
+
+        lines.join("\n")
+      end
+
+      def self.summarize(output, _args)
+        count = output.lines.count
+        "#{count} diagnostic(s)"
+      end
+    end
+  end
+end

data/lib/rubyn_code/tools/ide_symbols.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module Tools
+    # Searches VS Code workspace symbols via the language server.
+    # Only available when running in IDE mode.
+    class IdeSymbols < Base
+      TOOL_NAME = 'ide_symbols'
+      DESCRIPTION = 'Search workspace symbols (classes, methods, modules) via VS Code language server. Only available in IDE mode.'
+      PARAMETERS = {
+        query: {
+          type: 'string',
+          description: 'Symbol search query (e.g. "User", "authenticate")',
+          required: true
+        }
+      }.freeze
+      RISK_LEVEL = :read
+
+      def initialize(project_root:, ide_client: nil)
+        super(project_root: project_root)
+        @ide_client = ide_client
+      end
+
+      def execute(**params)
+        unless @ide_client
+          return 'IDE symbols are only available when running inside VS Code.'
+        end
+
+        query = params[:query] || ''
+        return 'Query is required.' if query.empty?
+
+        result = @ide_client.request('ide/getWorkspaceSymbols', { query: query }, timeout: 10)
+        symbols = result['symbols'] || []
+
+        return "No symbols found matching '#{query}'." if symbols.empty?
+
+        lines = symbols.first(50).map do |s|
+          container = s['containerName'] ? " (in #{s['containerName']})" : ''
+          line_info = s['line'] ? ":#{s['line']}" : ''
+          "#{s['kind']} #{s['name']}#{container} — #{s['file']}#{line_info}"
+        end
+
+        header = "Found #{symbols.size} symbol(s) matching '#{query}':"
+        ([header] + lines).join("\n")
+      end
+
+      def self.summarize(output, _args)
+        first_line = output.lines.first&.strip || ''
+        first_line.start_with?('Found') ? first_line : ''
+      end
+    end
+  end
+end

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