@desplega.ai/agent-swarm 1.103.0 → 1.105.0

package/templates/community/dora-metrics/report.mjs

@@ -0,0 +1,393 @@
+import fs from "node:fs";
+import path from "node:path";
+import { execFileSync } from "node:child_process";
+
+const [outDir, repoDir, repoName, runDate, branch = "main", windowDaysArg = "90", hotfixWindowArg = "24", tagPattern = "v*"] = process.argv.slice(2);
+if (!outDir || !repoDir || !repoName || !runDate) {
+  console.error("Usage: node report.mjs <outDir> <repoDir> <repoName> <runDate> [branch] [windowDays] [hotfixWindowHours] [tagPattern]");
+  process.exit(1);
+}
+
+const windowDays = Number(windowDaysArg);
+const hotfixWindowHours = Number(hotfixWindowArg);
+const now = new Date(`${runDate}T23:59:59Z`);
+const start = new Date(now.getTime() - windowDays * 24 * 60 * 60 * 1000);
+
+const CONFIG = {
+  deploymentFrequency: {
+    elitePerDay: 1,
+    highPerDay: 1 / 7,
+    mediumPerDay: 1 / 30,
+  },
+  leadTimeHours: {
+    eliteMax: 24,
+    highMax: 24 * 7,
+    mediumMax: 24 * 30,
+  },
+  changeFailureRate: {
+    eliteMax: 0.05,
+    highMax: 0.2,
+    mediumMax: 0.1,
+  },
+  failedDeploymentRecoveryHours: {
+    eliteMax: 1,
+    highMax: 24,
+    mediumMax: 24,
+  },
+};
+
+const read = (file) => fs.existsSync(file) ? fs.readFileSync(file, "utf8") : "";
+const esc = (value) => String(value ?? "")
+  .replaceAll("&", "&amp;")
+  .replaceAll("<", "&lt;")
+  .replaceAll(">", "&gt;")
+  .replaceAll('"', "&quot;");
+const hoursBetween = (a, b) => Math.max(0, (b.getTime() - a.getTime()) / 36e5);
+const fmtHours = (hours) => {
+  if (!Number.isFinite(hours)) return "n/a";
+  if (hours < 48) return `${Math.round(hours * 10) / 10}h`;
+  return `${Math.round((hours / 24) * 10) / 10}d`;
+};
+const fmtPct = (value) => `${Math.round(value * 1000) / 10}%`;
+const median = (values) => {
+  const sorted = values.filter(Number.isFinite).sort((a, b) => a - b);
+  if (!sorted.length) return null;
+  const mid = Math.floor(sorted.length / 2);
+  return sorted.length % 2 ? sorted[mid] : (sorted[mid - 1] + sorted[mid]) / 2;
+};
+const git = (args) => execFileSync("git", ["-C", repoDir, ...args], { encoding: "utf8" }).trim();
+
+function parseTsv(text, fields) {
+  return text.trim().split("\n").filter(Boolean).map((line) => {
+    const parts = line.split("\t");
+    return Object.fromEntries(fields.map((field, i) => [field, parts[i] ?? ""]));
+  });
+}
+
+function classifyDeploymentFrequency(perDay) {
+  if (perDay >= CONFIG.deploymentFrequency.elitePerDay) return "Elite";
+  if (perDay >= CONFIG.deploymentFrequency.highPerDay) return "High";
+  if (perDay >= CONFIG.deploymentFrequency.mediumPerDay) return "Medium";
+  return "Low";
+}
+
+function classifyLeadTime(hours) {
+  if (!Number.isFinite(hours)) return "Unknown";
+  if (hours < CONFIG.leadTimeHours.eliteMax) return "Elite";
+  if (hours <= CONFIG.leadTimeHours.highMax) return "High";
+  if (hours <= CONFIG.leadTimeHours.mediumMax) return "Medium";
+  return "Low";
+}
+
+function classifyChangeFailureRate(rate) {
+  if (!Number.isFinite(rate)) return "Unknown";
+  if (rate <= CONFIG.changeFailureRate.eliteMax) return "Elite";
+  if (rate <= CONFIG.changeFailureRate.mediumMax) return "Medium";
+  if (rate <= CONFIG.changeFailureRate.highMax) return "High";
+  return "Low";
+}
+
+function classifyRecovery(hours) {
+  if (!Number.isFinite(hours)) return "Unknown";
+  if (hours < CONFIG.failedDeploymentRecoveryHours.eliteMax) return "Elite";
+  if (hours <= CONFIG.failedDeploymentRecoveryHours.highMax) return "High";
+  if (hours <= CONFIG.failedDeploymentRecoveryHours.mediumMax) return "Medium";
+  return "Low";
+}
+
+function commitsBetween(fromRef, toRef) {
+  const range = fromRef ? `${fromRef}..${toRef}` : toRef;
+  const text = git(["log", range, "--format=%H%x09%ct%x09%s", "--no-merges"]);
+  return parseTsv(text, ["sha", "unix", "subject"]).map((row) => ({
+    ...row,
+    date: new Date(Number(row.unix) * 1000),
+  }));
+}
+
+const allTags = parseTsv(read(path.join(outDir, "tags.tsv")), ["name", "sha", "date", "unix"])
+  .map((tag) => ({ ...tag, at: new Date(tag.date), unix: Number(tag.unix) }))
+  .filter((tag) => tag.name && Number.isFinite(tag.unix))
+  .sort((a, b) => a.unix - b.unix);
+
+const deployments = allTags.filter((tag) => tag.at >= start && tag.at <= now);
+const leadSamples = [];
+const deploymentRows = [];
+
+for (const tag of deployments) {
+  const idx = allTags.findIndex((candidate) => candidate.name === tag.name);
+  const previous = idx > 0 ? allTags[idx - 1] : null;
+  const commits = commitsBetween(previous?.name, tag.name);
+  const samples = commits
+    .map((commit) => hoursBetween(commit.date, tag.at))
+    .filter((hours) => Number.isFinite(hours) && hours >= 0);
+  leadSamples.push(...samples);
+  deploymentRows.push({
+    tag: tag.name,
+    date: tag.date,
+    commitCount: commits.length,
+    medianLeadTimeHours: median(samples),
+    previousTag: previous?.name ?? null,
+  });
+}
+
+const remediationCommits = parseTsv(read(path.join(outDir, "remediation-commits.tsv")), ["sha", "unix", "author", "subject"])
+  .map((row) => ({ ...row, at: new Date(Number(row.unix) * 1000), source: "commit" }));
+
+const prs = JSON.parse(read(path.join(outDir, "prs.json")) || "[]");
+const hotfixPrs = prs
+  .filter((pr) => pr?.mergedAt && /(revert|rollback|hotfix|fix-forward)/i.test(pr.title ?? ""))
+  .map((pr) => ({
+    sha: `PR #${pr.number}`,
+    at: new Date(pr.mergedAt),
+    author: pr.author?.login ?? "",
+    subject: pr.title,
+    url: pr.url,
+    source: "pull-request",
+  }))
+  .filter((signal) => signal.at >= start && signal.at <= now);
+
+const remediationSignals = [...remediationCommits, ...hotfixPrs]
+  .filter((signal) => signal.at >= start && signal.at <= now)
+  .sort((a, b) => a.at - b.at);
+
+const failureSignals = [];
+const failedDeploymentNames = new Set();
+for (const signal of remediationSignals) {
+  const fixing = deployments.find((tag) => tag.at >= signal.at) ?? deployments[deployments.length - 1];
+  const failing = [...deployments].reverse().find((tag) => {
+    const diff = (signal.at.getTime() - tag.at.getTime()) / 36e5;
+    return diff >= 0 && diff <= hotfixWindowHours;
+  });
+  if (!failing || !fixing) continue;
+  if (fixing.at < signal.at) continue;
+  if (fixing.name === failing.name) continue;
+  failedDeploymentNames.add(failing.name);
+  failureSignals.push({
+    source: signal.source,
+    subject: signal.subject,
+    sha: signal.sha,
+    url: signal.url,
+    signalAt: signal.at.toISOString(),
+    failingTag: failing.name,
+    failingAt: failing.at.toISOString(),
+    fixingTag: fixing.name,
+    fixingAt: fixing.at.toISOString(),
+    recoveryHours: hoursBetween(failing.at, fixing.at),
+  });
+}
+
+const deploymentCount = deployments.length;
+const deploymentFrequencyPerDay = deploymentCount / windowDays;
+const leadTimeMedianHours = median(leadSamples);
+const changeFailureRate = deploymentCount ? failedDeploymentNames.size / deploymentCount : 0;
+const recoveryMedianHours = median(failureSignals.map((signal) => signal.recoveryHours));
+
+const metrics = {
+  deploymentFrequency: {
+    label: "Deployment Frequency",
+    quality: "EXACT",
+    value: deploymentFrequencyPerDay,
+    display: `${Math.round(deploymentFrequencyPerDay * 100) / 100}/day`,
+    band: classifyDeploymentFrequency(deploymentFrequencyPerDay),
+    detail: `${deploymentCount} ${tagPattern} deployments over ${windowDays} days`,
+    source: `${tagPattern} git tags mapped to production releases`,
+  },
+  leadTimeForChanges: {
+    label: "Lead Time for Changes",
+    quality: "EXACT",
+    valueHours: leadTimeMedianHours,
+    display: fmtHours(leadTimeMedianHours),
+    band: classifyLeadTime(leadTimeMedianHours),
+    detail: `Median across ${leadSamples.length} non-merge commits included in release tags`,
+    source: "Commit timestamp to containing release tag timestamp",
+  },
+  changeFailureRate: {
+    label: "Change Failure Rate",
+    quality: "PROXY",
+    value: changeFailureRate,
+    display: fmtPct(changeFailureRate),
+    band: classifyChangeFailureRate(changeFailureRate),
+    detail: `${failedDeploymentNames.size} failed-release proxies / ${deploymentCount} deployments`,
+    source: `Revert, rollback, hotfix, and fix-forward signals within ${hotfixWindowHours}h of a release`,
+  },
+  failedDeploymentRecoveryTime: {
+    label: "Failed Deployment Recovery Time",
+    quality: "PROXY",
+    valueHours: recoveryMedianHours,
+    display: fmtHours(recoveryMedianHours),
+    band: classifyRecovery(recoveryMedianHours),
+    detail: `${failureSignals.length} remediation signal(s) paired to release tags`,
+    source: "Time from failed-release proxy tag to fixing tag",
+  },
+};
+
+const summary = {
+  repoName,
+  runDate,
+  generatedAt: new Date().toISOString(),
+  branch,
+  window: {
+    days: windowDays,
+    start: start.toISOString(),
+    end: now.toISOString(),
+  },
+  tagPattern,
+  hotfixWindowHours,
+  commit: read(path.join(outDir, "revision.txt")).trim(),
+  commitSummary: read(path.join(outDir, "revision-summary.txt")).trim(),
+  metrics,
+  deployments: deploymentRows,
+  failureSignals,
+  notes: [
+    "Deployment Frequency and Lead Time for Changes are exact only when the configured tag pattern maps 1:1 to production releases.",
+    "Change Failure Rate and Failed Deployment Recovery Time are proxy estimates. They can miss manual incidents and can include non-incident remediation work.",
+    "Use a formal incident tracker or production deployment event stream before treating CFR/MTTR as precise operational truth.",
+  ],
+  references: {
+    doraMetrics: "https://dora.dev/guides/dora-metrics/",
+    dora2024Report: "https://dora.dev/research/2024/dora-report/",
+  },
+};
+
+fs.writeFileSync(path.join(outDir, "summary.json"), JSON.stringify(summary, null, 2));
+fs.writeFileSync(path.join(outDir, "latest-pointer.json"), JSON.stringify({
+  repoName,
+  runDate,
+  path: outDir,
+  latestJson: path.join(path.dirname(outDir), "latest.json"),
+  latestHtml: path.join(path.dirname(outDir), "latest.html"),
+  generatedAt: summary.generatedAt,
+}, null, 2));
+
+const dataJson = JSON.stringify(summary).replaceAll("</script", "<\\/script");
+const bandClass = (band) => String(band ?? "Unknown").toLowerCase();
+const metricCards = Object.values(metrics).map((metric) => `
+    <div class="metric ${esc(bandClass(metric.band))} ${esc(String(metric.quality).toLowerCase())}">
+      <span>${esc(metric.label)} <em>${esc(metric.quality)}</em></span>
+      <strong>${esc(metric.display)}</strong>
+      <b>${esc(metric.band)}</b>
+      <p>${esc(metric.detail)}</p>
+    </div>`).join("");
+
+const deploymentRowsHtml = deploymentRows.slice(-30).reverse().map((row) => `
+      <tr>
+        <td>${esc(row.tag)}</td>
+        <td>${esc(row.date)}</td>
+        <td>${esc(row.commitCount)}</td>
+        <td>${esc(fmtHours(row.medianLeadTimeHours))}</td>
+      </tr>`).join("");
+
+const failureRowsHtml = failureSignals.map((signal) => `
+      <tr>
+        <td>${esc(signal.failingTag)}</td>
+        <td>${esc(signal.fixingTag)}</td>
+        <td>${esc(fmtHours(signal.recoveryHours))}</td>
+        <td>${esc(signal.source)}</td>
+        <td>${signal.url ? `<a href="${esc(signal.url)}">${esc(signal.subject)}</a>` : esc(signal.subject)}</td>
+      </tr>`).join("") || `<tr><td colspan="5">No proxy remediation signals detected in this window.</td></tr>`;
+
+const html = `<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>DORA Metrics - ${esc(repoName)}</title>
+  <style>
+    body { margin: 0; background: #f7f6f3; color: #181817; font-family: ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif; line-height: 1.5; }
+    main { width: min(1180px, calc(100% - 32px)); margin: 0 auto; padding: 48px 0 80px; }
+    h1 { font-size: clamp(2rem, 5vw, 4rem); line-height: 1; margin: 0 0 12px; }
+    h2 { margin-top: 40px; }
+    p, .muted { color: #686660; }
+    .grid { display: grid; grid-template-columns: repeat(4, minmax(0, 1fr)); gap: 12px; margin: 28px 0; }
+    .metric, .card, .callout { background: #fff; border: 1px solid #e4ded3; border-radius: 8px; padding: 18px; }
+    .metric span { display: flex; justify-content: space-between; gap: 8px; color: #686660; font-size: 12px; font-weight: 700; text-transform: uppercase; }
+    .metric em { color: #181817; font-style: normal; }
+    .metric strong { display: block; margin-top: 8px; font-size: 30px; }
+    .metric b { display: inline-block; margin-top: 8px; padding: 2px 8px; border-radius: 999px; background: #f0ece5; font-size: 12px; text-transform: uppercase; }
+    .metric.proxy { border-color: #d4a84f; }
+    .charts { display: grid; grid-template-columns: 1fr 1fr; gap: 16px; }
+    .chart { height: 320px; }
+    svg { width: 100%; height: 100%; display: block; }
+    table { width: 100%; border-collapse: collapse; font-size: 13px; background: #fff; border: 1px solid #e4ded3; border-radius: 8px; overflow: hidden; }
+    th, td { padding: 8px 10px; border-bottom: 1px solid #eee8dc; text-align: left; vertical-align: top; }
+    th { color: #686660; font-size: 11px; text-transform: uppercase; letter-spacing: .06em; }
+    td { max-width: 520px; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+    code { background: #fff; border: 1px solid #e4ded3; padding: 1px 5px; border-radius: 4px; }
+    a { color: #8b5a00; }
+    @media (max-width: 920px) { .grid, .charts { grid-template-columns: 1fr; } }
+  </style>
+</head>
+<body>
+<main>
+  <p class="muted">Generated ${esc(summary.generatedAt)}</p>
+  <h1>DORA Metrics</h1>
+  <p><strong>${esc(repoName)}</strong> at <code>${esc(summary.commit.slice(0, 12))}</code>. Window: ${esc(summary.window.start.slice(0, 10))} to ${esc(summary.window.end.slice(0, 10))}. Release signal: <code>${esc(tagPattern)}</code> tags.</p>
+
+  <section class="grid">
+${metricCards}
+  </section>
+
+  <section class="callout">
+    <h2>Data-source reality check</h2>
+    <p>Deployment Frequency and Lead Time for Changes are <strong>exact</strong> for this configuration because release tags are treated as production deployments. Change Failure Rate and Failed Deployment Recovery Time are <strong>proxy estimates</strong> from remediation signals. They are useful for trend watching, not a substitute for incident tracking.</p>
+  </section>
+
+  <section class="charts">
+    <div class="card">
+      <h2>Deployments by week</h2>
+      <div id="deployments" class="chart"></div>
+    </div>
+    <div class="card">
+      <h2>Lead time by release</h2>
+      <div id="leadtime" class="chart"></div>
+    </div>
+  </section>
+
+  <h2>Recent deployments</h2>
+  <table>
+    <thead><tr><th>Tag</th><th>Date</th><th>Commits</th><th>Median lead time</th></tr></thead>
+    <tbody>${deploymentRowsHtml}</tbody>
+  </table>
+
+  <h2>Proxy failure signals</h2>
+  <table>
+    <thead><tr><th>Failing tag</th><th>Fixing tag</th><th>Recovery</th><th>Source</th><th>Signal</th></tr></thead>
+    <tbody>${failureRowsHtml}</tbody>
+  </table>
+
+  <h2>References</h2>
+  <ul>
+    <li><a href="https://dora.dev/guides/dora-metrics/">DORA metrics guide</a></li>
+    <li><a href="https://dora.dev/research/2024/dora-report/">2024 Accelerate State of DevOps Report</a></li>
+  </ul>
+</main>
+<script src="https://cdn.jsdelivr.net/npm/d3@7/dist/d3.min.js"></script>
+<script id="report-data" type="application/json">${dataJson}</script>
+<script>
+const data = JSON.parse(document.getElementById("report-data").textContent);
+const deployments = data.deployments.map((d) => ({ ...d, dateObj: new Date(d.date), lead: d.medianLeadTimeHours || 0 }));
+function drawBars(id, values, getX, getY) {
+  const el = document.getElementById(id);
+  const width = el.clientWidth || 520;
+  const height = el.clientHeight || 320;
+  const margin = { top: 16, right: 16, bottom: 42, left: 46 };
+  const svg = d3.select(el).append("svg").attr("viewBox", [0, 0, width, height]);
+  const x = d3.scaleBand().domain(values.map(getX)).range([margin.left, width - margin.right]).padding(0.2);
+  const y = d3.scaleLinear().domain([0, d3.max(values, getY) || 1]).nice().range([height - margin.bottom, margin.top]);
+  svg.append("g").attr("transform", "translate(0," + (height - margin.bottom) + ")").call(d3.axisBottom(x).tickValues(x.domain().filter((_, i) => i % Math.ceil(x.domain().length / 6) === 0))).selectAll("text").attr("transform", "rotate(-35)").style("text-anchor", "end");
+  svg.append("g").attr("transform", "translate(" + margin.left + ",0)").call(d3.axisLeft(y).ticks(5));
+  svg.append("g").selectAll("rect").data(values).join("rect")
+    .attr("x", (d) => x(getX(d)))
+    .attr("y", (d) => y(getY(d)))
+    .attr("width", x.bandwidth())
+    .attr("height", (d) => y(0) - y(getY(d)))
+    .attr("fill", "#b58118");
+}
+const byWeek = Array.from(d3.rollup(deployments, (v) => v.length, (d) => d3.utcFormat("%Y-W%U")(d.dateObj)), ([week, count]) => ({ week, count }));
+drawBars("deployments", byWeek, (d) => d.week, (d) => d.count);
+drawBars("leadtime", deployments.slice(-20), (d) => d.tag, (d) => d.lead);
+</script>
+</body>
+</html>`;
+
+fs.writeFileSync(path.join(outDir, "report.html"), html);

