ares-runtime 2.0.3 → 2.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c321feb80ab38315e30a032600325160b61fba7e2369fd731052c86ee4fa1341
-  data.tar.gz: f7409e906b26c98ed91a1fd2c77747b22dc359662d769adcda7ee47002ba2ac4
+  metadata.gz: 24fc0fcd364ccd0c506af86b1757e8c29542184245ec22d5b6a3cb357af839b9
+  data.tar.gz: 44c8d7a31b0b3996613934510d64117634a3ac3614ae0ac34fdf67c8127e5ca3
 SHA512:
-  metadata.gz: 3d7153a6fa16e1eccd05ced673a3527b1a13f50313066f517ea3cd240756ad23ee2feaeedb75a72cbab40e32a4444cb64625a742c5a8e0c0725534428b7d8482
-  data.tar.gz: 1eef6e2f4c9dd99ae5e037da0e5adab6e30d3573d88f193ff6678d4d928f1f2340a6464185b8edfe2ee0e62d9085c33a9868184449d889579ac2bfebf845d5ef
+  metadata.gz: 8c3b8198c8f11b94ebfbd9845ec17de889afc98bf01870e4e1f874c5ca6d94a95b3021ba2c9237dad4ee40c26dcbb6946a43afa313b1c31f03df634bd22226af
+  data.tar.gz: add502d6a5cf0ac14ae20fc369ccf947253105b0904a6f5019ce2079fe109b25b5b6ab11cd44fa1a4b1fe62d02da1e9def57809b26766adc47e1d1dd2d90ef43

data/exe/ares

@@ -7,16 +7,14 @@ require 'optparse'
 module Ares
   class CLI
     def self.start
-      command = ARGV.shift
-
-      case command
-      when 'init'    then init
-      when 'config'  then config
-      when 'doctor'  then doctor
-      when 'version' then version
-      when 'logs'    then logs
+      case ARGV.first
+      when 'init'    then ARGV.shift; init
+      when 'config'  then ARGV.shift; config
+      when 'doctor'  then ARGV.shift; doctor
+      when 'version' then ARGV.shift; version
+      when 'logs'    then ARGV.shift; logs
       else
-        run_task(command)
+        run_task
       end
     end
 
@@ -40,7 +38,7 @@ module Ares
       Ares::Runtime::LogsCLI.run
     end
 
