@skyhook-io/k8s-ui 1.5.13 → 1.6.0

package/src/components/gitops/insights/index.ts

@@ -0,0 +1,6 @@
+export {
+  GitOpsActivityInsightView,
+  GitOpsChangesView,
+  GitOpsIssuesBand,
+  GitOpsStatusStrip,
+} from './GitOpsInsightViews'

package/src/components/gitops/insights/insights-helpers.test.ts

@@ -0,0 +1,98 @@
+import { describe, it, expect } from 'vitest'
+import { SEVERITY_DOT } from '../../../utils/badge-colors'
+import { compactSource, entryTone, gitopsToSeverity, messageToPhase, phaseToTone } from './insights-helpers'
+
+describe('gitopsToSeverity', () => {
+  it.each([
+    ['critical', 'error'],
+    ['Failed', 'error'],
+    ['UpgradeFailed', 'error'],
+    ['alert', 'alert'],
+    ['warning', 'warning'],
+    ['Terminating', 'warning'],
+    ['Pending', 'warning'],
+    ['info', 'info'],
+    ['Progressing', 'info'],
+    ['Reconciling', 'info'],
+    ['Succeeded', 'success'],
+    ['Healthy', 'success'],
+    ['', 'neutral'],
+    [undefined, 'neutral'],
+    ['mystery-phase', 'neutral'],
+  ] as const)('%s → %s', (input, expected) => {
+    expect(gitopsToSeverity(input)).toBe(expected)
+  })
+})
+
+describe('phaseToTone', () => {
+  it('returns SEVERITY_DOT class for known phases', () => {
+    expect(phaseToTone('Succeeded')).toBe(SEVERITY_DOT.success)
+    expect(phaseToTone('Failed')).toBe(SEVERITY_DOT.error)
+    expect(phaseToTone('Progressing')).toBe(SEVERITY_DOT.info)
+    expect(phaseToTone('Pending')).toBe(SEVERITY_DOT.warning)
+  })
+  it('returns null when phase has no meaningful signal', () => {
+    expect(phaseToTone(undefined)).toBeNull()
+    expect(phaseToTone('')).toBeNull()
+    expect(phaseToTone('mystery')).toBeNull()
+  })
+})
+
+describe('messageToPhase', () => {
+  it('detects success language', () => {
+    expect(messageToPhase('Application was synced successfully')).toBe('succeeded')
+    expect(messageToPhase('reconcile succeeded')).toBe('succeeded')
+  })
+  it('detects failure language', () => {
+    expect(messageToPhase('reconciliation failed: context deadline')).toBe('failed')
+    expect(messageToPhase('Helm upgrade error')).toBe('failed')
+  })
+  it('detects in-flight language', () => {
+    expect(messageToPhase('progressing toward target state')).toBe('progressing')
+    expect(messageToPhase('still reconciling')).toBe('progressing')
+  })
+  it('returns undefined when nothing matches', () => {
+    expect(messageToPhase(undefined)).toBeUndefined()
+    expect(messageToPhase('')).toBeUndefined()
+    expect(messageToPhase('plain note')).toBeUndefined()
+  })
+})
+
+describe('entryTone', () => {
+  it('uses explicit phase when present', () => {
+    const tone = entryTone({ phase: 'Succeeded' })
+    expect(tone.dot).toBe(SEVERITY_DOT.success)
+    expect(tone.inferredFrom).toBeUndefined()
+  })
+  it('falls back to message inference when phase is missing', () => {
+    const tone = entryTone({ message: 'reconciliation failed' })
+    expect(tone.dot).toBe(SEVERITY_DOT.error)
+    expect(tone.inferredFrom).toBe('inferred from message')
+  })
+  it('returns neutral when neither phase nor message carries signal', () => {
+    const tone = entryTone({})
+    expect(tone.dot).toBe(SEVERITY_DOT.neutral)
+    expect(tone.inferredFrom).toBe('no phase information')
+  })
+})
+
+describe('compactSource', () => {
+  it('strips https://github.com/ prefix and collapses deep paths', () => {
+    const got = compactSource('https://github.com/KoalaOps/deployment · argocd/addons/karpenter/default-nodepool/overlays/nonprod-cluster-us-east1')
+    expect(got).toBe('KoalaOps/deployment · argocd/…/nonprod-cluster-us-east1')
+  })
+  it('keeps short paths intact', () => {
+    expect(compactSource('https://github.com/org/repo · charts/foo')).toBe('org/repo · charts/foo')
+  })
+  it('handles trailing slash and no path', () => {
+    expect(compactSource('https://github.com/org/repo/')).toBe('org/repo')
+    expect(compactSource('https://github.com/org/repo')).toBe('org/repo')
+  })
+  it('strips http and www prefixes', () => {
+    expect(compactSource('http://www.github.com/org/repo')).toBe('org/repo')
+  })
+  it('returns empty string for missing input', () => {
+    expect(compactSource(undefined)).toBe('')
+    expect(compactSource('')).toBe('')
+  })
+})

package/src/components/gitops/insights/insights-helpers.ts

