@cat-factory/app 1.0.0

package/app/stores/documents.ts

@@ -0,0 +1,165 @@
+import { defineStore } from 'pinia'
+import { computed, ref } from 'vue'
+import type {
+  DocumentBoardPlan,
+  DocumentConnection,
+  DocumentSourceDescriptor,
+  DocumentSourceKind,
+  SourceDocument,
+} from '~/types/domain'
+import { useWorkspaceStore } from '~/stores/workspace'
+
+/**
+ * Document-source integration state: the sources the backend offers (and their
+ * connect metadata), the workspace's per-source connections, and the pages it
+ * has imported — plus the actions that connect/import/plan/spawn/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
+ * `auth.required` gates the login UI). The abstraction is source-agnostic; every
+ * action is keyed by a `DocumentSourceKind`. Per-workspace, like the board
+ * itself; nothing is persisted client-side.
+ */
+export const useDocumentsStore = defineStore('documents', () => {
+  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<DocumentSourceDescriptor[]>([])
+  /** Live connections, one per connected source. */
+  const connections = ref<DocumentConnection[]>([])
+  const documents = ref<SourceDocument[]>([])
+  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: DocumentSourceKind): DocumentSourceDescriptor | undefined {
+    return sources.value.find((s) => s.source === source)
+  }
+
+  function connectionFor(source: DocumentSourceKind): DocumentConnection | undefined {
+    return connections.value.find((c) => c.source === source)
+  }
+
+  function isConnected(source: DocumentSourceKind): boolean {
+    return connectionFor(source) !== undefined
+  }
+
+  /** Imported documents currently attached to a given block. */
+  function docsForBlock(blockId: string): SourceDocument[] {
+    return documents.value.filter((d) => d.linkedBlockId === blockId)
+  }
+
+  /** Merge a document returned by the backend into the local cache. */
+  function upsertDoc(doc: SourceDocument) {
+    const i = documents.value.findIndex(
+      (d) => d.source === doc.source && d.externalId === doc.externalId,
+    )
+    if (i >= 0) documents.value[i] = doc
+    else documents.value.unshift(doc)
+  }
+
+  function upsertConnection(conn: DocumentConnection) {
+    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.listDocumentSources(workspace.requireId()),
+        api.listDocumentConnections(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: DocumentSourceKind, credentials: Record<string, string>) {
+    const conn = await api.connectDocumentSource(workspace.requireId(), source, credentials)
+    upsertConnection(conn)
+    available.value = true
+  }
+
+  /** Disconnect the workspace from a source. */
+  async function disconnect(source: DocumentSourceKind) {
+    await api.disconnectDocumentSource(workspace.requireId(), source)
+    connections.value = connections.value.filter((c) => c.source !== source)
+  }
+
+  /** Load the imported documents for the workspace (across sources). */
+  async function loadDocuments() {
+    documents.value = await api.listDocuments(workspace.requireId())
+  }
+
+  /** Import (fetch + persist) a page by id or URL from a source. */
+  async function importDocument(source: DocumentSourceKind, ref: string): Promise<SourceDocument> {
+    loading.value = true
+    try {
+      const doc = await api.importDocument(workspace.requireId(), source, { ref })
+      upsertDoc(doc)
+      return doc
+    } finally {
+      loading.value = false
+    }
+  }
+
+  /** Preview the board structure a page would expand into (no writes). */
+  function plan(source: DocumentSourceKind, externalId: string): Promise<DocumentBoardPlan> {
+    return api.planDocument(workspace.requireId(), source, externalId)
+  }
+
+  /** Apply a page's structure to the board, then refresh the board snapshot. */
+  async function spawn(source: DocumentSourceKind, externalId: string, frameId?: string) {
+    const { result } = await api.spawnDocument(workspace.requireId(), source, {
+      externalId,
+      frameId,
+    })
+    await workspace.refresh()
+    return result
+  }
+
+  /** Attach an imported page to a block as agent context. */
+  async function linkToBlock(blockId: string, source: DocumentSourceKind, externalId: string) {
+    const doc = await api.linkDocument(workspace.requireId(), { source, externalId, blockId })
+    upsertDoc(doc)
+    return doc
+  }
+
+  return {
+    available,
+    sources,
+    connections,
+    documents,
+    loading,
+    connectedSources,
+    anyConnected,
+    descriptorFor,
+    connectionFor,
+    isConnected,
+    docsForBlock,
+    probe,
+    connect,
+    disconnect,
+    loadDocuments,
+    importDocument,
+    plan,
+    spawn,
+    linkToBlock,
+  }
+})

package/app/stores/execution.ts

