100 lines
3.8 KiB
Ruby
100 lines
3.8 KiB
Ruby
require_relative "board_spec"
|
|
|
|
module Backlog
|
|
# Card-level operations over an authenticated Planka client: create a
|
|
# card at Backlog (the only column the AI ever creates into), and build
|
|
# a read-only board snapshot (lists with their cards, labels, card-label
|
|
# assignments) for the list skill and the triage/audit agents.
|
|
#
|
|
# Never moves cards between columns and never deletes anything.
|
|
class Cards
|
|
# @param client [Planka::Client] an already-authenticated client
|
|
def initialize(client:)
|
|
@client = client
|
|
end
|
|
|
|
# Create a card at the board's Backlog list. Raises if the board or
|
|
# its Backlog list doesn't exist (callers run board-ensure first).
|
|
#
|
|
# @return [Hash] the created card
|
|
def add(board_name:, title:, description: nil)
|
|
board = find_board!(board_name)
|
|
backlog = find_list!(board, "Backlog")
|
|
attrs = { name: title, type: "project", position: next_position(board, backlog) }
|
|
attrs[:description] = description if description
|
|
@client.cards.create(backlog["id"], attrs)
|
|
end
|
|
|
|
# Read-only snapshot of a whole board: every list in BoardSpec order
|
|
# (plus any extras), each with its cards and their label names.
|
|
#
|
|
# @return [Hash] { "board" => name, "labels" => [names],
|
|
# "lists" => [{ "name", "cards" => [{card fields + "labels"}] }] }
|
|
def snapshot(board_name:)
|
|
board = find_board!(board_name)
|
|
included = @client.boards.get(board["id"])["included"]
|
|
labels_by_id = (included["labels"] || []).to_h { |l| [l["id"], l["name"]] }
|
|
card_labels = (included["cardLabels"] || []).group_by { |cl| cl["cardId"] }
|
|
cards_by_list = (included["cards"] || []).group_by { |c| c["listId"] }
|
|
|
|
lists = (included["lists"] || [])
|
|
.select { |l| l["name"] } # skip built-in archive/trash lists (name: null)
|
|
.sort_by { |l| l["position"] || Float::INFINITY }
|
|
.map do |list|
|
|
cards = (cards_by_list[list["id"]] || []).map do |card|
|
|
label_names = (card_labels[card["id"]] || []).filter_map { |cl| labels_by_id[cl["labelId"]] }
|
|
card.merge("labels" => label_names)
|
|
end
|
|
{ "name" => list["name"], "cards" => cards }
|
|
end
|
|
|
|
{ "board" => board["name"], "labels" => labels_by_id.values, "lists" => lists }
|
|
end
|
|
|
|
# Attach a board label (by name) to a card. The only card mutation the
|
|
# triage agent is allowed — label changes, never column moves.
|
|
#
|
|
# @return [Hash] the card-label join record
|
|
def attach_label(board_name:, card_id:, label:)
|
|
board = find_board!(board_name)
|
|
record = @client.labels.list(board["id"]).find { |l| l["name"] == label }
|
|
raise "board #{board_name.inspect} has no label #{label.inspect} (run board-ensure)" unless record
|
|
|
|
@client.labels.attach_to_card(card_id, record["id"])
|
|
end
|
|
|
|
# Add a comment to a card. The only card mutation the audit agent is
|
|
# allowed.
|
|
#
|
|
# @return [Hash] the created comment
|
|
def comment(card_id:, text:)
|
|
@client.comments.create(card_id, text: text)
|
|
end
|
|
|
|
private
|
|
|
|
def find_board!(name)
|
|
@client.projects.list.each do |project|
|
|
board = @client.boards.list(project["id"]).find { |b| b["name"] == name }
|
|
return board if board
|
|
end
|
|
raise "no board named #{name.inspect} found (run board-ensure first)"
|
|
end
|
|
|
|
def find_list!(board, list_name)
|
|
list = @client.lists.list(board["id"]).find { |l| l["name"] == list_name }
|
|
raise "board #{board['name'].inspect} has no #{list_name.inspect} list (run board-ensure)" unless list
|
|
|
|
list
|
|
end
|
|
|
|
def next_position(board, list)
|
|
included = @client.boards.get(board["id"])["included"]
|
|
positions = (included["cards"] || [])
|
|
.select { |c| c["listId"] == list["id"] }
|
|
.filter_map { |c| c["position"] }
|
|
(positions.max || 0) + 65_536
|
|
end
|
|
end
|
|
end
|