queue_order.py parses queue.py list --json into positions and reasons; the Tasks board overlays each card with its queue position, wait and reason, and falls back to Order only when the queue cannot be read. Tests run once on unify/skills-20261114 after the merge (operator order 2026-11-14). 🎯 Fix: 80 % 💥 Break: 10 % 💸 Tokens: 20 % ⏱️ Velocity: 20 % 🛡️ Security: 100 % 🏆 Score: 100 🚦 Gate: ⛔ fix 80 % < 90, break 10 % > 5 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
273 lines
13 KiB
JavaScript
273 lines
13 KiB
JavaScript
const Kanban = (() => {
|
|
"use strict";
|
|
const COLUMNS = [["queued", "Waiting"], ["running", "Running"], ["done", "Done"]];
|
|
const LANES = [["p1", "P1"], ["p2", "P2"], ["p3", "P3"], ["p4", "P4+"], ["unpinned", "Unpinned"]];
|
|
const PINS = {p1: 1, p2: 2, p3: 3};
|
|
const FREE_FROM = 4;
|
|
const OFF = ["command"];
|
|
const DAY = 86400;
|
|
const HOUR = 3600;
|
|
const MINUTE = 60;
|
|
const REFUSED = ["failed", "refused"];
|
|
const QUEUE = "queue/";
|
|
const RUNNING = "run";
|
|
const QUEUE_LAYERS = [["line", "Queue line", "k-queue-line"], ["jobs", "Queue jobs", "k-queue-jobs"]];
|
|
const CLASS_TONES = {hotfix: "bad", fix: "warn", feature: "info", main: "violet"};
|
|
|
|
const onBoard = (row) => !OFF.includes(row.kind);
|
|
const laneOf = (prio) => (prio === null ? "unpinned" : prio >= FREE_FROM ? "p4" : `p${Math.max(prio, 1)}`);
|
|
const labelOf = (row) => (row.status === "blocked" || row.status === "stopped" ? row.status : null);
|
|
const old = (row, now) => columnOf(row) === "done" && row.end !== null && now - row.end > DAY;
|
|
const score = (row) => (row.wsjf ? row.wsjf.score : null);
|
|
|
|
/**
|
|
* @param row - a task row.
|
|
* @returns "done" for done and stopped, "running" for running and for blocked once started, else "queued".
|
|
*/
|
|
function columnOf(row) {
|
|
if (row.status === "done" || row.status === "stopped") {
|
|
return "done";
|
|
}
|
|
return row.status === "running" || (row.status === "blocked" && row.start !== null) ? "running" : "queued";
|
|
}
|
|
|
|
function ranked(a, b) {
|
|
const pins = (a.prio === null) - (b.prio === null) || (a.prio || 0) - (b.prio || 0);
|
|
const scores = (score(a) === null) - (score(b) === null) || (score(b) || 0) - (score(a) || 0);
|
|
return pins || scores || a.task.localeCompare(b.task, "en");
|
|
}
|
|
|
|
/**
|
|
* @param rows - the task rows to place, staged changes applied.
|
|
* @param options - {now, old: true shows Done cards that ended more than 24 h ago}.
|
|
* @returns {lanes, hidden}: per lane of LANES {id, label, count, cells: {column: rows}}, each cell in pin then WSJF
|
|
* order (WSJF rank alone in Unpinned), and the count of hidden old Done cards. Operator commands are never placed;
|
|
* a pin below 1 counts as P1.
|
|
*/
|
|
function board(rows, options) {
|
|
const placed = rows.filter(onBoard);
|
|
const hidden = options.old ? [] : placed.filter((row) => old(row, options.now));
|
|
const shown = placed.filter((row) => !hidden.includes(row)).sort(ranked);
|
|
const lanes = LANES.map(([id, label]) => {
|
|
const own = shown.filter((row) => laneOf(row.prio) === id);
|
|
return {id, label, count: own.length, cells: Object.fromEntries(COLUMNS.map(([column]) => [column, own.filter((row) => columnOf(row) === column)]))};
|
|
});
|
|
return {lanes, hidden: hidden.length};
|
|
}
|
|
|
|
/**
|
|
* @param rows - every task row, staged changes applied.
|
|
* @param task - the task that moves into P4+.
|
|
* @returns the lowest pin from 4 no other open task holds.
|
|
*/
|
|
function freePin(rows, task) {
|
|
const held = new Set(rows.filter((row) => row.task !== task && !row.ended && row.prio !== null).map((row) => row.prio));
|
|
let pin = FREE_FROM;
|
|
while (held.has(pin)) {
|
|
pin += 1;
|
|
}
|
|
return pin;
|
|
}
|
|
|
|
const slotOf = (target) => (target.after ? `after:${target.after}` : target.drop ? `after:${target.drop}` : target.lane ? "prio" : "status");
|
|
const slotOfArgv = (argv) => (argv[2] === "--after" || argv[2] === "--drop-after" ? `after:${argv[3]}` : argv[2] === "--status" ? "status" : "prio");
|
|
|
|
/**
|
|
* @param row - the hub's row of the moved card.
|
|
* @param target - {column}, {status}, {lane}, {after: the task it follows} or {drop: the task it no longer follows}.
|
|
* @param rows - every task row, staged changes applied, for the free pin.
|
|
* @returns the rasci.py argv of the move against the hub's row, or null when the row already reads so.
|
|
*/
|
|
function move(row, target, rows) {
|
|
if (target.column) {
|
|
return columnOf(row) === target.column ? null : ["set", row.task, "--status", target.column];
|
|
}
|
|
if (target.status) {
|
|
return row.status === target.status ? null : ["set", row.task, "--status", target.status];
|
|
}
|
|
if (target.lane) {
|
|
if (laneOf(row.prio) === target.lane) {
|
|
return null;
|
|
}
|
|
return target.lane === "unpinned" ? ["set", row.task, "--unpin"] : ["set", row.task, "--prio", String(PINS[target.lane] || freePin(rows, row.task))];
|
|
}
|
|
if (target.after) {
|
|
return target.after === row.task || row.after.includes(target.after) ? null : ["set", row.task, "--after", target.after];
|
|
}
|
|
return target.drop && row.after.includes(target.drop) ? ["set", row.task, "--drop-after", target.drop] : null;
|
|
}
|
|
|
|
/**
|
|
* @param staged - the staged changes, each {task, argv}.
|
|
* @param row - the hub's row of the moved card.
|
|
* @param target - as move() takes it.
|
|
* @param rows - every task row, staged changes applied.
|
|
* @returns the new staged list: the move replaces an earlier one of the same task and kind (status, pin, or one
|
|
* dependency), and a move back to the hub's state leaves only the drop of that earlier one.
|
|
*/
|
|
function stage(staged, row, target, rows) {
|
|
const slot = slotOf(target);
|
|
const kept = staged.filter((change) => !(change.task === row.task && slotOfArgv(change.argv) === slot));
|
|
const argv = move(row, target, rows);
|
|
return argv ? [...kept, {task: row.task, argv}] : kept;
|
|
}
|
|
|
|
/**
|
|
* @param rows - the hub's task rows.
|
|
* @param staged - the staged changes.
|
|
* @returns the rows as they read once the staged changes are applied, a changed row with pending, the argv
|
|
* staged for it; the others unchanged.
|
|
*/
|
|
function pending(rows, staged) {
|
|
return rows.map((row) => {
|
|
const own = staged.filter((change) => change.task === row.task);
|
|
if (!own.length) {
|
|
return row;
|
|
}
|
|
const next = {...row, after: [...row.after], pending: own.map((change) => change.argv)};
|
|
for (const {argv} of own) {
|
|
const [, , flag, value] = argv;
|
|
if (flag === "--status") {
|
|
Object.assign(next, {status: value, ended: value === "done" || value === "stopped", end: null});
|
|
} else if (flag === "--prio") {
|
|
next.prio = Number(value);
|
|
} else if (flag === "--unpin") {
|
|
next.prio = null;
|
|
} else if (flag === "--after") {
|
|
next.after.push(value);
|
|
} else {
|
|
next.after = next.after.filter((task) => task !== value);
|
|
}
|
|
}
|
|
return next;
|
|
});
|
|
}
|
|
|
|
/**
|
|
* @param rows - the shown cards' rows, staged changes applied.
|
|
* @param line - the hub's queue_line: tasks holding a live queue entry, in grant order.
|
|
* @returns {arrows, queue}: one {from, to} per after dependency between two shown cards, and the shown tasks of the
|
|
* queue line in its order.
|
|
*/
|
|
function lines(rows, line) {
|
|
const shown = new Set(rows.map((row) => row.task));
|
|
const arrows = rows.flatMap((row) => row.after.filter((task) => task !== row.task && shown.has(task)).map((from) => ({from, to: row.task})));
|
|
return {arrows, queue: line.filter((task) => shown.has(task))};
|
|
}
|
|
|
|
/**
|
|
* @param jobs - the hub's jobs.
|
|
* @param task - a card's task.
|
|
* @returns {failed, applied, total} over the task's changes in its newest signed batch (a job without a batch is
|
|
* one of its own): failed the jobs rasci.py or the runner refused, oldest first, applied the count rasci.py ran;
|
|
* null when none of them failed.
|
|
*/
|
|
function why(jobs, task) {
|
|
const own = jobs.filter((job) => job.kind === "task" && job.task === task).sort((a, b) => a.created_ts - b.created_ts);
|
|
const newest = own[own.length - 1];
|
|
const batch = !newest ? [] : newest.batch ? own.filter((job) => job.batch === newest.batch) : [newest];
|
|
const failed = batch.filter((job) => REFUSED.includes(job.status));
|
|
return failed.length ? {failed, applied: batch.filter((job) => job.status === "done").length, total: batch.length} : null;
|
|
}
|
|
|
|
/**
|
|
* @param seconds - a span in seconds.
|
|
* @returns the span in words, cut to its two largest units: "45 s", "12 min", "2 h 5 min", "3 d 4 h".
|
|
*/
|
|
function span(seconds) {
|
|
const whole = Math.max(0, Math.floor(seconds));
|
|
if (whole < MINUTE) {
|
|
return `${whole} s`;
|
|
}
|
|
if (whole < HOUR) {
|
|
return `${Math.floor(whole / MINUTE)} min`;
|
|
}
|
|
const [big, unit, small, rest] = whole < DAY ? [HOUR, "h", MINUTE, "min"] : [DAY, "d", HOUR, "h"];
|
|
const part = Math.floor((whole % big) / small);
|
|
return part ? `${Math.floor(whole / big)} ${unit} ${part} ${rest}` : `${Math.floor(whole / big)} ${unit}`;
|
|
}
|
|
|
|
/**
|
|
* @param rows - the shown cards' rows.
|
|
* @param line - the hub's queue_line: tasks holding a live queue entry, in grant order.
|
|
* @param jobs - the hub's queue_jobs: the rows of `queue.py list --json` in grant order, null where the installed
|
|
* queue.py lists no JSON.
|
|
* @returns {task: {place, of, jobs}} for each shown card the queue concerns: place its 1-based stop on the queue
|
|
* line (null for a card off the line), of the line's length, and jobs its queue jobs in grant order, a queue card's
|
|
* own job and a task card's jobs by task; jobs stays empty without queue_jobs.
|
|
*/
|
|
function queued(rows, line, jobs) {
|
|
const found = {};
|
|
for (const row of rows) {
|
|
const place = line.indexOf(row.task);
|
|
const own = (jobs || []).filter((job) => (row.kind === "queue" ? `${QUEUE}${job.id}` === row.task : job.task === row.task));
|
|
if (place >= 0 || own.length) {
|
|
found[row.task] = {place: place >= 0 ? place + 1 : null, of: line.length, jobs: own};
|
|
}
|
|
}
|
|
return found;
|
|
}
|
|
|
|
const placeOf = (job) => (typeof job.position === "number" ? `#${job.position}` : job.position === RUNNING ? "running" : job.position || "?");
|
|
|
|
/**
|
|
* @param job - one queue_jobs row.
|
|
* @returns the chips of its card overlay in display order, each {key, text, hint, tone}: its grant position, class,
|
|
* pin, WSJF, the gate it runs (its kind), how long it waits and its ETA; a class, pin, WSJF or wait the row lacks
|
|
* leaves its chip out, an unknown ETA reads "ETA ?".
|
|
*/
|
|
function jobChips(job) {
|
|
const running = job.position === RUNNING;
|
|
const chips = [{key: "position", text: placeOf(job), hint: `${job.id}: ${running ? "granted, running now" : `grant position ${placeOf(job)}`}`, tone: "neutral"}];
|
|
if (job.class) {
|
|
chips.push({key: "class", text: job.class, hint: `${job.id}: class ${job.class}`, tone: CLASS_TONES[job.class]});
|
|
}
|
|
if (job.prio !== null) {
|
|
chips.push({key: "prio", text: `P${job.prio}`, hint: `${job.id}: its task is pinned P${job.prio}`, tone: "neutral"});
|
|
}
|
|
if (job.wsjf !== null) {
|
|
chips.push({key: "wsjf", text: `WSJF ${Number(job.wsjf.toFixed(2))}`, hint: `${job.id}: WSJF ${job.wsjf} of its task`, tone: "neutral"});
|
|
}
|
|
chips.push({key: "gate", text: job.kind || "?", hint: `${job.id}: runs the gate ${job.kind || "of an unknown kind"}`, tone: "teal"});
|
|
if (job.waited_s !== null) {
|
|
chips.push({key: "waited", text: `${running ? "waited" : "waits"} ${span(job.waited_s)}`, hint: `${job.id}: ${running ? "waited" : "waits"} ${span(job.waited_s)} in the queue`, tone: "neutral"});
|
|
}
|
|
const eta = job.eta_s === null ? "no ETA learned yet" : `${running ? "ends" : "starts"} in about ${span(job.eta_s)}`;
|
|
chips.push({key: "eta", text: job.eta_s === null ? "ETA ?" : `ETA ${span(job.eta_s)}`, hint: `${job.id}: ${eta}`, tone: "neutral"});
|
|
return chips;
|
|
}
|
|
|
|
/**
|
|
* @param job - one queue_jobs row.
|
|
* @returns {label, place, steps}: the popover's name, where the job stands (#n, running or the word queue.py gave)
|
|
* and the rule trace that put it there, in the order queue.py applied it; a row without a trace shows its reason
|
|
* as the only step, one without either says so.
|
|
*/
|
|
function whyHere(job) {
|
|
const steps = job.trace.length ? job.trace : [job.reason || "queue.py gave no trace and no reason for this job"];
|
|
return {label: `Why here: ${job.id} at ${placeOf(job)}`, place: placeOf(job), steps};
|
|
}
|
|
|
|
/**
|
|
* @param hidden - the kanban.hidden view-store list: the queue layers switched off.
|
|
* @returns {line, jobs}: whether the numbered queue line and the job overlay of the cards show.
|
|
*/
|
|
function layers(hidden) {
|
|
return Object.fromEntries(QUEUE_LAYERS.map(([id]) => [id, !hidden.includes(id)]));
|
|
}
|
|
|
|
/**
|
|
* @param jobs - the hub's queue_jobs.
|
|
* @returns them with waited_s and eta_s in whole minutes.
|
|
*/
|
|
function queueSig(jobs) {
|
|
const minutes = (value) => (value === null ? null : Math.floor(value / MINUTE));
|
|
return jobs === null ? null : jobs.map((job) => ({...job, waited_s: minutes(job.waited_s), eta_s: minutes(job.eta_s)}));
|
|
}
|
|
|
|
return {COLUMNS, LANES, FREE_FROM, QUEUE_LAYERS, onBoard, columnOf, laneOf, labelOf, board, freePin, move, stage, pending, lines, why, span, queued, jobChips, whyHere, layers, queueSig};
|
|
})();
|
|
if (typeof module === "object" && module.exports) {
|
|
module.exports = Kanban;
|
|
}
|