@@ -0,0 +1,115 @@
+import { defineStore } from 'pinia'
+import { ref, computed } from 'vue'
+import type { Decision, ExecutionInstance, Pipeline, PipelineStep } from '~/types/domain'
+import { useWorkspaceStore } from '~/stores/workspace'
+
+/**
+ * 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.
+ */
+export const useExecutionStore = defineStore('execution', () => {
+  const api = useApi()
+  const instances = ref<ExecutionInstance[]>([])
+
+  /** Replace the cached executions with a server snapshot. */
+  function hydrate(next: ExecutionInstance[]) {
+    instances.value = next
+  }
+
+  /** Insert or replace a single execution instance pushed by the event stream. */
+  function upsert(instance: ExecutionInstance) {
+    const i = instances.value.findIndex((e) => e.id === instance.id)
+    if (i >= 0) instances.value[i] = instance
+    else instances.value.push(instance)
+  }
+
+  const byId = computed(() => {
+    const map = new Map<string, ExecutionInstance>()
+    for (const e of instances.value) map.set(e.id, e)
+    return map
+  })
+
+  function getInstance(id: string | null | undefined) {
+    return id ? byId.value.get(id) : undefined
+  }
+
+  function getByBlock(blockId: string) {
+    return instances.value.find((e) => e.blockId === blockId)
+  }
+
+  /** How many decisions anywhere are awaiting a human. */
+  const pendingDecisionCount = computed(() =>
+    instances.value.reduce(
+      (n, e) => n + e.steps.filter((s) => s.decision && !s.decision.chosen).length,
+      0,
+    ),
+  )
+
+  /** All currently-unresolved decisions across all runs (for the toolbar/queue). */
+  const openDecisions = computed(() => {
+    const out: {
+      instanceId: string
+      blockId: string
+      decision: Decision
+      agentKind: PipelineStep['agentKind']
+    }[] = []
+    for (const e of instances.value) {
+      for (const s of e.steps) {
+        if (s.decision && !s.decision.chosen) {
+          out.push({
+            instanceId: e.id,
+            blockId: e.blockId,
+            decision: s.decision,
+            agentKind: s.agentKind,
+          })
+        }
+      }
+    }
+    return out
+  })
+
+  /** Start `pipeline` against a block; the server marks the block in-progress. */
+  async function start(blockId: string, pipeline: Pipeline) {
+    const ws = useWorkspaceStore()
+    await api.startExecution(ws.requireId(), blockId, { pipelineId: pipeline.id })
+    await ws.refresh()
+  }
+
+  async function resolveDecision(instanceId: string, decisionId: string, choice: string) {
+    const ws = useWorkspaceStore()
+    await api.resolveDecision(ws.requireId(), instanceId, decisionId, { choice })
+    await ws.refresh()
+  }
+
+  /** Merge an open PR (a task in `pr_ready`) — the server completes the task. */
+  async function mergePr(blockId: string) {
+    const ws = useWorkspaceStore()
+    await api.mergeBlock(ws.requireId(), blockId)
+    await ws.refresh()
+  }
+
+  /** Cancel the execution running against a block and reset it to planned. */
+  async function cancel(blockId: string) {
+    const ws = useWorkspaceStore()
+    await api.cancelExecution(ws.requireId(), blockId)
+    instances.value = instances.value.filter((e) => e.blockId !== blockId)
+    await ws.refresh()
+  }
+
+  return {
+    instances,
+    hydrate,
+    upsert,
+    byId,
+    getInstance,
+    getByBlock,
+    pendingDecisionCount,
+    openDecisions,
+    start,
+    resolveDecision,
+    mergePr,
+    cancel,
+  }
+})

package/app/stores/fragmentLibrary.ts

