octo-agent 0.11.2

data/lib/octo/agent_profile.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module Octo
+  # Loads and represents an agent profile (system prompt + skill whitelist).
+  #
+  # Lookup order for a profile named "coding":
+  #   1. ~/.octo/agents/coding/          (user override)
+  #   2. <gem>/lib/octo/default_agents/coding/  (built-in default)
+  #
+  # Each profile directory must contain:
+  #   - profile.yml       — name, description, skills whitelist
+  #   - system_prompt.md  — agent-specific system prompt content
+  #
+  # Global files (shared across all agents), also with user-override support:
+  #   - SOUL.md   — agent personality/values
+  #   - USER.md   — user profile information
+  #   - base_prompt.md — universal behavioral rules (todo manager, tool usage, etc.)
+  class AgentProfile
+    DEFAULT_AGENTS_DIR = File.expand_path("../default_agents", __FILE__).freeze
+    USER_AGENTS_DIR = File.expand_path("~/.octo/agents").freeze
+
+    attr_reader :name, :description
+
+    def initialize(name)
+      @name = name.to_s
+      profile_data = load_profile_yml
+      @description = profile_data["description"] || ""
+      @system_prompt_content = load_agent_file("system_prompt.md")
+    end
+
+    # Load a named profile. Raises ArgumentError if profile directory not found.
+    # @param name [String, Symbol] profile name (e.g. "coding", "general")
+    # @return [AgentProfile]
+    def self.load(name)
+      new(name)
+    end
+
+    # @return [String] agent-specific system prompt content
+    def system_prompt
+      @system_prompt_content
+    end
+
+    # @return [String] base prompt shared by all agents
+    def base_prompt
+      load_global_file("base_prompt.md")
+    end
+
+    # @return [String] soul content (user override → built-in default)
+    def soul
+      load_global_file("SOUL.md")
+    end
+
+    # @return [String] user profile content (user override → built-in default)
+    def user_profile
+      load_global_file("USER.md")
+    end
+
+    private def load_profile_yml
+      path = find_agent_file("profile.yml")
+      raise ArgumentError, "Agent profile '#{@name}' not found. " \
+        "Looked in #{user_agent_dir} and #{default_agent_dir}" unless path
+
+      YAML.safe_load(File.read(path)) || {}
+    end
+
+    # Load a file from the agent-specific directory (user override → built-in)
+    private def load_agent_file(filename)
+      path = find_agent_file(filename)
+      return "" unless path
+
+      File.read(path).strip
+    end
+
+    # Load a global file shared across all agents (user override → built-in)
+    private def load_global_file(filename)
+      user_path = File.join(USER_AGENTS_DIR, filename)
+      default_path = File.join(DEFAULT_AGENTS_DIR, filename)
+
+      path = if File.exist?(user_path) && !File.zero?(user_path)
+               user_path
+             elsif File.exist?(default_path)
+               default_path
+             end
+
+      return "" unless path
+
+      File.read(path).strip
+    end
+
+    # Find a file in user override dir first, then built-in default dir
+    private def find_agent_file(filename)
+      user_path = File.join(user_agent_dir, filename)
+      default_path = File.join(default_agent_dir, filename)
+
+      if File.exist?(user_path) && !File.zero?(user_path)
+        user_path
+      elsif File.exist?(default_path)
+        default_path
+      end
+    end
+
+    private def user_agent_dir
+      File.join(USER_AGENTS_DIR, @name)
+    end
+
+    private def default_agent_dir
+      File.join(DEFAULT_AGENTS_DIR, @name)
+    end
+  end
+end

