@skyhook-io/radar-app 0.2.2 → 0.3.1

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

@@ -0,0 +1,56 @@
+import { describe, expect, it } from 'vitest'
+import {
+  getRightsizingScanSurfaceState,
+  RIGHTSIZING_SCAN_DESCRIPTION,
+  RIGHTSIZING_SCAN_METHODOLOGY,
+} from './RightsizingScanView'
+
+describe('rightsizing scan copy', () => {
+  it('sets expectations without claiming efficiency or savings', () => {
+    const copy = `${RIGHTSIZING_SCAN_DESCRIPTION} ${RIGHTSIZING_SCAN_METHODOLOGY}`
+    expect(copy).toContain('CPU and memory requests')
+    expect(copy).toContain('increase, reduce, or review')
+    expect(copy).toContain('Radar never changes them')
+    expect(copy).toContain('CPU P95 and memory maximum')
+    expect(copy).toContain('Memory reductions require verifiable restart history')
+    expect(copy.toLowerCase()).not.toContain('efficiency')
+    expect(copy.toLowerCase()).not.toContain('savings')
+  })
+
+  it('retains a prior snapshot after a failed rerun but treats a first-run failure as fatal', () => {
+    expect(
+      getRightsizingScanSurfaceState({
+        statusLoading: false,
+        hasStatus: true,
+        connected: true,
+        pending: false,
+        hasResult: true,
+        hasError: true,
+        resultState: 'complete',
+      }),
+    ).toBe('results')
+    expect(
+      getRightsizingScanSurfaceState({
+        statusLoading: false,
+        hasStatus: true,
+        connected: true,
+        pending: false,
+        hasResult: false,
+        hasError: true,
+      }),
+    ).toBe('fatal_error')
+  })
+
+  it('does not auto-scan a connected first visit', () => {
+    expect(
+      getRightsizingScanSurfaceState({
+        statusLoading: false,
+        hasStatus: true,
+        connected: true,
+        pending: false,
+        hasResult: false,
+        hasError: false,
+      }),
+    ).toBe('first_run')
+  })
+})

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

