kward 0.75.0 → 0.77.0

data/lib/kward/workers/queue_runner.rb

@@ -1,166 +0,0 @@
-require_relative "../agent"
-require_relative "../config_files"
-require_relative "../model/client"
-require_relative "../tools/registry"
-require_relative "../workspace"
-require_relative "git_guard"
-require_relative "tool_policy"
-
-module Kward
-  module Workers
-    # Executes session-backed worker queue jobs one at a time.
-    class QueueRunner
-      CONTINUE_PROMPT = <<~PROMPT.freeze
-        Continue this session as an implementation worker.
-        Make the smallest correct change, preserve existing style, and run focused verification when practical.
-        Stop when the work is ready for human review.
-      PROMPT
-
-      def initialize(queue_store:, session_store:, client_factory: -> { Client.new }, prompt: nil, workspace_root: Dir.pwd, provider: nil, model: nil, reasoning_effort: nil, git_guard: nil, write_lock: nil)
-        @queue_store = queue_store
-        @session_store = session_store
-        @client_factory = client_factory
-        @prompt = prompt
-        @workspace_root = ConfigFiles.canonical_workspace_root(workspace_root)
-        @provider = provider
-        @model = model
-        @reasoning_effort = reasoning_effort
-        @git_guard = git_guard || GitGuard.new(root: @workspace_root)
-        @write_lock = write_lock
-      end
-
-      def run_next
-        record = @queue_store.next_queued
-        return nil unless record
-
-        run_job(record)
-      end
-
-      def run_all
-        results = []
-        loop do
-          record = run_next
-          break unless record
-
-          results << record
-          break unless record["status"] == "ready_for_review"
-        end
-        results
-      end
-
-      def suspend(id)
-        record = find_job(id)
-        raise ArgumentError, "Worker job #{id} is not running" unless record["status"] == "running"
-
-        stash_ref = stash_worker_changes(record)
-        @queue_store.update_status(record.fetch("id"), "suspended", stash_ref: stash_ref, error: "")
-      rescue StandardError => e
-        @queue_store.update_status(id, "blocked", error: e.message)
-      end
-
-      def resume(id)
-        record = find_job(id)
-        raise ArgumentError, "Worker job #{id} is not suspended" unless record["status"] == "suspended"
-
-        restore_worker_changes(record)
-        queued = @queue_store.update_status(record.fetch("id"), "queued", stash_ref: "", error: "")
-        run_job(queued, require_clean: false)
-      rescue DirtyWorkspaceError => e
-        @queue_store.update_status(id, "blocked", error: e.message)
-      rescue StandardError => e
-        @queue_store.update_status(id, "blocked", error: e.message)
-      end
-
-      private
-
-      def run_job(record, require_clean: true)
-        id = record.fetch("id")
-        ensure_clean_workspace!(record) if require_clean
-        @queue_store.update_status(id, "running", error: "")
-        session, conversation = load_job_session(record)
-        agent = Agent.new(client: @client_factory.call, tool_registry: tool_registry(record, id), conversation: conversation)
-        report = agent.ask(CONTINUE_PROMPT)
-        commit = commit_if_needed(record)
-        session.append_message({ role: "assistant", content: completion_report(report, commit) }) if commit
-        @queue_store.update_status(id, "ready_for_review", commit_sha: commit, error: "")
-      rescue DirtyWorkspaceError => e
-        @queue_store.update_status(id, "blocked", error: e.message)
-      rescue StandardError => e
-        @queue_store.update_status(id, "failed", error: e.message)
-      end
-
-      def ensure_clean_workspace!(record)
-        return unless @git_guard.repository?
-        return if @git_guard.clean?
-
-        raise DirtyWorkspaceError, "Workspace is dirty; clean or stash changes before running worker #{record.fetch('id')}"
-      end
-
-      def find_job(id)
-        @queue_store.find(id) || raise(ArgumentError, "Unknown worker job: #{id}")
-      end
-
-      def stash_worker_changes(record)
-        return "" unless @git_guard.repository?
-        return "" if @git_guard.clean?
-
-        result = @git_guard.stash("Kward worker #{record.fetch('id')}: #{record.fetch('title')}")
-        raise "Worker changes could not be stashed: #{result.output}" unless result.success?
-
-        result.commit.to_s
-      end
-
-      def restore_worker_changes(record)
-        ensure_clean_workspace!(record)
-        ref = record["stash_ref"].to_s
-        return if ref.empty?
-
-        apply = @git_guard.apply_stash(ref)
-        raise "Worker stash could not be restored: #{apply.output}" unless apply.success?
-
-        drop = @git_guard.drop_stash(ref)
-        raise "Worker stash could not be dropped: #{drop.output}" unless drop.success?
-      end
-
-      def load_job_session(record)
-        @session_store.load(
-          record.fetch("session_path"),
-          workspace: Workspace.new(root: record["workspace_root"] || @workspace_root),
-          provider: @provider,
-          model: @model,
-          reasoning_effort: @reasoning_effort
-        )
-      end
-
-      def tool_registry(record, writer_id)
-        ToolRegistry.new(
-          workspace: Workspace.new(root: record["workspace_root"] || @workspace_root),
-          prompt: @prompt,
-          allowed_tool_names: ToolPolicy.allowed_tool_names("implementation"),
-          write_lock: @write_lock,
-          writer_id: writer_id
-        )
-      end
-
-      def commit_if_needed(record)
-        return nil unless @git_guard.repository?
-        return nil if @git_guard.clean?
-
-        result = @git_guard.commit_all(commit_message(record))
-        raise "Worker changed files but commit failed: #{result.output}" unless result.success?
-
-        result.commit
-      end
-
-      def commit_message(record)
-        "Kward worker #{record.fetch('id')}: #{record.fetch('title')}"
-      end
-
-      def completion_report(report, commit)
-        [report, "", "Committed workspace changes: #{commit}"].join("\n")
-      end
-
-      class DirtyWorkspaceError < StandardError; end
-    end
-  end
-end

