@codyswann/lisa 4.27.7 → 4.27.8

package/typescript/copy-overwrite/scripts/nightly-e2e-tracking-config.mjs

@@ -0,0 +1,149 @@
+// This file is managed by Lisa and IS replaced on each `lisa` run.
+// Do not edit directly — durable changes belong upstream in Lisa.
+
+/**
+ * Public configuration and provider dispatch for nightly-E2E tracking.
+ *
+ * @module scripts/nightly-e2e-tracking-config
+ */
+export const MAX_TRACKING_DIAGNOSTIC = 4096;
+export const TRACKING_DESTINATIONS = Object.freeze([
+  "github",
+  "sentry",
+  "jira",
+  "linear",
+  "none",
+]);
+const PROVIDER_WORKFLOWS = Object.freeze({
+  github: ".github/workflows/create-github-issue-on-failure.yml",
+  sentry: ".github/workflows/create-sentry-issue-on-failure.yml",
+  jira: ".github/workflows/create-jira-issue-on-failure.yml",
+  linear: ".github/workflows/create-linear-issue-on-failure.yml",
+});
+const PROVIDER_SECRETS = Object.freeze({
+  github: ["PAT"],
+  sentry: ["SENTRY_AUTH_TOKEN"],
+  jira: ["JIRA_API_TOKEN"],
+  linear: ["LINEAR_API_KEY"],
+});
+
+/** Return whether a value is a plain object. */
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+/** Throw a stable diagnostic which contains no rejected value. */
+export function refuseTracking(message) {
+  throw new Error(message.slice(0, MAX_TRACKING_DIAGNOSTIC));
+}
+
+/** Read one non-empty string from a selected provider block. */
+function requiredString(record, key, pathName) {
+  const prefix =
+    "nightlyE2E.tracking.destination supports " +
+    "github, sentry, jira, linear, none";
+  if (!isRecord(record)) {
+    refuseTracking(`${prefix}; ${pathName} must be an object`);
+  }
+  const value = record[key];
+  if (typeof value !== "string" || value.trim() === "") {
+    refuseTracking(`${prefix}; ${pathName}.${key} must be a non-empty string`);
+  }
+  return value;
+}
+
+/** Resolve a selected provider's existing project configuration. */
+function resolveProvider(config, destination) {
+  if (destination === "github") {
+    return Object.freeze({
+      org: requiredString(config.github, "org", "github"),
+      repo: requiredString(config.github, "repo", "github"),
+    });
+  }
+  if (destination === "sentry") {
+    return Object.freeze({
+      org: requiredString(config.sentry, "org", "sentry"),
+      project: requiredString(config.sentry, "project", "sentry"),
+    });
+  }
+  if (destination === "jira") {
+    return Object.freeze({
+      jira: Object.freeze({
+        ...config.jira,
+        project: requiredString(config.jira, "project", "jira"),
+      }),
+      atlassian: Object.freeze({
+        ...config.atlassian,
+        site: requiredString(config.atlassian, "site", "atlassian"),
+      }),
+    });
+  }
+  return Object.freeze({
+    ...config.linear,
+    teamKey: requiredString(config.linear, "teamKey", "linear"),
+  });
+}
+
+/** Resolve the public destination and reuse its existing provider block. */
+export function resolveNightlyTrackingConfig(config) {
+  if (!isRecord(config)) refuseTracking("project config must be an object");
+  if (!("nightlyE2E" in config)) {
+    return Object.freeze({ destination: "none", provider: null });
+  }
+  if (!isRecord(config.nightlyE2E)) {
+    refuseTracking("nightlyE2E must be an object");
+  }
+  if (!("tracking" in config.nightlyE2E)) {
+    return Object.freeze({ destination: "none", provider: null });
+  }
+  if (!isRecord(config.nightlyE2E.tracking)) {
+    refuseTracking("nightlyE2E.tracking must be an object");
+  }
+  const destination =
+    "destination" in config.nightlyE2E.tracking
+      ? config.nightlyE2E.tracking.destination
+      : "none";
+  if (!TRACKING_DESTINATIONS.includes(destination)) {
+    refuseTracking(
+      "nightlyE2E.tracking.destination must be one of " +
+        "github, sentry, jira, linear, none"
+    );
+  }
+  return Object.freeze({
+    destination,
+    provider:
+      destination === "none" ? null : resolveProvider(config, destination),
+  });
+}
+
+/** Build the exact handoff consumed by the selected provider workflow. */
+export function buildProviderDispatch(settings, plan) {
+  const { destination, provider } = settings;
+  if (destination === "none" || !provider) {
+    refuseTracking("requested destination none has no provider dispatch");
+  }
+  const inputs = {
+    workflow_name: "Nightly E2E condition",
+    tracking_action: plan.action,
+    tracking_marker: plan.marker,
+    tracking_title: plan.title ?? "",
+    tracking_body: plan.body ?? "",
+    tracking_id: plan.trackerId ?? "",
+  };
+  if (destination === "sentry") {
+    inputs.SENTRY_ORG = provider.org;
+    inputs.SENTRY_PROJECT = provider.project;
+  } else if (destination === "jira") {
+    inputs.JIRA_BASE_URL = `https://${provider.atlassian.site}`;
+    inputs.JIRA_USER_EMAIL = provider.atlassian.email ?? "";
+    inputs.JIRA_PROJECT_KEY = provider.jira.project;
+  } else if (destination === "linear") {
+    inputs.team_key = provider.teamKey;
+  }
+  return Object.freeze({
+    destination,
+    workflow: PROVIDER_WORKFLOWS[destination],
+    inputs: Object.freeze(inputs),
+    secrets: Object.freeze([...PROVIDER_SECRETS[destination]]),
+  });
+}

