@skyhook-io/radar-app 1.13.1 → 1.13.3

package/src/components/diagnose/DiagnoseContext.tsx

@@ -1,5 +1,5 @@
 // The single controller for the AI assistant surface. One instance app-wide:
-// the per-resource "Diagnose" button and the global top-bar entry both dispatch
+// the per-resource "Investigate" button and the global top-bar entry both dispatch
 // here. Investigations are durable, server-side jobs (see internal/ai RunManager);
 // this provider lists them, tracks which one is focused, and owns the push-content
 // layout. The run lifetime is the server's, so closing/navigating never kills one.
@@ -29,9 +29,12 @@ import {
   type AgentInfo,
   type ExecutionProfile,
 } from "../../api/diagnose";
+import { runTargetKey } from "./target";
 
 export interface Target {
   kind: string;
+  /** Kubernetes API group; empty means core. */
+  group: string;
   namespace: string;
   name: string;
   /** The issue this investigation is for, when it came from an issue. Hosts
@@ -45,7 +48,7 @@ export interface Target {
 }
 export type DiagnoseView = "home" | "investigation";
 
-// Setup readiness of the local AI-diagnosis feature, derived from the agents API:
+// Setup readiness of local AI investigations, derived from the agents API:
 //  - "ready":         an agent is installed and the engine is running (available)
 //  - "needs-install": the feature is supported here but no agent CLI is installed
 //  - "needs-restart": a supported agent is now on PATH but Radar booted before it
@@ -110,16 +113,6 @@ interface DiagnoseLayoutCtx {
   runningKeys: ReadonlySet<string>; // resources with a live investigation (see runTargetKey)
 }
 
-// Stable key for "is THIS resource being investigated right now" — built the same way
-// from a run summary and from a button's target so the two always match.
-export function runTargetKey(
-  kind: string,
-  namespace: string,
-  name: string,
-): string {
-  return `${kind} ${namespace} ${name}`;
-}
-
 const Ctx = createContext<DiagnoseCtx | null>(null);
 const LayoutCtx = createContext<DiagnoseLayoutCtx | null>(null);
 
@@ -168,7 +161,7 @@ export function agentLabelFor(name: string, fallbackLabel?: string): string {
 }
 
 // openDiagnoseSettings opens the Settings dialog (App.tsx listens for this DOM
-// event) — the canonical home for AI-diagnosis config.
+// event) — the canonical home for AI investigation config.
 export function openDiagnoseSettings() {
   window.dispatchEvent(
     new CustomEvent("radar:open-settings", { detail: { section: "ai" } }),
@@ -476,15 +469,17 @@ export function DiagnoseProvider({
   }, []);
 
   // A content-stable signature of the resources with a live investigation,
-  // so the per-resource Diagnose buttons can show a "running" indicator even with the
+  // so the per-resource Investigate buttons can show a "running" indicator even with the
   // panel closed — and only re-render when the set actually changes, not every poll.
   const runningSig = runs
     .filter((r) => r.status === "running" || r.status === "stopping")
-    .map((r) => runTargetKey(r.kind, r.namespace, r.name))
+    .map((r) => runTargetKey(r.kind, r.namespace, r.name, r.group))
     .sort()
-    .join("|");
+    // resourceKey itself is pipe-delimited; newlines cannot occur in a
+    // Kubernetes group, Kind, namespace, or name.
+    .join("\n");
   const runningKeys = useMemo(
-    () => new Set(runningSig ? runningSig.split("|") : []),
+    () => new Set(runningSig ? runningSig.split("\n") : []),
     [runningSig],
   );
   const hasRunning = runningSig.length > 0;

package/src/components/diagnose/DiagnoseSurface.test.tsx

@@ -1,9 +1,21 @@
-import { describe, expect, it } from "vitest";
-import { canCopyRunLink, canStartNewInvestigation } from "./DiagnoseSurface";
+import { describe, expect, it, vi } from "vitest";
+import {
+  DIAGNOSE_SURFACE_FRAME_CLASS,
+  MAXIMIZED_COMPACT_HISTORY_VISIBILITY_CLASS,
+  MAXIMIZED_HOME_DETAIL_VISIBILITY_CLASS,
+  MAXIMIZED_HOME_RUN_HEADER_VISIBILITY_CLASS,
+  INVESTIGATION_HISTORY_MIN_WIDTH,
+  MAXIMIZED_RUN_META_VISIBILITY_CLASS,
+  canStartNewInvestigation,
+  canCopyRunLink,
+  investigationHeaderPresentation,
+  openInvestigationEvidenceResource,
+} from "./DiagnoseSurface";
 import {
   canContinueInvestigation,
+  canInvestigateFurther,
   canStopInvestigation,
-} from "./InvestigationView";
+} from "./investigationState";
 import type { RunSummary } from "../../api/diagnose";
 
 // The "new investigation" button dispatches an agent and spends the user's own
@@ -13,6 +25,7 @@ function run(status: RunSummary["status"]): RunSummary {
   return {
     id: "r1",
     kind: "Deployment",
+    group: "apps",
     namespace: "prod",
     name: "payments",
     context: "prod-cluster",
@@ -43,13 +56,18 @@ describe("canStartNewInvestigation", () => {
     ).toBe(false);
   });
 
-  it("stays hidden while a stopped turn is draining", () => {
+  it("stays hidden on a stale run", () => {
+    // A closed session must not start a new investigation against a resource
+    // that may not exist in the active cluster.
+    expect(canStartNewInvestigation("investigation", run("stale"), false)).toBe(
+      false,
+    );
+  });
+
+  it("blocks fresh starts while a human turn stops, but allows a separate human run from an automatic one", () => {
     expect(
       canStartNewInvestigation("investigation", run("stopping"), false),
     ).toBe(false);
-  });
-
-  it("offers a separate human investigation while an automatic run is in flight", () => {
     expect(
       canStartNewInvestigation(
         "investigation",
@@ -59,15 +77,6 @@ describe("canStartNewInvestigation", () => {
     ).toBe(true);
   });
 
-  it("stays hidden on a stale run", () => {
-    // The body offers "Re-run on current cluster" WITH the context-changed
-    // warning. A bare + carries none of it, at a resource that may not exist in
-    // the context it would now run against.
-    expect(canStartNewInvestigation("investigation", run("stale"), false)).toBe(
-      false,
-    );
-  });
-
   it("stays hidden while consent is pending", () => {
     expect(canStartNewInvestigation("investigation", run("done"), true)).toBe(
       false,
@@ -89,6 +98,152 @@ describe("canStartNewInvestigation", () => {
   });
 });
 
+describe("investigation history navigation", () => {
+  it("restores the docked surface before opening an evidence resource", () => {
+    const events: string[] = [];
+    const onOpenResource = vi.fn(() => events.push("open"));
+    const setMaximized = vi.fn(() => events.push("dock"));
+    const closeDiagnose = vi.fn(() => events.push("close"));
+    const ref = {
+      kind: "Deployment",
+      group: "apps",
+      namespace: "shop",
+      name: "api",
+    };
+
+    openInvestigationEvidenceResource(
+      ref,
+      onOpenResource,
+      setMaximized,
+      closeDiagnose,
+      false,
+    );
+
+    expect(events).toEqual(["dock", "open"]);
+    expect(setMaximized).toHaveBeenCalledWith(false);
+    expect(closeDiagnose).not.toHaveBeenCalled();
+    expect(onOpenResource).toHaveBeenCalledWith(ref);
+  });
+
+  it("closes an overlay before opening an evidence resource", () => {
+    const events: string[] = [];
+    const onOpenResource = vi.fn(() => events.push("open"));
+    const setMaximized = vi.fn(() => events.push("dock"));
+    const closeDiagnose = vi.fn(() => events.push("close"));
+    const ref = {
+      kind: "Pod",
+      namespace: "shop",
+      name: "api-7d9f",
+    };
+
+    openInvestigationEvidenceResource(
+      ref,
+      onOpenResource,
+      setMaximized,
+      closeDiagnose,
+      true,
+    );
+
+    expect(events).toEqual(["close", "open"]);
+    expect(setMaximized).not.toHaveBeenCalled();
+    expect(closeDiagnose).toHaveBeenCalledOnce();
+    expect(onOpenResource).toHaveBeenCalledWith(ref);
+  });
+
+  it("keeps document overflow out of the bounded Diagnose frame", () => {
+    expect(DIAGNOSE_SURFACE_FRAME_CLASS).toContain("absolute");
+    expect(DIAGNOSE_SURFACE_FRAME_CLASS).toContain("min-h-0");
+    expect(DIAGNOSE_SURFACE_FRAME_CLASS).toContain("overflow-hidden");
+    expect(DIAGNOSE_SURFACE_FRAME_CLASS).not.toContain("overflow-y-auto");
+  });
+
+  it("reserves the history rail for wider investigation surfaces", () => {
+    expect(INVESTIGATION_HISTORY_MIN_WIDTH).toBe(1750);
+    expect(MAXIMIZED_COMPACT_HISTORY_VISIBILITY_CLASS).toBe(
+      "@min-[1750px]/diagnose-surface:hidden",
+    );
+    expect(MAXIMIZED_HOME_DETAIL_VISIBILITY_CLASS).toBe(
+      "hidden @min-[1750px]/diagnose-surface:flex",
+    );
+    expect(MAXIMIZED_HOME_RUN_HEADER_VISIBILITY_CLASS).toBe(
+      "hidden @min-[1750px]/diagnose-surface:block",
+    );
+    expect(MAXIMIZED_RUN_META_VISIBILITY_CLASS).toBe(
+      "hidden @min-[1750px]/diagnose-surface:flex",
+    );
+  });
+
+  it("keeps docked Home generic and removes actions for its retained run", () => {
+    expect(
+      investigationHeaderPresentation({
+        view: "home",
+        maximized: false,
+        hasVisibleRunDetail: true,
+      }),
+    ).toEqual({
+      genericIdentityClass: "",
+      detailIdentityClass: null,
+      runActionsClass: null,
+    });
+  });
+
+  it("swaps generic Home identity for the labeled retained detail at the wide breakpoint", () => {
+    expect(
+      investigationHeaderPresentation({
+        view: "home",
+        maximized: true,
+        hasVisibleRunDetail: true,
+      }),
+    ).toEqual({
+      genericIdentityClass: MAXIMIZED_COMPACT_HISTORY_VISIBILITY_CLASS,
+      detailIdentityClass: MAXIMIZED_HOME_RUN_HEADER_VISIBILITY_CLASS,
+      runActionsClass: MAXIMIZED_HOME_DETAIL_VISIBILITY_CLASS,
+    });
+  });
+
+  it("labels a direct detail at every size and keeps its run actions with it", () => {
+    expect(
+      investigationHeaderPresentation({
+        view: "investigation",
+        maximized: false,
+        hasVisibleRunDetail: true,
+      }),
+    ).toEqual({
+      genericIdentityClass: null,
+      detailIdentityClass: "",
+      runActionsClass: "",
+    });
+  });
+
+  it("does not invent a retained-detail header or actions without a run", () => {
+    expect(
+      investigationHeaderPresentation({
+        view: "home",
+        maximized: true,
+        hasVisibleRunDetail: false,
+      }),
+    ).toEqual({
+      genericIdentityClass: "",
+      detailIdentityClass: null,
+      runActionsClass: null,
+    });
+  });
+
+  it("removes run actions when another surface replaces the direct detail", () => {
+    expect(
+      investigationHeaderPresentation({
+        view: "investigation",
+        maximized: true,
+        hasVisibleRunDetail: false,
+      }),
+    ).toEqual({
+      genericIdentityClass: null,
+      detailIdentityClass: "",
+      runActionsClass: null,
+    });
+  });
+});
+
 describe("canStopInvestigation", () => {
   it("lets the terminal transcript outrank a lagging running summary", () => {
     expect(canStopInvestigation(run("running"), false, false, "done")).toBe(
@@ -181,3 +336,43 @@ describe("canCopyRunLink", () => {
     expect(canCopyRunLink({ ...run("done"), radarUrl: "" })).toBe(false);
   });
 });
+
+describe("canInvestigateFurther", () => {
+  it("offers a context-preserving next step on a completed automatic investigation", () => {
+    expect(
+      canInvestigateFurther({
+        ...run("done"),
+        trigger: "background",
+        issueId: "issue-1",
+      }),
+    ).toBe(true);
+  });
+
+  it("does not promise findings for missing, unfinished, stale or human investigations", () => {
+    expect(canInvestigateFurther(run("done"))).toBe(false);
+    expect(
+      canInvestigateFurther({ ...run("done"), trigger: "background" }),
+    ).toBe(false);
+    for (const status of [
+      "running",
+      "stopping",
+      "error",
+      "stopped",
+      "stale",
+    ] as const) {
+      expect(
+        canInvestigateFurther({
+          ...run(status),
+          trigger: "background",
+          issueId: "issue-1",
+        }),
+      ).toBe(false);
+    }
+    expect(
+      canInvestigateFurther(
+        { ...run("done"), trigger: "background", issueId: "issue-1" },
+        true,
+      ),
+    ).toBe(false);
+  });
+});