@keystrokehq/cli 0.0.1

package/dist/validate.handler-DOcTaJL0.mjs

@@ -0,0 +1,280 @@
+#!/usr/bin/env node
+
+import { D as throwReportedCliExit, h as toErrorMessage, t as ui } from "./keystroke.mjs";
+import { d as trackProject } from "./dist-CUK7yBM0.mjs";
+import { i as writeJson } from "./output-DM4b7KgY.mjs";
+import { t as requireWorkflowsDir } from "./resolve-project-DDJ29sCF.mjs";
+import { s as build, t as WorkflowNotFoundError } from "./workflow-build-DBQaBfnn.mjs";
+import { t as createBuildProgress } from "./build-progress-DgYKb4hB.mjs";
+import { mkdtemp, rm } from "node:fs/promises";
+import * as os from "node:os";
+import * as path$1 from "node:path";
+//#region src/commands/workflows/validate/workflow-validate.ts
+/**
+* workflow-validate.ts
+*
+* Validation-only build: runs analysis phases without
+* writing any permanent output artifacts. Uses a temp dir cleaned up afterwards.
+*/
+var WorkflowValidationFailedError = class extends Error {
+	result;
+	constructor(result) {
+		super(`Validation failed with ${result.errorCount} error(s).`);
+		this.name = "WorkflowValidationFailedError";
+		this.result = result;
+	}
+};
+async function runWorkflowValidate(options) {
+	const startTime = Date.now();
+	const tmpDir = await mkdtemp(path$1.join(os.tmpdir(), "keystroke-validate-"));
+	let buildResult;
+	try {
+		buildResult = await build({
+			projectRoot: options.workflowsDir,
+			outDir: tmpDir,
+			force: true,
+			onProgressEvent: options.onProgressEvent
+		});
+	} finally {
+		await rm(tmpDir, {
+			recursive: true,
+			force: true
+		});
+	}
+	const totalMs = Date.now() - startTime;
+	let result = mapBuildResultToValidateResult(buildResult, totalMs);
+	result = filterValidationResult(result, options.workflow);
+	if (!result.success) throw new WorkflowValidationFailedError(result);
+	return result;
+}
+function mapBuildResultToValidateResult(buildResult, totalMs) {
+	const workflowMap = /* @__PURE__ */ new Map();
+	for (const artifact of buildResult.artifacts) workflowMap.set(artifact.manifest.id, {
+		id: artifact.manifest.id,
+		name: artifact.manifest.name,
+		filePath: artifact.workflow.resolvedFilePath,
+		issues: []
+	});
+	for (const failure of buildResult.failures) appendFailureIssue(workflowMap, failure);
+	if (buildResult.warnings.length > 0) workflowMap.set("__project__", {
+		name: "project",
+		filePath: "",
+		issues: buildResult.warnings.map((warning) => ({
+			severity: "warning",
+			message: warning,
+			type: "other"
+		}))
+	});
+	const workflows = [...workflowMap.values()];
+	const errorCount = workflows.reduce((count, workflow) => count + workflow.issues.filter((issue) => issue.severity === "error").length, 0);
+	const warningCount = workflows.reduce((count, workflow) => count + workflow.issues.filter((issue) => issue.severity === "warning").length, 0);
+	return {
+		success: errorCount === 0,
+		workflows,
+		errorCount,
+		warningCount,
+		totalMs
+	};
+}
+function appendFailureIssue(workflowMap, failure) {
+	if (failure.kind === "workflow" || failure.kind === "loader-protocol") {
+		const key = failure.workflow.resolvedFilePath;
+		const existing = workflowMap.get(key) ?? workflowMap.get(failure.workflow.workflowId ?? "") ?? createWorkflowValidateStats({
+			id: failure.workflow.workflowId,
+			name: path$1.basename(failure.workflow.resolvedFilePath, path$1.extname(failure.workflow.resolvedFilePath)),
+			filePath: failure.workflow.resolvedFilePath
+		});
+		existing.issues.push({
+			severity: "error",
+			file: failure.workflow.resolvedFilePath,
+			message: failure.error,
+			type: "analysis"
+		});
+		workflowMap.set(key, existing);
+		return;
+	}
+	if (failure.kind === "duplicate-workflow-id") {
+		const key = `duplicate:${failure.workflowId}`;
+		const existing = workflowMap.get(key) ?? createWorkflowValidateStats({
+			id: failure.workflowId,
+			name: failure.workflowId,
+			filePath: failure.files[0] ?? ""
+		});
+		existing.issues.push({
+			severity: "error",
+			file: failure.files[0],
+			message: failure.error,
+			type: "analysis"
+		});
+		workflowMap.set(key, existing);
+		return;
+	}
+	if (failure.kind === "duplicate-agent-id") {
+		const key = `duplicate-agent:${failure.agentId}`;
+		const existing = workflowMap.get(key) ?? createWorkflowValidateStats({
+			name: failure.agentId,
+			filePath: failure.files[0] ?? ""
+		});
+		existing.issues.push({
+			severity: "error",
+			file: failure.files[0],
+			message: failure.error,
+			type: "analysis"
+		});
+		workflowMap.set(key, existing);
+		return;
+	}
+	if (failure.kind === "agent-cycle") {
+		const key = `agent-cycle:${failure.cyclePath.join(">")}`;
+		const existing = workflowMap.get(key) ?? createWorkflowValidateStats({
+			name: "Agent cycle",
+			filePath: ""
+		});
+		existing.issues.push({
+			severity: "error",
+			file: void 0,
+			message: failure.error,
+			type: "analysis"
+		});
+		workflowMap.set(key, existing);
+		return;
+	}
+	if (failure.kind === "trigger") {
+		const key = `trigger:${failure.workflowId}:${failure.triggerExportName}`;
+		const existing = workflowMap.get(key) ?? createWorkflowValidateStats({
+			name: failure.triggerName,
+			filePath: ""
+		});
+		existing.issues.push({
+			severity: "error",
+			file: void 0,
+			message: failure.error,
+			type: "analysis"
+		});
+		workflowMap.set(key, existing);
+		return;
+	}
+	if (failure.kind === "task") {
+		const key = `task:${failure.task.taskId}`;
+		const existing = workflowMap.get(key) ?? createWorkflowValidateStats({
+			name: failure.task.taskId,
+			filePath: failure.task.resolvedFilePath
+		});
+		existing.issues.push({
+			severity: "error",
+			file: failure.task.resolvedFilePath,
+			message: failure.error,
+			type: "analysis"
+		});
+		workflowMap.set(key, existing);
+		return;
+	}
+	if (failure.kind === "agent") {
+		const key = `agent:${failure.agent.agentId}`;
+		const existing = workflowMap.get(key) ?? createWorkflowValidateStats({
+			name: failure.agent.agentName,
+			filePath: failure.agent.resolvedFilePath
+		});
+		existing.issues.push({
+			severity: "error",
+			file: failure.agent.resolvedFilePath,
+			message: failure.error,
+			type: "analysis"
+		});
+		workflowMap.set(key, existing);
+		return;
+	}
+	const filePath = "filePath" in failure ? failure.filePath : "";
+	const key = `discovery:${filePath}`;
+	const existing = workflowMap.get(key) ?? createWorkflowValidateStats({
+		name: path$1.basename(filePath, path$1.extname(filePath)),
+		filePath
+	});
+	existing.issues.push({
+		severity: "error",
+		file: filePath,
+		message: failure.error,
+		type: "analysis"
+	});
+	workflowMap.set(key, existing);
+}
+function createWorkflowValidateStats(stats) {
+	return {
+		id: stats.id,
+		name: stats.name,
+		filePath: stats.filePath,
+		issues: []
+	};
+}
+function filterValidationResult(result, workflowRef) {
+	if (!workflowRef) return result;
+	const matching = result.workflows.filter((workflow) => workflow.id === workflowRef || workflow.name === workflowRef || path$1.basename(workflow.filePath, path$1.extname(workflow.filePath)) === workflowRef);
+	if (matching.length === 0) {
+		const availableNames = result.workflows.map((workflow) => workflow.name).filter((name) => name !== "project");
+		const availableIds = result.workflows.map((workflow) => workflow.id).filter((id) => id !== void 0);
+		throw new WorkflowNotFoundError(workflowRef, availableNames.length > 0 ? availableNames : availableIds);
+	}
+	return {
+		...result,
+		success: matching.every((workflow) => workflow.issues.every((issue) => issue.severity !== "error")),
+		workflows: matching,
+		errorCount: matching.reduce((count, workflow) => count + workflow.issues.filter((issue) => issue.severity === "error").length, 0),
+		warningCount: matching.reduce((count, workflow) => count + workflow.issues.filter((issue) => issue.severity === "warning").length, 0)
+	};
+}
+function renderValidateHeader(name) {
+	if (name) ui.header(`Validating workflow "${name}"...`);
+	else ui.header("Validating workflows...");
+}
+function renderValidateSummary(result) {
+	if (result.success) {
+		const workflowLabel = result.workflows.length === 1 ? "1 workflow" : `${result.workflows.length} workflows`;
+		ui.success(`Validation passed — ${workflowLabel}, ${result.errorCount} errors, ${result.warningCount} warnings`);
+	}
+}
+function renderValidateFailure(error, asJson) {
+	if (error instanceof WorkflowValidationFailedError) {
+		if (!asJson) {
+			ui.error(`Validation failed with ${error.result.errorCount} error(s):`);
+			for (const workflow of error.result.workflows) for (const issue of workflow.issues.filter((i) => i.severity === "error")) {
+				const loc = issue.file ? issue.line !== void 0 ? `${issue.file}:${issue.line}` : issue.file : "";
+				ui.hint(`  ${loc ? `${loc} — ` : ""}${issue.message}`);
+				ui.hint(`    workflow: ${workflow.name}`);
+				ui.hint(`    type: ${issue.type}`);
+			}
+		} else writeJson(error.result);
+		return;
+	}
+	if (error instanceof WorkflowNotFoundError) {
+		ui.error(`Workflow "${error.workflowName}" not found.`);
+		if (error.availableNames.length > 0) ui.hint(`Available: ${error.availableNames.join(", ")}`);
+		return;
+	}
+	ui.error(`Validation error: ${toErrorMessage(error)}`);
+}
+//#endregion
+//#region src/commands/workflows/validate/validate.handler.ts
+async function handleWorkflowsValidate(options, ctx) {
+	const workflowsDir = await requireWorkflowsDir(options.path);
+	trackProject(workflowsDir);
+	const { jsonMode } = ctx;
+	renderValidateHeader(options.workflow);
+	const progress = createBuildProgress(options.workflow ?? "all workflows");
+	try {
+		const result = await runWorkflowValidate({
+			workflowsDir,
+			verbose: options.verbose,
+			workflow: options.workflow,
+			onProgressEvent: progress.handleEvent
+		});
+		if (jsonMode) writeJson(result);
+		else renderValidateSummary(result);
+	} catch (error) {
+		renderValidateFailure(error, jsonMode);
+		throwReportedCliExit("Workflow validation failed.", { cause: error });
+	} finally {
+		progress.stop();
+	}
+}
+//#endregion
+export { handleWorkflowsValidate };