sonamu 0.9.5 → 0.9.7

package/dist/api/websocket-helpers.d.ts

@@ -0,0 +1,24 @@
+import { type Server } from "http";
+import { type WebsocketPluginOptions } from "@fastify/websocket";
+import { type FastifyReply } from "fastify";
+import { type ExtendedApi } from "./decorators";
+export declare function resolveIntegratedViteHmrOptions({ httpServer, requiresDedicatedWebSocketServer, rawPort, }: {
+    httpServer: Server;
+    requiresDedicatedWebSocketServer: boolean;
+    rawPort?: string | undefined;
+}): {
+    server: Server;
+} | {
+    port: number;
+};
+export declare function resolveWebSocketPluginOptions({ rawPluginOption, apis, }: {
+    rawPluginOption: boolean | WebsocketPluginOptions | undefined;
+    apis: ExtendedApi[];
+}): WebsocketPluginOptions | undefined;
+export declare function resolveWebSocketCloseDescriptor(error: unknown): {
+    code: number;
+    reason: string;
+    logLevel: "warn" | "error";
+};
+export declare function createWebSocketReplyStub(): FastifyReply;
+//# sourceMappingURL=websocket-helpers.d.ts.map

package/dist/api/websocket-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"websocket-helpers.d.ts","sourceRoot":"","sources":["../../src/api/websocket-helpers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,MAAM,CAAC;AAEnC,OAAO,EAAE,KAAK,sBAAsB,EAAE,MAAM,oBAAoB,CAAC;AACjE,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,SAAS,CAAC;AAI5C,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,cAAc,CAAC;AAIhD,wBAAgB,+BAA+B,CAAC,EAC9C,UAAU,EACV,gCAAgC,EAChC,OAA0C,GAC3C,EAAE;IACD,UAAU,EAAE,MAAM,CAAC;IACnB,gCAAgC,EAAE,OAAO,CAAC;IAC1C,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAC9B,GAAG;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,CAOxC;AAID,wBAAgB,6BAA6B,CAAC,EAC5C,eAAe,EACf,IAAI,GACL,EAAE;IACD,eAAe,EAAE,OAAO,GAAG,sBAAsB,GAAG,SAAS,CAAC;IAC9D,IAAI,EAAE,WAAW,EAAE,CAAC;CACrB,GAAG,sBAAsB,GAAG,SAAS,CA6BrC;AAID,wBAAgB,+BAA+B,CAAC,KAAK,EAAE,OAAO,GAAG;IAC/D,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC;CAC5B,CAgCA;AAID,wBAAgB,wBAAwB,IAAI,YAAY,CAQvD"}

package/dist/api/websocket-helpers.js

