@cat-factory/app 0.162.2 → 0.163.0

package/app/components/layout/CommandBar.vue

@@ -118,6 +118,14 @@ const dynamicIntegrationCommands = computed<Command[]>(() => {
         keywords: t('layout.commandBar.keywords.taskImport'),
         run: () => ui.openTaskImport(null),
       })
+      list.push({
+        id: 'bug-hunt',
+        label: t('layout.commandBar.cmd.bugHunt'),
+        group: groupIntegrations,
+        icon: 'i-lucide-radar',
+        keywords: t('layout.commandBar.keywords.bugHunt'),
+        run: () => ui.openBugHunt(null),
+      })
     }
   }
   return list

package/app/components/layout/IntegrationsHub.vue

@@ -241,6 +241,13 @@ const groups = computed<IntegrationGroup[]>(() => {
         description: t('layout.integrationsHub.items.taskImport.description'),
         onClick: () => go(() => ui.openTaskImport(null)),
       })
+      trackers.push({
+        key: 'task:bug-hunt',
+        icon: 'i-lucide-radar',
+        label: t('layout.integrationsHub.items.bugHunt.label'),
+        description: t('layout.integrationsHub.items.bugHunt.description'),
+        onClick: () => go(() => ui.openBugHunt(null)),
+      })
     }
     // Choosing the filing tracker / writeback is workspace CONFIG, not an integration, so it
     // sits as a quiet footer link under the sources rather than a competing row.

package/app/components/panels/InspectorPanel.vue

@@ -451,6 +451,19 @@ const showOriginalDescription = ref(false)
               : t('panels.inspector.connectTracker')
           }}
         </UButton>
+        <!-- Hunt this service's tracker board for a bug worth picking up. Scoped to the
+             selected container, so an adopted candidate lands here rather than wherever the
+             board's first frame happens to be. -->
+        <UButton
+          v-if="isContainer && tasks.anyOffered"
+          color="neutral"
+          variant="soft"
+          size="xs"
+          icon="i-lucide-radar"
+          @click="ui.openBugHunt(null, block!.id)"
+        >
+          {{ t('panels.inspector.huntBugs') }}
+        </UButton>
         <UButton
           v-if="isContainer && documents.available && documents.anyConnected"
           color="neutral"

package/app/components/tasks/BugHuntModal.vue

