@savvy-web/github-action-builder 0.1.3 → 0.2.0

package/123.js

@@ -1,8 +1,9 @@
 import { Console, Context, Data, Effect, Layer, ManagedRuntime, Option, ParseResult, Schema } from "effect";
-import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { createRequire } from "node:module";
-import { resolve } from "node:path";
+import { dirname, join, relative, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
+import { createHash } from "node:crypto";
 import { parse } from "yaml";
 const ConfigNotFoundBase = Data.TaggedError("ConfigNotFound");
 class ConfigNotFound extends ConfigNotFoundBase {
@@ -43,6 +44,12 @@ class CleanError extends CleanErrorBase {
 const BuildFailedBase = Data.TaggedError("BuildFailed");
 class BuildFailed extends BuildFailedBase {
 }
+const PersistLocalErrorBase = Data.TaggedError("PersistLocalError");
+class PersistLocalError extends PersistLocalErrorBase {
+}
+const ActionYmlPathErrorBase = Data.TaggedError("ActionYmlPathError");
+class ActionYmlPathError extends ActionYmlPathErrorBase {
+}
 function pathLikeToString(pathLike) {
     if ("string" == typeof pathLike) return pathLike;
     if (Buffer.isBuffer(pathLike)) return pathLike.toString("utf8");
@@ -109,6 +116,17 @@ const ValidationOptionsSchema = Schema.Struct({
     maxBundleSize: Schema.optional(Schema.String),
     strict: Schema.optional(Schema.Boolean)
 });
+const PersistLocalOptionsSchema = Schema.Struct({
+    enabled: Schema.optionalWith(Schema.Boolean, {
+        default: ()=>true
+    }),
+    path: Schema.optionalWith(Schema.String, {
+        default: ()=>".github/actions/local"
+    }),
+    actTemplate: Schema.optionalWith(Schema.Boolean, {
+        default: ()=>true
+    })
+});
 const ConfigInputSchema = Schema.Struct({
     entries: Schema.optional(Schema.Struct({
         main: Schema.optional(Schema.String),
@@ -126,18 +144,25 @@ const ConfigInputSchema = Schema.Struct({
         requireActionYml: Schema.optional(Schema.Boolean),
         maxBundleSize: Schema.optional(Schema.String),
         strict: Schema.optional(Schema.Boolean)
+    })),
+    persistLocal: Schema.optional(Schema.Struct({
+        enabled: Schema.optional(Schema.Boolean),
+        path: Schema.optional(Schema.String),
+        actTemplate: Schema.optional(Schema.Boolean)
     }))
 });
 const ConfigSchema = Schema.Struct({
     entries: EntriesSchema,
     build: BuildOptionsSchema,
-    validation: ValidationOptionsSchema
+    validation: ValidationOptionsSchema,
+    persistLocal: PersistLocalOptionsSchema
 });
 function defineConfig(config = {}) {
     return Schema.decodeUnknownSync(ConfigSchema)({
         entries: config.entries ?? {},
         build: config.build ?? {},
-        validation: config.validation ?? {}
+        validation: config.validation ?? {},
+        persistLocal: config.persistLocal ?? {}
     });
 }
 const LoadConfigOptionsSchema = Schema.Struct({
@@ -394,6 +419,213 @@ const ConfigServiceLive = Layer.succeed(ConfigService, {
             };
         })
 });
+const PersistLocalRunnerOptionsSchema = Schema.Struct({
+    cwd: Schema.optional(Schema.String)
+});
+const PersistLocalResultSchema = Schema.Struct({
+    success: Schema.Boolean,
+    filesCopied: Schema.Number,
+    filesSkipped: Schema.Number,
+    actTemplateGenerated: Schema.Boolean,
+    outputPath: Schema.String,
+    error: Schema.optional(Schema.String)
+});
+const PersistLocalService = Context.GenericTag("PersistLocalService");
+function fileHash(filePath) {
+    const content = readFileSync(filePath);
+    return createHash("sha256").update(content).digest("hex");
+}
+function syncFile(src, dest) {
+    if (existsSync(dest)) {
+        const srcHash = fileHash(src);
+        const destHash = fileHash(dest);
+        if (srcHash === destHash) return false;
+    }
+    mkdirSync(dirname(dest), {
+        recursive: true
+    });
+    copyFileSync(src, dest);
+    return true;
+}
+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;
+}
+function syncDirectory(srcDir, destDir) {
+    const stats = {
+        copied: 0,
+        skipped: 0
+    };
+    const srcFiles = walkDirectory(srcDir);
+    for (const relPath of srcFiles){
+        const copied = syncFile(join(srcDir, relPath), join(destDir, relPath));
+        if (copied) 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)){
+            const entries = readdirSync(parent);
+            if (0 === entries.length) {
+                rmSync(parent, {
+                    recursive: true
+                });
+                parent = dirname(parent);
+            } else break;
+        }
+    }
+    return stats;
+}
+function validateActionYmlPaths(actionYmlPath, destDir) {
+    return Effect.gen(function*() {
+        if (!existsSync(actionYmlPath)) return;
+        const content = readFileSync(actionYmlPath, "utf8");
+        const parsed = parse(content);
+        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: push
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - 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");
+}
+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
+                    }),
+                catch: (error)=>new PersistLocalError({
+                        path: outputPath,
+                        cause: error instanceof Error ? error.message : String(error)
+                    })
+            });
+            let totalCopied = 0;
+            let totalSkipped = 0;
+            const actionYmlSrc = resolve(cwd, "action.yml");
+            const actionYmlDest = resolve(outputPath, "action.yml");
+            if (existsSync(actionYmlSrc)) {
+                const copied = yield* Effect["try"]({
+                    try: ()=>syncFile(actionYmlSrc, actionYmlDest),
+                    catch: (error)=>new PersistLocalError({
+                            path: actionYmlSrc,
+                            cause: error instanceof Error ? error.message : String(error)
+                        })
+                });
+                if (copied) 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")),
+                    catch: (error)=>new PersistLocalError({
+                            path: distSrc,
+                            cause: error instanceof Error ? error.message : String(error)
+                        })
+                });
+                totalCopied += distStats.copied;
+                totalSkipped += distStats.skipped;
+            }
+            const destActionYml = resolve(outputPath, "action.yml");
+            yield* validateActionYmlPaths(destActionYml, 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"),
+                        catch: (error)=>new PersistLocalError({
+                                path: actrcPath,
+                                cause: error instanceof Error ? error.message : String(error)
+                            })
+                    });
+                    actTemplateGenerated = true;
+                }
+                if (!existsSync(actWorkflowPath)) {
+                    yield* Effect["try"]({
+                        try: ()=>{
+                            mkdirSync(dirname(actWorkflowPath), {
+                                recursive: true
+                            });
+                            writeFileSync(actWorkflowPath, ACT_WORKFLOW_CONTENT, "utf8");
+                        },
+                        catch: (error)=>new PersistLocalError({
+                                path: actWorkflowPath,
+                                cause: error instanceof Error ? error.message : String(error)
+                            })
+                    });
+                    actTemplateGenerated = true;
+                }
+            }
+            return {
+                success: true,
+                filesCopied: totalCopied,
+                filesSkipped: totalSkipped,
+                actTemplateGenerated,
+                outputPath
+            };
+        }),
+    formatResult: formatPersistResult
+});
 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,
