@savvy-web/github-action-builder 2.1.1 → 2.2.1

package/services/persist-local.js

@@ -1,7 +1,21 @@
-import { Context, Schema } from "effect";
+import { ActionYmlPathError, PersistLocalError } from "../errors.js";
+import { Context, Effect, Layer, Schema } from "effect";
+import { copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { dirname, join, relative, resolve } from "node:path";
+import { createHash } from "node:crypto";
+import { Yaml } from "@effected/yaml";
 
 //#region src/services/persist-local.ts
 /**
+* PersistLocalService - Effect service for copying build output to a local action directory.
+*
+* @remarks
+* Provides smart-sync of action.yml and dist/ to a local directory
+* for testing with nektos/act.
+*
+* @internal
+*/
+/**
 * Options for the persist operation.
 * @public
 */
@@ -27,11 +41,209 @@ const PersistLocalResultSchema = Schema.Struct({
 	error: Schema.optional(Schema.String)
 });
 /**
+* Compute SHA-256 hash of a file's contents.
+*/
+function fileHash(filePath) {
+	const content = readFileSync(filePath);
+	return createHash("sha256").update(content).digest("hex");
+}
+/**
+* Sync a single file from src to dest using hash comparison.
+* Returns true if the file was copied, false if skipped.
+*/
+function syncFile(src, dest) {
+	if (existsSync(dest)) {
+		if (fileHash(src) === fileHash(dest)) return false;
+	}
+	mkdirSync(dirname(dest), { recursive: true });
+	copyFileSync(src, dest);
+	return true;
+}
+/**
+* Recursively collect all file paths relative to a base directory.
+*/
+function walkDirectory(dir, base = dir) {
+	const files = [];
+	if (!existsSync(dir)) return files;
+	for (const entry of readdirSync(dir, { withFileTypes: true })) {
+		const fullPath = join(dir, entry.name);
+		if (entry.isDirectory()) files.push(...walkDirectory(fullPath, base));
+		else files.push(relative(base, fullPath));
+	}
+	return files;
+}
+/**
+* Smart-sync a directory: copy changed files, remove stale dest files.
+*/
+function syncDirectory(srcDir, destDir) {
+	const stats = {
+		copied: 0,
+		skipped: 0
+	};
+	const srcFiles = walkDirectory(srcDir);
+	for (const relPath of srcFiles) if (syncFile(join(srcDir, relPath), join(destDir, relPath))) stats.copied++;
+	else stats.skipped++;
+	const srcFileSet = new Set(srcFiles);
+	const destFiles = walkDirectory(destDir);
+	for (const relPath of destFiles) if (!srcFileSet.has(relPath)) {
+		rmSync(join(destDir, relPath), { force: true });
+		let parent = dirname(join(destDir, relPath));
+		while (parent !== destDir && existsSync(parent)) if (readdirSync(parent).length === 0) {
+			rmSync(parent, { recursive: true });
+			parent = dirname(parent);
+		} else break;
+	}
+	return stats;
+}
+/**
+* Validate that action.yml runs paths resolve correctly relative to the destination.
+*/
+function validateActionYmlPaths(actionYmlPath, destDir) {
+	return Effect.gen(function* () {
+		if (!existsSync(actionYmlPath)) return;
+		const content = readFileSync(actionYmlPath, "utf8");
+		const parsed = yield* Yaml.parse(content).pipe(Effect.catch(() => Effect.succeed(null)));
+		if (!parsed?.runs) return;
+		for (const entryType of [
+			"main",
+			"pre",
+			"post"
+		]) {
+			const specifiedPath = parsed.runs[entryType];
+			if (!specifiedPath) continue;
+			const expectedPath = resolve(destDir, specifiedPath);
+			if (!existsSync(expectedPath)) return yield* Effect.fail(new ActionYmlPathError({
+				entryType,
+				specifiedPath,
+				expectedPath
+			}));
+		}
+	});
+}
+const ACTRC_CONTENT = `--container-architecture linux/amd64
+-W .github/workflows/act-test.yml
+`;
+const ACT_WORKFLOW_CONTENT = `name: Local Test
+on:
+  workflow_dispatch:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+      - uses: ./.github/actions/local
+`;
+function formatPersistResult(result) {
+	const lines = [];
+	if (result.success) {
+		lines.push("Persist Local Summary:");
+		lines.push(`  Output: ${result.outputPath}`);
+		lines.push(`  Files copied: ${result.filesCopied}`);
+		lines.push(`  Files skipped (unchanged): ${result.filesSkipped}`);
+		if (result.actTemplateGenerated) lines.push("  Act template files generated");
+	} else lines.push(`Persist Local Failed: ${result.error}`);
+	return lines.join("\n");
+}
+/**
 * PersistLocalService key for dependency injection.
 *
 * @public
 */
-var PersistLocalService = class extends Context.Service()("PersistLocalService") {};
+var PersistLocalService = class extends Context.Service()("PersistLocalService") {
+	/**
+	* Production implementation of {@link PersistLocalService}.
+	*
+	* @public
+	*/
+	static layer = Layer.succeed(this, {
+		persist: (config, options = {}) => Effect.gen(function* () {
+			const cwd = options.cwd ?? process.cwd();
+			const outputPath = resolve(cwd, config.persistLocal.path);
+			if (!config.persistLocal.enabled) return {
+				success: true,
+				filesCopied: 0,
+				filesSkipped: 0,
+				actTemplateGenerated: false,
+				outputPath
+			};
+			yield* Effect.try({
+				try: () => mkdirSync(outputPath, { recursive: true }),
+				/* v8 ignore next 5 - error branch requires fs permission failures */
+				catch: (error) => new PersistLocalError({
+					path: outputPath,
+					cause: error
+				})
+			});
+			let totalCopied = 0;
+			let totalSkipped = 0;
+			const actionYmlSrc = resolve(cwd, "action.yml");
+			const actionYmlDest = resolve(outputPath, "action.yml");
+			if (existsSync(actionYmlSrc)) if (yield* Effect.try({
+				try: () => syncFile(actionYmlSrc, actionYmlDest),
+				/* v8 ignore next 5 - error branch requires fs permission failures */
+				catch: (error) => new PersistLocalError({
+					path: actionYmlSrc,
+					cause: error
+				})
+			})) totalCopied++;
+			else totalSkipped++;
+			else if (existsSync(actionYmlDest)) rmSync(actionYmlDest, { force: true });
+			const distSrc = resolve(cwd, "dist");
+			if (existsSync(distSrc) && statSync(distSrc).isDirectory()) {
+				const distStats = yield* Effect.try({
+					try: () => syncDirectory(distSrc, resolve(outputPath, "dist")),
+					/* v8 ignore next 5 - error branch requires fs permission failures */
+					catch: (error) => new PersistLocalError({
+						path: distSrc,
+						cause: error
+					})
+				});
+				totalCopied += distStats.copied;
+				totalSkipped += distStats.skipped;
+			}
+			yield* validateActionYmlPaths(resolve(outputPath, "action.yml"), outputPath);
+			let actTemplateGenerated = false;
+			if (config.persistLocal.actTemplate) {
+				const actrcPath = resolve(cwd, ".actrc");
+				const actWorkflowPath = resolve(cwd, ".github/workflows/act-test.yml");
+				if (!existsSync(actrcPath)) {
+					yield* Effect.try({
+						try: () => writeFileSync(actrcPath, ACTRC_CONTENT, "utf8"),
+						/* v8 ignore next 5 - error branch requires fs permission failures */
+						catch: (error) => new PersistLocalError({
+							path: actrcPath,
+							cause: error
+						})
+					});
+					actTemplateGenerated = true;
+				}
+				if (!existsSync(actWorkflowPath)) {
+					yield* Effect.try({
+						try: () => {
+							mkdirSync(dirname(actWorkflowPath), { recursive: true });
+							writeFileSync(actWorkflowPath, ACT_WORKFLOW_CONTENT, "utf8");
+						},
+						/* v8 ignore next 5 - error branch requires fs permission failures */
+						catch: (error) => new PersistLocalError({
+							path: actWorkflowPath,
+							cause: error
+						})
+					});
+					actTemplateGenerated = true;
+				}
+			}
+			return {
+				success: true,
+				filesCopied: totalCopied,
+				filesSkipped: totalSkipped,
+				actTemplateGenerated,
+				outputPath
+			};
+		}),
+		formatResult: formatPersistResult
+	});
+};
 
 //#endregion
 export { PersistLocalResultSchema, PersistLocalRunnerOptionsSchema, PersistLocalService };

package/services/validation.js

@@ -1,8 +1,23 @@
+import { ActionYmlMissing, ActionYmlSchemaError, ActionYmlSyntaxError, MainEntryMissing, ValidationFailed } from "../errors.js";
 import { OptionalPathLikeSchema } from "../schemas/path.js";
-import { Context, Schema } from "effect";
+import { ConfigService } from "./config.js";
+import { ActionYml } from "../schemas/action-yml.js";
+import { Context, Effect, Layer, Result, Schema } from "effect";
+import { existsSync, readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { Yaml } from "@effected/yaml";
 
 //#region src/services/validation.ts
 /**
+* ValidationService - Effect service for validation.
+*
+* @remarks
+* Provides validation of configuration, entry points, and action.yml
+* using Effect's service pattern with Context.Service.
+*
+* @internal
+*/
+/**
 * Options for validation.
 * @public
 */
@@ -66,6 +81,29 @@ const ActionYmlResultSchema = Schema.Struct({
 	/** Validation warnings. */
 	warnings: Schema.Array(ValidationWarningSchema)
 });
+/* v8 ignore start - CI environment detection has multiple env var formats */
+/** Check if running in CI environment. */
+const isCI = () => process.env.CI === "true" || process.env.CI === "1" || process.env.GITHUB_ACTIONS === "true";
+/** Resolve strict mode from config or environment. */
+const resolveStrict = (configStrict) => configStrict ?? isCI();
+/* v8 ignore stop */
+/** Create a validation warning, omitting undefined file. */
+const makeWarning = (code, message, suggestion, file) => file !== void 0 ? {
+	code,
+	message,
+	suggestion,
+	file
+} : {
+	code,
+	message,
+	suggestion
+};
+/** Format schema parse errors. */
+/* v8 ignore start - only called for schema validation errors */
+const formatSchemaErrors = (error, filePath) => [{
+	path: filePath,
+	message: error.message
+}];
 /**
 * ValidationService key for dependency injection.
 *
@@ -91,7 +129,190 @@ const ActionYmlResultSchema = Schema.Struct({
 *
 * @public
 */
-var ValidationService = class extends Context.Service()("ValidationService") {};
+var ValidationService = class extends Context.Service()("ValidationService") {
+	/**
+	* Production implementation of {@link ValidationService}.
+	*
+	* @remarks
+	* Depends on {@link ConfigService}.
+	*
+	* @public
+	*/
+	static layer = Layer.effect(this, Effect.gen(function* () {
+		const configService = yield* ConfigService;
+		/** Read and parse action.yml file. */
+		const readActionYml = (path) => Effect.gen(function* () {
+			if (!existsSync(path)) return yield* new ActionYmlMissing({ cwd: path });
+			const content = yield* Effect.try({
+				try: () => readFileSync(path, "utf8"),
+				/* v8 ignore next */
+				catch: () => new ActionYmlSyntaxError({
+					path,
+					message: "Failed to read file"
+				})
+			});
+			const parsed = yield* Yaml.parse(content).pipe(
+				/* v8 ignore next 5 - requires malformed YAML */
+				Effect.mapError((error) => new ActionYmlSyntaxError({
+					path,
+					message: error.message
+				}))
+			);
+			/* v8 ignore start - requires non-object YAML (e.g., scalar or array) */
+			if (!parsed || typeof parsed !== "object") return yield* new ActionYmlSyntaxError({
+				path,
+				message: "action.yml must be an object"
+			});
+			/* v8 ignore stop */
+			return parsed;
+		});
+		/** Validate parsed content against ActionYml schema. */
+		/* v8 ignore start - schema validation error branch */
+		const validateSchema = (parsed, path) => Effect.gen(function* () {
+			const result = yield* Effect.result(Schema.decodeUnknownEffect(ActionYml)(parsed));
+			if (Result.isFailure(result)) return yield* new ActionYmlSchemaError({
+				path,
+				errors: formatSchemaErrors(result.failure, path)
+			});
+			return result.success;
+		});
+		/* v8 ignore stop */
+		/** Check for recommended fields and generate warnings. */
+		/* v8 ignore start - recommendation checks have many branches */
+		const checkRecommendations = (content, filePath) => {
+			const warnings = [];
+			if (!content.branding) warnings.push(makeWarning("ACTION_YML_NO_BRANDING", "No branding configuration found", "Add branding.icon and branding.color for better marketplace visibility", filePath));
+			else {
+				const branding = content.branding;
+				if (!branding.icon) warnings.push(makeWarning("ACTION_YML_NO_BRANDING_ICON", "Branding icon not specified", "Add branding.icon for better marketplace visibility", filePath));
+				if (!branding.color) warnings.push(makeWarning("ACTION_YML_NO_BRANDING_COLOR", "Branding color not specified", "Add branding.color for better marketplace visibility", filePath));
+			}
+			if (content.inputs) {
+				const inputs = content.inputs;
+				for (const [name, input] of Object.entries(inputs)) if (!input.description) warnings.push(makeWarning("ACTION_YML_INPUT_NO_DESCRIPTION", `Input '${name}' has no description`, `Add a description for the '${name}' input`, filePath));
+			}
+			if (content.outputs) {
+				const outputs = content.outputs;
+				for (const [name, output] of Object.entries(outputs)) if (!output.description) warnings.push(makeWarning("ACTION_YML_OUTPUT_NO_DESCRIPTION", `Output '${name}' has no description`, `Add a description for the '${name}' output`, filePath));
+			}
+			return warnings;
+		};
+		/* v8 ignore stop */
+		/** Validate action.yml file completely. */
+		const validateActionYml = (path) => Effect.gen(function* () {
+			const parsed = yield* readActionYml(path);
+			return {
+				valid: true,
+				content: yield* validateSchema(parsed, path),
+				errors: [],
+				warnings: checkRecommendations(parsed, path)
+			};
+		});
+		/** Check entry points exist. */
+		const checkEntries = (config, cwd) => Effect.gen(function* () {
+			const errors = [];
+			const entriesConfig = { main: config.entries.main };
+			if (config.entries.pre) entriesConfig.pre = config.entries.pre;
+			if (config.entries.post) entriesConfig.post = config.entries.post;
+			const result = yield* Effect.result(configService.detectEntries(cwd, entriesConfig));
+			/* v8 ignore start - error branch requires missing main entry */
+			if (Result.isFailure(result) && result.failure instanceof MainEntryMissing) errors.push({
+				code: "MAIN_ENTRY_MISSING",
+				message: `Main entry point not found: ${result.failure.expectedPath}`,
+				file: result.failure.expectedPath,
+				suggestion: "Create src/main.ts or specify a different path in config"
+			});
+			/* v8 ignore stop */
+			return errors;
+		});
+		/** Check action.yml and collect errors/warnings. */
+		/* v8 ignore start - action.yml validation has many error branches */
+		const checkActionYml = (config, cwd) => Effect.gen(function* () {
+			const errors = [];
+			const warnings = [];
+			if (!config.validation.requireActionYml) return {
+				errors,
+				warnings
+			};
+			const actionYmlPath = resolve(cwd, "action.yml");
+			const result = yield* Effect.result(validateActionYml(actionYmlPath));
+			if (Result.isFailure(result)) {
+				const error = result.failure;
+				if (error instanceof ActionYmlMissing) warnings.push({
+					code: "ACTION_YML_MISSING",
+					message: "action.yml not found",
+					file: actionYmlPath,
+					suggestion: "Create action.yml to define your action metadata"
+				});
+				else if (error instanceof ActionYmlSyntaxError) errors.push({
+					code: "ACTION_YML_SYNTAX_ERROR",
+					message: error.message,
+					file: error.path
+				});
+				else if (error instanceof ActionYmlSchemaError) for (const schemaError of error.errors) errors.push({
+					code: "ACTION_YML_SCHEMA_ERROR",
+					message: schemaError.message,
+					file: error.path
+				});
+			} else warnings.push(...result.success.warnings);
+			return {
+				errors,
+				warnings
+			};
+		});
+		/* v8 ignore stop */
+		return {
+			validate: (config, options = {}) => Effect.gen(function* () {
+				const cwd = options.cwd ?? process.cwd();
+				const strict = resolveStrict(options.strict ?? config.validation.strict);
+				const entryErrors = yield* checkEntries(config, cwd);
+				const actionYmlResult = yield* checkActionYml(config, cwd);
+				const errors = [...entryErrors, ...actionYmlResult.errors];
+				const warnings = [...actionYmlResult.warnings];
+				const valid = errors.length === 0 && (!strict || warnings.length === 0);
+				/* v8 ignore start - strict mode branch requires CI environment */
+				if (strict && warnings.length > 0 && errors.length === 0) return yield* new ValidationFailed({
+					errorCount: 0,
+					warningCount: warnings.length,
+					message: "Warnings treated as errors in strict mode"
+				});
+				/* v8 ignore stop */
+				return {
+					valid,
+					errors,
+					warnings
+				};
+			}),
+			validateActionYml,
+			/* v8 ignore start - formatting function tested via integration */
+			formatResult: (result) => {
+				const lines = [];
+				if (result.errors.length > 0) {
+					lines.push("Errors:");
+					for (const error of result.errors) {
+						lines.push(`  ✗ ${error.message}`);
+						if (error.suggestion) lines.push(`    → ${error.suggestion}`);
+					}
+				}
+				if (result.warnings.length > 0) {
+					if (lines.length > 0) lines.push("");
+					lines.push("Warnings:");
+					for (const warning of result.warnings) {
+						lines.push(`  ⚠ ${warning.message}`);
+						if (warning.suggestion) lines.push(`    → ${warning.suggestion}`);
+					}
+				}
+				if (result.valid && result.errors.length === 0 && result.warnings.length === 0) lines.push("✓ All checks passed");
+				return lines.join("\n");
+			},
+			/* v8 ignore stop */
+			/* v8 ignore next 2 - environment detection */
+			isCI: () => Effect.succeed(isCI()),
+			/* v8 ignore next */
+			isStrict: (configStrict) => Effect.succeed(resolveStrict(configStrict))
+		};
+	}));
+};
 
 //#endregion
 export { ActionYmlResultSchema, ValidateOptionsSchema, ValidationErrorSchema, ValidationResultSchema, ValidationService, ValidationWarningSchema };