@cat-factory/app 0.153.3 → 0.154.0

package/app/stores/execution.ts

@@ -1,21 +1,17 @@
 import { defineStore } from 'pinia'
 import { ref, computed } from 'vue'
-import type {
-  Decision,
-  ExecutionInstance,
-  Pipeline,
-  PipelineStep,
-  StepApproval,
-} from '~/types/domain'
-import type { RequestStepChangesInput } from '@cat-factory/contracts'
-import type { IterationCapChoice } from '~/types/execution'
-import { useWorkspaceStore } from '~/stores/workspace'
+import type { Decision, ExecutionInstance, PipelineStep, StepApproval } from '~/types/domain'
+import { createExecutionCommands } from '~/stores/execution/commands'
 
 /**
  * Running pipeline instances. The simulation engine lives on the backend: this
  * store mirrors the server's executions and drives them via the API. Commands
  * call the worker and then refresh the workspace snapshot, since advancing an
  * execution also rolls status/progress up onto its block server-side.
+ *
+ * The run-control commands live in a cohesive factory ({@link createExecutionCommands}, under
+ * `stores/execution/`) that closes over the state assembled here — a size-only split mirroring
+ * `stores/board/`, not a new seam.
  */
 export const useExecutionStore = defineStore('execution', () => {
   const api = useApi()
@@ -225,101 +221,6 @@ export const useExecutionStore = defineStore('execution', () => {
   const decisionsByBlock = computed(() => groupByBlock(openDecisions.value))
   const approvalsByBlock = computed(() => groupByBlock(openApprovals.value))
 
-  /**
-   * Start `pipeline` against a block; the server marks the block in-progress. A block
-   * pinned to an individual-usage model (Claude) needs the initiator's personal
-   * password — supplied transparently from the local cache, and prompted via the
-   * credential modal (then retried) when the server replies 428.
-   */
-  async function start(blockId: string, pipeline: Pipeline): Promise<boolean> {
-    const ws = useWorkspaceStore()
-    const personal = usePersonalSubscriptionsStore()
-    // Returns false when the user cancels the personal-password prompt OR the start was
-    // refused (a 409 conflict, surfaced as an actionable toast here), so an optimistic
-    // caller can revert its "Starting…" state without its own error handling.
-    try {
-      return await personal.withCredential(async (password) => {
-        await api.startExecution(ws.requireId(), blockId, { pipelineId: pipeline.id }, password)
-        await ws.refresh()
-      })
-    } catch (e) {
-      runErrors.present(e, 'errors.action.startFailed')
-      return false
-    }
-  }
-
-  // Interacting with a running individual-usage run (resolve/approve/request-changes) advances
-  // + re-dispatches the run, so the server re-mints its short-TTL activation from the personal
-  // password first. It rides the cached password transparently, and — like start/retry — is
-  // gated through `withCredential`: a within-buffer/lapsed cache re-prompts EARLY here (while
-  // the user is present) rather than letting the run break mid-pipeline. For a non-individual
-  // run the server ignores it and nothing prompts.
-  async function resolveDecision(instanceId: string, decisionId: string, choice: string) {
-    const ws = useWorkspaceStore()
-    const personal = usePersonalSubscriptionsStore()
-    return await personal.withCredential(async (password) => {
-      await api.resolveDecision(ws.requireId(), instanceId, decisionId, { choice }, password)
-      await ws.refresh()
-    })
-  }
-
-  /** Approve a step's gated proposal (optionally edited); the run advances. */
-  async function approveStep(instanceId: string, approvalId: string, proposal?: string) {
-    const ws = useWorkspaceStore()
-    const personal = usePersonalSubscriptionsStore()
-    return await personal.withCredential(async (password) => {
-      await api.approveStep(ws.requireId(), instanceId, approvalId, { proposal }, password)
-      await ws.refresh()
-    })
-  }
-
-  /** Request changes on a gated proposal; the step re-runs with the review. */
-  async function requestStepChanges(
-    instanceId: string,
-    approvalId: string,
-    review: RequestStepChangesInput,
-  ) {
-    const ws = useWorkspaceStore()
-    const personal = usePersonalSubscriptionsStore()
-    return await personal.withCredential(async (password) => {
-      await api.requestStepChanges(ws.requireId(), instanceId, approvalId, review, password)
-      await ws.refresh()
-    })
-  }
-
-  /** Reject a gated proposal; the run stops entirely (a retryable failure). */
-  async function rejectStep(instanceId: string, approvalId: string, reason?: string) {
-    const ws = useWorkspaceStore()
-    await api.rejectStep(ws.requireId(), instanceId, approvalId, { reason })
-    await ws.refresh()
-  }
-
-  /**
-   * Resolve a companion step parked at its rework cap: extra-round (one more pass) /
-   * proceed (advance with the current output) / stop-reset (cancel + reset the task).
-   * Rides the cached personal password (gated through `withCredential`, so a within-buffer
-   * cache re-prompts early) for the server to re-mint the run's activation before
-   * re-dispatching on extra-round/proceed.
-   */
-  async function resolveCompanionExceeded(
-    instanceId: string,
-    approvalId: string,
-    choice: IterationCapChoice,
-  ) {
-    const ws = useWorkspaceStore()
-    const personal = usePersonalSubscriptionsStore()
-    return await personal.withCredential(async (password) => {
-      await api.resolveCompanionExceeded(
-        ws.requireId(),
-        instanceId,
-        approvalId,
-        { choice },
-        password,
-      )
-      await ws.refresh()
-    })
-  }
-
   /** How many approval gates anywhere are awaiting a human. */
   const pendingApprovalCount = computed(() =>
     instances.value.reduce(
@@ -328,62 +229,11 @@ export const useExecutionStore = defineStore('execution', () => {
     ),
   )
 
-  /** Merge an open PR (a task in `pr_ready`) — the server completes the task. */
-  async function mergePr(blockId: string) {
-    const ws = useWorkspaceStore()
-    try {
-      await api.mergeBlock(ws.requireId(), blockId)
-      await ws.refresh()
-    } catch (e) {
-      runErrors.present(e, 'errors.action.mergeFailed')
-    }
-  }
-
-  /**
-   * Restart a run from a chosen step: the server re-runs from `stepIndex` onward
-   * (resetting that step + later steps' iteration counters) while preserving the
-   * earlier steps' outputs as handoff context, and re-drives a fresh run. Like
-   * start/retry it may dispatch an individual-usage (Claude) step, so it rides the
-   * initiator's personal password — prompted (then retried) on a 428. Returns false
-   * when the user cancels that prompt (nothing was restarted).
-   */
-  async function restartFromStep(instanceId: string, stepIndex: number): Promise<boolean> {
-    const ws = useWorkspaceStore()
-    const personal = usePersonalSubscriptionsStore()
-    try {
-      return await personal.withCredential(async (password) => {
-        await api.restartFromStep(ws.requireId(), instanceId, stepIndex, password)
-        await ws.refresh()
-      })
-    } catch (e) {
-      runErrors.present(e, 'errors.action.restartFailed')
-      return false
-    }
-  }
-
-  /**
-   * Cancel the execution running against a block and reset it to planned. `workspaceId`
-   * defaults to the current workspace but can be pinned by callers that cancel a run for a
-   * board the user may have since navigated away from (e.g. a deferred delete's commit).
-   */
-  async function cancel(blockId: string, workspaceId?: string) {
-    const ws = useWorkspaceStore()
-    await api.cancelExecution(workspaceId ?? ws.requireId(), blockId)
-    instances.value = instances.value.filter((e) => e.blockId !== blockId)
-    await ws.refresh()
-  }
-
-  /**
-   * Stop a running execution WITHOUT deleting it: halts the container + durable driver
-   * and records the run as `cancelled` (a retryable failure), leaving the block
-   * `blocked`. Unlike {@link cancel} the run is kept — its steps/output stay readable on
-   * the board and it can be retried from where it stopped. `runId` is the execution id.
-   */
-  async function stop(runId: string) {
-    const ws = useWorkspaceStore()
-    await api.stopAgentRun(ws.requireId(), runId)
-    await ws.refresh()
-  }
+  // The run-control commands (start / decide / approve / merge / restart / cancel / stop),
+  // extracted into a cohesive factory sharing the state above (a size-only split mirroring
+  // `stores/board/` and `stores/pipelines/` — behaviour is identical to the former in-closure
+  // functions).
+  const commands = createExecutionCommands({ api, runErrors, instances })
 
   return {
     instances,
@@ -398,15 +248,6 @@ export const useExecutionStore = defineStore('execution', () => {
     decisionsByBlock,
     approvalsByBlock,
     pendingApprovalCount,
-    start,
-    resolveDecision,
-    approveStep,
-    requestStepChanges,
-    rejectStep,
-    resolveCompanionExceeded,
-    restartFromStep,
-    mergePr,
-    cancel,
-    stop,
+    ...commands,
   }
 })

package/app/stores/github/connection.ts

@@ -0,0 +1,60 @@
+import type { ResyncRequest } from '~/types/domain'
+import type { GitHubStoreContext } from './context'
+
+/**
+ * The App-installation lifecycle: discovering/binding an installation, dropping it, and
+ * triggering a resync of the projections. Extracted from the store setup; each operation closes
+ * over the shared {@link GitHubStoreContext} so behaviour is identical to the original
+ * in-closure functions — the split is purely to keep every function within the size budget.
+ */
+export function createGitHubConnectionActions(ctx: GitHubStoreContext) {
+  const { api, workspace, available, connection, installations, loadingInstallations } = ctx
+  const { repos, availableRepos, pulls, issues, branches, syncing, load } = ctx
+
+  /** The URL a workspace owner visits to install the App against this workspace. */
+  function getInstallUrl(): Promise<string> {
+    return api.getGitHubInstallUrl(workspace.requireId()).then((r) => r.url)
+  }
+
+  /** Discover the App's installations so the user can connect one without typing an id. */
+  async function loadInstallations() {
+    loadingInstallations.value = true
+    try {
+      const { installations: list } = await api.listGitHubInstallations(workspace.requireId())
+      installations.value = list
+    } finally {
+      loadingInstallations.value = false
+    }
+  }
+
+  /** Programmatic bind by installation id (the browser flow uses the redirect). */
+  async function connect(installationId: number) {
+    connection.value = await api.connectGitHub(workspace.requireId(), installationId)
+    available.value = true
+    await load()
+  }
+
+  async function disconnect() {
+    await api.disconnectGitHub(workspace.requireId())
+    connection.value = null
+    repos.value = []
+    availableRepos.value = []
+    pulls.value = []
+    issues.value = []
+    branches.value = {}
+  }
+
+  /** Trigger a resync, then refresh projections (no-op for queued/backfill). */
+  async function resync(body: ResyncRequest = {}) {
+    syncing.value = true
+    try {
+      const res = await api.resyncGitHub(workspace.requireId(), body)
+      await load()
+      return res
+    } finally {
+      syncing.value = false
+    }
+  }
+
+  return { getInstallUrl, loadInstallations, connect, disconnect, resync }
+}

package/app/stores/github/context.ts

@@ -0,0 +1,46 @@
+import type { Ref } from 'vue'
+import type {
+  GitHubBranch,
+  GitHubConnection,
+  GitHubAvailableRepo,
+  GitHubInstallationOption,
+  GitHubIssue,
+  GitHubPullRequest,
+  GitHubRepo,
+  RepoTreeEntry,
+} from '~/types/domain'
+import { useWorkspaceStore } from '~/stores/workspace'
+
+/** Stable identity for a pull request in the `pulls` list: repo + PR number. */
+export const pullKey = (repoGithubId: number, number: number) => `${repoGithubId}:${number}`
+
+/**
+ * Shared reactive state + injected dependencies the GitHub-store action factories close over.
+ * Created once in the `github` store setup and threaded into {@link createGitHubConnectionActions}
+ * and {@link createGitHubRepoActions} so the split operations stay behaviourally identical to the
+ * original single-closure store — a size-only extraction mirroring `stores/board/` and
+ * `stores/pipelines/`, not a new seam.
+ */
+export interface GitHubStoreContext {
+  api: ReturnType<typeof useApi>
+  workspace: ReturnType<typeof useWorkspaceStore>
+  available: Ref<boolean | null>
+  connection: Ref<GitHubConnection | null>
+  installations: Ref<GitHubInstallationOption[]>
+  loadingInstallations: Ref<boolean>
+  repos: Ref<GitHubRepo[]>
+  availableRepos: Ref<GitHubAvailableRepo[]>
+  loadingAvailable: Ref<boolean>
+  savingRepos: Ref<boolean>
+  pulls: Ref<GitHubPullRequest[]>
+  upsertPull: (pull: GitHubPullRequest) => void
+  getPull: (key: string) => GitHubPullRequest | undefined
+  issues: Ref<GitHubIssue[]>
+  branches: Ref<Record<number, GitHubBranch[]>>
+  repoFiles: Ref<Record<number, RepoTreeEntry[]>>
+  syncing: Ref<boolean>
+  /** Whether an App installation is bound (the store's `connected` computed). */
+  connected: Readonly<Ref<boolean>>
+  /** Reload the cached repos/PRs/issues projection (the store's `load`). */
+  load: () => Promise<void>
+}

package/app/stores/github/repoActions.ts

@@ -0,0 +1,151 @@
+import type {
+  CreateBranchInput,
+  GitHubAvailableRepo,
+  GitHubBranch,
+  MergePullRequestInput,
+  OpenPullRequestInput,
+  RepoTreeEntry,
+} from '~/types/domain'
+import { pullKey, type GitHubStoreContext } from './context'
+
+/**
+ * The per-repo reads (link picker, branches, trees, file listings) and writes (create repo /
+ * branch, open / merge a PR, comment). Extracted from the store setup; each operation closes
+ * over the shared {@link GitHubStoreContext} so behaviour is identical to the original
+ * in-closure functions — the split is purely to keep every function within the size budget.
+ */
+export function createGitHubRepoActions(ctx: GitHubStoreContext) {
+  const { api, workspace, connected, repos, availableRepos, loadingAvailable, savingRepos } = ctx
+  const { branches, repoFiles, upsertPull, getPull, load } = ctx
+
+  /**
+   * Load the repos the installation can access, with this workspace's link state.
+   * With a `q` the backend filters `owner/name` server-side (the add-service picker
+   * searches instead of prefetching a huge installation); without one it browses all
+   * (the repo-link panel). A blank/short `q` clears the list rather than fetching.
+   */
+  async function loadAvailableRepos(q?: string) {
+    if (!connected.value) return
+    if (q !== undefined && q.trim() === '') {
+      availableRepos.value = []
+      return
+    }
+    loadingAvailable.value = true
+    try {
+      availableRepos.value = await api.listGitHubAvailableRepos(workspace.requireId(), q)
+    } finally {
+      loadingAvailable.value = false
+    }
+  }
+
+  /**
+   * Search the installation/PAT-accessible repos server-side WITHOUT touching the shared
+   * `availableRepos`/`loadingAvailable` singleton — it returns the matches to the caller instead.
+   * This is the reusable form behind `useRepoSearch`: two independent pickers (the add-service
+   * modal and the doc-task reference-repo picker) can search concurrently without clobbering
+   * each other's results. A blank/short `q` (or no connection) returns `[]`.
+   */
+  async function searchAvailableRepos(q: string): Promise<GitHubAvailableRepo[]> {
+    if (!connected.value || q.trim() === '') return []
+    return api.listGitHubAvailableRepos(workspace.requireId(), q)
+  }
+
+  /** Set the exact set of repos this workspace links, then refresh projections. */
+  async function setLinkedRepos(repoGithubIds: number[]) {
+    savingRepos.value = true
+    try {
+      repos.value = await api.setGitHubLinkedRepos(workspace.requireId(), repoGithubIds)
+      // Reflect the new link state in the picker and refresh PRs/issues.
+      const linked = new Set(repoGithubIds)
+      availableRepos.value = availableRepos.value.map((r) => ({
+        ...r,
+        linked: linked.has(r.githubId),
+      }))
+      await load()
+    } finally {
+      savingRepos.value = false
+    }
+  }
+
+  /** Lazily load (and cache) the branches for a single repo. */
+  async function loadBranches(repoGithubId: number): Promise<GitHubBranch[]> {
+    const list = await api.listGitHubBranches(workspace.requireId(), repoGithubId)
+    branches.value = { ...branches.value, [repoGithubId]: list }
+    return list
+  }
+
+  /** List one level of a (monorepo) repo's tree, for the service-directory picker. */
+  function loadRepoTree(repoGithubId: number, path = '') {
+    return api.listGitHubRepoTree(workspace.requireId(), repoGithubId, path)
+  }
+
+  /**
+   * Load (and cache) EVERY file in a repo — the whole tree in one recursive read — so a
+   * picker can search files by path entirely client-side (no per-keystroke server call).
+   * Cached by repo id so re-opening the picker for the same repo is instant; force a
+   * refetch with `{ reload: true }`. Mirrors the branches cache.
+   */
+  async function loadRepoFiles(
+    repoGithubId: number,
+    opts: { reload?: boolean } = {},
+  ): Promise<RepoTreeEntry[]> {
+    const cached = repoFiles.value[repoGithubId]
+    if (cached && !opts.reload) return cached
+    const files = await api.listGitHubRepoFiles(workspace.requireId(), repoGithubId)
+    repoFiles.value = { ...repoFiles.value, [repoGithubId]: files }
+    return files
+  }
+
+  // ---- repo writes ----------------------------------------------------------
+
+  /**
+   * Create a repository under the connected account (privileged App tier). Only
+   * meaningful when `canCreateRepos`; the backend 409s otherwise. Returns the
+   * created repo so the caller can confirm/link it.
+   */
+  function createRepo(input: Parameters<typeof api.createGitHubRepo>[1]) {
+    return api.createGitHubRepo(workspace.requireId(), input)
+  }
+
+  async function createBranch(repoGithubId: number, input: CreateBranchInput) {
+    const branch = await api.createGitHubBranch(workspace.requireId(), repoGithubId, input)
+    const next = branches.value[repoGithubId] ?? []
+    branches.value = { ...branches.value, [repoGithubId]: [branch, ...next] }
+    return branch
+  }
+
+  async function openPullRequest(repoGithubId: number, input: OpenPullRequestInput) {
+    const pr = await api.openGitHubPullRequest(workspace.requireId(), repoGithubId, input)
+    upsertPull(pr)
+    return pr
+  }
+
+  async function mergePullRequest(
+    repoGithubId: number,
+    number: number,
+    input: MergePullRequestInput = {},
+  ) {
+    await api.mergeGitHubPullRequest(workspace.requireId(), repoGithubId, number, input)
+    // Optimistically reflect the merge until the next sync confirms it.
+    const existing = getPull(pullKey(repoGithubId, number))
+    if (existing) upsertPull({ ...existing, state: 'closed', merged: true })
+  }
+
+  function comment(repoGithubId: number, number: number, body: string) {
+    return api.commentGitHubIssue(workspace.requireId(), repoGithubId, number, body)
+  }
+
+  return {
+    loadAvailableRepos,
+    searchAvailableRepos,
+    setLinkedRepos,
+    loadBranches,
+    loadRepoTree,
+    loadRepoFiles,
+    createRepo,
+    createBranch,
+    openPullRequest,
+    mergePullRequest,
+    comment,
+  }
+}