@skyhook-io/radar-app 1.14.2 → 1.14.3

package/src/components/diagnose/investigationEvidence/cardParts.tsx

@@ -0,0 +1,312 @@
+import type { InvestigationTimelineScope } from "./navigation";
+import { clsx } from "clsx";
+import { EVIDENCE_KIND_TRAITS } from "../investigationEvidenceKinds";
+import {
+  FileClock,
+  FileSearch,
+  Info,
+  SquareArrowOutUpRight,
+} from "lucide-react";
+import { defaultConditionTone, displayKind } from "@skyhook-io/k8s-ui";
+import type {
+  InvestigationEvidenceData,
+  InvestigationEvidenceGroup,
+  InvestigationEvidenceObservation,
+  InvestigationEvidenceSource,
+  InvestigationEvidenceTier,
+} from ".";
+import type { DiagnosisResourceRef } from "../diagnoseEvidenceTypes";
+import { Tooltip } from "../../ui/Tooltip";
+
+export function OpenResourceButton({
+  resourceRef,
+  onOpenResource,
+  compact = false,
+}: {
+  resourceRef?: DiagnosisResourceRef;
+  onOpenResource?: (ref: DiagnosisResourceRef) => void;
+  compact?: boolean;
+}) {
+  if (!resourceRef || !onOpenResource) return null;
+  const identity = `${resourceRef.namespace ? `${resourceRef.namespace}/` : ""}${resourceRef.name}`;
+  const label = `Open current ${displayKind(resourceRef.kind)} ${identity} in Radar`;
+  return (
+    <Tooltip
+      content={label}
+      delay={350}
+      position="left"
+      wrapperClassName="flex shrink-0"
+    >
+      <button
+        type="button"
+        aria-label={label}
+        onClick={() => onOpenResource(resourceRef)}
+        className={clsx(
+          "flex h-7 shrink-0 items-center justify-center rounded text-theme-text-tertiary transition-colors hover:bg-theme-hover hover:text-accent-text focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-accent",
+          "gap-1 px-2 text-xs font-medium",
+        )}
+      >
+        {compact ? null : (
+          <span>Open current {displayKind(resourceRef.kind)}</span>
+        )}
+        <SquareArrowOutUpRight className="h-3.5 w-3.5" aria-hidden />
+      </button>
+    </Tooltip>
+  );
+}
+
+export function OpenTimelineButton({
+  scope,
+  onOpenTimeline,
+}: {
+  scope: InvestigationTimelineScope;
+  onOpenTimeline?: (scope: InvestigationTimelineScope) => void;
+}) {
+  if (!onOpenTimeline) return null;
+  const identity = `${scope.namespace ? `${scope.namespace}/` : ""}${scope.name}`;
+  const label = `Open the Timeline for ${identity}`;
+  return (
+    <Tooltip
+      content={label}
+      delay={350}
+      position="left"
+      wrapperClassName="flex shrink-0"
+    >
+      <button
+        type="button"
+        aria-label={label}
+        onClick={() => onOpenTimeline(scope)}
+        className="flex h-7 shrink-0 items-center justify-center gap-1 rounded px-2 text-xs font-medium text-theme-text-tertiary transition-colors hover:bg-theme-hover hover:text-accent-text focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-accent"
+      >
+        <FileClock className="h-3.5 w-3.5" aria-hidden />
+        <span className="hidden @min-[540px]/card:inline">Timeline</span>
+      </button>
+    </Tooltip>
+  );
+}
+
+export function uniquePrimarySources(
+  group: InvestigationEvidenceGroup,
+): InvestigationEvidenceSource[] {
+  // One tool call can contribute repeated revisions to the same semantic group.
+  // It still owns one navigation destination, and DOM ids must remain unique.
+  const sources = new Map<string, InvestigationEvidenceSource>();
+  for (const observation of group.observations) {
+    const { source } = observation;
+    if (source.primaryGroupId === group.id && !sources.has(source.id)) {
+      sources.set(source.id, source);
+    }
+  }
+  return [...sources.values()];
+}
+
+export type EvidenceDataOf<T extends InvestigationEvidenceData["type"]> =
+  Extract<InvestigationEvidenceData, { type: T }>;
+
+export function gitOpsValueSeverity(label: string, value: string) {
+  const normalized = value.toLowerCase();
+  if (
+    normalized === "healthy" ||
+    normalized === "synced" ||
+    normalized === "succeeded" ||
+    (label === "Ready" && normalized.startsWith("true"))
+  ) {
+    return "success" as const;
+  }
+  if (
+    normalized === "degraded" ||
+    normalized === "missing" ||
+    normalized === "failed" ||
+    normalized === "error" ||
+    (label === "Ready" && normalized.startsWith("false"))
+  ) {
+    return "error" as const;
+  }
+  if (normalized === "outofsync") return "warning" as const;
+  if (normalized === "progressing" || normalized === "running")
+    return "info" as const;
+  return "neutral" as const;
+}
+
+export function ResourceFact({
+  label,
+  value,
+}: {
+  label: string;
+  value: unknown;
+}) {
+  if (value === undefined || value === null || value === "") return null;
+  return (
+    <div className="flex justify-between gap-2 @min-[560px]/evidence:block">
+      <dt className="text-theme-text-tertiary">{label}</dt>
+      <dd className="font-mono font-medium text-theme-text-primary">
+        {String(value)}
+      </dd>
+    </div>
+  );
+}
+
+export function conditionStatusTone(condition: {
+  type: string;
+  status: string;
+}): "healthy" | "degraded" | "unhealthy" | "unknown" {
+  switch (defaultConditionTone(condition)) {
+    case "ok":
+      return "healthy";
+    case "warning":
+      return "degraded";
+    case "fail":
+      return "unhealthy";
+    case "unknown":
+      return "unknown";
+  }
+}
+
+export function EvidenceCaveat({ data }: { data: InvestigationEvidenceData }) {
+  // Changes get a tooltip rather than a sentence because the wording depends
+  // on whether the reported age was collected with the change.
+  if (data.type === "changes") {
+    return (
+      <Tooltip
+        content={`A change alone does not establish the cause.${data.changeContext?.when ? " The reported age is as of collection." : ""}`}
+        position="left"
+        className="pointer-events-none"
+        wrapperClassName="flex shrink-0"
+      >
+        <button
+          type="button"
+          aria-label="About change evidence"
+          className="flex h-7 w-7 items-center justify-center rounded-md text-theme-text-tertiary hover:bg-theme-hover hover:text-theme-text-secondary focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-accent/50"
+        >
+          <Info className="h-3.5 w-3.5" aria-hidden />
+        </button>
+      </Tooltip>
+    );
+  }
+  const text = EVIDENCE_KIND_TRAITS[data.type].caveat;
+  if (!text) return null;
+  return (
+    <p className="flex items-start gap-1.5 text-xs leading-relaxed text-theme-text-tertiary">
+      <Info className="mt-0.5 h-3 w-3 shrink-0" aria-hidden />
+      {text}
+    </p>
+  );
+}
+
+export function EvidenceIcon({
+  observation,
+  prominence,
+}: {
+  observation: InvestigationEvidenceObservation;
+  prominence: "primary" | "supporting" | "secondary";
+}) {
+  const Icon = evidenceIcon(observation.data.type);
+  return (
+    <span
+      className={clsx(
+        "flex shrink-0 items-center justify-center text-theme-text-tertiary",
+        prominence === "primary" ? "h-7 w-7" : "h-6 w-6",
+      )}
+    >
+      <Icon
+        className={prominence === "primary" ? "h-4 w-4" : "h-3.5 w-3.5"}
+        aria-hidden
+      />
+    </span>
+  );
+}
+
+export function SourceButton({
+  ariaLabel,
+  buttonLabel = "View result",
+  compact = false,
+  onClick,
+}: {
+  ariaLabel?: string;
+  buttonLabel?: string;
+  compact?: boolean;
+  onClick: () => void;
+}) {
+  const tooltip = "Open the original tool result";
+  return (
+    <Tooltip
+      content={tooltip}
+      delay={350}
+      position="left"
+      wrapperClassName="flex shrink-0"
+    >
+      <button
+        type="button"
+        aria-label={ariaLabel ?? tooltip}
+        onClick={onClick}
+        className={clsx(
+          "flex h-7 shrink-0 items-center justify-center rounded-md text-theme-text-tertiary hover:bg-theme-hover hover:text-accent-text focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-accent/50",
+          "gap-1 px-2 text-xs font-medium",
+        )}
+      >
+        <FileSearch className="h-3.5 w-3.5" aria-hidden />
+        <span
+          className={compact ? "hidden @min-[540px]/card:inline" : undefined}
+        >
+          {buttonLabel}
+        </span>
+      </button>
+    </Tooltip>
+  );
+}
+
+function evidenceIcon(type: InvestigationEvidenceData["type"]) {
+  return EVIDENCE_KIND_TRAITS[type].icon;
+}
+
+export function severityBadge(value: string) {
+  const tone = value.toLowerCase();
+  if (
+    tone === "error" ||
+    tone === "critical" ||
+    tone === "failed" ||
+    tone === "blocker"
+  )
+    return "error" as const;
+  if (tone === "alert" || tone === "high") return "alert" as const;
+  if (tone === "warning" || tone === "medium") return "warning" as const;
+  if (tone === "info" || tone === "low" || tone === "review")
+    return "info" as const;
+  return "neutral" as const;
+}
+
+export function phaseLabel(
+  phase: InvestigationEvidenceObservation["source"]["phase"],
+): string {
+  switch (phase) {
+    case "initial":
+      return "Initial";
+    case "followup":
+      return "Follow-up";
+    case "verification":
+      return "Verification";
+    case "apply":
+      return "Apply";
+  }
+}
+
+export function toneBorder(
+  tone: InvestigationEvidenceObservation["tone"],
+  tier: InvestigationEvidenceTier,
+  prominence: "primary" | "supporting" | "secondary",
+): string {
+  if (prominence !== "primary") return "border-theme-border/70";
+  // A supporting adverse card is what the healthy-conflict banner points at,
+  // so it must be tellable from its neutral neighbours: a thin rule, lighter
+  // than the Key tier's.
+  if (tier === "supporting" && tone === "error")
+    return "border-l-2 border-l-semantic-error border-theme-border";
+  if (tier === "supporting" && (tone === "warning" || tone === "alert"))
+    return "border-l-2 border-l-semantic-warning border-theme-border";
+  if (tier !== "key") return "border-theme-border";
+  if (tone === "error")
+    return "border-l-[3px] border-l-red-500 border-theme-border";
+  if (tone === "alert")
+    return "border-l-[3px] border-l-orange-500 border-theme-border";
+  return "border-l-[3px] border-l-amber-500 border-theme-border";
+}