package/templates/community/dora-metrics/run.sh

@@ -0,0 +1,113 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# DORA metrics recurring report template.
+#
+# Lead kickoff prompt:
+#   See ./lead-prompt.md in this template. It is the canonical copy-paste prompt
+#   for asking an agent-swarm Lead to install this runner, run it once, publish a
+#   stable page, and schedule weekly refreshes.
+#
+# Default weekly cadence for the surrounding swarm schedule:
+#   cron: "0 22 * * 0"
+#   timezone: "UTC"
+# Change the cron field to adjust when the report refreshes. Keep the same page
+# ID when publishing so the report URL stays stable.
+#
+# Data-source note:
+#   Deployment Frequency and Lead Time for Changes are exact for repositories
+#   where v* tags map 1:1 to production releases. Change Failure Rate and Failed
+#   Deployment Recovery Time are proxy estimates from revert/hotfix signals.
+
+BASE_DIR="${BASE_DIR:-/workspace/dora-metrics}"
+REPO_NAME="${REPO_NAME:-my-repo}"
+REPO_URL="${REPO_URL:-https://github.com/OWNER/REPO.git}"
+BRANCH="${BRANCH:-main}"
+LOCAL_SOURCE="${LOCAL_SOURCE:-}"
+WINDOW_DAYS="${WINDOW_DAYS:-90}"
+HOTFIX_WINDOW_HOURS="${HOTFIX_WINDOW_HOURS:-24}"
+TAG_PATTERN="${TAG_PATTERN:-v*}"
+
+REPO_DIR="$BASE_DIR/repos/$REPO_NAME"
+OUT_ROOT="$BASE_DIR/out/$REPO_NAME"
+RUN_DATE="${RUN_DATE:-$(date -u +%F)}"
+OUT_DIR="$OUT_ROOT/$RUN_DATE"
+
+mkdir -p "$BASE_DIR/repos" "$OUT_DIR"
+
+need_cmd() {
+  command -v "$1" >/dev/null 2>&1
+}
+
+ensure_cmd() {
+  local cmd="$1"
+  local pkg="${2:-$1}"
+  if ! need_cmd "$cmd"; then
+    sudo apt-get update
+    sudo apt-get install -y "$pkg"
+  fi
+}
+
+prepare_repo() {
+  if [ -d "$REPO_DIR/.git" ]; then
+    git -C "$REPO_DIR" remote set-url --push origin DISABLED >/dev/null 2>&1 || true
+    git -C "$REPO_DIR" fetch origin "$BRANCH" --prune
+    git -C "$REPO_DIR" fetch origin "refs/tags/$TAG_PATTERN:refs/tags/$TAG_PATTERN" --prune --force || true
+    git -C "$REPO_DIR" checkout -q "$BRANCH" || git -C "$REPO_DIR" checkout -q -B "$BRANCH" "origin/$BRANCH"
+    git -C "$REPO_DIR" reset --hard "origin/$BRANCH" >/dev/null
+    git -C "$REPO_DIR" clean -fdx >/dev/null
+    return
+  fi
+
+  if [ -n "$LOCAL_SOURCE" ] && [ -d "$LOCAL_SOURCE/.git" ]; then
+    git clone --no-hardlinks "$LOCAL_SOURCE" "$REPO_DIR"
+    git -C "$REPO_DIR" remote set-url origin "$REPO_URL" || true
+    git -C "$REPO_DIR" remote set-url --push origin DISABLED || true
+    git -C "$REPO_DIR" fetch origin "$BRANCH" --prune
+    git -C "$REPO_DIR" fetch origin "refs/tags/$TAG_PATTERN:refs/tags/$TAG_PATTERN" --prune --force || true
+    git -C "$REPO_DIR" checkout -q "$BRANCH" || git -C "$REPO_DIR" checkout -q -B "$BRANCH" "origin/$BRANCH"
+    git -C "$REPO_DIR" reset --hard "origin/$BRANCH" >/dev/null
+  else
+    git clone --branch "$BRANCH" "$REPO_URL" "$REPO_DIR"
+    git -C "$REPO_DIR" remote set-url --push origin DISABLED || true
+    git -C "$REPO_DIR" fetch origin "refs/tags/$TAG_PATTERN:refs/tags/$TAG_PATTERN" --prune --force || true
+  fi
+}
+
+write_pr_metadata() {
+  local slug
+  slug="$(printf '%s\n' "$REPO_URL" | sed -E 's#^git@github.com:##; s#^https://github.com/##; s#\.git$##')"
+  if need_cmd gh && gh auth status >/dev/null 2>&1 && printf '%s\n' "$slug" | grep -Eq '^[^/]+/[^/]+$'; then
+    gh pr list \
+      --repo "$slug" \
+      --state merged \
+      --base "$BRANCH" \
+      --limit 1000 \
+      --json number,title,mergedAt,url,author,headRefName \
+      > "$OUT_DIR/prs.json" || printf '[]\n' > "$OUT_DIR/prs.json"
+  else
+    printf '[]\n' > "$OUT_DIR/prs.json"
+  fi
+}
+
+ensure_cmd git git
+ensure_cmd jq jq
+ensure_cmd node nodejs
+prepare_repo
+
+git -C "$REPO_DIR" rev-parse HEAD > "$OUT_DIR/revision.txt"
+git -C "$REPO_DIR" log -1 --format='%h %ad %an %s' --date=short > "$OUT_DIR/revision-summary.txt"
+git -C "$REPO_DIR" for-each-ref "refs/tags/$TAG_PATTERN" --sort=creatordate --format='%(refname:short)%09%(objectname)%09%(creatordate:iso-strict)%09%(creatordate:unix)' > "$OUT_DIR/tags.tsv"
+git -C "$REPO_DIR" log "origin/$BRANCH" --since="$WINDOW_DAYS days ago" --format='%H%x09%ct%x09%an%x09%s' > "$OUT_DIR/recent-commits.tsv"
+git -C "$REPO_DIR" log "origin/$BRANCH" --since="$WINDOW_DAYS days ago" --grep='revert' --grep='rollback' --grep='hotfix' --grep='fix-forward' --regexp-ignore-case --format='%H%x09%ct%x09%an%x09%s' > "$OUT_DIR/remediation-commits.tsv"
+write_pr_metadata
+
+node "$BASE_DIR/report.mjs" "$OUT_DIR" "$REPO_DIR" "$REPO_NAME" "$RUN_DATE" "$BRANCH" "$WINDOW_DAYS" "$HOTFIX_WINDOW_HOURS" "$TAG_PATTERN"
+
+cp "$OUT_DIR/summary.json" "$OUT_ROOT/latest.json"
+cp "$OUT_DIR/report.html" "$OUT_ROOT/latest.html"
+cp "$OUT_DIR/latest-pointer.json" "$OUT_ROOT/latest-pointer.json"
+
+echo "Wrote $OUT_DIR"
+echo "Latest summary: $OUT_ROOT/latest.json"
+echo "Latest page HTML: $OUT_ROOT/latest.html"

