bosun 0.42.2 → 0.42.4

package/ui/tui/tasks-screen-helpers.js

@@ -0,0 +1,301 @@
+import {
+  taskCreate,
+  taskDelete,
+  taskList,
+  taskUpdate,
+} from "../../task/task-cli.mjs";
+
+export const TASK_VIEW_WIDTH_THRESHOLD = 140;
+export const DISPLAY_COLUMNS = [
+  { key: "todo", label: "TODO" },
+  { key: "in_progress", label: "IN PROGRESS" },
+  { key: "review", label: "REVIEW" },
+  { key: "done", label: "DONE" },
+];
+export const STATUS_OPTIONS = DISPLAY_COLUMNS.map((column) => column.key);
+export const PRIORITY_OPTIONS = ["critical", "high", "medium", "low"];
+export const PRIORITY_COLOR_MAP = {
+  critical: "red",
+  high: "#ff9e3d",
+  medium: "yellow",
+  low: "green",
+};
+export const EMPTY_TASK_FORM = {
+  title: "",
+  priority: "medium",
+  status: "todo",
+  tagsText: "",
+  description: "",
+  stepsText: "",
+  acceptanceCriteriaText: "",
+  verificationText: "",
+};
+export const LINE_LIST_FIELD_KEYS = new Set([
+  "stepsText",
+  "acceptanceCriteriaText",
+  "verificationText",
+]);
+
+const DISPLAY_STATUS_ORDER = {
+  todo: 0,
+  in_progress: 1,
+  review: 2,
+  done: 3,
+};
+
+const PERSISTED_STATUS_MAP = {
+  draft: "todo",
+  todo: "todo",
+  in_progress: "in_progress",
+  inprogress: "in_progress",
+  blocked: "in_progress",
+  review: "review",
+  inreview: "review",
+  done: "done",
+};
+
+const PRIORITY_ORDER = {
+  critical: 0,
+  high: 1,
+  medium: 2,
+  low: 3,
+};
+
+function shortTaskId(id) {
+  const value = String(id || "").trim();
+  if (!value) return "--------";
+  return value.length <= 8 ? value : value.slice(0, 8);
+}
+
+export function truncateText(value, maxWidth = 24) {
+  const text = String(value || "");
+  if (text.length <= maxWidth) return text;
+  if (maxWidth <= 1) return "…";
+  return `${text.slice(0, Math.max(0, maxWidth - 1))}…`;
+}
+
+export function normalizeTaskStatus(status) {
+  return PERSISTED_STATUS_MAP[String(status || "todo").trim().toLowerCase()] || "todo";
+}
+
+export function toPersistedStatus(status) {
+  const normalized = normalizeTaskStatus(status);
+  if (normalized === "in_progress") return "inprogress";
+  if (normalized === "review") return "inreview";
+  return normalized;
+}
+
+export function resolveTaskView(width, preferredView = "kanban") {
+  if (Number(width || 0) < TASK_VIEW_WIDTH_THRESHOLD) return "list";
+  return preferredView === "list" ? "list" : "kanban";
+}
+
+export function parseTags(tagsText) {
+  if (Array.isArray(tagsText)) {
+    return tagsText.map((tag) => String(tag || "").trim().toLowerCase()).filter(Boolean);
+  }
+  return String(tagsText || "")
+    .split(",")
+    .map((tag) => tag.trim().toLowerCase())
+    .filter(Boolean);
+}
+
+export function parseLineList(value) {
+  if (Array.isArray(value)) {
+    return value.map((line) => String(line || "").trim()).filter(Boolean);
+  }
+  return String(value || "")
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter(Boolean);
+}
+
+function normalizeTask(task, titleWidth = 24) {
+  const normalizedStatus = normalizeTaskStatus(task?.status);
+  const tags = Array.isArray(task?.tags) ? task.tags : parseTags(task?.tagsText);
+  return {
+    ...task,
+    idShort: shortTaskId(task?.id),
+    statusDisplay: normalizedStatus,
+    priority: String(task?.priority || "medium").toLowerCase(),
+    priorityColor: PRIORITY_COLOR_MAP[String(task?.priority || "medium").toLowerCase()] || "yellow",
+    tags,
+    truncatedTitle: truncateText(task?.title || "Untitled", Math.max(8, titleWidth)),
+  };
+}
+
+function matchesFilter(task, filterText) {
+  const query = String(filterText || "").trim().toLowerCase();
+  if (!query) return true;
+  const title = String(task?.title || "").toLowerCase();
+  const id = String(task?.id || "").toLowerCase();
+  const tags = (Array.isArray(task?.tags) ? task.tags : []).map((tag) => String(tag || "").toLowerCase());
+  return title.includes(query) || id.includes(query) || tags.some((tag) => tag.includes(query));
+}
+
+function compareTasks(left, right) {
+  const statusDelta = (DISPLAY_STATUS_ORDER[left.statusDisplay] ?? 99) - (DISPLAY_STATUS_ORDER[right.statusDisplay] ?? 99);
+  if (statusDelta !== 0) return statusDelta;
+  const priorityDelta = (PRIORITY_ORDER[left.priority] ?? 99) - (PRIORITY_ORDER[right.priority] ?? 99);
+  if (priorityDelta !== 0) return priorityDelta;
+  return String(left.title || "").localeCompare(String(right.title || ""));
+}
+
+export function buildBoardColumns(tasks = [], { filterText = "", columnWidth = 32 } = {}) {
+  const filtered = (Array.isArray(tasks) ? tasks : [])
+    .map((task) => normalizeTask(task, columnWidth - 12))
+    .filter((task) => matchesFilter(task, filterText))
+    .sort(compareTasks);
+
+  return DISPLAY_COLUMNS.map((column) => {
+    const items = filtered.filter((task) => task.statusDisplay === column.key);
+    return {
+      ...column,
+      count: items.length,
+      items,
+    };
+  });
+}
+
+export function buildListRows(tasks = [], { filterText = "", rowWidth = 72 } = {}) {
+  return (Array.isArray(tasks) ? tasks : [])
+    .map((task) => normalizeTask(task, rowWidth - 28))
+    .filter((task) => matchesFilter(task, filterText))
+    .sort(compareTasks);
+}
+
+export function formatColumnSummary(columns = []) {
+  return (Array.isArray(columns) ? columns : [])
+    .map((column) => `${column.label} (${Number(column.count || 0)})`)
+    .join(" | ");
+}
+
+export function validateTaskForm(formState = {}) {
+  const errors = {};
+  if (!String(formState.title || "").trim()) {
+    errors.title = "Title is required";
+  }
+  return errors;
+}
+
+export function parseTaskDescription(description = "") {
+  const lines = String(description || "").split(/\r?\n/);
+  const state = {
+    description: [],
+    steps: [],
+    acceptanceCriteria: [],
+    verification: [],
+  };
+  let section = "description";
+
+  for (const rawLine of lines) {
+    const line = String(rawLine || "");
+    const trimmed = line.trim();
+    if (/^##\s+Implementation Steps$/i.test(trimmed)) {
+      section = "steps";
+      continue;
+    }
+    if (/^##\s+Acceptance Criteria$/i.test(trimmed)) {
+      section = "acceptanceCriteria";
+      continue;
+    }
+    if (/^##\s+Verification$/i.test(trimmed)) {
+      section = "verification";
+      continue;
+    }
+    if (!trimmed) {
+      if (section === "description") {
+        state.description.push("");
+      }
+      continue;
+    }
+    if (section === "description") {
+      state.description.push(line);
+      continue;
+    }
+    state[section].push(trimmed.replace(/^-\s*/, ""));
+  }
+
+  return {
+    description: state.description.join("\n").trim(),
+    steps: state.steps,
+    acceptanceCriteria: state.acceptanceCriteria,
+    verification: state.verification,
+  };
+}
+
+export function buildTaskDescription(formState = {}) {
+  const sections = [];
+  const description = String(formState.description || "").trim();
+  if (description) sections.push(description);
+
+  const groups = [
+    ["Implementation Steps", parseLineList(formState.steps ?? formState.stepsText)],
+    ["Acceptance Criteria", parseLineList(formState.acceptanceCriteria ?? formState.acceptanceCriteriaText)],
+    ["Verification", parseLineList(formState.verification ?? formState.verificationText)],
+  ];
+
+  for (const [label, entries] of groups) {
+    if (!entries.length) continue;
+    if (sections.length) sections.push("");
+    sections.push(`## ${label}`);
+    entries.forEach((entry) => {
+      sections.push(`- ${entry}`);
+    });
+  }
+
+  return sections.join("\n").trim();
+}
+
+export function buildTaskPayload(formState = {}) {
+  return {
+    title: String(formState.title || "").trim(),
+    priority: String(formState.priority || "medium").trim().toLowerCase() || "medium",
+    status: toPersistedStatus(formState.status || "todo"),
+    tags: parseTags(formState.tagsText ?? formState.tags),
+    description: buildTaskDescription(formState),
+    draft: false,
+  };
+}
+
+export function buildFormStateFromTask(task = {}) {
+  const parsed = parseTaskDescription(task.description || "");
+  return {
+    title: String(task.title || ""),
+    priority: String(task.priority || "medium").toLowerCase() || "medium",
+    status: normalizeTaskStatus(task.status || "todo"),
+    tagsText: (Array.isArray(task.tags) ? task.tags : []).join(", "),
+    description: parsed.description,
+    stepsText: parsed.steps.join("\n"),
+    acceptanceCriteriaText: parsed.acceptanceCriteria.join("\n"),
+    verificationText: parsed.verification.join("\n"),
+  };
+}
+
+export async function listTasksFromApi(filters = {}, taskApi = { list: taskList }) {
+  return taskApi.list(filters);
+}
+
+export async function createTaskFromForm(formState = {}, taskApi = { create: taskCreate }) {
+  const errors = validateTaskForm(formState);
+  if (Object.keys(errors).length) {
+    const err = new Error(errors.title || "Validation failed");
+    err.validationErrors = errors;
+    throw err;
+  }
+  return taskApi.create(buildTaskPayload(formState));
+}
+
+export async function updateTaskFromForm(taskId, formState = {}, taskApi = { update: taskUpdate }) {
+  const errors = validateTaskForm(formState);
+  if (Object.keys(errors).length) {
+    const err = new Error(errors.title || "Validation failed");
+    err.validationErrors = errors;
+    throw err;
+  }
+  return taskApi.update(taskId, buildTaskPayload(formState));
+}
+
+export async function deleteTaskById(taskId, taskApi = { delete: taskDelete }) {
+  return taskApi.delete(taskId);
+}

