agentwaste-core 0.1.0

package/src/report.js

@@ -0,0 +1,544 @@
+export function buildReport(stats, options) {
+  const color = colorizer(options.color);
+  const json = toReportJson(stats, options);
+  return {
+    json,
+    text: renderText(json, color),
+  };
+}
+
+export function toReportJson(stats, options) {
+  return {
+    version: options.version,
+    elapsed_ms: options.elapsedMs,
+    scanned: {
+      days: stats.days,
+      files: stats.files,
+      sessions: stats.sessions,
+      subagent_sessions: stats.subagentSessions,
+      sources: Object.fromEntries(Object.entries(stats.sources).map(([key, source]) => [key, sourceJson(source)])),
+    },
+    metrics: {
+      context_efficiency: {
+        level: stats.derived.contextOverheadLevel,
+        confidence: stats.derived.sampleConfidence,
+        active_tokens: stats.tokens.active,
+        fresh_input_tokens: stats.tokens.freshInput,
+        output_tokens: stats.tokens.output,
+        cached_input_tokens: stats.tokens.cached,
+        fresh_input_drag_percent: stats.derived.contextDragPercent,
+        cache_hit_percent: stats.derived.cacheHitPercent,
+        excess_fresh_input_percent: stats.derived.excessFreshInputPercent,
+        excess_fresh_input_tokens: stats.derived.excessFreshInputTokens,
+        active_tokens_per_tool_call: stats.derived.avgTokensPerToolCall,
+        fresh_input_tokens_per_tool_call: stats.derived.avgFreshInputPerToolCall,
+        review_threshold_fresh_input_tokens_per_tool_call: stats.derived.contextReviewFreshInputPerToolCall,
+        observed_model_calls: stats.tokens.observedModelCalls,
+        observed_tokens: stats.tokens.total,
+      },
+      credential_exposure: {
+        level: stats.derived.credentialRiskLevel,
+        score: stats.derived.credentialRiskScore,
+        unique_secret_fingerprints: stats.secrets.rawKeys,
+        model_facing_secret_fingerprints: stats.secrets.modelFacingKeys,
+        by_kind: stats.secrets.byKind,
+      },
+      tool_reliability: {
+        level: stats.derived.reliabilityLevel,
+        failure_rate_percent: stats.derived.retryRatePercent,
+        failed_tool_calls: stats.failedToolCalls,
+        tool_calls: stats.toolCalls,
+        avg_retries_per_failure: stats.derived.avgRetriesPerFailure,
+        retry_recovery_percent: stats.derived.retryRecoveryPercent,
+        unresolved_failures: stats.derived.unresolvedFailures,
+      },
+      state_continuity: {
+        level: stats.derived.stateContinuityLevel,
+        hard_breaks: stats.stateLoss.incidents,
+        hard_breaks_per_session: stats.derived.hardBreakRatePerSession,
+        aborted_turns: stats.stateLoss.abortedTurns,
+        compaction_signals: stats.stateLoss.compactSignals,
+        phrase_signals: stats.stateLoss.phraseSignals,
+        compactions_per_session: stats.derived.compactionsPerSession,
+      },
+      trace_coverage: {
+        level: stats.derived.traceCoverageLevel,
+        session_file_coverage_percent: stats.derived.traceCoveragePercent,
+        structured_trace_signals: stats.traces.signals,
+        session_log_files: stats.derived.sessionLogFiles,
+        traced_session_log_files: stats.derived.tracedSessionLogFiles,
+      },
+      automation_footprint: {
+        level: stats.derived.automationFootprintLevel,
+        lines: stats.glue.lines,
+        files: stats.glue.files,
+        roots: stats.glue.roots,
+        largest_files: stats.glue.scriptFiles.slice(0, 5),
+      },
+    },
+    monthly_impact_estimate: {
+      active_tokens_30d: stats.derived.monthlyTokens,
+      excess_fresh_input_tokens_30d: stats.derived.excessMonthlyFreshInputTokens,
+      excess_context_spend_low_usd: stats.derived.excessSpendLow,
+      excess_context_spend_high_usd: stats.derived.excessSpendHigh,
+      cost_assumption_usd_per_million_excess_input_tokens: stats.derived.costPerMillionTokens,
+      failure_recovery_minutes: stats.derived.failureRecoveryMinutes,
+      state_recovery_minutes: stats.derived.stateRecoveryMinutes,
+      automation_maintenance_minutes: stats.derived.automationMaintenanceMinutes,
+      debugging_hours: stats.derived.debuggingHours,
+      security_exposure: stats.derived.securityExposure,
+    },
+    recommendation: {
+      diagnosis: diagnosis(stats),
+      fixes: [
+        "move repeated execution into reviewed scripts or jobs",
+        "vault credentials instead of passing secrets through model context",
+        "add full traces, retries, artifacts, and durable state",
+      ],
+    },
+    evidence: {
+      secret_files_sample: stats.secrets.files,
+      state_continuity_files_sample: stats.stateLoss.files,
+      trace_files_sample: stats.traces.files,
+      diagnostics: stats.diagnostics.slice(0, 10),
+    },
+  };
+}
+
+function sourceJson(source) {
+  return {
+    label: source.label,
+    files: source.files,
+    sessions: source.sessions,
+    tool_calls: source.toolCalls,
+    failed_tool_calls: source.failedToolCalls,
+    tokens: source.tokens,
+    active_tokens: source.activeTokens,
+    fresh_input_tokens: source.freshInputTokens,
+    cached_input_tokens: source.cachedInputTokens,
+    secret_fingerprints: source.secrets,
+    model_facing_secret_fingerprints: source.modelFacingSecrets,
+    trace_signals: source.traces,
+    traced_session_log_files: source.tracedFiles,
+    retry_recovery_signals: source.retryAfterFailure,
+    unavailable: source.unavailable,
+  };
+}
+
+function renderText(report, color) {
+  const context = report.metrics.context_efficiency;
+  const credential = report.metrics.credential_exposure;
+  const reliability = report.metrics.tool_reliability;
+  const trace = report.metrics.trace_coverage;
+  const verdict = wasteVerdict(report);
+
+  const rows = [
+    reportText("agentmess postmortem", color.title("agentmess postmortem")),
+    reportText("──────────────────────────────", color.rule("──────────────────────────────")),
+    reportText(""),
+    reportSection("finding", color),
+    ...paragraphRows(agentFinding(report), color, { level: verdict.level }),
+    reportText(""),
+    reportSection("impact", color),
+    ...paragraphRows(agentImpact(report), color),
+    reportText(""),
+    reportSection("agent leaderboard", color),
+    ...agentLeaderboardRows(report, color),
+    reportText(""),
+    reportSection("numbers", color),
+    metricLine("sessions scanned", formatNumber(report.scanned.sessions), color),
+    metricLine("files scanned", formatNumber(report.scanned.files), color),
+    metricLine("fresh input/tool", `${formatNumber(context.fresh_input_tokens_per_tool_call)} tokens`, color, { level: context.level }),
+    metricLine("model-facing secrets", formatNumber(credential.model_facing_secret_fingerprints), color, { level: credential.model_facing_secret_fingerprints > 0 ? "CRITICAL" : "LOW" }),
+    metricLine("tool failure rate", `${reliability.failure_rate_percent}%`, color, { level: reliability.level }),
+    metricLine("trace coverage", `${trace.session_file_coverage_percent}%`, color, { level: trace.level }),
+  ];
+
+  return rows.map((row) => row.painted).join("\n");
+}
+
+function agentFinding(report) {
+  const context = report.metrics.context_efficiency;
+  const credential = report.metrics.credential_exposure;
+  const reliability = report.metrics.tool_reliability;
+  const trace = report.metrics.trace_coverage;
+  const findings = [];
+  if (credential.model_facing_secret_fingerprints > 0) findings.push("model-facing secret exposure");
+  if (context.fresh_input_tokens_per_tool_call > context.review_threshold_fresh_input_tokens_per_tool_call) findings.push("context above review threshold");
+  if (reliability.failed_tool_calls > 0) findings.push("tool-call failures");
+  if (trace.session_file_coverage_percent < 80) findings.push("low trace coverage");
+  if (findings.length === 0) return "No high-priority agent issues were detected in the scanned window.";
+  return `The scan found ${findings.join(", ")} in local agent activity.`;
+}
+
+function agentImpact(report) {
+  const credential = report.metrics.credential_exposure;
+  const reliability = report.metrics.tool_reliability;
+  const trace = report.metrics.trace_coverage;
+  const missingTraceLogs = Math.max(0, trace.session_log_files - trace.traced_session_log_files);
+  const parts = [];
+  if (credential.model_facing_secret_fingerprints > 0) parts.push(`${formatNumber(credential.model_facing_secret_fingerprints)} secret fingerprints reached model-facing records`);
+  if (reliability.unresolved_failures > 0) parts.push(`${formatNumber(reliability.unresolved_failures)} failed tool calls did not show recovery`);
+  if (missingTraceLogs > 0) parts.push(`${formatNumber(missingTraceLogs)} session logs may be hard to replay`);
+  if (parts.length === 0) return "The scanned agent activity looks operationally low-risk.";
+  return `${parts.join("; ")}.`;
+}
+
+export function calculationGuide(options = {}) {
+  const guide = {
+    version: options.version ?? "0.1.0",
+    formulas: {
+      context_efficiency: {
+        codex_fresh_input_tokens: "max(input_tokens - cached_input_tokens, 0)",
+        claude_fresh_input_tokens: "input_tokens + cache_creation_input_tokens",
+        active_tokens: "fresh_input_tokens + output_tokens",
+        fresh_input_tokens_per_tool_call: "sum(fresh_input_tokens) / tool_calls",
+        fresh_input_drag_percent: "fresh_input_tokens / active_tokens * 100",
+        cache_hit_percent: "cached_input_tokens / (fresh_input_tokens + cached_input_tokens) * 100",
+        excess_fresh_input_tokens: "max(0, fresh_input_tokens - tool_calls * 4000)",
+        note: "This is context overhead, not a universal waste benchmark. Cached reads are separated because prompt caching docs treat them as reusable prompt work.",
+      },
+      credential_exposure: {
+        raw_keys_found: "unique redacted fingerprints matched by known API-key patterns in scanned logs/configs",
+        keys_passed_to_model: "unique key fingerprints found in user/assistant/tool-call records that are model-facing",
+        level: "CRITICAL if any key is model-facing; HIGH if any raw key appears in logs/config; LOW otherwise",
+      },
+      tool_reliability: {
+        failure_rate_percent: "failed_tool_calls / tool_calls * 100",
+        avg_retries_per_failure: "retry_after_failure_signals / failed_tool_calls",
+        retry_recovery_percent: "retry_after_failure_signals / failed_tool_calls * 100",
+        unresolved_failures: "max(0, failed_tool_calls - retry_after_failure_signals)",
+        retry_after_failure_signal: "same tool signature appears again after a failed result",
+      },
+      state_continuity: {
+        hard_breaks: "aborted turns + model-facing text that mentions lost/forgotten context/state/history/memory",
+        compaction_signals: "summarization/compaction records counted separately because compaction is risk evidence, not always data loss",
+        hard_breaks_per_session: "hard_breaks / sessions",
+      },
+      trace_coverage: {
+        session_file_coverage_percent: "session log files with structured trace evidence / scanned session log files * 100",
+        structured_trace_signal: "tool text containing trace_id, span_id, run_id, OpenTelemetry, or otel",
+      },
+      automation_footprint: {
+        lines: "line count of likely local agent/tool automation files under scripts, bin, tools, .claude, .codex, .cursor, .agents, or .mcp",
+        roots: "top-level directories containing likely local automation files",
+        note: "This is a maintainability footprint. Lines are not inherently bad; scattered roots and large scripts raise review priority.",
+      },
+      monthly_impact_estimate: {
+        active_tokens_30d: "active_tokens scaled to 30 days",
+        excess_context_spend: "excess_fresh_input_tokens scaled to 30 days * explicit $3 per 1M input-token assumption, shown as a rough low/high range",
+        recovery_toil: "failed_tool_calls*3min + retry_signals*4min + hard_breaks*20min + automation_lines/35min",
+      },
+    },
+  };
+
+  if (options.json) return JSON.stringify(guide, null, 2);
+
+  return [
+    `agentmess calculation guide v${guide.version}`,
+    "",
+    "context efficiency",
+    "  codex fresh input = max(input_tokens - cached_input_tokens, 0).",
+    "  claude fresh input = input_tokens + cache_creation_input_tokens.",
+    "  active tokens = fresh input + output tokens.",
+    "  fresh input/tool call = sum(fresh input tokens) / tool_calls.",
+    "  fresh-input drag % = fresh_input_tokens / active_tokens * 100.",
+    "  cache hit % = cached_input_tokens / (fresh_input_tokens + cached_input_tokens) * 100.",
+    "  excess context = max(0, fresh_input_tokens - tool_calls*4000).",
+    "",
+    "credential exposure",
+    "  raw keys = unique redacted fingerprints matched by known api-key patterns.",
+    "  model-facing keys = those fingerprints inside user/assistant/tool-call records.",
+    "  level = critical for any model-facing secret, high for any raw secret in logs/config.",
+    "",
+    "tool reliability",
+    "  failure rate = failed_tool_calls / tool_calls * 100.",
+    "  avg retries/failure = retry-after-failure signals / failed_tool_calls.",
+    "  retry recovery % = retry-after-failure signals / failed_tool_calls * 100.",
+    "  a retry signal means the same tool signature appears again after a failure.",
+    "",
+    "state continuity",
+    "  hard breaks = aborted turns + model-facing text mentioning lost/forgotten context, state, history, or memory.",
+    "  compaction signals are reported separately because compaction can be healthy summarization or a risk signal.",
+    "",
+    "trace coverage",
+    "  coverage = session log files with structured trace evidence / scanned session log files * 100.",
+    "  trace signals include trace_id, span_id, run_id, opentelemetry, or otel.",
+    "",
+    "automation footprint",
+    "  lines counted from likely local agent/tool automation files under scripts, bin, tools, .claude, .codex, .cursor, .agents, or .mcp.",
+    "  roots count top-level directories containing those files.",
+    "",
+    "30-day impact estimate",
+    "  active token burn = active tokens scaled to 30 days.",
+    "  excess context spend = excess fresh input tokens scaled to 30 days * explicit $3 per 1m input-token assumption.",
+    "  recovery/toil time = failures*3min + retry signals*4min + hard breaks*20min + automation_lines/35min.",
+  ].join("\n");
+}
+
+function diagnosis(stats) {
+  const highContextOverhead = stats.derived.contextOverheadLevel === "HIGH" || stats.derived.contextOverheadLevel === "CRITICAL";
+  const noTrace = stats.derived.traceCoverageLevel === "MISSING";
+  const riskySecrets = stats.derived.credentialRiskLevel === "HIGH" || stats.derived.credentialRiskLevel === "CRITICAL";
+  if (highContextOverhead && noTrace && riskySecrets) return "high operational risk. thrilling, in the wrong direction.";
+  if (highContextOverhead && noTrace) return "context-heavy and under-instrumented. a classic.";
+  if (riskySecrets) return "credential exposure detected. very senior behavior from the agents.";
+  return "mostly healthy. annoyingly competent.";
+}
+
+function scanWindow(days) {
+  return days === "all" ? "all sessions" : `last ${days}d`;
+}
+
+function conversationBox(title, rows, color) {
+  const width = Math.max(42, ...rows.map((row) => row.raw.length), title.length + 4);
+  const topFill = "─".repeat(Math.max(1, width - title.length - 1));
+  const bottomFill = "─".repeat(width + 2);
+  return [
+    `${color.border("╭─")} ${color.title(title)} ${color.border(`${topFill}╮`)}`,
+    ...rows.map((row) => boxRow(row, width, color)),
+    `${color.border("╰")}${color.border(bottomFill)}${color.border("╯")}`,
+  ].join("\n");
+}
+
+function boxRow(row, width, color) {
+  const padding = " ".repeat(Math.max(0, width - row.raw.length));
+  return `${color.border("│")} ${row.painted}${padding} ${color.border("│")}`;
+}
+
+function blankRow() {
+  return { raw: "", painted: "" };
+}
+
+function textRow(raw, painted = raw) {
+  return { raw, painted };
+}
+
+function reportText(raw, painted = raw) {
+  return { raw, painted: raw ? `  ${painted}` : "" };
+}
+
+function reportLine(label, value, color, options = {}) {
+  const labelWidth = options.labelWidth ?? 14;
+  const indent = " ".repeat(options.indent ?? 2);
+  const safeLabel = String(label).toLowerCase().slice(0, labelWidth);
+  const paintValue = options.solution ? color.solution(value) : options.level ? color.level(value, options.level) : color.value(value);
+  return {
+    raw: `${indent}${safeLabel.padEnd(labelWidth)} ${value}`,
+    painted: `${indent}${color.label(safeLabel.padEnd(labelWidth))} ${paintValue}`,
+  };
+}
+
+function metricLine(label, value, color, options = {}) {
+  return reportLine(label, value, color, { ...options, indent: 4, labelWidth: 28 });
+}
+
+function reportSection(label, color) {
+  return reportText(String(label).toLowerCase(), color.title(String(label).toLowerCase()));
+}
+
+function agentLeaderboardRows(report, color) {
+  const rows = rankAgentsOverall(report).slice(0, 5);
+  if (rows.length === 0) return paragraphRows("No agent had enough data for a leaderboard.", color);
+  const best = rows[0];
+  return rows.map((entry) => {
+    const winner = entry.score === best.score;
+    return leaderboardLine(winner ? `🏆 ${entry.label}` : `   ${entry.label}`, `${entry.score} risk pts · ${entry.summary}`, color, winner);
+  });
+}
+
+function rankAgentsOverall(report) {
+  return Object.values(report.scanned.sources ?? {})
+    .filter((source) => source.label !== "Agent config" && source.unavailable !== true && eligibleOverallAgent(source))
+    .map((source) => {
+      const traceCoverage = source.files > 0 ? ((source.traced_session_log_files ?? 0) / source.files) * 100 : 100;
+      const freshPerTool = source.tool_calls > 0 ? (source.fresh_input_tokens ?? 0) / source.tool_calls : 0;
+      const failureRate = source.tool_calls > 0 ? ((source.failed_tool_calls ?? 0) / source.tool_calls) * 100 : 0;
+      const unresolved = Math.max(0, (source.failed_tool_calls ?? 0) - (source.retry_recovery_signals ?? 0));
+      const score = Math.round(
+        Math.max(0, 100 - traceCoverage) * 0.25 +
+        Math.min(80, freshPerTool / 1000) +
+        failureRate * 1.5 +
+        Math.min(50, unresolved) +
+        (source.model_facing_secret_fingerprints ?? 0) * 20 +
+        (source.secret_fingerprints ?? 0) * 4,
+      );
+      return {
+        label: source.label,
+        score,
+        summary: agentSummary(source, traceCoverage, freshPerTool, failureRate),
+      };
+    })
+    .sort((a, b) => a.score - b.score || a.label.localeCompare(b.label));
+}
+
+function eligibleOverallAgent(source) {
+  return (source.sessions ?? 0) >= 20 || (source.tool_calls ?? 0) >= 100 || (source.files ?? 0) >= 100;
+}
+
+function agentSummary(source, traceCoverage, freshPerTool, failureRate) {
+  const parts = [];
+  if ((source.model_facing_secret_fingerprints ?? 0) > 0) parts.push(`${formatNumber(source.model_facing_secret_fingerprints)} model-facing secrets`);
+  if (failureRate > 0) parts.push(`${round(failureRate, 1)}% failures`);
+  if (freshPerTool > 0) parts.push(`${formatNumber(Math.round(freshPerTool))} fresh/tool`);
+  if (source.files > 0) parts.push(`${Math.round(traceCoverage)}% traces`);
+  return parts.slice(0, 2).join(" · ") || "cleanest scanned agent";
+}
+
+function leaderboardLine(label, value, color, winner) {
+  const safeLabel = shortText(label, 26).padEnd(26);
+  const paintLabel = winner ? color.solution(safeLabel) : color.label(safeLabel);
+  const paintValue = winner ? color.solution(value) : color.value(value);
+  return { raw: `    ${safeLabel} ${value}`, painted: `    ${paintLabel} ${paintValue}` };
+}
+
+function paragraphRows(value, color, options = {}) {
+  const indent = "    ";
+  return wrapText(String(value), 76).map((line) => {
+    const paintValue = options.solution ? color.solution(line) : options.level ? color.level(line, options.level) : color.value(line);
+    return { raw: `${indent}${line}`, painted: `${indent}${paintValue}` };
+  });
+}
+
+function wrapText(value, width) {
+  const words = String(value).split(/\s+/).filter(Boolean);
+  const lines = [];
+  let line = "";
+  for (const word of words) {
+    if (!line) {
+      line = word;
+      continue;
+    }
+    if (`${line} ${word}`.length > width) {
+      lines.push(line);
+      line = word;
+    } else {
+      line = `${line} ${word}`;
+    }
+  }
+  if (line) lines.push(line);
+  return lines.length > 0 ? lines : [""];
+}
+
+function compactLine(label, value, color, options = {}) {
+  const raw = `${label.padEnd(10)} ${value}`;
+  const paintValue = options.solution ? color.solution(value) : options.level ? color.level(value, options.level) : color.value(value);
+  return { raw, painted: `${color.label(label.padEnd(10))} ${paintValue}` };
+}
+
+function solutionLine(report) {
+  const context = report.metrics.context_efficiency;
+  const credential = report.metrics.credential_exposure;
+  const reliability = report.metrics.tool_reliability;
+  const trace = report.metrics.trace_coverage;
+  const actions = [];
+
+  if (credential.unique_secret_fingerprints > 0) actions.push("rotate exposed credentials");
+  if (context.fresh_input_tokens_per_tool_call > context.review_threshold_fresh_input_tokens_per_tool_call) actions.push("reduce repeated context");
+  if (trace.session_file_coverage_percent < 80) actions.push("add trace/run IDs");
+  if (reliability.failed_tool_calls > 0) actions.push("classify retryable failures");
+
+  return actions.length > 0 ? actions.slice(0, 3).join(" · ") : "nothing urgent";
+}
+
+function wasteVerdict(report) {
+  const levels = [
+    report.metrics.context_efficiency.level,
+    report.metrics.credential_exposure.level,
+    report.metrics.tool_reliability.level,
+    report.metrics.trace_coverage.level,
+  ];
+  const score = levels.reduce((sum, level) => sum + levelWeight(level), 0);
+  if (score >= 8) return { label: "not good", level: "CRITICAL", line: "strong architecture review energy." };
+  if (score >= 4) return { label: "risky", level: "HIGH", line: "ship it only if you enjoy follow-up meetings." };
+  if (score >= 2) return { label: "mostly fine", level: "MEDIUM", line: "some review comments, not a rewrite." };
+  return { label: "healthy", level: "LOW", line: "i tried to complain. limited material." };
+}
+
+function shortText(value, max) {
+  const text = String(value ?? "");
+  if (text.length <= max) return text;
+  return `${text.slice(0, Math.max(0, max - 1))}…`;
+}
+
+function round(value, digits) {
+  const factor = 10 ** digits;
+  return Math.round(value * factor) / factor;
+}
+
+function levelWeight(level) {
+  switch (String(level).toLowerCase()) {
+    case "critical":
+    case "missing":
+      return 3;
+    case "high":
+      return 2;
+    case "medium":
+    case "partial":
+      return 1;
+    default:
+      return 0;
+  }
+}
+
+function formatNumber(value) {
+  return Number(value || 0).toLocaleString("en-US");
+}
+
+function formatSeconds(ms) {
+  const seconds = Math.max(0.1, ms / 1000);
+  return `${seconds.toFixed(seconds >= 10 ? 0 : 1)}s`;
+}
+
+function colorizer(enabled) {
+  if (!enabled) return plainColors();
+  const paint = (code, value) => `\x1b[${code}m${value}\x1b[0m`;
+  return {
+    accent: (value) => paint("38;2;147;197;253", value),
+    dim: (value) => paint("2", value),
+    border: (value) => paint("38;2;100;116;139", value),
+    label: (value) => paint("38;2;186;230;253", value),
+    muted: (value) => paint("38;2;148;163;184", value),
+    rule: (value) => paint("38;2;71;85;105", value),
+    solution: (value) => paint("38;2;125;211;252", value),
+    title: (value) => paint("38;2;147;197;253;1", value),
+    value: (value) => paint("38;2;226;232;240", value),
+    level: (value, level) => paint(levelColor(level), value),
+  };
+}
+
+function plainColors() {
+  return {
+    accent: (value) => value,
+    dim: (value) => value,
+    border: (value) => value,
+    label: (value) => value,
+    muted: (value) => value,
+    rule: (value) => value,
+    solution: (value) => value,
+    title: (value) => value,
+    value: (value) => value,
+    level: (value) => value,
+  };
+}
+
+function levelColor(level) {
+  switch (String(level).toLowerCase()) {
+    case "critical":
+    case "missing":
+      return "38;2;251;113;133";
+    case "high":
+      return "38;2;253;186;116";
+    case "medium":
+    case "partial":
+      return "38;2;147;197;253";
+    case "good":
+    case "low":
+      return "38;2;125;211;252";
+    case "config_only":
+    case "no_data":
+      return "38;2;148;163;184";
+    default:
+      return "90";
+  }
+}