rubyn-code 0.2.2 → 0.3.0

data/lib/rubyn_code/agent/loop_detector.rb

@@ -7,10 +7,16 @@ module RubynCode
     class LoopDetector
       # @param window [Integer] number of recent calls to keep in the sliding window
       # @param threshold [Integer] number of identical signatures that indicate a stall
-      def initialize(window: 5, threshold: 3)
-        @window    = window
-        @threshold = threshold
-        @history   = []
+      # @param name_window [Integer] larger window for tool name repetition detection
+      # @param name_threshold [Integer] how many times the same tool name in name_window triggers stall
+      def initialize(window: 5, threshold: 3, name_window: 12, name_threshold: 6)
+        @window         = window
+        @threshold      = threshold
+        @name_window    = name_window
+        @name_threshold = name_threshold
+        @history        = []
+        @name_history   = []
+        @file_edits     = Hash.new(0)
       end
 
       # Record a tool invocation. The signature is derived from the tool name
@@ -21,9 +27,9 @@ module RubynCode
       # @param tool_input [Hash, String, nil]
       # @return [void]
       def record(tool_name, tool_input)
-        sig = signature(tool_name, tool_input)
-        @history << sig
-        @history.shift while @history.length > @window
+        record_signature(tool_name, tool_input)
+        record_tool_name(tool_name)
+        record_file_edit(tool_name, tool_input)
       end
 
       # Returns true when the same tool call signature appears at least
@@ -31,10 +37,7 @@ module RubynCode
       #
       # @return [Boolean]
       def stalled?
-        return false if @history.length < @threshold
-
-        counts = @history.tally
-        counts.any? { |_sig, count| count >= @threshold }
+        exact_call_repeated? || tool_name_repeated? || file_over_edited?
       end
 
       # Clear recorded history.
@@ -42,6 +45,8 @@ module RubynCode
       # @return [void]
       def reset!
         @history.clear
+        @name_history.clear
+        @file_edits.clear
       end
 
       # A system-level nudge message to inject when a stall is detected.
@@ -56,6 +61,40 @@ module RubynCode
 
       private
 
+      def record_signature(tool_name, tool_input)
+        sig = signature(tool_name, tool_input)
+        @history << sig
+        @history.shift while @history.length > @window
+      end
+
+      def record_tool_name(tool_name)
+        @name_history << tool_name.to_s
+        @name_history.shift while @name_history.length > @name_window
+      end
+
+      def record_file_edit(tool_name, tool_input)
+        return unless %w[edit_file write_file].include?(tool_name.to_s) && tool_input.is_a?(Hash)
+
+        path = tool_input[:path] || tool_input['path']
+        @file_edits[path.to_s] += 1 if path
+      end
+
+      def exact_call_repeated?
+        return false if @history.length < @threshold
+
+        @history.tally.any? { |_sig, count| count >= @threshold }
+      end
+
+      def tool_name_repeated?
+        return false if @name_history.length < @name_threshold
+
+        @name_history.tally.any? { |_name, count| count >= @name_threshold }
+      end
+
+      def file_over_edited?
+        @file_edits.any? { |_path, count| count >= 3 }
+      end
+
       def signature(tool_name, tool_input)
         input_str = case tool_input
                     when Hash   then stable_hash(tool_input)

