acp_sdk_async 0.2.0

data/lib/acp/transport.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+require "json"
+require "async/queue"
+require_relative "exceptions"
+
+module ACP
+  def self.memory_transport_pair
+    MemoryTransport.pair
+  end
+
+  module Transport
+    def send_message(_message)
+      raise NotImplementedError
+    end
+
+    def receive_message
+      raise NotImplementedError
+    end
+
+    def close
+      raise NotImplementedError
+    end
+  end
+
+  class NdjsonTransport
+    include Transport
+
+    attr_reader :input, :output
+
+    def initialize(input, output, receive_timeout: nil)
+      @input = input
+      @output = output
+      @receive_timeout = receive_timeout
+      @write_mutex = Mutex.new
+      @closed = false
+      @output.sync = true if @output.respond_to?(:sync=)
+    end
+
+    def closed?
+      @closed
+    end
+
+    def send_message(message)
+      line = JSON.generate(message)
+      @write_mutex.synchronize do
+        raise ConnectionError, "Transport is closed" if @closed
+
+        @output.write("#{line}\n")
+        @output.flush if @output.respond_to?(:flush)
+      end
+    rescue IOError, Errno::EPIPE, Errno::EBADF => e
+      raise ConnectionError, "Failed to write message: #{e.message}"
+    end
+
+    def receive_message
+      loop do
+        line = read_line
+        return nil if line.nil?
+
+        line = line.scrub unless line.valid_encoding?
+        stripped = line.strip
+        next if stripped.empty?
+
+        begin
+          return JSON.parse(stripped)
+        rescue JSON::ParserError => e
+          ACP.logger.warn("acp: skipping malformed JSON line: #{e.message}")
+        end
+      end
+    rescue IOError, Errno::EBADF
+      nil
+    end
+
+    def close
+      @write_mutex.synchronize { @closed = true }
+      [@input, @output].each do |io|
+        io.close unless io.nil? || io.closed?
+      rescue IOError, Errno::EBADF
+        nil
+      end
+    end
+
+    private
+
+    def read_line
+      if @receive_timeout && @input.respond_to?(:wait_readable) && !@input.wait_readable(@receive_timeout)
+        raise TimeoutError, "No message received within #{@receive_timeout}s"
+      end
+
+      @input.gets
+    end
+  end
+
+  class MemoryTransport
+    include Transport
+
+    def self.pair
+      a_to_b = ::Async::Queue.new
+      b_to_a = ::Async::Queue.new
+      [new(b_to_a, a_to_b), new(a_to_b, b_to_a)]
+    end
+
+    def initialize(inbox, outbox)
+      @inbox = inbox
+      @outbox = outbox
+      @closed = false
+    end
+
+    def closed?
+      @closed
+    end
+
+    def send_message(message)
+      raise ConnectionError, "Transport is closed" if @closed
+
+      @outbox.push(JSON.parse(JSON.generate(message)))
+    end
+
+    def receive_message
+      return nil if @closed && @inbox.empty?
+
+      @inbox.pop
+    end
+
+    def close
+      return if @closed
+
+      @closed = true
+      @outbox.push(nil)
+      @inbox.push(nil)
+    end
+  end
+end

data/lib/acp/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module ACP
+  VERSION = "0.2.0"
+end