@@ -0,0 +1,361 @@
+<script setup lang="ts">
+// Bug hunt: pick a connected tracker, pick one of its boards, and let the platform rank that
+// board's open, UNASSIGNED bugs by impact against implementation complexity. Confirming a
+// candidate adopts it as a bug task in the chosen container and starts the bug-fix pipeline.
+//
+// The interactive dual of the recurring bug-triage schedule: same reading and same pipeline,
+// but a human picks the bug instead of the oldest match being claimed unattended.
+//
+// Two states this deliberately renders rather than hides: a board whose ranking was
+// unavailable or failed still shows its candidates (flagged as unassessed, since the scan is
+// useful on its own), and a scan that hit its cap says so — a silently shortened list reads
+// exactly like an exhaustive one.
+import type {
+  BugHuntAnalysisStatus,
+  BugHuntCandidate,
+  BugHuntConfidence,
+  TaskSourceKind,
+} from '~/types/domain'
+import IntegrationBackTitle from '~/components/layout/IntegrationBackTitle.vue'
+
+const { t, d, n } = useI18n()
+const ui = useUiStore()
+const tasks = useTasksStore()
+const board = useBoardStore()
+const hunt = useBugHuntStore()
+const toast = useToast()
+
+const open = computed({
+  get: () => ui.bugHunt !== null,
+  set: (v: boolean) => {
+    if (!v) ui.closeBugHunt()
+  },
+})
+const back = useIntegrationBack(open)
+
+const source = ref<TaskSourceKind | undefined>(undefined)
+const boardId = ref('')
+const issueType = ref('')
+const labels = ref('')
+const containerId = ref<string | undefined>(undefined)
+
+// Containers an adopted bug can land in: every service frame and module on the board. Modules
+// are labelled with their parent frame so the choice is unambiguous (same as the import modal).
+const containerItems = computed(() =>
+  board.blocks
+    .filter((b) => b.level === 'frame' || b.level === 'module')
+    .map((b) => ({
+      label:
+        b.level === 'module'
+          ? `${board.getBlock(b.parentId ?? '')?.title ?? '?'} › ${b.title}`
+          : b.title,
+      value: b.id,
+    })),
+)
+
+const sourceItems = computed(() =>
+  tasks.offeredSources.map((s) => ({ label: s.label, value: s.source })),
+)
+
+const boardItems = computed(() =>
+  hunt.boards.map((b) => ({
+    label: b.key && b.key !== b.name ? `${b.name} (${b.key})` : b.name,
+    value: b.id,
+  })),
+)
+
+/**
+ * The tracker CANNOT enumerate boards, so the user types the scope in themselves. Keyed on the
+ * backend's reason code, not on "any error": an unreachable tracker or an expired token would
+ * otherwise present as a free-text field that simply moves the same failure to the next click.
+ */
+const boardIsFreeText = computed(
+  () => !hunt.boardsLoading && hunt.boardsErrorReason === 'boards_unsupported',
+)
+
+/** A board read that failed for a reason the user has to fix — shown, never silently swallowed. */
+const boardsFailure = computed(() =>
+  !hunt.boardsLoading && hunt.boardsError !== null && !boardIsFreeText.value
+    ? hunt.boardsError
+    : null,
+)
+
+/**
+ * A tracker date the SPA can actually format. A provider reports `createdAt` as an opaque
+ * string, so an unparseable one must render as nothing rather than as "Invalid Date".
+ */
+function createdAtDate(createdAt: string): Date | null {
+  if (!createdAt) return null
+  const parsed = new Date(createdAt)
+  return Number.isNaN(parsed.getTime()) ? null : parsed
+}
+
+const canHunt = computed(() => !!source.value && boardId.value.trim().length > 0)
+
+watch(open, (isOpen) => {
+  if (!isOpen) return
+  hunt.reset()
+  boardId.value = ''
+  issueType.value = ''
+  labels.value = ''
+  source.value = ui.bugHunt?.source ?? tasks.offeredSources[0]?.source ?? undefined
+  containerId.value = ui.bugHunt?.containerId ?? containerItems.value[0]?.value
+  if (source.value) hunt.loadBoards(source.value)
+})
+
+// Switching tracker invalidates both the board list and any ranking already on screen — the
+// candidates belong to the previous tracker's board and would otherwise sit there looking current.
+watch(source, (next) => {
+  boardId.value = ''
+  hunt.reset()
+  if (next) hunt.loadBoards(next)
+})
+
+async function runHunt() {
+  if (!source.value || !canHunt.value) return
+  const parsedLabels = labels.value
+    .split(',')
+    .map((l) => l.trim())
+    .filter((l) => l.length > 0)
+  const ok = await hunt.hunt(source.value, {
+    board: boardId.value.trim(),
+    ...(issueType.value.trim() ? { issueType: issueType.value.trim() } : {}),
+    ...(parsedLabels.length ? { labels: parsedLabels } : {}),
+  })
+  if (!ok) {
+    toast.add({
+      title: t('bugHunt.huntFailed'),
+      description: hunt.huntError ?? undefined,
+      icon: 'i-lucide-triangle-alert',
+      color: 'error',
+    })
+  }
+}
+
+async function adopt(candidate: BugHuntCandidate) {
+  if (!source.value || !containerId.value) return
+  try {
+    const blockId = await hunt.adopt(source.value, candidate.externalId, containerId.value)
+    if (!blockId) return // the user cancelled the personal-credential prompt
+    ui.closeBugHunt()
+    ui.select(blockId)
+    toast.add({
+      title: t('bugHunt.adopted', { id: candidate.externalId }),
+      description: t('bugHunt.adoptedRunning'),
+      icon: 'i-lucide-bug-play',
+    })
+  } catch (e) {
+    toast.add({
+      title: t('bugHunt.adoptFailed'),
+      description: e instanceof Error ? e.message : String(e),
+      icon: 'i-lucide-triangle-alert',
+      color: 'error',
+    })
+  }
+}
+
+/** Colour the score chip by how good the impact-per-effort ratio is. */
+function scoreColor(score: number): 'success' | 'primary' | 'neutral' {
+  if (score >= 2) return 'success'
+  if (score >= 1) return 'primary'
+  return 'neutral'
+}
+
+/**
+ * Confidence labels, as an exhaustive Record over the closed union so a new member fails the
+ * typecheck rather than rendering a raw code (the enum→key drift guard).
+ */
+const CONFIDENCE_KEYS: Record<BugHuntConfidence, string> = {
+  high: 'bugHunt.confidence.high',
+  medium: 'bugHunt.confidence.medium',
+  low: 'bugHunt.confidence.low',
+}
+
+/** The banner shown above the results, per analysis status — same exhaustive-Record guard. */
+const STATUS_KEYS: Record<BugHuntAnalysisStatus, string> = {
+  ranked: 'bugHunt.status.ranked',
+  unavailable: 'bugHunt.status.unavailable',
+  failed: 'bugHunt.status.failed',
+  over_budget: 'bugHunt.status.over_budget',
+  empty: 'bugHunt.status.empty',
+}
+</script>
+
+<template>
+  <UModal v-model:open="open" :title="t('bugHunt.title')" :ui="{ content: 'max-w-3xl' }">
+    <template #title>
+      <IntegrationBackTitle :title="t('bugHunt.title')" @back="back" />
+    </template>
+    <template #body>
+      <!-- No tracker offered (none connected/installed, or all disabled). -->
+      <div v-if="!tasks.anyOffered" class="space-y-3 text-center">
+        <UIcon name="i-lucide-plug" class="mx-auto h-8 w-8 text-slate-500" />
+        <p class="text-sm text-slate-400">{{ t('bugHunt.connectFirst') }}</p>
+        <div class="flex justify-center gap-2">
+          <UButton
+            v-for="s in tasks.sources"
+            :key="s.source"
+            color="primary"
+            variant="soft"
+            :icon="s.icon"
+            @click="ui.openTaskConnect(s.source)"
+          >
+            {{ t('bugHunt.connectSource', { label: s.label }) }}
+          </UButton>
+        </div>
+      </div>
+
+      <!-- No service frame yet → nowhere for an adopted bug to land. -->
+      <p v-else-if="!containerItems.length" class="text-center text-xs text-slate-500">
+        {{ t('bugHunt.needFrameFirst') }}
+      </p>
+
+      <div v-else class="space-y-4">
+        <p class="text-xs text-slate-400">{{ t('bugHunt.intro') }}</p>
+
+        <div class="grid gap-3 sm:grid-cols-2">
+          <UFormField :label="t('bugHunt.tracker')">
+            <USelect v-model="source" :items="sourceItems" class="w-full" />
+          </UFormField>
+
+          <UFormField :label="t('bugHunt.board')">
+            <!-- A tracker that can't enumerate its boards gets a free-text field rather than
+                 an empty picker, so the hunt is still usable. -->
+            <UInput
+              v-if="boardIsFreeText"
+              v-model="boardId"
+              :placeholder="t('bugHunt.boardPlaceholder')"
+              class="w-full"
+            />
+            <USelect
+              v-else
+              v-model="boardId"
+              :items="boardItems"
+              :loading="hunt.boardsLoading"
+              :placeholder="t('bugHunt.pickBoard')"
+              class="w-full"
+            />
+            <!-- A board read that failed for a fixable reason (unreachable site, expired
+                 token): named, so the user isn't left with an empty picker and no cause. -->
+            <p v-if="boardsFailure" class="mt-1 text-xs text-amber-400">
+              {{ t('bugHunt.boardsFailed', { reason: boardsFailure }) }}
+            </p>
+          </UFormField>
+
+          <UFormField :label="t('bugHunt.issueType')" :help="t('bugHunt.issueTypeHelp')">
+            <UInput v-model="issueType" placeholder="bug" class="w-full" />
+          </UFormField>
+
+          <UFormField :label="t('bugHunt.labels')" :help="t('bugHunt.labelsHelp')">
+            <UInput v-model="labels" placeholder="regression, checkout" class="w-full" />
+          </UFormField>
+        </div>
+
+        <UFormField :label="t('bugHunt.adoptInto')">
+          <USelect v-model="containerId" :items="containerItems" class="w-full" />
+        </UFormField>
+
+        <div class="flex items-center gap-2">
+          <UButton
+            color="primary"
+            icon="i-lucide-radar"
+            :loading="hunt.hunting"
+            :disabled="!canHunt"
+            @click="runHunt"
+          >
+            {{ t('bugHunt.run') }}
+          </UButton>
+          <span v-if="hunt.hunting" class="text-xs text-slate-400">
+            {{ t('bugHunt.running') }}
+          </span>
+        </div>
+
+        <!-- Results -->
+        <div v-if="hunt.hasResult" class="space-y-3 border-t border-slate-800 pt-3">
+          <p class="text-xs text-slate-400">
+            {{ t(STATUS_KEYS[hunt.result!.analysisStatus]) }}
+            <span v-if="hunt.result!.model" class="text-slate-500">
+              {{ t('bugHunt.viaModel', { model: hunt.result!.model }) }}
+            </span>
+          </p>
+          <p v-if="hunt.result!.truncated" class="text-xs text-amber-400">
+            {{ t('bugHunt.truncated', { count: hunt.result!.scanned }) }}
+          </p>
+
+          <div
+            v-for="candidate in hunt.candidates"
+            :key="candidate.externalId"
+            class="space-y-2 rounded-md border border-slate-800 p-3"
+          >
+            <div class="flex items-start justify-between gap-3">
+              <div class="min-w-0 space-y-1">
+                <div class="flex items-center gap-2">
+                  <UBadge
+                    v-if="candidate.analysis"
+                    :color="scoreColor(candidate.analysis.score)"
+                    variant="soft"
+                  >
+                    {{ n(candidate.analysis.score) }}
+                  </UBadge>
+                  <UBadge v-else color="neutral" variant="soft">
+                    {{ t('bugHunt.notAssessed') }}
+                  </UBadge>
+                  <ULink
+                    :to="candidate.url"
+                    target="_blank"
+                    rel="noopener noreferrer"
+                    class="truncate text-sm font-medium text-slate-100"
+                  >
+                    {{ candidate.externalId }}: {{ candidate.title }}
+                  </ULink>
+                </div>
+                <p v-if="candidate.analysis" class="text-xs text-slate-400">
+                  {{
+                    t('bugHunt.ratings', {
+                      impact: candidate.analysis.impact,
+                      complexity: candidate.analysis.complexity,
+                      confidence: t(CONFIDENCE_KEYS[candidate.analysis.confidence]),
+                    })
+                  }}
+                </p>
+                <p v-if="candidate.analysis?.rationale" class="text-xs text-slate-300">
+                  {{ candidate.analysis.rationale }}
+                </p>
+                <div class="flex flex-wrap items-center gap-2 text-[11px] text-slate-500">
+                  <span v-if="candidate.priority">{{ candidate.priority }}</span>
+                  <span v-for="label in candidate.labels" :key="label">{{ label }}</span>
+                  <span v-if="createdAtDate(candidate.createdAt)">
+                    {{ d(createdAtDate(candidate.createdAt)!, 'short') }}
+                  </span>
+                  <span>{{
+                    t('bugHunt.comments', { count: candidate.commentCount }, candidate.commentCount)
+                  }}</span>
+                </div>
+              </div>
+              <div class="flex shrink-0 flex-col items-end gap-1">
+                <UBadge v-if="candidate.analysis?.recommended" color="success" variant="subtle">
+                  {{ t('bugHunt.recommended') }}
+                </UBadge>
+                <UButton
+                  color="primary"
+                  variant="soft"
+                  icon="i-lucide-play"
+                  size="xs"
+                  :loading="hunt.adopting === candidate.externalId"
+                  :disabled="hunt.adopting !== null"
+                  @click="adopt(candidate)"
+                >
+                  {{ t('bugHunt.adopt') }}
+                </UButton>
+              </div>
+            </div>
+          </div>
+
+          <p v-if="!hunt.candidates.length" class="text-center text-xs text-slate-500">
+            {{ t('bugHunt.noCandidates') }}
+          </p>
+        </div>
+      </div>
+    </template>
+  </UModal>
+</template>

