roast-ai 0.4.9 → 0.5.0

data/lib/roast/dsl/cogs/agent/providers/claude/claude_invocation.rb

@@ -0,0 +1,185 @@
+# typed: true
+# frozen_string_literal: true
+
+module Roast
+  module DSL
+    module Cogs
+      class Agent < Cog
+        module Providers
+          class Claude < Provider
+            class ClaudeInvocation
+              class ClaudeInvocationError < Roast::Error; end
+
+              class ClaudeNotStartedError < ClaudeInvocationError; end
+
+              class ClaudeAlreadyStartedError < ClaudeInvocationError; end
+
+              class ClaudeNotCompletedError < ClaudeInvocationError; end
+
+              class ClaudeFailedError < ClaudeInvocationError; end
+
+              class Context
+                def initialize
+                  @tool_uses = {} #: Hash[String, Messages::ToolUseMessage]
+                end
+
+                #: (String?) -> Messages::ToolUseMessage?
+                def tool_use(tool_use_id)
+                  @tool_uses[tool_use_id] if tool_use_id
+                end
+
+                #: (Messages::ToolUseMessage) -> void
+                def add_tool_use(tool_use_message)
+                  id = tool_use_message.id
+                  @tool_uses[id] = tool_use_message if id
+                end
+              end
+
+              class Result
+                #: String
+                attr_accessor :response
+
+                #: bool
+                attr_accessor :success
+
+                #: String?
+                attr_accessor :session
+
+                #: Stats?
+                attr_accessor :stats
+
+                def initialize
+                  @response = ""
+                  @success = false
+                end
+              end
+
+              #: (Agent::Config, Agent::Input) -> void
+              def initialize(config, input)
+                @base_command = config.valid_command #: (String | Array[String])?
+                @model = config.valid_model #: String?
+                @append_system_prompt = config.valid_initial_prompt #: String?
+                @apply_permissions = config.apply_permissions? #: bool
+                @working_directory = config.valid_working_directory #: Pathname?
+                @prompt = input.valid_prompt! #: String
+                @session = input.session #: String?
+                @context = Context.new #: Context
+                @result = Result.new #: Result
+                @raw_dump_file = config.valid_dump_raw_agent_messages_to_path #: Pathname?
+                @show_progress = config.show_progress? #: bool
+              end
+
+              #: () -> void
+              def run!
+                raise ClaudeAlreadyStartedError if started?
+
+                @started = true
+                _stdout, stderr, status = CommandRunner.execute(
+                  command_line,
+                  working_directory: @working_directory,
+                  stdin_content: @prompt,
+                  stdout_handler: lambda { |line| handle_stdout(line) },
+                )
+
+                if status.success?
+                  @completed = true
+                else
+                  @failed = true
+                  @result.success = false
+                  @result.response += "\n" unless @result.response.blank? || @result.response.ends_with?("\n")
+                  @result.response += stderr
+                end
+              end
+
+              #: () -> bool
+              def started?
+                @started ||= false
+              end
+
+              #: () -> bool
+              def running?
+                started? && !completed? && !failed?
+              end
+
+              #: () -> bool
+              def completed?
+                @completed ||= false
+              end
+
+              #: () -> bool
+              def failed?
+                @failed ||= false
+              end
+
+              #: () -> Result
+              def result
+                raise ClaudeNotStartedError unless started?
+                raise ClaudeFailedError, @result.response if failed?
+                raise ClaudeNotCompletedError, @result.response unless completed?
+
+                @result
+              end
+
+              private
+
+              #: (String) -> void
+              def handle_stdout(line)
+                line = line.strip
+                message = Message.from_json(line, raw_dump_file: @raw_dump_file) unless line.empty?
+                return unless message
+
+                handle_message(message)
+              end
+
+              #: (Message) -> void
+              def handle_message(message)
+                case message
+                when Messages::AssistantMessage
+                  message.messages.each { |msg| handle_message(msg) }
+                when Messages::ResultMessage
+                  @result.response = message.content
+                  @result.success = message.success
+                  @result.stats = message.stats
+                when Messages::ToolUseMessage
+                  @context.add_tool_use(message)
+                when Messages::UserMessage
+                  message.messages.each { |msg| handle_message(msg) }
+                end
+
+                @result.session = message.session_id if message.session_id.present?
+
+                formatted_message = message.format(@context)
+                puts formatted_message if formatted_message.present? && @show_progress
+
+                unless message.unparsed.blank?
+                  # TODO: do something better with unhandled data so we can improve the parser
+                  puts "[WARNING] Unhandled data in Claude #{message.type} message:"
+                  puts JSON.pretty_generate(message.unparsed)
+                  puts "[FULL MESSAGE: #{message.type}]"
+                  pp(message)
+                end
+              end
+
+              #: () -> Array[String]
+              def command_line
+                command = if @base_command.is_a?(Array)
+                  @base_command.dup
+                elsif @base_command.is_a?(String)
+                  @base_command.split
+                else
+                  ["claude"]
+                end
+                command.push("-p", "--verbose", "--output-format", "stream-json")
+                command.push("--model", @model) if @model
+                command.push("--append-system-prompt", @append_system_prompt) if @append_system_prompt
+                command.push("--fork-session", "--resume", @session) if @session.present?
+                command << "--dangerously-skip-permissions" unless @apply_permissions
+                command
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/roast/dsl/cogs/agent/providers/claude/message.rb