package/src/components/diagnose/investigationEvidence/excerpt.test.ts

@@ -0,0 +1,105 @@
+import { describe, expect, it } from "vitest";
+import { storyExcerpt } from "./excerpt";
+import type { InvestigationEvidenceObservation } from "./types";
+
+function observation(
+  data: InvestigationEvidenceObservation["data"],
+): InvestigationEvidenceObservation {
+  return {
+    source: { id: "s1", turnIndex: 0 },
+    revision: 1,
+    title: "t",
+    data,
+  } as unknown as InvestigationEvidenceObservation;
+}
+
+describe("storyExcerpt", () => {
+  it("keeps a log card's newest two selected lines even when compact, the rest behind the fold", () => {
+    const logs = observation({
+      type: "logs",
+      pod: "api-1",
+      container: "api",
+      previous: false,
+      warnings: [],
+      logs: { lines: ["a", "b", "c", "d"], totalLines: 4, matchedLines: 4 },
+    } as never);
+    expect(storyExcerpt(logs, [], { compact: true })).toEqual({
+      kind: "lines",
+      head: ["c", "d"],
+      rest: ["a", "b"],
+    });
+  });
+
+  it("shows a chart only when the card is the cause or the symptom, and never compact", () => {
+    const metrics = observation({ type: "metrics", origin: "query" } as never);
+    expect(
+      storyExcerpt(metrics, [{ role: "context" }], { compact: false }),
+    ).toBeUndefined();
+    expect(
+      storyExcerpt(metrics, [{ role: "symptom" }], { compact: false }),
+    ).toEqual({ kind: "chart" });
+    expect(
+      storyExcerpt(metrics, [{ role: "cause" }], { compact: true }),
+    ).toBeUndefined();
+  });
+
+  it("picks the workload's own rows from a ranking and the findings on it from a posture card", () => {
+    const ranking = observation({
+      type: "ranking",
+      kind: "pods",
+      sort: "memory",
+      scope: "namespace shop",
+      rows: [
+        { kind: "Pod", name: "other", cpu: "1m", memory: "1Mi", target: false },
+        { kind: "Pod", name: "api-1", cpu: "2m", memory: "2Mi", target: true },
+      ],
+    } as never);
+    expect(storyExcerpt(ranking, [], { compact: false })).toMatchObject({
+      kind: "ranking",
+      rows: [{ name: "api-1" }],
+    });
+    expect(
+      storyExcerpt(ranking, [{ subject: { kind: "Pod", name: "other" } }], {
+        compact: false,
+      }),
+    ).toMatchObject({
+      kind: "ranking",
+      rows: [{ name: "other" }, { name: "api-1" }],
+    });
+    const posture = observation({
+      type: "posture",
+      source: "audit",
+      scope: "namespace shop",
+      findings: [
+        {
+          kind: "Deployment",
+          name: "api",
+          check: "runAsRoot",
+          severity: "high",
+          message: "m",
+          target: true,
+        },
+      ],
+    } as never);
+    expect(storyExcerpt(posture, [], { compact: false })).toMatchObject({
+      kind: "posture",
+      findings: [{ check: "runAsRoot" }],
+    });
+  });
+
+  it("shows the rows a citation names on a listing, and nothing for an unnamed one", () => {
+    const listing = observation({
+      type: "inventory",
+      scope: "namespace shop",
+      resources: [{ kind: "ConfigMap", namespace: "shop", name: "cfg" }],
+    } as never);
+    expect(storyExcerpt(listing, [], { compact: false })).toBeUndefined();
+    expect(
+      storyExcerpt(
+        listing,
+        [{ subject: { kind: "ConfigMap", namespace: "shop", name: "cfg" } }],
+        { compact: false },
+      ),
+    ).toMatchObject({ kind: "rows", entries: [{ matches: 1 }] });
+  });
+});

