rubyn-code 0.2.2 → 0.4.0

data/lib/rubyn_code/skills/ttl_manager.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module Skills
+    # Manages skill TTL (time-to-live) and size caps. Skills injected into
+    # context are tracked with a turn counter; once a skill exceeds its
+    # TTL it is marked for ejection during the next compaction pass.
+    class TtlManager
+      DEFAULT_TTL = 5          # turns
+      MAX_SKILL_TOKENS = 800   # tokens
+      CHARS_PER_TOKEN = 4
+
+      Entry = Data.define(:name, :loaded_at_turn, :ttl, :token_count, :last_referenced_turn) do
+        def expired?(current_turn)
+          current_turn - last_referenced_turn > ttl
+        end
+      end
+
+      attr_reader :entries
+
+      def initialize
+        @entries = {}
+        @current_turn = 0
+      end
+
+      # Advance the turn counter. Call this once per agent loop iteration.
+      def tick!
+        @current_turn += 1
+      end
+
+      # Register a loaded skill with optional TTL override.
+      #
+      # @param name [String] skill name
+      # @param content [String] skill content
+      # @param ttl [Integer] turns before expiry (default 5)
+      # @return [String] content, possibly truncated to size cap
+      def register(name, content, ttl: DEFAULT_TTL)
+        truncated = enforce_size_cap(content)
+        token_count = estimate_tokens(truncated)
+
+        @entries[name] = Entry.new(
+          name: name,
+          loaded_at_turn: @current_turn,
+          ttl: ttl,
+          token_count: token_count,
+          last_referenced_turn: @current_turn
+        )
+
+        truncated
+      end
+
+      # Mark a skill as recently referenced (resets its TTL countdown).
+      def touch(name)
+        return unless @entries.key?(name)
+
+        @entries[name] = @entries[name].with(last_referenced_turn: @current_turn)
+      end
+
+      # Returns names of skills that have exceeded their TTL.
+      def expired_skills
+        @entries.select { |_, entry| entry.expired?(@current_turn) }.keys
+      end
+
+      # Remove expired skills and return their names.
+      def eject_expired!
+        expired = expired_skills
+        expired.each { |name| @entries.delete(name) }
+        expired
+      end
+
+      # Returns total tokens used by currently loaded skills.
+      def total_tokens
+        @entries.values.sum(&:token_count)
+      end
+
+      # Returns stats for the analytics dashboard.
+      def stats
+        {
+          loaded_skills: @entries.size,
+          total_tokens: total_tokens,
+          expired: expired_skills.size,
+          current_turn: @current_turn
+        }
+      end
+
+      private
+
+      def enforce_size_cap(content)
+        max_chars = MAX_SKILL_TOKENS * CHARS_PER_TOKEN
+        return content if content.length <= max_chars
+
+        content[0, max_chars] + "\n... [skill truncated to #{MAX_SKILL_TOKENS} tokens]"
+      end
+
+      def estimate_tokens(text)
+        (text.bytesize.to_f / CHARS_PER_TOKEN).ceil
+      end
+    end
+  end
+end

data/lib/rubyn_code/sub_agents/runner.rb

@@ -32,40 +32,35 @@ module RubynCode
       end
 
       def run
-        conversation = build_conversation
-        executor = build_executor
-        tool_defs = build_tool_definitions
+        state = { conversation: build_conversation, executor: build_executor,
+                  tool_defs: build_tool_definitions, final_text: '' }
 
-        iteration = 0
-        final_text = ''
-
-        loop do
-          break if iteration >= @max_iterations
-
-          response = request_llm(conversation, tool_defs)
-          iteration += 1
-
-          text_content = extract_text(response)
-          tool_calls = extract_tool_calls(response)
+        @max_iterations.times do
+          result = run_single_iteration(state)
+          break if result == :done
+        end
 
-          if tool_calls.empty?
-            final_text = text_content
-            break
-          end
+        Summarizer.call(state[:final_text])
+      end
 
-          conversation << { role: 'assistant', content: response }
+      private
 
-          tool_results = execute_tools(executor, tool_calls)
-          conversation << { role: 'user', content: tool_results }
+      def run_single_iteration(state)
+        response = request_llm(state[:conversation], state[:tool_defs])
+        text_content = extract_text(response)
+        tool_calls = extract_tool_calls(response)
 
-          final_text = text_content unless text_content.empty?
+        if tool_calls.empty?
+          state[:final_text] = text_content
+          return :done
         end
 
