@wp-typia/project-tools 0.11.1

package/dist/runtime/cli-core.js

@@ -0,0 +1,25 @@
+/**
+ * Public runtime helper barrel consumed by the canonical `wp-typia` package.
+ *
+ * These exports do not make `@wp-typia/project-tools` the CLI owner again. Command
+ * taxonomy, help text ownership, and published bin responsibility stay in
+ * `packages/wp-typia`.
+ *
+ * Import `formatAddHelpText`, `runAddBlockCommand`,
+ * `createAddPlaceholderMessage`, and `seedWorkspaceMigrationProject` for
+ * explicit `wp-typia add` flows,
+ * `getDoctorChecks`, `runDoctor`, and `DoctorCheck` for diagnostics,
+ * `formatHelpText` for top-level CLI usage output, scaffold helpers such as
+ * `createReadlinePrompt`, `getNextSteps`, `getOptionalOnboarding`,
+ * `runScaffoldFlow`, and `ReadlinePrompt` for interactive project creation,
+ * and template helpers such as `formatTemplateDetails`,
+ * `formatTemplateFeatures`, `formatTemplateSummary`, `getTemplateById`,
+ * `getTemplateSelectOptions`, `listTemplates`, and `isBuiltInTemplateId` for
+ * template inspection flows.
+ */
+export { getDoctorChecks, runDoctor } from "./cli-doctor.js";
+export { createAddPlaceholderMessage, formatAddHelpText, runAddBlockCommand, seedWorkspaceMigrationProject } from "./cli-add.js";
+export { formatHelpText } from "./cli-help.js";
+export { getNextSteps, getOptionalOnboarding, runScaffoldFlow, } from "./cli-scaffold.js";
+export { createReadlinePrompt } from "./cli-prompt.js";
+export { formatTemplateDetails, formatTemplateFeatures, formatTemplateSummary, getTemplateById, getTemplateSelectOptions, isBuiltInTemplateId, listTemplates, } from "./cli-templates.js";

package/dist/runtime/cli-doctor.d.ts

@@ -0,0 +1,34 @@
+/**
+ * One doctor check rendered by the CLI diagnostics flow.
+ */
+export interface DoctorCheck {
+    /** Human-readable status detail rendered next to the label. */
+    detail: string;
+    /** Short label for the dependency, directory, or template check. */
+    label: string;
+    /** Final pass/fail status for this diagnostic row. */
+    status: "pass" | "fail";
+}
+interface RunDoctorOptions {
+    renderLine?: (check: DoctorCheck) => void;
+}
+/**
+ * Collect all runtime doctor checks for the current environment.
+ *
+ * The returned array includes command availability checks, directory
+ * writability checks, and built-in template asset checks in display order.
+ *
+ * @param cwd Working directory to validate for writability.
+ * @returns Ordered doctor check rows ready for CLI rendering.
+ */
+export declare function getDoctorChecks(cwd: string): Promise<DoctorCheck[]>;
+/**
+ * Run doctor checks, render each line, and fail when any check does not pass.
+ *
+ * @param cwd Working directory to validate.
+ * @param options Optional renderer override for each emitted check row.
+ * @returns The completed list of doctor checks.
+ * @throws {Error} When one or more checks fail.
+ */
+export declare function runDoctor(cwd: string, { renderLine, }?: RunDoctorOptions): Promise<DoctorCheck[]>;
+export {};

package/dist/runtime/cli-doctor.js

