kward 0.76.0 → 0.78.0

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"