package/templates/schedules/weekly-dora-metrics/config.json

@@ -0,0 +1,13 @@
+{
+  "kind": "schedule",
+  "name": "weekly-dora-metrics",
+  "displayName": "Weekly DORA Metrics",
+  "slug": "weekly-dora-metrics",
+  "title": "Weekly DORA Metrics",
+  "description": "Gallery entry point for the community DORA metrics report package. Run a weekly DORA report and update a stable page in place.",
+  "version": "1.0.0",
+  "category": "schedules",
+  "placeholders": ["REPO_URL", "BRANCH", "TAG_PATTERN", "REPORT_NAME", "PAGE_ID", "TIMEZONE"],
+  "runAllSeedersCandidate": false,
+  "tags": ["dora", "metrics", "engineering-productivity", "reporting", "community-template"]
+}

package/templates/schedules/weekly-dora-metrics/content.md

@@ -0,0 +1,61 @@
+# Weekly DORA Metrics
+
+Run a recurring DORA metrics report for a repository and update the same stable report page in place.
+
+This schedule is the templates gallery entry point for the community package in `templates/community/dora-metrics/`. The package itself is intentionally not an agent-template config; it is a runnable playbook bundle (`PLAYBOOK.md`, `run.sh`, `report.mjs`, and `lead-prompt.md`) used by this schedule.
+
+## Schedule
+
+```json
+{
+  "cron": "0 22 * * 0",
+  "timezone": "UTC",
+  "agentRole": "worker",
+  "enabled": true
+}
+```
+
+## Scheduled Task
+
+This is a reusable starting prompt. Before enabling it, replace the repository, branch, release tag pattern, report name, page ID, timezone, and worker targeting details with values for your project.
+
+Task Type: Weekly DORA Metrics
+
+Repository: `https://github.com/OWNER/REPO.git`
+Default branch: `main`
+Release tag pattern: `v*`
+Report name: `my-repo`
+Stable page ID: `<PAGE_ID>`
+
+## Instructions
+
+1. Use the community template in `templates/community/dora-metrics/`. See the docs playbook at `https://docs.agent-swarm.dev/docs/playbooks/dora-metrics` for the full setup, metric-definition notes, and proxy caveats.
+2. Install or update the runner workspace under `/workspace/dora-metrics`:
+   - `run.sh`
+   - `report.mjs`
+   - `lead-prompt.md`
+3. Run the report with project-specific parameters:
+
+   ```bash
+   BASE_DIR=/workspace/dora-metrics \
+   REPO_NAME=my-repo \
+   REPO_URL=https://github.com/OWNER/REPO.git \
+   BRANCH=main \
+   TAG_PATTERN='v*' \
+   WINDOW_DAYS=90 \
+   bash /workspace/dora-metrics/run.sh
+   ```
+
+4. Publish `/workspace/dora-metrics/out/my-repo/latest.html` to the existing stable page ID. Do not create a new page for routine refreshes.
+5. Verify the rendered page loads, D3 charts are not blank, and the exact/proxy labels are visible.
+6. If the run fails because of a local runner, dependency, branch, tag-pattern, or report-generator issue, diagnose and fix it before reporting failure.
+
+## Cadence
+
+The default cron is `0 22 * * 0`, weekly on Sunday at 22:00 UTC. Change the `cron` field to adjust when the report refreshes, and change `timezone` if the cron should be interpreted in a different zone.
+
+The cadence is separate from page identity. Keep updating the same page ID so the report URL remains stable.
+
+## Completion
+
+Call `store-progress` with status `completed` and an output summary that includes the stable page URL, report workspace path, commit analyzed, generated timestamp, and the data-source caveat: Deployment Frequency and Lead Time are exact from release tags/commits; Change Failure Rate and Failed Deployment Recovery Time are proxy estimates from revert/hotfix-style remediation signals.