@ykdz/template 0.0.0 → 0.0.1

package/dist/cli.js

@@ -8,6 +8,7 @@ import { initTsLibProject } from "./ts-lib.js";
 import { initVueHonoAppProject } from "./vue-hono-app.js";
 import { initVueAppProject } from "./vue-app.js";
 import { addPackage } from "./package-addition.js";
+import { planPostCommands, runPostCommands } from "./post-commands.js";
 import { blueprintJsonSchema, builtInPresets, presetFileJsonSchema, validatePresetFile, validateProjectBlueprint } from "./declarations.js";
 function usage() {
     return [
@@ -25,6 +26,7 @@ function usage() {
         "  --name <name>    Package name to add",
         "  --scope <name>   Package scope for workspace package names",
         "  --yes            Accept defaults for non-interactive generation",
+        "  --ready          Run template-maintained Post Commands after writing files",
         "  --dry-run        Print the planned generation without writing files",
         "  --json           Print machine-readable output"
     ].join("\n");
@@ -61,6 +63,7 @@ function parseInitOptions(args) {
     let yes = false;
     let dryRun = false;
     let json = false;
+    let ready = false;
     let scope;
     for (let index = 2; index < args.length; index += 1) {
         const arg = args[index];
@@ -72,6 +75,10 @@ function parseInitOptions(args) {
             dryRun = true;
             continue;
         }
+        if (arg === "--ready") {
+            ready = true;
+            continue;
+        }
         if (arg === "--json") {
             json = true;
             continue;
@@ -99,7 +106,7 @@ function parseInitOptions(args) {
     if (!dir) {
         throw new Error("init requires a target directory");
     }
-    return { dir, preset, yes, dryRun, json, scope };
+    return { dir, preset, yes, dryRun, json, ready, scope };
 }
 function normalizeNpmScope(value) {
     if (value !== value.trim() || /\s/.test(value)) {
@@ -164,6 +171,18 @@ function formatBlueprintSummary(targetDir, blueprint) {
     lines.push(`  Features: ${blueprint.features.join(", ")}`);
     return lines.join("\n");
 }
+function formatPostCommand(command) {
+    return [command.command, ...command.args].join(" ");
+}
+function formatPostCommandPlan(commands) {
+    if (commands.length === 0) {
+        return ["Post Commands:", "  (none)"].join("\n");
+    }
+    return [
+        "Post Commands:",
+        ...commands.map((command) => `  ${command.label}: ${formatPostCommand(command)}`)
+    ].join("\n");
+}
 function nextStepsForPreset(preset) {
     if (preset === "rust-bin") {
         return ["cd <target>", "./scripts/check"];
@@ -176,19 +195,78 @@ function formatNextSteps(targetDir, preset) {
         ...nextStepsForPreset(preset).map((step) => `  ${step.replace("<target>", targetDir)}`)
     ].join("\n");
 }
-function printInitComplete(options, blueprint) {
+function postCommandReport(planned, executions, skipped) {
+    return {
+        planned: planned.map((command) => ({
+            id: command.id,
+            label: command.label,
+            command: command.command,
+            args: [...command.args],
+            cwd: command.cwd
+        })),
+        run: executions
+            .filter((execution) => execution.status === "run")
+            .map((execution) => ({
+            id: execution.command.id,
+            exitCode: execution.exitCode
+        })),
+        failed: executions
+            .filter((execution) => execution.status === "failed")
+            .map((execution) => ({
+            id: execution.command.id,
+            exitCode: execution.exitCode,
+            error: execution.error
+        })),
+        skipped
+    };
+}
+function failedPostCommand(executions) {
+    return executions.find((execution) => execution.status === "failed");
+}
+function skippedPostCommands(commands, reason) {
+    return commands.map((command) => ({ id: command.id, reason }));
+}
+async function generateInitProject(options) {
+    if (options.preset === "ts-lib") {
+        await initTsLibProject(options.dir);
+        return;
+    }
+    if (options.preset === "hono-api") {
+        await initHonoApiProject(options.dir);
+        return;
+    }
+    if (options.preset === "vue-app") {
+        await initVueAppProject(options.dir);
+        return;
+    }
+    if (options.preset === "vue-hono-app") {
+        await initVueHonoAppProject(options.dir, { scope: options.scope });
+        return;
+    }
+    if (options.preset === "rust-bin") {
+        await initRustBinProject(options.dir);
+        return;
+    }
+    throw new Error("Only the ts-lib, hono-api, vue-app, vue-hono-app, and rust-bin presets are supported in this version");
+}
+function printInitComplete(options, blueprint, report) {
     const preset = blueprint.preset;
     if (options.json) {
         printJson({
             command: "init",
             dryRun: false,
+            ready: options.ready,
             targetDir: options.dir,
             blueprint,
+            postCommands: report,
             nextSteps: nextStepsForPreset(preset).map((step) => step.replace("<target>", options.dir))
         });
         return;
     }
     console.log(`Initialized ${options.preset} project in ${options.dir}`);
+    if (options.ready) {
+        console.log(formatPostCommandPlan(report.planned));
+    }
     console.log(formatNextSteps(options.dir, preset));
 }
 function isInteractiveTerminal() {
@@ -287,16 +365,23 @@ async function main(args) {
         const options = parseInitOptions(args);
         const blueprint = blueprintForInit(options);
         if (options.dryRun) {
+            const postCommandPlan = planPostCommands({
+                preset: blueprint.preset,
+                targetDir: options.dir
+            });
             if (options.json) {
                 printJson({
                     command: "init",
                     dryRun: true,
+                    ready: options.ready,
                     targetDir: options.dir,
-                    blueprint
+                    blueprint,
+                    postCommands: postCommandReport(postCommandPlan.commands, [], skippedPostCommands(postCommandPlan.commands, "dry-run"))
                 });
                 return;
             }
             console.log(formatBlueprintSummary(options.dir, blueprint));
+            console.log(formatPostCommandPlan(postCommandPlan.commands));
             return;
         }
         if (!options.yes && (options.json || !isInteractiveTerminal())) {
@@ -305,32 +390,20 @@ async function main(args) {
         if (!options.yes && !(await confirmInit(options.dir, blueprint))) {
             throw new Error("Init cancelled");
         }
-        if (options.preset === "ts-lib") {
-            await initTsLibProject(options.dir);
-            printInitComplete(options, blueprint);
-            return;
-        }
-        if (options.preset === "hono-api") {
-            await initHonoApiProject(options.dir);
-            printInitComplete(options, blueprint);
-            return;
-        }
-        if (options.preset === "vue-app") {
-            await initVueAppProject(options.dir);
-            printInitComplete(options, blueprint);
-            return;
-        }
-        if (options.preset === "vue-hono-app") {
-            await initVueHonoAppProject(options.dir, { scope: options.scope });
-            printInitComplete(options, blueprint);
-            return;
-        }
-        if (options.preset === "rust-bin") {
-            await initRustBinProject(options.dir);
-            printInitComplete(options, blueprint);
-            return;
+        const postCommandPlan = planPostCommands({
+            preset: blueprint.preset,
+            targetDir: options.dir
+        });
+        await generateInitProject(options);
+        const executions = options.ready ? await runPostCommands({ plan: postCommandPlan }) : [];
+        const failedExecution = failedPostCommand(executions);
+        printInitComplete(options, blueprint, postCommandReport(postCommandPlan.commands, executions, options.ready
+            ? []
+            : skippedPostCommands(postCommandPlan.commands, "ready-mode-not-requested")));
+        if (failedExecution) {
+            throw new Error(failedExecution.error);
         }
-        throw new Error("Only the ts-lib, hono-api, vue-app, vue-hono-app, and rust-bin presets are supported in this version");
+        return;
     }
     if (command === "add" && args[1] === "package") {
         const options = parseAddPackageOptions(args);

package/dist/hono-api.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hono-api.d.ts","sourceRoot":"","sources":["../src/hono-api.ts"],"names":[],"mappings":"AAwPA,wBAAsB,kBAAkB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAMzE"}
+{"version":3,"file":"hono-api.d.ts","sourceRoot":"","sources":["../src/hono-api.ts"],"names":[],"mappings":"AAiNA,wBAAsB,kBAAkB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAOzE"}

package/dist/hono-api.js

@@ -50,7 +50,7 @@ function packageJson(projectName) {
             vitest: "catalog:"
         },
         engines: {
-            node: ">=22.0.0"
+            node: "22"
         },
         packageManager: "pnpm@10.0.0"
     };
@@ -114,24 +114,16 @@ function operationsForHonoApi(projectName) {
             }
         },
         {
-            kind: "writeJson",
-            to: ".oxlintrc.json",
-            value: {
-                categories: {
-                    correctness: "error",
-                    suspicious: "error"
-                },
-                plugins: ["typescript", "oxc"]
-            }
+            kind: "copyFile",
+            sourceRoot: "sharedOxc",
+            from: "node/oxlint.config.ts",
+            to: "oxlint.config.ts"
         },
         {
-            kind: "writeJson",
-            to: ".oxfmtrc.json",
-            value: {
-                printWidth: 100,
-                singleQuote: false,
-                trailingComma: "none"
-            }
+            kind: "copyFile",
+            sourceRoot: "sharedOxc",
+            from: "oxfmt.config.ts",
+            to: "oxfmt.config.ts"
         },
         {
             kind: "writeText",
@@ -189,58 +181,27 @@ function operationsForHonoApi(projectName) {
             }
         },
         {
-            kind: "writeText",
+            kind: "copyFile",
+            from: ".github/workflows/check.yml",
             to: ".github/workflows/check.yml",
-            text: [
-                "name: Check",
-                "",
-                "on:",
-                "  pull_request:",
-                "  push:",
-                "    branches:",
-                "      - main",
-                "",
-                "jobs:",
-                "  check:",
-                "    runs-on: ubuntu-latest",
-                "    steps:",
-                "      - uses: actions/checkout@v4",
-                "      - uses: pnpm/action-setup@v4",
-                "        with:",
-                "          version: 10.0.0",
-                "      - uses: actions/setup-node@v4",
-                "        with:",
-                "          node-version: 22",
-                "      - run: pnpm install",
-                "      - run: pnpm run check",
-                ""
-            ].join("\n")
         },
         {
-            kind: "writeText",
+            kind: "copyFile",
+            from: ".github/dependabot.yml",
             to: ".github/dependabot.yml",
-            text: [
-                "version: 2",
-                "updates:",
-                "  - package-ecosystem: npm",
-                "    directory: /",
-                "    schedule:",
-                "      interval: weekly",
-                "  - package-ecosystem: github-actions",
-                "    directory: /",
-                "    schedule:",
-                "      interval: weekly",
-                ""
-            ].join("\n")
         }
     ];
 }
 function templateSourceRoot() {
     return path.join(path.dirname(fileURLToPath(import.meta.url)), "..", "templates", "hono-api");
 }
+function sharedOxcSourceRoot() {
+    return path.join(path.dirname(fileURLToPath(import.meta.url)), "..", "templates", "shared", "oxc");
+}
 export async function initHonoApiProject(targetDir) {
     await renderNewProject({
         sourceRoot: templateSourceRoot(),
+        sourceRoots: { sharedOxc: sharedOxcSourceRoot() },
         targetRoot: targetDir,
         operations: operationsForHonoApi(projectNameFromDir(targetDir))
     });

package/dist/package-addition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"package-addition.d.ts","sourceRoot":"","sources":["../src/package-addition.ts"],"names":[],"mappings":"AAMA,MAAM,MAAM,iBAAiB,GAAG;IAC9B,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAyoBF,wBAAsB,UAAU,CAAC,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC,CA0C1E"}
+{"version":3,"file":"package-addition.d.ts","sourceRoot":"","sources":["../src/package-addition.ts"],"names":[],"mappings":"AAMA,MAAM,MAAM,iBAAiB,GAAG;IAC9B,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAqnBF,wBAAsB,UAAU,CAAC,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC,CA2C1E"}

package/dist/package-addition.js

@@ -71,7 +71,7 @@ function tsLibPackageJson(packageName) {
             typescript: "catalog:"
         },
         engines: {
-            node: ">=22.0.0"
+            node: "22"
         }
     };
 }
@@ -108,24 +108,16 @@ function tsLibPackageOperations(packagePath, packageName) {
             }
         },
         {
-            kind: "writeJson",
-            to: `${packagePath}/.oxlintrc.json`,
-            value: {
-                categories: {
-                    correctness: "error",
-                    suspicious: "error"
-                },
-                plugins: ["typescript", "oxc"]
-            }
+            kind: "copyFile",
+            sourceRoot: "sharedOxc",
+            from: "node/oxlint.config.ts",
+            to: `${packagePath}/oxlint.config.ts`
         },
         {
-            kind: "writeJson",
-            to: `${packagePath}/.oxfmtrc.json`,
-            value: {
-                printWidth: 100,
-                singleQuote: false,
-                trailingComma: "none"
-            }
+            kind: "copyFile",
+            sourceRoot: "sharedOxc",
+            from: "oxfmt.config.ts",
+            to: `${packagePath}/oxfmt.config.ts`
         },
         {
             kind: "copyFile",
@@ -165,7 +157,7 @@ function honoApiPackageJson(packageName) {
             vitest: "catalog:"
         },
         engines: {
-            node: ">=22.0.0"
+            node: "22"
         }
     };
 }
@@ -210,24 +202,16 @@ function honoApiPackageOperations(packagePath, packageName) {
             }
         },
         {
-            kind: "writeJson",
-            to: `${packagePath}/.oxlintrc.json`,
-            value: {
-                categories: {
-                    correctness: "error",
-                    suspicious: "error"
-                },
-                plugins: ["typescript", "oxc"]
-            }
+            kind: "copyFile",
+            sourceRoot: "sharedOxc",
+            from: "node/oxlint.config.ts",
+            to: `${packagePath}/oxlint.config.ts`
         },
         {
-            kind: "writeJson",
-            to: `${packagePath}/.oxfmtrc.json`,
-            value: {
-                printWidth: 100,
-                singleQuote: false,
-                trailingComma: "none"
-            }
+            kind: "copyFile",
+            sourceRoot: "sharedOxc",
+            from: "oxfmt.config.ts",
+            to: `${packagePath}/oxfmt.config.ts`
         },
         { kind: "copyFile", from: "src/app.ts", to: `${packagePath}/src/app.ts` },
         { kind: "copyFile", from: "src/server.ts", to: `${packagePath}/src/server.ts` },
@@ -276,7 +260,7 @@ function vueAppPackageJson(packageName) {
             "vue-tsc": "catalog:"
         },
         engines: {
-            node: ">=22.0.0"
+            node: "22"
         }
     };
 }
@@ -351,24 +335,16 @@ function vueAppPackageOperations(packagePath, packageName) {
             }
         },
         {
-            kind: "writeJson",
-            to: `${packagePath}/.oxlintrc.json`,
-            value: {
-                categories: {
-                    correctness: "error",
-                    suspicious: "error"
-                },
-                plugins: ["typescript", "oxc", "vue"]
-            }
+            kind: "copyFile",
+            sourceRoot: "sharedOxc",
+            from: "vue/oxlint.config.ts",
+            to: `${packagePath}/oxlint.config.ts`
         },
         {
-            kind: "writeJson",
-            to: `${packagePath}/.oxfmtrc.json`,
-            value: {
-                printWidth: 100,
-                singleQuote: false,
-                trailingComma: "none"
-            }
+            kind: "copyFile",
+            sourceRoot: "sharedOxc",
+            from: "oxfmt.config.ts",
+            to: `${packagePath}/oxfmt.config.ts`
         },
         { kind: "copyFile", from: "env.d.ts", to: `${packagePath}/env.d.ts` },
         { kind: "copyFile", from: "index.html", to: `${packagePath}/index.html` },
@@ -417,6 +393,9 @@ function rootTsReferencesForPreset(preset, packagePath) {
 function templateSourceRoot(preset) {
     return path.join(path.dirname(fileURLToPath(import.meta.url)), "..", "templates", preset);
 }
+function sharedOxcSourceRoot() {
+    return path.join(path.dirname(fileURLToPath(import.meta.url)), "..", "templates", "shared", "oxc");
+}
 function localPortsFromText(text) {
     return [
         ...text.matchAll(/port:\s*(\d+)/g),
@@ -568,6 +547,7 @@ export async function addPackage(options) {
     await mkdir(path.join(root, packagePath), { recursive: true });
     await renderProject({
         sourceRoot: templateSourceRoot(options.preset),
+        sourceRoots: { sharedOxc: sharedOxcSourceRoot() },
         targetRoot: root,
         operations: packageOperationsForPreset(options.preset, packagePath, packageName)
     });

package/dist/post-commands.d.ts

@@ -0,0 +1,40 @@
+import type { PresetName } from "./declarations.js";
+export type PostCommand = {
+    id: string;
+    label: string;
+    command: string;
+    args: readonly string[];
+    cwd: string;
+};
+export type PlanPostCommandsOptions = {
+    preset: PresetName;
+    targetDir: string;
+};
+declare const postCommandPlanBrand: unique symbol;
+export type PostCommandPlan = {
+    readonly preset: PresetName;
+    readonly targetDir: string;
+    readonly commands: readonly PostCommand[];
+    readonly [postCommandPlanBrand]: true;
+};
+export type PostCommandExecution = {
+    command: PostCommand;
+    status: "run";
+    exitCode: 0;
+} | {
+    command: PostCommand;
+    status: "failed";
+    exitCode: number | null;
+    error: string;
+};
+export type PostCommandExecutor = (command: PostCommand) => Promise<{
+    exitCode: number;
+}>;
+export type RunPostCommandsOptions = {
+    plan: PostCommandPlan;
+    executor?: PostCommandExecutor;
+};
+export declare function planPostCommands(options: PlanPostCommandsOptions): PostCommandPlan;
+export declare function runPostCommands(options: RunPostCommandsOptions): Promise<PostCommandExecution[]>;
+export {};
+//# sourceMappingURL=post-commands.d.ts.map

package/dist/post-commands.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"post-commands.d.ts","sourceRoot":"","sources":["../src/post-commands.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAEpD,MAAM,MAAM,WAAW,GAAG;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,SAAS,MAAM,EAAE,CAAC;IACxB,GAAG,EAAE,MAAM,CAAC;CACb,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG;IACpC,MAAM,EAAE,UAAU,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,QAAA,MAAM,oBAAoB,EAAE,OAAO,MAAkC,CAAC;AAEtE,MAAM,MAAM,eAAe,GAAG;IAC5B,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAC;IAC5B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,QAAQ,EAAE,SAAS,WAAW,EAAE,CAAC;IAC1C,QAAQ,CAAC,CAAC,oBAAoB,CAAC,EAAE,IAAI,CAAC;CACvC,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAC5B;IACE,OAAO,EAAE,WAAW,CAAC;IACrB,MAAM,EAAE,KAAK,CAAC;IACd,QAAQ,EAAE,CAAC,CAAC;CACb,GACD;IACE,OAAO,EAAE,WAAW,CAAC;IACrB,MAAM,EAAE,QAAQ,CAAC;IACjB,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEN,MAAM,MAAM,mBAAmB,GAAG,CAChC,OAAO,EAAE,WAAW,KACjB,OAAO,CAAC;IAAE,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC;AAEnC,MAAM,MAAM,sBAAsB,GAAG;IACnC,IAAI,EAAE,eAAe,CAAC;IACtB,QAAQ,CAAC,EAAE,mBAAmB,CAAC;CAChC,CAAC;AAmEF,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,uBAAuB,GAAG,eAAe,CAalF;AAoED,wBAAsB,eAAe,CACnC,OAAO,EAAE,sBAAsB,GAC9B,OAAO,CAAC,oBAAoB,EAAE,CAAC,CAqCjC"}

package/dist/post-commands.js

@@ -0,0 +1,154 @@
+import { spawn } from "node:child_process";
+import path from "node:path";
+const postCommandPlanBrand = Symbol("PostCommandPlan");
+const packageManagerPin = "pnpm@10.0.0";
+const nodeReadyCommands = [
+    {
+        id: "node-enable-corepack",
+        label: "Enable Corepack",
+        command: "corepack",
+        args: ["enable"]
+    },
+    {
+        id: "node-refresh-package-manager-pin",
+        label: "Refresh Package Manager Pin and Install Dependencies",
+        command: "corepack",
+        args: ["use", packageManagerPin]
+    },
+    {
+        id: "node-run-fix",
+        label: "Run Fix Command",
+        command: "pnpm",
+        args: ["run", "fix"]
+    }
+];
+const vueReadyCommand = {
+    id: "vue-install-playwright-browsers",
+    label: "Install Playwright browser assets",
+    command: "pnpm",
+    args: ["exec", "playwright", "install", "chromium"]
+};
+const vueHonoReadyCommand = {
+    id: "vue-hono-install-playwright-browsers",
+    label: "Install Playwright browser assets for web workspace",
+    command: "pnpm",
+    args: ["--filter", "./apps/web", "exec", "playwright", "install", "chromium"]
+};
+function postCommandsForPreset(options) {
+    if (options.preset !== "ts-lib" &&
+        options.preset !== "hono-api" &&
+        options.preset !== "vue-app" &&
+        options.preset !== "vue-hono-app") {
+        return [];
+    }
+    const commands = [...nodeReadyCommands];
+    if (options.preset === "vue-app") {
+        commands.push(vueReadyCommand);
+    }
+    if (options.preset === "vue-hono-app") {
+        commands.push(vueHonoReadyCommand);
+    }
+    return commands.map((command) => ({
+        ...command,
+        cwd: options.targetDir
+    }));
+}
+export function planPostCommands(options) {
+    const targetDir = path.resolve(options.targetDir);
+    const commands = postCommandsForPreset({
+        preset: options.preset,
+        targetDir
+    }).map((command) => Object.freeze(command));
+    return Object.freeze({
+        preset: options.preset,
+        targetDir,
+        commands: Object.freeze(commands),
+        [postCommandPlanBrand]: true
+    });
+}
+async function defaultExecutor(command) {
+    return await new Promise((resolve, reject) => {
+        const child = spawn(command.command, [...command.args], {
+            cwd: command.cwd,
+            stdio: "ignore"
+        });
+        child.once("error", reject);
+        child.once("close", (exitCode) => {
+            resolve({ exitCode: exitCode ?? 1 });
+        });
+    });
+}
+function isWithinDirectory(parentDir, childPath) {
+    const relativePath = path.relative(path.resolve(parentDir), path.resolve(childPath));
+    return (relativePath === "" ||
+        (!relativePath.startsWith("..") && !path.isAbsolute(relativePath)));
+}
+function sameCommand(left, right) {
+    return (left.id === right.id &&
+        left.label === right.label &&
+        left.command === right.command &&
+        left.args.length === right.args.length &&
+        left.args.every((arg, index) => arg === right.args[index]) &&
+        path.resolve(left.cwd) === path.resolve(right.cwd));
+}
+function validatePostCommandPlan(plan) {
+    const expectedCommands = postCommandsForPreset({
+        preset: plan.preset,
+        targetDir: path.resolve(plan.targetDir)
+    });
+    const expectedCommandIds = new Set(expectedCommands.map((command) => command.id));
+    for (const command of plan.commands) {
+        if (!isWithinDirectory(plan.targetDir, command.cwd)) {
+            throw new Error(`Post Command cwd must stay within the target directory: ${command.id}`);
+        }
+        if (!expectedCommandIds.has(command.id)) {
+            throw new Error(`Unplanned Post Command: ${command.id}`);
+        }
+    }
+    if (plan.commands.length !== expectedCommands.length) {
+        throw new Error("Post Command plan must match the complete planned sequence");
+    }
+    for (const [index, command] of plan.commands.entries()) {
+        const expectedCommand = expectedCommands[index];
+        if (!expectedCommand || command.id !== expectedCommand.id) {
+            throw new Error("Post Command plan must match the complete planned sequence");
+        }
+        if (!sameCommand(command, expectedCommand)) {
+            throw new Error(`Post Command does not match the planned template command: ${command.id}`);
+        }
+    }
+}
+export async function runPostCommands(options) {
+    const executor = options.executor ?? defaultExecutor;
+    const results = [];
+    validatePostCommandPlan(options.plan);
+    for (const command of options.plan.commands) {
+        try {
+            const result = await executor(command);
+            if (result.exitCode !== 0) {
+                results.push({
+                    command,
+                    status: "failed",
+                    exitCode: result.exitCode,
+                    error: `Post Command failed with exit code ${result.exitCode}: ${command.id}`
+                });
+                break;
+            }
+            results.push({ command, status: "run", exitCode: 0 });
+        }
+        catch (error) {
+            const exitCode = error instanceof Error && "exitCode" in error && typeof error.exitCode === "number"
+                ? error.exitCode
+                : null;
+            const message = error instanceof Error ? error.message : String(error);
+            results.push({
+                command,
+                status: "failed",
+                exitCode,
+                error: `Post Command failed: ${command.id}: ${message}`
+            });
+            break;
+        }
+    }
+    return results;
+}