package/ui/tui/useTasks.js

@@ -0,0 +1,61 @@
+import { useCallback, useEffect, useState } from "react";
+
+import { taskCreate, taskDelete, taskList, taskUpdate } from "../../task/task-cli.mjs";
+
+async function withMutedConsole(work) {
+  const originalLog = console.log;
+  const originalInfo = console.info;
+  console.log = () => {};
+  console.info = () => {};
+  try {
+    return await work();
+  } finally {
+    console.log = originalLog;
+    console.info = originalInfo;
+  }
+}
+
+export function useTasks() {
+  const [tasks, setTasks] = useState([]);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState(null);
+
+  const refresh = useCallback(async () => {
+    setLoading(true);
+    try {
+      const nextTasks = await withMutedConsole(() => taskList());
+      setTasks(Array.isArray(nextTasks) ? nextTasks : []);
+      setError(null);
+    } catch (err) {
+      setError(String(err?.message || err));
+    } finally {
+      setLoading(false);
+    }
+  }, []);
+
+  useEffect(() => {
+    refresh();
+  }, [refresh]);
+
+  const createTask = useCallback(async (payload) => {
+    const created = await withMutedConsole(() => taskCreate(payload));
+    await refresh();
+    return created;
+  }, [refresh]);
+
+  const updateTask = useCallback(async (taskId, patch) => {
+    const updated = await withMutedConsole(() => taskUpdate(taskId, patch));
+    await refresh();
+    return updated;
+  }, [refresh]);
+
+  const deleteTask = useCallback(async (taskId) => {
+    const deleted = await withMutedConsole(() => taskDelete(taskId));
+    await refresh();
+    return deleted;
+  }, [refresh]);
+
+  return { tasks, loading, error, refresh, createTask, updateTask, deleteTask };
+}
+
+export default useTasks;

