ask-coding-providers 0.1.0

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

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+require "json"
+require "open3"
+
+module Ask
+  module CodingProviders
+    module Claude
+      # Adapter for Claude Code CLI.
+      #
+      # Uses `claude -p --output-format=stream-json` for non-interactive prompts.
+      # Streams JSON events via stdout for real-time response display.
+      #
+      # @example
+      #   adapter = Ask::CodingProviders::Claude::Adapter.new(cli_path: "claude")
+      #   adapter.start
+      #   sid = adapter.create_session("/tmp")
+      #   adapter.send_and_stream(sid, "Hello") { |ev| puts ev }
+      class Adapter < Ask::CodingProviders::Adapter
+        def initialize(cli_path: "claude", cwd: ".", request_timeout: 120.0)
+          @cli_path = cli_path
+          @cwd = cwd
+          @request_timeout = request_timeout
+          @started = false
+          @sessions = {}
+        end
+
+        def start
+          @started = true
+        end
+
+        def stop
+          @started = false
+          @sessions = {}
+        end
+
+        def running?
+          @started
+        end
+
+        def create_session(workspace_path, mode: nil)
+          ensure_started
+          sid = "sess_#{SecureRandom.uuid}"
+          @sessions[sid] = { workspace: workspace_path, mode: mode, created_at: Time.now }
+          sid
+        end
+
+        def resume_session(session_id)
+          @sessions&.dig(session_id) || {}
+        end
+
+        def subscribe(session_id, after_seq: 0)
+          { "eventSeq" => 0 }
+        end
+
+        def send_message(session_id, content)
+          ensure_started
+          run_claude(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_started
+
+          block.call({ type: "turn.started", seq: 1, payload: { "sessionId" => session_id } })
+
+          deadline = Time.now + (turn_timeout || @request_timeout)
+          accumulated = ""
+
+          begin
+            stdin, stdout, stderr, wait_thr = Open3.popen3(
+              @cli_path, "-p", content.to_s,
+              "--verbose", "--output-format=stream-json",
+              chdir: @cwd
+            )
+            stdin.close
+
+            # Read JSON events from stdout
+            stdout.each_line do |line|
+              break if Time.now > deadline
+              line = line.strip
+              next if line.empty?
+
+              begin
+                event = JSON.parse(line)
+              rescue JSON::ParserError
+                next
+              end
+
+              case event["type"]
+              when "assistant"
+                msg = event["message"] || {}
+                (msg["content"] || []).each do |block|
+                  if block["type"] == "text" && block["text"]
+                    delta = block["text"]
+                    accumulated += delta
+                    block.call({
+                      type: "model.streaming", seq: 2,
+                      payload: { "delta" => delta, "sessionId" => session_id }
+                    })
+                  end
+                end
+              when "result"
+                is_error = event["is_error"]
+                if is_error
+                  err = event["result"] || "Claude error"
+                  block.call({
+                    type: "turn.failed", seq: 3,
+                    payload: { "error" => { "message" => err }, "sessionId" => session_id }
+                  })
+                else
+                  block.call({
+                    type: "turn.completed", seq: 3,
+                    payload: { "response" => accumulated, "sessionId" => session_id }
+                  })
+                end
+              when "error"
+                err_msg = event["message"] || event["error"] || "Claude error"
+                block.call({
+                  type: "turn.failed", seq: 3,
+                  payload: { "error" => { "message" => err_msg }, "sessionId" => session_id }
+                })
+              end
+            end
+
+            stdout.close rescue nil
+            stderr.close rescue nil
+            wait_thr&.join(5)
+
+          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)
+          {}
+        end
+
+        def respond(request_id, result)
+        end
+
+        def get_workspace_state(workspace_path)
+          {}
+        end
+
+        def self.from_config(workspace_path: Dir.pwd, cli_path: nil, request_timeout: 120, **)
+          new(cli_path: cli_path || "claude", cwd: workspace_path, request_timeout: request_timeout)
+        end
+
+        private
+
+        def ensure_started
+          raise Error, "Claude adapter not started" unless @started
+        end
+
+        def run_claude(content)
+          stdout, stderr, wait_thr = Open3.capture3(
+            @cli_path, "-p", content.to_s,
+            "--verbose", "--output-format=stream-json",
+            chdir: @cwd
+          )
+          events = stdout.split("\n").filter_map { |l| JSON.parse(l) rescue nil }
+          result = events.find { |e| e["type"] == "result" }
+          if result && result["is_error"]
+            { "error" => result["result"] || "Claude error" }
+          else
+            text = events
+              .select { |e| e["type"] == "assistant" }
+              .flat_map { |e| (e.dig("message", "content") || []).map { |c| c["text"] } }
+              .join
+            { "response" => text }
+          end
+        end
+      end
+    end
+  end
+end
+
+Ask::CodingProviders.register_adapter(:claude, Ask::CodingProviders::Claude::Adapter)

