sensorium-mcp 3.1.2 → 3.1.3-board.10

package/dist/board/schema/policy.js

@@ -0,0 +1,261 @@
+/**
+ * Card-builder "How" policy schema.  ✅ EDITABLE design-layer data.
+ *
+ * Single source of truth for the builder Step 2 ("How") controls, rendered
+ * GENERICALLY by views/BuilderView.js — only the widget *types* are hardcoded
+ * in the view's dispatch, never the options.
+ *
+ * ── Widget vocabulary ────────────────────────────────────────────────────────
+ *   "select"    — single choice from `options` (dropdown)
+ *   "combobox"  — free-text input + curated per-provider suggestions
+ *                 (`suggestionsBy` maps the value of `dependsOn` to grouped lists)
+ *   "segmented" — single choice from `options` (button group)
+ *   "chips"     — multi-select subset of `options` (value is an array)
+ *   "toggle"    — boolean on/off switch
+ *   "phases"    — ordered list of phase objects {name, review, provider, model}
+ *                 (per-phase provider/model override the card-level pick; "Inherit" / "" = card default)
+ *   "text"      — single-line free text
+ *   "textarea"  — multiline free text
+ *   "dirpicker" — directory-dialog button + chosen-path display (supports `required`)
+ *   "memory"    — memory selector with a conditional existing-thread field:
+ *                 Ephemeral (none) / Existing thread (thread dropdown).
+ *                 Value: { mode, threadId }
+ *
+ * ── Field shape ──────────────────────────────────────────────────────────────
+ *   { key, widget, label, desc?, options?, default, placeholder?, required?,
+ *     group?, inline? (rendered inside a parent accordion, skipped by the generic loop),
+ *     showWhen? / requires? / conflicts? — field-dependency constraints evaluated by
+ *       evaluateField() (state/useBuilder.js). Each is a condition or an AND-array of
+ *       conditions; a condition is {key, equals} or {key, in:[...]}. showWhen hides,
+ *       requires/conflicts disable. (Legacy `visibleIf: {key, equals}` still works,
+ *       honored as showWhen.) }
+ */
+
+/** @typedef {"select"|"segmented"|"chips"|"toggle"|"phases"|"text"|"textarea"|"dirpicker"|"memory"} PolicyWidget */
+
+export const MEMORY_MODES = ["Ephemeral", "Existing thread"];
+
+/**
+ * Ordered list of How-step fields.
+ * @type {Array<{key:string, widget:PolicyWidget, label:string, desc?:string, options?:string[], default:*, placeholder?:string, required?:boolean}>}
+ */
+export const POLICY_SCHEMA = [
+  {
+    key: "provider",
+    widget: "segmented",
+    label: "Provider",
+    options: ["Claude", "Copilot", "Codex"],
+    default: "Copilot",
+  },
+  {
+    key: "model",
+    widget: "combobox",
+    label: "Model (optional)",
+    desc: "pick a suggestion or type any alias; empty = provider default",
+    placeholder: "e.g. claude-opus-4.8",
+    default: "",
+    dependsOn: "provider",
+    // A per-spawn model alias applies only to Claude; hide it for other providers.
+    showWhen: { key: "provider", equals: "Claude" },
+    // Curated static suggestions per provider — no live API fetch.
+    suggestionsBy: {
+      Claude: [
+        { label: null, options: ["claude-opus-4-8", "claude-sonnet-4-6", "claude-haiku-4-5"] },
+      ],
+      Copilot: [
+        { label: "Anthropic (via Copilot)", options: ["claude-opus-4.8", "claude-sonnet-4.6"] },
+        { label: "OpenAI (via Copilot)", options: ["gpt-5.2", "gpt-5.2-codex", "o5-mini"] },
+      ],
+      Codex: [
+        { label: null, options: ["gpt-5.2-codex", "gpt-5.2", "o5-mini"] },
+      ],
+    },
+  },
+  {
+    key: "workdir",
+    widget: "dirpicker",
+    label: "Working directory",
+    desc: "the repo path this card's worker runs against",
+    required: true,
+    default: "",
+  },
+  {
+    key: "skills",
+    widget: "chips",
+    label: "Skills",
+    // Representative MOCK sample of real non-system skill names, for the offline
+    // preview only (so it can show skill chips without a registry). In production
+    // the server resolves the live list from the real skills registry (loadSkills,
+    // non-system) via GET /api/board/policy.
+    options: ["Clean Code", "Code Review", "Expert Code Review", "Playwright", "Markdown to PDF", "Buildless Vue Preview"],
+    default: [],
+  },
+  {
+    key: "autonomy",
+    widget: "segmented",
+    label: "Autonomy",
+    desc: "how often the worker checks in with you",
+    options: ["Autonomous", "Checkpoints", "Collaborative"],
+    default: "Autonomous",
+  },
+  {
+    key: "memory",
+    widget: "memory",
+    label: "Memory",
+    desc: "Where this card's worker (and any sub-workers it spawns) keep memory",
+    default: { mode: "Ephemeral" },
+  },
+  {
+    key: "worktree",
+    widget: "toggle",
+    label: "Run in a git worktree",
+    desc: "Isolated branch — nothing touches main until you merge",
+    default: true,
+    onText: "git worktree, merge on approval",
+    offText: "direct on main",
+  },
+  {
+    key: "verifyDone",
+    widget: "toggle",
+    label: "Verify acceptance (separate worker)",
+    desc: "A separate worker checks the acceptance criteria before moving to Done",
+    default: true,
+    onText: "verify acceptance → move to Done → notify you",
+    offText: "off",
+  },
+  {
+    key: "openPr",
+    widget: "toggle",
+    label: "Create pull request",
+    desc: "Open a PR when the work is ready (compiles into the worker prompt)",
+    default: false,
+    group: "pr",
+    onText: "create",
+    offText: "off",
+  },
+  {
+    key: "prDraft",
+    widget: "toggle",
+    label: "Draft PR",
+    desc: "Open as draft; mark ready after review",
+    default: true,
+    group: "pr",
+    inline: true,
+    onText: "draft",
+    offText: "ready",
+  },
+  {
+    key: "prProvider",
+    widget: "select",
+    label: "Target",
+    desc: "Auto: detected from repo remote",
+    options: ["Auto", "GitHub", "Azure DevOps"],
+    default: "Auto",
+    group: "pr",
+    inline: true,
+  },
+  {
+    key: "phases",
+    widget: "phases",
+    label: "Phases",
+    desc: "run in order; each phase may toggle its own review and override provider/model",
+    default: [
+      { name: "Plan", review: true, provider: "Inherit", model: "" },
+      { name: "Implement", review: false, provider: "Inherit", model: "" },
+    ],
+  },
+];
+
+/**
+ * Presets seed the whole How step in one click.
+ * `values` is keyed by POLICY_SCHEMA field `key`; any key omitted falls back to
+ * that field's `default`. Editing a control after applying a preset clears it.
+ * (Adapted to the current field set: model is a free-text alias, memory
+ * replaces the old runIn.)
+ * @type {Array<{name:string, values:Object}>}
+ */
+export const PRESETS = [
+  {
+    name: "Bug fix",
+    values: {
+      provider: "Claude",
+      model: "",
+      skills: [],
+      autonomy: "Autonomous",
+      memory: { mode: "Ephemeral" },
+      worktree: true,
+      verifyDone: true,
+      phases: [
+        { name: "Reproduce", review: false, provider: "Inherit", model: "" },
+        { name: "Fix root cause", review: true, provider: "Inherit", model: "" },
+        { name: "Verify", review: false, provider: "Inherit", model: "" },
+      ],
+    },
+  },
+  {
+    name: "Feature",
+    values: {
+      provider: "Claude",
+      model: "claude-opus-4.8",
+      skills: [],
+      autonomy: "Checkpoints",
+      memory: { mode: "Ephemeral" },
+      worktree: true,
+      verifyDone: true,
+      phases: [
+        { name: "Plan", review: true, provider: "Inherit", model: "" },
+        { name: "Implement", review: false, provider: "Inherit", model: "" },
+        { name: "Test & document", review: true, provider: "Inherit", model: "" },
+        { name: "Final review", review: false, provider: "Inherit", model: "" },
+      ],
+    },
+  },
+  {
+    name: "Full delivery",
+    values: {
+      provider: "Claude",
+      model: "claude-opus-4.8",
+      skills: [],
+      autonomy: "Checkpoints",
+      memory: { mode: "Ephemeral" },
+      worktree: true,
+      verifyDone: true,
+      phases: [
+        { name: "Analysis", review: false, provider: "Inherit", model: "" },
+        { name: "Plan", review: true, provider: "Inherit", model: "" },
+        { name: "Implementation", review: false, provider: "Inherit", model: "" },
+        { name: "Final review", review: true, provider: "Inherit", model: "" },
+        { name: "Commit", review: false, provider: "Inherit", model: "" },
+      ],
+    },
+  },
+  {
+    name: "Research",
+    values: {
+      provider: "Claude",
+      model: "",
+      skills: [],
+      autonomy: "Collaborative",
+      memory: { mode: "Ephemeral" },
+      worktree: false,
+      verifyDone: false,
+      phases: [],
+    },
+  },
+  {
+    name: "Tech debt",
+    values: {
+      provider: "Codex",
+      model: "",
+      skills: [],
+      autonomy: "Autonomous",
+      memory: { mode: "Ephemeral" },
+      worktree: true,
+      verifyDone: true,
+      phases: [
+        { name: "Map current structure", review: false, provider: "Inherit", model: "" },
+        { name: "Migrate incrementally", review: true, provider: "Inherit", model: "" },
+      ],
+    },
+  },
+];

