ask-coding-harness 0.1.0

data/lib/ask/coding_harness/server.rb

@@ -0,0 +1,319 @@
+# frozen_string_literal: true
+
+require "roda"
+require "json"
+require "fileutils"
+
+module Ask
+  module CodingHarness
+    # HTTP API + static file server for the coding harness.
+    #
+    # Endpoints:
+    #   GET  /api/config          — models, adapter, workspace, features
+    #   GET  /api/workspace       — workspace name, root, git branch
+    #   GET  /api/conversations   — list conversations (archived filter)
+    #   GET  /api/conversations/:id         — conversation with messages
+    #   PATCH /api/conversations/:id        — rename
+    #   DELETE /api/conversations/:id       — delete
+    #   POST /api/conversations/:id/archive — toggle archive
+    #   PATCH/DELETE /api/conversations/:id/messages/:index — edit/trim
+    #   POST /api/chat            — send a message, stream events via SSE
+    #   POST /api/conversations/:id/approvals/:actionId/approve|reject
+    #   POST /api/conversations/:id/approvals/approve-all
+    #   POST /api/conversations/:id/plan/approve|reject
+    #   POST /api/conversations/:id/abort
+    #   GET  /*                   — static frontend (PWA), SPA fallback
+    class Server < Roda
+      # Built frontend (PWA). Shipped inside the gem.
+      def self.public_dir
+        File.expand_path("../../../public", __dir__)
+      end
+
+      plugin :default_headers, {
+        "Access-Control-Allow-Origin" => "*",
+        "Access-Control-Allow-Methods" => "GET, POST, PATCH, DELETE, OPTIONS",
+        "Access-Control-Allow-Headers" => "Content-Type"
+      }
+      plugin :error_handler do |e|
+        if env["PATH_INFO"]&.start_with?("/api/")
+          response.status = 500
+          { error: e.message }.to_json
+        else
+          raise e
+        end
+      end
+      plugin :public, root: public_dir
+      plugin :streaming
+
+      # Build a server instance wired to the given components. Tests build
+      # servers with fakes; the CLI builds with the real store + runner.
+      #
+      # @param config [Config]
+      # @param store [Store]
+      # @param runner [AgentRunner]
+      def self.build(config:, store:, runner:)
+        Class.new(self) do
+          define_method(:harness_config) { config }
+          define_method(:harness_store) { store }
+          define_method(:harness_runner) { runner }
+        end
+      end
+
+      route do |r|
+        # CORS preflight
+        if r.request_method == "OPTIONS"
+          response.status = 204
+          next
+        end
+
+        r.on "api" do
+          # GET /api/config — models, adapter, workspace, features
+          r.get "config" do
+            cfg = harness_config
+            {
+              models: models,
+              defaultModel: cfg.model,
+              currentAdapter: cfg.adapter,
+              workspace: workspace_info,
+              features: {
+                approvals: cfg.approvals?,
+                planMode: cfg.plan_mode,
+                todos: cfg.todos
+              }
+            }.to_json
+          end
+
+          # GET /api/workspace — name, root, git branch
+          r.get "workspace" do
+            workspace_info.to_json
+          end
+
+          # POST /api/chat — streaming turn
+          r.post "chat" do
+            body = JSON.parse(r.body.read)
+            input = body["message"].to_s.strip
+            conversation_id = body["conversation_id"]
+            model = body["model"]
+
+            if input.empty?
+              response.status = 400
+              next { error: "message is required" }.to_json
+            end
+
+            store = harness_store
+            existing = conversation_id && store.load(conversation_id)
+            conversation = existing || store.build(directory: harness_config.workspace)
+            new_conversation = existing.nil?
+            conversation = store.save(conversation) if new_conversation
+
+            response.headers["Content-Type"] = "text/event-stream"
+            response.headers["Cache-Control"] = "no-cache"
+            response.headers["Connection"] = "keep-alive"
+
+            stream do |out|
+              out << "event: conversation.created\ndata: #{conversation["id"]}\n\n" if new_conversation
+
+              out << "event: turn.started\ndata: {}\n\n"
+              harness_runner.start_turn(conversation, input, model: model) do |ev|
+                begin
+                  out << "event: #{ev[:type]}\ndata: #{JSON.generate(ev[:data])}\n\n"
+                rescue IOError, Errno::EPIPE, Errno::ECONNRESET
+                  # Client disconnected — the turn keeps running and the
+                  # outcome is persisted by the runner.
+                end
+              end.join
+            end
+          end
+
+          # GET /api/conversations
+          r.get "conversations" do
+            harness_store.list(archived: r.params["archived"] == "true").to_json
+          end
+
+          r.on "conversations", String do |id|
+            store = harness_store
+
+            # GET /api/conversations/:id
+            r.get do
+              conv = store.load(id)
+              if conv
+                conv.to_json
+              else
+                response.status = 404
+                { error: "Conversation not found" }.to_json
+              end
+            end
+
+            # PATCH /api/conversations/:id — rename
+            r.is method: :patch do
+              body = JSON.parse(r.body.read)
+              title = body["title"].to_s.strip
+              if title.empty?
+                response.status = 400
+                next { error: "title is required" }.to_json
+              end
+              conv = store.load(id)
+              unless conv
+                response.status = 404
+                next { error: "Conversation not found" }.to_json
+              end
+              conv["title"] = title
+              store.save(conv)
+              { id: id, title: title }.to_json
+            end
+
+            # DELETE /api/conversations/:id
+            r.is method: :delete do
+              store.delete(id)
+              { deleted: true }.to_json
+            end
+
+            # POST /api/conversations/:id/archive
+            r.post "archive" do
+              conv = store.load(id)
+              unless conv
+                response.status = 404
+                next { error: "Conversation not found" }.to_json
+              end
+              conv["archived"] = !conv["archived"]
+              store.save(conv)
+              { id: id, archived: conv["archived"] }.to_json
+            end
+
+            # POST /api/conversations/:id/abort
+            r.post "abort" do
+              harness_runner.abort(id)
+              { aborted: true }.to_json
+            end
+
+            # ── Approvals ──
+            r.on "approvals" do
+              # POST /api/conversations/:id/approvals/approve-all
+              r.post "approve-all" do
+                harness_runner.approve_all(id)
+                { approved: true }.to_json
+              end
+
+              r.on Integer do |action_id|
+                r.post "approve" do
+                  harness_runner.approve(id, action_id)
+                  { approved: true }.to_json
+                end
+                r.post "reject" do
+                  harness_runner.reject(id, action_id)
+                  { rejected: true }.to_json
+                end
+              end
+            end
+
+            # ── Plan ──
+            r.on "plan" do
+              r.post "approve" do
+                harness_runner.approve_plan(id)
+                { approved: true }.to_json
+              end
+              r.post "reject" do
+                harness_runner.reject_plan(id)
+                { rejected: true }.to_json
+              end
+            end
+
+            # ── Messages ──
+            r.on "messages", Integer do |index|
+              # PATCH /api/conversations/:id/messages/:index — edit a user message
+              r.on method: :patch do
+                body = JSON.parse(r.body.read)
+                content = body["content"].to_s.strip
+                if content.empty?
+                  response.status = 400
+                  next { error: "content is required" }.to_json
+                end
+                conv = store.load(id)
+                unless conv
+                  response.status = 404
+                  next { error: "Conversation not found" }.to_json
+                end
+                msg = conv["messages"][index]
+                unless msg
+                  response.status = 404
+                  next { error: "Message not found" }.to_json
+                end
+                if msg["role"] != "user"
+                  response.status = 400
+                  next { error: "Only user messages can be edited" }.to_json
+                end
+                msg["content"] = content
+                store.save(conv)
+                conv.to_json
+              end
+
+              # DELETE /api/conversations/:id/messages/:index — trim from here
+              r.on method: :delete do
+                conv = store.load(id)
+                unless conv
+                  response.status = 404
+                  next { error: "Conversation not found" }.to_json
+                end
+                if index >= conv["messages"].length
+                  response.status = 404
+                  next { error: "Message not found" }.to_json
+                end
+                conv["messages"] = conv["messages"][0...index]
+                store.save(conv)
+                conv.to_json
+              end
+            end
+          end
+        end
+
+        # ── Static files (PWA frontend) ──
+        r.public
+        # SPA fallback: serve index.html for unmatched GET requests
+        r.get do
+          file = File.join(self.class.public_dir, "index.html")
+          if File.exist?(file)
+            response["Content-Type"] = "text/html"
+            File.read(file)
+          end
+        end
+      end
+
+      private
+
+      def harness_config
+        raise NotImplementedError, "built via Server.build"
+      end
+
+      def harness_store
+        raise NotImplementedError, "built via Server.build"
+      end
+
+      def harness_runner
+        raise NotImplementedError, "built via Server.build"
+      end
+
+      def workspace_info
+        cfg = harness_config
+        root = cfg.workspace
+        branch = nil
+        head = File.join(root, ".git", "HEAD")
+        if File.file?(head)
+          ref = File.read(head).strip
+          branch = ref.split("/").last if ref.start_with?("ref:")
+        end
+        { name: File.basename(root), root: root, gitBranch: branch }
+      rescue SystemCallError
+        { name: File.basename(root), root: root, gitBranch: nil }
+      end
+
+      def models
+        env_models = ENV["ACH_MODELS"]
+        if env_models&.length&.positive?
+          env_models.split(",").map(&:strip)
+        else
+          ["deepseek-v4-flash", "claude-sonnet-4", "gpt-4o", "o3-mini"]
+        end
+      end
+    end
+  end
+end

