@cat-factory/app 1.0.0

package/app/stores/github.ts

@@ -0,0 +1,291 @@
+import { defineStore } from 'pinia'
+import { computed, ref } from 'vue'
+import type {
+  CreateBranchInput,
+  CreateRepoRequest,
+  GitHubAvailableRepo,
+  GitHubBranch,
+  GitHubConnection,
+  GitHubInstallationOption,
+  GitHubIssue,
+  GitHubPullRequest,
+  GitHubRepo,
+  MergePullRequestInput,
+  OpenPullRequestInput,
+  ResyncRequest,
+} from '~/types/domain'
+import { useWorkspaceStore } from '~/stores/workspace'
+
+/**
+ * GitHub integration state: the workspace's App installation, the projected
+ * repos/branches/pull-requests/issues the backend caches in D1, and the actions
+ * that connect/resync and write against the repo. `available` mirrors the
+ * backend's opt-in gate — a 503 from the connection probe means the integration
+ * is off, and the UI hides its entry points (exactly as the documents store
+ * gates on its source probe, and `auth.required` gates the login UI). Per
+ * workspace, like the board itself; nothing is persisted client-side.
+ */
+export const useGitHubStore = defineStore('github', () => {
+  const api = useApi()
+  const workspace = useWorkspaceStore()
+
+  /** null = unknown (not probed yet), true/false = integration on/off. */
+  const available = ref<boolean | null>(null)
+  /** The workspace's App installation, or null when not yet connected. */
+  const connection = ref<GitHubConnection | null>(null)
+  /** Discovered App installations for the connect picker; loaded on demand. */
+  const installations = ref<GitHubInstallationOption[]>([])
+  const loadingInstallations = ref(false)
+  const repos = ref<GitHubRepo[]>([])
+  /** Repos the installation can access, for the per-workspace link picker. */
+  const availableRepos = ref<GitHubAvailableRepo[]>([])
+  const loadingAvailable = ref(false)
+  const savingRepos = ref(false)
+  const pulls = ref<GitHubPullRequest[]>([])
+  const issues = ref<GitHubIssue[]>([])
+  /** Branches loaded lazily per repo (by GitHub numeric id). */
+  const branches = ref<Record<number, GitHubBranch[]>>({})
+  const loading = ref(false)
+  const syncing = ref(false)
+
+  const connected = computed(() => connection.value !== null)
+  /** Whether cat-factory can create repos under the connected account itself. */
+  const canCreateRepos = computed(() => connection.value?.canCreateRepos === true)
+
+  function repoFor(repoGithubId: number): GitHubRepo | undefined {
+    return repos.value.find((r) => r.githubId === repoGithubId)
+  }
+
+  /** The repo linked to a board block (its backing service repo), if any. */
+  function repoForBlock(blockId: string): GitHubRepo | undefined {
+    return repos.value.find((r) => r.blockId === blockId)
+  }
+
+  function pullsForRepo(repoGithubId: number): GitHubPullRequest[] {
+    return pulls.value.filter((p) => p.repoGithubId === repoGithubId)
+  }
+
+  function issuesForRepo(repoGithubId: number): GitHubIssue[] {
+    return issues.value.filter((i) => i.repoGithubId === repoGithubId)
+  }
+
+  /** Build the github.com URL for a repo / PR / issue from the projection row. */
+  function repoUrl(repoGithubId: number): string | null {
+    const r = repoFor(repoGithubId)
+    return r ? `https://github.com/${r.owner}/${r.name}` : null
+  }
+  function pullUrl(pr: GitHubPullRequest): string | null {
+    const base = repoUrl(pr.repoGithubId)
+    return base ? `${base}/pull/${pr.number}` : null
+  }
+  function issueUrl(issue: GitHubIssue): string | null {
+    const base = repoUrl(issue.repoGithubId)
+    return base ? `${base}/issues/${issue.number}` : null
+  }
+
+  /** Probe the integration: resolves `available` and the current connection. */
+  async function probe() {
+    if (!workspace.workspaceId) return
+    try {
+      const { connection: conn } = await api.getGitHubConnection(workspace.requireId())
+      available.value = true
+      connection.value = conn
+    } catch {
+      // 503 (integration disabled) or any error → hide the UI entry points.
+      available.value = false
+      connection.value = null
+    }
+  }
+
+  /** Load the cached repos, pull requests and issues for the workspace. */
+  async function load() {
+    if (!connected.value) return
+    loading.value = true
+    try {
+      const [r, p, i] = await Promise.all([
+        api.listGitHubRepos(workspace.requireId()),
+        api.listGitHubPullRequests(workspace.requireId()),
+        api.listGitHubIssues(workspace.requireId()),
+      ])
+      repos.value = r
+      pulls.value = p
+      issues.value = i
+    } finally {
+      loading.value = false
+    }
+  }
+
+  /**
+   * Ensure the projection (repos/PRs/issues) is loaded at least once — for views
+   * that need it without opening the GitHub panel (e.g. the inspector's repo link).
+   * Probes the integration first if it hasn't been yet.
+   */
+  async function ensureLoaded() {
+    if (available.value === null) await probe()
+    if (connected.value && repos.value.length === 0) await load()
+  }
+
+  /** Load the repos the installation can access, with this workspace's link state. */
+  async function loadAvailableRepos() {
+    if (!connected.value) return
+    loadingAvailable.value = true
+    try {
+      availableRepos.value = await api.listGitHubAvailableRepos(workspace.requireId())
+    } finally {
+      loadingAvailable.value = false
+    }
+  }
+
+  /** 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
+  }
+
+  /** 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: CreateRepoRequest) {
+    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)
+    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)
+    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 i = pulls.value.findIndex((p) => p.repoGithubId === repoGithubId && p.number === number)
+    if (i >= 0) pulls.value[i] = { ...pulls.value[i]!, state: 'closed', merged: true }
+  }
+
+  function comment(repoGithubId: number, number: number, body: string) {
+    return api.commentGitHubIssue(workspace.requireId(), repoGithubId, number, body)
+  }
+
+  return {
+    available,
+    connection,
+    installations,
+    loadingInstallations,
+    repos,
+    availableRepos,
+    loadingAvailable,
+    savingRepos,
+    pulls,
+    issues,
+    branches,
+    loading,
+    syncing,
+    connected,
+    canCreateRepos,
+    repoFor,
+    repoForBlock,
+    pullsForRepo,
+    issuesForRepo,
+    repoUrl,
+    pullUrl,
+    issueUrl,
+    probe,
+    load,
+    ensureLoaded,
+    loadAvailableRepos,
+    setLinkedRepos,
+    loadBranches,
+    getInstallUrl,
+    loadInstallations,
+    connect,
+    disconnect,
+    resync,
+    createRepo,
+    createBranch,
+    openPullRequest,
+    mergePullRequest,
+    comment,
+  }
+})

package/app/stores/models.ts

@@ -0,0 +1,48 @@
+import { defineStore } from 'pinia'
+import { ref, computed } from 'vue'
+import type { ModelOption } from '~/types/domain'
+
+/**
+ * The model picker catalog. Served by `GET /models`, where each model is already
+ * resolved to the flavour in use for this deployment (direct when the provider's
+ * key is configured, else the Cloudflare fallback). Fetched once and cached for
+ * the per-block picker, and used to label which model produced a step's output.
+ */
+export const useModelsStore = defineStore('models', () => {
+  const api = useApi()
+  const models = ref<ModelOption[]>([])
+  const loaded = ref(false)
+
+  /** Fetch the catalog once; subsequent calls are no-ops. */
+  async function ensureLoaded() {
+    if (loaded.value) return
+    models.value = await api.getModels()
+    loaded.value = true
+  }
+
+  const byId = computed(() => {
+    const map = new Map<string, ModelOption>()
+    for (const m of models.value) map.set(m.id, m)
+    return map
+  })
+
+  function getModel(id: string | undefined) {
+    return id ? byId.value.get(id) : undefined
+  }
+
+  /**
+   * Friendly label for a recorded `provider:model` identifier (as carried on a
+   * pipeline step). Matches it against the catalog's effective refs; falls back
+   * to the bare model id for anything not in the catalog (e.g. a pinned override).
+   */
+  function labelForRef(ref: string | undefined): string | undefined {
+    if (!ref) return undefined
+    const idx = ref.indexOf(':')
+    const provider = idx === -1 ? ref : ref.slice(0, idx)
+    const model = idx === -1 ? '' : ref.slice(idx + 1)
+    const hit = models.value.find((m) => m.provider === provider && m.model === model)
+    return hit ? `${hit.label} · ${hit.providerLabel}` : model || ref
+  }
+
+  return { models, loaded, ensureLoaded, byId, getModel, labelForRef }
+})

package/app/stores/pipelines.ts

@@ -0,0 +1,77 @@
+import { defineStore } from 'pinia'
+import { ref } from 'vue'
+import type { AgentKind, Pipeline } from '~/types/domain'
+import { useWorkspaceStore } from '~/stores/workspace'
+
+/**
+ * Saved, reusable pipelines (the pipeline palette) plus the in-progress draft
+ * being assembled in the pipeline builder. Saved pipelines live on the backend;
+ * the draft is transient client state.
+ */
+export const usePipelinesStore = defineStore('pipelines', () => {
+  const api = useApi()
+  const pipelines = ref<Pipeline[]>([])
+
+  /** The chain currently being assembled in the builder. */
+  const draft = ref<AgentKind[]>([])
+  const draftName = ref('New pipeline')
+
+  /** Replace the cached pipelines with a server snapshot. */
+  function hydrate(next: Pipeline[]) {
+    pipelines.value = next
+  }
+
+  function getPipeline(id: string) {
+    return pipelines.value.find((p) => p.id === id)
+  }
+
+  function addToDraft(kind: AgentKind) {
+    draft.value.push(kind)
+  }
+
+  function removeFromDraft(index: number) {
+    draft.value.splice(index, 1)
+  }
+
+  function moveInDraft(from: number, to: number) {
+    if (to < 0 || to >= draft.value.length) return
+    const [item] = draft.value.splice(from, 1)
+    if (item) draft.value.splice(to, 0, item)
+  }
+
+  function clearDraft() {
+    draft.value = []
+    draftName.value = 'New pipeline'
+  }
+
+  /** Persist the draft as a new pipeline on the backend. */
+  async function saveDraft(): Promise<Pipeline | null> {
+    if (draft.value.length === 0) return null
+    const pipeline = await api.createPipeline(useWorkspaceStore().requireId(), {
+      name: draftName.value.trim() || 'Untitled pipeline',
+      agentKinds: [...draft.value],
+    })
+    pipelines.value.push(pipeline)
+    clearDraft()
+    return pipeline
+  }
+
+  async function removePipeline(id: string) {
+    await api.removePipeline(useWorkspaceStore().requireId(), id)
+    pipelines.value = pipelines.value.filter((p) => p.id !== id)
+  }
+
+  return {
+    pipelines,
+    draft,
+    draftName,
+    hydrate,
+    getPipeline,
+    addToDraft,
+    removeFromDraft,
+    moveInDraft,
+    clearDraft,
+    saveDraft,
+    removePipeline,
+  }
+})

package/app/stores/requirements.ts

@@ -0,0 +1,133 @@
+import { defineStore } from 'pinia'
+import { ref } from 'vue'
+import type { RequirementReview, ReviewItemStatus } from '~/types/requirements'
+import { useWorkspaceStore } from '~/stores/workspace'
+import { useBoardStore } from '~/stores/board'
+
+/**
+ * Requirements-review state: the stateless reviewer agent's findings per block.
+ * A review is generated synchronously (the LLM runs inline server-side and the
+ * items come back in the response), so — unlike executions/bootstraps — there is
+ * no real-time stream; every mutation returns the updated review and we patch the
+ * local cache from it. `available` mirrors the backend's opt-in gate: a 503 from
+ * the review probe means the feature is off and the UI hides its entry points.
+ * Per-workspace; nothing is persisted client-side.
+ */
+export const useRequirementsStore = defineStore('requirements', () => {
+  const api = useApi()
+  const workspace = useWorkspaceStore()
+  const board = useBoardStore()
+
+  /** 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 review is being (re)generated. */
+  const reviewing = ref<Set<string>>(new Set())
+  /** Review ids currently incorporating their answers. */
+  const incorporating = ref<Set<string>>(new Set())
+
+  function reviewFor(blockId: string): RequirementReview | null {
+    return reviews.value[blockId] ?? null
+  }
+  function isReviewing(blockId: string): boolean {
+    return reviewing.value.has(blockId)
+  }
+  function isIncorporating(reviewId: string): boolean {
+    return incorporating.value.has(reviewId)
+  }
+
+  /** Open items still needing a human (everything not resolved/dismissed). */
+  function openCount(review: RequirementReview): number {
+    return review.items.filter((i) => i.status !== 'resolved' && i.status !== 'dismissed').length
+  }
+  /** Whether every item is settled, so the answers can be incorporated. */
+  function allSettled(review: RequirementReview): boolean {
+    return review.items.length > 0 && openCount(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
+    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
+    }
+  }
+
+  /** Run a fresh review of a block's collected requirements. */
+  async function review(blockId: string): Promise<RequirementReview> {
+    withFlag(reviewing, blockId, true)
+    try {
+      const result = await api.reviewRequirements(workspace.requireId(), blockId)
+      available.value = true
+      store(result)
+      return result
+    } finally {
+      withFlag(reviewing, blockId, false)
+    }
+  }
+
+  /** 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 (resolve / dismiss / reopen). */
+  async function setItemStatus(
+    review: RequirementReview,
+    itemId: string,
+    status: ReviewItemStatus,
+  ) {
+    store(await api.setRequirementItemStatus(workspace.requireId(), review.id, itemId, status))
+  }
+
+  /**
+   * Fold the answers back into the block's requirements. Patches the board with
+   * the returned (rewritten) block so the inspector/description reflect it.
+   */
+  async function incorporate(review: RequirementReview) {
+    withFlag(incorporating, review.id, true)
+    try {
+      const { review: updated, block } = await api.incorporateRequirements(
+        workspace.requireId(),
+        review.id,
+      )
+      store(updated)
+      board.upsert(block)
+      return { review: updated, block }
+    } finally {
+      withFlag(incorporating, review.id, false)
+    }
+  }
+
+  return {
+    available,
+    reviews,
+    reviewFor,
+    isReviewing,
+    isIncorporating,
+    openCount,
+    allSettled,
+    load,
+    review,
+    reply,
+    setItemStatus,
+    incorporate,
+  }
+})

package/app/stores/scenarios.spec.ts

@@ -0,0 +1,82 @@
+import { describe, it, expect, beforeEach } from 'vitest'
+import { useScenariosStore } from '~/stores/scenarios'
+
+describe('scenarios store', () => {
+  let store: ReturnType<typeof useScenariosStore>
+  beforeEach(() => {
+    store = useScenariosStore()
+  })
+
+  it('drafts the standard set of scenarios for a feature', () => {
+    const created = store.generateForFeature('Login')
+    expect(created).toHaveLength(3)
+    expect(store.scenariosForFeature('Login')).toHaveLength(3)
+    // Each is a Given/When/Then with the feature folded in.
+    const happy = created[0]!
+    expect(happy.feature).toBe('Login')
+    expect(happy.when.join(' ')).toContain('Login')
+    expect(happy.then.length).toBeGreaterThan(0)
+    expect(happy.source).toBe('generated')
+  })
+
+  it('is additive: re-drafting only fills gaps and never duplicates', () => {
+    store.generateForFeature('Login')
+    const again = store.generateForFeature('Login')
+    expect(again).toHaveLength(0)
+    expect(store.scenariosForFeature('Login')).toHaveLength(3)
+
+    // A removed scenario is re-created on the next draft, the rest are kept.
+    const removed = store.scenariosForFeature('Login')[1]!
+    store.removeScenario(removed.id)
+    const refilled = store.generateForFeature('Login')
+    expect(refilled).toHaveLength(1)
+    expect(store.scenariosForFeature('Login')).toHaveLength(3)
+  })
+
+  it('matches features case- and whitespace-insensitively', () => {
+    store.generateForFeature('User  Login')
+    expect(store.hasScenarios('user login')).toBe(true)
+    expect(store.scenariosForFeature('USER LOGIN')).toHaveLength(3)
+  })
+
+  it('folds linked requirements into the generated Given', () => {
+    const [happy] = store.generateForFeature('Checkout', { requirements: ['Payments PRD'] })
+    expect(happy!.given.join(' ')).toContain('Payments PRD')
+  })
+
+  it('collects scenarios across all of a block features', () => {
+    store.generateForFeature('Login')
+    store.generateForFeature('Logout')
+    const forBlock = store.scenariosForBlock({ features: ['Login', 'Logout'] })
+    expect(forBlock).toHaveLength(6)
+    expect(store.scenariosForBlock({ features: [] })).toHaveLength(0)
+  })
+
+  it('generates Playwright tests only for scenarios that lack one (idempotent)', () => {
+    store.generateForFeature('Login')
+    expect(store.untested('Login')).toBe(3)
+
+    const first = store.generatePlaywrightTests('Login')
+    expect(first).toHaveLength(3)
+    expect(store.untested('Login')).toBe(0)
+    expect(store.scenariosForFeature('Login').every((s) => s.hasPlaywrightTest)).toBe(true)
+
+    // Re-running creates nothing new...
+    expect(store.generatePlaywrightTests('Login')).toHaveLength(0)
+
+    // ...but a freshly added scenario does get a test on the next run.
+    store.addScenario({ feature: 'Login', title: 'Login: remember me' })
+    expect(store.untested('Login')).toBe(1)
+    expect(store.generatePlaywrightTests('Login')).toHaveLength(1)
+  })
+
+  it('edits and removes scenarios', () => {
+    const scenario = store.addScenario({ feature: 'Login', title: 'Draft' })
+    store.updateScenario(scenario.id, { title: 'Renamed', status: 'approved' })
+    expect(store.scenariosForFeature('Login')[0]!.title).toBe('Renamed')
+    expect(store.scenariosForFeature('Login')[0]!.status).toBe('approved')
+
+    store.removeScenario(scenario.id)
+    expect(store.scenariosForFeature('Login')).toHaveLength(0)
+  })
+})