ares-runtime 2.0.1

data/lib/ares/runtime/context_loader.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Ares
+  module Runtime
+    class ContextLoader
+      def self.load
+        root = find_workspace_root(Dir.pwd)
+
+        agents_file = File.join(root, 'AGENTS.md')
+        skills_dir  = File.join(root, '.skills')
+
+        agents = File.exist?(agents_file) ? File.read(agents_file) : ''
+        skills = ''
+
+        if Dir.exist?(skills_dir)
+          Dir.glob(File.join(skills_dir, '**/SKILL.md')).each do |file|
+            skills += "#{File.read(file)}\n"
+          end
+        end
+
+        "Workspace Root: #{root}\n#{agents}\n#{skills}"
+      end
+
+      def self.find_workspace_root(path)
+        # Check explicitly registered workspaces first
+        registered = ConfigManager.load_merged('workspaces.yml')[:workspaces] || []
+        registered.each do |workspace|
+          return workspace if path.start_with?(workspace)
+        end
+
+        # Walk up the tree looking for AGENTS.md
+        current = path
+        while current != '/'
+          # Stop at home directory or root
+          break if current == Dir.home || current == '/'
+          return current if File.exist?(File.join(current, 'AGENTS.md'))
+
+          current = File.expand_path('..', current)
+        end
+
+        path # Default to CWD if no root found
+      end
+    end
+  end
+end

data/lib/ares/runtime/core_subsystem.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative 'task_logger'
+require_relative 'planner/ollama_planner'
+require_relative 'planner/tiny_task_processor'
+require_relative 'ollama_client_factory'
+
+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
+
+      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
+
+      private
+
+      def initialize_ollama
+        healthy = OllamaClientFactory.health_check?
+        if healthy
+          puts "✅ Local AI Engine (Ollama) is available."
+        else
+          puts "⚠️ Local AI (Ollama) unavailable. Running in Safe Mode for planning/diagnostics."
+        end
+        healthy
+      end
+    end
+  end
+end