package/dist/board/state/recur.js

@@ -0,0 +1,24 @@
+const MINUTES_PER_UNIT = {
+  hours: 60,
+  days: 1_440,
+  weeks: 10_080,
+};
+
+/**
+ * Converts the recurring form controls to the board API's delay in minutes.
+ *
+ * A recurring schedule with an invalid interval uses one unit. This keeps the
+ * UI's minimum of one while avoiding an invalid non-positive delay request.
+ *
+ * @param {{ recurring: boolean, every: unknown, unit: string }} schedule
+ * @returns {number|null}
+ */
+export function recurDelayMinutes({ recurring, every, unit }) {
+  if (!recurring) return null;
+
+  if (!Object.hasOwn(MINUTES_PER_UNIT, unit)) return null;
+  const minutesPerUnit = MINUTES_PER_UNIT[unit];
+
+  const interval = Number.isFinite(Number(every)) ? Math.trunc(Number(every)) : 1;
+  return Math.max(1, interval) * minutesPerUnit;
+}

package/dist/board/state/recur.test.ts

@@ -0,0 +1,24 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { recurDelayMinutes } from "./recur.js";
+
+test("recurDelayMinutes omits a disabled schedule", () => {
+  assert.equal(recurDelayMinutes({ recurring: false, every: 2, unit: "weeks" }), null);
+});
+
+test("recurDelayMinutes converts each supported unit to minutes", () => {
+  assert.equal(recurDelayMinutes({ recurring: true, every: 1, unit: "hours" }), 60);
+  assert.equal(recurDelayMinutes({ recurring: true, every: 1, unit: "days" }), 1_440);
+  assert.equal(recurDelayMinutes({ recurring: true, every: 2, unit: "weeks" }), 20_160);
+});
+
+test("recurDelayMinutes uses one unit for invalid recurring intervals", () => {
+  assert.equal(recurDelayMinutes({ recurring: true, every: 0, unit: "days" }), 1_440);
+  assert.equal(recurDelayMinutes({ recurring: true, every: "invalid", unit: "hours" }), 60);
+});
+
+test("recurDelayMinutes rejects unknown units", () => {
+  assert.equal(recurDelayMinutes({ recurring: true, every: 1, unit: "months" }), null);
+  assert.equal(recurDelayMinutes({ recurring: true, every: 1, unit: "toString" }), null);
+});