@@ -0,0 +1,227 @@
+import { describe, expect, it } from 'vitest'
+import type { RightsizingScanResponse, RightsizingRow } from '../../api/client'
+import { calculateImpact, classifyRows, flattenScanResults, scanClassCounts } from './model'
+
+function metric(overrides: Partial<RightsizingRow> = {}): RightsizingRow {
+  return {
+    container: 'app',
+    resource: 'cpu',
+    fit: 'balanced',
+    confidence: 'high',
+    sampleCount: 2017,
+    expectedSamples: 2017,
+    coverage: 1,
+    hpaManaged: false,
+    hpaEvidenceAvailable: true,
+    oomEvidenceAvailable: true,
+    ...overrides,
+  }
+}
+
+function response(
+  rows: RightsizingRow[],
+  replicas = 1,
+  namespace = 'shop',
+  scaledToZero = false,
+): RightsizingScanResponse {
+  return {
+    state: 'complete',
+    scannedAt: '2026-07-12T10:00:00Z',
+    window: '7d',
+    source: 'radar',
+    coverage: {
+      workloadsDiscovered: 1,
+      workloadsEvaluated: 1,
+      workloadsWithData: 1,
+      batches: 1,
+      completedBatches: 1,
+    },
+    workloads: [
+      {
+        kind: 'Deployment',
+        namespace,
+        name: 'api',
+        replicas,
+        scaledToZero,
+        rows,
+      },
+    ],
+  }
+}
+
+describe('rightsizing scan model', () => {
+  it('prioritizes reliability guidance and explicit safety review', () => {
+    expect(
+      classifyRows([
+        metric({
+          fit: 'oversized',
+          currentRequestValue: 0.1,
+          recommendedRequestValue: 0.02,
+          recommendedRequest: '20m',
+        }),
+        metric({
+          resource: 'memory',
+          fit: 'missing_request',
+          recommendedRequestValue: 64 * 1024 * 1024,
+          recommendedRequest: '64Mi',
+        }),
+      ]),
+    ).toBe('increase')
+    expect(
+      classifyRows([
+        metric({
+          fit: 'oversized',
+          hpaManaged: true,
+          recommendationReason: 'hpa_managed',
+        }),
+      ]),
+    ).toBe('review')
+    expect(
+      classifyRows([
+        metric({
+          fit: 'oversized',
+          recommendationReason: 'hpa_evidence_unavailable',
+        }),
+      ]),
+    ).toBe('review')
+    expect(
+      classifyRows([
+        metric({
+          fit: 'oversized',
+          currentRequestValue: 0.2,
+          recommendedRequestValue: 0.1,
+          recommendedRequest: '100m',
+          throttleRatio: 0.1,
+        }),
+      ]),
+    ).toBe('review')
+    expect(
+      classifyRows([
+        metric({
+          fit: 'oversized',
+          currentRequestValue: 0.2,
+          recommendedRequestValue: 0.1,
+          recommendedRequest: '100m',
+          bursty: true,
+        }),
+      ]),
+    ).toBe('review')
+  })
+
+  it('suppresses reductions that are not meaningful across replicas', () => {
+    const tiny = metric({
+      fit: 'oversized',
+      currentRequestValue: 0.005,
+      recommendedRequestValue: 0.001,
+      recommendedRequest: '1m',
+    })
+    const meaningful = metric({
+      fit: 'oversized',
+      currentRequestValue: 0.1,
+      recommendedRequestValue: 0.02,
+      recommendedRequest: '20m',
+    })
+    expect(classifyRows([tiny], 9)).toBe('in_range')
+    expect(classifyRows([meaningful], 1)).toBe('reduction')
+  })
+
+  it('excludes recommendations that require manual review from aggregate impact', () => {
+    const cpu = metric({
+      fit: 'oversized',
+      currentRequestValue: 0.1,
+      recommendedRequestValue: 0.05,
+      recommendedRequest: '50m',
+      throttleRatio: 0.2,
+    })
+    const memory = metric({
+      resource: 'memory',
+      fit: 'oversized',
+      currentRequestValue: 128 * 1024 * 1024,
+      recommendedRequestValue: 64 * 1024 * 1024,
+      recommendedRequest: '64Mi',
+    })
+    expect(calculateImpact([cpu, memory], 3)).toEqual({
+      replicas: 3,
+      cpuChange: 0,
+      memoryChange: -192 * 1024 * 1024,
+    })
+  })
+
+  it('keeps incomplete history out of no-change results', () => {
+    expect(classifyRows([metric({ fit: 'insufficient_history' })])).toBe('need_data')
+    expect(classifyRows([metric({ queryError: 'query failed' })])).toBe('need_data')
+  })
+
+  it('keeps workloads with no current replicas in review', () => {
+    const oversized = flattenScanResults(
+      response(
+        [
+          metric({
+            fit: 'oversized',
+            currentRequestValue: 0.2,
+            recommendedRequestValue: 0.05,
+            recommendedRequest: '50m',
+          }),
+        ],
+        0,
+        'shop',
+        true,
+      ),
+    )[0]
+    expect(oversized.classification).toBe('review')
+    expect(oversized.impact.cpuChange).toBe(0)
+
+    expect(classifyRows([metric()], 0, true)).toBe('review')
+    expect(classifyRows([metric({ fit: 'insufficient_history' })], 0, true)).toBe('need_data')
+    expect(
+      classifyRows(
+        [
+          metric({
+            fit: 'missing_request',
+            recommendedRequestValue: 0.1,
+            recommendedRequest: '100m',
+          }),
+        ],
+        0,
+        true,
+      ),
+    ).toBe('review')
+    expect(
+      classifyRows(
+        [
+          metric({
+            fit: 'under_requested',
+            currentRequestValue: 0.1,
+            recommendedRequestValue: 0.2,
+            recommendedRequest: '200m',
+          }),
+        ],
+        0,
+        true,
+      ),
+    ).toBe('review')
+  })
+
+  it('groups resources, calculates replica impact, and tags system workloads', () => {
+    const rows = flattenScanResults(
+      response(
+        [
+          metric({
+            fit: 'under_requested',
+            currentRequestValue: 0.1,
+            recommendedRequestValue: 0.2,
+            recommendedRequest: '200m',
+            throttleRatio: 0.2,
+          }),
+          metric({ resource: 'memory', currentPodOOM: true }),
+        ],
+        3,
+        'kube-system',
+      ),
+    )
+    expect(rows).toHaveLength(1)
+    expect(rows[0].impact.cpuChange).toBeCloseTo(0.3)
+    expect(rows[0].system).toBe(true)
+    expect(scanClassCounts(rows).increase).toBe(1)
+  })
+})

