@cat-factory/app 0.6.0 → 0.7.2

package/app/composables/useContextLinking.ts

@@ -1,65 +1,65 @@
-import type { DocumentSourceKind, TaskSourceKind } from '~/types/domain'
-
-// Shared model + orchestration for attaching external context (imported docs and
-// tracker issues) to a board block. A "pending" item is something the user has
-// chosen to attach but which is only linked once the block exists — so the task
-// creation popup can collect selections up front and commit them after the task
-// is created. Search hits and pasted URLs carry `needsImport: true`: they are not
-// yet projected locally, so they are imported (fetched + persisted) before being
-// linked; already-imported items are linked directly. Reused wherever context is
-// attached (the add-task popup today; the inspector can adopt it later).
-
-export interface PendingContext {
-  kind: 'document' | 'task'
-  source: DocumentSourceKind | TaskSourceKind
-  /** A canonical external id (already-imported / search hit) or a pasted URL/ref. */
-  externalId: string
-  title: string
-  /** Secondary line: an issue status, a source label, the raw URL, … */
-  subtitle?: string
-  /** Lucide icon for the row. */
-  icon?: string
-  /** True when the item must be imported before it can be linked. */
-  needsImport: boolean
-}
-
-/** Stable key for a pending item, used for dedupe + selection toggles. */
-export function contextKey(c: Pick<PendingContext, 'kind' | 'source' | 'externalId'>): string {
-  return `${c.kind}:${c.source}:${c.externalId}`
-}
-
-export function useContextLinking() {
-  const documents = useDocumentsStore()
-  const tasks = useTasksStore()
-
-  /**
-   * Import (when needed) then link every pending item to `blockId`. Each failure
-   * is counted rather than aborting the batch, so one bad attachment doesn't sink
-   * the rest; returns how many failed.
-   */
-  async function linkPending(blockId: string, items: PendingContext[]): Promise<number> {
-    let failed = 0
-    for (const item of items) {
-      try {
-        if (item.kind === 'document') {
-          const source = item.source as DocumentSourceKind
-          const externalId = item.needsImport
-            ? (await documents.importDocument(source, item.externalId)).externalId
-            : item.externalId
-          await documents.linkToBlock(blockId, source, externalId)
-        } else {
-          const source = item.source as TaskSourceKind
-          const externalId = item.needsImport
-            ? (await tasks.importTask(source, item.externalId)).externalId
-            : item.externalId
-          await tasks.linkToBlock(blockId, source, externalId)
-        }
-      } catch {
-        failed++
-      }
-    }
-    return failed
-  }
-
-  return { linkPending }
-}
+import type { DocumentSourceKind, TaskSourceKind } from '~/types/domain'
+
+// Shared model + orchestration for attaching external context (imported docs and
+// tracker issues) to a board block. A "pending" item is something the user has
+// chosen to attach but which is only linked once the block exists — so the task
+// creation popup can collect selections up front and commit them after the task
+// is created. Search hits and pasted URLs carry `needsImport: true`: they are not
+// yet projected locally, so they are imported (fetched + persisted) before being
+// linked; already-imported items are linked directly. Reused wherever context is
+// attached (the add-task popup today; the inspector can adopt it later).
+
+export interface PendingContext {
+  kind: 'document' | 'task'
+  source: DocumentSourceKind | TaskSourceKind
+  /** A canonical external id (already-imported / search hit) or a pasted URL/ref. */
+  externalId: string
+  title: string
+  /** Secondary line: an issue status, a source label, the raw URL, … */
+  subtitle?: string
+  /** Lucide icon for the row. */
+  icon?: string
+  /** True when the item must be imported before it can be linked. */
+  needsImport: boolean
+}
+
+/** Stable key for a pending item, used for dedupe + selection toggles. */
+export function contextKey(c: Pick<PendingContext, 'kind' | 'source' | 'externalId'>): string {
+  return `${c.kind}:${c.source}:${c.externalId}`
+}
+
+export function useContextLinking() {
+  const documents = useDocumentsStore()
+  const tasks = useTasksStore()
+
+  /**
+   * Import (when needed) then link every pending item to `blockId`. Each failure
+   * is counted rather than aborting the batch, so one bad attachment doesn't sink
+   * the rest; returns how many failed.
+   */
+  async function linkPending(blockId: string, items: PendingContext[]): Promise<number> {
+    let failed = 0
+    for (const item of items) {
+      try {
+        if (item.kind === 'document') {
+          const source = item.source as DocumentSourceKind
+          const externalId = item.needsImport
+            ? (await documents.importDocument(source, item.externalId)).externalId
+            : item.externalId
+          await documents.linkToBlock(blockId, source, externalId)
+        } else {
+          const source = item.source as TaskSourceKind
+          const externalId = item.needsImport
+            ? (await tasks.importTask(source, item.externalId)).externalId
+            : item.externalId
+          await tasks.linkToBlock(blockId, source, externalId)
+        }
+      } catch {
+        failed++
+      }
+    }
+    return failed
+  }
+
+  return { linkPending }
+}

