@cat-factory/app 0.6.0

package/app/stores/slack.ts

@@ -0,0 +1,142 @@
+import { defineStore } from 'pinia'
+import { computed, ref } from 'vue'
+import type {
+  SlackChannel,
+  SlackConnection,
+  SlackMemberMappingEntry,
+  SlackNotificationSettings,
+} from '~/types/domain'
+import { useWorkspaceStore } from '~/stores/workspace'
+
+/**
+ * Slack integration state: the account's connection (an extra delivery transport
+ * for the notification mechanism), the per-workspace notification routing, the
+ * channel picker, and the per-account @-mention member map. `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 GitHub and
+ * documents stores gate on their probes). Nothing is persisted client-side.
+ */
+export const useSlackStore = defineStore('slack', () => {
+  const api = useApi()
+  const workspace = useWorkspaceStore()
+
+  /** null = unknown (not probed yet), true/false = integration on/off. */
+  const available = ref<boolean | null>(null)
+  /** The account's Slack connection, or null when not connected. */
+  const connection = ref<SlackConnection | null>(null)
+  /** Whether the OAuth "Add to Slack" flow is configured (else paste a token). */
+  const oauthEnabled = ref(false)
+  /** The workspace's notification routing, loaded on demand. */
+  const settings = ref<SlackNotificationSettings | null>(null)
+  /** Channels for the routing picker, loaded on demand. */
+  const channels = ref<SlackChannel[]>([])
+  const loadingChannels = ref(false)
+  /** The account's GitHub→Slack member map, loaded on demand. */
+  const memberMapping = ref<SlackMemberMappingEntry[]>([])
+  const connecting = ref(false)
+  const saving = ref(false)
+
+  const connected = computed(() => connection.value !== null)
+
+  /**
+   * Probe the integration: a 503 (or any error) on the connection read means Slack
+   * is off — hide the UI. On success, capture the connection + whether OAuth is
+   * available. Called on workspace change, like the GitHub probe.
+   */
+  async function probe() {
+    try {
+      const { connection: conn, oauthEnabled: oauth } = await api.getSlackConnection(
+        workspace.requireId(),
+      )
+      available.value = true
+      connection.value = conn
+      oauthEnabled.value = oauth
+    } catch {
+      available.value = false
+      connection.value = null
+    }
+  }
+
+  /** Resolve the "Add to Slack" OAuth URL (only when oauthEnabled). */
+  function installUrl(): Promise<string> {
+    return api.getSlackInstallUrl(workspace.requireId()).then((r) => r.url)
+  }
+
+  /** Connect by pasting a bot token (the always-available fallback). */
+  async function connectWithToken(token: string) {
+    connecting.value = true
+    try {
+      connection.value = await api.connectSlack(workspace.requireId(), token)
+    } finally {
+      connecting.value = false
+    }
+  }
+
+  async function disconnect() {
+    await api.disconnectSlack(workspace.requireId())
+    connection.value = null
+    channels.value = []
+  }
+
+  async function loadChannels() {
+    loadingChannels.value = true
+    try {
+      channels.value = (await api.listSlackChannels(workspace.requireId())).channels
+    } finally {
+      loadingChannels.value = false
+    }
+  }
+
+  async function loadSettings() {
+    settings.value = await api.getSlackSettings(workspace.requireId())
+  }
+
+  async function updateSettings(body: {
+    routes: SlackNotificationSettings['routes']
+    mentionsEnabled: boolean
+  }) {
+    saving.value = true
+    try {
+      settings.value = await api.updateSlackSettings(workspace.requireId(), body)
+    } finally {
+      saving.value = false
+    }
+  }
+
+  async function loadMemberMapping() {
+    memberMapping.value = (await api.getSlackMemberMapping(workspace.requireId())).entries
+  }
+
+  async function updateMemberMapping(entries: SlackMemberMappingEntry[]) {
+    saving.value = true
+    try {
+      memberMapping.value = (
+        await api.updateSlackMemberMapping(workspace.requireId(), entries)
+      ).entries
+    } finally {
+      saving.value = false
+    }
+  }
+
+  return {
+    available,
+    connection,
+    oauthEnabled,
+    settings,
+    channels,
+    loadingChannels,
+    memberMapping,
+    connecting,
+    saving,
+    connected,
+    probe,
+    installUrl,
+    connectWithToken,
+    disconnect,
+    loadChannels,
+    loadSettings,
+    updateSettings,
+    loadMemberMapping,
+    updateMemberMapping,
+  }
+})

