@codyswann/lisa 2.119.1 → 2.121.1

package/plugins/lisa-copilot/scripts/automation-status-report.mjs

@@ -0,0 +1,170 @@
+#!/usr/bin/env node
+/**
+ * Shared automation-status report helpers for the base Lisa operator surface.
+ *
+ * Keep this dependency-free so the grouped fleet rendering contract can ship in
+ * plugin distributions and downstream repos before the runtime adapters land.
+ */
+
+export const AUTOMATION_HEALTH_STATUSES = [
+  "HEALTHY",
+  "MISSING",
+  "UNSUPPORTED",
+  "DRIFTED",
+  "STALE",
+  "FAILING",
+];
+
+export const AUTOMATION_FLEET_VERDICTS = [
+  "HEALTHY",
+  "PARTIAL_SUPPORT",
+  "ATTENTION_NEEDED",
+];
+
+/**
+ * @typedef {"HEALTHY" | "MISSING" | "UNSUPPORTED" | "DRIFTED" | "STALE" | "FAILING"} AutomationHealthStatus
+ * @typedef {"HEALTHY" | "PARTIAL_SUPPORT" | "ATTENTION_NEEDED"} AutomationFleetVerdict
+ *
+ * @typedef {{
+ *   readonly id: string
+ *   readonly status: AutomationHealthStatus
+ *   readonly summary: string
+ *   readonly expectedCadence?: string
+ *   readonly expectedCommand?: string
+ *   readonly observed?: string
+ *   readonly remediation?: string
+ * }} AutomationStatusItem
+ *
+ * @typedef {{
+ *   readonly id: string
+ *   readonly title: string
+ *   readonly items: readonly AutomationStatusItem[]
+ * }} AutomationStatusGroup
+ *
+ * @typedef {{
+ *   readonly runtime?: string
+ *   readonly generatedAt?: string
+ *   readonly groups: readonly AutomationStatusGroup[]
+ * }} AutomationStatusReportInput
+ */
+
+/**
+ * @param {readonly AutomationStatusGroup[]} groups
+ * @returns {AutomationFleetVerdict}
+ */
+export function computeAutomationFleetVerdict(groups) {
+  const items = groups.flatMap(group => group.items);
+  if (
+    items.some(item =>
+      ["MISSING", "DRIFTED", "STALE", "FAILING"].includes(item.status)
+    )
+  ) {
+    return "ATTENTION_NEEDED";
+  }
+  if (items.some(item => item.status === "UNSUPPORTED")) {
+    return "PARTIAL_SUPPORT";
+  }
+  return "HEALTHY";
+}
+
+/**
+ * @param {readonly AutomationStatusGroup[]} groups
+ * @returns {Record<AutomationHealthStatus, number>}
+ */
+export function countAutomationHealthStatuses(groups) {
+  return groups
+    .flatMap(group => group.items)
+    .reduce(
+      (counts, item) => ({
+        ...counts,
+        [item.status]: counts[item.status] + 1,
+      }),
+      {
+        HEALTHY: 0,
+        MISSING: 0,
+        UNSUPPORTED: 0,
+        DRIFTED: 0,
+        STALE: 0,
+        FAILING: 0,
+      }
+    );
+}
+
+/**
+ * @param {AutomationStatusReportInput} input
+ * @returns {{ readonly verdict: AutomationFleetVerdict, readonly counts: Record<AutomationHealthStatus, number>, readonly text: string }}
+ */
+export function renderAutomationStatusReport(input) {
+  const groups = input.groups.map(normalizeGroup);
+  const verdict = computeAutomationFleetVerdict(groups);
+  const counts = countAutomationHealthStatuses(groups);
+  const lines = [
+    `Overall verdict: ${verdict}`,
+    `Counts: ${AUTOMATION_HEALTH_STATUSES.map(status => `${counts[status]} ${status}`).join(", ")}`,
+  ];
+
+  if (input.runtime) {
+    lines.push(`Runtime inspected: ${input.runtime}`);
+  }
+
+  if (input.generatedAt) {
+    lines.push(`Generated at: ${input.generatedAt}`);
+  }
+
+  for (const group of groups) {
+    lines.push("", `${group.id}. ${group.title}`);
+    if (group.items.length === 0) {
+      lines.push(
+        "- UNSUPPORTED empty-group: no automations expected in this group"
+      );
+      continue;
+    }
+
+    for (const item of group.items) {
+      lines.push(`- ${item.status} ${item.id}: ${item.summary}`);
+      if (item.expectedCadence || item.expectedCommand) {
+        const cadence = item.expectedCadence ?? "cadence unavailable";
+        const command = item.expectedCommand ?? "command unavailable";
+        lines.push(`  Expected: ${cadence} -> ${command}`);
+      }
+      if (item.observed) {
+        lines.push(`  Observed: ${item.observed}`);
+      }
+      if (item.remediation) {
+        lines.push(`  Remediation: ${item.remediation}`);
+      }
+    }
+  }
+
+  return {
+    verdict,
+    counts,
+    text: `${lines.join("\n")}\n`,
+  };
+}
+
+/**
+ * @param {AutomationStatusGroup} group
+ * @returns {AutomationStatusGroup}
+ */
+function normalizeGroup(group) {
+  return {
+    ...group,
+    items: group.items.map(normalizeItem),
+  };
+}
+
+/**
+ * @param {AutomationStatusItem} item
+ * @returns {AutomationStatusItem}
+ */
+function normalizeItem(item) {
+  const normalizedStatus = AUTOMATION_HEALTH_STATUSES.includes(item.status)
+    ? item.status
+    : "FAILING";
+
+  return {
+    ...item,
+    status: normalizedStatus,
+  };
+}

