ask-coding-providers 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c705fccdf37e62127cbbff2ad58fa7102ac202429ab07fe291fe8b649ab3ddd4
+  data.tar.gz: 3884a19f15a0a7595b0d4a56787f38ff00d500438d4656d78db8ed3cb42332f9
+SHA512:
+  metadata.gz: 360d444a0f376927de910213f38d30f3ac1cfca4c86b1c85e8e44e5cd60f91dcb57feb4ce976d6124bf20a10d8bf5c2e920eaa682fd6393e74d087f5cfd72e06
+  data.tar.gz: 9860f5295b9926fa6317aeb6f3cb25c94c8082eed66b8a04d5f6f3d5a377c6c4d695f356772d9edc7dbdc9b6f1ee026bea5b3ff809968fcf758526128a6eb66a

data/lib/ask/coding_providers/acp/adapter.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+module Ask
+  module CodingProviders
+    module ACP
+      # Adapter that connects to any ACP-speaking coding agent over stdio.
+      #
+      # ACP (Agent Client Protocol) is a JSON-RPC 2.0 standard for agent-editor
+      # communication. This adapter wraps the ACP client into the generic
+      # {Ask::CodingProviders::Adapter} interface. It is the **primary
+      # recommended adapter** for new deployments.
+      #
+      # Works with any ACP-compatible agent:
+      # - **Codex** — `ACP_COMMAND='codex acp'` (native ACP support)
+      # - **Claude Code** — `ACP_COMMAND='claude acp'` (native ACP support)
+      # - **OpenCode** — `ACP_COMMAND='opencode acp'` (native ACP support)
+      # - **ZCode** — via ACP bridges like william0wang/zcode-acp or
+      #   alexeygrigorev/zcode-acp
+      # - **Gemini CLI** — `ACP_COMMAND='gemini-cli acp'` (native ACP support)
+      #
+      # @example
+      #   adapter = Ask::CodingProviders::ACP::Adapter.new(
+      #     command: ["codex", "acp"],
+      #     cwd: Dir.pwd
+      #   )
+      #   adapter.start
+      #   sid = adapter.create_session("/tmp")
+      #   adapter.send_and_stream(sid, "Hello") { |ev| puts ev }
+      class Adapter < Ask::CodingProviders::Adapter
+        # @param command [Array<String>] the command to spawn the ACP agent
+        # @param cwd [String] working directory
+        # @param request_timeout [Float] timeout for ACP requests
+        def initialize(command:, cwd: ".", request_timeout: 60.0)
+          require "ask/acp"
+
+          @command = command
+          @cwd = cwd
+          @request_timeout = request_timeout
+          @client = nil
+          @sessions = {}
+        end
+
+        def start
+          return if @client
+          @client = Ask::ACP::Client.new(command: @command, request_timeout: @request_timeout)
+          @client.start
+          @client.initialize!(client_name: "askoda", client_version: "0.1.0")
+        end
+
+        def stop
+          @client&.stop
+          @client = nil
+          @sessions = {}
+        end
+
+        def running?
+          @client&.running? || false
+        end
+
+        def create_session(workspace_path, mode: nil)
+          ensure_running
+          params = { cwd: workspace_path || @cwd }
+          session = @client.session_new(**params)
+          sid = session[:id]
+          @sessions[sid] = { workspace: workspace_path, mode: mode, created_at: Time.now }
+          sid
+        end
+
+        def resume_session(session_id)
+          ensure_running
+          @client.session_resume(session_id)
+        rescue => e
+          {}
+        end
+
+        def subscribe(session_id, after_seq: 0)
+          ensure_running
+          { "eventSeq" => 0 }
+        end
+
+        def send_message(session_id, content)
+          ensure_running
+          @client.session_prompt(session_id, content)
+        end
+
+        def send_and_stream(session_id, content, turn_timeout: 600.0, &block)
+          return enum_for(:send_and_stream, session_id, content, turn_timeout: turn_timeout) unless block
+          ensure_running
+
+          accumulated = ""
+          block.call({ type: "turn.started", seq: 1, payload: { "sessionId" => session_id } })
+
+          result = @client.session_prompt(session_id, content, timeout: turn_timeout) do |event|
+            case event[:method]
+            when "text"
+              delta = event.dig(:params, "content") || ""
+              accumulated += delta
+              block.call({
+                type: "model.streaming", seq: 2,
+                payload: { "delta" => delta, "sessionId" => session_id }
+              }) unless delta.empty?
+            when "turn_complete"
+              block.call({
+                type: "turn.completed", seq: 3,
+                payload: { "response" => accumulated, "sessionId" => session_id }
+              })
+            when "turn_failed"
+              err = event.dig(:params, "error") || "Unknown error"
+              block.call({
+                type: "turn.failed", seq: 3,
+                payload: { "error" => { "message" => err }, "sessionId" => session_id }
+              })
+            end
+          end
+
+          # If the prompt response contains the result and we haven't sent completed yet
+          if result.is_a?(Hash)
+            stop_reason = result["stopReason"] || result[:stopReason]
+            if stop_reason == "cancelled" || stop_reason == "refusal"
+              block.call({
+                type: "turn.failed", seq: 3,
+                payload: { "error" => { "message" => "Turn #{stop_reason}" }, "sessionId" => session_id }
+              })
+            end
+          end
+        rescue => e
+          block.call({
+            type: "turn.failed", seq: 3,
+            payload: { "error" => { "message" => e.message }, "sessionId" => session_id }
+          })
+        end
+
+        def get_events(session_id, after_seq:, limit: nil)
+          ensure_running
+          {}
+        end
+
+        def respond(request_id, result)
+          # ACP uses notification-based reverse requests, no direct respond
+        end
+
+        def get_workspace_state(workspace_path)
+          ensure_running
+          {}
+        rescue => e
+          {}
+        end
+
+        # Build an ACP adapter from config.
+        # Reads ACP_COMMAND env var (space-separated command + args).
+        def self.from_config(workspace_path: Dir.pwd, cli_path: nil, request_timeout: 600, **)
+          cmd = cli_path || ENV["ACP_COMMAND"] || raise(
+            Ask::CodingProviders::ConfigurationError,
+            "Missing ACP_COMMAND. Set ACP_COMMAND or pass cli_path, e.g. ACP_COMMAND='codex acp'"
+          )
+          new(
+            command: cmd.is_a?(String) ? cmd.split : cmd,
+            cwd: workspace_path,
+            request_timeout: request_timeout
+          )
+        end
+
+        private
+
+        def ensure_running
+          raise Error, "ACP adapter is not running. Call #start first." unless @client&.running?
+        end
+      end
+    end
+  end
+end
+
+Ask::CodingProviders.register_adapter(:acp, Ask::CodingProviders::ACP::Adapter)