package/src/components/rightsizing/model.ts

@@ -0,0 +1,158 @@
+import type { RightsizingScanResponse, RightsizingRow } from '../../api/client'
+
+export type ScanClass = 'increase' | 'reduction' | 'review' | 'in_range' | 'need_data'
+
+export interface RightsizingImpact {
+  replicas: number
+  cpuChange: number
+  memoryChange: number
+}
+
+export interface RightsizingScanRow {
+  id: string
+  kind: string
+  namespace: string
+  name: string
+  container: string
+  replicas: number
+  cpu?: RightsizingRow
+  memory?: RightsizingRow
+  classification: ScanClass
+  impact: RightsizingImpact
+  system: boolean
+  scaledToZero: boolean
+}
+
+const CLASS_RANK: Record<ScanClass, number> = {
+  reduction: 0,
+  increase: 1,
+  review: 2,
+  need_data: 3,
+  in_range: 4,
+}
+
+const MIN_CPU_REDUCTION = 0.05
+const MIN_MEMORY_REDUCTION = 64 * 1024 * 1024
+
+export function classifyRows(
+  rows: RightsizingRow[],
+  replicas = 1,
+  scaledToZero = false,
+): ScanClass {
+  if (rows.some((row) => row.queryError || row.fit === 'insufficient_history')) return 'need_data'
+  if (scaledToZero) return 'review'
+  if (
+    rows.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 (-impact.cpuChange >= MIN_CPU_REDUCTION || -impact.memoryChange >= MIN_MEMORY_REDUCTION)
+    return 'reduction'
+  return 'in_range'
+}
+
+function needsManualReview(row: RightsizingRow): boolean {
+  return (
+    row.hpaManaged ||
+    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))
+  )
+}
+
+function isReduction(row: RightsizingRow): boolean {
+  return (
+    row.recommendedRequestValue != null &&
+    row.currentRequestValue != null &&
+    row.recommendedRequestValue < row.currentRequestValue
+  )
+}
+
+export function calculateImpact(rows: RightsizingRow[], replicas: number): RightsizingImpact {
+  const count = Math.max(replicas, 0)
+  let cpuChange = 0
+  let memoryChange = 0
+  for (const row of rows) {
+    if (row.recommendedRequestValue == null || needsManualReview(row)) continue
+    const change = (row.recommendedRequestValue - (row.currentRequestValue ?? 0)) * count
+    if (row.resource === 'cpu') cpuChange += change
+    else memoryChange += change
+  }
+  return { replicas: count, cpuChange, memoryChange }
+}
+
+export function flattenScanResults(scan: RightsizingScanResponse): RightsizingScanRow[] {
+  const result: RightsizingScanRow[] = []
+  for (const workload of scan.workloads ?? []) {
+    const byContainer = new Map<string, RightsizingRow[]>()
+    for (const row of workload.rows ?? []) {
+      const rows = byContainer.get(row.container) ?? []
+      rows.push(row)
+      byContainer.set(row.container, rows)
+    }
+    for (const [container, rows] of byContainer) {
+      const replicas = workload.replicas ?? 1
+      result.push({
+        id: `${workload.kind}/${workload.namespace}/${workload.name}/${container}`,
+        kind: workload.kind,
+        namespace: workload.namespace,
+        name: workload.name,
+        container,
+        replicas,
+        cpu: rows.find((row) => row.resource === 'cpu'),
+        memory: rows.find((row) => row.resource === 'memory'),
+        classification: classifyRows(rows, replicas, workload.scaledToZero),
+        impact: calculateImpact(rows, replicas),
+        system: isSystemNamespace(workload.namespace),
+        scaledToZero: workload.scaledToZero,
+      })
+    }
+  }
+  return result.sort(
+    (a, b) =>
+      CLASS_RANK[a.classification] - CLASS_RANK[b.classification] ||
+      impactScore(b) - impactScore(a) ||
+      a.namespace.localeCompare(b.namespace) ||
+      a.name.localeCompare(b.name) ||
+      a.container.localeCompare(b.container),
+  )
+}
+
+function impactScore(row: RightsizingScanRow): number {
+  return Math.max(
+    Math.abs(row.impact.cpuChange) / MIN_CPU_REDUCTION,
+    Math.abs(row.impact.memoryChange) / MIN_MEMORY_REDUCTION,
+  )
+}
+
+export function scanClassCounts(rows: RightsizingScanRow[]): Record<ScanClass, number> {
+  const counts: Record<ScanClass, number> = {
+    increase: 0,
+    reduction: 0,
+    review: 0,
+    in_range: 0,
+    need_data: 0,
+  }
+  for (const row of rows) counts[row.classification]++
+  return counts
+}
+
+export function isActionableClass(value: ScanClass): boolean {
+  return value === 'increase' || value === 'reduction' || value === 'review'
+}
+
+function isSystemNamespace(namespace: string): boolean {
+  return (
+    namespace === 'kube-system' ||
+    namespace === 'kube-public' ||
+    namespace === 'kube-node-lease' ||
+    namespace.startsWith('gke-managed-')
+  )
+}

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

