@cat-factory/app 0.153.3 → 0.154.0

package/app/stores/github.ts

@@ -1,7 +1,6 @@
 import { defineStore } from 'pinia'
 import { computed, ref } from 'vue'
 import type {
-  CreateBranchInput,
   GitHubAvailableRepo,
   GitHubBranch,
   GitHubConnection,
@@ -9,18 +8,15 @@ import type {
   GitHubIssue,
   GitHubPullRequest,
   GitHubRepo,
-  MergePullRequestInput,
-  OpenPullRequestInput,
   RepoTreeEntry,
-  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}`
+import { pullKey, type GitHubStoreContext } from '~/stores/github/context'
+import { createGitHubConnectionActions } from '~/stores/github/connection'
+import { createGitHubRepoActions } from '~/stores/github/repoActions'
 
 /**
  * GitHub integration state: the workspace's App installation, the projected
@@ -155,170 +151,35 @@ export const useGitHubStore = defineStore('github', () => {
     if (connected.value && repos.value.length === 0) await load()
   }
 
-  /**
-   * 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 {@link 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)
-  }
-
   /** Full file listing per repo (recursive tree), cached by GitHub numeric id. */
   const repoFiles = ref<Record<number, RepoTreeEntry[]>>({})
 
-  /**
-   * 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
-  }
-
-  /** 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
-    }
-  }
-
-  // ---- 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)
+  // The installation lifecycle + the per-repo reads/writes, split into cohesive factories
+  // sharing the state above (a size-only extraction mirroring `stores/board/` — behaviour is
+  // identical to the former in-closure functions).
+  const context: GitHubStoreContext = {
+    api,
+    workspace,
+    available,
+    connection,
+    installations,
+    loadingInstallations,
+    repos,
+    availableRepos,
+    loadingAvailable,
+    savingRepos,
+    pulls,
+    upsertPull,
+    getPull,
+    issues,
+    branches,
+    repoFiles,
+    syncing,
+    connected,
+    load,
   }
+  const connectionActions = createGitHubConnectionActions(context)
+  const repoActions = createGitHubRepoActions(context)
 
   /**
    * Drop the per-workspace projection + connection state (called on workspace switch)
@@ -365,23 +226,9 @@ export const useGitHubStore = defineStore('github', () => {
     ensureProbed,
     load,
     ensureLoaded,
-    loadAvailableRepos,
-    searchAvailableRepos,
-    setLinkedRepos,
-    loadRepoTree,
     repoFiles,
-    loadRepoFiles,
-    loadBranches,
-    getInstallUrl,
-    loadInstallations,
-    connect,
-    disconnect,
-    resync,
-    createRepo,
-    createBranch,
-    openPullRequest,
-    mergePullRequest,
-    comment,
+    ...connectionActions,
+    ...repoActions,
     reset,
   }
 })

package/app/stores/initiative/curation.ts

@@ -0,0 +1,89 @@
+import { ref } from 'vue'
+import type {
+  InitiativeExecutionPolicy,
+  PromoteInitiativeFollowUpInput,
+  UpdateInitiativeItemInput,
+} from '~/types/domain'
+import type { InitiativeActionContext } from './planning'
+
+/**
+ * The tracker-curation actions: promoting / dismissing a harvested follow-up, editing one
+ * tracker item (or driving its status), and replacing the execution policy. Every one runs
+ * through the shared `curate` wrapper so the window has a single in-flight flag.
+ */
+export function createInitiativeCurationActions(ctx: InitiativeActionContext) {
+  const { api, workspace, upsert } = ctx
+
+  /** True while a curation action (promote/dismiss/edit item/edit policy) is in flight. */
+  const curating = ref(false)
+
+  async function curate<T>(fn: () => Promise<T>): Promise<T> {
+    if (!workspace.workspaceId) throw new Error('No active workspace')
+    curating.value = true
+    try {
+      return await fn()
+    } finally {
+      curating.value = false
+    }
+  }
+
+  /** Promote an `open` harvested follow-up into a new pending tracker item. */
+  async function promoteFollowUp(
+    initiativeId: string,
+    followUpId: string,
+    input: PromoteInitiativeFollowUpInput,
+  ) {
+    return curate(async () => {
+      const updated = await api.promoteInitiativeFollowUp(
+        workspace.workspaceId!,
+        initiativeId,
+        followUpId,
+        input,
+      )
+      upsert(updated)
+      return updated
+    })
+  }
+
+  /** Dismiss a harvested follow-up. */
+  async function dismissFollowUp(initiativeId: string, followUpId: string) {
+    return curate(async () => {
+      const updated = await api.dismissInitiativeFollowUp(
+        workspace.workspaceId!,
+        initiativeId,
+        followUpId,
+      )
+      upsert(updated)
+      return updated
+    })
+  }
+
+  /** Edit one tracker item and/or drive its status (retry a blocked item / skip it). */
+  async function updateItem(
+    initiativeId: string,
+    itemId: string,
+    input: UpdateInitiativeItemInput,
+  ) {
+    return curate(async () => {
+      const updated = await api.updateInitiativeItem(
+        workspace.workspaceId!,
+        initiativeId,
+        itemId,
+        input,
+      )
+      upsert(updated)
+      return updated
+    })
+  }
+
+  /** Replace the execution policy (concurrency + pipeline rules). */
+  async function updatePolicy(initiativeId: string, policy: InitiativeExecutionPolicy) {
+    return curate(async () => {
+      const updated = await api.updateInitiativePolicy(workspace.workspaceId!, initiativeId, policy)
+      upsert(updated)
+      return updated
+    })
+  }
+
+  return { curating, promoteFollowUp, dismissFollowUp, updateItem, updatePolicy }
+}

package/app/stores/initiative/planning.ts

@@ -0,0 +1,121 @@
+import type { Ref } from 'vue'
+import { ref } from 'vue'
+import type { Initiative } from '~/types/domain'
+import { useWorkspaceStore } from '~/stores/workspace'
+
+/**
+ * Shared reactive state + injected dependencies the initiatives-store action factories close
+ * over. Created once in the `initiatives` store setup and threaded into
+ * {@link createInitiativePlanningActions} / {@link createInitiativeCurationActions} 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 InitiativeActionContext {
+  api: ReturnType<typeof useApi>
+  workspace: ReturnType<typeof useWorkspaceStore>
+  /** Patch an entity a call returned into the by-block cache (newest rev wins). */
+  upsert: (initiative: Initiative) => void
+}
+
+/**
+ * The planning-window actions: answering / dismissing the interviewer's questions, asking it to
+ * recommend an answer, and the two loop-resuming controls (continue / proceed). Owns the
+ * in-flight flags the window renders its spinners from.
+ */
+export function createInitiativePlanningActions(ctx: InitiativeActionContext) {
+  const { api, workspace, upsert } = ctx
+
+  /** True while a planning-window action (continue/proceed) is resuming the run. */
+  const resuming = ref(false)
+  /** Question ids the interviewer is currently drafting a recommendation for (window spinner). */
+  const recommending: Ref<Set<string>> = ref(new Set())
+
+  /** Record the human's answer to one pending interview question (no run resume). */
+  async function answerQuestion(blockId: string, questionId: string, answer: string) {
+    if (!workspace.workspaceId) throw new Error('No active workspace')
+    const updated = await api.answerInitiativeQuestion(
+      workspace.workspaceId,
+      blockId,
+      questionId,
+      answer,
+    )
+    upsert(updated)
+    return updated
+  }
+
+  /** Mark a planning question not-relevant (`dismissed`) or reopen it (no run resume). */
+  async function setQuestionStatus(
+    blockId: string,
+    questionId: string,
+    status: 'open' | 'dismissed',
+  ) {
+    if (!workspace.workspaceId) throw new Error('No active workspace')
+    const updated = await api.setInitiativeQuestionStatus(
+      workspace.workspaceId,
+      blockId,
+      questionId,
+      status,
+    )
+    upsert(updated)
+    return updated
+  }
+
+  /**
+   * Ask the interviewer to recommend a suggested answer for one pending question. Runs the
+   * interviewer LLM inline server-side; the returned entity carries the suggestion on the question.
+   * Tracks the in-flight id so the window can show a per-question spinner.
+   */
+  async function recommendAnswer(blockId: string, questionId: string) {
+    if (!workspace.workspaceId) throw new Error('No active workspace')
+    recommending.value = new Set(recommending.value).add(questionId)
+    try {
+      const updated = await api.recommendInitiativeAnswer(
+        workspace.workspaceId,
+        blockId,
+        questionId,
+      )
+      upsert(updated)
+      return updated
+    } finally {
+      const next = new Set(recommending.value)
+      next.delete(questionId)
+      recommending.value = next
+    }
+  }
+
+  /** Submit the answers and resume the interview (the interviewer re-runs, may ask more). */
+  async function continuePlanning(blockId: string) {
+    if (!workspace.workspaceId) throw new Error('No active workspace')
+    resuming.value = true
+    try {
+      const updated = await api.continueInitiativePlanning(workspace.workspaceId, blockId)
+      upsert(updated)
+      return updated
+    } finally {
+      resuming.value = false
+    }
+  }
+
+  /** Skip remaining questions: the interviewer converges and the run advances. */
+  async function proceedPlanning(blockId: string) {
+    if (!workspace.workspaceId) throw new Error('No active workspace')
+    resuming.value = true
+    try {
+      const updated = await api.proceedInitiativePlanning(workspace.workspaceId, blockId)
+      upsert(updated)
+      return updated
+    } finally {
+      resuming.value = false
+    }
+  }
+
+  return {
+    resuming,
+    recommending,
+    answerQuestion,
+    setQuestionStatus,
+    recommendAnswer,
+    continuePlanning,
+    proceedPlanning,
+  }
+}

package/app/stores/initiative.ts

@@ -1,16 +1,14 @@
 import { defineStore } from 'pinia'
 import { computed, ref } from 'vue'
-import type {
-  Initiative,
-  InitiativeExecutionPolicy,
-  InitiativePresetDescriptor,
-  InitiativePresetInputs,
-  PromoteInitiativeFollowUpInput,
-  UpdateInitiativeItemInput,
-} from '~/types/domain'
+import type { Initiative, InitiativePresetDescriptor, InitiativePresetInputs } from '~/types/domain'
 
 import { useWorkspaceStore } from '~/stores/workspace'
 import { useBoardStore } from '~/stores/board'
+import {
+  createInitiativePlanningActions,
+  type InitiativeActionContext,
+} from '~/stores/initiative/planning'
+import { createInitiativeCurationActions } from '~/stores/initiative/curation'
 
 /** The built-in generic preset id (mirrors kernel's `GENERIC_INITIATIVE_PRESET_ID`). */
 export const GENERIC_PRESET_ID = 'preset_generic'
@@ -165,91 +163,6 @@ export const useInitiativesStore = defineStore('initiatives', () => {
     }
   }
 
-  /** True while a planning-window action (continue/proceed) is resuming the run. */
-  const resuming = ref(false)
-
-  /** Record the human's answer to one pending interview question (no run resume). */
-  async function answerQuestion(blockId: string, questionId: string, answer: string) {
-    if (!workspace.workspaceId) throw new Error('No active workspace')
-    const updated = await api.answerInitiativeQuestion(
-      workspace.workspaceId,
-      blockId,
-      questionId,
-      answer,
-    )
-    upsert(updated)
-    return updated
-  }
-
-  /** Question ids the interviewer is currently drafting a recommendation for (window spinner). */
-  const recommending = ref<Set<string>>(new Set())
-
-  /** Mark a planning question not-relevant (`dismissed`) or reopen it (no run resume). */
-  async function setQuestionStatus(
-    blockId: string,
-    questionId: string,
-    status: 'open' | 'dismissed',
-  ) {
-    if (!workspace.workspaceId) throw new Error('No active workspace')
-    const updated = await api.setInitiativeQuestionStatus(
-      workspace.workspaceId,
-      blockId,
-      questionId,
-      status,
-    )
-    upsert(updated)
-    return updated
-  }
-
-  /**
-   * Ask the interviewer to recommend a suggested answer for one pending question. Runs the
-   * interviewer LLM inline server-side; the returned entity carries the suggestion on the question.
-   * Tracks the in-flight id so the window can show a per-question spinner.
-   */
-  async function recommendAnswer(blockId: string, questionId: string) {
-    if (!workspace.workspaceId) throw new Error('No active workspace')
-    recommending.value = new Set(recommending.value).add(questionId)
-    try {
-      const updated = await api.recommendInitiativeAnswer(
-        workspace.workspaceId,
-        blockId,
-        questionId,
-      )
-      upsert(updated)
-      return updated
-    } finally {
-      const next = new Set(recommending.value)
-      next.delete(questionId)
-      recommending.value = next
-    }
-  }
-
-  /** Submit the answers and resume the interview (the interviewer re-runs, may ask more). */
-  async function continuePlanning(blockId: string) {
-    if (!workspace.workspaceId) throw new Error('No active workspace')
-    resuming.value = true
-    try {
-      const updated = await api.continueInitiativePlanning(workspace.workspaceId, blockId)
-      upsert(updated)
-      return updated
-    } finally {
-      resuming.value = false
-    }
-  }
-
-  /** Skip remaining questions: the interviewer converges and the run advances. */
-  async function proceedPlanning(blockId: string) {
-    if (!workspace.workspaceId) throw new Error('No active workspace')
-    resuming.value = true
-    try {
-      const updated = await api.proceedInitiativePlanning(workspace.workspaceId, blockId)
-      upsert(updated)
-      return updated
-    } finally {
-      resuming.value = false
-    }
-  }
-
   /** True while a loop control (pause/resume/cancel) is in flight. */
   const controlling = ref(false)
 
@@ -272,76 +185,12 @@ export const useInitiativesStore = defineStore('initiatives', () => {
     }
   }
 
-  /** True while a curation action (promote/dismiss/edit item/edit policy) is in flight. */
-  const curating = ref(false)
-
-  async function curate<T>(fn: () => Promise<T>): Promise<T> {
-    if (!workspace.workspaceId) throw new Error('No active workspace')
-    curating.value = true
-    try {
-      return await fn()
-    } finally {
-      curating.value = false
-    }
-  }
-
-  /** Promote an `open` harvested follow-up into a new pending tracker item. */
-  async function promoteFollowUp(
-    initiativeId: string,
-    followUpId: string,
-    input: PromoteInitiativeFollowUpInput,
-  ) {
-    return curate(async () => {
-      const updated = await api.promoteInitiativeFollowUp(
-        workspace.workspaceId!,
-        initiativeId,
-        followUpId,
-        input,
-      )
-      upsert(updated)
-      return updated
-    })
-  }
-
-  /** Dismiss a harvested follow-up. */
-  async function dismissFollowUp(initiativeId: string, followUpId: string) {
-    return curate(async () => {
-      const updated = await api.dismissInitiativeFollowUp(
-        workspace.workspaceId!,
-        initiativeId,
-        followUpId,
-      )
-      upsert(updated)
-      return updated
-    })
-  }
-
-  /** Edit one tracker item and/or drive its status (retry a blocked item / skip it). */
-  async function updateItem(
-    initiativeId: string,
-    itemId: string,
-    input: UpdateInitiativeItemInput,
-  ) {
-    return curate(async () => {
-      const updated = await api.updateInitiativeItem(
-        workspace.workspaceId!,
-        initiativeId,
-        itemId,
-        input,
-      )
-      upsert(updated)
-      return updated
-    })
-  }
-
-  /** Replace the execution policy (concurrency + pipeline rules). */
-  async function updatePolicy(initiativeId: string, policy: InitiativeExecutionPolicy) {
-    return curate(async () => {
-      const updated = await api.updateInitiativePolicy(workspace.workspaceId!, initiativeId, policy)
-      upsert(updated)
-      return updated
-    })
-  }
+  // The planning-window + tracker-curation actions, split into cohesive factories sharing the
+  // state above (a size-only extraction mirroring `stores/board/` — behaviour is identical to the
+  // former in-closure functions). Each owns the in-flight flags its window renders.
+  const context: InitiativeActionContext = { api, workspace, upsert }
+  const planning = createInitiativePlanningActions(context)
+  const curation = createInitiativeCurationActions(context)
 
   function reset() {
     byBlock.value = {}
@@ -353,10 +202,7 @@ export const useInitiativesStore = defineStore('initiatives', () => {
     presets,
     all,
     creating,
-    resuming,
     controlling,
-    curating,
-    recommending,
     forBlock,
     presetById,
     planningPipelineIdFor,
@@ -366,16 +212,9 @@ export const useInitiativesStore = defineStore('initiatives', () => {
     create,
     probePreset,
     load,
-    answerQuestion,
-    setQuestionStatus,
-    recommendAnswer,
-    continuePlanning,
-    proceedPlanning,
     control,
-    promoteFollowUp,
-    dismissFollowUp,
-    updateItem,
-    updatePolicy,
+    ...planning,
+    ...curation,
     reset,
   }
 })