package/app/composables/useFrameResize.ts

@@ -1,54 +1,54 @@
-import { ref } from 'vue'
-import type { Block } from '~/types/domain'
-
-/**
- * Pointer-driven resizing for service frames (Miro-style border drag). The drag
- * delta is divided by the board zoom so the edge tracks the cursor, and the new
- * size is clamped to the frame's content extent so dragging in never clips the
- * tasks/modules inside. The frame grows live (the store block is mutated in place,
- * which `containerSize` reads back), and the final size is persisted once on
- * release rather than on every move.
- */
-export function useFrameResize() {
-  const board = useBoardStore()
-  const ui = useUiStore()
-  /** Id of the frame currently being resized, for cursor/handle styling. */
-  const resizingId = ref<string | null>(null)
-
-  /**
-   * Begin a resize from one of the frame's edges/corner. `edge` selects which
-   * dimensions move: `'e'` width only, `'s'` height only, `'se'` both.
-   */
-  function startResize(block: Block, e: PointerEvent, edge: 'e' | 's' | 'se') {
-    if (e.button !== 0) return
-    e.preventDefault()
-    e.stopPropagation()
-    const startX = e.clientX
-    const startY = e.clientY
-    // The content extent is the floor — never shrink a frame below its tasks.
-    const min = board.contentSize(block.id)
-    // Seed from the current rendered size so the first move doesn't jump.
-    const start = board.containerSize(block.id)
-    resizingId.value = block.id
-
-    const onMove = (ev: PointerEvent) => {
-      const z = ui.zoom || 1
-      const w = edge === 's' ? start.w : Math.max(min.w, start.w + (ev.clientX - startX) / z)
-      const h = edge === 'e' ? start.h : Math.max(min.h, start.h + (ev.clientY - startY) / z)
-      // Optimistic, local-only: mutate the cached block so the frame grows live
-      // without a round-trip on every pointer move.
-      block.size = { w: Math.round(w), h: Math.round(h) }
-    }
-    const onUp = () => {
-      window.removeEventListener('pointermove', onMove)
-      window.removeEventListener('pointerup', onUp)
-      resizingId.value = null
-      // Persist the final size once (also re-applies it as the authoritative block).
-      if (block.size) void board.updateBlock(block.id, { size: block.size })
-    }
-    window.addEventListener('pointermove', onMove)
-    window.addEventListener('pointerup', onUp)
-  }
-
-  return { resizingId, startResize }
-}
+import { ref } from 'vue'
+import type { Block } from '~/types/domain'
+
+/**
+ * Pointer-driven resizing for service frames (Miro-style border drag). The drag
+ * delta is divided by the board zoom so the edge tracks the cursor, and the new
+ * size is clamped to the frame's content extent so dragging in never clips the
+ * tasks/modules inside. The frame grows live (the store block is mutated in place,
+ * which `containerSize` reads back), and the final size is persisted once on
+ * release rather than on every move.
+ */
+export function useFrameResize() {
+  const board = useBoardStore()
+  const ui = useUiStore()
+  /** Id of the frame currently being resized, for cursor/handle styling. */
+  const resizingId = ref<string | null>(null)
+
+  /**
+   * Begin a resize from one of the frame's edges/corner. `edge` selects which
+   * dimensions move: `'e'` width only, `'s'` height only, `'se'` both.
+   */
+  function startResize(block: Block, e: PointerEvent, edge: 'e' | 's' | 'se') {
+    if (e.button !== 0) return
+    e.preventDefault()
+    e.stopPropagation()
+    const startX = e.clientX
+    const startY = e.clientY
+    // The content extent is the floor — never shrink a frame below its tasks.
+    const min = board.contentSize(block.id)
+    // Seed from the current rendered size so the first move doesn't jump.
+    const start = board.containerSize(block.id)
+    resizingId.value = block.id
+
+    const onMove = (ev: PointerEvent) => {
+      const z = ui.zoom || 1
+      const w = edge === 's' ? start.w : Math.max(min.w, start.w + (ev.clientX - startX) / z)
+      const h = edge === 'e' ? start.h : Math.max(min.h, start.h + (ev.clientY - startY) / z)
+      // Optimistic, local-only: mutate the cached block so the frame grows live
+      // without a round-trip on every pointer move.
+      block.size = { w: Math.round(w), h: Math.round(h) }
+    }
+    const onUp = () => {
+      window.removeEventListener('pointermove', onMove)
+      window.removeEventListener('pointerup', onUp)
+      resizingId.value = null
+      // Persist the final size once (also re-applies it as the authoritative block).
+      if (block.size) void board.updateBlock(block.id, { size: block.size })
+    }
+    window.addEventListener('pointermove', onMove)
+    window.addEventListener('pointerup', onUp)
+  }
+
+  return { resizingId, startResize }
+}