data/lib/ask/coding_harness/store.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require "securerandom"
+require "fileutils"
+
+module Ask
+  module CodingHarness
+    # Persistence for conversations, backed by ask-state-providers (SQLite).
+    #
+    # A conversation is a plain Hash with string keys:
+    #   id, title, directory, archived, messages, created_at, updated_at
+    #
+    # Messages are { "role" => "user"|"assistant", "content" => String,
+    # "created_at" => String } hashes. The store is the single owner of
+    # conversation records; the server and runner only read/write through it.
+    class Store
+      CONVERSATIONS_KEY = "__conversations__"
+      MAX_CONVERSATIONS = 500
+
+      # @param db_path [String] path to the SQLite database file
+      def initialize(db_path:)
+        @db_path = db_path
+        dir = File.dirname(db_path)
+        FileUtils.mkdir_p(dir) unless File.directory?(dir)
+      end
+
+      # A fresh conversation record. Not persisted until {#save}.
+      def build(directory: nil, title: "New conversation")
+        now = Time.now.iso8601
+        {
+          "id" => SecureRandom.uuid,
+          "title" => title,
+          "directory" => directory,
+          "archived" => false,
+          "messages" => [],
+          "created_at" => now,
+          "updated_at" => now
+        }
+      end
+
+      # Persist a conversation, bumping updated_at and guessing a title when
+      # the conversation is still untitled and has messages.
+      def save(conv)
+        conv["updated_at"] = Time.now.iso8601
+        if conv["title"] == "New conversation" && conv["messages"].length >= 1
+          conv["title"] = guess_title(conv["messages"])
+        end
+        db.set("conv:#{conv["id"]}", conv)
+        index_conversation(conv["id"])
+        conv
+      end
+
+      # Load a conversation by id, or nil when missing.
+      def load(id)
+        data = db.get("conv:#{id}")
+        data&.transform_keys(&:to_s)
+      end
+
+      def delete(id)
+        db.delete("conv:#{id}")
+        db.list_remove(CONVERSATIONS_KEY, id)
+      end
+
+      # Conversation summaries (no messages), sorted by most recent first.
+      def list(archived: false)
+        ids = db.list_range(CONVERSATIONS_KEY, 0, -1)
+        summaries = ids.filter_map do |id|
+          data = db.get("conv:#{id}")
+          next unless data
+          next if data["archived"] == true && !archived
+          summary(data)
+        end
+        summaries.sort_by { |c| c["updated_at"].to_s }.reverse
+      end
+
+      # Summaries for one workspace directory, most recent first.
+      def list_for_directory(directory, archived: false)
+        list(archived: archived).select { |c| c["directory"] == directory }
+      end
+
+      # Workspace directories that have conversations, with counts.
+      def projects(archived: false)
+        list(archived: archived).each_with_object(Hash.new(0)) do |c, counts|
+          dir = c["directory"]
+          counts[dir] += 1 if dir
+        end.map { |dir, count| { "directory" => dir, "name" => File.basename(dir), "conversation_count" => count } }
+      end
+
+      def close
+        @db&.close
+        @db = nil
+      end
+
+      private
+
+      def db
+        @db ||= Ask::State::Providers::SQLite.new(path: @db_path)
+      end
+
+      def summary(data)
+        {
+          "id" => data["id"],
+          "title" => data["title"] || "New conversation",
+          "directory" => data["directory"],
+          "archived" => data["archived"] == true,
+          "message_count" => data["messages"]&.length || 0,
+          "created_at" => data["created_at"],
+          "updated_at" => data["updated_at"]
+        }
+      end
+
+      def guess_title(messages)
+        first = messages.find { |m| m["role"] == "user" }
+        text = (first && first["content"]).to_s
+        text.length > 40 ? text[0, 40] + "…" : text
+      end
+
+      # Append to the conversation index, skipping duplicates (saves happen
+      # on every message).
+      def index_conversation(id)
+        existing = db.list_range(CONVERSATIONS_KEY, 0, -1)
+        db.list_append(CONVERSATIONS_KEY, id, max_length: MAX_CONVERSATIONS) unless existing.include?(id)
+      end
+    end
+  end
+end

