rubyn-code 0.1.0

data/lib/rubyn_code/tasks/dag.rb

@@ -0,0 +1,208 @@
+# frozen_string_literal: true
+
+require "set"
+
+module RubynCode
+  module Tasks
+    # Directed acyclic graph tracking task dependencies.
+    # Backed by a SQLite table for persistence; keeps an in-memory
+    # adjacency list for fast traversal.
+    class DAG
+      # @param db [DB::Connection]
+      def initialize(db)
+        @db = db
+        @forward  = Hash.new { |h, k| h[k] = Set.new } # task_id -> depends_on ids
+        @reverse  = Hash.new { |h, k| h[k] = Set.new } # task_id -> dependent ids
+        ensure_table
+        load_from_db
+      end
+
+      # Declares that +task_id+ depends on +depends_on_id+.
+      #
+      # @param task_id [String]
+      # @param depends_on_id [String]
+      # @raise [ArgumentError] if this would create a cycle
+      # @return [void]
+      def add_dependency(task_id, depends_on_id)
+        raise ArgumentError, "A task cannot depend on itself" if task_id == depends_on_id
+        raise ArgumentError, "Cycle detected" if reachable?(depends_on_id, task_id)
+
+        return if @forward[task_id].include?(depends_on_id)
+
+        @db.execute(
+          "INSERT OR IGNORE INTO task_dependencies (task_id, depends_on_id) VALUES (?, ?)",
+          [task_id, depends_on_id]
+        )
+        @forward[task_id].add(depends_on_id)
+        @reverse[depends_on_id].add(task_id)
+      end
+
+      # Removes a dependency edge.
+      #
+      # @param task_id [String]
+      # @param depends_on_id [String]
+      # @return [void]
+      def remove_dependency(task_id, depends_on_id)
+        @db.execute(
+          "DELETE FROM task_dependencies WHERE task_id = ? AND depends_on_id = ?",
+          [task_id, depends_on_id]
+        )
+        @forward[task_id].delete(depends_on_id)
+        @reverse[depends_on_id].delete(task_id)
+      end
+
+      # Returns the IDs of tasks that +task_id+ directly depends on.
+      #
+      # @param task_id [String]
+      # @return [Array<String>]
+      def dependencies_for(task_id)
+        @forward[task_id].to_a
+      end
+
+      # Returns the IDs of tasks that directly depend on +task_id+.
+      #
+      # @param task_id [String]
+      # @return [Array<String>]
+      def dependents_of(task_id)
+        @reverse[task_id].to_a
+      end
+
+      # Returns true if +task_id+ has any incomplete dependency.
+      #
+      # @param task_id [String]
+      # @return [Boolean]
+      def blocked?(task_id)
+        deps = @forward[task_id]
+        return false if deps.empty?
+
+        rows = @db.query(
+          "SELECT id FROM tasks WHERE id IN (#{placeholders(deps.size)}) AND status != 'completed'",
+          deps.to_a
+        ).to_a
+        !rows.empty?
+      end
+
+      # Called when a task is completed. Removes it as a blocker from
+      # every dependent, flipping dependents from 'blocked' to 'pending'
+      # when all their deps are met.
+      #
+      # @param completed_task_id [String]
+      # @return [Array<String>] IDs of tasks that were unblocked
+      def unblock_cascade(completed_task_id)
+        unblocked = []
+
+        dependents_of(completed_task_id).each do |dep_id|
+          next if blocked?(dep_id)
+
+          rows = @db.query("SELECT status FROM tasks WHERE id = ?", [dep_id]).to_a
+          next if rows.empty?
+
+          current_status = rows.first["status"]
+          next unless current_status == "blocked"
+
+          @db.execute(
+            "UPDATE tasks SET status = 'pending', updated_at = datetime('now') WHERE id = ?",
+            [dep_id]
+          )
+          unblocked << dep_id
+        end
+
+        unblocked
+      end
+
+      # Returns all known task IDs in a valid execution order (dependencies first).
+      #
+      # @return [Array<String>]
+      # @raise [RuntimeError] if the graph contains a cycle
+      def topological_sort
+        in_degree = Hash.new(0)
+        all_nodes = Set.new
+
+        @forward.each do |task_id, deps|
+          all_nodes.add(task_id)
+          deps.each do |dep_id|
+            all_nodes.add(dep_id)
+            in_degree[dep_id] # touch to initialize
+            in_degree[task_id] += 1 # task_id depends on dep_id, so task_id has higher in-degree
+          end
+        end
+
+        # Nodes with no dependencies come first
+        # Note: in our graph, forward[task_id] = set of tasks task_id depends ON,
+        # so the "edges" for topological sort point from dep -> task_id.
+        in_degree_corrected = Hash.new(0)
+        all_nodes.each { |n| in_degree_corrected[n] = 0 }
+
+        @forward.each do |task_id, deps|
+          # task_id depends on each dep, meaning dep must come before task_id
+          in_degree_corrected[task_id] += deps.size
+        end
+
+        queue = all_nodes.select { |n| in_degree_corrected[n].zero? }
+        sorted = []
+
+        until queue.empty?
+          node = queue.shift
+          sorted << node
+
+          @reverse[node].each do |dependent|
+            in_degree_corrected[dependent] -= 1
+            queue << dependent if in_degree_corrected[dependent].zero?
+          end
+        end
+
+        if sorted.size != all_nodes.size
+          raise "Cycle detected in task dependency graph"
+        end
+
+        sorted
+      end
+
+      private
+
+      def ensure_table
+        @db.execute(<<~SQL)
+          CREATE TABLE IF NOT EXISTS task_dependencies (
+            task_id    TEXT NOT NULL,
+            depends_on_id TEXT NOT NULL,
+            PRIMARY KEY (task_id, depends_on_id),
+            FOREIGN KEY (task_id)       REFERENCES tasks(id) ON DELETE CASCADE,
+            FOREIGN KEY (depends_on_id) REFERENCES tasks(id) ON DELETE CASCADE
+          )
+        SQL
+      end
+
+      def load_from_db
+        rows = @db.query("SELECT task_id, depends_on_id FROM task_dependencies").to_a
+        rows.each do |row|
+          tid = row["task_id"]
+          did = row["depends_on_id"]
+          @forward[tid].add(did)
+          @reverse[did].add(tid)
+        end
+      end
+
+      # Checks if +target+ is reachable from +source+ following forward edges.
+      def reachable?(source, target)
+        visited = Set.new
+        stack = [source]
+
+        until stack.empty?
+          node = stack.pop
+          next if visited.include?(node)
+
+          return true if node == target
+
+          visited.add(node)
+          @forward[node].each { |dep| stack << dep }
+        end
+
+        false
+      end
+
+      def placeholders(count)
+        (["?"] * count).join(", ")
+      end
+    end
+  end
+end