package/app/composables/api/bugHunt.ts

@@ -0,0 +1,40 @@
+import {
+  adoptBugHuntCandidateContract,
+  listTrackerBoardsContract,
+  runBugHuntContract,
+} from '@cat-factory/contracts'
+import type { RunBugHuntInput, TaskSourceKind } from '~/types/domain'
+import type { ApiContext } from './context'
+
+/** Bug hunt: list a tracker's boards, rank a board's open unassigned bugs, adopt one. */
+export function bugHuntApi({ send, sendWith, ws, pwHeaders }: ApiContext) {
+  return {
+    // The boards a hunt can run against (Jira projects / Linear teams / GitHub repos). Errors
+    // when the source can't enumerate them, which the modal turns into a free-text board field.
+    listTrackerBoards: (workspaceId: string, source: TaskSourceKind) =>
+      send(listTrackerBoardsContract, { pathPrefix: ws(workspaceId), pathParams: { source } }),
+
+    // Scan the board for open, unassigned bugs and rank them by impact vs complexity. A live
+    // external call plus a model call, so it can take a while — the modal shows progress.
+    runBugHunt: (workspaceId: string, source: TaskSourceKind, body: RunBugHuntInput) =>
+      send(runBugHuntContract, {
+        pathPrefix: ws(workspaceId),
+        pathParams: { source },
+        body,
+      }),
+
+    // Adopt the confirmed candidate as a bug task and start its run. Carries the personal
+    // password header when the pipeline resolves an individual-usage model, like every start.
+    adoptBugHuntCandidate: (
+      workspaceId: string,
+      source: TaskSourceKind,
+      body: { externalId: string; containerId: string; pipelineId?: string },
+      password?: string,
+    ) =>
+      sendWith(pwHeaders(password), adoptBugHuntCandidateContract, {
+        pathPrefix: ws(workspaceId),
+        pathParams: { source },
+        body,
+      }),
+  }
+}