@@ -642,5 +874,6 @@ const ValidationServiceLive = Layer.effect(ValidationService, Effect.gen(functio
 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 };
+const PersistLocalLayer = PersistLocalServiceLive;
+const AppLayer = Layer.mergeAll(ConfigServiceLive, ValidationLayer, BuildLayer, PersistLocalLayer);
+export { ActionYmlMissing, ActionYmlMissingBase, ActionYmlPathError, ActionYmlPathErrorBase, 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, PersistLocalError, PersistLocalErrorBase, PersistLocalLayer, PersistLocalOptionsSchema, PersistLocalResultSchema, PersistLocalRunnerOptionsSchema, PersistLocalService, Schema, ValidateOptionsSchema, ValidationErrorSchema, ValidationFailed, ValidationFailedBase, ValidationLayer, ValidationOptionsSchema, ValidationResultSchema, ValidationService, ValidationWarningSchema, WriteError, WriteErrorBase, defineConfig, existsSync, mkdirSync, resolve, writeFileSync };

package/README.md

@@ -14,6 +14,8 @@ production-ready Node.js 24 actions.
 - **Schema validation** - Validates `action.yml` against GitHub's official
   metadata specification
 - **Single-file bundles** - All dependencies inlined using @vercel/ncc
+- **Local testing** - Auto-persists build output for testing with
+  [nektos/act](https://github.com/nektos/act)
 - **CI-aware** - Strict validation in CI, warnings-only locally
 
 ## Quick Start
@@ -126,6 +128,7 @@ runs:
 
 - [Getting Started](./docs/getting-started.md) - Installation and first build
 - [Configuration](./docs/configuration.md) - All configuration options
+- [Local Testing](./docs/local-testing.md) - Testing with nektos/act
 - [CLI Reference](./docs/cli-reference.md) - Complete command reference
 - [Architecture](./docs/architecture.md) - How it works internally
 - [Troubleshooting](./docs/troubleshooting.md) - Common issues and solutions

package/bin/github-action-builder.js

@@ -1,14 +1,16 @@
 #!/usr/bin/env node
 import { Args, Command, Options } from "@effect/cli";
 import { NodeContext, NodeRuntime } from "@effect/platform-node";
-import { Layer, AppLayer, BuildService, ValidationService, ConfigService, Effect, existsSync, resolve, mkdirSync, writeFileSync, Console, Option } from "../123.js";
+import { Layer, writeFileSync, AppLayer, BuildService, ConfigService, ValidationService, Effect, existsSync, resolve, mkdirSync, PersistLocalService, Console, Option } from "../123.js";
 const configOption = Options.file("config").pipe(Options.withAlias("c"), Options.withDescription("Path to configuration file"), Options.optional);
 const quietOption = Options.boolean("quiet").pipe(Options.withAlias("q"), Options.withDescription("Suppress non-error output"), Options.withDefault(false));
 const noValidateOption = Options.boolean("no-validate").pipe(Options.withDescription("Skip validation step"), Options.withDefault(false));
-const buildHandler = ({ config, quiet, noValidate })=>Effect.gen(function*() {
+const noPersistOption = Options.boolean("no-persist").pipe(Options.withDescription("Skip persisting build output to local action directory"), Options.withDefault(false));
+const buildHandler = ({ config, quiet, noValidate, noPersist })=>Effect.gen(function*() {
         const configService = yield* ConfigService;
         const validationService = yield* ValidationService;
         const buildService = yield* BuildService;
+        const persistLocalService = yield* PersistLocalService;
         const cwd = process.cwd();
         if (!quiet) yield* Console.log("Loading configuration...");
         const loadOptions = Option.isSome(config) ? {
@@ -44,17 +46,25 @@ const buildHandler = ({ config, quiet, noValidate })=>Effect.gen(function*() {
             yield* Console.log(`\n${buildService.formatResult(buildResult)}`);
             yield* Console.log("\nBuild completed successfully!");
         }
+        if (!noPersist && configResult.config.persistLocal.enabled) {
+            if (!quiet) yield* Console.log("\nPersisting to local action directory...");
+            const persistResult = yield* persistLocalService.persist(configResult.config, {
+                cwd
+            });
+            if (!quiet && persistResult.success) yield* Console.log(persistLocalService.formatResult(persistResult));
+        }
     });
 const buildCommand = Command.make("build", {
     config: configOption,
     quiet: quietOption,
-    noValidate: noValidateOption
+    noValidate: noValidateOption,
+    noPersist: noPersistOption
 }, buildHandler);
 const actionNameArg = Args.text({
     name: "action-name"
 }).pipe(Args.withDescription("Name of the GitHub Action (also the output directory)"));
 const forceOption = Options.boolean("force").pipe(Options.withAlias("f"), Options.withDescription("Overwrite existing files"), Options.withDefault(false));
-const getPackageVersion = ()=>"0.1.3";
+const getPackageVersion = ()=>"0.2.0";
 const generatePackageJson = (name)=>{
     const version = getPackageVersion();
     const pkg = {
@@ -287,7 +297,7 @@ const rootCommand = Command.make("github-action-builder").pipe(Command.withSubco
 ]));
 const cli = Command.run(rootCommand, {
     name: "github-action-builder",
-    version: "0.1.3"
+    version: "0.2.0"
 });
 const CliLayer = Layer.merge(AppLayer, NodeContext.layer);
 const main = Effect.suspend(()=>cli(process.argv)).pipe(Effect.provide(CliLayer));

package/index.d.ts

@@ -83,6 +83,41 @@ export declare const ActionYmlMissingBase: new <A extends Record<string, any> =
     readonly _tag: "ActionYmlMissing";
 } & Readonly<A>;
 
+/**
+ * Error when action.yml runs paths don't resolve correctly in destination.
+ *
+ * @public
+ */
+export declare class ActionYmlPathError extends ActionYmlPathErrorBase<{
+    /**
+     * The entry type whose path failed validation (main, pre, post).
+     */
+    readonly entryType: string;
+    /**
+     * The path specified in action.yml.
+     */
+    readonly specifiedPath: string;
+    /**
+     * The expected resolved path.
+     */
+    readonly expectedPath: string;
+}> {
+}
+
+/**
+ * Base class for ActionYmlPathError error.
+ *
+ * @privateRemarks
+ * This export is required for api-extractor documentation generation.
+ * Effect's Data.TaggedError creates an anonymous base class that must be
+ * explicitly exported to avoid "forgotten export" warnings. Do not delete.
+ *
+ * @internal
+ */
+export declare const ActionYmlPathErrorBase: new <A extends Record<string, any> = {}>(args: Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => YieldableError & {
+    readonly _tag: "ActionYmlPathError";
+} & Readonly<A>;
+
 /**
  * Result of action.yml validation.
  * @public
@@ -200,13 +235,14 @@ export declare const ActionYmlSyntaxErrorBase: new <A extends Record<string, any
  *
  * @public
  */
-export declare type AppError = ConfigError | ValidationError | BuildError;
+export declare type AppError = ConfigError | ValidationError | BuildError | PersistError;
 
 /**
  * Combined layer providing all services.
  *
  * @remarks
- * This layer composes ConfigService, ValidationService, and BuildService.
+ * This layer composes ConfigService, ValidationService, BuildService,
+ * and PersistLocalService.
  * Use this when you need access to all services in your Effect program.
  *
  * @example Using AppLayer with Effect
@@ -229,7 +265,7 @@ export declare type AppError = ConfigError | ValidationError | BuildError;
  *
  * @public
  */
-export declare const AppLayer: Layer.Layer<BuildService | ConfigService | ValidationService, never, never>;
+export declare const AppLayer: Layer.Layer<BuildService | ConfigService | PersistLocalService | ValidationService, never, never>;
 
 /**
  * Union of all build-related errors.
@@ -618,6 +654,11 @@ export declare const ConfigInputSchema: Schema.Struct<{
         maxBundleSize: Schema.optional<typeof Schema.String>;
         strict: Schema.optional<typeof Schema.Boolean>;
     }>>;
+    persistLocal: Schema.optional<Schema.Struct<{
+        enabled: Schema.optional<typeof Schema.Boolean>;
+        path: Schema.optional<typeof Schema.String>;
+        actTemplate: Schema.optional<typeof Schema.Boolean>;
+    }>>;
 }>;
 
 /**
@@ -771,6 +812,20 @@ export declare const ConfigSchema: Schema.Struct<{
         /** Treat warnings as errors. Auto-detects from CI when undefined. */
         strict: Schema.optional<typeof Schema.Boolean>;
     }>;
+    persistLocal: Schema.Struct<{
+        /** Enable persisting build output locally. Defaults to true. */
+        enabled: Schema.optionalWith<typeof Schema.Boolean, {
+            default: () => true;
+        }>;
+        /** Path for the local action directory, relative to cwd. Defaults to ".github/actions/local". */
+        path: Schema.optionalWith<typeof Schema.String, {
+            default: () => string;
+        }>;
+        /** Generate act boilerplate files (.actrc, act-test.yml) if they don't exist. Defaults to true. */
+        actTemplate: Schema.optionalWith<typeof Schema.Boolean, {
+            default: () => true;
+        }>;
+    }>;
 }>;
 
 /**
@@ -1221,6 +1276,15 @@ export declare const GitHubActionBuildResultSchema: Schema.Struct<{
             suggestion: Schema.optional<typeof Schema.String>;
         }>>;
     }>>;
+    /** Persist-local result if persist was performed. */
+    persistLocal: Schema.optional<Schema.Struct<{
+        success: typeof Schema.Boolean;
+        filesCopied: typeof Schema.Number;
+        filesSkipped: typeof Schema.Number;
+        actTemplateGenerated: typeof Schema.Boolean;
+        outputPath: typeof Schema.String;
+        error: Schema.optional<typeof Schema.String>;
+    }>>;
     /** Error message if the build or validation failed. */
     error: Schema.optional<typeof Schema.String>;
 }>;
@@ -1271,7 +1335,7 @@ export declare interface GitHubActionOptions {
      * @remarks
      * Advanced option for testing or customizing service implementations.
      */
-    layer?: Layer.Layer<ConfigService | ValidationService | BuildService>;
+    layer?: Layer.Layer<ConfigService | ValidationService | BuildService | PersistLocalService>;
 }
 
 /**
@@ -1335,6 +1399,163 @@ export declare const MainEntryMissingBase: new <A extends Record<string, any> =
     readonly _tag: "MainEntryMissing";
 } & Readonly<A>;
 
+/**
+ * Union of all persist-local-related errors.
+ *
+ * @public
+ */
+export declare type PersistError = PersistLocalError | ActionYmlPathError;
+
+/**
+ * Error when persisting build output to local action directory fails.
+ *
+ * @public
+ */
+export declare class PersistLocalError extends PersistLocalErrorBase<{
+    /**
+     * The path involved in the failure.
+     */
+    readonly path: string;
+    /**
+     * The underlying error message.
+     */
+    readonly cause: string;
+}> {
+}
+
+/**
+ * Base class for PersistLocalError error.
+ *
+ * @privateRemarks
+ * This export is required for api-extractor documentation generation.
+ * Effect's Data.TaggedError creates an anonymous base class that must be
+ * explicitly exported to avoid "forgotten export" warnings. Do not delete.
+ *
+ * @internal
+ */
+export declare const PersistLocalErrorBase: new <A extends Record<string, any> = {}>(args: Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => YieldableError & {
+    readonly _tag: "PersistLocalError";
+} & Readonly<A>;
+
+/**
+ * Layer providing PersistLocalService (no dependencies).
+ *
+ * @remarks
+ * Use this layer when you only need persist-local functionality.
+ *
+ * @public
+ */
+export declare const PersistLocalLayer: Layer.Layer<PersistLocalService, never, never>;
+
+/**
+ * Persist-local options for copying build output.
+ *
+ * @public
+ */
+export declare type PersistLocalOptions = typeof PersistLocalOptionsSchema.Type;
+
+/**
+ * Schema for persist-local options.
+ *
+ * @remarks
+ * Controls automatic copying of build output to a local action directory
+ * for testing with nektos/act.
+ *
+ * @internal
+ */
+export declare const PersistLocalOptionsSchema: Schema.Struct<{
+    /** Enable persisting build output locally. Defaults to true. */
+    enabled: Schema.optionalWith<typeof Schema.Boolean, {
+        default: () => true;
+    }>;
+    /** Path for the local action directory, relative to cwd. Defaults to ".github/actions/local". */
+    path: Schema.optionalWith<typeof Schema.String, {
+        default: () => string;
+    }>;
+    /** Generate act boilerplate files (.actrc, act-test.yml) if they don't exist. Defaults to true. */
+    actTemplate: Schema.optionalWith<typeof Schema.Boolean, {
+        default: () => true;
+    }>;
+}>;
+
+/**
+ * Result of the persist-local operation.
+ * @public
+ */
+export declare type PersistLocalResult = typeof PersistLocalResultSchema.Type;
+
+/**
+ * Result of the persist-local operation.
+ * @internal
+ */
+export declare const PersistLocalResultSchema: Schema.Struct<{
+    /** Whether the operation completed successfully. */
+    success: typeof Schema.Boolean;
+    /** Number of files copied (changed or new). */
+    filesCopied: typeof Schema.Number;
+    /** Number of files skipped (unchanged). */
+    filesSkipped: typeof Schema.Number;
+    /** Whether act template files were generated. */
+    actTemplateGenerated: typeof Schema.Boolean;
+    /** Output path where files were persisted. */
+    outputPath: typeof Schema.String;
+    /** Error message if failed. */
+    error: Schema.optional<typeof Schema.String>;
+}>;
+
+/**
+ * Options for the persist operation.
+ * @public
+ */
+export declare type PersistLocalRunnerOptions = typeof PersistLocalRunnerOptionsSchema.Type;
+
+/**
+ * Options for the persist operation.
+ * @internal
+ */
+export declare const PersistLocalRunnerOptionsSchema: Schema.Struct<{
+    /** Working directory. Accepts string. */
+    cwd: Schema.optional<typeof Schema.String>;
+}>;
+
+/**
+ * PersistLocalService interface for copying build output locally.
+ *
+ * @remarks
+ * This service handles:
+ * - Smart-syncing action.yml and dist/ to a local action directory
+ * - Hash-based comparison to avoid unnecessary copies
+ * - Removing stale files in the destination
+ * - Validating action.yml runs paths resolve in the destination
+ * - Generating act boilerplate files
+ *
+ * @public
+ */
+export declare interface PersistLocalService {
+    /**
+     * Persist build output to the local action directory.
+     *
+     * @param config - Configuration with persistLocal options
+     * @param options - Runner options (cwd, etc.)
+     * @returns Effect that resolves to persist result
+     */
+    readonly persist: (config: Config, options?: PersistLocalRunnerOptions) => Effect.Effect<PersistLocalResult, PersistLocalError | ActionYmlPathError>;
+    /**
+     * Format persist result for display.
+     *
+     * @param result - Persist result to format
+     * @returns Formatted string for terminal output
+     */
+    readonly formatResult: (result: PersistLocalResult) => string;
+}
+
+/**
+ * PersistLocalService tag for dependency injection.
+ *
+ * @public
+ */
+export declare const PersistLocalService: Context.Tag<PersistLocalService, PersistLocalService>;
+
 /**
  * Options for validation.
  * @public

package/index.js

@@ -1,8 +1,9 @@
-import { Schema, AppLayer, BuildService, ConfigService, ValidationService, Effect, BuildResultSchema, ValidationResultSchema, ManagedRuntime, defineConfig } from "./123.js";
+import { Schema, AppLayer, BuildService, ConfigService, ValidationService, Effect, BuildResultSchema, PersistLocalResultSchema, ValidationResultSchema, ManagedRuntime, defineConfig, PersistLocalService } from "./123.js";
 const GitHubActionBuildResultSchema = Schema.Struct({
     success: Schema.Boolean,
     build: Schema.optional(BuildResultSchema),
     validation: Schema.optional(ValidationResultSchema),
+    persistLocal: Schema.optional(PersistLocalResultSchema),
     error: Schema.optional(Schema.String)
 });
 class GitHubAction {
@@ -94,14 +95,26 @@ class GitHubAction {
                     error: buildResult.error ?? "Build failed"
                 };
             }
+            let persistLocalResult;
+            if (config.persistLocal.enabled) {
+                const persistProgram = Effect.gen(function*() {
+                    const persistLocalService = yield* PersistLocalService;
+                    return yield* persistLocalService.persist(config, {
+                        cwd
+                    });
+                });
+                persistLocalResult = await this.runtime.runPromise(persistProgram);
+            }
             if (validationResult) return {
                 success: true,
                 build: buildResult,
-                validation: validationResult
+                validation: validationResult,
+                persistLocal: persistLocalResult
             };
             return {
                 success: true,
-                build: buildResult
+                build: buildResult,
+                persistLocal: persistLocalResult
             };
         } catch (error) {
             return {
@@ -114,5 +127,5 @@ class GitHubAction {
         await this.runtime.dispose();
     }
 }
-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, DetectEntriesResultSchema, DetectedEntrySchema, EntriesSchema, EntryFileMissing, EntryFileMissingBase, LoadConfigOptionsSchema, MainEntryMissing, MainEntryMissingBase, ValidateOptionsSchema, ValidationErrorSchema, ValidationFailed, ValidationFailedBase, ValidationLayer, ValidationOptionsSchema, ValidationResultSchema, ValidationService, ValidationWarningSchema, WriteError, WriteErrorBase, defineConfig } from "./123.js";
+export { ActionYmlMissing, ActionYmlMissingBase, ActionYmlPathError, ActionYmlPathErrorBase, 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, DetectEntriesResultSchema, DetectedEntrySchema, EntriesSchema, EntryFileMissing, EntryFileMissingBase, LoadConfigOptionsSchema, MainEntryMissing, MainEntryMissingBase, PersistLocalError, PersistLocalErrorBase, PersistLocalLayer, PersistLocalOptionsSchema, PersistLocalResultSchema, PersistLocalRunnerOptionsSchema, PersistLocalService, ValidateOptionsSchema, ValidationErrorSchema, ValidationFailed, ValidationFailedBase, ValidationLayer, ValidationOptionsSchema, ValidationResultSchema, ValidationService, ValidationWarningSchema, WriteError, WriteErrorBase, defineConfig } from "./123.js";
 export { GitHubAction, GitHubActionBuildResultSchema };

package/package.json

@@ -1,86 +1,86 @@
 {
-	"name": "@savvy-web/github-action-builder",
-	"version": "0.1.3",
-	"private": false,
-	"description": "A zero-config build tool for creating GitHub Actions from TypeScript. Bundles with @vercel/ncc, validates action.yml against GitHub's schema, and outputs production-ready Node.js 24 actions.",
-	"keywords": [
-		"github-actions",
-		"github",
-		"actions",
-		"ncc",
-		"vercel-ncc",
-		"bundler",
-		"typescript",
-		"node24",
-		"cli",
-		"build-tool",
-		"action-builder",
-		"effect-ts",
-		"esm"
-	],
-	"homepage": "https://github.com/savvy-web/github-action-builder#readme",
-	"bugs": {
-		"url": "https://github.com/savvy-web/github-action-builder/issues"
-	},
-	"repository": {
-		"type": "git",
-		"url": "git+https://github.com/savvy-web/github-action-builder.git"
-	},
-	"license": "MIT",
-	"author": {
-		"name": "C. Spencer Beggs",
-		"email": "spencer@savvyweb.systems",
-		"url": "https://savvyweb.systems"
-	},
-	"type": "module",
-	"exports": {
-		".": {
-			"types": "./index.d.ts",
-			"import": "./index.js"
-		}
-	},
-	"bin": {
-		"github-action-builder": "./bin/github-action-builder.js"
-	},
-	"dependencies": {
-		"@effect/cli": "^0.73.1",
-		"@effect/platform": "^0.94.2",
-		"@effect/platform-node": "^0.104.1",
-		"@effect/printer": "^0.47.0",
-		"@effect/printer-ansi": "^0.47.0",
-		"@effect/typeclass": "^0.38.0",
-		"@vercel/ncc": "^0.38.4",
-		"effect": "^3.19.15",
-		"picocolors": "^1.1.1",
-		"yaml": "^2.8.2"
-	},
-	"peerDependencies": {
-		"@types/node": "^25.2.3",
-		"@typescript/native-preview": "7.0.0-dev.20260214.1",
-		"typescript": "^5.9.3"
-	},
-	"peerDependenciesMeta": {
-		"@types/node": {
-			"optional": false
-		},
-		"@typescript/native-preview": {
-			"optional": false
-		},
-		"typescript": {
-			"optional": false
-		}
-	},
-	"files": [
-		"!github-action-builder.api.json",
-		"!tsconfig.json",
-		"!tsdoc.json",
-		"123.js",
-		"LICENSE",
-		"README.md",
-		"bin/github-action-builder.js",
-		"index.d.ts",
-		"index.js",
-		"package.json",
-		"tsdoc-metadata.json"
-	]
-}
+  "name": "@savvy-web/github-action-builder",
+  "version": "0.2.0",
+  "private": false,
+  "description": "A zero-config build tool for creating GitHub Actions from TypeScript. Bundles with @vercel/ncc, validates action.yml against GitHub's schema, and outputs production-ready Node.js 24 actions.",
+  "keywords": [
+    "github-actions",
+    "github",
+    "actions",
+    "ncc",
+    "vercel-ncc",
+    "bundler",
+    "typescript",
+    "node24",
+    "cli",
+    "build-tool",
+    "action-builder",
+    "effect-ts",
+    "esm"
+  ],
+  "homepage": "https://github.com/savvy-web/github-action-builder#readme",
+  "bugs": {
+    "url": "https://github.com/savvy-web/github-action-builder/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/savvy-web/github-action-builder.git"
+  },
+  "license": "MIT",
+  "author": {
+    "name": "C. Spencer Beggs",
+    "email": "spencer@savvyweb.systems",
+    "url": "https://savvyweb.systems"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./index.js"
+    }
+  },
+  "bin": {
+    "github-action-builder": "./bin/github-action-builder.js"
+  },
+  "dependencies": {
+    "@effect/cli": "^0.73.1",
+    "@effect/platform": "^0.94.2",
+    "@effect/platform-node": "^0.104.1",
+    "@effect/printer": "^0.47.0",
+    "@effect/printer-ansi": "^0.47.0",
+    "@effect/typeclass": "^0.38.0",
+    "@vercel/ncc": "^0.38.4",
+    "effect": "^3.19.19",
+    "picocolors": "^1.1.1",
+    "yaml": "^2.8.2"
+  },
+  "peerDependencies": {
+    "@types/node": "^25.2.0",
+    "@typescript/native-preview": "^7.0.0-dev.20260124.1",
+    "typescript": "^5.9.3"
+  },
+  "peerDependenciesMeta": {
+    "@types/node": {
+      "optional": false
+    },
+    "@typescript/native-preview": {
+      "optional": false
+    },
+    "typescript": {
+      "optional": false
+    }
+  },
+  "files": [
+    "!github-action-builder.api.json",
+    "!tsconfig.json",
+    "!tsdoc.json",
+    "123.js",
+    "LICENSE",
+    "README.md",
+    "bin/github-action-builder.js",
+    "index.d.ts",
+    "index.js",
+    "package.json",
+    "tsdoc-metadata.json"
+  ]
+}