@@ -0,0 +1,77 @@
+import { __esmMin } from "../_virtual/rolldown_runtime.js";
+import { init_so_exceptions, isSoException } from "../exceptions/so-exceptions.js";
+import { init_utils, isPlainObject } from "../utils/utils.js";
+
+//#region src/api/websocket-helpers.ts
+function resolveIntegratedViteHmrOptions({ httpServer, requiresDedicatedWebSocketServer, rawPort = process.env.SONAMU_VITE_HMR_PORT }) {
+	if (!requiresDedicatedWebSocketServer) {
+		return { server: httpServer };
+	}
+	const parsedPort = rawPort?.trim() ? Number(rawPort) : 24678;
+	return Number.isFinite(parsedPort) && parsedPort > 0 ? { port: parsedPort } : { port: 24678 };
+}
+function resolveWebSocketPluginOptions({ rawPluginOption, apis }) {
+	const pluginOptions = rawPluginOption && rawPluginOption !== true ? { ...rawPluginOption } : {};
+	const serverOptions = isPlainObject(pluginOptions.options) ? { ...pluginOptions.options } : {};
+	if (isPositiveNumber(pluginOptions.maxPayload) && serverOptions.maxPayload === undefined) {
+		serverOptions.maxPayload = pluginOptions.maxPayload;
+		delete pluginOptions.maxPayload;
+	}
+	if (serverOptions.maxPayload === undefined) {
+		const routeMaxPayloads = apis.map((api) => api.websocketOptions?.maxPayload).filter(isPositiveNumber);
+		if (routeMaxPayloads.length > 0) {
+			serverOptions.maxPayload = Math.max(...routeMaxPayloads);
+		}
+	}
+	if (Object.keys(serverOptions).length > 0) {
+		pluginOptions.options = serverOptions;
+	}
+	return Object.keys(pluginOptions).length > 0 ? pluginOptions : undefined;
+}
+function resolveWebSocketCloseDescriptor(error) {
+	if (isSoException(error)) {
+		if (error.statusCode === 400) {
+			return {
+				code: 1008,
+				reason: "Invalid websocket handshake",
+				logLevel: "warn"
+			};
+		}
+		if (error.statusCode === 401 || error.statusCode === 403) {
+			return {
+				code: 1008,
+				reason: "Unauthorized websocket connection",
+				logLevel: "warn"
+			};
+		}
+		if (error.statusCode >= 400 && error.statusCode < 500) {
+			return {
+				code: 1008,
+				reason: "Rejected websocket connection",
+				logLevel: "warn"
+			};
+		}
+	}
+	return {
+		code: 1011,
+		reason: "WebSocket handler failed",
+		logLevel: "error"
+	};
+}
+function createWebSocketReplyStub() {
+	return new Proxy({}, { get() {
+		throw new Error("FastifyReply is not available in websocket context. Define websocketContextProvider if your context setup depends on reply mutation.");
+	} });
+}
+function isPositiveNumber(value) {
+	return typeof value === "number" && Number.isFinite(value) && value > 0;
+}
+var init_websocket_helpers = __esmMin((() => {
+	init_so_exceptions();
+	init_utils();
+}));
+
+//#endregion
+init_websocket_helpers();
+export { createWebSocketReplyStub, init_websocket_helpers, resolveIntegratedViteHmrOptions, resolveWebSocketCloseDescriptor, resolveWebSocketPluginOptions };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid2Vic29ja2V0LWhlbHBlcnMuanMiLCJuYW1lcyI6W10sInNvdXJjZXMiOlsiLi4vLi4vc3JjL2FwaS93ZWJzb2NrZXQtaGVscGVycy50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyB0eXBlIFNlcnZlciB9IGZyb20gXCJodHRwXCI7XG5cbmltcG9ydCB7IHR5cGUgV2Vic29ja2V0UGx1Z2luT3B0aW9ucyB9IGZyb20gXCJAZmFzdGlmeS93ZWJzb2NrZXRcIjtcbmltcG9ydCB7IHR5cGUgRmFzdGlmeVJlcGx5IH0gZnJvbSBcImZhc3RpZnlcIjtcblxuaW1wb3J0IHsgaXNTb0V4Y2VwdGlvbiB9IGZyb20gXCIuLi9leGNlcHRpb25zL3NvLWV4Y2VwdGlvbnNcIjtcbmltcG9ydCB7IGlzUGxhaW5PYmplY3QgfSBmcm9tIFwiLi4vdXRpbHMvdXRpbHNcIjtcbmltcG9ydCB7IHR5cGUgRXh0ZW5kZWRBcGkgfSBmcm9tIFwiLi9kZWNvcmF0b3JzXCI7XG5cbi8vIEZhc3RpZnkgd2Vic29ja2V0IHJvdXRl7JmAIFZpdGUgSE1SIHdlYnNvY2tldOydtCDqsJnsnYAgc2VydmVyIHNvY2tldOydhCDrkZDqs6Ag7Lap64+M7ZWY64qUIOqyg+ydhCDrsKnsp4DtlZjquLAg7JyE7ZW0LFxuLy8gV1Mgcm91dGXqsIAg7KG07J6s7ZWY66m0IEhNUuydhCDrs4Trj4Qg7Y+s7Yq466GcIOu2hOumrO2VtCDrnYTsm4BcbmV4cG9ydCBmdW5jdGlvbiByZXNvbHZlSW50ZWdyYXRlZFZpdGVIbXJPcHRpb25zKHtcbiAgaHR0cFNlcnZlcixcbiAgcmVxdWlyZXNEZWRpY2F0ZWRXZWJTb2NrZXRTZXJ2ZXIsXG4gIHJhd1BvcnQgPSBwcm9jZXNzLmVudi5TT05BTVVfVklURV9ITVJfUE9SVCxcbn06IHtcbiAgaHR0cFNlcnZlcjogU2VydmVyO1xuICByZXF1aXJlc0RlZGljYXRlZFdlYlNvY2tldFNlcnZlcjogYm9vbGVhbjtcbiAgcmF3UG9ydD86IHN0cmluZyB8IHVuZGVmaW5lZDtcbn0pOiB7IHNlcnZlcjogU2VydmVyIH0gfCB7IHBvcnQ6IG51bWJlciB9IHtcbiAgaWYgKCFyZXF1aXJlc0RlZGljYXRlZFdlYlNvY2tldFNlcnZlcikge1xuICAgIHJldHVybiB7IHNlcnZlcjogaHR0cFNlcnZlciB9O1xuICB9XG5cbiAgY29uc3QgcGFyc2VkUG9ydCA9IHJhd1BvcnQ/LnRyaW0oKSA/IE51bWJlcihyYXdQb3J0KSA6IDI0Njc4O1xuICByZXR1cm4gTnVtYmVyLmlzRmluaXRlKHBhcnNlZFBvcnQpICYmIHBhcnNlZFBvcnQgPiAwID8geyBwb3J0OiBwYXJzZWRQb3J0IH0gOiB7IHBvcnQ6IDI0Njc4IH07XG59XG5cbi8vIHJvdXRlLWxldmVsIG1heFBheWxvYWTrpbwg7ISc67KEIHBsdWdpbiBvcHRpb25z7Jy866GcIOyKueqyqeyLnOy8nCwg7YGwIGZyYW1l7J2EIOuwm+ydgCDrkqQg64ur64qUIOuMgOyLoFxuLy8gdHJhbnNwb3J0IOugiOuyqOyXkOyEnCDrqLzsoIAg7KCc7ZWc65CY64+E66GdIO2VqFxuZXhwb3J0IGZ1bmN0aW9uIHJlc29sdmVXZWJTb2NrZXRQbHVnaW5PcHRpb25zKHtcbiAgcmF3UGx1Z2luT3B0aW9uLFxuICBhcGlzLFxufToge1xuICByYXdQbHVnaW5PcHRpb246IGJvb2xlYW4gfCBXZWJzb2NrZXRQbHVnaW5PcHRpb25zIHwgdW5kZWZpbmVkO1xuICBhcGlzOiBFeHRlbmRlZEFwaVtdO1xufSk6IFdlYnNvY2tldFBsdWdpbk9wdGlvbnMgfCB1bmRlZmluZWQge1xuICBjb25zdCBwbHVnaW5PcHRpb25zID1cbiAgICByYXdQbHVnaW5PcHRpb24gJiYgcmF3UGx1Z2luT3B0aW9uICE9PSB0cnVlXG4gICAgICA/IHsgLi4ucmF3UGx1Z2luT3B0aW9uIH1cbiAgICAgIDogKHt9IGFzIFdlYnNvY2tldFBsdWdpbk9wdGlvbnMgJiB7IG1heFBheWxvYWQ/OiBudW1iZXIgfSk7XG4gIGNvbnN0IHNlcnZlck9wdGlvbnMgPSBpc1BsYWluT2JqZWN0KHBsdWdpbk9wdGlvbnMub3B0aW9ucylcbiAgICA/IHsgLi4ucGx1Z2luT3B0aW9ucy5vcHRpb25zIH1cbiAgICA6ICh7fSBhcyBOb25OdWxsYWJsZTxXZWJzb2NrZXRQbHVnaW5PcHRpb25zW1wib3B0aW9uc1wiXT4pO1xuXG4gIGlmIChpc1Bvc2l0aXZlTnVtYmVyKHBsdWdpbk9wdGlvbnMubWF4UGF5bG9hZCkgJiYgc2VydmVyT3B0aW9ucy5tYXhQYXlsb2FkID09PSB1bmRlZmluZWQpIHtcbiAgICBzZXJ2ZXJPcHRpb25zLm1heFBheWxvYWQgPSBwbHVnaW5PcHRpb25zLm1heFBheWxvYWQ7XG4gICAgZGVsZXRlIHBsdWdpbk9wdGlvbnMubWF4UGF5bG9hZDtcbiAgfVxuXG4gIGlmIChzZXJ2ZXJPcHRpb25zLm1heFBheWxvYWQgPT09IHVuZGVmaW5lZCkge1xuICAgIGNvbnN0IHJvdXRlTWF4UGF5bG9hZHMgPSBhcGlzXG4gICAgICAubWFwKChhcGkpID0+IGFwaS53ZWJzb2NrZXRPcHRpb25zPy5tYXhQYXlsb2FkKVxuICAgICAgLmZpbHRlcihpc1Bvc2l0aXZlTnVtYmVyKTtcblxuICAgIGlmIChyb3V0ZU1heFBheWxvYWRzLmxlbmd0aCA+IDApIHtcbiAgICAgIHNlcnZlck9wdGlvbnMubWF4UGF5bG9hZCA9IE1hdGgubWF4KC4uLnJvdXRlTWF4UGF5bG9hZHMpO1xuICAgIH1cbiAgfVxuXG4gIGlmIChPYmplY3Qua2V5cyhzZXJ2ZXJPcHRpb25zKS5sZW5ndGggPiAwKSB7XG4gICAgcGx1Z2luT3B0aW9ucy5vcHRpb25zID0gc2VydmVyT3B0aW9ucztcbiAgfVxuXG4gIHJldHVybiBPYmplY3Qua2V5cyhwbHVnaW5PcHRpb25zKS5sZW5ndGggPiAwID8gcGx1Z2luT3B0aW9ucyA6IHVuZGVmaW5lZDtcbn1cblxuLy8gaGFuZHNoYWtlL2F1dGgvdmFsaWRhdGlvbiDsi6TtjKjrpbwgZ2VuZXJpYyAxMDEx66GcIOutieqwnOyngCDslYrqs6AgMTAwOChwb2xpY3kgdmlvbGF0aW9uKeuhnCDrp6TtlZHtlbQsXG4vLyBjbG9zZSBjb2RlIHBvbGljeeulvCDtlZwg6rOz7JeQ7IScIOygleydmO2VqFxuZXhwb3J0IGZ1bmN0aW9uIHJlc29sdmVXZWJTb2NrZXRDbG9zZURlc2NyaXB0b3IoZXJyb3I6IHVua25vd24pOiB7XG4gIGNvZGU6IG51bWJlcjtcbiAgcmVhc29uOiBzdHJpbmc7XG4gIGxvZ0xldmVsOiBcIndhcm5cIiB8IFwiZXJyb3JcIjtcbn0ge1xuICBpZiAoaXNTb0V4Y2VwdGlvbihlcnJvcikpIHtcbiAgICBpZiAoZXJyb3Iuc3RhdHVzQ29kZSA9PT0gNDAwKSB7XG4gICAgICByZXR1cm4ge1xuICAgICAgICBjb2RlOiAxMDA4LFxuICAgICAgICByZWFzb246IFwiSW52YWxpZCB3ZWJzb2NrZXQgaGFuZHNoYWtlXCIsXG4gICAgICAgIGxvZ0xldmVsOiBcIndhcm5cIixcbiAgICAgIH07XG4gICAgfVxuXG4gICAgaWYgKGVycm9yLnN0YXR1c0NvZGUgPT09IDQwMSB8fCBlcnJvci5zdGF0dXNDb2RlID09PSA0MDMpIHtcbiAgICAgIHJldHVybiB7XG4gICAgICAgIGNvZGU6IDEwMDgsXG4gICAgICAgIHJlYXNvbjogXCJVbmF1dGhvcml6ZWQgd2Vic29ja2V0IGNvbm5lY3Rpb25cIixcbiAgICAgICAgbG9nTGV2ZWw6IFwid2FyblwiLFxuICAgICAgfTtcbiAgICB9XG5cbiAgICBpZiAoZXJyb3Iuc3RhdHVzQ29kZSA+PSA0MDAgJiYgZXJyb3Iuc3RhdHVzQ29kZSA8IDUwMCkge1xuICAgICAgcmV0dXJuIHtcbiAgICAgICAgY29kZTogMTAwOCxcbiAgICAgICAgcmVhc29uOiBcIlJlamVjdGVkIHdlYnNvY2tldCBjb25uZWN0aW9uXCIsXG4gICAgICAgIGxvZ0xldmVsOiBcIndhcm5cIixcbiAgICAgIH07XG4gICAgfVxuICB9XG5cbiAgcmV0dXJuIHtcbiAgICBjb2RlOiAxMDExLFxuICAgIHJlYXNvbjogXCJXZWJTb2NrZXQgaGFuZGxlciBmYWlsZWRcIixcbiAgICBsb2dMZXZlbDogXCJlcnJvclwiLFxuICB9O1xufVxuXG4vLyBXUyDqsr3roZzsl5DshJzripQgcmVwbHnqsIAg7KG07J6s7ZWY7KeAIOyViuycvOuvgOuhnCDsoJHqt7wg7Iuc64+E66W8IOymieyLnCDsl5Drn6zroZwgc3VyZmFjZe2VtCB0cmFuc3BvcnQgbWlzdXNl66W8IOu5qOumrCDrk5zrn6zrg4Rcbi8vIFNTRS9yZXBseeyXkCDsnZjsobTtlZjripQgY29udGV4dFByb3ZpZGVy6rCAIOyeiOycvOuptCB3ZWJzb2NrZXRDb250ZXh0UHJvdmlkZXLrpbwg65Sw66GcIOygleydmO2VmOudvOuKlCDqsIDsnbTrk5wg7Jet7ZWg64+EIO2VqFxuZXhwb3J0IGZ1bmN0aW9uIGNyZWF0ZVdlYlNvY2tldFJlcGx5U3R1YigpOiBGYXN0aWZ5UmVwbHkge1xuICByZXR1cm4gbmV3IFByb3h5KHt9IGFzIEZhc3RpZnlSZXBseSwge1xuICAgIGdldCgpIHtcbiAgICAgIHRocm93IG5ldyBFcnJvcihcbiAgICAgICAgXCJGYXN0aWZ5UmVwbHkgaXMgbm90IGF2YWlsYWJsZSBpbiB3ZWJzb2NrZXQgY29udGV4dC4gRGVmaW5lIHdlYnNvY2tldENvbnRleHRQcm92aWRlciBpZiB5b3VyIGNvbnRleHQgc2V0dXAgZGVwZW5kcyBvbiByZXBseSBtdXRhdGlvbi5cIixcbiAgICAgICk7XG4gICAgfSxcbiAgfSk7XG59XG5cbmZ1bmN0aW9uIGlzUG9zaXRpdmVOdW1iZXIodmFsdWU6IHVua25vd24pOiB2YWx1ZSBpcyBudW1iZXIge1xuICByZXR1cm4gdHlwZW9mIHZhbHVlID09PSBcIm51bWJlclwiICYmIE51bWJlci5pc0Zpbml0ZSh2YWx1ZSkgJiYgdmFsdWUgPiAwO1xufVxuIl0sIm1hcHBpbmdzIjoiOzs7OztBQVdBLFNBQWdCLGdDQUFnQyxFQUM5QyxZQUNBLGtDQUNBLFVBQVUsUUFBUSxJQUFJLHdCQUtrQjtBQUN4QyxLQUFJLENBQUMsa0NBQWtDO0FBQ3JDLFNBQU8sRUFBRSxRQUFRLFlBQVk7O0NBRy9CLE1BQU0sYUFBYSxTQUFTLE1BQU0sR0FBRyxPQUFPLFFBQVEsR0FBRztBQUN2RCxRQUFPLE9BQU8sU0FBUyxXQUFXLElBQUksYUFBYSxJQUFJLEVBQUUsTUFBTSxZQUFZLEdBQUcsRUFBRSxNQUFNLE9BQU87O0FBSy9GLFNBQWdCLDhCQUE4QixFQUM1QyxpQkFDQSxRQUlxQztDQUNyQyxNQUFNLGdCQUNKLG1CQUFtQixvQkFBb0IsT0FDbkMsRUFBRSxHQUFHLGlCQUFpQixHQUNyQixFQUFFO0NBQ1QsTUFBTSxnQkFBZ0IsY0FBYyxjQUFjLFFBQVEsR0FDdEQsRUFBRSxHQUFHLGNBQWMsU0FBUyxHQUMzQixFQUFFO0FBRVAsS0FBSSxpQkFBaUIsY0FBYyxXQUFXLElBQUksY0FBYyxlQUFlLFdBQVc7QUFDeEYsZ0JBQWMsYUFBYSxjQUFjO0FBQ3pDLFNBQU8sY0FBYzs7QUFHdkIsS0FBSSxjQUFjLGVBQWUsV0FBVztFQUMxQyxNQUFNLG1CQUFtQixLQUN0QixLQUFLLFFBQVEsSUFBSSxrQkFBa0IsV0FBVyxDQUM5QyxPQUFPLGlCQUFpQjtBQUUzQixNQUFJLGlCQUFpQixTQUFTLEdBQUc7QUFDL0IsaUJBQWMsYUFBYSxLQUFLLElBQUksR0FBRyxpQkFBaUI7OztBQUk1RCxLQUFJLE9BQU8sS0FBSyxjQUFjLENBQUMsU0FBUyxHQUFHO0FBQ3pDLGdCQUFjLFVBQVU7O0FBRzFCLFFBQU8sT0FBTyxLQUFLLGNBQWMsQ0FBQyxTQUFTLElBQUksZ0JBQWdCOztBQUtqRSxTQUFnQixnQ0FBZ0MsT0FJOUM7QUFDQSxLQUFJLGNBQWMsTUFBTSxFQUFFO0FBQ3hCLE1BQUksTUFBTSxlQUFlLEtBQUs7QUFDNUIsVUFBTztJQUNMLE1BQU07SUFDTixRQUFRO0lBQ1IsVUFBVTtJQUNYOztBQUdILE1BQUksTUFBTSxlQUFlLE9BQU8sTUFBTSxlQUFlLEtBQUs7QUFDeEQsVUFBTztJQUNMLE1BQU07SUFDTixRQUFRO0lBQ1IsVUFBVTtJQUNYOztBQUdILE1BQUksTUFBTSxjQUFjLE9BQU8sTUFBTSxhQUFhLEtBQUs7QUFDckQsVUFBTztJQUNMLE1BQU07SUFDTixRQUFRO0lBQ1IsVUFBVTtJQUNYOzs7QUFJTCxRQUFPO0VBQ0wsTUFBTTtFQUNOLFFBQVE7RUFDUixVQUFVO0VBQ1g7O0FBS0gsU0FBZ0IsMkJBQXlDO0FBQ3ZELFFBQU8sSUFBSSxNQUFNLEVBQUUsRUFBa0IsRUFDbkMsTUFBTTtBQUNKLFFBQU0sSUFBSSxNQUNSLHVJQUNEO0lBRUosQ0FBQzs7QUFHSixTQUFTLGlCQUFpQixPQUFpQztBQUN6RCxRQUFPLE9BQU8sVUFBVSxZQUFZLE9BQU8sU0FBUyxNQUFNLElBQUksUUFBUTs7O3FCQW5IWjthQUNiIn0=

