@ykdz/template 0.0.35 → 0.0.36

package/dist/application.d.ts

@@ -22,6 +22,8 @@ export type InitCommandOptions = {
     readonly dryRun: boolean;
     readonly json: boolean;
     readonly todo: boolean;
+    readonly name?: string;
+    readonly path?: string;
     readonly scope?: string;
 };
 export type AddPackageCommandOptions = {
@@ -58,7 +60,6 @@ type PackageAdditionCliResult = {
     readonly actions: readonly [];
     readonly conflicts: readonly PackageAdditionCliConflict[];
 };
-export declare function normalizeNpmScope(value: string): string;
 export declare function formatPresetCatalog(): string;
 export declare function renderPackageAdditionResult(result: PackageAdditionCliResult, options: AddPackageCommandOptions, preset: string): string;
 export declare function validateBlueprintFile(filePath: string, runtime: ApplicationRuntime): Promise<string>;

package/dist/application.js

@@ -1,17 +1,10 @@
 import { readFile } from "node:fs/promises";
 import path from "node:path";
-import { builtInPresetRegistry, createGenerationContext, planGeneratedRepositoryInitialization, planGeneratedRepositoryPackageAddition, templateSources, } from "#template-builtin-presets";
-import { assertProjectBlueprintV2, validateProjectBlueprintV2, } from "#template-core/project-blueprint-v2";
-import { reconcileAndApplyProjectProjections, } from "#template-core/project-projection";
+import { builtInPresetRegistry, loadLocalTemplateMetadata, prepareGeneratedRepositoryInitialization, planGeneratedRepositoryPackageAddition, templateSources, } from "#template-builtin-presets";
+import { validateProjectBlueprint } from "#template-core/project-blueprint";
+import { reconcileAndApplyProjectProjections, materializeProjectProjection, } from "#template-core/project-projection";
 import { renderNewProject } from "#template-core/renderer";
 import { resolveToolchainVersions, } from "#template-core/toolchain-resolution";
-export function normalizeNpmScope(value) {
-    const scope = value.startsWith("@") ? value.slice(1) : value;
-    if (value !== value.trim() || !/^[a-z0-9][a-z0-9._-]*$/.test(scope)) {
-        throw new Error("--scope must be a valid npm scope without whitespace");
-    }
-    return scope;
-}
 export function formatPresetCatalog() {
     return [
         "Built-in presets",
@@ -97,25 +90,9 @@ export function renderPackageAdditionResult(result, options, preset) {
             : result.actions.map((action) => `  ${action.action} ${action.path} (${action.driver})`)),
     ].join("\n");
 }
-async function readBlueprint(filePath) {
-    const value = JSON.parse(await readFile(filePath, "utf8"));
-    if (typeof value === "object" &&
-        value !== null &&
-        "schemaVersion" in value &&
-        value.schemaVersion === 1) {
-        throw new Error("Unsupported Local Template Metadata: Blueprint version 1 is not supported");
-    }
-    return assertProjectBlueprintV2(value);
-}
 export async function validateBlueprintFile(filePath, runtime) {
     const value = JSON.parse(await readFile(path.resolve(runtime.cwd, filePath), "utf8"));
-    if (typeof value === "object" &&
-        value !== null &&
-        "schemaVersion" in value &&
-        value.schemaVersion === 1) {
-        throw new Error("Unsupported Local Template Metadata: Blueprint version 1 is not supported");
-    }
-    const result = validateProjectBlueprintV2(value);
+    const result = validateProjectBlueprint(value);
     if (!result.ok) {
         throw new Error(result.issues
             .map((issue) => `${issue.path}: ${issue.message}`)
@@ -123,40 +100,66 @@ export async function validateBlueprintFile(filePath, runtime) {
     }
     return "Blueprint is valid";
 }
-function deriveExistingPackageScope(blueprint) {
-    const scopes = new Set();
-    for (const definition of blueprint.packages) {
-        const match = definition.name.match(/^@([^/]+)\//);
-        if (!match?.[1]) {
-            throw new Error(`Package Addition requires a scoped Package Definition: ${definition.name}`);
-        }
-        scopes.add(match[1]);
-    }
-    if (scopes.size !== 1) {
-        throw new Error(`Package Addition requires exactly one existing npm scope; found ${[...scopes].join(", ") || "none"}`);
-    }
-    return [...scopes][0];
-}
 export async function runInit(options, runtime) {
     const definition = builtInPresetRegistry.require(options.preset);
     const toolchain = await resolveToolchain(runtime.env);
-    const context = createGenerationContext({
+    const preparation = prepareGeneratedRepositoryInitialization({
+        definition,
         targetDir: path.resolve(runtime.cwd, options.dir),
-        ...(options.scope ? { scope: normalizeNpmScope(options.scope) } : {}),
         toolchain: {
             nodeLtsMajor: toolchain.nodeLtsMajor.value,
             packageManagerPin: toolchain.packageManagerPin.value,
         },
+        ...((options.name ?? options.path ?? options.scope) === undefined
+            ? {}
+            : {
+                overrides: {
+                    ...(options.name === undefined ? {} : { name: options.name }),
+                    ...(options.path === undefined ? {} : { path: options.path }),
+                    ...(options.scope === undefined ? {} : { scope: options.scope }),
+                },
+            }),
+    });
+    const { plan, resolved, publicationSetup } = preparation;
+    const resolvedPackageRows = [
+        ["Name", resolved.packages.map(({ name }) => name).join(", ")],
+        [
+            "Path",
+            resolved.packages.map(({ path: packagePath }) => packagePath).join(", "),
+        ],
+    ];
+    const operations = [
+        ...plan.operations,
+        ...(options.todo
+            ? [
+                {
+                    kind: "writeTextTemplate",
+                    source: templateSources.foundation,
+                    from: "TODO.md.template",
+                    to: "TODO.md",
+                    replacements: {
+                        NEXT_STEPS: plan.nextStepInstructions
+                            .map((instruction, index) => `${index + 1}. \`${instruction.display}\``)
+                            .join("\n"),
+                    },
+                },
+            ]
+            : []),
+    ];
+    await materializeProjectProjection({
+        operations,
+        reconciliation: plan.reconciliation,
     });
-    const plan = planGeneratedRepositoryInitialization({ definition, context });
     const output = {
         command: "init",
         dryRun: options.dryRun,
         targetDir: options.dir,
+        resolved,
         blueprint: plan.blueprint,
         generationRecord: plan.generationRecord,
         toolchain: toolchainReport(toolchain),
         nextSteps: plan.nextStepInstructions,
+        publicationSetup,
         followUpDocument: {
             enabled: options.todo,
             path: options.todo ? "TODO.md" : undefined,
@@ -174,6 +177,9 @@ export async function runInit(options, runtime) {
                 "Planned project",
                 "",
                 ...formatRows([
+                    ["Preset", resolved.preset],
+                    ...resolvedPackageRows,
+                    ["Scope", resolved.scope],
                     ["Target", options.dir],
                     ["Packages", String(plan.blueprint.packages.length)],
                 ]),
@@ -184,24 +190,7 @@ export async function runInit(options, runtime) {
     }
     await renderNewProject({
         targetRoot: path.resolve(runtime.cwd, options.dir),
-        operations: [
-            ...plan.operations,
-            ...(options.todo
-                ? [
-                    {
-                        kind: "writeTextTemplate",
-                        source: templateSources.foundation,
-                        from: "TODO.md.template",
-                        to: "TODO.md",
-                        replacements: {
-                            NEXT_STEPS: plan.nextStepInstructions
-                                .map((instruction, index) => `${index + 1}. \`${instruction.display}\``)
-                                .join("\n"),
-                        },
-                    },
-                ]
-                : []),
-        ],
+        operations,
     });
     if (options.json)
         return JSON.stringify(output, null, 2);
@@ -209,31 +198,31 @@ export async function runInit(options, runtime) {
         "Initialized project",
         "",
         ...formatRows([
-            ["Preset", definition.metadata.name],
+            ["Preset", resolved.preset],
+            ...resolvedPackageRows,
+            ["Scope", resolved.scope],
             ["Target", options.dir],
         ]),
         "",
         "Next steps",
         "",
         ...plan.nextStepInstructions.map((instruction, index) => `  ${index + 1}. ${instruction.display}`),
+        ...(publicationSetup === null
+            ? []
+            : [
+                "",
+                "One-time npm publication setup",
+                "",
+                `  ${publicationSetup.command}`,
+            ]),
     ].join("\n");
 }
 export async function runAddPackage(options, runtime) {
-    const blueprint = await readBlueprint(path.join(runtime.cwd, ".template/blueprint.json"));
-    const toolchain = await resolveToolchain(runtime.env);
+    const localTemplateMetadata = loadLocalTemplateMetadata(runtime.cwd);
     const definition = builtInPresetRegistry.require(options.preset);
-    const context = createGenerationContext({
-        targetDir: runtime.cwd,
-        scope: deriveExistingPackageScope(blueprint),
-        toolchain: {
-            nodeLtsMajor: toolchain.nodeLtsMajor.value,
-            packageManagerPin: toolchain.packageManagerPin.value,
-        },
-    });
     const plan = planGeneratedRepositoryPackageAddition({
         definition,
-        context,
-        blueprint,
+        localTemplateMetadata,
         packageLeafName: options.name,
         ...(options.path ? { packagePath: options.path } : {}),
         ...(options.linkFrom.length > 0 ? { linkFrom: options.linkFrom } : {}),

package/dist/main.js

@@ -46,9 +46,11 @@ export function createCliCommand(runtime) {
         .exitOverride();
     command
         .command("init <dir>")
-        .description("Initialize a repository.")
+        .description("Resolve a Preset, initial package name and path, and package scope before initialization.")
         .requiredOption("--preset <name>", "Project preset to generate")
-        .option("--scope <name>", "Package scope for workspace package names")
+        .option("--name <name>", "Unscoped leaf name when the Preset supports Primary Package Identity overrides")
+        .option("--path <path>", "Two-segment path when the Preset supports Primary Package Identity overrides")
+        .option("--scope <name>", "Resolved default package scope")
         .option("-y, --yes", "Accept defaults for non-interactive generation")
         .option("--dry-run", "Print the planned generation without writing files")
         .option("--json", "Print machine-readable output")
@@ -61,6 +63,8 @@ export function createCliCommand(runtime) {
             dryRun: Boolean(options.dryRun),
             json: Boolean(options.json),
             todo: options.todo,
+            ...(options.name === undefined ? {} : { name: options.name }),
+            ...(options.path === undefined ? {} : { path: options.path }),
             ...(options.scope === undefined ? {} : { scope: options.scope }),
         };
         runtime.streams.stdout.write(`${await runInit(initOptions, runtime)}\n`);

package/node_modules/@ykdz/template-builtin-presets/dist/src/foundation.d.ts

@@ -1,38 +1,28 @@
 import type { CiDiagnosticArtifactDeclaration } from "#template-core/ci-diagnostic-artifact";
 import { type DevelopmentContainerToolLayerBuildArgument, type DevelopmentContainerToolLayerMount, type DevelopmentContainerToolLayerProbe, type PlannedDevelopmentContainerToolLayer } from "#template-core/development-container-tool-layer";
 import type { CheckEnvironmentNeed, DeploymentEnvironmentNeed } from "#template-core/module-graph";
-import { type PackageContribution } from "#template-core/package-contribution";
-import type { BuiltInPresetDefinition, GenerationContext } from "#template-core/preset-definition";
-import { type ProjectBlueprintV2 } from "#template-core/project-blueprint-v2";
+import type { BuiltInPresetDefinition, GenerationContext, PlannedPackageContribution, ResolvedPrimaryPackageIdentity } from "#template-core/preset-definition";
+import { type ProjectBlueprint } from "#template-core/project-blueprint";
 import type { DependencyMaintenancePolicy } from "#template-core/project-github";
 import type { MaterializeProjectProjectionOptions, ProjectProjectionPathPrecondition, ProjectProjectionReconciliation } from "#template-core/project-projection";
 import type { RenderOperation } from "#template-core/renderer";
 import { type TemplateSourceHandle } from "#template-core/renderer";
-export type { PackageDefinition, PackageLinkIntent, PackageRole, ProjectBlueprintV2, } from "#template-core/project-blueprint-v2";
+import { type GenerationRecord } from "./generation-record.ts";
+export type { PackageDefinition, PackageDefinitionId, PackageLinkIntent, PackageRole, PersistedPackageDefinition, ProjectBlueprint, } from "#template-core/project-blueprint";
 export type { PackageContribution } from "#template-core/package-contribution";
 export type BuiltInGenerationContext = GenerationContext;
 export type { BuiltInPresetDefinition } from "#template-core/preset-definition";
 export type NextStepInstruction = {
     readonly display: string;
 };
-type GeneratedPackagePlanningRecord = {
-    readonly path: string;
-    readonly definitionName: string;
-    readonly planningContribution: "foundationPlan" | "planInitialization" | "planPackageAddition";
-};
-type GenerationRecord = {
-    readonly schemaVersion: 1;
-    readonly preset: string;
-    readonly templateVersion: "0.0.0";
-    readonly toolchain: BuiltInGenerationContext["toolchain"];
-    readonly packages: readonly GeneratedPackagePlanningRecord[];
-};
 export type GeneratedRepositoryPlan = {
     readonly definitionName: string;
     readonly plannerSourceFile: string;
     readonly planningContribution: "planInitialization" | "planPackageAddition";
-    readonly blueprint: ProjectBlueprintV2;
+    readonly blueprint: ProjectBlueprint;
     readonly generationRecord: GenerationRecord;
+    /** Resolved Preset contributions consumed by Blueprint and projections. */
+    readonly packageContributions: readonly PlannedPackageContribution[];
     readonly operations: readonly RenderOperation[];
     readonly reconciliation: readonly ProjectProjectionReconciliation[];
     readonly developmentContainer: {
@@ -50,6 +40,17 @@ export type GeneratedRepositoryPlan = {
     readonly dependencyMaintenancePolicy: DependencyMaintenancePolicy;
     readonly nextStepInstructions: readonly NextStepInstruction[];
 };
+declare const localTemplateMetadataStateKey: unique symbol;
+export type LocalTemplateMetadata = {
+    readonly blueprint: ProjectBlueprint;
+    readonly context: BuiltInGenerationContext;
+    /** Opaque Foundation-owned facts; callers pass the whole metadata value. */
+    readonly [localTemplateMetadataStateKey]: {
+        readonly generationRecord: GenerationRecord;
+        readonly foundationContribution: PlannedPackageContribution;
+        readonly packageContributions: readonly PlannedPackageContribution[];
+    };
+};
 export type GeneratedRepositoryPackageAdditionPlan = GeneratedRepositoryPlan & {
     readonly projectProjections: {
         readonly before: MaterializeProjectProjectionOptions;
@@ -57,11 +58,8 @@ export type GeneratedRepositoryPackageAdditionPlan = GeneratedRepositoryPlan & {
         readonly preconditions: readonly ProjectProjectionPathPrecondition[];
     };
 };
-/** One independently checkable initial Package Contribution and its real plan. */
-export type BuiltInPresetTemplateSourceCheckContext = {
-    readonly definition: BuiltInPresetDefinition;
-    readonly contribution: PackageContribution;
-    readonly plan: GeneratedRepositoryPlan;
+export type PublicationSetupHandoff = null | {
+    readonly command: "./scripts/npm-publication-setup/setup.sh";
 };
 /**
  * The Foundation persists the non-rendering half of every Package
@@ -71,7 +69,7 @@ export type BuiltInPresetTemplateSourceCheckContext = {
  */
 /** Resolve an owned source handle for diagnostics and source checks. */
 export declare function resolveBuiltInTemplateSource(source: TemplateSourceHandle, relativePath: string): string;
-export declare function validateProjectBlueprintV2(value: unknown): import("@ykdz/template-core/project-blueprint-v2").BlueprintV2ValidationResult;
+export declare function validateProjectBlueprint(value: unknown): import("@ykdz/template-core/project-blueprint").BlueprintValidationResult;
 declare class PresetRegistry {
     #private;
     constructor(definitions: readonly BuiltInPresetDefinition[]);
@@ -79,29 +77,45 @@ declare class PresetRegistry {
     require(name: string): BuiltInPresetDefinition;
 }
 export declare const builtInPresetRegistry: PresetRegistry;
-/** Registry-derived Template Source roots checked independently of render plans. */
-export declare function builtInPresetTemplateSourceContexts(): readonly {
-    readonly name: string;
-    readonly root: string;
-}[];
-/**
- * Derives direct Template Source checks from every registered Definition's
- * actual initial contributions, without maintaining a second Preset catalog.
- */
-export declare function builtInPresetTemplateSourceCheckContexts(): readonly BuiltInPresetTemplateSourceCheckContext[];
 export declare function createGenerationContext(options: {
     readonly targetDir: string;
-    readonly scope?: string;
+    readonly defaultPackageScope?: string;
     readonly toolchain: BuiltInGenerationContext["toolchain"];
 }): BuiltInGenerationContext;
+export declare function loadLocalTemplateMetadata(repositoryRoot: string): LocalTemplateMetadata;
+export type InitializationIdentityOverrides = {
+    readonly name?: string;
+    readonly path?: string;
+    readonly scope?: string;
+};
+export type ResolvedInitialization = {
+    readonly preset: string;
+    readonly topology: "configurable-primary-package" | "fixed";
+    readonly packages: readonly {
+        readonly name: string;
+        readonly path: string;
+    }[];
+    readonly scope: string;
+};
 export declare function planGeneratedRepositoryInitialization(options: {
     readonly definition: BuiltInPresetDefinition;
     readonly context: BuiltInGenerationContext;
 }): GeneratedRepositoryPlan;
-export declare function planGeneratedRepositoryPackageAddition(options: {
+export declare function prepareGeneratedRepositoryInitialization(options: {
     readonly definition: BuiltInPresetDefinition;
+    readonly targetDir: string;
+    readonly toolchain: BuiltInGenerationContext["toolchain"];
+    readonly overrides?: InitializationIdentityOverrides;
+}): {
     readonly context: BuiltInGenerationContext;
-    readonly blueprint: ProjectBlueprintV2;
+    readonly resolvedPackageIdentity?: ResolvedPrimaryPackageIdentity;
+    readonly resolved: ResolvedInitialization;
+    readonly plan: GeneratedRepositoryPlan;
+    readonly publicationSetup: PublicationSetupHandoff;
+};
+export declare function planGeneratedRepositoryPackageAddition(options: {
+    readonly definition: BuiltInPresetDefinition;
+    readonly localTemplateMetadata: LocalTemplateMetadata;
     readonly packageLeafName: string;
     readonly packagePath?: string;
     /** Existing consumers that explicitly import the newly added provider. */