@@ -0,0 +1,147 @@
+import { defineStore } from 'pinia'
+import { computed, ref } from 'vue'
+import type {
+  CreatePromptFragmentInput,
+  FragmentSource,
+  LinkFragmentSourceInput,
+  PromptFragment,
+  ResolvedFragment,
+  UpdatePromptFragmentInput,
+} from '~/types/domain'
+import { useWorkspaceStore } from '~/stores/workspace'
+
+/**
+ * Prompt-fragment library state (ADR 0006), scoped to the active board. Holds the
+ * board's own (workspace-tier) fragments, its linked guideline repos, and the
+ * merged catalog an agent actually sees (built-in ∪ account ∪ workspace). The
+ * management surface targets the workspace tier; the resolved read is what every
+ * agent run is selected from. `available` mirrors the backend's opt-in gate: a
+ * 503 from the resolve probe means the feature is off and the UI hides its entry.
+ */
+export const useFragmentLibraryStore = defineStore('fragmentLibrary', () => {
+  const api = useApi()
+  const workspace = useWorkspaceStore()
+
+  /** null = not probed yet; true/false = library on/off. */
+  const available = ref<boolean | null>(null)
+  /** This board's hand-authored + sourced fragments (workspace tier, raw). */
+  const fragments = ref<PromptFragment[]>([])
+  /** The merged catalog an agent sees (with each entry's winning tier). */
+  const resolved = ref<ResolvedFragment[]>([])
+  /** Linked guideline repos for this board. */
+  const sources = ref<FragmentSource[]>([])
+  /** Per-source "changes available" counts from the last status check. */
+  const sourceChanges = ref<Record<string, number>>({})
+  const loading = ref(false)
+
+  const builtinCount = computed(() => resolved.value.filter((f) => f.tier === 'builtin').length)
+
+  /** Probe the feature + load this board's tier, sources and resolved catalog. */
+  async function probe() {
+    if (!workspace.workspaceId) return
+    const id = workspace.requireId()
+    try {
+      const [tier, srcs, merged] = await Promise.all([
+        api.listFragments('workspace', id),
+        api.listFragmentSources('workspace', id).catch(() => [] as FragmentSource[]),
+        api.getResolvedFragments(id),
+      ])
+      fragments.value = tier
+      sources.value = srcs
+      resolved.value = merged
+      available.value = true
+    } catch {
+      available.value = false
+      fragments.value = []
+      sources.value = []
+      resolved.value = []
+    }
+  }
+
+  async function refreshResolved() {
+    resolved.value = await api.getResolvedFragments(workspace.requireId())
+  }
+
+  async function create(input: CreatePromptFragmentInput) {
+    loading.value = true
+    try {
+      await api.createFragment('workspace', workspace.requireId(), input)
+      await Promise.all([reloadTier(), refreshResolved()])
+    } finally {
+      loading.value = false
+    }
+  }
+
+  async function update(fragmentId: string, patch: UpdatePromptFragmentInput) {
+    await api.updateFragment('workspace', workspace.requireId(), fragmentId, patch)
+    await Promise.all([reloadTier(), refreshResolved()])
+  }
+
+  /** Tombstone a fragment at the workspace tier (suppresses an inherited one). */
+  async function remove(fragmentId: string) {
+    await api.deleteFragment('workspace', workspace.requireId(), fragmentId)
+    await Promise.all([reloadTier(), refreshResolved()])
+  }
+
+  async function reloadTier() {
+    fragments.value = await api.listFragments('workspace', workspace.requireId())
+  }
+
+  async function linkSource(input: LinkFragmentSourceInput) {
+    const source = await api.linkFragmentSource('workspace', workspace.requireId(), input)
+    sources.value = [source, ...sources.value]
+    return source
+  }
+
+  async function unlinkSource(sourceId: string) {
+    await api.unlinkFragmentSource('workspace', workspace.requireId(), sourceId)
+    sources.value = sources.value.filter((s) => s.id !== sourceId)
+    await refreshResolved()
+  }
+
+  /** Resync a source's Markdown into the catalog, then refresh views. */
+  async function syncSource(sourceId: string) {
+    loading.value = true
+    try {
+      const result = await api.syncFragmentSource('workspace', workspace.requireId(), sourceId)
+      delete sourceChanges.value[sourceId]
+      await Promise.all([reloadSources(), refreshResolved()])
+      return result
+    } finally {
+      loading.value = false
+    }
+  }
+
+  /** Cheap "check for changes" for a source; caches the changed count. */
+  async function checkSource(sourceId: string) {
+    const status = await api.fragmentSourceStatus('workspace', workspace.requireId(), sourceId)
+    sourceChanges.value = {
+      ...sourceChanges.value,
+      [sourceId]: status.changed ? status.changedCount : 0,
+    }
+    return status
+  }
+
+  async function reloadSources() {
+    sources.value = await api.listFragmentSources('workspace', workspace.requireId())
+  }
+
+  return {
+    available,
+    fragments,
+    resolved,
+    sources,
+    sourceChanges,
+    loading,
+    builtinCount,
+    probe,
+    refreshResolved,
+    create,
+    update,
+    remove,
+    linkSource,
+    unlinkSource,
+    syncSource,
+    checkSource,
+  }
+})

package/app/stores/fragments.ts

@@ -0,0 +1,40 @@
+import { defineStore } from 'pinia'
+import { ref, computed } from 'vue'
+import type { BlockType, PromptFragment } from '~/types/domain'
+
+/**
+ * The best-practice prompt fragment catalog. It is build-static reference data on
+ * the backend (`GET /prompt-fragments`), workspace-independent, so this store
+ * fetches it once and caches it for the per-block picker in the inspector.
+ */
+export const useFragmentsStore = defineStore('fragments', () => {
+  const api = useApi()
+  const fragments = ref<PromptFragment[]>([])
+  const loaded = ref(false)
+
+  /** Fetch the catalog once; subsequent calls are no-ops. */
+  async function ensureLoaded() {
+    if (loaded.value) return
+    fragments.value = await api.getPromptFragments()
+    loaded.value = true
+  }
+
+  const byId = computed(() => {
+    const map = new Map<string, PromptFragment>()
+    for (const f of fragments.value) map.set(f.id, f)
+    return map
+  })
+
+  function getFragment(id: string) {
+    return byId.value.get(id)
+  }
+
+  /** Fragments suitable for a block type (those with no `blockTypes` apply to all). */
+  function forBlockType(type: BlockType) {
+    return fragments.value.filter(
+      (f) => !f.appliesTo?.blockTypes || f.appliesTo.blockTypes.includes(type),
+    )
+  }
+
+  return { fragments, loaded, ensureLoaded, byId, getFragment, forBlockType }
+})