@savvy-web/github-action-builder 0.1.0

package/123.js

@@ -0,0 +1,646 @@
+import { Console, Context, Data, Effect, Layer, ManagedRuntime, Option, ParseResult, Schema } from "effect";
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { parse } from "yaml";
+const ConfigNotFoundBase = Data.TaggedError("ConfigNotFound");
+class ConfigNotFound extends ConfigNotFoundBase {
+}
+const ConfigInvalidBase = Data.TaggedError("ConfigInvalid");
+class ConfigInvalid extends ConfigInvalidBase {
+}
+const ConfigLoadFailedBase = Data.TaggedError("ConfigLoadFailed");
+class ConfigLoadFailed extends ConfigLoadFailedBase {
+}
+const MainEntryMissingBase = Data.TaggedError("MainEntryMissing");
+class MainEntryMissing extends MainEntryMissingBase {
+}
+const EntryFileMissingBase = Data.TaggedError("EntryFileMissing");
+class EntryFileMissing extends EntryFileMissingBase {
+}
+const ActionYmlMissingBase = Data.TaggedError("ActionYmlMissing");
+class ActionYmlMissing extends ActionYmlMissingBase {
+}
+const ActionYmlSyntaxErrorBase = Data.TaggedError("ActionYmlSyntaxError");
+class ActionYmlSyntaxError extends ActionYmlSyntaxErrorBase {
+}
+const ActionYmlSchemaErrorBase = Data.TaggedError("ActionYmlSchemaError");
+class ActionYmlSchemaError extends ActionYmlSchemaErrorBase {
+}
+const ValidationFailedBase = Data.TaggedError("ValidationFailed");
+class ValidationFailed extends ValidationFailedBase {
+}
+const BundleFailedBase = Data.TaggedError("BundleFailed");
+class BundleFailed extends BundleFailedBase {
+}
+const WriteErrorBase = Data.TaggedError("WriteError");
+class WriteError extends WriteErrorBase {
+}
+const CleanErrorBase = Data.TaggedError("CleanError");
+class CleanError extends CleanErrorBase {
+}
+const BuildFailedBase = Data.TaggedError("BuildFailed");
+class BuildFailed extends BuildFailedBase {
+}
+function pathLikeToString(pathLike) {
+    if ("string" == typeof pathLike) return pathLike;
+    if (Buffer.isBuffer(pathLike)) return pathLike.toString("utf8");
+    if (pathLike instanceof URL) return fileURLToPath(pathLike);
+    return String(pathLike);
+}
+const PathLikeSchema = Schema.transform(Schema.Union(Schema.String, Schema.instanceOf(Buffer), Schema.instanceOf(URL)), Schema.String, {
+    strict: true,
+    decode: (pathLike)=>pathLikeToString(pathLike),
+    encode: (s)=>s
+});
+const OptionalPathLikeSchema = Schema.optional(PathLikeSchema);
+const BuildRunnerOptionsSchema = Schema.Struct({
+    cwd: OptionalPathLikeSchema,
+    clean: Schema.optional(Schema.Boolean)
+});
+const BundleStatsSchema = Schema.Struct({
+    entry: Schema.String,
+    size: Schema.Number,
+    duration: Schema.Number,
+    outputPath: Schema.String
+});
+const BundleResultSchema = Schema.Struct({
+    success: Schema.Boolean,
+    stats: Schema.optional(BundleStatsSchema),
+    error: Schema.optional(Schema.String)
+});
+const BuildResultSchema = Schema.Struct({
+    success: Schema.Boolean,
+    entries: Schema.Array(BundleResultSchema),
+    duration: Schema.Number,
+    error: Schema.optional(Schema.String)
+});
+const BuildService = Context.GenericTag("BuildService");
+const EntriesSchema = Schema.Struct({
+    main: Schema.optionalWith(Schema.String, {
+        default: ()=>"src/main.ts"
+    }),
+    pre: Schema.optional(Schema.String),
+    post: Schema.optional(Schema.String)
+});
+const EsTarget = Schema.Literal("es2020", "es2021", "es2022", "es2023", "es2024");
+const BuildOptionsSchema = Schema.Struct({
+    minify: Schema.optionalWith(Schema.Boolean, {
+        default: ()=>true
+    }),
+    target: Schema.optionalWith(EsTarget, {
+        default: ()=>"es2022"
+    }),
+    sourceMap: Schema.optionalWith(Schema.Boolean, {
+        default: ()=>false
+    }),
+    externals: Schema.optionalWith(Schema.Array(Schema.String), {
+        default: ()=>[]
+    }),
+    quiet: Schema.optionalWith(Schema.Boolean, {
+        default: ()=>false
+    })
+});
+const ValidationOptionsSchema = Schema.Struct({
+    requireActionYml: Schema.optionalWith(Schema.Boolean, {
+        default: ()=>true
+    }),
+    maxBundleSize: Schema.optional(Schema.String),
+    strict: Schema.optional(Schema.Boolean)
+});
+const ConfigInputSchema = Schema.Struct({
+    entries: Schema.optional(Schema.Struct({
+        main: Schema.optional(Schema.String),
+        pre: Schema.optional(Schema.String),
+        post: Schema.optional(Schema.String)
+    })),
+    build: Schema.optional(Schema.Struct({
+        minify: Schema.optional(Schema.Boolean),
+        target: Schema.optional(EsTarget),
+        sourceMap: Schema.optional(Schema.Boolean),
+        externals: Schema.optional(Schema.Array(Schema.String)),
+        quiet: Schema.optional(Schema.Boolean)
+    })),
+    validation: Schema.optional(Schema.Struct({
+        requireActionYml: Schema.optional(Schema.Boolean),
+        maxBundleSize: Schema.optional(Schema.String),
+        strict: Schema.optional(Schema.Boolean)
+    }))
+});
+const ConfigSchema = Schema.Struct({
+    entries: EntriesSchema,
+    build: BuildOptionsSchema,
+    validation: ValidationOptionsSchema
+});
+function defineConfig(config = {}) {
+    return Schema.decodeUnknownSync(ConfigSchema)({
+        entries: config.entries ?? {},
+        build: config.build ?? {},
+        validation: config.validation ?? {}
+    });
+}
+const LoadConfigOptionsSchema = Schema.Struct({
+    cwd: OptionalPathLikeSchema,
+    configPath: OptionalPathLikeSchema
+});
+const EntryTypeSchema = Schema.Literal("main", "pre", "post");
+const DetectedEntrySchema = Schema.Struct({
+    type: EntryTypeSchema,
+    path: Schema.String,
+    output: Schema.String
+});
+const DetectEntriesResultSchema = Schema.Struct({
+    success: Schema.Boolean,
+    entries: Schema.Array(DetectedEntrySchema)
+});
+Schema.Struct({
+    config: ConfigSchema,
+    configPath: Schema.optional(Schema.String),
+    usingDefaults: Schema.Boolean
+});
+const ConfigService = Context.GenericTag("ConfigService");
+const build_live_require = createRequire(import.meta.url);
+const ncc = build_live_require("@vercel/ncc");
+async function bundle(entryPath, options = {}) {
+    return ncc(entryPath, {
+        minify: options.minify ?? true,
+        sourceMap: options.sourceMap ?? false,
+        target: options.target ?? "es2022",
+        quiet: options.quiet ?? true,
+        externals: options.externals ?? [],
+        ...options
+    });
+}
+function getBundleSize(code) {
+    return Buffer.byteLength(code, "utf8");
+}
+function formatBytes(bytes) {
+    if (bytes < 1024) return `${bytes} B`;
+    if (bytes < 1048576) return `${(bytes / 1024).toFixed(1)} KB`;
+    return `${(bytes / 1048576).toFixed(1)} MB`;
+}
+function formatBuildResult(result) {
+    const lines = [];
+    if (result.success) {
+        lines.push("Build Summary:");
+        for (const entry of result.entries)if (entry.success && entry.stats) {
+            const { entry: name, size, duration, outputPath } = entry.stats;
+            lines.push(`  ✓ ${name}: ${formatBytes(size)} (${duration}ms) → ${outputPath}`);
+        }
+        lines.push(`\nTotal time: ${result.duration}ms`);
+    } else {
+        lines.push("Build Failed:");
+        for (const entry of result.entries)if (!entry.success) lines.push(`  ✗ ${entry.error}`);
+    }
+    return lines.join("\n");
+}
+function cleanDirectory(dir) {
+    return Effect["try"]({
+        try: ()=>{
+            if (existsSync(dir)) rmSync(dir, {
+                recursive: true,
+                force: true
+            });
+        },
+        catch: (error)=>new CleanError({
+                directory: dir,
+                cause: error instanceof Error ? error.message : String(error)
+            })
+    });
+}
+function writeFile(path, content) {
+    return Effect["try"]({
+        try: ()=>{
+            const dir = resolve(path, "..");
+            mkdirSync(dir, {
+                recursive: true
+            });
+            writeFileSync(path, content, "utf8");
+        },
+        catch: (error)=>new WriteError({
+                path,
+                cause: error instanceof Error ? error.message : String(error)
+            })
+    });
+}
+function bundleEntry(entry, config, cwd) {
+    return Effect.gen(function*() {
+        const startTime = Date.now();
+        const nccResult = yield* Effect.tryPromise({
+            try: ()=>bundle(entry.path, {
+                    minify: config.build.minify,
+                    sourceMap: config.build.sourceMap,
+                    target: config.build.target,
+                    externals: [
+                        ...config.build.externals
+                    ],
+                    quiet: config.build.quiet
+                }),
+            catch: (error)=>new BundleFailed({
+                    entry: entry.path,
+                    cause: error instanceof Error ? error.message : String(error)
+                })
+        });
+        const outputPath = resolve(cwd, entry.output);
+        yield* writeFile(outputPath, nccResult.code);
+        if (config.build.sourceMap && nccResult.map) yield* writeFile(`${outputPath}.map`, nccResult.map);
+        if (nccResult.assets) {
+            const outputDir = resolve(outputPath, "..");
+            for (const [assetName, assetData] of Object.entries(nccResult.assets)){
+                const assetPath = resolve(outputDir, assetName);
+                const content = "string" == typeof assetData.source ? assetData.source : assetData.source.toString("utf8");
+                yield* writeFile(assetPath, content);
+            }
+        }
+        const duration = Date.now() - startTime;
+        const size = getBundleSize(nccResult.code);
+        return {
+            success: true,
+            stats: {
+                entry: entry.type,
+                size,
+                duration,
+                outputPath: entry.output
+            }
+        };
+    });
+}
+const BuildServiceLive = Layer.effect(BuildService, Effect.gen(function*() {
+    const configService = yield* ConfigService;
+    return {
+        build: (config, options = {})=>Effect.gen(function*() {
+                const cwd = options.cwd ?? process.cwd();
+                const shouldClean = options.clean ?? true;
+                const startTime = Date.now();
+                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 entriesResult = yield* configService.detectEntries(cwd, entriesConfig);
+                if (shouldClean) yield* cleanDirectory(resolve(cwd, "dist"));
+                const entryResults = [];
+                for (const entry of entriesResult.entries){
+                    const result = yield* Effect.either(bundleEntry(entry, config, cwd));
+                    if ("Left" === result._tag) entryResults.push({
+                        success: false,
+                        error: result.left.cause
+                    });
+                    else entryResults.push(result.right);
+                }
+                yield* writeFile(resolve(cwd, "dist/package.json"), '{ "type": "module" }');
+                const duration = Date.now() - startTime;
+                const success = entryResults.every((r)=>r.success);
+                if (!success) return {
+                    success,
+                    entries: entryResults,
+                    duration,
+                    error: "One or more entries failed to build"
+                };
+                return {
+                    success,
+                    entries: entryResults,
+                    duration
+                };
+            }),
+        bundle: (entry, config)=>bundleEntry(entry, config, process.cwd()),
+        clean: (outputDir)=>cleanDirectory(outputDir),
+        formatResult: formatBuildResult,
+        formatBytes: formatBytes
+    };
+}));
+const CONFIG_FILENAMES = [
+    "action.config.ts",
+    "action.config.js",
+    "action.config.mjs"
+];
+const DEFAULT_ENTRIES = {
+    main: "src/main.ts",
+    pre: "src/pre.ts",
+    post: "src/post.ts"
+};
+function findConfigFile(cwd) {
+    for (const filename of CONFIG_FILENAMES){
+        const configPath = resolve(cwd, filename);
+        if (existsSync(configPath)) return configPath;
+    }
+}
+function detectOptionalEntry(cwd, type, explicitPath) {
+    const defaultPath = DEFAULT_ENTRIES[type];
+    const entryPath = explicitPath ?? defaultPath;
+    const absolutePath = resolve(cwd, entryPath);
+    if (existsSync(absolutePath)) return {
+        type,
+        path: absolutePath,
+        output: `dist/${type}.js`
+    };
+}
+const ConfigServiceLive = Layer.succeed(ConfigService, {
+    load: (options = {})=>Effect.gen(function*() {
+            const cwd = options.cwd ?? process.cwd();
+            const configPath = options.configPath ?? findConfigFile(cwd);
+            if (!configPath) return {
+                config: defineConfig({}),
+                usingDefaults: true
+            };
+            if (!existsSync(configPath)) return yield* Effect.fail(new ConfigNotFound({
+                path: configPath,
+                message: "Specified config file does not exist"
+            }));
+            const absolutePath = resolve(cwd, configPath);
+            const configModule = yield* Effect.tryPromise({
+                try: async ()=>import(absolutePath),
+                catch: (error)=>new ConfigLoadFailed({
+                        path: configPath,
+                        cause: error instanceof Error ? error.message : String(error)
+                    })
+            });
+            const configInput = configModule.default;
+            if (!configInput || "object" != typeof configInput) return yield* Effect.fail(new ConfigInvalid({
+                path: configPath,
+                errors: [
+                    "Config file must export a default configuration object"
+                ]
+            }));
+            const config = defineConfig(configInput);
+            return {
+                config,
+                configPath,
+                usingDefaults: false
+            };
+        }),
+    resolve: (input = {})=>Effect.succeed(defineConfig(input)),
+    detectEntries: (cwd, entries)=>Effect.gen(function*() {
+            const detected = [];
+            const mainPath = entries?.main ?? DEFAULT_ENTRIES.main;
+            const absoluteMainPath = resolve(cwd, mainPath);
+            if (!existsSync(absoluteMainPath)) return yield* Effect.fail(new MainEntryMissing({
+                expectedPath: mainPath,
+                cwd
+            }));
+            detected.push({
+                type: "main",
+                path: absoluteMainPath,
+                output: "dist/main.js"
+            });
+            const preEntry = detectOptionalEntry(cwd, "pre", entries?.pre);
+            if (preEntry) detected.push(preEntry);
+            const postEntry = detectOptionalEntry(cwd, "post", entries?.post);
+            if (postEntry) detected.push(postEntry);
+            return {
+                success: true,
+                entries: detected
+            };
+        })
+});
+const BrandingIcon = Schema.Literal("activity", "airplay", "alert-circle", "alert-octagon", "alert-triangle", "align-center", "align-justify", "align-left", "align-right", "anchor", "aperture", "archive", "arrow-down-circle", "arrow-down-left", "arrow-down-right", "arrow-down", "arrow-left-circle", "arrow-left", "arrow-right-circle", "arrow-right", "arrow-up-circle", "arrow-up-left", "arrow-up-right", "arrow-up", "at-sign", "award", "bar-chart-2", "bar-chart", "battery-charging", "battery", "bell-off", "bell", "bluetooth", "bold", "book-open", "book", "bookmark", "box", "briefcase", "calendar", "camera-off", "camera", "cast", "check-circle", "check-square", "check", "chevron-down", "chevron-left", "chevron-right", "chevron-up", "chevrons-down", "chevrons-left", "chevrons-right", "chevrons-up", "circle", "clipboard", "clock", "cloud-drizzle", "cloud-lightning", "cloud-off", "cloud-rain", "cloud-snow", "cloud", "code", "command", "compass", "copy", "corner-down-left", "corner-down-right", "corner-left-down", "corner-left-up", "corner-right-down", "corner-right-up", "corner-up-left", "corner-up-right", "cpu", "credit-card", "crop", "crosshair", "database", "delete", "disc", "dollar-sign", "download-cloud", "download", "droplet", "edit-2", "edit-3", "edit", "external-link", "eye-off", "eye", "fast-forward", "feather", "file-minus", "file-plus", "file-text", "file", "film", "filter", "flag", "folder-minus", "folder-plus", "folder", "gift", "git-branch", "git-commit", "git-merge", "git-pull-request", "globe", "grid", "hard-drive", "hash", "headphones", "heart", "help-circle", "home", "image", "inbox", "info", "italic", "layers", "layout", "life-buoy", "link-2", "link", "list", "loader", "lock", "log-in", "log-out", "mail", "map-pin", "map", "maximize-2", "maximize", "menu", "message-circle", "message-square", "mic-off", "mic", "minimize-2", "minimize", "minus-circle", "minus-square", "minus", "monitor", "moon", "more-horizontal", "more-vertical", "move", "music", "navigation-2", "navigation", "octagon", "package", "paperclip", "pause-circle", "pause", "percent", "phone-call", "phone-forwarded", "phone-incoming", "phone-missed", "phone-off", "phone-outgoing", "phone", "pie-chart", "play-circle", "play", "plus-circle", "plus-square", "plus", "pocket", "power", "printer", "radio", "refresh-ccw", "refresh-cw", "repeat", "rewind", "rotate-ccw", "rotate-cw", "rss", "save", "scissors", "search", "send", "server", "settings", "share-2", "share", "shield-off", "shield", "shopping-bag", "shopping-cart", "shuffle", "sidebar", "skip-back", "skip-forward", "slash", "sliders", "smartphone", "speaker", "square", "star", "stop-circle", "sun", "sunrise", "sunset", "table", "tablet", "tag", "target", "terminal", "thermometer", "thumbs-down", "thumbs-up", "toggle-left", "toggle-right", "trash-2", "trash", "trending-down", "trending-up", "triangle", "truck", "tv", "type", "umbrella", "underline", "unlock", "upload-cloud", "upload", "user-check", "user-minus", "user-plus", "user-x", "user", "users", "video-off", "video", "voicemail", "volume-1", "volume-2", "volume-x", "volume", "watch", "wifi-off", "wifi", "wind", "x-circle", "x-square", "x", "zap-off", "zap", "zoom-in", "zoom-out");
+const ActionInput = Schema.Struct({
+    description: Schema.String,
+    required: Schema.optional(Schema.Boolean),
+    default: Schema.optional(Schema.String),
+    deprecationMessage: Schema.optional(Schema.String)
+});
+const ActionOutput = Schema.Struct({
+    description: Schema.String
+});
+const Runs = Schema.Struct({
+    using: Schema.Literal("node24"),
+    main: Schema.String,
+    pre: Schema.optional(Schema.String),
+    "pre-if": Schema.optional(Schema.String),
+    post: Schema.optional(Schema.String),
+    "post-if": Schema.optional(Schema.String)
+});
+const BrandingColor = Schema.Literal("white", "black", "yellow", "blue", "green", "orange", "red", "purple", "gray-dark");
+const Branding = Schema.Struct({
+    icon: Schema.optional(BrandingIcon),
+    color: Schema.optional(BrandingColor)
+});
+const ActionYml = Schema.Struct({
+    name: Schema.String,
+    description: Schema.String,
+    author: Schema.optional(Schema.String),
+    inputs: Schema.optional(Schema.Record({
+        key: Schema.String,
+        value: ActionInput
+    })),
+    outputs: Schema.optional(Schema.Record({
+        key: Schema.String,
+        value: ActionOutput
+    })),
+    runs: Runs,
+    branding: Schema.optional(Branding)
+});
+const ValidateOptionsSchema = Schema.Struct({
+    cwd: OptionalPathLikeSchema,
+    strict: Schema.optional(Schema.Boolean)
+});
+const ValidationErrorSchema = Schema.Struct({
+    code: Schema.String,
+    message: Schema.String,
+    file: Schema.optional(Schema.String),
+    suggestion: Schema.optional(Schema.String)
+});
+const ValidationWarningSchema = Schema.Struct({
+    code: Schema.String,
+    message: Schema.String,
+    file: Schema.optional(Schema.String),
+    suggestion: Schema.optional(Schema.String)
+});
+const ValidationResultSchema = Schema.Struct({
+    valid: Schema.Boolean,
+    errors: Schema.Array(ValidationErrorSchema),
+    warnings: Schema.Array(ValidationWarningSchema)
+});
+const ActionYmlResultSchema = Schema.Struct({
+    valid: Schema.Boolean,
+    content: Schema.optional(Schema.Any),
+    errors: Schema.Array(ValidationErrorSchema),
+    warnings: Schema.Array(ValidationWarningSchema)
+});
+const ValidationService = Context.GenericTag("ValidationService");
+const isCI = ()=>"true" === process.env.CI || "1" === process.env.CI || "true" === process.env.GITHUB_ACTIONS;
+const resolveStrict = (configStrict)=>configStrict ?? isCI();
+const makeWarning = (code, message, suggestion, file)=>void 0 !== file ? {
+        code,
+        message,
+        suggestion,
+        file
+    } : {
+        code,
+        message,
+        suggestion
+    };
+const formatSchemaErrors = (error, filePath)=>[
+        {
+            path: filePath,
+            message: ParseResult.TreeFormatter.formatErrorSync(error)
+        }
+    ];
+const ValidationServiceLive = Layer.effect(ValidationService, Effect.gen(function*() {
+    const configService = yield* ConfigService;
+    const readActionYml = (path)=>Effect.gen(function*() {
+            if (!existsSync(path)) return yield* new ActionYmlMissing({
+                cwd: path
+            });
+            const content = yield* Effect["try"]({
+                try: ()=>readFileSync(path, "utf8"),
+                catch: ()=>new ActionYmlSyntaxError({
+                        path,
+                        message: "Failed to read file"
+                    })
+            });
+            const parsed = yield* Effect["try"]({
+                try: ()=>parse(content),
+                catch: (error)=>new ActionYmlSyntaxError({
+                        path,
+                        message: error instanceof Error ? error.message : "Invalid YAML syntax"
+                    })
+            });
+            if (!parsed || "object" != typeof parsed) return yield* new ActionYmlSyntaxError({
+                path,
+                message: "action.yml must be an object"
+            });
+            return parsed;
+        });
+    const validateSchema = (parsed, path)=>Effect.gen(function*() {
+            const result = Schema.decodeUnknownEither(ActionYml)(parsed);
+            if ("Left" === result._tag) return yield* new ActionYmlSchemaError({
+                path,
+                errors: formatSchemaErrors(result.left, path)
+            });
+            return result.right;
+        });
+    const checkRecommendations = (content, filePath)=>{
+        const warnings = [];
+        if (content.branding) {
+            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));
+        } else warnings.push(makeWarning("ACTION_YML_NO_BRANDING", "No branding configuration found", "Add branding.icon and 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;
+    };
+    const validateActionYml = (path)=>Effect.gen(function*() {
+            const parsed = yield* readActionYml(path);
+            const content = yield* validateSchema(parsed, path);
+            const warnings = checkRecommendations(parsed, path);
+            return {
+                valid: true,
+                content,
+                errors: [],
+                warnings
+            };
+        });
+    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));
+            if ("Left" === result._tag && 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"
+            });
+            return errors;
+        });
+    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 ("Left" === result._tag) {
+                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
+            };
+        });
+    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 = 0 === errors.length && (!strict || 0 === warnings.length);
+                if (strict && warnings.length > 0 && 0 === errors.length) return yield* new ValidationFailed({
+                    errorCount: 0,
+                    warningCount: warnings.length,
+                    message: "Warnings treated as errors in strict mode"
+                });
+                return {
+                    valid,
+                    errors,
+                    warnings
+                };
+            }),
+        validateActionYml,
+        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 && 0 === result.errors.length && 0 === result.warnings.length) lines.push("\u2713 All checks passed");
+            return lines.join("\n");
+        },
+        isCI: ()=>Effect.succeed(isCI()),
+        isStrict: (configStrict)=>Effect.succeed(resolveStrict(configStrict))
+    };
+}));
+const ConfigLayer = ConfigServiceLive;
+const ValidationLayer = ValidationServiceLive.pipe(Layer.provide(ConfigServiceLive));
+const BuildLayer = BuildServiceLive.pipe(Layer.provide(ConfigServiceLive));
+const AppLayer = Layer.mergeAll(ConfigServiceLive, ValidationLayer, BuildLayer);
+export { ActionYmlMissing, ActionYmlMissingBase, ActionYmlResultSchema, ActionYmlSchemaError, ActionYmlSchemaErrorBase, ActionYmlSyntaxError, ActionYmlSyntaxErrorBase, AppLayer, BuildFailed, BuildFailedBase, BuildLayer, BuildOptionsSchema, BuildResultSchema, BuildRunnerOptionsSchema, BuildService, BundleFailed, BundleFailedBase, BundleResultSchema, BundleStatsSchema, CleanError, CleanErrorBase, ConfigInputSchema, ConfigInvalid, ConfigInvalidBase, ConfigLayer, ConfigLoadFailed, ConfigLoadFailedBase, ConfigNotFound, ConfigNotFoundBase, ConfigSchema, ConfigService, Console, DetectEntriesResultSchema, DetectedEntrySchema, Effect, EntriesSchema, EntryFileMissing, EntryFileMissingBase, Layer, LoadConfigOptionsSchema, MainEntryMissing, MainEntryMissingBase, ManagedRuntime, Option, Schema, ValidateOptionsSchema, ValidationErrorSchema, ValidationFailed, ValidationFailedBase, ValidationLayer, ValidationOptionsSchema, ValidationResultSchema, ValidationService, ValidationWarningSchema, WriteError, WriteErrorBase, defineConfig, existsSync, mkdirSync, resolve, writeFileSync };

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Savvy Web Strategy, LLC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.