@@ -0,0 +1,131 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { execFileSync } from "node:child_process";
+import { access, constants as fsConstants, rm, writeFile } from "node:fs/promises";
+import { getBuiltInTemplateLayerDirs } from "./template-builtins.js";
+import { listTemplates } from "./template-registry.js";
+function readCommandVersion(command, args = ["--version"]) {
+    try {
+        return execFileSync(command, args, {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+        }).trim();
+    }
+    catch {
+        return null;
+    }
+}
+function compareMajorVersion(actualVersion, minimumMajor) {
+    const parsed = Number.parseInt(actualVersion.replace(/^v/, "").split(".")[0] ?? "", 10);
+    return Number.isFinite(parsed) && parsed >= minimumMajor;
+}
+async function checkWritableDirectory(directory) {
+    try {
+        await access(directory, fsConstants.W_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function checkTempDirectory() {
+    const tempFile = path.join(os.tmpdir(), `wp-typia-${Date.now()}.tmp`);
+    try {
+        await writeFile(tempFile, "ok", "utf8");
+        await rm(tempFile, { force: true });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Collect all runtime doctor checks for the current environment.
+ *
+ * The returned array includes command availability checks, directory
+ * writability checks, and built-in template asset checks in display order.
+ *
+ * @param cwd Working directory to validate for writability.
+ * @returns Ordered doctor check rows ready for CLI rendering.
+ */
+export async function getDoctorChecks(cwd) {
+    const checks = [];
+    const bunVersion = readCommandVersion("bun");
+    const nodeVersion = readCommandVersion("node");
+    const gitVersion = readCommandVersion("git");
+    const cwdWritable = await checkWritableDirectory(cwd);
+    const tempWritable = await checkTempDirectory();
+    checks.push({
+        status: bunVersion && compareMajorVersion(bunVersion, 1) ? "pass" : "fail",
+        label: "Bun",
+        detail: bunVersion ? `Detected ${bunVersion}` : "Not available",
+    });
+    checks.push({
+        status: nodeVersion && compareMajorVersion(nodeVersion, 20) ? "pass" : "fail",
+        label: "Node",
+        detail: nodeVersion ? `Detected ${nodeVersion}` : "Not available",
+    });
+    checks.push({
+        status: gitVersion ? "pass" : "fail",
+        label: "git",
+        detail: gitVersion ?? "Not available",
+    });
+    checks.push({
+        status: cwdWritable ? "pass" : "fail",
+        label: "Current directory",
+        detail: cwdWritable ? "Writable" : "Not writable",
+    });
+    checks.push({
+        status: tempWritable ? "pass" : "fail",
+        label: "Temp directory",
+        detail: tempWritable ? "Writable" : "Not writable",
+    });
+    for (const template of listTemplates()) {
+        const layerDirs = template.id === "persistence"
+            ? Array.from(new Set([
+                ...getBuiltInTemplateLayerDirs(template.id, { persistencePolicy: "authenticated" }),
+                ...getBuiltInTemplateLayerDirs(template.id, { persistencePolicy: "public" }),
+            ]))
+            : template.id === "compound"
+                ? Array.from(new Set([
+                    ...getBuiltInTemplateLayerDirs(template.id),
+                    ...getBuiltInTemplateLayerDirs(template.id, {
+                        persistenceEnabled: true,
+                        persistencePolicy: "authenticated",
+                    }),
+                    ...getBuiltInTemplateLayerDirs(template.id, {
+                        persistenceEnabled: true,
+                        persistencePolicy: "public",
+                    }),
+                ]))
+                : getBuiltInTemplateLayerDirs(template.id);
+        const hasAssets = layerDirs.every((layerDir) => fs.existsSync(layerDir)) &&
+            layerDirs.some((layerDir) => fs.existsSync(path.join(layerDir, "package.json.mustache"))) &&
+            layerDirs.some((layerDir) => fs.existsSync(path.join(layerDir, "src")));
+        checks.push({
+            status: hasAssets ? "pass" : "fail",
+            label: `Template ${template.id}`,
+            detail: hasAssets ? layerDirs.join(" + ") : "Missing core template assets",
+        });
+    }
+    return checks;
+}
+/**
+ * Run doctor checks, render each line, and fail when any check does not pass.
+ *
+ * @param cwd Working directory to validate.
+ * @param options Optional renderer override for each emitted check row.
+ * @returns The completed list of doctor checks.
+ * @throws {Error} When one or more checks fail.
+ */
+export async function runDoctor(cwd, { renderLine = (check) => console.log(`${check.status.toUpperCase()} ${check.label}: ${check.detail}`), } = {}) {
+    const checks = await getDoctorChecks(cwd);
+    for (const check of checks) {
+        renderLine(check);
+    }
+    if (checks.some((check) => check.status === "fail")) {
+        throw new Error("Doctor found one or more failing checks.");
+    }
+    return checks;
+}

package/dist/runtime/cli-help.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Return the canonical CLI usage text for `wp-typia`.
+ *
+ * The rendered help includes the current built-in template ids and supported
+ * package manager ids from the runtime registry.
+ *
+ * @returns Human-readable help text for CLI usage output.
+ */
+export declare function formatHelpText(): string;

package/dist/runtime/cli-help.js

@@ -0,0 +1,37 @@
+import { PACKAGE_MANAGER_IDS } from "./package-managers.js";
+import { TEMPLATE_IDS } from "./template-registry.js";
+/**
+ * Return the canonical CLI usage text for `wp-typia`.
+ *
+ * The rendered help includes the current built-in template ids and supported
+ * package manager ids from the runtime registry.
+ *
+ * @returns Human-readable help text for CLI usage output.
+ */
+export function formatHelpText() {
+    return `Usage:
+  wp-typia create <project-dir> [--template <basic|interactivity>] [--namespace <value>] [--text-domain <value>] [--php-prefix <value>] [--with-migration-ui] [--with-wp-env] [--with-test-preset] [--yes] [--no-install] [--package-manager <id>]
+  wp-typia create <project-dir> [--template <./path|github:owner/repo/path[#ref]>] [--variant <name>] [--namespace <value>] [--text-domain <value>] [--php-prefix <value>] [--with-wp-env] [--with-test-preset] [--yes] [--no-install] [--package-manager <id>]
+  wp-typia create <project-dir> [--template <npm-package>] [--variant <name>] [--namespace <value>] [--text-domain <value>] [--php-prefix <value>] [--with-wp-env] [--with-test-preset] [--yes] [--no-install] [--package-manager <id>]
+  wp-typia create <project-dir> [--template persistence] [--data-storage <post-meta|custom-table>] [--persistence-policy <authenticated|public>] [--namespace <value>] [--text-domain <value>] [--php-prefix <value>] [--with-migration-ui] [--with-wp-env] [--with-test-preset] [--yes] [--no-install] [--package-manager <id>]
+  wp-typia create <project-dir> [--template compound] [--data-storage <post-meta|custom-table>] [--persistence-policy <authenticated|public>] [--namespace <value>] [--text-domain <value>] [--php-prefix <value>] [--with-migration-ui] [--with-wp-env] [--with-test-preset] [--yes] [--no-install] [--package-manager <id>]
+  wp-typia <project-dir> [create flags...]
+  wp-typia add block <name> --template <basic|interactivity|persistence|compound> [--data-storage <post-meta|custom-table>] [--persistence-policy <authenticated|public>]
+  wp-typia add variation
+  wp-typia add pattern
+  wp-typia migrate <init|snapshot|diff|scaffold|verify|doctor|fixtures|fuzz> [...]
+  wp-typia templates list
+  wp-typia templates inspect <id>
+  wp-typia doctor
+  wp-typia mcp <list|sync>
+  wp-typia skills <list|sync>
+  wp-typia completions <bash|zsh|fish|powershell>
+
+Built-in templates: ${TEMPLATE_IDS.join(", ")}
+Package managers: ${PACKAGE_MANAGER_IDS.join(", ")}
+Notes:
+  \`wp-typia create\` is the canonical scaffold command.
+  \`wp-typia <project-dir>\` remains a backward-compatible alias to \`create\`.
+  \`add variation\` and \`add pattern\` are reserved placeholders in this release.
+  \`migrate\` is the canonical migration command; \`migrations\` is no longer supported.`;
+}

package/dist/runtime/cli-prompt.d.ts

@@ -0,0 +1,21 @@
+type ValidateInput = (value: string) => boolean | string;
+interface PromptOption<T extends string> {
+    hint?: string;
+    label: string;
+    value: T;
+}
+/**
+ * Prompt adapter used by CLI scaffold flows and migration wizard flows.
+ */
+export interface ReadlinePrompt {
+    close(): void;
+    select<T extends string>(message: string, options: PromptOption<T>[], defaultValue?: number): Promise<T>;
+    text(message: string, defaultValue: string, validate?: ValidateInput): Promise<string>;
+}
+/**
+ * Create the default readline-backed prompt implementation for the CLI.
+ *
+ * @returns A prompt adapter that reads from stdin and writes to stdout.
+ */
+export declare function createReadlinePrompt(): ReadlinePrompt;
+export {};

package/dist/runtime/cli-prompt.js

@@ -0,0 +1,53 @@
+import readline from "node:readline";
+/**
+ * Create the default readline-backed prompt implementation for the CLI.
+ *
+ * @returns A prompt adapter that reads from stdin and writes to stdout.
+ */
+export function createReadlinePrompt() {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return {
+        async text(message, defaultValue, validate) {
+            const suffix = defaultValue ? ` (${defaultValue})` : "";
+            const answer = await new Promise((resolve) => {
+                rl.question(`${message}${suffix}: `, resolve);
+            });
+            const value = String(answer).trim() || defaultValue;
+            if (validate) {
+                const result = validate(value);
+                if (result !== true) {
+                    console.error(`❌ ${typeof result === "string" ? result : "Invalid input"}`);
+                    return this.text(message, defaultValue, validate);
+                }
+            }
+            return value;
+        },
+        async select(message, options, defaultValue = 1) {
+            if (options.length === 0) {
+                throw new Error(`select() requires at least one option for prompt: ${message}`);
+            }
+            console.log(message);
+            options.forEach((option, index) => {
+                const hint = option.hint ? ` - ${option.hint}` : "";
+                console.log(`  ${index + 1}. ${option.label}${hint}`);
+            });
+            const answer = await this.text("Choice", String(defaultValue));
+            const numericChoice = Number(answer);
+            if (!Number.isNaN(numericChoice) && options[numericChoice - 1]) {
+                return options[numericChoice - 1].value;
+            }
+            const directChoice = options.find((option) => option.value === answer);
+            if (directChoice) {
+                return directChoice.value;
+            }
+            console.error(`❌ Invalid selection: ${answer}`);
+            return this.select(message, options, defaultValue);
+        },
+        close() {
+            rl.close();
+        },
+    };
+}

package/dist/runtime/cli-scaffold.d.ts

@@ -0,0 +1,79 @@
+import { collectScaffoldAnswers, scaffoldProject } from "./scaffold.js";
+import type { DataStorageMode, PersistencePolicy } from "./scaffold.js";
+import type { PackageManagerId } from "./package-managers.js";
+import type { TemplateDefinition } from "./template-registry.js";
+interface GetNextStepsOptions {
+    noInstall: boolean;
+    packageManager: PackageManagerId;
+    projectDir: string;
+    projectInput: string;
+    templateId: string;
+}
+interface GetOptionalOnboardingOptions {
+    packageManager: PackageManagerId;
+    templateId: string;
+    compoundPersistenceEnabled?: boolean;
+}
+interface OptionalOnboardingGuidance {
+    note: string;
+    steps: string[];
+}
+interface RunScaffoldFlowOptions {
+    allowExistingDir?: boolean;
+    cwd?: string;
+    dataStorageMode?: string;
+    installDependencies?: Parameters<typeof scaffoldProject>[0]["installDependencies"];
+    isInteractive?: boolean;
+    namespace?: string;
+    noInstall?: boolean;
+    packageManager?: string;
+    phpPrefix?: string;
+    projectInput: string;
+    promptText?: Parameters<typeof collectScaffoldAnswers>[0]["promptText"];
+    selectDataStorage?: () => Promise<DataStorageMode>;
+    selectPackageManager?: () => Promise<PackageManagerId>;
+    selectPersistencePolicy?: () => Promise<PersistencePolicy>;
+    selectTemplate?: () => Promise<TemplateDefinition["id"]>;
+    selectWithMigrationUi?: () => Promise<boolean>;
+    selectWithTestPreset?: () => Promise<boolean>;
+    selectWithWpEnv?: () => Promise<boolean>;
+    templateId?: string;
+    textDomain?: string;
+    variant?: string;
+    persistencePolicy?: string;
+    withMigrationUi?: boolean;
+    withTestPreset?: boolean;
+    withWpEnv?: boolean;
+    yes?: boolean;
+}
+/**
+ * Build the printed next-step commands for a scaffolded project.
+ *
+ * @param options Project location and package-manager details used to format
+ * next-step commands.
+ * @returns Ordered shell commands shown after scaffolding succeeds.
+ */
+export declare function getNextSteps({ projectInput, projectDir, packageManager, noInstall, templateId, }: GetNextStepsOptions): string[];
+/**
+ * Compute optional onboarding guidance shown after scaffolding completes.
+ *
+ * @param options Package-manager and template context for optional guidance.
+ * @returns Optional onboarding note and step list.
+ */
+export declare function getOptionalOnboarding({ packageManager, templateId, compoundPersistenceEnabled, }: GetOptionalOnboardingOptions): OptionalOnboardingGuidance;
+/**
+ * Resolve scaffold options, prompts, and follow-up steps for one CLI run.
+ *
+ * @param options CLI/runtime inputs used to collect answers and scaffold a
+ * project.
+ * @returns The scaffold result together with next-step guidance.
+ */
+export declare function runScaffoldFlow({ projectInput, cwd, templateId, dataStorageMode, persistencePolicy, packageManager, namespace, textDomain, phpPrefix, yes, noInstall, isInteractive, allowExistingDir, selectTemplate, selectDataStorage, selectPersistencePolicy, selectPackageManager, promptText, installDependencies, variant, selectWithTestPreset, selectWithWpEnv, selectWithMigrationUi, withMigrationUi, withTestPreset, withWpEnv, }: RunScaffoldFlowOptions): Promise<{
+    optionalOnboarding: OptionalOnboardingGuidance;
+    projectDir: string;
+    projectInput: string;
+    packageManager: PackageManagerId;
+    result: import("./scaffold.js").ScaffoldProjectResult;
+    nextSteps: string[];
+}>;
+export {};

package/dist/runtime/cli-scaffold.js

@@ -0,0 +1,206 @@
+import path from "node:path";
+import { collectScaffoldAnswers, DATA_STORAGE_MODES, PERSISTENCE_POLICIES, isDataStorageMode, isPersistencePolicy, resolvePackageManagerId, resolveTemplateId, scaffoldProject, } from "./scaffold.js";
+import { formatInstallCommand, formatRunScript, } from "./package-managers.js";
+import { getPrimaryDevelopmentScript } from "./local-dev-presets.js";
+import { getOptionalOnboardingNote, getOptionalOnboardingSteps, } from "./scaffold-onboarding.js";
+import { isBuiltInTemplateId } from "./template-registry.js";
+const OFFICIAL_WORKSPACE_TEMPLATE_PACKAGE = "@wp-typia/create-workspace-template";
+function templateUsesPersistenceSettings(templateId, options) {
+    if (templateId === "persistence") {
+        return true;
+    }
+    if (templateId !== "compound") {
+        return false;
+    }
+    return Boolean(options.dataStorageMode || options.persistencePolicy);
+}
+function parseSelectableValue(label, value, isValue, allowedValues) {
+    if (isValue(value)) {
+        return value;
+    }
+    throw new Error(`Unsupported ${label} "${value}". Expected one of: ${allowedValues.join(", ")}`);
+}
+async function resolveOptionalSelection({ defaultValue, explicitValue, isInteractive, isValue, label, allowedValues, select, shouldResolve = true, yes, }) {
+    if (!shouldResolve) {
+        return undefined;
+    }
+    if (explicitValue) {
+        return parseSelectableValue(label, explicitValue, isValue, allowedValues);
+    }
+    if (yes) {
+        return defaultValue;
+    }
+    if (isInteractive && select) {
+        return select();
+    }
+    return defaultValue;
+}
+async function resolveOptionalBooleanFlag({ defaultValue = false, disabled = false, explicitValue, isInteractive, select, yes, }) {
+    if (disabled) {
+        return defaultValue;
+    }
+    if (typeof explicitValue === "boolean") {
+        return explicitValue;
+    }
+    if (yes) {
+        return defaultValue;
+    }
+    if (isInteractive && select) {
+        return select();
+    }
+    return defaultValue;
+}
+function quoteShellValue(value) {
+    if (!value.startsWith("-") &&
+        /^[A-Za-z0-9._/@:-]+(?:\/[A-Za-z0-9._@:-]+)*$/.test(value)) {
+        return value;
+    }
+    return `'${value.replace(/'/g, `'\"'\"'`)}'`;
+}
+/**
+ * Build the printed next-step commands for a scaffolded project.
+ *
+ * @param options Project location and package-manager details used to format
+ * next-step commands.
+ * @returns Ordered shell commands shown after scaffolding succeeds.
+ */
+export function getNextSteps({ projectInput, projectDir, packageManager, noInstall, templateId, }) {
+    const cdTarget = path.isAbsolute(projectInput) ? projectDir : projectInput;
+    const steps = [`cd ${quoteShellValue(cdTarget)}`];
+    if (noInstall) {
+        steps.push(formatInstallCommand(packageManager));
+    }
+    steps.push(formatRunScript(packageManager, getPrimaryDevelopmentScript(templateId)));
+    return steps;
+}
+/**
+ * Compute optional onboarding guidance shown after scaffolding completes.
+ *
+ * @param options Package-manager and template context for optional guidance.
+ * @returns Optional onboarding note and step list.
+ */
+export function getOptionalOnboarding({ packageManager, templateId, compoundPersistenceEnabled = false, }) {
+    return {
+        note: getOptionalOnboardingNote(packageManager, templateId),
+        steps: getOptionalOnboardingSteps(packageManager, templateId, {
+            compoundPersistenceEnabled,
+        }),
+    };
+}
+/**
+ * Resolve scaffold options, prompts, and follow-up steps for one CLI run.
+ *
+ * @param options CLI/runtime inputs used to collect answers and scaffold a
+ * project.
+ * @returns The scaffold result together with next-step guidance.
+ */
+export async function runScaffoldFlow({ projectInput, cwd = process.cwd(), templateId, dataStorageMode, persistencePolicy, packageManager, namespace, textDomain, phpPrefix, yes = false, noInstall = false, isInteractive = false, allowExistingDir = false, selectTemplate, selectDataStorage, selectPersistencePolicy, selectPackageManager, promptText, installDependencies = undefined, variant, selectWithTestPreset, selectWithWpEnv, selectWithMigrationUi, withMigrationUi, withTestPreset, withWpEnv, }) {
+    if (!projectInput) {
+        throw new Error("Project directory is required. Usage: wp-typia create <project-dir> (or wp-typia <project-dir>).");
+    }
+    const resolvedTemplateId = await resolveTemplateId({
+        templateId,
+        yes,
+        isInteractive,
+        selectTemplate,
+    });
+    const shouldResolvePersistence = templateUsesPersistenceSettings(resolvedTemplateId, {
+        dataStorageMode,
+        persistencePolicy,
+    });
+    const resolvedDataStorage = await resolveOptionalSelection({
+        allowedValues: DATA_STORAGE_MODES,
+        defaultValue: "custom-table",
+        explicitValue: dataStorageMode,
+        isInteractive,
+        isValue: isDataStorageMode,
+        label: "data storage mode",
+        select: selectDataStorage,
+        shouldResolve: shouldResolvePersistence,
+        yes,
+    });
+    const resolvedPersistencePolicy = await resolveOptionalSelection({
+        allowedValues: PERSISTENCE_POLICIES,
+        defaultValue: "authenticated",
+        explicitValue: persistencePolicy,
+        isInteractive,
+        isValue: isPersistencePolicy,
+        label: "persistence policy",
+        select: selectPersistencePolicy,
+        shouldResolve: shouldResolvePersistence,
+        yes,
+    });
+    const resolvedPackageManager = await resolvePackageManagerId({
+        packageManager,
+        yes,
+        isInteractive,
+        selectPackageManager,
+    });
+    const resolvedWithWpEnv = await resolveOptionalBooleanFlag({
+        explicitValue: withWpEnv,
+        isInteractive,
+        select: selectWithWpEnv,
+        yes,
+    });
+    const resolvedWithTestPreset = await resolveOptionalBooleanFlag({
+        explicitValue: withTestPreset,
+        isInteractive,
+        select: selectWithTestPreset,
+        yes,
+    });
+    const resolvedWithMigrationUi = await resolveOptionalBooleanFlag({
+        disabled: !isBuiltInTemplateId(resolvedTemplateId) &&
+            resolvedTemplateId !== OFFICIAL_WORKSPACE_TEMPLATE_PACKAGE,
+        explicitValue: withMigrationUi,
+        isInteractive,
+        select: selectWithMigrationUi,
+        yes,
+    });
+    const projectDir = path.resolve(cwd, projectInput);
+    const projectName = path.basename(projectDir);
+    const answers = await collectScaffoldAnswers({
+        dataStorageMode: resolvedDataStorage,
+        namespace,
+        persistencePolicy: resolvedPersistencePolicy,
+        phpPrefix,
+        projectName,
+        templateId: resolvedTemplateId,
+        textDomain,
+        yes,
+        promptText,
+    });
+    const result = await scaffoldProject({
+        answers,
+        allowExistingDir,
+        cwd,
+        dataStorageMode: resolvedDataStorage,
+        installDependencies,
+        noInstall,
+        packageManager: resolvedPackageManager,
+        persistencePolicy: resolvedPersistencePolicy,
+        projectDir,
+        templateId: resolvedTemplateId,
+        variant,
+        withMigrationUi: resolvedWithMigrationUi,
+        withTestPreset: resolvedWithTestPreset,
+        withWpEnv: resolvedWithWpEnv,
+    });
+    return {
+        optionalOnboarding: getOptionalOnboarding({
+            packageManager: resolvedPackageManager,
+            templateId: resolvedTemplateId,
+            compoundPersistenceEnabled: result.variables.compoundPersistenceEnabled === "true",
+        }),
+        projectDir,
+        projectInput,
+        packageManager: resolvedPackageManager,
+        result,
+        nextSteps: getNextSteps({
+            projectInput,
+            projectDir,
+            packageManager: resolvedPackageManager,
+            noInstall,
+            templateId: resolvedTemplateId,
+        }),
+    };
+}

package/dist/runtime/cli-templates.d.ts

@@ -0,0 +1,30 @@
+import { getTemplateById, getTemplateSelectOptions, isBuiltInTemplateId, listTemplates } from "./template-registry.js";
+import type { TemplateDefinition } from "./template-registry.js";
+/**
+ * Format one line of template list output for a built-in template.
+ *
+ * @param template Template metadata including `id` and `description`.
+ * @returns One-line summary text for `templates list`.
+ */
+export declare function formatTemplateSummary(template: TemplateDefinition): string;
+/**
+ * Format the feature hint line shown under a template summary.
+ *
+ * @param template Template metadata including the `features` list.
+ * @returns Indented feature text for CLI list output.
+ */
+export declare function formatTemplateFeatures(template: TemplateDefinition): string;
+/**
+ * Format the detailed template description for `templates inspect`.
+ *
+ * This expands special layer combinations for the `persistence` and `compound`
+ * templates and returns a multi-line block including category, overlay path,
+ * resolved layers, and feature labels.
+ *
+ * @param template Template metadata including `id`, `defaultCategory`,
+ * `templateDir`, and `features`.
+ * @returns Multi-line template details text for CLI output.
+ */
+export declare function formatTemplateDetails(template: TemplateDefinition): string;
+export { getTemplateById, getTemplateSelectOptions, listTemplates };
+export { isBuiltInTemplateId };