data/lib/kward/workers/queue_store.rb

@@ -1,112 +0,0 @@
-require "fileutils"
-require "json"
-require_relative "../config_files"
-require_relative "job"
-
-module Kward
-  module Workers
-    # JSON-backed queue store for session-backed worker jobs.
-    class QueueStore
-      def initialize(path: File.join(ConfigFiles.config_dir, "worker_queue.json"))
-        @path = path
-        @mutex = Mutex.new
-      end
-
-      attr_reader :path
-
-      def enqueue(title:, session_path:, workspace_root:, id: nil)
-        job = Job.new(
-          id: id || SecureRandom.hex(4),
-          title: title,
-          session_path: session_path,
-          workspace_root: workspace_root,
-          position: next_position
-        )
-        upsert(job)
-        job
-      end
-
-      def upsert(job)
-        record = job.respond_to?(:to_h) ? job.to_h : job.to_h
-        update_records do |records|
-          index = records.index { |item| item["id"] == record["id"] }
-          index ? records[index] = record : records << record
-          normalize_positions(records)
-        end
-        record
-      end
-
-      def list(include_archived: false)
-        records = read_records
-        records = records.reject { |record| record["status"] == "archived" } unless include_archived
-        sorted(records)
-      end
-
-      def find(id)
-        read_records.find { |record| record["id"] == id.to_s }
-      end
-
-      def update_status(id, status, **values)
-        record = nil
-        update_records do |records|
-          index = records.index { |item| item["id"] == id.to_s }
-          raise ArgumentError, "Unknown worker job: #{id}" unless index
-
-          job = Job.from_h(records[index])
-          job.update_status(status, **values)
-          record = job.to_h
-          records[index] = record
-          normalize_positions(records)
-        end
-        record
-      end
-
-      def archive(id)
-        update_status(id, "archived")
-      end
-
-      def next_queued
-        list.find { |record| record["status"] == "queued" }
-      end
-
-      private
-
-      def next_position
-        last = list(include_archived: true).map { |record| record["position"].to_i }.max
-        last ? last + 1 : 1
-      end
-
-      def read_records
-        @mutex.synchronize { read_records_unlocked }
-      end
-
-      def read_records_unlocked
-        return [] unless File.exist?(@path)
-
-        data = JSON.parse(File.read(@path))
-        data.is_a?(Array) ? data : []
-      rescue JSON::ParserError
-        raise "Invalid worker queue JSON: #{@path}"
-      end
-
-      def update_records
-        @mutex.synchronize do
-          records = read_records_unlocked
-          yield records
-          FileUtils.mkdir_p(File.dirname(@path))
-          File.write(@path, JSON.pretty_generate(sorted(records)) + "\n")
-        end
-      end
-
-      def sorted(records)
-        records.sort_by { |record| [record["position"].to_i, record["enqueued_at"].to_s, record["id"].to_s] }
-      end
-
-      def normalize_positions(records)
-        sorted(records).each_with_index do |record, index|
-          record["position"] = index + 1
-        end
-      end
-    end
-  end
-end