@@ -0,0 +1,99 @@
+// Pure helpers for GitOps insight rendering. Extracted from
+// GitOpsInsightViews.tsx so they can be unit-tested without importing JSX.
+
+import { SEVERITY_DOT, type Severity } from '../../../utils/badge-colors'
+import type { GitOpsHistoryItem } from '../../../types'
+import type { SyncStatus, GitOpsHealthStatus } from '../../../types/gitops'
+
+const SYNC_STATUS_SET = new Set<SyncStatus>(['Synced', 'OutOfSync', 'Reconciling', 'Unknown'])
+const HEALTH_STATUS_SET = new Set<GitOpsHealthStatus>(['Healthy', 'Progressing', 'Degraded', 'Suspended', 'Missing', 'Unknown'])
+
+// normalizeSyncStatus narrows an arbitrary string (e.g. a GitOpsChange.category
+// or .sync from the backend) onto the SyncStatusBadge's expected union. Unknown
+// values fall back to "Unknown" rather than rendering whatever the badge's
+// default-case branch happens to do — silently rendering wrong was the failure
+// mode of the `as any` casts this replaces.
+export function normalizeSyncStatus(value: string | undefined | null): SyncStatus {
+  if (value && (SYNC_STATUS_SET as Set<string>).has(value)) return value as SyncStatus
+  return 'Unknown'
+}
+
+export function normalizeHealthStatus(value: string | undefined | null): GitOpsHealthStatus {
+  if (value && (HEALTH_STATUS_SET as Set<string>).has(value)) return value as GitOpsHealthStatus
+  return 'Unknown'
+}
+
+// Map GitOps-flavored vocabulary (Argo/Flux phase strings, insight Issue
+// severities) onto the canonical Severity tokens used by SEVERITY_BADGE /
+// SEVERITY_TEXT / SEVERITY_DOT. Centralizing this keeps call sites from
+// hand-rolling Tailwind color literals (which bypass theme overrides and
+// drift from the rest of the OSS surface).
+export function gitopsToSeverity(value: string | undefined): Severity {
+  const v = (value || '').toLowerCase()
+  if (!v) return 'neutral'
+  if (v === 'critical' || v.includes('fail') || v.includes('error')) return 'error'
+  if (v === 'alert') return 'alert'
+  if (v === 'warning' || v.includes('terminat') || v.includes('pending') || v.includes('wait')) return 'warning'
+  if (v === 'info' || v.includes('progress') || v.includes('running') || v.includes('reconcil')) return 'info'
+  if (v.includes('succeed') || v === 'healthy' || v === 'ok') return 'success'
+  return 'neutral'
+}
+
+// Map a phase string to its dot color, or null if the phase carries no
+// meaningful signal (caller decides whether to fall back to inference).
+export function phaseToTone(phase?: string): string | null {
+  const sev = gitopsToSeverity(phase)
+  return sev === 'neutral' ? null : SEVERITY_DOT[sev]
+}
+
+// Best-effort phase recovery from message text. Argo only populates the
+// phase field on the most recent revision; older entries lose their
+// outcome signal unless we read it from the human-readable message.
+export function messageToPhase(message?: string): string | undefined {
+  if (!message) return undefined
+  const m = message.toLowerCase()
+  if (m.includes('successfully') || m.includes('succeeded')) return 'succeeded'
+  if (m.includes('failed') || m.includes('error')) return 'failed'
+  if (m.includes('progressing') || m.includes('reconciling')) return 'progressing'
+  return undefined
+}
+
+export interface EntryTone {
+  dot: string
+  inferredFrom?: string
+}
+
+// Pick a dot color via the canonical SEVERITY_DOT palette. Argo only
+// populates phase on the most recent revision; older entries fall back to
+// inference from the message string so the timeline still encodes outcome
+// at a glance instead of degenerating into a column of neutral dots.
+export function entryTone(item: GitOpsHistoryItem): EntryTone {
+  const explicit = phaseToTone(item.phase)
+  if (explicit) return { dot: explicit }
+  const inferred = phaseToTone(messageToPhase(item.message))
+  if (inferred) return { dot: inferred, inferredFrom: 'inferred from message' }
+  // No signal at all — keep the dot visible but neutral. Coloring it green
+  // would be a guess (a failed revision can sit at history's head with no
+  // successor), and a wrong-color dot is worse than no information.
+  return { dot: SEVERITY_DOT.neutral, inferredFrom: 'no phase information' }
+}
+
+// Compact a source string for inline display. Argo emits the full GitHub URL
+// followed by " · path/within/repo", which dominates the timeline row when
+// rendered raw. Strip the protocol+host (full string still shown on hover via
+// title), and shorten deep paths to "head/…/leaf" form.
+export function compactSource(source?: string): string {
+  if (!source) return ''
+  const [repoPart, ...pathParts] = source.split(' · ')
+  const repo = repoPart
+    .replace(/^https?:\/\/(www\.)?github\.com\//, '')
+    .replace(/^https?:\/\//, '')
+    .replace(/\/$/, '')
+  const path = pathParts.join(' · ').trim()
+  if (!path) return repo
+  const segments = path.split('/').filter(Boolean)
+  const shortPath = segments.length > 3
+    ? `${segments[0]}/…/${segments[segments.length - 1]}`
+    : path
+  return `${repo} · ${shortPath}`
+}