data/lib/octo/anthropic_stream_aggregator.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Octo
+  # Reassembles an Anthropic Messages SSE stream (event: message_start /
+  # content_block_start / content_block_delta / content_block_stop /
+  # message_delta / message_stop / ping) into the same hash shape that
+  # MessageFormat::Anthropic.parse_response expects from a non-streaming
+  # response, while invoking on_chunk(input_tokens:, output_tokens:) as
+  # usage accumulates.
+  #
+  # Wire reference: https://docs.anthropic.com/en/api/messages-streaming
+  class AnthropicStreamAggregator
+    def initialize(on_chunk: nil)
+      @on_chunk = on_chunk
+      @blocks = {}
+      @stop_reason = nil
+      @usage = {}
+      @last_input_tokens = 0
+      @last_output_tokens = 0
+    end
+
+    def handle(event, data_str)
+      data = parse_or_nil(data_str)
+      return unless data
+
+      case event
+      when "message_start"
+        msg = data["message"] || {}
+        if (u = msg["usage"])
+          @usage.merge!(u)
+          emit_usage_progress
+        end
+      when "content_block_start"
+        idx = data["index"] || @blocks.size
+        cb = data["content_block"] || {}
+        case cb["type"]
+        when "tool_use"
+          @blocks[idx] = { kind: :tool_use, id: cb["id"], name: cb["name"], input_str: +"" }
+        else
+          @blocks[idx] = { kind: :text, text: +"" }
+        end
+      when "content_block_delta"
+        idx = data["index"] || 0
+        delta = data["delta"] || {}
+        block = (@blocks[idx] ||= { kind: :text, text: +"" })
+        case delta["type"]
+        when "text_delta"
+          block[:kind] ||= :text
+          block[:text] ||= +""
+          block[:text] << delta["text"].to_s
+        when "input_json_delta"
+          block[:kind] = :tool_use
+          block[:input_str] ||= +""
+          block[:input_str] << delta["partial_json"].to_s
+        when "thinking_delta"
+          block[:kind] = :thinking
+          block[:thinking] ||= +""
+          block[:thinking] << delta["thinking"].to_s
+        end
+        emit_estimate_progress
+      when "content_block_stop"
+        # Nothing to do: blocks are finalised in to_h.
+      when "message_delta"
+        if (d = data["delta"])
+          @stop_reason = d["stop_reason"] if d["stop_reason"]
+        end
+        if (u = data["usage"])
+          @usage.merge!(u)
+          emit_usage_progress
+        end
+      when "message_stop", "ping", "error"
+        # no-op
+      end
+    end
+
+    # Canonical non-streaming Anthropic response shape consumed by
+    # MessageFormat::Anthropic.parse_response.
+    def to_h
+      content_blocks = @blocks.keys.sort.map do |idx|
+        b = @blocks[idx]
+        case b[:kind]
+        when :tool_use
+          input_value =
+            if b[:input_str].to_s.empty?
+              {}
+            else
+              JSON.parse(b[:input_str]) rescue b[:input_str]
+            end
+          { "type" => "tool_use", "id" => b[:id], "name" => b[:name], "input" => input_value }
+        when :thinking
+          { "type" => "thinking", "thinking" => b[:thinking].to_s }
+        else
+          { "type" => "text", "text" => b[:text].to_s }
+        end
+      end
+
+      { "content" => content_blocks, "stop_reason" => @stop_reason, "usage" => @usage }
+    end
+
+    private def parse_or_nil(s)
+      JSON.parse(s)
+    rescue JSON::ParserError
+      nil
+    end
+
+    private def emit_usage_progress
+      return unless @on_chunk
+      input  = @usage["input_tokens"].to_i + @usage["cache_read_input_tokens"].to_i
+      output = @usage["output_tokens"].to_i
+      return if input == @last_input_tokens && output == @last_output_tokens
+      @last_input_tokens = input
+      @last_output_tokens = output
+      @on_chunk.call(input_tokens: input, output_tokens: output)
+    rescue => e
+      Octo::Logger.warn("[AnthropicStreamAggregator] on_chunk: #{e.class}: #{e.message}")
+    end
+
+    private def emit_estimate_progress
+      return unless @on_chunk
+      output = approximate_output_tokens
+      return if output == @last_output_tokens
+      @last_output_tokens = output
+      @on_chunk.call(input_tokens: @last_input_tokens, output_tokens: output)
+    rescue => e
+      Octo::Logger.warn("[AnthropicStreamAggregator] on_chunk: #{e.class}: #{e.message}")
+    end
+
+    private def approximate_output_tokens
+      total_chars = @blocks.values.sum do |b|
+        b[:text].to_s.bytesize + b[:input_str].to_s.bytesize + b[:thinking].to_s.bytesize
+      end
+      (total_chars / 4.0).ceil
+    end
+  end
+end

data/lib/octo/background_task_registry.rb