package/ui/tui/useWebSocket.js

@@ -0,0 +1,166 @@
+import React, { useEffect, useMemo, useRef, useState } from "react";
+
+import { TuiWsBridge, buildTuiWebSocketUrl } from "../../tui/lib/ws-bridge.mjs";
+
+function applyTaskPatch(tasks, payload) {
+  const next = Array.isArray(tasks) ? [...tasks] : [];
+  const reason = String(payload?.reason || "").toLowerCase();
+  const sourceEvent = String(payload?.sourceEvent || "").toLowerCase();
+  const taskId = payload?.taskId ?? payload?.patch?.id;
+  const patch = taskId ? { ...(payload?.patch || {}), id: taskId } : null;
+  const index = next.findIndex((task) => String(task?.id || "") === String(taskId || ""));
+
+  if (reason.includes("delete") || sourceEvent.includes("delete")) {
+    if (index >= 0) next.splice(index, 1);
+    return next;
+  }
+
+  if (!patch) return next;
+  if (index >= 0) next[index] = { ...next[index], ...patch };
+  else next.unshift(patch);
+  return next;
+}
+
+function upsertSession(sessions, session) {
+  const next = Array.isArray(sessions) ? [...sessions] : [];
+  const sessionId = String(session?.id || "");
+  if (!sessionId) return next;
+  const index = next.findIndex((entry) => String(entry?.id || "") === sessionId);
+  if (index >= 0) next[index] = { ...next[index], ...session };
+  else next.unshift(session);
+  return next;
+}
+
+export function buildBusWebSocketUrl(options) {
+  return buildTuiWebSocketUrl(options);
+}
+
+export function useWebSocket({ host, port, configDir, protocol = "ws" }) {
+  const bridgeRef = useRef(null);
+  const [state, setState] = useState({
+    connected: false,
+    connectionStatus: "connecting",
+    reconnectPulse: false,
+    reconnectCount: 0,
+    stats: null,
+    sessions: [],
+    tasks: [],
+    logs: [],
+    workflows: [],
+    error: null,
+    lastEventAt: null,
+  });
+
+  useEffect(() => {
+    const bridge = new TuiWsBridge({ host, port, configDir, protocol });
+    bridgeRef.current = bridge;
+
+    const unsubscribers = [
+      bridge.on("connect", () => {
+        setState((prev) => ({
+          ...prev,
+          connected: true,
+          connectionStatus: "connected",
+          reconnectPulse: false,
+          error: null,
+          lastEventAt: Date.now(),
+        }));
+      }),
+      bridge.on("disconnect", () => {
+        setState((prev) => ({
+          ...prev,
+          connected: false,
+          connectionStatus: "reconnecting",
+          reconnectCount: prev.reconnectCount + 1,
+          lastEventAt: Date.now(),
+        }));
+      }),
+      bridge.on("error", (error) => {
+        setState((prev) => ({
+          ...prev,
+          connected: false,
+          connectionStatus: prev.connected ? "disconnected" : "reconnecting",
+          error: String(error?.message || "WebSocket error"),
+          lastEventAt: Date.now(),
+        }));
+      }),
+      bridge.on("monitor:stats", (stats) => {
+        setState((prev) => ({ ...prev, stats: stats || null, lastEventAt: Date.now() }));
+      }),
+      bridge.on("stats", (stats) => {
+        setState((prev) => ({ ...prev, stats: stats || prev.stats, lastEventAt: Date.now() }));
+      }),
+      bridge.on("sessions:update", (payload) => {
+        const sessions = Array.isArray(payload?.sessions)
+          ? payload.sessions
+          : Array.isArray(payload)
+            ? payload
+            : [];
+        setState((prev) => ({ ...prev, sessions, lastEventAt: Date.now() }));
+      }),
+      bridge.on("session:event", (payload) => {
+        const session = payload?.session;
+        if (!session) return;
+        setState((prev) => ({
+          ...prev,
+          sessions: upsertSession(prev.sessions, session),
+          lastEventAt: Date.now(),
+        }));
+      }),
+      bridge.on("tasks:update", (payload) => {
+        setState((prev) => ({
+          ...prev,
+          tasks: applyTaskPatch(prev.tasks, payload),
+          lastEventAt: Date.now(),
+        }));
+      }),
+      bridge.on("logs:stream", (payload) => {
+        setState((prev) => ({
+          ...prev,
+          logs: [payload, ...prev.logs].slice(0, 100),
+          lastEventAt: Date.now(),
+        }));
+      }),
+      bridge.on("workflow:status", (payload) => {
+        setState((prev) => ({
+          ...prev,
+          workflows: [payload, ...prev.workflows].slice(0, 50),
+          lastEventAt: Date.now(),
+        }));
+      }),
+    ];
+
+    bridge.connect();
+
+    return () => {
+      for (const unsubscribe of unsubscribers) {
+        if (typeof unsubscribe === "function") unsubscribe();
+      }
+      bridge.disconnect();
+      bridgeRef.current = null;
+    };
+  }, [configDir, host, port, protocol]);
+
+  useEffect(() => {
+    if (state.connectionStatus !== "reconnecting") {
+      setState((prev) => (prev.reconnectPulse ? { ...prev, reconnectPulse: false } : prev));
+      return undefined;
+    }
+
+    const timer = setInterval(() => {
+      setState((prev) => ({ ...prev, reconnectPulse: !prev.reconnectPulse }));
+    }, 450);
+
+    return () => clearInterval(timer);
+  }, [state.connectionStatus]);
+
+  return useMemo(() => ({
+    ...state,
+    send(type, payload = {}) {
+      bridgeRef.current?.send(type, payload);
+    },
+    url: buildTuiWebSocketUrl({ host, port, protocol }),
+  }), [host, port, protocol, state]);
+}
+
+export default useWebSocket;

package/ui/tui/useWorkflows.js

@@ -0,0 +1,30 @@
+import { useCallback, useEffect, useState } from "react";
+
+import { listWorkflowSummaries } from "../../workflow/workflow-cli.mjs";
+
+export function useWorkflows(config) {
+  const [workflows, setWorkflows] = useState([]);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState(null);
+
+  const refresh = useCallback(async () => {
+    setLoading(true);
+    try {
+      const summaries = await Promise.resolve(listWorkflowSummaries(config));
+      setWorkflows(Array.isArray(summaries) ? summaries : []);
+      setError(null);
+    } catch (err) {
+      setError(String(err?.message || err));
+    } finally {
+      setLoading(false);
+    }
+  }, [config]);
+
+  useEffect(() => {
+    refresh();
+  }, [refresh]);
+
+  return { workflows, loading, error, refresh };
+}
+
+export default useWorkflows;