package/dist/bin/cli.js

@@ -1,3 +1,4 @@
+import { execWithLinePrefix, init_console_util, printBuildSummary, printTaskFailed, printTaskHeader, printTaskStart, printTaskSuccess } from "../utils/console-util.js";
 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";
@@ -7,7 +8,6 @@ import { addCompanionsToEntities, generateBetterAuthEntities } from "../auth/aut
 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";
@@ -16,9 +16,9 @@ import { cp, mkdir, readFile, readdir, rm, symlink, writeFile } from "fs/promise
 import path from "path";
 import chalk from "chalk";
 import os from "os";
-import dotenv from "dotenv";
 import { execSync, spawn } from "child_process";
 import { createRequire } from "module";
+import dotenv from "dotenv";
 import process from "process";
 import { tsicli } from "tsicli";
 
@@ -255,9 +255,17 @@ bootstrap().finally(async () => {
 /**
 * pnpm sync 하면 실행되는 함수입니다.
 * 프로젝트를 싱크합니다.
+*
+* `--force` 옵션이 주어지면 lock을 무시하고 풀-싱크를 수행합니다.
+* git post-merge hook이나 CI에서 매 pull 후 자동 실행할 수 있도록 노출.
 */
 async function sync() {
-	await Sonamu.syncer.sync();
+	const { flags } = parseCliOptions();
+	if (flags.has("force")) {
+		await Sonamu.syncer.forceSync();
+	} else {
+		await Sonamu.syncer.sync();
+	}
 }
 /**
 * API 개발 서버를 실행하는 공통 로직입니다.
@@ -1172,4 +1180,4 @@ async function findWorkspaceRoot() {
 
 //#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  const require = createRequire(import.meta.url);\n  const { version } = require(\"../../package.json\");\n  console.log(`🌲 Sonamu v${version}\\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 require = createRequire(import.meta.url);\n  const { version } = require(\"../../package.json\");\n  console.log(`🌲 Sonamu v${version}\\n`);\n\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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"}
+//# 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 *\n * `--force` 옵션이 주어지면 lock을 무시하고 풀-싱크를 수행합니다.\n * git post-merge hook이나 CI에서 매 pull 후 자동 실행할 수 있도록 노출.\n */\nasync function sync() {\n  const { flags } = parseCliOptions();\n  if (flags.has(\"force\")) {\n    await Sonamu.syncer.forceSync();\n  } else {\n    await Sonamu.syncer.sync();\n  }\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 누르면 lock 제거 후 재시작 → 새 프로세스가 부트스트랩에서 풀-싱크. force sync CLI를 shell로 부르면 살아있는 서버의 watcher 폭풍이 :restart와 충돌해 상태 이상.\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  const require = createRequire(import.meta.url);\n  const { version } = require(\"../../package.json\");\n  console.log(`🌲 Sonamu v${version}\\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 require = createRequire(import.meta.url);\n  const { version } = require(\"../../package.json\");\n  console.log(`🌲 Sonamu v${version}\\n`);\n\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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"}