@@ -0,0 +1,324 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+module Octo
+  class BackgroundTaskRegistry
+    @tasks          = {}
+    @callbacks      = {}
+    @mutex          = Mutex.new
+    @sweep_running  = false
+
+    HANDLE_ALPHABET  = (('a'..'z').to_a + ('0'..'9').to_a).freeze
+    HANDLE_LENGTH    = 9
+
+    TTL_UNWATCHED    = 600
+    SWEEP_INTERVAL   = 30
+
+    class << self
+      def create_task(type:, metadata: {}, on_cancel: nil, dedup_key: nil)
+        @mutex.synchronize do
+          if dedup_key
+            existing = @tasks.values.find do |t|
+              t[:status] == "running" &&
+                t[:type] == type &&
+                t[:metadata]&.[](:dedup_key) == dedup_key
+            end
+            if existing
+              return { duplicate: true, handle_id: existing[:id], created_at: existing[:created_at] }
+            end
+          end
+
+          handle_id = generate_unique_handle_id
+          @tasks[handle_id] = {
+            id: handle_id,
+            type: type,
+            status: "running",
+            metadata: dedup_key ? metadata.merge(dedup_key: dedup_key) : metadata,
+            result: nil,
+            created_at: Time.now,
+            completed_at: nil,
+            on_cancel: on_cancel,
+            last_activity_at: metadata[:watched] ? nil : Time.now
+          }
+
+          ensure_sweep_thread unless metadata[:watched]
+
+          handle_id
+        end
+      end
+
+      def register_callback(handle_id:, agent:, &block)
+        fire_immediately = nil
+        captured_task    = nil
+
+        @mutex.synchronize do
+          task = @tasks[handle_id]
+          return false unless task
+
+          if task[:status] == "completed" || task[:status] == "cancelled"
+            fire_immediately = task[:result] || {
+              cancelled: task[:status] == "cancelled",
+              output: task[:cancel_reason] || (task[:status] == "cancelled" ? "Task was cancelled by user." : ""),
+              exit_code: nil,
+              state: task[:status]
+            }
+            captured_task = task
+          else
+            @callbacks[handle_id] = {
+              agent: agent,
+              callback: block,
+              registered_at: Time.now
+            }
+          end
+        end
+
+        fire_immediately = enrich_with_timing(fire_immediately, captured_task) if fire_immediately
+
+        if fire_immediately
+          Thread.new do
+            Thread.current.name = "bg-task-notify-late-#{handle_id[0, 8]}"
+            begin
+              block.call(fire_immediately)
+            rescue => e
+              Octo::Logger.warn("background_task_callback_retry",
+                handle_id: handle_id,
+                agent_session: agent&.session_id,
+                error: e
+              )
+              begin
+                sleep 0.5
+                block.call(fire_immediately)
+              rescue => e2
+                Octo::Logger.error("background_task_callback_error",
+                  handle_id: handle_id,
+                  agent_session: agent&.session_id,
+                  error: e2
+                )
+              end
+            end
+          end
+        end
+
+        true
+      end
+
+      def cancel(handle_id, reason: nil)
+        task = nil
+        handler = nil
+
+        @mutex.synchronize do
+          task = @tasks[handle_id]
+          return false unless task
+          return false if task[:status] == "completed" || task[:status] == "cancelled"
+
+          task[:status] = "cancelled"
+          task[:completed_at] = Time.now
+          task[:cancel_reason] = reason || "Task was cancelled by user."
+          handler = @callbacks.delete(handle_id)
+        end
+
+        begin
+          task[:on_cancel]&.call(task)
+        rescue => e
+          Octo::Logger.error("background_task_cancel_hook_error",
+            handle_id: handle_id,
+            error: e
+          )
+        end
+
+        if handler
+          enriched = enrich_with_timing({
+            cancelled: true,
+            output: task[:cancel_reason],
+            exit_code: nil,
+            state: "cancelled"
+          }, task)
+          Thread.new do
+            Thread.current.name = "bg-task-cancel-#{handle_id[0, 8]}"
+            begin
+              handler[:callback].call(enriched)
+            rescue => e
+              Octo::Logger.warn("background_task_callback_retry",
+                handle_id: handle_id,
+                agent_session: handler[:agent]&.session_id,
+                error: e
+              )
+              begin
+                sleep 0.5
+                handler[:callback].call(enriched)
+              rescue => e2
+                Octo::Logger.error("background_task_callback_error",
+                  handle_id: handle_id,
+                  agent_session: handler[:agent]&.session_id,
+                  error: e2
+                )
+              end
+            end
+          end
+        end
+
+        true
+      end
+
+      def complete(handle_id, result)
+        task = nil
+        handler = nil
+
+        @mutex.synchronize do
+          task = @tasks[handle_id]
+          return unless task
+          return if task[:status] == "cancelled"
+
+          task[:status] = "completed"
+          task[:result] = result
+          task[:completed_at] = Time.now
+
+          handler = @callbacks.delete(handle_id)
+        end
+
+        return unless handler
+
+        enriched = enrich_with_timing(result, task)
+
+        Thread.new do
+          Thread.current.name = "bg-task-notify-#{handle_id[0, 8]}"
+          begin
+            handler[:callback].call(enriched)
+          rescue => e
+            Octo::Logger.warn("background_task_callback_retry",
+              handle_id: handle_id,
+              agent_session: handler[:agent]&.session_id,
+              error: e
+            )
+            begin
+              sleep 0.5
+              handler[:callback].call(enriched)
+            rescue => e2
+              Octo::Logger.error("background_task_callback_error",
+                handle_id: handle_id,
+                agent_session: handler[:agent]&.session_id,
+                error: e2
+              )
+            end
+          end
+        end
+      end
+
+      def list_running(agent_session_id: nil)
+        @mutex.synchronize do
+          tasks = @tasks.values.select { |t| t[:status] == "running" }
+          tasks = tasks.select { |t| t[:metadata][:agent_session_id] == agent_session_id } if agent_session_id
+          tasks.map do |t|
+            {
+              handle_id: t[:id],
+              type: t[:type],
+              command: t[:metadata][:command],
+              started_at: t[:created_at]
+            }
+          end
+        end
+      end
+
+      def get(handle_id)
+        @mutex.synchronize { @tasks[handle_id]&.dup }
+      end
+
+      def record_activity(handle_id)
+        @mutex.synchronize do
+          task = @tasks[handle_id]
+          task[:last_activity_at] = Time.now if task
+        end
+      end
+
+      def forget(handle_id)
+        @mutex.synchronize do
+          @tasks.delete(handle_id)
+          @callbacks.delete(handle_id)
+        end
+      end
+
+      def prune_completed(max_age: 3600, agent_session_id: nil)
+        cutoff = Time.now - max_age
+        @mutex.synchronize do
+          @tasks.delete_if do |_id, task|
+            next false unless task[:status] == "completed"
+            next false unless task[:completed_at] && task[:completed_at] < cutoff
+            next false if agent_session_id && task[:metadata][:agent_session_id] != agent_session_id
+            true
+          end
+        end
+      end
+
+      def reset!
+        @mutex.synchronize do
+          @tasks.clear
+          @callbacks.clear
+          @sweep_running = false
+        end
+      end
+
+      private def ensure_sweep_thread
+        return if @sweep_running
+        @sweep_running = true
+        Thread.new do
+          Thread.current.name = "bg-task-sweep"
+          sweep_loop
+        end
+      end
+
+      private def sweep_loop
+        while @sweep_running
+          sleep SWEEP_INTERVAL
+          break unless @sweep_running
+
+          to_cancel = []
+          @mutex.synchronize do
+            now = Time.now
+            @tasks.each do |handle_id, task|
+              next unless task[:status] == "running"
+              next if task[:metadata]&.[](:watched)
+
+              last_activity = task[:last_activity_at] || task[:created_at]
+              next unless last_activity
+              ttl = task[:metadata]&.[](:max_duration) || TTL_UNWATCHED
+              next if now - last_activity < ttl
+
+              to_cancel << { handle_id: handle_id, ttl: ttl }
+            end
+          end
+
+          to_cancel.each do |item|
+            begin
+              cancel(item[:handle_id], reason: "Task timed out after #{item[:ttl]}s")
+              Octo::Logger.info("bg_task_ttl_cleanup",
+                handle_id: item[:handle_id],
+                reason: "unwatched handle exceeded #{item[:ttl]}s TTL"
+              )
+            rescue => e
+              Octo::Logger.error("bg_task_sweep_error",
+                handle_id: item[:handle_id],
+                error: e
+              )
+            end
+          end
+        end
+      end
+
+      private def generate_unique_handle_id
+        loop do
+          id = HANDLE_LENGTH.times.map { HANDLE_ALPHABET[SecureRandom.random_number(HANDLE_ALPHABET.size)] }.join
+          return id unless @tasks.key?(id)
+        end
+      end
+
+      private def enrich_with_timing(result, task)
+        return result unless task && task[:created_at] && task[:completed_at]
+        result.merge(
+          started_at:      task[:created_at],
+          elapsed_seconds: (task[:completed_at] - task[:created_at]).round
+        )
+      end
+    end
+  end
+end

data/lib/octo/banner.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "pastel"
+require_relative "version"
+require_relative "block_font"
+
+module Octo
+  # Banner provides logo for CLI startup.
+  class Banner
+    DEFAULT_CLI_LOGO = Octo::BlockFont.render("octo")
+
+    TAGLINE = "[>] Your personal Assistant & Technical Co-founder"
+
+    def initialize
+      @pastel = Pastel.new
+    end
+
+    def logo
+      @pastel.cyan(DEFAULT_CLI_LOGO)
+    end
+
+    def tagline
+      @pastel.dim(TAGLINE)
+    end
+
+    def highlight(text)
+      @pastel.bright_white(text)
+    end
+
+    def full_banner
+      "#{logo}\n#{tagline}"
+    end
+  end
+end