@skyhook-io/radar-app 1.14.3 → 1.14.5

package/src/components/rightsizing/empty-state.test.tsx

@@ -0,0 +1,67 @@
+import { renderToStaticMarkup } from 'react-dom/server'
+import { describe, expect, it } from 'vitest'
+import { ScanEmptyState } from './RightsizingScanView'
+
+const props = {
+  counts: { increase: 0, reduction: 0, review: 0, need_data: 0, in_range: 2 },
+  classFilter: 'actions' as const,
+  hasResultFilters: false,
+  onlySystemRowsAreHidden: false,
+  hasQueryErrors: false,
+  onSelect: () => {},
+  onClear: () => {},
+  onIncludeSystem: () => {},
+}
+
+describe('rightsizing empty journeys', () => {
+  it('affirms no actionable changes only for evaluated evidence, with an inspection action', () => {
+    const html = renderToStaticMarkup(<ScanEmptyState {...props} />)
+    expect(html).toContain('No actionable changes')
+    expect(html).toContain('2 evaluated containers')
+    expect(html).toContain('outside the scan coverage')
+    expect(html).toContain('View evaluated containers')
+    expect(html).not.toContain('Show recommended actions')
+  })
+
+  it.each([false, true])(
+    'explains unknown evidence (query errors: %s) without claiming health',
+    (hasQueryErrors) => {
+      const html = renderToStaticMarkup(
+        <ScanEmptyState
+          {...props}
+          counts={{ ...props.counts, in_range: 0, need_data: 2 }}
+          hasQueryErrors={hasQueryErrors}
+        />,
+      )
+      expect(html).toContain('Not enough evidence for recommendations')
+      expect(html).toContain('View containers needing evidence')
+      expect(html).toContain(
+        hasQueryErrors ? 'Some metrics queries failed' : 'not enough usable CPU and memory history',
+      )
+      expect(html).not.toContain('No actionable changes')
+    },
+  )
+
+  it('qualifies a mixture of in-range and unknown containers', () => {
+    const html = renderToStaticMarkup(
+      <ScanEmptyState {...props} counts={{ ...props.counts, need_data: 1 }} />,
+    )
+    expect(html).toContain('No actionable changes in available evidence')
+    expect(html).toContain('not a complete assessment')
+    expect(html).toContain('View containers needing evidence')
+  })
+
+  it('does not blame missing history when a search or category filter hides results', () => {
+    for (const override of [{ hasResultFilters: true }, { classFilter: 'increase' as const }]) {
+      const html = renderToStaticMarkup(<ScanEmptyState {...props} {...override} />)
+      expect(html).toContain('No results match the current filters')
+      expect(html).toContain('Clear filters')
+    }
+  })
+
+  it('retains the system-workload recovery action', () => {
+    const html = renderToStaticMarkup(<ScanEmptyState {...props} onlySystemRowsAreHidden />)
+    expect(html).toContain('System workloads are hidden')
+    expect(html).toContain('Include system workloads')
+  })
+})

package/src/components/rightsizing/model.test.ts

@@ -1,6 +1,12 @@
 import { describe, expect, it } from 'vitest'
 import type { RightsizingScanResponse, RightsizingRow } from '../../api/client'
