ask-acp 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 847f6fef76788fc8ddb79a41f6d071ed5f9c62ea05e191b713a628afe0325614
+  data.tar.gz: 81692ef719aff5a322b5fa9ae34dffad897d93f1b7c43acc661e369bdb573858
+SHA512:
+  metadata.gz: 36000307696429f9d664b2d0e3d6e750ac146089b7f7dcf8d94fafd7392dc332e58973f824fc19d182d13ed7391abb1f89a6153c7e5a27d800c100f71fac26e8
+  data.tar.gz: e6ec8427722c7444cb2e9b1d2a06538d924f49530bf48795b719233d9372cf0a5e298c40ac4a807afd0e22883e4059b5a3368bf9964af8e6f618965b561a0c72

data/lib/ask/acp/client.rb

@@ -0,0 +1,288 @@
+# frozen_string_literal: true
+
+require "json"
+require "open3"
+
+module Ask
+  module ACP
+    # ACP client that connects to a coding agent over stdio using JSON-RPC 2.0.
+    #
+    # Spawns the agent CLI as a subprocess and communicates via stdin/stdout.
+    # Supports all ACP methods: initialize, session/new, session/prompt, etc.
+    #
+    # @example
+    #   client = Ask::ACP::Client.new(command: ["codex", "acp"])
+    #   client.start
+    #   result = client.initialize!(name: "askoda", version: "0.1.0")
+    #   session = client.session_new(cwd: "/tmp")
+    #   client.session_prompt(session[:id], "Hello") { |event| puts event }
+    #   client.stop
+    class Client
+      attr_reader :command, :running
+
+      def initialize(command:, request_timeout: 30.0)
+        @command = command
+        @request_timeout = request_timeout
+        @stdin = nil
+        @next_id = 1
+        @pending = {}
+        @event_handlers = []
+        @running = false
+        @mutex = Mutex.new
+        @initialized = false
+      end
+
+      # Start the agent subprocess and begin reading stdout.
+      def start
+        @mutex.synchronize do
+          return if @running
+          @stdin, stdout, stderr, @wait_thr = Open3.popen3(*@command)
+
+          @stdout_thread = Thread.new(stdout) do |io|
+            io.each_line do |line|
+              line = line.strip
+              next if line.empty?
+              handle_message(Protocol.parse(line))
+            end
+          end
+
+          # Drain stderr to prevent deadlocks
+          Thread.new(stderr) { |io| io.each_line { |_| } }
+
+          @running = true
+        end
+      end
+
+      # Stop the agent subprocess.
+      def stop
+        @mutex.synchronize do
+          return unless @running
+          @running = false
+          @initialized = false
+          @stdin&.close rescue nil
+          @stdout_thread&.join(3) rescue nil
+          Process.kill("TERM", @wait_thr.pid) rescue nil
+          @wait_thr&.join(5) rescue nil
+          @stdin = nil
+          @pending.each_value { |f| f[:error] = Error.new("process exited"); f[:done] = true; f[:condition].signal }
+          @pending.clear
+        end
+      end
+
+      def running?
+        @running && @wait_thr&.alive?
+      end
+
+      # Register a handler for incoming notifications (client methods from agent).
+      def on_notification(&handler)
+        @mutex.synchronize { @event_handlers << handler }
+      end
+
+      # ── ACP Methods ──
+
+      # Initialize handshake. Must be called first.
+      def initialize!(client_name:, client_version:, capabilities: {})
+        result = request(Protocol::AGENT_METHODS[:initialize], {
+          protocolVersion: Protocol::PROTOCOL_VERSION,
+          clientInfo: { name: client_name, version: client_version },
+          capabilities: capabilities
+        })
+        @initialized = true
+        result
+      end
+
+      # Authenticate with the agent (if required).
+      def authenticate(token:, scheme: "bearer")
+        request(Protocol::AGENT_METHODS[:authenticate], {
+          credentials: { scheme: scheme, token: token }
+        })
+      end
+
+      # Create a new session in the given working directory.
+      # Returns { id:, status:, created_at: }.
+      def session_new(cwd: ".", model: nil, tools: nil)
+        ensure_initialized!
+        params = { cwd: cwd, mcpServers: [] }
+        params[:model] = model if model
+        result = request(Protocol::AGENT_METHODS[:session_new], params)
+        normalize_session(result)
+      end
+
+      # Load an existing session by ID.
+      def session_load(session_id)
+        ensure_initialized!
+        result = request(Protocol::AGENT_METHODS[:session_load], { sessionId: session_id })
+        normalize_session(result)
+      end
+
+      # List sessions.
+      def session_list(cwd: nil)
+        ensure_initialized!
+        params = {}
+        params[:cwd] = cwd if cwd
+        result = request(Protocol::AGENT_METHODS[:session_list], params)
+        (result["sessions"] || result[:sessions] || []).map { |s| normalize_session(s) }
+      end
+
+      # Fork a session from an existing one.
+      def session_fork(session_id)
+        ensure_initialized!
+        result = request(Protocol::AGENT_METHODS[:session_fork], { sessionId: session_id })
+        normalize_session(result)
+      end
+
+      # Resume a session.
+      def session_resume(session_id)
+        ensure_initialized!
+        result = request(Protocol::AGENT_METHODS[:session_resume], { sessionId: session_id })
+        normalize_session(result)
+      end
+
+      # Close a session.
+      def session_close(session_id)
+        ensure_initialized!
+        request(Protocol::AGENT_METHODS[:session_close], { sessionId: session_id })
+      end
+
+      # Send a prompt to a session and stream events via the block.
+      # The prompt is automatically wrapped in a ContentBlock array if given
+      # as a plain string.
+      #
+      # @yield [Hash] event with :method and :params
+      # @return [Hash] the final session/prompt response
+      def session_prompt(session_id, prompt, timeout: nil, &block)
+        ensure_initialized!
+        prompt_blocks = prompt.is_a?(Array) ? prompt : [{ type: "text", text: prompt.to_s }]
+        params = { sessionId: session_id, prompt: prompt_blocks }
+        if block
+          # Register a temporary handler for streaming events
+          handler = ->(msg) { block.call(method: msg["method"], params: msg["params"] || {}) if msg["method"] }
+          on_notification(&handler)
+          begin
+            request(Protocol::AGENT_METHODS[:session_prompt], params, timeout: timeout)
+          ensure
+            @mutex.synchronize { @event_handlers.delete(handler) }
+          end
+        else
+          request(Protocol::AGENT_METHODS[:session_prompt], params, timeout: timeout)
+        end
+      end
+
+      # Cancel the current prompt execution.
+      def session_cancel(session_id)
+        ensure_initialized!
+        request(Protocol::AGENT_METHODS[:session_cancel], { sessionId: session_id })
+      end
+
+      # Set a config option on a session.
+      def session_set_config_option(session_id, key, value)
+        ensure_initialized!
+        request(Protocol::AGENT_METHODS[:session_set_config_option], {
+          sessionId: session_id, key: key, value: value
+        })
+      end
+
+      # Set the mode on a session.
+      def session_set_mode(session_id, mode)
+        ensure_initialized!
+        request(Protocol::AGENT_METHODS[:session_set_mode], {
+          sessionId: session_id, mode: mode
+        })
+      end
+
+      # Set the model on a session.
+      def session_set_model(session_id, provider:, model:)
+        ensure_initialized!
+        request(Protocol::AGENT_METHODS[:session_set_model], {
+          sessionId: session_id, provider: provider, model: model
+        })
+      end
+
+      # Send a JSON-RPC request and wait for the response.
+      def request(method, params = nil, timeout: nil)
+        ensure_running!
+        future = { done: false, result: nil, error: nil, condition: ConditionVariable.new }
+
+        @mutex.synchronize do
+          id = @next_id
+          @next_id += 1
+          @pending[id] = future
+          write(Protocol.build_request(method, params, id: id))
+        end
+
+        timeout ||= @request_timeout
+        deadline = Time.now + timeout
+
+        @mutex.synchronize do
+          until future[:done]
+            remaining = deadline - Time.now
+            raise TimeoutError, "Request timed out after #{timeout}s" if remaining <= 0
+            future[:condition].wait(@mutex, remaining)
+          end
+        end
+
+        raise future[:error] if future[:error]
+        future[:result]
+      end
+
+      private
+
+      def ensure_running!
+        raise Error, "ACP client not started. Call #start first." unless running?
+      end
+
+      def ensure_initialized!
+        ensure_running!
+        raise Error, "ACP not initialized. Call #initialize! first." unless @initialized
+      end
+
+      def write(msg)
+        @stdin&.puts(JSON.generate(msg))
+        @stdin&.flush
+      end
+
+      def handle_message(msg)
+        return unless msg
+
+        # Response to a pending request
+        if msg.key?("id")
+          rid = msg["id"]
+          future = nil
+          @mutex.synchronize { future = @pending.delete(rid) }
+
+          if future
+            @mutex.synchronize do
+              if msg.key?("error")
+                err = msg["error"]
+                future[:error] = Error.new("[#{err["code"]}] #{err["message"]}")
+              elsif msg.key?("result")
+                future[:result] = msg["result"]
+              else
+                future[:error] = Error.new("No result or error")
+              end
+              future[:done] = true
+              future[:condition].signal
+            end
+            return
+          end
+        end
+
+        # Notification or event (no id or unmatched id)
+        dispatch_event(msg)
+      end
+
+      def dispatch_event(msg)
+        @event_handlers.dup.each { |h| h.call(msg) rescue nil }
+      end
+
+      def normalize_session(result)
+        s = result["session"] || result[:session] || result
+        {
+          id: s["id"] || s["sessionId"],
+          status: s["status"] || "unknown",
+          created_at: s["createdAt"] || s["created_at"]
+        }
+      end
+    end
+  end
+end

