acp_sdk_async 0.2.0

data/lib/acp/schema_base.rb

@@ -0,0 +1,440 @@
+# frozen_string_literal: true
+
+require "json"
+
+module ACP
+  module Schema
+    class ValidationError < StandardError
+      attr_reader :path
+
+      def initialize(message, path = [])
+        @path = path
+        super(path.empty? ? message : "#{path.join('.')}: #{message}")
+      end
+    end
+
+    def self.to_camel(snake)
+      parts = snake.to_s.split("_")
+      parts[0] + parts[1..].map(&:capitalize).join
+    end
+
+    def self.to_snake(camel)
+      camel.to_s.gsub(/([A-Z])/) { "_#{$1.downcase}" }.sub(/\A_/, "")
+    end
+
+    def self.serialize(value)
+      case value
+      when Base then value.to_h
+      when Array then value.map { |v| serialize(v) }
+      when Hash then value.each_with_object({}) { |(k, v), h| h[k.to_s] = serialize(v) }
+      else value
+      end
+    end
+
+    module Types
+      def self.resolve(spec)
+        case spec
+        when Symbol then Scalar.for(spec)
+        when String then Ref.new(spec)
+        when Array then List.new(resolve(spec.first))
+        else
+          raise ArgumentError, "Unsupported type spec: #{spec.inspect}" unless spec.respond_to?(:coerce)
+
+          spec
+        end
+      end
+
+      class Scalar
+        KINDS = %i[string integer number boolean object any].freeze
+
+        def self.for(kind)
+          @instances ||= KINDS.to_h { |k| [k, new(k)] }
+          @instances.fetch(kind) { raise ArgumentError, "Unknown scalar type: #{kind.inspect}" }
+        end
+
+        attr_reader :kind
+
+        def initialize(kind)
+          @kind = kind
+        end
+
+        def coerce(value, path = [])
+          case @kind
+          when :any then value
+          when :string
+            return value if value.is_a?(String)
+
+            fail!(value, path)
+          when :integer
+            return value if value.is_a?(Integer)
+            return value.to_i if value.is_a?(Float) && value.finite? && value == value.floor
+
+            fail!(value, path)
+          when :number
+            return value if value.is_a?(Numeric)
+
+            fail!(value, path)
+          when :boolean
+            return value if value == true || value == false
+
+            fail!(value, path)
+          when :object
+            return value if value.is_a?(Hash)
+
+            fail!(value, path)
+          end
+        end
+
+        private
+
+        def fail!(value, path)
+          raise ValidationError.new("expected #{@kind}, got #{value.class}", path)
+        end
+      end
+
+      STRING = Scalar.for(:string)
+      INTEGER = Scalar.for(:integer)
+      NUMBER = Scalar.for(:number)
+      BOOLEAN = Scalar.for(:boolean)
+      OBJECT = Scalar.for(:object)
+      ANY = Scalar.for(:any)
+
+      class ProtocolVersion
+        def coerce(value, _path = [])
+          return value if value.is_a?(Integer)
+
+          Integer(value)
+        rescue ArgumentError, TypeError
+          1
+        end
+      end
+
+      PROTOCOL_VERSION = ProtocolVersion.new
+
+      class Ref
+        attr_reader :name
+
+        def initialize(name)
+          @name = name
+          @target = nil
+        end
+
+        def target
+          @target ||= Schema.const_get(@name)
+        end
+
+        def coerce(value, path = [])
+          target.coerce(value, path)
+        end
+      end
+
+      class List
+        attr_reader :item
+
+        def initialize(item, skip_invalid: false)
+          @item = Types.resolve(item)
+          @skip_invalid = skip_invalid
+        end
+
+        def coerce(value, path = [])
+          raise ValidationError.new("expected array, got #{value.class}", path) unless value.is_a?(Array)
+
+          result = []
+          value.each_with_index do |element, index|
+            begin
+              result << @item.coerce(element, path + [index])
+            rescue ValidationError
+              raise unless @skip_invalid
+            end
+          end
+          result
+        end
+      end
+
+      class Map
+        def initialize(value_type)
+          @value_type = Types.resolve(value_type)
+        end
+
+        def coerce(value, path = [])
+          raise ValidationError.new("expected object, got #{value.class}", path) unless value.is_a?(Hash)
+
+          value.each_with_object({}) do |(key, element), result|
+            result[key.to_s] = @value_type.coerce(element, path + [key.to_s])
+          end
+        end
+      end
+
+      class Enum
+        attr_reader :values
+
+        def initialize(values, open: false)
+          @values = values.freeze
+          @open = open
+        end
+
+        def coerce(value, path = [])
+          raise ValidationError.new("expected string, got #{value.class}", path) unless value.is_a?(String)
+          return value if @open || @values.include?(value)
+
+          raise ValidationError.new("unexpected value #{value.inspect}, allowed: #{@values.join(', ')}", path)
+        end
+      end
+
+      class Union
+        attr_reader :tag, :tagged, :untagged
+
+        def initialize(tag: nil, tagged: {}, untagged: [])
+          @tag = tag
+          @tagged = tagged.transform_values { |list| Array(list).map { |t| Types.resolve(t) } }
+          @untagged = Array(untagged).map { |t| Types.resolve(t) }
+        end
+
+        def variants
+          (@tagged.values.flatten + @untagged).map { |t| t.is_a?(Ref) ? t.target : t }
+        end
+
+        def coerce(value, path = [])
+          if value.is_a?(Base)
+            return value if variant_classes.any? { |variant| value.is_a?(variant) }
+
+            return coerce(value.to_h, path)
+          end
+
+          if @tag && value.is_a?(Hash)
+            tag_value = read_tag(value)
+            candidates = @tagged[tag_value] if tag_value
+            if candidates && !candidates.empty?
+              return try_variants(candidates, value, path) { |error| raise error }
+            end
+          end
+
+          try_variants(@untagged, value, path) do
+            raise ValidationError.new(union_error_message(value), path)
+          end
+        end
+
+        private
+
+        def variant_classes
+          @variant_classes ||= variants.select { |variant| variant.is_a?(Class) }
+        end
+
+        def read_tag(hash)
+          snake = Schema.to_snake(@tag)
+          [@tag, @tag.to_sym, snake, snake.to_sym].each do |key|
+            return hash[key] if hash.key?(key)
+          end
+          nil
+        end
+
+        def try_variants(candidates, value, path)
+          last_error = nil
+          candidates.each do |candidate|
+            return candidate.coerce(value, path)
+          rescue ValidationError => e
+            last_error = e
+          end
+          yield(last_error || ValidationError.new(union_error_message(value), path))
+        end
+
+        def union_error_message(value)
+          if @tag && value.is_a?(Hash)
+            "no variant matches #{@tag}=#{read_tag(value).inspect}"
+          else
+            "no variant matches value of type #{value.class}"
+          end
+        end
+      end
+    end
+
+    class Base
+      FieldDef = Struct.new(
+        :name, :key, :type, :required, :default, :const, :default_on_error,
+        keyword_init: true
+      )
+
+      class << self
+        def fields
+          @fields ||= superclass.respond_to?(:fields) ? superclass.fields.dup : []
+        end
+
+        def field_names
+          fields.map(&:name)
+        end
+
+        def field(name, type = :any, key: nil, required: false, default: nil, const: nil, default_on_error: false)
+          name = name.to_sym
+          fields.reject! { |f| f.name == name }
+          fields << FieldDef.new(
+            name: name,
+            key: key || Schema.to_camel(name),
+            type: Types.resolve(type),
+            required: required,
+            default: default,
+            const: const,
+            default_on_error: default_on_error
+          )
+          attr_reader name
+          define_method(:"#{name}=") do |value|
+            instance_variable_set(:"@#{name}", value)
+            @set_fields << name
+          end
+        end
+
+        def coerce(value, path = [])
+          return value if value.is_a?(self)
+          raise ValidationError.new("expected object, got #{value.class}", path) unless value.is_a?(Hash)
+
+          instance = allocate
+          instance.send(:load_from_hash, value, path)
+          instance
+        end
+
+        def from_hash(hash)
+          return nil if hash.nil?
+
+          coerce(hash)
+        end
+
+        alias parse coerce
+      end
+
+      attr_reader :field_meta
+
+      def initialize(**kwargs)
+        @set_fields = []
+        @field_meta = kwargs.delete(:field_meta) || kwargs.delete(:_meta)
+        unknown = kwargs.keys - self.class.field_names
+        raise ArgumentError, "Unknown fields for #{self.class.name}: #{unknown.join(', ')}" unless unknown.empty?
+
+        self.class.fields.each do |f|
+          if kwargs.key?(f.name)
+            value = kwargs[f.name]
+            value = f.type.coerce(value, [f.key]) unless value.nil?
+            assign(f, value, set: !value.nil?)
+          elsif f.const
+            assign(f, f.const, set: true)
+          else
+            assign(f, default_for(f), set: false)
+          end
+        end
+      end
+
+      def field_meta=(value)
+        @field_meta = value
+      end
+
+      def set?(name)
+        @set_fields.include?(name.to_sym)
+      end
+
+      def [](name)
+        public_send(name)
+      end
+
+      def to_h
+        result = {}
+        ordered_fields.each do |f|
+          next unless f.const || @set_fields.include?(f.name)
+
+          value = instance_variable_get(:"@#{f.name}")
+          next if value.nil?
+
+          result[f.key] = Schema.serialize(value)
+        end
+        result["_meta"] = Schema.serialize(@field_meta) if @field_meta
+        result
+      end
+
+      def to_json(*args)
+        to_h.to_json(*args)
+      end
+
+      def ==(other)
+        other.class == self.class && other.to_h == to_h
+      end
+
+      alias eql? ==
+
+      def hash
+        [self.class, to_h].hash
+      end
+
+      def inspect
+        "#<#{self.class.name} #{to_h.inspect}>"
+      end
+
+      private
+
+      def ordered_fields
+        fields = self.class.fields
+        fields.select(&:const) + fields.reject(&:const)
+      end
+
+      def assign(field, value, set:)
+        instance_variable_set(:"@#{field.name}", value)
+        @set_fields << field.name if set
+      end
+
+      def default_for(field)
+        default = field.default
+        return nil if default.nil?
+
+        default = deep_dup(default)
+        begin
+          field.type.coerce(default, [field.key])
+        rescue ValidationError
+          default
+        end
+      end
+
+      def deep_dup(value)
+        case value
+        when Hash then value.transform_values { |v| deep_dup(v) }
+        when Array then value.map { |v| deep_dup(v) }
+        when String then value.dup
+        else value
+        end
+      end
+
+      def load_from_hash(hash, path)
+        @set_fields = []
+        self.class.fields.each do |f|
+          present, raw = lookup(hash, f)
+          if present && !raw.nil?
+            load_present(f, raw, path)
+          elsif f.const
+            assign(f, f.const, set: true)
+          elsif f.required && !(present && f.default_on_error)
+            raise ValidationError.new("missing required field #{f.key}", path)
+          else
+            assign(f, default_for(f), set: false)
+          end
+        end
+        meta = hash.key?("_meta") ? hash["_meta"] : hash[:_meta]
+        @field_meta = meta.is_a?(Hash) ? meta : nil
+      end
+
+      def load_present(field, raw, path)
+        value = field.type.coerce(raw, path + [field.key])
+        if field.const && value != field.const
+          raise ValidationError.new("expected #{field.const.inspect}, got #{value.inspect}", path + [field.key])
+        end
+
+        assign(field, value, set: true)
+      rescue ValidationError
+        raise unless field.default_on_error
+
+        assign(field, default_for(field), set: false)
+      end
+
+      def lookup(hash, field)
+        [field.key, field.key.to_sym, field.name.to_s, field.name].each do |candidate|
+          return [true, hash[candidate]] if hash.key?(candidate)
+        end
+        [false, nil]
+      end
+    end
+  end
+end