package/app/composables/useApi.ts

@@ -44,6 +44,7 @@ import { reviewsApi } from './api/reviews'
 import { slackApi } from './api/slack'
 import { specApi } from './api/spec'
 import { tasksApi } from './api/tasks'
+import { bugHuntApi } from './api/bugHunt'
 import { testSecretsApi } from './api/testSecrets'
 import { userSecretsApi } from './api/userSecrets'
 import { userSettingsApi } from './api/userSettings'
@@ -119,6 +120,7 @@ export function useApi() {
     ...executionApi(ctx),
     ...documentsApi(ctx),
     ...tasksApi(ctx),
+    ...bugHuntApi(ctx),
     ...reviewsApi(ctx),
     ...followUpsApi(ctx),
     ...forkDecisionApi(ctx),

package/app/pages/index.vue

@@ -45,6 +45,7 @@ const TaskSourceConnectModal = defineAsyncComponent(
   () => import('~/components/tasks/TaskSourceConnectModal.vue'),
 )
 const TaskImportModal = defineAsyncComponent(() => import('~/components/tasks/TaskImportModal.vue'))
+const BugHuntModal = defineAsyncComponent(() => import('~/components/tasks/BugHuntModal.vue'))
 const RecurringPipelineModal = defineAsyncComponent(
   () => import('~/components/board/RecurringPipelineModal.vue'),
 )
@@ -398,6 +399,7 @@ watch(
            first open (its own chunk) rather than bloating the initial bundle. -->
       <TaskSourceConnectModal v-if="ui.taskConnect" />
       <TaskImportModal v-if="ui.taskImport" />
+      <BugHuntModal v-if="ui.bugHunt" />
       <RecurringPipelineModal v-if="ui.addRecurringFrameId" />
       <ObservabilityPanel v-if="ui.observabilityInstanceId" />
       <OperatorDashboardPanel v-if="ui.operatorDashboardOpen" />

package/app/stores/bugHunt.spec.ts

@@ -0,0 +1,103 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest'
+import { useBugHuntStore } from '~/stores/bugHunt'
+import { useWorkspaceStore } from '~/stores/workspace'
+import { ApiError } from '~/composables/api/errors'
+import type { TaskSourceKind, TrackerBoardsView } from '~/types/domain'
+
+// What the board picker does with a FAILED board read. Only one failure means "this tracker
+// cannot enumerate boards, so type one in"; every other failure has to stay visible as an error,
+// or a tracker outage silently wears the same clothes as an unsupported provider.
+
+function apiError(statusCode: number, code: string, details?: Record<string, unknown>): ApiError {
+  return new ApiError(statusCode, { error: { code, message: 'nope', details } })
+}
+
+/** The unsupported-source refusal `BugHuntService.listBoards` raises. */
+const boardsUnsupported = () =>
+  Promise.reject(apiError(400, 'validation', { reason: 'boards_unsupported' }))
+
+/**
+ * Stub `useApi` ONCE, behind a handler the test can swap. The store resolves `useApi()` at setup,
+ * so re-stubbing after `useBugHuntStore()` would leave it holding the first stub for ever.
+ */
+function stubApi(): {
+  store: ReturnType<typeof useBugHuntStore>
+  serve: (fn: () => Promise<unknown>) => void
+} {
+  let handler: () => Promise<unknown> = () => Promise.resolve({ source: 'jira', boards: [] })
+  vi.stubGlobal('useApi', () => ({
+    listTrackerBoards: (_ws: string, _source: TaskSourceKind) =>
+      handler() as Promise<TrackerBoardsView>,
+  }))
+  return {
+    store: useBugHuntStore(),
+    serve: (fn) => {
+      handler = fn
+    },
+  }
+}
+
+describe('bug hunt store — board listing failures', () => {
+  beforeEach(() => {
+    useWorkspaceStore().workspaceId = 'ws1'
+  })
+
+  it('keeps the backend reason so the picker can offer free text for an unsupported source', async () => {
+    const { store, serve } = stubApi()
+    serve(boardsUnsupported)
+
+    await store.loadBoards('jira')
+
+    expect(store.boards).toEqual([])
+    expect(store.boardsErrorReason).toBe('boards_unsupported')
+    expect(store.boardsError).toBeTruthy()
+  })
+
+  it('records NO reason for a failure that is simply an unreachable tracker', async () => {
+    const { store, serve } = stubApi()
+    serve(() => Promise.reject(apiError(502, 'upstream')))
+
+    await store.loadBoards('jira')
+
+    // The modal keys its free-text fallback on the reason, so a null one keeps this an error.
+    expect(store.boardsErrorReason).toBeNull()
+    expect(store.boardsError).toBeTruthy()
+  })
+
+  it('clears a previous failure when a later source lists its boards fine', async () => {
+    const { store, serve } = stubApi()
+    serve(boardsUnsupported)
+    await store.loadBoards('jira')
+
+    serve(() =>
+      Promise.resolve({ source: 'linear', boards: [{ id: 't1', name: 'Eng', key: 'ENG' }] }),
+    )
+    await store.loadBoards('linear')
+
+    expect(store.boardsError).toBeNull()
+    expect(store.boardsErrorReason).toBeNull()
+    expect(store.boards.map((b) => b.id)).toEqual(['t1'])
+  })
+
+  it('a source switch mid-flight never lands the older tracker failure on the newer one', async () => {
+    const { store, serve } = stubApi()
+    let rejectJira!: (e: unknown) => void
+    serve(
+      () =>
+        new Promise((_res, rej) => {
+          rejectJira = rej
+        }),
+    )
+    const inFlight = store.loadBoards('jira')
+
+    serve(() => Promise.resolve({ source: 'linear', boards: [] }))
+    await store.loadBoards('linear')
+    rejectJira(apiError(400, 'validation', { reason: 'boards_unsupported' }))
+    await inFlight
+
+    // The slower tracker's refusal must not flip the newer tracker's picker to free text.
+    expect(store.boardsSource).toBe('linear')
+    expect(store.boardsErrorReason).toBeNull()
+    expect(store.boardsError).toBeNull()
+  })
+})