rubyn-code 0.2.2 → 0.3.0

data/lib/rubyn_code/permissions/policy.rb

@@ -15,10 +15,10 @@ module RubynCode
       ALWAYS_ALLOW = %w[
         read_file glob grep git_status git_diff git_log
         memory_search memory_write load_skill compact
-        task web_search web_fetch
+        task web_search web_fetch ask_user
       ].to_set.freeze
 
-      def self.check(tool_name:, tool_input:, tier:, deny_list:)
+      def self.check(tool_name:, tier:, deny_list:, tool_input: nil) # rubocop:disable Lint/UnusedMethodArgument
         return :deny if deny_list.blocks?(tool_name)
         return :allow if ALWAYS_ALLOW.include?(tool_name)
 
@@ -26,17 +26,15 @@ module RubynCode
 
         return :ask if risk == :destructive
 
+        resolve_by_tier(tier, risk)
+      end
+
+      def self.resolve_by_tier(tier, risk)
         case tier
-        when Tier::ASK_ALWAYS
-          :ask
-        when Tier::ALLOW_READ
-          risk == :read ? :allow : :ask
-        when Tier::AUTONOMOUS
-          risk == :external ? :ask : :allow
-        when Tier::UNRESTRICTED
-          :allow
-        else
-          :ask
+        when Tier::ASK_ALWAYS, nil then :ask
+        when Tier::ALLOW_READ      then risk == :read ? :allow : :ask
+        when Tier::AUTONOMOUS      then risk == :external ? :ask : :allow
+        when Tier::UNRESTRICTED    then :allow
         end
       end
 
@@ -53,7 +51,7 @@ module RubynCode
         :unknown
       end
 
-      private_class_method :resolve_risk
+      private_class_method :resolve_risk, :resolve_by_tier
     end
   end
 end

data/lib/rubyn_code/permissions/prompter.rb

@@ -33,21 +33,20 @@ module RubynCode
       # @param tool_input [Hash]
       # @return [Boolean] true if the user approved
       def self.confirm_destructive(tool_name, tool_input)
-        prompt = build_prompt
         pastel = Pastel.new
+        display_destructive_warning(pastel, tool_name, tool_input)
+
+        answer = build_prompt.ask(pastel.red.bold('Type "yes" to confirm this destructive action:'))
+        answer&.strip&.downcase == 'yes'
+      rescue TTY::Prompt::Reader::InputInterrupt
+        false
+      end
 
+      def self.display_destructive_warning(pastel, tool_name, tool_input)
         $stdout.puts pastel.red.bold('WARNING: Destructive operation requested')
         $stdout.puts pastel.red('=' * 50)
         display_tool_summary(pastel, tool_name, tool_input)
         $stdout.puts pastel.red('=' * 50)
-
-        answer = prompt.ask(
-          pastel.red.bold('Type "yes" to confirm this destructive action:')
-        )
-
-        answer&.strip&.downcase == 'yes'
-      rescue TTY::Prompt::Reader::InputInterrupt
-        false
       end
 
       # @api private

data/lib/rubyn_code/protocols/plan_approval.rb

@@ -22,39 +22,44 @@ module RubynCode
         # @return [Symbol] :approved or :rejected
         def request(plan_text, prompt: nil)
           pastel = Pastel.new
-          tty = build_prompt
+          display_plan(pastel, plan_text, prompt)
 
+          approved = build_prompt.yes?(
+            pastel.yellow.bold('Do you approve this plan?'),
+            default: false
+          )
+
+          approved ? approve(pastel) : reject(pastel)
+        rescue TTY::Reader::InputInterrupt
+          $stdout.puts pastel.red("\nPlan rejected (interrupted).")
+          REJECTED
+        end
+
+        private
+
+        def display_plan(pastel, plan_text, prompt)
           $stdout.puts
           $stdout.puts pastel.cyan.bold('Proposed Plan')
           $stdout.puts pastel.cyan('=' * 60)
           $stdout.puts plan_text
           $stdout.puts pastel.cyan('=' * 60)
           $stdout.puts
+          return unless prompt
 