package/src/components/diagnose/investigationEvidence/excerpt.ts

@@ -0,0 +1,92 @@
+import { sameKind } from "./observations";
+import type {
+  DiagnosisEvidenceRole,
+  DiagnosisEvidenceSubject,
+} from "../../../api/diagnose";
+import { namedInventoryRows } from "./bodies/inventory";
+import { stripAnsi } from "@skyhook-io/k8s-ui";
+import type {
+  InvestigationEvidenceObservation,
+  InvestigationPostureFinding,
+  InvestigationRankingRow,
+  InvestigationResourceSummary,
+} from "./types";
+
+/** How many selected log lines a card carries; the rest wait in the record. */
+export const VISIBLE_LOG_EVIDENCE_LINES = 12;
+
+/**
+ * What a card placed in the story shows inline, under its header, before the
+ * fold. The citation decides it: the lines Radar selected, the row a subject
+ * names, the workload's own row in a ranking, the findings on it, or the
+ * chart when the card is the cause or the symptom. Nothing here is the
+ * agent's text; every excerpt is a slice of Radar's record.
+ */
+export type StoryExcerpt =
+  | { kind: "lines"; head: string[]; rest: string[] }
+  | { kind: "rows"; entries: ReturnType<typeof namedInventoryRows> }
+  | { kind: "ranking"; rows: InvestigationRankingRow[] }
+  | { kind: "posture"; findings: InvestigationPostureFinding[] }
+  | { kind: "chart" };
+
+export interface StoryExcerptItem {
+  role?: DiagnosisEvidenceRole;
+  subject?: DiagnosisEvidenceSubject;
+}
+
+export function storyExcerpt(
+  observation: InvestigationEvidenceObservation,
+  items: readonly StoryExcerptItem[],
+  options: { compact: boolean; scopeNamespace?: string },
+): StoryExcerpt | undefined {
+  const data = observation.data;
+  // The lines are the card: a compact log card keeps them.
+  if (data.type === "logs") {
+    const lines = (data.logs?.lines ?? [])
+      .slice(-VISIBLE_LOG_EVIDENCE_LINES)
+      .map((line) => stripAnsi(line));
+    if (lines.length === 0) return undefined;
+    return { kind: "lines", head: lines.slice(-2), rest: lines.slice(0, -2) };
+  }
+  if (options.compact) return undefined;
+  const named = (row: { kind: string; namespace?: string; name: string }) =>
+    items.some(
+      (item) =>
+        item.subject?.name === row.name &&
+        sameKind(item.subject.kind, row.kind) &&
+        (!item.subject.namespace ||
+          row.namespace === undefined ||
+          item.subject.namespace === row.namespace),
+    );
+  switch (data.type) {
+    case "metrics":
+      // A chart placed as the cause or the symptom is the card.
+      return items.some(
+        (item) => item.role === "cause" || item.role === "symptom",
+      )
+        ? { kind: "chart" }
+        : undefined;
+    case "inventory": {
+      const entries = namedInventoryRows(
+        data.resources as InvestigationResourceSummary[],
+        items,
+        options.scopeNamespace,
+      );
+      return entries.length > 0 ? { kind: "rows", entries } : undefined;
+    }
+    case "ranking": {
+      const rows = data.rows
+        .filter((row) => row.target || named(row))
+        .slice(0, 3);
+      return rows.length > 0 ? { kind: "ranking", rows } : undefined;
+    }
+    case "posture": {
+      const findings = data.findings
+        .filter((finding) => finding.target || named(finding))
+        .slice(0, 3);
+      return findings.length > 0 ? { kind: "posture", findings } : undefined;
+    }
+    default:
+      return undefined;
+  }
+}

