ares-runtime 2.0.1

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

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require 'ollama_client'
+require 'timeout'
+require_relative '../config_manager'
+require_relative '../ollama_client_factory'
+
+module Ares
+  module Runtime
+    class TinyTaskProcessor
+      MAX_SUMMARY_INPUT = 5_000
+      DEFAULT_TIMEOUT = 30
+      HARD_TIMEOUT = 35
+
+      def initialize(healthy: true)
+        @healthy = healthy
+        @client = healthy ? OllamaClientFactory.build(timeout_seconds: DEFAULT_TIMEOUT) : nil
+      end
+
+      def summarize_output(output, type: :test)
+        return safe_summary_fallback('Safe Mode: Ollama skipped') unless @healthy
+
+        truncated = filter_and_truncate(output, type)
+        prompt = build_summary_prompt(truncated, type)
+
+        OllamaClientFactory.with_resilience(
+          hard_timeout: HARD_TIMEOUT,
+          fallback_value: safe_summary_fallback('Summary failed')
+        ) do
+          @client.generate(prompt: prompt, schema: summary_schema)
+        end
+      end
+
+      def summarize_diff(diff)
+        return safe_diff_fallback('Safe Mode: Ollama skipped') unless @healthy
+
+        OllamaClientFactory.with_resilience(
+          hard_timeout: HARD_TIMEOUT,
+          fallback_value: safe_diff_fallback('Diff summary failed')
+        ) do
+          @client.generate(prompt: build_diff_prompt(diff), schema: diff_schema)
+        end
+      end
+
+      private
+
+      def filter_and_truncate(output, type)
+        filtered = filter_output(output, type)
+        return filtered if filtered.length <= MAX_SUMMARY_INPUT
+
+        "#{filtered[0, MAX_SUMMARY_INPUT]}\n\n[... output truncated ...]"
+      end
+
+      def build_summary_prompt(truncated, type)
+        instruction = case type
+                      when :lint then 'Summarize RuboCop offenses. Extract file paths and line numbers:'
+                      when :syntax then 'Summarize Ruby syntax errors. Extract file paths and line numbers:'
+                      else 'Summarize RSpec failures. Extract file paths and line numbers:'
+                      end
+
+        PromptBuilder.new
+                     .add_instruction(instruction)
+                     .add_instruction(truncated)
+                     .build
+      end
+
+      def build_diff_prompt(diff)
+        PromptBuilder.new
+                     .add_instruction('Summarize the following git diff. Identify modified files, describe the core changes, and assess the risk level.')
+                     .add_instruction(diff)
+                     .build
+      end
+
+      def summary_schema
+        {
+          'type' => 'object',
+          'required' => %w[failed_items error_summary files],
+          'properties' => {
+            'failed_items' => { 'type' => 'array', 'items' => { 'type' => 'string' } },
+            'error_summary' => { 'type' => 'string' },
+            'files' => {
+              'type' => 'array',
+              'items' => {
+                'type' => 'object',
+                'required' => %w[path line],
+                'properties' => { 'path' => { 'type' => 'string' }, 'line' => { 'type' => 'integer' } }
+              }
+            }
+          }
+        }
+      end
+
+      def diff_schema
+        {
+          'type' => 'object',
+          'required' => %w[modified_files change_summary risk_level],
+          'properties' => {
+            'modified_files' => { 'type' => 'array', 'items' => { 'type' => 'string' } },
+            'change_summary' => { 'type' => 'string' },
+            'risk_level' => { 'type' => 'string', 'enum' => %w[low medium high] }
+          }
+        }
+      end
+
+      def safe_summary_fallback(reason)
+        { 'failed_items' => [], 'error_summary' => "Safe Mode: #{reason}", 'files' => [] }
+      end
+
+      def safe_diff_fallback(reason)
+        { 'modified_files' => [], 'change_summary' => "Safe Mode: #{reason}", 'risk_level' => 'medium' }
+      end
+
+      def filter_output(output, type)
+        lines = output.split("\n")
+        case type
+        when :lint
+          lines.grep(/:\d+:\d+: [CW]: /).first(20).join("\n")
+        when :test
+          lines.select do |l|
+            l.match?(/\d+\)\s/) || l.match?(%r{\s+Failure/Error:}) ||
+              l.match?(/\s+expected:/) || l.match?(/\s+got:/) || l.match?(/\.rb:\d+/)
+          end.first(50).join("\n")
+        else
+          lines.first(100).join("\n")
+        end
+      end
+    end
+  end
+end