data/lib/rubyn_code/tasks/manager.rb

@@ -0,0 +1,212 @@
+# frozen_string_literal: true
+
+require "securerandom"
+require_relative "models"
+require_relative "dag"
+
+module RubynCode
+  module Tasks
+    # CRUD manager for tasks backed by SQLite.
+    class Manager
+      attr_reader :db
+
+      # @param db [DB::Connection]
+      def initialize(db)
+        @db = db
+        ensure_table
+        @dag = DAG.new(db)
+      end
+
+      # Creates a new task and persists it.
+      #
+      # @param title [String]
+      # @param description [String, nil]
+      # @param session_id [String, nil]
+      # @param blocked_by [Array<String>] IDs of tasks this one depends on
+      # @param priority [Integer]
+      # @return [Task]
+      def create(title:, description: nil, session_id: nil, blocked_by: [], priority: 0)
+        id = SecureRandom.uuid
+        now = Time.now.utc.strftime("%Y-%m-%d %H:%M:%S")
+        status = blocked_by.empty? ? "pending" : "blocked"
+
+        @db.transaction do
+          @db.execute(<<~SQL, [id, session_id, title, description, status, priority, now, now])
+            INSERT INTO tasks (id, session_id, title, description, status, priority, created_at, updated_at)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+          SQL
+
+          blocked_by.each do |dep_id|
+            @dag.add_dependency(id, dep_id)
+          end
+        end
+
+        get(id)
+      end
+
+      # Updates arbitrary attributes on a task.
+      #
+      # @param id [String]
+      # @param attrs [Hash] supported keys: status, priority, owner, result, description, title, metadata
+      # @return [Task]
+      def update(id, **attrs)
+        allowed = %i[status priority owner result description title metadata]
+        filtered = attrs.select { |k, _| allowed.include?(k) }
+        return get(id) if filtered.empty?
+
+        sets = filtered.map { |k, _| "#{k} = ?" }
+        sets << "updated_at = datetime('now')"
+        values = filtered.values
+        values << id
+
+        @db.execute(
+          "UPDATE tasks SET #{sets.join(', ')} WHERE id = ?",
+          values
+        )
+
+        get(id)
+      end
+
+      # Marks a task as completed and cascades unblocking via the DAG.
+      #
+      # @param id [String]
+      # @param result [String, nil]
+      # @return [Task]
+      def complete(id, result: nil)
+        sets = ["status = 'completed'", "updated_at = datetime('now')"]
+        values = []
+
+        if result
+          sets << "result = ?"
+          values << result
+        end
+
+        values << id
+
+        @db.execute(
+          "UPDATE tasks SET #{sets.join(', ')} WHERE id = ?",
+          values
+        )
+
+        @dag.unblock_cascade(id)
+
+        get(id)
+      end
+
+      # Claims a task by setting the owner and moving it to in_progress.
+      #
+      # @param id [String]
+      # @param owner [String]
+      # @return [Task]
+      def claim(id, owner:)
+        @db.execute(
+          "UPDATE tasks SET owner = ?, status = 'in_progress', updated_at = datetime('now') WHERE id = ?",
+          [owner, id]
+        )
+
+        get(id)
+      end
+
+      # Fetches a single task by ID.
+      #
+      # @param id [String]
+      # @return [Task, nil]
+      def get(id)
+        rows = @db.query("SELECT * FROM tasks WHERE id = ?", [id]).to_a
+        row_to_task(rows.first)
+      end
+
+      # Lists tasks with optional filters.
+      #
+      # @param status [String, nil]
+      # @param session_id [String, nil]
+      # @return [Array<Task>]
+      def list(status: nil, session_id: nil)
+        conditions = []
+        params = []
+
+        if status
+          conditions << "status = ?"
+          params << status
+        end
+
+        if session_id
+          conditions << "session_id = ?"
+          params << session_id
+        end
+
+        sql = "SELECT * FROM tasks"
+        sql += " WHERE #{conditions.join(' AND ')}" unless conditions.empty?
+        sql += " ORDER BY priority DESC, created_at ASC"
+
+        @db.query(sql, params).to_a.filter_map { |row| row_to_task(row) }
+      end
+
+      # Returns tasks that are pending, unowned, and have no unmet dependencies.
+      #
+      # @return [Array<Task>]
+      def ready_tasks
+        rows = @db.query(
+          "SELECT * FROM tasks WHERE status = 'pending' AND owner IS NULL ORDER BY priority DESC, created_at ASC"
+        ).to_a
+
+        rows.filter_map { |row| row_to_task(row) }
+            .reject { |task| @dag.blocked?(task.id) }
+      end
+
+      # Deletes a task and its dependency edges (via CASCADE).
+      #
+      # @param id [String]
+      # @return [void]
+      def delete(id)
+        @db.execute("DELETE FROM tasks WHERE id = ?", [id])
+      end
+
+      private
+
+      def ensure_table
+        @db.execute(<<~SQL)
+          CREATE TABLE IF NOT EXISTS tasks (
+            id          TEXT PRIMARY KEY,
+            session_id  TEXT,
+            title       TEXT NOT NULL,
+            description TEXT,
+            status      TEXT NOT NULL DEFAULT 'pending',
+            priority    INTEGER NOT NULL DEFAULT 0,
+            owner       TEXT,
+            result      TEXT,
+            metadata    TEXT,
+            created_at  TEXT NOT NULL,
+            updated_at  TEXT NOT NULL
+          )
+        SQL
+
+        @db.execute(<<~SQL)
+          CREATE INDEX IF NOT EXISTS idx_tasks_status ON tasks(status)
+        SQL
+
+        @db.execute(<<~SQL)
+          CREATE INDEX IF NOT EXISTS idx_tasks_session ON tasks(session_id)
+        SQL
+      end
+
+      def row_to_task(row)
+        return nil if row.nil?
+
+        Task.new(
+          id:          row["id"],
+          session_id:  row["session_id"],
+          title:       row["title"],
+          description: row["description"],
+          status:      row["status"],
+          priority:    row["priority"],
+          owner:       row["owner"],
+          result:      row["result"],
+          metadata:    row["metadata"],
+          created_at:  row["created_at"],
+          updated_at:  row["updated_at"]
+        )
+      end
+    end
+  end
+end