@@ -0,0 +1,104 @@
+import { describe, expect, it } from 'vitest'
+import type { RightsizingRow } from '../../api/client'
+import { getResourceRequestPresentation } from './presentation'
+
+function metric(overrides: Partial<RightsizingRow> = {}): RightsizingRow {
+  return {
+    container: 'app',
+    resource: 'cpu',
+    fit: 'balanced',
+    confidence: 'high',
+    sampleCount: 2017,
+    expectedSamples: 2017,
+    coverage: 1,
+    hpaManaged: false,
+    hpaEvidenceAvailable: true,
+    oomEvidenceAvailable: true,
+    ...overrides,
+  }
+}
+
+describe('rightsizing request presentation', () => {
+  it('shows configured and suggested values in a consistent comparison', () => {
+    expect(
+      getResourceRequestPresentation(
+        metric({
+          fit: 'oversized',
+          currentRequest: '1500m',
+          currentRequestValue: 1.5,
+          recommendedRequest: '750m',
+          recommendedRequestValue: 0.75,
+        }),
+      ),
+    ).toEqual({
+      primary: '1500m → 750m',
+      secondary: 'Reduce request',
+      signals: [],
+      tone: 'reduction',
+    })
+  })
+
+  it('makes missing requests explicit', () => {
+    expect(
+      getResourceRequestPresentation(
+        metric({
+          fit: 'missing_request',
+          recommendedRequest: '100m',
+          recommendedRequestValue: 0.1,
+        }),
+      ),
+    ).toEqual({
+      primary: 'Unset → 100m',
+      secondary: 'Add request',
+      signals: [],
+      tone: 'increase',
+    })
+  })
+
+  it('keeps the configured value visible when safety signals require review', () => {
+    expect(
+      getResourceRequestPresentation(
+        metric({
+          fit: 'oversized',
+          currentRequest: '200m',
+          currentRequestValue: 0.2,
+          recommendedRequest: '100m',
+          recommendedRequestValue: 0.1,
+          bursty: true,
+          throttleRatio: 0.2,
+        }),
+      ),
+    ).toEqual({
+      primary: '200m current',
+      secondary: 'Review before reducing',
+      signals: ['bursty', 'throttling'],
+      tone: 'review',
+    })
+  })
+
+  it('places resource-specific safety evidence with the request it qualifies', () => {
+    expect(
+      getResourceRequestPresentation(
+        metric({
+          resource: 'memory',
+          currentRequest: '128Mi',
+          currentRequestValue: 128 * 1024 * 1024,
+          recommendationReason: 'oom_evidence',
+          windowOomEvidence: true,
+        }),
+      ),
+    ).toEqual({
+      primary: '128Mi current',
+      secondary: 'Keep current request',
+      signals: ['oom'],
+      tone: 'review',
+    })
+  })
+
+  it('keeps no-change and unavailable data neutral', () => {
+    expect(getResourceRequestPresentation(metric()).tone).toBe('neutral')
+    expect(getResourceRequestPresentation(metric({ queryError: 'query failed' })).tone).toBe(
+      'neutral',
+    )
+  })
+})

