sonamu 0.10.13 → 0.11.1

package/dist/tooling/cli-tooling.js

@@ -0,0 +1,901 @@
+import { z } from "zod";
+//#region src/tooling/cli-tooling.ts
+const jsonValueSchema = z.json();
+const MIGRATION_TARGETS = /* @__PURE__ */ new Set([
+	"development",
+	"staging",
+	"production",
+	"fixture",
+	"test"
+]);
+function assertMigrationTarget(target) {
+	if (MIGRATION_TARGETS.has(target)) return;
+	throw Object.assign(/* @__PURE__ */ new Error(`Unsupported migration target: ${target}`), {
+		code: "INVALID_MIGRATION_TARGET",
+		exitCode: 2
+	});
+}
+function assertShadowMigrationTarget(target) {
+	if (target === "fixture" || target === "test") return;
+	throw Object.assign(/* @__PURE__ */ new Error(`Invalid shadow migration target: ${target}`), {
+		code: "INVALID_SHADOW_MIGRATION_TARGET",
+		target,
+		exitCode: 2
+	});
+}
+async function migrationPlan(target, migrations, action = "apply") {
+	const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(JSON.stringify({
+		action,
+		target,
+		migrations
+	})));
+	return {
+		kind: "migration-plan",
+		action,
+		target,
+		migrations,
+		fingerprint: Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("")
+	};
+}
+const REQUIRED_METHODS = {
+	core: ["sync"],
+	entity: [
+		"list",
+		"show",
+		"search",
+		"applyPatch",
+		"create",
+		"cones"
+	],
+	scaffold: [
+		"model",
+		"model_test",
+		"view_list",
+		"view_form",
+		"status",
+		"preview",
+		"batch"
+	],
+	migration: [
+		"run",
+		"generate",
+		"status",
+		"connections",
+		"code",
+		"preview",
+		"shadow",
+		"rollback"
+	],
+	fixture: [
+		"init",
+		"import",
+		"sync",
+		"gen",
+		"fetch",
+		"explore"
+	],
+	build: [
+		"all",
+		"api",
+		"web"
+	],
+	test: ["run", "status"],
+	auth: ["generate", "addCompanions"],
+	i18n: [
+		"list",
+		"check",
+		"import",
+		"export",
+		"create",
+		"update",
+		"remove"
+	],
+	task: [
+		"definitions",
+		"runs",
+		"show",
+		"steps",
+		"watch",
+		"pause",
+		"resume",
+		"cancel"
+	],
+	cdd: [
+		"tree",
+		"read",
+		"rules",
+		"showRule",
+		"addRule",
+		"addAcceptanceCriterion"
+	],
+	stub: ["practice"]
+};
+let initialization;
+async function ensureSonamu() {
+	const { Sonamu } = await import("../api/sonamu.js");
+	if (Sonamu.isInitialized) return;
+	initialization ??= Sonamu.init(true, false);
+	await initialization;
+}
+async function syncOperation(input) {
+	await ensureSonamu();
+	const { Sonamu } = await import("../api/sonamu.js");
+	return input.force === true ? Sonamu.syncer.forceSync() : Sonamu.syncer.sync();
+}
+function text(input, key) {
+	const value = z.string().safeParse(input[key]);
+	return value.success ? value.data : void 0;
+}
+function strings(input, key) {
+	const value = z.array(z.string()).safeParse(input[key]);
+	return value.success ? value.data : [];
+}
+function requiredText(input, key) {
+	const value = text(input, key);
+	if (value !== void 0 && value.length > 0) return value;
+	throw Object.assign(/* @__PURE__ */ new Error(`Missing ${key}.`), {
+		code: "MISSING_ARGUMENT",
+		exitCode: 2
+	});
+}
+/**
+* 생략한 값은 `undefined`로 통과시키되, 값이 있는데 문자열이 아니면 인자 오류로 거절합니다.
+*
+* `text()`처럼 조용히 무시하면 잘못된 타입의 입력이 기본값으로 둔갑합니다.
+*/
+function optionalText(input, key) {
+	const value = input[key];
+	if (value === void 0 || value === null) return void 0;
+	const parsed = z.string().safeParse(value);
+	if (parsed.success) return parsed.data;
+	throw Object.assign(/* @__PURE__ */ new Error(`Invalid ${key}.`), {
+		code: "INVALID_ARGUMENT",
+		exitCode: 2
+	});
+}
+function parseJson(contents, code, schema) {
+	try {
+		return schema.parse(JSON.parse(contents));
+	} catch (cause) {
+		throw Object.assign(/* @__PURE__ */ new Error("Invalid JSON input."), {
+			code,
+			exitCode: 2,
+			cause
+		});
+	}
+}
+function mutationRequested(input) {
+	return input.execute === true || input.dryRun === false;
+}
+function explicitlyDryRun(input) {
+	return input.dryRun === true || input.execute === false;
+}
+const entityPatchSchema = z.object({
+	entityId: z.string().min(1),
+	operations: z.array(z.object({
+		op: z.literal("add"),
+		path: z.literal("/props/-"),
+		value: z.object({
+			name: z.string().min(1),
+			type: z.string().min(1)
+		}).catchall(jsonValueSchema)
+	}))
+});
+const i18nEntriesSchema = z.array(z.object({
+	key: z.string(),
+	values: z.record(z.string(), z.string())
+}));
+const dictionaryValuesSchema = z.record(z.string(), z.string());
+const dictionarySourceSchema = z.enum([
+	"entity",
+	"project",
+	"sonamu"
+]);
+const coneLocaleSchema = z.enum([
+	"ko",
+	"en",
+	"ja"
+]);
+/**
+* cone 생성에 사용할 locale을 결정합니다.
+*
+* 명시한 locale이 최우선이고, 없으면 프로젝트 i18n 기본 locale, 그마저 없으면 "ko"를 사용합니다.
+*/
+async function resolveConeLocale(input) {
+	const explicit = coneLocaleSchema.safeParse(input.locale);
+	if (explicit.success) return explicit.data;
+	const { Sonamu } = await import("../api/sonamu.js");
+	let configuredLocale;
+	try {
+		configuredLocale = Sonamu.config.i18n?.defaultLocale;
+	} catch {}
+	const configured = coneLocaleSchema.safeParse(configuredLocale);
+	return configured.success ? configured.data : "ko";
+}
+async function entityOperation(method, input) {
+	await ensureSonamu();
+	const { EntityManager } = await import("../entity/entity-manager.js");
+	const entities = EntityManager.getAllEntities();
+	if (method === "list") return entities.map((entity) => entity.toJson());
+	if (method === "show") {
+		const entityId = requiredText(input, "entityId");
+		if (!EntityManager.exists(entityId)) throw Object.assign(/* @__PURE__ */ new Error(`Entity not found: ${entityId}`), { code: "ENTITY_NOT_FOUND" });
+		return EntityManager.get(entityId).toJson();
+	}
+	if (method === "search") {
+		const query = requiredText(input, "query").toLocaleLowerCase();
+		return entities.map((entity) => entity.toJson()).filter((entity) => JSON.stringify(entity).toLocaleLowerCase().includes(query));
+	}
+	if (method === "create") {
+		const entityId = requiredText(input, "name");
+		const { Sonamu } = await import("../api/sonamu.js");
+		await Sonamu.syncer.createEntity({
+			entityId,
+			title: entityId
+		});
+		if (input.noCones === true) return {
+			entityId,
+			cones: "skipped"
+		};
+		const entity = EntityManager.get(entityId);
+		if (input.ai === true) return entity.generateCones({
+			preserveExisting: false,
+			onlyEmpty: false,
+			locale: await resolveConeLocale(input)
+		});
+		await entity.generateTemplateCones();
+		return {
+			entityId,
+			cones: "template"
+		};
+	}
+	if (method === "cones") {
+		const entityId = requiredText(input, "entityId");
+		const targets = input.all === true || entityId === "all" ? EntityManager.getAllEntities() : EntityManager.exists(entityId) ? [EntityManager.get(entityId)] : [];
+		if (targets.length === 0) throw Object.assign(/* @__PURE__ */ new Error(`Entity not found: ${entityId}`), { code: "ENTITY_NOT_FOUND" });
+		const regenerate = input.regenerate === true;
+		const selectedLocale = await resolveConeLocale(input);
+		const settled = await Promise.allSettled(targets.map(async (entity) => ({
+			entityId: entity.id,
+			...await entity.generateCones({
+				preserveExisting: !regenerate,
+				onlyEmpty: !regenerate,
+				locale: selectedLocale
+			})
+		})));
+		const results = [];
+		const failures = [];
+		for (const [index, outcome] of settled.entries()) {
+			if (outcome.status === "fulfilled") {
+				results.push(outcome.value);
+				continue;
+			}
+			failures.push({
+				entityId: targets[index].id,
+				message: outcome.reason instanceof Error ? outcome.reason.message : String(outcome.reason)
+			});
+		}
+		if (failures.length === 0) return results;
+		throw Object.assign(/* @__PURE__ */ new Error(`Cone generation failed for ${failures.length} entity(s).`), {
+			code: "CONE_GENERATION_FAILED",
+			details: {
+				results,
+				failures
+			}
+		});
+	}
+	const file = requiredText(input, "file");
+	const { readFile } = await import("node:fs/promises");
+	const patch = parseJson(file === "-" ? await (async () => {
+		const chunks = [];
+		for await (const chunk of process.stdin) chunks.push(Buffer.from(chunk));
+		return Buffer.concat(chunks).toString("utf8");
+	})() : await readFile(file, "utf8"), "INVALID_ENTITY_PATCH", entityPatchSchema);
+	if (!EntityManager.exists(patch.entityId)) throw Object.assign(/* @__PURE__ */ new Error(`Entity not found: ${patch.entityId}`), { code: "ENTITY_NOT_FOUND" });
+	const target = EntityManager.get(patch.entityId);
+	const before = target.toJson();
+	const after = structuredClone(before);
+	const nextProps = [...after.props, ...patch.operations.map(({ value }) => structuredClone(value))];
+	const { EntityJsonSchema } = await import("../types/types.js");
+	const validation = EntityJsonSchema.safeParse({
+		...after,
+		props: nextProps
+	});
+	if (!validation.success) throw Object.assign(/* @__PURE__ */ new Error("Invalid entity patch."), {
+		code: "INVALID_ENTITY_PATCH",
+		exitCode: 2,
+		cause: validation.error
+	});
+	after.props = nextProps;
+	if (mutationRequested(input)) {
+		target.props = after.props;
+		await target.save();
+	}
+	return {
+		changed: patch.operations.length > 0,
+		before,
+		after
+	};
+}
+async function renderScaffolds(input) {
+	await ensureSonamu();
+	const { renderTemplate } = await import("../syncer/code-generator.js");
+	const entities = strings(input, "entities");
+	const templates = strings(input, "templates");
+	const rendered = [];
+	for (const entityId of entities) for (const template of templates) {
+		const templateKey = z.enum([
+			"model",
+			"model_test",
+			"view_list",
+			"view_form",
+			"view_search_input"
+		]).parse(template);
+		const files = await renderTemplate(templateKey, { entityId });
+		rendered.push({
+			entityId,
+			template: templateKey,
+			files
+		});
+	}
+	return rendered;
+}
+async function scaffoldOperation(method, input) {
+	const directTemplate = z.enum([
+		"model",
+		"model_test",
+		"view_list",
+		"view_form"
+	]).safeParse(method);
+	if (directTemplate.success) {
+		await ensureSonamu();
+		const { Sonamu } = await import("../api/sonamu.js");
+		const entityId = requiredText(input, "entityId");
+		return directTemplate.data === "view_list" ? Sonamu.syncer.generateTemplate("view_list", {
+			entityId,
+			extra: input.extra
+		}) : Sonamu.syncer.generateTemplate(directTemplate.data, { entityId });
+	}
+	const rendered = await renderScaffolds(input);
+	const { access } = await import("node:fs/promises");
+	const path = await import("node:path");
+	const { Sonamu } = await import("../api/sonamu.js");
+	const items = await Promise.all(rendered.flatMap(({ entityId, template, files }) => files.map(async (file) => {
+		const target = path.default.join(Sonamu.appRootPath, file.path.replace("/:target/", "/web/"));
+		let exists = true;
+		try {
+			await access(target);
+		} catch {
+			exists = false;
+		}
+		return {
+			entityId,
+			template,
+			target,
+			exists,
+			content: file.code
+		};
+	})));
+	if (method === "status") return items.map(({ content: _content, ...item }) => item);
+	if (method === "preview" || method === "batch" && explicitlyDryRun(input)) return items;
+	const results = [];
+	for (const item of items) {
+		const { content: _content, ...summary } = item;
+		if (item.exists && input.overwrite !== true) {
+			results.push({
+				...summary,
+				status: "skipped"
+			});
+			continue;
+		}
+		await Sonamu.syncer.generateTemplate(item.template, { entityId: item.entityId }, { overwrite: input.overwrite === true });
+		results.push({
+			...summary,
+			status: "written"
+		});
+	}
+	return { items: results };
+}
+async function migrationOperation(method, input) {
+	let shadowTarget;
+	if (method === "shadow") {
+		const requestedTarget = requiredText(input, "target");
+		assertMigrationTarget(requestedTarget);
+		assertShadowMigrationTarget(requestedTarget);
+		shadowTarget = requestedTarget;
+	}
+	await ensureSonamu();
+	const { Migrator } = await import("../migration/migrator.js");
+	const migrator = new Migrator();
+	if (method === "status") return migrator.getStatus();
+	if (method === "generate") {
+		if (!(await migrator.getStatus()).conns.some((connection) => connection.status === 0)) throw Object.assign(/* @__PURE__ */ new Error("Pending migrations must be applied before generation."), { code: "MIGRATION_NOT_READY" });
+		return { count: await migrator.generatePreparedCodes() };
+	}
+	if (method === "run") {
+		if (!mutationRequested(input)) return { dryRun: true };
+		const { getSonamuEnvironment } = await import("../env.js");
+		const environment = getSonamuEnvironment();
+		return migrator.apply(environment === "test" ? ["test", "fixture"] : [environment]);
+	}
+	if (method === "connections") return migrator.getConnections();
+	if (method === "apply") {
+		const rawTargets = strings(input, "targets");
+		if (rawTargets.length === 0) throw Object.assign(/* @__PURE__ */ new Error("Missing targets."), {
+			code: "MISSING_ARGUMENT",
+			exitCode: 2
+		});
+		const targets = rawTargets.map((target) => {
+			assertMigrationTarget(target);
+			return target;
+		});
+		if (mutationRequested(input)) return migrator.apply(targets);
+		return Promise.all(targets.map(async (target) => {
+			return migrationPlan(target, (await migrator.getConnectionStatus(target)).pending);
+		}));
+	}
+	if (method === "shadow") {
+		if (shadowTarget === void 0) throw new Error("Shadow target validation was skipped.");
+		if (mutationRequested(input)) {
+			const result = await migrator.runShadowTest({ target: shadowTarget });
+			return Array.isArray(result) ? {
+				ok: true,
+				target: shadowTarget,
+				migrations: result.flatMap(({ applied }) => applied)
+			} : result;
+		}
+		const status = await migrator.getConnectionStatus(shadowTarget);
+		return migrationPlan(shadowTarget, status.pending);
+	}
+	const target = requiredText(input, "target");
+	assertMigrationTarget(target);
+	if (method === "code") return migrator.getPreparedCodes(target);
+	const action = method === "rollback" || text(input, "action") === "rollback" ? "rollback" : "apply";
+	const plan = await migrationPlan(target, action === "apply" ? (await migrator.getConnectionStatus(target)).pending : (await migrator.getLatestAppliedBatch(target)).files, action);
+	if (method !== "rollback" || !mutationRequested(input)) return plan;
+	return migrator.rollback([target]);
+}
+async function fixtureOperation(method, input) {
+	await ensureSonamu();
+	const [fixtureCommands, { FixtureManager }, fixtureService, { Sonamu }] = await Promise.all([
+		import("../bin/fixture.js"),
+		import("../testing/fixture-manager.js"),
+		import("./fixture-service.js"),
+		import("../api/sonamu.js")
+	]);
+	if (method === "init") return mutationRequested(input) ? fixtureCommands.fixtureInitCommand() : { dryRun: true };
+	if (method === "import") {
+		if (!mutationRequested(input)) return { dryRun: true };
+		FixtureManager.init();
+		await FixtureManager.importFixture(requiredText(input, "entityId"), z.array(z.number()).parse(input.recordIds));
+		await FixtureManager.sync();
+		return { imported: true };
+	}
+	if (method === "sync") {
+		if (!mutationRequested(input)) return { dryRun: true };
+		FixtureManager.init();
+		await FixtureManager.sync();
+		return { synced: true };
+	}
+	const legacyCommand = z.enum([
+		"gen",
+		"fetch",
+		"explore"
+	]).parse(method);
+	if (![
+		"entityId",
+		"source",
+		"target",
+		"field",
+		"values",
+		"relations",
+		"depth"
+	].some((key) => input[key] !== void 0)) {
+		const options = fixtureService.normalizeLegacyFixtureCommandOptions(legacyCommand, input);
+		const strategy = z.enum([
+			"sample",
+			"ids",
+			"query",
+			"file",
+			"recent",
+			"random"
+		]).optional().parse(options.strategy);
+		const fixtureOptions = {
+			...options,
+			strategy
+		};
+		if (legacyCommand !== "explore" && !mutationRequested(input)) return {
+			dryRun: true,
+			request: fixtureOptions
+		};
+		if (legacyCommand === "gen") return fixtureCommands.fixtureGenCommand(fixtureOptions);
+		if (legacyCommand === "explore") return fixtureCommands.fixtureExploreCommand(fixtureOptions);
+		return fixtureCommands.fixtureFetchCommand(fixtureOptions);
+	}
+	const entityId = requiredText(input, "entityId");
+	const source = requiredText(input, "source");
+	const target = requiredText(input, "target");
+	const field = requiredText(input, "field");
+	const values = strings(input, "values");
+	const relations = requiredText(input, "relations");
+	const depth = z.number().int().nonnegative().safeParse(input.depth);
+	if (!Object.hasOwn(Sonamu.dbConfig, source) || !Object.hasOwn(Sonamu.dbConfig, target) || values.length === 0 || ![
+		"include",
+		"exclude",
+		"none"
+	].includes(relations) || !depth.success) throw Object.assign(/* @__PURE__ */ new Error("Invalid fixture transfer selector."), {
+		code: "INVALID_FIXTURE_TRANSFER",
+		exitCode: 2
+	});
+	const sourceKey = source;
+	const targetKey = target;
+	const records = (await Promise.all(values.map((value) => FixtureManager.getFixtures(sourceKey, targetKey, {
+		entityId,
+		field,
+		value,
+		searchType: "equals"
+	}, {
+		includeRelations: relations === "include",
+		maxDepth: depth.data
+	})))).flat();
+	if (explicitlyDryRun(input)) return {
+		dryRun: true,
+		records
+	};
+	if (records.length > 0) await FixtureManager.insertFixtures(targetKey, records);
+	return { records };
+}
+async function buildOperation(method) {
+	const { buildApiCommand, buildWebCommand } = await import("../bin/build-config.js");
+	if (method === "api") return buildApiCommand();
+	if (method === "web") return buildWebCommand();
+	await buildApiCommand();
+	return buildWebCommand({ skipIfMissing: true });
+}
+async function testOperation(method, input) {
+	const { createDefaultTestRunClient } = await import("./test-run-client.js");
+	const client = createDefaultTestRunClient();
+	if (method === "status") return client.status();
+	const request = {
+		files: z.array(z.string()).catch([]).parse(input.files),
+		pattern: z.string().optional().parse(input.pattern),
+		traces: input.traces === true
+	};
+	return {
+		request,
+		result: await client.run(request)
+	};
+}
+const betterAuthPluginSchema = z.enum([
+	"2fa",
+	"admin",
+	"anonymous",
+	"api-key",
+	"audit-log",
+	"jwt",
+	"organization",
+	"passkey",
+	"phone-number",
+	"sso",
+	"username"
+]);
+async function authOperation(method, input) {
+	const { addCompanionsToEntities, generateBetterAuthEntities } = await import("../auth/index.js");
+	if (method === "addCompanions") return addCompanionsToEntities();
+	return generateBetterAuthEntities({ plugins: z.array(betterAuthPluginSchema).parse((optionalText(input, "plugins") ?? "").split(",").map((plugin) => plugin.trim()).filter(Boolean)) });
+}
+async function i18nOperation(method, input) {
+	await ensureSonamu();
+	const { sonamuDictionary } = await import("../dict/sonamu-dictionary.js");
+	if (method === "list") {
+		const dictionary = await sonamuDictionary.getDictionary();
+		const locale = text(input, "locale");
+		return locale === void 0 ? dictionary : {
+			...dictionary,
+			locales: [locale],
+			rows: dictionary.rows.map((row) => ({
+				key: row.key,
+				source: row.source,
+				[locale]: row[locale]
+			}))
+		};
+	}
+	if (method === "check") {
+		const dictionary = await sonamuDictionary.getDictionary();
+		return sonamuDictionary.checkUsage(dictionary.rows.map((row) => row.key));
+	}
+	if (method === "export" || method === "import") {
+		const file = requiredText(input, "file");
+		if (explicitlyDryRun(input)) return {
+			operation: method,
+			dryRun: true
+		};
+		const { readFile, writeFile } = await import("node:fs/promises");
+		const format = text(input, "format") === "json" ? "json" : "workbook";
+		if (method === "export" && format === "workbook") {
+			const { buffer } = await sonamuDictionary.exportToExcel();
+			await writeFile(file, buffer);
+			return { exported: 1 };
+		}
+		if (method === "import" && format === "workbook") return sonamuDictionary.importFromExcel(await readFile(file));
+		if (method === "export") {
+			const dictionary = await sonamuDictionary.getDictionary();
+			const locale = text(input, "locale");
+			const rows = dictionary.rows.map(({ key, source: _source, isFunction: _isFunction, ...values }) => ({
+				key,
+				values: locale === void 0 ? values : { [locale]: z.string().catch("").parse(values[locale]) }
+			}));
+			await writeFile(file, JSON.stringify(rows, null, 2));
+			return { exported: rows.length };
+		}
+		const entries = parseJson((await readFile(file)).toString("utf8"), "I18N_INVALID_JSON", i18nEntriesSchema);
+		const current = await sonamuDictionary.getDictionary();
+		const existingKeys = new Set(current.rows.map(({ key }) => key));
+		for (const entry of entries) if (existingKeys.has(entry.key)) await sonamuDictionary.updateEntry({
+			oldKey: entry.key,
+			newKey: entry.key,
+			source: "project",
+			values: entry.values
+		});
+		else await sonamuDictionary.createEntry(entry);
+		return { imported: entries.length };
+	}
+	const key = requiredText(input, "key");
+	if (method === "create") {
+		if (explicitlyDryRun(input)) return {
+			operation: "create",
+			input,
+			dryRun: true
+		};
+		return sonamuDictionary.createEntry({
+			key,
+			values: dictionaryValuesSchema.parse(input.values)
+		});
+	}
+	if (method === "update") {
+		if (explicitlyDryRun(input)) return {
+			operation: "update",
+			input,
+			dryRun: true
+		};
+		const explicitSource = text(input, "source");
+		const resolvedSource = explicitSource === void 0 ? (await sonamuDictionary.getDictionary()).rows.find((row) => row.key === key)?.source ?? "project" : explicitSource;
+		return sonamuDictionary.updateEntry({
+			oldKey: key,
+			newKey: text(input, "newKey") ?? key,
+			source: dictionarySourceSchema.parse(resolvedSource),
+			values: dictionaryValuesSchema.parse(input.values)
+		});
+	}
+	if (!mutationRequested(input)) return {
+		key,
+		operation: "remove",
+		dryRun: true
+	};
+	return sonamuDictionary.deleteEntry(key);
+}
+async function taskOperation(method, input) {
+	await ensureSonamu();
+	const { Sonamu } = await import("../api/sonamu.js");
+	const workflows = Sonamu.workflows;
+	const backend = workflows.backend;
+	if (method === "definitions") return { definitions: workflows.workflowDefinitions };
+	if (method === "runs") return backend.listWorkflowRuns({ limit: 50 });
+	const workflowRunId = requiredText(input, "runId");
+	if (method === "show") return backend.getWorkflowRun({ workflowRunId });
+	if (method === "watch") {
+		const { isDeepStrictEqual } = await import("node:util");
+		return (async function* watch() {
+			let previous;
+			while (true) {
+				const snapshot = await backend.getWorkflowRun({ workflowRunId });
+				if (snapshot === null) throw Object.assign(/* @__PURE__ */ new Error(`Workflow run not found: ${workflowRunId}`), { code: "TASK_RUN_NOT_FOUND" });
+				const rawState = snapshot.status === "succeeded" ? "completed" : snapshot.status;
+				const state = rawState === "canceled" ? "cancelled" : rawState;
+				const current = {
+					...snapshot,
+					state
+				};
+				if (!isDeepStrictEqual(current, previous)) {
+					previous = structuredClone(current);
+					yield current;
+				}
+				if ([
+					"completed",
+					"failed",
+					"cancelled"
+				].includes(state)) return;
+				await new Promise((resolve) => setTimeout(resolve, 1e3));
+			}
+		})();
+	}
+	if (method === "steps") return backend.listStepAttempts({
+		workflowRunId,
+		limit: 100
+	});
+	if (!mutationRequested(input)) return {
+		operation: method,
+		workflowRunId,
+		dryRun: true
+	};
+	if (method === "pause") return backend.pauseWorkflowRun({ workflowRunId });
+	if (method === "resume") return backend.resumeWorkflowRun({ workflowRunId });
+	return backend.cancelWorkflowRun({ workflowRunId });
+}
+async function cddRootPath() {
+	const [{ Sonamu }, path] = await Promise.all([import("../api/sonamu.js"), import("node:path")]);
+	return path.join(Sonamu.appRootPath, "contract");
+}
+const practiceSequencePattern = /^p([0-9]+)-/;
+const practiceNamePattern = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+function invalidPracticeName(name) {
+	return Object.assign(/* @__PURE__ */ new Error(`Invalid practice name: ${name}. Use letters, digits, ".", "-", and "_" only, starting with a letter or digit.`), {
+		code: "INVALID_PRACTICE_NAME",
+		exitCode: 2
+	});
+}
+function invalidPracticeDirectory(directory) {
+	return Object.assign(/* @__PURE__ */ new Error(`Practice directory escapes the API root: ${directory}`), {
+		code: "INVALID_PRACTICE_PATH",
+		exitCode: 2
+	});
+}
+/**
+* `src/practices` 아래에 다음 시퀀스 번호를 가진 practice 스텁 파일을 만듭니다.
+*
+* 구 CLI(`stub practice`)의 파일명 규칙과 스텁 본문을 그대로 유지합니다.
+*/
+async function stubPracticeOperation(input) {
+	const name = requiredText(input, "name");
+	if (!practiceNamePattern.test(name)) throw invalidPracticeName(name);
+	await ensureSonamu();
+	const [{ Sonamu }, { constants }, { mkdir, open, readdir, realpath }, path] = await Promise.all([
+		import("../api/sonamu.js"),
+		import("node:fs"),
+		import("node:fs/promises"),
+		import("node:path")
+	]);
+	const practiceDirectory = path.default.join(Sonamu.apiRootPath, "src", "practices");
+	await mkdir(practiceDirectory, { recursive: true });
+	const [canonicalApiRoot, canonicalDirectory] = await Promise.all([realpath(Sonamu.apiRootPath), realpath(practiceDirectory)]);
+	const directoryRelative = path.default.relative(canonicalApiRoot, canonicalDirectory);
+	if (directoryRelative.startsWith("..") || path.default.isAbsolute(directoryRelative)) throw invalidPracticeDirectory(practiceDirectory);
+	const fileName = `p${(await readdir(practiceDirectory)).filter((fileName) => fileName.startsWith("p") && fileName.endsWith(".ts")).reduce((largest, fileName) => {
+		const matched = practiceSequencePattern.exec(fileName);
+		return matched === null ? largest : Math.max(largest, Number.parseInt(matched[1], 10));
+	}, 0) + 1}-${name}.ts`;
+	const filePath = path.default.resolve(practiceDirectory, fileName);
+	const stubCode = [
+		`import { Sonamu } from "sonamu";`,
+		"",
+		`console.clear();`,
+		`console.log("${fileName}");`,
+		"",
+		`Sonamu.runScript(async () => {`,
+		` // TODO`,
+		`});`,
+		""
+	].join("\n");
+	let handle;
+	try {
+		handle = await open(filePath, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 438);
+		await handle.writeFile(stubCode, "utf8");
+	} catch (error) {
+		const errorCode = error.code;
+		if (errorCode === "EEXIST" || errorCode === "ELOOP") throw Object.assign(/* @__PURE__ */ new Error(`Practice file already exists: ${filePath}`), {
+			code: "PRACTICE_FILE_EXISTS",
+			exitCode: 2,
+			cause: error
+		});
+		throw error;
+	} finally {
+		await handle?.close();
+	}
+	return {
+		fileName,
+		path: filePath
+	};
+}
+async function readCddTree(directory, root) {
+	const [{ readdir }, path] = await Promise.all([import("node:fs/promises"), import("node:path")]);
+	const entries = await readdir(directory, { withFileTypes: true });
+	const nodes = [];
+	for (const entry of entries) {
+		if (entry.name === "rules") continue;
+		const absolutePath = path.join(directory, entry.name);
+		const relativePath = path.relative(root, absolutePath);
+		if (entry.isDirectory()) {
+			const children = await readCddTree(absolutePath, root);
+			if (children.length > 0) nodes.push({
+				name: entry.name,
+				path: relativePath,
+				type: "directory",
+				children
+			});
+		} else if (entry.isFile() && entry.name.endsWith(".contract.md")) nodes.push({
+			name: entry.name,
+			path: relativePath,
+			type: "file",
+			fileType: "contract"
+		});
+	}
+	return nodes;
+}
+async function cddOperation(method, input) {
+	await ensureSonamu();
+	const [{ access }, { createDefaultCddToolingAdapter }] = await Promise.all([import("node:fs/promises"), import("./cdd-service.js")]);
+	const adapter = createDefaultCddToolingAdapter({ contractRoot: await cddRootPath() });
+	if (method === "tree") {
+		const root = await cddRootPath();
+		try {
+			await access(root);
+		} catch {
+			return {
+				exists: false,
+				tree: []
+			};
+		}
+		return {
+			exists: true,
+			tree: await readCddTree(root, root)
+		};
+	}
+	if (method === "read") {
+		const relativePath = requiredText(input, "path");
+		return adapter.read({ path: relativePath });
+	}
+	if (method === "rules") return adapter.rules();
+	if (method === "showRule") {
+		const ruleId = requiredText(input, "ruleId");
+		return adapter.showRule({ ruleId });
+	}
+	if (method === "addRule") {
+		const ruleKey = requiredText(input, "ruleKey");
+		const id = requiredText(input, "id");
+		const when = requiredText(input, "when");
+		const ruleText = text(input, "instruction") ?? requiredText(input, "text");
+		return adapter.addRule({
+			ruleKey,
+			id,
+			when,
+			text: ruleText,
+			examples: strings(input, "examples"),
+			dryRun: explicitlyDryRun(input)
+		});
+	}
+	if (explicitlyDryRun(input)) return {
+		operation: "addAcceptanceCriterion",
+		input,
+		dryRun: true
+	};
+	const document = requiredText(input, "document");
+	const criterion = requiredText(input, "text");
+	return adapter.addAcceptanceCriterion({
+		document,
+		text: criterion,
+		dryRun: false
+	});
+}
+async function invokeDefault(group, method, input) {
+	if (group === "core") return syncOperation(input);
+	if (group === "entity") return entityOperation(method, input);
+	if (group === "scaffold") return scaffoldOperation(method, input);
+	if (group === "migration") return migrationOperation(method, input);
+	if (group === "fixture") return fixtureOperation(method, input);
+	if (group === "build") return buildOperation(method);
+	if (group === "test") return testOperation(method, input);
+	if (group === "auth") return authOperation(method, input);
+	if (group === "i18n") return i18nOperation(method, input);
+	if (group === "task") return taskOperation(method, input);
+	if (group === "stub") return stubPracticeOperation(input);
+	return cddOperation(method, input);
+}
+const tooling = Object.fromEntries(Object.entries(REQUIRED_METHODS).map(([group, methods]) => [group, Object.fromEntries(methods.map((method) => [method, (input) => invokeDefault(group, method, input)]))]));
+Object.defineProperty(tooling.migration, "apply", {
+	enumerable: false,
+	value: (input) => invokeDefault("migration", "apply", input)
+});
+//#endregion
+export { tooling };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"cli-tooling.js","names":[],"sources":["../../src/tooling/cli-tooling.ts"],"sourcesContent":["import { z } from \"zod\";\n\nimport { type FixtureCommandOptions } from \"../bin/fixture\";\n\nconst jsonValueSchema = z.json();\ntype CommandValue = z.infer<typeof jsonValueSchema> | undefined;\ntype CommandInput = Record<string, CommandValue>;\ntype ToolingResult = object | string | number | boolean | null | void | AsyncIterable<object>;\ntype ToolingOperation = (input: CommandInput) => ToolingResult | Promise<ToolingResult>;\ntype ToolingGroup = Record<string, ToolingOperation>;\nexport type CliToolingOperations = Record<string, ToolingGroup>;\n\ntype MigrationTarget = \"development\" | \"staging\" | \"production\" | \"fixture\" | \"test\";\n\nconst MIGRATION_TARGETS = new Set<string>([\n  \"development\",\n  \"staging\",\n  \"production\",\n  \"fixture\",\n  \"test\",\n]);\n\nfunction assertMigrationTarget(target: string): asserts target is MigrationTarget {\n  // DB 상태를 조회하거나 변경하기 전에 모든 외부 대상을 검증합니다.\n  if (MIGRATION_TARGETS.has(target)) return;\n  throw Object.assign(new Error(`Unsupported migration target: ${target}`), {\n    code: \"INVALID_MIGRATION_TARGET\",\n    exitCode: 2,\n  });\n}\n\nfunction assertShadowMigrationTarget(\n  target: MigrationTarget,\n): asserts target is Extract<MigrationTarget, \"fixture\" | \"test\"> {\n  if (target === \"fixture\" || target === \"test\") return;\n\n  // Shadow DB는 운영 계열 연결에 접근하기 전에 허용 대상을 제한합니다.\n  throw Object.assign(new Error(`Invalid shadow migration target: ${target}`), {\n    code: \"INVALID_SHADOW_MIGRATION_TARGET\",\n    target,\n    exitCode: 2,\n  });\n}\n\nasync function migrationPlan(\n  target: MigrationTarget,\n  migrations: string[],\n  action: \"apply\" | \"rollback\" = \"apply\",\n) {\n  const digest = await crypto.subtle.digest(\n    \"SHA-256\",\n    new TextEncoder().encode(JSON.stringify({ action, target, migrations })),\n  );\n  return {\n    kind: \"migration-plan\" as const,\n    action,\n    target,\n    migrations,\n    fingerprint: Array.from(new Uint8Array(digest), (byte) =>\n      byte.toString(16).padStart(2, \"0\"),\n    ).join(\"\"),\n  };\n}\n\nconst REQUIRED_METHODS = {\n  core: [\"sync\"],\n  entity: [\"list\", \"show\", \"search\", \"applyPatch\", \"create\", \"cones\"],\n  scaffold: [\"model\", \"model_test\", \"view_list\", \"view_form\", \"status\", \"preview\", \"batch\"],\n  migration: [\"run\", \"generate\", \"status\", \"connections\", \"code\", \"preview\", \"shadow\", \"rollback\"],\n  fixture: [\"init\", \"import\", \"sync\", \"gen\", \"fetch\", \"explore\"],\n  build: [\"all\", \"api\", \"web\"],\n  test: [\"run\", \"status\"],\n  auth: [\"generate\", \"addCompanions\"],\n  i18n: [\"list\", \"check\", \"import\", \"export\", \"create\", \"update\", \"remove\"],\n  task: [\"definitions\", \"runs\", \"show\", \"steps\", \"watch\", \"pause\", \"resume\", \"cancel\"],\n  cdd: [\"tree\", \"read\", \"rules\", \"showRule\", \"addRule\", \"addAcceptanceCriterion\"],\n  stub: [\"practice\"],\n} as const;\n\nlet initialization: Promise<void> | undefined;\n\nasync function ensureSonamu(): Promise<void> {\n  const { Sonamu } = await import(\"../api/sonamu\");\n  if (Sonamu.isInitialized) return;\n  initialization ??= Sonamu.init(true, false);\n  await initialization;\n}\n\nasync function syncOperation(input: CommandInput): Promise<ToolingResult> {\n  await ensureSonamu();\n  const { Sonamu } = await import(\"../api/sonamu\");\n  return input.force === true ? Sonamu.syncer.forceSync() : Sonamu.syncer.sync();\n}\n\nfunction text(input: CommandInput, key: string): string | undefined {\n  const value = z.string().safeParse(input[key]);\n  return value.success ? value.data : undefined;\n}\n\nfunction strings(input: CommandInput, key: string): string[] {\n  const value = z.array(z.string()).safeParse(input[key]);\n  return value.success ? value.data : [];\n}\n\nfunction requiredText(input: CommandInput, key: string): string {\n  const value = text(input, key);\n  if (value !== undefined && value.length > 0) return value;\n  throw Object.assign(new Error(`Missing ${key}.`), { code: \"MISSING_ARGUMENT\", exitCode: 2 });\n}\n\n/**\n * 생략한 값은 `undefined`로 통과시키되, 값이 있는데 문자열이 아니면 인자 오류로 거절합니다.\n *\n * `text()`처럼 조용히 무시하면 잘못된 타입의 입력이 기본값으로 둔갑합니다.\n */\nfunction optionalText(input: CommandInput, key: string): string | undefined {\n  const value = input[key];\n  if (value === undefined || value === null) return undefined;\n  const parsed = z.string().safeParse(value);\n  if (parsed.success) return parsed.data;\n  throw Object.assign(new Error(`Invalid ${key}.`), { code: \"INVALID_ARGUMENT\", exitCode: 2 });\n}\n\nfunction parseJson<Schema extends z.ZodType>(\n  contents: string,\n  code: string,\n  schema: Schema,\n): z.infer<Schema> {\n  try {\n    return schema.parse(JSON.parse(contents));\n  } catch (cause) {\n    throw Object.assign(new Error(\"Invalid JSON input.\"), { code, exitCode: 2, cause });\n  }\n}\n\nfunction mutationRequested(input: CommandInput): boolean {\n  return input.execute === true || input.dryRun === false;\n}\n\nfunction explicitlyDryRun(input: CommandInput): boolean {\n  return input.dryRun === true || input.execute === false;\n}\n\nconst entityPatchSchema = z.object({\n  entityId: z.string().min(1),\n  operations: z.array(\n    z.object({\n      op: z.literal(\"add\"),\n      path: z.literal(\"/props/-\"),\n      value: z\n        .object({ name: z.string().min(1), type: z.string().min(1) })\n        .catchall(jsonValueSchema),\n    }),\n  ),\n});\nconst i18nEntriesSchema = z.array(\n  z.object({ key: z.string(), values: z.record(z.string(), z.string()) }),\n);\nconst dictionaryValuesSchema = z.record(z.string(), z.string());\nconst dictionarySourceSchema = z.enum([\"entity\", \"project\", \"sonamu\"]);\nconst coneLocaleSchema = z.enum([\"ko\", \"en\", \"ja\"]);\n\n/**\n * cone 생성에 사용할 locale을 결정합니다.\n *\n * 명시한 locale이 최우선이고, 없으면 프로젝트 i18n 기본 locale, 그마저 없으면 \"ko\"를 사용합니다.\n */\nasync function resolveConeLocale(input: CommandInput): Promise<z.infer<typeof coneLocaleSchema>> {\n  const explicit = coneLocaleSchema.safeParse(input.locale);\n  if (explicit.success) return explicit.data;\n\n  const { Sonamu } = await import(\"../api/sonamu\");\n  let configuredLocale: unknown;\n  try {\n    configuredLocale = Sonamu.config.i18n?.defaultLocale;\n  } catch {\n    // 설정을 아직 읽을 수 없는 실행 경로에서는 기본 locale로 폴백합니다.\n  }\n  const configured = coneLocaleSchema.safeParse(configuredLocale);\n  return configured.success ? configured.data : \"ko\";\n}\n\nasync function entityOperation(method: string, input: CommandInput): Promise<ToolingResult> {\n  await ensureSonamu();\n  const { EntityManager } = await import(\"../entity/entity-manager\");\n  const entities = EntityManager.getAllEntities();\n\n  if (method === \"list\") return entities.map((entity) => entity.toJson());\n  if (method === \"show\") {\n    const entityId = requiredText(input, \"entityId\");\n    if (!EntityManager.exists(entityId)) {\n      throw Object.assign(new Error(`Entity not found: ${entityId}`), {\n        code: \"ENTITY_NOT_FOUND\",\n      });\n    }\n    return EntityManager.get(entityId).toJson();\n  }\n  if (method === \"search\") {\n    const query = requiredText(input, \"query\").toLocaleLowerCase();\n    return entities\n      .map((entity) => entity.toJson())\n      .filter((entity) => JSON.stringify(entity).toLocaleLowerCase().includes(query));\n  }\n  if (method === \"create\") {\n    const entityId = requiredText(input, \"name\");\n    const { Sonamu } = await import(\"../api/sonamu\");\n    await Sonamu.syncer.createEntity({ entityId, title: entityId });\n    if (input.noCones === true) return { entityId, cones: \"skipped\" };\n    const entity = EntityManager.get(entityId);\n    if (input.ai === true) {\n      return entity.generateCones({\n        preserveExisting: false,\n        onlyEmpty: false,\n        locale: await resolveConeLocale(input),\n      });\n    }\n    await entity.generateTemplateCones();\n    return { entityId, cones: \"template\" };\n  }\n  if (method === \"cones\") {\n    const entityId = requiredText(input, \"entityId\");\n    const targets =\n      input.all === true || entityId === \"all\"\n        ? EntityManager.getAllEntities()\n        : EntityManager.exists(entityId)\n          ? [EntityManager.get(entityId)]\n          : [];\n    if (targets.length === 0) {\n      throw Object.assign(new Error(`Entity not found: ${entityId}`), {\n        code: \"ENTITY_NOT_FOUND\",\n      });\n    }\n    const regenerate = input.regenerate === true;\n    const selectedLocale = await resolveConeLocale(input);\n    // 한 엔티티의 실패가 나머지 엔티티의 cone 생성을 취소하지 않도록 전부 끝까지 실행합니다.\n    const settled = await Promise.allSettled(\n      targets.map(async (entity) => ({\n        entityId: entity.id,\n        ...(await entity.generateCones({\n          preserveExisting: !regenerate,\n          onlyEmpty: !regenerate,\n          locale: selectedLocale,\n        })),\n      })),\n    );\n    const results = [];\n    const failures = [];\n    for (const [index, outcome] of settled.entries()) {\n      if (outcome.status === \"fulfilled\") {\n        results.push(outcome.value);\n        continue;\n      }\n      failures.push({\n        entityId: targets[index].id,\n        message: outcome.reason instanceof Error ? outcome.reason.message : String(outcome.reason),\n      });\n    }\n    if (failures.length === 0) return results;\n    throw Object.assign(new Error(`Cone generation failed for ${failures.length} entity(s).`), {\n      code: \"CONE_GENERATION_FAILED\",\n      details: { results, failures },\n    });\n  }\n\n  const file = requiredText(input, \"file\");\n  const { readFile } = await import(\"node:fs/promises\");\n  const contents =\n    file === \"-\"\n      ? await (async () => {\n          const chunks = [];\n          for await (const chunk of process.stdin) chunks.push(Buffer.from(chunk));\n          return Buffer.concat(chunks).toString(\"utf8\");\n        })()\n      : await readFile(file, \"utf8\");\n  const patch = parseJson(contents, \"INVALID_ENTITY_PATCH\", entityPatchSchema);\n  if (!EntityManager.exists(patch.entityId)) {\n    throw Object.assign(new Error(`Entity not found: ${patch.entityId}`), {\n      code: \"ENTITY_NOT_FOUND\",\n    });\n  }\n  const target = EntityManager.get(patch.entityId);\n  const before = target.toJson();\n  const after = structuredClone(before);\n  const nextProps = [\n    ...after.props,\n    ...patch.operations.map(({ value }) => structuredClone(value)),\n  ];\n  // 파일이나 등록된 엔티티를 건드리기 전에 patch 적용 결과 전체를 entity 스키마로 검증합니다.\n  const { EntityJsonSchema } = await import(\"../types/types\");\n  const validation = EntityJsonSchema.safeParse({ ...after, props: nextProps });\n  if (!validation.success) {\n    throw Object.assign(new Error(\"Invalid entity patch.\"), {\n      code: \"INVALID_ENTITY_PATCH\",\n      exitCode: 2,\n      cause: validation.error,\n    });\n  }\n  // SAFETY: EntityJsonSchema가 patch 적용 결과 전체를 검증했습니다.\n  after.props = nextProps as typeof after.props;\n  if (mutationRequested(input)) {\n    // SAFETY: after.props originates from the current entity plus schema-validated prop additions.\n    target.props = after.props as typeof target.props;\n    await target.save();\n  }\n  return { changed: patch.operations.length > 0, before, after };\n}\n\nasync function renderScaffolds(input: CommandInput) {\n  await ensureSonamu();\n  const { renderTemplate } = await import(\"../syncer/code-generator\");\n  const entities = strings(input, \"entities\");\n  const templates = strings(input, \"templates\");\n  const rendered = [];\n  for (const entityId of entities) {\n    for (const template of templates) {\n      const templateKey = z\n        .enum([\"model\", \"model_test\", \"view_list\", \"view_form\", \"view_search_input\"])\n        .parse(template);\n      const files = await renderTemplate(templateKey, { entityId });\n      rendered.push({ entityId, template: templateKey, files });\n    }\n  }\n  return rendered;\n}\n\nasync function scaffoldOperation(method: string, input: CommandInput): Promise<ToolingResult> {\n  const directTemplate = z\n    .enum([\"model\", \"model_test\", \"view_list\", \"view_form\"])\n    .safeParse(method);\n  if (directTemplate.success) {\n    await ensureSonamu();\n    const { Sonamu } = await import(\"../api/sonamu\");\n    const entityId = requiredText(input, \"entityId\");\n    return directTemplate.data === \"view_list\"\n      ? Sonamu.syncer.generateTemplate(\"view_list\", { entityId, extra: input.extra })\n      : Sonamu.syncer.generateTemplate(directTemplate.data, { entityId });\n  }\n  const rendered = await renderScaffolds(input);\n  const { access } = await import(\"node:fs/promises\");\n  const path = await import(\"node:path\");\n  const { Sonamu } = await import(\"../api/sonamu\");\n  const items = await Promise.all(\n    rendered.flatMap(({ entityId, template, files }) =>\n      files.map(async (file) => {\n        const target = path.default.join(\n          Sonamu.appRootPath,\n          file.path.replace(\"/:target/\", \"/web/\"),\n        );\n        let exists = true;\n        try {\n          await access(target);\n        } catch {\n          exists = false;\n        }\n        return { entityId, template, target, exists, content: file.code };\n      }),\n    ),\n  );\n  if (method === \"status\") return items.map(({ content: _content, ...item }) => item);\n  if (method === \"preview\" || (method === \"batch\" && explicitlyDryRun(input))) return items;\n\n  const results = [];\n  for (const item of items) {\n    const { content: _content, ...summary } = item;\n    if (item.exists && input.overwrite !== true) {\n      results.push({ ...summary, status: \"skipped\" });\n      continue;\n    }\n    await Sonamu.syncer.generateTemplate(\n      item.template,\n      { entityId: item.entityId },\n      { overwrite: input.overwrite === true },\n    );\n    results.push({ ...summary, status: \"written\" });\n  }\n  return { items: results };\n}\n\nasync function migrationOperation(method: string, input: CommandInput): Promise<ToolingResult> {\n  let shadowTarget: Extract<MigrationTarget, \"fixture\" | \"test\"> | undefined;\n  if (method === \"shadow\") {\n    const requestedTarget = requiredText(input, \"target\");\n    assertMigrationTarget(requestedTarget);\n    assertShadowMigrationTarget(requestedTarget);\n    shadowTarget = requestedTarget;\n  }\n\n  await ensureSonamu();\n  const { Migrator } = await import(\"../migration/migrator\");\n  const migrator = new Migrator();\n  if (method === \"status\") return migrator.getStatus();\n  if (method === \"generate\") {\n    const status = await migrator.getStatus();\n    if (!status.conns.some((connection) => connection.status === 0)) {\n      throw Object.assign(new Error(\"Pending migrations must be applied before generation.\"), {\n        code: \"MIGRATION_NOT_READY\",\n      });\n    }\n    return { count: await migrator.generatePreparedCodes() };\n  }\n  if (method === \"run\") {\n    if (!mutationRequested(input)) return { dryRun: true };\n    const { getSonamuEnvironment } = await import(\"../env\");\n    const environment = getSonamuEnvironment();\n    return migrator.apply(environment === \"test\" ? [\"test\", \"fixture\"] : [environment]);\n  }\n  if (method === \"connections\") return migrator.getConnections();\n  if (method === \"apply\") {\n    const rawTargets = strings(input, \"targets\");\n    if (rawTargets.length === 0) {\n      throw Object.assign(new Error(\"Missing targets.\"), { code: \"MISSING_ARGUMENT\", exitCode: 2 });\n    }\n    const targets = rawTargets.map((target) => {\n      assertMigrationTarget(target);\n      return target;\n    });\n    if (mutationRequested(input)) return migrator.apply(targets);\n    return Promise.all(\n      targets.map(async (target) => {\n        const status = await migrator.getConnectionStatus(target);\n        return migrationPlan(target, status.pending);\n      }),\n    );\n  }\n  if (method === \"shadow\") {\n    if (shadowTarget === undefined) throw new Error(\"Shadow target validation was skipped.\");\n    if (mutationRequested(input)) {\n      const result = await migrator.runShadowTest({ target: shadowTarget });\n      return Array.isArray(result)\n        ? {\n            ok: true,\n            target: shadowTarget,\n            migrations: result.flatMap(({ applied }) => applied),\n          }\n        : result;\n    }\n\n    const status = await migrator.getConnectionStatus(shadowTarget);\n    return migrationPlan(shadowTarget, status.pending);\n  }\n\n  const target = requiredText(input, \"target\");\n  assertMigrationTarget(target);\n  if (method === \"code\") return migrator.getPreparedCodes(target);\n\n  const action =\n    method === \"rollback\" || text(input, \"action\") === \"rollback\" ? \"rollback\" : \"apply\";\n  const migrations =\n    action === \"apply\"\n      ? (await migrator.getConnectionStatus(target)).pending\n      : (await migrator.getLatestAppliedBatch(target)).files;\n  const plan = await migrationPlan(target, migrations, action);\n  if (method !== \"rollback\" || !mutationRequested(input)) return plan;\n  return migrator.rollback([target]);\n}\n\nasync function fixtureOperation(method: string, input: CommandInput): Promise<ToolingResult> {\n  await ensureSonamu();\n  const [fixtureCommands, { FixtureManager }, fixtureService, { Sonamu }] = await Promise.all([\n    import(\"../bin/fixture\"),\n    import(\"../testing/fixture-manager\"),\n    import(\"./fixture-service\"),\n    import(\"../api/sonamu\"),\n  ]);\n  if (method === \"init\") {\n    return mutationRequested(input) ? fixtureCommands.fixtureInitCommand() : { dryRun: true };\n  }\n  if (method === \"import\") {\n    if (!mutationRequested(input)) return { dryRun: true };\n    FixtureManager.init();\n    await FixtureManager.importFixture(\n      requiredText(input, \"entityId\"),\n      z.array(z.number()).parse(input.recordIds),\n    );\n    await FixtureManager.sync();\n    return { imported: true };\n  }\n  if (method === \"sync\") {\n    if (!mutationRequested(input)) return { dryRun: true };\n    FixtureManager.init();\n    await FixtureManager.sync();\n    return { synced: true };\n  }\n  const legacyCommand = z.enum([\"gen\", \"fetch\", \"explore\"]).parse(method);\n  const isTransfer = [\"entityId\", \"source\", \"target\", \"field\", \"values\", \"relations\", \"depth\"].some(\n    (key) => input[key] !== undefined,\n  );\n  if (!isTransfer) {\n    const options = fixtureService.normalizeLegacyFixtureCommandOptions(legacyCommand, input);\n    const strategy = z\n      .enum([\"sample\", \"ids\", \"query\", \"file\", \"recent\", \"random\"])\n      .optional()\n      .parse(options.strategy);\n    const fixtureOptions = { ...options, strategy } satisfies FixtureCommandOptions;\n    if (legacyCommand !== \"explore\" && !mutationRequested(input)) {\n      return { dryRun: true, request: fixtureOptions };\n    }\n    if (legacyCommand === \"gen\") return fixtureCommands.fixtureGenCommand(fixtureOptions);\n    if (legacyCommand === \"explore\") return fixtureCommands.fixtureExploreCommand(fixtureOptions);\n    return fixtureCommands.fixtureFetchCommand(fixtureOptions);\n  }\n\n  const entityId = requiredText(input, \"entityId\");\n  const source = requiredText(input, \"source\");\n  const target = requiredText(input, \"target\");\n  const field = requiredText(input, \"field\");\n  const values = strings(input, \"values\");\n  const relations = requiredText(input, \"relations\");\n  // CLI 문법이 integer({ min: 0 })이므로 관계 순회를 끄는 depth 0을 허용합니다.\n  const depth = z.number().int().nonnegative().safeParse(input.depth);\n  if (\n    !Object.hasOwn(Sonamu.dbConfig, source) ||\n    !Object.hasOwn(Sonamu.dbConfig, target) ||\n    values.length === 0 ||\n    ![\"include\", \"exclude\", \"none\"].includes(relations) ||\n    !depth.success\n  ) {\n    throw Object.assign(new Error(\"Invalid fixture transfer selector.\"), {\n      code: \"INVALID_FIXTURE_TRANSFER\",\n      exitCode: 2,\n    });\n  }\n  // SAFETY: Object.hasOwn checks above establish both keys as configured DB presets.\n  const sourceKey = source as keyof typeof Sonamu.dbConfig;\n  // SAFETY: Object.hasOwn checks above establish both keys as configured DB presets.\n  const targetKey = target as keyof typeof Sonamu.dbConfig;\n  const records = (\n    await Promise.all(\n      values.map((value) =>\n        FixtureManager.getFixtures(\n          sourceKey,\n          targetKey,\n          { entityId, field, value, searchType: \"equals\" },\n          { includeRelations: relations === \"include\", maxDepth: depth.data },\n        ),\n      ),\n    )\n  ).flat();\n  if (explicitlyDryRun(input)) return { dryRun: true, records };\n  if (records.length > 0) await FixtureManager.insertFixtures(targetKey, records);\n  return { records };\n}\n\nasync function buildOperation(method: string): Promise<ToolingResult> {\n  const { buildApiCommand, buildWebCommand } = await import(\"../bin/build-config\");\n  if (method === \"api\") return buildApiCommand();\n  if (method === \"web\") return buildWebCommand();\n  await buildApiCommand();\n  return buildWebCommand({ skipIfMissing: true });\n}\n\nasync function testOperation(method: string, input: CommandInput): Promise<ToolingResult> {\n  const { createDefaultTestRunClient } = await import(\"./test-run-client\");\n  const client = createDefaultTestRunClient();\n  if (method === \"status\") return client.status();\n  const request = {\n    files: z.array(z.string()).catch([]).parse(input.files),\n    pattern: z.string().optional().parse(input.pattern),\n    traces: input.traces === true,\n  };\n  return { request, result: await client.run(request) };\n}\n\nconst betterAuthPluginSchema = z.enum([\n  \"2fa\",\n  \"admin\",\n  \"anonymous\",\n  \"api-key\",\n  \"audit-log\",\n  \"jwt\",\n  \"organization\",\n  \"passkey\",\n  \"phone-number\",\n  \"sso\",\n  \"username\",\n]);\n\nasync function authOperation(method: string, input: CommandInput): Promise<ToolingResult> {\n  const { addCompanionsToEntities, generateBetterAuthEntities } = await import(\"../auth\");\n  if (method === \"addCompanions\") return addCompanionsToEntities();\n  // plugins는 선택 옵션이므로 생략하면 core 엔티티만 생성합니다.\n  const plugins = z.array(betterAuthPluginSchema).parse(\n    (optionalText(input, \"plugins\") ?? \"\")\n      .split(\",\")\n      .map((plugin) => plugin.trim())\n      .filter(Boolean),\n  );\n  return generateBetterAuthEntities({ plugins });\n}\n\nasync function i18nOperation(method: string, input: CommandInput): Promise<ToolingResult> {\n  await ensureSonamu();\n  const { sonamuDictionary } = await import(\"../dict/sonamu-dictionary\");\n  if (method === \"list\") {\n    const dictionary = await sonamuDictionary.getDictionary();\n    const locale = text(input, \"locale\");\n    return locale === undefined\n      ? dictionary\n      : {\n          ...dictionary,\n          locales: [locale],\n          rows: dictionary.rows.map((row) => ({\n            key: row.key,\n            source: row.source,\n            [locale]: row[locale],\n          })),\n        };\n  }\n  if (method === \"check\") {\n    const dictionary = await sonamuDictionary.getDictionary();\n    return sonamuDictionary.checkUsage(dictionary.rows.map((row) => row.key));\n  }\n  if (method === \"export\" || method === \"import\") {\n    const file = requiredText(input, \"file\");\n    if (explicitlyDryRun(input)) return { operation: method, dryRun: true };\n    const { readFile, writeFile } = await import(\"node:fs/promises\");\n    const format = text(input, \"format\") === \"json\" ? \"json\" : \"workbook\";\n    if (method === \"export\" && format === \"workbook\") {\n      const { buffer } = await sonamuDictionary.exportToExcel();\n      await writeFile(file, buffer);\n      return { exported: 1 };\n    }\n    if (method === \"import\" && format === \"workbook\") {\n      return sonamuDictionary.importFromExcel(await readFile(file));\n    }\n\n    if (method === \"export\") {\n      const dictionary = await sonamuDictionary.getDictionary();\n      const locale = text(input, \"locale\");\n      const rows = dictionary.rows.map(\n        ({ key, source: _source, isFunction: _isFunction, ...values }) => ({\n          key,\n          values:\n            locale === undefined\n              ? values\n              : { [locale]: z.string().catch(\"\").parse(values[locale]) },\n        }),\n      );\n      await writeFile(file, JSON.stringify(rows, null, 2));\n      return { exported: rows.length };\n    }\n\n    const entries = parseJson(\n      (await readFile(file)).toString(\"utf8\"),\n      \"I18N_INVALID_JSON\",\n      i18nEntriesSchema,\n    );\n    const current = await sonamuDictionary.getDictionary();\n    const existingKeys = new Set(current.rows.map(({ key }) => key));\n    for (const entry of entries) {\n      if (existingKeys.has(entry.key)) {\n        await sonamuDictionary.updateEntry({\n          oldKey: entry.key,\n          newKey: entry.key,\n          source: \"project\",\n          values: entry.values,\n        });\n      } else {\n        await sonamuDictionary.createEntry(entry);\n      }\n    }\n    return { imported: entries.length };\n  }\n  const key = requiredText(input, \"key\");\n  if (method === \"create\") {\n    if (explicitlyDryRun(input)) return { operation: \"create\", input, dryRun: true };\n    return sonamuDictionary.createEntry({\n      key,\n      values: dictionaryValuesSchema.parse(input.values),\n    });\n  }\n  if (method === \"update\") {\n    if (explicitlyDryRun(input)) return { operation: \"update\", input, dryRun: true };\n    const explicitSource = text(input, \"source\");\n    // source를 생략하면 사전에 등록된 기존 source를 유지해 entity 항목이 project override로 덮이지 않게 합니다.\n    const resolvedSource =\n      explicitSource === undefined\n        ? ((await sonamuDictionary.getDictionary()).rows.find((row) => row.key === key)?.source ??\n          \"project\")\n        : explicitSource;\n    return sonamuDictionary.updateEntry({\n      oldKey: key,\n      newKey: text(input, \"newKey\") ?? key,\n      source: dictionarySourceSchema.parse(resolvedSource),\n      values: dictionaryValuesSchema.parse(input.values),\n    });\n  }\n  if (!mutationRequested(input)) return { key, operation: \"remove\", dryRun: true };\n  return sonamuDictionary.deleteEntry(key);\n}\n\nasync function taskOperation(method: string, input: CommandInput): Promise<ToolingResult> {\n  await ensureSonamu();\n  const { Sonamu } = await import(\"../api/sonamu\");\n  const workflows = Sonamu.workflows;\n  const backend = workflows.backend;\n  if (method === \"definitions\") return { definitions: workflows.workflowDefinitions };\n  if (method === \"runs\") return backend.listWorkflowRuns({ limit: 50 });\n  const workflowRunId = requiredText(input, \"runId\");\n  if (method === \"show\") return backend.getWorkflowRun({ workflowRunId });\n  if (method === \"watch\") {\n    const { isDeepStrictEqual } = await import(\"node:util\");\n    return (async function* watch() {\n      let previous: object | undefined;\n      while (true) {\n        const snapshot = await backend.getWorkflowRun({ workflowRunId });\n        if (snapshot === null) {\n          throw Object.assign(new Error(`Workflow run not found: ${workflowRunId}`), {\n            code: \"TASK_RUN_NOT_FOUND\",\n          });\n        }\n        const rawState = snapshot.status === \"succeeded\" ? \"completed\" : snapshot.status;\n        const state = rawState === \"canceled\" ? \"cancelled\" : rawState;\n        const current = { ...snapshot, state };\n        if (!isDeepStrictEqual(current, previous)) {\n          previous = structuredClone(current);\n          yield current;\n        }\n        if ([\"completed\", \"failed\", \"cancelled\"].includes(state)) return;\n        await new Promise((resolve) => setTimeout(resolve, 1_000));\n      }\n    })();\n  }\n  if (method === \"steps\") return backend.listStepAttempts({ workflowRunId, limit: 100 });\n  if (!mutationRequested(input)) return { operation: method, workflowRunId, dryRun: true };\n  if (method === \"pause\") return backend.pauseWorkflowRun({ workflowRunId });\n  if (method === \"resume\") return backend.resumeWorkflowRun({ workflowRunId });\n  return backend.cancelWorkflowRun({ workflowRunId });\n}\n\nasync function cddRootPath(): Promise<string> {\n  const [{ Sonamu }, path] = await Promise.all([import(\"../api/sonamu\"), import(\"node:path\")]);\n  return path.join(Sonamu.appRootPath, \"contract\");\n}\n\nconst practiceSequencePattern = /^p([0-9]+)-/;\n\n// 이름은 파일명과 스텁 본문의 문자열 리터럴에 그대로 들어가므로,\n// 경로 구분자/상위 경로 참조/따옴표/역슬래시를 원천 차단하는 문자만 허용합니다.\nconst practiceNamePattern = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;\n\nfunction invalidPracticeName(name: string): Error {\n  return Object.assign(\n    new Error(\n      `Invalid practice name: ${name}. Use letters, digits, \".\", \"-\", and \"_\" only, starting with a letter or digit.`,\n    ),\n    { code: \"INVALID_PRACTICE_NAME\", exitCode: 2 },\n  );\n}\n\nfunction invalidPracticeDirectory(directory: string): Error {\n  return Object.assign(new Error(`Practice directory escapes the API root: ${directory}`), {\n    code: \"INVALID_PRACTICE_PATH\",\n    exitCode: 2,\n  });\n}\n\n/**\n * `src/practices` 아래에 다음 시퀀스 번호를 가진 practice 스텁 파일을 만듭니다.\n *\n * 구 CLI(`stub practice`)의 파일명 규칙과 스텁 본문을 그대로 유지합니다.\n */\nasync function stubPracticeOperation(input: CommandInput): Promise<ToolingResult> {\n  const name = requiredText(input, \"name\");\n  if (!practiceNamePattern.test(name)) throw invalidPracticeName(name);\n  await ensureSonamu();\n  const [{ Sonamu }, { constants }, { mkdir, open, readdir, realpath }, path] = await Promise.all([\n    import(\"../api/sonamu\"),\n    import(\"node:fs\"),\n    import(\"node:fs/promises\"),\n    import(\"node:path\"),\n  ]);\n  const practiceDirectory = path.default.join(Sonamu.apiRootPath, \"src\", \"practices\");\n  await mkdir(practiceDirectory, { recursive: true });\n  // cdd-service와 같이 실제 경로까지 확인해, symlink로 연결된 practices 디렉터리가\n  // api root 밖을 가리키는 경우를 차단합니다.\n  const [canonicalApiRoot, canonicalDirectory] = await Promise.all([\n    realpath(Sonamu.apiRootPath),\n    realpath(practiceDirectory),\n  ]);\n  const directoryRelative = path.default.relative(canonicalApiRoot, canonicalDirectory);\n  if (directoryRelative.startsWith(\"..\") || path.default.isAbsolute(directoryRelative)) {\n    throw invalidPracticeDirectory(practiceDirectory);\n  }\n  const fileNames = await readdir(practiceDirectory);\n  const maxSequence = fileNames\n    .filter((fileName) => fileName.startsWith(\"p\") && fileName.endsWith(\".ts\"))\n    .reduce((largest, fileName) => {\n      const matched = practiceSequencePattern.exec(fileName);\n      return matched === null ? largest : Math.max(largest, Number.parseInt(matched[1], 10));\n    }, 0);\n\n  const fileName = `p${maxSequence + 1}-${name}.ts`;\n  // 이름 패턴이 경로 구분자를 차단하므로 파일명은 항상 이 디렉터리의 직계 자식입니다.\n  // 경로는 설정된 값 그대로 돌려주고, 탈출 여부는 위의 canonical 검사로 판단합니다.\n  const filePath = path.default.resolve(practiceDirectory, fileName);\n  const stubCode = [\n    `import { Sonamu } from \"sonamu\";`,\n    \"\",\n    `console.clear();`,\n    `console.log(\"${fileName}\");`,\n    \"\",\n    `Sonamu.runScript(async () => {`,\n    ` // TODO`,\n    `});`,\n    \"\",\n  ].join(\"\\n\");\n  let handle;\n  try {\n    // 기존 파일을 truncate하지 않도록 배타 생성하고, 최종 경로의 symlink는 따라가지 않습니다.\n    handle = await open(\n      filePath,\n      constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW,\n      0o666,\n    );\n    await handle.writeFile(stubCode, \"utf8\");\n  } catch (error) {\n    // SAFETY: node:fs open 실패의 code만 읽어 기존 파일/symlink 충돌을 정규화합니다.\n    const errorCode = (error as NodeJS.ErrnoException).code;\n    if (errorCode === \"EEXIST\" || errorCode === \"ELOOP\") {\n      throw Object.assign(new Error(`Practice file already exists: ${filePath}`), {\n        code: \"PRACTICE_FILE_EXISTS\",\n        exitCode: 2,\n        cause: error,\n      });\n    }\n    throw error;\n  } finally {\n    await handle?.close();\n  }\n  // 에디터 열기/클립보드 복사 같은 대화형 부수효과는 비대화형 실행을 깨뜨리므로 호출자에게 맡깁니다.\n  return { fileName, path: filePath };\n}\n\nasync function readCddTree(directory: string, root: string): Promise<object[]> {\n  const [{ readdir }, path] = await Promise.all([import(\"node:fs/promises\"), import(\"node:path\")]);\n  const entries = await readdir(directory, { withFileTypes: true });\n  const nodes = [];\n  for (const entry of entries) {\n    if (entry.name === \"rules\") continue;\n    const absolutePath = path.join(directory, entry.name);\n    const relativePath = path.relative(root, absolutePath);\n    if (entry.isDirectory()) {\n      const children = await readCddTree(absolutePath, root);\n      if (children.length > 0) {\n        nodes.push({ name: entry.name, path: relativePath, type: \"directory\", children });\n      }\n    } else if (entry.isFile() && entry.name.endsWith(\".contract.md\")) {\n      nodes.push({ name: entry.name, path: relativePath, type: \"file\", fileType: \"contract\" });\n    }\n  }\n  return nodes;\n}\n\nasync function cddOperation(method: string, input: CommandInput): Promise<ToolingResult> {\n  await ensureSonamu();\n  const [{ access }, { createDefaultCddToolingAdapter }] = await Promise.all([\n    import(\"node:fs/promises\"),\n    import(\"./cdd-service\"),\n  ]);\n  const adapter = createDefaultCddToolingAdapter({ contractRoot: await cddRootPath() });\n  if (method === \"tree\") {\n    const root = await cddRootPath();\n    try {\n      await access(root);\n    } catch {\n      return { exists: false, tree: [] };\n    }\n    return { exists: true, tree: await readCddTree(root, root) };\n  }\n  if (method === \"read\") {\n    const relativePath = requiredText(input, \"path\");\n    return adapter.read({ path: relativePath });\n  }\n  if (method === \"rules\") return adapter.rules();\n  if (method === \"showRule\") {\n    const ruleId = requiredText(input, \"ruleId\");\n    return adapter.showRule({ ruleId });\n  }\n  if (method === \"addRule\") {\n    const ruleKey = requiredText(input, \"ruleKey\");\n    const id = requiredText(input, \"id\");\n    const when = requiredText(input, \"when\");\n    const ruleText = text(input, \"instruction\") ?? requiredText(input, \"text\");\n    return adapter.addRule({\n      ruleKey,\n      id,\n      when,\n      text: ruleText,\n      examples: strings(input, \"examples\"),\n      dryRun: explicitlyDryRun(input),\n    });\n  }\n  if (explicitlyDryRun(input)) {\n    return { operation: \"addAcceptanceCriterion\", input, dryRun: true };\n  }\n  const document = requiredText(input, \"document\");\n  const criterion = requiredText(input, \"text\");\n  return adapter.addAcceptanceCriterion({ document, text: criterion, dryRun: false });\n}\n\nasync function invokeDefault(\n  group: string,\n  method: string,\n  input: CommandInput,\n): Promise<ToolingResult> {\n  if (group === \"core\") return syncOperation(input);\n  if (group === \"entity\") return entityOperation(method, input);\n  if (group === \"scaffold\") return scaffoldOperation(method, input);\n  if (group === \"migration\") return migrationOperation(method, input);\n  if (group === \"fixture\") return fixtureOperation(method, input);\n  if (group === \"build\") return buildOperation(method);\n  if (group === \"test\") return testOperation(method, input);\n  if (group === \"auth\") return authOperation(method, input);\n  if (group === \"i18n\") return i18nOperation(method, input);\n  if (group === \"task\") return taskOperation(method, input);\n  if (group === \"stub\") return stubPracticeOperation(input);\n  return cddOperation(method, input);\n}\n\n// 기본 registry는 호출 시점까지 Sonamu 초기화와 외부 작업을 모두 미룹니다.\nexport const tooling: CliToolingOperations = Object.fromEntries(\n  Object.entries(REQUIRED_METHODS).map(([group, methods]) => [\n    group,\n    Object.fromEntries(\n      methods.map((method) => [\n        method,\n        (input: CommandInput) => invokeDefault(group, method, input),\n      ]),\n    ),\n  ]),\n);\n\nObject.defineProperty(tooling.migration, \"apply\", {\n  enumerable: false,\n  value: (input: CommandInput) => invokeDefault(\"migration\", \"apply\", input),\n});\n"],"mappings":"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"}