package/src/components/diagnose/investigationEvidence/identity.test.ts

@@ -446,12 +446,7 @@ describe("root-cause evidence resolution", () => {
   it("keeps an unadapted successful Radar check linkable to Activity", () => {
     const ref = evidenceRef("a", "b");
     const projection = project([
-      tool(
-        "metrics-1",
-        "discover_metrics",
-        { result: [1] },
-        { evidenceRef: ref },
-      ),
+      tool("metrics-1", "get_dashboard", { result: [1] }, { evidenceRef: ref }),
     ]);
 
     expect(projection.groups).toHaveLength(0);
@@ -501,7 +496,10 @@ describe("root-cause evidence resolution", () => {
         { status: "linked", refs: [priorRef] },
         1,
       ),
-    ).toMatchObject({ status: "linked", links: [{ source: { stepId: "old" } }] });
+    ).toMatchObject({
+      status: "linked",
+      links: [{ source: { stepId: "old" } }],
+    });
     // A result read AFTER the assessment turn is not: the assessment could not
     // have seen it.
     expect(

package/src/components/diagnose/investigationEvidence/index.ts

@@ -15,7 +15,7 @@ export {
   isInvestigationEvidenceRef,
   resolveInvestigationRootCauseEvidence,
 } from "./identity";
-export { evidenceSemanticSnapshot } from "./observations";
+export { evidenceSemanticSnapshot, sameKind } from "./observations";
 export type {
   InvestigationAccessCheck,
   InvestigationAlertInstance,

package/src/components/diagnose/investigationEvidence/navigation.tsx

@@ -0,0 +1,26 @@
+import { createContext } from "react";
+import type { MetricsChangeCoverage } from "../investigationMetrics";
+import type { DiagnosisResourceRef } from "../diagnoseEvidenceTypes";
+import type { InvestigationCaseItem } from "../investigationCase";
+
+/** The Timeline scope a changes card can open: one resource name in one namespace. */
+export interface InvestigationTimelineScope {
+  namespace?: string;
+  name: string;
+}
+
+export const EvidenceNavigationContext = createContext<{
+  onOpenResource?: (ref: DiagnosisResourceRef) => void;
+  onOpenTimeline?: (scope: InvestigationTimelineScope) => void;
+  revealSourceId?: string;
+  revealRequestId?: number;
+  expandedGroupIds?: ReadonlySet<string>;
+  onGroupOpenChange?: (id: string, open: boolean) => void;
+  citedOrderByGroup?: ReadonlyMap<string, number>;
+  /** Change markers for each metrics observation, keyed by its source id. */
+  metricsMarkersBySource?: ReadonlyMap<string, MetricsChangeCoverage>;
+  /** Card- and revision-placed agent items, keyed by group id. */
+  caseByGroup?: ReadonlyMap<string, InvestigationCaseItem[]>;
+  /** The hypothesis each `rules_out` item excludes, keyed by item. */
+  excludedByItem?: ReadonlyMap<string, string>;
+}>({});

package/src/components/diagnose/investigationEvidence/observations.ts

@@ -17,6 +17,7 @@ import {
 } from "../diagnoseEvidenceTypes";
 import { investigationResourceEvidenceSummary } from "../investigationResourceEvidenceModel";
 import { kindToPluralWithGroup } from "../../../utils/navigation";
+import { pluralToKind } from "@skyhook-io/k8s-ui";
 import { stableHash } from "./identity";
 import { nonEmptyString, parseJSON, record, stringArray } from "./parse";
 import {
@@ -185,12 +186,22 @@ const INVESTIGATION_RESULT_LABELS: Readonly<Record<string, string>> = {
   get_helm_release: "Helm release",
   get_subject_permissions: "Permissions",
   query_prometheus: "Prometheus query",
+  top_resources: "Resource ranking",
+  get_cluster_audit: "Posture findings",
+  get_cluster_upgrade_readiness: "Upgrade readiness",
+  list_helm_releases: "Helm releases",
+  list_packages: "Installed packages",
+  search: "Search results",
+  discover_metrics: "Metric discovery",
 };
 export function investigationResultLabel(
   source: InvestigationEvidenceSource,
 ): string {
   return INVESTIGATION_RESULT_LABELS[source.tool] ?? "Investigation result";
 }
+export function sameKind(left: string, right: string): boolean {
+  return pluralToKind(left).toLowerCase() === pluralToKind(right).toLowerCase();
+}
 export function resourceMatchesTarget(
   target: InvestigationEvidenceTarget,
   resource: {

package/src/components/diagnose/investigationEvidence/projection.test.ts

@@ -1774,7 +1774,7 @@ describe("strict evidence adapters", () => {
 
   it("keeps unknown tools in Activity and limits invalid known contracts", () => {
     const result = project([
-      tool("other", "discover_metrics", { data: "ignored" }),
+      tool("other", "get_dashboard", { data: "ignored" }),
       tool("bad-events", "get_events", { events: [{ nope: true }] }),
     ]);
     expect(result.sources.map((source) => source.stepId)).toEqual([