data/lib/kward/workers/store.rb

@@ -1,72 +0,0 @@
-require "fileutils"
-require "json"
-require_relative "../config_files"
-
-module Kward
-  module Workers
-    # JSON-backed metadata store for worker records.
-    class Store
-      def initialize(path: File.join(ConfigFiles.config_dir, "workers.json"))
-        @path = path
-        @mutex = Mutex.new
-      end
-
-      attr_reader :path
-
-      def upsert(worker)
-        record = worker.respond_to?(:to_h) ? worker.to_h : worker.to_h
-        update_records do |records|
-          index = records.index { |item| item["id"] == record["id"] }
-          index ? records[index] = record : records << record
-        end
-        record
-      end
-
-      def list(include_archived: false)
-        records = read_records
-        records = records.reject { |record| record["status"] == "archived" } unless include_archived
-        records.sort_by { |record| record["created_at"].to_s }
-      end
-
-      def find(id)
-        read_records.find { |record| record["id"] == id.to_s }
-      end
-
-      def archive(id)
-        record = nil
-        update_records do |records|
-          index = records.index { |item| item["id"] == id.to_s }
-          raise ArgumentError, "Unknown worker: #{id}" unless index
-
-          record = records[index].merge("status" => "archived")
-          records[index] = record
-        end
-        record
-      end
-
-      private
-
-      def read_records
-        @mutex.synchronize { read_records_unlocked }
-      end
-
-      def read_records_unlocked
-        return [] unless File.exist?(@path)
-
-        data = JSON.parse(File.read(@path))
-        data.is_a?(Array) ? data : []
-      rescue JSON::ParserError
-        raise "Invalid worker store JSON: #{@path}"
-      end
-
-      def update_records
-        @mutex.synchronize do
-          records = read_records_unlocked
-          yield records
-          FileUtils.mkdir_p(File.dirname(@path))
-          File.write(@path, JSON.pretty_generate(records) + "\n")
-        end
-      end
-    end
-  end
-end

data/lib/kward/workers/tool_policy.rb

@@ -1,23 +0,0 @@
-module Kward
-  module Workers
-    # Tool allowlists for worker roles.
-    module ToolPolicy
-      READ_ONLY_TOOLS = %w[list_directory read_file code_search summarize_file_structure retrieve_tool_output web_search fetch_content fetch_raw read_skill].freeze
-
-      module_function
-
-      def allowed_tool_names(role)
-        case role.to_s
-        when "request", "read_only"
-          READ_ONLY_TOOLS
-        else
-          nil
-        end
-      end
-
-      def write_capable?(role)
-        allowed_tool_names(role).nil?
-      end
-    end
-  end
-end