@@ -0,0 +1,73 @@
+# typed: true
+# frozen_string_literal: true
+
+module Roast
+  module DSL
+    module Cogs
+      class Agent < Cog
+        module Providers
+          class Claude < Provider
+            class Message
+              IGNORED_FIELDS = [
+                :uuid,
+              ].freeze
+
+              class << self
+                #: (String, ?raw_dump_file: Pathname?) -> Message
+                def from_json(json, raw_dump_file: nil)
+                  raw_dump_file&.dirname&.mkpath
+                  File.write("./tmp/claude-messages.log", "#{json}\n", mode: "a") if raw_dump_file
+                  from_hash(JSON.parse(json, symbolize_names: true))
+                end
+
+                #: (Hash[Symbol, untyped]) -> Message
+                def from_hash(hash)
+                  type = hash.delete(:type)&.to_sym
+                  case type
+                  when :assistant
+                    Messages::AssistantMessage.new(type:, hash:)
+                  when :result
+                    Messages::ResultMessage.new(type:, hash:)
+                  when :system
+                    Messages::SystemMessage.new(type:, hash:)
+                  when :text
+                    Messages::TextMessage.new(type:, hash:)
+                  when :tool_result
+                    Messages::ToolResultMessage.new(type:, hash:)
+                  when :tool_use
+                    Messages::ToolUseMessage.new(type:, hash:)
+                  when :user
+                    Messages::UserMessage.new(type:, hash:)
+                  else
+                    Messages::UnknownMessage.new(type:, hash:)
+                  end
+                end
+              end
+
+              #: String?
+              attr_reader :session_id
+
+              #: Symbol
+              attr_reader :type
+
+              #: Hash[Symbol, untyped]
+              attr_reader :unparsed
+
+              #: (type: Symbol, hash: Hash[Symbol, untyped]) -> void
+              def initialize(type:, hash:)
+                @session_id = hash.delete(:session_id)
+                @type = type
+                hash.except!(*IGNORED_FIELDS)
+                @unparsed = hash
+              end
+
+              #: (ClaudeInvocation::Context) -> String?
+              def format(context)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/roast/dsl/cogs/agent/providers/claude/messages/assistant_message.rb

@@ -0,0 +1,36 @@
+# typed: true
+# frozen_string_literal: true
+
+module Roast
+  module DSL
+    module Cogs
+      class Agent < Cog
+        module Providers
+          class Claude < Provider
+            module Messages
+              class AssistantMessage < Message
+                IGNORED_FIELDS = [
+                  :parent_tool_use_id,
+                ].freeze
+
+                #: Array[Message]
+                attr_reader :messages
+
+                #: (type: Symbol, hash: Hash[Symbol, untyped]) -> void
+                def initialize(type:, hash:)
+                  @messages = hash.dig(:message, :content)&.map do |content|
+                    content[:role] = :assistant
+                    Message.from_hash(content)
+                  end&.compact || []
+                  hash.delete(:message)
+                  hash.except!(*IGNORED_FIELDS)
+                  super(type:, hash:)
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/roast/dsl/cogs/agent/providers/claude/messages/result_message.rb