data/lib/ask/coding_providers/claude.rb

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

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

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+module Ask
+  module CodingProviders
+    module Codex
+      # Adapter implementation for the Codex app-server.
+      #
+      # Communicates with `codex app-server` over stdio JSON-RPC 2.0.
+      # Supports thread (session) lifecycle and streaming turns.
+      #
+      # Note: Codex does not speak ACP. Use this adapter for Codex.
+      # For agents that support ACP (Claude, OpenCode, Gemini CLI), use
+      # {Ask::CodingProviders::ACP::Adapter} instead.
+      class Adapter < Ask::CodingProviders::Adapter
+        def initialize(cwd: ".", cli_path: nil, request_timeout: 60.0, model: nil, model_provider: nil)
+          @cwd = cwd
+          @cli_path = cli_path
+          @request_timeout = request_timeout
+          @model = model || ENV["CODEX_MODEL"]
+          @model_provider = model_provider || ENV["CODEX_MODEL_PROVIDER"]
+          @client = nil
+          @codex_db = CodexDB.new
+        end
+
+        def start
+          return if @client
+          @client = AppServerClient.new(cwd: @cwd, cli_path: @cli_path, request_timeout: @request_timeout,
+                                         model: @model, model_provider: @model_provider)
+          @client.on_notification { |method, params, request_id| handle_notification(method, params, request_id) }
+          @client.start
+          # Perform the initialize handshake
+          @client.initialize!
+          @client.send_initialized
+        end
+
+        def stop
+          @client&.stop
+          @client = nil
+        end
+
+        def running?
+          @client&.running? || false
+        end
+
+        def create_session(workspace_path, mode: nil)
+          ensure_running
+          thread = @client.thread_start(cwd: workspace_path)
+          tid = thread["id"] || thread[:id]
+          raise Error, "thread/start did not return thread id" unless tid
+          tid
+        end
+
+        def resume_session(session_id)
+          ensure_running
+          @client.thread_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.turn_start(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
+          raise "send_and_stream requires app-server mode" unless @client
+
+          ev_queue = Queue.new
+          my_turn_id = nil
+          done = false
+
+          handler = ->(method, params, request_id) do
+            case method
+            when "turn/started"
+              my_turn_id = params["turnId"] || params[:turnId]
+              ev_queue << {
+                type: "turn.started", seq: params["seq"] || params[:seq] || 0,
+                payload: { "sessionId" => session_id }
+              }
+            when "item/agentMessage/delta"
+              tid = params["turnId"] || params[:turnId]
+              if my_turn_id.nil? || tid == my_turn_id
+                ev_queue << {
+                  type: "model.streaming", seq: params["seq"] || params[:seq] || 0,
+                  payload: { "delta" => params["content"] || params[:content] || "", "sessionId" => session_id }
+                }
+              end
+            when "turn/completed"
+              tid = params["turnId"] || params[:turnId]
+              if my_turn_id.nil? || tid == my_turn_id
+                response = params.dig("response", "message") || params.dig("turn", "response") || ""
+                ev_queue << {
+                  type: "turn.completed", seq: params["seq"] || params[:seq] || 0,
+                  payload: { "response" => response, "sessionId" => session_id,
+                             "tokenCount" => params["tokenCount"] || params[:tokenCount] || 0 }
+                }
+                done = true
+              end
+            when "turn/failed"
+              error_msg = params.dig("error", "message") || "Turn failed"
+              ev_queue << {
+                type: "turn.failed", seq: params["seq"] || params[:seq] || 0,
+                payload: { "error" => { "message" => error_msg }, "sessionId" => session_id }
+              }
+              done = true
+            end
+          end
+
+          @client.on_notification(&handler)
+          begin
+            @client.turn_start(session_id, content)
+            deadline = Time.now + turn_timeout
+            until done
+              remaining = deadline - Time.now
+              break if remaining <= 0
+              begin
+                block.call(ev_queue.pop(timeout: remaining))
+              rescue ThreadError
+                break
+              end
+            end
+          end
+        end
+
+        def get_events(session_id, after_seq:, limit: nil)
+          ensure_running
+          {}
+        end
+
+        def respond(request_id, result)
+          @client&.respond(request_id, result)
+        end
+
+        def get_workspace_state(workspace_path)
+          ensure_running
+          @client.read_workspace_state
+        rescue => e
+          {}
+        end
+
+        # Build a Codex adapter from config.
+        def self.from_config(workspace_path: Dir.pwd, cli_path: nil, request_timeout: 600, model: nil, model_provider: nil, **)
+          new(cwd: workspace_path, cli_path: cli_path, request_timeout: request_timeout,
+              model: model, model_provider: model_provider)
+        end
+
+        # ── Session/project queries (delegated to CodexDB) ──
+
+        def list_projects
+          @codex_db.list_projects
+        end
+
+        def find_sessions(directory:, limit: 20)
+          @codex_db.find_sessions(directory: directory, limit: limit)
+        end
+
+        def find_recent_session
+          @codex_db.find_recent_session
+        end
+
+        def find_recent_tui_session(workspace_path)
+          @codex_db.find_recent_tui_session(workspace_path)
+        end
+
+        def session_directory(session_id)
+          @codex_db.session_directory(session_id)
+        end
+
+        def session_history(session_id, limit: 100)
+          @codex_db.session_history(session_id, limit: limit)
+        end
+
+        def recent_sessions
+          @codex_db.recent_sessions
+        end
+
+        private
+
+        def ensure_running
+          raise Error, "Codex app-server is not running. Call #start first." unless @client&.running?
+        end
+
+        def handle_notification(method, params, request_id)
+          # Auto-respond to user input requests
+          return unless request_id
+          return unless method == "ToolRequestUserInput"
+          @client&.respond(request_id, { "response" => "" })
+        end
+      end
+    end
+  end
+end
+
+Ask::CodingProviders.register_adapter(:codex, Ask::CodingProviders::Codex::Adapter)

data/lib/ask/coding_providers/codex/app_server_client.rb

@@ -0,0 +1,261 @@
+# frozen_string_literal: true
+
+require "json"
+require "open3"
+
+module Ask
+  module CodingProviders
+    module Codex
+      # JSON-RPC 2.0 client for the Codex app-server (stdio transport).
+      #
+      # Protocol: https://learn.chatgpt.com/docs/app-server
+      #
+      # Spawns `codex app-server` as a subprocess and communicates over stdio
+      # using newline-delimited JSON.
+      class AppServerClient
+        CLI_PATHS = [
+          -> { ENV["CODEX_CLI_PATH"] },
+          -> { find_in_path("codex") },
+        ].freeze
+
+        attr_reader :cli_path
+
+        def initialize(cwd: ".", cli_path: nil, request_timeout: 30.0, model: nil, model_provider: nil)
+          @cwd = cwd
+          @cli_path = cli_path || self.class.resolve_cli_path
+          @request_timeout = request_timeout
+          @model = model
+          @model_provider = model_provider
+          @extra_args = build_extra_args
+          @mutex = Mutex.new
+          @stdin = nil
+          @event_handlers = []
+          @pending = {}
+          @next_id = 0
+          @started = false
+          @stdout_queue = Queue.new
+          @initialized = false
+        end
+
+        def start
+          @mutex.synchronize do
+            return if @started
+            @stdin, stdout, stderr, @wait_thr = Open3.popen3(@cli_path, "app-server", "--stdio", *@extra_args, chdir: @cwd)
+
+            @stdout_thread = Thread.new(stdout) do |io|
+              io.each_line do |line|
+                line = line.strip
+                @stdout_queue << line unless line.empty?
+              end
+              @stdout_queue << nil
+            end
+
+            # Drain stderr to avoid deadlocks
+            Thread.new(stderr) { |io| io.each_line { |_| } }
+
+            @dispatcher = Thread.new do
+              while (line = @stdout_queue.pop)
+                begin
+                  handle_message(JSON.parse(line))
+                rescue JSON::ParserError
+                end
+              end
+            rescue => e
+            end
+
+            @started = true
+          end
+        end
+
+        def stop
+          @mutex.synchronize do
+            return unless @started
+            @started = 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?
+          @started && @wait_thr&.alive?
+        end
+
+        def on_notification(&handler)
+          @mutex.synchronize { @event_handlers << handler }
+        end
+
+        # Perform the JSON-RPC initialize handshake.
+        # Must be called before any other request.
+        def initialize!
+          result = request("initialize", {
+            protocolVersion: "0.1.0",
+            clientInfo: { name: "askoda", version: "0.1.0" },
+            capabilities: {}
+          })
+          @initialized = true
+          result
+        end
+
+        def send_initialized
+          return unless @initialized
+          # The 'initialized' notification is a JSON-RPC 2.0 notification (no id)
+          @mutex.synchronize do
+            write_line({ jsonrpc: "2.0", method: "initialized", params: {} })
+          end
+        end
+
+        # -- High-level API --
+
+        def thread_start(cwd: nil)
+          ensure_initialized
+          params = {
+            cwd: cwd || @cwd,
+            approvalPolicy: "never",
+            sandbox: "read-only"
+          }
+          result = request("thread/start", params)
+          result&.dig("thread") || result&.dig(:thread) || {}
+        end
+
+        def thread_resume(thread_id)
+          ensure_initialized
+          request("thread/resume", { threadId: thread_id })
+        end
+
+        def turn_start(thread_id, input)
+          ensure_initialized
+          input_items = input.is_a?(Array) ? input : [{ type: "text", text: input.to_s }]
+          request("turn/start", {
+            threadId: thread_id,
+            input: input_items,
+            cwd: @cwd
+          })
+        end
+
+        def thread_list(limit: 20)
+          ensure_initialized
+          request("thread/list", { limit: limit })
+        end
+
+        def read_workspace_state
+          ensure_initialized
+          request("config/read", {})
+        end
+
+        def model_list
+          ensure_initialized
+          request("model/list", {})
+        end
+
+        def respond(request_id, result)
+          ensure_initialized
+          @mutex.synchronize { write_line({ id: request_id, result: result }) }
+        end
+
+        def request(method, params = nil, timeout: nil)
+          ensure_running
+          future = { done: false, result: nil, error: nil, condition: ConditionVariable.new }
+
+          @mutex.synchronize do
+            @next_id += 1
+            @pending[@next_id] = future
+            write_line({ jsonrpc: "2.0", id: @next_id, method: method, params: params }.compact)
+          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
+
+        def self.resolve_cli_path
+          CLI_PATHS.each do |resolver|
+            path = resolver.call
+            return path if path && File.exist?(path)
+          end
+          # Check the npm global install path
+          npm_path = File.expand_path("~/.asdf/installs/nodejs/*/lib/node_modules/@openai/codex/bin/codex.js")
+          Dir[npm_path].each { |p| return p if File.exist?(p) }
+          raise Error, "Cannot find Codex CLI. Set CODEX_CLI_PATH or install Codex."
+        end
+
+        private
+
+        def build_extra_args
+          args = []
+          args += ["-c", "model=#{@model}"] if @model
+          args += ["-c", "model_provider=#{@model_provider}"] if @model_provider
+          args
+        end
+
+        def ensure_running
+          raise Error, "app-server is not running. Call #start first." unless running?
+        end
+
+        def ensure_initialized
+          ensure_running
+          raise Error, "Not initialized. Call #initialize! first." unless @initialized
+        end
+
+        def write_line(msg)
+          @stdin&.puts(JSON.generate(msg))
+          @stdin&.flush
+        end
+
+        def handle_message(msg)
+          if msg.key?("id")
+            rid = msg["id"]
+            future = nil
+            @mutex.synchronize { future = @pending.delete(rid) }
+
+            if future
+              @mutex.synchronize do
+                if msg.key?("error")
+                  future[:error] = Error.new("[#{msg["error"]["code"]}] #{msg["error"]["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
+
+            dispatch_notification(msg["method"], msg["params"] || {}, msg["id"]) if msg.key?("method")
+            return
+          end
+
+          dispatch_notification(msg["method"], msg["params"] || {}, nil) if msg.key?("method")
+        end
+
+        def dispatch_notification(method, params, request_id)
+          @event_handlers.dup.each { |h| h.call(method, params, request_id) rescue nil }
+        end
+
+        def self.find_in_path(executable)
+          ENV["PATH"].to_s.split(File::PATH_SEPARATOR).each do |dir|
+            path = File.join(dir, executable)
+            return path if File.exist?(path)
+          end
+          nil
+        end
+      end
+    end
+  end
+end