data/lib/ares/runtime/prompt_builder.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Ares
+  module Runtime
+    # Implements the Builder Pattern for constructing complex LLM prompts
+    class PromptBuilder
+      def initialize
+        @sections = []
+      end
+
+      def add_context(context)
+        @sections << context unless context.to_s.strip.empty?
+        self
+      end
+
+      def add_task(task_description)
+        @sections << "TASK:\n#{task_description}"
+        self
+      end
+
+      def add_diagnostic(type, failed_items, error_summary)
+        @sections << <<~DIAG.strip
+          DIAGNOSTIC SUMMARY (#{type.to_s.upcase}):
+          Failed Items: #{Array(failed_items).join(', ')}
+          Error: #{error_summary}
+        DIAG
+        self
+      end
+
+      def add_files(files)
+        return self if files.nil? || files.empty?
+
+        files_content = Array(files).filter_map do |f|
+          path = File.expand_path(f['path'], Dir.pwd)
+          "--- FILE: #{f['path']} ---\n#{File.read(path)}" if File.exist?(path)
+        end.join("\n\n")
+
+        @sections << "FAILING FILE CONTENTS:\n#{files_content}" unless files_content.empty?
+        self
+      end
+
+      def add_instruction(instruction)
+        @sections << instruction unless instruction.to_s.strip.empty?
+        self
+      end
+
+      def build
+        @sections.join("\n\n")
+      end
+    end
+  end
+end

data/lib/ares/runtime/quota_manager.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Ares
+  module Runtime
+    class QuotaManager
+      GLOBAL_DIR = File.expand_path('~/.ares')
+      QUOTA_FILE = File.expand_path("#{GLOBAL_DIR}/.quota.json", __dir__)
+      LIMITS = { claude: 50, codex: 100 }.freeze
+
+      def self.usage
+        data = load_data
+        today = Date.today.to_s
+        {
+          claude: data[today] || 0,
+          codex: 0 # Tracked separately or placeholder
+        }
+      end
+
+      def self.increment_usage(engine)
+        return unless engine == :claude
+
+        data = load_data
+        today = Date.today.to_s
+
+        data[today] ||= 0
+        data[today] += 1
+
+        File.write(QUOTA_FILE, JSON.pretty_generate(data))
+      end
+
+      def self.remaining_quota
+        LIMITS[:claude] - usage[:claude]
+      end
+
+      def self.quota_exceeded?
+        remaining_quota <= 0
+      end
+
+      def self.load_data
+        return {} unless File.exist?(QUOTA_FILE)
+
+        JSON.parse(File.read(QUOTA_FILE))
+      rescue JSON::ParserError
+        {}
+      end
+    end
+  end
+end

data/lib/ares/runtime/router.rb

@@ -0,0 +1,285 @@
+# frozen_string_literal: true
+
+module Ares
+  module Runtime
+    class Router
+      def initialize
+        @core = CoreSubsystem.new
+      end
+
+      def run(task, options = {})
+        puts "Task ID: #{@core.logger.task_id}"
+        check_quota!
+
+        @spinner = TTY::Spinner.new('[:spinner] :title', format: :dots)
+
+        shortcut_result = match_shortcut_task(task, options)
+        return shortcut_result if shortcut_result
+
+        plan = plan_task(task)
+        selection = select_model_for_plan(plan)
+        selection = handle_low_confidence(selection, plan)
+
+        return if selection.nil? # User aborted
+
+        execute_engine_task(task, plan, selection, options)
+      end
+
+      private
+
+      def run_test_diagnostic(options)
+        run_diagnostic_loop('bundle exec rspec', options.merge(type: :test, title: 'Running tests'))
+      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
+      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)
+      end
+
+      def check_quota!
+        return unless QuotaManager.quota_exceeded?
+
+        puts '❌ Quota exceeded for Claude. Please try again later or use a different engine.'
+        exit 1
+      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)
+        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
+      end
+
+      def select_model_for_plan(plan)
+        selection = nil
+        @spinner.update(title: 'Selecting optimal model...')
+        @spinner.run { selection = ModelSelector.select(plan) }
+        selection
+      end
+
+      def handle_low_confidence(selection, plan)
+        return selection if plan['confidence'].to_f >= 0.7
+
+        prompt = TTY::Prompt.new
+        choice = prompt.select('Low confidence detected. How should we proceed?',
+                               "Execute with suggested #{selection[:engine]} (#{selection[:model] || 'default'})",
+                               'Override and use Claude Opus', 'Abort task')
+
+        case choice
+        when /Override/
+          puts 'Overridden: Using Claude Opus.'
+          { engine: :claude, model: 'opus' }
+        when /Abort/
+          puts 'Task aborted by user.'
+          nil
+        else selection
+        end
+      end
+
+      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 ---')
+
+        @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)
+        prompt = PromptBuilder.new
+                              .add_context(ContextLoader.load)
+                              .add_task(task)
+                              .build
+
+        adapter_opts = { model: selection[:model], fork_session: true, resume: true, cloud: options[:cloud] }
+
+        output = chain.call(prompt, adapter_opts, total: fallback_chain.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
+        JSON.parse(raw)
+      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/task_logger.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Ares
+  module Runtime
+    class TaskLogger
+      attr_reader :task_id
+
+      def initialize
+        @task_id = SecureRandom.uuid
+        @log_dir = File.join(ConfigManager.project_root, 'logs')
+        FileUtils.mkdir_p(@log_dir)
+      end
+
+      def log_task(task, plan, selection)
+        log_file = File.join(@log_dir, "#{@task_id}.json")
+        data = {
+          task_id: @task_id,
+          timestamp: Time.now.iso8601,
+          task: task,
+          plan: plan,
+          selection: selection
+        }
+        File.write(log_file, JSON.pretty_generate(data))
+      end
+
+      def log_result(result)
+        log_file = File.join(@log_dir, "#{@task_id}.json")
+        return unless File.exist?(log_file)
+
+        data = JSON.parse(File.read(log_file))
+        data[:result] = result
+        data[:completed_at] = Time.now.iso8601
+        File.write(log_file, JSON.pretty_generate(data))
+      end
+    end
+  end
+end

data/lib/ares/runtime/task_manager.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Ares
+  module Runtime
+    class TaskManager
+      # Placeholder for future task lifecycle management
+    end
+  end
+end

data/lib/ares/runtime/terminal_runner.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'open3'
+
+module Ares
+  module Runtime
+    # Core class for executing terminal commands, with support for sandboxing via Codex.
+    class TerminalRunner
+      def self.run(cmd, stdin_data: nil)
+        # Ensure cmd is an array for capture2e if we want to avoid shell injection,
+        # but the Router currently passes strings for complex commands.
+        # We'll normalize or handle both.
+        output, status = if cmd.is_a?(Array)
+                           Open3.capture2e(*cmd, stdin_data: stdin_data)
+                         else
+                           Open3.capture2e(cmd, stdin_data: stdin_data)
+                         end
+
+        # Safe join for logging/errors
+        cmd_str = cmd.is_a?(Array) ? cmd.join(' ') : cmd
+        raise "Command failed: #{cmd_str}\nOutput: #{output}" unless status.success?
+
+        { output: output, exit_status: status.exitstatus }
+      rescue StandardError => e
+        # Return a hash consistent with the Router's expectations
+        { output: e.message, exit_status: 1 }
+      end
+
+      def self.run_sandboxed(cmd)
+        # Use codex sandbox for secure execution
+        cmd_array = cmd.is_a?(Array) ? cmd : [cmd]
+        full_cmd = ['codex', 'sandbox', '--full-auto', '--', *cmd_array]
+        run(full_cmd)
+      end
+    end
+  end
+end