package/src/components/rightsizing/presentation.ts

@@ -0,0 +1,94 @@
+import type { RightsizingRow } from '../../api/client'
+
+export type ResourceSignal = 'hpa' | 'oom' | 'bursty' | 'throttling' | 'query_error'
+export type RightsizingActionTone = 'reduction' | 'increase' | 'review' | 'neutral'
+
+export const RIGHTSIZING_ACTION_SEVERITY = {
+  reduction: 'info',
+  increase: 'warning',
+  review: 'neutral',
+} as const
+
+export interface ResourceRequestPresentation {
+  primary: string
+  secondary: string
+  signals: ResourceSignal[]
+  tone: RightsizingActionTone
+}
+
+export function getResourceRequestPresentation(
+  row?: RightsizingRow,
+  scaledToZero = false,
+): ResourceRequestPresentation {
+  if (!row) return { primary: '—', secondary: 'No result returned', signals: [], tone: 'neutral' }
+
+  const current = row.currentRequest && row.currentRequestValue !== 0 ? row.currentRequest : 'Unset'
+  const currentOnly = current === 'Unset' ? current : `${current} current`
+  const signals = resourceSignals(row)
+  const reason = row.recommendationReason
+
+  if (row.queryError)
+    return { primary: currentOnly, secondary: 'Metrics query failed', signals, tone: 'neutral' }
+  if (row.fit === 'insufficient_history')
+    return { primary: currentOnly, secondary: 'Not enough history', signals, tone: 'neutral' }
+  if (scaledToZero)
+    return { primary: currentOnly, secondary: 'Review before workload runs again', signals, tone: 'review' }
+  if (row.hpaManaged)
+    return { primary: currentOnly, secondary: 'Review with autoscaling', signals, tone: 'review' }
+  if (reason === 'hpa_evidence_unavailable')
+    return {
+      primary: currentOnly,
+      secondary: 'Review — autoscaling status unavailable',
+      signals,
+      tone: 'review',
+    }
+  if (reason === 'oom_evidence')
+    return { primary: currentOnly, secondary: 'Keep current request', signals, tone: 'review' }
+  if (reason === 'oom_evidence_unavailable')
+    return {
+      primary: currentOnly,
+      secondary: 'Review — restart history incomplete',
+      signals,
+      tone: 'review',
+    }
+
+  const isReduction =
+    row.recommendedRequestValue != null &&
+    row.currentRequestValue != null &&
+    row.recommendedRequestValue < row.currentRequestValue
+  const comparison = row.recommendedRequest
+    ? `${current} → ${row.recommendedRequest}`
+    : currentOnly
+
+  if (row.limitConflict)
+    return {
+      primary: comparison,
+      secondary: 'Raise the limit before changing',
+      signals,
+      tone: 'review',
+    }
+  if (row.resource === 'cpu' && isReduction && (row.bursty || (row.throttleRatio ?? 0) >= 0.1))
+    return { primary: currentOnly, secondary: 'Review before reducing', signals, tone: 'review' }
+  if (row.recommendedRequest) {
+    if (current === 'Unset')
+      return { primary: comparison, secondary: 'Add request', signals, tone: 'increase' }
+    const increase = (row.recommendedRequestValue ?? 0) > (row.currentRequestValue ?? 0)
+    return {
+      primary: comparison,
+      secondary: increase ? 'Increase request' : 'Reduce request',
+      signals,
+      tone: increase ? 'increase' : 'reduction',
+    }
+  }
+  return { primary: currentOnly, secondary: 'No meaningful change', signals, tone: 'neutral' }
+}
+
+function resourceSignals(row: RightsizingRow): ResourceSignal[] {
+  const signals: ResourceSignal[] = []
+  if (row.hpaManaged) signals.push('hpa')
+  if (row.resource === 'memory' && (row.currentPodOOM || row.windowOomEvidence)) signals.push('oom')
+  if (row.resource === 'cpu' && row.bursty) signals.push('bursty')
+  if (row.resource === 'cpu' && (row.throttleRatio ?? 0) >= 0.1) signals.push('throttling')
+  if (row.queryError) signals.push('query_error')
+  return signals
+}