@cat-factory/app 0.6.0

package/app/stores/recurringPipelines.ts

@@ -0,0 +1,112 @@
+import { defineStore } from 'pinia'
+import { computed, ref } from 'vue'
+import type {
+  CreateScheduleInput,
+  PipelineSchedule,
+  ScheduleRun,
+  UpdateScheduleInput,
+} from '~/types/recurring'
+import { useWorkspaceStore } from '~/stores/workspace'
+import { useBoardStore } from '~/stores/board'
+
+/**
+ * The workspace's recurring pipelines — schedules that re-run a pipeline against a
+ * service on a cadence. Hydrated from the workspace snapshot; created from a button
+ * on the service frame and managed from the inspector. Run history is fetched
+ * lazily per schedule (it is retained only ~1 week so it stays small).
+ */
+export const useRecurringPipelinesStore = defineStore('recurringPipelines', () => {
+  const api = useApi()
+  const toast = useToast()
+
+  const schedules = ref<PipelineSchedule[]>([])
+  /** Lazily-loaded run history, keyed by schedule id. */
+  const runsBySchedule = ref<Record<string, ScheduleRun[]>>({})
+
+  function hydrate(list: PipelineSchedule[]) {
+    schedules.value = [...list].sort((a, b) => a.createdAt - b.createdAt)
+  }
+
+  /** Schedules grouped by the service frame they live in (for board badges). */
+  const byFrame = computed<Record<string, PipelineSchedule[]>>(() => {
+    const map: Record<string, PipelineSchedule[]> = {}
+    for (const s of schedules.value) (map[s.frameId] ??= []).push(s)
+    return map
+  })
+
+  /** The schedule whose reused block is `blockId`, if any. */
+  function byBlock(blockId: string): PipelineSchedule | undefined {
+    return schedules.value.find((s) => s.blockId === blockId)
+  }
+
+  async function create(input: CreateScheduleInput) {
+    const ws = useWorkspaceStore()
+    const created = await api.createRecurringPipeline(ws.requireId(), input)
+    await ws.refresh()
+    return created
+  }
+
+  async function update(id: string, patch: UpdateScheduleInput) {
+    const ws = useWorkspaceStore()
+    const updated = await api.updateRecurringPipeline(ws.requireId(), id, patch)
+    await ws.refresh()
+    return updated
+  }
+
+  /**
+   * Delete a recurring pipeline. Deleting the schedule cascades to its reused block
+   * + run history server-side, so we hide BOTH immediately (optimistic) and restore
+   * them with a toast if the backend rejects the delete.
+   */
+  async function remove(id: string) {
+    const ws = useWorkspaceStore()
+    const board = useBoardStore()
+    const sched = schedules.value.find((s) => s.id === id)
+    const blockSnap = sched ? board.detach(sched.blockId) : null
+    const prevSchedules = schedules.value
+    schedules.value = schedules.value.filter((s) => s.id !== id)
+    try {
+      await api.deleteRecurringPipeline(ws.requireId(), id)
+      delete runsBySchedule.value[id]
+      await ws.refresh()
+    } catch (e) {
+      schedules.value = prevSchedules
+      if (blockSnap) board.reattach(blockSnap)
+      toast.add({
+        title: 'Could not delete recurring pipeline',
+        description: e instanceof Error ? e.message : String(e),
+        icon: 'i-lucide-triangle-alert',
+        color: 'error',
+      })
+    }
+  }
+
+  async function runNow(id: string) {
+    const ws = useWorkspaceStore()
+    const schedule = await api.runScheduleNow(ws.requireId(), id)
+    await loadRuns(id)
+    await ws.refresh()
+    return schedule
+  }
+
+  /** Fetch (and cache) a schedule's run history for the inspector. */
+  async function loadRuns(id: string) {
+    const ws = useWorkspaceStore()
+    const runs = await api.listScheduleRuns(ws.requireId(), id)
+    runsBySchedule.value = { ...runsBySchedule.value, [id]: runs }
+    return runs
+  }
+
+  return {
+    schedules,
+    runsBySchedule,
+    byFrame,
+    byBlock,
+    hydrate,
+    create,
+    update,
+    remove,
+    runNow,
+    loadRuns,
+  }
+})

package/app/stores/releaseHealth.ts

