@cat-factory/app 0.36.0 → 0.37.0

package/app/composables/api/tasks.ts

@@ -1,61 +1,69 @@
-import type {
-  Block,
-  SourceTask,
-  TaskConnection,
-  TaskSearchResult,
-  TaskSourceDiagnostic,
-  TaskSourceKind,
-  TaskSourceState,
-} from '~/types/domain'
-import type { PutTrackerSettingsInput, TrackerSettings } from '~/types/tracker'
+import {
+  connectTaskSourceContract,
+  createTaskFromIssueContract,
+  diagnoseTaskSourceContract,
+  disconnectTaskSourceContract,
+  getTrackerSettingsContract,
+  importTaskContract,
+  linkTaskContract,
+  listTaskConnectionsContract,
+  listTaskSourcesContract,
+  listTasksContract,
+  putTrackerSettingsContract,
+  searchTasksContract,
+  setTaskSourceEnabledContract,
+  spawnEpicContract,
+} from '@cat-factory/contracts'
+import type { TaskSourceKind } from '~/types/domain'
+import type { PutTrackerSettingsInput } from '~/types/tracker'
 import type { ApiContext } from './context'
 
 /** Task sources (Jira, …): connect/import/search/link + the workspace tracker selection. */
-export function tasksApi({ http, ws }: ApiContext) {
+export function tasksApi({ send, ws }: ApiContext) {
   return {
     // ---- task sources (Jira, …) ------------------------------------------
     // The configured trackers + their connect/import metadata + the workspace's
     // per-source state (available + enabled). A 503 means the integration is off
     // (the store hides its UI on any error here).
     listTaskSources: (workspaceId: string) =>
-      http<{ sources: TaskSourceState[] }>(`${ws(workspaceId)}/task-sources`),
+      send(listTaskSourcesContract, { pathPrefix: ws(workspaceId) }),
 
     setTaskSourceEnabled: (workspaceId: string, source: TaskSourceKind, enabled: boolean) =>
-      http(`${ws(workspaceId)}/task-sources/${source}/enabled`, {
-        method: 'PUT',
+      send(setTaskSourceEnabledContract, {
+        pathPrefix: ws(workspaceId),
+        pathParams: { source },
         body: { enabled },
       }),
 
     listTaskConnections: (workspaceId: string) =>
-      http<{ connections: TaskConnection[] }>(`${ws(workspaceId)}/task-sources/connections`),
+      send(listTaskConnectionsContract, { pathPrefix: ws(workspaceId) }),
 
     connectTaskSource: (
       workspaceId: string,
       source: TaskSourceKind,
       credentials: Record<string, string>,
     ) =>
-      http<TaskConnection>(`${ws(workspaceId)}/task-sources/${source}/connect`, {
-        method: 'POST',
+      send(connectTaskSourceContract, {
+        pathPrefix: ws(workspaceId),
+        pathParams: { source },
         body: { credentials },
       }),
 
     disconnectTaskSource: (workspaceId: string, source: TaskSourceKind) =>
-      http(`${ws(workspaceId)}/task-sources/${source}/connection`, { method: 'DELETE' }),
+      send(disconnectTaskSourceContract, {
+        pathPrefix: ws(workspaceId),
+        pathParams: { source },
+      }),
 
     // Live "check setup" probe: authenticates against the source and reads a slice
     // of its issues API, returning a classified verdict the panel renders verbatim.
     checkTaskSource: (workspaceId: string, source: TaskSourceKind) =>
-      http<TaskSourceDiagnostic>(`${ws(workspaceId)}/task-sources/${source}/diagnostics`, {
-        method: 'POST',
-      }),
+      send(diagnoseTaskSourceContract, { pathPrefix: ws(workspaceId), pathParams: { source } }),
 
-    listTasks: (workspaceId: string) => http<SourceTask[]>(`${ws(workspaceId)}/tasks`),
+    listTasks: (workspaceId: string) => send(listTasksContract, { pathPrefix: ws(workspaceId) }),
 
     importTask: (workspaceId: string, source: TaskSourceKind, body: { ref: string }) =>
-      http<SourceTask>(`${ws(workspaceId)}/task-sources/${source}/import`, {
-        method: 'POST',
-        body,
-      }),
+      send(importTaskContract, { pathPrefix: ws(workspaceId), pathParams: { source }, body }),
 
     searchTaskSource: (
       workspaceId: string,
@@ -63,24 +71,21 @@ export function tasksApi({ http, ws }: ApiContext) {
       query: string,
       blockId?: string,
     ) =>
-      http<{ results: TaskSearchResult[] }>(`${ws(workspaceId)}/task-sources/${source}/search`, {
-        method: 'POST',
+      send(searchTasksContract, {
+        pathPrefix: ws(workspaceId),
+        pathParams: { source },
         body: { query, ...(blockId ? { blockId } : {}) },
       }),
 
     linkTask: (
       workspaceId: string,
       body: { source: TaskSourceKind; externalId: string; blockId: string },
-    ) => http<SourceTask>(`${ws(workspaceId)}/tasks/link`, { method: 'POST', body }),
+    ) => send(linkTaskContract, { pathPrefix: ws(workspaceId), body }),
 
     createTaskFromIssue: (
       workspaceId: string,
       body: { source: TaskSourceKind; externalId: string; containerId: string },
-    ) =>
-      http<{ block: Block; task: SourceTask }>(`${ws(workspaceId)}/tasks/create-block`, {
-        method: 'POST',
-        body,
-      }),
+    ) => send(createTaskFromIssueContract, { pathPrefix: ws(workspaceId), body }),
 
     // Spawn an epic + its children as an epic node + child tasks, with dependency edges
     // seeded from the issues' blocked-by/depends-on links.
@@ -88,17 +93,13 @@ export function tasksApi({ http, ws }: ApiContext) {
       workspaceId: string,
       source: TaskSourceKind,
       body: { ref: string; containerId: string; position?: { x: number; y: number } },
-    ) =>
-      http<{ epic: Block; tasks: Block[] }>(
-        `${ws(workspaceId)}/task-sources/${source}/epics/spawn`,
-        { method: 'POST', body },
-      ),
+    ) => send(spawnEpicContract, { pathPrefix: ws(workspaceId), pathParams: { source }, body }),
 
     // ---- issue-tracker selection (workspace-level) ------------------------
     getTrackerSettings: (workspaceId: string) =>
-      http<TrackerSettings>(`${ws(workspaceId)}/tracker-settings`),
+      send(getTrackerSettingsContract, { pathPrefix: ws(workspaceId) }),
 
     putTrackerSettings: (workspaceId: string, body: PutTrackerSettingsInput) =>
-      http<TrackerSettings>(`${ws(workspaceId)}/tracker-settings`, { method: 'PUT', body }),
+      send(putTrackerSettingsContract, { pathPrefix: ws(workspaceId), body }),
   }
 }

package/app/composables/api/userSecrets.ts

@@ -1,31 +1,26 @@
-import type {
-  ConnectionTestResult,
-  StoreUserSecretInput,
-  TestUserSecretInput,
-  UserSecretDescriptor,
-  UserSecretKind,
-  UserSecretStatus,
-} from '~/types/userSecrets'
+import {
+  listUserSecretsContract,
+  removeUserSecretContract,
+  storeUserSecretContract,
+  testUserSecretContract,
+} from '@cat-factory/contracts'
+import type { StoreUserSecretInput, TestUserSecretInput, UserSecretKind } from '~/types/userSecrets'
 import type { ApiContext } from './context'
 
 // Per-USER generic secrets (a GitHub PAT today). User-scoped (no workspace); the secret
 // is write-only server-side and never returned — only status metadata + a `hasSecret`
 // flag. `descriptors` drive the generic connect form; `test` probes before save.
-export function userSecretsApi({ http }: ApiContext) {
+export function userSecretsApi({ send }: ApiContext) {
   return {
-    listUserSecrets: () =>
-      http<{ secrets: UserSecretStatus[]; descriptors: UserSecretDescriptor[] }>('/user-secrets'),
+    listUserSecrets: () => send(listUserSecretsContract, {}),
 
     storeUserSecret: (kind: UserSecretKind, body: StoreUserSecretInput) =>
-      http<UserSecretStatus>(`/user-secrets/${encodeURIComponent(kind)}`, { method: 'POST', body }),
+      send(storeUserSecretContract, { pathParams: { kind }, body }),
 
     deleteUserSecret: (kind: UserSecretKind) =>
-      http(`/user-secrets/${encodeURIComponent(kind)}`, { method: 'DELETE' }),
+      send(removeUserSecretContract, { pathParams: { kind } }),
 
     testUserSecret: (kind: UserSecretKind, body: TestUserSecretInput) =>
-      http<ConnectionTestResult>(`/user-secrets/${encodeURIComponent(kind)}/test`, {
-        method: 'POST',
-        body,
-      }),
+      send(testUserSecretContract, { pathParams: { kind }, body }),
   }
 }

package/app/composables/api/workspaces.ts

@@ -1,36 +1,42 @@
-import type {
-  UpdateWorkspaceSettingsInput,
-  Workspace,
-  WorkspaceSettings,
-  WorkspaceSnapshot,
-} from '~/types/domain'
+import {
+  createWorkspaceContract,
+  deleteWorkspaceContract,
+  getWorkspaceContract,
+  getWorkspaceSettingsContract,
+  listWorkspacesContract,
+  updateWorkspaceContract,
+  updateWorkspaceSettingsContract,
+} from '@cat-factory/contracts'
+import type { UpdateWorkspaceSettingsInput } from '~/types/domain'
 import type { ApiContext } from './context'
 
 /** Workspace CRUD + the full snapshot read. */
-export function workspacesApi({ http, ws }: ApiContext) {
+export function workspacesApi({ send, ws }: ApiContext) {
   return {
     // ---- workspaces -------------------------------------------------------
-    listWorkspaces: () => http<Workspace[]>('/workspaces'),
+    listWorkspaces: () => send(listWorkspacesContract, {}),
 
     createWorkspace: (
       body: { name?: string; description?: string; seed?: boolean; accountId?: string } = {},
-    ) => http<WorkspaceSnapshot>('/workspaces', { method: 'POST', body }),
+    ) => send(createWorkspaceContract, { body }),
 
-    getWorkspace: (workspaceId: string) => http<WorkspaceSnapshot>(ws(workspaceId)),
+    getWorkspace: (workspaceId: string) =>
+      send(getWorkspaceContract, { pathParams: { workspaceId } }),
 
     updateWorkspace: (workspaceId: string, body: { name?: string; description?: string | null }) =>
-      http<Workspace>(ws(workspaceId), { method: 'PATCH', body }),
+      send(updateWorkspaceContract, { pathParams: { workspaceId }, body }),
 
     renameWorkspace: (workspaceId: string, name: string) =>
-      http<Workspace>(ws(workspaceId), { method: 'PATCH', body: { name } }),
+      send(updateWorkspaceContract, { pathParams: { workspaceId }, body: { name } }),
 
-    deleteWorkspace: (workspaceId: string) => http(ws(workspaceId), { method: 'DELETE' }),
+    deleteWorkspace: (workspaceId: string) =>
+      send(deleteWorkspaceContract, { pathParams: { workspaceId } }),
 
     // ---- workspace runtime settings (human-wait escalation + per-service task limit) --
     getWorkspaceSettings: (workspaceId: string) =>
-      http<WorkspaceSettings>(`${ws(workspaceId)}/settings`),
+      send(getWorkspaceSettingsContract, { pathPrefix: ws(workspaceId) }),
 
     updateWorkspaceSettings: (workspaceId: string, body: UpdateWorkspaceSettingsInput) =>
-      http<WorkspaceSettings>(`${ws(workspaceId)}/settings`, { method: 'PUT', body }),
+      send(updateWorkspaceSettingsContract, { pathPrefix: ws(workspaceId), body }),
   }
 }

package/app/composables/useApi.ts

@@ -1,4 +1,5 @@
 import type { FragmentOwnerKind } from '~/types/domain'
+import { createApiClient, createSend, createSendWith } from './api/client'
 import type { ApiContext } from './api/context'
 import { accountsApi } from './api/accounts'
 import { authApi } from './api/auth'
@@ -75,7 +76,14 @@ export function useApi() {
       ? `/accounts/${encodeURIComponent(id)}`
       : `/workspaces/${encodeURIComponent(id)}`
 
-  const ctx: ApiContext = { http, ws, scope, pwHeaders }
+  // The contract-driven client (wretch + sendByApiContract): one source of truth for
+  // path/method/request/response, shared with the backend via @cat-factory/contracts.
+  // API groups are migrated onto `send` incrementally; the rest still use `http`.
+  const client = createApiClient()
+  const send = createSend(client)
+  const sendWith = createSendWith(client)
+
+  const ctx: ApiContext = { http, client, send, sendWith, ws, scope, pwHeaders }
 
   return {
     ...authApi(ctx),

package/app/composables/useIntegrationBack.ts

@@ -1,20 +1,26 @@
 import type { Ref, WritableComputedRef } from 'vue'
 
 /**
- * The shared "back to Integrations" handler for an integration sub-panel's modal header.
- * Every panel reached from the Integrations hub closes itself and reopens the hub when its
+ * The shared "back to the hub" handler for an integration sub-panel's modal header.
+ * Every panel reached from a hub closes itself and reopens that hub when its
  * {@link IntegrationBackTitle} Back control fires `@back`. Centralising it keeps the ~13
  * panels from each re-implementing the two-step close-then-reopen inline — which also
  * dodges a Vue SFC-compiler trap: a multi-statement inline template handler
  * (`open = false` ⏎ `ui.openIntegrations()`) is rejected at build time, so callers had to
  * resort to an obscure comma-operator expression. A named handler reads clearly instead.
  *
+ * Returns to whichever hub the panel was reached from: the user-scoped "My setup" hub when
+ * `cameFromPersonal` is set, else the workspace Integrations hub. A shared panel (e.g. the
+ * vendor-credentials modal, reachable from both) thus lands the user back where they were.
+ *
  * Pass the panel's `open` model (the writable ref/computed bound to its `UModal`).
  */
 export function useIntegrationBack(open: Ref<boolean> | WritableComputedRef<boolean>) {
   const ui = useUiStore()
   return () => {
+    const toPersonal = ui.cameFromPersonal
     open.value = false
-    ui.openIntegrations()
+    if (toPersonal) ui.openPersonalSetup()
+    else ui.openIntegrations()
   }
 }

package/app/pages/index.vue

@@ -28,6 +28,7 @@ import GitHubOnboarding from '~/components/github/GitHubOnboarding.vue'
 import FragmentLibraryPanel from '~/components/fragments/FragmentLibraryPanel.vue'
 import CommandBar from '~/components/layout/CommandBar.vue'
 import IntegrationsHub from '~/components/layout/IntegrationsHub.vue'
+import PersonalSetupModal from '~/components/layout/PersonalSetupModal.vue'
 import WorkspaceSettingsPanel from '~/components/settings/WorkspaceSettingsPanel.vue'
 import AccountSettingsPanel from '~/components/settings/AccountSettingsPanel.vue'
 import ObservabilityConnectionPanel from '~/components/settings/ObservabilityConnectionPanel.vue'
@@ -189,6 +190,7 @@ watch(
       <FragmentLibraryPanel />
       <CommandBar />
       <IntegrationsHub />
+      <PersonalSetupModal />
       <WorkspaceSettingsPanel />
       <AccountSettingsPanel />
       <ObservabilityConnectionPanel />

package/app/stores/auth.ts

@@ -1,3 +1,4 @@
+import type { LocalModeConfig } from '@cat-factory/contracts'
 import { defineStore } from 'pinia'
 import { computed, ref } from 'vue'
 import type { AuthUser } from '~/types/domain'
@@ -29,7 +30,7 @@ export const useAuthStore = defineStore(
      * `githubPatSetupUrl` is set when local mode has no GitHub PAT configured (drives the
      * setup banner). Null on every other facade.
      */
-    const localMode = ref<{ enabled: boolean; githubPatSetupUrl?: string } | null>(null)
+    const localMode = ref<LocalModeConfig | null>(null)
     /** True once the initial auth handshake has settled. */
     const ready = ref(false)
 

package/app/stores/board.ts

@@ -1,5 +1,6 @@
 import { defineStore } from 'pinia'
 import { ref } from 'vue'
+import type { UpdateBlockInput } from '@cat-factory/contracts'
 import type { Block, BlockType, CreateTaskType, TaskTypeFields } from '~/types/domain'
 import { useServicesStore } from '~/stores/services'
 import { useWorkspaceStore } from '~/stores/workspace'
@@ -295,7 +296,7 @@ export const useBoardStore = defineStore('board', () => {
   }
 
   /** Patch the user-editable fields of a block (title, features, threshold…). */
-  async function updateBlock(id: string, patch: Partial<Block>) {
+  async function updateBlock(id: string, patch: UpdateBlockInput) {
     const b = getBlock(id)
     if (!b) return
     Object.assign(b, patch) // optimistic

package/app/stores/brainstorm.ts

@@ -1,10 +1,10 @@
 import { defineStore } from 'pinia'
 import { ref } from 'vue'
 import type {
+  BrainstormItemStatus,
   BrainstormSession,
   BrainstormStage,
   ResolveBrainstormExceededChoice,
-  ReviewItemStatus,
 } from '~/types/brainstorm'
 import { useWorkspaceStore } from '~/stores/workspace'
 
@@ -123,7 +123,7 @@ export const useBrainstormStore = defineStore('brainstorm', () => {
   async function setItemStatus(
     session: BrainstormSession,
     itemId: string,
-    status: ReviewItemStatus,
+    status: BrainstormItemStatus,
   ) {
     store(await api.setBrainstormItemStatus(workspace.requireId(), session.id, itemId, status))
   }

package/app/stores/clarity.ts

@@ -1,6 +1,10 @@
 import { defineStore } from 'pinia'
 import { ref } from 'vue'
-import type { ClarityReview, ResolveClarityExceededChoice, ReviewItemStatus } from '~/types/clarity'
+import type {
+  ClarityItemStatus,
+  ClarityReview,
+  ResolveClarityExceededChoice,
+} from '~/types/clarity'
 import { useWorkspaceStore } from '~/stores/workspace'
 
 /**
@@ -120,7 +124,7 @@ export const useClarityStore = defineStore('clarity', () => {
   }
 
   /** Set an item's status (dismiss / reopen). */
-  async function setItemStatus(review: ClarityReview, itemId: string, status: ReviewItemStatus) {
+  async function setItemStatus(review: ClarityReview, itemId: string, status: ClarityItemStatus) {
     store(await api.setClarityItemStatus(workspace.requireId(), review.id, itemId, status))
   }
 

package/app/stores/execution.ts

@@ -7,7 +7,8 @@ import type {
   PipelineStep,
   StepApproval,
 } from '~/types/domain'
-import type { IterationCapChoice, ReviewComment } from '~/types/execution'
+import type { RequestStepChangesInput } from '@cat-factory/contracts'
+import type { IterationCapChoice } from '~/types/execution'
 import { useWorkspaceStore } from '~/stores/workspace'
 
 /**
@@ -163,7 +164,7 @@ export const useExecutionStore = defineStore('execution', () => {
   async function requestStepChanges(
     instanceId: string,
     approvalId: string,
-    review: { feedback?: string; comments?: ReviewComment[] },
+    review: RequestStepChangesInput,
   ) {
     const ws = useWorkspaceStore()
     const personal = usePersonalSubscriptionsStore()

package/app/stores/github.ts

@@ -2,7 +2,6 @@ import { defineStore } from 'pinia'
 import { computed, ref } from 'vue'
 import type {
   CreateBranchInput,
-  CreateRepoRequest,
   GitHubAvailableRepo,
   GitHubBranch,
   GitHubConnection,
@@ -224,7 +223,7 @@ export const useGitHubStore = defineStore('github', () => {
    * meaningful when `canCreateRepos`; the backend 409s otherwise. Returns the
    * created repo so the caller can confirm/link it.
    */
-  function createRepo(input: CreateRepoRequest) {
+  function createRepo(input: Parameters<typeof api.createGitHubRepo>[1]) {
     return api.createGitHubRepo(workspace.requireId(), input)
   }
 

package/app/stores/mergePresets.ts

@@ -1,10 +1,6 @@
 import { defineStore } from 'pinia'
 import { computed, ref } from 'vue'
-import type {
-  CreateMergePresetInput,
-  MergeThresholdPreset,
-  UpdateMergePresetInput,
-} from '~/types/domain'
+import type { MergeThresholdPreset, UpdateMergePresetInput } from '~/types/domain'
 import { useWorkspaceStore } from '~/stores/workspace'
 
 /**
@@ -34,7 +30,7 @@ export const useMergePresetsStore = defineStore('mergePresets', () => {
     return defaultPreset.value
   }
 
-  async function create(input: CreateMergePresetInput) {
+  async function create(input: Parameters<typeof api.createMergePreset>[1]) {
     const ws = useWorkspaceStore()
     const created = await api.createMergePreset(ws.requireId(), input)
     await ws.refresh()

package/app/stores/pipelines.ts

@@ -132,7 +132,7 @@ export const usePipelinesStore = defineStore('pipelines', () => {
   function toggleDraftGating(index: number) {
     draftGating.value[index] = draftGating.value[index]?.enabled
       ? null
-      : { enabled: true, minRisk: 0.5, minImpact: 0.5 }
+      : { enabled: true, minRisk: 0.5, minImpact: 0.5, onMissingEstimate: 'run' }
   }
 
   /**

package/app/stores/recurringPipelines.ts

@@ -1,11 +1,6 @@
 import { defineStore } from 'pinia'
 import { computed, ref } from 'vue'
-import type {
-  CreateScheduleInput,
-  PipelineSchedule,
-  ScheduleRun,
-  UpdateScheduleInput,
-} from '~/types/recurring'
+import type { PipelineSchedule, ScheduleRun, UpdateScheduleInput } from '~/types/recurring'
 import { useWorkspaceStore } from '~/stores/workspace'
 import { useBoardStore } from '~/stores/board'
 
@@ -39,7 +34,7 @@ export const useRecurringPipelinesStore = defineStore('recurringPipelines', () =
     return schedules.value.find((s) => s.blockId === blockId)
   }
 
-  async function create(input: CreateScheduleInput) {
+  async function create(input: Parameters<typeof api.createRecurringPipeline>[1]) {
     const ws = useWorkspaceStore()
     const created = await api.createRecurringPipeline(ws.requireId(), input)
     await ws.refresh()

package/app/stores/sandbox.ts

@@ -2,7 +2,6 @@ import { defineStore } from 'pinia'
 import { computed, ref } from 'vue'
 import type { ModelOption } from '~/types/domain'
 import type {
-  CreateSandboxExperimentInput,
   SandboxAgentKindMeta,
   SandboxExperiment,
   SandboxExperimentDetail,
@@ -118,7 +117,7 @@ export const useSandboxStore = defineStore('sandbox', () => {
     await load()
   }
 
-  async function createExperiment(input: CreateSandboxExperimentInput) {
+  async function createExperiment(input: Parameters<typeof api.createSandboxExperiment>[1]) {
     const ws = useWorkspaceStore()
     const created = await api.createSandboxExperiment(ws.requireId(), input)
     await load()