sonamu 0.8.26 → 0.9.0

package/dist/bin/cli.js

@@ -1,1211 +1,1074 @@
+import { exists, init_fs_utils } from "../utils/fs-utils.js";
+import { findApiRootPath, findAppRootPath, init_utils } from "../utils/utils.js";
+import { Sonamu, init_sonamu } from "../api/sonamu.js";
+import { EntityManager, init_entity_manager } from "../entity/entity-manager.js";
+import { SUPPORTED_PLUGIN_IDS, isValidPluginId } from "../auth/plugins/entity-definitions/index.js";
+import { addCompanionsToEntities, generateBetterAuthEntities } from "../auth/auth-generator.js";
+import { API_ARTIFACTS, WEB_ARTIFACTS } from "./build-config.js";
+import { Migrator, init_migrator } from "../migration/migrator.js";
+import { FixtureManager, init_fixture_manager } from "../testing/fixture-manager.js";
+import { execWithLinePrefix, init_console_util, printBuildSummary, printTaskFailed, printTaskHeader, printTaskStart, printTaskSuccess } from "../utils/console-util.js";
+import { fixtureExploreCommand, fixtureFetchCommand, fixtureGenCommand } from "./fixture.js";
+import { testCommand } from "./test-command.js";
+import assert from "assert";
+import knex from "knex";
+import { cp, mkdir, readFile, readdir, rm, symlink, writeFile } from "fs/promises";
+import path from "path";
 import chalk from "chalk";
+import os from "os";
 import dotenv from "dotenv";
-dotenv.config();
-import assert from "assert";
 import { execSync, spawn } from "child_process";
-import { cp, mkdir, readdir, readFile, rm, symlink, writeFile } from "node:fs/promises";
-import knex from "knex";
 import { createRequire } from "module";
-import os from "os";
-import path from "path";
 import process from "process";
 import { tsicli } from "tsicli";