data/lib/ask/coding_providers/acp.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require_relative "acp/adapter"
+
+module Ask
+  module CodingProviders
+    module ACP
+      class Error < Ask::CodingProviders::Error; end
+    end
+  end
+end

data/lib/ask/coding_providers/adapter.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+module Ask
+  module CodingProviders
+    # Abstract base class for coding agent adapters.
+    #
+    # A coding agent adapter wraps an AI coding agent (e.g., ZCode, Claude Code, Codex)
+    # and provides a uniform interface for the coder engine to interact with it.
+    #
+    # Subclasses must implement all methods that raise NotImplementedError.
+    class Adapter
+      # Create a new session on the agent.
+      #
+      # @param workspace_path [String] the working directory
+      # @param mode [String, nil] permission mode
+      # @return [String] the session ID
+      def create_session(workspace_path, mode: nil)
+        raise NotImplementedError, "#{self.class} must implement #create_session"
+      end
+
+      # Resume an existing session.
+      #
+      # @param session_id [String] the session ID
+      # @return [Hash] session snapshot
+      def resume_session(session_id)
+        raise NotImplementedError, "#{self.class} must implement #resume_session"
+      end
+
+      # List available sessions.
+      #
+      # @param workspace_path [String, nil] optional filter
+      # @param limit [Integer] max sessions
+      # @return [Array<Hash>] session summaries
+      def list_sessions(workspace_path: nil, limit: 20)
+        raise NotImplementedError, "#{self.class} must implement #list_sessions"
+      end
+
+      # Subscribe to session events.
+      #
+      # @param session_id [String] the session ID
+      # @param after_seq [Integer] sequence to start from
+      # @return [Hash] subscription result
+      def subscribe(session_id, after_seq: 0)
+        raise NotImplementedError, "#{self.class} must implement #subscribe"
+      end
+
+      # Send a message to a session (fire-and-forget).
+      def send_message(session_id, content)
+        raise NotImplementedError, "#{self.class} must implement #send_message"
+      end
+
+      # Send a message and stream the response events.
+      #
+      # @yield [Hash] stream events with :type, :payload, :seq
+      def send_and_stream(session_id, content, turn_timeout: 600.0, &block)
+        raise NotImplementedError, "#{self.class} must implement #send_and_stream"
+      end
+
+      # Get events after a sequence number (polling).
+      #
+      # @return [Hash] events list
+      def get_events(session_id, after_seq:, limit: nil)
+        raise NotImplementedError, "#{self.class} must implement #get_events"
+      end
+
+      # Respond to a reverse request (permission approval, etc.).
+      def respond(request_id, result)
+        raise NotImplementedError, "#{self.class} must implement #respond"
+      end
+
+      # Read the workspace state (model info, settings, etc.).
+      def get_workspace_state(workspace_path)
+        {}
+      end
+
+      # Called when a session operation fails. The adapter can signal how
+      # the Engine should recover.
+      #
+      # @param session_id [String] the session that failed
+      # @param error [StandardError] the error that occurred
+      # @return [Symbol, nil] :create_new to replace the session, nil to show error as-is
+      def handle_session_error(session_id, error)
+        nil  # Unknown error — let the Engine show it to the user
+      end
+
+      # Optional: list available projects with session counts.
+      # Returns [{project_id:, directory:, session_count:}] or nil.
+      def list_projects
+        nil
+      end
+
+      # Optional: find sessions in a directory.
+      # Returns [{session_id:, title:, updated:}] or [].
+      def find_sessions(directory:, limit: 20)
+        []
+      end
+
+      # Optional: find the single most recent session.
+      # Returns {session_id:, directory:} or nil.
+      def find_recent_session
+        nil
+      end
+
+      # Optional: find the most recent TUI session in a workspace.
+      # Returns {session_id:, title:, directory:} or nil.
+      def find_recent_tui_session(workspace_path)
+        nil
+      end
+
+      # Optional: get a session's workspace directory by ID.
+      # Returns directory string or nil.
+      def session_directory(session_id)
+        nil
+      end
+
+      # Optional: get session message history.
+      # Returns [{text:, role:, origin:}] or [].
+      def session_history(session_id, limit: 100)
+        []
+      end
+
+      # Optional: list recent sessions across all projects.
+      # Returns [{session_id:, title:, updated:, msg_count:}] or [].
+      def recent_sessions
+        []
+      end
+
+      # Start the agent connection.
+      def start
+      end
+
+      # Stop the agent connection.
+      def stop
+      end
+
+      # Whether the agent is running.
+      def running?
+        true
+      end
+
+      # Build an adapter instance from a configuration hash.
+      # Override in subclasses to extract adapter-specific settings.
+      # The default passes the entire hash to +new+.
+      #
+      # @param config [Hash] configuration options (typically from ENV)
+      # @return [Adapter] a configured adapter instance
+      def self.from_config(**config)
+        new(**config)
+      end
+    end
+  end
+end