package/dist/board/state/useBoard.js

@@ -0,0 +1,161 @@
+/**
+ * Board store — cards + lanes polling and operator actions.  ❌ FROZEN SEAM.
+ *
+ * Frozen return surface (the seam the UI is built against):
+ *   { cards, laneGroups, loading, error, laneGroupFilter, includeArchived,
+ *     byStatus, statuses, laneGroupName, start, stop, actions }
+ *
+ * A single shared instance (module singleton) so the board view and any header
+ * share one poll loop.
+ *
+ * @typedef {import('../api/contract.js').BoardCard} BoardCard
+ */
+
+import { ref, computed } from "../vendor/vue.esm-browser.js";
+import { api } from "../api/api.js";
+import { POLL_INTERVAL_MS, CARD_STATUSES } from "../config.js";
+
+let singleton = null;
+
+export function filterCardsByLaneGroup(cards, laneGroupId) {
+  return laneGroupId == null ? cards : cards.filter((card) => card.laneGroupId === laneGroupId);
+}
+
+export function countCardsInLaneGroup(cards, laneGroupId) {
+  return cards.filter((card) => card.laneGroupId === laneGroupId).length;
+}
+
+export function useBoard() {
+  if (singleton) return singleton;
+
+  const cards = ref([]);
+  const limitedProviders = ref([]);
+  const laneGroups = ref([]);
+  const loading = ref(false);
+  const error = ref(null);
+  const laneGroupFilter = ref(null); // null = all groups
+  const includeArchived = ref(false);
+  let timer = null;
+
+  async function refresh() {
+    try {
+      error.value = null;
+      const [c, groups] = await Promise.all([
+        api.listCards({ includeArchived: includeArchived.value }),
+        api.listLaneGroups(),
+      ]);
+      cards.value = c.cards;
+      limitedProviders.value = c.limitedProviders;
+      laneGroups.value = groups;
+    } catch (e) {
+      error.value = (e && e.message) || String(e);
+    } finally {
+      loading.value = false;
+    }
+  }
+
+  async function load() {
+    loading.value = true;
+    await refresh();
+  }
+
+  function start() {
+    stop();
+    load();
+    timer = setInterval(() => {
+      if (typeof document === "undefined" || document.visibilityState === "visible") refresh();
+    }, POLL_INTERVAL_MS);
+  }
+
+  function stop() {
+    if (timer) {
+      clearInterval(timer);
+      timer = null;
+    }
+  }
+
+  /** The Board view's group-filtered cards; shared consumers always use `cards`. */
+  const filteredCards = computed(() => filterCardsByLaneGroup(cards.value, laneGroupFilter.value));
+
+  /** Filtered Board cards grouped by status, each group priority-desc then oldest-first. */
+  const byStatus = computed(() => {
+    const groups = {};
+    for (const s of CARD_STATUSES) groups[s] = [];
+    for (const card of filteredCards.value) (groups[card.status] ||= []).push(card);
+    for (const s of Object.keys(groups)) {
+      groups[s].sort((a, b) => b.priority - a.priority || (a.createdAt < b.createdAt ? -1 : 1));
+    }
+    return groups;
+  });
+
+  const laneGroupName = (groupId) =>
+    laneGroups.value.find((group) => group.groupId === groupId)?.name ?? "Ungrouped";
+
+  const actions = {
+    setLaneGroupFilter: (v) => {
+      laneGroupFilter.value = v;
+      return refresh();
+    },
+    setIncludeArchived: (v) => {
+      includeArchived.value = v;
+      return refresh();
+    },
+    create: async (card) => {
+      const c = await api.createCard(card);
+      await refresh();
+      return c;
+    },
+    move: async (id, status) => {
+      const c = await api.updateCard(id, { status });
+      await refresh();
+      return c;
+    },
+    stop: async (id) => {
+      const c = await api.stopCard(id);
+      await refresh();
+      return c;
+    },
+    archive: async (id) => {
+      const c = await api.updateCard(id, { archivedAt: new Date().toISOString() });
+      await refresh();
+      return c;
+    },
+    remove: async (id) => {
+      await api.deleteCard(id);
+      await refresh();
+    },
+    addLaneGroup: async (name) => {
+      const l = await api.createLaneGroup(name);
+      await refresh();
+      return l;
+    },
+    renameLaneGroup: async (id, name) => {
+      const l = await api.updateLaneGroup(id, { name });
+      await refresh();
+      return l;
+    },
+    removeLaneGroup: async (id) => {
+      await api.deleteLaneGroup(id);
+      await refresh();
+    },
+    refresh,
+  };
+
+  singleton = {
+    cards,
+    limitedProviders,
+    laneGroups,
+    loading,
+    error,
+    laneGroupFilter,
+    includeArchived,
+    filteredCards,
+    byStatus,
+    statuses: CARD_STATUSES,
+    laneGroupName,
+    start,
+    stop,
+    actions,
+  };
+  return singleton;
+}