-          if prompt
-            $stdout.puts pastel.yellow(prompt)
-            $stdout.puts
-          end
+          $stdout.puts pastel.yellow(prompt)
+          $stdout.puts
+        end
 
-          approved = tty.yes?(
-            pastel.yellow.bold('Do you approve this plan?'),
-            default: false
-          )
+        def approve(pastel)
+          $stdout.puts pastel.green('Plan approved.')
+          APPROVED
+        end
 
-          if approved
-            $stdout.puts pastel.green('Plan approved.')
-            APPROVED
-          else
-            $stdout.puts pastel.red('Plan rejected.')
-            REJECTED
-          end
-        rescue TTY::Reader::InputInterrupt
-          $stdout.puts pastel.red("\nPlan rejected (interrupted).")
+        def reject(pastel)
+          $stdout.puts pastel.red('Plan rejected.')
           REJECTED
         end
 
-        private
-
         # Builds a TTY::Prompt instance configured for non-destructive interrupt handling.
         #
         # @return [TTY::Prompt]

data/lib/rubyn_code/skills/document.rb

@@ -19,30 +19,30 @@ module RubynCode
       class << self
         def parse(content, filename: nil)
           match = FRONTMATTER_PATTERN.match(content)
+          match ? parse_with_frontmatter(match) : parse_without_frontmatter(content, filename)
+        end
 
-          if match
-            frontmatter = YAML.safe_load(match[1], permitted_classes: [Symbol]) || {}
-            body = match[2].to_s.strip
+        def parse_with_frontmatter(match)
+          frontmatter = YAML.safe_load(match[1], permitted_classes: [Symbol]) || {}
+          new(
+            name: frontmatter['name'].to_s,
+            description: frontmatter['description'].to_s,
+            tags: Array(frontmatter['tags']),
+            body: match[2].to_s.strip
+          )
+        end
 
-            new(
-              name: frontmatter['name'].to_s,
-              description: frontmatter['description'].to_s,
-              tags: Array(frontmatter['tags']),
-              body: body
-            )
-          else
-            body = content.to_s.strip
-            title = extract_title(body)
-            derived_name = filename ? File.basename(filename, '.*').tr('_', '-') : title_to_name(title)
-            tags = derive_tags(derived_name, body)
+        def parse_without_frontmatter(content, filename)
+          body = content.to_s.strip
+          title = extract_title(body)
+          derived_name = filename ? File.basename(filename, '.*').tr('_', '-') : title_to_name(title)
 
-            new(
-              name: derived_name,
-              description: title,
-              tags: tags,
-              body: body
-            )
-          end
+          new(
+            name: derived_name,
+            description: title,
+            tags: derive_tags(derived_name, body),
+            body: body
+          )
         end
 
         def parse_file(path)
@@ -53,6 +53,15 @@ module RubynCode
           parse(content, filename: path)
         end
 
+        TAG_RULES = [
+          ['ruby',        /\bruby\b/i],
+          ['rails',       /\brails\b/i],
+          ['rspec',       /\brspec\b/i],
+          ['testing',     /\b(?:test|spec|minitest)\b/i],
+          ['patterns',    /\b(?:pattern|design|solid)\b/i],
+          ['refactoring', /\brefactor/i]
+        ].freeze
+
         private
 
         def extract_title(body)
@@ -65,14 +74,9 @@ module RubynCode
         end
 
         def derive_tags(name, body)
-          tags = []
-          tags << 'ruby' if body.match?(/\bruby\b/i) || name.include?('ruby')
-          tags << 'rails' if body.match?(/\brails\b/i) || name.include?('rails')
-          tags << 'rspec' if body.match?(/\brspec\b/i) || name.include?('rspec')
-          tags << 'testing' if body.match?(/\b(test|spec|minitest)\b/i)
-          tags << 'patterns' if body.match?(/\b(pattern|design|solid)\b/i)
-          tags << 'refactoring' if body.match?(/\brefactor/i)
-          tags.uniq
+          TAG_RULES.each_with_object([]) do |(tag, pattern), tags|
+            tags << tag if body.match?(pattern) || name.include?(tag)
+          end.uniq
         end
       end
     end

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/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

@@ -57,7 +57,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 +68,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 +84,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 +115,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)' }