data/lib/rubyn_code/agent/prompts.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module Agent
+    # Holds the static prompt text used by the SystemPromptBuilder module.
+    # Extracted here to keep module bodies within the line-count limit.
+    module Prompts
+      SYSTEM_PROMPT = <<~PROMPT
+        You are Rubyn — a snarky but lovable AI coding assistant who lives and breathes Ruby.
+        You're the kind of pair programmer who'll roast your colleague's `if/elsif/elsif/else` chain
+        with a smirk, then immediately rewrite it as a beautiful `case/in` with pattern matching.
+        You're sharp, opinionated, and genuinely helpful. Think of yourself as the senior Ruby dev
+        who's seen every Rails antipattern in production and somehow still loves this language.
+
+        ## Personality
+        - Snarky but never mean. You tease the code, not the coder.
+        - You celebrate good Ruby — "Oh, a proper guard clause? You love to see it."
+        - You mourn bad Ruby — "A `for` loop? In MY Ruby? It's more likely than you think."
+        - Brief and punchy. No walls of text unless teaching something important.
+        - You use Ruby metaphors: "Let's refactor this like Matz intended."
+        - When something is genuinely good code, you say so. No notes.
+
+        ## Ruby Convictions (non-negotiable)
+        - `frozen_string_literal: true` in every file. Every. Single. One.
+        - Prefer `each`, `map`, `select`, `reduce` over manual iteration. Always.
+        - Guard clauses over nested conditionals. Return early, return often.
+        - `Data.define` for value objects (Ruby 3.2+). `Struct` only if you need mutability.
+        - `snake_case` methods, `CamelCase` classes, `SCREAMING_SNAKE` constants. No exceptions.
+        - Single quotes unless you're interpolating. Fight me.
+        - Methods under 15 lines. Classes under 100. Extract or explain why not.
+        - Explicit over clever. Metaprogramming is a spice, not the main course.
+        - `raise` over `fail`. Rescue specific exceptions, never bare `rescue`.
+        - Prefer composition over inheritance. Mixins are not inheritance.
+        - `&&` / `||` over `and` / `or`. The precedence difference has burned too many.
+        - `dig` for nested hashes. `fetch` with defaults over `[]` with `||`.
+        - `freeze` your constants. Frozen arrays, frozen hashes, frozen regexps.
+        - No `OpenStruct`. Ever. It's slow, it's a footgun, and `Data.define` exists.
+
+        ## Rails Convictions
+        - Skinny controllers, fat models is dead. Skinny controllers, skinny models, service objects.
+        - `has_many :through` over `has_and_belongs_to_many`. Every time.
+        - Add database indexes for every foreign key and every column you query.
+        - Migrations are generated, not handwritten. `rails generate migration`.
+        - Strong parameters in controllers. No `permit!`. Ever.
+        - Use `find_each` for batch processing. `each` on a large scope is a memory bomb.
+        - `exists?` over `present?` for checking DB existence. One is a COUNT, the other loads the record.
+        - Scopes over class methods for chainable queries.
+        - Background jobs for anything that takes more than 100ms.
+        - Don't put business logic in callbacks. That way lies madness.
+
+        ## Testing Convictions
+        - RSpec > Minitest (but you'll work with either without complaining... much)
+        - FactoryBot over fixtures. Factories are explicit. Fixtures are magic.
+        - One assertion per test when practical. "It does three things" is three tests.
+        - `let` over instance variables. `let!` only when you need eager evaluation.
+        - `described_class` over repeating the class name.
+        - Test behavior, not implementation. Mock the boundary, not the internals.
+
+        ## How You Work
+        - For greetings and casual chat, just respond naturally. No need to run tools.
+        - Only use tools when the user asks you to DO something (read, write, search, run, review).
+        - Read before you write. Always understand existing code before suggesting changes.
+        - Use tools to verify. Don't guess if a file exists — check.
+        - Show diffs when editing. The human should see what changed.
+        - Run specs after changes. If they break, fix them.
+        - When you are asked to work in a NEW directory you haven't seen yet, check for RUBYN.md, CLAUDE.md, or AGENT.md there. But don't do this unprompted on startup — those files are already loaded into your context.
+        - Load skills when you need deep knowledge on a topic. Don't wing it.
+        - You have 112 curated best-practice skill documents covering Ruby, Rails, RSpec, design patterns, and code quality. When writing new code or reviewing existing code, load the relevant skill BEFORE implementing. Don't reinvent patterns that are already documented.
+        - HOWEVER: always respect patterns already established in the codebase. If the project uses a specific convention (e.g. service objects, a particular test style, a custom base class), follow that convention even if it differs from the skill doc. Consistency with the codebase beats textbook best practice. Only break from established patterns if they are genuinely harmful (security issues, major performance problems, or bugs).
+        - Keep responses concise. Code speaks louder than paragraphs.
+        - Use spawn_agent sparingly — only for tasks that require reading many files (10+) or deep exploration. For simple reads or edits, use tools directly. Don't spawn a sub-agent when a single read_file or grep will do.
+        - If an approach fails, diagnose WHY before switching tactics. Read the error, check your assumptions, try a focused fix. Don't retry the identical action blindly, but don't abandon a viable approach after a single failure either.
+        - When you're genuinely stuck after investigation, use the ask_user tool to ask for clarification or guidance. Don't spin your wheels — ask.
+        - NEVER chase lint/rubocop fixes in a loop. Run `rubocop --autocorrect-all` ONCE. For remaining manual fixes, read ALL the offenses, then fix ALL of them in ONE pass across all files before re-checking. Never do fix-one-check-fix-one-check.
+        - Batch your work. If you need to edit 5 files, edit all 5, THEN verify. Don't edit-verify-edit-verify for each one.
+        - If you find yourself editing the same file more than twice, STOP. Tell the user what you're stuck on and ask how to proceed.
+        - IMPORTANT: You can call MULTIPLE tools in a single response. When you need to read several files, search multiple patterns, or perform independent operations, return all tool_use blocks at once rather than one at a time. This is dramatically faster and cheaper. For example, if you need to read 5 files, emit 5 read_file tool calls in one response — don't read them one by one across 5 turns.
+
+        ## Memory
+        You have persistent memory across sessions via `memory_write` and `memory_search` tools.
+        Use them proactively:
+        - When the user tells you a preference or convention, save it: memory_write(content: "User prefers Grape over Rails controllers for APIs", category: "user_preference")
+        - When you discover a project pattern (e.g. "this app uses service objects in app/services/"), save it: memory_write(content: "...", category: "project_convention")
+        - When you fix a tricky bug, save the resolution: memory_write(content: "...", category: "error_resolution")
+        - When you learn a key architectural decision, save it: memory_write(content: "...", category: "decision")
+        - Before starting work on a project, search memory for context: memory_search(query: "project conventions")
+        - Don't save trivial things. Save what would be useful in a future session.
+        Categories: user_preference, project_convention, error_resolution, decision, code_pattern
+      PROMPT
+
+      PLAN_MODE_PROMPT = <<~PLAN
+        ## Plan Mode Active
+
+        You are in PLAN MODE. This means:
+        - Reason through the problem step by step
+        - You have READ-ONLY tools available — use them to explore the codebase
+        - Read files, grep, glob, check git status/log/diff — gather context
+        - Do NOT write, edit, execute, or modify anything
+        - Outline your plan with numbered steps
+        - Identify files you'd need to read or modify
+        - Call out risks, edge cases, and trade-offs
+        - Ask clarifying questions if the request is ambiguous
+        - When the user is satisfied with the plan, they'll toggle plan mode off with /plan
+
+        You CAN use read-only tools. You MUST NOT use any tool that writes, edits, or executes.
+      PLAN
+    end
+  end
+end

data/lib/rubyn_code/agent/response_modes.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module Agent
+    # Dynamically adjusts response verbosity based on the current task type.
+    # Injects mode-specific instructions into the system prompt to reduce
+    # unnecessary output tokens without losing useful information.
+    module ResponseModes
+      MODES = {
+        implementing: {
+          label: 'implementing',
+          instruction: 'Write the code. Brief comment on non-obvious decisions only. No preamble or recap.'
+        },
+        explaining: {
+          label: 'explaining',
+          instruction: 'Explain clearly and concisely. Use examples from this codebase when possible.'
+        },
+        reviewing: {
+          label: 'reviewing',
+          instruction: 'List findings with severity, file, line. No filler between findings.'
+        },
+        exploring: {
+          label: 'exploring',
+          instruction: 'Summarize structure. Use tree format. Note patterns and anti-patterns briefly.'
+        },
+        debugging: {
+          label: 'debugging',
+          instruction: 'State most likely cause first. Then evidence. Then fix. No preamble.'
+        },
+        testing: {
+          label: 'testing',
+          instruction: 'Write specs directly. Minimal explanation. Only note non-obvious test setup.'
+        },
+        chatting: {
+          label: 'chatting',
+          instruction: 'Respond naturally and concisely.'
+        }
+      }.freeze
+
+      DEFAULT_MODE = :chatting
+
+      class << self
+        # Detects the response mode from the user's message content.
+        #
+        # @param message [String] the user's input
+        # @param tool_calls [Array] recent tool calls (for context)
+        # @return [Symbol] one of the MODES keys
+        def detect(message, tool_calls: []) # rubocop:disable Metrics/CyclomaticComplexity -- mode detection dispatch
+          return :implementing if implementation_signal?(message)
+          return :debugging    if debugging_signal?(message)
+          return :reviewing    if reviewing_signal?(message)
+          return :testing      if testing_signal?(message)
+          return :exploring    if exploring_signal?(message)
+          return :explaining   if explaining_signal?(message)
+
+          recent_tool = tool_calls.last
+          return detect_from_tool(recent_tool) if recent_tool
+
+          DEFAULT_MODE
+        end
+
+        # Returns the instruction text for a given mode.
+        #
+        # @param mode [Symbol]
+        # @return [String]
+        def instruction_for(mode)
+          config = MODES.fetch(mode, MODES[DEFAULT_MODE])
+          "\n## Response Mode: #{config[:label]}\n#{config[:instruction]}"
+        end
+
+        private
+
+        def implementation_signal?(msg)
+          msg.match?(/\b(add|create|implement|build|write|generate|make)\b/i) &&
+            msg.match?(/\b(method|class|module|function|feature|endpoint|service|model|controller)\b/i)
+        end
+
+        def debugging_signal?(msg)
+          msg.match?(/\b(fix|bug|error|broken|failing|crash|wrong|issue|problem|debug)\b/i)
+        end
+
+        def reviewing_signal?(msg)
+          msg.match?(/\b(review|pr|pull request|code review|check|audit)\b/i)
+        end
+
+        def testing_signal?(msg)
+          msg.match?(/\b(test|spec|rspec|minitest|coverage|assert)\b/i)
+        end
+
+        def exploring_signal?(msg)
+          msg.match?(/\b(explore|find|search|where|structure|architecture|how does|show me)\b/i)
+        end
+
+        def explaining_signal?(msg)
+          msg.match?(/\b(explain|why|what is|how does|tell me|describe|understand)\b/i)
+        end
+
+        def detect_from_tool(tool_call)
+          name = tool_call.is_a?(Hash) ? (tool_call[:name] || tool_call['name']) : tool_call.to_s
+          case name.to_s
+          when 'run_specs'               then :testing
+          when 'write_file', 'edit_file' then :implementing
+          when 'grep', 'glob'            then :exploring
+          when 'review_pr'               then :reviewing
+          else DEFAULT_MODE
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubyn_code/agent/response_parser.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require_relative 'usage_tracker'
+
+module RubynCode
+  module Agent
+    # Extracts and interprets content from LLM responses: tool calls, text
+    # blocks, truncation detection, and multi-turn recovery.
+    module ResponseParser
+      include UsageTracker
+
+      private
+
+      def extract_tool_calls(response)
+        get_content(response).select { |block| block_type(block) == 'tool_use' }
+      end
+
+      def response_content(response)
+        get_content(response)
+      end
+
+      def extract_response_text(response)
+        get_content(response)
+          .select { |b| block_type(b) == 'text' }
+          .map { |b| text_from_block(b) }
+          .compact.join("\n")
+      end
+
+      def text_from_block(block)
+        block.respond_to?(:text) ? block.text : (block[:text] || block['text'])
+      end
+
+      def get_content(response)
+        case response
+        when ->(r) { r.respond_to?(:content) }
+          Array(response.content)
+        when Hash
+          Array(response[:content] || response['content'])
+        else
+          []
+        end
+      end
+
+      def block_type(block)
+        if block.respond_to?(:type)
+          block.type.to_s
+        elsif block.is_a?(Hash)
+          (block[:type] || block['type']).to_s
+        end
+      end
+
+      def truncated?(response)
+        extract_stop_reason(response) == 'max_tokens'
+      end
+
+      def extract_stop_reason(response)
+        if response.respond_to?(:stop_reason)
+          response.stop_reason
+        elsif response.is_a?(Hash)
+          response[:stop_reason] || response['stop_reason']
+        end
+      end
+
+      def recover_truncated_response(response)
+        @max_tokens_override ||= Config::Defaults::ESCALATED_MAX_OUTPUT_TOKENS
+        @conversation.add_assistant_message(response_content(response))
+        max_retries = Config::Defaults::MAX_OUTPUT_TOKENS_RECOVERY_LIMIT
+
+        max_retries.times do |attempt|
+          response = attempt_recovery(attempt, max_retries)
+          break unless truncated?(response)
+
+          RubynCode::Debug.recovery("Still truncated after attempt #{attempt + 1}")
+          @conversation.add_assistant_message(response_content(response))
+        end
+
+        log_exhausted(max_retries) if truncated?(response)
+        response
+      end
+
+      def attempt_recovery(attempt, max_retries)
+        @output_recovery_count += 1
+        RubynCode::Debug.recovery("Tier 2: Recovery attempt #{attempt + 1}/#{max_retries}")
+        @conversation.add_user_message(
+          'Output token limit hit. Resume directly — no apology, no recap, just continue exactly where you left off.'
+        )
+        response = call_llm
+        RubynCode::Debug.recovery("Recovery successful on attempt #{attempt + 1}") unless truncated?(response)
+        response
+      end
+
+      def log_exhausted(max_retries)
+        RubynCode::Debug.recovery("Tier 3: Exhausted #{max_retries} recovery attempts, returning partial response")
+      end
+
+      def field(obj, key)
+        if obj.respond_to?(key)
+          obj.send(key)
+        elsif obj.is_a?(Hash)
+          obj[key] || obj[key.to_s]
+        end
+      end
+
+      def symbolize_keys(hash)
+        return {} unless hash.is_a?(Hash)
+
+        hash.transform_keys(&:to_sym)
+      end
+    end
+  end
+end

data/lib/rubyn_code/agent/system_prompt_builder.rb

@@ -0,0 +1,205 @@
+# frozen_string_literal: true
+
+require_relative 'prompts'
+
+module RubynCode
+  module Agent
+    # Assembles the system prompt for the agent loop, including base personality,
+    # plan-mode instructions, memories, instincts, project instructions, and
+    # available skills/tools.
+    module SystemPromptBuilder # rubocop:disable Metrics/ModuleLength -- heavily extracted, residual 3 lines over
+      include Prompts
+
+      INSTRUCTION_FILES = %w[RUBYN.md CLAUDE.md AGENT.md].freeze
+
+      private
+
+      def build_system_prompt
+        parts = [SYSTEM_PROMPT]
+        parts << PLAN_MODE_PROMPT if @plan_mode
+        parts << "Working directory: #{@project_root}" if @project_root
+        append_response_mode(parts)
+        append_project_profile(parts)
+        append_codebase_index(parts)
+        append_memories(parts)
+        append_project_instructions(parts)
+        append_instincts(parts)
+        append_skills(parts)
+        append_deferred_tools(parts)
+        parts.join("\n")
+      end
+
+      def append_response_mode(parts)
+        text = last_user_text
+        return if text.empty?
+
+        mode = ResponseModes.detect(text)
+        parts << ResponseModes.instruction_for(mode)
+      rescue StandardError
+        nil
+      end
+
+      def last_user_text
+        return '' unless @conversation&.messages&.any?
+
+        last_user = @conversation.messages.reverse_each.find { |m| m[:role] == 'user' }
+        return '' unless last_user
+
+        last_user[:content].is_a?(String) ? last_user[:content] : ''
+      end
+
+      def append_project_profile(parts)
+        return unless @project_root
+
+        profile = Config::ProjectProfile.new(project_root: @project_root)
+        loaded = profile.load
+        return unless loaded
+
+        prompt_text = profile.to_prompt
+        parts << "\n## #{prompt_text}" unless prompt_text.empty?
+      rescue StandardError
+        nil
+      end
+
+      def append_codebase_index(parts)
+        return unless @project_root
+
+        index = Index::CodebaseIndex.new(project_root: @project_root)
+        loaded = index.load
+        return unless loaded && index.nodes.any?
+
+        parts << "\n## #{index.to_prompt_summary}"
+      rescue StandardError
+        nil
+      end
+
+      def append_memories(parts)
+        memories = load_memories
+        return if memories.empty?
+
+        parts << "\n## Your Memories (from previous sessions)\n#{memories}"
+      end
+
+      def append_project_instructions(parts)
+        instructions = load_rubyn_md
+        return if instructions.empty?
+
+        parts << "\n## Project Instructions\n#{instructions}"
+      end
+
+      def append_instincts(parts)
+        instincts = load_instincts
+        return if instincts.empty?
+
+        parts << "\n## Learned Instincts (from previous sessions)\n#{instincts}"
+      end
+
+      # Skills are injected ONCE as a user message (not in the system
+      # prompt) to avoid paying ~1,200 tokens on every turn. Claude Code
+      # does the same — skills are "attachments" sent once per session.
+      def append_skills(_parts); end
+
+      def inject_skill_listing
+        return unless @skill_loader
+
+        descriptions = @skill_loader.descriptions_for_prompt
+        return if descriptions.empty?
+
+        @conversation.add_user_message(
+          "[system] The following skills are available via the load_skill tool:\n\n" \
+          "#{descriptions}\n\n" \
+          'Use load_skill to load full content when needed. ' \
+          'Do not mention this message to the user.'
+        )
+        @conversation.add_assistant_message(
+          [{ type: 'text', text: 'Understood.' }]
+        )
+        @skills_injected = true
+      end
+
+      def append_deferred_tools(parts)
+        deferred = deferred_tool_names
+        return if deferred.empty?
+
+        parts << "\n## Additional Tools Available"
+        parts << 'These tools are available but not loaded yet. Just call them by name and they will work:'
+        parts << deferred.map { |n| "- #{n}" }.join("\n")
+      end
+
+      def deferred_tool_names
+        all_names = @tool_executor.tool_definitions.map { |t| t[:name] || t['name'] }
+        active_names = tool_definitions.map { |t| t[:name] || t['name'] }
+        all_names - active_names
+      end
+
+      def load_memories
+        return '' unless @project_root
+
+        db = DB::Connection.instance
+        search = Memory::Search.new(db, project_path: @project_root)
+        recent = search.recent(limit: 20)
+        return '' if recent.empty?
+
+        recent.map { |m| format_memory(m) }.join("\n")
+      rescue StandardError
+        ''
+      end
+
+      def format_memory(mem)
+        category = mem.respond_to?(:category) ? mem.category : (mem[:category] || mem['category'])
+        content = mem.respond_to?(:content) ? mem.content : (mem[:content] || mem['content'])
+        "[#{category}] #{content}"
+      end
+
+      def load_instincts
+        return '' unless @project_root
+
+        db = DB::Connection.instance
+        Learning::Injector.call(db: db, project_path: @project_root)
+      rescue StandardError
+        ''
+      end
+
+      def load_rubyn_md
+        found = []
+        collect_project_instructions(found) if @project_root
+        collect_instruction(File.join(Config::Defaults::HOME_DIR, 'RUBYN.md'), found)
+        found.uniq.join("\n\n")
+      end
+
+      def collect_project_instructions(found)
+        walk_up_for_instructions(@project_root, found)
+        INSTRUCTION_FILES.each { |name| collect_instruction(File.join(@project_root, name), found) }
+        collect_instruction(File.join(@project_root, '.rubyn-code', 'RUBYN.md'), found)
+        INSTRUCTION_FILES.each do |n|
+          Dir.glob(File.join(@project_root, '*', n)).each do |p|
+            collect_instruction(p, found)
+          end
+        end
+      end
+
+      def walk_up_for_instructions(start_dir, found)
+        dir = File.dirname(start_dir)
+        home = File.expand_path('~')
+
+        while dir.length >= home.length
+          INSTRUCTION_FILES.each { |name| collect_instruction(File.join(dir, name), found) }
+          break if dir == home
+
+          dir = File.dirname(dir)
+        end
+      end
+
+      def collect_instruction(path, found)
+        return unless File.exist?(path) && File.file?(path)
+
+        content = File.read(path, encoding: 'utf-8')
+                      .encode('UTF-8', invalid: :replace, undef: :replace, replace: '')
+                      .strip
+        return if content.empty?
+
+        found << "# From #{path}\n#{content}"
+      end
+    end
+  end
+end