data/lib/rubyn_code/tasks/models.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module Tasks
+    Task = Data.define(
+      :id, :session_id, :title, :description, :status,
+      :priority, :owner, :result, :metadata, :created_at, :updated_at
+    ) do
+      def pending? = status == "pending"
+      def in_progress? = status == "in_progress"
+      def completed? = status == "completed"
+      def blocked? = status == "blocked"
+
+      def to_h
+        {
+          id: id,
+          session_id: session_id,
+          title: title,
+          description: description,
+          status: status,
+          priority: priority,
+          owner: owner,
+          result: result,
+          metadata: metadata,
+          created_at: created_at,
+          updated_at: updated_at
+        }
+      end
+    end
+  end
+end

data/lib/rubyn_code/teams/mailbox.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require "json"
+require "securerandom"
+
+module RubynCode
+  module Teams
+    # JSONL-based mailbox for inter-agent messaging backed by SQLite.
+    #
+    # Messages are stored in the `mailbox_messages` table with structured
+    # JSON content. Each message tracks read/unread state per recipient.
+    class Mailbox
+      # @param db [DB::Connection] the database connection
+      def initialize(db)
+        @db = db
+        ensure_table!
+      end
+
+      # Sends a message from one agent to another.
+      #
+      # @param from [String] sender agent name
+      # @param to [String] recipient agent name
+      # @param content [String] message body
+      # @param message_type [String] type of message (default: "message")
+      # @return [String] the message id
+      def send(from:, to:, content:, message_type: "message")
+        id = SecureRandom.uuid
+        now = Time.now.utc.iso8601
+
+        payload = JSON.generate({
+          id: id,
+          from: from,
+          to: to,
+          content: content,
+          message_type: message_type,
+          timestamp: now
+        })
+
+        @db.execute(
+          <<~SQL,
+            INSERT INTO mailbox_messages (id, sender, recipient, message_type, payload, read, created_at)
+            VALUES (?, ?, ?, ?, ?, 0, ?)
+          SQL
+          [id, from, to, message_type, payload, now]
+        )
+
+        id
+      end
+
+      # Reads all unread messages for the given agent and marks them as read.
+      #
+      # @param name [String] the recipient agent name
+      # @return [Array<Hash>] parsed message hashes
+      def read_inbox(name)
+        rows = @db.query(
+          <<~SQL,
+            SELECT id, payload FROM mailbox_messages
+            WHERE recipient = ? AND read = 0
+            ORDER BY created_at ASC
+          SQL
+          [name]
+        ).to_a
+
+        return [] if rows.empty?
+
+        ids = rows.map { |r| r["id"] }
+        messages = rows.map { |r| JSON.parse(r["payload"], symbolize_names: true) }
+
+        # Mark all fetched messages as read in a single statement
+        placeholders = ids.map { "?" }.join(", ")
+        @db.execute(
+          "UPDATE mailbox_messages SET read = 1 WHERE id IN (#{placeholders})",
+          ids
+        )
+
+        messages
+      end
+
+      # Broadcasts a message from one agent to all other agents.
+      #
+      # @param from [String] sender agent name
+      # @param content [String] message body
+      # @param all_names [Array<String>] list of all agent names in the team
+      # @return [Array<String>] message ids
+      def broadcast(from:, content:, all_names:)
+        recipients = all_names.reject { |n| n == from }
+
+        recipients.map do |recipient|
+          send(from: from, to: recipient, content: content, message_type: "broadcast")
+        end
+      end
+
+      # Returns the count of unread messages for the given agent.
+      #
+      # @param name [String] the recipient agent name
+      # @return [Integer]
+      def unread_count(name)
+        rows = @db.query(
+          "SELECT COUNT(*) AS cnt FROM mailbox_messages WHERE recipient = ? AND read = 0",
+          [name]
+        ).to_a
+        rows.first&.fetch("cnt", 0) || 0
+      end
+
+      private
+
+      # Creates the mailbox_messages table if it does not already exist.
+      def ensure_table!
+        @db.execute(<<~SQL)
+          CREATE TABLE IF NOT EXISTS mailbox_messages (
+            id TEXT PRIMARY KEY,
+            sender TEXT NOT NULL,
+            recipient TEXT NOT NULL,
+            message_type TEXT NOT NULL DEFAULT 'message',
+            payload TEXT NOT NULL,
+            read INTEGER NOT NULL DEFAULT 0,
+            created_at TEXT NOT NULL
+          )
+        SQL
+
+        @db.execute(<<~SQL)
+          CREATE INDEX IF NOT EXISTS idx_mailbox_recipient_read
+          ON mailbox_messages (recipient, read)
+        SQL
+      end
+    end
+  end
+end