@skyhook-io/radar-app 1.14.4 → 1.14.5

package/src/components/rightsizing/model.ts

@@ -24,11 +24,11 @@ export interface RightsizingScanRow {
 }
 
 const CLASS_RANK: Record<ScanClass, number> = {
-  reduction: 0,
   increase: 1,
-  review: 2,
-  need_data: 3,
-  in_range: 4,
+  reduction: 2,
+  review: 3,
+  need_data: 4,
+  in_range: 5,
 }
 
 const MIN_CPU_REDUCTION = 0.05
@@ -39,32 +39,55 @@ export function classifyRows(
   replicas = 1,
   scaledToZero = false,
 ): ScanClass {
-  if (rows.some((row) => row.queryError || row.fit === 'insufficient_history')) return 'need_data'
+  const evidenced = rows.filter((row) => !row.queryError && row.fit !== 'insufficient_history')
+  if (evidenced.length === 0) return 'need_data'
   if (scaledToZero) return 'review'
   if (
-    rows.some(
+    evidenced.some(
       (row) =>
         (row.fit === 'under_requested' || row.fit === 'missing_request') && row.recommendedRequest,
     )
   )
     return 'increase'
-  if (rows.some(needsManualReview)) return 'review'
-  const impact = calculateImpact(rows, replicas)
+  if (evidenced.some(needsManualReview)) return 'review'
+  const impact = calculateImpact(evidenced, replicas)
   if (-impact.cpuChange >= MIN_CPU_REDUCTION || -impact.memoryChange >= MIN_MEMORY_REDUCTION)
     return 'reduction'
-  return 'in_range'
+  return evidenced.length === rows.length ? 'in_range' : 'need_data'
 }
 
 function needsManualReview(row: RightsizingRow): boolean {
   return (
     row.hpaManaged ||
+    needsSafetyReview(row) ||
+    (isReduction(row) && row.bursty === true) ||
+    row.recommendationReason === 'hpa_evidence_unavailable' ||
+    row.recommendationReason === 'oom_evidence_unavailable'
+  )
+}
+
+function needsSafetyReview(row: RightsizingRow): boolean {
+  return (
     row.currentPodOOM === true ||
     row.windowOomEvidence === true ||
     row.limitConflict === true ||
-    row.recommendationReason === 'hpa_evidence_unavailable' ||
-    row.recommendationReason === 'oom_evidence_unavailable' ||
-    (isReduction(row) && (row.bursty || (row.throttleRatio ?? 0) >= 0.1))
+    (isReduction(row) && (row.throttleRatio ?? 0) >= 0.1)
+  )
+}
+
+function scanPriority(row: RightsizingScanRow): number {
+  if (
+    !row.scaledToZero &&
+    [row.cpu, row.memory].some(
+      (resource) =>
+        resource &&
+        !resource.queryError &&
+        resource.fit !== 'insufficient_history' &&
+        needsSafetyReview(resource),
+    )
   )
+    return 0
+  return CLASS_RANK[row.classification]
 }
 
 function isReduction(row: RightsizingRow): boolean {
@@ -117,7 +140,7 @@ export function flattenScanResults(scan: RightsizingScanResponse): RightsizingSc
   }
   return result.sort(
     (a, b) =>
-      CLASS_RANK[a.classification] - CLASS_RANK[b.classification] ||
+      scanPriority(a) - scanPriority(b) ||
       impactScore(b) - impactScore(a) ||
       a.namespace.localeCompare(b.namespace) ||
       a.name.localeCompare(b.name) ||

package/src/components/rightsizing/notices.test.tsx

@@ -0,0 +1,175 @@
+import { renderToStaticMarkup } from 'react-dom/server'
+import { describe, expect, it } from 'vitest'
+import type { RightsizingRow, RightsizingScanResponse } from '../../api/client'
+import { FitWhy, ScanNotices, ScanSummary } from './RightsizingScanView'
+
+const scan: RightsizingScanResponse = {
+  state: 'complete',
+  scannedAt: '2026-09-19T06:52:54Z',
+  window: '7d',
+  source: 'radar',
+  coverage: {
+    workloadsDiscovered: 120,
+    workloadsEvaluated: 120,
+    workloadsWithData: 47,
+    batches: 3,
+    completedBatches: 3,
+  },
+  workloads: [],
+}
+
+function render(result: RightsizingScanResponse) {
+  return renderToStaticMarkup(<ScanNotices result={result} />)
+}
+
+describe('rightsizing scan notices', () => {
+  it('keeps timeout coverage visible with query failures behind one collapsed disclosure', () => {
+    const html = render({
+      ...scan,
+      state: 'partial',
+      coverage: {
+        ...scan.coverage,
+        workloadsEvaluated: 100,
+        completedBatches: 0,
+        daemonSetsWithoutNodes: 27,
+      },
+      warnings: ['cpu_query_failed', 'memory_query_failed', 'scan_deadline_exceeded'].map(
+        (code) => ({ code, message: 'backend-specific details' }),
+      ),
+    })
+    expect(html.match(/<section/g)).toHaveLength(1)
+    expect(html.match(/<button/g)).toHaveLength(1)
+    expect(html).toContain('Partial results')
+    expect(html).not.toContain('workloads evaluated')
+    expect(html).toContain('select namespaces in the top bar')
+    expect(html).toContain('Available recommendations are shown')
+    expect(html).toContain('aria-expanded="false"')
+    expect(html).toContain('inert=""')
+    expect(html).toContain('Some CPU data could not be queried')
+    expect(html).toContain('Some memory data could not be queried')
+    expect(html).toContain('27 DaemonSets')
+    expect(html).not.toContain('completed batches')
+    expect(html).not.toContain('backend-specific details')
+  })
+
+  it('does not label a complete scan with excluded DaemonSets as a query failure', () => {
+    const html = render({
+      ...scan,
+      coverage: { ...scan.coverage, daemonSetsWithoutNodes: 1 },
+    })
+    expect(html).toContain('Scan notes')
+    expect(html).toContain('1 DaemonSet runs on no node right now and is not listed')
+    expect(html).not.toContain('<button')
+    expect(html).not.toContain('Partial results')
+    expect(html).not.toContain('time limit')
+  })
+
+  it('preserves access and cache limitations without claiming a timeout', () => {
+    const html = render({
+      ...scan,
+      state: 'partial',
+      coverage: {
+        ...scan.coverage,
+        restrictedKinds: ['Deployment'],
+        partiallyCachedKinds: ['StatefulSet'],
+        unavailableKinds: ['DaemonSet'],
+      },
+    })
+    expect(html).toContain('Kubernetes access')
+    expect(html).toContain('available ownership data')
+    expect(html).toContain('caching only some namespaces')
+    expect(html).not.toContain('time limit')
+  })
+
+  it('does not infer a timeout or short history from a query failure', () => {
+    const html = render({
+      ...scan,
+      state: 'partial',
+      warnings: [{ code: 'cpu_query_failed', message: 'unknown error' }],
+    })
+    expect(html).toContain('Some CPU data could not be queried')
+    expect(html).not.toContain('time limit')
+    expect(html).not.toContain('not enough recent history')
+  })
+
+  it('shows no notice for a clean scan and no empty Details button for deadline-only partial results', () => {
+    expect(render(scan)).toBe('')
+    const html = render({
+      ...scan,
+      state: 'partial',
+      warnings: [{ code: 'scan_deadline_exceeded', message: 'deadline' }],
+    })
+    expect(html).toContain('time limit')
+    expect(html).not.toContain('<button')
+  })
+})
+
+describe('rightsizing evidence explanation', () => {
+  const row: RightsizingRow = {
+    container: 'app',
+    resource: 'cpu',
+    fit: 'insufficient_history',
+    confidence: 'low',
+    coverage: 0,
+    sampleCount: 0,
+    expectedSamples: 2017,
+    hpaManaged: false,
+    hpaEvidenceAvailable: true,
+    oomEvidenceAvailable: false,
+  }
+
+  it('distinguishes failed queries from successfully measured short history', () => {
+    const failed = renderToStaticMarkup(
+      <FitWhy label="CPU" row={{ ...row, queryError: 'usage query failed' }} />,
+    )
+    expect(failed).toContain('Metrics could not be queried')
+    expect(failed).not.toContain('0.0 days')
+    expect(failed).not.toContain('Wait for more runtime history')
+    const short = renderToStaticMarkup(<FitWhy label="CPU" row={row} />)
+    expect(short).toContain('0.0 days')
+    expect(short).toContain('Wait for more runtime history')
+  })
+})
+
+describe('rightsizing scope and coverage summary', () => {
+  const counts = {
+    increase: 1,
+    reduction: 4,
+    review: 0,
+    in_range: 2,
+    need_data: 3,
+  }
+  it('separates attempted workloads from usage evidence and container counts', () => {
+    const html = renderToStaticMarkup(
+      <ScanSummary
+        namespaces={['dev', 'staging']}
+        result={{
+          ...scan,
+          coverage: { ...scan.coverage, workloadsEvaluated: 100 },
+        }}
+        counts={counts}
+        selected="actions"
+        onSelect={() => {}}
+      />,
+    )
+    expect(html).toContain('dev, staging')
+    expect(html).toContain('Change scan scope in the top bar')
+    expect(html).toContain('100 of 120 workloads attempted')
+    expect(html).toContain('47 with usage data')
+    expect(html).toContain('7d window')
+    expect(html).toContain('1 container<')
+    expect(html).not.toContain('workloads evaluated')
+  })
+  it('qualifies the all-namespace scope by visibility', () => {
+    const html = renderToStaticMarkup(
+      <ScanSummary
+        namespaces={[]}
+        result={scan}
+        counts={counts}
+        selected="actions"
+        onSelect={() => {}}
+      />,
+    )
+    expect(html).toContain('All visible namespaces')
+  })
+})

package/src/components/ui/Markdown.tsx

@@ -13,9 +13,10 @@ interface MarkdownProps {
    * reference, say) into a control instead of an external link.
    */
   linkRenderer?: (href: string | undefined, children: ReactNode) => ReactNode | null
+  codeActions?: (code: string) => ReactNode
 }
 
-export function Markdown({ children, className, linkRenderer }: MarkdownProps) {
+export function Markdown({ children, className, linkRenderer, codeActions }: MarkdownProps) {
   return (
     <div className={clsx('markdown-content', className)}>
       <ReactMarkdown
@@ -62,6 +63,15 @@ export function Markdown({ children, className, linkRenderer }: MarkdownProps) {
         code: ({ className, children }) => {
           const isInline = !className
           if (isInline) {
+            const actions = codeActions?.(String(children))
+            if (actions) {
+              return (
+                <span className="inline-flex max-w-full items-start gap-1 align-middle">
+                  <code className="inline-code min-w-0">{children}</code>
+                  {actions}
+                </span>
+              )
+            }
             return (
               <code className="inline-code">
                 {children}
@@ -72,11 +82,28 @@ export function Markdown({ children, className, linkRenderer }: MarkdownProps) {
             <code className="block font-mono text-theme-text-secondary">{children}</code>
           )
         },
-        pre: ({ children }) => (
-          <pre className="my-3 p-3 bg-theme-elevated rounded-lg overflow-x-auto text-xs font-mono text-theme-text-secondary">
-            {children}
-          </pre>
-        ),
+        pre: ({ children, node }) => {
+          const code = node?.children[0]
+          const text = code?.type === 'element'
+            ? code.children.filter(child => child.type === 'text').map(child => child.value).join('')
+            : ''
+          const actions = codeActions?.(text)
+          if (actions) {
+            // Render the code directly so an unlabelled fence does not also
+            // receive the inline-code action. Only the code scrolls, not Copy.
+            return (
+              <pre className="my-3 flex items-start gap-2 rounded-lg bg-theme-elevated p-3 text-xs font-mono text-theme-text-secondary">
+                <code className="min-w-0 flex-1 overflow-x-auto">{text}</code>
+                {actions}
+              </pre>
+            )
+          }
+          return (
+            <pre className="my-3 p-3 bg-theme-elevated rounded-lg overflow-x-auto text-xs font-mono text-theme-text-secondary">
+              {children}
+            </pre>
+          )
+        },
         blockquote: ({ children }) => (
           <blockquote className="border-l-2 border-theme-border pl-3 my-2 text-theme-text-tertiary italic">
             {children}