ares-runtime 2.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f1e365203d1a9e9c5744f269c549442361f39cf36da8525f311bae426947b58e
+  data.tar.gz: 96fc6b9900f2bea091cd6f90331eb09c51a7f751c5c42810fd9465e2d797d1b3
+SHA512:
+  metadata.gz: a0a770802c524ee3dbdadda2b8d0842e23d19c2c42943a763151a20cdc185fe6a11d0326b925fdaa907d9e165696df290a9c81cc3c3e16749f295c8f18deef21
+  data.tar.gz: be7b15ebe2c4cd3a4e80aadfdfa3ccddbe0c436876e9e9e115851acd9d2ce1c4b45db728c9c6d1f644e1a5b5ea45f1e9b2c8bf17c459456df036471c940414d0

data/CHANGELOG.md

@@ -0,0 +1,10 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+## [2.0.0] - 2026-02-28
+- Complete rewrite for Ares 2.0.
+- Introduced Deterministic Multi-Agent Orchestration.
+- Added Tiny Task Layer for diagnostic parsing.
+- Integrated TTY toolkit for advanced CLI UX.
+- Gemified project for distribution.

data/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 shubhamtaywade82@gmail.com
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,110 @@
+# 🧠 Ares 2.0: Agent Orchestrator
+
+A production-grade, deterministic multi-agent orchestrator CLI. Ares routes tasks to the best localized executor (Claude, Codex, or Cursor) based on a strategic planning phase powered by local Ollama.
+
+## 🏗️ Architecture
+
+```mermaid
+graph TD
+    User["User Task"] --> Router["Router (Ares CLI)"]
+    Router --> Planner["Ollama Planner (Local qwen3:latest)"]
+    Planner --> Router
+    Router --> TinyTask["Tiny Task Layer (Diagnostics)"]
+    TinyTask --> Router
+    Router --> Selector["Model Selector (Config-Driven)"]
+    Selector --> Router
+    Router --> Quota["Quota Manager"]
+    Router --> Logger["Task Logger (UUID)"]
+    Router --> Git["Git Manager (Auto-branch)"]
+    Router --> Adapter["Engine Adapter (Claude/Codex/Cursor)"]
+    Adapter --> Router
+    Router --> Verify["Post-Fix Verification"]
+```
+
+- **Planning Layer**: Uses local Ollama model to classify tasks, assign risk/confidence scores, and decompose tasks into discrete slices.
+- **Tiny Task Layer (Diagnostics)**: Offloads raw terminal output parsing and diff summarization to local Ollama, reducing token load on Claude by 60-80%.
+- **Routing Layer**: Deterministic rules in `config/ares/models.yml` allocate tasks to engines based on type and risk.
+- **Automated Fix Loop**: Detects failures, summarizes them locally, escalates for a fix, and re-verifies automatically.
+- **Traceability**: Every task receives a UUID and is logged in `logs/UUID.json`.
+- **Safety**: Built-in quota tracking and confidence-based escalation to Claude Opus for high-risk work.
+
+## 📟 Terminal User Interface (TUI)
+
+Ares 2.0 includes a professional, interactive dashboard for real-time task management.
+```bash
+bin/ares --tui
+```
+- **Live Monitoring**: Track quotas, task history, and AI reasoning live.
+- **In-App Config**: Change models and Ollama settings without leaving the CLI.
+- **Universal Fixes**: Trigger test, lint, or syntax healing with one keypress.
+
+## 📚 Documentation & Guides
+
+- [**TUI Guide**](file:///home/nemesis/project/agent-orchestrator/docs/TUI_GUIDE.md): Master the interactive dashboard.
+- [**Self-Healing Guide**](file:///home/nemesis/project/agent-orchestrator/docs/SELF_HEALING.md): How Ares automatically repairs your code.
+- [**Configuration Guide**](file:///home/nemesis/project/agent-orchestrator/docs/CONFIGURATION.md): Tuning model routing and local AI parameters.
+
+## 🚀 Usage
+
+### Installation (from RubyGems)
+```bash
+gem install ares-runtime
+```
+
+### Development Setup
+Install dependencies:
+```bash
+bundle install
+```
+
+Run a task:
+```bash
+# Using the installed gem
+ares "Task description"
+
+# Or using the local executable
+exe/ares "Task description"
+```
+
+### Automated Diagnostic Loop
+To run tests and automatically attempt fixes for failures:
+```bash
+exe/ares "run tests"
+```
+
+### Flags
+- `-d, --dry-run`: Plan and select model without execution.
+- `-g, --git`: Auto-branch before execution and auto-commit results.
+
+## 🎯 Model Routing Rules
+
+Routed via `config/models.yml`:
+- **Architecture**: Claude Opus (High Reasoning)
+- **Refactor**: Claude Sonnet (Primary Executor)
+- **Bulk Patch / Test Gen**: Codex (High Speed)
+- **Interactive Edit**: Cursor Agent (Human-in-the-loop)
+- **Summarization**: Claude Haiku (Low Cost)
+
+## 🔐 Safety & Project Hygiene
+
+1. **Deterministic One-Hop**: No recursive agent loops.
+2. **Quota Aware**: Claude usage is tracked daily via `QuotaManager`.
+3. **Workspace Isolation**: Execution is pinned to the current directory's context via recursive `AGENTS.md` discovery.
+4. **Git Protection**: `.gitignore` automatically excludes `logs/`, `*.gem`, and AI-specific session/cache directories (`.claude`, `.cursor`, etc.).
+
+## 🛠️ Configuration
+
+- `config/models.yml`: Define routing logic and confidence thresholds.
+- `config/workspaces.yml`: Register explicit workspace roots.
+- `config/planner_schema.rb`: The strict JSON schema for the Ollama planner.
+
+## 🛤️ Roadmap
+
+- [ ] **Cost Tracker**: USD/token cost calculation per engine.
+- [ ] **Parallel Execution**: Execute independent task slices concurrently.
+- [ ] **Automatic Diff Chunking**: Handle massive diffs by chunking before LLM processing.
+- [ ] **Rate Limiting**: Intelligent throttling to prevent mid-workflow blocks.
+
+---
+**Author**: Antigravity (shubhamtaywade82@gmail.com)
+**Repository**: [github.com/shubhamtaywade82/agent-orchestrator](https://github.com/shubhamtaywade82/agent-orchestrator)

data/config/models.yml

@@ -0,0 +1,25 @@
+architecture:
+  engine: claude
+  model: opus
+
+refactor:
+  engine: claude
+  model: sonnet
+
+bulk_patch:
+  engine: codex
+  model: default
+
+test_generation:
+  engine: codex
+  model: default
+
+summarization:
+  engine: ollama
+  model: default
+
+interactive_edit:
+  engine: cursor
+
+pr_automation:
+  engine: codex

data/config/ollama.yml

@@ -0,0 +1,4 @@
+base_url: "http://localhost:11434"
+timeout: 300
+num_ctx: 4096
+retries: 3

data/config/workspaces.yml

@@ -0,0 +1,6 @@
+# Register your project roots here for context discovery
+# Example:
+# workspaces:
+#   - /path/to/project-a
+#   - /path/to/project-b
+workspaces: []

data/exe/ares

@@ -0,0 +1,75 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'ares_runtime'
+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
+      else
+        run_task(command)
+      end
+    end
+
+    def self.init
+      Ares::Runtime::Initializer.run
+    end
+
+    def self.config
+      Ares::Runtime::ConfigCLI.run
+    end
+
+    def self.doctor
+      Ares::Runtime::Doctor.run
+    end
+
+    def self.version
+      puts "Ares v#{Ares::Runtime::VERSION}"
+    end
+
+    def self.logs
+      Ares::Runtime::LogsCLI.run
+    end
+
+    def self.run_task(first_arg)
+      options = {
+        dry_run: false,
+        git: false,
+        tui: false
+      }
+
+      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 }
+      end.parse!
+
+      if options[:tui]
+        Ares::Runtime::Tui.start
+        exit
+      end
+
+      task = ([first_arg] + ARGV).compact.join(' ').strip
+
+      if task.empty?
+        puts 'No task provided.'
+        exit 1
+      end
+
+      Ares::Runtime::Router.new.run(task, options)
+    end
+  end
+end
+
+Ares::CLI.start

data/lib/ares/cli.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative 'runtime/config_manager'
+require 'fileutils'
+
+module Ares
+  class CLI
+    def self.init
+      root = Ares::Runtime::ConfigManager.project_root
+      target_dir = File.join(root, 'config', 'ares')
+
+      if Dir.exist?(target_dir)
+        puts "Ares config already exists at #{target_dir}"
+        return
+      end
+
+      FileUtils.mkdir_p(target_dir)
+
+      copy_default('models.yml', target_dir)
+      copy_default('ollama.yml', target_dir)
+
+      puts "Ares initialized at #{target_dir}"
+    end
+
+    def self.copy_default(filename, target_dir)
+      gem_root = Gem::Specification.find_by_name('agent-orchestrator').gem_dir
+      source = File.join(gem_root, 'config', filename)
+
+      unless File.exist?(source)
+        puts "Warning: default #{filename} not found in gem."
+        return
+      end
+
+      FileUtils.cp(source, File.join(target_dir, filename))
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require 'open3'
+require 'timeout'
+
+module Ares
+  module Runtime
+    # Abstract base class implementing the Template Method pattern for CLI adapters.
+    # Defines the skeleton for execution, timeouts, and retries.
+    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
+
+        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
+      rescue Timeout::Error => e
+        raise "#{adapter_name} timed out after #{timeout}s: #{e.message}"
+      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 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
+
+      def adapter_name
+        self.class.name.split('::').last.sub('Adapter', '')
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative 'base_adapter'
+
+module Ares
+  module Runtime
+    # Adapter for Claude CLI. Passes prompts via stdin to avoid ARG_MAX limits.
+    class ClaudeAdapter < BaseAdapter
+      def call(prompt, model = nil, fork_session: false, **_options)
+        check_auth!
+        super(prompt, model, fork_session: fork_session)
+      end
+
+      protected
+
+      def build_command(_prompt, model, fork_session: false, **_options)
+        model ||= 'sonnet'
+        # -p - means read prompt from stdin
+        # --allow-dangerously-skip-permissions bypasses interactive prompts
+        cmd = ['claude', '--model', model, '-p', '-', '--allow-dangerously-skip-permissions']
+        cmd += %w[--continue --fork-session] if fork_session
+        cmd
+      end
+
+      private
+
+      def check_auth!
+        system('claude auth status > /dev/null 2>&1')
+        return if $CHILD_STATUS.success?
+
+        raise 'Claude CLI not logged in. Please run `claude login` in your terminal.'
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative 'base_adapter'
+
+module Ares
+  module Runtime
+    # Adapter for OpenAI Codex CLI. Uses exec mode with full automation for headless environments.
+    class CodexAdapter < BaseAdapter
+      def call(prompt, model = nil, resume: true, **_options)
+        super(prompt, model, resume: resume)
+      end
+
+      def apply_cloud_task(task_id)
+        cmd = ['codex', 'apply', task_id]
+        Ares::Runtime::TerminalRunner.run(cmd)
+      end
+
+      protected
+
+      def build_command(_prompt, _model, resume: true, **_options)
+        cmd = ['codex', 'exec', '--full-auto', '-']
+        cmd << '--resume' if resume
+        cmd
+      end
+
+      def should_retry?(status, output)
+        !status.success? && (output.include?('No session found') || output.include?('error: unexpected argument'))
+      end
+
+      def build_retry_command(cmd, _prompt, **_options)
+        cmd.dup.tap { |c| c.delete('--resume') }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative 'base_adapter'
+
+module Ares
+  module Runtime
+    # Adapter for Cursor CLI (agent). Uses stdin piping and trust flags for automation.
+    class CursorAdapter < BaseAdapter
+      def call(prompt, model = nil, resume: true, cloud: false, **_options)
+        super(prompt, model, resume: resume, cloud: cloud)
+      end
+
+      protected
+
+      def build_command(_prompt, _model, resume: true, cloud: false, **_options)
+        # --trust --yolo ensures no interactive prompts in headless mode
+        cmd = ['agent', '-p', '-', '--trust', '--yolo']
+        cmd << '-c' if cloud
+        cmd << '--continue' if resume && !cloud
+        cmd
+      end
+
+      def should_retry?(status, output)
+        !status.success? && output.include?('No previous chats found')
+      end
+
+      def build_retry_command(cmd, _prompt, **_options)
+        cmd.dup.tap { |c| c.delete('--continue') }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Ares
+  module Runtime
+    class OllamaAdapter
+      def initialize
+        config_data = ConfigManager.load_ollama
+        config = Ollama::Config.new
+        config.base_url = config_data[:base_url]
+        config.timeout = config_data[:timeout]
+        config.num_ctx = config_data[:num_ctx]
+        config.retries = config_data[:retries]
+
+        @client = Ollama::Client.new(config: config)
+      end
+
+      def call(prompt, model = nil, schema: nil)
+        model ||= best_available_model
+
+        options = { prompt: prompt, model: model }
+        options[:schema] = schema if schema
+
+        @client.generate(**options)
+      end
+
+      private
+
+      def best_available_model
+        available = @client.list_model_names
+        return 'qwen3:latest' if available.include?('qwen3:latest')
+        return 'qwen3:8b' if available.include?('qwen3:8b')
+
+        available.first || 'qwen3:8b' # Fallback
+      end
+    end
+  end
+end

data/lib/ares/runtime/config_cli.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Ares
+  module Runtime
+    class ConfigCLI
+      def self.run
+        models = ConfigManager.load_models
+        ollama = ConfigManager.load_ollama
+
+        puts "\nModels Configuration:"
+        puts models.to_yaml
+
+        puts "\nOllama Configuration:"
+        puts ollama.to_yaml
+      end
+    end
+  end
+end

data/lib/ares/runtime/config_manager.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+require 'yaml'
+require 'fileutils'
+
+module Ares
+  module Runtime
+    class ConfigManager
+      GLOBAL_DIR = File.expand_path('~/.ares')
+
+      # Public API -----------------------------------------------------------
+      def self.load_models
+        load_merged('models.yml')
+      end
+
+      def self.load_ollama
+        load_merged('ollama.yml')
+      end
+
+      def self.save_models(config)
+        save_config('models.yml', config)
+      end
+
+      def self.save_ollama(config)
+        save_config('ollama.yml', config)
+      end
+
+      def self.task_types
+        load_models.keys
+      end
+
+      def self.update_task_config(task_type, engine, model = nil)
+        config = load_models
+        config[task_type] = { engine: engine, model: model }
+        save_models(config)
+      end
+
+      # -------------------------------------------------------------------
+      # Internal helpers
+      def self.load_merged(filename)
+        merged = {}
+        merged = deep_merge(merged, load_file(gem_default_path(filename)))
+        merged = deep_merge(merged, load_file(global_path(filename)))
+        deep_merge(merged, load_file(local_path(filename)))
+      end
+
+      def self.load_file(path)
+        return {} unless File.exist?(path)
+
+        data = YAML.load_file(path)
+        return {} unless data.is_a?(Hash)
+
+        symbolize_keys(data)
+      rescue StandardError
+        {}
+      end
+
+      def self.save_config(filename, config)
+        target = File.exist?(local_path(filename)) ? local_path(filename) : global_path(filename)
+        FileUtils.mkdir_p(File.dirname(target))
+        File.write(target, stringify_keys(config || {}).to_yaml)
+      end
+
+      # Path helpers --------------------------------------------------------
+      def self.project_root
+        dir = Dir.pwd
+
+        loop do
+          # Look for the namespaced config directory
+          return dir if File.exist?(File.join(dir, 'config', 'ares', 'models.yml'))
+
+          parent = File.dirname(dir)
+          break if parent == dir
+
+          dir = parent
+        end
+
+        Dir.pwd
+      end
+
+      def self.local_path(filename)
+        File.join(project_root, 'config', 'ares', filename)
+      end
+
+      def self.global_path(filename)
+        File.join(GLOBAL_DIR, filename)
+      end
+
+      def self.gem_default_path(filename)
+        spec = Gem.loaded_specs['ares-runtime'] || begin
+          Gem::Specification.find_by_name('ares-runtime')
+        rescue StandardError
+          nil
+        end
+        if spec
+          File.join(spec.gem_dir, 'config', filename)
+        else
+          File.expand_path("../../config/#{filename}", __dir__)
+        end
+      end
+
+      # Utility methods ------------------------------------------------------
+      def self.deep_merge(hash1, hash2)
+        result = hash1.dup
+        hash2.each do |key, value|
+          result[key] = if result[key].is_a?(Hash) && value.is_a?(Hash)
+                          deep_merge(result[key], value)
+                        else
+                          value
+                        end
+        end
+        result
+      end
+
+      def self.symbolize_keys(hash)
+        return {} unless hash.is_a?(Hash)
+
+        hash.each_with_object({}) do |(k, v), h|
+          key = begin
+            k.to_sym
+          rescue StandardError
+            k
+          end
+          h[key] = v.is_a?(Hash) ? symbolize_keys(v) : v
+        end
+      end
+
+      def self.stringify_keys(hash)
+        return {} unless hash.is_a?(Hash)
+
+        hash.transform_keys(&:to_s).each_with_object({}) do |(k, v), h|
+          h[k] = v.is_a?(Hash) ? stringify_keys(v) : v
+        end
+      end
+    end
+  end
+end