-    def self.run_task(first_arg)
+    def self.run_task
       options = {
         dry_run: false,
         git: false,
@@ -50,9 +48,10 @@ module Ares
       OptionParser.new do |opts|
         opts.banner = 'Usage: ares [options] "task description"'
 
-        opts.on('-d', '--dry-run') { options[:dry_run] = true }
-        opts.on('-g', '--git')     { options[:git] = true }
-        opts.on('--tui')           { options[:tui] = true }
+        opts.on('-d', '--dry-run')    { options[:dry_run] = true }
+        opts.on('-g', '--git')        { options[:git] = true }
+        opts.on('--tui')              { options[:tui] = true }
+        opts.on('--fail-fast')        { options[:fail_fast] = true }
       end.parse!
 
       if options[:tui]
@@ -60,7 +59,7 @@ module Ares
         exit
       end
 
-      task = ([first_arg] + ARGV).compact.join(' ').strip
+      task = ARGV.join(' ').strip
 
       if task.empty?
         puts 'No task provided.'

data/lib/ares/runtime/adapters/base_adapter.rb

@@ -10,52 +10,55 @@ module Ares
     class BaseAdapter
       DEFAULT_TIMEOUT = 30
 
-      # Template Method: The core algorithm skeleton
       def call(prompt, model = nil, **options)
         cmd = build_command(prompt, model, **options)
-
-        output, status = execute_with_timeout(cmd, prompt, timeout_seconds)
-
-        if should_retry?(status, output)
-          cmd = build_retry_command(cmd, prompt, **options)
-          output, status = execute_with_timeout(cmd, prompt, timeout_seconds)
-        end
+        output, status = execute_with_retry(cmd, prompt, options)
 
         handle_errors(status, output)
-
         output
       end
 
       protected
 
-      def execute_with_timeout(cmd, prompt, timeout)
-        Timeout.timeout(timeout) do
-          Open3.capture2e(*cmd, stdin_data: prompt)
-        end
+      def execute_with_retry(cmd, prompt, options)
+        output, status = run_with_timeout(cmd, prompt)
+        return [output, status] unless should_retry?(status, output)
+
+        run_with_timeout(build_retry_command(cmd, prompt, **options), prompt)
+      end
+
+      def run_with_timeout(cmd, prompt)
+        Timeout.timeout(timeout_seconds) { run_command(cmd, prompt) }
       rescue Timeout::Error => e
-        raise "#{adapter_name} timed out after #{timeout}s: #{e.message}"
+        raise "#{adapter_name} timed out after #{timeout_seconds}s: #{e.message}"
+      end
+
+      def run_command(cmd, prompt)
+        return Open3.capture2e(*cmd, stdin_data: prompt) if pipes_prompt_to_stdin?
+
+        Open3.capture2e(*cmd)
       end
 
       def handle_errors(status, output)
         raise "#{adapter_name} command failed: #{output}" unless status.success?
       end
 
-      # Subclasses MUST implement this
       def build_command(prompt, model, **options)
         raise NotImplementedError, "#{self.class} must implement #build_command"
       end
 
-      # Hook: Override in subclasses for complex retry logic
+      def pipes_prompt_to_stdin?
+        true
+      end
+
       def should_retry?(_status, _output)
         false
       end
 
-      # Hook: Customize the command for the retry attempt
       def build_retry_command(cmd, _prompt, **_options)
         cmd
       end
 
-      # Hook: Override for specific adapter timeouts
       def timeout_seconds
         DEFAULT_TIMEOUT
       end

data/lib/ares/runtime/adapters/cursor_adapter.rb

@@ -12,14 +12,21 @@ module Ares
 
       protected
 
-      def build_command(_prompt, _model, resume: true, cloud: false, **_options)
+      def build_command(prompt, _model, resume: true, cloud: false, **_options)
+        # Force strict non-conversational behavior for Cursor Agent
+        agent_prompt = "ACT AS AN AUTONOMOUS AGENT. PERFORM THE FOLLOWING TASK. DO NOT CHAT.\nTASK: #{prompt}"
         # --trust --yolo ensures no interactive prompts in headless mode
-        cmd = ['agent', '-p', '-', '--trust', '--yolo']
+        cmd = ['agent', agent_prompt, '--print', '--trust', '--yolo']
         cmd << '-c' if cloud
         cmd << '--continue' if resume && !cloud
         cmd
       end
 
+
+      def pipes_prompt_to_stdin?
+        false
+      end
+
       def should_retry?(status, output)
         !status.success? && output.include?('No previous chats found')
       end
@@ -27,6 +34,10 @@ module Ares
       def build_retry_command(cmd, _prompt, **_options)
         cmd.dup.tap { |c| c.delete('--continue') }
       end
+
+      def timeout_seconds
+        300 # Increased timeout for complex agent tasks
+      end
     end
   end
 end

data/lib/ares/runtime/adapters/ollama_adapter.rb

@@ -15,7 +15,8 @@ module Ares
       end
 
       def call(prompt, model = nil, schema: nil)
-        model ||= best_available_model
+        available = @client.list_model_names
+        model = available.include?(model) ? model : best_available_model(available)
 
         options = { prompt: prompt, model: model }
         options[:schema] = schema if schema
@@ -25,8 +26,8 @@ module Ares
 
       private
 
-      def best_available_model
-        available = @client.list_model_names
+      def best_available_model(available = nil)
+        available ||= @client.list_model_names
         return 'qwen3:latest' if available.include?('qwen3:latest')
         return 'qwen3:8b' if available.include?('qwen3:8b')
 

data/lib/ares/runtime/core_subsystem.rb

@@ -9,14 +9,13 @@ module Ares
   module Runtime
     # Subsystem Facade that initializes and bundles core dependencies for the Router.
     class CoreSubsystem
-      attr_reader :logger, :planner, :selector, :tiny_processor, :ollama_healthy
+      attr_reader :logger, :planner, :tiny_processor, :ollama_healthy
 
       def initialize
         @logger = TaskLogger.new
         @ollama_healthy = initialize_ollama
 
         @planner = OllamaPlanner.new(healthy: @ollama_healthy)
-        @selector = ModelSelector.new
         @tiny_processor = TinyTaskProcessor.new(healthy: @ollama_healthy)
       end
 

data/lib/ares/runtime/diagnostic_runner.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require_relative 'fix_applicator'
+
+module Ares
+  module Runtime
+    # Runs diagnostic commands (tests, syntax, lint) and escalates failures to AI fix.
+    class DiagnosticRunner
+      def initialize(core:, spinner:)
+        @core = core
+        @spinner = spinner
+      end
+
+      def run_tests(options = {})
+        run_loop('bundle exec rspec', options.merge(type: :test, title: 'Running tests'))
+      end
+
+      def run_syntax_check(options = {})
+        cmd = "ruby -e 'Dir.glob(\"{lib,bin,exe,spec}/**/*.rb\").each { |f| (puts \"Checking \#{f}\"; system(\"ruby -c \#{f}\")) or exit(1) }'"
+        run_loop(cmd, options.merge(type: :syntax, title: 'Checking syntax'))
+      end
+
+      def run_lint(options = {})
+        run_loop('bundle exec rubocop -A', options.merge(type: :lint, title: 'Running RuboCop'))
+      end
+
+      def run_loop(command, options)
+        title = options[:title] || 'Running verification'
+        result = run_with_spinner(command, title)
+
+        return report_success(title) if result[:exit_status].zero?
+
+        summary = parse_summary(result[:output], title, options[:type] || :test)
+        print_summary(summary, options[:type] || :test, title: title)
+
+        return skip_escalation if options[:dry_run]
+
+        applicator = FixApplicator.new(core: @core, spinner: @spinner, diagnostic_runner: self)
+        result = applicator.escalate(
+          type: options[:type] || :test,
+          summary: summary,
+          verify_command: command,
+          fix_first_only: !!options[:fix_first_only]
+        )
+
+        return result if options[:fail_fast]
+      end
+
+      def print_summary(summary, type, title: nil)
+        header = title || "Diagnostic Summary (#{type.to_s.upcase})"
+        table = TTY::Table.new(header: %w[Attribute Value])
+        table << ['Failed Items', Array(summary['failed_items'] || summary['failed_tests']).join("\n")]
+        table << ['Error Summary', summary['error_summary']]
+        puts "\n--- #{header} ---"
+        puts table.render(:unicode, multiline: true)
+      end
+
+      private
+
+      def run_with_spinner(command, title)
+        @spinner.update(title: "#{title}...")
+        result = nil
+        @spinner.run { result = TerminalRunner.run(command) }
+        result
+      end
+
+      def parse_summary(output, title, type)
+        @spinner.update(title: "#{title} failed. Summarizing diagnostic output...")
+        summary = nil
+        @spinner.run do
+          parsed = DiagnosticParser.parse(output, type: type)
+          if parsed['files'].empty? && parsed['failed_items'].empty?
+            @spinner.update(title: "#{title} failed. LLM Fallback (Slow)...")
+            summary = @core.tiny_processor.summarize_output(output, type: type)
+          else
+            summary = parsed
+          end
+        end
+        summary
+      rescue StandardError => e
+        @spinner.update(title: "#{title} failed. Error in fast-path: #{e.message}. LLM Fallback...")
+        @spinner.run { @core.tiny_processor.summarize_output(output, type: type) }
+      end
+
+      def report_success(title)
+        puts "#{title} passed! ✅"
+        true
+      end
+
+      def skip_escalation
+        puts 'Dry run: skipping escalation.'
+        false
+      end
+    end
+  end
+end

data/lib/ares/runtime/engine_chain.rb

@@ -9,57 +9,30 @@ module Ares
   module Runtime
     # Chain of Responsibility Handler linking CLI engines for automated fallback.
     class EngineChain
+      CAPABLE_ENGINES = %w[claude codex cursor ollama].freeze
+
       attr_accessor :next_handler
       attr_reader :engine_name
 
+      def self.build_fallback(initial_engine)
+        initial = initial_engine.to_s
+        fallback_order = ([initial] + (CAPABLE_ENGINES - [initial])).uniq
+        chain = build(fallback_order)
+        { chain: chain, size: fallback_order.size }
+      end
+
       def initialize(engine_name)
         @engine_name = engine_name
         @next_handler = nil
         @adapter = get_adapter(engine_name)
       end
 
-      # Standard execution chain
       def call(prompt, options, attempt: 1, total: 1)
-        if attempt > 1
-          puts "Falling back to #{@engine_name} (attempt #{attempt}/#{total})..."
-        else
-          puts "Executing task via #{@engine_name} (attempt #{attempt}/#{total})..."
-        end
-
-        begin
-          QuotaManager.increment_usage(@engine_name)
-
-          @adapter.call(prompt, options[:model], **adapter_options(options))
-        rescue StandardError => e
-          puts "\n⚠️ #{@engine_name} failed: #{e.message.split("\n").first}"
-
-          raise 'All available AI engines failed to execute the task.' unless @next_handler
-
-          @next_handler.call(prompt, options, attempt: attempt + 1, total: total)
-        end
+        execute_with_fallback(prompt, options, attempt, total, mode: :task)
       end
 
-      # Specialized call for fix escalation
-      def call_fix(prompt, options, attempt: 1, total: 1, &checkpoint_block)
-        if attempt > 1
-          puts "Falling back to #{@engine_name} for fix (attempt #{attempt}/#{total})..."
-        else
-          puts "Applying fix via #{@engine_name} (attempt #{attempt}/#{total})..."
-        end
-
-        checkpoint_block&.call(@engine_name)
-
-        begin
-          QuotaManager.increment_usage(@engine_name)
-
-          @adapter.call(prompt, options[:model], **adapter_options(options))
-        rescue StandardError => e
-          puts "\n⚠️ #{@engine_name} failed during fix: #{e.message.split("\n").first}"
-
-          raise 'All available AI engines failed to apply the fix.' unless @next_handler
-
-          @next_handler.call_fix(prompt, options, attempt: attempt + 1, total: total, &checkpoint_block)
-        end
+      def call_fix(prompt, options, attempt: 1, total: 1, &block)
+        execute_with_fallback(prompt, options, attempt, total, mode: :fix, &block)
       end
 
       # Factory method to build the chain
@@ -80,6 +53,42 @@ module Ares
 
       private
 
+      def execute_with_fallback(prompt, options, attempt, total, mode:, &block)
+        puts status_message(attempt, total, mode)
+        block&.call(@engine_name)
+
+        QuotaManager.increment_usage(@engine_name)
+        opts = adapter_options(options)
+        opts[:schema] = options[:schema] if options[:schema]
+        @adapter.call(prompt, options[:model], **opts)
+      rescue StandardError => e
+        failed_msg = mode == :fix ? "#{@engine_name} failed during fix:" : "#{@engine_name} failed:"
+        puts "\n❌ #{failed_msg} #{e.message.split("\n").first}"
+        raise all_engines_failed_message(mode) unless @next_handler
+
+        next_method = mode == :fix ? :call_fix : :call
+        @next_handler.public_send(next_method, prompt, options, attempt: attempt + 1, total: total, &block)
+      end
+
+      def status_message(attempt, total, mode)
+        action = if attempt > 1
+                   'Falling back to'
+                 elsif mode == :fix
+                   'Applying fix via'
+                 else
+                   'Executing task via'
+                 end
+        "#{action} #{@engine_name} (attempt #{attempt}/#{total})..."
+      end
+
+      def all_engines_failed_message(mode)
+        if mode == :fix
+          'All available AI engines failed to apply the fix.'
+        else
+          'All available AI engines failed to execute the task.'
+        end
+      end
+
       def get_adapter(engine)
         case engine
         when 'claude' then Ares::Runtime::ClaudeAdapter.new

data/lib/ares/runtime/fix_applicator.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+module Ares
+  module Runtime
+    # Escalates diagnostic failures to AI engines and applies patches.
+    class FixApplicator
+      MAX_LINT_ITERATIONS = 20
+
+      def initialize(core:, spinner:, diagnostic_runner:)
+        @core = core
+        @spinner = spinner
+        @diagnostic_runner = diagnostic_runner
+      end
+
+      def escalate(type:, summary:, verify_command:, fix_first_only: false)
+        type == :lint ? escalate_lint_iteratively(summary, verify_command) : escalate_once(summary, type, verify_command)
+      end
+
+      private
+
+      def escalate_lint_iteratively(summary, verify_command)
+        current_summary = summary
+
+        MAX_LINT_ITERATIONS.times do |iteration|
+          puts "\n--- Fix iteration #{iteration + 1}/#{MAX_LINT_ITERATIONS} ---" if iteration.positive?
+
+          success = escalate_once(current_summary, :lint, verify_command, fix_first_only: true)
+          return true if success
+
+          verify_result = rerun_and_summarize(verify_command)
+          return false if verify_result[:exit_status].zero?
+
+          current_summary = verify_result[:summary]
+          @diagnostic_runner.print_summary(current_summary, :lint, title: 'Remaining offenses')
+        end
+
+        puts "\nReached max iterations (#{MAX_LINT_ITERATIONS}). Some offenses may remain."
+        false
+      end
+
+      def escalate_once(summary, type, verify_command, fix_first_only: false)
+        selection = ModelSelector.select({ 'task_type' => 'refactor', 'risk_level' => 'medium' })
+        puts "Selected Engine for fix: #{selection[:engine]} (#{selection[:model] || 'default'})"
+
+        result = apply_fix_with_fallbacks(build_fix_prompt(summary, type, fix_first_only), selection)
+        return false unless result
+
+        apply_patches(result) if result['patches']&.any?
+
+        verify_result = run_verify(verify_command)
+        handle_verification(verify_result, type)
+      end
+
+      def rerun_and_summarize(verify_command)
+        @spinner.update(title: 'Re-running RuboCop...')
+        verify_result = nil
+        @spinner.run { verify_result = TerminalRunner.run(verify_command) }
+
+        return { exit_status: verify_result[:exit_status], summary: nil } if verify_result[:exit_status].zero?
+
+        @spinner.update(title: 'Summarizing remaining offenses...')
+        summary = nil
+        @spinner.run { summary = @core.tiny_processor.summarize_output(verify_result[:output], type: :lint) }
+        { exit_status: verify_result[:exit_status], summary: summary }
+      end
+
+      def build_fix_prompt(summary, type, fix_first_only)
+        builder = PromptBuilder.new
+                               .add_context(ContextLoader.load)
+                               .add_diagnostic(type, summary['failed_items'] || summary['failed_tests'], summary['error_summary'])
+                               .add_instruction("TASK: Fix the #{type} failures identified above.")
+
+        builder.add_instruction('Fix ONLY the first offense listed.') if fix_first_only
+
+        builder.add_instruction("You MUST provide JSON with 'explanation' and 'patches' (with 'file' and 'content' fields).")
+               .add_files(summary['files'])
+               .build
+      end
+
+      def apply_fix_with_fallbacks(fix_prompt, selection)
+        fallback = EngineChain.build_fallback(selection[:engine] || :claude)
+        adapter_opts = { model: selection[:model], fork_session: true, resume: true }
+
+        raw = fallback[:chain].call_fix(fix_prompt, adapter_opts, total: fallback[:size]) do |engine|
+          @spinner.update(title: checkpoint_message(engine))
+        end
+        parse_json(raw)
+      end
+
+      def parse_json(raw)
+        json_str = raw.match(/```(?:json)?\s*(.*?)\s*```/m)&.captures&.first || raw
+        JSON.parse(json_str)
+      rescue JSON::ParserError => e
+        puts "\n⚠️ Failed to parse valid JSON from the AI engine's response."
+        puts "--- Raw Output ---\n#{raw}\n----------------"
+        raise e
+      end
+
+      def apply_patches(result)
+        result['patches'].each do |patch|
+          path = File.expand_path(patch['file'], Dir.pwd)
+          FileUtils.mkdir_p(File.dirname(path))
+          File.write(path, patch['content'])
+          puts "Applied fix to #{patch['file']} ✅"
+        end
+      end
+
+      def run_verify(verify_command)
+        @spinner.update(title: 'Verifying fix...')
+        result = nil
+        @spinner.run { result = TerminalRunner.run(verify_command) }
+        result
+      end
+
+      def handle_verification(verify_result, type)
+        if verify_result[:exit_status].zero?
+          puts "Fix successful! #{type.to_s.capitalize} issues resolved. ✅"
+          true
+        else
+          puts "Fix failed. #{type.to_s.capitalize} issues still persist. ❌"
+          false
+        end
+      end
+
+      def checkpoint_message(engine)
+        case engine.to_s
+        when 'claude' then 'Leveraging Claude auto-checkpoint...'
+        when 'codex' then 'Leveraging Codex session persistence...'
+        else "Ensuring state persistence for #{engine}..."
+        end
+      end
+    end
+  end
+end

data/lib/ares/runtime/model_selector.rb

@@ -6,7 +6,7 @@ module Ares
       CONFIDENCE_THRESHOLD = 0.7
 
       def self.select(plan)
-        @config = ConfigManager.load_models
+        config = ConfigManager.load_models
 
         task_type = plan['task_type'] || 'refactor'
         confidence = plan['confidence'] || 1.0
@@ -15,7 +15,7 @@ module Ares
         return { engine: :claude, model: 'opus' } if confidence < CONFIDENCE_THRESHOLD || plan['risk_level'] == 'high'
 
         # Use string key lookup as ConfigManager returns keys as strings sometimes
-        rule = @config[task_type.to_sym] || @config[:refactor]
+        rule = config[task_type.to_sym] || config[:refactor]
         engine = rule[:engine].to_sym
 
         # Safety: restrict Ollama from code-modifying tasks if configured incorrectly

data/lib/ares/runtime/planner/ollama_planner.rb

@@ -8,8 +8,8 @@ require_relative '../ollama_client_factory'
 module Ares
   module Runtime
     class OllamaPlanner
-      PLANNER_TIMEOUT = 30 # Longer once health is verified
-      HARD_TIMEOUT = 35
+      PLANNER_TIMEOUT = 60 # Longer once health is verified
+      HARD_TIMEOUT = 65
 
       def initialize(healthy: true)
         @healthy = healthy

data/lib/ares/runtime/router.rb

@@ -1,8 +1,16 @@
 # frozen_string_literal: true
 
+require_relative 'diagnostic_runner'
+
 module Ares
   module Runtime
     class Router
+      SHORTCUT_PATTERNS = {
+        /\A(run\s+|check\s+)?(test|rspec|fix|diagnostic)(s|ing)?\s*\z/i => :run_test_diagnostic,
+        /\A(run\s+|check\s+)?(syntax|compile)(\s+check)?\s*\z/i => :run_syntax_check,
+        /\A(run\s+|check\s+)?(lint|format|style)(ting|ing|s)?\s*\z/i => :run_lint
+      }.freeze
+
       def initialize
         @core = CoreSubsystem.new
       end
@@ -12,6 +20,7 @@ module Ares
         check_quota!
 
         @spinner = TTY::Spinner.new('[:spinner] :title', format: :dots)
+        @diagnostic = DiagnosticRunner.new(core: @core, spinner: @spinner)
 
         shortcut_result = match_shortcut_task(task, options)
         return shortcut_result if shortcut_result
@@ -28,112 +37,15 @@ module Ares
       private
 
       def run_test_diagnostic(options)
-        run_diagnostic_loop('bundle exec rspec', options.merge(type: :test, title: 'Running tests'))
+        @diagnostic.run_tests(options)
       end
 
       def run_syntax_check(options)
-        # Check syntax for all ruby files in lib, bin, spec individually to catch all errors
-        cmd = "ruby -e 'Dir.glob(\"{lib,bin,exe,spec}/**/*.rb\").each { |f| (puts \"Checking \#{f}\"; system(\"ruby -c \#{f}\")) or exit(1) }'"
-        run_diagnostic_loop(cmd, options.merge(type: :syntax, title: 'Checking syntax'))
-      end
-
-      def run_diagnostic_loop(command, options)
-        title = options[:title] || 'Running verification'
-        @spinner.update(title: "#{title}...")
-        result = nil
-        @spinner.run { result = TerminalRunner.run(command) }
-
-        if result[:exit_status].zero?
-          puts "#{title} passed! ✅"
-          return true
-        end
-
-        type = options[:type] || :test
-        @spinner.update(title: "#{title} failed. Summarizing diagnostic output...")
-        summary = nil
-
-        @spinner.run do
-          # Try fast-path regex/JSON parsing first
-          summary = DiagnosticParser.parse(result[:output], type: type)
-
-          # Fallback to LLM only if fast-path failed to identify files
-          if summary['files'].empty? || summary['failed_items'].empty?
-            @spinner.update(title: "#{title} failed. LLM Fallback (Slow)...")
-            summary = @core.tiny_processor.summarize_output(result[:output], type: type)
-          end
-        rescue StandardError => e
-          @spinner.update(title: "#{title} failed. Error in fast-path: #{e.message}. LLM Fallback...")
-          summary = @core.tiny_processor.summarize_output(result[:output], type: type)
-        end
-
-        puts "\n--- Diagnostic Summary (#{type.to_s.upcase}) ---"
-        table = TTY::Table.new(header: %w[Attribute Value])
-        table << ['Failed Items', Array(summary['failed_items'] || summary['failed_tests']).join("\n")]
-        table << ['Error Summary', summary['error_summary']]
-        puts table.render(:unicode, multiline: true)
-
-        if options[:dry_run]
-          puts 'Dry run: skipping escalation.'
-          return false
-        end
-
-        # Escalate to executor for fix
-        if type == :lint
-          escalate_lint_one_at_a_time(summary, options.merge(verify_command: command))
-        else
-          escalate_to_executor(summary, options.merge(verify_command: command))
-        end
+        @diagnostic.run_syntax_check(options)
       end
 
-      def escalate_lint_one_at_a_time(summary, options)
-        max_iterations = 20
-        current_summary = summary
-
-        max_iterations.times do |iteration|
-          puts "\n--- Fix iteration #{iteration + 1}/#{max_iterations} ---" if iteration.positive?
-
-          success = escalate_to_executor(current_summary, options.merge(fix_first_only: true))
-          return true if success
-
-          @spinner.update(title: 'Re-running RuboCop...')
-          verify_result = nil
-          @spinner.run { verify_result = TerminalRunner.run(options[:verify_command]) }
-
-          return false if verify_result[:exit_status].zero?
-
-          @spinner.update(title: 'Summarizing remaining offenses...')
-          current_summary = nil
-          @spinner.run { current_summary = @core.tiny_processor.summarize_output(verify_result[:output], type: :lint) }
-
-          puts "\n--- Remaining offenses ---"
-          table = TTY::Table.new(header: %w[Attribute Value])
-          table << ['Failed Items', Array(current_summary['failed_items']).join("\n")]
-          table << ['Error Summary', current_summary['error_summary']]
-          puts table.render(:unicode, multiline: true)
-        end
-
-        puts "\nReached max iterations (#{max_iterations}). Some offenses may remain."
-        false
-      end
-
-      def escalate_to_executor(summary, options)
-        type = options[:type] || :test
-        verify_command = options[:verify_command] || 'bundle exec rspec'
-        fix_prompt = generate_fix_prompt(summary, options)
-
-        selection = ModelSelector.select({ 'task_type' => 'refactor', 'risk_level' => 'medium' })
-        puts "Selected Engine for fix: #{selection[:engine]} (#{selection[:model] || 'default'})"
-
-        result = apply_fix_with_fallbacks(fix_prompt, selection)
-        return false unless result
-
-        apply_patches(result) if result['patches']&.any?
-
-        @spinner.update(title: 'Verifying fix...')
-        verify_result = nil
-        @spinner.run { verify_result = TerminalRunner.run(verify_command) }
-
-        handle_verification_result(verify_result, type)
+      def run_lint(options)
+        @diagnostic.run_lint(options)
       end
 
       def check_quota!
@@ -144,27 +56,20 @@ module Ares
       end
 
       def match_shortcut_task(task, options)
-        if task.match?(/\A(run\s+|check\s+)?(test|rspec|fix|diagnostic)(s|ing)?\s*\z/i)
-          return run_test_diagnostic(options)
+        SHORTCUT_PATTERNS.each do |pattern, method|
+          return send(method, options) if task.match?(pattern)
         end
-        return run_syntax_check(options) if task.match?(/\A(run\s+|check\s+)?(syntax|compile)(\s+check)?\s*\z/i)
-        return run_lint(options) if task.match?(/\A(run\s+|check\s+)?(lint|format|style)(ting|ing|s)?\s*\z/i)
-
         nil
       end
 
       def plan_task(task)
-        plan = nil
         @spinner.update(title: 'Planning task...')
-        @spinner.run { plan = @core.planner.plan(task) }
-        plan
+        @spinner.run { @core.planner.plan(task) }
       end
 
       def select_model_for_plan(plan)
-        selection = nil
         @spinner.update(title: 'Selecting optimal model...')
-        @spinner.run { selection = ModelSelector.select(plan) }
-        selection
+        @spinner.run { ModelSelector.select(plan) }
       end
 
       def handle_low_confidence(selection, plan)
@@ -188,16 +93,15 @@ module Ares
 
       def execute_engine_task(task, plan, selection, options)
         puts "Engine Selected: #{selection[:engine]} (#{selection[:model] || 'default'})"
-        return if options[:dry_run] && puts('--- DRY RUN MODE ---')
+        if options[:dry_run]
+          puts '--- DRY RUN MODE ---'
+          return
+        end
 
         @core.logger.log_task(task, plan, selection)
         GitManager.create_branch(@core.logger.task_id, task) if options[:git]
 
-        capable_engines = %w[claude codex cursor]
-        initial_engine = selection[:engine]&.to_s || 'claude'
-        fallback_chain = ([initial_engine] + (capable_engines - [initial_engine])).uniq
-
-        chain = EngineChain.build(fallback_chain)
+        fallback = EngineChain.build_fallback(selection[:engine] || :claude)
         prompt = PromptBuilder.new
                               .add_context(ContextLoader.load)
                               .add_task(task)
@@ -205,92 +109,13 @@ module Ares
 
         adapter_opts = { model: selection[:model], fork_session: true, resume: true, cloud: options[:cloud] }
 
-        output = chain.call(prompt, adapter_opts, total: fallback_chain.size)
+        output = fallback[:chain].call(prompt, adapter_opts, total: fallback[:size])
         @core.logger.log_result(output)
 
         GitManager.commit_changes(@core.logger.task_id, task) if options[:git]
         puts output
       end
 
-      def generate_fix_prompt(summary, options)
-        type = options[:type] || :test
-
-        builder = PromptBuilder.new
-                               .add_context(ContextLoader.load)
-                               .add_diagnostic(type, summary['failed_items'] || summary['failed_tests'], summary['error_summary'])
-                               .add_instruction("TASK: Fix the #{type} failures identifying above.")
-
-        builder.add_instruction('Fix ONLY the first offense listed.') if options[:fix_first_only]
-
-        builder.add_instruction("You MUST provide JSON with 'explanation' and 'patches' (with 'file' and 'content' fields).")
-               .add_files(summary['files'])
-               .build
-      end
-
-      def apply_fix_with_fallbacks(fix_prompt, selection)
-        capable_engines = %w[claude codex cursor]
-        initial_engine = selection[:engine]&.to_s || 'claude'
-        fallback_chain = ([initial_engine] + (capable_engines - [initial_engine])).uniq
-
-        chain = EngineChain.build(fallback_chain)
-        adapter_opts = { model: selection[:model], fork_session: true, resume: true }
-
-        raw = chain.call_fix(fix_prompt, adapter_opts, total: fallback_chain.size) do |current_engine|
-          create_checkpoint(current_engine)
-        end
-        parse_robust_json(raw)
-      end
-
-      def parse_robust_json(raw)
-        json_str = raw.match(/```(?:json)?\s*(.*?)\s*```/m)&.captures&.first || raw
-        begin
-          JSON.parse(json_str)
-        rescue JSON::ParserError => e
-          puts "\n⚠️ Failed to parse valid JSON from the AI engine's response."
-          puts "--- Raw Output ---\n#{raw}\n----------------"
-          raise e
-        end
-      end
-
-      def apply_patches(result)
-        result['patches'].each do |patch|
-          path = File.expand_path(patch['file'], Dir.pwd)
-          FileUtils.mkdir_p(File.dirname(path))
-          File.write(path, patch['content'])
-          puts "Applied fix to #{patch['file']} ✅"
-        end
-      end
-
-      def handle_verification_result(verify_result, type)
-        if verify_result[:exit_status].zero?
-          puts "Fix successful! #{type.to_s.capitalize} issues resolved. ✅"
-          true
-        else
-          puts "Fix failed. #{type.to_s.capitalize} issues still persist. ❌"
-          false
-        end
-      end
-
-      def create_checkpoint(engine)
-        # Checkpointing logic varies by engine.
-        # For now, we ensure a git-based safety net if not in a git repo or if native fails.
-        case engine
-        when :claude
-          # Claude Code does automatic checkpointing on every prompt.
-          @spinner.update(title: 'Leveraging Claude auto-checkpoint...')
-        when :codex
-          # Codex sessions are automatically persisted.
-          @spinner.update(title: 'Leveraging Codex session persistence...')
-        else
-          # Fallback to git stash or similar if we wanted a hard checkpoint,
-          # but since we are often on a task branch, git is our checkpoint.
-          @spinner.update(title: "Ensuring state persistence for #{engine}...")
-        end
-      end
-
-      def run_lint(options)
-        run_diagnostic_loop('bundle exec rubocop -A', options.merge(type: :lint, title: 'Running RuboCop'))
-      end
     end
   end
 end

data/lib/ares/runtime/version.rb

@@ -2,6 +2,6 @@
 
 module Ares
   module Runtime
-    VERSION = '2.0.3'
+    VERSION = '2.0.5'
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ares-runtime
 version: !ruby/object:Gem::Version
-  version: 2.0.3
+  version: 2.0.5
 platform: ruby
 authors:
 - Shubham
@@ -192,8 +192,10 @@ files:
 - lib/ares/runtime/context_loader.rb
 - lib/ares/runtime/core_subsystem.rb
 - lib/ares/runtime/diagnostic_parser.rb
+- lib/ares/runtime/diagnostic_runner.rb
 - lib/ares/runtime/doctor.rb
 - lib/ares/runtime/engine_chain.rb
+- lib/ares/runtime/fix_applicator.rb
 - lib/ares/runtime/git_manager.rb
 - lib/ares/runtime/initializer.rb
 - lib/ares/runtime/logs_cli.rb