@akshatmittal/invoker 0.1.0 → 0.3.0

package/dist/slack.mjs

@@ -0,0 +1,482 @@
+import { z } from "zod";
+import { WebAPIRateLimitedError, WebClient } from "@slack/web-api";
+import { setTimeout } from "node:timers/promises";
+//#region src/slack/report.ts
+const stringSchema = z.string();
+const jsonObjectSchema = z.record(stringSchema, z.json());
+const invokerMetaSchema = z.strictObject({
+	schema: z.literal(1),
+	matrix: jsonObjectSchema,
+	metadata: jsonObjectSchema.optional(),
+	output: z.json().optional()
+});
+const testMetaSchema = z.object({ invoker: invokerMetaSchema.optional() });
+const errorMessageSchema = z.object({ message: stringSchema });
+const errorStackSchema = z.object({ stack: stringSchema });
+const TABLE_ROW_LIMIT = 100;
+const TABLE_CHARACTER_LIMIT = 1e4;
+const SECTION_CHARACTER_LIMIT = 3e3;
+const NAME_CHARACTER_LIMIT = 200;
+const METADATA_CHARACTER_LIMIT = 1800;
+function collectWorkflowReports(modules) {
+	const workflows = /* @__PURE__ */ new Map();
+	for (const module of modules) for (const testCase of module.children.allTests()) {
+		const meta = testMetaSchema.safeParse(testCase.meta());
+		const invoker = meta.success ? meta.data.invoker : void 0;
+		const taskSuite = testCase.parent;
+		const workflowSuite = taskSuite.type === "suite" ? taskSuite.parent : void 0;
+		if (!invoker || taskSuite.type !== "suite" || workflowSuite?.type !== "suite") continue;
+		let workflow = workflows.get(workflowSuite);
+		if (!workflow) {
+			workflow = {
+				name: workflowSuite.name,
+				module,
+				suite: workflowSuite,
+				metadata: invoker.metadata,
+				tasks: /* @__PURE__ */ new Map()
+			};
+			workflows.set(workflowSuite, workflow);
+		}
+		let task = workflow.tasks.get(taskSuite);
+		if (!task) {
+			task = {
+				name: taskSuite.name,
+				suite: taskSuite,
+				total: 0,
+				passed: 0,
+				retried: 0,
+				failed: 0,
+				skipped: 0,
+				incomplete: 0,
+				failures: [],
+				retries: []
+			};
+			workflow.tasks.set(taskSuite, task);
+		}
+		task.total += 1;
+		const result = testCase.result();
+		const diagnostic = testCase.diagnostic();
+		task[result.state === "pending" ? "incomplete" : result.state] += 1;
+		const retryCount = diagnostic?.retryCount ?? 0;
+		if (retryCount > 0) {
+			task.retried += 1;
+			if (result.state === "passed") task.retries.push({
+				task: task.name,
+				caseName: testCase.name,
+				matrix: invoker.matrix,
+				count: retryCount,
+				messages: (result.errors ?? []).map(errorMessage)
+			});
+		}
+		if (diagnostic) {
+			task.startedAt = Math.min(task.startedAt ?? diagnostic.startTime, diagnostic.startTime);
+			task.endedAt = Math.max(task.endedAt ?? 0, diagnostic.startTime + diagnostic.duration);
+		}
+		if (result.state === "failed") task.failures.push({
+			task: task.name,
+			caseName: testCase.name,
+			matrix: invoker.matrix,
+			messages: result.errors.map(errorMessage)
+		});
+	}
+	return [...workflows.values()].map((workflow) => {
+		const failures = [];
+		const retries = [];
+		addErrors(failures, workflow.suite.errors());
+		addErrors(failures, workflow.module.errors());
+		const collectedTasks = [...workflow.tasks.values()];
+		for (const task of collectedTasks) {
+			failures.push(...task.failures);
+			retries.push(...task.retries);
+			addErrors(failures, task.suite.errors(), task.name);
+		}
+		const { startedAt, endedAt } = timeSpan(collectedTasks);
+		return {
+			name: workflow.name,
+			metadata: workflow.metadata,
+			tasks: collectedTasks.map(({ suite: _suite, failures: _failures, retries: _retries, startedAt, endedAt, ...task }) => ({
+				...task,
+				duration: startedAt === void 0 || endedAt === void 0 ? 0 : endedAt - startedAt
+			})),
+			failures: deduplicateFailures(failures),
+			retries,
+			startedAt,
+			endedAt
+		};
+	});
+}
+function summaryMessage(reports, runUrl) {
+	const timestamp = Math.floor(Date.now() / 1e3);
+	const { startedAt, endedAt } = timeSpan(reports);
+	const footer = [
+		`Elapsed: ${formatDuration(startedAt === void 0 || endedAt === void 0 ? 0 : endedAt - startedAt)}`,
+		`<!date^${timestamp}^{date_short_pretty} at {time}|${(/* @__PURE__ */ new Date(timestamp * 1e3)).toISOString()}>`,
+		...runUrl ? [`<${escapeSlackControl(runUrl)}|View run>`] : []
+	].join(" • ");
+	return {
+		text: "Invoker Report",
+		attachments: [...reports.flatMap(workflowAttachments), { blocks: [{
+			type: "context",
+			elements: [{
+				type: "mrkdwn",
+				text: footer
+			}]
+		}] }]
+	};
+}
+function workflowAttachments(report) {
+	const tables = taskTables(report.tasks);
+	return tables.map((rows, index) => workflowAttachment(report, rows, index, tables.length));
+}
+function workflowAttachment(report, rows, index, pages) {
+	const totals = taskTotals(report.tasks);
+	const status = workflowStatus(report);
+	const metadata = metadataText(report.metadata);
+	const page = pages > 1 ? ` (${index + 1}/${pages})` : "";
+	const headline = `${status.emoji} *${escapeSlack(truncate(report.name, NAME_CHARACTER_LIMIT))} — ${totals.passed}/${totals.total} passed${page}*`;
+	return {
+		color: status.color,
+		blocks: [
+			{
+				type: "section",
+				text: {
+					type: "mrkdwn",
+					text: headline
+				}
+			},
+			...metadata ? [{
+				type: "context",
+				elements: [{
+					type: "mrkdwn",
+					text: metadata
+				}]
+			}] : [],
+			{
+				type: "table",
+				column_settings: [
+					{ is_wrapped: true },
+					{ align: "right" },
+					{ align: "right" },
+					{ align: "right" },
+					{ align: "right" },
+					{ align: "right" }
+				],
+				rows
+			}
+		]
+	};
+}
+function failureMessages(report) {
+	return [...Map.groupBy(report.failures, (failure) => failure.task)].flatMap(([task, failures]) => {
+		const title = escapeSlack(truncate(task ?? "Workflow errors", NAME_CHARACTER_LIMIT));
+		const workflow = `*Workflow:* ${escapeSlack(truncate(report.name, NAME_CHARACTER_LIMIT))}`;
+		const metadata = metadataText(report.metadata);
+		const context = metadata ? `${workflow}  •  ${metadata}` : workflow;
+		return chunk(failures.map((failure) => {
+			return `${failure.caseName ? `*${escapeSlack(failure.caseName)}*` : task ? "*Task error*" : "*Workflow error*"}${failure.matrix ? `\nMatrix: ${escapeSlack(JSON.stringify(failure.matrix))}` : ""}${failure.messages.map((message) => `\n• ${escapeSlack(message)}`).join("")}`;
+		}), 3e3).map((details, index, messages) => {
+			const part = messages.length > 1 ? ` (${index + 1}/${messages.length})` : "";
+			return {
+				text: `${truncate(report.name, NAME_CHARACTER_LIMIT)} › ${truncate(task ?? "Workflow", NAME_CHARACTER_LIMIT)} — ${failures.length} failed${part}`,
+				attachments: [{
+					color: "danger",
+					blocks: [
+						{
+							type: "section",
+							text: {
+								type: "mrkdwn",
+								text: `🔴 *${title} — ${failures.length} failed${part}*`
+							}
+						},
+						{
+							type: "context",
+							elements: [{
+								type: "mrkdwn",
+								text: context
+							}]
+						},
+						{
+							type: "section",
+							text: {
+								type: "mrkdwn",
+								text: details
+							}
+						}
+					]
+				}]
+			};
+		});
+	});
+}
+function retryMessages(report) {
+	return [...Map.groupBy(report.retries, (retry) => retry.task)].flatMap(([task, retries]) => {
+		const title = escapeSlack(truncate(task, NAME_CHARACTER_LIMIT));
+		const workflow = `*Workflow:* ${escapeSlack(truncate(report.name, NAME_CHARACTER_LIMIT))}`;
+		const metadata = metadataText(report.metadata);
+		const context = metadata ? `${workflow}  •  ${metadata}` : workflow;
+		return chunk(retries.map((retry) => {
+			const matrix = `\nMatrix: ${escapeSlack(JSON.stringify(retry.matrix))}`;
+			const messages = retry.messages.map((message) => `\n• ${escapeSlack(message)}`).join("");
+			return `*${escapeSlack(retry.caseName)}*\nRetries: ${retry.count}${matrix}${messages}`;
+		}), SECTION_CHARACTER_LIMIT).map((details, index, messages) => {
+			const part = messages.length > 1 ? ` (${index + 1}/${messages.length})` : "";
+			return {
+				text: `${truncate(report.name, NAME_CHARACTER_LIMIT)} › ${truncate(task, NAME_CHARACTER_LIMIT)} — ${retries.length} retried${part}`,
+				attachments: [{
+					color: "warning",
+					blocks: [
+						{
+							type: "section",
+							text: {
+								type: "mrkdwn",
+								text: `🟡 *${title} — ${retries.length} retried${part}*`
+							}
+						},
+						{
+							type: "context",
+							elements: [{
+								type: "mrkdwn",
+								text: context
+							}]
+						},
+						{
+							type: "section",
+							text: {
+								type: "mrkdwn",
+								text: details
+							}
+						}
+					]
+				}]
+			};
+		});
+	});
+}
+function unhandledErrorMessages(errors) {
+	const messages = [...new Set(errors.map(errorMessage))];
+	return chunk(messages.map((message) => `• ${escapeSlack(message)}`), SECTION_CHARACTER_LIMIT).map((details, index, chunks) => {
+		const part = chunks.length > 1 ? ` (${index + 1}/${chunks.length})` : "";
+		return {
+			text: `Invoker run — ${messages.length} unhandled error${messages.length === 1 ? "" : "s"}${part}`,
+			attachments: [{
+				color: "danger",
+				blocks: [{
+					type: "section",
+					text: {
+						type: "mrkdwn",
+						text: `🔴 *Run errors${part}*`
+					}
+				}, {
+					type: "section",
+					text: {
+						type: "mrkdwn",
+						text: details
+					}
+				}]
+			}]
+		};
+	});
+}
+function addErrors(failures, errors, task) {
+	const messages = errors.map(errorMessage);
+	if (messages.length > 0) failures.push({
+		task,
+		messages
+	});
+}
+function errorMessage(cause) {
+	const message = errorMessageSchema.safeParse(cause);
+	if (message.success) return message.data.message;
+	const stack = errorStackSchema.safeParse(cause);
+	if (stack.success) return stack.data.stack.split("\n", 1)[0];
+	return String(cause);
+}
+function deduplicateFailures(failures) {
+	const seen = /* @__PURE__ */ new Set();
+	return failures.flatMap((failure) => {
+		const messages = failure.messages.filter((message) => {
+			const key = JSON.stringify([
+				failure.task,
+				failure.caseName,
+				failure.matrix,
+				message
+			]);
+			if (seen.has(key)) return false;
+			seen.add(key);
+			return true;
+		});
+		return messages.length > 0 ? [{
+			...failure,
+			messages
+		}] : [];
+	});
+}
+function escapeSlack(value) {
+	return escapeSlackControl(value).replaceAll("*", "∗").replaceAll("_", "＿").replaceAll("~", "∼").replaceAll("`", "ˋ");
+}
+function escapeSlackControl(value) {
+	return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+}
+function taskTotals(tasks) {
+	return tasks.reduce((totals, task) => ({
+		total: totals.total + task.total,
+		passed: totals.passed + task.passed
+	}), {
+		total: 0,
+		passed: 0
+	});
+}
+function workflowStatus(report) {
+	if (report.failures.length > 0 || report.tasks.some((task) => task.failed > 0)) return {
+		emoji: "🔴",
+		color: "danger"
+	};
+	if (report.tasks.some((task) => task.retried > 0 || task.skipped > 0 || task.incomplete > 0)) return {
+		emoji: "🟡",
+		color: "warning"
+	};
+	return {
+		emoji: "🟢",
+		color: "good"
+	};
+}
+function metadataText(metadata) {
+	if (!metadata || Object.keys(metadata).length === 0) return void 0;
+	return truncate(Object.entries(metadata).map(([key, value]) => {
+		const string = stringSchema.safeParse(value);
+		return `*${escapeSlack(key)}:* ${escapeSlack(string.success ? string.data : JSON.stringify(value))}`;
+	}).join("  •  "), METADATA_CHARACTER_LIMIT);
+}
+function rawCell(text) {
+	return {
+		type: "raw_text",
+		text
+	};
+}
+function taskTables(tasks) {
+	const header = [
+		"Task",
+		"Passed",
+		"Retries",
+		"Failed",
+		"Skipped",
+		"Time"
+	].map(rawCell);
+	const headerCharacters = rowCharacters(header);
+	const tables = [];
+	let rows = [header];
+	let characters = headerCharacters;
+	for (const task of tasks) {
+		const values = [
+			String(task.passed),
+			String(task.retried),
+			String(task.failed),
+			String(task.skipped),
+			formatDuration(task.duration)
+		];
+		const taskNameLimit = TABLE_CHARACTER_LIMIT - headerCharacters - values.reduce((total, value) => total + value.length, 0);
+		const row = [truncate(task.name, taskNameLimit), ...values].map(rawCell);
+		const rowLength = rowCharacters(row);
+		if (rows.length === TABLE_ROW_LIMIT || characters + rowLength > TABLE_CHARACTER_LIMIT) {
+			tables.push(rows);
+			rows = [header];
+			characters = headerCharacters;
+		}
+		rows.push(row);
+		characters += rowLength;
+	}
+	tables.push(rows);
+	return tables;
+}
+function rowCharacters(row) {
+	return row.reduce((total, cell) => total + cell.text.length, 0);
+}
+function formatDuration(milliseconds) {
+	if (milliseconds < 1e3) return `${Math.round(milliseconds)}ms`;
+	return `${(milliseconds / 1e3).toFixed(1)}s`;
+}
+function chunk(entries, limit) {
+	const chunks = [];
+	for (const entry of entries) {
+		const value = entry.length > limit ? `${entry.slice(0, limit - 1)}…` : entry;
+		const previous = chunks.at(-1);
+		if (previous && previous.length + value.length + 2 <= limit) chunks[chunks.length - 1] = `${previous}\n\n${value}`;
+		else chunks.push(value);
+	}
+	return chunks;
+}
+function truncate(value, limit) {
+	return value.length > limit ? `${value.slice(0, limit - 1)}…` : value;
+}
+function timeSpan(values) {
+	let startedAt;
+	let endedAt;
+	for (const value of values) {
+		if (value.startedAt !== void 0) startedAt = Math.min(startedAt ?? value.startedAt, value.startedAt);
+		if (value.endedAt !== void 0) endedAt = Math.max(endedAt ?? value.endedAt, value.endedAt);
+	}
+	return {
+		startedAt,
+		endedAt
+	};
+}
+//#endregion
+//#region src/slack/reporter.ts
+function slackReporter(options) {
+	const client = new WebClient(options.token, {
+		rejectRateLimitedCalls: true,
+		retryConfig: { retries: 0 },
+		timeout: 1e4
+	});
+	const postMessage = async (arguments_) => {
+		try {
+			return await client.chat.postMessage(arguments_);
+		} catch (error) {
+			if (!(error instanceof WebAPIRateLimitedError)) throw error;
+			await setTimeout(error.retryAfter * 1e3);
+			return client.chat.postMessage(arguments_);
+		}
+	};
+	return { async onTestRunEnd(modules, unhandledErrors) {
+		const reports = collectWorkflowReports(modules);
+		if (reports.length === 0) return;
+		const parentMessage = summaryMessage(reports, options.runUrl);
+		let parentTimestamp;
+		try {
+			const parentArguments = {
+				channel: options.channel,
+				...parentMessage,
+				mrkdwn: false,
+				unfurl_links: false
+			};
+			parentTimestamp = (await postMessage(parentArguments)).ts;
+		} catch {
+			console.warn("[invoker] Could not post the Slack report.");
+			return;
+		}
+		const replies = [
+			...reports.flatMap(failureMessages),
+			...reports.flatMap(retryMessages),
+			...unhandledErrorMessages(unhandledErrors)
+		];
+		if (replies.length > 0 && !parentTimestamp) {
+			console.warn("[invoker] Slack did not return a timestamp for the report thread.");
+			return;
+		}
+		let failedMessages = 0;
+		for (const reply of replies) try {
+			await postMessage({
+				channel: options.channel,
+				...reply,
+				thread_ts: parentTimestamp,
+				mrkdwn: false,
+				unfurl_links: false
+			});
+		} catch {
+			failedMessages += 1;
+		}
+		if (failedMessages > 0) console.warn(`[invoker] Could not post ${failedMessages} Slack report message${failedMessages === 1 ? "" : "s"}.`);
+	} };
+}
+//#endregion
+export { slackReporter };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akshatmittal/invoker",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "Typed matrix-driven regression workflows for Vitest.",
   "keywords": [
     "matrix",
@@ -27,11 +27,27 @@
     ".": {
       "types": "./dist/index.d.mts",
       "import": "./dist/index.mjs"
+    },
+    "./github": {
+      "types": "./dist/github.d.mts",
+      "import": "./dist/github.mjs"
+    },
+    "./slack": {
+      "types": "./dist/slack.d.mts",
+      "import": "./dist/slack.mjs"
     }
   },
   "publishConfig": {
     "access": "public"
   },
+  "dependencies": {
+    "@octokit/auth-app": "^8.3.0",
+    "@octokit/request": "^10.0.13",
+    "@slack/web-api": "^8.0.0",
+    "croner": "^10.0.1",
+    "evlog": "^2.26.0",
+    "zod": "^4.4.3"
+  },
   "devDependencies": {
     "@types/node": "^24.13.3",
     "tsdown": "^0.22.14",
@@ -42,6 +58,11 @@
   "peerDependencies": {
     "vitest": "^4.1.10"
   },
+  "peerDependenciesMeta": {
+    "vitest": {
+      "optional": true
+    }
+  },
   "engines": {
     "node": "^24.18.1"
   },