data/lib/ask/acp/protocol.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Ask
+  module ACP
+    # Protocol constants and message helpers for the Agent Client Protocol (ACP).
+    #
+    # ACP uses JSON-RPC 2.0 over stdio (newline-delimited JSON).
+    # Protocol version: 1 (v0.11.3 schema)
+    module Protocol
+      PROTOCOL_VERSION = 1
+
+      # Agent methods (client → agent)
+      AGENT_METHODS = {
+        initialize: "initialize",
+        authenticate: "authenticate",
+        logout: "logout",
+        session_cancel: "session/cancel",
+        session_close: "session/close",
+        session_fork: "session/fork",
+        session_list: "session/list",
+        session_load: "session/load",
+        session_new: "session/new",
+        session_prompt: "session/prompt",
+        session_resume: "session/resume",
+        session_set_config_option: "session/set_config_option",
+        session_set_mode: "session/set_mode",
+        session_set_model: "session/set_model"
+      }.freeze
+
+      # Client methods (agent → client, for tool execution and elicitation)
+      CLIENT_METHODS = {
+        fs_read_text_file: "fs/read_text_file",
+        fs_write_text_file: "fs/write_text_file",
+        session_elicitation: "session/elicitation",
+        session_elicitation_complete: "session/elicitation/complete",
+        session_request_permission: "session/request_permission",
+        session_update: "session/update",
+        terminal_create: "terminal/create",
+        terminal_kill: "terminal/kill",
+        terminal_output: "terminal/output",
+        terminal_release: "terminal/release",
+        terminal_wait_for_exit: "terminal/wait_for_exit"
+      }.freeze
+
+      # Prompt response event types (streamed from session/prompt)
+      PROMPT_EVENTS = {
+        text: "text",
+        tool_use: "tool_use",
+        tool_result: "tool_result",
+        turn_complete: "turn_complete",
+        turn_failed: "turn_failed",
+        session_update: "session/update",
+        permission_request: "session/request_permission",
+        elicitation: "session/elicitation"
+      }.freeze
+
+      STATUSES = {
+        completed: "completed",
+        failed: "failed",
+        cancelled: "cancelled",
+        in_progress: "in_progress"
+      }.freeze
+
+      # Build a JSON-RPC 2.0 request.
+      def self.build_request(method, params = nil, id: nil)
+        msg = { jsonrpc: "2.0", method: method }
+        msg[:id] = id
+        msg[:params] = params if params
+        msg
+      end
+
+      # Build a JSON-RPC 2.0 notification (no id).
+      def self.build_notification(method, params = nil)
+        msg = { jsonrpc: "2.0", method: method }
+        msg[:params] = params if params
+        msg
+      end
+
+      # Build a JSON-RPC 2.0 success response.
+      def self.build_response(id, result)
+        { jsonrpc: "2.0", id: id, result: result }
+      end
+
+      # Build a JSON-RPC 2.0 error response.
+      def self.build_error(id, code, message, data: nil)
+        err = { code: code, message: message }
+        err[:data] = data if data
+        { jsonrpc: "2.0", id: id, error: err }
+      end
+
+      # Parse a JSON-RPC message from a line.
+      # Returns a hash with string keys, or nil if invalid.
+      def self.parse(line)
+        return nil if line.nil? || line.strip.empty?
+        JSON.parse(line)
+      rescue JSON::ParserError
+        nil
+      end
+
+      # Serialize a message to a JSON line (with newline).
+      def self.serialize(msg)
+        JSON.generate(msg) + "\n"
+      end
+    end
+  end
+end