@@ -0,0 +1,75 @@
+import { defineStore } from 'pinia'
+import { ref } from 'vue'
+import type {
+  DatadogConnectionView,
+  ReleaseHealthConfig,
+  UpsertDatadogConnectionInput,
+  UpsertReleaseHealthConfigInput,
+} from '~/types/releaseHealth'
+import { useWorkspaceStore } from '~/stores/workspace'
+
+/**
+ * The workspace's Datadog post-release-health settings: the (single) connection — keys
+ * are write-only, never read back — and the per-block monitor/SLO mappings the
+ * `post-release-health` gate reads. Loaded on demand (the settings panel), not from the
+ * snapshot, since the secrets never leave the server.
+ */
+export const useReleaseHealthStore = defineStore('releaseHealth', () => {
+  const api = useApi()
+
+  const connection = ref<DatadogConnectionView>({ connected: false, site: null })
+  const configs = ref<ReleaseHealthConfig[]>([])
+  const loading = ref(false)
+
+  async function load() {
+    const ws = useWorkspaceStore()
+    loading.value = true
+    try {
+      const [conn, list] = await Promise.all([
+        api.getDatadogConnection(ws.requireId()),
+        api.listReleaseHealthConfigs(ws.requireId()),
+      ])
+      connection.value = conn
+      configs.value = list
+    } finally {
+      loading.value = false
+    }
+  }
+
+  async function saveConnection(input: UpsertDatadogConnectionInput) {
+    const ws = useWorkspaceStore()
+    connection.value = await api.setDatadogConnection(ws.requireId(), input)
+  }
+
+  async function removeConnection() {
+    const ws = useWorkspaceStore()
+    await api.deleteDatadogConnection(ws.requireId())
+    connection.value = { connected: false, site: null }
+  }
+
+  async function saveConfig(blockId: string, input: UpsertReleaseHealthConfigInput) {
+    const ws = useWorkspaceStore()
+    const saved = await api.upsertReleaseHealthConfig(ws.requireId(), blockId, input)
+    const idx = configs.value.findIndex((c) => c.blockId === blockId)
+    if (idx >= 0) configs.value[idx] = saved
+    else configs.value.push(saved)
+    return saved
+  }
+
+  async function removeConfig(blockId: string) {
+    const ws = useWorkspaceStore()
+    await api.deleteReleaseHealthConfig(ws.requireId(), blockId)
+    configs.value = configs.value.filter((c) => c.blockId !== blockId)
+  }
+
+  return {
+    connection,
+    configs,
+    loading,
+    load,
+    saveConnection,
+    removeConnection,
+    saveConfig,
+    removeConfig,
+  }
+})

package/app/stores/requirements.spec.ts

@@ -0,0 +1,94 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest'
+import type { RequirementReview } from '~/types/requirements'
+import { useRequirementsStore } from '~/stores/requirements'
+import { useWorkspaceStore } from '~/stores/workspace'
+
+/** Minimal review factory — only the fields the store getters touch. */
+function review(over: Partial<RequirementReview> = {}): RequirementReview {
+  return {
+    id: 'rr1',
+    blockId: 'b1',
+    status: 'ready',
+    iteration: 1,
+    maxIterations: 3,
+    items: [],
+    incorporatedRequirements: null,
+    model: null,
+    ...over,
+  } as RequirementReview
+}
+
+describe('requirements store load() loading flag', () => {
+  beforeEach(() => {
+    // The store resolves its workspace id from the workspace store at call time.
+    useWorkspaceStore().workspaceId = 'ws1'
+  })
+
+  it('flags the block as loading while the fetch is in flight, then clears it', async () => {
+    // A deferred fetch so we can observe the in-flight window before it resolves —
+    // this is the race the spinner state guards against (review null + not loading
+    // would otherwise render the "no review yet" empty state on first open).
+    let resolveFetch!: (r: RequirementReview) => void
+    const pending = new Promise<RequirementReview>((res) => {
+      resolveFetch = res
+    })
+    vi.stubGlobal('useApi', () => ({ getRequirementReview: () => pending }))
+
+    const store = useRequirementsStore()
+    expect(store.isLoading('b1')).toBe(false)
+
+    const loadPromise = store.load('b1')
+    // In flight: no review cached yet, but the block is flagged loading.
+    expect(store.reviewFor('b1')).toBeNull()
+    expect(store.isLoading('b1')).toBe(true)
+
+    resolveFetch(review())
+    await loadPromise
+
+    expect(store.isLoading('b1')).toBe(false)
+    expect(store.reviewFor('b1')?.id).toBe('rr1')
+  })
+
+  it('clears the loading flag even when the fetch rejects', async () => {
+    vi.stubGlobal('useApi', () => ({
+      getRequirementReview: () => Promise.reject(new Error('503')),
+    }))
+
+    const store = useRequirementsStore()
+    await store.load('b1')
+
+    expect(store.isLoading('b1')).toBe(false)
+    expect(store.available).toBe(false)
+    expect(store.reviewFor('b1')).toBeNull()
+  })
+
+  it('coalesces concurrent load() calls for the same block into one request', async () => {
+    // Two callers open at once (the inspector badge watch + the review window). They must
+    // share a single in-flight request, not each fetch their own.
+    let calls = 0
+    let resolveFetch!: (r: RequirementReview) => void
+    const pending = new Promise<RequirementReview>((res) => {
+      resolveFetch = res
+    })
+    vi.stubGlobal('useApi', () => ({
+      getRequirementReview: () => {
+        calls++
+        return pending
+      },
+    }))
+
+    const store = useRequirementsStore()
+    const first = store.load('b1')
+    const second = store.load('b1')
+    expect(calls).toBe(1)
+
+    resolveFetch(review())
+    await Promise.all([first, second])
+    expect(calls).toBe(1)
+    expect(store.reviewFor('b1')?.id).toBe('rr1')
+
+    // Once the in-flight request settles, a later load fetches fresh.
+    void store.load('b1')
+    expect(calls).toBe(2)
+  })
+})