data/lib/ares/runtime/diagnostic_parser.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Ares
+  module Runtime
+    # Parses RuboCop and RSpec JSON output into a unified diagnostic structure.
+    # Avoids sending raw logs to LLMs for summarization.
+    class DiagnosticParser
+      def self.parse(output, type:)
+        return fallback_parse(output, type) if output.nil? || output.strip.empty?
+
+        clean_output = strip_ansi(output)
+        case type
+        when :lint then parse_rubocop(clean_output)
+        when :syntax then parse_syntax(clean_output)
+        else parse_rspec(clean_output)
+        end
+      end
+
+      def self.strip_ansi(text)
+        text.to_s.gsub(/\e\[([;\d]+)?m/, '')
+      end
+
+      def self.parse_rubocop(output)
+        data = JSON.parse(output)
+        failed_items = []
+        files = []
+
+        data['files']&.each do |file|
+          path = file['path']
+          file['offenses']&.each do |offense|
+            line = offense.dig('location', 'line') || offense.dig('location', 'start_line')
+            failed_items << "#{path}:#{line}: #{offense['message']}"
+            files << { 'path' => path, 'line' => line.to_i }
+          end
+        end
+
+        {
+          'failed_items' => failed_items,
+          'error_summary' => build_error_summary(failed_items, 'RuboCop'),
+          'files' => remove_duplicates(files)
+        }
+      rescue JSON::ParserError
+        parse_text_rubocop(output)
+      end
+
+      def self.parse_text_rubocop(output)
+        failed_items = []
+        files = []
+        output.each_line do |line|
+          # Match standard RuboCop line: path:line:col: C: Message
+          # Using match instead of match? to capture data safely
+          m = line.match(/([^:\s]+):(\d+):(\d+): ([A-Z]): (.+)/)
+          next unless m
+
+          path = m[1]&.strip
+          line_num = m[2].to_i
+          letter = m[4]
+          msg = m[5]&.strip
+
+          next unless path && msg
+
+          # Only collect if it looks like a real RuboCop offense level
+          if %w[C W E F].include?(letter)
+            failed_items << "#{path}:#{line_num}: #{msg}"
+            files << { 'path' => path, 'line' => line_num }
+          end
+        end
+
+        {
+          'failed_items' => failed_items,
+          'error_summary' => build_error_summary(failed_items, 'RuboCop'),
+          'files' => remove_duplicates(files)
+        }
+      end
+
+      def self.parse_rspec(output)
+        data = JSON.parse(output)
+        failed_items = []
+        files = []
+
+        data['examples']&.each do |ex|
+          next unless ex['status'] == 'failed'
+
+          path = ex['file_path']&.delete_prefix('./')
+          line = ex['line_number']
+          msg = ex.dig('exception', 'message') || ex['full_description']
+          failed_items << "#{path}:#{line}: #{msg}"
+          files << { 'path' => path, 'line' => line.to_i }
+        end
+
+        {
+          'failed_items' => failed_items,
+          'error_summary' => build_error_summary(failed_items, 'RSpec'),
+          'files' => remove_duplicates(files)
+        }
+      rescue JSON::ParserError
+        parse_text_rspec(output)
+      end
+
+      def self.parse_text_rspec(output)
+        failed_items = []
+        files = []
+        # Match typical RSpec failure location: # ./path/to/spec.rb:123:in `...'
+        output.scan(%r{#\s+\./(.+?):(\d+):in}).each do |path, line|
+          failed_items << "Failure at #{path}:#{line}"
+          files << { 'path' => path, 'line' => line.to_i }
+        end
+
+        {
+          'failed_items' => failed_items,
+          'error_summary' => build_error_summary(failed_items, 'RSpec'),
+          'files' => remove_duplicates(files)
+        }
+      end
+
+      def self.parse_syntax(output)
+        failed_items = []
+        files = []
+        output.each_line do |line|
+          m = line.match(/\A(.+?):(\d+):\s*(.+)\z/)
+          next unless m
+
+          path = m[1].strip
+          line_num = m[2].to_i
+          msg = m[3].strip
+          failed_items << "#{path}:#{line_num}: #{msg}"
+          files << { 'path' => path, 'line' => line_num }
+        end
+
+        {
+          'failed_items' => failed_items,
+          'error_summary' => build_error_summary(failed_items, 'syntax'),
+          'files' => remove_duplicates(files)
+        }
+      end
+
+      def self.build_error_summary(failed_items, source)
+        count = failed_items.size
+        return "No #{source} issues found." if count.zero?
+
+        "There are #{count} failed #{source.downcase} item(s)."
+      end
+
+      def self.remove_duplicates(files)
+        files.uniq { |f| [f['path'], f['line']] }
+      end
+
+      def self.fallback_parse(output, type)
+        {
+          'failed_items' => [output.to_s.lines.first(50).join],
+          'error_summary' => "Parsed #{type} output via fallback.",
+          'files' => []
+        }
+      end
+    end
+  end
+end

data/lib/ares/runtime/doctor.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Ares
+  module Runtime
+    class Doctor
+      def self.run
+        puts "Running Ares diagnostics...\n\n"
+
+        check_ollama
+        check_claude
+        check_codex
+        check_cursor
+
+        puts "\nDiagnostics complete."
+      end
+
+      def self.check_ollama
+        puts "Ollama: #{system('which ollama > /dev/null') ? 'OK' : 'Missing'}"
+      end
+
+      def self.check_claude
+        puts "Claude CLI: #{system('which claude > /dev/null') ? 'OK' : 'Missing'}"
+      end
+
+      def self.check_codex
+        puts "Codex CLI: #{system('which codex > /dev/null') ? 'OK' : 'Missing'}"
+      end
+
+      def self.check_cursor
+        puts "Cursor CLI: #{system('which cursor > /dev/null') ? 'OK' : 'Missing'}"
+      end
+    end
+  end
+end

data/lib/ares/runtime/engine_chain.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require_relative 'adapters/claude_adapter'
+require_relative 'adapters/codex_adapter'
+require_relative 'adapters/cursor_adapter'
+require_relative 'adapters/ollama_adapter'
+
+module Ares
+  module Runtime
+    # Chain of Responsibility Handler linking CLI engines for automated fallback.
+    class EngineChain
+      attr_accessor :next_handler
+      attr_reader :engine_name
+
+      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
+      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
+      end
+
+      # Factory method to build the chain
+      def self.build(engine_names)
+        return nil if engine_names.empty?
+
+        first_handler = new(engine_names.first)
+        current = first_handler
+
+        engine_names[1..].each do |name|
+          handler = new(name)
+          current.next_handler = handler
+          current = handler
+        end
+
+        first_handler
+      end
+
+      private
+
+      def get_adapter(engine)
+        case engine
+        when 'claude' then Ares::Runtime::ClaudeAdapter.new
+        when 'cursor' then Ares::Runtime::CursorAdapter.new
+        when 'codex'  then Ares::Runtime::CodexAdapter.new
+        when 'ollama' then Ares::Runtime::OllamaAdapter.new
+        else raise "Unknown engine: #{engine}"
+        end
+      end
+
+      def adapter_options(options)
+        opts = {}
+        case @engine_name
+        when 'claude'
+          opts[:fork_session] = options[:fork_session] if options.key?(:fork_session)
+        when 'cursor'
+          opts[:resume] = options.fetch(:resume, true)
+          opts[:cloud] = options[:cloud] if options.key?(:cloud)
+        when 'codex'
+          opts[:resume] = options.fetch(:resume, true)
+        end
+        opts
+      end
+    end
+  end
+end

data/lib/ares/runtime/git_manager.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Ares
+  module Runtime
+    # Manages Git operations for task-based branching and committing.
+    class GitManager
+      def self.create_branch(task_id, task_description = nil)
+        # Default to main or master as base branch
+        base = `git rev-parse --verify main >/dev/null 2>&1 && echo main || echo master`.strip
+
+        slug = if task_description
+                 task_description.downcase.gsub(/[^a-z0-9]/, '-').squeeze('-').slice(0, 40).strip.gsub(/^-|-$/, '')
+               end
+        branch_name = slug ? "task-#{task_id}-#{slug}" : "task-#{task_id}"
+
+        # Branch from the base branch to keep a flat history
+        `git checkout -b #{branch_name} #{base}`
+      end
+
+      def self.commit_changes(task_id, task_description)
+        `git add .`
+        `git commit -m "ares: task-#{task_id} #{task_description}"`
+      end
+    end
+  end
+end

data/lib/ares/runtime/initializer.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+
+module Ares
+  module Runtime
+    class Initializer
+      def self.run
+        root = ConfigManager.project_root
+        target = File.join(root, 'config', 'ares')
+
+        if Dir.exist?(target)
+          puts 'Ares already initialized.'
+          return
+        end
+
+        FileUtils.mkdir_p(target)
+        copy_default('models.yml', target)
+        copy_default('ollama.yml', target)
+
+        puts "Initialized Ares in #{target}"
+      end
+
+      def self.copy_default(file, target)
+        source = ConfigManager.gem_default_path(file)
+        FileUtils.cp(source, File.join(target, file)) if File.exist?(source)
+      end
+    end
+  end
+end

data/lib/ares/runtime/logs_cli.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Ares
+  module Runtime
+    class LogsCLI
+      def self.run
+        project_log_dir = File.join(ConfigManager.project_root, 'logs')
+        global_log_dir = File.expand_path('~/.ares/logs')
+
+        log_dir = Dir.exist?(project_log_dir) ? project_log_dir : global_log_dir
+
+        unless Dir.exist?(log_dir)
+          puts "No logs found in #{log_dir}."
+          return
+        end
+
+        logs = Dir.glob("#{log_dir}/*.json").sort_by { |f| File.mtime(f) }.last(10).reverse
+
+        if logs.empty?
+          puts "No JSON logs found in #{log_dir}."
+          return
+        end
+
+        logs.each do |file|
+          puts "\n--- Task: #{File.basename(file, '.json')} ---"
+          data = JSON.parse(File.read(file))
+          puts "Timestamp: #{data['timestamp']}"
+          puts "Task:      #{data['task']}"
+          puts "Engine:    #{data.dig('selection', 'engine')}"
+          puts "Result:    #{data['result']&.slice(0, 100)}..."
+        end
+      end
+    end
+  end
+end

data/lib/ares/runtime/model_selector.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Ares
+  module Runtime
+    class ModelSelector
+      CONFIDENCE_THRESHOLD = 0.7
+
+      def self.select(plan)
+        @config = ConfigManager.load_models
+
+        task_type = plan['task_type'] || 'refactor'
+        confidence = plan['confidence'] || 1.0
+
+        # Escalate if confidence is low or risk is explicitly high
+        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]
+        engine = rule[:engine].to_sym
+
+        # Safety: restrict Ollama from code-modifying tasks if configured incorrectly
+        if engine == :ollama && %w[refactor architecture bulk_patch test_generation].include?(task_type.to_s)
+          engine = :claude
+          model = 'sonnet'
+        else
+          model = rule[:model]
+        end
+
+        {
+          engine: engine,
+          model: model
+        }
+      end
+    end
+  end
+end

data/lib/ares/runtime/ollama_client_factory.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'ollama_client'
+require 'timeout'
+require_relative 'config_manager'
+
+module Ares
+  module Runtime
+    # Centralizes Ollama client creation with strict timeouts and fail-fast logic.
+    class OllamaClientFactory
+      def self.build(timeout_seconds: 10)
+        config_data = ConfigManager.load_ollama
+        config = Ollama::Config.new
+        config.base_url = config_data[:base_url]
+        config.num_ctx = config_data[:num_ctx]
+        config.timeout = timeout_seconds
+        config.retries = 0 # Fail fast, let Ares handle fallbacks
+
+        Ollama::Client.new(config: config)
+      end
+
+      # 5s strict health check to determine if local AI is available.
+      def self.health_check?
+        Timeout.timeout(5) do
+          client = build(timeout_seconds: 4)
+          # 'tags' call is a lightweight way to check connectivity
+          client.tags
+          true
+        end
+      rescue StandardError, Timeout::Error
+        false
+      end
+
+      # Executes an Ollama call with a hard timeout and a provided fallback block.
+      def self.with_resilience(hard_timeout: 15, fallback_value: nil, &block)
+        Timeout.timeout(hard_timeout, &block)
+      rescue StandardError, Timeout::Error => e
+        puts "\n⚠️ Local AI (Ollama) Failure: #{e.message.split("\n").first}. Triggering Safe Mode fallback."
+        fallback_value
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'ollama_client'
+require 'timeout'
+require_relative '../../../../config/planner_schema'
+require_relative '../ollama_client_factory'
+
+module Ares
+  module Runtime
+    class OllamaPlanner
+      PLANNER_TIMEOUT = 30 # Longer once health is verified
+      HARD_TIMEOUT = 35
+
+      def initialize(healthy: true)
+        @healthy = healthy
+        @client = healthy ? OllamaClientFactory.build(timeout_seconds: PLANNER_TIMEOUT) : nil
+      end
+
+      def plan(task)
+        return safe_default_plan(task) unless @healthy
+
+        OllamaClientFactory.with_resilience(
+          hard_timeout: HARD_TIMEOUT,
+          fallback_value: safe_default_plan(task)
+        ) do
+          @client.generate(prompt: build_prompt(task), schema: PLANNER_SCHEMA)
+        end
+      end
+
+      private
+
+      def safe_default_plan(task)
+        {
+          'task_type' => 'refactor',
+          'risk_level' => 'medium',
+          'confidence' => 1.0,
+          'slices' => [task],
+          'explanation' => 'Safe Mode Default: Proceeding with high-level refactor plan.'
+        }
+      end
+
+      def build_prompt(task)
+        PromptBuilder.new
+                     .add_instruction("Analyze the following engineering task.\nDecompose it into discrete, executable work units (slices).\nAssign a task type, risk level, and confidence score.")
+                     .add_task(task)
+                     .add_instruction('Respond strictly as JSON. Slices should be a clean array of strings.')
+                     .build
+      end
+    end
+  end
+end