data/lib/ask/acp/replay_client.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Ask
+  module ACP
+    # ACP client that replays pre-recorded interactions from a fixture file.
+    #
+    # Like VCR for stdio — no subprocess, instant response, deterministic.
+    # Records are newline-delimited JSON with format:
+    #   {"request": {...}}    ← request sent to agent
+    #   {"response": {...}}   ← response from agent (or mock)
+    #   {"notification": {...}} ← async notification from agent
+    #
+    # @example
+    #   client = Ask::ACP::ReplayClient.new(fixture: "test/fixtures/opencode_session.jsonl")
+    #   client.start
+    #   client.initialize!(client_name: "test", client_version: "0.1.0")
+    class ReplayClient
+      attr_reader :fixture_path, :running
+
+      def initialize(fixture_path:)
+        @fixture_path = fixture_path
+        @events = []
+        @index = 0
+        @running = false
+        @initialized = false
+        @event_handlers = []
+        @pending = {}
+        @next_id = 1
+        @mutex = Mutex.new
+      end
+
+      def start
+        load_fixture
+        @running = true
+      end
+
+      def stop
+        @running = false
+        @initialized = false
+      end
+
+      def running?
+        @running
+      end
+
+      def on_notification(&handler)
+        @mutex.synchronize { @event_handlers << handler }
+      end
+
+      # ── ACP Methods (same interface as Client) ──
+
+      def initialize!(client_name:, client_version:, capabilities: {})
+        @initialized = true
+        make_request("initialize", {
+          protocolVersion: 1, clientInfo: { name: client_name, version: client_version }, capabilities: capabilities
+        })
+      end
+
+      def session_new(cwd: ".", model: nil)
+        ensure_initialized!
+        params = { cwd: cwd, mcpServers: [] }
+        params[:model] = model if model
+        normalize_session(make_request(Protocol::AGENT_METHODS[:session_new], params))
+      end
+
+      def session_load(session_id)
+        ensure_initialized!
+        result = make_request(Protocol::AGENT_METHODS[:session_load], { sessionId: session_id })
+        normalize_session(result)
+      end
+
+      def session_list(cwd: nil)
+        ensure_initialized!
+        params = {}
+        params[:cwd] = cwd if cwd
+        result = make_request(Protocol::AGENT_METHODS[:session_list], params)
+        (result["sessions"] || result[:sessions] || []).map { |s| normalize_session(s) }
+      end
+
+      def session_resume(session_id)
+        ensure_initialized!
+        result = make_request(Protocol::AGENT_METHODS[:session_resume], { sessionId: session_id })
+        normalize_session(result)
+      end
+
+      def session_close(session_id)
+        ensure_initialized!
+        make_request(Protocol::AGENT_METHODS[:session_close], { sessionId: session_id })
+      end
+
+      def session_prompt(session_id, prompt, timeout: nil, &block)
+        ensure_initialized!
+        prompt_blocks = prompt.is_a?(Array) ? prompt : [{ type: "text", text: prompt.to_s }]
+        params = { sessionId: session_id, prompt: prompt_blocks }
+
+        # Dispatch any notifications before the response
+        while @index < @events.length
+          event = @events[@index]
+          break if event.key?("response")
+          if event.key?("notification")
+            dispatch_event(event["notification"])
+          end
+          @index += 1
+        end
+
+        # Get the response
+        event = @events[@index]
+        @index += 1
+        if event && event["response"]
+          result = event["response"]["result"]
+          error = event["response"]["error"]
+          raise Error.new("[#{error["code"]}] #{error["message"]}") if error
+          result
+        else
+          { "status" => "completed" }
+        end
+      end
+
+      private
+
+      def ensure_initialized!
+        raise Error, "ReplayClient not started. Call #start first." unless @running
+        raise Error, "Not initialized. Call #initialize! first." unless @initialized
+      end
+
+      def load_fixture
+        @events = []
+        File.readlines(@fixture_path).each do |line|
+          line = line.strip
+          next if line.empty?
+          @events << JSON.parse(line)
+        end
+        @index = 0
+      rescue => e
+        raise Error, "Failed to load fixture #{@fixture_path}: #{e.message}"
+      end
+
+      def make_request(method, params)
+        # Look for the next response event matching this method
+        while @index < @events.length
+          event = @events[@index]
+          @index += 1
+
+          if event["response"]
+            result = event["response"]["result"]
+            error = event["response"]["error"]
+            raise Error.new("[#{error["code"]}] #{error["message"]}") if error
+            return result
+          end
+        end
+        {}
+      end
+
+      def dispatch_event(msg)
+        @event_handlers.dup.each { |h| h.call(msg) rescue nil }
+      end
+
+      def normalize_session(result)
+        s = result["session"] || result[:session] || result
+        {
+          id: s["id"] || s["sessionId"],
+          status: s["status"] || "unknown",
+          created_at: s["createdAt"] || s["created_at"]
+        }
+      end
+    end
+  end
+end