data/lib/ask/coding_harness/version.rb

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

data/lib/ask-coding-harness.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "ask/coding_harness/version"
+
+module Ask
+  # Ask Coding Harness — a general-purpose coding agent in the browser.
+  #
+  # Self-hosted web coding agent for the ask-rb ecosystem. Runs
+  # Ask::Agent::Session against any workspace, streams every event to a
+  # mobile-first PWA over SSE, and comes with an `ach` utility CLI for
+  # headless runs.
+  #
+  #   Ask::CodingHarness.configure do |c|
+  #     c.workspace = "/path/to/project"
+  #     c.model = "deepseek-v4-flash"
+  #   end
+  #
+  #   Ask::CodingHarness.run_server
+  module CodingHarness
+    class << self
+      # Global configuration. See Config for available settings.
+      def config
+        @config ||= Config.new
+      end
+
+      # Configure the harness. Yields the global Config instance.
+      def configure
+        yield config if block_given?
+        config
+      end
+
+      # Run the web server (blocking). See CLI for the non-blocking path.
+      def run_server(host: nil, port: nil)
+        require_relative "ask/coding_harness/server"
+        require "rackup"
+
+        store = Store.new(db_path: config.db_path)
+        runner = AgentRunner.new(config: config, store: store)
+        app = Server.build(config: config, store: store, runner: runner).freeze.app
+        Rackup::Server.start(app: app, Host: host || config.host, Port: port || config.port)
+      end
+
+      # Run a prompt headlessly against the workspace and return the result.
+      #
+      # @param prompt [String] the task to run
+      # @param workspace [String, nil] overrides config.workspace
+      # @return [Ask::CodingHarness::Runner::Result]
+      def run(prompt, workspace: nil, **opts)
+        require_relative "ask/coding_harness/runner"
+        Runner.new(config: config).run(prompt, workspace: workspace, **opts)
+      end
+    end
+  end
+end
+
+require "ask-tools-shell"
+require "ask-state-providers"
+require "ask/coding_harness/config"
+require "ask/coding_harness/store"
+require "ask/coding_harness/event_translator"
+require "ask/coding_harness/agent_runner"
+require "ask/coding_harness/runner"