package/typescript/copy-overwrite/scripts/reconcile-nightly-e2e-tracking-cli.mjs

@@ -0,0 +1,56 @@
+// This file is managed by Lisa and IS replaced on each `lisa` run.
+// Do not edit directly — durable changes belong upstream in Lisa.
+
+/**
+ * GitHub Actions output adapter for the nightly-E2E tracking planner.
+ *
+ * @module scripts/reconcile-nightly-e2e-tracking-cli
+ */
+import * as fs from "node:fs";
+import { randomUUID } from "node:crypto";
+
+/** Append one GitHub Actions output without command injection. */
+function appendOutput(name, value) {
+  const file = process.env.GITHUB_OUTPUT;
+  if (!file) throw new Error("GITHUB_OUTPUT is required in --plan mode");
+  let delimiter = `LISA_${name}_${randomUUID()}`;
+  while (String(value).includes(delimiter)) {
+    delimiter = `LISA_${name}_${randomUUID()}`;
+  }
+  fs.appendFileSync(file, `${name}<<${delimiter}\n${value}\n${delimiter}\n`);
+}
+
+/**
+ * Resolve config/findings into provider-job outputs.
+ *
+ * @param input - Pure config and plan functions
+ */
+export function runTrackingPlan(input) {
+  const configPath = process.env.LISA_CONFIG_PATH ?? ".lisa.config.json";
+  const config = JSON.parse(fs.readFileSync(configPath, "utf8"));
+  const findings = JSON.parse(process.env.NIGHTLY_E2E_FINDINGS ?? "[]");
+  const settings = input.resolveConfig(config);
+  const plan = input.plan(findings, []);
+  let destination = settings.destination;
+  let action = plan.action === "refresh" ? "create" : plan.action;
+  if (settings.destination === "none") {
+    action = "none";
+  } else if (plan.action === "none" && plan.reason === "both_suites_green") {
+    action = "close";
+  } else if (plan.action === "none") {
+    destination = "none";
+  }
+  appendOutput("destination", destination);
+  appendOutput("tracking_action", action);
+  appendOutput("tracking_marker", plan.marker);
+  appendOutput("tracking_title", plan.title ?? "");
+  appendOutput("tracking_body", plan.body ?? "");
+  appendOutput("tracking_id", plan.trackerId ?? "");
+  appendOutput("provider_json", JSON.stringify(settings.provider ?? {}));
+  appendOutput("tracking_findings", JSON.stringify(findings));
+  if (settings.destination === "none") {
+    console.log("tracking_disabled");
+    const summary = process.env.GITHUB_STEP_SUMMARY;
+    if (summary) fs.appendFileSync(summary, "tracking_disabled\n");
+  }
+}