package/app/stores/taskExpansion.ts

@@ -0,0 +1,36 @@
+import { defineStore } from 'pinia'
+import { ref } from 'vue'
+
+/**
+ * Which task cards may expand their full build-pipeline list once zoomed in.
+ *
+ * Deep-zoom (`steps`/`subtasks`) grows a task card downward, and cards are
+ * absolutely positioned in their frame, so several expanded cards stacked
+ * vertically pile on top of each other. The board driver (`useTaskExpansion`)
+ * recomputes a permitted set every frame — only on-screen cards, and only the
+ * one closest to the screen centre when two would overlap — and writes it here.
+ * `TaskPipelineMini` reads `canExpand` to decide whether to expand or stay compact.
+ *
+ * `driverActive` lets the gate degrade gracefully: with no board driver mounted
+ * (e.g. a card rendered in isolation) `canExpand` falls back to "allowed", so the
+ * plain zoom behaviour is unchanged.
+ */
+export const useTaskExpansionStore = defineStore('taskExpansion', () => {
+  const allowed = ref<Set<string>>(new Set())
+  const driverActive = ref(false)
+
+  function setAllowed(ids: Set<string>) {
+    allowed.value = ids
+  }
+
+  function setDriverActive(active: boolean) {
+    driverActive.value = active
+    if (!active) allowed.value = new Set()
+  }
+
+  function canExpand(id: string) {
+    return driverActive.value ? allowed.value.has(id) : true
+  }
+
+  return { allowed, driverActive, setAllowed, setDriverActive, canExpand }
+})

package/app/stores/tasks.spec.ts

@@ -0,0 +1,71 @@
+import { describe, it, expect, beforeEach } from 'vitest'
+import type { SourceTask, TaskConnection, TaskSourceDescriptor } from '~/types/domain'
+import { useTasksStore } from '~/stores/tasks'
+
+/** Minimal SourceTask factory — only the fields the read getters care about. */
+function sourceTask(externalId: string, over: Partial<SourceTask> = {}): SourceTask {
+  return {
+    source: 'jira',
+    externalId,
+    title: externalId,
+    url: `https://acme.atlassian.net/browse/${externalId}`,
+    status: 'To Do',
+    type: 'Task',
+    assignee: null,
+    priority: null,
+    labels: [],
+    description: '',
+    comments: [],
+    excerpt: '',
+    linkedBlockId: null,
+    syncedAt: 0,
+    ...over,
+  }
+}
+
+const jiraDescriptor: TaskSourceDescriptor = {
+  source: 'jira',
+  label: 'Jira',
+  icon: 'i-lucide-square-check',
+  credentialFields: [],
+  refLabel: 'Issue key or URL',
+  refPlaceholder: 'PROJ-123',
+}
+
+const jiraConnection: TaskConnection = { source: 'jira', label: 'acme', connectedAt: 0 }
+
+describe('tasks store read getters', () => {
+  let store: ReturnType<typeof useTasksStore>
+  beforeEach(() => {
+    store = useTasksStore()
+  })
+
+  it('tasksForBlock returns only issues linked to the block', () => {
+    store.tasks = [
+      sourceTask('PROJ-1', { linkedBlockId: 'b1' }),
+      sourceTask('PROJ-2', { linkedBlockId: 'b2' }),
+      sourceTask('PROJ-3', { linkedBlockId: null }),
+    ]
+    expect(store.tasksForBlock('b1').map((t) => t.externalId)).toEqual(['PROJ-1'])
+    expect(store.tasksForBlock('bX')).toEqual([])
+  })
+
+  it('isConnected / connectedSources / anyConnected reflect connections', () => {
+    store.sources = [jiraDescriptor]
+    expect(store.anyConnected).toBe(false)
+    expect(store.isConnected('jira')).toBe(false)
+    expect(store.connectedSources).toEqual([])
+
+    store.connections = [jiraConnection]
+    expect(store.anyConnected).toBe(true)
+    expect(store.isConnected('jira')).toBe(true)
+    expect(store.connectedSources.map((s) => s.source)).toEqual(['jira'])
+  })
+
+  it('descriptorFor / connectionFor resolve by source', () => {
+    store.sources = [jiraDescriptor]
+    store.connections = [jiraConnection]
+    expect(store.descriptorFor('jira')?.label).toBe('Jira')
+    expect(store.connectionFor('jira')?.label).toBe('acme')
+  })
+})