package/app/stores/requirements.ts

@@ -0,0 +1,208 @@
+import { defineStore } from 'pinia'
+import { ref } from 'vue'
+import type {
+  RequirementReview,
+  ResolveRequirementsExceededChoice,
+  ReviewItemStatus,
+} from '~/types/requirements'
+import { useWorkspaceStore } from '~/stores/workspace'
+
+/**
+ * Requirements-review state. On the pipeline path the reviewer runs as the first gate
+ * step: the run parks while the human answers/dismisses findings, then asks to incorporate.
+ * Incorporation + the re-review run ASYNCHRONOUSLY in the durable driver — the call returns
+ * at once (status `incorporating`) and the user goes back to the board; they are summoned
+ * again (a notification) only if the re-review yields findings or hits the cap. The store is
+ * patched both from call responses and from live `requirements` stream events (see
+ * `upsert`). `available` mirrors the backend's opt-in gate (a 503 hides the UI).
+ * Per-workspace; nothing is persisted client-side.
+ */
+export const useRequirementsStore = defineStore('requirements', () => {
+  const api = useApi()
+  const workspace = useWorkspaceStore()
+
+  /** null = unknown (not probed), true/false = feature on/off. */
+  const available = ref<boolean | null>(null)
+  /** The current review per block id (null = fetched, none exists). */
+  const reviews = ref<Record<string, RequirementReview | null>>({})
+  /** Block ids whose reviewer is currently running (review / re-review). */
+  const reviewing = ref<Set<string>>(new Set())
+  /** Review ids currently incorporating their answers. */
+  const incorporating = ref<Set<string>>(new Set())
+  /** Block ids whose current review is being fetched (the initial `load`). */
+  const loadingByBlock = ref<Set<string>>(new Set())
+  /**
+   * In-flight `load()` promises keyed by block id, so concurrent callers for the same
+   * block (the inspector's badge watch + the review window opening together) share ONE
+   * request instead of each firing its own. Plain Map — internal bookkeeping, not
+   * reactive. Cleared once the request settles.
+   */
+  const inFlight = new Map<string, Promise<void>>()
+
+  function reviewFor(blockId: string): RequirementReview | null {
+    return reviews.value[blockId] ?? null
+  }
+  /**
+   * The async background stage a block's review is in, or null. While the driver folds the
+   * answers (`incorporating`) then re-reviews the document (`reviewing`), NO human action is
+   * needed — so the board suppresses the "Approval needed" gate and shows this working state
+   * instead, with copy that names which of the two stages is running.
+   */
+  function backgroundStage(blockId: string): 'incorporating' | 'reviewing' | null {
+    const status = reviews.value[blockId]?.status
+    return status === 'incorporating' || status === 'reviewing' ? status : null
+  }
+  function isReviewing(blockId: string): boolean {
+    return reviewing.value.has(blockId)
+  }
+  function isLoading(blockId: string): boolean {
+    return loadingByBlock.value.has(blockId)
+  }
+  function isIncorporating(reviewId: string): boolean {
+    return incorporating.value.has(reviewId)
+  }
+
+  /** Findings still needing a human (status `open`). */
+  function openCount(review: RequirementReview): number {
+    return review.items.filter((i) => i.status === 'open').length
+  }
+  /** Findings the human answered (a reply recorded), which the companion folds in. */
+  function answeredCount(review: RequirementReview): number {
+    return review.items.filter((i) => i.status === 'answered' || i.status === 'resolved').length
+  }
+  /** Every finding is settled (answered or dismissed) — none still open. */
+  function allSettled(review: RequirementReview): boolean {
+    return openCount(review) === 0
+  }
+  /** Incorporation is possible: all findings settled AND at least one was answered. */
+  function canIncorporate(review: RequirementReview): boolean {
+    return allSettled(review) && answeredCount(review) > 0
+  }
+  /** Proceed (skip the companion) is possible: all findings settled but none answered. */
+  function canProceed(review: RequirementReview): boolean {
+    return allSettled(review) && answeredCount(review) === 0
+  }
+
+  function store(review: RequirementReview) {
+    reviews.value = { ...reviews.value, [review.blockId]: review }
+  }
+
+  function withFlag(set: typeof reviewing, key: string, on: boolean) {
+    const next = new Set(set.value)
+    if (on) next.add(key)
+    else next.delete(key)
+    set.value = next
+  }
+
+  /** Fetch the current review for a block (probing the feature's availability). */
+  async function load(blockId: string) {
+    if (!workspace.workspaceId) return
+    // Coalesce overlapping loads of the same block onto a single request.
+    const pending = inFlight.get(blockId)
+    if (pending) return pending
+    const promise = (async () => {
+      withFlag(loadingByBlock, blockId, true)
+      try {
+        const review = await api.getRequirementReview(workspace.requireId(), blockId)
+        available.value = true
+        reviews.value = { ...reviews.value, [blockId]: review }
+      } catch {
+        // 503 (feature off) or any error → hide the UI entry points.
+        available.value = false
+      } finally {
+        withFlag(loadingByBlock, blockId, false)
+        inFlight.delete(blockId)
+      }
+    })()
+    inFlight.set(blockId, promise)
+    return promise
+  }
+
+  /** Record a human's answer to one item. */
+  async function reply(review: RequirementReview, itemId: string, text: string) {
+    store(await api.replyRequirementItem(workspace.requireId(), review.id, itemId, text))
+  }
+
+  /** Set an item's status (dismiss / reopen). */
+  async function setItemStatus(
+    review: RequirementReview,
+    itemId: string,
+    status: ReviewItemStatus,
+  ) {
+    store(await api.setRequirementItemStatus(workspace.requireId(), review.id, itemId, status))
+  }
+
+  /**
+   * Ask the driver to incorporate the answers ASYNCHRONOUSLY. Optional `feedback` is the "do
+   * it differently" direction when redoing a merge. Returns at once with the `incorporating`
+   * review (the fold + re-review run in the background); the caller returns the user to the
+   * board. A live `requirements` event / a notification reflects the outcome later.
+   */
+  async function incorporate(review: RequirementReview, feedback?: string) {
+    withFlag(incorporating, review.id, true)
+    try {
+      const updated = await api.incorporateRequirements(
+        workspace.requireId(),
+        review.blockId,
+        feedback,
+      )
+      store(updated)
+      return updated
+    } finally {
+      withFlag(incorporating, review.id, false)
+    }
+  }
+
+  /** Re-review the incorporated document (one more reviewer pass; may converge/advance). */
+  async function reReview(blockId: string): Promise<RequirementReview> {
+    withFlag(reviewing, blockId, true)
+    try {
+      const updated = await api.reReviewRequirements(workspace.requireId(), blockId)
+      store(updated)
+      return updated
+    } finally {
+      withFlag(reviewing, blockId, false)
+    }
+  }
+
+  /** Proceed: settle the requirements and advance the parked run. */
+  async function proceed(blockId: string): Promise<RequirementReview> {
+    const updated = await api.proceedRequirements(workspace.requireId(), blockId)
+    store(updated)
+    return updated
+  }
+
+  /** Resolve a capped review: extra-round / proceed / stop-reset. */
+  async function resolveExceeded(
+    blockId: string,
+    choice: ResolveRequirementsExceededChoice,
+  ): Promise<RequirementReview> {
+    const updated = await api.resolveRequirementsExceeded(workspace.requireId(), blockId, choice)
+    store(updated)
+    return updated
+  }
+
+  return {
+    available,
+    reviews,
+    reviewFor,
+    backgroundStage,
+    isReviewing,
+    isLoading,
+    isIncorporating,
+    openCount,
+    answeredCount,
+    allSettled,
+    canIncorporate,
+    canProceed,
+    load,
+    reply,
+    setItemStatus,
+    incorporate,
+    reReview,
+    proceed,
+    resolveExceeded,
+    // Patch the cache from a live `requirements` stream event.
+    upsert: store,
+  }
+})