data/lib/ask/acp/server.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Ask
+  module ACP
+    # ACP server that lets a Ruby agent speak the Agent Client Protocol over stdio.
+    #
+    # Handles the JSON-RPC 2.0 transport, method dispatch, and streaming responses.
+    # Subclass and implement the method handlers you need.
+    #
+    # @example
+    #   class MyAgent < Ask::ACP::Server
+    #     def handle_initialize(params)
+    #       { protocolVersion: 1, serverInfo: { name: "my-agent", version: "0.1.0" } }
+    #     end
+    #
+    #     def handle_session_new(params)
+    #       { session: { id: SecureRandom.uuid, status: "running" } }
+    #     end
+    #   end
+    #
+    #   MyAgent.new.run
+    class Server
+      def initialize
+        @methods = {}
+        register_defaults
+      end
+
+      # Start reading from stdin and processing requests.
+      def run
+        $stdin.each_line do |line|
+          line = line.strip
+          next if line.empty?
+          handle(Protocol.parse(line))
+        end
+      rescue => e
+        $stderr.puts "ACP server error: #{e.message}"
+      end
+
+      private
+
+      def register_defaults
+        register("initialize") do |params|
+          {
+            protocolVersion: Protocol::PROTOCOL_VERSION,
+            capabilities: {},
+            serverInfo: { name: "ask-acp", version: VERSION }
+          }
+        end
+
+        register("session/new") do |params|
+          handle_session_new(params)
+        end
+
+        register("session/load") do |params|
+          handle_session_load(params)
+        end
+
+        register("session/list") do |params|
+          handle_session_list(params)
+        end
+
+        register("session/resume") do |params|
+          handle_session_resume(params)
+        end
+
+        register("session/close") do |params|
+          handle_session_close(params)
+        end
+
+        register("session/prompt") do |params|
+          handle_session_prompt(params)
+        end
+
+        register("session/cancel") do |params|
+          handle_session_cancel(params)
+        end
+      end
+
+      # Default handlers — override in subclasses.
+
+      def handle_initialize(params)
+        { protocolVersion: Protocol::PROTOCOL_VERSION, capabilities: {}, serverInfo: { name: "ask-acp", version: VERSION } }
+      end
+
+      def handle_session_new(params)
+        require "securerandom"
+        id = SecureRandom.uuid
+        { session: { id: id, status: "running" } }
+      end
+
+      def handle_session_load(params)
+        { session: { id: params["sessionId"], status: "running" } }
+      end
+
+      def handle_session_list(params)
+        { sessions: [] }
+      end
+
+      def handle_session_resume(params)
+        { session: { id: params["sessionId"], status: "running" } }
+      end
+
+      def handle_session_close(params)
+        {}
+      end
+
+      def handle_session_prompt(params)
+        # Default: stream back a completion event immediately
+        send_text_delta(params["sessionId"], "Hello from ACP server!")
+        send_event("turn_complete", { sessionId: params["sessionId"] })
+        { status: "completed" }
+      end
+
+      def handle_session_cancel(params)
+        {}
+      end
+
+      def register(method, &handler)
+        @methods[method] = handler
+      end
+
+      def handle(msg)
+        return unless msg
+
+        if msg.key?("id")
+          id = msg["id"]
+          method = msg["method"]
+          params = msg["params"] || {}
+
+          handler = @methods[method]
+          if handler
+            begin
+              result = handler.call(params)
+              write(Protocol.build_response(id, result))
+            rescue => e
+              write(Protocol.build_error(id, -32_600, e.message))
+            end
+          else
+            write(Protocol.build_error(id, -32_601, "Unknown method: #{method}"))
+          end
+        end
+      end
+
+      def write(msg)
+        $stdout.puts(JSON.generate(msg))
+        $stdout.flush
+      end
+
+      def send_event(method, params)
+        write(Protocol.build_notification(method, params))
+      end
+
+      def send_text_delta(session_id, content)
+        send_event("text", { sessionId: session_id, content: content })
+      end
+    end
+  end
+end

