wp-typia 0.20.5 → 0.22.0

package/dist-bunli/cli-init-djhwr245.js

@@ -0,0 +1,844 @@
+// @bun
+import {
+  getPackageVersions
+} from "./cli-39er8888.js";
+import {
+  discoverMigrationInitLayout
+} from "./cli-gcbre1zs.js";
+import {
+  formatAddDevDependenciesCommand,
+  formatPackageExecCommand,
+  formatRunScript,
+  getPackageManager,
+  transformPackageManagerText
+} from "./cli-sj5mtyzj.js";
+import"./cli-tke8twkn.js";
+import {
+  quoteTsString,
+  require_typescript,
+  rollbackWorkspaceMutation,
+  snapshotWorkspaceFiles,
+  toPascalCase,
+  updateWorkspaceInventorySource
+} from "./cli-j180bk07.js";
+import {
+  CLI_DIAGNOSTIC_CODES,
+  createCliDiagnosticCodeError
+} from "./cli-p95wr1q8.js";
+import {
+  parseWorkspacePackageManagerId,
+  tryResolveWorkspaceProject
+} from "./cli-pd5pqgre.js";
+import {
+  __toESM
+} from "./cli-xnn9xjcy.js";
+
+// ../wp-typia-project-tools/src/runtime/cli-init.ts
+var import_typescript = __toESM(require_typescript(), 1);
+import fs from "fs";
+import { promises as fsp } from "fs";
+import path from "path";
+import { analyzeSourceTypes } from "@wp-typia/block-runtime/metadata-parser";
+var SUPPORTED_RETROFIT_LAYOUT_NOTE = "Supported retrofit layouts currently mirror the migration bootstrap detector: `src/block.json` + `src/types.ts` + `src/save.tsx`, legacy root `block.json` + `src/types.ts` + `src/save.tsx`, or multi-block `src/blocks/*/block.json` workspaces.";
+var RETROFIT_APPLY_PREVIEW_NOTE = "If you rerun with `wp-typia init --apply`, package.json and generated helper files are snapshotted and rolled back automatically if a write fails.";
+var RETROFIT_ROLLBACK_NOTE = "Apply mode writes package.json and generated helper files with rollback-on-failure protection.";
+var BASE_RETROFIT_SCRIPTS = {
+  sync: "tsx scripts/sync-project.ts",
+  "sync-types": "tsx scripts/sync-types-to-block-json.ts",
+  typecheck: "bun run sync --check && tsc --noEmit"
+};
+var BASE_RETROFIT_DEV_DEPENDENCIES = [
+  "@typia/unplugin",
+  "@wp-typia/block-runtime",
+  "@wp-typia/block-types",
+  "tsx",
+  "typescript",
+  "typia"
+];
+function normalizeRelativePath(value) {
+  return value.replace(/\\/gu, "/");
+}
+function readProjectPackageJson(projectDir) {
+  const packageJsonPath = path.join(projectDir, "package.json");
+  if (!fs.existsSync(packageJsonPath)) {
+    return null;
+  }
+  const source = fs.readFileSync(packageJsonPath, "utf8");
+  try {
+    return JSON.parse(source);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.INVALID_ARGUMENT, `Unable to parse ${packageJsonPath}: ${message}`, error instanceof Error ? { cause: error } : undefined);
+  }
+}
+function inferInitPackageManager(projectDir, packageJson) {
+  if (packageJson?.packageManager) {
+    return parseWorkspacePackageManagerId(packageJson.packageManager);
+  }
+  if (fs.existsSync(path.join(projectDir, "bun.lock")) || fs.existsSync(path.join(projectDir, "bun.lockb"))) {
+    return "bun";
+  }
+  if (fs.existsSync(path.join(projectDir, "pnpm-lock.yaml"))) {
+    return "pnpm";
+  }
+  if (fs.existsSync(path.join(projectDir, "yarn.lock")) || fs.existsSync(path.join(projectDir, ".yarnrc.yml"))) {
+    return "yarn";
+  }
+  return "npm";
+}
+function resolveInitPackageManager(projectDir, packageJson, override) {
+  if (!override) {
+    return inferInitPackageManager(projectDir, packageJson);
+  }
+  if (override !== "bun" && override !== "npm" && override !== "pnpm" && override !== "yarn") {
+    throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.INVALID_ARGUMENT, `Unknown package manager "${override}". Expected one of: bun, npm, pnpm, yarn.`);
+  }
+  return override;
+}
+function getWpTypiaCliSpecifier() {
+  const versions = getPackageVersions();
+  return versions.wpTypiaPackageExactVersion === "0.0.0" ? "wp-typia" : `wp-typia@${versions.wpTypiaPackageExactVersion}`;
+}
+function buildRequiredDevDependencyMap() {
+  const versions = getPackageVersions();
+  return {
+    "@typia/unplugin": versions.typiaUnpluginPackageVersion,
+    "@wp-typia/block-runtime": versions.blockRuntimePackageVersion,
+    "@wp-typia/block-types": versions.blockTypesPackageVersion,
+    tsx: versions.tsxPackageVersion,
+    typescript: versions.typescriptPackageVersion,
+    typia: versions.typiaPackageVersion
+  };
+}
+function getExistingDependencyVersion(packageJson, name) {
+  return packageJson?.devDependencies?.[name] ?? packageJson?.dependencies?.[name];
+}
+function buildDependencyChanges(packageJson) {
+  const requiredDependencies = buildRequiredDevDependencyMap();
+  return BASE_RETROFIT_DEV_DEPENDENCIES.flatMap((name) => {
+    const requiredValue = requiredDependencies[name];
+    const currentValue = getExistingDependencyVersion(packageJson, name);
+    if (currentValue === requiredValue) {
+      return [];
+    }
+    return [
+      {
+        action: currentValue ? "update" : "add",
+        ...currentValue ? { currentValue } : {},
+        name,
+        requiredValue
+      }
+    ];
+  });
+}
+function buildScriptChanges(packageJson, packageManager) {
+  const scripts = packageJson?.scripts ?? {};
+  return Object.entries(BASE_RETROFIT_SCRIPTS).flatMap(([name, commandSource]) => {
+    const requiredValue = transformPackageManagerText(commandSource, packageManager);
+    const currentValue = scripts[name];
+    if (currentValue === requiredValue) {
+      return [];
+    }
+    return [
+      {
+        action: typeof currentValue === "string" ? "update" : "add",
+        ...typeof currentValue === "string" ? { currentValue } : {},
+        name,
+        requiredValue
+      }
+    ];
+  });
+}
+function buildPackageManagerFieldChange(packageJson, packageManager, options = {}) {
+  if (!options.persistExplicitOverride && packageManager === "npm") {
+    return;
+  }
+  const requiredValue = getPackageManager(packageManager).packageManagerField;
+  const currentValue = packageJson?.packageManager;
+  if (currentValue === requiredValue) {
+    return;
+  }
+  return {
+    action: typeof currentValue === "string" ? "update" : "add",
+    ...typeof currentValue === "string" ? { currentValue } : {},
+    requiredValue
+  };
+}
+function buildGeneratedArtifactPaths(blockJsonFile, manifestFile) {
+  const manifestDir = path.dirname(manifestFile);
+  const artifactPaths = [
+    blockJsonFile,
+    manifestFile,
+    path.join(manifestDir, "typia.schema.json"),
+    path.join(manifestDir, "typia-validator.php"),
+    path.join(manifestDir, "typia.openapi.json")
+  ];
+  return Array.from(new Set(artifactPaths.map((filePath) => normalizeRelativePath(filePath))));
+}
+function collectNamedSourceTypeCandidates(typesSource) {
+  const sourceFile = import_typescript.default.createSourceFile("types.ts", typesSource, import_typescript.default.ScriptTarget.Latest, true, import_typescript.default.ScriptKind.TS);
+  return sourceFile.statements.flatMap((statement) => {
+    if (import_typescript.default.isInterfaceDeclaration(statement) || import_typescript.default.isTypeAliasDeclaration(statement)) {
+      return [statement.name.text];
+    }
+    return [];
+  });
+}
+function isObjectLikeSourceType(projectDir, typesFile, sourceTypeName) {
+  const analyzedTypes = analyzeSourceTypes({
+    projectRoot: projectDir,
+    typesFile
+  }, [sourceTypeName]);
+  return analyzedTypes[sourceTypeName]?.kind === "object";
+}
+function inferRetrofitAttributeTypeName(projectDir, block) {
+  const typesPath = path.join(projectDir, block.typesFile);
+  const typesSource = fs.readFileSync(typesPath, "utf8");
+  const blockNameSegments = block.blockName.split("/");
+  const slug = blockNameSegments[blockNameSegments.length - 1] ?? block.key;
+  const candidateNames = collectNamedSourceTypeCandidates(typesSource);
+  const validCandidates = candidateNames.filter((candidateName) => isObjectLikeSourceType(projectDir, block.typesFile, candidateName));
+  const preferredName = `${toPascalCase(slug)}Attributes`;
+  if (validCandidates.includes(preferredName)) {
+    return preferredName;
+  }
+  const attributeCandidates = validCandidates.filter((candidateName) => candidateName.endsWith("Attributes"));
+  if (attributeCandidates.length === 1) {
+    return attributeCandidates[0];
+  }
+  if (validCandidates.length === 1) {
+    return validCandidates[0];
+  }
+  if (validCandidates.length === 0) {
+    throw new Error(`Unable to infer an object-like source type from ${block.typesFile}. Add one interface or type alias such as ${preferredName} before rerunning \`wp-typia init\`.`);
+  }
+  throw new Error(`Unable to infer a unique source type from ${block.typesFile}. Candidate object-like exports: ${validCandidates.join(", ")}. Rename one to ${preferredName} or leave a single object-like attributes type before rerunning \`wp-typia init\`.`);
+}
+function buildRetrofitBlockTarget(projectDir, block) {
+  const blockNameSegments = block.blockName.split("/");
+  const slug = blockNameSegments[blockNameSegments.length - 1] ?? block.key;
+  return {
+    attributeTypeName: inferRetrofitAttributeTypeName(projectDir, block),
+    blockJsonFile: block.blockJsonFile,
+    blockName: block.blockName,
+    manifestFile: block.manifestFile,
+    saveFile: block.saveFile,
+    slug,
+    typesFile: block.typesFile
+  };
+}
+function buildRetrofitBlockConfigEntry(target) {
+  return [
+    "\t{",
+    `		slug: ${quoteTsString(target.slug)},`,
+    `		attributeTypeName: ${quoteTsString(target.attributeTypeName)},`,
+    `		blockJsonFile: ${quoteTsString(target.blockJsonFile)},`,
+    `		manifestFile: ${quoteTsString(target.manifestFile)},`,
+    `		typesFile: ${quoteTsString(target.typesFile)},`,
+    "\t},"
+  ].join(`
+`);
+}
+function buildRetrofitBlockConfigSource(targets) {
+  const blockEntries = targets.map(buildRetrofitBlockConfigEntry).join(`
+`);
+  const baseSource = `export interface WorkspaceBlockConfig {
+	attributeTypeName: string;
+	apiTypesFile?: string;
+	blockJsonFile?: string;
+	manifestFile?: string;
+	openApiFile?: string;
+	restManifest?: ReturnType<
+		typeof import( '@wp-typia/block-runtime/metadata-core' ).defineEndpointManifest
+	>;
+	slug: string;
+	typesFile: string;
+}
+
+export const BLOCKS: WorkspaceBlockConfig[] = [
+${blockEntries}
+];
+`;
+  return `${updateWorkspaceInventorySource(baseSource)}
+`;
+}
+function buildRetrofitSyncTypesScriptSource() {
+  return `/* eslint-disable no-console */
+import path from 'node:path';
+
+import { syncBlockMetadata } from '@wp-typia/block-runtime/metadata-core';
+
+import { BLOCKS } from './block-config';
+
+function parseCliOptions( argv: string[] ) {
+	const options = {
+		check: false,
+	};
+
+	for ( const argument of argv ) {
+		if ( argument === '--check' ) {
+			options.check = true;
+			continue;
+		}
+
+		throw new Error( \`Unknown sync-types flag: \${ argument }\` );
+	}
+
+	return options;
+}
+
+async function main() {
+	const options = parseCliOptions( process.argv.slice( 2 ) );
+
+	if ( BLOCKS.length === 0 ) {
+		console.log(
+			options.check
+				? '\u2139\uFE0F No retrofit blocks are registered yet. \`sync-types --check\` is already clean.'
+				: '\u2139\uFE0F No retrofit blocks are registered yet. Add one block target to scripts/block-config.ts before rerunning sync-types.'
+		);
+		return;
+	}
+
+	for ( const block of BLOCKS ) {
+		const blockDir = path.dirname( block.typesFile );
+		const blockJsonFile =
+			block.blockJsonFile ?? path.join( blockDir, 'block.json' );
+		const manifestFile =
+			block.manifestFile ?? path.join( blockDir, 'typia.manifest.json' );
+		const manifestDir = path.dirname( manifestFile );
+		const result = await syncBlockMetadata(
+			{
+				blockJsonFile,
+				jsonSchemaFile: path.join( manifestDir, 'typia.schema.json' ),
+				manifestFile,
+				openApiFile: path.join( manifestDir, 'typia.openapi.json' ),
+				sourceTypeName: block.attributeTypeName,
+				typesFile: block.typesFile,
+			},
+			{
+				check: options.check,
+			}
+		);
+		for ( const warning of result.lossyProjectionWarnings ) {
+			console.warn( \`\u26A0\uFE0F \${ block.slug }: \${ warning }\` );
+		}
+		for ( const warning of result.phpGenerationWarnings ) {
+			console.warn( \`\u26A0\uFE0F \${ block.slug }: \${ warning }\` );
+		}
+
+		console.log(
+			options.check
+				? \`\u2705 \${ block.slug }: block.json, typia.manifest.json, typia-validator.php, typia.schema.json, and typia.openapi.json are already up to date with the TypeScript types!\`
+				: \`\u2705 \${ block.slug }: block.json, typia.manifest.json, typia-validator.php, typia.schema.json, and typia.openapi.json were generated from TypeScript types!\`
+		);
+		console.log( '\uD83D\uDCDD Generated attributes:', result.attributeNames );
+	}
+}
+
+main().catch( ( error ) => {
+	console.error( '\u274C Type sync failed:', error );
+	process.exit( 1 );
+} );
+`;
+}
+function buildRetrofitSyncProjectScriptSource() {
+  return `/* eslint-disable no-console */
+import { spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+
+interface SyncCliOptions {
+	check: boolean;
+}
+
+function parseCliOptions( argv: string[] ): SyncCliOptions {
+	const options: SyncCliOptions = {
+		check: false,
+	};
+
+	for ( const argument of argv ) {
+		if ( argument === '--check' ) {
+			options.check = true;
+			continue;
+		}
+
+		throw new Error( \`Unknown sync flag: \${ argument }\` );
+	}
+
+	return options;
+}
+
+function getSyncScriptEnv() {
+	const binaryDirectory = path.join( process.cwd(), 'node_modules', '.bin' );
+	const inheritedPath =
+		process.env.PATH ??
+		process.env.Path ??
+		Object.entries( process.env ).find(
+			( [ key ] ) => key.toLowerCase() === 'path'
+		)?.[ 1 ] ??
+		'';
+	const nextPath = fs.existsSync( binaryDirectory )
+		? \`\${ binaryDirectory }\${ path.delimiter }\${ inheritedPath }\`
+		: inheritedPath;
+	const env: NodeJS.ProcessEnv = {
+		...process.env,
+	};
+
+	for ( const key of Object.keys( env ) ) {
+		if ( key.toLowerCase() === 'path' ) {
+			delete env[ key ];
+		}
+	}
+
+	env.PATH = nextPath;
+
+	return env;
+}
+
+function runSyncScript( scriptPath: string, options: SyncCliOptions ) {
+	const args = [ scriptPath ];
+	if ( options.check ) {
+		args.push( '--check' );
+	}
+
+	const result = spawnSync( 'tsx', args, {
+		cwd: process.cwd(),
+		env: getSyncScriptEnv(),
+		shell: process.platform === 'win32',
+		stdio: 'inherit',
+	} );
+
+	if ( result.error ) {
+		if ( ( result.error as NodeJS.ErrnoException ).code === 'ENOENT' ) {
+			throw new Error(
+				'Unable to resolve \`tsx\` for project sync. Install project dependencies or rerun the command through your package manager.'
+			);
+		}
+
+		throw result.error;
+	}
+
+	if ( result.status !== 0 ) {
+		throw new Error( \`Sync script failed: \${ scriptPath }\` );
+	}
+}
+
+async function main() {
+	const options = parseCliOptions( process.argv.slice( 2 ) );
+	const syncTypesScriptPath = path.join( 'scripts', 'sync-types-to-block-json.ts' );
+
+	runSyncScript( syncTypesScriptPath, options );
+
+	console.log(
+		options.check
+			? '\u2705 Generated project metadata is already synchronized.'
+			: '\u2705 Generated project metadata was synchronized.'
+	);
+}
+
+main().catch( ( error ) => {
+	console.error( '\u274C Project sync failed:', error );
+	process.exit( 1 );
+} );
+`;
+}
+function buildLayoutDetails(projectDir) {
+  try {
+    const discoveredLayout = discoverMigrationInitLayout(projectDir);
+    const discoveredBlocks = discoveredLayout.mode === "multi" ? discoveredLayout.blocks : [discoveredLayout.block];
+    let blockTargets;
+    try {
+      blockTargets = discoveredBlocks.map((block) => buildRetrofitBlockTarget(projectDir, block));
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return {
+        blockNames: discoveredBlocks.map((block) => block.blockName),
+        blockTargets: [],
+        description: "Detected supported block files, but could not infer retrofit block-config metadata automatically yet.",
+        generatedArtifacts: [],
+        kind: "unsupported",
+        notes: [message, SUPPORTED_RETROFIT_LAYOUT_NOTE]
+      };
+    }
+    if (discoveredLayout.mode === "multi") {
+      return {
+        blockNames: discoveredBlocks.map((block) => block.blockName),
+        blockTargets,
+        description: `Detected a supported multi-block retrofit candidate (${discoveredBlocks.length} targets).`,
+        generatedArtifacts: discoveredBlocks.flatMap((block) => buildGeneratedArtifactPaths(block.blockJsonFile, block.manifestFile)),
+        kind: "multi-block",
+        notes: [
+          "Migration bootstrap can stay optional. Add it later with `wp-typia migrate init --current-migration-version v1` once the typed sync surface is in place."
+        ]
+      };
+    }
+    return {
+      blockNames: [discoveredLayout.block.blockName],
+      blockTargets,
+      description: "Detected a supported single-block retrofit candidate.",
+      generatedArtifacts: buildGeneratedArtifactPaths(discoveredLayout.block.blockJsonFile, discoveredLayout.block.manifestFile),
+      kind: "single-block",
+      notes: discoveredLayout.block.blockJsonFile === "block.json" ? [
+        "Legacy root `block.json` layouts are still supported for retrofit planning, but newer scaffolds keep generated block metadata under `src/`."
+      ] : []
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      blockNames: [],
+      blockTargets: [],
+      description: "No supported retrofit layout was auto-detected yet.",
+      generatedArtifacts: [],
+      kind: "unsupported",
+      notes: [message, SUPPORTED_RETROFIT_LAYOUT_NOTE]
+    };
+  }
+}
+function hasExistingWpTypiaProjectSurface(projectDir, packageJson) {
+  const scripts = packageJson?.scripts ?? {};
+  const hasSyncSurface = typeof scripts.sync === "string" || typeof scripts["sync-types"] === "string";
+  const hasHelperFiles = [
+    path.join("scripts", "block-config.ts"),
+    path.join("scripts", "sync-project.ts"),
+    path.join("scripts", "sync-types-to-block-json.ts")
+  ].every((relativePath) => fs.existsSync(path.join(projectDir, relativePath)));
+  const hasRuntimeDeps = typeof getExistingDependencyVersion(packageJson, "@wp-typia/block-runtime") === "string" && typeof getExistingDependencyVersion(packageJson, "@wp-typia/block-types") === "string";
+  return hasSyncSurface && hasHelperFiles && hasRuntimeDeps;
+}
+function buildPlannedFiles(projectDir, layoutKind) {
+  if (layoutKind === "unsupported") {
+    return [];
+  }
+  return [
+    {
+      action: fs.existsSync(path.join(projectDir, "scripts", "block-config.ts")) ? "update" : "add",
+      path: "scripts/block-config.ts",
+      purpose: "Declare the current retrofit block targets so sync-types can regenerate metadata from the existing TypeScript source of truth."
+    },
+    {
+      action: fs.existsSync(path.join(projectDir, "scripts", "sync-types-to-block-json.ts")) ? "update" : "add",
+      path: "scripts/sync-types-to-block-json.ts",
+      purpose: "Generate block.json and Typia metadata artifacts from the current TypeScript source of truth."
+    },
+    {
+      action: fs.existsSync(path.join(projectDir, "scripts", "sync-project.ts")) ? "update" : "add",
+      path: "scripts/sync-project.ts",
+      purpose: "Provide one shared sync entrypoint that can grow into sync-rest or workspace-aware refresh steps later."
+    }
+  ];
+}
+function buildChangeSummary(changes, options) {
+  const lines = [];
+  for (const dependencyChange of changes.packageChanges.addDevDependencies) {
+    lines.push(`devDependency ${dependencyChange.action} ${dependencyChange.name} -> ${dependencyChange.requiredValue}`);
+  }
+  if (changes.packageChanges.packageManagerField) {
+    lines.push(`packageManager ${changes.packageChanges.packageManagerField.action} -> ${changes.packageChanges.packageManagerField.requiredValue}`);
+  }
+  for (const scriptChange of changes.packageChanges.scripts) {
+    lines.push(`script ${scriptChange.action} ${scriptChange.name} -> ${scriptChange.requiredValue}`);
+  }
+  for (const filePlan of changes.plannedFiles) {
+    lines.push(`file ${filePlan.action} ${filePlan.path} (${filePlan.purpose})`);
+  }
+  if (options.includeGeneratedArtifacts) {
+    for (const artifactPath of changes.generatedArtifacts) {
+      lines.push(`generated artifact ${artifactPath}`);
+    }
+  }
+  return lines;
+}
+function buildNextSteps(options) {
+  const cliSpecifier = getWpTypiaCliSpecifier();
+  const syncTypesRun = formatRunScript(options.packageManager, "sync-types");
+  const syncRun = formatRunScript(options.packageManager, "sync");
+  const doctorRun = formatPackageExecCommand(options.packageManager, cliSpecifier, "doctor");
+  const migrationInitRun = formatPackageExecCommand(options.packageManager, cliSpecifier, "migrate init --current-migration-version v1");
+  const dependencyInstallCommand = formatAddDevDependenciesCommand(options.packageManager, buildRequiredDevDependencyMapEntries());
+  if (options.layoutKind === "unsupported") {
+    return [
+      "Align the project to one of the supported retrofit layouts listed below, then rerun `wp-typia init`.",
+      dependencyInstallCommand,
+      syncTypesRun,
+      doctorRun
+    ];
+  }
+  if (options.commandMode === "apply") {
+    return [
+      ...options.dependencyChangeCount > 0 ? [
+        "Install or reinstall project dependencies so the retrofit sync scripts and metadata generators are available locally.",
+        dependencyInstallCommand
+      ] : [],
+      syncRun,
+      doctorRun,
+      `Optional migration bootstrap: ${migrationInitRun}`
+    ];
+  }
+  const steps = [
+    ...options.hasPlannedChanges ? [
+      "Re-run `wp-typia init --apply` to write the planned package.json changes and helper files automatically.",
+      ...options.dependencyChangeCount > 0 ? [dependencyInstallCommand] : []
+    ] : [],
+    syncRun,
+    doctorRun,
+    `Optional migration bootstrap: ${migrationInitRun}`
+  ];
+  return steps;
+}
+function buildRequiredDevDependencyMapEntries() {
+  return Object.entries(buildRequiredDevDependencyMap()).map(([name, version]) => `${name}@${version.replace(/^workspace:/u, "")}`);
+}
+function buildRetrofitPlanSummary(options) {
+  if (options.status === "already-initialized") {
+    return options.commandMode === "apply" ? "This project already exposes the minimum wp-typia retrofit surface. No files were changed." : "This project already exposes the minimum wp-typia retrofit surface.";
+  }
+  if (options.commandMode === "apply") {
+    return "Applied the minimum wp-typia retrofit surface so package.json and helper scripts are ready for the next install and sync run.";
+  }
+  return "This command previews the minimum wp-typia adoption layer for the current project without rewriting it into a full scaffold.";
+}
+function createRetrofitPlan(options) {
+  const includeGeneratedArtifacts = options.commandMode === "preview-only";
+  const plannedChanges = buildChangeSummary({
+    generatedArtifacts: options.generatedArtifacts,
+    packageChanges: options.packageChanges,
+    plannedFiles: options.plannedFiles
+  }, {
+    includeGeneratedArtifacts
+  });
+  return {
+    blockTargets: options.blockTargets,
+    commandMode: options.commandMode,
+    detectedLayout: options.detectedLayout,
+    generatedArtifacts: options.generatedArtifacts,
+    nextSteps: options.nextSteps ?? buildNextSteps({
+      commandMode: options.commandMode,
+      dependencyChangeCount: options.packageChanges.addDevDependencies.length,
+      hasPlannedChanges: plannedChanges.length > 0,
+      layoutKind: options.detectedLayout.kind,
+      packageManager: options.packageManager
+    }),
+    notes: options.notes,
+    packageChanges: options.packageChanges,
+    plannedFiles: options.plannedFiles,
+    packageManager: options.packageManager,
+    projectDir: options.projectDir,
+    projectName: options.projectName,
+    status: options.status,
+    summary: buildRetrofitPlanSummary({
+      commandMode: options.commandMode,
+      status: options.status
+    })
+  };
+}
+function setDependencyVersion(packageJson, name, requiredValue) {
+  if (packageJson.devDependencies?.[name] !== undefined) {
+    packageJson.devDependencies[name] = requiredValue;
+    return;
+  }
+  if (packageJson.dependencies?.[name] !== undefined) {
+    packageJson.dependencies[name] = requiredValue;
+    return;
+  }
+  packageJson.devDependencies ??= {};
+  packageJson.devDependencies[name] = requiredValue;
+}
+function buildNextProjectPackageJson(options) {
+  const nextPackageJson = options.packageJson ? JSON.parse(JSON.stringify(options.packageJson)) : {
+    name: options.projectName,
+    private: true
+  };
+  nextPackageJson.devDependencies ??= {};
+  nextPackageJson.scripts ??= {};
+  for (const dependencyChange of options.packageChanges.addDevDependencies) {
+    setDependencyVersion(nextPackageJson, dependencyChange.name, dependencyChange.requiredValue);
+  }
+  if (options.packageChanges.packageManagerField) {
+    nextPackageJson.packageManager = options.packageChanges.packageManagerField.requiredValue;
+  } else if (!nextPackageJson.packageManager && options.packageManager !== "npm") {
+    nextPackageJson.packageManager = getPackageManager(options.packageManager).packageManagerField;
+  }
+  for (const scriptChange of options.packageChanges.scripts) {
+    nextPackageJson.scripts[scriptChange.name] = scriptChange.requiredValue;
+  }
+  return nextPackageJson;
+}
+function buildProjectPackageJsonSource(packageJson) {
+  return `${JSON.stringify(packageJson, null, 2)}
+`;
+}
+function buildRetrofitHelperFiles(blockTargets) {
+  return {
+    [path.join("scripts", "block-config.ts")]: buildRetrofitBlockConfigSource(blockTargets),
+    [path.join("scripts", "sync-project.ts")]: buildRetrofitSyncProjectScriptSource(),
+    [path.join("scripts", "sync-types-to-block-json.ts")]: buildRetrofitSyncTypesScriptSource()
+  };
+}
+async function createRetrofitMutationSnapshot(projectDir, filePaths) {
+  const scriptsDir = path.join(projectDir, "scripts");
+  const scriptsDirExisted = fs.existsSync(scriptsDir);
+  const fileSources = await snapshotWorkspaceFiles(filePaths);
+  const targetPaths = fileSources.filter((entry) => entry.source === null).map((entry) => entry.filePath);
+  if (!scriptsDirExisted) {
+    targetPaths.push(scriptsDir);
+  }
+  return {
+    fileSources,
+    snapshotDirs: [],
+    targetPaths
+  };
+}
+async function writeRetrofitFiles(options) {
+  const helperFiles = buildRetrofitHelperFiles(options.blockTargets);
+  const scriptsDir = path.join(options.projectDir, "scripts");
+  await fsp.mkdir(scriptsDir, { recursive: true });
+  await fsp.writeFile(path.join(options.projectDir, "package.json"), buildProjectPackageJsonSource(options.packageJson), "utf8");
+  for (const [relativePath, source] of Object.entries(helperFiles)) {
+    await fsp.writeFile(path.join(options.projectDir, relativePath), source, "utf8");
+  }
+}
+function buildApplyFailureError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.INVALID_ARGUMENT, `Unable to apply the retrofit init plan safely. The command restored the previous package.json/helper-file snapshot. ${message}`, error instanceof Error ? { cause: error } : undefined);
+}
+function getInitPlan(projectDir, options = {}) {
+  const resolvedProjectDir = path.resolve(projectDir);
+  const packageJson = readProjectPackageJson(resolvedProjectDir);
+  const packageManager = resolveInitPackageManager(resolvedProjectDir, packageJson, options.packageManager);
+  const workspace = tryResolveWorkspaceProject(resolvedProjectDir);
+  if (workspace) {
+    const workspacePackageJson = readProjectPackageJson(workspace.projectDir);
+    const workspacePackageManager = resolveInitPackageManager(workspace.projectDir, workspacePackageJson, options.packageManager);
+    const cliSpecifier = getWpTypiaCliSpecifier();
+    return createRetrofitPlan({
+      blockTargets: [],
+      commandMode: "preview-only",
+      detectedLayout: {
+        blockNames: [],
+        description: "Already an official wp-typia workspace.",
+        kind: "official-workspace"
+      },
+      generatedArtifacts: [],
+      nextSteps: [
+        "Use `wp-typia add <kind> <name>` to extend the official workspace instead of rerunning init.",
+        formatRunScript(workspacePackageManager, "sync"),
+        formatPackageExecCommand(workspacePackageManager, cliSpecifier, "doctor")
+      ],
+      notes: [
+        "The official workspace template already owns inventory, doctor, and add-command workflows."
+      ],
+      packageChanges: {
+        addDevDependencies: [],
+        scripts: []
+      },
+      packageManager: workspacePackageManager,
+      plannedFiles: [],
+      projectDir: workspace.projectDir,
+      projectName: workspace.packageName,
+      status: "already-initialized"
+    });
+  }
+  const projectName = typeof packageJson?.name === "string" && packageJson.name.length > 0 ? packageJson.name : path.basename(resolvedProjectDir);
+  const layout = buildLayoutDetails(resolvedProjectDir);
+  const dependencyChanges = buildDependencyChanges(packageJson);
+  const scriptChanges = buildScriptChanges(packageJson, packageManager);
+  const packageManagerFieldChange = buildPackageManagerFieldChange(packageJson, packageManager, {
+    persistExplicitOverride: typeof options.packageManager === "string"
+  });
+  const rawPlannedFiles = layout.kind === "generated-project" || layout.kind === "official-workspace" ? [] : buildPlannedFiles(resolvedProjectDir, layout.kind);
+  const hasExistingSurface = hasExistingWpTypiaProjectSurface(resolvedProjectDir, packageJson);
+  const status = hasExistingSurface && dependencyChanges.length === 0 && scriptChanges.length === 0 && packageManagerFieldChange === undefined ? "already-initialized" : "preview";
+  const plannedFiles = status === "already-initialized" ? [] : rawPlannedFiles;
+  const detectedLayout = status === "already-initialized" && hasExistingSurface ? {
+    blockNames: layout.blockNames,
+    description: layout.kind === "unsupported" ? "Already exposes the minimum wp-typia sync surface." : `Already exposes the minimum wp-typia sync surface for ${layout.kind === "multi-block" ? "a multi-block project" : "a single-block project"}.`,
+    kind: "generated-project"
+  } : {
+    blockNames: layout.blockNames,
+    description: layout.description,
+    kind: layout.kind
+  };
+  return createRetrofitPlan({
+    blockTargets: layout.blockTargets,
+    commandMode: "preview-only",
+    detectedLayout,
+    generatedArtifacts: status === "already-initialized" && detectedLayout.kind === "generated-project" ? [] : layout.generatedArtifacts,
+    notes: Array.from(new Set([
+      "Preview only: `wp-typia init` does not write files yet.",
+      RETROFIT_APPLY_PREVIEW_NOTE,
+      ...layout.notes
+    ])),
+    packageChanges: {
+      addDevDependencies: dependencyChanges,
+      ...packageManagerFieldChange ? { packageManagerField: packageManagerFieldChange } : {},
+      scripts: scriptChanges
+    },
+    packageManager,
+    plannedFiles,
+    projectDir: resolvedProjectDir,
+    projectName,
+    status
+  });
+}
+async function applyInitPlan(projectDir, options = {}) {
+  const previewPlan = getInitPlan(projectDir, options);
+  if (previewPlan.detectedLayout.kind === "unsupported") {
+    throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.INVALID_ARGUMENT, "`wp-typia init --apply` requires a supported retrofit layout. Run `wp-typia init` first to inspect the preview plan and any blocking notes.");
+  }
+  if (previewPlan.status === "already-initialized") {
+    return createRetrofitPlan({
+      ...previewPlan,
+      commandMode: "apply",
+      notes: Array.from(new Set([
+        ...previewPlan.notes.filter((note) => note !== "Preview only: `wp-typia init` does not write files yet." && note !== RETROFIT_APPLY_PREVIEW_NOTE),
+        RETROFIT_ROLLBACK_NOTE
+      ])),
+      status: "already-initialized"
+    });
+  }
+  const nextPackageJson = buildNextProjectPackageJson({
+    packageChanges: previewPlan.packageChanges,
+    packageJson: readProjectPackageJson(previewPlan.projectDir),
+    packageManager: previewPlan.packageManager,
+    projectName: previewPlan.projectName
+  });
+  const helperFiles = buildRetrofitHelperFiles(previewPlan.blockTargets);
+  const filePaths = [
+    path.join(previewPlan.projectDir, "package.json"),
+    ...Object.keys(helperFiles).map((relativePath) => path.join(previewPlan.projectDir, relativePath))
+  ];
+  const mutationSnapshot = await createRetrofitMutationSnapshot(previewPlan.projectDir, filePaths);
+  try {
+    await writeRetrofitFiles({
+      blockTargets: previewPlan.blockTargets,
+      packageJson: nextPackageJson,
+      projectDir: previewPlan.projectDir
+    });
+  } catch (error) {
+    await rollbackWorkspaceMutation(mutationSnapshot);
+    throw buildApplyFailureError(error);
+  }
+  return createRetrofitPlan({
+    ...previewPlan,
+    commandMode: "apply",
+    notes: Array.from(new Set([
+      ...previewPlan.notes.filter((note) => note !== "Preview only: `wp-typia init` does not write files yet." && note !== RETROFIT_APPLY_PREVIEW_NOTE),
+      RETROFIT_ROLLBACK_NOTE
+    ])),
+    status: "applied"
+  });
+}
+async function runInitCommand(options) {
+  return options.apply ? applyInitPlan(options.projectDir, {
+    packageManager: options.packageManager
+  }) : getInitPlan(options.projectDir, {
+    packageManager: options.packageManager
+  });
+}
+export {
+  runInitCommand,
+  getInitPlan,
+  applyInitPlan
+};
+
+//# debugId=5F125D72345735E864756E2164756E21