package/app/stores/tasks.ts

@@ -0,0 +1,176 @@
+import { defineStore } from 'pinia'
+import { computed, ref } from 'vue'
+import type {
+  SourceTask,
+  TaskConnection,
+  TaskSearchResult,
+  TaskSourceDescriptor,
+  TaskSourceKind,
+} from '~/types/domain'
+import { useWorkspaceStore } from '~/stores/workspace'
+
+/**
+ * Task-source integration state: the trackers the backend offers (and their
+ * connect metadata), the workspace's per-source connections, and the issues it
+ * has imported — plus the actions that connect/import/link against the backend.
+ * `available` mirrors the backend's opt-in gate: a 503 from the source probe
+ * means the integration is off, and the UI hides its entry points (just as the
+ * documents store does). The abstraction is source-agnostic; every action is
+ * keyed by a `TaskSourceKind`. Per-workspace; nothing is persisted client-side.
+ *
+ * Unlike documents there is no plan/spawn — an issue is linked to a block for
+ * agent context, never expanded into board structure.
+ */
+export const useTasksStore = defineStore('tasks', () => {
+  const api = useApi()
+  const workspace = useWorkspaceStore()
+
+  /** null = unknown (not probed yet), true/false = integration on/off. */
+  const available = ref<boolean | null>(null)
+  /** The configured sources and their connect/import descriptors. */
+  const sources = ref<TaskSourceDescriptor[]>([])
+  /** Live connections, one per connected source. */
+  const connections = ref<TaskConnection[]>([])
+  const tasks = ref<SourceTask[]>([])
+  const loading = ref(false)
+
+  /** Sources the workspace currently has a live connection to. */
+  const connectedSources = computed(() =>
+    sources.value.filter((s) => connections.value.some((c) => c.source === s.source)),
+  )
+  const anyConnected = computed(() => connections.value.length > 0)
+
+  function descriptorFor(source: TaskSourceKind): TaskSourceDescriptor | undefined {
+    return sources.value.find((s) => s.source === source)
+  }
+
+  function connectionFor(source: TaskSourceKind): TaskConnection | undefined {
+    return connections.value.find((c) => c.source === source)
+  }
+
+  function isConnected(source: TaskSourceKind): boolean {
+    return connectionFor(source) !== undefined
+  }
+
+  /** Imported issues currently attached to a given block. */
+  function tasksForBlock(blockId: string): SourceTask[] {
+    return tasks.value.filter((t) => t.linkedBlockId === blockId)
+  }
+
+  /** Merge an issue returned by the backend into the local cache. */
+  function upsertTask(task: SourceTask) {
+    const i = tasks.value.findIndex(
+      (t) => t.source === task.source && t.externalId === task.externalId,
+    )
+    if (i >= 0) tasks.value[i] = task
+    else tasks.value.unshift(task)
+  }
+
+  function upsertConnection(conn: TaskConnection) {
+    const i = connections.value.findIndex((c) => c.source === conn.source)
+    if (i >= 0) connections.value[i] = conn
+    else connections.value.push(conn)
+  }
+
+  /** Probe the integration: resolves `available`, the sources and connections. */
+  async function probe() {
+    if (!workspace.workspaceId) return
+    try {
+      const [{ sources: srcs }, { connections: conns }] = await Promise.all([
+        api.listTaskSources(workspace.requireId()),
+        api.listTaskConnections(workspace.requireId()),
+      ])
+      available.value = true
+      sources.value = srcs
+      connections.value = conns
+    } catch {
+      // 503 (integration disabled) or any error → hide the UI entry points.
+      available.value = false
+      sources.value = []
+      connections.value = []
+    }
+  }
+
+  /** Connect the workspace to a source with its credential bag. */
+  async function connect(source: TaskSourceKind, credentials: Record<string, string>) {
+    const conn = await api.connectTaskSource(workspace.requireId(), source, credentials)
+    upsertConnection(conn)
+    available.value = true
+  }
+
+  /** Disconnect the workspace from a source. */
+  async function disconnect(source: TaskSourceKind) {
+    await api.disconnectTaskSource(workspace.requireId(), source)
+    connections.value = connections.value.filter((c) => c.source !== source)
+  }
+
+  /** Load the imported issues for the workspace (across sources). */
+  async function loadTasks() {
+    tasks.value = await api.listTasks(workspace.requireId())
+  }
+
+  /** Import (fetch + persist) an issue by key or URL from a source. */
+  async function importTask(source: TaskSourceKind, ref: string): Promise<SourceTask> {
+    loading.value = true
+    try {
+      const task = await api.importTask(workspace.requireId(), source, { ref })
+      upsertTask(task)
+      return task
+    } finally {
+      loading.value = false
+    }
+  }
+
+  /** Search a connected tracker's issues by free text (title/content). */
+  async function search(source: TaskSourceKind, query: string): Promise<TaskSearchResult[]> {
+    const { results } = await api.searchTaskSource(workspace.requireId(), source, query)
+    return results
+  }
+
+  /** Attach an imported issue to a block as agent context. */
+  async function linkToBlock(blockId: string, source: TaskSourceKind, externalId: string) {
+    const task = await api.linkTask(workspace.requireId(), { source, externalId, blockId })
+    upsertTask(task)
+    return task
+  }
+
+  /**
+   * Create a new board task from an imported issue inside a container, linking the
+   * issue to it for context. The caller upserts the returned block onto the board.
+   */
+  async function createTaskFromIssue(
+    source: TaskSourceKind,
+    externalId: string,
+    containerId: string,
+  ) {
+    const result = await api.createTaskFromIssue(workspace.requireId(), {
+      source,
+      externalId,
+      containerId,
+    })
+    upsertTask(result.task)
+    return result
+  }
+
+  return {
+    available,
+    sources,
+    connections,
+    tasks,
+    loading,
+    connectedSources,
+    anyConnected,
+    descriptorFor,
+    connectionFor,
+    isConnected,
+    tasksForBlock,
+    probe,
+    connect,
+    disconnect,
+    loadTasks,
+    importTask,
+    search,
+    linkToBlock,
+    createTaskFromIssue,
+  }
+})

package/app/stores/tracker.ts

@@ -0,0 +1,27 @@
+import { defineStore } from 'pinia'
+import { ref } from 'vue'
+import type { PutTrackerSettingsInput, TrackerSettings } from '~/types/tracker'
+import { useWorkspaceStore } from '~/stores/workspace'
+
+/**
+ * The workspace's issue-tracker selection (GitHub Issues or Jira) — where the
+ * tech-debt recurring pipeline files its ticket. Hydrated from the snapshot;
+ * edited inline when configuring a tech-debt recurring pipeline.
+ */
+export const useTrackerStore = defineStore('tracker', () => {
+  const api = useApi()
+
+  const settings = ref<TrackerSettings>({ tracker: null, jiraProjectKey: null, updatedAt: 0 })
+
+  function hydrate(value: TrackerSettings | undefined) {
+    settings.value = value ?? { tracker: null, jiraProjectKey: null, updatedAt: 0 }
+  }
+
+  async function save(input: PutTrackerSettingsInput) {
+    const ws = useWorkspaceStore()
+    settings.value = await api.putTrackerSettings(ws.requireId(), input)
+    return settings.value
+  }
+
+  return { settings, hydrate, save }
+})