data/lib/acp/wait.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require "async"
+require "async/promise"
+require "logger"
+require_relative "exceptions"
+
+module ACP
+  def self.logger
+    @logger ||= Logger.new($stderr, progname: "acp").tap { |logger| logger.level = Logger::WARN }
+  end
+
+  def self.logger=(value)
+    @logger = value
+  end
+
+  module Wait
+    def self.async?
+      !::Async::Task.current?.nil?
+    rescue RuntimeError
+      false
+    end
+
+    def self.ensure_reactor!
+      return if async?
+
+      raise Error, "ACP must run inside an Async reactor; wrap your code in Sync { ... }"
+    end
+
+    def self.spawn(name = nil, &block)
+      ensure_reactor!
+      Async(annotation: name, &block)
+    end
+
+    def self.alive?(worker)
+      return false if worker.nil?
+
+      worker.alive? && !worker.finished?
+    end
+
+    def self.current_worker
+      ::Async::Task.current
+    end
+
+    def self.current?(worker)
+      return false if worker.nil?
+
+      worker == ::Async::Task.current?
+    end
+
+    def self.stop(worker)
+      return if worker.nil? || worker.finished?
+
+      worker.stop
+    rescue ::Async::Cancel, StandardError
+      nil
+    end
+
+    def self.join(worker, timeout = nil)
+      return true if worker.nil? || worker.finished?
+
+      if timeout.nil?
+        worker.wait
+      else
+        worker.wait(timeout: timeout)
+      end
+      true
+    rescue ::Async::Cancel
+      true
+    rescue ::Async::TimeoutError, TimeoutError
+      false
+    rescue StandardError
+      worker.finished? || !alive?(worker)
+    end
+
+    class Latch
+      def initialize
+        @promise = ::Async::Promise.new
+      end
+
+      def open?
+        @promise.completed?
+      end
+
+      def open
+        @promise.resolve(true)
+      end
+
+      def wait(timeout = nil)
+        if timeout.nil?
+          @promise.wait
+        else
+          @promise.wait(timeout: timeout)
+        end
+        true
+      rescue ::Async::TimeoutError
+        false
+      end
+    end
+
+    class Promise
+      def initialize
+        @promise = ::Async::Promise.new
+      end
+
+      def settled?
+        @promise.resolved?
+      end
+
+      def resolve(value)
+        @promise.resolve(value)
+      end
+
+      def reject(error)
+        @promise.reject(error)
+      end
+
+      def wait(timeout = nil)
+        if timeout.nil?
+          @promise.wait
+        else
+          @promise.wait(timeout: timeout)
+        end
+      rescue ::Async::TimeoutError
+        raise TimeoutError, "Timed out after #{timeout}s"
+      end
+    end
+  end
+end

data/lib/acp_sdk.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "acp_sdk_async"

data/lib/acp_sdk_async.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative "acp/version"
+require_relative "acp/exceptions"
+require_relative "acp/wait"
+require_relative "acp/meta"
+require_relative "acp/schema_base"
+require_relative "acp/schema"
+require_relative "acp/transport"
+require_relative "acp/connection"
+require_relative "acp/router"
+require_relative "acp/client"
+require_relative "acp/agent"
+require_relative "acp/stdio"

data/schema/VERSION

@@ -0,0 +1 @@
+refs/tags/schema-v1.21.0

data/schema/meta.json

@@ -0,0 +1,52 @@
+{
+  "version": 1,
+  "agentMethods": {
+    "initialize": "initialize",
+    "authenticate": "authenticate",
+    "providers_list": "providers/list",
+    "providers_set": "providers/set",
+    "providers_disable": "providers/disable",
+    "session_new": "session/new",
+    "session_load": "session/load",
+    "session_set_mode": "session/set_mode",
+    "session_set_config_option": "session/set_config_option",
+    "session_prompt": "session/prompt",
+    "session_cancel": "session/cancel",
+    "mcp_message": "mcp/message",
+    "session_list": "session/list",
+    "session_delete": "session/delete",
+    "session_fork": "session/fork",
+    "session_resume": "session/resume",
+    "session_close": "session/close",
+    "logout": "logout",
+    "nes_start": "nes/start",
+    "nes_suggest": "nes/suggest",
+    "nes_accept": "nes/accept",
+    "nes_reject": "nes/reject",
+    "nes_close": "nes/close",
+    "document_did_open": "document/didOpen",
+    "document_did_change": "document/didChange",
+    "document_did_close": "document/didClose",
+    "document_did_save": "document/didSave",
+    "document_did_focus": "document/didFocus"
+  },
+  "clientMethods": {
+    "session_request_permission": "session/request_permission",
+    "session_update": "session/update",
+    "fs_write_text_file": "fs/write_text_file",
+    "fs_read_text_file": "fs/read_text_file",
+    "terminal_create": "terminal/create",
+    "terminal_output": "terminal/output",
+    "terminal_release": "terminal/release",
+    "terminal_wait_for_exit": "terminal/wait_for_exit",
+    "terminal_kill": "terminal/kill",
+    "mcp_connect": "mcp/connect",
+    "mcp_message": "mcp/message",
+    "mcp_disconnect": "mcp/disconnect",
+    "elicitation_create": "elicitation/create",
+    "elicitation_complete": "elicitation/complete"
+  },
+  "protocolMethods": {
+    "cancel_request": "$/cancel_request"
+  }
+}