@ykdz/template 0.0.4 → 0.0.6

package/dist/src/cli.js

@@ -2,27 +2,32 @@
 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 [
         "Usage:",
         "  template init <dir> --preset <name> --yes",
-        "  template add package --preset <name> --name <name> [--path <package-path>]",
+        "  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",
+        "  --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",
@@ -134,23 +139,10 @@ 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 = [
@@ -206,7 +198,8 @@ function toolchainResolutionSourceFromEnv() {
     return undefined;
 }
 async function generationContextForInit(options, blueprint) {
-    if (!findBuiltInPresetProjection(options.preset)) {
+    if (findBuiltInPresetSourceManifestPreset(options.preset)?.projection ===
+        undefined) {
         return undefined;
     }
     return assembleGenerationContext({
@@ -220,20 +213,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}`);
@@ -283,6 +284,7 @@ function parseAddPackageOptions(args) {
     let preset = "";
     let name = "";
     let packagePath;
+    const linkFrom = [];
     for (let index = 2; index < args.length; index += 1) {
         const arg = args[index];
         if (arg === "--preset") {
@@ -312,6 +314,15 @@ function parseAddPackageOptions(args) {
             index += 1;
             continue;
         }
+        if (arg === "--link-from") {
+            const value = args[index + 1];
+            if (!value) {
+                throw new Error("--link-from requires a value");
+            }
+            linkFrom.push(value);
+            index += 1;
+            continue;
+        }
         throw new Error(`Unknown option: ${arg}`);
     }
     if (!preset) {
@@ -320,7 +331,7 @@ function parseAddPackageOptions(args) {
     if (!name) {
         throw new Error("add package requires --name");
     }
-    return { preset, name, path: packagePath };
+    return { preset, name, path: packagePath, linkFrom };
 }
 async function main(args) {
     const command = args[0];
@@ -338,7 +349,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];
@@ -352,6 +367,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) {
@@ -369,8 +410,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}`);
@@ -417,6 +461,7 @@ async function main(args) {
             preset: options.preset,
             name: options.name,
             path: options.path,
+            linkFrom: options.linkFrom,
         });
         console.log(`Added ${options.preset} package ${options.name}`);
         return;

package/dist/src/declarations.d.ts

@@ -1,4 +1,6 @@
 import * as v from "valibot";
+import type { PackageAdditionSupport } from "./package-addition-support.js";
+import type { PackageLinkIntent, PackageRole, PackageSourcePreset } from "./package-linking.js";
 export type BuiltInPreset = {
     name: string;
     title: string;
@@ -6,6 +8,7 @@ export type BuiltInPreset = {
     generation: "supported" | "future";
     supportedPackageManagers: readonly PackageManager[];
     supportedProjectKinds: readonly ProjectKind[];
+    packageAdditionSupport: PackageAdditionSupport;
     features: readonly FeatureName[];
 };
 export type PackageManager = "pnpm";
@@ -23,6 +26,8 @@ export type PresetFile = {
 export type ProjectPackage = {
     name: string;
     path: string;
+    role?: PackageRole;
+    sourcePreset?: PackageSourcePreset;
 };
 export type ProjectBlueprint = {
     schemaVersion: 1;
@@ -31,6 +36,7 @@ export type ProjectBlueprint = {
     projectKind: ProjectKind;
     features: FeatureName[];
     packages?: ProjectPackage[];
+    packageLinkIntents?: PackageLinkIntent[];
 };
 export declare const builtInPresets: readonly BuiltInPreset[];
 export declare const presetFileJsonSchema: {
@@ -123,6 +129,30 @@ export declare const blueprintJsonSchema: {
                         readonly type: "string";
                         readonly minLength: 1;
                     };
+                    readonly role: {
+                        readonly enum: readonly ["runtime-service", "shared-library"];
+                    };
+                    readonly sourcePreset: {
+                        readonly enum: readonly ["hono-api", "ts-lib", "vue-app"];
+                    };
+                };
+            };
+        };
+        readonly packageLinkIntents: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["consumerPackagePath", "providerPackagePath"];
+                readonly properties: {
+                    readonly consumerPackagePath: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                    readonly providerPackagePath: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
                 };
             };
         };
@@ -146,6 +176,12 @@ export declare const projectBlueprintSchema: v.StrictObjectSchema<{
     readonly packages: v.OptionalSchema<v.ArraySchema<v.StrictObjectSchema<{
         readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
         readonly path: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+        readonly role: v.OptionalSchema<v.PicklistSchema<["runtime-service", "shared-library"], undefined>, undefined>;
+        readonly sourcePreset: v.OptionalSchema<v.PicklistSchema<["hono-api", "ts-lib", "vue-app"], undefined>, undefined>;
+    }, undefined>, undefined>, undefined>;
+    readonly packageLinkIntents: v.OptionalSchema<v.ArraySchema<v.StrictObjectSchema<{
+        readonly consumerPackagePath: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+        readonly providerPackagePath: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
     }, undefined>, undefined>, undefined>;
 }, undefined>;
 export type ValidationIssue = {

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",
@@ -78,6 +78,20 @@ export const blueprintJsonSchema = {
                 properties: {
                     name: { type: "string", minLength: 1 },
                     path: { type: "string", minLength: 1 },
+                    role: { enum: ["runtime-service", "shared-library"] },
+                    sourcePreset: { enum: ["hono-api", "ts-lib", "vue-app"] },
+                },
+            },
+        },
+        packageLinkIntents: {
+            type: "array",
+            items: {
+                type: "object",
+                additionalProperties: false,
+                required: ["consumerPackagePath", "providerPackagePath"],
+                properties: {
+                    consumerPackagePath: { type: "string", minLength: 1 },
+                    providerPackagePath: { type: "string", minLength: 1 },
                 },
             },
         },
@@ -90,6 +104,15 @@ const projectKindSchema = v.picklist([
     "multi-package",
 ]);
 const featureNameSchema = v.picklist(featureNames);
+const packageRoleSchema = v.picklist([
+    "runtime-service",
+    "shared-library",
+]);
+const packageSourcePresetSchema = v.picklist([
+    "hono-api",
+    "ts-lib",
+    "vue-app",
+]);
 export const presetFileSchema = v.strictObject({
     schemaVersion: v.literal(1),
     name: nonEmptyString,
@@ -108,6 +131,12 @@ export const projectBlueprintSchema = v.strictObject({
     packages: v.optional(v.array(v.strictObject({
         name: nonEmptyString,
         path: nonEmptyString,
+        role: v.optional(packageRoleSchema),
+        sourcePreset: v.optional(packageSourcePresetSchema),
+    }))),
+    packageLinkIntents: v.optional(v.array(v.strictObject({
+        consumerPackagePath: nonEmptyString,
+        providerPackagePath: nonEmptyString,
     }))),
 });
 function formatIssuePath(issue) {

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>;