@ykdz/template 0.0.5 → 0.0.7

package/dist/src/cli.js

@@ -2,32 +2,41 @@
 import { readFile } from "node:fs/promises";
 import path from "node:path";
 import { createInterface } from "node:readline/promises";
-import { findBuiltInPresetProjection, projectPresetThroughRegistry, } from "../templates/registry.js";
 import { blueprintJsonSchema, builtInPresets, presetFileJsonSchema, validatePresetFile, validateProjectBlueprint, } from "./declarations.js";
 import { assembleGenerationContext, } from "./generation-context.js";
 import { addPackage } from "./package-addition.js";
 import { planNextStepInstructionsForProjection, } from "./preset-projection.js";
+import { findBuiltInPresetSourceManifestPreset, presetSourceManifestJsonSchema, validateBuiltInPresetSourceManifest, validatePresetSourceManifest, } from "./preset-source.js";
+import { blueprintForPresetSourcePreset, projectPresetSourcePreset, } from "./projection-capabilities.js";
+import { renderNewProject } from "./renderer.js";
 import { resolveToolchainVersions, } from "./toolchain-resolution.js";
 function usage() {
     return [
+        "Project Kit template CLI",
+        "",
         "Usage:",
+        "  template <command> [options]",
+        "",
+        "Commands:",
         "  template init <dir> --preset <name> --yes",
         "  template add package --preset <name> --name <name> [--path <package-path>] [--link-from <package-path>]...",
         "  template presets",
         "  template schema preset",
+        "  template schema preset-source",
         "  template schema blueprint",
         "  template preset validate <path>",
+        "  template preset-source validate <path>",
         "  template blueprint validate <path>",
         "",
         "Options:",
-        "  --preset <name>  Project preset to generate",
-        "  --name <name>    Package name to add",
-        "  --path <path>    Two-segment Package Path to add",
+        "  --preset <name>     Project preset to generate",
+        "  --name <name>       Package name to add",
+        "  --path <path>       Two-segment Package Path to add",
         "  --link-from <path>  Existing consumer Package Path to link from; repeatable",
-        "  --scope <name>   Package scope for workspace package names",
-        "  --yes            Accept defaults for non-interactive generation",
-        "  --dry-run        Print the planned generation without writing files",
-        "  --json           Print machine-readable output",
+        "  --scope <name>      Package scope for workspace package names",
+        "  --yes               Accept defaults for non-interactive generation",
+        "  --dry-run           Print the planned generation without writing files",
+        "  --json              Print machine-readable output",
     ].join("\n");
 }
 function printJson(value) {
@@ -52,10 +61,18 @@ function formatValidationIssues(issues) {
         .map((issue) => `  - ${issue.path}: ${issue.message}`)
         .join("\n");
 }
+function formatFieldRows(rows) {
+    const width = Math.max(...rows.map(([label]) => `${label}:`.length));
+    return rows.map(([label, value]) => `  ${`${label}:`.padEnd(width)} ${value}`);
+}
 function formatPresetCatalog() {
     return [
         "Built-in presets",
-        ...builtInPresets.map((preset) => `  ${preset.name.padEnd(8)} ${preset.title} (${preset.generation}) - ${preset.description}`),
+        "",
+        ...formatFieldRows(builtInPresets.map((preset) => [
+            preset.name,
+            `${preset.title} (${preset.generation}) - ${preset.description}`,
+        ])),
     ].join("\n");
 }
 function parseInitOptions(args) {
@@ -135,42 +152,35 @@ function formatList(values) {
 }
 function blueprintForInit(options) {
     const preset = supportedPreset(options.preset);
-    const projection = findBuiltInPresetProjection(preset.name);
-    if (projection) {
-        return projection.blueprint({
-            targetDir: options.dir,
-            scope: options.scope,
-        });
-    }
-    const blueprint = {
-        schemaVersion: 1,
-        preset: preset.name,
-        projectKind: preset.supportedProjectKinds[0],
-        features: [...preset.features],
-    };
-    if (preset.supportedPackageManagers[0]) {
-        blueprint.packageManager = preset.supportedPackageManagers[0];
-    }
-    return blueprint;
+    return blueprintForPresetSourcePreset(preset, {
+        targetDir: options.dir,
+        scope: options.scope,
+    });
 }
 function formatBlueprintSummary(targetDir, blueprint) {
-    const lines = [
-        "Project Blueprint",
-        `  Target: ${targetDir}`,
-        `  Preset: ${blueprint.preset}`,
-        `  Project kind: ${blueprint.projectKind}`,
+    const rows = [
+        ["Target", targetDir],
+        ["Preset", blueprint.preset],
+        ["Project kind", blueprint.projectKind],
     ];
     if (blueprint.packageManager) {
-        lines.push(`  Package manager: ${blueprint.packageManager}`);
+        rows.push(["Package manager", blueprint.packageManager]);
     }
-    if (blueprint.packages) {
-        lines.push("  Packages:");
-        for (const pkg of blueprint.packages) {
-            lines.push(`    - ${pkg.name} (${pkg.path})`);
-        }
-    }
-    lines.push(`  Features: ${blueprint.features.join(", ")}`);
-    return lines.join("\n");
+    return [
+        "Project Blueprint",
+        "",
+        ...formatFieldRows(rows),
+        ...(blueprint.packages
+            ? [
+                "",
+                "  Packages:",
+                ...blueprint.packages.map((pkg) => `    - ${pkg.name} (${pkg.path})`),
+            ]
+            : []),
+        "",
+        "  Features:",
+        ...blueprint.features.map((feature) => `    - ${feature}`),
+    ].join("\n");
 }
 function formatProjectionNextSteps(targetDir, projectionPlan) {
     const steps = planNextStepInstructionsForProjection({
@@ -179,7 +189,11 @@ function formatProjectionNextSteps(targetDir, projectionPlan) {
     });
     return [
         "Next Step Instructions:",
-        ...steps.map((step) => `  ${step.label}: ${step.display}`),
+        "",
+        ...steps.flatMap((step, index) => [
+            `  ${index + 1}. ${step.label}`,
+            `     ${step.display}`,
+        ]),
     ].join("\n");
 }
 function toolchainReport(toolchain) {
@@ -193,9 +207,12 @@ function toolchainReport(toolchain) {
 function formatToolchainReport(toolchain) {
     return [
         "Toolchain Resolution:",
-        `  Source: ${toolchain.source}`,
-        `  Node LTS major: ${toolchain.nodeLtsMajor.value}`,
-        `  Package Manager Pin: ${toolchain.packageManagerPin.value}`,
+        "",
+        ...formatFieldRows([
+            ["Source", toolchain.source],
+            ["Node LTS major", toolchain.nodeLtsMajor.value],
+            ["Package Manager Pin", toolchain.packageManagerPin.value],
+        ]),
         ...toolchain.diagnostics.map((diagnostic) => `  ${diagnostic}`),
     ].join("\n");
 }
@@ -207,7 +224,8 @@ function toolchainResolutionSourceFromEnv() {
     return undefined;
 }
 async function generationContextForInit(options, blueprint) {
-    if (!findBuiltInPresetProjection(options.preset)) {
+    if (findBuiltInPresetSourceManifestPreset(options.preset)?.projection ===
+        undefined) {
         return undefined;
     }
     return assembleGenerationContext({
@@ -221,20 +239,28 @@ async function generationContextForInit(options, blueprint) {
     });
 }
 async function generateInitProject(options, generationContext) {
-    const projection = findBuiltInPresetProjection(options.preset);
-    if (projection) {
-        if (!generationContext) {
-            throw new Error(`Missing Generation Context for Preset Projection: ${options.preset}`);
-        }
-        const plan = projection.project(generationContext);
-        await projection.render({ targetDir: options.dir, plan });
-        return;
+    const preset = findBuiltInPresetSourceManifestPreset(options.preset);
+    if (!preset?.projection) {
+        throw new Error(formatSupportedPresetError());
     }
-    throw new Error(formatSupportedPresetError());
+    if (!generationContext) {
+        throw new Error(`Missing Generation Context for Preset Projection: ${options.preset}`);
+    }
+    const plan = projectPresetSourcePreset({
+        preset,
+        context: generationContext,
+    });
+    await renderNewProject({
+        sourceRoot: plan.sourceRoot,
+        sourceRoots: plan.sourceRoots,
+        targetRoot: options.dir,
+        operations: [...plan.operations],
+    });
 }
 function printInitComplete(options, blueprint, generationContext) {
-    const projectionPlan = generationContext
-        ? projectPresetThroughRegistry(generationContext)
+    const preset = findBuiltInPresetSourceManifestPreset(blueprint.preset);
+    const projectionPlan = generationContext && preset?.projection
+        ? projectPresetSourcePreset({ preset, context: generationContext })
         : undefined;
     if (!projectionPlan) {
         throw new Error(`Missing Preset Projection plan: ${blueprint.preset}`);
@@ -256,10 +282,19 @@ function printInitComplete(options, blueprint, generationContext) {
         });
         return;
     }
-    console.log(`Initialized ${options.preset} project in ${options.dir}`);
+    console.log([
+        "Initialized project",
+        "",
+        ...formatFieldRows([
+            ["Preset", options.preset],
+            ["Target", options.dir],
+        ]),
+    ].join("\n"));
     if (generationContext) {
+        console.log("");
         console.log(formatToolchainReport(generationContext.toolchain));
     }
+    console.log("");
     console.log(formatProjectionNextSteps(options.dir, projectionPlan));
 }
 function isInteractiveTerminal() {
@@ -349,7 +384,11 @@ async function main(args) {
             printJson(blueprintJsonSchema);
             return;
         }
-        throw new Error("schema requires preset or blueprint");
+        if (schemaName === "preset-source") {
+            printJson(presetSourceManifestJsonSchema);
+            return;
+        }
+        throw new Error("schema requires preset, preset-source, or blueprint");
     }
     if (command === "preset" && args[1] === "validate") {
         const filePath = args[2];
@@ -363,6 +402,32 @@ async function main(args) {
         console.log(`Preset file is valid: ${result.value.name}`);
         return;
     }
+    if (command === "preset-source" && args[1] === "validate") {
+        const filePath = args[2];
+        if (!filePath) {
+            throw new Error("preset-source validate requires a path");
+        }
+        const declaration = await readJsonDeclaration(filePath);
+        const sourceName = typeof declaration === "object" &&
+            declaration !== null &&
+            !Array.isArray(declaration) &&
+            "name" in declaration &&
+            typeof declaration.name === "string"
+            ? declaration.name
+            : undefined;
+        const result = sourceName === "built-in"
+            ? validateBuiltInPresetSourceManifest(declaration, {
+                sourceRoot: path.dirname(filePath),
+            })
+            : validatePresetSourceManifest(declaration, {
+                sourceRoot: path.dirname(filePath),
+            });
+        if (!result.ok) {
+            throw new Error(`Preset Source Manifest is invalid:\n${formatValidationIssues(result.issues)}`);
+        }
+        console.log(`Preset Source Manifest is valid: ${result.value.name} (${result.value.presets.map((preset) => preset.name).join(", ")})`);
+        return;
+    }
     if (command === "blueprint" && args[1] === "validate") {
         const filePath = args[2];
         if (!filePath) {
@@ -380,8 +445,11 @@ async function main(args) {
         const blueprint = blueprintForInit(options);
         if (options.dryRun) {
             const generationContext = await generationContextForInit(options, blueprint);
+            const preset = findBuiltInPresetSourceManifestPreset(options.preset);
             const projectionPlan = generationContext
-                ? projectPresetThroughRegistry(generationContext)
+                ? preset?.projection
+                    ? projectPresetSourcePreset({ preset, context: generationContext })
+                    : undefined
                 : undefined;
             if (!projectionPlan) {
                 throw new Error(`Missing Preset Projection plan: ${blueprint.preset}`);
@@ -405,8 +473,10 @@ async function main(args) {
             }
             console.log(formatBlueprintSummary(options.dir, blueprint));
             if (generationContext) {
+                console.log("");
                 console.log(formatToolchainReport(generationContext.toolchain));
             }
+            console.log("");
             console.log(formatProjectionNextSteps(options.dir, projectionPlan));
             return;
         }
@@ -430,7 +500,15 @@ async function main(args) {
             path: options.path,
             linkFrom: options.linkFrom,
         });
-        console.log(`Added ${options.preset} package ${options.name}`);
+        console.log([
+            "Added package",
+            "",
+            ...formatFieldRows([
+                ["Preset", options.preset],
+                ["Name", options.name],
+                ...(options.path ? [["Path", options.path]] : []),
+            ]),
+        ].join("\n"));
         return;
     }
     if (command === "--help" || command === "-h") {
@@ -441,8 +519,8 @@ async function main(args) {
 }
 main(process.argv.slice(2)).catch((error) => {
     const message = error instanceof Error ? error.message : String(error);
-    console.error(message);
+    console.error(`Error: ${message}`);
     console.error("");
-    console.error(usage());
+    console.error("Run `template --help` for usage.");
     process.exitCode = 1;
 });

package/dist/src/declarations.js

@@ -1,6 +1,6 @@
 import * as v from "valibot";
-import { builtInPresetMetadata } from "../templates/registry.js";
-export const builtInPresets = builtInPresetMetadata;
+import { loadBuiltInPresetSourceManifest } from "./preset-source.js";
+export const builtInPresets = loadBuiltInPresetSourceManifest().presets;
 const featureNames = [
     "pnpm-catalog",
     "oxc-format-lint",

package/dist/src/generated-scenarios.d.ts

@@ -0,0 +1,62 @@
+import type { PresetSourceManifest } from "./preset-source.js";
+export type GeneratedScenarioSet = "init" | "package-addition-matrix";
+export type GeneratedScenario = {
+    readonly set: GeneratedScenarioSet;
+    readonly basePreset: string;
+    readonly addedPreset?: string;
+    readonly linkFrom?: readonly string[];
+    readonly id: string;
+    readonly label: string;
+};
+export type SkippedGeneratedScenario = {
+    readonly set: GeneratedScenarioSet;
+    readonly basePreset: string;
+    readonly addedPreset: string;
+    readonly id: string;
+    readonly label: string;
+    readonly reason: string;
+};
+export type GeneratedScenarioSelection = {
+    readonly runnable: readonly GeneratedScenario[];
+    readonly skipped: readonly SkippedGeneratedScenario[];
+};
+export type GeneratedScenarioCommandStep = {
+    readonly id: string;
+    readonly command: string;
+    readonly args: readonly string[];
+    readonly cwd: string;
+    readonly display: string;
+};
+export type GeneratedScenarioCommandRunner = (command: string, args: readonly string[], cwd: string, options?: {
+    readonly env?: Record<string, string>;
+    readonly logPrefix?: string;
+}) => Promise<void>;
+export type GeneratedScenarioReporter = {
+    readonly info?: (message: string) => void;
+    readonly error?: (message: string) => void;
+};
+export type GeneratedScenarioRunnerOptions = {
+    readonly repoRoot: string;
+    readonly cliPath: string;
+    readonly runCommand?: GeneratedScenarioCommandRunner;
+    readonly reporter?: GeneratedScenarioReporter;
+    readonly deterministicToolchainEnv?: Record<string, string>;
+    readonly rootCheckLock?: ExclusiveLock;
+};
+export type ExclusiveLock = {
+    readonly run: <T>(callback: () => Promise<T>) => Promise<T>;
+};
+export declare function createExclusiveLock(): ExclusiveLock;
+export declare function generatedScenarioId(scenario: Pick<GeneratedScenario, "basePreset" | "addedPreset" | "linkFrom">): string;
+export declare function generatedScenarioLabel(scenario: Pick<GeneratedScenario, "basePreset" | "addedPreset" | "linkFrom">): string;
+export declare function selectGeneratedScenarios(manifest: PresetSourceManifest, set: GeneratedScenarioSet): GeneratedScenarioSelection;
+export declare function packageLeafNameForAddedPreset(manifest: PresetSourceManifest, presetName: string): string;
+export declare function defaultGeneratedScenarioCommandRunner(command: string, args: readonly string[], cwd: string, options?: {
+    readonly env?: Record<string, string>;
+    readonly logPrefix?: string;
+}): Promise<void>;
+export declare function generatedScenarioQualityGateSteps(manifest: PresetSourceManifest, scenario: GeneratedScenario, projectDir: string, addedPackagePath: string | undefined, options: GeneratedScenarioRunnerOptions): GeneratedScenarioCommandStep[];
+export declare function fixtureConcurrency(scenarioCount: number): number;
+export declare function errorForFailedGeneratedScenario(scenario: GeneratedScenario, error: unknown): Error;
+export declare function runGeneratedScenariosConcurrently(manifest: PresetSourceManifest, scenarios: readonly GeneratedScenario[], workspace: string, concurrency: number, options: GeneratedScenarioRunnerOptions): Promise<void>;
+export declare function runGeneratedScenarioSet(manifest: PresetSourceManifest, set: GeneratedScenarioSet, workspace: string, options: GeneratedScenarioRunnerOptions): Promise<GeneratedScenarioSelection>;