@@ -0,0 +1,61 @@
+# typed: true
+# frozen_string_literal: true
+
+module Roast
+  module DSL
+    module Cogs
+      class Agent < Cog
+        module Providers
+          class Claude < Provider
+            module Messages
+              class ResultMessage < Message
+                IGNORED_FIELDS = [
+                  :duration_api_ms,
+                  :permission_denials,
+                  :usage,
+                  :uuid,
+                ].freeze
+
+                #: String
+                attr_reader :content
+
+                #: bool
+                attr_reader :success
+
+                #: Stats
+                attr_reader :stats
+
+                #: (type: Symbol, hash: Hash[Symbol, untyped]) -> void
+                def initialize(type:, hash:)
+                  subtype = hash.delete(:subtype)
+                  @content = hash.delete(:result) || ""
+                  @success = hash.delete(:success) || subtype == "success"
+                  if hash.delete(:is_error) || subtype == "error"
+                    @content = @content || hash.dig(:error, :message) || "Unknown error"
+                    hash.delete(:error)
+                  end
+
+                  @stats = Stats.new
+                  @stats.duration_ms = hash.delete(:duration_ms)
+                  @stats.num_turns = hash.delete(:num_turns)
+                  hash.delete(:modelUsage)&.each do |model, h|
+                    usage = Usage.new
+                    usage.input_tokens = h[:inputTokens]
+                    usage.output_tokens = h[:outputTokens]
+                    usage.cost_usd = h[:costUSD]
+                    @stats.model_usage[model] = usage
+                    @stats.usage.input_tokens = (@stats.usage.input_tokens || 0) + (usage.input_tokens || 0)
+                    @stats.usage.output_tokens = (@stats.usage.output_tokens || 0) + (usage.output_tokens || 0)
+                  end
+                  @stats.usage.cost_usd = hash.delete(:total_cost_usd)
+                  hash.except!(*IGNORED_FIELDS)
+                  super(type:, hash:)
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/roast/dsl/cogs/agent/providers/claude/messages/system_message.rb

@@ -0,0 +1,47 @@
+# typed: true
+# frozen_string_literal: true
+
+module Roast
+  module DSL
+    module Cogs
+      class Agent < Cog
+        module Providers
+          class Claude < Provider
+            module Messages
+              class SystemMessage < Message
+                IGNORED_FIELDS = [
+                  :subtype,
+                  :cwd,
+                  :tools,
+                  :mcp_servers,
+                  :permissionMode,
+                  :slash_commands,
+                  :apiKeySource,
+                  :claude_code_version,
+                  :output_style,
+                  :agents,
+                  :skills,
+                  :plugins,
+                ].freeze
+
+                #: String?
+                attr_reader :message
+
+                #: String?
+                attr_reader :model
+
+                #: (type: Symbol, hash: Hash[Symbol, untyped]) -> void
+                def initialize(type:, hash:)
+                  @message = hash.delete(:message)
+                  @model = hash.delete(:model)
+                  hash.except!(*IGNORED_FIELDS)
+                  super(type:, hash:)
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/roast/dsl/cogs/agent/providers/claude/messages/text_message.rb

@@ -0,0 +1,36 @@
+# typed: true
+# frozen_string_literal: true
+
+module Roast
+  module DSL
+    module Cogs
+      class Agent < Cog
+        module Providers
+          class Claude < Provider
+            module Messages
+              class TextMessage < Message
+                #: Symbol?
+                attr_reader :role
+
+                #: String
+                attr_reader :text
+
+                #: (type: Symbol, hash: Hash[Symbol, untyped]) -> void
+                def initialize(type:, hash:)
+                  @role = hash.delete(:role)
+                  @text = hash.delete(:text) || ""
+                  super(type:, hash:)
+                end
+
+                #: (ClaudeInvocation::Context) -> String
+                def format(context)
+                  @text
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/roast/dsl/cogs/agent/providers/claude/messages/tool_result_message.rb

@@ -0,0 +1,47 @@
+# typed: true
+# frozen_string_literal: true
+
+module Roast
+  module DSL
+    module Cogs
+      class Agent < Cog
+        module Providers
+          class Claude < Provider
+            module Messages
+              class ToolResultMessage < Message
+                IGNORED_FIELDS = [
+                  :role,
+                ].freeze
+
+                #: String?
+                attr_reader :tool_use_id
+
+                #: String?
+                attr_reader :content
+
+                #: bool
+                attr_reader :is_error
+
+                #: (type: Symbol, hash: Hash[Symbol, untyped]) -> void
+                def initialize(type:, hash:)
+                  @tool_use_id = hash.delete(:tool_use_id)
+                  @content = hash.delete(:content)
+                  @is_error = hash.delete(:is_error) || false
+                  hash.except!(*IGNORED_FIELDS)
+                  super(type:, hash:)
+                end
+
+                #: (ClaudeInvocation::Context) -> String?
+                def format(context)
+                  tool_use = context.tool_use(tool_use_id)
+                  tool_result = ToolResult.new(tool_use:, content:, is_error:)
+                  tool_result.format
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/roast/dsl/cogs/agent/providers/claude/messages/tool_use_message.rb

