@cat-factory/app 0.121.0 → 0.121.2

package/app/composables/useUpsertList.spec.ts

@@ -25,6 +25,19 @@ describe('useUpsertList', () => {
     expect(items.value.map((x) => x.id)).toEqual(['b', 'a'])
   })
 
+  it('replaces an existing item in place under prepend (no reorder)', () => {
+    // The github `pulls` list is prepend (newest-first); re-opening / optimistically
+    // merging an existing PR must replace it where it sits, not bump it to the front.
+    const { items, upsert } = useUpsertList<Item>({ key: (x) => x.id, prepend: true })
+    upsert({ id: 'a', v: 1 })
+    upsert({ id: 'b', v: 2 })
+    upsert({ id: 'a', v: 9 }) // existing key → replace in place
+    expect(items.value).toEqual([
+      { id: 'b', v: 2 },
+      { id: 'a', v: 9 },
+    ])
+  })
+
   it('removes by key and looks up by key', () => {
     const { items, upsert, remove, get } = useUpsertList<Item>({ key: (x) => x.id })
     upsert({ id: 'a', v: 1 })

package/app/stores/accounts.ts

@@ -1,5 +1,6 @@
 import { defineStore } from 'pinia'
 import { computed, ref } from 'vue'
+import { useUpsertList } from '~/composables/useUpsertList'
 import type {
   Account,
   AccountInvitation,
@@ -23,7 +24,7 @@ export const useAccountsStore = defineStore(
   () => {
     const api = useApi()
 
-    const accounts = ref<Account[]>([])
+    const { items: accounts, upsert: upsertAccount } = useUpsertList<Account>({ key: (a) => a.id })
     /** Active account id (persisted so a reload keeps the same context). */
     const activeAccountId = ref<string | null>(null)
     const ready = ref(false)
@@ -46,7 +47,7 @@ export const useAccountsStore = defineStore(
     /** Create a shared org account and make it active. */
     async function createOrg(name: string) {
       const account = await api.createAccount({ name })
-      accounts.value.push(account)
+      upsertAccount(account)
       activeAccountId.value = account.id
       return account
     }
@@ -62,8 +63,7 @@ export const useAccountsStore = defineStore(
      */
     async function setDefaultCloudProvider(id: string, provider: CloudProvider) {
       const updated = await api.updateAccount(id, { defaultCloudProvider: provider })
-      const i = accounts.value.findIndex((a) => a.id === id)
-      if (i >= 0) accounts.value[i] = updated
+      upsertAccount(updated)
       return updated
     }
 
@@ -73,14 +73,15 @@ export const useAccountsStore = defineStore(
      */
     async function setSpendMonthlyLimit(id: string, limit: number | null) {
       const updated = await api.updateAccount(id, { spendMonthlyLimit: limit })
-      const i = accounts.value.findIndex((a) => a.id === id)
-      if (i >= 0) accounts.value[i] = updated
+      upsertAccount(updated)
       return updated
     }
 
     // ---- members + invitations -------------------------------------------
 
-    const members = ref<AccountMember[]>([])
+    const { items: members, upsert: upsertMember } = useUpsertList<AccountMember>({
+      key: (m) => m.userId,
+    })
     const invitations = ref<AccountInvitation[]>([])
 
     /** Load the active account's member roster + pending invitations. */
@@ -108,8 +109,7 @@ export const useAccountsStore = defineStore(
     /** Set a member's role set (admin-only); patches the loaded roster in place. */
     async function setMemberRoles(accountId: string, userId: string, roles: AccountRole[]) {
       const updated = await api.setMemberRoles(accountId, userId, roles)
-      const i = members.value.findIndex((m) => m.userId === userId)
-      if (i >= 0) members.value[i] = updated
+      upsertMember(updated)
       return updated
     }
 

package/app/stores/agentRuns.spec.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect, beforeEach } from 'vitest'
-import type { BootstrapJob } from '~/types/domain'
+import type { BootstrapJob, EnvConfigRepairJob } from '~/types/domain'
 import { useAgentRunsStore } from '~/stores/agentRuns'
 
 /** Minimal BootstrapJob factory — only the fields the store's reconcile logic touches. */
@@ -72,3 +72,56 @@ describe('agentRuns store — monotonic bootstrap reconcile', () => {
     expect(store.bootstrapJobs[0]!.status).toBe('succeeded')
   })
 })
+
+/** Minimal EnvConfigRepairJob factory — only the fields the store touches. */
+function repairJob(id: string, over: Partial<EnvConfigRepairJob> = {}): EnvConfigRepairJob {
+  return {
+    id,
+    workspaceId: 'ws_test',
+    owner: 'acme',
+    repo: 'svc',
+    branch: 'main',
+    status: 'running',
+    ok: null,
+    issues: [],
+    subtasks: null,
+    error: null,
+    failure: null,
+    createdAt: 1,
+    updatedAt: 1,
+    ...over,
+  }
+}
+
+describe('agentRuns store — env-config-repair (plain useUpsertList adoption, candidate #3)', () => {
+  let store: ReturnType<typeof useAgentRunsStore>
+  beforeEach(() => {
+    store = useAgentRunsStore()
+  })
+
+  it('upsertEnvConfigRepair prepends a new run (newest-first) and replaces in place by id', () => {
+    store.upsertEnvConfigRepair(repairJob('r1'))
+    store.upsertEnvConfigRepair(repairJob('r2'))
+    // Newest prepended, so r2 leads r1.
+    expect(store.envConfigRepairJobs.map((j) => j.id)).toEqual(['r2', 'r1'])
+    // A later event for r1 replaces it IN PLACE (no reorder), unlike a monotonic-guarded list.
+    store.upsertEnvConfigRepair(repairJob('r1', { status: 'succeeded' }))
+    expect(store.envConfigRepairJobs.map((j) => j.id)).toEqual(['r2', 'r1'])
+    expect(store.envConfigRepairById('r1')?.status).toBe('succeeded')
+  })
+
+  it('envConfigRepairById looks a run up by id (absent → undefined)', () => {
+    store.upsertEnvConfigRepair(repairJob('r1'))
+    expect(store.envConfigRepairById('r1')?.id).toBe('r1')
+    expect(store.envConfigRepairById('nope')).toBeUndefined()
+  })
+
+  it('hydrateEnvConfigRepair replaces the cache newest-first', () => {
+    store.upsertEnvConfigRepair(repairJob('stale'))
+    store.hydrateEnvConfigRepair([
+      repairJob('old', { createdAt: 1 }),
+      repairJob('new', { createdAt: 9 }),
+    ])
+    expect(store.envConfigRepairJobs.map((j) => j.id)).toEqual(['new', 'old'])
+  })
+})

package/app/stores/agentRuns.ts

@@ -9,6 +9,7 @@ import type {
 } from '~/types/domain'
 import { useWorkspaceStore } from '~/stores/workspace'
 import { useExecutionStore } from '~/stores/execution'
+import { useUpsertList } from '~/composables/useUpsertList'
 
 /**
  * A coarse, per-block view of the current "agent run" against a block, regardless
@@ -62,9 +63,15 @@ export const useAgentRunsStore = defineStore('agentRuns', () => {
    * Env-config-repair runs for this workspace, newest-first. These have NO board block —
    * they're surfaced only on the infrastructure-providers window (looked up by the
    * `repairJobId` the `bootstrapRepo` response returned), so they're held separately and
-   * NOT merged into {@link byBlock}.
+   * NOT merged into {@link byBlock}. Unlike the bootstrap list this is a PLAIN find-by-id
+   * upsert (no `updatedAt` monotonic guard), so it routes through the shared
+   * {@link useUpsertList} helper (the last plain-upsert holdout, refactoring candidate #3).
    */
-  const envConfigRepairJobs = ref<EnvConfigRepairJob[]>([])
+  const {
+    items: envConfigRepairJobs,
+    upsert: upsertEnvConfigRepair,
+    get: envConfigRepairById,
+  } = useUpsertList<EnvConfigRepairJob>({ key: (j) => j.id, prepend: true })
 
   /**
    * Reconcile the cached bootstrap runs with a server snapshot for `workspaceId`. A snapshot is
@@ -96,27 +103,11 @@ export const useAgentRunsStore = defineStore('agentRuns', () => {
     bootstrapJobs.value = [...reconciled, ...preserved].sort((a, b) => b.createdAt - a.createdAt)
   }
 
-  /** Replace the cached env-config-repair runs with a server snapshot. */
+  /** Replace the cached env-config-repair runs with a server snapshot (newest-first). */
   function hydrateEnvConfigRepair(jobs: EnvConfigRepairJob[]) {
     envConfigRepairJobs.value = [...jobs].sort((a, b) => b.createdAt - a.createdAt)
   }
 
-  /**
-   * Patch an env-config-repair run from a real-time `env-config-repair` event (or after
-   * launching one): replace it in place by id, else prepend it. Keeps the infra window's
-   * "repairing…" indicator reactive to live progress / outcome without a refetch.
-   */
-  function upsertEnvConfigRepair(job: EnvConfigRepairJob) {
-    const i = envConfigRepairJobs.value.findIndex((j) => j.id === job.id)
-    if (i >= 0) envConfigRepairJobs.value[i] = job
-    else envConfigRepairJobs.value.unshift(job)
-  }
-
-  /** Look up a single env-config-repair run by id (the infra window tracks one by `repairJobId`). */
-  function envConfigRepairById(id: string): EnvConfigRepairJob | undefined {
-    return envConfigRepairJobs.value.find((j) => j.id === id)
-  }
-
   /**
    * Patch a bootstrap run from a real-time `bootstrap` event (or after launching
    * one): replace it in place by id, else prepend it. Keeps the service card

package/app/stores/bootstrap.ts

@@ -6,6 +6,7 @@ import type {
   ReferenceArchitecture,
   UpdateReferenceArchitectureInput,
 } from '~/types/domain'
+import { useUpsertList } from '~/composables/useUpsertList'
 import { useWorkspaceStore } from '~/stores/workspace'
 import { useAgentRunsStore } from '~/stores/agentRuns'
 
@@ -27,7 +28,11 @@ export const useBootstrapStore = defineStore('bootstrap', () => {
 
   /** null = unknown (not probed yet), true/false = module reachable or not. */
   const available = ref<boolean | null>(null)
-  const architectures = ref<ReferenceArchitecture[]>([])
+  const {
+    items: architectures,
+    upsert: upsertArchitecture,
+    remove: dropArchitecture,
+  } = useUpsertList<ReferenceArchitecture>({ key: (a) => a.id, prepend: true })
   const loading = ref(false)
 
   const hasArchitectures = computed(() => architectures.value.length > 0)
@@ -50,22 +55,21 @@ export const useBootstrapStore = defineStore('bootstrap', () => {
   /** Register a new reference architecture. */
   async function createArchitecture(input: CreateReferenceArchitectureInput) {
     const created = await api.createReferenceArchitecture(workspace.requireId(), input)
-    architectures.value.unshift(created)
+    upsertArchitecture(created)
     return created
   }
 
   /** Patch a reference architecture. */
   async function updateArchitecture(id: string, input: UpdateReferenceArchitectureInput) {
     const updated = await api.updateReferenceArchitecture(workspace.requireId(), id, input)
-    const i = architectures.value.findIndex((a) => a.id === id)
-    if (i >= 0) architectures.value[i] = updated
+    upsertArchitecture(updated)
     return updated
   }
 
   /** Remove a reference architecture. */
   async function deleteArchitecture(id: string) {
     await api.deleteReferenceArchitecture(workspace.requireId(), id)
-    architectures.value = architectures.value.filter((a) => a.id !== id)
+    dropArchitecture(id)
   }
 
   /**

package/app/stores/github.ts

@@ -14,9 +14,13 @@ import type {
   ResyncRequest,
 } from '~/types/domain'
 import { useSingleFlightProbe } from '~/composables/useSingleFlightProbe'
+import { useUpsertList } from '~/composables/useUpsertList'
 import { useWorkspaceStore } from '~/stores/workspace'
 import { useServicesStore } from '~/stores/services'
 
+/** Stable identity for a pull request in the `pulls` list: repo + PR number. */
+const pullKey = (repoGithubId: number, number: number) => `${repoGithubId}:${number}`
+
 /**
  * GitHub integration state: the workspace's App installation, the projected
  * repos/branches/pull-requests/issues the backend caches in D1, and the actions
@@ -42,7 +46,14 @@ export const useGitHubStore = defineStore('github', () => {
   const availableRepos = ref<GitHubAvailableRepo[]>([])
   const loadingAvailable = ref(false)
   const savingRepos = ref(false)
-  const pulls = ref<GitHubPullRequest[]>([])
+  const {
+    items: pulls,
+    upsert: upsertPull,
+    get: getPull,
+  } = useUpsertList<GitHubPullRequest>({
+    key: (p) => pullKey(p.repoGithubId, p.number),
+    prepend: true,
+  })
   const issues = ref<GitHubIssue[]>([])
   /** Branches loaded lazily per repo (by GitHub numeric id). */
   const branches = ref<Record<number, GitHubBranch[]>>({})
@@ -269,11 +280,7 @@ export const useGitHubStore = defineStore('github', () => {
 
   async function openPullRequest(repoGithubId: number, input: OpenPullRequestInput) {
     const pr = await api.openGitHubPullRequest(workspace.requireId(), repoGithubId, input)
-    const i = pulls.value.findIndex(
-      (p) => p.repoGithubId === pr.repoGithubId && p.number === pr.number,
-    )
-    if (i >= 0) pulls.value[i] = pr
-    else pulls.value.unshift(pr)
+    upsertPull(pr)
     return pr
   }
 
@@ -284,8 +291,8 @@ export const useGitHubStore = defineStore('github', () => {
   ) {
     await api.mergeGitHubPullRequest(workspace.requireId(), repoGithubId, number, input)
     // Optimistically reflect the merge until the next sync confirms it.
-    const i = pulls.value.findIndex((p) => p.repoGithubId === repoGithubId && p.number === number)
-    if (i >= 0) pulls.value[i] = { ...pulls.value[i]!, state: 'closed', merged: true }
+    const existing = getPull(pullKey(repoGithubId, number))
+    if (existing) upsertPull({ ...existing, state: 'closed', merged: true })
   }
 
   function comment(repoGithubId: number, number: number, body: string) {

package/app/stores/pipelines.ts

@@ -4,6 +4,7 @@ import type { AgentKind, Pipeline } from '~/types/domain'
 import type { ConsensusStepConfig, StepGating } from '~/types/consensus'
 import type { StepOptions, TesterQualityConfig } from '@cat-factory/contracts'
 import { companionForProducer, uid } from '~/utils/catalog'
+import { useUpsertList } from '~/composables/useUpsertList'
 import { useWorkspaceStore } from '~/stores/workspace'
 
 /** A sensible default config when a step is first flipped to consensus in the builder. */
@@ -31,7 +32,11 @@ function defaultConsensusConfig(): ConsensusStepConfig {
  */
 export const usePipelinesStore = defineStore('pipelines', () => {
   const api = useApi()
-  const pipelines = ref<Pipeline[]>([])
+  const {
+    items: pipelines,
+    upsert: upsertPipeline,
+    remove: dropPipeline,
+  } = useUpsertList<Pipeline>({ key: (p) => p.id })
   /**
    * Current built-in catalog versions (`seedPipelines()`), keyed by pipeline id, from the
    * workspace snapshot. A built-in whose stored `version` is below its catalog value here has
@@ -369,13 +374,12 @@ export const usePipelinesStore = defineStore('pipelines', () => {
     const payload = draftPayload()
     if (editingId.value) {
       const updated = await api.updatePipeline(wsId, editingId.value, payload)
-      const i = pipelines.value.findIndex((p) => p.id === updated.id)
-      if (i >= 0) pipelines.value[i] = updated
+      upsertPipeline(updated)
       clearDraft()
       return updated
     }
     const pipeline = await api.createPipeline(wsId, payload)
-    pipelines.value.push(pipeline)
+    upsertPipeline(pipeline)
     clearDraft()
     return pipeline
   }
@@ -383,14 +387,14 @@ export const usePipelinesStore = defineStore('pipelines', () => {
   /** Clone any pipeline (built-in or custom) into an editable copy, ready to edit. */
   async function clonePipeline(id: string): Promise<Pipeline> {
     const clone = await api.clonePipeline(useWorkspaceStore().requireId(), id)
-    pipelines.value.push(clone)
+    upsertPipeline(clone)
     loadForEdit(clone)
     return clone
   }
 
   async function removePipeline(id: string) {
     await api.removePipeline(useWorkspaceStore().requireId(), id)
-    pipelines.value = pipelines.value.filter((p) => p.id !== id)
+    dropPipeline(id)
     if (editingId.value === id) clearDraft()
   }
 
@@ -401,8 +405,7 @@ export const usePipelinesStore = defineStore('pipelines', () => {
    */
   async function reseed(id: string): Promise<Pipeline> {
     const updated = await api.reseedPipeline(useWorkspaceStore().requireId(), id)
-    const i = pipelines.value.findIndex((p) => p.id === updated.id)
-    if (i >= 0) pipelines.value[i] = updated
+    upsertPipeline(updated)
     if (editingId.value === id) clearDraft()
     return updated
   }
@@ -410,8 +413,7 @@ export const usePipelinesStore = defineStore('pipelines', () => {
   /** Set a pipeline's organizational metadata (labels / archive). Works on built-ins too. */
   async function organize(id: string, body: { labels?: string[]; archived?: boolean }) {
     const updated = await api.organizePipeline(useWorkspaceStore().requireId(), id, body)
-    const i = pipelines.value.findIndex((p) => p.id === updated.id)
-    if (i >= 0) pipelines.value[i] = updated
+    upsertPipeline(updated)
     return updated
   }
 

package/app/stores/releaseHealth.ts

@@ -10,6 +10,7 @@ import type {
   IncidentEnrichmentView,
   UpsertIncidentEnrichmentInput,
 } from '~/types/incidentEnrichment'
+import { useUpsertList } from '~/composables/useUpsertList'
 import { useWorkspaceStore } from '~/stores/workspace'
 
 /**
@@ -26,7 +27,11 @@ export const useReleaseHealthStore = defineStore('releaseHealth', () => {
     provider: null,
     summary: null,
   })
-  const configs = ref<ReleaseHealthConfig[]>([])
+  const {
+    items: configs,
+    upsert: upsertConfig,
+    remove: dropConfig,
+  } = useUpsertList<ReleaseHealthConfig>({ key: (c) => c.blockId })
   // Incident-enrichment (PagerDuty + incident.io) connection — write-only secrets, the
   // store only ever holds the presence summary. Wired alongside observability.
   const incident = ref<IncidentEnrichmentView>({ connected: false, summary: null })
@@ -91,16 +96,14 @@ export const useReleaseHealthStore = defineStore('releaseHealth', () => {
   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)
+    upsertConfig(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)
+    dropConfig(blockId)
   }
 
   /** Load the incident-enrichment connection (separate opt-in gate from observability). */

package/app/stores/sharedStacks.ts

@@ -1,10 +1,10 @@
 import { defineStore } from 'pinia'
-import { ref } from 'vue'
 import type {
   DetectSharedStackInput,
   SharedStack,
   UpdateSharedStackInput,
 } from '~/types/sharedStacks'
+import { useUpsertList } from '~/composables/useUpsertList'
 import { useWorkspaceStore } from '~/stores/workspace'
 
 /**
@@ -19,18 +19,13 @@ import { useWorkspaceStore } from '~/stores/workspace'
  */
 export const useSharedStacksStore = defineStore('sharedStacks', () => {
   const api = useApi()
-  const stacks = ref<SharedStack[]>([])
+  const { items: stacks, upsert: patch } = useUpsertList<SharedStack>({ key: (s) => s.id })
 
   function hydrate(list: SharedStack[]) {
+    // Keep the snapshot sorted oldest-first; the helper's plain hydrate wouldn't sort.
     stacks.value = [...list].sort((a, b) => a.createdAt - b.createdAt)
   }
 
-  function patch(stack: SharedStack) {
-    const idx = stacks.value.findIndex((s) => s.id === stack.id)
-    if (idx >= 0) stacks.value[idx] = stack
-    else stacks.value.push(stack)
-  }
-
   async function create(input: Parameters<typeof api.createSharedStack>[1]) {
     const ws = useWorkspaceStore()
     const created = await api.createSharedStack(ws.requireId(), input)