data/lib/ask/acp/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Ask
+  module ACP
+    VERSION = "0.1.0"
+  end
+end

data/lib/ask/acp.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative "acp/version"
+require_relative "acp/protocol"
+require_relative "acp/client"
+require_relative "acp/replay_client"
+require_relative "acp/server"
+
+module Ask
+  module ACP
+    class Error < StandardError; end
+    class TimeoutError < Error; end
+  end
+end

data/lib/ask-acp.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "ask/acp"

metadata

@@ -0,0 +1,119 @@
+--- !ruby/object:Gem::Specification
+name: ask-acp
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Kaka Ruto
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.25'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.25'
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.22'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.22'
+description: Ruby implementation of the Agent Client Protocol (ACP) — a JSON-RPC standard
+  for agent-editor communication. Includes client (connect to ACP agents), server
+  (host Ruby agents via ACP), and transport layer.
+email:
+- kaka@myrrlabs.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/ask-acp.rb
+- lib/ask/acp.rb
+- lib/ask/acp/client.rb
+- lib/ask/acp/protocol.rb
+- lib/ask/acp/replay_client.rb
+- lib/ask/acp/server.rb
+- lib/ask/acp/version.rb
+homepage: https://github.com/ask-rb/ask-acp
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.3
+specification_version: 4
+summary: Agent Client Protocol for Ruby
+test_files: []