@@ -0,0 +1,46 @@
+# typed: true
+# frozen_string_literal: true
+
+module Roast
+  module DSL
+    module Cogs
+      class Agent < Cog
+        module Providers
+          class Claude < Provider
+            module Messages
+              class ToolUseMessage < Message
+                IGNORED_FIELDS = [
+                  :role,
+                ].freeze
+
+                #: String?
+                attr_reader :id
+
+                #: Symbol
+                attr_reader :name
+
+                #: Hash[Symbol, untyped]
+                attr_reader :input
+
+                #: (type: Symbol, hash: Hash[Symbol, untyped]) -> void
+                def initialize(type:, hash:)
+                  @name = hash.delete(:name)&.downcase&.to_sym || :unknown
+                  @id = hash.delete(:id)
+                  @input = hash.delete(:input) || {}
+                  hash.except!(*IGNORED_FIELDS)
+                  super(type:, hash:)
+                end
+
+                #: (ClaudeInvocation::Context) -> String?
+                def format(context)
+                  tool_use = ToolUse.new(name:, input:)
+                  tool_use.format
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/roast/dsl/cogs/agent/providers/claude/messages/unknown_message.rb

@@ -0,0 +1,27 @@
+# typed: true
+# frozen_string_literal: true
+
+module Roast
+  module DSL
+    module Cogs
+      class Agent < Cog
+        module Providers
+          class Claude < Provider
+            module Messages
+              class UnknownMessage < Message
+                #: Hash[Symbol, untyped]
+                attr_reader :raw
+
+                #: (type: Symbol, hash: Hash[Symbol, untyped]) -> void
+                def initialize(type:, hash:)
+                  super(type:, hash:)
+                  @raw = hash
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/roast/dsl/cogs/agent/providers/claude/messages/user_message.rb

@@ -0,0 +1,37 @@
+# typed: true
+# frozen_string_literal: true
+
+module Roast
+  module DSL
+    module Cogs
+      class Agent < Cog
+        module Providers
+          class Claude < Provider
+            module Messages
+              class UserMessage < Message
+                IGNORED_FIELDS = [
+                  :parent_tool_use_id,
+                  :tool_use_result,
+                ].freeze
+
+                #: Array[Message]
+                attr_reader :messages
+
+                #: (type: Symbol, hash: Hash[Symbol, untyped]) -> void
+                def initialize(type:, hash:)
+                  @messages = hash.dig(:message, :content)&.map do |content|
+                    content[:role] = :user
+                    Message.from_hash(content)
+                  end&.compact || []
+                  hash.delete(:message)
+                  hash.except!(*IGNORED_FIELDS)
+                  super(type:, hash:)
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/roast/dsl/cogs/agent/providers/claude/tool_result.rb

@@ -0,0 +1,51 @@
+# typed: true
+# frozen_string_literal: true
+
+module Roast
+  module DSL
+    module Cogs
+      class Agent < Cog
+        module Providers
+          class Claude < Provider
+            class ToolResult
+              #: Symbol?
+              attr_reader :tool_name
+
+              #: String?
+              attr_reader :tool_use_description
+
+              #: String?
+              attr_reader :content
+
+              #: bool
+              attr_reader :is_error
+
+              #: (tool_use: Messages::ToolUseMessage?, content: String?, is_error: bool) -> void
+              def initialize(tool_use:, content:, is_error:)
+                @tool_name = tool_use&.name || :unknown
+                @tool_use_description = tool_use&.input&.fetch(:description, nil) #: String?
+                @content = content
+                @is_error = is_error
+              end
+
+              #: () -> String
+              def format
+                format_method_name = "format_#{tool_name}".to_sym
+                return send(format_method_name) if respond_to?(format_method_name, true)
+
+                format_unknown
+              end
+
+              private
+
+              #: () -> String
+              def format_unknown
+                "UNKNOWN [#{tool_name}] #{is_error ? " ERROR" : "OK"} #{tool_use_description || ""}\n#{content}"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/roast/dsl/cogs/agent/providers/claude/tool_use.rb

@@ -0,0 +1,48 @@
+# typed: true
+# frozen_string_literal: true
+
+module Roast
+  module DSL
+    module Cogs
+      class Agent < Cog
+        module Providers
+          class Claude < Provider
+            class ToolUse
+              #: Symbol
+              attr_reader :name
+
+              #: Hash[Symbol, untyped]
+              attr_reader :input
+
+              #: (name: Symbol, input: Hash[Symbol, untyped]) -> void
+              def initialize(name:, input:)
+                @name = name
+                @input = input
+              end
+
+              #: () -> String
+              def format
+                format_method_name = "format_#{name}".to_sym
+                return send(format_method_name) if respond_to?(format_method_name, true)
+
+                format_unknown
+              end
+
+              private
+
+              #: () -> String
+              def format_bash
+                "BASH #{input.inspect}"
+              end
+
+              #: () -> String
+              def format_unknown
+                "UNKNOWN [#{name}] #{input.inspect}"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end