package/app/stores/serviceFragmentDefaults.ts

@@ -0,0 +1,29 @@
+import { defineStore } from 'pinia'
+import { ref } from 'vue'
+import { useWorkspaceStore } from '~/stores/workspace'
+
+/**
+ * The workspace's default service-fragment selection — the best-practice fragment ids
+ * a NEW service inherits onto its `serviceFragmentIds`. Hydrated from the workspace
+ * snapshot; edited via the Default-service-fragments settings panel, which replaces
+ * the whole list on save. Changing it does not retroactively change existing services.
+ */
+export const useServiceFragmentDefaultsStore = defineStore('serviceFragmentDefaults', () => {
+  const api = useApi()
+
+  /** The default fragment ids new services inherit. */
+  const fragmentIds = ref<string[]>([])
+
+  function hydrate(ids: string[] | undefined) {
+    fragmentIds.value = [...(ids ?? [])]
+  }
+
+  /** Replace the whole default list and persist it. */
+  async function set(ids: string[]) {
+    const ws = useWorkspaceStore()
+    const saved = await api.setServiceFragmentDefaults(ws.requireId(), ids)
+    fragmentIds.value = [...saved.fragmentIds]
+  }
+
+  return { fragmentIds, hydrate, set }
+})

package/app/stores/services.ts