package/plugins/lisa-copilot/scripts/doctor-report.mjs

@@ -0,0 +1,143 @@
+#!/usr/bin/env node
+/**
+ * Shared doctor report helpers for the base Lisa doctor surface.
+ *
+ * The first doctor milestone needs a stable grouped output contract before the
+ * repo adds real readiness probes. Keep this file dependency-free so future
+ * doctor scripts can reuse it from plugin distributions and downstream repos.
+ */
+
+export const DOCTOR_STATUSES = ["PASS", "WARN", "FAIL", "SKIP"];
+export const DOCTOR_VERDICTS = ["READY", "READY_WITH_WARNINGS", "NOT_READY"];
+
+/**
+ * @typedef {"PASS" | "WARN" | "FAIL" | "SKIP"} DoctorStatus
+ * @typedef {"READY" | "READY_WITH_WARNINGS" | "NOT_READY"} DoctorVerdict
+ *
+ * @typedef {{
+ *   readonly id: string
+ *   readonly status: DoctorStatus
+ *   readonly summary: string
+ *   readonly observed?: string
+ *   readonly remediation?: string
+ * }} DoctorCheck
+ *
+ * @typedef {{
+ *   readonly id: string
+ *   readonly title: string
+ *   readonly checks: readonly DoctorCheck[]
+ * }} DoctorGroup
+ *
+ * @typedef {{
+ *   readonly generatedAt?: string
+ *   readonly groups: readonly DoctorGroup[]
+ * }} DoctorReportInput
+ */
+
+/**
+ * @param {readonly DoctorGroup[]} groups
+ * @returns {DoctorVerdict}
+ */
+export function computeDoctorVerdict(groups) {
+  const checks = groups.flatMap(group => group.checks.map(normalizeCheck));
+  if (checks.some(check => check.status === "FAIL")) {
+    return "NOT_READY";
+  }
+  if (checks.some(check => check.status === "WARN")) {
+    return "READY_WITH_WARNINGS";
+  }
+  return "READY";
+}
+
+/**
+ * @param {readonly DoctorGroup[]} groups
+ * @returns {Record<DoctorStatus, number>}
+ */
+export function countDoctorStatuses(groups) {
+  return groups
+    .flatMap(group => group.checks.map(normalizeCheck))
+    .reduce(
+      (counts, check) => ({
+        ...counts,
+        [check.status]: counts[check.status] + 1,
+      }),
+      { PASS: 0, WARN: 0, FAIL: 0, SKIP: 0 }
+    );
+}
+
+/**
+ * @param {DoctorReportInput} input
+ * @returns {{ readonly verdict: DoctorVerdict, readonly counts: Record<DoctorStatus, number>, readonly text: string }}
+ */
+export function renderDoctorReport(input) {
+  const groups = input.groups.map(normalizeGroup);
+  const verdict = computeDoctorVerdict(groups);
+  const counts = countDoctorStatuses(groups);
+  const lines = [
+    `Overall verdict: ${verdict}`,
+    `Counts: ${DOCTOR_STATUSES.map(status => `${counts[status]} ${status}`).join(", ")}`,
+  ];
+
+  if (input.generatedAt) {
+    lines.push(`Generated at: ${input.generatedAt}`);
+  }
+
+  for (const group of groups) {
+    lines.push("", `${group.id}. ${group.title}`);
+    if (group.checks.length === 0) {
+      lines.push("- SKIP empty-group: no checks registered yet");
+      continue;
+    }
+    for (const check of group.checks) {
+      lines.push(`- ${check.status} ${check.id}: ${check.summary}`);
+      if (check.observed) {
+        lines.push(`  Observed: ${check.observed}`);
+      }
+      if (check.remediation) {
+        lines.push(`  Remediation: ${check.remediation}`);
+      }
+    }
+  }
+
+  return {
+    verdict,
+    counts,
+    text: `${lines.join("\n")}\n`,
+  };
+}
+
+/**
+ * @param {DoctorGroup} group
+ * @returns {DoctorGroup}
+ */
+function normalizeGroup(group) {
+  const checks =
+    group.checks.length === 0
+      ? [
+          {
+            id: "empty-group",
+            status: "SKIP",
+            summary: "no checks registered yet",
+          },
+        ]
+      : group.checks.map(normalizeCheck);
+
+  return {
+    ...group,
+    checks,
+  };
+}
+
+/**
+ * @param {DoctorCheck} check
+ * @returns {DoctorCheck}
+ */
+function normalizeCheck(check) {
+  const normalizedStatus = DOCTOR_STATUSES.includes(check.status)
+    ? check.status
+    : "FAIL";
+  return {
+    ...check,
+    status: normalizedStatus,
+  };
+}