-import { calculateImpact, classifyRows, flattenScanResults, scanClassCounts } from './model'
+import {
+  calculateImpact,
+  classifyRows,
+  flattenScanResults,
+  isActionableClass,
+  scanClassCounts,
+} from './model'
 
 function metric(overrides: Partial<RightsizingRow> = {}): RightsizingRow {
   return {
@@ -152,6 +158,77 @@ describe('rightsizing scan model', () => {
     expect(classifyRows([metric({ queryError: 'query failed' })])).toBe('need_data')
   })
 
+  describe.each([
+    ['failed query', { queryError: 'usage query failed' }],
+    ['short history', { fit: 'insufficient_history' as const }],
+  ])('with %s on one resource', (_label, missing) => {
+    it.each([
+      [
+        'increase',
+        {
+          fit: 'under_requested' as const,
+          recommendedRequest: '1Gi',
+          recommendedRequestValue: 1024 ** 3,
+        },
+      ],
+      ['review', { currentPodOOM: true }],
+      ['review', { hpaManaged: true, recommendationReason: 'hpa_managed' }],
+      [
+        'reduction',
+        {
+          fit: 'oversized' as const,
+          currentRequestValue: 1024 ** 3,
+          recommendedRequest: '512Mi',
+          recommendedRequestValue: 512 * 1024 ** 2,
+        },
+      ],
+      ['need_data', {}],
+    ])('retains %s from the other resource', (classification, known) => {
+      const cpu = metric(missing)
+      const memory = metric({ resource: 'memory', ...known })
+      const rows = flattenScanResults(response([cpu, memory]))
+      expect(rows).toHaveLength(1)
+      expect(rows[0].classification).toBe(classification)
+      expect(rows[0].cpu).toBe(cpu)
+      expect(rows[0].memory).toBe(memory)
+      expect(scanClassCounts(rows)[rows[0].classification]).toBe(1)
+      const actions = rows.filter((row) => isActionableClass(row.classification))
+      expect(actions).toHaveLength(classification === 'need_data' ? 0 : 1)
+    })
+  })
+
+  it('retains a known CPU increase when memory has no evidence', () => {
+    const cpu = metric({
+      fit: 'under_requested',
+      recommendedRequest: '200m',
+      recommendedRequestValue: 0.2,
+      currentRequestValue: 0.1,
+    })
+    const memory = metric({ resource: 'memory', fit: 'insufficient_history' })
+    const [row] = flattenScanResults(response([cpu, memory], 3))
+    expect(row.classification).toBe('increase')
+    expect(row.impact.cpuChange).toBeCloseTo(0.3)
+    expect(row.impact.memoryChange).toBe(0)
+    expect(row.memory).toBe(memory)
+  })
+
+  it('keeps empty and entirely unevidenced containers in need_data', () => {
+    expect(classifyRows([])).toBe('need_data')
+    expect(
+      classifyRows([
+        metric({ queryError: 'usage query failed' }),
+        metric({ resource: 'memory', fit: 'insufficient_history' }),
+      ]),
+    ).toBe('need_data')
+    expect(
+      classifyRows(
+        [metric({ fit: 'insufficient_history' }), metric({ resource: 'memory' })],
+        0,
+        true,
+      ),
+    ).toBe('review')
+  })
+
   it('keeps workloads with no current replicas in review', () => {
     const oversized = flattenScanResults(
       response(
@@ -225,3 +302,43 @@ describe('rightsizing scan model', () => {
     expect(scanClassCounts(rows).increase).toBe(1)
   })
 })
+
+it('ranks known safety risks and increases above savings, while routine reviews stay lower', () => {
+  const make = (name: string, rows: RightsizingRow[], scaledToZero = false) => ({
+    ...response(rows, scaledToZero ? 0 : 1, 'shop', scaledToZero).workloads[0],
+    name,
+  })
+  const cut = metric({
+    fit: 'oversized',
+    currentRequestValue: 10,
+    recommendedRequestValue: 1,
+    recommendedRequest: '1',
+  })
+  const grow = metric({
+    fit: 'under_requested',
+    currentRequestValue: 0.1,
+    recommendedRequestValue: 0.2,
+    recommendedRequest: '200m',
+  })
+  const risk = metric({ resource: 'memory', currentPodOOM: true })
+  const workloads = [
+    make('cut', [cut]),
+    make('grow', [grow]),
+    make('hpa', [metric({ hpaManaged: true })]),
+    make('oom', [risk]),
+    make('limit', [metric({ limitConflict: true })]),
+    make('bursty', [{ ...cut, bursty: true }]),
+    make('throttled', [{ ...cut, throttleRatio: 0.2 }]),
+    make('idle', [risk], true),
+    make('failed-risk', [metric({ queryError: 'failed', currentPodOOM: true })]),
+    make('partial-grow', [grow, metric({ resource: 'memory', queryError: 'failed' })]),
+    make('steady', [metric()]),
+  ]
+  const rows = flattenScanResults({ ...response([]), workloads })
+  const names = rows.map((row) => row.name)
+  expect(new Set(names.slice(0, 3))).toEqual(new Set(['oom', 'limit', 'throttled']))
+  expect(names.slice(3, 5)).toEqual(['grow', 'partial-grow'])
+  expect(names[5]).toBe('cut')
+  expect(names.slice(6, 9)).toEqual(['bursty', 'hpa', 'idle'])
+  expect(names.slice(9)).toEqual(['failed-risk', 'steady'])
+})

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}