data/lib/kward/workers/worker.rb

@@ -1,82 +0,0 @@
-require "securerandom"
-require "time"
-require_relative "../config_files"
-require_relative "../cancellation"
-
-module Kward
-  module Workers
-    # Runtime record for one independent unit of agent work.
-    class Worker
-      STATUSES = %w[idle queued running ready failed cancelled archived].freeze
-
-      def initialize(id: SecureRandom.hex(4), title:, role:, workspace_root: Dir.pwd, status: "idle", prompt: nil, conversation: nil, session: nil, cancellation: Cancellation.new, created_at: Time.now.utc)
-        @id = id
-        @title = title.to_s
-        @role = role.to_s
-        @workspace_root = ConfigFiles.canonical_workspace_root(workspace_root)
-        @status = status.to_s
-        @prompt = prompt.to_s
-        @conversation = conversation
-        @session = session
-        @cancellation = cancellation
-        @created_at = created_at
-        @updated_at = created_at
-        @started_at = nil
-        @finished_at = nil
-        @report = nil
-        @error = nil
-        @thread = nil
-        @event_history = []
-        @event_queue = Queue.new
-      end
-
-      attr_reader :id, :title, :role, :workspace_root, :prompt, :conversation, :session, :cancellation, :created_at, :updated_at, :started_at, :finished_at, :report, :error, :thread, :event_history, :event_queue
-      attr_writer :conversation, :session, :thread
-
-      def status
-        @status
-      end
-
-      def update_status(status, error: nil, report: nil)
-        @status = status.to_s
-        @error = error unless error.nil?
-        @report = report unless report.nil?
-        now = Time.now.utc
-        @updated_at = now
-        @started_at ||= now if @status == "running"
-        @finished_at = now if %w[ready failed cancelled archived].include?(@status)
-        self
-      end
-
-      def record_event(event)
-        @event_history << event
-        @event_queue << event
-      end
-
-      def to_h
-        {
-          "id" => id,
-          "title" => title,
-          "role" => role,
-          "status" => status,
-          "prompt" => prompt,
-          "workspace_root" => workspace_root,
-          "session_id" => session&.id,
-          "session_path" => session&.path,
-          "created_at" => timestamp(created_at),
-          "updated_at" => timestamp(updated_at),
-          "started_at" => timestamp(started_at),
-          "finished_at" => timestamp(finished_at),
-          "report" => report,
-          "error" => error
-        }
-      end
-
-      private
-
-      def timestamp(value)
-        value&.utc&.iso8601(3)
-      end
-    end
-  end
-end

data/lib/kward/workers/write_lock.rb

@@ -1,38 +0,0 @@
-require "thread"
-
-module Kward
-  module Workers
-    # Cooperative ownership guard for workspace-mutating worker tools.
-    class WriteLock
-      def initialize
-        @owner_id = nil
-        @mutex = Mutex.new
-      end
-
-      attr_reader :owner_id
-
-      def acquire(owner_id)
-        owner = owner_id.to_s
-        return false if owner.empty?
-
-        @mutex.synchronize do
-          return true if @owner_id == owner
-          return false if @owner_id
-
-          @owner_id = owner
-          true
-        end
-      end
-
-      def owned_by?(owner_id)
-        @mutex.synchronize { @owner_id == owner_id.to_s }
-      end
-
-      def release(owner_id)
-        @mutex.synchronize do
-          @owner_id = nil if @owner_id == owner_id.to_s
-        end
-      end
-    end
-  end
-end

data/lib/kward/workers.rb

@@ -1,10 +0,0 @@
-require_relative "workers/git_guard"
-require_relative "workers/job"
-require_relative "workers/live_view"
-require_relative "workers/manager"
-require_relative "workers/queue_runner"
-require_relative "workers/queue_store"
-require_relative "workers/store"
-require_relative "workers/tool_policy"
-require_relative "workers/write_lock"
-require_relative "workers/worker"