package/typescript/copy-overwrite/scripts/reconcile-nightly-e2e-tracking.mjs

@@ -0,0 +1,208 @@
+#!/usr/bin/env node
+// This file is managed by Lisa and IS replaced on each `lisa` run.
+// Do not edit directly — durable changes belong upstream in Lisa.
+
+/**
+ * Resolve and reconcile one nightly-E2E condition across provider adapters.
+ *
+ * @module scripts/reconcile-nightly-e2e-tracking
+ */
+import * as path from "node:path";
+import { pathToFileURL } from "node:url";
+import {
+  MAX_TRACKING_DIAGNOSTIC,
+  TRACKING_DESTINATIONS,
+  buildProviderDispatch,
+  refuseTracking as refuse,
+  resolveNightlyTrackingConfig,
+} from "./nightly-e2e-tracking-config.mjs";
+import { runTrackingPlan } from "./reconcile-nightly-e2e-tracking-cli.mjs";
+
+export {
+  TRACKING_DESTINATIONS,
+  buildProviderDispatch,
+  resolveNightlyTrackingConfig,
+};
+export const TRACKED_SUITE_LABELS = Object.freeze([
+  "🎭 Playwright Web E2E",
+  "📱 Maestro Native E2E",
+]);
+export const CONDITION_MARKER = "<!-- lisa_nightly_e2e_condition:v1 -->";
+
+/** Validate exact suite and tracker authority before deriving any action. */
+function validateAuthority(findings, trackers) {
+  const exactSuiteMessage =
+    "findings must contain exactly Playwright Web E2E and Maestro Native E2E";
+  if (!Array.isArray(findings) || findings.length !== 2) {
+    refuse(exactSuiteMessage);
+  }
+  const labels = findings.map(finding => finding?.label).sort();
+  const expected = [...TRACKED_SUITE_LABELS].sort();
+  if (JSON.stringify(labels) !== JSON.stringify(expected)) {
+    refuse(exactSuiteMessage);
+  }
+  if (!Array.isArray(trackers)) refuse("tracker list must be an array");
+  if (trackers.some(tracker => tracker?.marker !== CONDITION_MARKER)) {
+    refuse("tracker adapter returned a record outside marker authority");
+  }
+  if (trackers.length > 1) refuse("multiple matching condition trackers found");
+}
+
+/** Produce one destination-neutral create, refresh, close, or no-op plan. */
+export function planCombinedTracking(findings, trackers) {
+  validateAuthority(findings, trackers);
+  const incomplete = findings.some(
+    finding => !finding.complete || finding.state === "unknown"
+  );
+  if (incomplete) {
+    return Object.freeze({
+      action: "none",
+      marker: CONDITION_MARKER,
+      trackerId: null,
+      title: null,
+      body: null,
+      pin: null,
+      reason: "incomplete_evidence",
+    });
+  }
+  const existing = trackers[0] ?? null;
+  const red = findings.some(finding => finding.state === "fail");
+  if (!red && !existing) {
+    return Object.freeze({
+      action: "none",
+      marker: CONDITION_MARKER,
+      trackerId: null,
+      title: null,
+      body: null,
+      pin: null,
+      reason: "both_suites_green",
+    });
+  }
+  if (!red) {
+    return Object.freeze({
+      action: "close",
+      marker: CONDITION_MARKER,
+      trackerId: existing.id,
+      title: null,
+      body: null,
+      pin: false,
+      reason: "both_suites_green",
+    });
+  }
+  const status = findings.map(
+    finding =>
+      `- **${finding.label}**: ${finding.state} ([run](${finding.runUrl}))`
+  );
+  return Object.freeze({
+    action: existing ? "refresh" : "create",
+    marker: CONDITION_MARKER,
+    trackerId: existing?.id ?? null,
+    title: "Nightly E2E condition is red",
+    body: `${CONDITION_MARKER}\n## Nightly E2E condition\n\n${status.join("\n")}`,
+    pin: true,
+    reason: "at_least_one_suite_red",
+  });
+}
+
+/** Convert a provider exception into a bounded, secret-free classification. */
+function providerFailure(destination, action, error) {
+  const raw = error instanceof Error ? error.message : String(error);
+  const status =
+    raw.match(/\bHTTP\s+\d{3}\b/iu)?.[0] ??
+    raw.match(/\breadback\b.*\bauthority\b/iu)?.[0] ??
+    (raw.includes("success false") ? "success false" : undefined) ??
+    (raw.includes("refused") ? "refused" : "provider error");
+  return new Error(
+    `Requested ${destination} destination ${action} failed: ${status}`.slice(
+      0,
+      MAX_TRACKING_DIAGNOSTIC
+    )
+  );
+}
+
+/** Invoke one adapter action and wrap its errors at the trust boundary. */
+async function providerCall(destination, action, invoke) {
+  try {
+    return await invoke();
+  } catch (error) {
+    throw providerFailure(destination, action, error);
+  }
+}
+
+/** Reconcile the combined condition through exactly one selected adapter. */
+export async function reconcileCombinedTracking(input) {
+  const settings = resolveNightlyTrackingConfig(input.config);
+  if (settings.destination === "none") {
+    return Object.freeze({
+      destination: "none",
+      action: "skipped",
+      trackerId: null,
+      reason: "tracking_disabled",
+    });
+  }
+  const destination = settings.destination;
+  const adapters = input.adapters ?? {};
+  const adapter = adapters[destination];
+  if (!adapter) refuse(`${destination} adapter is unavailable`);
+  const trackers = await providerCall(destination, "list", () =>
+    adapter.list(CONDITION_MARKER)
+  );
+  const plan = planCombinedTracking(input.findings, trackers);
+  if (plan.action === "none") {
+    return Object.freeze({
+      destination,
+      action: "none",
+      trackerId: null,
+      reason: plan.reason,
+    });
+  }
+  if (plan.action === "create") {
+    const tracker = await providerCall(destination, "create", () =>
+      adapter.create(plan)
+    );
+    if (adapter.pin) {
+      await providerCall(destination, "pin", () => adapter.pin(tracker.id));
+    }
+    return Object.freeze({
+      destination,
+      action: "create",
+      trackerId: tracker.id,
+      reason: plan.reason,
+    });
+  }
+  if (plan.action === "refresh") {
+    const tracker = await providerCall(destination, "refresh", () =>
+      adapter.refresh(plan.trackerId, plan)
+    );
+    if (adapter.pin) {
+      await providerCall(destination, "pin", () => adapter.pin(tracker.id));
+    }
+    return Object.freeze({
+      destination,
+      action: "refresh",
+      trackerId: tracker.id,
+      reason: plan.reason,
+    });
+  }
+  if (adapter.unpin) {
+    await providerCall(destination, "unpin", () =>
+      adapter.unpin(plan.trackerId)
+    );
+  }
+  await providerCall(destination, "close", () => adapter.close(plan.trackerId));
+  return Object.freeze({
+    destination,
+    action: "close",
+    trackerId: plan.trackerId,
+    reason: plan.reason,
+  });
+}
+
+const invokedPath = process.argv[1] ? path.resolve(process.argv[1]) : "";
+if (invokedPath && pathToFileURL(invokedPath).href === import.meta.url) {
+  if (!process.argv.includes("--plan")) refuse("expected --plan");
+  runTrackingPlan({
+    resolveConfig: resolveNightlyTrackingConfig,
+    plan: planCombinedTracking,
+  });
+}