data/lib/ask/coding_providers/ask_agent/adapter.rb

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+module Ask
+  module CodingProviders
+    module AskAgent
+      # Adapter that wraps Ask::Agent::Session directly (in-process).
+      #
+      # No app-server, no external binary — sessions run in the same process.
+      # Perfect for deployments where running a separate process is impractical.
+      #
+      # @example
+      #   adapter = AskAgent::Adapter.new(model: "deepseek-v4-flash", provider: "opencode_go")
+      #   adapter.start
+      #   sid = adapter.create_session("/tmp")
+      #   adapter.send_and_stream(sid, "Hello") { |ev| puts ev }
+      class Adapter < Ask::CodingProviders::Adapter
+        # @param model [String] model ID (e.g. "deepseek-v4-flash")
+        # @param provider [String] provider slug (e.g. "opencode_go")
+        # @param tools [Array] tool instances to make available
+        # @param max_turns [Integer] max conversation turns per session
+        def initialize(model:, provider:, tools: [], max_turns: 25, **session_opts)
+          # Lazy require — these gems are optional for the gem but required for this adapter
+          begin
+            require "ask-llm-providers"
+            require "ask/agent"
+          rescue LoadError => e
+            raise "Missing dependency for AskAgent adapter: #{e.message}. Add ask-agent and ask-llm-providers to your Gemfile."
+          end
+
+          @model_id = model
+          @provider_slug = provider
+          @tools = tools
+          @max_turns = max_turns
+          @session_opts = session_opts
+          @started = false
+          @provider = nil
+        end
+
+  def start
+    return if @started
+    klass = Ask::Provider.resolve(@provider_slug)
+    compat = klass.respond_to?(:compat_config) ? klass.compat_config : {}
+    api_key = ENV[compat[:alternate_env].to_s] || ENV[compat[:api_key_env].to_s] || ENV["#{@provider_slug.upcase}_API_KEY"]
+    @provider = klass.new(api_key: api_key)
+    @started = true
+  end
+
+        def stop
+          @started = false
+          @provider = nil
+        end
+
+        def running?
+          @started
+        end
+
+        # Create a new conversation session.
+        # The workspace_path is noted but not used by in-process agent.
+        # Returns a session ID (UUID).
+        def create_session(workspace_path, mode: nil)
+          ensure_started
+          sid = "sess_#{SecureRandom.uuid}"
+          @sessions ||= {}
+          @sessions[sid] = { workspace: workspace_path, mode: mode, created_at: Time.now }
+          sid
+        end
+
+        def resume_session(session_id)
+          ensure_started
+          @sessions&.dig(session_id) || {}
+        end
+
+        def subscribe(session_id, after_seq: 0)
+          ensure_started
+          { "eventSeq" => 0 }
+        end
+
+        def send_message(session_id, content)
+          ensure_started
+          # Run synchronously — returns when done
+          result = run_session(session_id, content)
+          { "response" => result }
+        end
+
+        def send_and_stream(session_id, content, turn_timeout: 600.0, &block)
+          return enum_for(:send_and_stream, session_id, content, turn_timeout: turn_timeout) unless block
+          ensure_started
+
+          # Build the ask-agent chat with our pre-configured provider
+          chat = build_chat
+          session = Ask::Agent::Session.new(
+            model: chat,
+            max_turns: @max_turns,
+            **@session_opts
+          )
+
+          # Emit turn.started
+          block.call({ type: "turn.started", seq: 1, payload: { "sessionId" => session_id } })
+
+          # Wire streaming events
+          session.on_event do |event|
+            case event
+            when Ask::Agent::Events::TextDelta
+              block.call({
+                type: "model.streaming", seq: 2,
+                payload: { "delta" => event.content, "sessionId" => session_id }
+              })
+            end
+          end
+
+          begin
+            result = session.run(content)
+            block.call({
+              type: "turn.completed", seq: 3,
+              payload: { "response" => result, "sessionId" => session_id,
+                         "tokenCount" => session.total_input_tokens + session.total_output_tokens }
+            })
+          rescue => e
+            block.call({
+              type: "turn.failed", seq: 3,
+              payload: { "error" => { "message" => e.message }, "sessionId" => session_id }
+            })
+          end
+        end
+
+        def get_events(session_id, after_seq:, limit: nil)
+          { "events" => [] }
+        end
+
+        def respond(request_id, result)
+          # No reverse requests in basic mode
+        end
+
+	  def get_workspace_state(workspace_path)
+	    # No workspace state to report
+	    {}
+	  end
+
+	  # Build an AskAgent adapter from config.
+	  # Reads ASK_AGENT_MODEL, ASK_AGENT_LLM_PROVIDER, ASK_AGENT_MAX_TURNS from ENV.
+	  def self.from_config(model: nil, llm_provider: nil, max_turns: nil, **)
+	    new(
+	      model: model || ENV.fetch("ASK_AGENT_MODEL", "deepseek-v4-flash"),
+	      provider: llm_provider || ENV.fetch("ASK_AGENT_LLM_PROVIDER", "opencode_go"),
+	      max_turns: (max_turns || ENV.fetch("ASK_AGENT_MAX_TURNS", "10")).to_i
+	    )
+	  end
+
+	  private
+
+        def ensure_started
+          raise "Adapter not started. Call #start first." unless @started
+        end
+
+        def build_chat
+          chat = Ask::Agent::Chat.new(
+            model: @model_id,
+            provider: @provider_slug,
+            tools: @tools
+          )
+          # Inject pre-configured provider to bypass Ask::Auth.resolve
+          chat.instance_variable_set(:@provider, @provider)
+          chat
+        end
+
+        def run_session(session_id, content)
+          chat = build_chat
+          session = Ask::Agent::Session.new(
+            model: chat,
+            max_turns: @max_turns,
+            **@session_opts
+          )
+          session.run(content)
+        end
+      end
+    end
+  end
+end
+
+Ask::CodingProviders.register_adapter(:ask_agent, Ask::CodingProviders::AskAgent::Adapter)

data/lib/ask/coding_providers/ask_agent.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative "ask_agent/adapter"
+
+module Ask
+  module CodingProviders
+    # AskAgent coding provider — uses Ask::Agent::Session in-process.
+    #
+    # No app-server, no external binary. Sessions run in the same process.
+    #
+    # @example
+    #   adapter = Ask::CodingProviders::AskAgent::Adapter.new(
+    #     model: "deepseek-v4-flash",
+    #     provider: "opencode_go"
+    #   )
+    module AskAgent
+    end
+  end
+end