@piwitests/server 0.24.0 → 0.26.0

package/.output/server/chunks/build/DiagnosisPanel-C_ndadzP.mjs

@@ -0,0 +1,1207 @@
+import { j as useToast, k as _sfc_main$p, l as _sfc_main$k, v as __nuxt_component_12 } from './server.mjs';
+import { _ as __nuxt_component_2 } from './HelpHint-C96TlqxY.mjs';
+import { b as __nuxt_component_1, d as __nuxt_component_3, e as __nuxt_component_8, f as __nuxt_component_6 } from './DiagnosisResult-GAjo6Lt3.mjs';
+import { _ as _sfc_main$2 } from './Textarea-CmjqdiIA.mjs';
+import { provide, ref, computed, watch, onScopeDispose, defineComponent, nextTick, mergeProps, unref, withCtx, createTextVNode, toDisplayString, isRef, createVNode, inject, useSSRContext } from 'vue';
+import { ssrRenderAttrs, ssrRenderComponent, ssrInterpolate, ssrRenderClass, ssrRenderList, ssrRenderAttr } from 'vue/server-renderer';
+import { a as formatRelativeTime } from './index-2GmuPNF-.mjs';
+import { _ as _sfc_main$3 } from './Alert-gs8RgKxH.mjs';
+import { eW as extractCitedSectionIds, am as formatBytes, eX as SUPPORTED_IMAGE_MEDIA_TYPES } from '../nitro/nitro.mjs';
+import { u as useAiStatus } from './useAiStatus-CiK1MZbH.mjs';
+
+const intervalError = "[nuxt] `setInterval` should not be used on the server. Consider wrapping it with an `onNuxtReady`, `onBeforeMount` or `onMounted` lifecycle hook, or ensure you only call it in the browser by checking `false`.";
+const setInterval = (() => {
+  console.error(intervalError);
+});
+const CLUSTER_DIAGNOSIS_KEY = /* @__PURE__ */ Symbol("cluster-diagnosis");
+function createClusterDiagnosisStore(clusterId) {
+  const toast = useToast();
+  const baseCommit = ref("");
+  const savedBaseCommit = ref("");
+  const selectedCommitShas = ref([]);
+  const autoSelectedCommits = ref([]);
+  const baseCommitIsPinned = computed(() => !!savedBaseCommit.value);
+  const contextText = ref(null);
+  const contextSections = ref([]);
+  const tokenEstimate = ref(0);
+  const imageTokenEstimate = ref(0);
+  const coverage = ref(null);
+  const scmChanges = ref(null);
+  const contextLoading = ref(false);
+  const diagnosis = ref(null);
+  const posting = ref(false);
+  let pollTimer = null;
+  function buildContextQuery() {
+    const query = {};
+    if (baseCommit.value.trim()) query.baseCommit = baseCommit.value.trim();
+    if (selectedCommitShas.value.length) query.selectedCommitShas = selectedCommitShas.value;
+    return query;
+  }
+  async function refreshContext() {
+    contextLoading.value = true;
+    try {
+      const res = await $fetch(`/api/failure-clusters/${clusterId}/context`, {
+        query: { ...buildContextQuery(), format: "json" }
+      });
+      contextText.value = res.text;
+      contextSections.value = res.sections;
+      tokenEstimate.value = res.tokenEstimate;
+      imageTokenEstimate.value = res.imageTokenEstimate ?? 0;
+      coverage.value = res.coverage;
+      scmChanges.value = res.scmChanges ?? null;
+    } catch {
+      contextText.value = "(failed to load context)";
+      contextSections.value = [];
+      tokenEstimate.value = 0;
+      imageTokenEstimate.value = 0;
+      coverage.value = null;
+      scmChanges.value = null;
+    } finally {
+      contextLoading.value = false;
+    }
+  }
+  function stopPoll() {
+    if (pollTimer) {
+      clearInterval(pollTimer);
+      pollTimer = null;
+    }
+  }
+  function startPoll() {
+    if (pollTimer) return;
+    pollTimer = setInterval();
+  }
+  async function runDiagnosis(opts = {}) {
+    posting.value = true;
+    try {
+      const url = opts.force ? `/api/failure-clusters/${clusterId}/diagnose?force=true` : `/api/failure-clusters/${clusterId}/diagnose`;
+      const body = {};
+      if (opts.additionalContext) body.additionalContext = opts.additionalContext;
+      if (baseCommit.value.trim()) body.baseCommit = baseCommit.value.trim();
+      if (selectedCommitShas.value.length) body.selectedCommitShas = selectedCommitShas.value;
+      if (opts.images?.length) body.images = opts.images;
+      diagnosis.value = await $fetch(url, {
+        method: "POST",
+        body: Object.keys(body).length ? body : void 0
+      });
+      if (diagnosis.value?.status === "running") startPoll();
+    } catch (err) {
+      const status = err?.statusCode;
+      if (status === 409) startPoll();
+      else
+        toast.add({ title: "Diagnosis failed", description: String(err?.message ?? err), color: "error" });
+    } finally {
+      posting.value = false;
+    }
+  }
+  watch(baseCommit, (val) => {
+    return;
+  });
+  watch(
+    selectedCommitShas,
+    () => {
+      return;
+    },
+    { deep: true }
+  );
+  watch(diagnosis, (val) => {
+    if (val?.status === "running") startPoll();
+    else stopPoll();
+  });
+  onScopeDispose(() => {
+    stopPoll();
+  });
+  return {
+    clusterId,
+    baseCommit,
+    savedBaseCommit,
+    selectedCommitShas,
+    autoSelectedCommits,
+    baseCommitIsPinned,
+    contextText,
+    contextSections,
+    tokenEstimate,
+    imageTokenEstimate,
+    coverage,
+    scmChanges,
+    contextLoading,
+    refreshContext,
+    diagnosis,
+    posting,
+    runDiagnosis
+  };
+}
+function provideClusterDiagnosis(clusterId) {
+  const store = createClusterDiagnosisStore(clusterId);
+  provide(CLUSTER_DIAGNOSIS_KEY, store);
+  return store;
+}
+function useClusterDiagnosis() {
+  const store = inject(CLUSTER_DIAGNOSIS_KEY);
+  if (!store) throw new Error("useClusterDiagnosis() must be used under a page that called provideClusterDiagnosis()");
+  return store;
+}
+function useOrProvideClusterDiagnosis(clusterId) {
+  const store = inject(CLUSTER_DIAGNOSIS_KEY, null);
+  if (store) return store;
+  if (clusterId == null)
+    throw new Error("useOrProvideClusterDiagnosis() requires a clusterId when used outside provideClusterDiagnosis()");
+  return provideClusterDiagnosis(clusterId);
+}
+const _sfc_main$1 = /* @__PURE__ */ defineComponent({
+  __name: "DiagnosisScreenshots",
+  __ssrInlineRender: true,
+  props: {
+    affectedTestCases: {}
+  },
+  emits: ["update:images"],
+  setup(__props, { emit: __emit }) {
+    const emit = __emit;
+    const screenshots = ref([]);
+    const loading = ref(false);
+    function emitSelected() {
+      emit(
+        "update:images",
+        screenshots.value.filter((s) => s.selected).map(({ name, mediaType, data }) => ({ name, mediaType, data }))
+      );
+    }
+    function selectAll() {
+      screenshots.value.forEach((s) => s.selected = true);
+      emitSelected();
+    }
+    function deselectAll() {
+      screenshots.value.forEach((s) => s.selected = false);
+      emitSelected();
+    }
+    const selectedCount = computed(() => screenshots.value.filter((s) => s.selected).length);
+    return (_ctx, _push, _parent, _attrs) => {
+      const _component_UIcon = _sfc_main$p;
+      const _component_UButton = _sfc_main$k;
+      if (unref(loading)) {
+        _push(`<div${ssrRenderAttrs(mergeProps({ class: "flex items-center gap-1.5 text-xs text-gray-400 py-1" }, _attrs))}>`);
+        _push(ssrRenderComponent(_component_UIcon, {
+          name: "i-lucide-loader-2",
+          class: "size-3 animate-spin"
+        }, null, _parent));
+        _push(` Loading screenshots from test evidence… </div>`);
+      } else if (unref(screenshots).length) {
+        _push(`<div${ssrRenderAttrs(mergeProps({ class: "space-y-1.5" }, _attrs))}><div class="flex items-center justify-between"><span class="text-xs font-medium text-gray-500"> Test screenshots <span class="text-gray-400 font-normal">(${ssrInterpolate(unref(selectedCount))}/${ssrInterpolate(unref(screenshots).length)} will be sent to AI)</span></span><div class="flex gap-0.5">`);
+        _push(ssrRenderComponent(_component_UButton, {
+          size: "xs",
+          color: "neutral",
+          variant: "ghost",
+          onClick: selectAll
+        }, {
+          default: withCtx((_, _push2, _parent2, _scopeId) => {
+            if (_push2) {
+              _push2(`All`);
+            } else {
+              return [
+                createTextVNode("All")
+              ];
+            }
+          }),
+          _: 1
+        }, _parent));
+        _push(ssrRenderComponent(_component_UButton, {
+          size: "xs",
+          color: "neutral",
+          variant: "ghost",
+          onClick: deselectAll
+        }, {
+          default: withCtx((_, _push2, _parent2, _scopeId) => {
+            if (_push2) {
+              _push2(`None`);
+            } else {
+              return [
+                createTextVNode("None")
+              ];
+            }
+          }),
+          _: 1
+        }, _parent));
+        _push(`</div></div><div class="grid grid-cols-4 gap-1.5"><!--[-->`);
+        ssrRenderList(unref(screenshots), (img, i) => {
+          _push(`<div class="${ssrRenderClass([img.selected ? "border-primary" : "border-default opacity-50", "cursor-pointer rounded overflow-hidden border-2 transition-all"])}"><div class="relative"><img${ssrRenderAttr("src", img.src)}${ssrRenderAttr("alt", img.name)} class="w-full h-14 object-cover object-top"><div class="absolute top-0.5 right-0.5">`);
+          _push(ssrRenderComponent(_component_UIcon, {
+            name: img.selected ? "i-lucide-check-circle-2" : "i-lucide-circle",
+            class: ["size-3.5 drop-shadow", img.selected ? "text-primary" : "text-gray-300"]
+          }, null, _parent));
+          _push(`</div></div><div class="px-1 py-0.5 bg-elevated space-y-0.5"><p class="text-[9px] text-gray-700 dark:text-gray-300 truncate font-medium leading-tight"${ssrRenderAttr("title", img.caseTitle)}>${ssrInterpolate(img.caseTitle)}</p><div class="flex items-center gap-1 flex-wrap"><span class="${ssrRenderClass([
+            img.status === "passed" ? "bg-success/15 text-success" : img.status === "failed" ? "bg-error/15 text-error" : "bg-neutral/15 text-gray-500",
+            "text-[8px] px-1 rounded leading-tight font-medium"
+          ])}">${ssrInterpolate(img.status)}</span>`);
+          if (img.retries > 0) {
+            _push(`<span class="text-[8px] text-gray-400 leading-tight">retry ${ssrInterpolate(img.retries)}</span>`);
+          } else {
+            _push(`<!---->`);
+          }
+          if (img.browser) {
+            _push(`<span class="text-[8px] text-gray-400 leading-tight truncate">${ssrInterpolate(img.browser)}</span>`);
+          } else {
+            _push(`<!---->`);
+          }
+          if (img.startTime) {
+            _push(`<span class="text-[8px] text-gray-400 leading-tight ml-auto">${ssrInterpolate(unref(formatRelativeTime)(img.startTime))}</span>`);
+          } else {
+            _push(`<!---->`);
+          }
+          _push(`</div></div></div>`);
+        });
+        _push(`<!--]--></div></div>`);
+      } else {
+        _push(`<!---->`);
+      }
+    };
+  }
+});
+const _sfc_setup$1 = _sfc_main$1.setup;
+_sfc_main$1.setup = (props, ctx) => {
+  const ssrContext = useSSRContext();
+  (ssrContext.modules || (ssrContext.modules = /* @__PURE__ */ new Set())).add("components/diagnosis/DiagnosisScreenshots.vue");
+  return _sfc_setup$1 ? _sfc_setup$1(props, ctx) : void 0;
+};
+const __nuxt_component_7 = Object.assign(_sfc_main$1, { __name: "DiagnosisScreenshots" });
+const STORAGE_KEY = "piwi-diagnosis-notifications";
+function useDiagnosisNotification() {
+  const permission = ref("default");
+  const notifiedIds = /* @__PURE__ */ new Set();
+  const enabled = ref(true);
+  const supported = computed(() => false);
+  const active = computed(() => supported.value && permission.value === "granted" && enabled.value);
+  async function requestPermission() {
+    if (!supported.value) return;
+    const result = await Notification.requestPermission();
+    permission.value = result;
+  }
+  function toggleEnabled() {
+    enabled.value = !enabled.value;
+    localStorage.setItem(STORAGE_KEY, String(enabled.value));
+  }
+  function notify(diagnosis, clusterId) {
+    notifyFromPayload({
+      clusterId,
+      summary: diagnosis.summary,
+      rootCause: diagnosis.rootCause,
+      category: diagnosis.category,
+      confidence: diagnosis.confidence
+    });
+  }
+  function notifyFromPayload(payload) {
+    if (!active.value) return;
+    if (notifiedIds.has(payload.clusterId)) return;
+    const lines = [payload.summary || payload.rootCause];
+    if (payload.category) lines.push(`Category: ${payload.category}`);
+    if (payload.confidence) lines.push(`Confidence: ${payload.confidence}`);
+    const body = lines.join("\n");
+    if (!body) return;
+    const notification = new Notification("Piwi diagnosis complete", {
+      body,
+      tag: `diagnosis-${payload.clusterId}`,
+      icon: "/logo.svg"
+    });
+    notification.onclick = () => {
+      (void 0).focus();
+      notification.close();
+    };
+    notifiedIds.add(payload.clusterId);
+  }
+  return { permission, supported, active, requestPermission, toggleEnabled, notify, notifyFromPayload };
+}
+function useStreamingDiagnosis(clusterId) {
+  const thinkingText = ref("");
+  const stage = ref(null);
+  const status = ref("idle");
+  const result = ref(null);
+  const error = ref(null);
+  let abortController = null;
+  function cancel() {
+    if (abortController) {
+      abortController.abort();
+      abortController = null;
+    }
+    if (status.value === "streaming") {
+      status.value = "cancelled";
+    }
+  }
+  function reset() {
+    cancel();
+    thinkingText.value = "";
+    stage.value = null;
+    status.value = "idle";
+    result.value = null;
+    error.value = null;
+  }
+  async function startStream(body = {}) {
+    thinkingText.value = "";
+    stage.value = null;
+    error.value = null;
+    result.value = null;
+    status.value = "streaming";
+    const cid = unref(clusterId);
+    abortController = new AbortController();
+    const query = new URLSearchParams();
+    if (body.force) query.set("force", "true");
+    const url = `/api/failure-clusters/${cid}/diagnose/stream${query.toString() ? "?" + query.toString() : ""}`;
+    try {
+      const response = await $fetch.raw(url, {
+        method: "POST",
+        body: {
+          additionalContext: body.additionalContext,
+          images: body.images,
+          baseCommit: body.baseCommit,
+          selectedCommitShas: body.selectedCommitShas,
+          scope: body.scope,
+          executionId: body.testRunsCaseId
+        },
+        responseType: "stream",
+        signal: abortController.signal,
+        // Do not throw on non-2xx — we read the body ourselves
+        ignoreResponseError: true
+      });
+      const rawBody = response._data ?? response.body;
+      if (!rawBody) {
+        throw new Error("No response body from streaming endpoint");
+      }
+      let reader;
+      if (rawBody instanceof ReadableStream) {
+        reader = rawBody.getReader();
+      } else if (rawBody instanceof Uint8Array || rawBody instanceof ArrayBuffer) {
+        const decoder2 = new TextDecoder();
+        const text = decoder2.decode(rawBody instanceof ArrayBuffer ? new Uint8Array(rawBody) : rawBody);
+        parseSseBuffer(text);
+        if (status.value === "streaming") {
+          status.value = "error";
+          error.value = "Stream ended without a result event";
+        }
+        return;
+      } else {
+        if (typeof rawBody?.getReader === "function") {
+          reader = rawBody.getReader();
+        } else if (rawBody?.pipeThrough) {
+          const rs = rawBody;
+          reader = rs.getReader();
+        } else {
+          throw new Error("Unsupported stream response format");
+        }
+      }
+      const decoder = new TextDecoder();
+      let buffer = "";
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const messages = buffer.split("\n\n");
+        buffer = messages.pop() || "";
+        let resultEventReceived = false;
+        for (const msg of messages) {
+          const parsed = parseSseMessage(msg);
+          if (parsed) {
+            if (parsed.event === "result") {
+              result.value = parsed.data;
+              status.value = "complete";
+              resultEventReceived = true;
+            } else if (parsed.event === "thinking") {
+              const d = parsed.data;
+              thinkingText.value += d.text;
+            } else if (parsed.event === "stage") {
+              stage.value = parsed.data.stage;
+            } else if (parsed.event === "error") {
+              const d = parsed.data;
+              error.value = d.message;
+              status.value = "error";
+            }
+          }
+        }
+        if (resultEventReceived) break;
+      }
+      if (buffer.trim()) {
+        const parsed = parseSseMessage(buffer.trim());
+        if (parsed) {
+          if (parsed.event === "result") {
+            result.value = parsed.data;
+            status.value = "complete";
+          } else if (parsed.event === "error") {
+            error.value = parsed.data.message;
+            status.value = "error";
+          }
+        }
+      }
+      if (status.value === "streaming") {
+        if (!error.value) {
+          status.value = "complete";
+        }
+      }
+    } catch (err) {
+      if (err?.name === "AbortError") {
+        status.value = "cancelled";
+        return;
+      }
+      error.value = String(err?.message ?? err);
+      status.value = "error";
+    } finally {
+      abortController = null;
+    }
+  }
+  function parseSseMessage(raw) {
+    if (!raw.trim()) return null;
+    const lines = raw.split("\n");
+    let eventType = "message";
+    let dataStr = "";
+    for (const line of lines) {
+      if (line.startsWith("event: ")) {
+        eventType = line.slice(7).trim();
+      } else if (line.startsWith("data: ")) {
+        dataStr += line.slice(6);
+      } else if (line.startsWith(":")) ;
+    }
+    if (!dataStr) return null;
+    try {
+      return { event: eventType, data: JSON.parse(dataStr) };
+    } catch {
+      return { event: eventType, data: dataStr };
+    }
+  }
+  function parseSseBuffer(text) {
+    const messages = text.split("\n\n");
+    for (const msg of messages) {
+      const parsed = parseSseMessage(msg);
+      if (parsed) {
+        if (parsed.event === "result") {
+          result.value = parsed.data;
+          status.value = "complete";
+        } else if (parsed.event === "thinking") {
+          const d = parsed.data;
+          thinkingText.value += d.text;
+        } else if (parsed.event === "stage") {
+          stage.value = parsed.data.stage;
+        } else if (parsed.event === "error") {
+          error.value = parsed.data.message;
+          status.value = "error";
+        }
+      }
+    }
+  }
+  onScopeDispose(() => {
+    cancel();
+  });
+  return {
+    thinkingText,
+    stage,
+    status,
+    result,
+    error,
+    startStream,
+    cancel,
+    reset
+  };
+}
+const MAX_TEXT_BYTES = 200 * 1024;
+const MAX_IMAGE_BYTES = 5 * 1024 * 1024;
+function fileToBase64(file) {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onload = () => {
+      const part = reader.result.split(",")[1];
+      if (part !== void 0) resolve(part);
+      else reject(new Error("Failed to read file"));
+    };
+    reader.onerror = reject;
+    reader.readAsDataURL(file);
+  });
+}
+function useAttachments() {
+  const toast = useToast();
+  const files = ref([]);
+  const images = ref([]);
+  const dragOver = ref(false);
+  async function processFiles(list) {
+    for (const file of Array.from(list)) {
+      if (SUPPORTED_IMAGE_MEDIA_TYPES.includes(file.type)) {
+        if (file.size > MAX_IMAGE_BYTES) {
+          toast.add({ title: "Image too large", description: `${file.name} exceeds 5 MB`, color: "error" });
+          continue;
+        }
+        const data = await fileToBase64(file);
+        const preview = `data:${file.type};base64,${data}`;
+        images.value.push({ name: file.name, mediaType: file.type, data, preview, size: file.size });
+      } else {
+        if (file.size > MAX_TEXT_BYTES) {
+          toast.add({ title: "File too large", description: `${file.name} exceeds 200 KB`, color: "error" });
+          continue;
+        }
+        const content = await file.text();
+        files.value.push({ name: file.name, content, size: file.size });
+      }
+    }
+  }
+  function onDragOver(e) {
+    e.preventDefault();
+    dragOver.value = true;
+  }
+  function onDragLeave(e) {
+    if (!e.currentTarget?.contains(e.relatedTarget)) {
+      dragOver.value = false;
+    }
+  }
+  function onDrop(e) {
+    e.preventDefault();
+    dragOver.value = false;
+    if (e.dataTransfer?.files?.length) processFiles(e.dataTransfer.files);
+  }
+  function removeFile(i) {
+    files.value.splice(i, 1);
+  }
+  function removeImage(i) {
+    images.value.splice(i, 1);
+  }
+  function filesMarkdown() {
+    if (!files.value.length) return "";
+    const blocks = files.value.map((f) => `### ${f.name}
+\`\`\`
+${f.content}
+\`\`\``);
+    return `## Attached Files
+
+${blocks.join("\n\n")}`;
+  }
+  function imagesPayload() {
+    return images.value.map((img) => ({ name: img.name, mediaType: img.mediaType, data: img.data }));
+  }
+  return {
+    files,
+    images,
+    dragOver,
+    processFiles,
+    onDragOver,
+    onDragLeave,
+    onDrop,
+    removeFile,
+    removeImage,
+    filesMarkdown,
+    imagesPayload
+  };
+}
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "DiagnosisPanel",
+  __ssrInlineRender: true,
+  props: {
+    clusterId: {},
+    lastSeenRunId: {},
+    affectedTestCases: {}
+  },
+  setup(__props) {
+    const props = __props;
+    const {
+      diagnosis,
+      posting,
+      contextText,
+      contextSections,
+      tokenEstimate,
+      imageTokenEstimate,
+      contextLoading,
+      coverage,
+      baseCommit,
+      selectedCommitShas,
+      refreshContext,
+      runDiagnosis
+    } = useOrProvideClusterDiagnosis(props.clusterId);
+    const { aiStatus } = useAiStatus();
+    useToast();
+    const {
+      permission: notifPermission,
+      active: notifActive,
+      requestPermission,
+      toggleEnabled
+    } = useDiagnosisNotification();
+    const {
+      thinkingText: streamThinkingText,
+      stage: streamStage,
+      status: streamStatus,
+      result: streamResult,
+      error: streamError,
+      startStream,
+      cancel: cancelStream
+    } = useStreamingDiagnosis(computed(() => props.clusterId ?? 0));
+    const attachments = useAttachments();
+    const {
+      files: attachedFiles,
+      images: attachedImages,
+      dragOver
+    } = attachments;
+    const additionalContext = ref("");
+    const fileInputRef = ref(null);
+    const testCaseImages = ref([]);
+    const allImages = computed(() => [
+      ...testCaseImages.value,
+      ...attachedImages.value.length ? attachments.imagesPayload() : []
+    ]);
+    const showAiContext = ref(false);
+    const showAdditionalContext = ref(false);
+    const focusSection = ref(null);
+    const thinkingContainer = ref(null);
+    function onViewSection(sectionId) {
+      focusSection.value = sectionId;
+      showAiContext.value = true;
+    }
+    const citedSections = computed(() => {
+      const det = diagnosis.value?.details;
+      if (!det) return [];
+      const texts = [];
+      if (Array.isArray(det.evidence)) texts.push(...det.evidence);
+      if (Array.isArray(det.hypotheses)) {
+        for (const h of det.hypotheses) if (Array.isArray(h?.evidence)) texts.push(...h.evidence);
+      }
+      return extractCitedSectionIds(texts);
+    });
+    watch(streamThinkingText, () => {
+      nextTick(() => {
+        if (thinkingContainer.value) {
+          thinkingContainer.value.scrollTop = thinkingContainer.value.scrollHeight;
+        }
+      });
+    });
+    watch(streamResult, (val) => {
+      if (val) {
+        diagnosis.value = val;
+      }
+    });
+    watch(
+      () => diagnosis.value?.details,
+      (det) => {
+        if (!det) return;
+        const d = det;
+        if (typeof d.additionalContext === "string" && d.additionalContext.trim() && !additionalContext.value) {
+          additionalContext.value = d.additionalContext;
+        }
+      },
+      { immediate: true }
+    );
+    function onPrefillContext(text) {
+      additionalContext.value = additionalContext.value ? `${additionalContext.value}
+
+${text}` : text;
+      showAdditionalContext.value = true;
+    }
+    function buildPromptContext() {
+      const parts = [];
+      if (additionalContext.value.trim()) parts.push(additionalContext.value.trim());
+      const filesMd = attachments.filesMarkdown();
+      if (filesMd) parts.push(filesMd);
+      return parts.join("\n\n");
+    }
+    async function diagnose(force = false) {
+      await startStream({
+        force,
+        additionalContext: buildPromptContext() || void 0,
+        baseCommit: baseCommit.value.trim() || void 0,
+        selectedCommitShas: selectedCommitShas.value.length ? [...selectedCommitShas.value] : void 0,
+        images: allImages.value.length ? allImages.value : void 0
+      });
+    }
+    async function diagnoseFallback(force = false) {
+      await runDiagnosis({
+        force,
+        additionalContext: buildPromptContext() || void 0,
+        images: allImages.value.length ? allImages.value : void 0
+      });
+    }
+    function markDiagnosisFailed() {
+      diagnosis.value = null;
+    }
+    function isStale(d) {
+      return d.status === "running" && Date.now() - new Date(d.updatedAt).getTime() > 5 * 60 * 1e3;
+    }
+    function isStreaming() {
+      return streamStatus.value === "streaming";
+    }
+    function showDiagnoseButton() {
+      return !isStreaming() && (!diagnosis.value || diagnosis.value.status === "failed" || isStale(diagnosis.value));
+    }
+    function showResult() {
+      return !isStreaming() && diagnosis.value && (diagnosis.value.status === "completed" || diagnosis.value.status === "failed");
+    }
+    return (_ctx, _push, _parent, _attrs) => {
+      const _component_UIcon = _sfc_main$p;
+      const _component_HelpHint = __nuxt_component_2;
+      const _component_CopyAiPromptButton = __nuxt_component_1;
+      const _component_UButton = _sfc_main$k;
+      const _component_DiagnosisCoverageStrip = __nuxt_component_3;
+      const _component_DiagnosisContextModal = __nuxt_component_8;
+      const _component_UTextarea = _sfc_main$2;
+      const _component_DiagnosisScreenshots = __nuxt_component_7;
+      const _component_UAlert = _sfc_main$3;
+      const _component_DiagnosisResult = __nuxt_component_6;
+      const _component_NuxtLink = __nuxt_component_12;
+      _push(`<div${ssrRenderAttrs(mergeProps({ class: "space-y-4" }, _attrs))}><div class="pb-2 border-b border-default"><div class="flex items-center justify-between gap-2"><div class="flex items-center gap-1.5">`);
+      _push(ssrRenderComponent(_component_UIcon, {
+        name: "i-lucide-sparkles",
+        class: "size-4 text-primary shrink-0"
+      }, null, _parent));
+      _push(`<span class="text-sm font-semibold">Diagnosis</span>`);
+      _push(ssrRenderComponent(_component_HelpHint, { topic: "cluster.diagnosis" }, null, _parent));
+      _push(`<span class="text-xs text-gray-400"> — `);
+      _push(ssrRenderComponent(_component_UIcon, {
+        name: "i-lucide-triangle-alert",
+        class: "size-3 shrink-0 inline"
+      }, null, _parent));
+      _push(` AI-generated, verify before applying </span></div><div class="flex items-center gap-1.5">`);
+      _push(ssrRenderComponent(_component_CopyAiPromptButton, {
+        "context-endpoint": `/api/failure-clusters/${__props.clusterId}/context`
+      }, null, _parent));
+      _push(ssrRenderComponent(_component_UButton, {
+        icon: unref(showAiContext) ? "i-lucide-eye-off" : "i-lucide-eye",
+        size: "xs",
+        color: "neutral",
+        variant: "outline",
+        loading: unref(contextLoading),
+        onClick: ($event) => showAiContext.value = !unref(showAiContext)
+      }, {
+        default: withCtx((_, _push2, _parent2, _scopeId) => {
+          if (_push2) {
+            _push2(`${ssrInterpolate(unref(showAiContext) ? "Hide context" : "Show context")}`);
+          } else {
+            return [
+              createTextVNode(toDisplayString(unref(showAiContext) ? "Hide context" : "Show context"), 1)
+            ];
+          }
+        }),
+        _: 1
+      }, _parent));
+      if (unref(diagnosis) && unref(diagnosis).status === "completed") {
+        _push(ssrRenderComponent(_component_UButton, {
+          icon: "i-lucide-refresh-cw",
+          size: "xs",
+          color: "primary",
+          variant: "soft",
+          loading: unref(posting),
+          onClick: ($event) => diagnose(true)
+        }, {
+          default: withCtx((_, _push2, _parent2, _scopeId) => {
+            if (_push2) {
+              _push2(` Re-diagnose `);
+            } else {
+              return [
+                createTextVNode(" Re-diagnose ")
+              ];
+            }
+          }),
+          _: 1
+        }, _parent));
+      } else {
+        _push(`<!---->`);
+      }
+      _push(`</div></div></div>`);
+      if (unref(notifPermission) === "granted" && unref(aiStatus)?.configured) {
+        _push(`<div class="flex items-center gap-2 px-3 py-2 rounded-lg bg-elevated/50 border border-default text-xs">`);
+        _push(ssrRenderComponent(_component_UIcon, {
+          name: "i-lucide-bell",
+          class: ["size-3.5 shrink-0", unref(notifActive) ? "text-primary" : "text-gray-400"]
+        }, null, _parent));
+        _push(`<span class="text-gray-500">${ssrInterpolate(unref(notifActive) ? "Diagnosis notifications on" : "Diagnosis notifications off")}</span>`);
+        _push(ssrRenderComponent(_component_UButton, {
+          size: "xs",
+          color: unref(notifActive) ? "neutral" : "primary",
+          variant: "outline",
+          onClick: unref(toggleEnabled)
+        }, {
+          default: withCtx((_, _push2, _parent2, _scopeId) => {
+            if (_push2) {
+              _push2(`${ssrInterpolate(unref(notifActive) ? "Disable" : "Enable")}`);
+            } else {
+              return [
+                createTextVNode(toDisplayString(unref(notifActive) ? "Disable" : "Enable"), 1)
+              ];
+            }
+          }),
+          _: 1
+        }, _parent));
+        _push(`</div>`);
+      } else if (unref(notifPermission) === "default" && unref(aiStatus)?.configured) {
+        _push(`<div class="flex items-center gap-2 px-3 py-2 rounded-lg bg-elevated/50 border border-default text-xs">`);
+        _push(ssrRenderComponent(_component_UIcon, {
+          name: "i-lucide-bell",
+          class: "size-3.5 text-gray-400 shrink-0"
+        }, null, _parent));
+        _push(`<span class="text-gray-500">Notify when diagnosis completes?</span>`);
+        _push(ssrRenderComponent(_component_UButton, {
+          size: "xs",
+          color: "neutral",
+          variant: "outline",
+          onClick: unref(requestPermission)
+        }, {
+          default: withCtx((_, _push2, _parent2, _scopeId) => {
+            if (_push2) {
+              _push2(`Enable`);
+            } else {
+              return [
+                createTextVNode("Enable")
+              ];
+            }
+          }),
+          _: 1
+        }, _parent));
+        _push(`</div>`);
+      } else {
+        _push(`<!---->`);
+      }
+      if (unref(aiStatus)?.configured) {
+        _push(ssrRenderComponent(_component_DiagnosisCoverageStrip, {
+          sections: unref(contextSections),
+          "not-applicable": unref(coverage)?.notApplicable,
+          "token-estimate": unref(tokenEstimate),
+          loading: unref(contextLoading),
+          onViewSection,
+          onOpen: ($event) => showAiContext.value = true
+        }, null, _parent));
+      } else {
+        _push(`<!---->`);
+      }
+      _push(ssrRenderComponent(_component_DiagnosisContextModal, {
+        open: unref(showAiContext),
+        sections: unref(contextSections),
+        "token-estimate": unref(tokenEstimate),
+        "image-token-estimate": unref(imageTokenEstimate),
+        loading: unref(contextLoading),
+        "focus-section": unref(focusSection),
+        "cited-sections": unref(citedSections),
+        "not-applicable-sections": unref(coverage)?.notApplicable,
+        "onUpdate:open": ($event) => {
+          showAiContext.value = $event;
+          if (!$event) focusSection.value = null;
+        },
+        onRefresh: unref(refreshContext)
+      }, null, _parent));
+      if (unref(aiStatus)?.configured) {
+        _push(`<!--[--><div><div class="flex items-center gap-1 mb-1"><button class="flex items-center gap-1.5 text-xs font-medium text-gray-500 hover:text-gray-700 dark:hover:text-gray-300 text-left">`);
+        _push(ssrRenderComponent(_component_UIcon, {
+          name: unref(showAdditionalContext) ? "i-lucide-chevron-down" : "i-lucide-chevron-right",
+          class: "size-3.5"
+        }, null, _parent));
+        _push(` Additional context `);
+        if (unref(attachedFiles).length || unref(attachedImages).length || unref(additionalContext).trim()) {
+          _push(`<span class="text-primary"> (${ssrInterpolate(unref(attachedFiles).length + unref(attachedImages).length + (unref(additionalContext).trim() ? 1 : 0))}) </span>`);
+        } else {
+          _push(`<!---->`);
+        }
+        _push(`</button>`);
+        _push(ssrRenderComponent(_component_HelpHint, { topic: "cluster.context-input" }, null, _parent));
+        _push(`</div>`);
+        if (unref(showAdditionalContext)) {
+          _push(`<div><div class="${ssrRenderClass([unref(dragOver) ? "border-primary bg-primary/5 border-solid" : "border-dashed border-default", "rounded-lg border-2 transition-colors"])}">`);
+          _push(ssrRenderComponent(_component_UTextarea, {
+            modelValue: unref(additionalContext),
+            "onUpdate:modelValue": ($event) => isRef(additionalContext) ? additionalContext.value = $event : null,
+            placeholder: "e.g. We deployed a new auth middleware yesterday\\u2026",
+            rows: 3,
+            class: "w-full text-sm border-0 bg-transparent focus:ring-0"
+          }, null, _parent));
+          _push(`<div class="flex items-center gap-2 px-3 pb-2 pt-1 border-t border-default"><input type="file" multiple class="hidden" accept=".txt,.log,.md,.json,.ts,.js,.py,.sql,.xml,.yaml,.yml,.html,.css,.env,image/*">`);
+          _push(ssrRenderComponent(_component_UButton, {
+            icon: "i-lucide-paperclip",
+            size: "xs",
+            color: "neutral",
+            variant: "ghost",
+            onClick: ($event) => unref(fileInputRef)?.click()
+          }, {
+            default: withCtx((_, _push2, _parent2, _scopeId) => {
+              if (_push2) {
+                _push2(` Attach files `);
+              } else {
+                return [
+                  createTextVNode(" Attach files ")
+                ];
+              }
+            }),
+            _: 1
+          }, _parent));
+          if (unref(dragOver)) {
+            _push(`<span class="text-xs text-primary">Drop files here\\u2026</span>`);
+          } else {
+            _push(`<span class="text-xs text-gray-400">or drag &amp; drop text files and images</span>`);
+          }
+          _push(`</div></div></div>`);
+        } else {
+          _push(`<!---->`);
+        }
+        _push(`</div>`);
+        if (unref(attachedFiles).length) {
+          _push(`<div class="flex flex-wrap gap-2"><!--[-->`);
+          ssrRenderList(unref(attachedFiles), (f, i) => {
+            _push(`<div class="flex items-center gap-1.5 bg-elevated rounded-full px-2.5 py-1 text-xs border border-default">`);
+            _push(ssrRenderComponent(_component_UIcon, {
+              name: "i-lucide-file-text",
+              class: "size-3 text-gray-500 shrink-0"
+            }, null, _parent));
+            _push(`<span class="max-w-40 truncate">${ssrInterpolate(f.name)}</span><span class="text-gray-400">${ssrInterpolate(("formatBytes" in _ctx ? _ctx.formatBytes : unref(formatBytes))(f.size))}</span><button class="text-gray-400 hover:text-error ml-0.5">`);
+            _push(ssrRenderComponent(_component_UIcon, {
+              name: "i-lucide-x",
+              class: "size-3"
+            }, null, _parent));
+            _push(`</button></div>`);
+          });
+          _push(`<!--]--></div>`);
+        } else {
+          _push(`<!---->`);
+        }
+        if (unref(attachedImages).length) {
+          _push(`<div class="flex flex-wrap gap-2"><!--[-->`);
+          ssrRenderList(unref(attachedImages), (img, i) => {
+            _push(`<div class="relative group"><img${ssrRenderAttr("src", img.preview)}${ssrRenderAttr("alt", img.name)} class="h-16 w-16 object-cover rounded-lg border border-default"><div class="absolute inset-0 bg-black/40 opacity-0 group-hover:opacity-100 transition-opacity rounded-lg flex items-center justify-center"><button class="text-white">`);
+            _push(ssrRenderComponent(_component_UIcon, {
+              name: "i-lucide-x",
+              class: "size-4"
+            }, null, _parent));
+            _push(`</button></div><p class="text-xs text-gray-500 text-center mt-0.5 w-16 truncate">${ssrInterpolate(img.name)}</p></div>`);
+          });
+          _push(`<!--]--></div>`);
+        } else {
+          _push(`<!---->`);
+        }
+        if (__props.affectedTestCases?.length) {
+          _push(ssrRenderComponent(_component_DiagnosisScreenshots, {
+            "affected-test-cases": __props.affectedTestCases,
+            "onUpdate:images": ($event) => testCaseImages.value = $event
+          }, null, _parent));
+        } else {
+          _push(`<!---->`);
+        }
+        if (showDiagnoseButton()) {
+          _push(`<div class="pt-1">`);
+          _push(ssrRenderComponent(_component_UButton, {
+            icon: "i-lucide-sparkles",
+            size: "sm",
+            color: "primary",
+            variant: "solid",
+            loading: unref(posting),
+            onClick: ($event) => diagnose()
+          }, {
+            default: withCtx((_, _push2, _parent2, _scopeId) => {
+              if (_push2) {
+                _push2(` Diagnose with AI `);
+              } else {
+                return [
+                  createTextVNode(" Diagnose with AI ")
+                ];
+              }
+            }),
+            _: 1
+          }, _parent));
+          _push(`</div>`);
+        } else {
+          _push(`<!---->`);
+        }
+        if (isStreaming()) {
+          _push(`<div class="rounded-lg border border-default overflow-hidden"><div class="flex items-center justify-between gap-2 px-3 py-2 bg-elevated/30 border-b border-default"><div class="flex items-center gap-2 text-sm text-gray-500">`);
+          _push(ssrRenderComponent(_component_UIcon, {
+            name: "i-lucide-loader-2",
+            class: "size-4 animate-spin text-primary"
+          }, null, _parent));
+          _push(`<span>Analyzing failure cluster</span>`);
+          if (unref(streamStage)) {
+            _push(`<span class="inline-flex items-center gap-1 text-xs text-gray-400">`);
+            _push(ssrRenderComponent(_component_UIcon, {
+              name: "i-lucide-workflow",
+              class: "size-3"
+            }, null, _parent));
+            _push(` ${ssrInterpolate(unref(streamStage) === "research" ? "Researching patterns" : "Diagnosing root cause")}</span>`);
+          } else {
+            _push(`<!---->`);
+          }
+          _push(`</div>`);
+          _push(ssrRenderComponent(_component_UButton, {
+            size: "xs",
+            color: "neutral",
+            variant: "ghost",
+            icon: "i-lucide-x",
+            title: "Cancel diagnosis",
+            onClick: unref(cancelStream)
+          }, null, _parent));
+          _push(`</div><div class="max-h-64 overflow-y-auto p-3 text-xs font-mono leading-relaxed whitespace-pre-wrap break-words text-gray-600 dark:text-gray-400 bg-elevated/10">`);
+          if (unref(streamThinkingText)) {
+            _push(`<!--[-->${ssrInterpolate(unref(streamThinkingText))} <span class="inline-block w-2 h-4 bg-primary/60 animate-pulse ml-0.5 align-text-bottom"></span><!--]-->`);
+          } else {
+            _push(`<span class="text-gray-400 italic">Waiting for model response\\u2026</span>`);
+          }
+          _push(`</div><div class="px-3 py-1.5 border-t border-default text-xs text-gray-400 flex items-center gap-2">`);
+          _push(ssrRenderComponent(_component_UIcon, {
+            name: "i-lucide-file-text",
+            class: "size-3"
+          }, null, _parent));
+          _push(`<span>${ssrInterpolate(unref(streamThinkingText).length.toLocaleString())} characters received</span></div></div>`);
+        } else {
+          _push(`<!---->`);
+        }
+        if (unref(diagnosis)?.status === "running" && !isStale(unref(diagnosis)) && !isStreaming()) {
+          _push(`<div class="rounded-lg border border-warning/40 bg-warning/5 p-3 space-y-2"><div class="flex items-center gap-2 text-sm">`);
+          _push(ssrRenderComponent(_component_UIcon, {
+            name: "i-lucide-alert-triangle",
+            class: "size-4 text-warning shrink-0"
+          }, null, _parent));
+          _push(`<span class="font-medium text-warning-700 dark:text-warning-400">Diagnosis was interrupted</span></div><p class="text-xs text-gray-500"> A previous diagnosis started but never completed — the server may have restarted. You can restart it below. </p><div class="flex items-center gap-2 pt-1">`);
+          _push(ssrRenderComponent(_component_UButton, {
+            icon: "i-lucide-refresh-cw",
+            size: "xs",
+            color: "warning",
+            variant: "solid",
+            loading: unref(posting),
+            onClick: ($event) => diagnose(true)
+          }, {
+            default: withCtx((_, _push2, _parent2, _scopeId) => {
+              if (_push2) {
+                _push2(` Restart diagnosis `);
+              } else {
+                return [
+                  createTextVNode(" Restart diagnosis ")
+                ];
+              }
+            }),
+            _: 1
+          }, _parent));
+          _push(ssrRenderComponent(_component_UButton, {
+            size: "xs",
+            color: "neutral",
+            variant: "ghost",
+            loading: unref(posting),
+            onClick: markDiagnosisFailed
+          }, {
+            default: withCtx((_, _push2, _parent2, _scopeId) => {
+              if (_push2) {
+                _push2(` Dismiss `);
+              } else {
+                return [
+                  createTextVNode(" Dismiss ")
+                ];
+              }
+            }),
+            _: 1
+          }, _parent));
+          _push(`</div><p class="text-xs text-gray-400">Started ${ssrInterpolate(unref(formatRelativeTime)(unref(diagnosis).updatedAt))}</p></div>`);
+        } else {
+          _push(`<!---->`);
+        }
+        if (unref(streamError)) {
+          _push(ssrRenderComponent(_component_UAlert, {
+            color: "error",
+            icon: "i-lucide-alert-circle",
+            title: "Streaming diagnosis failed",
+            description: unref(streamError),
+            class: "mt-2"
+          }, {
+            actions: withCtx((_, _push2, _parent2, _scopeId) => {
+              if (_push2) {
+                _push2(ssrRenderComponent(_component_UButton, {
+                  size: "xs",
+                  color: "neutral",
+                  variant: "outline",
+                  onClick: ($event) => diagnoseFallback(true)
+                }, {
+                  default: withCtx((_2, _push3, _parent3, _scopeId2) => {
+                    if (_push3) {
+                      _push3(` Retry (fallback) `);
+                    } else {
+                      return [
+                        createTextVNode(" Retry (fallback) ")
+                      ];
+                    }
+                  }),
+                  _: 1
+                }, _parent2, _scopeId));
+              } else {
+                return [
+                  createVNode(_component_UButton, {
+                    size: "xs",
+                    color: "neutral",
+                    variant: "outline",
+                    onClick: ($event) => diagnoseFallback(true)
+                  }, {
+                    default: withCtx(() => [
+                      createTextVNode(" Retry (fallback) ")
+                    ]),
+                    _: 1
+                  }, 8, ["onClick"])
+                ];
+              }
+            }),
+            _: 1
+          }, _parent));
+        } else {
+          _push(`<!---->`);
+        }
+        if (showResult()) {
+          _push(ssrRenderComponent(_component_DiagnosisResult, {
+            diagnosis: unref(diagnosis),
+            "last-seen-run-id": __props.lastSeenRunId,
+            onViewSection,
+            onPrefillContext
+          }, null, _parent));
+        } else {
+          _push(`<!---->`);
+        }
+        _push(`<!--]-->`);
+      } else {
+        _push(`<div class="flex flex-col items-center justify-center p-8 text-center text-gray-400 border border-dashed border-default rounded-lg">`);
+        _push(ssrRenderComponent(_component_UIcon, {
+          name: "i-lucide-sparkles",
+          class: "size-8 mb-2 opacity-30"
+        }, null, _parent));
+        _push(`<p class="text-sm inline-flex items-center gap-1"> AI diagnosis is not configured `);
+        _push(ssrRenderComponent(_component_HelpHint, { topic: "cluster.ai-setup" }, null, _parent));
+        _push(`</p>`);
+        _push(ssrRenderComponent(_component_UButton, {
+          to: "/settings/ai",
+          size: "xs",
+          color: "neutral",
+          variant: "outline",
+          class: "mt-3"
+        }, {
+          default: withCtx((_, _push2, _parent2, _scopeId) => {
+            if (_push2) {
+              _push2(` Configure in Settings `);
+            } else {
+              return [
+                createTextVNode(" Configure in Settings ")
+              ];
+            }
+          }),
+          _: 1
+        }, _parent));
+        _push(`<p class="text-xs text-gray-400 mt-4 max-w-xs"> Use the <strong>Show context</strong> button above to inspect the full diagnosis context and copy it for use with your own AI tool. </p></div>`);
+      }
+      _push(`<div class="pt-1 text-center">`);
+      _push(ssrRenderComponent(_component_NuxtLink, {
+        to: "/mcp",
+        class: "inline-flex items-center gap-1 text-xs text-gray-400 hover:text-primary transition-colors"
+      }, {
+        default: withCtx((_, _push2, _parent2, _scopeId) => {
+          if (_push2) {
+            _push2(ssrRenderComponent(_component_UIcon, {
+              name: "i-lucide-bot",
+              class: "size-3"
+            }, null, _parent2, _scopeId));
+            _push2(` Query this cluster from your AI agent via the MCP server `);
+          } else {
+            return [
+              createVNode(_component_UIcon, {
+                name: "i-lucide-bot",
+                class: "size-3"
+              }),
+              createTextVNode(" Query this cluster from your AI agent via the MCP server ")
+            ];
+          }
+        }),
+        _: 1
+      }, _parent));
+      _push(`</div></div>`);
+    };
+  }
+});
+const _sfc_setup = _sfc_main.setup;
+_sfc_main.setup = (props, ctx) => {
+  const ssrContext = useSSRContext();
+  (ssrContext.modules || (ssrContext.modules = /* @__PURE__ */ new Set())).add("components/diagnosis/DiagnosisPanel.vue");
+  return _sfc_setup ? _sfc_setup(props, ctx) : void 0;
+};
+const __nuxt_component_0 = Object.assign(_sfc_main, { __name: "DiagnosisPanel" });
+
+export { __nuxt_component_0 as _, provideClusterDiagnosis as p, useClusterDiagnosis as u };
+//# sourceMappingURL=DiagnosisPanel-C_ndadzP.mjs.map