package/app/pages/index.vue

@@ -26,6 +26,7 @@ import GitHubOnboarding from '~/components/github/GitHubOnboarding.vue'
 import FragmentLibraryPanel from '~/components/fragments/FragmentLibraryPanel.vue'
 import CommandBar from '~/components/layout/CommandBar.vue'
 import MergeThresholdsPanel from '~/components/settings/MergeThresholdsPanel.vue'
+import IssueTrackerWritebackPanel from '~/components/settings/IssueTrackerWritebackPanel.vue'
 import WorkspaceSettingsPanel from '~/components/settings/WorkspaceSettingsPanel.vue'
 import DatadogPanel from '~/components/settings/DatadogPanel.vue'
 import ModelDefaultsPanel from '~/components/settings/ModelDefaultsPanel.vue'
@@ -115,6 +116,7 @@ watch(
       <FragmentLibraryPanel />
       <CommandBar />
       <MergeThresholdsPanel />
+      <IssueTrackerWritebackPanel />
       <WorkspaceSettingsPanel />
       <DatadogPanel />
       <ModelDefaultsPanel />

package/app/stores/documents.ts

@@ -1,176 +1,176 @@
-import { defineStore } from 'pinia'
-import { computed, ref } from 'vue'
-import type {
-  DocumentBoardPlan,
-  DocumentConnection,
-  DocumentSearchResult,
-  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
-    }
-  }
-
-  /** Search a connected source's catalogue by free text (title/content). */
-  async function search(
-    source: DocumentSourceKind,
-    query: string,
-  ): Promise<DocumentSearchResult[]> {
-    const { results } = await api.searchDocumentSource(workspace.requireId(), source, query)
-    return results
-  }
-
-  /** 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,
-    search,
-    plan,
-    spawn,
-    linkToBlock,
-  }
-})
+import { defineStore } from 'pinia'
+import { computed, ref } from 'vue'
+import type {
+  DocumentBoardPlan,
+  DocumentConnection,
+  DocumentSearchResult,
+  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
+    }
+  }
+
+  /** Search a connected source's catalogue by free text (title/content). */
+  async function search(
+    source: DocumentSourceKind,
+    query: string,
+  ): Promise<DocumentSearchResult[]> {
+    const { results } = await api.searchDocumentSource(workspace.requireId(), source, query)
+    return results
+  }
+
+  /** 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,
+    search,
+    plan,
+    spawn,
+    linkToBlock,
+  }
+})