data/lib/acp/stdio.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+require_relative "transport"
+require_relative "client"
+require_relative "wait"
+
+module ACP
+  module Stdio
+    DEFAULT_INHERITED_ENV = %w[HOME LOGNAME PATH SHELL TERM USER].freeze
+
+    def self.default_environment
+      env = {}
+      DEFAULT_INHERITED_ENV.each do |key|
+        value = ENV.fetch(key, nil)
+        next if value.nil? || value.start_with?("()")
+
+        env[key] = value
+      end
+      env
+    end
+
+    def self.stdio_streams(input = $stdin, output = $stdout)
+      input.binmode if input.respond_to?(:binmode)
+      output.binmode if output.respond_to?(:binmode)
+      input.set_encoding("UTF-8") if input.respond_to?(:set_encoding)
+      output.set_encoding("UTF-8") if output.respond_to?(:set_encoding)
+      output.sync = true if output.respond_to?(:sync=)
+      [input, output]
+    end
+
+    def self.spawn_agent(command, *args, env: nil, cwd: nil, stderr: :log, receive_timeout: nil)
+      merged = default_environment
+      merged.merge!(env.transform_keys(&:to_s)) if env
+
+      reader, writer = IO.pipe
+      child_reader, child_writer = IO.pipe
+      stderr_reader, stderr_writer = stderr == :log ? IO.pipe : [nil, nil]
+
+      options = { in: child_reader, out: writer }
+      options[:chdir] = cwd.to_s if cwd
+      options[:err] = case stderr
+                      when :log then stderr_writer
+                      when :inherit then $stderr
+                      when :discard then File::NULL
+                      when IO then stderr
+                      else raise ArgumentError, "Unsupported stderr option: #{stderr.inspect}"
+                      end
+
+      pid = Process.spawn(merged, command, *args, **options)
+      child_reader.close
+      writer.close
+      stderr_writer&.close
+
+      reader.set_encoding("UTF-8")
+      child_writer.set_encoding("UTF-8")
+      child_writer.sync = true
+
+      drain = stderr_reader ? start_stderr_drain(stderr_reader, "#{File.basename(command)}[#{pid}]") : nil
+
+      transport = NdjsonTransport.new(reader, child_writer, receive_timeout: receive_timeout)
+      AgentProcess.new(pid: pid, transport: transport, stdin: child_writer, stdout: reader, stderr_drain: drain)
+    end
+
+    def self.start_stderr_drain(io, label)
+      io.set_encoding("UTF-8")
+      Wait.spawn("acp-stderr-#{label}") do
+        io.each_line do |line|
+          line = line.scrub unless line.valid_encoding?
+          ACP.logger.info("acp[#{label}] stderr: #{line.chomp}")
+        end
+      rescue IOError, Errno::EBADF, ::Async::Cancel
+        nil
+      ensure
+        io.close unless io.closed?
+      end
+    end
+
+    class AgentProcess
+      attr_reader :pid, :transport
+
+      def initialize(pid:, transport:, stdin:, stdout:, stderr_drain: nil)
+        @pid = pid
+        @transport = transport
+        @stdin = stdin
+        @stdout = stdout
+        @stderr_drain = stderr_drain
+        @status = nil
+      end
+
+      def connect(client_handler, start_listening: true, **options)
+        connection = Client::Connection.new(client_handler, @transport, **options)
+        connection.start if start_listening
+        connection
+      end
+
+      def alive?
+        return false if @status
+
+        Process.kill(0, @pid)
+        true
+      rescue Errno::ESRCH, Errno::EPERM
+        false
+      end
+
+      def wait
+        return @status if @status
+
+        _, status = Process.wait2(@pid)
+        @status = status
+      rescue Errno::ECHILD
+        @status
+      end
+
+      def kill(signal = "TERM")
+        Process.kill(signal, @pid)
+      rescue Errno::ESRCH
+        nil
+      end
+
+      def close(timeout: 2.0)
+        @stdin.close unless @stdin.closed?
+        @transport.close
+        return finish if wait_with_timeout(timeout)
+
+        kill
+        return finish if wait_with_timeout(timeout)
+
+        kill("KILL")
+        wait
+        finish
+      rescue StandardError
+        nil
+      end
+
+      private
+
+      def finish
+        Wait.join(@stderr_drain, 1.0)
+        @status
+      end
+
+      def wait_with_timeout(timeout)
+        return true if @status
+
+        deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + timeout
+        loop do
+          _, status = Process.wait2(@pid, Process::WNOHANG)
+          if status
+            @status = status
+            return true
+          end
+
+          return false if Process.clock_gettime(Process::CLOCK_MONOTONIC) >= deadline
+
+          sleep 0.02
+        end
+      rescue Errno::ECHILD
+        true
+      end
+    end
+  end
+end