sensorium-mcp 3.1.2 → 3.1.3-board.10

package/dist/board/state/useBuilder.js

@@ -0,0 +1,357 @@
+/**
+ * Card-builder draft store.  ❌ FROZEN SEAM.
+ *
+ * P0 is the placeholder builder SHELL: the WHAT fields (title / description /
+ * acceptance) plus lane / priority, submitted via the create endpoint.
+ * The schema-driven HOW builder + compiled preview arrive in P1 — this surface
+ * stays stable so the UI is not rewired then. It is extended ADDITIVELY here
+ * with { policySchema, presets } (the How-step field schema + presets, sourced
+ * from the editable schema/policy.js via the data seam) and { preview,
+ * setPreviewProfile, stopPreview } (a DEBOUNCED live compiled-policy preview
+ * bound to POST /api/board/cards/preview) and { profileSave, saveProfile } (the
+ * "Save as profile" action that persists the current How draft via POST
+ * /api/board/profiles, with { saving, savedName, error } feedback); the original
+ * returns ({ draft, lanes, profiles, submitting, error, load, reset, submit })
+ * are unchanged.
+ */
+
+import { onUnmounted, reactive, ref, watch } from "../vendor/vue.esm-browser.js";
+import { api } from "../api/api.js";
+
+const AUTONOMY_VALUES = ["Autonomous", "Checkpoints", "Collaborative"];
+const MEMORY_MODES = ["Ephemeral"];
+/** Coalesce keystrokes/toggles into one preview compile (real endpoint call). */
+const PREVIEW_DEBOUNCE_MS = 300;
+
+/**
+ * Map the phases control to the backend phase shape: exactly
+ * {name, review, provider, model}, stripping the view's transient `auto`/`_id`
+ * keys. Drops any half-added row whose name is still blank, and the synthetic
+ * `auto` "Review" row the widget inserts for display only (its parent phase
+ * already carries review:true — persisting the row would double-encode it).
+ */
+function phasesFromHow(phases) {
+  return phases
+    .filter((phase) => !phase.auto && typeof phase.name === "string" && phase.name.trim())
+    .map((phase) => ({
+      name: phase.name.trim(),
+      review: phase.review,
+      provider: phase.provider,
+      model: phase.model,
+    }));
+}
+
+/**
+ * Kebab-case a profile name into its stable id: lowercase, every run of
+ * non-alphanumerics collapsed to a single dash, leading/trailing dashes trimmed.
+ */
+export function slugifyProfileName(name) {
+  return name
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "");
+}
+
+/**
+ * Map the How controls that the current board backend persists into a profile.
+ *
+ * `fields` is the resolved policy schema (policySchema.value). A control whose
+ * schema field is HIDDEN by its showWhen — decided by the SAME evaluateField the
+ * view renders with — is skipped, so a hidden field never persists (e.g. the
+ * model alias once the provider isn't Claude, whose showWhen then fails). The
+ * skip is generic: each control is keyed on the field.key it shares with its How
+ * key, never on the provider string. An empty `fields` imposes no constraints,
+ * so every mapped control persists (back-compat, and preview before the schema
+ * has loaded).
+ */
+export function profileFromHow(how, fields = []) {
+  const hidden = new Set(
+    fields.filter((field) => !evaluateField(field, how).visible).map((field) => field.key),
+  );
+  const shown = (key) => !hidden.has(key);
+  const profile = {};
+  if (shown("skills") && Array.isArray(how.skills)) profile.skills = how.skills;
+  const provider = typeof how.provider === "string" ? how.provider.toLowerCase() : "";
+  if (shown("provider") && provider) profile.agentType = provider;
+  if (shown("model") && typeof how.model === "string" && how.model.trim())
+    profile.model = how.model.trim();
+  if (shown("worktree") && typeof how.worktree === "boolean") profile.worktree = how.worktree;
+  if (shown("workdir") && typeof how.workdir === "string" && how.workdir.trim())
+    profile.repository = how.workdir.trim();
+  if (shown("openPr") && typeof how.openPr === "boolean") profile.openPr = how.openPr;
+  if (how.openPr === true) {
+    if (shown("prDraft") && typeof how.prDraft === "boolean") profile.prDraft = how.prDraft;
+    if (shown("prProvider") && typeof how.prProvider === "string")
+      profile.prProvider = how.prProvider;
+  }
+  if (
+    shown("autonomy") &&
+    typeof how.autonomy === "string" &&
+    AUTONOMY_VALUES.includes(how.autonomy)
+  )
+    profile.autonomy = how.autonomy;
+  if (shown("verifyDone") && typeof how.verifyDone === "boolean")
+    profile.verifyDone = how.verifyDone;
+  if (shown("memory") && how.memory && MEMORY_MODES.includes(how.memory.mode))
+    profile.memory = { mode: how.memory.mode };
+  if (shown("phases") && Array.isArray(how.phases)) {
+    const phases = phasesFromHow(how.phases);
+    if (phases.length) profile.phases = phases;
+  }
+  return profile;
+}
+
+/**
+ * Normalize a constraint (a single condition or an AND-array of conditions) to a
+ * plain array. A missing constraint yields an empty list, which every predicate
+ * below treats as vacuously satisfied.
+ */
+function conditionList(constraint) {
+  if (!constraint) return [];
+  return Array.isArray(constraint) ? constraint : [constraint];
+}
+
+/**
+ * Does one condition hold against the current How values? `{ key, in: [...] }`
+ * matches when the field's value is one of the listed values; otherwise
+ * `{ key, equals }` matches on strict equality.
+ */
+function conditionHolds(condition, how) {
+  const value = how[condition.key];
+  if (Array.isArray(condition.in)) return condition.in.some((option) => option === value);
+  return value === condition.equals;
+}
+
+/** Human phrase for one condition, used to explain why a field is disabled. */
+function conditionPhrase(condition) {
+  if (Array.isArray(condition.in)) return `${condition.key} in ${condition.in.join(", ")}`;
+  return `${condition.key} = ${condition.equals}`;
+}
+
+/**
+ * Pure, data-driven field-dependency evaluator. Given a schema field and the
+ * current How values it decides whether the field is visible / enabled and, when
+ * disabled, a short English reason. Constraints are declared on the field as
+ * data — the engine never special-cases a field key:
+ *   showWhen  — all conditions must hold, else the field is HIDDEN
+ *               (a legacy `visibleIf` is honored as showWhen, unchanged).
+ *   requires  — all conditions must hold, else the field is visible but DISABLED.
+ *   conflicts — if all conditions hold, the field is visible but DISABLED.
+ * A constraint is a single condition or an AND-array; a condition is
+ * `{ key, equals }` or `{ key, in: [...] }`.
+ * @returns {{ visible: boolean, disabled: boolean, reason: string }}
+ */
+export function evaluateField(field, how) {
+  const showWhen = field.showWhen || field.visibleIf;
+  const visible = conditionList(showWhen).every((condition) => conditionHolds(condition, how));
+
+  const unmet = conditionList(field.requires).filter((c) => !conditionHolds(c, how));
+  if (unmet.length)
+    return {
+      visible,
+      disabled: true,
+      reason: `Requires ${unmet.map(conditionPhrase).join(" and ")}`,
+    };
+
+  const conflicts = conditionList(field.conflicts);
+  if (conflicts.length && conflicts.every((c) => conditionHolds(c, how)))
+    return {
+      visible,
+      disabled: true,
+      reason: `Conflicts with ${conflicts.map(conditionPhrase).join(" and ")}`,
+    };
+
+  return { visible, disabled: false, reason: "" };
+}
+
+export function useBuilder(dependencies = {}) {
+  const apiClient = dependencies.api || api;
+  const timers = dependencies.timers || globalThis;
+  const previewDebounceMs = dependencies.previewDebounceMs || PREVIEW_DEBOUNCE_MS;
+
+  const draft = reactive({
+    title: "",
+    description: "",
+    acceptance: "",
+    laneGroupId: null,
+    priority: 0,
+  });
+
+  const lanes = ref([]);
+  const profiles = ref({});
+  const submitting = ref(false);
+  const error = ref(null);
+  // How-step schema + presets (additive; from schema/policy.js via the seam).
+  const policySchema = ref([]);
+  const presets = ref([]);
+  // "Save as profile" state: savedName is the last persisted name (empty until a
+  // save succeeds), error is the last failure message (empty on success). Both
+  // are empty strings, never null, and drive the builder's save-button feedback.
+  const profileSave = reactive({ saving: false, savedName: "", error: "" });
+
+  // Live compiled-policy preview: { text, loading, error } recomputed DEBOUNCED
+  // whenever the draft (WHAT fields) or the profile (HOW fields, fed by the view
+  // via setPreviewProfile) changes. text is the REAL server-rendered briefing.
+  const preview = reactive({ text: "", loading: false, error: null });
+  let previewProfile = {};
+  let previewTimer = null;
+  // Bumped every time a compile actually fires; a late response whose generation
+  // is stale (a newer draft superseded it) must not overwrite the newer preview.
+  let previewGen = 0;
+
+  function buildPreviewDraft() {
+    return {
+      title: draft.title,
+      description: draft.description,
+      acceptance: draft.acceptance,
+      priority: Number(draft.priority) || 0,
+      ...(draft.laneGroupId != null ? { laneGroupId: Number(draft.laneGroupId) } : {}),
+      profile: previewProfile,
+    };
+  }
+
+  async function runPreview() {
+    const gen = ++previewGen;
+    preview.loading = true;
+    try {
+      const text = await apiClient.previewBriefing(buildPreviewDraft());
+      if (gen !== previewGen) return; // a newer draft already superseded this compile
+      preview.text = text;
+      preview.error = null;
+    } catch (e) {
+      if (gen !== previewGen) return;
+      preview.error = (e && e.message) || String(e);
+    } finally {
+      if (gen === previewGen) preview.loading = false;
+    }
+  }
+
+  function schedulePreview() {
+    if (previewTimer) timers.clearTimeout(previewTimer);
+    previewTimer = timers.setTimeout(runPreview, previewDebounceMs);
+  }
+
+  // Any WHAT-field edit reschedules the debounced compile; the view pushes HOW
+  // edits through setPreviewProfile (below), which also reschedules.
+  const stopPreviewWatch = watch(draft, schedulePreview, { deep: true });
+
+  /** View seam: feed the current HOW-derived ExecutionProfile into the preview. */
+  function setPreviewProfile(profile) {
+    previewProfile = profile;
+    schedulePreview();
+  }
+
+  /** Cancel the pending compile and invalidate any in-flight response. */
+  function stopPreview() {
+    previewGen += 1;
+    if (previewTimer) timers.clearTimeout(previewTimer);
+    previewTimer = null;
+    stopPreviewWatch();
+  }
+  onUnmounted(stopPreview);
+
+  async function load() {
+    try {
+      const [l, p] = await Promise.all([apiClient.listLaneGroups(), apiClient.getProfiles()]);
+      lanes.value = l;
+      profiles.value = Object.fromEntries(p.map((profile) => [profile.id, profile.profile]));
+      if (draft.laneGroupId == null && l.length) draft.laneGroupId = l[0].groupId;
+    } catch (e) {
+      error.value = (e && e.message) || String(e);
+    }
+    // Additive, non-fatal: the schema-driven How controls. In production the real
+    // API loading remains non-fatal — degrade to a
+    // schema-less builder rather than failing the whole load.
+    try {
+      const [schema, ps] = await Promise.all([apiClient.getPolicySchema(), apiClient.getPresets()]);
+      policySchema.value = schema;
+      presets.value = ps;
+    } catch {
+      /* schema/presets unavailable — builder still renders the WHAT step */
+    }
+  }
+
+  function reset() {
+    Object.assign(draft, {
+      title: "",
+      description: "",
+      acceptance: "",
+      priority: 0,
+    });
+  }
+
+  /** @returns {Promise<import('../api/contract.js').BoardCard|null>} */
+  /** @returns {Promise<import('../api/contract.js').BoardCard|null>} */
+  async function submit(how = {}, recurDelayMin = null) {
+    error.value = null;
+    if (!draft.title.trim()) {
+      error.value = "Title is required";
+      return null;
+    }
+    submitting.value = true;
+    try {
+      return await apiClient.createCard({
+        title: draft.title.trim(),
+        description: draft.description,
+        acceptance: draft.acceptance,
+        ...(draft.laneGroupId != null ? { laneGroupId: Number(draft.laneGroupId) } : {}),
+        priority: Number(draft.priority) || 0,
+        profile: profileFromHow(how, policySchema.value),
+        ...(recurDelayMin != null ? { recurDelayMin } : {}),
+        correlationId: crypto.randomUUID(),
+      });
+    } catch (e) {
+      error.value = (e && e.message) || String(e);
+      return null;
+    } finally {
+      submitting.value = false;
+    }
+  }
+
+  /**
+   * Persist the current How draft as a named execution profile. Slugifies the
+   * name into the id, builds the profile the same way submit() does, and merges
+   * the saved profile back into profiles.value so it is immediately available.
+   * A blank name is a no-op; a failure (e.g. a duplicate name) surfaces on
+   * profileSave.error and leaves savedName untouched.
+   * @returns {Promise<void>}
+   */
+  async function saveProfile(name, how = {}) {
+    const trimmed = (name || "").trim();
+    if (!trimmed) return;
+    profileSave.saving = true;
+    profileSave.error = "";
+    profileSave.savedName = "";
+    try {
+      const saved = await apiClient.saveProfile({
+        id: slugifyProfileName(trimmed),
+        name: trimmed,
+        profile: profileFromHow(how, policySchema.value),
+      });
+      profiles.value = { ...profiles.value, [saved.id]: saved.profile };
+      profileSave.savedName = saved.name;
+    } catch (e) {
+      profileSave.error = (e && e.message) || String(e);
+    } finally {
+      profileSave.saving = false;
+    }
+  }
+
+  return {
+    draft,
+    lanes,
+    profiles,
+    policySchema,
+    presets,
+    submitting,
+    error,
+    load,
+    reset,
+    submit,
+    preview,
+    setPreviewProfile,
+    stopPreview,
+    profileSave,
+    saveProfile,
+  };
+}