@savvy-web/github-action-builder 0.7.3 → 0.7.5

package/services/persist-local-live.js

@@ -0,0 +1,210 @@
+import { ActionYmlPathError, PersistLocalError } from "../errors.js";
+import { PersistLocalService } from "./persist-local.js";
+import { Effect, Layer } 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 { parse } from "yaml-effect";
+
+//#region src/services/persist-local-live.ts
+/**
+* PersistLocalService Layer implementation.
+*
+*/
+/**
+* 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 parsed = yield* parse(readFileSync(actionYmlPath, "utf8")).pipe(Effect.catchAll(() => 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@v6
+      - 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");
+}
+/**
+* Live implementation of PersistLocalService.
+*/
+const PersistLocalServiceLive = Layer.succeed(PersistLocalService, {
+	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 { PersistLocalServiceLive };

package/services/persist-local.js

@@ -0,0 +1,37 @@
+import { Context, Schema } from "effect";
+
+//#region src/services/persist-local.ts
+/**
+* Options for the persist operation.
+* @internal
+*/
+const PersistLocalRunnerOptionsSchema = Schema.Struct({ 
+/** Working directory. Accepts string. */
+cwd: Schema.optional(Schema.String) });
+/**
+* Result of the persist-local operation.
+* @internal
+*/
+const PersistLocalResultSchema = Schema.Struct({
+	/** Whether the operation completed successfully. */
+	success: Schema.Boolean,
+	/** Number of files copied (changed or new). */
+	filesCopied: Schema.Number,
+	/** Number of files skipped (unchanged). */
+	filesSkipped: Schema.Number,
+	/** Whether act template files were generated. */
+	actTemplateGenerated: Schema.Boolean,
+	/** Output path where files were persisted. */
+	outputPath: Schema.String,
+	/** Error message if failed. */
+	error: Schema.optional(Schema.String)
+});
+/**
+* PersistLocalService tag for dependency injection.
+*
+* @public
+*/
+const PersistLocalService = Context.GenericTag("PersistLocalService");
+
+//#endregion
+export { PersistLocalResultSchema, PersistLocalRunnerOptionsSchema, PersistLocalService };

package/services/validation-live.js

@@ -0,0 +1,216 @@
+import { ActionYmlMissing, ActionYmlSchemaError, ActionYmlSyntaxError, MainEntryMissing, ValidationFailed } from "../errors.js";
+import { ConfigService } from "./config.js";
+import { ActionYml } from "../schemas/action-yml.js";
+import { ValidationService } from "./validation.js";
+import { Effect, Layer, ParseResult, Schema } from "effect";
+import { existsSync, readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { parse } from "yaml-effect";
+
+//#region src/services/validation-live.ts
+/**
+* ValidationService Layer implementation.
+*/
+/* 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: ParseResult.TreeFormatter.formatErrorSync(error)
+}];
+/* v8 ignore stop */
+/**
+* Live implementation of ValidationService.
+*/
+const ValidationServiceLive = Layer.effect(ValidationService, 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 parsed = yield* parse(yield* Effect.try({
+			try: () => readFileSync(path, "utf8"),
+			/* v8 ignore next */
+			catch: () => new ActionYmlSyntaxError({
+				path,
+				message: "Failed to read file"
+			})
+		})).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 = Schema.decodeUnknownEither(ActionYml)(parsed);
+		if (result._tag === "Left") return yield* new ActionYmlSchemaError({
+			path,
+			errors: formatSchemaErrors(result.left, path)
+		});
+		return result.right;
+	});
+	/* 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.either(configService.detectEntries(cwd, entriesConfig));
+		/* v8 ignore start - error branch requires missing main entry */
+		if (result._tag === "Left" && result.left instanceof MainEntryMissing) errors.push({
+			code: "MAIN_ENTRY_MISSING",
+			message: `Main entry point not found: ${result.left.expectedPath}`,
+			file: result.left.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.either(validateActionYml(actionYmlPath));
+		if (result._tag === "Left") {
+			const error = result.left;
+			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.right.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(`  \u2717 ${error.message}`);
+					if (error.suggestion) lines.push(`    \u2192 ${error.suggestion}`);
+				}
+			}
+			if (result.warnings.length > 0) {
+				if (lines.length > 0) lines.push("");
+				lines.push("Warnings:");
+				for (const warning of result.warnings) {
+					lines.push(`  \u26A0 ${warning.message}`);
+					if (warning.suggestion) lines.push(`    \u2192 ${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 { ValidationServiceLive };

package/services/validation.js

@@ -0,0 +1,77 @@
+import { OptionalPathLikeSchema } from "../schemas/path.js";
+import { Context, Schema } from "effect";
+
+//#region src/services/validation.ts
+/**
+* Options for validation.
+* @internal
+*/
+const ValidateOptionsSchema = Schema.Struct({
+	/** Working directory for file operations. Accepts string, Buffer, or URL. */
+	cwd: OptionalPathLikeSchema,
+	/** Force strict mode regardless of environment. Auto-detects from CI when undefined. */
+	strict: Schema.optional(Schema.Boolean)
+});
+/**
+* A validation error item.
+* @internal
+*/
+const ValidationErrorSchema = Schema.Struct({
+	/** Error code for categorization. */
+	code: Schema.String,
+	/** Human-readable error message. */
+	message: Schema.String,
+	/** File path where error occurred. */
+	file: Schema.optional(Schema.String),
+	/** Suggestion for fixing the error. */
+	suggestion: Schema.optional(Schema.String)
+});
+/**
+* A validation warning.
+* @internal
+*/
+const ValidationWarningSchema = Schema.Struct({
+	/** Warning code for categorization. */
+	code: Schema.String,
+	/** Human-readable warning message. */
+	message: Schema.String,
+	/** File path where warning occurred. */
+	file: Schema.optional(Schema.String),
+	/** Suggestion for addressing the warning. */
+	suggestion: Schema.optional(Schema.String)
+});
+/**
+* Validation result with errors and warnings.
+* @internal
+*/
+const ValidationResultSchema = Schema.Struct({
+	/** Whether validation passed (no errors, or only warnings in non-strict mode). */
+	valid: Schema.Boolean,
+	/** Validation errors. */
+	errors: Schema.Array(ValidationErrorSchema),
+	/** Validation warnings. */
+	warnings: Schema.Array(ValidationWarningSchema)
+});
+/**
+* Result of action.yml validation.
+* @internal
+*/
+const ActionYmlResultSchema = Schema.Struct({
+	/** Whether the action.yml is valid. */
+	valid: Schema.Boolean,
+	/** Parsed action.yml content if valid. */
+	content: Schema.optional(Schema.Any),
+	/** Validation errors. */
+	errors: Schema.Array(ValidationErrorSchema),
+	/** Validation warnings. */
+	warnings: Schema.Array(ValidationWarningSchema)
+});
+/**
+* ValidationService tag for dependency injection.
+*
+* @public
+*/
+const ValidationService = Context.GenericTag("ValidationService");
+
+//#endregion
+export { ActionYmlResultSchema, ValidateOptionsSchema, ValidationErrorSchema, ValidationResultSchema, ValidationService, ValidationWarningSchema };

package/tsdoc-metadata.json

@@ -1,11 +1,11 @@
-// This file is read by tools that parse documentation comments conforming to the TSDoc standard.
-// It should be published with your NPM package.  It should not be tracked by Git.
-{
-  "tsdocVersion": "0.12",
-  "toolPackages": [
-    {
-      "packageName": "@microsoft/api-extractor",
-      "packageVersion": "7.58.7"
-    }
-  ]
-}
+// This file is read by tools that parse documentation comments conforming to the TSDoc standard.
+// It should be published with your NPM package.  It should not be tracked by Git.
+{
+  "tsdocVersion": "0.12",
+  "toolPackages": [
+    {
+      "packageName": "@microsoft/api-extractor",
+      "packageVersion": "7.58.7"
+    }
+  ]
+}

package/231.js

@@ -1,5 +0,0 @@
-var __webpack_require__ = {};
-(()=>{
-    __webpack_require__.j = "231";
-})();
-export { __webpack_require__ };

package/612.js

@@ -1,5 +0,0 @@
-var __webpack_require__ = {};
-(()=>{
-    __webpack_require__.j = "612";
-})();
-export { __webpack_require__ };