@ykdz/template 0.0.1 → 0.0.2

package/dist/cli.js

@@ -8,8 +8,10 @@ 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";
+import { assembleGenerationContext } from "./generation-context.js";
+import { planNextStepInstructions, } from "./next-step-instructions.js";
+import { blueprintJsonSchema, builtInPresets, presetFileJsonSchema, validatePresetFile, validateProjectBlueprint, } from "./declarations.js";
+import { resolveToolchainVersions, } from "./toolchain-resolution.js";
 function usage() {
     return [
         "Usage:",
@@ -26,9 +28,8 @@ 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"
+        "  --json           Print machine-readable output",
     ].join("\n");
 }
 function printJson(value) {
@@ -54,7 +55,7 @@ function formatValidationIssues(issues) {
 function formatPresetCatalog() {
     return [
         "Built-in presets",
-        ...builtInPresets.map((preset) => `  ${preset.name.padEnd(8)} ${preset.title} (${preset.generation}) - ${preset.description}`)
+        ...builtInPresets.map((preset) => `  ${preset.name.padEnd(8)} ${preset.title} (${preset.generation}) - ${preset.description}`),
     ].join("\n");
 }
 function parseInitOptions(args) {
@@ -63,7 +64,6 @@ 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];
@@ -75,10 +75,6 @@ function parseInitOptions(args) {
             dryRun = true;
             continue;
         }
-        if (arg === "--ready") {
-            ready = true;
-            continue;
-        }
         if (arg === "--json") {
             json = true;
             continue;
@@ -106,7 +102,7 @@ function parseInitOptions(args) {
     if (!dir) {
         throw new Error("init requires a target directory");
     }
-    return { dir, preset, yes, dryRun, json, ready, scope };
+    return { dir, preset, yes, dryRun, json, scope };
 }
 function normalizeNpmScope(value) {
     if (value !== value.trim() || /\s/.test(value)) {
@@ -139,7 +135,7 @@ function blueprintForInit(options) {
         schemaVersion: 1,
         preset: preset.name,
         projectKind: preset.supportedProjectKinds[0],
-        features: [...preset.features]
+        features: [...preset.features],
     };
     if (preset.supportedPackageManagers[0]) {
         blueprint.packageManager = preset.supportedPackageManagers[0];
@@ -147,7 +143,7 @@ function blueprintForInit(options) {
     if (preset.name === "vue-hono-app") {
         blueprint.packages = [
             { name: `@${packageScope}/web`, path: "apps/web" },
-            { name: `@${packageScope}/api`, path: "apps/api" }
+            { name: `@${packageScope}/api`, path: "apps/api" },
         ];
     }
     return blueprint;
@@ -157,7 +153,7 @@ function formatBlueprintSummary(targetDir, blueprint) {
         "Project Blueprint",
         `  Target: ${targetDir}`,
         `  Preset: ${blueprint.preset}`,
-        `  Project kind: ${blueprint.projectKind}`
+        `  Project kind: ${blueprint.projectKind}`,
     ];
     if (blueprint.packageManager) {
         lines.push(`  Package manager: ${blueprint.packageManager}`);
@@ -171,64 +167,54 @@ 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"];
-    }
-    return ["cd <target>", "pnpm install", "pnpm run check"];
-}
 function formatNextSteps(targetDir, preset) {
+    const plan = planNextStepInstructions({ preset, targetDir });
     return [
-        "Next steps:",
-        ...nextStepsForPreset(preset).map((step) => `  ${step.replace("<target>", targetDir)}`)
+        "Next Step Instructions:",
+        ...plan.steps.map((step) => `  ${step.label}: ${step.display}`),
     ].join("\n");
 }
-function postCommandReport(planned, executions, skipped) {
+function toolchainReport(toolchain) {
     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
+        nodeLtsMajor: toolchain.nodeLtsMajor.value,
+        packageManagerPin: toolchain.packageManagerPin.value,
+        source: toolchain.source,
+        diagnostics: [...toolchain.diagnostics],
     };
 }
-function failedPostCommand(executions) {
-    return executions.find((execution) => execution.status === "failed");
+function formatToolchainReport(toolchain) {
+    return [
+        "Toolchain Resolution:",
+        `  Source: ${toolchain.source}`,
+        `  Node LTS major: ${toolchain.nodeLtsMajor.value}`,
+        `  Package Manager Pin: ${toolchain.packageManagerPin.value}`,
+        ...toolchain.diagnostics.map((diagnostic) => `  ${diagnostic}`),
+    ].join("\n");
+}
+function toolchainResolutionSourceFromEnv() {
+    if (process.env.TEMPLATE_TOOLCHAIN_RESOLUTION === "online" ||
+        process.env.TEMPLATE_TOOLCHAIN_RESOLUTION === "bundled-fallback") {
+        return process.env.TEMPLATE_TOOLCHAIN_RESOLUTION;
+    }
+    return undefined;
 }
-function skippedPostCommands(commands, reason) {
-    return commands.map((command) => ({ id: command.id, reason }));
+async function generationContextForInit(options, blueprint) {
+    if (options.preset !== "ts-lib" && options.preset !== "rust-bin") {
+        return undefined;
+    }
+    return assembleGenerationContext({
+        targetDir: options.dir,
+        blueprint,
+        toolchain: await resolveToolchainVersions({
+            source: toolchainResolutionSourceFromEnv(),
+            nodeReleaseIndexUrl: process.env.TEMPLATE_TOOLCHAIN_NODE_RELEASE_INDEX_URL,
+            pnpmRegistryUrl: process.env.TEMPLATE_TOOLCHAIN_PNPM_REGISTRY_URL,
+        }),
+    });
 }
-async function generateInitProject(options) {
+async function generateInitProject(options, generationContext) {
     if (options.preset === "ts-lib") {
-        await initTsLibProject(options.dir);
+        await initTsLibProject(options.dir, { generationContext });
         return;
     }
     if (options.preset === "hono-api") {
@@ -244,28 +230,28 @@ async function generateInitProject(options) {
         return;
     }
     if (options.preset === "rust-bin") {
-        await initRustBinProject(options.dir);
+        await initRustBinProject(options.dir, { generationContext });
         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) {
+function printInitComplete(options, blueprint, generationContext) {
     const preset = blueprint.preset;
+    const nextSteps = planNextStepInstructions({ preset, targetDir: options.dir }).steps;
     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))
+            toolchain: generationContext ? toolchainReport(generationContext.toolchain) : undefined,
+            nextSteps,
         });
         return;
     }
     console.log(`Initialized ${options.preset} project in ${options.dir}`);
-    if (options.ready) {
-        console.log(formatPostCommandPlan(report.planned));
+    if (generationContext) {
+        console.log(formatToolchainReport(generationContext.toolchain));
     }
     console.log(formatNextSteps(options.dir, preset));
 }
@@ -276,7 +262,7 @@ async function confirmInit(targetDir, blueprint) {
     console.log(formatBlueprintSummary(targetDir, blueprint));
     const readline = createInterface({
         input: process.stdin,
-        output: process.stdout
+        output: process.stdout,
     });
     try {
         const answer = await readline.question("Generate this project? [y/N] ");
@@ -365,23 +351,24 @@ async function main(args) {
         const options = parseInitOptions(args);
         const blueprint = blueprintForInit(options);
         if (options.dryRun) {
-            const postCommandPlan = planPostCommands({
+            const generationContext = await generationContextForInit(options, blueprint);
+            const nextSteps = planNextStepInstructions({
                 preset: blueprint.preset,
-                targetDir: options.dir
-            });
+                targetDir: options.dir,
+            }).steps;
             if (options.json) {
                 printJson({
                     command: "init",
                     dryRun: true,
-                    ready: options.ready,
                     targetDir: options.dir,
                     blueprint,
-                    postCommands: postCommandReport(postCommandPlan.commands, [], skippedPostCommands(postCommandPlan.commands, "dry-run"))
+                    toolchain: generationContext ? toolchainReport(generationContext.toolchain) : undefined,
+                    nextSteps,
                 });
                 return;
             }
             console.log(formatBlueprintSummary(options.dir, blueprint));
-            console.log(formatPostCommandPlan(postCommandPlan.commands));
+            console.log(formatNextSteps(options.dir, blueprint.preset));
             return;
         }
         if (!options.yes && (options.json || !isInteractiveTerminal())) {
@@ -390,19 +377,9 @@ async function main(args) {
         if (!options.yes && !(await confirmInit(options.dir, blueprint))) {
             throw new Error("Init cancelled");
         }
-        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);
-        }
+        const generationContext = await generationContextForInit(options, blueprint);
+        await generateInitProject(options, generationContext);
+        printInitComplete(options, blueprint, generationContext);
         return;
     }
     if (command === "add" && args[1] === "package") {

package/dist/declarations.js

@@ -77,7 +77,7 @@ export const builtInPresets = [
         title: "Rust binary",
         description: "Single-package Rust native binary with rustfmt, clippy, and cargo tests.",
         generation: "supported",
-        supportedPackageManagers: [],
+        supportedPackageManagers: ["pnpm"],
         supportedProjectKinds: ["single-package"],
         features: [
             "root-check",

package/dist/devcontainer.d.ts

@@ -0,0 +1,17 @@
+export type DevcontainerNodeFeatureOptions = {
+    readonly nodeVersion: string;
+    readonly packageManagerPin: string;
+};
+export type DevcontainerNodeFeature = {
+    readonly version: string;
+    readonly pnpmVersion: string;
+};
+export declare function pnpmVersionFromPackageManagerPin(packageManagerPin: string): string;
+export declare function devcontainerNodeFeature(options: DevcontainerNodeFeatureOptions): Record<"ghcr.io/devcontainers/features/node:1", DevcontainerNodeFeature>;
+export declare function nodePnpmDevcontainer(options: {
+    readonly name: string;
+    readonly nodeVersion: string;
+    readonly packageManagerPin: string;
+    readonly extensions: readonly string[];
+}): Record<string, unknown>;
+//# sourceMappingURL=devcontainer.d.ts.map

package/dist/devcontainer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"devcontainer.d.ts","sourceRoot":"","sources":["../src/devcontainer.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,8BAA8B,GAAG;IAC3C,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAC;CACpC,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG;IACpC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;CAC9B,CAAC;AAEF,wBAAgB,gCAAgC,CAAC,iBAAiB,EAAE,MAAM,GAAG,MAAM,CAElF;AAED,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,8BAA8B,GACtC,MAAM,CAAC,uCAAuC,EAAE,uBAAuB,CAAC,CAO1E;AAED,wBAAgB,oBAAoB,CAAC,OAAO,EAAE;IAC5C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAC;IACnC,QAAQ,CAAC,UAAU,EAAE,SAAS,MAAM,EAAE,CAAC;CACxC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAW1B"}

package/dist/devcontainer.js

@@ -0,0 +1,23 @@
+export function pnpmVersionFromPackageManagerPin(packageManagerPin) {
+    return packageManagerPin.replace(/^pnpm@/, "");
+}
+export function devcontainerNodeFeature(options) {
+    return {
+        "ghcr.io/devcontainers/features/node:1": {
+            version: options.nodeVersion,
+            pnpmVersion: pnpmVersionFromPackageManagerPin(options.packageManagerPin),
+        },
+    };
+}
+export function nodePnpmDevcontainer(options) {
+    return {
+        name: options.name,
+        image: `mcr.microsoft.com/devcontainers/typescript-node:${options.nodeVersion}`,
+        features: devcontainerNodeFeature(options),
+        customizations: {
+            vscode: {
+                extensions: options.extensions,
+            },
+        },
+    };
+}

package/dist/generation-context.d.ts

@@ -0,0 +1,24 @@
+import type { PackageManager, PresetName, ProjectBlueprint } from "./declarations.js";
+import type { ResolvedToolchainVersions } from "./toolchain-resolution.js";
+export type ProjectName = {
+    readonly kind: "ProjectName";
+    readonly value: string;
+};
+export type GenerationPackageManager = {
+    readonly kind: "PackageManager";
+    readonly value: PackageManager;
+};
+export type GenerationContext = {
+    readonly projectName: ProjectName;
+    readonly preset: PresetName;
+    readonly packageManager?: GenerationPackageManager;
+    readonly blueprint: ProjectBlueprint;
+    readonly toolchain: ResolvedToolchainVersions;
+};
+export type AssembleGenerationContextOptions = {
+    readonly targetDir: string;
+    readonly blueprint: ProjectBlueprint;
+    readonly toolchain: ResolvedToolchainVersions;
+};
+export declare function assembleGenerationContext(options: AssembleGenerationContextOptions): GenerationContext;
+//# sourceMappingURL=generation-context.d.ts.map

package/dist/generation-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generation-context.d.ts","sourceRoot":"","sources":["../src/generation-context.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AACtF,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,2BAA2B,CAAC;AAE3E,MAAM,MAAM,WAAW,GAAG;IACxB,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC;IAC7B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB,CAAC;AAEF,MAAM,MAAM,wBAAwB,GAAG;IACrC,QAAQ,CAAC,IAAI,EAAE,gBAAgB,CAAC;IAChC,QAAQ,CAAC,KAAK,EAAE,cAAc,CAAC;CAChC,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,QAAQ,CAAC,WAAW,EAAE,WAAW,CAAC;IAClC,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAC;IAC5B,QAAQ,CAAC,cAAc,CAAC,EAAE,wBAAwB,CAAC;IACnD,QAAQ,CAAC,SAAS,EAAE,gBAAgB,CAAC;IACrC,QAAQ,CAAC,SAAS,EAAE,yBAAyB,CAAC;CAC/C,CAAC;AAEF,MAAM,MAAM,gCAAgC,GAAG;IAC7C,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,SAAS,EAAE,gBAAgB,CAAC;IACrC,QAAQ,CAAC,SAAS,EAAE,yBAAyB,CAAC;CAC/C,CAAC;AAEF,wBAAgB,yBAAyB,CACvC,OAAO,EAAE,gCAAgC,GACxC,iBAAiB,CAUnB"}

package/dist/generation-context.js

@@ -0,0 +1,12 @@
+import path from "node:path";
+export function assembleGenerationContext(options) {
+    return {
+        projectName: { kind: "ProjectName", value: path.basename(path.resolve(options.targetDir)) },
+        preset: options.blueprint.preset,
+        packageManager: options.blueprint.packageManager
+            ? { kind: "PackageManager", value: options.blueprint.packageManager }
+            : undefined,
+        blueprint: options.blueprint,
+        toolchain: options.toolchain,
+    };
+}

package/dist/hono-api.d.ts

@@ -1,2 +1,3 @@
+export declare function projectHonoApiPackageScripts(): Record<string, string>;
 export declare function initHonoApiProject(targetDir: string): Promise<void>;
 //# sourceMappingURL=hono-api.d.ts.map

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

@@ -1 +1 @@
-{"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"}
+{"version":3,"file":"hono-api.d.ts","sourceRoot":"","sources":["../src/hono-api.ts"],"names":[],"mappings":"AAiCA,wBAAgB,4BAA4B,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAarE;AAgLD,wBAAsB,kBAAkB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAOzE"}

package/dist/hono-api.js

@@ -1,5 +1,8 @@
 import path from "node:path";
 import { fileURLToPath } from "node:url";
+import { nodePnpmDevcontainer } from "./devcontainer.js";
+import { planNodeChecks, planNodeFixes, renderFixCommand, renderRootCheckCommand, } from "./module-graph.js";
+import { projectPresetDependabotConfig, projectPresetGithubCheckWorkflow } from "./project-github.js";
 import { renderNewProject } from "./renderer.js";
 const features = [
     "pnpm-catalog",
@@ -9,37 +12,40 @@ const features = [
     "fix-command",
     "devcontainer",
     "github-actions",
-    "dependabot"
+    "dependabot",
 ];
 const generatedBy = {
     packageName: "@ykdz/template",
     version: "0.0.0",
-    command: "template init --preset hono-api"
+    command: "template init --preset hono-api",
 };
 function projectNameFromDir(targetDir) {
     return path.basename(path.resolve(targetDir));
 }
+export function projectHonoApiPackageScripts() {
+    return {
+        build: "tsc -p tsconfig.build.json && tsc-alias -p tsconfig.build.json",
+        check: renderRootCheckCommand(planNodeChecks("hono-api")),
+        fix: renderFixCommand(planNodeFixes("hono-api")),
+        "format:check": "oxfmt --check .",
+        "format:write": "oxfmt --write .",
+        lint: "oxlint . --deny-warnings",
+        "lint:fix": "oxlint . --fix --deny-warnings",
+        start: "node dist/server.js",
+        test: "vitest run",
+        typecheck: "tsc -p tsconfig.json --noEmit",
+    };
+}
 function packageJson(projectName) {
     return {
         name: projectName,
         version: "0.0.0",
         private: true,
         type: "module",
-        scripts: {
-            build: "tsc -p tsconfig.build.json && tsc-alias -p tsconfig.build.json",
-            check: "pnpm run format:check && pnpm run lint && pnpm run typecheck && pnpm run build && pnpm run test",
-            fix: "pnpm run format:write && pnpm run lint:fix",
-            "format:check": "oxfmt --check .",
-            "format:write": "oxfmt --write .",
-            lint: "oxlint . --deny-warnings",
-            "lint:fix": "oxlint . --fix --deny-warnings",
-            start: "node dist/server.js",
-            test: "vitest run",
-            typecheck: "tsc -p tsconfig.json --noEmit"
-        },
+        scripts: projectHonoApiPackageScripts(),
         dependencies: {
             "@hono/node-server": "catalog:",
-            hono: "catalog:"
+            hono: "catalog:",
         },
         devDependencies: {
             "@types/node": "catalog:",
@@ -47,12 +53,12 @@ function packageJson(projectName) {
             oxlint: "catalog:",
             "tsc-alias": "catalog:",
             typescript: "catalog:",
-            vitest: "catalog:"
+            vitest: "catalog:",
         },
         engines: {
-            node: "22"
+            node: "22",
         },
-        packageManager: "pnpm@10.0.0"
+        packageManager: "pnpm@10.0.0",
     };
 }
 function operationsForHonoApi(projectName) {
@@ -60,7 +66,7 @@ function operationsForHonoApi(projectName) {
         {
             kind: "writeJson",
             to: "package.json",
-            value: packageJson(projectName)
+            value: packageJson(projectName),
         },
         {
             kind: "writeText",
@@ -78,8 +84,8 @@ function operationsForHonoApi(projectName) {
                 "  tsc-alias: ^1.8.17",
                 "  typescript: ^5.8.0",
                 "  vitest: ^4.1.9",
-                ""
-            ].join("\n")
+                "",
+            ].join("\n"),
         },
         {
             kind: "writeJson",
@@ -90,15 +96,15 @@ function operationsForHonoApi(projectName) {
                     moduleResolution: "NodeNext",
                     noEmitOnError: true,
                     paths: {
-                        "@/*": ["./src/*"]
+                        "@/*": ["./src/*"],
                     },
                     skipLibCheck: false,
                     strict: true,
                     target: "ES2022",
-                    types: ["node", "vitest/globals"]
+                    types: ["node", "vitest/globals"],
                 },
-                include: ["src/**/*.ts", "test/**/*.ts", "vitest.config.ts"]
-            }
+                include: ["src/**/*.ts", "test/**/*.ts", "vitest.config.ts"],
+            },
         },
         {
             kind: "writeJson",
@@ -108,47 +114,47 @@ function operationsForHonoApi(projectName) {
                 compilerOptions: {
                     outDir: "dist",
                     rootDir: "src",
-                    types: ["node"]
+                    types: ["node"],
                 },
-                include: ["src/**/*.ts"]
-            }
+                include: ["src/**/*.ts"],
+            },
         },
         {
             kind: "copyFile",
             sourceRoot: "sharedOxc",
             from: "node/oxlint.config.ts",
-            to: "oxlint.config.ts"
+            to: "oxlint.config.ts",
         },
         {
             kind: "copyFile",
             sourceRoot: "sharedOxc",
             from: "oxfmt.config.ts",
-            to: "oxfmt.config.ts"
+            to: "oxfmt.config.ts",
         },
         {
             kind: "writeText",
             to: ".gitignore",
-            text: ["node_modules", "dist", ".env", ""].join("\n")
+            text: ["node_modules", "dist", ".env", ""].join("\n"),
         },
         {
             kind: "copyFile",
             from: "src/app.ts",
-            to: "src/app.ts"
+            to: "src/app.ts",
         },
         {
             kind: "copyFile",
             from: "src/server.ts",
-            to: "src/server.ts"
+            to: "src/server.ts",
         },
         {
             kind: "copyFile",
             from: "test/app.test.ts",
-            to: "test/app.test.ts"
+            to: "test/app.test.ts",
         },
         {
             kind: "copyFile",
             from: "vitest.config.ts",
-            to: "vitest.config.ts"
+            to: "vitest.config.ts",
         },
         {
             kind: "writeJson",
@@ -158,38 +164,34 @@ function operationsForHonoApi(projectName) {
                 preset: "hono-api",
                 packageManager: "pnpm",
                 projectKind: "single-package",
-                features
-            }
+                features,
+            },
         },
         {
             kind: "writeJson",
             to: ".project-kit/generated-by.json",
-            value: generatedBy
+            value: generatedBy,
         },
         {
             kind: "writeJson",
             to: ".devcontainer/devcontainer.json",
-            value: {
+            value: nodePnpmDevcontainer({
                 name: `${projectName} API development`,
-                image: "mcr.microsoft.com/devcontainers/typescript-node:22",
-                postCreateCommand: "corepack enable && pnpm install",
-                customizations: {
-                    vscode: {
-                        extensions: ["oxc.oxc-vscode"]
-                    }
-                }
-            }
+                nodeVersion: "22",
+                packageManagerPin: "pnpm@10.0.0",
+                extensions: ["oxc.oxc-vscode"],
+            }),
         },
         {
-            kind: "copyFile",
-            from: ".github/workflows/check.yml",
+            kind: "writeText",
             to: ".github/workflows/check.yml",
+            text: projectPresetGithubCheckWorkflow("hono-api"),
         },
         {
-            kind: "copyFile",
-            from: ".github/dependabot.yml",
+            kind: "writeText",
             to: ".github/dependabot.yml",
-        }
+            text: projectPresetDependabotConfig("hono-api"),
+        },
     ];
 }
 function templateSourceRoot() {
@@ -203,6 +205,6 @@ export async function initHonoApiProject(targetDir) {
         sourceRoot: templateSourceRoot(),
         sourceRoots: { sharedOxc: sharedOxcSourceRoot() },
         targetRoot: targetDir,
-        operations: operationsForHonoApi(projectNameFromDir(targetDir))
+        operations: operationsForHonoApi(projectNameFromDir(targetDir)),
     });
 }