-        Summarizer.call(final_text)
+        state[:conversation] << { role: 'assistant', content: response }
+        state[:conversation] << { role: 'user', content: execute_tools(state[:executor], tool_calls) }
+        state[:final_text] = text_content unless text_content.empty?
+        :continue
       end
 
-      private
-
       def build_conversation
         [
           { role: 'user', content: @prompt }

data/lib/rubyn_code/tasks/dag.rb

@@ -113,30 +113,35 @@ module RubynCode
       # @return [Array<String>]
       # @raise [RuntimeError] if the graph contains a cycle
       def topological_sort
-        in_degree = Hash.new(0)
-        all_nodes = Set.new
+        all_nodes = collect_all_nodes
+        in_degree = compute_in_degrees(all_nodes)
 
-        @forward.each do |task_id, deps|
-          all_nodes.add(task_id)
-          deps.each do |dep_id|
-            all_nodes.add(dep_id)
-            in_degree[dep_id] # touch to initialize
-            in_degree[task_id] += 1 # task_id depends on dep_id, so task_id has higher in-degree
-          end
-        end
+        sorted = kahn_sort(all_nodes, in_degree)
+        raise 'Cycle detected in task dependency graph' if sorted.size != all_nodes.size
 
-        # Nodes with no dependencies come first
-        # Note: in our graph, forward[task_id] = set of tasks task_id depends ON,
-        # so the "edges" for topological sort point from dep -> task_id.
-        in_degree_corrected = Hash.new(0)
-        all_nodes.each { |n| in_degree_corrected[n] = 0 }
+        sorted
+      end
+
+      private
 
+      def collect_all_nodes
+        nodes = Set.new
         @forward.each do |task_id, deps|
-          # task_id depends on each dep, meaning dep must come before task_id
-          in_degree_corrected[task_id] += deps.size
+          nodes.add(task_id)
+          deps.each { |dep_id| nodes.add(dep_id) }
         end
+        nodes
+      end
+
+      def compute_in_degrees(all_nodes)
+        in_degree = Hash.new(0)
+        all_nodes.each { |n| in_degree[n] = 0 }
+        @forward.each { |task_id, deps| in_degree[task_id] += deps.size }
+        in_degree
+      end
 
-        queue = all_nodes.select { |n| in_degree_corrected[n].zero? }
+      def kahn_sort(all_nodes, in_degree)
+        queue = all_nodes.select { |n| in_degree[n].zero? }
         sorted = []
 
         until queue.empty?
@@ -144,18 +149,14 @@ module RubynCode
           sorted << node
 
           @reverse[node].each do |dependent|
-            in_degree_corrected[dependent] -= 1
-            queue << dependent if in_degree_corrected[dependent].zero?
+            in_degree[dependent] -= 1
+            queue << dependent if in_degree[dependent].zero?
           end
         end
 
-        raise 'Cycle detected in task dependency graph' if sorted.size != all_nodes.size
-
         sorted
       end
 
-      private
-
       def ensure_table
         @db.execute(<<~SQL)
           CREATE TABLE IF NOT EXISTS task_dependencies (

data/lib/rubyn_code/tasks/models.rb

@@ -10,6 +10,7 @@ module RubynCode
       def in_progress? = status == 'in_progress'
       def completed? = status == 'completed'
       def blocked? = status == 'blocked'
+      def failed? = status == 'failed'
 
       def to_h
         {

data/lib/rubyn_code/tools/ask_user.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+require_relative 'registry'
+
+module RubynCode
+  module Tools
+    class AskUser < Base
+      TOOL_NAME = 'ask_user'
+      DESCRIPTION = 'Ask the user a question and wait for their response. ' \
+                    'Use this when you need clarification, want to confirm a plan before executing, ' \
+                    'or are stuck and need guidance. The question is displayed and the user\'s answer ' \
+                    'is returned as the tool result.'
+      PARAMETERS = {
+        question: {
+          type: :string,
+          description: 'The question to ask the user',
+          required: true
+        }
+      }.freeze
+      RISK_LEVEL = :read # Never needs approval — it IS the approval mechanism
+
+      attr_writer :prompt_callback
+
+      def execute(question:)
+        if @prompt_callback
+          @prompt_callback.call(question)
+        elsif $stdin.respond_to?(:tty?) && $stdin.tty?
+          # Interactive fallback: prompt on stdin
+          $stdout.puts
+          $stdout.puts "  #{question}"
+          $stdout.print '  > '
+          $stdout.flush
+          $stdin.gets&.strip || '[no response]'
+        else
+          # Non-interactive (piped input, -p mode, daemon) — can't ask
+          '[non-interactive session — cannot ask user. Make your best judgment and proceed.]'
+        end
+      end
+    end
+
+    Registry.register(AskUser)
+  end
+end

data/lib/rubyn_code/tools/background_run.rb

@@ -30,7 +30,8 @@ module RubynCode
         return 'Error: Background worker not available. Use bash tool instead.' unless @background_worker
 
         job_id = @background_worker.run(command, timeout: timeout)
-        "Background job started: #{job_id}\nCommand: #{command}\nTimeout: #{timeout}s\nResults will appear automatically when complete."
+        "Background job started: #{job_id}\nCommand: #{command}\n" \
+          "Timeout: #{timeout}s\nResults will appear automatically when complete."
       end
     end
 

data/lib/rubyn_code/tools/base.rb

@@ -37,6 +37,19 @@ module RubynCode
             input_schema: Schema.build(parameters)
           }
         end
+
+        # One-line summary of a successful invocation, shown in the IDE's
+        # chat card. Default is empty so the UI renders a clean "Done"
+        # indicator. Override in subclasses that have a useful one-liner
+        # (e.g. "Edited app.rb (1 replacement)"). The full output still
+        # goes to the conversation untouched — this only affects the UI.
+        #
+        # @param output [String] what execute(**) returned
+        # @param args   [Hash]   the tool arguments (string-keyed)
+        # @return [String]
+        def summarize(_output, _args)
+          ''
+        end
       end
 
       attr_reader :project_root
@@ -57,7 +70,8 @@ module RubynCode
                    end
 
         unless expanded.start_with?(project_root)
-          raise PermissionDeniedError, "Path traversal denied: #{path} resolves outside project root"
+          raise PermissionDeniedError,
+                "Path traversal denied: #{path} resolves outside project root"
         end
 
         expanded
@@ -67,7 +81,8 @@ module RubynCode
         return output if output.nil? || output.length <= max
 
         half = max / 2
-        "#{output[0, half]}\n\n... [truncated #{output.length - max} characters] ...\n\n#{output[-half, half]}"
+        middle = "\n\n... [truncated #{output.length - max} characters] ...\n\n"
+        "#{output[0, half]}#{middle}#{output[-half, half]}"
       end
 
       private
@@ -82,34 +97,30 @@ module RubynCode
         stdout = +''
         stderr = +''
 
-        out_reader = Thread.new do
-          stdout << stdout_io.read
-        rescue StandardError
-          nil
-        end
-        err_reader = Thread.new do
-          stderr << stderr_io.read
-        rescue StandardError
-          nil
-        end
+        out_reader = Thread.new { stdout << stdout_io.read rescue nil } # rubocop:disable Style/RescueModifier
+        err_reader = Thread.new { stderr << stderr_io.read rescue nil } # rubocop:disable Style/RescueModifier
 
-        timed_out = false
-        unless wait_thr.join(timeout)
-          timed_out = true
-          begin
-            Process.kill('TERM', wait_thr.pid)
-          rescue StandardError
-            nil
-          end
-          sleep 0.1
-          begin
-            Process.kill('KILL', wait_thr.pid)
-          rescue StandardError
-            nil
-          end
-          wait_thr.join(5)
-        end
+        wait_for_process(wait_thr, timeout)
+        finalize_readers(out_reader, err_reader, stdout_io, stderr_io)
+
+        [stdout, stderr, wait_thr.value]
+      end
+
+      def wait_for_process(wait_thr, timeout)
+        return if wait_thr.join(timeout)
+
+        kill_process(wait_thr.pid)
+        wait_thr.join(5)
+        raise Error, "Command timed out after #{timeout}s"
+      end
 
+      def kill_process(pid)
+        Process.kill('TERM', pid) rescue nil # rubocop:disable Style/RescueModifier
+        sleep 0.1
+        Process.kill('KILL', pid) rescue nil # rubocop:disable Style/RescueModifier
+      end
+
+      def finalize_readers(out_reader, err_reader, stdout_io, stderr_io)
         out_reader.join(5)
         err_reader.join(5)
         [stdout_io, stderr_io].each do |io|
@@ -117,10 +128,6 @@ module RubynCode
         rescue StandardError
           nil
         end
-
-        raise Error, "Command timed out after #{timeout}s" if timed_out
-
-        [stdout, stderr, wait_thr.value]
       end
 
       def read_file_safely(path)

data/lib/rubyn_code/tools/bash.rb

@@ -9,7 +9,8 @@ module RubynCode
   module Tools
     class Bash < Base
       TOOL_NAME = 'bash'
-      DESCRIPTION = 'Runs a shell command in the project directory. Blocks dangerous patterns and scrubs sensitive environment variables.'
+      DESCRIPTION = 'Runs a shell command in the project directory. Blocks dangerous patterns ' \
+                    'and scrubs sensitive environment variables.'
       PARAMETERS = {
         command: { type: :string, required: true, description: 'The shell command to execute' },
         timeout: { type: :integer, required: false, default: 120, description: 'Timeout in seconds (default: 120)' }
@@ -17,6 +18,11 @@ module RubynCode
       RISK_LEVEL = :execute
       REQUIRES_CONFIRMATION = true
 
+      def self.summarize(_output, args)
+        cmd = args['command'] || args[:command] || ''
+        "$ #{cmd[0, 180]}"
+      end
+
       def execute(command:, timeout: 120)
         validate_command!(command)
 

data/lib/rubyn_code/tools/edit_file.rb

@@ -7,40 +7,153 @@ 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
       RISK_LEVEL = :write
       REQUIRES_CONFIRMATION = false
 
+      # Take the first line of the tool's output, which is already formatted
+      # as "Edited /path.rb (N replacements)".
+      def self.summarize(output, _args)
+        output.to_s.lines.first.to_s.chomp[0, 200]
+      end
+
       def execute(path:, old_text:, new_text:, replace_all: false)
         resolved = read_file_safely(path)
         content = File.read(resolved)
 
-        occurrences = content.scan(old_text).length
+        validate_occurrences!(path, content, old_text, replace_all)
+
+        new_content = apply_replacement(content, old_text, new_text, replace_all)
+        File.write(resolved, new_content)
+
+        format_diff_result(path, content, old_text, new_text, replace_all)
+      end
 
-        raise Error, "old_text not found in #{path}. No changes made." if occurrences.zero?
+      # Compute the proposed file content without writing to disk.
+      # Used by IDE mode to preview the edit in a diff view before the user
+      # accepts. Raises if old_text is missing or ambiguous, same as execute.
+      #
+      # @return [Hash] { content: String, type: 'modify' }
+      def preview_content(path:, old_text:, new_text:, replace_all: false)
+        resolved = read_file_safely(path)
+        content = File.read(resolved)
+
+        validate_occurrences!(path, content, old_text, replace_all)
+
+        { content: apply_replacement(content, old_text, new_text, replace_all), type: 'modify' }
+      end
 
-        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."
+      private
+
+      def validate_occurrences!(path, content, old_text, replace_all)
+        count = content.scan(old_text).length
+
+        # If exact match fails, try with normalized trailing whitespace on
+        # each line. Models sometimes strip or add trailing spaces/tabs.
+        if count.zero?
+          normalized_content = normalize_trailing_ws(content)
+          normalized_old = normalize_trailing_ws(old_text)
+          count = normalized_content.scan(normalized_old).length
+
+          raise Error, "old_text not found in #{path}. No changes made." if count.zero?
         end
 
-        new_content = if replace_all
-                        content.gsub(old_text, new_text)
-                      else
-                        content.sub(old_text, new_text)
-                      end
+        return if replace_all || count == 1
 
-        File.write(resolved, new_content)
+        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)
+        # Try exact match first
+        if content.include?(old_text)
+          return replace_all ? content.gsub(old_text, new_text) : content.sub(old_text, new_text)
+        end
+
+        # Fall back to normalized trailing-whitespace match
+        normalized_content = normalize_trailing_ws(content)
+        normalized_old = normalize_trailing_ws(old_text)
+
+        if normalized_content.include?(normalized_old)
+          if replace_all
+            normalized_content.gsub(normalized_old, new_text)
+          else
+            normalized_content.sub(normalized_old, new_text)
+          end
+        else
+          content.sub(old_text, new_text)
+        end
+      end
+
+      def normalize_trailing_ws(str)
+        str.gsub(/[^\S\n]+$/, '')
+      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 = find_index(content, text)
+        return [] unless idx
+
+        before = content[0...idx].lines.last(CONTEXT_LINES)
+        before.map { |l| "    #{l.chomp}" }
+      end
+
+      def context_after(content, text)
+        idx = find_index(content, 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 = find_index(content, text)
+        return nil unless idx
+
+        content[0...idx].count("\n") + 1
+      end
+
+      # Find the index of text in content, falling back to normalized match.
+      def find_index(content, text)
+        idx = content.index(text)
+        return idx if idx
 
-        replaced_count = replace_all ? occurrences : 1
-        "Successfully replaced #{replaced_count} occurrence#{'s' if replaced_count > 1} in #{path}"
+        normalize_trailing_ws(content).index(normalize_trailing_ws(text))
       end
     end