-import { Sonamu } from "../api/index.js";
-import { addCompanionsToEntities, generateBetterAuthEntities } from "../auth/auth-generator.js";
-import { isValidPluginId, SUPPORTED_PLUGIN_IDS } from "../auth/plugins/entity-definitions/index.js";
-import { EntityManager } from "../entity/entity-manager.js";
-import { Migrator } from "../migration/migrator.js";
-import { FixtureManager } from "../testing/fixture-manager.js";
-import { execWithLinePrefix, printBuildSummary, printTaskFailed, printTaskHeader, printTaskStart, printTaskSuccess } from "../utils/console-util.js";
-import { exists } from "../utils/fs-utils.js";
-import { findApiRootPath, findAppRootPath } from "../utils/utils.js";
-import { API_ARTIFACTS, WEB_ARTIFACTS } from "./build-config.js";
-import { fixtureExploreCommand, fixtureFetchCommand, fixtureGenCommand } from "./fixture.js";
-import { testCommand } from "./test-command.js";
+
+//#region src/bin/cli.ts
+init_sonamu();
+init_entity_manager();
+init_migrator();
+init_fixture_manager();
+init_console_util();
+init_fs_utils();
+init_utils();
+dotenv.config();
 let migrator;
 /**
- * CLI 옵션을 파싱하는 헬퍼 함수
- */ function parseCliOptions(argv = process.argv) {
-    const flags = new Set();
-    const options = {};
-    for(let i = 0; i < argv.length; i++){
-        const arg = argv[i];
-        if (!arg.startsWith("--")) continue;
-        // --option=value 형식
-        if (arg.includes("=")) {
-            const [key, value] = arg.slice(2).split("=");
-            options[key] = value;
-            continue;
-        }
-        // --option value 형식인지 확인
-        const nextArg = argv[i + 1];
-        if (nextArg && !nextArg.startsWith("--") && !nextArg.startsWith("-")) {
-            options[arg.slice(2)] = nextArg;
-            i++; // 다음 arg는 값이므로 스킵
-        } else {
-            // --flag 형식
-            flags.add(arg.slice(2));
-        }
-    }
-    return {
-        flags,
-        options
-    };
+* CLI 옵션을 파싱하는 헬퍼 함수
+*/
+function parseCliOptions(argv = process.argv) {
+	const flags = new Set();
+	const options = {};
+	for (let i = 0; i < argv.length; i++) {
+		const arg = argv[i];
+		if (!arg.startsWith("--")) continue;
+		if (arg.includes("=")) {
+			const [key, value] = arg.slice(2).split("=");
+			options[key] = value;
+			continue;
+		}
+		const nextArg = argv[i + 1];
+		if (nextArg && !nextArg.startsWith("--") && !nextArg.startsWith("-")) {
+			options[arg.slice(2)] = nextArg;
+			i++;
+		} else {
+			flags.add(arg.slice(2));
+		}
+	}
+	return {
+		flags,
+		options
+	};
 }
 async function bootstrap() {
-    const notToInit = [
-        "dev",
-        "build",
-        "start",
-        "skills",
-        "test"
-    ].includes(process.argv[2] ?? "");
-    if (!notToInit) {
-        await Sonamu.init(false, false);
-    }
-    try {
-        // tsicli는 정확한 명령어 매칭만 지원하므로, --로 시작하는 옵션과 그 값을 필터링합니다.
-        // 옵션 파싱은 각 runner 함수에서 원본 process.argv를 사용하여 수행합니다.
-        // "--"(bare double dash)는 passthrough 구분자이므로, 그 뒤의 모든 인자도 제외합니다.
-        const filteredArgv = [];
-        let skipNext = false;
-        let afterDoubleDash = false;
-        for(let i = 0; i < process.argv.length; i++){
-            const arg = process.argv[i];
-            if (arg === "--") {
-                afterDoubleDash = true;
-                continue;
-            }
-            if (afterDoubleDash) continue;
-            if (skipNext) {
-                skipNext = false;
-                continue;
-            }
-            if (arg.startsWith("--")) {
-                // --option=value 형식은 이 arg만 스킵
-                if (arg.includes("=")) {
-                    continue;
-                }
-                // --option value 형식인지 확인: 다음 arg가 --로 시작하지 않으면 값이 있는 것
-                const nextArg = process.argv[i + 1];
-                if (nextArg && !nextArg.startsWith("--") && !nextArg.startsWith("-")) {
-                    skipNext = true;
-                }
-                continue;
-            }
-            filteredArgv.push(arg);
-        }
-        // build/dev 명령어가 서브커맨드 없이 호출될 때 "all"을 기본값으로 추가합니다.
-        // 예: `sonamu build` → `sonamu build all`, `sonamu dev` → `sonamu dev all`
-        const cmd = filteredArgv[2];
-        if ((cmd === "build" || cmd === "dev") && filteredArgv.length === 3) {
-            filteredArgv.push("all");
-        }
-        // test 커맨드는 가변 인자(파일명, --pattern 등)를 받으므로 tsicli를 우회합니다.
-        if (cmd === "test") {
-            return testCommand();
-        }
-        await tsicli(filteredArgv, {
-            types: {
-                "#entityId": {
-                    type: "autocomplete",
-                    name: "#entityId",
-                    message: "Please input #entityId",
-                    choices: EntityManager.getAllParentIds().map((entityId)=>({
-                            title: entityId,
-                            value: entityId
-                        }))
-                },
-                "#recordIds": "number[]",
-                "#name": "string",
-                "#targets": {
-                    type: "multiselect",
-                    name: "#targets",
-                    message: "Please input #targets",
-                    choices: [
-                        {
-                            title: "Development",
-                            value: "development_master"
-                        },
-                        {
-                            title: "Production",
-                            value: "production_master"
-                        },
-                        {
-                            title: "Fixture",
-                            value: "fixture"
-                        },
-                        {
-                            title: "Test",
-                            value: "test"
-                        }
-                    ]
-                }
-            },
-            args: [
-                [
-                    "fixture",
-                    "init"
-                ],
-                [
-                    "fixture",
-                    "import",
-                    "#entityId",
-                    "#recordIds"
-                ],
-                [
-                    "fixture",
-                    "sync"
-                ],
-                [
-                    "fixture",
-                    "gen"
-                ],
-                [
-                    "fixture",
-                    "fetch"
-                ],
-                [
-                    "fixture",
-                    "explore"
-                ],
-                [
-                    "migrate",
-                    "run"
-                ],
-                [
-                    "migrate",
-                    "apply",
-                    "#targets"
-                ],
-                [
-                    "migrate",
-                    "generate"
-                ],
-                [
-                    "migrate",
-                    "status"
-                ],
-                [
-                    "stub",
-                    "practice",
-                    "#name"
-                ],
-                [
-                    "stub",
-                    "entity",
-                    "#name"
-                ],
-                [
-                    "scaffold",
-                    "model",
-                    "#entityId"
-                ],
-                [
-                    "scaffold",
-                    "model_test",
-                    "#entityId"
-                ],
-                [
-                    "scaffold",
-                    "view_list",
-                    "#entityId"
-                ],
-                [
-                    "scaffold",
-                    "view_form",
-                    "#entityId"
-                ],
-                [
-                    "cone",
-                    "gen",
-                    "#entityId"
-                ],
-                [
-                    "sync"
-                ],
-                [
-                    "build",
-                    "all"
-                ],
-                [
-                    "build",
-                    "api"
-                ],
-                [
-                    "build",
-                    "web"
-                ],
-                [
-                    "dev",
-                    "all"
-                ],
-                [
-                    "dev",
-                    "api"
-                ],
-                [
-                    "dev",
-                    "web"
-                ],
-                [
-                    "start"
-                ],
-                [
-                    "skills",
-                    "sync"
-                ],
-                [
-                    "skills",
-                    "create",
-                    "#name"
-                ],
-                [
-                    "test"
-                ],
-                [
-                    "auth",
-                    "generate"
-                ],
-                [
-                    "auth",
-                    "add-companions"
-                ]
-            ],
-            runners: {
-                migrate_status,
-                migrate_run,
-                migrate_apply,
-                migrate_generate,
-                fixture_init,
-                fixture_import,
-                fixture_sync,
-                fixture_gen,
-                fixture_fetch,
-                fixture_explore,
-                stub_practice,
-                stub_entity,
-                scaffold_model,
-                scaffold_model_test,
-                // scaffold_view_list,
-                // scaffold_view_form,
-                cone_gen,
-                sync,
-                build_all,
-                build_api,
-                build_web,
-                dev_all,
-                dev_api,
-                dev_web,
-                start,
-                skills_sync,
-                skills_create,
-                test: testCommand,
-                auth_generate,
-                "auth_add-companions": auth_add_companions
-            }
-        });
-    } finally{
-        await Sonamu.destroy();
-    }
+	const notToInit = [
+		"dev",
+		"build",
+		"start",
+		"skills",
+		"test"
+	].includes(process.argv[2] ?? "");
+	if (!notToInit) {
+		await Sonamu.init(false, false);
+	}
+	try {
+		const filteredArgv = [];
+		let skipNext = false;
+		let afterDoubleDash = false;
+		for (let i = 0; i < process.argv.length; i++) {
+			const arg = process.argv[i];
+			if (arg === "--") {
+				afterDoubleDash = true;
+				continue;
+			}
+			if (afterDoubleDash) continue;
+			if (skipNext) {
+				skipNext = false;
+				continue;
+			}
+			if (arg.startsWith("--")) {
+				if (arg.includes("=")) {
+					continue;
+				}
+				const nextArg = process.argv[i + 1];
+				if (nextArg && !nextArg.startsWith("--") && !nextArg.startsWith("-")) {
+					skipNext = true;
+				}
+				continue;
+			}
+			filteredArgv.push(arg);
+		}
+		const cmd = filteredArgv[2];
+		if ((cmd === "build" || cmd === "dev") && filteredArgv.length === 3) {
+			filteredArgv.push("all");
+		}
+		if (cmd === "test") {
+			return testCommand();
+		}
+		await tsicli(filteredArgv, {
+			types: {
+				"#entityId": {
+					type: "autocomplete",
+					name: "#entityId",
+					message: "Please input #entityId",
+					choices: EntityManager.getAllParentIds().map((entityId) => ({
+						title: entityId,
+						value: entityId
+					}))
+				},
+				"#recordIds": "number[]",
+				"#name": "string",
+				"#targets": {
+					type: "multiselect",
+					name: "#targets",
+					message: "Please input #targets",
+					choices: [
+						{
+							title: "Development",
+							value: "development_master"
+						},
+						{
+							title: "Production",
+							value: "production_master"
+						},
+						{
+							title: "Fixture",
+							value: "fixture"
+						},
+						{
+							title: "Test",
+							value: "test"
+						}
+					]
+				}
+			},
+			args: [
+				["fixture", "init"],
+				[
+					"fixture",
+					"import",
+					"#entityId",
+					"#recordIds"
+				],
+				["fixture", "sync"],
+				["fixture", "gen"],
+				["fixture", "fetch"],
+				["fixture", "explore"],
+				["migrate", "run"],
+				[
+					"migrate",
+					"apply",
+					"#targets"
+				],
+				["migrate", "generate"],
+				["migrate", "status"],
+				[
+					"stub",
+					"practice",
+					"#name"
+				],
+				[
+					"stub",
+					"entity",
+					"#name"
+				],
+				[
+					"scaffold",
+					"model",
+					"#entityId"
+				],
+				[
+					"scaffold",
+					"model_test",
+					"#entityId"
+				],
+				[
+					"scaffold",
+					"view_list",
+					"#entityId"
+				],
+				[
+					"scaffold",
+					"view_form",
+					"#entityId"
+				],
+				[
+					"cone",
+					"gen",
+					"#entityId"
+				],
+				["sync"],
+				["build", "all"],
+				["build", "api"],
+				["build", "web"],
+				["dev", "all"],
+				["dev", "api"],
+				["dev", "web"],
+				["start"],
+				["skills", "sync"],
+				[
+					"skills",
+					"create",
+					"#name"
+				],
+				["test"],
+				["auth", "generate"],
+				["auth", "add-companions"]
+			],
+			runners: {
+				migrate_status,
+				migrate_run,
+				migrate_apply,
+				migrate_generate,
+				fixture_init,
+				fixture_import,
+				fixture_sync,
+				fixture_gen,
+				fixture_fetch,
+				fixture_explore,
+				stub_practice,
+				stub_entity,
+				scaffold_model,
+				scaffold_model_test,
+				cone_gen,
+				sync,
+				build_all,
+				build_api,
+				build_web,
+				dev_all,
+				dev_api,
+				dev_web,
+				start,
+				skills_sync,
+				skills_create,
+				test: testCommand,
+				auth_generate,
+				"auth_add-companions": auth_add_companions
+			}
+		});
+	} finally {
+		await Sonamu.destroy();
+	}
 }
-bootstrap().finally(async ()=>{
-    await FixtureManager.destroy();
+bootstrap().finally(async () => {
+	await FixtureManager.destroy();
 });
 /**
- * pnpm sync 하면 실행되는 함수입니다.
- * 프로젝트를 싱크합니다.
- */ async function sync() {
-    await Sonamu.syncer.sync();
+* pnpm sync 하면 실행되는 함수입니다.
+* 프로젝트를 싱크합니다.
+*/
+async function sync() {
+	await Sonamu.syncer.sync();
 }
 /**
- * API 개발 서버를 실행하는 공통 로직입니다.
- * dev_all과 dev_api에서 공유합니다.
- *
- * TypeScript를 바로 실행할 수 있도록 @sonamu-kit/ts-loader를,
- * HMR을 지원하기 위해 @sonamu-kit/hmr-hook을 import하며,
- * 소스맵 지원을 위해 --enable-source-maps 플래그를 포함하여 실행합니다.
- *
- * 이때 @sonamu-kit/ts-loader와 @sonamu-kit/hmr-hook는 sonamu가 자체적으로 가지고 있는 dependency입니다.
- * 또한 실행에 사용하는 @sonamu-kit/hmr-runner도 마찬가지로 sonamu가 자체적으로 가지고 있는 dependency입니다.
- * 따라서 사용자 프로젝트에서는 이 세 패키지를 직접 설치할 필요가 없습니다.
- */ function spawnApiDevServer(options) {
-    const apiRoot = findApiRootPath();
-    const entryPoint = "src/index.ts";
-    // 이 sonamu 패키지가 dependencies로 가지고 있는 @sonamu-kit/hmr-runner의 bin/run.js를 사용합니다.
-    // 이 경로(/bin/run.js)는 @sonamu-kit/hmr-runner의 package.json의 bin 필드에 명시되어 있는 그것과 같습니다.
-    const hotRunnerBinPath = createRequire(import.meta.url).resolve("@sonamu-kit/hmr-runner/bin/run.js");
-    const serverProcess = spawn(process.execPath, [
-        hotRunnerBinPath,
-        "--clear-screen=false",
-        "--node-args=--import=sonamu/ts-loader-register",
-        "--node-args=--import=sonamu/hmr-hook-register",
-        "--node-args=--enable-source-maps",
-        "--on-key=r:restart:Restart server",
-        "--on-key=c:clear:Clear screen",
-        `--on-key=f:shell(rm ${path.join(apiRoot, "sonamu.lock")}):restart:Force restart`,
-        "--on-key=enter:shell(echo hi):Key binding test",
-        "--on-key=ctrl+f ctrl+f:shell(git pull && pnpm install && pnpm --filter sonamu build && echo 'Sonamu is now up-to-date!'):restart:Pull & install & build & restart",
-        entryPoint
-    ], {
-        cwd: apiRoot,
-        stdio: "inherit",
-        env: {
-            ...process.env,
-            NODE_ENV: "development",
-            HOT: "yes",
-            API_ROOT_PATH: apiRoot,
-            ...options?.extraEnv
-        }
-    });
-    // 종료 처리
-    const cleanup = ()=>{
-        console.log(chalk.yellow("\n\n👋 Shutting down..."));
-        serverProcess.kill("SIGTERM");
-        process.exit(0);
-    };
-    process.on("SIGINT", cleanup);
-    process.on("SIGTERM", cleanup);
-    serverProcess.on("exit", (code)=>{
-        if (code !== 0) {
-            console.error(chalk.red(`Server exited with code ${code}`));
-            process.exit(code || 1);
-        }
-    });
+* API 개발 서버를 실행하는 공통 로직입니다.
+* dev_all과 dev_api에서 공유합니다.
+*
+* TypeScript를 바로 실행할 수 있도록 @sonamu-kit/ts-loader를,
+* HMR을 지원하기 위해 @sonamu-kit/hmr-hook을 import하며,
+* 소스맵 지원을 위해 --enable-source-maps 플래그를 포함하여 실행합니다.
+*
+* 이때 @sonamu-kit/ts-loader와 @sonamu-kit/hmr-hook는 sonamu가 자체적으로 가지고 있는 dependency입니다.
+* 또한 실행에 사용하는 @sonamu-kit/hmr-runner도 마찬가지로 sonamu가 자체적으로 가지고 있는 dependency입니다.
+* 따라서 사용자 프로젝트에서는 이 세 패키지를 직접 설치할 필요가 없습니다.
+*/
+function spawnApiDevServer(options) {
+	const apiRoot = findApiRootPath();
+	const entryPoint = "src/index.ts";
+	const hotRunnerBinPath = createRequire(import.meta.url).resolve("@sonamu-kit/hmr-runner/bin/run.js");
+	const serverProcess = spawn(process.execPath, [
+		hotRunnerBinPath,
+		"--clear-screen=false",
+		"--node-args=--import=sonamu/ts-loader-register",
+		"--node-args=--import=sonamu/hmr-hook-register",
+		"--node-args=--enable-source-maps",
+		"--on-key=r:restart:Restart server",
+		"--on-key=c:clear:Clear screen",
+		`--on-key=f:shell(rm ${path.join(apiRoot, "sonamu.lock")}):restart:Force restart`,
+		"--on-key=enter:shell(echo hi):Key binding test",
+		"--on-key=ctrl+f ctrl+f:shell(git pull && pnpm install && pnpm --filter sonamu build && echo 'Sonamu is now up-to-date!'):restart:Pull & install & build & restart",
+		entryPoint
+	], {
+		cwd: apiRoot,
+		stdio: "inherit",
+		env: {
+			...process.env,
+			NODE_ENV: "development",
+			HOT: "yes",
+			API_ROOT_PATH: apiRoot,
+			...options?.extraEnv
+		}
+	});
+	const cleanup = () => {
+		console.log(chalk.yellow("\n\n👋 Shutting down..."));
+		serverProcess.kill("SIGTERM");
+		process.exit(0);
+	};
+	process.on("SIGINT", cleanup);
+	process.on("SIGTERM", cleanup);
+	serverProcess.on("exit", (code) => {
+		if (code !== 0) {
+			console.error(chalk.red(`Server exited with code ${code}`));
+			process.exit(code || 1);
+		}
+	});
 }
 /**
- * pnpm dev / pnpm dev all 하면 실행되는 함수입니다.
- * 프로젝트에 대해 HMR 지원하는 개발 서버를 띄워줍니다.
- *
- * Sonamu.init 없이 호출될 것을 상정하여 구현되었습니다.
- */ function dev_all() {
-    console.log(chalk.yellow.bold("Starting Sonamu dev server...\n"));
-    spawnApiDevServer();
+* pnpm dev / pnpm dev all 하면 실행되는 함수입니다.
+* 프로젝트에 대해 HMR 지원하는 개발 서버를 띄워줍니다.
+*
+* Sonamu.init 없이 호출될 것을 상정하여 구현되었습니다.
+*/
+function dev_all() {
+	console.log(chalk.yellow.bold("Starting Sonamu dev server...\n"));
+	spawnApiDevServer();
 }
 /**
- * pnpm dev api 하면 실행되는 함수입니다.
- * API 전용 개발 서버를 띄웁니다.
- * dev_all과 거의 동일하되, 통합 웹 서버를 비활성화합니다.
- *
- * Sonamu.init 없이 호출될 것을 상정하여 구현되었습니다.
- */ function dev_api() {
-    console.log(chalk.yellow.bold("Starting Sonamu API-only dev server...\n"));
-    spawnApiDevServer({
-        extraEnv: {
-            SONAMU_DISABLE_INTEGRATED_WEB: "yes"
-        }
-    });
+* pnpm dev api 하면 실행되는 함수입니다.
+* API 전용 개발 서버를 띄웁니다.
+* dev_all과 거의 동일하되, 통합 웹 서버를 비활성화합니다.
+*
+* Sonamu.init 없이 호출될 것을 상정하여 구현되었습니다.
+*/
+function dev_api() {
+	console.log(chalk.yellow.bold("Starting Sonamu API-only dev server...\n"));
+	spawnApiDevServer({ extraEnv: { SONAMU_DISABLE_INTEGRATED_WEB: "yes" } });
 }
 /**
- * pnpm dev web 하면 실행되는 함수입니다.
- * Vite 개발 서버를 단독으로 실행합니다.
- * -- 뒤의 인자는 Vite에 그대로 전달됩니다.
- *
- * Sonamu.init 없이 호출될 것을 상정하여 구현되었습니다.
- */ async function dev_web() {
-    const appRoot = findAppRootPath();
-    const webPath = path.join(appRoot, "web");
-    if (!await exists(webPath)) {
-        console.error(`web 디렉토리를 찾을 수 없습니다: ${webPath}`);
-        process.exit(1);
-    }
-    // -- 뒤의 인자 추출
-    const doubleDashIndex = process.argv.indexOf("--");
-    const passthroughArgs = doubleDashIndex !== -1 ? process.argv.slice(doubleDashIndex + 1) : [];
-    const viteArgs = [
-        "exec",
-        "vite",
-        ...passthroughArgs
-    ];
-    console.log(chalk.yellow.bold("Starting Vite dev server...\n"));
-    const viteProcess = spawn("pnpm", viteArgs, {
-        cwd: webPath,
-        stdio: "inherit"
-    });
-    viteProcess.on("exit", (code)=>{
-        process.exit(code ?? 0);
-    });
-    // SIGINT/SIGTERM 시 Vite 프로세스를 gracefully 종료합니다.
-    for (const signal of [
-        "SIGINT",
-        "SIGTERM"
-    ]){
-        process.on(signal, ()=>{
-            viteProcess.kill(signal);
-        });
-    }
+* pnpm dev web 하면 실행되는 함수입니다.
+* Vite 개발 서버를 단독으로 실행합니다.
+* -- 뒤의 인자는 Vite에 그대로 전달됩니다.
+*
+* Sonamu.init 없이 호출될 것을 상정하여 구현되었습니다.
+*/
+async function dev_web() {
+	const appRoot = findAppRootPath();
+	const webPath = path.join(appRoot, "web");
+	if (!await exists(webPath)) {
+		console.error(`web 디렉토리를 찾을 수 없습니다: ${webPath}`);
+		process.exit(1);
+	}
+	const doubleDashIndex = process.argv.indexOf("--");
+	const passthroughArgs = doubleDashIndex !== -1 ? process.argv.slice(doubleDashIndex + 1) : [];
+	const viteArgs = [
+		"exec",
+		"vite",
+		...passthroughArgs
+	];
+	console.log(chalk.yellow.bold("Starting Vite dev server...\n"));
+	const viteProcess = spawn("pnpm", viteArgs, {
+		cwd: webPath,
+		stdio: "inherit"
+	});
+	viteProcess.on("exit", (code) => {
+		process.exit(code ?? 0);
+	});
+	for (const signal of ["SIGINT", "SIGTERM"]) {
+		process.on(signal, () => {
+			viteProcess.kill(signal);
+		});
+	}
 }
 /**
- * SWC 설정 파일 경로를 결정합니다. API 빌드(SWC)에서만 사용됩니다.
- * 프로젝트 루트에 .swcrc가 있으면 그것을, 없으면 sonamu 기본 설정을 사용합니다.
- */ async function resolveSwcConfigPath() {
-    let swcFilePath = ".swcrc";
-    try {
-        if (await exists(swcFilePath)) {
-            console.log(chalk.dim("Using .swcrc from project root..."));
-        } else {
-            console.log(chalk.dim("Using default .swcrc from sonamu package..."));
-            swcFilePath = path.join(import.meta.dirname, "..", "..", ".swcrc.project-default");
-        }
-    } catch (error) {
-        console.error(chalk.red("Setting up swc config file failed."), error);
-        process.exit(1);
-    }
-    return swcFilePath;
+* API 빌드 설정 파일 경로를 결정합니다.
+* 프로젝트 루트에 `tsdown.config.ts`가 있으면 그것을, 없으면 sonamu 기본 설정을 사용합니다.
+*/
+async function resolveApiBuildConfigPath() {
+	const localConfigPath = path.join(process.cwd(), "tsdown.config.ts");
+	try {
+		if (await exists(localConfigPath)) {
+			console.log(chalk.dim("Using tsdown.config.ts from project root..."));
+			return localConfigPath;
+		}
+		console.log(chalk.dim("Using default tsdown API config from sonamu package..."));
+		return path.join(import.meta.dirname, "..", "..", "tsdown.api.config.ts");
+	} catch (error) {
+		console.error(chalk.red("Setting up API build config failed."), error);
+		process.exit(1);
+	}
 }
 /**
- * sonamu build / sonamu build all 하면 실행되는 함수입니다.
- * build_api + build_web의 합성입니다. Web 디렉토리가 없으면 Web 빌드를 스킵합니다.
- */ async function build_all() {
-    await build_api();
-    await build_web({
-        skipIfMissing: true
-    });
+* sonamu build / sonamu build all 하면 실행되는 함수입니다.
+* build_api + build_web의 합성입니다. Web 디렉토리가 없으면 Web 빌드를 스킵합니다.
+*/
+async function build_all() {
+	await build_api();
+	await build_web({ skipIfMissing: true });
 }
 /**
- * pnpm build api 하면 실행되는 함수입니다.
- * API 프로젝트만 빌드합니다.
- *
- * Sonamu.init 없이 호출될 것을 상정하여 구현되었습니다.
- */ async function build_api() {
-    const appRoot = findAppRootPath();
-    const swcFilePath = await resolveSwcConfigPath();
-    const apiStartedAt = Date.now();
-    try {
-        for (const artifact of API_ARTIFACTS){
-            const cwd = path.join(appRoot, artifact.projectPath);
-            printTaskHeader(artifact.name, artifact.description, cwd);
-            await runBuildSteps(artifact, {
-                cwd,
-                buildCommandArgs: {
-                    configFilePath: swcFilePath
-                }
-            });
-        }
-        printBuildSummary("API", true, Date.now() - apiStartedAt);
-    } catch (e) {
-        printBuildSummary("API", false, Date.now() - apiStartedAt);
-        console.error(e);
-        process.exit(1);
-    }
+* pnpm build api 하면 실행되는 함수입니다.
+* API 프로젝트만 빌드합니다.
+*
+* Sonamu.init 없이 호출될 것을 상정하여 구현되었습니다.
+*/
+async function build_api() {
+	const appRoot = findAppRootPath();
+	const configFilePath = await resolveApiBuildConfigPath();
+	const apiStartedAt = Date.now();
+	try {
+		for (const artifact of API_ARTIFACTS) {
+			const cwd = path.join(appRoot, artifact.projectPath);
+			printTaskHeader(artifact.name, artifact.description, cwd);
+			await runBuildSteps(artifact, {
+				cwd,
+				buildCommandArgs: { configFilePath }
+			});
+		}
+		printBuildSummary("API", true, Date.now() - apiStartedAt);
+	} catch (e) {
+		printBuildSummary("API", false, Date.now() - apiStartedAt);
+		console.error(e);
+		process.exit(1);
+	}
 }
 /**
- * pnpm build web 하면 실행되는 함수입니다.
- * Web 프로젝트만 빌드합니다.
- *
- * Sonamu.init 없이 호출될 것을 상정하여 구현되었습니다.
- */ async function build_web({ skipIfMissing = false } = {}) {
-    const appRoot = findAppRootPath();
-    const webPath = path.join(appRoot, "web");
-    if (!await exists(webPath)) {
-        if (skipIfMissing) {
-            console.log(chalk.gray("Web 디렉토리가 없으므로 Web 빌드를 건너뜁니다."));
-            return;
-        }
-        console.error(`web 디렉토리를 찾을 수 없습니다: ${webPath}`);
-        process.exit(1);
-    }
-    const webStartedAt = Date.now();
-    try {
-        for (const artifact of WEB_ARTIFACTS){
-            const cwd = path.join(appRoot, artifact.projectPath);
-            printTaskHeader(artifact.name, artifact.description, cwd);
-            await runBuildSteps(artifact, {
-                cwd,
-                buildCommandArgs: {}
-            });
-        }
-        printBuildSummary("Web", true, Date.now() - webStartedAt);
-    } catch (e) {
-        printBuildSummary("Web", false, Date.now() - webStartedAt);
-        console.error(e);
-        process.exit(1);
-    }
+* pnpm build web 하면 실행되는 함수입니다.
+* Web 프로젝트만 빌드합니다.
+*
+* Sonamu.init 없이 호출될 것을 상정하여 구현되었습니다.
+*/
+async function build_web({ skipIfMissing = false } = {}) {
+	const appRoot = findAppRootPath();
+	const webPath = path.join(appRoot, "web");
+	if (!await exists(webPath)) {
+		if (skipIfMissing) {
+			console.log(chalk.gray("Web 디렉토리가 없으므로 Web 빌드를 건너뜁니다."));
+			return;
+		}
+		console.error(`web 디렉토리를 찾을 수 없습니다: ${webPath}`);
+		process.exit(1);
+	}
+	const webStartedAt = Date.now();
+	try {
+		for (const artifact of WEB_ARTIFACTS) {
+			const cwd = path.join(appRoot, artifact.projectPath);
+			printTaskHeader(artifact.name, artifact.description, cwd);
+			await runBuildSteps(artifact, {
+				cwd,
+				buildCommandArgs: {}
+			});
+		}
+		printBuildSummary("Web", true, Date.now() - webStartedAt);
+	} catch (e) {
+		printBuildSummary("Web", false, Date.now() - webStartedAt);
+		console.error(e);
+		process.exit(1);
+	}
 }
 /**
- * pre-build, build, post-build 단계를 순차적으로 실행합니다.
- */ async function runBuildSteps(artifact, options) {
-    const steps = [
-        {
-            name: "pre-build",
-            cmd: artifact.preBuildCommand?.()
-        },
-        {
-            name: "build",
-            cmd: artifact.buildCommand(options.buildCommandArgs)
-        },
-        {
-            name: "post-build",
-            cmd: artifact.postBuildCommand?.()
-        }
-    ].filter((step)=>step.cmd);
-    for(let i = 0; i < steps.length; i++){
-        const step = steps[i];
-        const isLast = i === steps.length - 1;
-        try {
-            assert(step.cmd);
-            printTaskStart(step.name, step.cmd, isLast);
-            await execWithLinePrefix(step.cmd, {
-                cwd: options.cwd
-            });
-            printTaskSuccess(step.name, isLast);
-        } catch (e) {
-            printTaskFailed(step.name, isLast);
-            throw new Error(`${step.name} failed`, {
-                cause: e
-            });
-        }
-    }
+* pre-build, build, post-build 단계를 순차적으로 실행합니다.
+*/
+async function runBuildSteps(artifact, options) {
+	const steps = [
+		{
+			name: "pre-build",
+			cmd: artifact.preBuildCommand?.()
+		},
+		{
+			name: "build",
+			cmd: artifact.buildCommand(options.buildCommandArgs)
+		},
+		{
+			name: "post-build",
+			cmd: artifact.postBuildCommand?.()
+		}
+	].filter((step) => step.cmd);
+	for (let i = 0; i < steps.length; i++) {
+		const step = steps[i];
+		const isLast = i === steps.length - 1;
+		try {
+			assert(step.cmd);
+			printTaskStart(step.name, step.cmd, isLast);
+			await execWithLinePrefix(step.cmd, { cwd: options.cwd });
+			printTaskSuccess(step.name, isLast);
+		} catch (e) {
+			printTaskFailed(step.name, isLast);
+			throw new Error(`${step.name} failed`, { cause: e });
+		}
+	}
 }
 /**
- * pnpm start 하면 실행되는 함수입니다.
- * 빌드된 프로젝트를 실행합니다.
- *
- * 빌드된 결과물(dist 디렉토리의 index.js 엔트리포인트)이 없다면 실행을 중단합니다.
- * 소스맵 지원과 dotenv 지원을 포함하여 실행합니다.
- *
- * Sonamu.init 없이 호출될 것을 상정하여 구현되었습니다.
- */ async function start() {
-    const apiRoot = findApiRootPath();
-    const entryPoint = "dist/index.js";
-    if (!await exists(entryPoint)) {
-        console.log(chalk.red(`${entryPoint} not found. Please build your project first.`));
-        console.log(chalk.blue("Run: pnpm sonamu build"));
-        return;
-    }
-    const { spawn } = await import("child_process");
-    const serverProcess = spawn(process.execPath, [
-        "--enable-source-maps",
-        "-r",
-        "dotenv/config",
-        entryPoint
-    ], {
-        cwd: apiRoot,
-        stdio: "inherit"
-    });
-    process.on("SIGINT", ()=>{
-        serverProcess.kill("SIGTERM");
-        process.exit(0);
-    });
+* pnpm start 하면 실행되는 함수입니다.
+* 빌드된 프로젝트를 실행합니다.
+*
+* 빌드된 결과물(dist 디렉토리의 index.js 엔트리포인트)이 없다면 실행을 중단합니다.
+* 소스맵 지원과 dotenv 지원을 포함하여 실행합니다.
+*
+* Sonamu.init 없이 호출될 것을 상정하여 구현되었습니다.
+*/
+async function start() {
+	const apiRoot = findApiRootPath();
+	const entryPoint = "dist/index.js";
+	if (!await exists(entryPoint)) {
+		console.log(chalk.red(`${entryPoint} not found. Please build your project first.`));
+		console.log(chalk.blue("Run: pnpm sonamu build"));
+		return;
+	}
+	const { spawn: spawn$1 } = await import("child_process");
+	const serverProcess = spawn$1(process.execPath, [
+		"--enable-source-maps",
+		"-r",
+		"dotenv/config",
+		entryPoint
+	], {
+		cwd: apiRoot,
+		stdio: "inherit"
+	});
+	process.on("SIGINT", () => {
+		serverProcess.kill("SIGTERM");
+		process.exit(0);
+	});
 }
 async function setupMigrator() {
-    // migrator
-    migrator = new Migrator();
+	migrator = new Migrator();
 }
 async function setupFixtureManager() {
-    FixtureManager.init();
+	FixtureManager.init();
 }
 async function migrate_apply(targets) {
-    await setupMigrator();
-    await migrator.runAction("apply", targets);
+	await setupMigrator();
+	await migrator.runAction("apply", targets);
 }
 async function migrate_run() {
-    await setupMigrator();
-    const localHosts = [
-        "localhost",
-        "127.0.0.1",
-        "0.0.0.0",
-        "::1"
-    ];
-    const targets = Object.keys(Sonamu.dbConfig).filter((target)=>{
-        const targetConfig = Sonamu.dbConfig[target];
-        const host = targetConfig?.connection?.host ?? "localhost";
-        return localHosts.includes(host.toLowerCase());
-    });
-    // 로컬 데이터베이스에 대해서만 전체 마이그레이션에서 동작
-    await migrator.runAction("apply", targets);
+	await setupMigrator();
+	const localHosts = [
+		"localhost",
+		"127.0.0.1",
+		"0.0.0.0",
+		"::1"
+	];
+	const targets = Object.keys(Sonamu.dbConfig).filter((target) => {
+		const targetConfig = Sonamu.dbConfig[target];
+		const host = (targetConfig?.connection)?.host ?? "localhost";
+		return localHosts.includes(host.toLowerCase());
+	});
+	await migrator.runAction("apply", targets);
 }
 async function migrate_generate() {
-    await setupMigrator();
-    const { conns } = await migrator.getStatus();
-    const hasStatus0 = conns.some((conn)=>conn.status === 0);
-    if (!hasStatus0) {
-        console.log(chalk.red("마이그레이션 파일을 생성하려면 기존 마이그레이션이 최소 하나의 DB에 모두 적용되어 있어야 합니다."));
-        for (const conn of conns){
-            if (conn.pending.length > 0) {
-                console.log(chalk.yellow(`  ${conn.name}: pending ${conn.pending.length}개`));
-            }
-        }
-        process.exit(1);
-    }
-    const count = await migrator.generatePreparedCodes();
-    if (count > 0) {
-        console.log(chalk.green(`${count}개의 마이그레이션 파일이 생성되었습니다.`));
-    }
+	await setupMigrator();
+	const { conns } = await migrator.getStatus();
+	const hasStatus0 = conns.some((conn) => conn.status === 0);
+	if (!hasStatus0) {
+		console.log(chalk.red("마이그레이션 파일을 생성하려면 기존 마이그레이션이 최소 하나의 DB에 모두 적용되어 있어야 합니다."));
+		for (const conn of conns) {
+			if (conn.pending.length > 0) {
+				console.log(chalk.yellow(`  ${conn.name}: pending ${conn.pending.length}개`));
+			}
+		}
+		process.exit(1);
+	}
+	const count = await migrator.generatePreparedCodes();
+	if (count > 0) {
+		console.log(chalk.green(`${count}개의 마이그레이션 파일이 생성되었습니다.`));
+	}
 }
 async function migrate_status() {
-    await setupMigrator();
-    const status = await migrator.getStatus();
-    // status;
-    console.log(status);
+	await setupMigrator();
+	const status = await migrator.getStatus();
+	console.log(status);
 }
 async function fixture_init() {
-    const srcConfig = Sonamu.dbConfig.development_master;
-    const targets = [
-        {
-            label: "(REMOTE) Fixture DB",
-            config: Sonamu.dbConfig.fixture
-        },
-        {
-            label: "(LOCAL) Testing DB",
-            config: Sonamu.dbConfig.test,
-            toSkip: (()=>{
-                const remoteConn = Sonamu.dbConfig.fixture.connection;
-                const localConn = Sonamu.dbConfig.test.connection;
-                return remoteConn.host === localConn.host && remoteConn.database === localConn.database;
-            })()
-        }
-    ];
-    // 1. 기준DB 스키마를 덤프
-    console.log("DUMP...");
-    const dumpFilename = `/tmp/sonamu-fixture-init-${Date.now()}.sql`;
-    const srcConn = srcConfig.connection;
-    const migrationsDump = `/tmp/sonamu-fixture-init-migrations-${Date.now()}.sql`;
-    execSync(`mysqldump -h${srcConn.host} -u${srcConn.user} -p${srcConn.password} --single-transaction -d --no-create-db --triggers ${srcConn.database} > ${dumpFilename}`);
-    const _db = knex(srcConfig);
-    const [[migrations]] = await _db.raw("SELECT COUNT(*) as count FROM information_schema.tables WHERE table_schema = ? AND table_name = 'knex_migrations'", [
-        srcConn.database
-    ]);
-    if (migrations.count > 0) {
-        execSync(`mysqldump -h${srcConn.host} -u${srcConn.user} -p${srcConn.password} --single-transaction --no-create-db --triggers ${srcConn.database} knex_migrations knex_migrations_lock > ${migrationsDump}`);
-    }
-    // 2. 대상DB 각각에 대하여 존재여부 확인 후 붓기
-    for await (const { label, config, toSkip } of targets){
-        const conn = config.connection;
-        if (toSkip === true) {
-            console.log(chalk.red(`${label}: Skipped!`));
-            continue;
-        }
-        const db = knex({
-            ...config,
-            connection: {
-                ...config.connection ?? {},
-                database: undefined
-            }
-        });
-        const [[row]] = await db.raw(`SHOW DATABASES LIKE "${conn.database}"`);
-        if (row) {
-            console.log(chalk.yellow(`${label}: Database "${conn.database}" Already exists`));
-            await db.destroy();
-            continue;
-        }
-        console.log(`SYNC to ${label}...`);
-        const mysqlCmd = `mysql -h${conn.host} -u${conn.user} -p${conn.password}`;
-        execSync(`${mysqlCmd} -e 'DROP DATABASE IF EXISTS \`${conn.database}\`'`);
-        execSync(`${mysqlCmd} -e 'CREATE DATABASE \`${conn.database}\`'`);
-        execSync(`${mysqlCmd} ${conn.database} < ${dumpFilename}`);
-        if (await exists(migrationsDump)) {
-            execSync(`${mysqlCmd} ${conn.database} < ${migrationsDump}`);
-        }
-        await db.destroy();
-    }
-    await _db.destroy();
+	const srcConfig = Sonamu.dbConfig.development_master;
+	const targets = [{
+		label: "(REMOTE) Fixture DB",
+		config: Sonamu.dbConfig.fixture
+	}, {
+		label: "(LOCAL) Testing DB",
+		config: Sonamu.dbConfig.test,
+		toSkip: (() => {
+			const remoteConn = Sonamu.dbConfig.fixture.connection;
+			const localConn = Sonamu.dbConfig.test.connection;
+			return remoteConn.host === localConn.host && remoteConn.database === localConn.database;
+		})()
+	}];
+	console.log("DUMP...");
+	const dumpFilename = `/tmp/sonamu-fixture-init-${Date.now()}.sql`;
+	const srcConn = srcConfig.connection;
+	const migrationsDump = `/tmp/sonamu-fixture-init-migrations-${Date.now()}.sql`;
+	execSync(`mysqldump -h${srcConn.host} -u${srcConn.user} -p${srcConn.password} --single-transaction -d --no-create-db --triggers ${srcConn.database} > ${dumpFilename}`);
+	const _db = knex(srcConfig);
+	const [[migrations]] = await _db.raw("SELECT COUNT(*) as count FROM information_schema.tables WHERE table_schema = ? AND table_name = 'knex_migrations'", [srcConn.database]);
+	if (migrations.count > 0) {
+		execSync(`mysqldump -h${srcConn.host} -u${srcConn.user} -p${srcConn.password} --single-transaction --no-create-db --triggers ${srcConn.database} knex_migrations knex_migrations_lock > ${migrationsDump}`);
+	}
+	for (const { label, config, toSkip } of targets) {
+		const conn = config.connection;
+		if (toSkip === true) {
+			console.log(chalk.red(`${label}: Skipped!`));
+			continue;
+		}
+		const db = knex({
+			...config,
+			connection: {
+				...config.connection ?? {},
+				database: undefined
+			}
+		});
+		const [[row]] = await db.raw(`SHOW DATABASES LIKE "${conn.database}"`);
+		if (row) {
+			console.log(chalk.yellow(`${label}: Database "${conn.database}" Already exists`));
+			await db.destroy();
+			continue;
+		}
+		console.log(`SYNC to ${label}...`);
+		const mysqlCmd = `mysql -h${conn.host} -u${conn.user} -p${conn.password}`;
+		execSync(`${mysqlCmd} -e 'DROP DATABASE IF EXISTS \`${conn.database}\`'`);
+		execSync(`${mysqlCmd} -e 'CREATE DATABASE \`${conn.database}\`'`);
+		execSync(`${mysqlCmd} ${conn.database} < ${dumpFilename}`);
+		if (await exists(migrationsDump)) {
+			execSync(`${mysqlCmd} ${conn.database} < ${migrationsDump}`);
+		}
+		await db.destroy();
+	}
+	await _db.destroy();
 }
 async function fixture_import(entityId, recordIds) {
-    await setupFixtureManager();
-    await FixtureManager.importFixture(entityId, recordIds);
-    await FixtureManager.sync();
+	await setupFixtureManager();
+	await FixtureManager.importFixture(entityId, recordIds);
+	await FixtureManager.sync();
 }
 async function fixture_sync() {
-    await setupFixtureManager();
-    await FixtureManager.sync();
+	await setupFixtureManager();
+	await FixtureManager.sync();
 }
 /**
- * fixture gen 명령어
- * 옵션을 process.argv에서 파싱
- */ async function fixture_gen() {
-    const options = parseOptions(process.argv);
-    await fixtureGenCommand(options);
+* fixture gen 명령어
+* 옵션을 process.argv에서 파싱
+*/
+async function fixture_gen() {
+	const options = parseOptions(process.argv);
+	await fixtureGenCommand(options);
 }
 /**
- * fixture fetch 명령어
- * 옵션을 process.argv에서 파싱
- */ async function fixture_fetch() {
-    const options = parseOptions(process.argv);
-    await fixtureFetchCommand(options);
+* fixture fetch 명령어
+* 옵션을 process.argv에서 파싱
+*/
+async function fixture_fetch() {
+	const options = parseOptions(process.argv);
+	await fixtureFetchCommand(options);
 }
 /**
- * fixture explore 명령어
- * 옵션을 process.argv에서 파싱
- */ async function fixture_explore() {
-    const options = parseOptions(process.argv);
-    await fixtureExploreCommand(options);
+* fixture explore 명령어
+* 옵션을 process.argv에서 파싱
+*/
+async function fixture_explore() {
+	const options = parseOptions(process.argv);
+	await fixtureExploreCommand(options);
 }
 /**
- * 간단한 옵션 파서
- */ function parseOptions(argv) {
-    const options = {
-        _: []
-    };
-    for(let i = 0; i < argv.length; i++){
-        const arg = argv[i];
-        if (arg.startsWith("--")) {
-            const key = arg.slice(2);
-            if (key.includes("=")) {
-                const [k, v] = key.split("=");
-                options[k] = v;
-            } else {
-                const next = argv[i + 1];
-                if (next && !next.startsWith("--")) {
-                    options[key] = next;
-                    i++;
-                } else {
-                    options[key] = true;
-                }
-            }
-        } else if (arg.startsWith("-")) {
-            const key = arg.slice(1);
-            const next = argv[i + 1];
-            if (next && !next.startsWith("-")) {
-                options[key] = next;
-                i++;
-            } else {
-                options[key] = true;
-            }
-        } else {
-            options._.push(arg);
-        }
-    }
-    return options;
+* 간단한 옵션 파서
+*/
+function parseOptions(argv) {
+	const options = { _: [] };
+	for (let i = 0; i < argv.length; i++) {
+		const arg = argv[i];
+		if (arg.startsWith("--")) {
+			const key = arg.slice(2);
+			if (key.includes("=")) {
+				const [k, v] = key.split("=");
+				options[k] = v;
+			} else {
+				const next = argv[i + 1];
+				if (next && !next.startsWith("--")) {
+					options[key] = next;
+					i++;
+				} else {
+					options[key] = true;
+				}
+			}
+		} else if (arg.startsWith("-")) {
+			const key = arg.slice(1);
+			const next = argv[i + 1];
+			if (next && !next.startsWith("-")) {
+				options[key] = next;
+				i++;
+			} else {
+				options[key] = true;
+			}
+		} else {
+			options._.push(arg);
+		}
+	}
+	return options;
 }
 async function stub_practice(name) {
-    const practiceDir = path.join(Sonamu.apiRootPath, "src", "practices");
-    const fileNames = await readdir(practiceDir);
-    const maxSeqNo = await (async ()=>{
-        if (!await exists(practiceDir)) {
-            await mkdir(practiceDir, {
-                recursive: true
-            });
-        }
-        const filteredSeqs = fileNames.filter((fileName)=>fileName.startsWith("p") && fileName.endsWith(".ts")).map((fileName)=>{
-            const [, seqNo] = fileName.match(/^p([0-9]+)-/) ?? [
-                "0",
-                "0"
-            ];
-            return parseInt(seqNo);
-        }).sort((a, b)=>b - a);
-        if (filteredSeqs.length > 0) {
-            return filteredSeqs[0];
-        }
-        return 0;
-    })();
-    const currentSeqNo = maxSeqNo + 1;
-    const fileName = `p${currentSeqNo}-${name}.ts`;
-    const dstPath = path.join(practiceDir, fileName);
-    const code = [
-        `import { Sonamu } from "sonamu";`,
-        "",
-        `console.clear();`,
-        `console.log("${fileName}");`,
-        "",
-        `Sonamu.runScript(async () => {`,
-        ` // TODO`,
-        `});`,
-        ""
-    ].join("\n");
-    await writeFile(dstPath, code);
-    execSync(`code ${dstPath}`);
-    const runCode = `yarn node -r dotenv/config --enable-source-maps dist/practices/${fileName.replace(".ts", ".js")}`;
-    console.log(`${chalk.blue(runCode)} copied to clipboard.`);
-    execSync(`echo "${runCode}" | pbcopy`);
+	const practiceDir = path.join(Sonamu.apiRootPath, "src", "practices");
+	const fileNames = await readdir(practiceDir);
+	const maxSeqNo = await (async () => {
+		if (!await exists(practiceDir)) {
+			await mkdir(practiceDir, { recursive: true });
+		}
+		const filteredSeqs = fileNames.filter((fileName$1) => fileName$1.startsWith("p") && fileName$1.endsWith(".ts")).map((fileName$1) => {
+			const [, seqNo] = fileName$1.match(/^p([0-9]+)-/) ?? ["0", "0"];
+			return parseInt(seqNo);
+		}).toSorted((a, b) => b - a);
+		if (filteredSeqs.length > 0) {
+			return filteredSeqs[0];
+		}
+		return 0;
+	})();
+	const currentSeqNo = maxSeqNo + 1;
+	const fileName = `p${currentSeqNo}-${name}.ts`;
+	const dstPath = path.join(practiceDir, fileName);
+	const code = [
+		`import { Sonamu } from "sonamu";`,
+		"",
+		`console.clear();`,
+		`console.log("${fileName}");`,
+		"",
+		`Sonamu.runScript(async () => {`,
+		` // TODO`,
+		`});`,
+		""
+	].join("\n");
+	await writeFile(dstPath, code);
+	execSync(`code ${dstPath}`);
+	const runCode = `yarn node -r dotenv/config --enable-source-maps dist/practices/${fileName.replace(".ts", ".js")}`;
+	console.log(`${chalk.blue(runCode)} copied to clipboard.`);
+	execSync(`echo "${runCode}" | pbcopy`);
 }
 async function stub_entity(entityId) {
-    await Sonamu.syncer.createEntity({
-        entityId,
-        title: entityId
-    });
-    const { flags } = parseCliOptions();
-    const useAI = flags.has("ai");
-    const noCones = flags.has("no-cones");
-    // --no-cones: cone 생성 스킵
-    if (noCones) {
-        console.log(`✓ Entity '${entityId}' created without cones`);
-        return;
-    }
-    const { EntityManager } = await import("../entity/entity-manager.js");
-    const entity = EntityManager.get(entityId);
-    if (!entity) {
-        console.error(`Entity not found: ${entityId}`);
-        return;
-    }
-    // --ai: LLM으로 cone 생성
-    if (useAI) {
-        console.log(`✓ Entity '${entityId}' created`);
-        console.log(`🌟 Generating AI-powered cones...`);
-        try {
-            const configLocale = Sonamu.config.i18n?.defaultLocale;
-            const locale = configLocale === "ko" || configLocale === "en" || configLocale === "ja" ? configLocale : "ko";
-            const result = await entity.generateCones({
-                preserveExisting: false,
-                onlyEmpty: false,
-                locale
-            });
-            console.log(`✅ Done (${result.tokensUsed} tokens)`);
-        } catch (error) {
-            if (error instanceof Error && error.message.includes("ANTHROPIC_API_KEY")) {
-                console.error(`\n❌ ${error.message}`);
-                console.error(`\n💡 Remove --ai flag to use template cones instead`);
-            } else {
-                throw error;
-            }
-        }
-        return;
-    }
-    // 기본: 템플릿 cone 자동 생성
-    // LLM 없이 faker-mappings.ts를 활용하여 기본 cone 메타데이터를 생성합니다.
-    // 이를 통해 ANTHROPIC_API_KEY가 없어도 Sonamu를 사용할 수 있으며,
-    // 생성된 템플릿 cone은 나중에 'cone gen' 명령어로 AI를 통해 업그레이드할 수 있습니다.
-    console.log(`🌟 Generating template cones...`);
-    await entity.generateTemplateCones();
-    console.log(`✓ Entity '${entityId}' created with template cones`);
-    console.log(`💡 Tip: Run 'pnpm sonamu cone gen ${entityId}' to improve with AI`);
+	await Sonamu.syncer.createEntity({
+		entityId,
+		title: entityId
+	});
+	const { flags } = parseCliOptions();
+	const useAI = flags.has("ai");
+	const noCones = flags.has("no-cones");
+	if (noCones) {
+		console.log(`✓ Entity '${entityId}' created without cones`);
+		return;
+	}
+	const { EntityManager: EntityManager$1 } = await import("../entity/entity-manager.js");
+	const entity = EntityManager$1.get(entityId);
+	if (!entity) {
+		console.error(`Entity not found: ${entityId}`);
+		return;
+	}
+	if (useAI) {
+		console.log(`✓ Entity '${entityId}' created`);
+		console.log(`🌟 Generating AI-powered cones...`);
+		try {
+			const configLocale = Sonamu.config.i18n?.defaultLocale;
+			const locale = configLocale === "ko" || configLocale === "en" || configLocale === "ja" ? configLocale : "ko";
+			const result = await entity.generateCones({
+				preserveExisting: false,
+				onlyEmpty: false,
+				locale
+			});
+			console.log(`✅ Done (${result.tokensUsed} tokens)`);
+		} catch (error) {
+			if (error instanceof Error && error.message.includes("ANTHROPIC_API_KEY")) {
+				console.error(`\n❌ ${error.message}`);
+				console.error(`\n💡 Remove --ai flag to use template cones instead`);
+			} else {
+				throw error;
+			}
+		}
+		return;
+	}
+	console.log(`🌟 Generating template cones...`);
+	await entity.generateTemplateCones();
+	console.log(`✓ Entity '${entityId}' created with template cones`);
+	console.log(`💡 Tip: Run 'pnpm sonamu cone gen ${entityId}' to improve with AI`);
 }
 /**
- * AI를 사용하여 entity의 cone 메타데이터를 생성하거나 업그레이드합니다.
- *
- * 옵션:
- * - --regenerate: 전체 재생성 (기존 cone 덮어쓰기)
- * - --locale <ko|en|ja>: 생성 언어 지정
- * - 기본: onlyEmpty 모드 (기존 fixtureHint 보존)
- *
- * ANTHROPIC_API_KEY 필요 (sonamu.secret.ts 또는 환경변수)
- */ async function cone_gen(entityId) {
-    const { EntityManager } = await import("../entity/entity-manager.js");
-    const { flags, options } = parseCliOptions();
-    // --all 옵션: 모든 entity cone 생성
-    if (flags.has("all") || entityId === "all") {
-        const allEntities = EntityManager.getAllEntities();
-        console.log(`🌟 Generating AI-powered cones for ${allEntities.length} entities...\n`);
-        let totalTokens = 0;
-        const errors = [];
-        for (const entity of allEntities){
-            try {
-                console.log(`Processing ${entity.id}...`);
-                const configLocale = options.locale || Sonamu.config.i18n?.defaultLocale;
-                const locale = configLocale === "ko" || configLocale === "en" || configLocale === "ja" ? configLocale : "ko";
-                const result = await entity.generateCones({
-                    preserveExisting: !flags.has("regenerate"),
-                    onlyEmpty: !flags.has("regenerate"),
-                    locale
-                });
-                totalTokens += result.tokensUsed;
-                console.log(`  ✓ ${entity.id} (${result.tokensUsed} tokens)\n`);
-            } catch (error) {
-                const message = error instanceof Error ? error.message : "Unknown error";
-                errors.push(`${entity.id}: ${message}`);
-                console.error(`  ✗ ${entity.id}: ${message}\n`);
-            }
-        }
-        console.log(`\n✅ Done! Total: ${totalTokens} tokens used`);
-        const estimatedCost = totalTokens * 9 / 1_000_000;
-        console.log(`💰 Estimated cost: ~$${estimatedCost.toFixed(4)}`);
-        if (errors.length > 0) {
-            console.error(`\n❌ Failed entities (${errors.length}):`);
-            for (const err of errors){
-                console.error(`  - ${err}`);
-            }
-        }
-        return;
-    }
-    // 단일 entity cone 생성
-    const entity = EntityManager.get(entityId);
-    if (!entity) {
-        console.error(`Entity not found: ${entityId}`);
-        return;
-    }
-    const mode = flags.has("regenerate") ? "regenerating" : "generating";
-    console.log(`🌟 ${mode === "regenerating" ? "Regenerating" : "Generating"} AI-powered cones for ${entityId}...`);
-    try {
-        const configLocale = options.locale || Sonamu.config.i18n?.defaultLocale;
-        const locale = configLocale === "ko" || configLocale === "en" || configLocale === "ja" ? configLocale : "ko";
-        const result = await entity.generateCones({
-            preserveExisting: !flags.has("regenerate"),
-            onlyEmpty: !flags.has("regenerate"),
-            locale
-        });
-        console.log(`✅ Done! (${result.tokensUsed} tokens used)`);
-        // 토큰 비용 계산 (대략적인 추정)
-        // Claude Sonnet 4.5: input $3/M tokens, output $15/M tokens
-        // 간단하게 평균 $9/M tokens로 계산
-        const estimatedCost = result.tokensUsed * 9 / 1_000_000;
-        console.log(`💰 Estimated cost: ~$${estimatedCost.toFixed(4)}`);
-    } catch (error) {
-        if (error instanceof Error) {
-            if (error.message.includes("ANTHROPIC_API_KEY")) {
-                console.error(`\n❌ ${error.message}`);
-                console.error(`\n💡 To use AI-powered cone generation:`);
-                console.error(`   1. Get an API key from https://console.anthropic.com/`);
-                console.error(`   2. Add it to sonamu.secret.ts or set ANTHROPIC_API_KEY environment variable`);
-            } else if (error.message.includes("Rate limit")) {
-                console.error(`\n❌ ${error.message}`);
-                console.error(`\n💡 Please wait a moment and try again.`);
-            } else {
-                console.error(`\n❌ Failed to generate cones: ${error.message}`);
-            }
-        } else {
-            console.error(`\n❌ Failed to generate cones: Unknown error`);
-        }
-    }
+* AI를 사용하여 entity의 cone 메타데이터를 생성하거나 업그레이드합니다.
+*
+* 옵션:
+* - --regenerate: 전체 재생성 (기존 cone 덮어쓰기)
+* - --locale <ko|en|ja>: 생성 언어 지정
+* - 기본: onlyEmpty 모드 (기존 fixtureHint 보존)
+*
+* ANTHROPIC_API_KEY 필요 (sonamu.secret.ts 또는 환경변수)
+*/
+async function cone_gen(entityId) {
+	const { EntityManager: EntityManager$1 } = await import("../entity/entity-manager.js");
+	const { flags, options } = parseCliOptions();
+	if (flags.has("all") || entityId === "all") {
+		const allEntities = EntityManager$1.getAllEntities();
+		console.log(`🌟 Generating AI-powered cones for ${allEntities.length} entities...\n`);
+		let totalTokens = 0;
+		const errors = [];
+		for (const entity$1 of allEntities) {
+			try {
+				console.log(`Processing ${entity$1.id}...`);
+				const configLocale = options.locale || Sonamu.config.i18n?.defaultLocale;
+				const locale = configLocale === "ko" || configLocale === "en" || configLocale === "ja" ? configLocale : "ko";
+				const result = await entity$1.generateCones({
+					preserveExisting: !flags.has("regenerate"),
+					onlyEmpty: !flags.has("regenerate"),
+					locale
+				});
+				totalTokens += result.tokensUsed;
+				console.log(`  ✓ ${entity$1.id} (${result.tokensUsed} tokens)\n`);
+			} catch (error) {
+				const message = error instanceof Error ? error.message : "Unknown error";
+				errors.push(`${entity$1.id}: ${message}`);
+				console.error(`  ✗ ${entity$1.id}: ${message}\n`);
+			}
+		}
+		console.log(`\n✅ Done! Total: ${totalTokens} tokens used`);
+		const estimatedCost = totalTokens * 9 / 1e6;
+		console.log(`💰 Estimated cost: ~$${estimatedCost.toFixed(4)}`);
+		if (errors.length > 0) {
+			console.error(`\n❌ Failed entities (${errors.length}):`);
+			for (const err of errors) {
+				console.error(`  - ${err}`);
+			}
+		}
+		return;
+	}
+	const entity = EntityManager$1.get(entityId);
+	if (!entity) {
+		console.error(`Entity not found: ${entityId}`);
+		return;
+	}
+	const mode = flags.has("regenerate") ? "regenerating" : "generating";
+	console.log(`🌟 ${mode === "regenerating" ? "Regenerating" : "Generating"} AI-powered cones for ${entityId}...`);
+	try {
+		const configLocale = options.locale || Sonamu.config.i18n?.defaultLocale;
+		const locale = configLocale === "ko" || configLocale === "en" || configLocale === "ja" ? configLocale : "ko";
+		const result = await entity.generateCones({
+			preserveExisting: !flags.has("regenerate"),
+			onlyEmpty: !flags.has("regenerate"),
+			locale
+		});
+		console.log(`✅ Done! (${result.tokensUsed} tokens used)`);
+		const estimatedCost = result.tokensUsed * 9 / 1e6;
+		console.log(`💰 Estimated cost: ~$${estimatedCost.toFixed(4)}`);
+	} catch (error) {
+		if (error instanceof Error) {
+			if (error.message.includes("ANTHROPIC_API_KEY")) {
+				console.error(`\n❌ ${error.message}`);
+				console.error(`\n💡 To use AI-powered cone generation:`);
+				console.error(`   1. Get an API key from https://console.anthropic.com/`);
+				console.error(`   2. Add it to sonamu.secret.ts or set ANTHROPIC_API_KEY environment variable`);
+			} else if (error.message.includes("Rate limit")) {
+				console.error(`\n❌ ${error.message}`);
+				console.error(`\n💡 Please wait a moment and try again.`);
+			} else {
+				console.error(`\n❌ Failed to generate cones: ${error.message}`);
+			}
+		} else {
+			console.error(`\n❌ Failed to generate cones: Unknown error`);
+		}
+	}
 }
 async function scaffold_model(entityId) {
-    await Sonamu.syncer.generateTemplate("model", {
-        entityId
-    });
+	await Sonamu.syncer.generateTemplate("model", { entityId });
 }
 async function scaffold_model_test(entityId) {
-    await Sonamu.syncer.generateTemplate("model_test", {
-        entityId
-    });
+	await Sonamu.syncer.generateTemplate("model_test", { entityId });
 }
 /**
- * pnpm sonamu skills sync 하면 실행되는 함수입니다.
- * 공식 Skills를 로컬 프로젝트 또는 글로벌 ~/.claude/로 동기화합니다.
- *
- * --global 플래그: ~/.claude/에 동기화 (프로젝트 생성 전 사용 가능)
- */ async function skills_sync() {
-    const { flags } = parseCliOptions();
-    const isGlobal = flags.has("global");
-    // 개발 환경 - cli.ts: sonamu/modules/sonamu/src/bin/cli.ts
-    // 빌드 후 - cli.js: node_modules/sonamu/dist/bin/cli.js (실제 실행)
-    // skills 위치: node_modules/sonamu/src/skills (npm 배포 시)
-    const sourceBase = path.resolve(import.meta.dirname, "..", "..", "src", "skills");
-    const sourceSkillsDir = path.join(sourceBase, "sonamu");
-    const sourceClaudeMd = path.join(sourceBase, "CLAUDE.md");
-    if (!await exists(sourceSkillsDir)) {
-        console.log(chalk.yellow("Skills source not found in sonamu package."));
-        return;
-    }
-    if (isGlobal) {
-        const homeClaudeDir = path.join(os.homedir(), ".claude");
-        await skills_sync_to(homeClaudeDir, sourceSkillsDir, sourceClaudeMd, {
-            useSymlink: false,
-            copyProjectTemplates: false,
-            isGlobal: true
-        });
-        // ~/.claude/commands/sonamu-skills.md 설치
-        const sourceCommandsDir = path.join(sourceBase, "commands");
-        const sourceCommand = path.join(sourceCommandsDir, "sonamu-skills.md");
-        if (await exists(sourceCommand)) {
-            const targetCommandsDir = path.join(homeClaudeDir, "commands");
-            await mkdir(targetCommandsDir, {
-                recursive: true
-            });
-            await cp(sourceCommand, path.join(targetCommandsDir, "sonamu-skills.md"));
-            console.log(chalk.green(`✓ /sonamu-skills command installed → ~/.claude/commands/`));
-        }
-        console.log(chalk.cyan(`\n  Global sync complete → ~/.claude/skills/sonamu/`));
-        console.log(chalk.dim(`  These skills are available in all Claude Code sessions.`));
-        console.log(chalk.dim(`  Once a project is created, run 'pnpm sonamu skills sync' for project-local sync.`));
-    } else {
-        const workspaceRoot = await findWorkspaceRoot();
-        const claudeDir = path.join(workspaceRoot, ".claude");
-        await skills_sync_to(claudeDir, sourceSkillsDir, sourceClaudeMd, {
-            useSymlink: true,
-            copyProjectTemplates: true,
-            sourceBase
-        });
-    }
+* pnpm sonamu skills sync 하면 실행되는 함수입니다.
+* 공식 Skills를 로컬 프로젝트 또는 글로벌 ~/.claude/로 동기화합니다.
+*
+* --global 플래그: ~/.claude/에 동기화 (프로젝트 생성 전 사용 가능)
+*/
+async function skills_sync() {
+	const { flags } = parseCliOptions();
+	const isGlobal = flags.has("global");
+	const sourceBase = path.resolve(import.meta.dirname, "..", "..", "src", "skills");
+	const sourceSkillsDir = path.join(sourceBase, "sonamu");
+	const sourceClaudeMd = path.join(sourceBase, "CLAUDE.md");
+	if (!await exists(sourceSkillsDir)) {
+		console.log(chalk.yellow("Skills source not found in sonamu package."));
+		return;
+	}
+	if (isGlobal) {
+		const homeClaudeDir = path.join(os.homedir(), ".claude");
+		await skills_sync_to(homeClaudeDir, sourceSkillsDir, sourceClaudeMd, {
+			useSymlink: false,
+			copyProjectTemplates: false,
+			isGlobal: true
+		});
+		const sourceCommandsDir = path.join(sourceBase, "commands");
+		const sourceCommand = path.join(sourceCommandsDir, "sonamu-skills.md");
+		if (await exists(sourceCommand)) {
+			const targetCommandsDir = path.join(homeClaudeDir, "commands");
+			await mkdir(targetCommandsDir, { recursive: true });
+			await cp(sourceCommand, path.join(targetCommandsDir, "sonamu-skills.md"));
+			console.log(chalk.green(`✓ /sonamu-skills command installed → ~/.claude/commands/`));
+		}
+		console.log(chalk.cyan(`\n  Global sync complete → ~/.claude/skills/sonamu/`));
+		console.log(chalk.dim(`  These skills are available in all Claude Code sessions.`));
+		console.log(chalk.dim(`  Once a project is created, run 'pnpm sonamu skills sync' for project-local sync.`));
+	} else {
+		const workspaceRoot = await findWorkspaceRoot();
+		const claudeDir = path.join(workspaceRoot, ".claude");
+		await skills_sync_to(claudeDir, sourceSkillsDir, sourceClaudeMd, {
+			useSymlink: true,
+			copyProjectTemplates: true,
+			sourceBase
+		});
+	}
 }
 /**
- * claudeDir로 skills를 동기화하는 공통 로직입니다.
- */ async function skills_sync_to(claudeDir, sourceSkillsDir, sourceClaudeMd, options) {
-    const targetSkillsDir = path.join(claudeDir, "skills", "sonamu");
-    // 기존 디렉토리/symlink 삭제 후 재생성
-    // exists()는 broken symlink를 감지하지 못하므로 rm을 무조건 시도합니다
-    try {
-        await rm(targetSkillsDir, {
-            recursive: true,
-            force: true
-        });
-    } catch  {
-    // 파일이 없으면 무시
-    }
-    await mkdir(path.dirname(targetSkillsDir), {
-        recursive: true
-    });
-    if (options.useSymlink) {
-        try {
-            await symlink(sourceSkillsDir, targetSkillsDir, "dir");
-            console.log(chalk.green(`✓ Skills linked (symlink)`));
-        } catch (error) {
-            console.log(chalk.yellow(`⚠ Symlink failed: ${error instanceof Error ? error.message : String(error)}`));
-            console.log(chalk.yellow(`  Falling back to copy...`));
-            await skillsCopy(sourceSkillsDir, targetSkillsDir);
-        }
-    } else {
-        await skillsCopy(sourceSkillsDir, targetSkillsDir);
-    }
-    // project 디렉토리 초기화 (없으면 생성, 있으면 유지)
-    if (options.copyProjectTemplates && options.sourceBase) {
-        const sourceProjectDir = path.join(options.sourceBase, "project");
-        const targetProjectDir = path.join(claudeDir, "skills", "project");
-        if (await exists(sourceProjectDir)) {
-            if (!await exists(targetProjectDir)) {
-                try {
-                    await cp(sourceProjectDir, targetProjectDir, {
-                        recursive: true
-                    });
-                    console.log(chalk.green(`✓ Project templates initialized`));
-                } catch (error) {
-                    console.error(chalk.red(`✗ Failed to initialize project templates: ${error instanceof Error ? error.message : String(error)}`));
-                }
-            } else {
-                console.log(chalk.dim(`⏭ Project templates already exist (preserved)`));
-            }
-        }
-    }
-    // settings.local.json — project-local 모드에서만, 없을 때만 생성
-    if (options.copyProjectTemplates) {
-        const settingsLocalPath = path.join(claudeDir, "settings.local.json");
-        if (!await exists(settingsLocalPath)) {
-            try {
-                const settingsContent = {
-                    hooks: {
-                        PostToolUse: [
-                            {
-                                matcher: "Edit|Write|MultiEdit",
-                                hooks: [
-                                    {
-                                        type: "command",
-                                        command: "pnpm biome check --changed 2>&1 | head -60"
-                                    }
-                                ]
-                            }
-                        ]
-                    }
-                };
-                await writeFile(settingsLocalPath, `${JSON.stringify(settingsContent, null, 2)}\n`);
-                console.log(chalk.green(`✓ .claude/settings.local.json created`));
-            } catch (error) {
-                console.error(chalk.red(`✗ Failed to create settings.local.json: ${error instanceof Error ? error.message : String(error)}`));
-            }
-        } else {
-            console.log(chalk.dim(`⏭ .claude/settings.local.json already exists (preserved)`));
-        }
-    }
-    // CLAUDE.md 복사/업데이트
-    if (await exists(sourceClaudeMd)) {
-        try {
-            const targetClaudeMd = path.join(claudeDir, "CLAUDE.md");
-            const rawContent = await readFile(sourceClaudeMd, "utf-8");
-            // 글로벌 모드에서는 상대 경로를 절대 경로로 변환합니다
-            const sourceContent = options.isGlobal ? rawContent.replaceAll(".claude/skills/sonamu/", "~/.claude/skills/sonamu/") : rawContent;
-            if (await exists(targetClaudeMd)) {
-                const targetContent = await readFile(targetClaudeMd, "utf-8");
-                const startMarker = "<!-- SONAMU:START -->";
-                const endMarker = "<!-- SONAMU:END -->";
-                if (targetContent.includes(startMarker) && targetContent.includes(endMarker)) {
-                    const startIdx = targetContent.indexOf(startMarker);
-                    const endIdx = targetContent.indexOf(endMarker);
-                    if (startIdx !== -1 && endIdx !== -1 && startIdx < endIdx) {
-                        const before = targetContent.substring(0, startIdx);
-                        const after = targetContent.substring(endIdx + endMarker.length);
-                        const newContent = `${before}${startMarker}\n${sourceContent}\n${endMarker}${after}`;
-                        await writeFile(targetClaudeMd, newContent);
-                        console.log(chalk.green(`✓ CLAUDE.md updated (marker region)`));
-                    } else {
-                        console.log(chalk.yellow(`⏭ CLAUDE.md marker positions invalid, skipped`));
-                    }
-                } else {
-                    // 마커가 없는 기존 CLAUDE.md에 Sonamu 섹션을 추가합니다
-                    const appended = `${targetContent.trimEnd()}\n\n<!-- SONAMU:START -->\n${sourceContent}\n<!-- SONAMU:END -->\n`;
-                    await writeFile(targetClaudeMd, appended);
-                    console.log(chalk.green(`✓ CLAUDE.md updated (appended Sonamu section)`));
-                }
-            } else {
-                const withMarkers = `<!-- SONAMU:START -->\n${sourceContent}\n<!-- SONAMU:END -->\n`;
-                await writeFile(targetClaudeMd, withMarkers);
-                console.log(chalk.green(`✓ CLAUDE.md created`));
-            }
-        } catch (error) {
-            console.error(chalk.red(`✗ Failed to update CLAUDE.md: ${error instanceof Error ? error.message : String(error)}`));
-        }
-    }
+* claudeDir로 skills를 동기화하는 공통 로직입니다.
+*/
+async function skills_sync_to(claudeDir, sourceSkillsDir, sourceClaudeMd, options) {
+	const targetSkillsDir = path.join(claudeDir, "skills", "sonamu");
+	try {
+		await rm(targetSkillsDir, {
+			recursive: true,
+			force: true
+		});
+	} catch {}
+	await mkdir(path.dirname(targetSkillsDir), { recursive: true });
+	if (options.useSymlink) {
+		try {
+			await symlink(sourceSkillsDir, targetSkillsDir, "dir");
+			console.log(chalk.green(`✓ Skills linked (symlink)`));
+		} catch (error) {
+			console.log(chalk.yellow(`⚠ Symlink failed: ${error instanceof Error ? error.message : String(error)}`));
+			console.log(chalk.yellow(`  Falling back to copy...`));
+			await skillsCopy(sourceSkillsDir, targetSkillsDir);
+		}
+	} else {
+		await skillsCopy(sourceSkillsDir, targetSkillsDir);
+	}
+	if (options.copyProjectTemplates && options.sourceBase) {
+		const sourceProjectDir = path.join(options.sourceBase, "project");
+		const targetProjectDir = path.join(claudeDir, "skills", "project");
+		if (await exists(sourceProjectDir)) {
+			if (!await exists(targetProjectDir)) {
+				try {
+					await cp(sourceProjectDir, targetProjectDir, { recursive: true });
+					console.log(chalk.green(`✓ Project templates initialized`));
+				} catch (error) {
+					console.error(chalk.red(`✗ Failed to initialize project templates: ${error instanceof Error ? error.message : String(error)}`));
+				}
+			} else {
+				console.log(chalk.dim(`⏭ Project templates already exist (preserved)`));
+			}
+		}
+	}
+	if (options.copyProjectTemplates) {
+		const settingsLocalPath = path.join(claudeDir, "settings.local.json");
+		if (!await exists(settingsLocalPath)) {
+			try {
+				const settingsContent = { hooks: { PostToolUse: [{
+					matcher: "Edit|Write|MultiEdit",
+					hooks: [{
+						type: "command",
+						command: "pnpm check 2>&1 | head -60"
+					}]
+				}] } };
+				await writeFile(settingsLocalPath, `${JSON.stringify(settingsContent, null, 2)}\n`);
+				console.log(chalk.green(`✓ .claude/settings.local.json created`));
+			} catch (error) {
+				console.error(chalk.red(`✗ Failed to create settings.local.json: ${error instanceof Error ? error.message : String(error)}`));
+			}
+		} else {
+			console.log(chalk.dim(`⏭ .claude/settings.local.json already exists (preserved)`));
+		}
+	}
+	if (await exists(sourceClaudeMd)) {
+		try {
+			const targetClaudeMd = path.join(claudeDir, "CLAUDE.md");
+			const rawContent = await readFile(sourceClaudeMd, "utf-8");
+			const sourceContent = options.isGlobal ? rawContent.replaceAll(".claude/skills/sonamu/", "~/.claude/skills/sonamu/") : rawContent;
+			if (await exists(targetClaudeMd)) {
+				const targetContent = await readFile(targetClaudeMd, "utf-8");
+				const startMarker = "<!-- SONAMU:START -->";
+				const endMarker = "<!-- SONAMU:END -->";
+				if (targetContent.includes(startMarker) && targetContent.includes(endMarker)) {
+					const startIdx = targetContent.indexOf(startMarker);
+					const endIdx = targetContent.indexOf(endMarker);
+					if (startIdx !== -1 && endIdx !== -1 && startIdx < endIdx) {
+						const before = targetContent.substring(0, startIdx);
+						const after = targetContent.substring(endIdx + endMarker.length);
+						const newContent = `${before}${startMarker}\n${sourceContent}\n${endMarker}${after}`;
+						await writeFile(targetClaudeMd, newContent);
+						console.log(chalk.green(`✓ CLAUDE.md updated (marker region)`));
+					} else {
+						console.log(chalk.yellow(`⏭ CLAUDE.md marker positions invalid, skipped`));
+					}
+				} else {
+					const appended = `${targetContent.trimEnd()}\n\n<!-- SONAMU:START -->\n${sourceContent}\n<!-- SONAMU:END -->\n`;
+					await writeFile(targetClaudeMd, appended);
+					console.log(chalk.green(`✓ CLAUDE.md updated (appended Sonamu section)`));
+				}
+			} else {
+				const withMarkers = `<!-- SONAMU:START -->\n${sourceContent}\n<!-- SONAMU:END -->\n`;
+				await writeFile(targetClaudeMd, withMarkers);
+				console.log(chalk.green(`✓ CLAUDE.md created`));
+			}
+		} catch (error) {
+			console.error(chalk.red(`✗ Failed to update CLAUDE.md: ${error instanceof Error ? error.message : String(error)}`));
+		}
+	}
 }
 async function skillsCopy(src, dest) {
-    try {
-        await cp(src, dest, {
-            recursive: true
-        });
-        console.log(chalk.green(`✓ Skills copied`));
-    } catch (copyError) {
-        console.error(chalk.red(`✗ Failed to copy skills: ${copyError instanceof Error ? copyError.message : String(copyError)}`));
-        throw copyError;
-    }
+	try {
+		await cp(src, dest, { recursive: true });
+		console.log(chalk.green(`✓ Skills copied`));
+	} catch (copyError) {
+		console.error(chalk.red(`✗ Failed to copy skills: ${copyError instanceof Error ? copyError.message : String(copyError)}`));
+		throw copyError;
+	}
 }
 /**
- * pnpm sonamu skills create <name> 하면 실행되는 함수입니다.
- * 로컬 skill 초안을 생성합니다.
- */ async function skills_create(name) {
-    const workspaceRoot = await findWorkspaceRoot();
-    const localDir = path.join(workspaceRoot, ".claude", "skills", "local");
-    // === 파일명 검증 및 Sanitize ===
-    if (!name || name.trim() === "") {
-        console.error(chalk.red("✗ Skill name is required"));
-        return;
-    }
-    let sanitized = name// 공백을 하이픈으로
-    .replace(/\s+/g, "-")// 경로 구분자 제거
-    .replace(/[/\\]/g, "-")// Path traversal 방지
-    .replace(/\.\./g, "")// Windows 금지 문자 제거
-    .replace(/[<>:"|?*]/g, "")// 시작/끝 점, 하이픈, 언더스코어 제거
-    .replace(/^[.\-_]+|[.\-_]+$/g, "")// 연속된 하이픈을 하나로
-    .replace(/-+/g, "-")// 알파벳, 숫자, 하이픈, 언더스코어, 한글만 허용
-    .replace(/[^a-zA-Z0-9-_가-힣]/g, "");
-    // 길이 제한
-    const MAX_LENGTH = 100;
-    if (sanitized.length > MAX_LENGTH) {
-        sanitized = sanitized.substring(0, MAX_LENGTH);
-        console.log(chalk.yellow(`⚠ Name truncated to ${MAX_LENGTH} characters`));
-    }
-    // Windows 예약어 확인
-    const RESERVED_NAMES = [
-        "CON",
-        "PRN",
-        "AUX",
-        "NUL",
-        "COM1",
-        "COM2",
-        "COM3",
-        "COM4",
-        "COM5",
-        "COM6",
-        "COM7",
-        "COM8",
-        "COM9",
-        "LPT1",
-        "LPT2",
-        "LPT3",
-        "LPT4",
-        "LPT5",
-        "LPT6",
-        "LPT7",
-        "LPT8",
-        "LPT9"
-    ];
-    if (RESERVED_NAMES.includes(sanitized.toUpperCase())) {
-        sanitized = `skill-${sanitized}`;
-        console.log(chalk.yellow(`⚠ Reserved name detected, prefixed with "skill-"`));
-    }
-    // 빈 문자열 체크
-    if (sanitized === "") {
-        console.error(chalk.red("✗ Invalid skill name after sanitization"));
-        console.log(chalk.dim(`  Original: "${name}"`));
-        return;
-    }
-    // 변경 알림
-    if (sanitized !== name) {
-        console.log(chalk.yellow(`⚠ Name sanitized: "${name}" → "${sanitized}"`));
-    }
-    const filePath = path.join(localDir, `${sanitized}.md`);
-    if (await exists(filePath)) {
-        console.log(chalk.yellow(`Skill "${sanitized}" already exists.`));
-        return;
-    }
-    await mkdir(localDir, {
-        recursive: true
-    });
-    const template = `---
+* pnpm sonamu skills create <name> 하면 실행되는 함수입니다.
+* 로컬 skill 초안을 생성합니다.
+*/
+async function skills_create(name) {
+	const workspaceRoot = await findWorkspaceRoot();
+	const localDir = path.join(workspaceRoot, ".claude", "skills", "local");
+	if (!name || name.trim() === "") {
+		console.error(chalk.red("✗ Skill name is required"));
+		return;
+	}
+	let sanitized = name.replace(/\s+/g, "-").replace(/[/\\]/g, "-").replace(/\.\./g, "").replace(/[<>:"|?*]/g, "").replace(/^[.\-_]+|[.\-_]+$/g, "").replace(/-+/g, "-").replace(/[^a-zA-Z0-9-_가-힣]/g, "");
+	const MAX_LENGTH = 100;
+	if (sanitized.length > MAX_LENGTH) {
+		sanitized = sanitized.substring(0, MAX_LENGTH);
+		console.log(chalk.yellow(`⚠ Name truncated to ${MAX_LENGTH} characters`));
+	}
+	const RESERVED_NAMES = [
+		"CON",
+		"PRN",
+		"AUX",
+		"NUL",
+		"COM1",
+		"COM2",
+		"COM3",
+		"COM4",
+		"COM5",
+		"COM6",
+		"COM7",
+		"COM8",
+		"COM9",
+		"LPT1",
+		"LPT2",
+		"LPT3",
+		"LPT4",
+		"LPT5",
+		"LPT6",
+		"LPT7",
+		"LPT8",
+		"LPT9"
+	];
+	if (RESERVED_NAMES.includes(sanitized.toUpperCase())) {
+		sanitized = `skill-${sanitized}`;
+		console.log(chalk.yellow(`⚠ Reserved name detected, prefixed with "skill-"`));
+	}
+	if (sanitized === "") {
+		console.error(chalk.red("✗ Invalid skill name after sanitization"));
+		console.log(chalk.dim(`  Original: "${name}"`));
+		return;
+	}
+	if (sanitized !== name) {
+		console.log(chalk.yellow(`⚠ Name sanitized: "${name}" → "${sanitized}"`));
+	}
+	const filePath = path.join(localDir, `${sanitized}.md`);
+	if (await exists(filePath)) {
+		console.log(chalk.yellow(`Skill "${sanitized}" already exists.`));
+		return;
+	}
+	await mkdir(localDir, { recursive: true });
+	const template = `---
 name: ${sanitized}
 category: other
 created_at: ${new Date().toISOString().split("T")[0]}
@@ -1228,84 +1091,80 @@ status: draft
 // 예시 코드
 \`\`\`
 `;
-    await writeFile(filePath, template);
-    console.log(chalk.green(`✓ Created .claude/skills/local/${sanitized}.md`));
+	await writeFile(filePath, template);
+	console.log(chalk.green(`✓ Created .claude/skills/local/${sanitized}.md`));
 }
 /**
- * pnpm sonamu auth generate 하면 실행되는 함수입니다.
- * better-auth 엔티티들(User, Session, Account, Verification)을 생성합니다.
- *
- * 옵션:
- * --plugins phone-number,2fa  플러그인 엔티티도 함께 생성
- */ async function auth_generate() {
-    // --plugins 옵션 파싱
-    const pluginsArg = process.argv.find((arg)=>arg.startsWith("--plugins"));
-    const plugins = [];
-    if (pluginsArg) {
-        const pluginValue = pluginsArg.includes("=") ? pluginsArg.split("=")[1] : process.argv[process.argv.indexOf(pluginsArg) + 1];
-        if (pluginValue) {
-            const pluginIds = pluginValue.split(",").map((p)=>p.trim());
-            for (const id of pluginIds){
-                if (isValidPluginId(id)) {
-                    plugins.push(id);
-                } else {
-                    console.log(chalk.yellow(`⚠ Unknown plugin: ${id}`));
-                    console.log(chalk.dim(`  Supported plugins: ${SUPPORTED_PLUGIN_IDS.join(", ")}`));
-                }
-            }
-        }
-    }
-    console.log(chalk.yellow.bold("🔐 Generating better-auth entities...\n"));
-    if (plugins.length > 0) {
-        console.log(chalk.dim(`  Plugins: ${plugins.join(", ")}`));
-    }
-    await generateBetterAuthEntities({
-        plugins
-    });
+* pnpm sonamu auth generate 하면 실행되는 함수입니다.
+* better-auth 엔티티들(User, Session, Account, Verification)을 생성합니다.
+*
+* 옵션:
+* --plugins phone-number,2fa  플러그인 엔티티도 함께 생성
+*/
+async function auth_generate() {
+	const pluginsArg = process.argv.find((arg) => arg.startsWith("--plugins"));
+	const plugins = [];
+	if (pluginsArg) {
+		const pluginValue = pluginsArg.includes("=") ? pluginsArg.split("=")[1] : process.argv[process.argv.indexOf(pluginsArg) + 1];
+		if (pluginValue) {
+			const pluginIds = pluginValue.split(",").map((p) => p.trim());
+			for (const id of pluginIds) {
+				if (isValidPluginId(id)) {
+					plugins.push(id);
+				} else {
+					console.log(chalk.yellow(`⚠ Unknown plugin: ${id}`));
+					console.log(chalk.dim(`  Supported plugins: ${SUPPORTED_PLUGIN_IDS.join(", ")}`));
+				}
+			}
+		}
+	}
+	console.log(chalk.yellow.bold("🔐 Generating better-auth entities...\n"));
+	if (plugins.length > 0) {
+		console.log(chalk.dim(`  Plugins: ${plugins.join(", ")}`));
+	}
+	await generateBetterAuthEntities({ plugins });
 }
 /**
- * pnpm sonamu auth add-companions 하면 실행되는 함수입니다.
- * 기존 프로젝트의 entity.json에 fixtureCompanions를 소급 추가합니다.
- *
- * 이미 fixtureCompanions가 있는 entity는 스킵합니다 (덮어쓰기 없음).
- */ async function auth_add_companions() {
-    console.log(chalk.yellow.bold("🔐 Adding fixtureCompanions to better-auth entities...\n"));
-    await addCompanionsToEntities();
-    console.log(chalk.bold("\n✅ Done!"));
+* pnpm sonamu auth add-companions 하면 실행되는 함수입니다.
+* 기존 프로젝트의 entity.json에 fixtureCompanions를 소급 추가합니다.
+*
+* 이미 fixtureCompanions가 있는 entity는 스킵합니다 (덮어쓰기 없음).
+*/
+async function auth_add_companions() {
+	console.log(chalk.yellow.bold("🔐 Adding fixtureCompanions to better-auth entities...\n"));
+	await addCompanionsToEntities();
+	console.log(chalk.bold("\n✅ Done!"));
 }
 /**
- * 워크스페이스 루트를 찾습니다.
- * 우선순위: pnpm-workspace.yaml > package.json(workspaces) > .agents/
- *
- * CLAUDE.md는 서브패키지에도 존재할 수 있으므로 사용하지 않습니다.
- * .agents/는 agents init이 생성하는 디렉토리로, 워크스페이스 루트에만 존재합니다.
- */ async function findWorkspaceRoot() {
-    let dir = process.cwd();
-    while(dir !== path.dirname(dir)){
-        // 1. pnpm-workspace.yaml: 확실한 monorepo 루트.
-        if (await exists(path.join(dir, "pnpm-workspace.yaml"))) {
-            return dir;
-        }
-        // 2. package.json에 workspaces 필드가 있으면 monorepo 루트.
-        const packagePath = path.join(dir, "package.json");
-        if (await exists(packagePath)) {
-            try {
-                const packageJson = JSON.parse(await readFile(packagePath, "utf-8"));
-                if (packageJson.workspaces) {
-                    return dir;
-                }
-            } catch  {
-            // 파싱 실패시 무시
-            }
-        }
-        // 3. .agents/: agents init이 생성한 디렉토리. 서브패키지에는 존재하지 않음.
-        if (await exists(path.join(dir, ".agents"))) {
-            return dir;
-        }
-        dir = path.dirname(dir);
-    }
-    // 찾지 못하면 api 폴더의 부모 사용
-    return findAppRootPath();
+* 워크스페이스 루트를 찾습니다.
+* 우선순위: pnpm-workspace.yaml > package.json(workspaces) > .agents/
+*
+* CLAUDE.md는 서브패키지에도 존재할 수 있으므로 사용하지 않습니다.
+* .agents/는 agents init이 생성하는 디렉토리로, 워크스페이스 루트에만 존재합니다.
+*/
+async function findWorkspaceRoot() {
+	let dir = process.cwd();
+	while (dir !== path.dirname(dir)) {
+		if (await exists(path.join(dir, "pnpm-workspace.yaml"))) {
+			return dir;
+		}
+		const packagePath = path.join(dir, "package.json");
+		if (await exists(packagePath)) {
+			try {
+				const packageJson = JSON.parse(await readFile(packagePath, "utf-8"));
+				if (packageJson.workspaces) {
+					return dir;
+				}
+			} catch {}
+		}
+		if (await exists(path.join(dir, ".agents"))) {
+			return dir;
+		}
+		dir = path.dirname(dir);
+	}
+	return findAppRootPath();
 }
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/bin/cli.ts"],"sourcesContent":["import chalk from \"chalk\";\nimport dotenv from \"dotenv\";\n\ndotenv.config();\n\nimport assert from \"assert\";\nimport { execSync, spawn } from \"child_process\";\nimport { cp, mkdir, readdir, readFile, rm, symlink, writeFile } from \"fs/promises\";\nimport knex, { type Knex } from \"knex\";\nimport { createRequire } from \"module\";\nimport os from \"os\";\nimport path from \"path\";\nimport process from \"process\";\nimport { tsicli } from \"tsicli\";\nimport { Sonamu } from \"../api\";\nimport { addCompanionsToEntities, generateBetterAuthEntities } from \"../auth/auth-generator\";\nimport {\n  type BetterAuthPluginId,\n  isValidPluginId,\n  SUPPORTED_PLUGIN_IDS,\n} from \"../auth/plugins/entity-definitions\";\nimport type { SonamuDBConfig } from \"../database/db\";\nimport { EntityManager } from \"../entity/entity-manager\";\nimport { Migrator } from \"../migration/migrator\";\nimport { FixtureManager } from \"../testing/fixture-manager\";\nimport {\n  execWithLinePrefix,\n  printBuildSummary,\n  printTaskFailed,\n  printTaskHeader,\n  printTaskStart,\n  printTaskSuccess,\n} from \"../utils/console-util\";\nimport { exists } from \"../utils/fs-utils\";\nimport { findApiRootPath, findAppRootPath } from \"../utils/utils\";\nimport { API_ARTIFACTS, type BuildArtifact, WEB_ARTIFACTS } from \"./build-config\";\nimport { fixtureExploreCommand, fixtureFetchCommand, fixtureGenCommand } from \"./fixture\";\nimport { testCommand } from \"./test-command\";\n\nlet migrator: Migrator;\n\n/**\n * CLI 옵션을 파싱하는 헬퍼 함수\n */\nfunction parseCliOptions(argv: string[] = process.argv): {\n  flags: Set<string>; // --regenerate, --ai, --no-cones 등\n  options: Record<string, string>; // --locale ko 등\n} {\n  const flags = new Set<string>();\n  const options: Record<string, string> = {};\n\n  for (let i = 0; i < argv.length; i++) {\n    const arg = argv[i];\n    if (!arg.startsWith(\"--\")) continue;\n\n    // --option=value 형식\n    if (arg.includes(\"=\")) {\n      const [key, value] = arg.slice(2).split(\"=\");\n      options[key] = value;\n      continue;\n    }\n\n    // --option value 형식인지 확인\n    const nextArg = argv[i + 1];\n    if (nextArg && !nextArg.startsWith(\"--\") && !nextArg.startsWith(\"-\")) {\n      options[arg.slice(2)] = nextArg;\n      i++; // 다음 arg는 값이므로 스킵\n    } else {\n      // --flag 형식\n      flags.add(arg.slice(2));\n    }\n  }\n\n  return { flags, options };\n}\n\nasync function bootstrap() {\n  const notToInit = [\"dev\", \"build\", \"start\", \"skills\", \"test\"].includes(process.argv[2] ?? \"\");\n  if (!notToInit) {\n    await Sonamu.init(false, false);\n  }\n\n  try {\n    // tsicli는 정확한 명령어 매칭만 지원하므로, --로 시작하는 옵션과 그 값을 필터링합니다.\n    // 옵션 파싱은 각 runner 함수에서 원본 process.argv를 사용하여 수행합니다.\n    // \"--\"(bare double dash)는 passthrough 구분자이므로, 그 뒤의 모든 인자도 제외합니다.\n    const filteredArgv: string[] = [];\n    let skipNext = false;\n    let afterDoubleDash = false;\n    for (let i = 0; i < process.argv.length; i++) {\n      const arg = process.argv[i];\n      if (arg === \"--\") {\n        afterDoubleDash = true;\n        continue;\n      }\n      if (afterDoubleDash) continue;\n      if (skipNext) {\n        skipNext = false;\n        continue;\n      }\n      if (arg.startsWith(\"--\")) {\n        // --option=value 형식은 이 arg만 스킵\n        if (arg.includes(\"=\")) {\n          continue;\n        }\n        // --option value 형식인지 확인: 다음 arg가 --로 시작하지 않으면 값이 있는 것\n        const nextArg = process.argv[i + 1];\n        if (nextArg && !nextArg.startsWith(\"--\") && !nextArg.startsWith(\"-\")) {\n          skipNext = true;\n        }\n        continue;\n      }\n      filteredArgv.push(arg);\n    }\n\n    // build/dev 명령어가 서브커맨드 없이 호출될 때 \"all\"을 기본값으로 추가합니다.\n    // 예: `sonamu build` → `sonamu build all`, `sonamu dev` → `sonamu dev all`\n    const cmd = filteredArgv[2];\n    if ((cmd === \"build\" || cmd === \"dev\") && filteredArgv.length === 3) {\n      filteredArgv.push(\"all\");\n    }\n\n    // test 커맨드는 가변 인자(파일명, --pattern 등)를 받으므로 tsicli를 우회합니다.\n    if (cmd === \"test\") {\n      return testCommand();\n    }\n\n    await tsicli(filteredArgv, {\n      types: {\n        \"#entityId\": {\n          type: \"autocomplete\",\n          name: \"#entityId\",\n          message: \"Please input #entityId\",\n          choices: EntityManager.getAllParentIds().map((entityId) => ({\n            title: entityId,\n            value: entityId,\n          })),\n        },\n        \"#recordIds\": \"number[]\",\n        \"#name\": \"string\",\n        \"#targets\": {\n          type: \"multiselect\",\n          name: \"#targets\",\n          message: \"Please input #targets\",\n          choices: [\n            { title: \"Development\", value: \"development_master\" },\n            { title: \"Production\", value: \"production_master\" },\n            { title: \"Fixture\", value: \"fixture\" },\n            { title: \"Test\", value: \"test\" },\n          ],\n        },\n      },\n      args: [\n        [\"fixture\", \"init\"],\n        [\"fixture\", \"import\", \"#entityId\", \"#recordIds\"],\n        [\"fixture\", \"sync\"],\n        [\"fixture\", \"gen\"],\n        [\"fixture\", \"fetch\"],\n        [\"fixture\", \"explore\"],\n        [\"migrate\", \"run\"],\n        [\"migrate\", \"apply\", \"#targets\"],\n        [\"migrate\", \"generate\"],\n        [\"migrate\", \"status\"],\n        [\"stub\", \"practice\", \"#name\"],\n        [\"stub\", \"entity\", \"#name\"],\n        [\"scaffold\", \"model\", \"#entityId\"],\n        [\"scaffold\", \"model_test\", \"#entityId\"],\n        [\"scaffold\", \"view_list\", \"#entityId\"],\n        [\"scaffold\", \"view_form\", \"#entityId\"],\n        [\"cone\", \"gen\", \"#entityId\"],\n        [\"sync\"],\n        [\"build\", \"all\"],\n        [\"build\", \"api\"],\n        [\"build\", \"web\"],\n        [\"dev\", \"all\"],\n        [\"dev\", \"api\"],\n        [\"dev\", \"web\"],\n        [\"start\"],\n        [\"skills\", \"sync\"],\n        [\"skills\", \"create\", \"#name\"],\n        [\"test\"],\n        [\"auth\", \"generate\"],\n        [\"auth\", \"add-companions\"],\n      ],\n      runners: {\n        migrate_status,\n        migrate_run,\n        migrate_apply,\n        migrate_generate,\n        fixture_init,\n        fixture_import,\n        fixture_sync,\n        fixture_gen,\n        fixture_fetch,\n        fixture_explore,\n        stub_practice,\n        stub_entity,\n        scaffold_model,\n        scaffold_model_test,\n        // scaffold_view_list,\n        // scaffold_view_form,\n        cone_gen,\n        sync,\n        build_all,\n        build_api,\n        build_web,\n        dev_all,\n        dev_api,\n        dev_web,\n        start,\n        skills_sync,\n        skills_create,\n        test: testCommand,\n        auth_generate,\n        \"auth_add-companions\": auth_add_companions,\n      },\n    });\n  } finally {\n    await Sonamu.destroy();\n  }\n}\n\nbootstrap().finally(async () => {\n  await FixtureManager.destroy();\n});\n\n/**\n * pnpm sync 하면 실행되는 함수입니다.\n * 프로젝트를 싱크합니다.\n */\nasync function sync() {\n  await Sonamu.syncer.sync();\n}\n\n/**\n * API 개발 서버를 실행하는 공통 로직입니다.\n * dev_all과 dev_api에서 공유합니다.\n *\n * TypeScript를 바로 실행할 수 있도록 @sonamu-kit/ts-loader를,\n * HMR을 지원하기 위해 @sonamu-kit/hmr-hook을 import하며,\n * 소스맵 지원을 위해 --enable-source-maps 플래그를 포함하여 실행합니다.\n *\n * 이때 @sonamu-kit/ts-loader와 @sonamu-kit/hmr-hook는 sonamu가 자체적으로 가지고 있는 dependency입니다.\n * 또한 실행에 사용하는 @sonamu-kit/hmr-runner도 마찬가지로 sonamu가 자체적으로 가지고 있는 dependency입니다.\n * 따라서 사용자 프로젝트에서는 이 세 패키지를 직접 설치할 필요가 없습니다.\n */\nfunction spawnApiDevServer(options?: { extraEnv?: Record<string, string> }) {\n  const apiRoot = findApiRootPath();\n  const entryPoint = \"src/index.ts\";\n\n  // 이 sonamu 패키지가 dependencies로 가지고 있는 @sonamu-kit/hmr-runner의 bin/run.js를 사용합니다.\n  // 이 경로(/bin/run.js)는 @sonamu-kit/hmr-runner의 package.json의 bin 필드에 명시되어 있는 그것과 같습니다.\n  const hotRunnerBinPath = createRequire(import.meta.url).resolve(\n    \"@sonamu-kit/hmr-runner/bin/run.js\",\n  );\n\n  const serverProcess = spawn(\n    process.execPath, // node\n    [\n      hotRunnerBinPath, // 이렇게 해서 hot-runner를 실행하구요\n      \"--clear-screen=false\", // 이하 hot-runner에게 넘겨줄 인자들입니다.\n      \"--node-args=--import=sonamu/ts-loader-register\", // TypeScript 서포트를 위한 로더,\n      \"--node-args=--import=sonamu/hmr-hook-register\", // HMR을 지원하기 위한 hook,\n      \"--node-args=--enable-source-maps\", // 그리고 소스맵 지원을 위한 플래그입니다.\n      \"--on-key=r:restart:Restart server\", // r 누르면 서버 재시작하게 해줘요.\n      \"--on-key=c:clear:Clear screen\", // c 누르면 터미널 화면을 지워줘요.\n      `--on-key=f:shell(rm ${path.join(apiRoot, \"sonamu.lock\")}):restart:Force restart`, // f 누르면 sonamu.lock 파일을 지우고 서버 재시작하게 해줘요.\n\n      \"--on-key=enter:shell(echo hi):Key binding test\", // enter를 key로 쓸 수 있음을 보이기 위한 테스트입니다.\n      \"--on-key=ctrl+f ctrl+f:shell(git pull && pnpm install && pnpm --filter sonamu build && echo 'Sonamu is now up-to-date!'):restart:Pull & install & build & restart\", // modifier와의 조합, 그리고 두 개의 chord를 사용할 수 있음을 보이기 위한 테스트입니다.\n      entryPoint, // 마지막으로 실제 실행할 스크립트의 경로를 넘겨줍니다.\n    ],\n    {\n      cwd: apiRoot,\n      stdio: \"inherit\",\n      env: {\n        ...process.env,\n        NODE_ENV: \"development\",\n        HOT: \"yes\", // 얘가 있어야 HMR이 활성화됩니다.\n        API_ROOT_PATH: apiRoot, // 이 경로가 hmr-hook의 루트 디렉토리가 됩니다.\n        ...options?.extraEnv,\n      },\n    },\n  );\n\n  // 종료 처리\n  const cleanup = () => {\n    console.log(chalk.yellow(\"\\n\\n👋 Shutting down...\"));\n    serverProcess.kill(\"SIGTERM\");\n    process.exit(0);\n  };\n\n  process.on(\"SIGINT\", cleanup);\n  process.on(\"SIGTERM\", cleanup);\n\n  serverProcess.on(\"exit\", (code) => {\n    if (code !== 0) {\n      console.error(chalk.red(`Server exited with code ${code}`));\n      process.exit(code || 1);\n    }\n  });\n}\n\n/**\n * pnpm dev / pnpm dev all 하면 실행되는 함수입니다.\n * 프로젝트에 대해 HMR 지원하는 개발 서버를 띄워줍니다.\n *\n * Sonamu.init 없이 호출될 것을 상정하여 구현되었습니다.\n */\nfunction dev_all() {\n  console.log(chalk.yellow.bold(\"Starting Sonamu dev server...\\n\"));\n  spawnApiDevServer();\n}\n\n/**\n * pnpm dev api 하면 실행되는 함수입니다.\n * API 전용 개발 서버를 띄웁니다.\n * dev_all과 거의 동일하되, 통합 웹 서버를 비활성화합니다.\n *\n * Sonamu.init 없이 호출될 것을 상정하여 구현되었습니다.\n */\nfunction dev_api() {\n  console.log(chalk.yellow.bold(\"Starting Sonamu API-only dev server...\\n\"));\n  spawnApiDevServer({\n    extraEnv: { SONAMU_DISABLE_INTEGRATED_WEB: \"yes\" },\n  });\n}\n\n/**\n * pnpm dev web 하면 실행되는 함수입니다.\n * Vite 개발 서버를 단독으로 실행합니다.\n * -- 뒤의 인자는 Vite에 그대로 전달됩니다.\n *\n * Sonamu.init 없이 호출될 것을 상정하여 구현되었습니다.\n */\nasync function dev_web() {\n  const appRoot = findAppRootPath();\n  const webPath = path.join(appRoot, \"web\");\n\n  if (!(await exists(webPath))) {\n    console.error(`web 디렉토리를 찾을 수 없습니다: ${webPath}`);\n    process.exit(1);\n  }\n\n  // -- 뒤의 인자 추출\n  const doubleDashIndex = process.argv.indexOf(\"--\");\n  const passthroughArgs = doubleDashIndex !== -1 ? process.argv.slice(doubleDashIndex + 1) : [];\n\n  const viteArgs = [\"exec\", \"vite\", ...passthroughArgs];\n\n  console.log(chalk.yellow.bold(\"Starting Vite dev server...\\n\"));\n\n  const viteProcess = spawn(\"pnpm\", viteArgs, {\n    cwd: webPath,\n    stdio: \"inherit\",\n  });\n\n  viteProcess.on(\"exit\", (code) => {\n    process.exit(code ?? 0);\n  });\n\n  // SIGINT/SIGTERM 시 Vite 프로세스를 gracefully 종료합니다.\n  for (const signal of [\"SIGINT\", \"SIGTERM\"] as const) {\n    process.on(signal, () => {\n      viteProcess.kill(signal);\n    });\n  }\n}\n\n/**\n * SWC 설정 파일 경로를 결정합니다. API 빌드(SWC)에서만 사용됩니다.\n * 프로젝트 루트에 .swcrc가 있으면 그것을, 없으면 sonamu 기본 설정을 사용합니다.\n */\nasync function resolveSwcConfigPath(): Promise<string> {\n  let swcFilePath = \".swcrc\";\n  try {\n    if (await exists(swcFilePath)) {\n      console.log(chalk.dim(\"Using .swcrc from project root...\"));\n    } else {\n      console.log(chalk.dim(\"Using default .swcrc from sonamu package...\"));\n      swcFilePath = path.join(import.meta.dirname, \"..\", \"..\", \".swcrc.project-default\");\n    }\n  } catch (error) {\n    console.error(chalk.red(\"Setting up swc config file failed.\"), error);\n    process.exit(1);\n  }\n  return swcFilePath;\n}\n\n/**\n * sonamu build / sonamu build all 하면 실행되는 함수입니다.\n * build_api + build_web의 합성입니다. Web 디렉토리가 없으면 Web 빌드를 스킵합니다.\n */\nasync function build_all() {\n  await build_api();\n  await build_web({ skipIfMissing: true });\n}\n\n/**\n * pnpm build api 하면 실행되는 함수입니다.\n * API 프로젝트만 빌드합니다.\n *\n * Sonamu.init 없이 호출될 것을 상정하여 구현되었습니다.\n */\nasync function build_api() {\n  const appRoot = findAppRootPath();\n  const swcFilePath = await resolveSwcConfigPath();\n\n  const apiStartedAt = Date.now();\n  try {\n    for (const artifact of API_ARTIFACTS) {\n      const cwd = path.join(appRoot, artifact.projectPath);\n      printTaskHeader(artifact.name, artifact.description, cwd);\n\n      await runBuildSteps(artifact, { cwd, buildCommandArgs: { configFilePath: swcFilePath } });\n    }\n    printBuildSummary(\"API\", true, Date.now() - apiStartedAt);\n  } catch (e) {\n    printBuildSummary(\"API\", false, Date.now() - apiStartedAt);\n    console.error(e);\n    process.exit(1);\n  }\n}\n\n/**\n * pnpm build web 하면 실행되는 함수입니다.\n * Web 프로젝트만 빌드합니다.\n *\n * Sonamu.init 없이 호출될 것을 상정하여 구현되었습니다.\n */\nasync function build_web({ skipIfMissing = false } = {}) {\n  const appRoot = findAppRootPath();\n  const webPath = path.join(appRoot, \"web\");\n\n  if (!(await exists(webPath))) {\n    if (skipIfMissing) {\n      console.log(chalk.gray(\"Web 디렉토리가 없으므로 Web 빌드를 건너뜁니다.\"));\n      return;\n    }\n    console.error(`web 디렉토리를 찾을 수 없습니다: ${webPath}`);\n    process.exit(1);\n  }\n\n  const webStartedAt = Date.now();\n  try {\n    for (const artifact of WEB_ARTIFACTS) {\n      const cwd = path.join(appRoot, artifact.projectPath);\n      printTaskHeader(artifact.name, artifact.description, cwd);\n\n      await runBuildSteps(artifact, { cwd, buildCommandArgs: {} });\n    }\n    printBuildSummary(\"Web\", true, Date.now() - webStartedAt);\n  } catch (e) {\n    printBuildSummary(\"Web\", false, Date.now() - webStartedAt);\n    console.error(e);\n    process.exit(1);\n  }\n}\n\n/**\n * pre-build, build, post-build 단계를 순차적으로 실행합니다.\n */\nasync function runBuildSteps<T>(\n  artifact: BuildArtifact<T>,\n  options: { cwd: string; buildCommandArgs: T },\n) {\n  const steps = [\n    { name: \"pre-build\", cmd: artifact.preBuildCommand?.() },\n    { name: \"build\", cmd: artifact.buildCommand(options.buildCommandArgs) },\n    { name: \"post-build\", cmd: artifact.postBuildCommand?.() },\n  ].filter((step) => step.cmd);\n\n  for (let i = 0; i < steps.length; i++) {\n    const step = steps[i];\n    const isLast = i === steps.length - 1;\n\n    try {\n      assert(step.cmd);\n      printTaskStart(step.name, step.cmd, isLast);\n      await execWithLinePrefix(step.cmd, { cwd: options.cwd });\n      printTaskSuccess(step.name, isLast);\n    } catch (e) {\n      printTaskFailed(step.name, isLast);\n      throw new Error(`${step.name} failed`, { cause: e });\n    }\n  }\n}\n\n/**\n * pnpm start 하면 실행되는 함수입니다.\n * 빌드된 프로젝트를 실행합니다.\n *\n * 빌드된 결과물(dist 디렉토리의 index.js 엔트리포인트)이 없다면 실행을 중단합니다.\n * 소스맵 지원과 dotenv 지원을 포함하여 실행합니다.\n *\n * Sonamu.init 없이 호출될 것을 상정하여 구현되었습니다.\n */\nasync function start() {\n  const apiRoot = findApiRootPath();\n  const entryPoint = \"dist/index.js\";\n\n  if (!(await exists(entryPoint))) {\n    console.log(chalk.red(`${entryPoint} not found. Please build your project first.`));\n    console.log(chalk.blue(\"Run: pnpm sonamu build\"));\n    return;\n  }\n\n  const { spawn } = await import(\"child_process\");\n  const serverProcess = spawn(\n    process.execPath,\n    [\"--enable-source-maps\", \"-r\", \"dotenv/config\", entryPoint],\n    {\n      cwd: apiRoot,\n      stdio: \"inherit\",\n    },\n  );\n\n  process.on(\"SIGINT\", () => {\n    serverProcess.kill(\"SIGTERM\");\n    process.exit(0);\n  });\n}\n\nasync function setupMigrator() {\n  // migrator\n  migrator = new Migrator();\n}\n\nasync function setupFixtureManager() {\n  FixtureManager.init();\n}\n\nasync function migrate_apply(targets: (keyof SonamuDBConfig)[]) {\n  await setupMigrator();\n  await migrator.runAction(\"apply\", targets);\n}\n\nasync function migrate_run() {\n  await setupMigrator();\n  const localHosts = [\"localhost\", \"127.0.0.1\", \"0.0.0.0\", \"::1\"];\n  const targets = Object.keys(Sonamu.dbConfig).filter((target) => {\n    const targetConfig = Sonamu.dbConfig[target as keyof SonamuDBConfig];\n    const host = (targetConfig?.connection as { host?: string })?.host ?? \"localhost\";\n    return localHosts.includes(host.toLowerCase());\n  });\n\n  // 로컬 데이터베이스에 대해서만 전체 마이그레이션에서 동작\n  await migrator.runAction(\"apply\", targets as (keyof SonamuDBConfig)[]);\n}\n\nasync function migrate_generate() {\n  await setupMigrator();\n\n  const { conns } = await migrator.getStatus();\n  const hasStatus0 = conns.some((conn) => conn.status === 0);\n  if (!hasStatus0) {\n    console.log(\n      chalk.red(\n        \"마이그레이션 파일을 생성하려면 기존 마이그레이션이 최소 하나의 DB에 모두 적용되어 있어야 합니다.\",\n      ),\n    );\n    for (const conn of conns) {\n      if (conn.pending.length > 0) {\n        console.log(chalk.yellow(`  ${conn.name}: pending ${conn.pending.length}개`));\n      }\n    }\n    process.exit(1);\n  }\n\n  const count = await migrator.generatePreparedCodes();\n  if (count > 0) {\n    console.log(chalk.green(`${count}개의 마이그레이션 파일이 생성되었습니다.`));\n  }\n}\n\nasync function migrate_status() {\n  await setupMigrator();\n\n  const status = await migrator.getStatus();\n  // status;\n  console.log(status);\n}\n\nasync function fixture_init() {\n  const srcConfig = Sonamu.dbConfig.development_master;\n  const targets = [\n    {\n      label: \"(REMOTE) Fixture DB\",\n      config: Sonamu.dbConfig.fixture,\n    },\n    {\n      label: \"(LOCAL) Testing DB\",\n      config: Sonamu.dbConfig.test,\n      toSkip: (() => {\n        const remoteConn = Sonamu.dbConfig.fixture.connection as Knex.ConnectionConfig;\n        const localConn = Sonamu.dbConfig.test.connection as Knex.ConnectionConfig;\n        return remoteConn.host === localConn.host && remoteConn.database === localConn.database;\n      })(),\n    },\n  ] as {\n    label: string;\n    config: Knex.Config;\n    toSkip?: boolean;\n  }[];\n\n  // 1. 기준DB 스키마를 덤프\n  console.log(\"DUMP...\");\n  const dumpFilename = `/tmp/sonamu-fixture-init-${Date.now()}.sql`;\n  const srcConn = srcConfig.connection as Knex.ConnectionConfig;\n  const migrationsDump = `/tmp/sonamu-fixture-init-migrations-${Date.now()}.sql`;\n  execSync(\n    `mysqldump -h${srcConn.host} -u${srcConn.user} -p${srcConn.password} --single-transaction -d --no-create-db --triggers ${srcConn.database} > ${dumpFilename}`,\n  );\n  const _db = knex(srcConfig);\n  const [[migrations]] = await _db.raw(\n    \"SELECT COUNT(*) as count FROM information_schema.tables WHERE table_schema = ? AND table_name = 'knex_migrations'\",\n    [srcConn.database],\n  );\n  if (migrations.count > 0) {\n    execSync(\n      `mysqldump -h${srcConn.host} -u${srcConn.user} -p${srcConn.password} --single-transaction --no-create-db --triggers ${srcConn.database} knex_migrations knex_migrations_lock > ${migrationsDump}`,\n    );\n  }\n\n  // 2. 대상DB 각각에 대하여 존재여부 확인 후 붓기\n  for await (const { label, config, toSkip } of targets) {\n    const conn = config.connection as Knex.ConnectionConfig;\n\n    if (toSkip === true) {\n      console.log(chalk.red(`${label}: Skipped!`));\n      continue;\n    }\n\n    const db = knex({\n      ...config,\n      connection: {\n        ...((config.connection ?? {}) as Knex.ConnectionConfig),\n        database: undefined,\n      },\n    });\n    const [[row]] = await db.raw(`SHOW DATABASES LIKE \"${conn.database}\"`);\n    if (row) {\n      console.log(chalk.yellow(`${label}: Database \"${conn.database}\" Already exists`));\n      await db.destroy();\n      continue;\n    }\n\n    console.log(`SYNC to ${label}...`);\n    const mysqlCmd = `mysql -h${conn.host} -u${conn.user} -p${conn.password}`;\n    execSync(`${mysqlCmd} -e 'DROP DATABASE IF EXISTS \\`${conn.database}\\`'`);\n    execSync(`${mysqlCmd} -e 'CREATE DATABASE \\`${conn.database}\\`'`);\n    execSync(`${mysqlCmd} ${conn.database} < ${dumpFilename}`);\n    if (await exists(migrationsDump)) {\n      execSync(`${mysqlCmd} ${conn.database} < ${migrationsDump}`);\n    }\n\n    await db.destroy();\n  }\n\n  await _db.destroy();\n}\n\nasync function fixture_import(entityId: string, recordIds: number[]) {\n  await setupFixtureManager();\n\n  await FixtureManager.importFixture(entityId, recordIds);\n  await FixtureManager.sync();\n}\n\nasync function fixture_sync() {\n  await setupFixtureManager();\n\n  await FixtureManager.sync();\n}\n\n/**\n * fixture gen 명령어\n * 옵션을 process.argv에서 파싱\n */\nasync function fixture_gen() {\n  const options = parseOptions(process.argv);\n  await fixtureGenCommand(options);\n}\n\n/**\n * fixture fetch 명령어\n * 옵션을 process.argv에서 파싱\n */\nasync function fixture_fetch() {\n  const options = parseOptions(process.argv);\n  await fixtureFetchCommand(options);\n}\n\n/**\n * fixture explore 명령어\n * 옵션을 process.argv에서 파싱\n */\nasync function fixture_explore() {\n  const options = parseOptions(process.argv);\n  await fixtureExploreCommand(options);\n}\n\n/**\n * 간단한 옵션 파서\n */\nfunction parseOptions(\n  argv: string[],\n): Record<string, string | boolean | string[]> & { _: string[] } {\n  const options: Record<string, string | boolean | string[]> & { _: string[] } = { _: [] };\n\n  for (let i = 0; i < argv.length; i++) {\n    const arg = argv[i];\n\n    if (arg.startsWith(\"--\")) {\n      const key = arg.slice(2);\n\n      if (key.includes(\"=\")) {\n        const [k, v] = key.split(\"=\");\n        options[k] = v;\n      } else {\n        const next = argv[i + 1];\n        if (next && !next.startsWith(\"--\")) {\n          options[key] = next;\n          i++;\n        } else {\n          options[key] = true;\n        }\n      }\n    } else if (arg.startsWith(\"-\")) {\n      const key = arg.slice(1);\n      const next = argv[i + 1];\n\n      if (next && !next.startsWith(\"-\")) {\n        options[key] = next;\n        i++;\n      } else {\n        options[key] = true;\n      }\n    } else {\n      options._.push(arg);\n    }\n  }\n\n  return options;\n}\n\nasync function stub_practice(name: string) {\n  const practiceDir = path.join(Sonamu.apiRootPath, \"src\", \"practices\");\n  const fileNames = await readdir(practiceDir);\n\n  const maxSeqNo = await (async () => {\n    if (!(await exists(practiceDir))) {\n      await mkdir(practiceDir, { recursive: true });\n    }\n\n    const filteredSeqs = fileNames\n      .filter((fileName) => fileName.startsWith(\"p\") && fileName.endsWith(\".ts\"))\n      .map((fileName) => {\n        const [, seqNo] = fileName.match(/^p([0-9]+)-/) ?? [\"0\", \"0\"];\n        return parseInt(seqNo);\n      })\n      .sort((a, b) => b - a);\n\n    if (filteredSeqs.length > 0) {\n      return filteredSeqs[0];\n    }\n\n    return 0;\n  })();\n\n  const currentSeqNo = maxSeqNo + 1;\n  const fileName = `p${currentSeqNo}-${name}.ts`;\n  const dstPath = path.join(practiceDir, fileName);\n\n  const code = [\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  await writeFile(dstPath, code);\n\n  execSync(`code ${dstPath}`);\n\n  const runCode = `yarn node -r dotenv/config --enable-source-maps dist/practices/${fileName.replace(\n    \".ts\",\n    \".js\",\n  )}`;\n  console.log(`${chalk.blue(runCode)} copied to clipboard.`);\n  execSync(`echo \"${runCode}\" | pbcopy`);\n}\n\nasync function stub_entity(entityId: string) {\n  await Sonamu.syncer.createEntity({ entityId, title: entityId });\n\n  const { flags } = parseCliOptions();\n  const useAI = flags.has(\"ai\");\n  const noCones = flags.has(\"no-cones\");\n\n  // --no-cones: cone 생성 스킵\n  if (noCones) {\n    console.log(`✓ Entity '${entityId}' created without cones`);\n    return;\n  }\n\n  const { EntityManager } = await import(\"../entity/entity-manager\");\n  const entity = EntityManager.get(entityId);\n  if (!entity) {\n    console.error(`Entity not found: ${entityId}`);\n    return;\n  }\n\n  // --ai: LLM으로 cone 생성\n  if (useAI) {\n    console.log(`✓ Entity '${entityId}' created`);\n    console.log(`🌟 Generating AI-powered cones...`);\n    try {\n      const configLocale = Sonamu.config.i18n?.defaultLocale;\n      const locale =\n        configLocale === \"ko\" || configLocale === \"en\" || configLocale === \"ja\"\n          ? configLocale\n          : \"ko\";\n\n      const result = await entity.generateCones({\n        preserveExisting: false,\n        onlyEmpty: false,\n        locale,\n      });\n\n      console.log(`✅ Done (${result.tokensUsed} tokens)`);\n    } catch (error) {\n      if (error instanceof Error && error.message.includes(\"ANTHROPIC_API_KEY\")) {\n        console.error(`\\n❌ ${error.message}`);\n        console.error(`\\n💡 Remove --ai flag to use template cones instead`);\n      } else {\n        throw error;\n      }\n    }\n    return;\n  }\n\n  // 기본: 템플릿 cone 자동 생성\n  // LLM 없이 faker-mappings.ts를 활용하여 기본 cone 메타데이터를 생성합니다.\n  // 이를 통해 ANTHROPIC_API_KEY가 없어도 Sonamu를 사용할 수 있으며,\n  // 생성된 템플릿 cone은 나중에 'cone gen' 명령어로 AI를 통해 업그레이드할 수 있습니다.\n  console.log(`🌟 Generating template cones...`);\n  await entity.generateTemplateCones();\n  console.log(`✓ Entity '${entityId}' created with template cones`);\n  console.log(`💡 Tip: Run 'pnpm sonamu cone gen ${entityId}' to improve with AI`);\n}\n\n/**\n * AI를 사용하여 entity의 cone 메타데이터를 생성하거나 업그레이드합니다.\n *\n * 옵션:\n * - --regenerate: 전체 재생성 (기존 cone 덮어쓰기)\n * - --locale <ko|en|ja>: 생성 언어 지정\n * - 기본: onlyEmpty 모드 (기존 fixtureHint 보존)\n *\n * ANTHROPIC_API_KEY 필요 (sonamu.secret.ts 또는 환경변수)\n */\nasync function cone_gen(entityId: string) {\n  const { EntityManager } = await import(\"../entity/entity-manager\");\n  const { flags, options } = parseCliOptions();\n\n  // --all 옵션: 모든 entity cone 생성\n  if (flags.has(\"all\") || entityId === \"all\") {\n    const allEntities = EntityManager.getAllEntities();\n    console.log(`🌟 Generating AI-powered cones for ${allEntities.length} entities...\\n`);\n\n    let totalTokens = 0;\n    const errors: string[] = [];\n\n    for (const entity of allEntities) {\n      try {\n        console.log(`Processing ${entity.id}...`);\n        const configLocale = options.locale || Sonamu.config.i18n?.defaultLocale;\n        const locale =\n          configLocale === \"ko\" || configLocale === \"en\" || configLocale === \"ja\"\n            ? configLocale\n            : \"ko\";\n\n        const result = await entity.generateCones({\n          preserveExisting: !flags.has(\"regenerate\"),\n          onlyEmpty: !flags.has(\"regenerate\"),\n          locale,\n        });\n\n        totalTokens += result.tokensUsed;\n        console.log(`  ✓ ${entity.id} (${result.tokensUsed} tokens)\\n`);\n      } catch (error) {\n        const message = error instanceof Error ? error.message : \"Unknown error\";\n        errors.push(`${entity.id}: ${message}`);\n        console.error(`  ✗ ${entity.id}: ${message}\\n`);\n      }\n    }\n\n    console.log(`\\n✅ Done! Total: ${totalTokens} tokens used`);\n    const estimatedCost = (totalTokens * 9) / 1_000_000;\n    console.log(`💰 Estimated cost: ~$${estimatedCost.toFixed(4)}`);\n\n    if (errors.length > 0) {\n      console.error(`\\n❌ Failed entities (${errors.length}):`);\n      for (const err of errors) {\n        console.error(`  - ${err}`);\n      }\n    }\n    return;\n  }\n\n  // 단일 entity cone 생성\n  const entity = EntityManager.get(entityId);\n  if (!entity) {\n    console.error(`Entity not found: ${entityId}`);\n    return;\n  }\n\n  const mode = flags.has(\"regenerate\") ? \"regenerating\" : \"generating\";\n  console.log(\n    `🌟 ${mode === \"regenerating\" ? \"Regenerating\" : \"Generating\"} AI-powered cones for ${entityId}...`,\n  );\n\n  try {\n    const configLocale = options.locale || Sonamu.config.i18n?.defaultLocale;\n    const locale =\n      configLocale === \"ko\" || configLocale === \"en\" || configLocale === \"ja\" ? configLocale : \"ko\";\n\n    const result = await entity.generateCones({\n      preserveExisting: !flags.has(\"regenerate\"),\n      onlyEmpty: !flags.has(\"regenerate\"),\n      locale,\n    });\n\n    console.log(`✅ Done! (${result.tokensUsed} tokens used)`);\n\n    // 토큰 비용 계산 (대략적인 추정)\n    // Claude Sonnet 4.5: input $3/M tokens, output $15/M tokens\n    // 간단하게 평균 $9/M tokens로 계산\n    const estimatedCost = (result.tokensUsed * 9) / 1_000_000;\n    console.log(`💰 Estimated cost: ~$${estimatedCost.toFixed(4)}`);\n  } catch (error) {\n    if (error instanceof Error) {\n      if (error.message.includes(\"ANTHROPIC_API_KEY\")) {\n        console.error(`\\n❌ ${error.message}`);\n        console.error(`\\n💡 To use AI-powered cone generation:`);\n        console.error(`   1. Get an API key from https://console.anthropic.com/`);\n        console.error(\n          `   2. Add it to sonamu.secret.ts or set ANTHROPIC_API_KEY environment variable`,\n        );\n      } else if (error.message.includes(\"Rate limit\")) {\n        console.error(`\\n❌ ${error.message}`);\n        console.error(`\\n💡 Please wait a moment and try again.`);\n      } else {\n        console.error(`\\n❌ Failed to generate cones: ${error.message}`);\n      }\n    } else {\n      console.error(`\\n❌ Failed to generate cones: Unknown error`);\n    }\n  }\n}\n\nasync function scaffold_model(entityId: string) {\n  await Sonamu.syncer.generateTemplate(\"model\", {\n    entityId,\n  });\n}\n\nasync function scaffold_model_test(entityId: string) {\n  await Sonamu.syncer.generateTemplate(\"model_test\", {\n    entityId,\n  });\n}\n\n/**\n * pnpm sonamu skills sync 하면 실행되는 함수입니다.\n * 공식 Skills를 로컬 프로젝트 또는 글로벌 ~/.claude/로 동기화합니다.\n *\n * --global 플래그: ~/.claude/에 동기화 (프로젝트 생성 전 사용 가능)\n */\nasync function skills_sync() {\n  const { flags } = parseCliOptions();\n  const isGlobal = flags.has(\"global\");\n\n  // 개발 환경 - cli.ts: sonamu/modules/sonamu/src/bin/cli.ts\n  // 빌드 후 - cli.js: node_modules/sonamu/dist/bin/cli.js (실제 실행)\n  // skills 위치: node_modules/sonamu/src/skills (npm 배포 시)\n  const sourceBase = path.resolve(import.meta.dirname, \"..\", \"..\", \"src\", \"skills\");\n  const sourceSkillsDir = path.join(sourceBase, \"sonamu\");\n  const sourceClaudeMd = path.join(sourceBase, \"CLAUDE.md\");\n\n  if (!(await exists(sourceSkillsDir))) {\n    console.log(chalk.yellow(\"Skills source not found in sonamu package.\"));\n    return;\n  }\n\n  if (isGlobal) {\n    const homeClaudeDir = path.join(os.homedir(), \".claude\");\n    await skills_sync_to(homeClaudeDir, sourceSkillsDir, sourceClaudeMd, {\n      useSymlink: false,\n      copyProjectTemplates: false,\n      isGlobal: true,\n    });\n\n    // ~/.claude/commands/sonamu-skills.md 설치\n    const sourceCommandsDir = path.join(sourceBase, \"commands\");\n    const sourceCommand = path.join(sourceCommandsDir, \"sonamu-skills.md\");\n    if (await exists(sourceCommand)) {\n      const targetCommandsDir = path.join(homeClaudeDir, \"commands\");\n      await mkdir(targetCommandsDir, { recursive: true });\n      await cp(sourceCommand, path.join(targetCommandsDir, \"sonamu-skills.md\"));\n      console.log(chalk.green(`✓ /sonamu-skills command installed → ~/.claude/commands/`));\n    }\n\n    console.log(chalk.cyan(`\\n  Global sync complete → ~/.claude/skills/sonamu/`));\n    console.log(chalk.dim(`  These skills are available in all Claude Code sessions.`));\n    console.log(\n      chalk.dim(\n        `  Once a project is created, run 'pnpm sonamu skills sync' for project-local sync.`,\n      ),\n    );\n  } else {\n    const workspaceRoot = await findWorkspaceRoot();\n    const claudeDir = path.join(workspaceRoot, \".claude\");\n    await skills_sync_to(claudeDir, sourceSkillsDir, sourceClaudeMd, {\n      useSymlink: true,\n      copyProjectTemplates: true,\n      sourceBase,\n    });\n  }\n}\n\n/**\n * claudeDir로 skills를 동기화하는 공통 로직입니다.\n */\nasync function skills_sync_to(\n  claudeDir: string,\n  sourceSkillsDir: string,\n  sourceClaudeMd: string,\n  options: {\n    useSymlink: boolean;\n    copyProjectTemplates: boolean;\n    sourceBase?: string;\n    isGlobal?: boolean;\n  },\n) {\n  const targetSkillsDir = path.join(claudeDir, \"skills\", \"sonamu\");\n\n  // 기존 디렉토리/symlink 삭제 후 재생성\n  // exists()는 broken symlink를 감지하지 못하므로 rm을 무조건 시도합니다\n  try {\n    await rm(targetSkillsDir, { recursive: true, force: true });\n  } catch {\n    // 파일이 없으면 무시\n  }\n\n  await mkdir(path.dirname(targetSkillsDir), { recursive: true });\n\n  if (options.useSymlink) {\n    try {\n      await symlink(sourceSkillsDir, targetSkillsDir, \"dir\");\n      console.log(chalk.green(`✓ Skills linked (symlink)`));\n    } catch (error) {\n      console.log(\n        chalk.yellow(`⚠ Symlink failed: ${error instanceof Error ? error.message : String(error)}`),\n      );\n      console.log(chalk.yellow(`  Falling back to copy...`));\n      await skillsCopy(sourceSkillsDir, targetSkillsDir);\n    }\n  } else {\n    await skillsCopy(sourceSkillsDir, targetSkillsDir);\n  }\n\n  // project 디렉토리 초기화 (없으면 생성, 있으면 유지)\n  if (options.copyProjectTemplates && options.sourceBase) {\n    const sourceProjectDir = path.join(options.sourceBase, \"project\");\n    const targetProjectDir = path.join(claudeDir, \"skills\", \"project\");\n\n    if (await exists(sourceProjectDir)) {\n      if (!(await exists(targetProjectDir))) {\n        try {\n          await cp(sourceProjectDir, targetProjectDir, { recursive: true });\n          console.log(chalk.green(`✓ Project templates initialized`));\n        } catch (error) {\n          console.error(\n            chalk.red(\n              `✗ Failed to initialize project templates: ${error instanceof Error ? error.message : String(error)}`,\n            ),\n          );\n        }\n      } else {\n        console.log(chalk.dim(`⏭ Project templates already exist (preserved)`));\n      }\n    }\n  }\n\n  // settings.local.json — project-local 모드에서만, 없을 때만 생성\n  if (options.copyProjectTemplates) {\n    const settingsLocalPath = path.join(claudeDir, \"settings.local.json\");\n    if (!(await exists(settingsLocalPath))) {\n      try {\n        const settingsContent = {\n          hooks: {\n            PostToolUse: [\n              {\n                matcher: \"Edit|Write|MultiEdit\",\n                hooks: [\n                  {\n                    type: \"command\",\n                    command: \"pnpm biome check --changed 2>&1 | head -60\",\n                  },\n                ],\n              },\n            ],\n          },\n        };\n        await writeFile(settingsLocalPath, `${JSON.stringify(settingsContent, null, 2)}\\n`);\n        console.log(chalk.green(`✓ .claude/settings.local.json created`));\n      } catch (error) {\n        console.error(\n          chalk.red(\n            `✗ Failed to create settings.local.json: ${error instanceof Error ? error.message : String(error)}`,\n          ),\n        );\n      }\n    } else {\n      console.log(chalk.dim(`⏭ .claude/settings.local.json already exists (preserved)`));\n    }\n  }\n\n  // CLAUDE.md 복사/업데이트\n  if (await exists(sourceClaudeMd)) {\n    try {\n      const targetClaudeMd = path.join(claudeDir, \"CLAUDE.md\");\n      const rawContent = await readFile(sourceClaudeMd, \"utf-8\");\n      // 글로벌 모드에서는 상대 경로를 절대 경로로 변환합니다\n      const sourceContent = options.isGlobal\n        ? rawContent.replaceAll(\".claude/skills/sonamu/\", \"~/.claude/skills/sonamu/\")\n        : rawContent;\n\n      if (await exists(targetClaudeMd)) {\n        const targetContent = await readFile(targetClaudeMd, \"utf-8\");\n        const startMarker = \"<!-- SONAMU:START -->\";\n        const endMarker = \"<!-- SONAMU:END -->\";\n        if (targetContent.includes(startMarker) && targetContent.includes(endMarker)) {\n          const startIdx = targetContent.indexOf(startMarker);\n          const endIdx = targetContent.indexOf(endMarker);\n\n          if (startIdx !== -1 && endIdx !== -1 && startIdx < endIdx) {\n            const before = targetContent.substring(0, startIdx);\n            const after = targetContent.substring(endIdx + endMarker.length);\n            const newContent = `${before}${startMarker}\\n${sourceContent}\\n${endMarker}${after}`;\n            await writeFile(targetClaudeMd, newContent);\n            console.log(chalk.green(`✓ CLAUDE.md updated (marker region)`));\n          } else {\n            console.log(chalk.yellow(`⏭ CLAUDE.md marker positions invalid, skipped`));\n          }\n        } else {\n          // 마커가 없는 기존 CLAUDE.md에 Sonamu 섹션을 추가합니다\n          const appended = `${targetContent.trimEnd()}\\n\\n<!-- SONAMU:START -->\\n${sourceContent}\\n<!-- SONAMU:END -->\\n`;\n          await writeFile(targetClaudeMd, appended);\n          console.log(chalk.green(`✓ CLAUDE.md updated (appended Sonamu section)`));\n        }\n      } else {\n        const withMarkers = `<!-- SONAMU:START -->\\n${sourceContent}\\n<!-- SONAMU:END -->\\n`;\n        await writeFile(targetClaudeMd, withMarkers);\n        console.log(chalk.green(`✓ CLAUDE.md created`));\n      }\n    } catch (error) {\n      console.error(\n        chalk.red(\n          `✗ Failed to update CLAUDE.md: ${error instanceof Error ? error.message : String(error)}`,\n        ),\n      );\n    }\n  }\n}\n\nasync function skillsCopy(src: string, dest: string) {\n  try {\n    await cp(src, dest, { recursive: true });\n    console.log(chalk.green(`✓ Skills copied`));\n  } catch (copyError) {\n    console.error(\n      chalk.red(\n        `✗ Failed to copy skills: ${copyError instanceof Error ? copyError.message : String(copyError)}`,\n      ),\n    );\n    throw copyError;\n  }\n}\n\n/**\n * pnpm sonamu skills create <name> 하면 실행되는 함수입니다.\n * 로컬 skill 초안을 생성합니다.\n */\nasync function skills_create(name: string) {\n  const workspaceRoot = await findWorkspaceRoot();\n  const localDir = path.join(workspaceRoot, \".claude\", \"skills\", \"local\");\n\n  // === 파일명 검증 및 Sanitize ===\n  if (!name || name.trim() === \"\") {\n    console.error(chalk.red(\"✗ Skill name is required\"));\n    return;\n  }\n\n  let sanitized = name\n    // 공백을 하이픈으로\n    .replace(/\\s+/g, \"-\")\n    // 경로 구분자 제거\n    .replace(/[/\\\\]/g, \"-\")\n    // Path traversal 방지\n    .replace(/\\.\\./g, \"\")\n    // Windows 금지 문자 제거\n    .replace(/[<>:\"|?*]/g, \"\")\n    // 시작/끝 점, 하이픈, 언더스코어 제거\n    .replace(/^[.\\-_]+|[.\\-_]+$/g, \"\")\n    // 연속된 하이픈을 하나로\n    .replace(/-+/g, \"-\")\n    // 알파벳, 숫자, 하이픈, 언더스코어, 한글만 허용\n    .replace(/[^a-zA-Z0-9-_가-힣]/g, \"\");\n\n  // 길이 제한\n  const MAX_LENGTH = 100;\n  if (sanitized.length > MAX_LENGTH) {\n    sanitized = sanitized.substring(0, MAX_LENGTH);\n    console.log(chalk.yellow(`⚠ Name truncated to ${MAX_LENGTH} characters`));\n  }\n\n  // Windows 예약어 확인\n  const RESERVED_NAMES = [\n    \"CON\",\n    \"PRN\",\n    \"AUX\",\n    \"NUL\",\n    \"COM1\",\n    \"COM2\",\n    \"COM3\",\n    \"COM4\",\n    \"COM5\",\n    \"COM6\",\n    \"COM7\",\n    \"COM8\",\n    \"COM9\",\n    \"LPT1\",\n    \"LPT2\",\n    \"LPT3\",\n    \"LPT4\",\n    \"LPT5\",\n    \"LPT6\",\n    \"LPT7\",\n    \"LPT8\",\n    \"LPT9\",\n  ];\n  if (RESERVED_NAMES.includes(sanitized.toUpperCase())) {\n    sanitized = `skill-${sanitized}`;\n    console.log(chalk.yellow(`⚠ Reserved name detected, prefixed with \"skill-\"`));\n  }\n\n  // 빈 문자열 체크\n  if (sanitized === \"\") {\n    console.error(chalk.red(\"✗ Invalid skill name after sanitization\"));\n    console.log(chalk.dim(`  Original: \"${name}\"`));\n    return;\n  }\n\n  // 변경 알림\n  if (sanitized !== name) {\n    console.log(chalk.yellow(`⚠ Name sanitized: \"${name}\" → \"${sanitized}\"`));\n  }\n\n  const filePath = path.join(localDir, `${sanitized}.md`);\n\n  if (await exists(filePath)) {\n    console.log(chalk.yellow(`Skill \"${sanitized}\" already exists.`));\n    return;\n  }\n\n  await mkdir(localDir, { recursive: true });\n\n  const template = `---\nname: ${sanitized}\ncategory: other\ncreated_at: ${new Date().toISOString().split(\"T\")[0]}\nstatus: draft\n---\n\n# ${sanitized}\n\n## 상황\n\n[어떤 문제였는지]\n\n## 해결 방법\n\n[어떻게 해결했는지]\n\n## 코드 예시\n\n\\`\\`\\`typescript\n// 예시 코드\n\\`\\`\\`\n`;\n\n  await writeFile(filePath, template);\n  console.log(chalk.green(`✓ Created .claude/skills/local/${sanitized}.md`));\n}\n\n/**\n * pnpm sonamu auth generate 하면 실행되는 함수입니다.\n * better-auth 엔티티들(User, Session, Account, Verification)을 생성합니다.\n *\n * 옵션:\n * --plugins phone-number,2fa  플러그인 엔티티도 함께 생성\n */\nasync function auth_generate() {\n  // --plugins 옵션 파싱\n  const pluginsArg = process.argv.find((arg) => arg.startsWith(\"--plugins\"));\n  const plugins: BetterAuthPluginId[] = [];\n\n  if (pluginsArg) {\n    const pluginValue = pluginsArg.includes(\"=\")\n      ? pluginsArg.split(\"=\")[1]\n      : process.argv[process.argv.indexOf(pluginsArg) + 1];\n\n    if (pluginValue) {\n      const pluginIds = pluginValue.split(\",\").map((p) => p.trim());\n\n      for (const id of pluginIds) {\n        if (isValidPluginId(id)) {\n          plugins.push(id);\n        } else {\n          console.log(chalk.yellow(`⚠ Unknown plugin: ${id}`));\n          console.log(chalk.dim(`  Supported plugins: ${SUPPORTED_PLUGIN_IDS.join(\", \")}`));\n        }\n      }\n    }\n  }\n\n  console.log(chalk.yellow.bold(\"🔐 Generating better-auth entities...\\n\"));\n\n  if (plugins.length > 0) {\n    console.log(chalk.dim(`  Plugins: ${plugins.join(\", \")}`));\n  }\n\n  await generateBetterAuthEntities({ plugins });\n}\n\n/**\n * pnpm sonamu auth add-companions 하면 실행되는 함수입니다.\n * 기존 프로젝트의 entity.json에 fixtureCompanions를 소급 추가합니다.\n *\n * 이미 fixtureCompanions가 있는 entity는 스킵합니다 (덮어쓰기 없음).\n */\nasync function auth_add_companions() {\n  console.log(chalk.yellow.bold(\"🔐 Adding fixtureCompanions to better-auth entities...\\n\"));\n  await addCompanionsToEntities();\n  console.log(chalk.bold(\"\\n✅ Done!\"));\n}\n\n/**\n * 워크스페이스 루트를 찾습니다.\n * 우선순위: pnpm-workspace.yaml > package.json(workspaces) > .agents/\n *\n * CLAUDE.md는 서브패키지에도 존재할 수 있으므로 사용하지 않습니다.\n * .agents/는 agents init이 생성하는 디렉토리로, 워크스페이스 루트에만 존재합니다.\n */\nasync function findWorkspaceRoot() {\n  let dir = process.cwd();\n\n  while (dir !== path.dirname(dir)) {\n    // 1. pnpm-workspace.yaml: 확실한 monorepo 루트.\n    if (await exists(path.join(dir, \"pnpm-workspace.yaml\"))) {\n      return dir;\n    }\n\n    // 2. package.json에 workspaces 필드가 있으면 monorepo 루트.\n    const packagePath = path.join(dir, \"package.json\");\n    if (await exists(packagePath)) {\n      try {\n        const packageJson = JSON.parse(await readFile(packagePath, \"utf-8\"));\n        if (packageJson.workspaces) {\n          return dir;\n        }\n      } catch {\n        // 파싱 실패시 무시\n      }\n    }\n\n    // 3. .agents/: agents init이 생성한 디렉토리. 서브패키지에는 존재하지 않음.\n    if (await exists(path.join(dir, \".agents\"))) {\n      return dir;\n    }\n\n    dir = path.dirname(dir);\n  }\n\n  // 찾지 못하면 api 폴더의 부모 사용\n  return findAppRootPath();\n}\n"],"names":["chalk","dotenv","config","assert","execSync","spawn","cp","mkdir","readdir","readFile","rm","symlink","writeFile","knex","createRequire","os","path","process","tsicli","Sonamu","addCompanionsToEntities","generateBetterAuthEntities","isValidPluginId","SUPPORTED_PLUGIN_IDS","EntityManager","Migrator","FixtureManager","execWithLinePrefix","printBuildSummary","printTaskFailed","printTaskHeader","printTaskStart","printTaskSuccess","exists","findApiRootPath","findAppRootPath","API_ARTIFACTS","WEB_ARTIFACTS","fixtureExploreCommand","fixtureFetchCommand","fixtureGenCommand","testCommand","migrator","parseCliOptions","argv","flags","Set","options","i","length","arg","startsWith","includes","key","value","slice","split","nextArg","add","bootstrap","notToInit","init","filteredArgv","skipNext","afterDoubleDash","push","cmd","types","type","name","message","choices","getAllParentIds","map","entityId","title","args","runners","migrate_status","migrate_run","migrate_apply","migrate_generate","fixture_init","fixture_import","fixture_sync","fixture_gen","fixture_fetch","fixture_explore","stub_practice","stub_entity","scaffold_model","scaffold_model_test","cone_gen","sync","build_all","build_api","build_web","dev_all","dev_api","dev_web","start","skills_sync","skills_create","test","auth_generate","auth_add_companions","destroy","finally","syncer","spawnApiDevServer","apiRoot","entryPoint","hotRunnerBinPath","url","resolve","serverProcess","execPath","join","cwd","stdio","env","NODE_ENV","HOT","API_ROOT_PATH","extraEnv","cleanup","console","log","yellow","kill","exit","on","code","error","red","bold","SONAMU_DISABLE_INTEGRATED_WEB","appRoot","webPath","doubleDashIndex","indexOf","passthroughArgs","viteArgs","viteProcess","signal","resolveSwcConfigPath","swcFilePath","dim","dirname","skipIfMissing","apiStartedAt","Date","now","artifact","projectPath","description","runBuildSteps","buildCommandArgs","configFilePath","e","gray","webStartedAt","steps","preBuildCommand","buildCommand","postBuildCommand","filter","step","isLast","Error","cause","blue","setupMigrator","setupFixtureManager","targets","runAction","localHosts","Object","keys","dbConfig","target","targetConfig","host","connection","toLowerCase","conns","getStatus","hasStatus0","some","conn","status","pending","count","generatePreparedCodes","green","srcConfig","development_master","label","fixture","toSkip","remoteConn","localConn","database","dumpFilename","srcConn","migrationsDump","user","password","_db","migrations","raw","db","undefined","row","mysqlCmd","recordIds","importFixture","parseOptions","_","k","v","next","practiceDir","apiRootPath","fileNames","maxSeqNo","recursive","filteredSeqs","fileName","endsWith","seqNo","match","parseInt","sort","a","b","currentSeqNo","dstPath","runCode","replace","createEntity","useAI","has","noCones","entity","get","configLocale","i18n","defaultLocale","locale","result","generateCones","preserveExisting","onlyEmpty","tokensUsed","generateTemplateCones","allEntities","getAllEntities","totalTokens","errors","id","estimatedCost","toFixed","err","mode","generateTemplate","isGlobal","sourceBase","sourceSkillsDir","sourceClaudeMd","homeClaudeDir","homedir","skills_sync_to","useSymlink","copyProjectTemplates","sourceCommandsDir","sourceCommand","targetCommandsDir","cyan","workspaceRoot","findWorkspaceRoot","claudeDir","targetSkillsDir","force","String","skillsCopy","sourceProjectDir","targetProjectDir","settingsLocalPath","settingsContent","hooks","PostToolUse","matcher","command","JSON","stringify","targetClaudeMd","rawContent","sourceContent","replaceAll","targetContent","startMarker","endMarker","startIdx","endIdx","before","substring","after","newContent","appended","trimEnd","withMarkers","src","dest","copyError","localDir","trim","sanitized","MAX_LENGTH","RESERVED_NAMES","toUpperCase","filePath","template","toISOString","pluginsArg","find","plugins","pluginValue","pluginIds","p","dir","packagePath","packageJson","parse","workspaces"],"mappings":"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"}
+//#endregion
+export {  };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"cli.js","names":["migrator: Migrator","options: Record<string, string>","filteredArgv: string[]","spawn","options: Record<string, string | boolean | string[]> & { _: string[] }","fileName","EntityManager","errors: string[]","entity","plugins: BetterAuthPluginId[]"],"sources":["../../src/bin/cli.ts"],"sourcesContent":["import chalk from \"chalk\";\nimport dotenv from \"dotenv\";\n\ndotenv.config();\n\nimport assert from \"assert\";\nimport { execSync, spawn } from \"child_process\";\nimport { cp, mkdir, readdir, readFile, rm, symlink, writeFile } from \"fs/promises\";\nimport { createRequire } from \"module\";\nimport os from \"os\";\nimport path from \"path\";\nimport process from \"process\";\n\nimport knex from \"knex\";\nimport { type Knex } from \"knex\";\nimport { tsicli } from \"tsicli\";\n\nimport { Sonamu } from \"../api/sonamu\";\nimport { addCompanionsToEntities, generateBetterAuthEntities } from \"../auth/auth-generator\";\nimport { isValidPluginId, SUPPORTED_PLUGIN_IDS } from \"../auth/plugins/entity-definitions\";\nimport { type BetterAuthPluginId } from \"../auth/plugins/entity-definitions\";\nimport { type SonamuDBConfig } from \"../database/db\";\nimport { EntityManager } from \"../entity/entity-manager\";\nimport { Migrator } from \"../migration/migrator\";\nimport { FixtureManager } from \"../testing/fixture-manager\";\nimport {\n  execWithLinePrefix,\n  printBuildSummary,\n  printTaskFailed,\n  printTaskHeader,\n  printTaskStart,\n  printTaskSuccess,\n} from \"../utils/console-util\";\nimport { exists } from \"../utils/fs-utils\";\nimport { findApiRootPath, findAppRootPath } from \"../utils/utils\";\nimport { API_ARTIFACTS, WEB_ARTIFACTS } from \"./build-config\";\nimport { type BuildArtifact } from \"./build-config\";\nimport { fixtureExploreCommand, fixtureFetchCommand, fixtureGenCommand } from \"./fixture\";\nimport { testCommand } from \"./test-command\";\n\nlet migrator: Migrator;\n\n/**\n * CLI 옵션을 파싱하는 헬퍼 함수\n */\nfunction parseCliOptions(argv: string[] = process.argv): {\n  flags: Set<string>; // --regenerate, --ai, --no-cones 등\n  options: Record<string, string>; // --locale ko 등\n} {\n  const flags = new Set<string>();\n  const options: Record<string, string> = {};\n\n  for (let i = 0; i < argv.length; i++) {\n    const arg = argv[i];\n    if (!arg.startsWith(\"--\")) continue;\n\n    // --option=value 형식\n    if (arg.includes(\"=\")) {\n      const [key, value] = arg.slice(2).split(\"=\");\n      options[key] = value;\n      continue;\n    }\n\n    // --option value 형식인지 확인\n    const nextArg = argv[i + 1];\n    if (nextArg && !nextArg.startsWith(\"--\") && !nextArg.startsWith(\"-\")) {\n      options[arg.slice(2)] = nextArg;\n      i++; // 다음 arg는 값이므로 스킵\n    } else {\n      // --flag 형식\n      flags.add(arg.slice(2));\n    }\n  }\n\n  return { flags, options };\n}\n\nasync function bootstrap() {\n  const notToInit = [\"dev\", \"build\", \"start\", \"skills\", \"test\"].includes(process.argv[2] ?? \"\");\n  if (!notToInit) {\n    await Sonamu.init(false, false);\n  }\n\n  try {\n    // tsicli는 정확한 명령어 매칭만 지원하므로, --로 시작하는 옵션과 그 값을 필터링합니다.\n    // 옵션 파싱은 각 runner 함수에서 원본 process.argv를 사용하여 수행합니다.\n    // \"--\"(bare double dash)는 passthrough 구분자이므로, 그 뒤의 모든 인자도 제외합니다.\n    const filteredArgv: string[] = [];\n    let skipNext = false;\n    let afterDoubleDash = false;\n    for (let i = 0; i < process.argv.length; i++) {\n      const arg = process.argv[i];\n      if (arg === \"--\") {\n        afterDoubleDash = true;\n        continue;\n      }\n      if (afterDoubleDash) continue;\n      if (skipNext) {\n        skipNext = false;\n        continue;\n      }\n      if (arg.startsWith(\"--\")) {\n        // --option=value 형식은 이 arg만 스킵\n        if (arg.includes(\"=\")) {\n          continue;\n        }\n        // --option value 형식인지 확인: 다음 arg가 --로 시작하지 않으면 값이 있는 것\n        const nextArg = process.argv[i + 1];\n        if (nextArg && !nextArg.startsWith(\"--\") && !nextArg.startsWith(\"-\")) {\n          skipNext = true;\n        }\n        continue;\n      }\n      filteredArgv.push(arg);\n    }\n\n    // build/dev 명령어가 서브커맨드 없이 호출될 때 \"all\"을 기본값으로 추가합니다.\n    // 예: `sonamu build` → `sonamu build all`, `sonamu dev` → `sonamu dev all`\n    const cmd = filteredArgv[2];\n    if ((cmd === \"build\" || cmd === \"dev\") && filteredArgv.length === 3) {\n      filteredArgv.push(\"all\");\n    }\n\n    // test 커맨드는 가변 인자(파일명, --pattern 등)를 받으므로 tsicli를 우회합니다.\n    if (cmd === \"test\") {\n      return testCommand();\n    }\n\n    await tsicli(filteredArgv, {\n      types: {\n        \"#entityId\": {\n          type: \"autocomplete\",\n          name: \"#entityId\",\n          message: \"Please input #entityId\",\n          choices: EntityManager.getAllParentIds().map((entityId) => ({\n            title: entityId,\n            value: entityId,\n          })),\n        },\n        \"#recordIds\": \"number[]\",\n        \"#name\": \"string\",\n        \"#targets\": {\n          type: \"multiselect\",\n          name: \"#targets\",\n          message: \"Please input #targets\",\n          choices: [\n            { title: \"Development\", value: \"development_master\" },\n            { title: \"Production\", value: \"production_master\" },\n            { title: \"Fixture\", value: \"fixture\" },\n            { title: \"Test\", value: \"test\" },\n          ],\n        },\n      },\n      args: [\n        [\"fixture\", \"init\"],\n        [\"fixture\", \"import\", \"#entityId\", \"#recordIds\"],\n        [\"fixture\", \"sync\"],\n        [\"fixture\", \"gen\"],\n        [\"fixture\", \"fetch\"],\n        [\"fixture\", \"explore\"],\n        [\"migrate\", \"run\"],\n        [\"migrate\", \"apply\", \"#targets\"],\n        [\"migrate\", \"generate\"],\n        [\"migrate\", \"status\"],\n        [\"stub\", \"practice\", \"#name\"],\n        [\"stub\", \"entity\", \"#name\"],\n        [\"scaffold\", \"model\", \"#entityId\"],\n        [\"scaffold\", \"model_test\", \"#entityId\"],\n        [\"scaffold\", \"view_list\", \"#entityId\"],\n        [\"scaffold\", \"view_form\", \"#entityId\"],\n        [\"cone\", \"gen\", \"#entityId\"],\n        [\"sync\"],\n        [\"build\", \"all\"],\n        [\"build\", \"api\"],\n        [\"build\", \"web\"],\n        [\"dev\", \"all\"],\n        [\"dev\", \"api\"],\n        [\"dev\", \"web\"],\n        [\"start\"],\n        [\"skills\", \"sync\"],\n        [\"skills\", \"create\", \"#name\"],\n        [\"test\"],\n        [\"auth\", \"generate\"],\n        [\"auth\", \"add-companions\"],\n      ],\n      runners: {\n        migrate_status,\n        migrate_run,\n        migrate_apply,\n        migrate_generate,\n        fixture_init,\n        fixture_import,\n        fixture_sync,\n        fixture_gen,\n        fixture_fetch,\n        fixture_explore,\n        stub_practice,\n        stub_entity,\n        scaffold_model,\n        scaffold_model_test,\n        // scaffold_view_list,\n        // scaffold_view_form,\n        cone_gen,\n        sync,\n        build_all,\n        build_api,\n        build_web,\n        dev_all,\n        dev_api,\n        dev_web,\n        start,\n        skills_sync,\n        skills_create,\n        test: testCommand,\n        auth_generate,\n        \"auth_add-companions\": auth_add_companions,\n      },\n    });\n  } finally {\n    await Sonamu.destroy();\n  }\n}\n\nbootstrap().finally(async () => {\n  await FixtureManager.destroy();\n});\n\n/**\n * pnpm sync 하면 실행되는 함수입니다.\n * 프로젝트를 싱크합니다.\n */\nasync function sync() {\n  await Sonamu.syncer.sync();\n}\n\n/**\n * API 개발 서버를 실행하는 공통 로직입니다.\n * dev_all과 dev_api에서 공유합니다.\n *\n * TypeScript를 바로 실행할 수 있도록 @sonamu-kit/ts-loader를,\n * HMR을 지원하기 위해 @sonamu-kit/hmr-hook을 import하며,\n * 소스맵 지원을 위해 --enable-source-maps 플래그를 포함하여 실행합니다.\n *\n * 이때 @sonamu-kit/ts-loader와 @sonamu-kit/hmr-hook는 sonamu가 자체적으로 가지고 있는 dependency입니다.\n * 또한 실행에 사용하는 @sonamu-kit/hmr-runner도 마찬가지로 sonamu가 자체적으로 가지고 있는 dependency입니다.\n * 따라서 사용자 프로젝트에서는 이 세 패키지를 직접 설치할 필요가 없습니다.\n */\nfunction spawnApiDevServer(options?: { extraEnv?: Record<string, string> }) {\n  const apiRoot = findApiRootPath();\n  const entryPoint = \"src/index.ts\";\n\n  // 이 sonamu 패키지가 dependencies로 가지고 있는 @sonamu-kit/hmr-runner의 bin/run.js를 사용합니다.\n  // 이 경로(/bin/run.js)는 @sonamu-kit/hmr-runner의 package.json의 bin 필드에 명시되어 있는 그것과 같습니다.\n  const hotRunnerBinPath = createRequire(import.meta.url).resolve(\n    \"@sonamu-kit/hmr-runner/bin/run.js\",\n  );\n\n  const serverProcess = spawn(\n    process.execPath, // node\n    [\n      hotRunnerBinPath, // 이렇게 해서 hot-runner를 실행하구요\n      \"--clear-screen=false\", // 이하 hot-runner에게 넘겨줄 인자들입니다.\n      \"--node-args=--import=sonamu/ts-loader-register\", // TypeScript 서포트를 위한 로더,\n      \"--node-args=--import=sonamu/hmr-hook-register\", // HMR을 지원하기 위한 hook,\n      \"--node-args=--enable-source-maps\", // 그리고 소스맵 지원을 위한 플래그입니다.\n      \"--on-key=r:restart:Restart server\", // r 누르면 서버 재시작하게 해줘요.\n      \"--on-key=c:clear:Clear screen\", // c 누르면 터미널 화면을 지워줘요.\n      `--on-key=f:shell(rm ${path.join(apiRoot, \"sonamu.lock\")}):restart:Force restart`, // f 누르면 sonamu.lock 파일을 지우고 서버 재시작하게 해줘요.\n\n      \"--on-key=enter:shell(echo hi):Key binding test\", // enter를 key로 쓸 수 있음을 보이기 위한 테스트입니다.\n      \"--on-key=ctrl+f ctrl+f:shell(git pull && pnpm install && pnpm --filter sonamu build && echo 'Sonamu is now up-to-date!'):restart:Pull & install & build & restart\", // modifier와의 조합, 그리고 두 개의 chord를 사용할 수 있음을 보이기 위한 테스트입니다.\n      entryPoint, // 마지막으로 실제 실행할 스크립트의 경로를 넘겨줍니다.\n    ],\n    {\n      cwd: apiRoot,\n      stdio: \"inherit\",\n      env: {\n        ...process.env,\n        NODE_ENV: \"development\",\n        HOT: \"yes\", // 얘가 있어야 HMR이 활성화됩니다.\n        API_ROOT_PATH: apiRoot, // 이 경로가 hmr-hook의 루트 디렉토리가 됩니다.\n        ...options?.extraEnv,\n      },\n    },\n  );\n\n  // 종료 처리\n  const cleanup = () => {\n    console.log(chalk.yellow(\"\\n\\n👋 Shutting down...\"));\n    serverProcess.kill(\"SIGTERM\");\n    process.exit(0);\n  };\n\n  process.on(\"SIGINT\", cleanup);\n  process.on(\"SIGTERM\", cleanup);\n\n  serverProcess.on(\"exit\", (code) => {\n    if (code !== 0) {\n      console.error(chalk.red(`Server exited with code ${code}`));\n      process.exit(code || 1);\n    }\n  });\n}\n\n/**\n * pnpm dev / pnpm dev all 하면 실행되는 함수입니다.\n * 프로젝트에 대해 HMR 지원하는 개발 서버를 띄워줍니다.\n *\n * Sonamu.init 없이 호출될 것을 상정하여 구현되었습니다.\n */\nfunction dev_all() {\n  console.log(chalk.yellow.bold(\"Starting Sonamu dev server...\\n\"));\n  spawnApiDevServer();\n}\n\n/**\n * pnpm dev api 하면 실행되는 함수입니다.\n * API 전용 개발 서버를 띄웁니다.\n * dev_all과 거의 동일하되, 통합 웹 서버를 비활성화합니다.\n *\n * Sonamu.init 없이 호출될 것을 상정하여 구현되었습니다.\n */\nfunction dev_api() {\n  console.log(chalk.yellow.bold(\"Starting Sonamu API-only dev server...\\n\"));\n  spawnApiDevServer({\n    extraEnv: { SONAMU_DISABLE_INTEGRATED_WEB: \"yes\" },\n  });\n}\n\n/**\n * pnpm dev web 하면 실행되는 함수입니다.\n * Vite 개발 서버를 단독으로 실행합니다.\n * -- 뒤의 인자는 Vite에 그대로 전달됩니다.\n *\n * Sonamu.init 없이 호출될 것을 상정하여 구현되었습니다.\n */\nasync function dev_web() {\n  const appRoot = findAppRootPath();\n  const webPath = path.join(appRoot, \"web\");\n\n  if (!(await exists(webPath))) {\n    console.error(`web 디렉토리를 찾을 수 없습니다: ${webPath}`);\n    process.exit(1);\n  }\n\n  // -- 뒤의 인자 추출\n  const doubleDashIndex = process.argv.indexOf(\"--\");\n  const passthroughArgs = doubleDashIndex !== -1 ? process.argv.slice(doubleDashIndex + 1) : [];\n\n  const viteArgs = [\"exec\", \"vite\", ...passthroughArgs];\n\n  console.log(chalk.yellow.bold(\"Starting Vite dev server...\\n\"));\n\n  const viteProcess = spawn(\"pnpm\", viteArgs, {\n    cwd: webPath,\n    stdio: \"inherit\",\n  });\n\n  viteProcess.on(\"exit\", (code) => {\n    process.exit(code ?? 0);\n  });\n\n  // SIGINT/SIGTERM 시 Vite 프로세스를 gracefully 종료합니다.\n  for (const signal of [\"SIGINT\", \"SIGTERM\"] as const) {\n    process.on(signal, () => {\n      viteProcess.kill(signal);\n    });\n  }\n}\n\n/**\n * API 빌드 설정 파일 경로를 결정합니다.\n * 프로젝트 루트에 `tsdown.config.ts`가 있으면 그것을, 없으면 sonamu 기본 설정을 사용합니다.\n */\nasync function resolveApiBuildConfigPath(): Promise<string> {\n  const localConfigPath = path.join(process.cwd(), \"tsdown.config.ts\");\n\n  try {\n    if (await exists(localConfigPath)) {\n      console.log(chalk.dim(\"Using tsdown.config.ts from project root...\"));\n      return localConfigPath;\n    }\n\n    console.log(chalk.dim(\"Using default tsdown API config from sonamu package...\"));\n    return path.join(import.meta.dirname, \"..\", \"..\", \"tsdown.api.config.ts\");\n  } catch (error) {\n    console.error(chalk.red(\"Setting up API build config failed.\"), error);\n    process.exit(1);\n  }\n}\n\n/**\n * sonamu build / sonamu build all 하면 실행되는 함수입니다.\n * build_api + build_web의 합성입니다. Web 디렉토리가 없으면 Web 빌드를 스킵합니다.\n */\nasync function build_all() {\n  await build_api();\n  await build_web({ skipIfMissing: true });\n}\n\n/**\n * pnpm build api 하면 실행되는 함수입니다.\n * API 프로젝트만 빌드합니다.\n *\n * Sonamu.init 없이 호출될 것을 상정하여 구현되었습니다.\n */\nasync function build_api() {\n  const appRoot = findAppRootPath();\n  const configFilePath = await resolveApiBuildConfigPath();\n\n  const apiStartedAt = Date.now();\n  try {\n    for (const artifact of API_ARTIFACTS) {\n      const cwd = path.join(appRoot, artifact.projectPath);\n      printTaskHeader(artifact.name, artifact.description, cwd);\n\n      await runBuildSteps(artifact, { cwd, buildCommandArgs: { configFilePath } });\n    }\n    printBuildSummary(\"API\", true, Date.now() - apiStartedAt);\n  } catch (e) {\n    printBuildSummary(\"API\", false, Date.now() - apiStartedAt);\n    console.error(e);\n    process.exit(1);\n  }\n}\n\n/**\n * pnpm build web 하면 실행되는 함수입니다.\n * Web 프로젝트만 빌드합니다.\n *\n * Sonamu.init 없이 호출될 것을 상정하여 구현되었습니다.\n */\nasync function build_web({ skipIfMissing = false } = {}) {\n  const appRoot = findAppRootPath();\n  const webPath = path.join(appRoot, \"web\");\n\n  if (!(await exists(webPath))) {\n    if (skipIfMissing) {\n      console.log(chalk.gray(\"Web 디렉토리가 없으므로 Web 빌드를 건너뜁니다.\"));\n      return;\n    }\n    console.error(`web 디렉토리를 찾을 수 없습니다: ${webPath}`);\n    process.exit(1);\n  }\n\n  const webStartedAt = Date.now();\n  try {\n    for (const artifact of WEB_ARTIFACTS) {\n      const cwd = path.join(appRoot, artifact.projectPath);\n      printTaskHeader(artifact.name, artifact.description, cwd);\n\n      await runBuildSteps(artifact, { cwd, buildCommandArgs: {} });\n    }\n    printBuildSummary(\"Web\", true, Date.now() - webStartedAt);\n  } catch (e) {\n    printBuildSummary(\"Web\", false, Date.now() - webStartedAt);\n    console.error(e);\n    process.exit(1);\n  }\n}\n\n/**\n * pre-build, build, post-build 단계를 순차적으로 실행합니다.\n */\nasync function runBuildSteps<T>(\n  artifact: BuildArtifact<T>,\n  options: { cwd: string; buildCommandArgs: T },\n) {\n  const steps = [\n    { name: \"pre-build\", cmd: artifact.preBuildCommand?.() },\n    { name: \"build\", cmd: artifact.buildCommand(options.buildCommandArgs) },\n    { name: \"post-build\", cmd: artifact.postBuildCommand?.() },\n  ].filter((step) => step.cmd);\n\n  for (let i = 0; i < steps.length; i++) {\n    const step = steps[i];\n    const isLast = i === steps.length - 1;\n\n    try {\n      assert(step.cmd);\n      printTaskStart(step.name, step.cmd, isLast);\n      await execWithLinePrefix(step.cmd, { cwd: options.cwd });\n      printTaskSuccess(step.name, isLast);\n    } catch (e) {\n      printTaskFailed(step.name, isLast);\n      throw new Error(`${step.name} failed`, { cause: e });\n    }\n  }\n}\n\n/**\n * pnpm start 하면 실행되는 함수입니다.\n * 빌드된 프로젝트를 실행합니다.\n *\n * 빌드된 결과물(dist 디렉토리의 index.js 엔트리포인트)이 없다면 실행을 중단합니다.\n * 소스맵 지원과 dotenv 지원을 포함하여 실행합니다.\n *\n * Sonamu.init 없이 호출될 것을 상정하여 구현되었습니다.\n */\nasync function start() {\n  const apiRoot = findApiRootPath();\n  const entryPoint = \"dist/index.js\";\n\n  if (!(await exists(entryPoint))) {\n    console.log(chalk.red(`${entryPoint} not found. Please build your project first.`));\n    console.log(chalk.blue(\"Run: pnpm sonamu build\"));\n    return;\n  }\n\n  const { spawn } = await import(\"child_process\");\n  const serverProcess = spawn(\n    process.execPath,\n    [\"--enable-source-maps\", \"-r\", \"dotenv/config\", entryPoint],\n    {\n      cwd: apiRoot,\n      stdio: \"inherit\",\n    },\n  );\n\n  process.on(\"SIGINT\", () => {\n    serverProcess.kill(\"SIGTERM\");\n    process.exit(0);\n  });\n}\n\nasync function setupMigrator() {\n  // migrator\n  migrator = new Migrator();\n}\n\nasync function setupFixtureManager() {\n  FixtureManager.init();\n}\n\nasync function migrate_apply(targets: (keyof SonamuDBConfig)[]) {\n  await setupMigrator();\n  await migrator.runAction(\"apply\", targets);\n}\n\nasync function migrate_run() {\n  await setupMigrator();\n  const localHosts = [\"localhost\", \"127.0.0.1\", \"0.0.0.0\", \"::1\"];\n  const targets = Object.keys(Sonamu.dbConfig).filter((target) => {\n    const targetConfig = Sonamu.dbConfig[target as keyof SonamuDBConfig];\n    const host = (targetConfig?.connection as { host?: string })?.host ?? \"localhost\";\n    return localHosts.includes(host.toLowerCase());\n  });\n\n  // 로컬 데이터베이스에 대해서만 전체 마이그레이션에서 동작\n  await migrator.runAction(\"apply\", targets as (keyof SonamuDBConfig)[]);\n}\n\nasync function migrate_generate() {\n  await setupMigrator();\n\n  const { conns } = await migrator.getStatus();\n  const hasStatus0 = conns.some((conn) => conn.status === 0);\n  if (!hasStatus0) {\n    console.log(\n      chalk.red(\n        \"마이그레이션 파일을 생성하려면 기존 마이그레이션이 최소 하나의 DB에 모두 적용되어 있어야 합니다.\",\n      ),\n    );\n    for (const conn of conns) {\n      if (conn.pending.length > 0) {\n        console.log(chalk.yellow(`  ${conn.name}: pending ${conn.pending.length}개`));\n      }\n    }\n    process.exit(1);\n  }\n\n  const count = await migrator.generatePreparedCodes();\n  if (count > 0) {\n    console.log(chalk.green(`${count}개의 마이그레이션 파일이 생성되었습니다.`));\n  }\n}\n\nasync function migrate_status() {\n  await setupMigrator();\n\n  const status = await migrator.getStatus();\n  // status;\n  console.log(status);\n}\n\nasync function fixture_init() {\n  const srcConfig = Sonamu.dbConfig.development_master;\n  const targets = [\n    {\n      label: \"(REMOTE) Fixture DB\",\n      config: Sonamu.dbConfig.fixture,\n    },\n    {\n      label: \"(LOCAL) Testing DB\",\n      config: Sonamu.dbConfig.test,\n      toSkip: (() => {\n        const remoteConn = Sonamu.dbConfig.fixture.connection as Knex.ConnectionConfig;\n        const localConn = Sonamu.dbConfig.test.connection as Knex.ConnectionConfig;\n        return remoteConn.host === localConn.host && remoteConn.database === localConn.database;\n      })(),\n    },\n  ] as {\n    label: string;\n    config: Knex.Config;\n    toSkip?: boolean;\n  }[];\n\n  // 1. 기준DB 스키마를 덤프\n  console.log(\"DUMP...\");\n  const dumpFilename = `/tmp/sonamu-fixture-init-${Date.now()}.sql`;\n  const srcConn = srcConfig.connection as Knex.ConnectionConfig;\n  const migrationsDump = `/tmp/sonamu-fixture-init-migrations-${Date.now()}.sql`;\n  execSync(\n    `mysqldump -h${srcConn.host} -u${srcConn.user} -p${srcConn.password} --single-transaction -d --no-create-db --triggers ${srcConn.database} > ${dumpFilename}`,\n  );\n  const _db = knex(srcConfig);\n  const [[migrations]] = await _db.raw(\n    \"SELECT COUNT(*) as count FROM information_schema.tables WHERE table_schema = ? AND table_name = 'knex_migrations'\",\n    [srcConn.database],\n  );\n  if (migrations.count > 0) {\n    execSync(\n      `mysqldump -h${srcConn.host} -u${srcConn.user} -p${srcConn.password} --single-transaction --no-create-db --triggers ${srcConn.database} knex_migrations knex_migrations_lock > ${migrationsDump}`,\n    );\n  }\n\n  // 2. 대상DB 각각에 대하여 존재여부 확인 후 붓기\n  for (const { label, config, toSkip } of targets) {\n    const conn = config.connection as Knex.ConnectionConfig;\n\n    if (toSkip === true) {\n      console.log(chalk.red(`${label}: Skipped!`));\n      continue;\n    }\n\n    const db = knex({\n      ...config,\n      connection: {\n        ...((config.connection ?? {}) as Knex.ConnectionConfig),\n        database: undefined,\n      },\n    });\n    const [[row]] = await db.raw(`SHOW DATABASES LIKE \"${conn.database}\"`);\n    if (row) {\n      console.log(chalk.yellow(`${label}: Database \"${conn.database}\" Already exists`));\n      await db.destroy();\n      continue;\n    }\n\n    console.log(`SYNC to ${label}...`);\n    const mysqlCmd = `mysql -h${conn.host} -u${conn.user} -p${conn.password}`;\n    execSync(`${mysqlCmd} -e 'DROP DATABASE IF EXISTS \\`${conn.database}\\`'`);\n    execSync(`${mysqlCmd} -e 'CREATE DATABASE \\`${conn.database}\\`'`);\n    execSync(`${mysqlCmd} ${conn.database} < ${dumpFilename}`);\n    if (await exists(migrationsDump)) {\n      execSync(`${mysqlCmd} ${conn.database} < ${migrationsDump}`);\n    }\n\n    await db.destroy();\n  }\n\n  await _db.destroy();\n}\n\nasync function fixture_import(entityId: string, recordIds: number[]) {\n  await setupFixtureManager();\n\n  await FixtureManager.importFixture(entityId, recordIds);\n  await FixtureManager.sync();\n}\n\nasync function fixture_sync() {\n  await setupFixtureManager();\n\n  await FixtureManager.sync();\n}\n\n/**\n * fixture gen 명령어\n * 옵션을 process.argv에서 파싱\n */\nasync function fixture_gen() {\n  const options = parseOptions(process.argv);\n  await fixtureGenCommand(options);\n}\n\n/**\n * fixture fetch 명령어\n * 옵션을 process.argv에서 파싱\n */\nasync function fixture_fetch() {\n  const options = parseOptions(process.argv);\n  await fixtureFetchCommand(options);\n}\n\n/**\n * fixture explore 명령어\n * 옵션을 process.argv에서 파싱\n */\nasync function fixture_explore() {\n  const options = parseOptions(process.argv);\n  await fixtureExploreCommand(options);\n}\n\n/**\n * 간단한 옵션 파서\n */\nfunction parseOptions(\n  argv: string[],\n): Record<string, string | boolean | string[]> & { _: string[] } {\n  const options: Record<string, string | boolean | string[]> & { _: string[] } = { _: [] };\n\n  for (let i = 0; i < argv.length; i++) {\n    const arg = argv[i];\n\n    if (arg.startsWith(\"--\")) {\n      const key = arg.slice(2);\n\n      if (key.includes(\"=\")) {\n        const [k, v] = key.split(\"=\");\n        options[k] = v;\n      } else {\n        const next = argv[i + 1];\n        if (next && !next.startsWith(\"--\")) {\n          options[key] = next;\n          i++;\n        } else {\n          options[key] = true;\n        }\n      }\n    } else if (arg.startsWith(\"-\")) {\n      const key = arg.slice(1);\n      const next = argv[i + 1];\n\n      if (next && !next.startsWith(\"-\")) {\n        options[key] = next;\n        i++;\n      } else {\n        options[key] = true;\n      }\n    } else {\n      options._.push(arg);\n    }\n  }\n\n  return options;\n}\n\nasync function stub_practice(name: string) {\n  const practiceDir = path.join(Sonamu.apiRootPath, \"src\", \"practices\");\n  const fileNames = await readdir(practiceDir);\n\n  const maxSeqNo = await (async () => {\n    if (!(await exists(practiceDir))) {\n      await mkdir(practiceDir, { recursive: true });\n    }\n\n    const filteredSeqs = fileNames\n      .filter((fileName) => fileName.startsWith(\"p\") && fileName.endsWith(\".ts\"))\n      .map((fileName) => {\n        const [, seqNo] = fileName.match(/^p([0-9]+)-/) ?? [\"0\", \"0\"];\n        return parseInt(seqNo);\n      })\n      .toSorted((a, b) => b - a);\n\n    if (filteredSeqs.length > 0) {\n      return filteredSeqs[0];\n    }\n\n    return 0;\n  })();\n\n  const currentSeqNo = maxSeqNo + 1;\n  const fileName = `p${currentSeqNo}-${name}.ts`;\n  const dstPath = path.join(practiceDir, fileName);\n\n  const code = [\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  await writeFile(dstPath, code);\n\n  execSync(`code ${dstPath}`);\n\n  const runCode = `yarn node -r dotenv/config --enable-source-maps dist/practices/${fileName.replace(\n    \".ts\",\n    \".js\",\n  )}`;\n  console.log(`${chalk.blue(runCode)} copied to clipboard.`);\n  execSync(`echo \"${runCode}\" | pbcopy`);\n}\n\nasync function stub_entity(entityId: string) {\n  await Sonamu.syncer.createEntity({ entityId, title: entityId });\n\n  const { flags } = parseCliOptions();\n  const useAI = flags.has(\"ai\");\n  const noCones = flags.has(\"no-cones\");\n\n  // --no-cones: cone 생성 스킵\n  if (noCones) {\n    console.log(`✓ Entity '${entityId}' created without cones`);\n    return;\n  }\n\n  const { EntityManager } = await import(\"../entity/entity-manager\");\n  const entity = EntityManager.get(entityId);\n  if (!entity) {\n    console.error(`Entity not found: ${entityId}`);\n    return;\n  }\n\n  // --ai: LLM으로 cone 생성\n  if (useAI) {\n    console.log(`✓ Entity '${entityId}' created`);\n    console.log(`🌟 Generating AI-powered cones...`);\n    try {\n      const configLocale = Sonamu.config.i18n?.defaultLocale;\n      const locale =\n        configLocale === \"ko\" || configLocale === \"en\" || configLocale === \"ja\"\n          ? configLocale\n          : \"ko\";\n\n      const result = await entity.generateCones({\n        preserveExisting: false,\n        onlyEmpty: false,\n        locale,\n      });\n\n      console.log(`✅ Done (${result.tokensUsed} tokens)`);\n    } catch (error) {\n      if (error instanceof Error && error.message.includes(\"ANTHROPIC_API_KEY\")) {\n        console.error(`\\n❌ ${error.message}`);\n        console.error(`\\n💡 Remove --ai flag to use template cones instead`);\n      } else {\n        throw error;\n      }\n    }\n    return;\n  }\n\n  // 기본: 템플릿 cone 자동 생성\n  // LLM 없이 faker-mappings.ts를 활용하여 기본 cone 메타데이터를 생성합니다.\n  // 이를 통해 ANTHROPIC_API_KEY가 없어도 Sonamu를 사용할 수 있으며,\n  // 생성된 템플릿 cone은 나중에 'cone gen' 명령어로 AI를 통해 업그레이드할 수 있습니다.\n  console.log(`🌟 Generating template cones...`);\n  await entity.generateTemplateCones();\n  console.log(`✓ Entity '${entityId}' created with template cones`);\n  console.log(`💡 Tip: Run 'pnpm sonamu cone gen ${entityId}' to improve with AI`);\n}\n\n/**\n * AI를 사용하여 entity의 cone 메타데이터를 생성하거나 업그레이드합니다.\n *\n * 옵션:\n * - --regenerate: 전체 재생성 (기존 cone 덮어쓰기)\n * - --locale <ko|en|ja>: 생성 언어 지정\n * - 기본: onlyEmpty 모드 (기존 fixtureHint 보존)\n *\n * ANTHROPIC_API_KEY 필요 (sonamu.secret.ts 또는 환경변수)\n */\nasync function cone_gen(entityId: string) {\n  const { EntityManager } = await import(\"../entity/entity-manager\");\n  const { flags, options } = parseCliOptions();\n\n  // --all 옵션: 모든 entity cone 생성\n  if (flags.has(\"all\") || entityId === \"all\") {\n    const allEntities = EntityManager.getAllEntities();\n    console.log(`🌟 Generating AI-powered cones for ${allEntities.length} entities...\\n`);\n\n    let totalTokens = 0;\n    const errors: string[] = [];\n\n    for (const entity of allEntities) {\n      try {\n        console.log(`Processing ${entity.id}...`);\n        const configLocale = options.locale || Sonamu.config.i18n?.defaultLocale;\n        const locale =\n          configLocale === \"ko\" || configLocale === \"en\" || configLocale === \"ja\"\n            ? configLocale\n            : \"ko\";\n\n        const result = await entity.generateCones({\n          preserveExisting: !flags.has(\"regenerate\"),\n          onlyEmpty: !flags.has(\"regenerate\"),\n          locale,\n        });\n\n        totalTokens += result.tokensUsed;\n        console.log(`  ✓ ${entity.id} (${result.tokensUsed} tokens)\\n`);\n      } catch (error) {\n        const message = error instanceof Error ? error.message : \"Unknown error\";\n        errors.push(`${entity.id}: ${message}`);\n        console.error(`  ✗ ${entity.id}: ${message}\\n`);\n      }\n    }\n\n    console.log(`\\n✅ Done! Total: ${totalTokens} tokens used`);\n    const estimatedCost = (totalTokens * 9) / 1_000_000;\n    console.log(`💰 Estimated cost: ~$${estimatedCost.toFixed(4)}`);\n\n    if (errors.length > 0) {\n      console.error(`\\n❌ Failed entities (${errors.length}):`);\n      for (const err of errors) {\n        console.error(`  - ${err}`);\n      }\n    }\n    return;\n  }\n\n  // 단일 entity cone 생성\n  const entity = EntityManager.get(entityId);\n  if (!entity) {\n    console.error(`Entity not found: ${entityId}`);\n    return;\n  }\n\n  const mode = flags.has(\"regenerate\") ? \"regenerating\" : \"generating\";\n  console.log(\n    `🌟 ${mode === \"regenerating\" ? \"Regenerating\" : \"Generating\"} AI-powered cones for ${entityId}...`,\n  );\n\n  try {\n    const configLocale = options.locale || Sonamu.config.i18n?.defaultLocale;\n    const locale =\n      configLocale === \"ko\" || configLocale === \"en\" || configLocale === \"ja\" ? configLocale : \"ko\";\n\n    const result = await entity.generateCones({\n      preserveExisting: !flags.has(\"regenerate\"),\n      onlyEmpty: !flags.has(\"regenerate\"),\n      locale,\n    });\n\n    console.log(`✅ Done! (${result.tokensUsed} tokens used)`);\n\n    // 토큰 비용 계산 (대략적인 추정)\n    // Claude Sonnet 4.5: input $3/M tokens, output $15/M tokens\n    // 간단하게 평균 $9/M tokens로 계산\n    const estimatedCost = (result.tokensUsed * 9) / 1_000_000;\n    console.log(`💰 Estimated cost: ~$${estimatedCost.toFixed(4)}`);\n  } catch (error) {\n    if (error instanceof Error) {\n      if (error.message.includes(\"ANTHROPIC_API_KEY\")) {\n        console.error(`\\n❌ ${error.message}`);\n        console.error(`\\n💡 To use AI-powered cone generation:`);\n        console.error(`   1. Get an API key from https://console.anthropic.com/`);\n        console.error(\n          `   2. Add it to sonamu.secret.ts or set ANTHROPIC_API_KEY environment variable`,\n        );\n      } else if (error.message.includes(\"Rate limit\")) {\n        console.error(`\\n❌ ${error.message}`);\n        console.error(`\\n💡 Please wait a moment and try again.`);\n      } else {\n        console.error(`\\n❌ Failed to generate cones: ${error.message}`);\n      }\n    } else {\n      console.error(`\\n❌ Failed to generate cones: Unknown error`);\n    }\n  }\n}\n\nasync function scaffold_model(entityId: string) {\n  await Sonamu.syncer.generateTemplate(\"model\", {\n    entityId,\n  });\n}\n\nasync function scaffold_model_test(entityId: string) {\n  await Sonamu.syncer.generateTemplate(\"model_test\", {\n    entityId,\n  });\n}\n\n/**\n * pnpm sonamu skills sync 하면 실행되는 함수입니다.\n * 공식 Skills를 로컬 프로젝트 또는 글로벌 ~/.claude/로 동기화합니다.\n *\n * --global 플래그: ~/.claude/에 동기화 (프로젝트 생성 전 사용 가능)\n */\nasync function skills_sync() {\n  const { flags } = parseCliOptions();\n  const isGlobal = flags.has(\"global\");\n\n  // 개발 환경 - cli.ts: sonamu/modules/sonamu/src/bin/cli.ts\n  // 빌드 후 - cli.js: node_modules/sonamu/dist/bin/cli.js (실제 실행)\n  // skills 위치: node_modules/sonamu/src/skills (npm 배포 시)\n  const sourceBase = path.resolve(import.meta.dirname, \"..\", \"..\", \"src\", \"skills\");\n  const sourceSkillsDir = path.join(sourceBase, \"sonamu\");\n  const sourceClaudeMd = path.join(sourceBase, \"CLAUDE.md\");\n\n  if (!(await exists(sourceSkillsDir))) {\n    console.log(chalk.yellow(\"Skills source not found in sonamu package.\"));\n    return;\n  }\n\n  if (isGlobal) {\n    const homeClaudeDir = path.join(os.homedir(), \".claude\");\n    await skills_sync_to(homeClaudeDir, sourceSkillsDir, sourceClaudeMd, {\n      useSymlink: false,\n      copyProjectTemplates: false,\n      isGlobal: true,\n    });\n\n    // ~/.claude/commands/sonamu-skills.md 설치\n    const sourceCommandsDir = path.join(sourceBase, \"commands\");\n    const sourceCommand = path.join(sourceCommandsDir, \"sonamu-skills.md\");\n    if (await exists(sourceCommand)) {\n      const targetCommandsDir = path.join(homeClaudeDir, \"commands\");\n      await mkdir(targetCommandsDir, { recursive: true });\n      await cp(sourceCommand, path.join(targetCommandsDir, \"sonamu-skills.md\"));\n      console.log(chalk.green(`✓ /sonamu-skills command installed → ~/.claude/commands/`));\n    }\n\n    console.log(chalk.cyan(`\\n  Global sync complete → ~/.claude/skills/sonamu/`));\n    console.log(chalk.dim(`  These skills are available in all Claude Code sessions.`));\n    console.log(\n      chalk.dim(\n        `  Once a project is created, run 'pnpm sonamu skills sync' for project-local sync.`,\n      ),\n    );\n  } else {\n    const workspaceRoot = await findWorkspaceRoot();\n    const claudeDir = path.join(workspaceRoot, \".claude\");\n    await skills_sync_to(claudeDir, sourceSkillsDir, sourceClaudeMd, {\n      useSymlink: true,\n      copyProjectTemplates: true,\n      sourceBase,\n    });\n  }\n}\n\n/**\n * claudeDir로 skills를 동기화하는 공통 로직입니다.\n */\nasync function skills_sync_to(\n  claudeDir: string,\n  sourceSkillsDir: string,\n  sourceClaudeMd: string,\n  options: {\n    useSymlink: boolean;\n    copyProjectTemplates: boolean;\n    sourceBase?: string;\n    isGlobal?: boolean;\n  },\n) {\n  const targetSkillsDir = path.join(claudeDir, \"skills\", \"sonamu\");\n\n  // 기존 디렉토리/symlink 삭제 후 재생성\n  // exists()는 broken symlink를 감지하지 못하므로 rm을 무조건 시도합니다\n  try {\n    await rm(targetSkillsDir, { recursive: true, force: true });\n  } catch {\n    // 파일이 없으면 무시\n  }\n\n  await mkdir(path.dirname(targetSkillsDir), { recursive: true });\n\n  if (options.useSymlink) {\n    try {\n      await symlink(sourceSkillsDir, targetSkillsDir, \"dir\");\n      console.log(chalk.green(`✓ Skills linked (symlink)`));\n    } catch (error) {\n      console.log(\n        chalk.yellow(`⚠ Symlink failed: ${error instanceof Error ? error.message : String(error)}`),\n      );\n      console.log(chalk.yellow(`  Falling back to copy...`));\n      await skillsCopy(sourceSkillsDir, targetSkillsDir);\n    }\n  } else {\n    await skillsCopy(sourceSkillsDir, targetSkillsDir);\n  }\n\n  // project 디렉토리 초기화 (없으면 생성, 있으면 유지)\n  if (options.copyProjectTemplates && options.sourceBase) {\n    const sourceProjectDir = path.join(options.sourceBase, \"project\");\n    const targetProjectDir = path.join(claudeDir, \"skills\", \"project\");\n\n    if (await exists(sourceProjectDir)) {\n      if (!(await exists(targetProjectDir))) {\n        try {\n          await cp(sourceProjectDir, targetProjectDir, { recursive: true });\n          console.log(chalk.green(`✓ Project templates initialized`));\n        } catch (error) {\n          console.error(\n            chalk.red(\n              `✗ Failed to initialize project templates: ${error instanceof Error ? error.message : String(error)}`,\n            ),\n          );\n        }\n      } else {\n        console.log(chalk.dim(`⏭ Project templates already exist (preserved)`));\n      }\n    }\n  }\n\n  // settings.local.json — project-local 모드에서만, 없을 때만 생성\n  if (options.copyProjectTemplates) {\n    const settingsLocalPath = path.join(claudeDir, \"settings.local.json\");\n    if (!(await exists(settingsLocalPath))) {\n      try {\n        const settingsContent = {\n          hooks: {\n            PostToolUse: [\n              {\n                matcher: \"Edit|Write|MultiEdit\",\n                hooks: [\n                  {\n                    type: \"command\",\n                    command: \"pnpm check 2>&1 | head -60\",\n                  },\n                ],\n              },\n            ],\n          },\n        };\n        await writeFile(settingsLocalPath, `${JSON.stringify(settingsContent, null, 2)}\\n`);\n        console.log(chalk.green(`✓ .claude/settings.local.json created`));\n      } catch (error) {\n        console.error(\n          chalk.red(\n            `✗ Failed to create settings.local.json: ${error instanceof Error ? error.message : String(error)}`,\n          ),\n        );\n      }\n    } else {\n      console.log(chalk.dim(`⏭ .claude/settings.local.json already exists (preserved)`));\n    }\n  }\n\n  // CLAUDE.md 복사/업데이트\n  if (await exists(sourceClaudeMd)) {\n    try {\n      const targetClaudeMd = path.join(claudeDir, \"CLAUDE.md\");\n      const rawContent = await readFile(sourceClaudeMd, \"utf-8\");\n      // 글로벌 모드에서는 상대 경로를 절대 경로로 변환합니다\n      const sourceContent = options.isGlobal\n        ? rawContent.replaceAll(\".claude/skills/sonamu/\", \"~/.claude/skills/sonamu/\")\n        : rawContent;\n\n      if (await exists(targetClaudeMd)) {\n        const targetContent = await readFile(targetClaudeMd, \"utf-8\");\n        const startMarker = \"<!-- SONAMU:START -->\";\n        const endMarker = \"<!-- SONAMU:END -->\";\n        if (targetContent.includes(startMarker) && targetContent.includes(endMarker)) {\n          const startIdx = targetContent.indexOf(startMarker);\n          const endIdx = targetContent.indexOf(endMarker);\n\n          if (startIdx !== -1 && endIdx !== -1 && startIdx < endIdx) {\n            const before = targetContent.substring(0, startIdx);\n            const after = targetContent.substring(endIdx + endMarker.length);\n            const newContent = `${before}${startMarker}\\n${sourceContent}\\n${endMarker}${after}`;\n            await writeFile(targetClaudeMd, newContent);\n            console.log(chalk.green(`✓ CLAUDE.md updated (marker region)`));\n          } else {\n            console.log(chalk.yellow(`⏭ CLAUDE.md marker positions invalid, skipped`));\n          }\n        } else {\n          // 마커가 없는 기존 CLAUDE.md에 Sonamu 섹션을 추가합니다\n          const appended = `${targetContent.trimEnd()}\\n\\n<!-- SONAMU:START -->\\n${sourceContent}\\n<!-- SONAMU:END -->\\n`;\n          await writeFile(targetClaudeMd, appended);\n          console.log(chalk.green(`✓ CLAUDE.md updated (appended Sonamu section)`));\n        }\n      } else {\n        const withMarkers = `<!-- SONAMU:START -->\\n${sourceContent}\\n<!-- SONAMU:END -->\\n`;\n        await writeFile(targetClaudeMd, withMarkers);\n        console.log(chalk.green(`✓ CLAUDE.md created`));\n      }\n    } catch (error) {\n      console.error(\n        chalk.red(\n          `✗ Failed to update CLAUDE.md: ${error instanceof Error ? error.message : String(error)}`,\n        ),\n      );\n    }\n  }\n}\n\nasync function skillsCopy(src: string, dest: string) {\n  try {\n    await cp(src, dest, { recursive: true });\n    console.log(chalk.green(`✓ Skills copied`));\n  } catch (copyError) {\n    console.error(\n      chalk.red(\n        `✗ Failed to copy skills: ${copyError instanceof Error ? copyError.message : String(copyError)}`,\n      ),\n    );\n    throw copyError;\n  }\n}\n\n/**\n * pnpm sonamu skills create <name> 하면 실행되는 함수입니다.\n * 로컬 skill 초안을 생성합니다.\n */\nasync function skills_create(name: string) {\n  const workspaceRoot = await findWorkspaceRoot();\n  const localDir = path.join(workspaceRoot, \".claude\", \"skills\", \"local\");\n\n  // === 파일명 검증 및 Sanitize ===\n  if (!name || name.trim() === \"\") {\n    console.error(chalk.red(\"✗ Skill name is required\"));\n    return;\n  }\n\n  let sanitized = name\n    // 공백을 하이픈으로\n    .replace(/\\s+/g, \"-\")\n    // 경로 구분자 제거\n    .replace(/[/\\\\]/g, \"-\")\n    // Path traversal 방지\n    .replace(/\\.\\./g, \"\")\n    // Windows 금지 문자 제거\n    .replace(/[<>:\"|?*]/g, \"\")\n    // 시작/끝 점, 하이픈, 언더스코어 제거\n    .replace(/^[.\\-_]+|[.\\-_]+$/g, \"\")\n    // 연속된 하이픈을 하나로\n    .replace(/-+/g, \"-\")\n    // 알파벳, 숫자, 하이픈, 언더스코어, 한글만 허용\n    .replace(/[^a-zA-Z0-9-_가-힣]/g, \"\");\n\n  // 길이 제한\n  const MAX_LENGTH = 100;\n  if (sanitized.length > MAX_LENGTH) {\n    sanitized = sanitized.substring(0, MAX_LENGTH);\n    console.log(chalk.yellow(`⚠ Name truncated to ${MAX_LENGTH} characters`));\n  }\n\n  // Windows 예약어 확인\n  const RESERVED_NAMES = [\n    \"CON\",\n    \"PRN\",\n    \"AUX\",\n    \"NUL\",\n    \"COM1\",\n    \"COM2\",\n    \"COM3\",\n    \"COM4\",\n    \"COM5\",\n    \"COM6\",\n    \"COM7\",\n    \"COM8\",\n    \"COM9\",\n    \"LPT1\",\n    \"LPT2\",\n    \"LPT3\",\n    \"LPT4\",\n    \"LPT5\",\n    \"LPT6\",\n    \"LPT7\",\n    \"LPT8\",\n    \"LPT9\",\n  ];\n  if (RESERVED_NAMES.includes(sanitized.toUpperCase())) {\n    sanitized = `skill-${sanitized}`;\n    console.log(chalk.yellow(`⚠ Reserved name detected, prefixed with \"skill-\"`));\n  }\n\n  // 빈 문자열 체크\n  if (sanitized === \"\") {\n    console.error(chalk.red(\"✗ Invalid skill name after sanitization\"));\n    console.log(chalk.dim(`  Original: \"${name}\"`));\n    return;\n  }\n\n  // 변경 알림\n  if (sanitized !== name) {\n    console.log(chalk.yellow(`⚠ Name sanitized: \"${name}\" → \"${sanitized}\"`));\n  }\n\n  const filePath = path.join(localDir, `${sanitized}.md`);\n\n  if (await exists(filePath)) {\n    console.log(chalk.yellow(`Skill \"${sanitized}\" already exists.`));\n    return;\n  }\n\n  await mkdir(localDir, { recursive: true });\n\n  const template = `---\nname: ${sanitized}\ncategory: other\ncreated_at: ${new Date().toISOString().split(\"T\")[0]}\nstatus: draft\n---\n\n# ${sanitized}\n\n## 상황\n\n[어떤 문제였는지]\n\n## 해결 방법\n\n[어떻게 해결했는지]\n\n## 코드 예시\n\n\\`\\`\\`typescript\n// 예시 코드\n\\`\\`\\`\n`;\n\n  await writeFile(filePath, template);\n  console.log(chalk.green(`✓ Created .claude/skills/local/${sanitized}.md`));\n}\n\n/**\n * pnpm sonamu auth generate 하면 실행되는 함수입니다.\n * better-auth 엔티티들(User, Session, Account, Verification)을 생성합니다.\n *\n * 옵션:\n * --plugins phone-number,2fa  플러그인 엔티티도 함께 생성\n */\nasync function auth_generate() {\n  // --plugins 옵션 파싱\n  const pluginsArg = process.argv.find((arg) => arg.startsWith(\"--plugins\"));\n  const plugins: BetterAuthPluginId[] = [];\n\n  if (pluginsArg) {\n    const pluginValue = pluginsArg.includes(\"=\")\n      ? pluginsArg.split(\"=\")[1]\n      : process.argv[process.argv.indexOf(pluginsArg) + 1];\n\n    if (pluginValue) {\n      const pluginIds = pluginValue.split(\",\").map((p) => p.trim());\n\n      for (const id of pluginIds) {\n        if (isValidPluginId(id)) {\n          plugins.push(id);\n        } else {\n          console.log(chalk.yellow(`⚠ Unknown plugin: ${id}`));\n          console.log(chalk.dim(`  Supported plugins: ${SUPPORTED_PLUGIN_IDS.join(\", \")}`));\n        }\n      }\n    }\n  }\n\n  console.log(chalk.yellow.bold(\"🔐 Generating better-auth entities...\\n\"));\n\n  if (plugins.length > 0) {\n    console.log(chalk.dim(`  Plugins: ${plugins.join(\", \")}`));\n  }\n\n  await generateBetterAuthEntities({ plugins });\n}\n\n/**\n * pnpm sonamu auth add-companions 하면 실행되는 함수입니다.\n * 기존 프로젝트의 entity.json에 fixtureCompanions를 소급 추가합니다.\n *\n * 이미 fixtureCompanions가 있는 entity는 스킵합니다 (덮어쓰기 없음).\n */\nasync function auth_add_companions() {\n  console.log(chalk.yellow.bold(\"🔐 Adding fixtureCompanions to better-auth entities...\\n\"));\n  await addCompanionsToEntities();\n  console.log(chalk.bold(\"\\n✅ Done!\"));\n}\n\n/**\n * 워크스페이스 루트를 찾습니다.\n * 우선순위: pnpm-workspace.yaml > package.json(workspaces) > .agents/\n *\n * CLAUDE.md는 서브패키지에도 존재할 수 있으므로 사용하지 않습니다.\n * .agents/는 agents init이 생성하는 디렉토리로, 워크스페이스 루트에만 존재합니다.\n */\nasync function findWorkspaceRoot() {\n  let dir = process.cwd();\n\n  while (dir !== path.dirname(dir)) {\n    // 1. pnpm-workspace.yaml: 확실한 monorepo 루트.\n    if (await exists(path.join(dir, \"pnpm-workspace.yaml\"))) {\n      return dir;\n    }\n\n    // 2. package.json에 workspaces 필드가 있으면 monorepo 루트.\n    const packagePath = path.join(dir, \"package.json\");\n    if (await exists(packagePath)) {\n      try {\n        const packageJson = JSON.parse(await readFile(packagePath, \"utf-8\"));\n        if (packageJson.workspaces) {\n          return dir;\n        }\n      } catch {\n        // 파싱 실패시 무시\n      }\n    }\n\n    // 3. .agents/: agents init이 생성한 디렉토리. 서브패키지에는 존재하지 않음.\n    if (await exists(path.join(dir, \".agents\"))) {\n      return dir;\n    }\n\n    dir = path.dirname(dir);\n  }\n\n  // 찾지 못하면 api 폴더의 부모 사용\n  return findAppRootPath();\n}\n"],"mappings":"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"}