premanmcp 0.7.0 → 0.8.0

package/bin/status.js

@@ -0,0 +1,210 @@
+/**
+ * `preman status` — endpoint health in the terminal.
+ *
+ * One request to GET /cli/status, rendered as a table. The backend degrades
+ * individual sections rather than failing, so this renderer must treat every
+ * section as possibly empty.
+ */
+
+import { backendUrl, callBackendJson, cliInvocation, makeArgs, resolveApiKey } from "./shared.js";
+
+export const STATUS_HELP = `
+Status options:
+  --workspace <id>      Workspace to report on. Defaults to your primary workspace
+  --json                Print the raw JSON payload instead of a table
+  --no-color            Disable ANSI colour
+`;
+
+// Honour the conventions people already expect from CLIs, so status can be piped
+// into a file or a CI log without escape codes landing in it.
+function makePaint(enabled) {
+  const wrap = (code) => (text) => (enabled ? `\u001b[${code}m${text}\u001b[0m` : String(text));
+  return {
+    green: wrap("32"),
+    red: wrap("31"),
+    yellow: wrap("33"),
+    blue: wrap("36"),
+    dim: wrap("2"),
+    bold: wrap("1"),
+  };
+}
+
+function colourEnabled(args) {
+  if (args.has("--no-color") || args.has("--no-colour")) return false;
+  if (process.env.NO_COLOR) return false;
+  if (process.env.FORCE_COLOR) return true;
+  return Boolean(process.stdout.isTTY);
+}
+
+function relativeTime(iso) {
+  if (!iso) return "";
+  const then = Date.parse(iso);
+  if (Number.isNaN(then)) return "";
+  const seconds = Math.max(0, Math.round((Date.now() - then) / 1000));
+  if (seconds < 60) return `${seconds}s ago`;
+  if (seconds < 3600) return `${Math.round(seconds / 60)}m ago`;
+  if (seconds < 86400) return `${Math.round(seconds / 3600)}h ago`;
+  return `${Math.round(seconds / 86400)}d ago`;
+}
+
+function truncate(value, width) {
+  const text = String(value ?? "");
+  return text.length <= width ? text : `${text.slice(0, width - 1)}…`;
+}
+
+const MAX_TARGET_WIDTH = 46;
+
+/** Column widths are measured across every row we will print, so the failing and
+ *  healthy blocks line up with each other rather than each aligning internally. */
+function endpointColumns(groups) {
+  const all = groups.flat();
+  return {
+    method: Math.max(3, ...all.map((e) => String(e.method || "GET").length)),
+    target: Math.min(
+      MAX_TARGET_WIDTH,
+      Math.max(8, ...all.map((e) => String(e.url || e.name || "").length))
+    ),
+  };
+}
+
+function renderEndpointRows(entries, { symbol, paint, colour, columns }) {
+  return entries.map((entry) => {
+    const method = String(entry.method || "GET").padEnd(columns.method);
+    const target = truncate(entry.url || entry.name || "", columns.target).padEnd(columns.target);
+    const code = entry.status_code ? String(entry.status_code) : "";
+    const trailing = [code, entry.error ? truncate(entry.error, 38) : "", relativeTime(entry.last_run_at)]
+      .filter(Boolean)
+      .join("  ");
+    return `  ${colour(symbol)} ${paint.dim(method)}  ${target}  ${paint.dim(trailing)}`.trimEnd();
+  });
+}
+
+export function renderStatus(payload, { colour = false } = {}) {
+  const paint = makePaint(colour);
+  const lines = [];
+
+  const workspace = payload.workspace || {};
+  lines.push(`${paint.bold("PreMan")} ${paint.dim("·")} ${workspace.name || "workspace"}`);
+  lines.push("");
+
+  const endpoints = payload.endpoints || {};
+  const healthy = Number(endpoints.healthy || 0);
+  const failing = Number(endpoints.failing || 0);
+  const untested = Number(endpoints.untested || 0);
+  const total = Number(endpoints.total || 0);
+
+  if (total === 0) {
+    lines.push(paint.dim("No saved endpoints yet."));
+    lines.push(paint.dim(`Run \`${cliInvocation()} endpoints discover\` to scan this repo.`));
+  } else {
+    const summary = [
+      failing ? paint.red(`${failing} failing`) : null,
+      healthy ? paint.green(`${healthy} healthy`) : null,
+      untested ? paint.yellow(`${untested} untested`) : null,
+    ]
+      .filter(Boolean)
+      .join(paint.dim(" · "));
+    lines.push(`${paint.bold("Endpoints")}  ${summary} ${paint.dim(`(${total} total)`)}`);
+
+    const failingExamples = endpoints.failing_examples || [];
+    const healthyExamples = endpoints.healthy_examples || [];
+    const columns = endpointColumns([failingExamples, healthyExamples]);
+    if (failingExamples.length) {
+      lines.push("");
+      lines.push(
+        ...renderEndpointRows(failingExamples, { symbol: "✗", paint, colour: paint.red, columns })
+      );
+    }
+    if (healthyExamples.length) {
+      lines.push("");
+      lines.push(
+        ...renderEndpointRows(healthyExamples, { symbol: "✓", paint, colour: paint.green, columns })
+      );
+    }
+  }
+
+  const fixed = payload.recently_fixed || [];
+  if (fixed.length) {
+    lines.push("");
+    lines.push(`${paint.bold("Recently fixed")} ${paint.dim("(7d)")}`);
+    for (const entry of fixed) {
+      const label = truncate(entry.title || entry.source_kind || "fix", 40).padEnd(40);
+      const pr = entry.pr_url ? paint.blue(entry.pr_url) : paint.dim("no PR recorded");
+      lines.push(`  ${paint.green("✓")} ${label} ${pr} ${paint.dim(relativeTime(entry.resolved_at))}`);
+    }
+  }
+
+  const push = payload.last_push;
+  lines.push("");
+  if (push) {
+    const verdict = push.verdict || push.status || "unknown";
+    const paintVerdict =
+      verdict === "impact_detected" ? paint.red : verdict === "no_impact" ? paint.green : paint.yellow;
+    lines.push(
+      `${paint.bold("Last push")}  ${push.repo || ""} ${paint.dim(`${push.branch || ""}@${push.commit || ""}`)} ` +
+        `${paintVerdict(verdict)} ${paint.dim(relativeTime(push.finished_at))}`
+    );
+  } else {
+    lines.push(`${paint.bold("Last push")}  ${paint.dim("no simulations yet")}`);
+  }
+
+  const observed = payload.observed_prod || {};
+  const routes = observed.routes || [];
+  if (routes.length) {
+    lines.push("");
+    lines.push(`${paint.bold("Production")} ${paint.dim("(24h)")}`);
+    const shown = routes.slice(0, 5);
+    const columns = endpointColumns([shown.map((r) => ({ method: r.method, url: r.route }))]);
+    const callsWidth = Math.max(...shown.map((r) => `${r.observations || 0} calls`.length));
+    for (const route of shown) {
+      const method = String(route.method || "GET").padEnd(columns.method);
+      const target = truncate(route.route, columns.target).padEnd(columns.target);
+      const errors = Number(route.errors || 0);
+      const errText = errors ? paint.red(`${errors} errors`) : paint.dim("clean");
+      const calls = `${route.observations || 0} calls`.padStart(callsWidth);
+      lines.push(`    ${paint.dim(method)}  ${target}  ${paint.dim(calls)}  ${errText}`);
+    }
+  } else if (observed.hint) {
+    lines.push("");
+    lines.push(`${paint.bold("Production")}  ${paint.dim(observed.hint)}`);
+  }
+
+  const integrations = payload.integrations || {};
+  const mark = (section) => (section && section.connected ? paint.green("✓") : paint.dim("–"));
+  lines.push("");
+  lines.push(
+    `${paint.bold("Integrations")}  github ${mark(integrations.github)}  ` +
+      `logs ${mark(integrations.logs)}  slack ${mark(integrations.slack)}`
+  );
+
+  return `${lines.join("\n")}\n`;
+}
+
+export async function statusCommand(commandArgs = []) {
+  const args = makeArgs(commandArgs);
+  const token = resolveApiKey(args);
+  if (!token) {
+    throw new Error(
+      `no PreMan API key found. Run \`${cliInvocation()} login\` first, or pass --api-key.`
+    );
+  }
+
+  const result = await callBackendJson(args, "GET", "/cli/status", {
+    token,
+    headers: { "x-workspace-id": args.value("--workspace", "") },
+  });
+
+  if (!result.ok) {
+    const detail = result.detail || result.raw || "request failed";
+    throw new Error(`could not read status from ${backendUrl(args)}: ${result.status_code} ${detail}`);
+  }
+
+  const { status_code, ok, ...payload } = result;
+  if (args.has("--json")) {
+    process.stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
+    return payload;
+  }
+
+  process.stdout.write(renderStatus(payload, { colour: colourEnabled(args) }));
+  return payload;
+}