wp-typia 0.15.5 → 0.16.1

package/.bunli/commands.gen.ts

@@ -9,10 +9,11 @@ import Create from '../src/commands/create.js'
 import Doctor from '../src/commands/doctor.js'
 import Mcp from '../src/commands/mcp.js'
 import Migrate from '../src/commands/migrate.js'
+import Sync from '../src/commands/sync.js'
 import Templates from '../src/commands/templates.js'
 
 // Narrow list of command names to avoid typeof-cycles in types
-const names = ['add', 'create', 'doctor', 'mcp', 'migrate', 'templates'] as const
+const names = ['add', 'create', 'doctor', 'mcp', 'migrate', 'sync', 'templates'] as const
 type GeneratedNames = typeof names[number]
 
 const modules: Record<GeneratedNames, Command<any>> = {
@@ -21,6 +22,7 @@ const modules: Record<GeneratedNames, Command<any>> = {
   'doctor': Doctor,
   'mcp': Mcp,
   'migrate': Migrate,
+  'sync': Sync,
   'templates': Templates
 } as const
 
@@ -50,6 +52,11 @@ const metadata: Record<GeneratedNames, GeneratedCommandMeta> = {
       description: 'Run migration workflows for migration-capable wp-typia projects.',
       path: './src/commands/migrate'
     },
+  'sync': {
+      name: 'sync',
+      description: 'Run the common generated-project sync workflow.',
+      path: './src/commands/sync'
+    },
   'templates': {
       name: 'templates',
       description: 'Inspect built-in and external scaffold templates.',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wp-typia",
-  "version": "0.15.5",
+  "version": "0.16.1",
   "description": "Canonical CLI package for wp-typia scaffolding and project workflows",
   "packageManager": "bun@1.3.11",
   "type": "module",
@@ -65,7 +65,7 @@
     "@bunli/tui": "0.6.0",
     "@bunli/utils": "0.6.0",
     "@wp-typia/api-client": "^0.4.2",
-    "@wp-typia/project-tools": "0.15.4",
+    "@wp-typia/project-tools": "0.16.0",
     "better-result": "^2.7.0",
     "react": "19.2.0",
     "react-dom": "19.2.0",

package/src/command-contract.ts

@@ -6,6 +6,7 @@ export const WP_TYPIA_BUNLI_MIGRATION_DOC = "docs/bunli-cli-migration.md";
 
 export const WP_TYPIA_RESERVED_TOP_LEVEL_COMMAND_NAMES = [
 	"create",
+	"sync",
 	"add",
 	"migrate",
 	"templates",
@@ -18,6 +19,7 @@ export const WP_TYPIA_RESERVED_TOP_LEVEL_COMMAND_NAMES = [
 
 export const WP_TYPIA_TOP_LEVEL_COMMAND_NAMES = [
 	"create",
+	"sync",
 	"add",
 	"migrate",
 	"templates",
@@ -108,6 +110,10 @@ export const WP_TYPIA_FUTURE_COMMAND_TREE = [
 		description: "Scaffold a new wp-typia project.",
 		name: "create",
 	},
+	{
+		description: "Run the common generated-project sync workflow.",
+		name: "sync",
+	},
 	{
 		description: "Extend an official wp-typia workspace.",
 		name: "add",

package/src/command-list.ts

@@ -5,10 +5,12 @@ import { createCommand } from "./commands/create";
 import { doctorCommand } from "./commands/doctor";
 import { mcpCommand } from "./commands/mcp";
 import { migrateCommand } from "./commands/migrate";
+import { syncCommand } from "./commands/sync";
 import { templatesCommand } from "./commands/templates";
 
 export const wpTypiaCommands: Command<any, any>[] = [
 	createCommand,
+	syncCommand,
 	addCommand,
 	migrateCommand,
 	templatesCommand,

package/src/commands/sync.ts

@@ -0,0 +1,25 @@
+import { defineCommand } from "@bunli/core";
+import { z } from "zod";
+
+import { executeSyncCommand } from "../runtime-bridge";
+
+export const syncCommand = defineCommand({
+	description: "Run the common generated-project sync workflow.",
+	handler: async (args) => {
+		await executeSyncCommand({
+			check: Boolean(args.flags.check),
+			cwd: args.cwd,
+		});
+	},
+	name: "sync",
+	options: {
+		check: {
+			argumentKind: "flag" as const,
+			description:
+				"Check generated artifacts without writing changes. Advanced sync-types-only flags stay on sync-types.",
+			schema: z.boolean().default(false),
+		},
+	},
+});
+
+export default syncCommand;

package/src/runtime-bridge.ts

@@ -1,5 +1,10 @@
+import { spawnSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+
 import {
 	createReadlinePrompt,
+	formatRunScript,
 	formatAddHelpText,
 	formatMigrationHelpText,
 	formatTemplateDetails,
@@ -44,6 +49,11 @@ type TemplatesExecutionInput = {
 	};
 };
 
+type SyncExecutionInput = {
+	check?: boolean;
+	cwd: string;
+};
+
 type MigrateExecutionInput = {
 	command?: string;
 	cwd: string;
@@ -53,6 +63,14 @@ type MigrateExecutionInput = {
 };
 
 type PrintLine = (line: string) => void;
+type PackageManagerId = "bun" | "npm" | "pnpm" | "yarn";
+
+type SyncProjectContext = {
+	cwd: string;
+	packageJsonPath: string;
+	packageManager: PackageManagerId;
+	scripts: Partial<Record<"sync" | "sync-rest" | "sync-types", string>>;
+};
 
 function printBlock(lines: string[], printLine: PrintLine): void {
 	for (const line of lines) {
@@ -100,6 +118,131 @@ function pushFlag(argv: string[], name: string, value: unknown): void {
 	argv.push(`--${name}`, String(value));
 }
 
+function getSyncRootError(cwd: string): Error {
+	return new Error(
+		`No generated wp-typia project root was found at ${cwd}. Run \`wp-typia sync\` from a scaffolded project or official workspace root.`,
+	);
+}
+
+function inferSyncPackageManager(cwd: string, packageManagerField?: string): PackageManagerId {
+	const field = String(packageManagerField ?? "");
+	if (field.startsWith("bun@")) return "bun";
+	if (field.startsWith("npm@")) return "npm";
+	if (field.startsWith("pnpm@")) return "pnpm";
+	if (field.startsWith("yarn@")) return "yarn";
+
+	if (
+		fs.existsSync(path.join(cwd, "bun.lock")) ||
+		fs.existsSync(path.join(cwd, "bun.lockb"))
+	) {
+		return "bun";
+	}
+	if (fs.existsSync(path.join(cwd, "pnpm-lock.yaml"))) {
+		return "pnpm";
+	}
+	if (
+		fs.existsSync(path.join(cwd, "yarn.lock")) ||
+		fs.existsSync(path.join(cwd, ".pnp.cjs")) ||
+		fs.existsSync(path.join(cwd, ".pnp.loader.mjs")) ||
+		fs.existsSync(path.join(cwd, ".yarnrc.yml"))
+	) {
+		return "yarn";
+	}
+	if (
+		fs.existsSync(path.join(cwd, "package-lock.json")) ||
+		fs.existsSync(path.join(cwd, "npm-shrinkwrap.json"))
+	) {
+		return "npm";
+	}
+
+	return "npm";
+}
+
+function resolveSyncProjectContext(cwd: string): SyncProjectContext {
+	const packageJsonPath = path.join(cwd, "package.json");
+	if (!fs.existsSync(packageJsonPath)) {
+		throw getSyncRootError(cwd);
+	}
+
+	const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8")) as {
+		packageManager?: string;
+		scripts?: Record<string, unknown>;
+	};
+	const scripts = packageJson.scripts ?? {};
+	const syncScripts = {
+		sync: typeof scripts.sync === "string" ? scripts.sync : undefined,
+		"sync-rest":
+			typeof scripts["sync-rest"] === "string" ? scripts["sync-rest"] : undefined,
+		"sync-types":
+			typeof scripts["sync-types"] === "string" ? scripts["sync-types"] : undefined,
+	} satisfies SyncProjectContext["scripts"];
+
+	if (!syncScripts.sync && !syncScripts["sync-types"]) {
+		throw new Error(
+			`Expected ${packageJsonPath} to define either a \`sync\` or \`sync-types\` script.`,
+		);
+	}
+
+	return {
+		cwd,
+		packageJsonPath,
+		packageManager: inferSyncPackageManager(cwd, packageJson.packageManager),
+		scripts: syncScripts,
+	};
+}
+
+function getPackageManagerRunInvocation(
+	packageManager: PackageManagerId,
+	scriptName: string,
+	extraArgs: string[],
+): { args: string[]; command: string } {
+	switch (packageManager) {
+		case "bun":
+			return { args: ["run", scriptName, ...extraArgs], command: "bun" };
+		case "npm":
+			return {
+				args: ["run", scriptName, ...(extraArgs.length > 0 ? ["--", ...extraArgs] : [])],
+				command: "npm",
+			};
+		case "pnpm":
+			return { args: ["run", scriptName, ...extraArgs], command: "pnpm" };
+		case "yarn":
+			return { args: ["run", scriptName, ...extraArgs], command: "yarn" };
+	}
+}
+
+function runProjectScript(
+	project: SyncProjectContext,
+	scriptName: "sync" | "sync-rest" | "sync-types",
+	extraArgs: string[],
+): void {
+	const script = project.scripts[scriptName];
+	if (!script) {
+		return;
+	}
+
+	const invocation = getPackageManagerRunInvocation(
+		project.packageManager,
+		scriptName,
+		extraArgs,
+	);
+
+	const result = spawnSync(invocation.command, invocation.args, {
+		cwd: project.cwd,
+		shell: process.platform === "win32",
+		stdio: "inherit",
+	});
+
+	if (result.error || result.status !== 0) {
+		throw new Error(
+			`\`${formatRunScript(project.packageManager, scriptName, extraArgs.join(" "))}\` failed.`,
+			{
+				cause: result.error,
+			},
+		);
+	}
+}
+
 const PACKAGE_MANAGER_PROMPT_OPTIONS = [
 	{ label: "npm", value: "npm", hint: "Use npm" },
 	{ label: "pnpm", value: "pnpm", hint: "Use pnpm" },
@@ -384,6 +527,25 @@ export async function executeDoctorCommand(cwd: string): Promise<void> {
 	await runDoctor(cwd);
 }
 
+export async function executeSyncCommand({
+	check = false,
+	cwd,
+}: SyncExecutionInput): Promise<void> {
+	const project = resolveSyncProjectContext(cwd);
+	const extraArgs = check ? ["--check"] : [];
+
+	if (project.scripts.sync) {
+		runProjectScript(project, "sync", extraArgs);
+		return;
+	}
+
+	runProjectScript(project, "sync-types", extraArgs);
+
+	if (project.scripts["sync-rest"]) {
+		runProjectScript(project, "sync-rest", extraArgs);
+	}
+}
+
 export async function executeMigrateCommand({
 	command,
 	cwd,

package/src/ui/README.md

@@ -15,3 +15,10 @@ Constraints:
   shell automation.
 - `@wp-typia/project-tools` remains the runtime library; these screens should only
   collect input and hand the resolved command state back to `wp-typia`.
+
+Alternate-buffer lifecycle contract:
+
+- `LazyFlow` owns pre-mount lifecycle safety for lazy loader failures and loading-time quit.
+- Mounted flows must use the shared alternate-buffer lifecycle helper instead of ad hoc exit logic.
+- `create`, `add`, and `migrate` must always call `runtime.exit()` on submit success, cancel, and quit.
+- Runtime execution failures use exit-on-failure: report the error, then exit immediately.

package/src/ui/add-flow.tsx

@@ -1,11 +1,9 @@
-import { useState } from "react";
-
-import { useRuntime } from "@bunli/runtime/app";
-import { Alert, SchemaForm } from "@bunli/tui";
+import { SchemaForm } from "@bunli/tui";
 import { HOOKED_BLOCK_POSITION_IDS } from "@wp-typia/project-tools";
 import { z } from "zod";
 
 import { executeAddCommand } from "../runtime-bridge";
+import { useAlternateBufferLifecycle } from "./alternate-buffer-lifecycle";
 
 const addFlowSchema = z.object({
 	anchor: z.string().optional(),
@@ -41,16 +39,11 @@ const HOOKED_BLOCK_POSITION_DESCRIPTIONS: Record<
 };
 
 export function AddFlow({ cwd, initialValues, workspaceBlockOptions }: AddFlowProps) {
-	const runtime = useRuntime();
-	const [errorMessage, setErrorMessage] = useState<string | null>(null);
+	const { handleCancel, handleSubmit } = useAlternateBufferLifecycle("wp-typia add failed");
 
 	return (
-		<>
-			{errorMessage ? (
-				<Alert message={errorMessage} title="Add failed" tone="danger" />
-			) : null}
-			<SchemaForm
-				fields={[
+		<SchemaForm
+			fields={[
 					{
 						kind: "select",
 						label: "Kind",
@@ -195,25 +188,20 @@ export function AddFlow({ cwd, initialValues, workspaceBlockOptions }: AddFlowPr
 							(values.template === "persistence" || values.template === "compound"),
 					},
 				]}
-				initialValues={initialValues}
-				onCancel={() => runtime.exit()}
-				onSubmit={async (values) => {
-					try {
-						setErrorMessage(null);
+			initialValues={initialValues}
+			onCancel={handleCancel}
+			onSubmit={async (values) =>
+				handleSubmit(async () => {
 						await executeAddCommand({
 							cwd,
 							flags: values,
 							kind: values.kind,
 							name: values.name,
 						});
-						runtime.exit();
-					} catch (error) {
-						setErrorMessage(error instanceof Error ? error.message : String(error));
-					}
-				}}
-				schema={addFlowSchema}
-				title="Extend a wp-typia workspace"
-			/>
-		</>
+				})
+			}
+			schema={addFlowSchema}
+			title="Extend a wp-typia workspace"
+		/>
 	);
 }

package/src/ui/alternate-buffer-lifecycle.ts

@@ -0,0 +1,152 @@
+import { useCallback } from "react";
+
+import { useRuntime } from "@bunli/runtime/app";
+import { useKeyboard } from "@bunli/tui";
+
+type AlternateBufferKeyEvent = {
+	ctrl?: boolean;
+	name?: string;
+};
+
+type AlternateBufferFailureOptions = {
+	context: string;
+	error: unknown;
+	exit: () => void;
+	log?: (message: string) => void;
+};
+
+type RunAlternateBufferActionOptions = {
+	action: () => Promise<void>;
+	context: string;
+	exit: () => void;
+	log?: (message: string) => void;
+};
+
+export function describeAlternateBufferFailure(context: string, error: unknown): string {
+	const message = error instanceof Error ? error.message : String(error);
+	return `${context}: ${message}`;
+}
+
+export function isAlternateBufferExitKey(key: AlternateBufferKeyEvent): boolean {
+	return key.name === "q" || (key.ctrl === true && key.name === "c");
+}
+
+export function reportAlternateBufferFailure({
+	context,
+	error,
+	exit,
+	log = console.error,
+}: AlternateBufferFailureOptions): void {
+	const message = describeAlternateBufferFailure(context, error);
+	exit();
+	log(message);
+}
+
+export async function runAlternateBufferAction({
+	action,
+	context,
+	exit,
+	log = console.error,
+}: RunAlternateBufferActionOptions): Promise<void> {
+	try {
+		await action();
+		exit();
+	} catch (error) {
+		reportAlternateBufferFailure({ context, error, exit, log });
+	}
+}
+
+export async function resolveLazyFlowComponent<TProps>({
+	loader,
+	onLoaded,
+	onFailure,
+	isDisposed,
+}: {
+	loader: () => Promise<{ default: React.ComponentType<TProps> }>;
+	onLoaded: (component: React.ComponentType<TProps>) => void;
+	onFailure: (error: unknown) => void;
+	isDisposed: () => boolean;
+}): Promise<void> {
+	try {
+		const module = await loader();
+		if (!isDisposed()) {
+			onLoaded(module.default);
+		}
+	} catch (error) {
+		if (!isDisposed()) {
+			onFailure(error);
+		}
+	}
+}
+
+export function useAlternateBufferExitKeys(options: {
+	enabled?: boolean;
+	exit?: () => void;
+} = {}): void {
+	const runtime = useRuntime();
+	const exit = options.exit ?? (() => runtime.exit());
+	const enabled = options.enabled ?? true;
+
+	useKeyboard((key: AlternateBufferKeyEvent) => {
+		if (!enabled) {
+			return;
+		}
+
+		if (isAlternateBufferExitKey(key)) {
+			exit();
+		}
+	});
+}
+
+export function useAlternateBufferLifecycle(
+	context: string,
+	options: {
+		enableExitKeys?: boolean;
+	} = {},
+): {
+	handleCancel: () => void;
+	handleFailure: (error: unknown) => void;
+	handleSubmit: (action: () => Promise<void>) => Promise<void>;
+} {
+	const runtime = useRuntime();
+	const exit = useCallback(() => {
+		runtime.exit();
+	}, [runtime]);
+
+	useAlternateBufferExitKeys({
+		enabled: options.enableExitKeys ?? true,
+		exit,
+	});
+
+	const handleCancel = useCallback(() => {
+		exit();
+	}, [exit]);
+
+	const handleFailure = useCallback(
+		(error: unknown) => {
+			reportAlternateBufferFailure({
+				context,
+				error,
+				exit,
+			});
+		},
+		[context, exit],
+	);
+
+	const handleSubmit = useCallback(
+		async (action: () => Promise<void>) => {
+			await runAlternateBufferAction({
+				action,
+				context,
+				exit,
+			});
+		},
+		[context, exit],
+	);
+
+	return {
+		handleCancel,
+		handleFailure,
+		handleSubmit,
+	};
+}

package/src/ui/create-flow.tsx

@@ -1,10 +1,8 @@
-import { useState } from "react";
-
-import { useRuntime } from "@bunli/runtime/app";
-import { Alert, SchemaForm } from "@bunli/tui";
+import { SchemaForm } from "@bunli/tui";
 import { z } from "zod";
 
 import { executeCreateCommand } from "../runtime-bridge";
+import { useAlternateBufferLifecycle } from "./alternate-buffer-lifecycle";
 
 const createFlowSchema = z.object({
 	"data-storage": z.string().optional(),
@@ -31,8 +29,7 @@ type CreateFlowProps = {
 };
 
 export function CreateFlow({ cwd, initialValues }: CreateFlowProps) {
-	const runtime = useRuntime();
-	const [errorMessage, setErrorMessage] = useState<string | null>(null);
+	const { handleCancel, handleSubmit } = useAlternateBufferLifecycle("wp-typia create failed");
 	const defaultPrompt = {
 		close() {},
 		select<T extends string>(_message: string, options: Array<{ value: T }>, defaultValue = 1) {
@@ -45,16 +42,8 @@ export function CreateFlow({ cwd, initialValues }: CreateFlowProps) {
 	};
 
 	return (
-		<>
-			{errorMessage ? (
-				<Alert
-					message={errorMessage}
-					title="Create failed"
-					tone="danger"
-				/>
-			) : null}
-			<SchemaForm
-				fields={[
+		<SchemaForm
+			fields={[
 					{ kind: "text", label: "Project directory", name: "project-dir", required: true },
 					{
 						kind: "select",
@@ -146,11 +135,10 @@ export function CreateFlow({ cwd, initialValues }: CreateFlowProps) {
 						name: "with-migration-ui",
 					},
 				]}
-				initialValues={initialValues}
-				onCancel={() => runtime.exit()}
-				onSubmit={async (values) => {
-					try {
-						setErrorMessage(null);
+			initialValues={initialValues}
+			onCancel={handleCancel}
+			onSubmit={async (values) =>
+				handleSubmit(async () => {
 						await executeCreateCommand({
 							cwd,
 							flags: values,
@@ -158,14 +146,10 @@ export function CreateFlow({ cwd, initialValues }: CreateFlowProps) {
 							projectDir: values["project-dir"],
 							prompt: defaultPrompt,
 						});
-						runtime.exit();
-					} catch (error) {
-						setErrorMessage(error instanceof Error ? error.message : String(error));
-					}
-				}}
-				schema={createFlowSchema}
-				title="Create a wp-typia project"
-			/>
-		</>
+				})
+			}
+			schema={createFlowSchema}
+			title="Create a wp-typia project"
+		/>
 	);
 }

package/src/ui/lazy-flow.tsx

@@ -1,5 +1,11 @@
 import { createElement, useEffect, useState, type ComponentType } from "react";
 
+import {
+	resolveLazyFlowComponent,
+	useAlternateBufferExitKeys,
+	useAlternateBufferLifecycle,
+} from "./alternate-buffer-lifecycle";
+
 type LazyFlowProps<TProps> = {
 	loader: () => Promise<{ default: ComponentType<TProps> }>;
 	props: TProps;
@@ -7,31 +13,30 @@ type LazyFlowProps<TProps> = {
 
 export function LazyFlow<TProps>({ loader, props }: LazyFlowProps<TProps>) {
 	const [Component, setComponent] = useState<ComponentType<TProps> | null>(null);
-	const [errorMessage, setErrorMessage] = useState<string | null>(null);
+	const { handleFailure } = useAlternateBufferLifecycle("wp-typia TUI flow failed", {
+		enableExitKeys: false,
+	});
+
+	useAlternateBufferExitKeys({
+		enabled: Component === null,
+	});
 
 	useEffect(() => {
 		let disposed = false;
 
-		void loader()
-			.then((module) => {
-				if (!disposed) {
-					setComponent(() => module.default);
-				}
-			})
-			.catch((error) => {
-				if (!disposed) {
-					setErrorMessage(error instanceof Error ? error.message : String(error));
-				}
-			});
+		void resolveLazyFlowComponent({
+			isDisposed: () => disposed,
+			loader,
+			onFailure: handleFailure,
+			onLoaded: (component) => {
+				setComponent(() => component);
+			},
+		});
 
 		return () => {
 			disposed = true;
 		};
-	}, [loader]);
-
-	if (errorMessage) {
-		return errorMessage;
-	}
+	}, [handleFailure, loader]);
 
 	if (!Component) {
 		return null;

package/src/ui/migrate-flow.tsx

@@ -1,10 +1,8 @@
-import { useState } from "react";
-
-import { useRuntime } from "@bunli/runtime/app";
-import { Alert, SchemaForm } from "@bunli/tui";
+import { SchemaForm } from "@bunli/tui";
 import { z } from "zod";
 
 import { executeMigrateCommand } from "../runtime-bridge";
+import { useAlternateBufferLifecycle } from "./alternate-buffer-lifecycle";
 
 const migrateFlowSchema = z.object({
 	all: z.boolean().default(false),
@@ -48,16 +46,11 @@ function sanitizeMigrateValues(values: MigrateFlowValues): Record<string, unknow
 }
 
 export function MigrateFlow({ cwd, initialValues }: MigrateFlowProps) {
-	const runtime = useRuntime();
-	const [errorMessage, setErrorMessage] = useState<string | null>(null);
+	const { handleCancel, handleSubmit } = useAlternateBufferLifecycle("wp-typia migrate failed");
 
 	return (
-		<>
-			{errorMessage ? (
-				<Alert message={errorMessage} title="Migrate failed" tone="danger" />
-			) : null}
-			<SchemaForm
-				fields={[
+		<SchemaForm
+			fields={[
 					{
 						kind: "select",
 						label: "Migration command",
@@ -164,24 +157,19 @@ export function MigrateFlow({ cwd, initialValues }: MigrateFlowProps) {
 						visibleWhen: (values) => values.command === "fuzz",
 					},
 				]}
-				initialValues={initialValues}
-				onCancel={() => runtime.exit()}
-				onSubmit={async (values) => {
-					try {
-						setErrorMessage(null);
+			initialValues={initialValues}
+			onCancel={handleCancel}
+			onSubmit={async (values) =>
+				handleSubmit(async () => {
 						await executeMigrateCommand({
 							command: values.command,
 							cwd,
 							flags: sanitizeMigrateValues(values),
 						});
-						runtime.exit();
-					} catch (error) {
-						setErrorMessage(error instanceof Error ? error.message : String(error));
-					}
-				}}
-				schema={migrateFlowSchema}
-				title="Run wp-typia migration workflows"
-			/>
-		</>
+				})
+			}
+			schema={migrateFlowSchema}
+			title="Run wp-typia migration workflows"
+		/>
 	);
 }