@cat-factory/app 1.0.0

package/app/stores/scenarios.ts

@@ -0,0 +1,196 @@
+/* eslint-disable unicorn/no-thenable -- `then` is the Gherkin clause name on plain
+   scenario data objects (a string[]), never a thenable callback; these objects
+   are never awaited. */
+import { defineStore } from 'pinia'
+import { ref, computed } from 'vue'
+import { uid } from '~/utils/catalog'
+import type { AcceptanceScenario, Block } from '~/types/domain'
+
+/** Context the acceptance agent draws on when drafting scenarios for a feature. */
+export interface ScenarioGenerationContext {
+  /** The block's free-text intent. */
+  description?: string
+  /** Titles/excerpts of linked requirement docs (PRDs), for traceable scenarios. */
+  requirements?: string[]
+}
+
+/** Normalise a feature/title into a comparable key (case- and space-insensitive). */
+function normalize(value: string): string {
+  return value.trim().toLowerCase().replace(/\s+/g, ' ')
+}
+
+/**
+ * Draft the standard set of acceptance scenarios for a feature: the happy path,
+ * an error path and an input-validation path. This mirrors what the `acceptance`
+ * agent does from requirements — deterministic here so the prototype has
+ * something concrete and editable to show. The feature name and any linked
+ * requirements are folded into the Given/When/Then so the output is specific.
+ */
+function draftScenarios(
+  feature: string,
+  context: ScenarioGenerationContext = {},
+): Omit<AcceptanceScenario, 'id' | 'createdAt'>[] {
+  const name = feature.trim()
+  const reqGiven = context.requirements?.length
+    ? [`the requirements for "${name}" (${context.requirements.join('; ')})`]
+    : []
+  const base = ['a user on the application', ...reqGiven]
+
+  return [
+    {
+      feature: name,
+      title: `${name}: happy path`,
+      given: base,
+      when: [`the user completes the "${name}" flow with valid input`],
+      then: [`the action succeeds`, `the expected result for "${name}" is shown`],
+      status: 'draft',
+      source: 'generated',
+      hasPlaywrightTest: false,
+    },
+    {
+      feature: name,
+      title: `${name}: invalid input is rejected`,
+      given: base,
+      when: [`the user attempts the "${name}" flow with invalid input`],
+      then: [`the action is rejected`, `a clear error message is shown`],
+      status: 'draft',
+      source: 'generated',
+      hasPlaywrightTest: false,
+    },
+    {
+      feature: name,
+      title: `${name}: required fields are validated`,
+      given: base,
+      when: [`the user submits the "${name}" flow with required fields missing`],
+      then: [`submission is blocked`, `each missing field is flagged`],
+      status: 'draft',
+      source: 'generated',
+      hasPlaywrightTest: false,
+    },
+  ]
+}
+
+/**
+ * The acceptance-scenario catalog. Feature-scoped Given/When/Then scenarios that
+ * the `acceptance` agent drafts from requirements and the `playwright` agent
+ * turns into e2e tests. Authored and refined client-side (persisted locally),
+ * this is the data the feature's scenario viewer renders.
+ */
+export const useScenariosStore = defineStore(
+  'scenarios',
+  () => {
+    const scenarios = ref<AcceptanceScenario[]>([])
+
+    /** Scenarios for a single feature, oldest first. */
+    function scenariosForFeature(feature: string): AcceptanceScenario[] {
+      const key = normalize(feature)
+      return scenarios.value
+        .filter((s) => normalize(s.feature) === key)
+        .sort((a, b) => a.createdAt - b.createdAt)
+    }
+
+    /** Scenarios across all of a block's features (the "current set" for a task). */
+    function scenariosForBlock(block: Pick<Block, 'features'>): AcceptanceScenario[] {
+      const features = (block.features ?? []).map(normalize)
+      if (!features.length) return []
+      const set = new Set(features)
+      return scenarios.value
+        .filter((s) => set.has(normalize(s.feature)))
+        .sort((a, b) => a.createdAt - b.createdAt)
+    }
+
+    /** True when a feature already has at least one scenario. */
+    function hasScenarios(feature: string): boolean {
+      const key = normalize(feature)
+      return scenarios.value.some((s) => normalize(s.feature) === key)
+    }
+
+    function addScenario(input: {
+      feature: string
+      title?: string
+      given?: string[]
+      when?: string[]
+      then?: string[]
+      source?: AcceptanceScenario['source']
+    }): AcceptanceScenario {
+      const scenario: AcceptanceScenario = {
+        id: uid('scn'),
+        feature: input.feature.trim(),
+        title: input.title?.trim() || 'New scenario',
+        given: input.given ?? [],
+        when: input.when ?? [],
+        then: input.then ?? [],
+        status: 'draft',
+        source: input.source ?? 'manual',
+        hasPlaywrightTest: false,
+        createdAt: Date.now(),
+      }
+      scenarios.value.push(scenario)
+      return scenario
+    }
+
+    function updateScenario(id: string, patch: Partial<AcceptanceScenario>) {
+      const scenario = scenarios.value.find((s) => s.id === id)
+      if (!scenario) return
+      Object.assign(scenario, patch)
+    }
+
+    function removeScenario(id: string) {
+      scenarios.value = scenarios.value.filter((s) => s.id !== id)
+    }
+
+    /**
+     * Draft scenarios for a feature from its requirements. Additive: titles that
+     * already exist for the feature are skipped, so re-running only fills gaps and
+     * never clobbers edits. Returns the scenarios actually created.
+     */
+    function generateForFeature(
+      feature: string,
+      context: ScenarioGenerationContext = {},
+    ): AcceptanceScenario[] {
+      const existing = new Set(scenariosForFeature(feature).map((s) => normalize(s.title)))
+      const created: AcceptanceScenario[] = []
+      for (const draft of draftScenarios(feature, context)) {
+        if (existing.has(normalize(draft.title))) continue
+        created.push(addScenario({ ...draft, source: 'generated' }))
+      }
+      return created
+    }
+
+    /**
+     * "Generate Playwright tests" for a feature. Mirrors the `playwright` agent's
+     * idempotent contract: only scenarios that don't yet have a test get one, so
+     * existing committed tests are never regenerated. Returns the scenarios for
+     * which a new test was created.
+     */
+    function generatePlaywrightTests(feature: string): AcceptanceScenario[] {
+      const created: AcceptanceScenario[] = []
+      for (const scenario of scenariosForFeature(feature)) {
+        if (scenario.hasPlaywrightTest) continue
+        scenario.hasPlaywrightTest = true
+        created.push(scenario)
+      }
+      return created
+    }
+
+    /** Count of scenarios still missing a Playwright test, for a feature. */
+    const untested = computed(
+      () => (feature: string) =>
+        scenariosForFeature(feature).filter((s) => !s.hasPlaywrightTest).length,
+    )
+
+    return {
+      scenarios,
+      scenariosForFeature,
+      scenariosForBlock,
+      hasScenarios,
+      untested,
+      addScenario,
+      updateScenario,
+      removeScenario,
+      generateForFeature,
+      generatePlaywrightTests,
+    }
+  },
+  { persist: true },
+)

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,149 @@
+import { defineStore } from 'pinia'
+import { computed, ref } from 'vue'
+import type {
+  SourceTask,
+  TaskConnection,
+  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
+    }
+  }
+
+  /** 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
+  }
+
+  return {
+    available,
+    sources,
+    connections,
+    tasks,
+    loading,
+    connectedSources,
+    anyConnected,
+    descriptorFor,
+    connectionFor,
+    isConnected,
+    tasksForBlock,
+    probe,
+    connect,
+    disconnect,
+    loadTasks,
+    importTask,
+    linkToBlock,
+  }
+})

package/app/stores/ui.ts

@@ -0,0 +1,204 @@
+import { defineStore } from 'pinia'
+import { ref, computed } from 'vue'
+import type { DocumentSourceKind, TaskSourceKind, LodLevel } from '~/types/domain'
+
+/** Transient UI state: selection, panels, zoom level. */
+export const useUiStore = defineStore('ui', () => {
+  const selectedBlockId = ref<string | null>(null)
+  const focusBlockId = ref<string | null>(null)
+  const builderOpen = ref(false)
+  const decisionContext = ref<{ instanceId: string; decisionId: string } | null>(null)
+
+  // Document-source integration modals, keyed by source. `documentImport` and
+  // `spawnPreview` carry an optional target frame, so structure spawned from a
+  // frame's inspector lands inside that frame rather than creating new top-level
+  // frames. `documentConnect` carries the source whose connect form to show;
+  // `documentImport`'s source may be null to let the modal pick a connected one.
+  const documentConnect = ref<{ source: DocumentSourceKind } | null>(null)
+  const documentImport = ref<{
+    source: DocumentSourceKind | null
+    targetFrameId: string | null
+  } | null>(null)
+  const spawnPreview = ref<{
+    source: DocumentSourceKind
+    externalId: string
+    targetFrameId: string | null
+  } | null>(null)
+
+  // Task-source integration modals, keyed by source. `taskConnect` carries the
+  // source whose connect form to show; `taskImport`'s source may be null to let
+  // the modal pick a connected one (there is no spawn target — issues are linked
+  // to a block for context, not expanded into structure).
+  const taskConnect = ref<{ source: TaskSourceKind } | null>(null)
+  const taskImport = ref<{ source: TaskSourceKind | null } | null>(null)
+
+  // Repo-bootstrap modal (manage reference architectures + launch a bootstrap).
+  const bootstrapOpen = ref(false)
+
+  // GitHub integration panel (connection management + repo/PR/issue browsing).
+  const githubOpen = ref(false)
+
+  // Prompt-fragment library panel (manage the board's best-practice catalog +
+  // linked guideline repos; ADR 0006).
+  const fragmentLibraryOpen = ref(false)
+
+  // Requirements-review panel: the block whose requirements review (questions /
+  // gaps / clarifications) to show, or null when closed.
+  const requirementReviewBlockId = ref<string | null>(null)
+
+  /** Current canvas zoom (driven by Vue Flow viewport). */
+  const zoom = ref(1)
+
+  const lod = computed<LodLevel>(() => {
+    if (zoom.value < 0.6) return 'far'
+    if (zoom.value < 1.2) return 'mid'
+    return 'close'
+  })
+
+  /** Frames the user has manually expanded to reveal their tasks. */
+  const expandedFrames = ref<Set<string>>(new Set())
+
+  function toggleFrame(id: string) {
+    const next = new Set(expandedFrames.value)
+    if (next.has(id)) next.delete(id)
+    else next.add(id)
+    expandedFrames.value = next
+  }
+
+  function expandFrame(id: string) {
+    if (expandedFrames.value.has(id)) return
+    expandedFrames.value = new Set(expandedFrames.value).add(id)
+  }
+
+  /** A frame shows its tasks when manually expanded OR when zoomed in close. */
+  function isFrameExpanded(id: string) {
+    return expandedFrames.value.has(id) || lod.value === 'close'
+  }
+
+  function select(id: string | null) {
+    selectedBlockId.value = id
+  }
+
+  function focus(id: string | null) {
+    focusBlockId.value = id
+  }
+
+  function openBuilder() {
+    builderOpen.value = true
+  }
+
+  function openDecision(instanceId: string, decisionId: string) {
+    decisionContext.value = { instanceId, decisionId }
+  }
+
+  function closeDecision() {
+    decisionContext.value = null
+  }
+
+  function openDocumentConnect(source: DocumentSourceKind) {
+    documentConnect.value = { source }
+  }
+  function closeDocumentConnect() {
+    documentConnect.value = null
+  }
+  function openDocumentImport(
+    targetFrameId: string | null = null,
+    source: DocumentSourceKind | null = null,
+  ) {
+    documentImport.value = { source, targetFrameId }
+  }
+  function closeDocumentImport() {
+    documentImport.value = null
+  }
+  function openSpawnPreview(
+    source: DocumentSourceKind,
+    externalId: string,
+    targetFrameId: string | null = null,
+  ) {
+    spawnPreview.value = { source, externalId, targetFrameId }
+  }
+  function closeSpawnPreview() {
+    spawnPreview.value = null
+  }
+  function openTaskConnect(source: TaskSourceKind) {
+    taskConnect.value = { source }
+  }
+  function closeTaskConnect() {
+    taskConnect.value = null
+  }
+  function openTaskImport(source: TaskSourceKind | null = null) {
+    taskImport.value = { source }
+  }
+  function closeTaskImport() {
+    taskImport.value = null
+  }
+  function openBootstrap() {
+    bootstrapOpen.value = true
+  }
+  function closeBootstrap() {
+    bootstrapOpen.value = false
+  }
+  function openGitHub() {
+    githubOpen.value = true
+  }
+  function closeGitHub() {
+    githubOpen.value = false
+  }
+  function openFragmentLibrary() {
+    fragmentLibraryOpen.value = true
+  }
+  function closeFragmentLibrary() {
+    fragmentLibraryOpen.value = false
+  }
+  function openRequirementReview(blockId: string) {
+    requirementReviewBlockId.value = blockId
+  }
+  function closeRequirementReview() {
+    requirementReviewBlockId.value = null
+  }
+
+  return {
+    selectedBlockId,
+    focusBlockId,
+    builderOpen,
+    decisionContext,
+    documentConnect,
+    documentImport,
+    spawnPreview,
+    taskConnect,
+    taskImport,
+    bootstrapOpen,
+    githubOpen,
+    fragmentLibraryOpen,
+    requirementReviewBlockId,
+    zoom,
+    lod,
+    expandedFrames,
+    toggleFrame,
+    expandFrame,
+    isFrameExpanded,
+    select,
+    focus,
+    openBuilder,
+    openDecision,
+    closeDecision,
+    openDocumentConnect,
+    closeDocumentConnect,
+    openDocumentImport,
+    closeDocumentImport,
+    openSpawnPreview,
+    closeSpawnPreview,
+    openTaskConnect,
+    closeTaskConnect,
+    openTaskImport,
+    closeTaskImport,
+    openBootstrap,
+    closeBootstrap,
+    openGitHub,
+    closeGitHub,
+    openFragmentLibrary,
+    closeFragmentLibrary,
+    openRequirementReview,
+    closeRequirementReview,
+  }
+})