@@ -0,0 +1,87 @@
+import { defineStore } from 'pinia'
+import { computed, ref } from 'vue'
+import type { Service, WorkspaceMount } from '~/types/services'
+import { useWorkspaceStore } from '~/stores/workspace'
+
+/**
+ * In-org shared services. A `Service` is account-owned (a service frame + its subtree + repo)
+ * and can be mounted onto several teams' boards; a `WorkspaceMount` places one onto THIS
+ * board with its own frame layout. Hydrated from the workspace snapshot:
+ *   - `mounts` — the services this board mounts (drives the per-board frame layout),
+ *   - `catalog` — the org's services this board can mount from (each with a `mountCount`).
+ */
+export const useServicesStore = defineStore('services', () => {
+  const api = useApi()
+
+  const mounts = ref<WorkspaceMount[]>([])
+  const catalog = ref<Service[]>([])
+
+  function hydrate(nextMounts: WorkspaceMount[], nextCatalog: Service[]) {
+    mounts.value = [...nextMounts]
+    catalog.value = [...nextCatalog]
+  }
+
+  /** Mount row keyed by service id. */
+  const byServiceId = computed<Record<string, WorkspaceMount>>(() => {
+    const map: Record<string, WorkspaceMount> = {}
+    for (const m of mounts.value) map[m.serviceId] = m
+    return map
+  })
+
+  /** Catalog service keyed by its frame block id (resolve a frame → its service). */
+  const serviceByFrameBlock = computed<Record<string, Service>>(() => {
+    const map: Record<string, Service> = {}
+    for (const s of catalog.value) map[s.frameBlockId] = s
+    return map
+  })
+
+  /** Org services NOT yet mounted on this board (the "add existing service" picker's options). */
+  const mountable = computed<Service[]>(() => {
+    const mounted = new Set(mounts.value.map((m) => m.serviceId))
+    return catalog.value.filter((s) => !mounted.has(s.id))
+  })
+
+  /** A frame is "shared" when its service is mounted on more than one board. */
+  function isSharedFrame(frameBlockId: string): boolean {
+    return (serviceByFrameBlock.value[frameBlockId]?.mountCount ?? 0) > 1
+  }
+
+  async function mount(serviceId: string, position?: { x: number; y: number }) {
+    const ws = useWorkspaceStore()
+    const created = await api.mountService(ws.requireId(), serviceId, position ? { position } : {})
+    await ws.refresh()
+    return created
+  }
+
+  async function unmount(serviceId: string) {
+    const ws = useWorkspaceStore()
+    await api.unmountService(ws.requireId(), serviceId)
+    await ws.refresh()
+  }
+
+  /** Persist a mounted frame's per-board layout (called on frame drag/resize end). */
+  async function updateLayout(
+    serviceId: string,
+    position?: { x: number; y: number },
+    size?: { w: number; h: number } | null,
+  ) {
+    const ws = useWorkspaceStore()
+    const updated = await api.updateMountLayout(ws.requireId(), serviceId, { position, size })
+    const local = mounts.value.find((m) => m.serviceId === serviceId)
+    if (local) Object.assign(local, updated)
+    return updated
+  }
+
+  return {
+    mounts,
+    catalog,
+    byServiceId,
+    serviceByFrameBlock,
+    mountable,
+    isSharedFrame,
+    hydrate,
+    mount,
+    unmount,
+    updateLayout,
+  }
+})