sonamu 0.7.53 → 0.8.0

package/dist/bin/cli.js

@@ -19,7 +19,37 @@ import { execWithLinePrefix, printBuildSummary, printTaskFailed, printTaskHeader
 import { exists } from "../utils/fs-utils.js";
 import { findApiRootPath, findAppRootPath } from "../utils/utils.js";
 import { API_ARTIFACTS, WEB_ARTIFACTS } from "./build-config.js";
+import { fixtureExploreCommand, fixtureFetchCommand, fixtureGenCommand } from "./fixture.js";
 let migrator;
+/**
+ * CLI 옵션을 파싱하는 헬퍼 함수
+ */ function parseCliOptions(argv = process.argv) {
+    const flags = new Set();
+    const options = {};
+    for(let i = 0; i < argv.length; i++){
+        const arg = argv[i];
+        if (!arg.startsWith("--")) continue;
+        // --option=value 형식
+        if (arg.includes("=")) {
+            const [key, value] = arg.slice(2).split("=");
+            options[key] = value;
+            continue;
+        }
+        // --option value 형식인지 확인
+        const nextArg = argv[i + 1];
+        if (nextArg && !nextArg.startsWith("--") && !nextArg.startsWith("-")) {
+            options[arg.slice(2)] = nextArg;
+            i++; // 다음 arg는 값이므로 스킵
+        } else {
+            // --flag 형식
+            flags.add(arg.slice(2));
+        }
+    }
+    return {
+        flags,
+        options
+    };
+}
 async function bootstrap() {
     const notToInit = [
         "dev",
@@ -33,23 +63,41 @@ async function bootstrap() {
     try {
         // tsicli는 정확한 명령어 매칭만 지원하므로, --로 시작하는 옵션과 그 값을 필터링합니다.
         // 옵션 파싱은 각 runner 함수에서 원본 process.argv를 사용하여 수행합니다.
+        // "--"(bare double dash)는 passthrough 구분자이므로, 그 뒤의 모든 인자도 제외합니다.
         const filteredArgv = [];
         let skipNext = false;
-        for (const arg of process.argv){
+        let afterDoubleDash = false;
+        for(let i = 0; i < process.argv.length; i++){
+            const arg = process.argv[i];
+            if (arg === "--") {
+                afterDoubleDash = true;
+                continue;
+            }
+            if (afterDoubleDash) continue;
             if (skipNext) {
                 skipNext = false;
                 continue;
             }
             if (arg.startsWith("--")) {
                 // --option=value 형식은 이 arg만 스킵
-                // --option value 형식은 다음 arg도 스킵
-                if (!arg.includes("=")) {
+                if (arg.includes("=")) {
+                    continue;
+                }
+                // --option value 형식인지 확인: 다음 arg가 --로 시작하지 않으면 값이 있는 것
+                const nextArg = process.argv[i + 1];
+                if (nextArg && !nextArg.startsWith("--") && !nextArg.startsWith("-")) {
                     skipNext = true;
                 }
                 continue;
             }
             filteredArgv.push(arg);
         }
+        // build/dev 명령어가 서브커맨드 없이 호출될 때 "all"을 기본값으로 추가합니다.
+        // 예: `sonamu build` → `sonamu build all`, `sonamu dev` → `sonamu dev all`
+        const cmd = filteredArgv[2];
+        if ((cmd === "build" || cmd === "dev") && filteredArgv.length === 3) {
+            filteredArgv.push("all");
+        }
         await tsicli(filteredArgv, {
             types: {
                 "#entityId": {
@@ -102,6 +150,18 @@ async function bootstrap() {
                     "fixture",
                     "sync"
                 ],
+                [
+                    "fixture",
+                    "gen"
+                ],
+                [
+                    "fixture",
+                    "fetch"
+                ],
+                [
+                    "fixture",
+                    "explore"
+                ],
                 [
                     "migrate",
                     "run"
@@ -145,14 +205,37 @@ async function bootstrap() {
                     "view_form",
                     "#entityId"
                 ],
+                [
+                    "cone",
+                    "gen",
+                    "#entityId"
+                ],
                 [
                     "sync"
                 ],
                 [
-                    "dev"
+                    "build",
+                    "all"
+                ],
+                [
+                    "build",
+                    "api"
+                ],
+                [
+                    "build",
+                    "web"
+                ],
+                [
+                    "dev",
+                    "all"
+                ],
+                [
+                    "dev",
+                    "api"
                 ],
                 [
-                    "build"
+                    "dev",
+                    "web"
                 ],
                 [
                     "start"
@@ -178,15 +261,23 @@ async function bootstrap() {
                 fixture_init,
                 fixture_import,
                 fixture_sync,
+                fixture_gen,
+                fixture_fetch,
+                fixture_explore,
                 stub_practice,
                 stub_entity,
                 scaffold_model,
                 scaffold_model_test,
                 // scaffold_view_list,
                 // scaffold_view_form,
+                cone_gen,
                 sync,
-                dev,
-                build,
+                build_all,
+                build_api,
+                build_web,
+                dev_all,
+                dev_api,
+                dev_web,
                 start,
                 skills_sync,
                 skills_create,
@@ -207,8 +298,8 @@ bootstrap().finally(async ()=>{
     await Sonamu.syncer.sync();
 }
 /**
- * pnpm dev 하면 실행되는 함수입니다.
- * 프로젝트에 대해 HMR 지원하는 개발 서버를 띄워줍니다.
+ * API 개발 서버를 실행하는 공통 로직입니다.
+ * dev_all과 dev_api에서 공유합니다.
  *
  * TypeScript를 바로 실행할 수 있도록 @sonamu-kit/ts-loader를,
  * HMR을 지원하기 위해 @sonamu-kit/hmr-hook을 import하며,
@@ -217,12 +308,9 @@ bootstrap().finally(async ()=>{
  * 이때 @sonamu-kit/ts-loader와 @sonamu-kit/hmr-hook는 sonamu가 자체적으로 가지고 있는 dependency입니다.
  * 또한 실행에 사용하는 @sonamu-kit/hmr-runner도 마찬가지로 sonamu가 자체적으로 가지고 있는 dependency입니다.
  * 따라서 사용자 프로젝트에서는 이 세 패키지를 직접 설치할 필요가 없습니다.
- *
- * Sonamu.init 없이 호출될 것을 상정하여 구현되었습니다.
- */ async function dev() {
+ */ function spawnApiDevServer(options) {
     const apiRoot = findApiRootPath();
     const entryPoint = "src/index.ts";
-    console.log(chalk.yellow.bold("🚀 Starting Sonamu dev server...\n"));
     // 이 sonamu 패키지가 dependencies로 가지고 있는 @sonamu-kit/hmr-runner의 bin/run.js를 사용합니다.
     // 이 경로(/bin/run.js)는 @sonamu-kit/hmr-runner의 package.json의 bin 필드에 명시되어 있는 그것과 같습니다.
     const hotRunnerBinPath = createRequire(import.meta.url).resolve("@sonamu-kit/hmr-runner/bin/run.js");
@@ -244,7 +332,8 @@ bootstrap().finally(async ()=>{
             ...process.env,
             NODE_ENV: "development",
             HOT: "yes",
-            API_ROOT_PATH: apiRoot
+            API_ROOT_PATH: apiRoot,
+            ...options?.extraEnv
         }
     });
     // 종료 처리
@@ -257,31 +346,82 @@ bootstrap().finally(async ()=>{
     process.on("SIGTERM", cleanup);
     serverProcess.on("exit", (code)=>{
         if (code !== 0) {
-            console.error(chalk.red(`❌ Server exited with code ${code}`));
+            console.error(chalk.red(`Server exited with code ${code}`));
             process.exit(code || 1);
         }
     });
 }
 /**
- * pnpm build 하면 실행되는 함수입니다.
- * 프로젝트를 빌드합니다.
+ * pnpm dev / pnpm dev all 하면 실행되는 함수입니다.
+ * 프로젝트에 대해 HMR 지원하는 개발 서버를 띄워줍니다.
  *
- * 빌드에 필요한 .swcrc는 프로젝트 루트에서 찾고, 없으면 sonamu가 관리하는 .swcrc.project-default를 사용합니다.
+ * Sonamu.init 없이 호출될 것을 상정하여 구현되었습니다.
+ */ function dev_all() {
+    console.log(chalk.yellow.bold("Starting Sonamu dev server...\n"));
+    spawnApiDevServer();
+}
+/**
+ * pnpm dev api 하면 실행되는 함수입니다.
+ * API 전용 개발 서버를 띄웁니다.
+ * dev_all과 거의 동일하되, 통합 웹 서버를 비활성화합니다.
  *
- * 실제 빌드 타겟(아티팩트)과 동작은 build-config.ts에 정의되어 있습니다.
- * 이 함수는 build-config.ts에 정의된 동작들을 실행해주는 역할만 합니다.
+ * Sonamu.init 없이 호출될 것을 상정하여 구현되었습니다.
+ */ function dev_api() {
+    console.log(chalk.yellow.bold("Starting Sonamu API-only dev server...\n"));
+    spawnApiDevServer({
+        extraEnv: {
+            SONAMU_DISABLE_INTEGRATED_WEB: "yes"
+        }
+    });
+}
+/**
+ * pnpm dev web 하면 실행되는 함수입니다.
+ * Vite 개발 서버를 단독으로 실행합니다.
+ * -- 뒤의 인자는 Vite에 그대로 전달됩니다.
  *
  * Sonamu.init 없이 호출될 것을 상정하여 구현되었습니다.
- */ async function build() {
+ */ async function dev_web() {
     const appRoot = findAppRootPath();
-    // .swcrc 파일을 지정합니다.
+    const webPath = path.join(appRoot, "web");
+    if (!await exists(webPath)) {
+        console.error(`web 디렉토리를 찾을 수 없습니다: ${webPath}`);
+        process.exit(1);
+    }
+    // -- 뒤의 인자 추출
+    const doubleDashIndex = process.argv.indexOf("--");
+    const passthroughArgs = doubleDashIndex !== -1 ? process.argv.slice(doubleDashIndex + 1) : [];
+    const viteArgs = [
+        "exec",
+        "vite",
+        ...passthroughArgs
+    ];
+    console.log(chalk.yellow.bold("Starting Vite dev server...\n"));
+    const viteProcess = spawn("pnpm", viteArgs, {
+        cwd: webPath,
+        stdio: "inherit"
+    });
+    viteProcess.on("exit", (code)=>{
+        process.exit(code ?? 0);
+    });
+    // SIGINT/SIGTERM 시 Vite 프로세스를 gracefully 종료합니다.
+    for (const signal of [
+        "SIGINT",
+        "SIGTERM"
+    ]){
+        process.on(signal, ()=>{
+            viteProcess.kill(signal);
+        });
+    }
+}
+/**
+ * SWC 설정 파일 경로를 결정합니다. API 빌드(SWC)에서만 사용됩니다.
+ * 프로젝트 루트에 .swcrc가 있으면 그것을, 없으면 sonamu 기본 설정을 사용합니다.
+ */ async function resolveSwcConfigPath() {
     let swcFilePath = ".swcrc";
     try {
         if (await exists(swcFilePath)) {
-            // 사용자 프로젝트에 .swcrc가 있으면 우선으로 사용합니다.
             console.log(chalk.dim("Using .swcrc from project root..."));
         } else {
-            // 아니라면 sonamu가 관리하는 .swcrc.project-default를 가져다 씁니다.
             console.log(chalk.dim("Using default .swcrc from sonamu package..."));
             swcFilePath = path.join(import.meta.dirname, "..", "..", ".swcrc.project-default");
         }
@@ -289,7 +429,25 @@ bootstrap().finally(async ()=>{
         console.error(chalk.red("Setting up swc config file failed."), error);
         process.exit(1);
     }
-    // API 프로젝트를 빌드합니다.
+    return swcFilePath;
+}
+/**
+ * sonamu build / sonamu build all 하면 실행되는 함수입니다.
+ * build_api + build_web의 합성입니다. Web 디렉토리가 없으면 Web 빌드를 스킵합니다.
+ */ async function build_all() {
+    await build_api();
+    await build_web({
+        skipIfMissing: true
+    });
+}
+/**
+ * pnpm build api 하면 실행되는 함수입니다.
+ * API 프로젝트만 빌드합니다.
+ *
+ * Sonamu.init 없이 호출될 것을 상정하여 구현되었습니다.
+ */ async function build_api() {
+    const appRoot = findAppRootPath();
+    const swcFilePath = await resolveSwcConfigPath();
     const apiStartedAt = Date.now();
     try {
         for (const artifact of API_ARTIFACTS){
@@ -303,11 +461,28 @@ bootstrap().finally(async ()=>{
             });
         }
         printBuildSummary("API", true, Date.now() - apiStartedAt);
-    } catch  {
+    } catch (e) {
         printBuildSummary("API", false, Date.now() - apiStartedAt);
+        console.error(e);
+        process.exit(1);
+    }
+}
+/**
+ * pnpm build web 하면 실행되는 함수입니다.
+ * Web 프로젝트만 빌드합니다.
+ *
+ * Sonamu.init 없이 호출될 것을 상정하여 구현되었습니다.
+ */ async function build_web({ skipIfMissing = false } = {}) {
+    const appRoot = findAppRootPath();
+    const webPath = path.join(appRoot, "web");
+    if (!await exists(webPath)) {
+        if (skipIfMissing) {
+            console.log(chalk.gray("Web 디렉토리가 없으므로 Web 빌드를 건너뜁니다."));
+            return;
+        }
+        console.error(`web 디렉토리를 찾을 수 없습니다: ${webPath}`);
         process.exit(1);
     }
-    // Web 프로젝트를 빌드합니다.
     const webStartedAt = Date.now();
     try {
         for (const artifact of WEB_ARTIFACTS){
@@ -319,8 +494,9 @@ bootstrap().finally(async ()=>{
             });
         }
         printBuildSummary("Web", true, Date.now() - webStartedAt);
-    } catch  {
+    } catch (e) {
         printBuildSummary("Web", false, Date.now() - webStartedAt);
+        console.error(e);
         process.exit(1);
     }
 }
@@ -351,9 +527,11 @@ bootstrap().finally(async ()=>{
                 cwd: options.cwd
             });
             printTaskSuccess(step.name, isLast);
-        } catch  {
+        } catch (e) {
             printTaskFailed(step.name, isLast);
-            throw new Error(`${step.name} failed`);
+            throw new Error(`${step.name} failed`, {
+                cause: e
+            });
         }
     }
 }
@@ -370,7 +548,7 @@ bootstrap().finally(async ()=>{
     const entryPoint = "dist/index.js";
     if (!await exists(entryPoint)) {
         console.log(chalk.red(`${entryPoint} not found. Please build your project first.`));
-        console.log(chalk.blue("Run: yarn sonamu build"));
+        console.log(chalk.blue("Run: pnpm sonamu build"));
         return;
     }
     const { spawn } = await import("child_process");
@@ -492,6 +670,64 @@ async function fixture_sync() {
     await setupFixtureManager();
     await FixtureManager.sync();
 }
+/**
+ * fixture gen 명령어
+ * 옵션을 process.argv에서 파싱
+ */ async function fixture_gen() {
+    const options = parseOptions(process.argv);
+    await fixtureGenCommand(options);
+}
+/**
+ * fixture fetch 명령어
+ * 옵션을 process.argv에서 파싱
+ */ async function fixture_fetch() {
+    const options = parseOptions(process.argv);
+    await fixtureFetchCommand(options);
+}
+/**
+ * fixture explore 명령어
+ * 옵션을 process.argv에서 파싱
+ */ async function fixture_explore() {
+    const options = parseOptions(process.argv);
+    await fixtureExploreCommand(options);
+}
+/**
+ * 간단한 옵션 파서
+ */ function parseOptions(argv) {
+    const options = {
+        _: []
+    };
+    for(let i = 0; i < argv.length; i++){
+        const arg = argv[i];
+        if (arg.startsWith("--")) {
+            const key = arg.slice(2);
+            if (key.includes("=")) {
+                const [k, v] = key.split("=");
+                options[k] = v;
+            } else {
+                const next = argv[i + 1];
+                if (next && !next.startsWith("--")) {
+                    options[key] = next;
+                    i++;
+                } else {
+                    options[key] = true;
+                }
+            }
+        } else if (arg.startsWith("-")) {
+            const key = arg.slice(1);
+            const next = argv[i + 1];
+            if (next && !next.startsWith("-")) {
+                options[key] = next;
+                i++;
+            } else {
+                options[key] = true;
+            }
+        } else {
+            options._.push(arg);
+        }
+    }
+    return options;
+}
 async function stub_practice(name) {
     const practiceDir = path.join(Sonamu.apiRootPath, "src", "practices");
     const fileNames = await readdir(practiceDir);
@@ -538,6 +774,138 @@ async function stub_entity(entityId) {
         entityId,
         title: entityId
     });
+    const { flags } = parseCliOptions();
+    const useAI = flags.has("ai");
+    const noCones = flags.has("no-cones");
+    // --no-cones: cone 생성 스킵
+    if (noCones) {
+        console.log(`✓ Entity '${entityId}' created without cones`);
+        return;
+    }
+    const { EntityManager } = await import("../entity/entity-manager.js");
+    const entity = EntityManager.get(entityId);
+    if (!entity) {
+        console.error(`Entity not found: ${entityId}`);
+        return;
+    }
+    // --ai: LLM으로 cone 생성
+    if (useAI) {
+        console.log(`✓ Entity '${entityId}' created`);
+        console.log(`🌟 Generating AI-powered cones...`);
+        try {
+            const configLocale = Sonamu.config.i18n?.defaultLocale;
+            const locale = configLocale === "ko" || configLocale === "en" || configLocale === "ja" ? configLocale : "ko";
+            const result = await entity.generateCones({
+                preserveExisting: false,
+                onlyEmpty: false,
+                locale
+            });
+            console.log(`✅ Done (${result.tokensUsed} tokens)`);
+        } catch (error) {
+            if (error instanceof Error && error.message.includes("ANTHROPIC_API_KEY")) {
+                console.error(`\n❌ ${error.message}`);
+                console.error(`\n💡 Remove --ai flag to use template cones instead`);
+            } else {
+                throw error;
+            }
+        }
+        return;
+    }
+    // 기본: 템플릿 cone 자동 생성
+    // LLM 없이 faker-mappings.ts를 활용하여 기본 cone 메타데이터를 생성합니다.
+    // 이를 통해 ANTHROPIC_API_KEY가 없어도 Sonamu를 사용할 수 있으며,
+    // 생성된 템플릿 cone은 나중에 'cone gen' 명령어로 AI를 통해 업그레이드할 수 있습니다.
+    console.log(`🌟 Generating template cones...`);
+    await entity.generateTemplateCones();
+    console.log(`✓ Entity '${entityId}' created with template cones`);
+    console.log(`💡 Tip: Run 'pnpm sonamu cone gen ${entityId}' to improve with AI`);
+}
+/**
+ * AI를 사용하여 entity의 cone 메타데이터를 생성하거나 업그레이드합니다.
+ *
+ * 옵션:
+ * - --regenerate: 전체 재생성 (기존 cone 덮어쓰기)
+ * - --locale <ko|en|ja>: 생성 언어 지정
+ * - 기본: onlyEmpty 모드 (기존 fixtureHint 보존)
+ *
+ * ANTHROPIC_API_KEY 필요 (sonamu.secret.ts 또는 환경변수)
+ */ async function cone_gen(entityId) {
+    const { EntityManager } = await import("../entity/entity-manager.js");
+    const { flags, options } = parseCliOptions();
+    // --all 옵션: 모든 entity cone 생성
+    if (flags.has("all") || entityId === "all") {
+        const allEntities = EntityManager.getAllEntities();
+        console.log(`🌟 Generating AI-powered cones for ${allEntities.length} entities...\n`);
+        let totalTokens = 0;
+        const errors = [];
+        for (const entity of allEntities){
+            try {
+                console.log(`Processing ${entity.id}...`);
+                const configLocale = options.locale || Sonamu.config.i18n?.defaultLocale;
+                const locale = configLocale === "ko" || configLocale === "en" || configLocale === "ja" ? configLocale : "ko";
+                const result = await entity.generateCones({
+                    preserveExisting: !flags.has("regenerate"),
+                    onlyEmpty: !flags.has("regenerate"),
+                    locale
+                });
+                totalTokens += result.tokensUsed;
+                console.log(`  ✓ ${entity.id} (${result.tokensUsed} tokens)\n`);
+            } catch (error) {
+                const message = error instanceof Error ? error.message : "Unknown error";
+                errors.push(`${entity.id}: ${message}`);
+                console.error(`  ✗ ${entity.id}: ${message}\n`);
+            }
+        }
+        console.log(`\n✅ Done! Total: ${totalTokens} tokens used`);
+        const estimatedCost = totalTokens * 9 / 1_000_000;
+        console.log(`💰 Estimated cost: ~$${estimatedCost.toFixed(4)}`);
+        if (errors.length > 0) {
+            console.error(`\n❌ Failed entities (${errors.length}):`);
+            for (const err of errors){
+                console.error(`  - ${err}`);
+            }
+        }
+        return;
+    }
+    // 단일 entity cone 생성
+    const entity = EntityManager.get(entityId);
+    if (!entity) {
+        console.error(`Entity not found: ${entityId}`);
+        return;
+    }
+    const mode = flags.has("regenerate") ? "regenerating" : "generating";
+    console.log(`🌟 ${mode === "regenerating" ? "Regenerating" : "Generating"} AI-powered cones for ${entityId}...`);
+    try {
+        const configLocale = options.locale || Sonamu.config.i18n?.defaultLocale;
+        const locale = configLocale === "ko" || configLocale === "en" || configLocale === "ja" ? configLocale : "ko";
+        const result = await entity.generateCones({
+            preserveExisting: !flags.has("regenerate"),
+            onlyEmpty: !flags.has("regenerate"),
+            locale
+        });
+        console.log(`✅ Done! (${result.tokensUsed} tokens used)`);
+        // 토큰 비용 계산 (대략적인 추정)
+        // Claude Sonnet 4.5: input $3/M tokens, output $15/M tokens
+        // 간단하게 평균 $9/M tokens로 계산
+        const estimatedCost = result.tokensUsed * 9 / 1_000_000;
+        console.log(`💰 Estimated cost: ~$${estimatedCost.toFixed(4)}`);
+    } catch (error) {
+        if (error instanceof Error) {
+            if (error.message.includes("ANTHROPIC_API_KEY")) {
+                console.error(`\n❌ ${error.message}`);
+                console.error(`\n💡 To use AI-powered cone generation:`);
+                console.error(`   1. Get an API key from https://console.anthropic.com/`);
+                console.error(`   2. Add it to sonamu.secret.ts or set ANTHROPIC_API_KEY environment variable`);
+            } else if (error.message.includes("Rate limit")) {
+                console.error(`\n❌ ${error.message}`);
+                console.error(`\n💡 Please wait a moment and try again.`);
+            } else {
+                console.error(`\n❌ Failed to generate cones: ${error.message}`);
+            }
+        } else {
+            console.error(`\n❌ Failed to generate cones: Unknown error`);
+        }
+    }
 }
 async function scaffold_model(entityId) {
     await Sonamu.syncer.generateTemplate("model", {
@@ -596,6 +964,23 @@ async function scaffold_model_test(entityId) {
             throw copyError;
         }
     }
+    // project 디렉토리 초기화 (없으면 생성, 있으면 유지)
+    const sourceProjectDir = path.join(sourceBase, "project");
+    const targetProjectDir = path.join(claudeDir, "skills", "project");
+    if (await exists(sourceProjectDir)) {
+        if (!await exists(targetProjectDir)) {
+            try {
+                await cp(sourceProjectDir, targetProjectDir, {
+                    recursive: true
+                });
+                console.log(chalk.green(`✓ Project templates initialized`));
+            } catch (error) {
+                console.error(chalk.red(`✗ Failed to initialize project templates: ${error instanceof Error ? error.message : String(error)}`));
+            }
+        } else {
+            console.log(chalk.dim(`⏭ Project templates already exist (preserved)`));
+        }
+    }
     // CLAUDE.md 복사/업데이트
     if (await exists(sourceClaudeMd)) {
         try {
@@ -790,4 +1175,4 @@ status: draft
     return findAppRootPath();
 }
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/bin/cli.ts"],"sourcesContent":["import chalk from \"chalk\";\nimport dotenv from \"dotenv\";\n\ndotenv.config();\n\nimport assert from \"assert\";\nimport { execSync, spawn } from \"child_process\";\nimport { cp, mkdir, readdir, readFile, rm, symlink, writeFile } from \"fs/promises\";\nimport knex, { type Knex } from \"knex\";\nimport { createRequire } from \"module\";\nimport path from \"path\";\nimport process from \"process\";\nimport { tsicli } from \"tsicli\";\nimport { Sonamu } from \"../api\";\nimport { generateBetterAuthEntities } from \"../auth/auth-generator\";\nimport {\n  type BetterAuthPluginId,\n  isValidPluginId,\n  SUPPORTED_PLUGIN_IDS,\n} from \"../auth/plugins/entity-definitions\";\nimport type { SonamuDBConfig } from \"../database/db\";\nimport { EntityManager } from \"../entity/entity-manager\";\nimport { Migrator } from \"../migration/migrator\";\nimport { FixtureManager } from \"../testing/fixture-manager\";\nimport {\n  execWithLinePrefix,\n  printBuildSummary,\n  printTaskFailed,\n  printTaskHeader,\n  printTaskStart,\n  printTaskSuccess,\n} from \"../utils/console-util\";\nimport { exists } from \"../utils/fs-utils\";\nimport { findApiRootPath, findAppRootPath } from \"../utils/utils\";\nimport { API_ARTIFACTS, type BuildArtifact, WEB_ARTIFACTS } from \"./build-config\";\n\nlet migrator: Migrator;\n\nasync function bootstrap() {\n  const notToInit = [\"dev\", \"build\", \"start\", \"skills\"].includes(process.argv[2] ?? \"\");\n  if (!notToInit) {\n    await Sonamu.init(false, false);\n  }\n\n  try {\n    // tsicli는 정확한 명령어 매칭만 지원하므로, --로 시작하는 옵션과 그 값을 필터링합니다.\n    // 옵션 파싱은 각 runner 함수에서 원본 process.argv를 사용하여 수행합니다.\n    const filteredArgv: string[] = [];\n    let skipNext = false;\n    for (const arg of process.argv) {\n      if (skipNext) {\n        skipNext = false;\n        continue;\n      }\n      if (arg.startsWith(\"--\")) {\n        // --option=value 형식은 이 arg만 스킵\n        // --option value 형식은 다음 arg도 스킵\n        if (!arg.includes(\"=\")) {\n          skipNext = true;\n        }\n        continue;\n      }\n      filteredArgv.push(arg);\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        [\"migrate\", \"run\"],\n        [\"migrate\", \"apply\", \"#targets\"],\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        [\"sync\"],\n        [\"dev\"],\n        [\"build\"],\n        [\"start\"],\n        [\"skills\", \"sync\"],\n        [\"skills\", \"create\", \"#name\"],\n        [\"auth\", \"generate\"],\n      ],\n      runners: {\n        migrate_status,\n        migrate_run,\n        migrate_apply,\n        fixture_init,\n        fixture_import,\n        fixture_sync,\n        stub_practice,\n        stub_entity,\n        scaffold_model,\n        scaffold_model_test,\n        // scaffold_view_list,\n        // scaffold_view_form,\n        sync,\n        dev,\n        build,\n        start,\n        skills_sync,\n        skills_create,\n        auth_generate,\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 * pnpm dev 하면 실행되는 함수입니다.\n * 프로젝트에 대해 HMR 지원하는 개발 서버를 띄워줍니다.\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 *\n * Sonamu.init 없이 호출될 것을 상정하여 구현되었습니다.\n */\nasync function dev() {\n  const apiRoot = findApiRootPath();\n  const entryPoint = \"src/index.ts\";\n\n  console.log(chalk.yellow.bold(\"🚀 Starting Sonamu dev server...\\n\"));\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=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      },\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 build 하면 실행되는 함수입니다.\n * 프로젝트를 빌드합니다.\n *\n * 빌드에 필요한 .swcrc는 프로젝트 루트에서 찾고, 없으면 sonamu가 관리하는 .swcrc.project-default를 사용합니다.\n *\n * 실제 빌드 타겟(아티팩트)과 동작은 build-config.ts에 정의되어 있습니다.\n * 이 함수는 build-config.ts에 정의된 동작들을 실행해주는 역할만 합니다.\n *\n * Sonamu.init 없이 호출될 것을 상정하여 구현되었습니다.\n */\nasync function build() {\n  const appRoot = findAppRootPath();\n\n  // .swcrc 파일을 지정합니다.\n  let swcFilePath = \".swcrc\";\n  try {\n    if (await exists(swcFilePath)) {\n      // 사용자 프로젝트에 .swcrc가 있으면 우선으로 사용합니다.\n      console.log(chalk.dim(\"Using .swcrc from project root...\"));\n    } else {\n      // 아니라면 sonamu가 관리하는 .swcrc.project-default를 가져다 씁니다.\n      console.log(chalk.dim(\"Using default .swcrc from sonamu package...\"));\n      swcFilePath = path.join(import.meta.dirname, \"..\", \"..\", \".swcrc.project-default\");\n    }\n  } catch (error) {\n    console.error(chalk.red(\"Setting up swc config file failed.\"), error);\n    process.exit(1);\n  }\n\n  // API 프로젝트를 빌드합니다.\n  const apiStartedAt = Date.now();\n  try {\n    for (const artifact of API_ARTIFACTS) {\n      const cwd = path.join(appRoot, artifact.projectPath);\n      printTaskHeader(artifact.name, artifact.description, cwd);\n\n      await runBuildSteps(artifact, { cwd, buildCommandArgs: { configFilePath: swcFilePath } });\n    }\n    printBuildSummary(\"API\", true, Date.now() - apiStartedAt);\n  } catch {\n    printBuildSummary(\"API\", false, Date.now() - apiStartedAt);\n    process.exit(1);\n  }\n\n  // Web 프로젝트를 빌드합니다.\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 {\n    printBuildSummary(\"Web\", false, Date.now() - webStartedAt);\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 {\n      printTaskFailed(step.name, isLast);\n      throw new Error(`${step.name} failed`);\n    }\n  }\n}\n\n/**\n * pnpm start 하면 실행되는 함수입니다.\n * 빌드된 프로젝트를 실행합니다.\n *\n * 빌드된 결과물(dist 디렉토리의 index.js 엔트리포인트)이 없다면 실행을 중단합니다.\n * 소스맵 지원과 dotenv 지원을 포함하여 실행합니다.\n *\n * Sonamu.init 없이 호출될 것을 상정하여 구현되었습니다.\n */\nasync function start() {\n  const apiRoot = findApiRootPath();\n  const entryPoint = \"dist/index.js\";\n\n  if (!(await exists(entryPoint))) {\n    console.log(chalk.red(`${entryPoint} not found. Please build your project first.`));\n    console.log(chalk.blue(\"Run: yarn 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_status() {\n  await setupMigrator();\n\n  const status = await migrator.getStatus();\n  // status;\n  console.log(status);\n}\n\nasync function fixture_init() {\n  const srcConfig = Sonamu.dbConfig.development_master;\n  const targets = [\n    {\n      label: \"(REMOTE) Fixture DB\",\n      config: Sonamu.dbConfig.fixture,\n    },\n    {\n      label: \"(LOCAL) Testing DB\",\n      config: Sonamu.dbConfig.test,\n      toSkip: (() => {\n        const remoteConn = Sonamu.dbConfig.fixture.connection as Knex.ConnectionConfig;\n        const localConn = Sonamu.dbConfig.test.connection as Knex.ConnectionConfig;\n        return remoteConn.host === localConn.host && remoteConn.database === localConn.database;\n      })(),\n    },\n  ] as {\n    label: string;\n    config: Knex.Config;\n    toSkip?: boolean;\n  }[];\n\n  // 1. 기준DB 스키마를 덤프\n  console.log(\"DUMP...\");\n  const dumpFilename = `/tmp/sonamu-fixture-init-${Date.now()}.sql`;\n  const srcConn = srcConfig.connection as Knex.ConnectionConfig;\n  const migrationsDump = `/tmp/sonamu-fixture-init-migrations-${Date.now()}.sql`;\n  execSync(\n    `mysqldump -h${srcConn.host} -u${srcConn.user} -p${srcConn.password} --single-transaction -d --no-create-db --triggers ${srcConn.database} > ${dumpFilename}`,\n  );\n  const _db = knex(srcConfig);\n  const [[migrations]] = await _db.raw(\n    \"SELECT COUNT(*) as count FROM information_schema.tables WHERE table_schema = ? AND table_name = 'knex_migrations'\",\n    [srcConn.database],\n  );\n  if (migrations.count > 0) {\n    execSync(\n      `mysqldump -h${srcConn.host} -u${srcConn.user} -p${srcConn.password} --single-transaction --no-create-db --triggers ${srcConn.database} knex_migrations knex_migrations_lock > ${migrationsDump}`,\n    );\n  }\n\n  // 2. 대상DB 각각에 대하여 존재여부 확인 후 붓기\n  for await (const { label, config, toSkip } of targets) {\n    const conn = config.connection as Knex.ConnectionConfig;\n\n    if (toSkip === true) {\n      console.log(chalk.red(`${label}: Skipped!`));\n      continue;\n    }\n\n    const db = knex({\n      ...config,\n      connection: {\n        ...((config.connection ?? {}) as Knex.ConnectionConfig),\n        database: undefined,\n      },\n    });\n    const [[row]] = await db.raw(`SHOW DATABASES LIKE \"${conn.database}\"`);\n    if (row) {\n      console.log(chalk.yellow(`${label}: Database \"${conn.database}\" Already exists`));\n      await db.destroy();\n      continue;\n    }\n\n    console.log(`SYNC to ${label}...`);\n    const mysqlCmd = `mysql -h${conn.host} -u${conn.user} -p${conn.password}`;\n    execSync(`${mysqlCmd} -e 'DROP DATABASE IF EXISTS \\`${conn.database}\\`'`);\n    execSync(`${mysqlCmd} -e 'CREATE DATABASE \\`${conn.database}\\`'`);\n    execSync(`${mysqlCmd} ${conn.database} < ${dumpFilename}`);\n    if (await exists(migrationsDump)) {\n      execSync(`${mysqlCmd} ${conn.database} < ${migrationsDump}`);\n    }\n\n    await db.destroy();\n  }\n\n  await _db.destroy();\n}\n\nasync function fixture_import(entityId: string, recordIds: number[]) {\n  await setupFixtureManager();\n\n  await FixtureManager.importFixture(entityId, recordIds);\n  await FixtureManager.sync();\n}\n\nasync function fixture_sync() {\n  await setupFixtureManager();\n\n  await FixtureManager.sync();\n}\n\nasync function stub_practice(name: string) {\n  const practiceDir = path.join(Sonamu.apiRootPath, \"src\", \"practices\");\n  const fileNames = await readdir(practiceDir);\n\n  const maxSeqNo = await (async () => {\n    if (!(await exists(practiceDir))) {\n      await mkdir(practiceDir, { recursive: true });\n    }\n\n    const filteredSeqs = fileNames\n      .filter((fileName) => fileName.startsWith(\"p\") && fileName.endsWith(\".ts\"))\n      .map((fileName) => {\n        const [, seqNo] = fileName.match(/^p([0-9]+)-/) ?? [\"0\", \"0\"];\n        return parseInt(seqNo);\n      })\n      .sort((a, b) => b - a);\n\n    if (filteredSeqs.length > 0) {\n      return filteredSeqs[0];\n    }\n\n    return 0;\n  })();\n\n  const currentSeqNo = maxSeqNo + 1;\n  const fileName = `p${currentSeqNo}-${name}.ts`;\n  const dstPath = path.join(practiceDir, fileName);\n\n  const code = [\n    `import { Sonamu } from \"sonamu\";`,\n    \"\",\n    `console.clear();`,\n    `console.log(\"${fileName}\");`,\n    \"\",\n    `Sonamu.runScript(async () => {`,\n    ` // TODO`,\n    `});`,\n    \"\",\n  ].join(\"\\n\");\n  await writeFile(dstPath, code);\n\n  execSync(`code ${dstPath}`);\n\n  const runCode = `yarn node -r dotenv/config --enable-source-maps dist/practices/${fileName.replace(\n    \".ts\",\n    \".js\",\n  )}`;\n  console.log(`${chalk.blue(runCode)} copied to clipboard.`);\n  execSync(`echo \"${runCode}\" | pbcopy`);\n}\n\nasync function stub_entity(entityId: string) {\n  await Sonamu.syncer.createEntity({ entityId, title: entityId });\n}\n\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를 로컬 프로젝트로 동기화합니다.\n */\nasync function skills_sync() {\n  const workspaceRoot = await findWorkspaceRoot();\n  const claudeDir = path.join(workspaceRoot, \".claude\");\n  const targetSkillsDir = path.join(claudeDir, \"skills\", \"sonamu\");\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  // 기존 디렉토리/symlink 삭제 후 symlink 생성\n  // exists()는 broken symlink를 감지하지 못하므로 rm을 무조건 시도합니다\n  try {\n    await rm(targetSkillsDir, { recursive: true, force: true });\n  } catch {\n    // 파일이 없으면 무시\n  }\n\n  // 대상 디렉토리 생성\n  await mkdir(path.dirname(targetSkillsDir), { recursive: true });\n\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    try {\n      await cp(sourceSkillsDir, targetSkillsDir, { 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  // CLAUDE.md 복사/업데이트\n  if (await exists(sourceClaudeMd)) {\n    try {\n      const targetClaudeMd = path.join(claudeDir, \"CLAUDE.md\");\n      const sourceContent = await readFile(sourceClaudeMd, \"utf-8\");\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          // marker 영역만 교체합니다.\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        }\n      } else {\n        await writeFile(targetClaudeMd, sourceContent);\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\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 * 워크스페이스 루트를 찾습니다.\n * 우선순위: pnpm-workspace.yaml > CLAUDE.md > 루트 package.json (workspaces 필드)\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. CLAUDE.md 파일이 있는지 확인. 있으면 프로젝트 루트로 간주함.\n    if (await exists(path.join(dir, \"CLAUDE.md\"))) {\n      return dir;\n    }\n\n    // 3. package.json에 workspaces 필드가 있으면 루트.\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    dir = path.dirname(dir);\n  }\n\n  // 찾지 못하면 api 폴더의 부모 사용\n  return findAppRootPath();\n}\n"],"names":["chalk","dotenv","config","assert","execSync","spawn","cp","mkdir","readdir","readFile","rm","symlink","writeFile","knex","createRequire","path","process","tsicli","Sonamu","generateBetterAuthEntities","isValidPluginId","SUPPORTED_PLUGIN_IDS","EntityManager","Migrator","FixtureManager","execWithLinePrefix","printBuildSummary","printTaskFailed","printTaskHeader","printTaskStart","printTaskSuccess","exists","findApiRootPath","findAppRootPath","API_ARTIFACTS","WEB_ARTIFACTS","migrator","bootstrap","notToInit","includes","argv","init","filteredArgv","skipNext","arg","startsWith","push","types","type","name","message","choices","getAllParentIds","map","entityId","title","value","args","runners","migrate_status","migrate_run","migrate_apply","fixture_init","fixture_import","fixture_sync","stub_practice","stub_entity","scaffold_model","scaffold_model_test","sync","dev","build","start","skills_sync","skills_create","auth_generate","destroy","finally","syncer","apiRoot","entryPoint","console","log","yellow","bold","hotRunnerBinPath","url","resolve","serverProcess","execPath","join","cwd","stdio","env","NODE_ENV","HOT","API_ROOT_PATH","cleanup","kill","exit","on","code","error","red","appRoot","swcFilePath","dim","dirname","apiStartedAt","Date","now","artifact","projectPath","description","runBuildSteps","buildCommandArgs","configFilePath","webStartedAt","options","steps","cmd","preBuildCommand","buildCommand","postBuildCommand","filter","step","i","length","isLast","Error","blue","setupMigrator","setupFixtureManager","targets","runAction","localHosts","Object","keys","dbConfig","target","targetConfig","host","connection","toLowerCase","status","getStatus","srcConfig","development_master","label","fixture","test","toSkip","remoteConn","localConn","database","dumpFilename","srcConn","migrationsDump","user","password","_db","migrations","raw","count","conn","db","undefined","row","mysqlCmd","recordIds","importFixture","practiceDir","apiRootPath","fileNames","maxSeqNo","recursive","filteredSeqs","fileName","endsWith","seqNo","match","parseInt","sort","a","b","currentSeqNo","dstPath","runCode","replace","createEntity","generateTemplate","workspaceRoot","findWorkspaceRoot","claudeDir","targetSkillsDir","sourceBase","sourceSkillsDir","sourceClaudeMd","force","green","String","copyError","targetClaudeMd","sourceContent","targetContent","startMarker","endMarker","startIdx","indexOf","endIdx","before","substring","after","newContent","localDir","trim","sanitized","MAX_LENGTH","RESERVED_NAMES","toUpperCase","filePath","template","toISOString","split","pluginsArg","find","plugins","pluginValue","pluginIds","p","id","dir","packagePath","packageJson","JSON","parse","workspaces"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/bin/cli.ts"],"sourcesContent":["import chalk from \"chalk\";\nimport dotenv from \"dotenv\";\n\ndotenv.config();\n\nimport assert from \"assert\";\nimport { execSync, spawn } from \"child_process\";\nimport { cp, mkdir, readdir, readFile, rm, symlink, writeFile } from \"fs/promises\";\nimport knex, { type Knex } from \"knex\";\nimport { createRequire } from \"module\";\nimport path from \"path\";\nimport process from \"process\";\nimport { tsicli } from \"tsicli\";\nimport { Sonamu } from \"../api\";\nimport { generateBetterAuthEntities } from \"../auth/auth-generator\";\nimport {\n  type BetterAuthPluginId,\n  isValidPluginId,\n  SUPPORTED_PLUGIN_IDS,\n} from \"../auth/plugins/entity-definitions\";\nimport type { SonamuDBConfig } from \"../database/db\";\nimport { EntityManager } from \"../entity/entity-manager\";\nimport { Migrator } from \"../migration/migrator\";\nimport { FixtureManager } from \"../testing/fixture-manager\";\nimport {\n  execWithLinePrefix,\n  printBuildSummary,\n  printTaskFailed,\n  printTaskHeader,\n  printTaskStart,\n  printTaskSuccess,\n} from \"../utils/console-util\";\nimport { exists } from \"../utils/fs-utils\";\nimport { findApiRootPath, findAppRootPath } from \"../utils/utils\";\nimport { API_ARTIFACTS, type BuildArtifact, WEB_ARTIFACTS } from \"./build-config\";\nimport { fixtureExploreCommand, fixtureFetchCommand, fixtureGenCommand } from \"./fixture\";\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\"].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    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\", \"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        [\"auth\", \"generate\"],\n      ],\n      runners: {\n        migrate_status,\n        migrate_run,\n        migrate_apply,\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        auth_generate,\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=f:shell(rm ${path.join(apiRoot, \"sonamu.lock\")}):restart:Force restart`, // f 누르면 sonamu.lock 파일을 지우고 서버 재시작하게 해줘요.\n\n      \"--on-key=enter:shell(echo hi):Key binding test\", // enter를 key로 쓸 수 있음을 보이기 위한 테스트입니다.\n      \"--on-key=ctrl+f ctrl+f:shell(git pull && pnpm install && pnpm --filter sonamu build && echo 'Sonamu is now up-to-date!'):restart:Pull & install & build & restart\", // modifier와의 조합, 그리고 두 개의 chord를 사용할 수 있음을 보이기 위한 테스트입니다.\n      entryPoint, // 마지막으로 실제 실행할 스크립트의 경로를 넘겨줍니다.\n    ],\n    {\n      cwd: apiRoot,\n      stdio: \"inherit\",\n      env: {\n        ...process.env,\n        NODE_ENV: \"development\",\n        HOT: \"yes\", // 얘가 있어야 HMR이 활성화됩니다.\n        API_ROOT_PATH: apiRoot, // 이 경로가 hmr-hook의 루트 디렉토리가 됩니다.\n        ...options?.extraEnv,\n      },\n    },\n  );\n\n  // 종료 처리\n  const cleanup = () => {\n    console.log(chalk.yellow(\"\\n\\n👋 Shutting down...\"));\n    serverProcess.kill(\"SIGTERM\");\n    process.exit(0);\n  };\n\n  process.on(\"SIGINT\", cleanup);\n  process.on(\"SIGTERM\", cleanup);\n\n  serverProcess.on(\"exit\", (code) => {\n    if (code !== 0) {\n      console.error(chalk.red(`Server exited with code ${code}`));\n      process.exit(code || 1);\n    }\n  });\n}\n\n/**\n * pnpm dev / pnpm dev all 하면 실행되는 함수입니다.\n * 프로젝트에 대해 HMR 지원하는 개발 서버를 띄워줍니다.\n *\n * Sonamu.init 없이 호출될 것을 상정하여 구현되었습니다.\n */\nfunction dev_all() {\n  console.log(chalk.yellow.bold(\"Starting Sonamu dev server...\\n\"));\n  spawnApiDevServer();\n}\n\n/**\n * pnpm dev api 하면 실행되는 함수입니다.\n * API 전용 개발 서버를 띄웁니다.\n * dev_all과 거의 동일하되, 통합 웹 서버를 비활성화합니다.\n *\n * Sonamu.init 없이 호출될 것을 상정하여 구현되었습니다.\n */\nfunction dev_api() {\n  console.log(chalk.yellow.bold(\"Starting Sonamu API-only dev server...\\n\"));\n  spawnApiDevServer({\n    extraEnv: { SONAMU_DISABLE_INTEGRATED_WEB: \"yes\" },\n  });\n}\n\n/**\n * pnpm dev web 하면 실행되는 함수입니다.\n * Vite 개발 서버를 단독으로 실행합니다.\n * -- 뒤의 인자는 Vite에 그대로 전달됩니다.\n *\n * Sonamu.init 없이 호출될 것을 상정하여 구현되었습니다.\n */\nasync function dev_web() {\n  const appRoot = findAppRootPath();\n  const webPath = path.join(appRoot, \"web\");\n\n  if (!(await exists(webPath))) {\n    console.error(`web 디렉토리를 찾을 수 없습니다: ${webPath}`);\n    process.exit(1);\n  }\n\n  // -- 뒤의 인자 추출\n  const doubleDashIndex = process.argv.indexOf(\"--\");\n  const passthroughArgs = doubleDashIndex !== -1 ? process.argv.slice(doubleDashIndex + 1) : [];\n\n  const viteArgs = [\"exec\", \"vite\", ...passthroughArgs];\n\n  console.log(chalk.yellow.bold(\"Starting Vite dev server...\\n\"));\n\n  const viteProcess = spawn(\"pnpm\", viteArgs, {\n    cwd: webPath,\n    stdio: \"inherit\",\n  });\n\n  viteProcess.on(\"exit\", (code) => {\n    process.exit(code ?? 0);\n  });\n\n  // SIGINT/SIGTERM 시 Vite 프로세스를 gracefully 종료합니다.\n  for (const signal of [\"SIGINT\", \"SIGTERM\"] as const) {\n    process.on(signal, () => {\n      viteProcess.kill(signal);\n    });\n  }\n}\n\n/**\n * SWC 설정 파일 경로를 결정합니다. API 빌드(SWC)에서만 사용됩니다.\n * 프로젝트 루트에 .swcrc가 있으면 그것을, 없으면 sonamu 기본 설정을 사용합니다.\n */\nasync function resolveSwcConfigPath(): Promise<string> {\n  let swcFilePath = \".swcrc\";\n  try {\n    if (await exists(swcFilePath)) {\n      console.log(chalk.dim(\"Using .swcrc from project root...\"));\n    } else {\n      console.log(chalk.dim(\"Using default .swcrc from sonamu package...\"));\n      swcFilePath = path.join(import.meta.dirname, \"..\", \"..\", \".swcrc.project-default\");\n    }\n  } catch (error) {\n    console.error(chalk.red(\"Setting up swc config file failed.\"), error);\n    process.exit(1);\n  }\n  return swcFilePath;\n}\n\n/**\n * sonamu build / sonamu build all 하면 실행되는 함수입니다.\n * build_api + build_web의 합성입니다. Web 디렉토리가 없으면 Web 빌드를 스킵합니다.\n */\nasync function build_all() {\n  await build_api();\n  await build_web({ skipIfMissing: true });\n}\n\n/**\n * pnpm build api 하면 실행되는 함수입니다.\n * API 프로젝트만 빌드합니다.\n *\n * Sonamu.init 없이 호출될 것을 상정하여 구현되었습니다.\n */\nasync function build_api() {\n  const appRoot = findAppRootPath();\n  const swcFilePath = await resolveSwcConfigPath();\n\n  const apiStartedAt = Date.now();\n  try {\n    for (const artifact of API_ARTIFACTS) {\n      const cwd = path.join(appRoot, artifact.projectPath);\n      printTaskHeader(artifact.name, artifact.description, cwd);\n\n      await runBuildSteps(artifact, { cwd, buildCommandArgs: { configFilePath: swcFilePath } });\n    }\n    printBuildSummary(\"API\", true, Date.now() - apiStartedAt);\n  } catch (e) {\n    printBuildSummary(\"API\", false, Date.now() - apiStartedAt);\n    console.error(e);\n    process.exit(1);\n  }\n}\n\n/**\n * pnpm build web 하면 실행되는 함수입니다.\n * Web 프로젝트만 빌드합니다.\n *\n * Sonamu.init 없이 호출될 것을 상정하여 구현되었습니다.\n */\nasync function build_web({ skipIfMissing = false } = {}) {\n  const appRoot = findAppRootPath();\n  const webPath = path.join(appRoot, \"web\");\n\n  if (!(await exists(webPath))) {\n    if (skipIfMissing) {\n      console.log(chalk.gray(\"Web 디렉토리가 없으므로 Web 빌드를 건너뜁니다.\"));\n      return;\n    }\n    console.error(`web 디렉토리를 찾을 수 없습니다: ${webPath}`);\n    process.exit(1);\n  }\n\n  const webStartedAt = Date.now();\n  try {\n    for (const artifact of WEB_ARTIFACTS) {\n      const cwd = path.join(appRoot, artifact.projectPath);\n      printTaskHeader(artifact.name, artifact.description, cwd);\n\n      await runBuildSteps(artifact, { cwd, buildCommandArgs: {} });\n    }\n    printBuildSummary(\"Web\", true, Date.now() - webStartedAt);\n  } catch (e) {\n    printBuildSummary(\"Web\", false, Date.now() - webStartedAt);\n    console.error(e);\n    process.exit(1);\n  }\n}\n\n/**\n * pre-build, build, post-build 단계를 순차적으로 실행합니다.\n */\nasync function runBuildSteps<T>(\n  artifact: BuildArtifact<T>,\n  options: { cwd: string; buildCommandArgs: T },\n) {\n  const steps = [\n    { name: \"pre-build\", cmd: artifact.preBuildCommand?.() },\n    { name: \"build\", cmd: artifact.buildCommand(options.buildCommandArgs) },\n    { name: \"post-build\", cmd: artifact.postBuildCommand?.() },\n  ].filter((step) => step.cmd);\n\n  for (let i = 0; i < steps.length; i++) {\n    const step = steps[i];\n    const isLast = i === steps.length - 1;\n\n    try {\n      assert(step.cmd);\n      printTaskStart(step.name, step.cmd, isLast);\n      await execWithLinePrefix(step.cmd, { cwd: options.cwd });\n      printTaskSuccess(step.name, isLast);\n    } catch (e) {\n      printTaskFailed(step.name, isLast);\n      throw new Error(`${step.name} failed`, { cause: e });\n    }\n  }\n}\n\n/**\n * pnpm start 하면 실행되는 함수입니다.\n * 빌드된 프로젝트를 실행합니다.\n *\n * 빌드된 결과물(dist 디렉토리의 index.js 엔트리포인트)이 없다면 실행을 중단합니다.\n * 소스맵 지원과 dotenv 지원을 포함하여 실행합니다.\n *\n * Sonamu.init 없이 호출될 것을 상정하여 구현되었습니다.\n */\nasync function start() {\n  const apiRoot = findApiRootPath();\n  const entryPoint = \"dist/index.js\";\n\n  if (!(await exists(entryPoint))) {\n    console.log(chalk.red(`${entryPoint} not found. Please build your project first.`));\n    console.log(chalk.blue(\"Run: pnpm sonamu build\"));\n    return;\n  }\n\n  const { spawn } = await import(\"child_process\");\n  const serverProcess = spawn(\n    process.execPath,\n    [\"--enable-source-maps\", \"-r\", \"dotenv/config\", entryPoint],\n    {\n      cwd: apiRoot,\n      stdio: \"inherit\",\n    },\n  );\n\n  process.on(\"SIGINT\", () => {\n    serverProcess.kill(\"SIGTERM\");\n    process.exit(0);\n  });\n}\n\nasync function setupMigrator() {\n  // migrator\n  migrator = new Migrator();\n}\n\nasync function setupFixtureManager() {\n  FixtureManager.init();\n}\n\nasync function migrate_apply(targets: (keyof SonamuDBConfig)[]) {\n  await setupMigrator();\n  await migrator.runAction(\"apply\", targets);\n}\n\nasync function migrate_run() {\n  await setupMigrator();\n  const localHosts = [\"localhost\", \"127.0.0.1\", \"0.0.0.0\", \"::1\"];\n  const targets = Object.keys(Sonamu.dbConfig).filter((target) => {\n    const targetConfig = Sonamu.dbConfig[target as keyof SonamuDBConfig];\n    const host = (targetConfig?.connection as { host?: string })?.host ?? \"localhost\";\n    return localHosts.includes(host.toLowerCase());\n  });\n\n  // 로컬 데이터베이스에 대해서만 전체 마이그레이션에서 동작\n  await migrator.runAction(\"apply\", targets as (keyof SonamuDBConfig)[]);\n}\n\nasync function migrate_status() {\n  await setupMigrator();\n\n  const status = await migrator.getStatus();\n  // status;\n  console.log(status);\n}\n\nasync function fixture_init() {\n  const srcConfig = Sonamu.dbConfig.development_master;\n  const targets = [\n    {\n      label: \"(REMOTE) Fixture DB\",\n      config: Sonamu.dbConfig.fixture,\n    },\n    {\n      label: \"(LOCAL) Testing DB\",\n      config: Sonamu.dbConfig.test,\n      toSkip: (() => {\n        const remoteConn = Sonamu.dbConfig.fixture.connection as Knex.ConnectionConfig;\n        const localConn = Sonamu.dbConfig.test.connection as Knex.ConnectionConfig;\n        return remoteConn.host === localConn.host && remoteConn.database === localConn.database;\n      })(),\n    },\n  ] as {\n    label: string;\n    config: Knex.Config;\n    toSkip?: boolean;\n  }[];\n\n  // 1. 기준DB 스키마를 덤프\n  console.log(\"DUMP...\");\n  const dumpFilename = `/tmp/sonamu-fixture-init-${Date.now()}.sql`;\n  const srcConn = srcConfig.connection as Knex.ConnectionConfig;\n  const migrationsDump = `/tmp/sonamu-fixture-init-migrations-${Date.now()}.sql`;\n  execSync(\n    `mysqldump -h${srcConn.host} -u${srcConn.user} -p${srcConn.password} --single-transaction -d --no-create-db --triggers ${srcConn.database} > ${dumpFilename}`,\n  );\n  const _db = knex(srcConfig);\n  const [[migrations]] = await _db.raw(\n    \"SELECT COUNT(*) as count FROM information_schema.tables WHERE table_schema = ? AND table_name = 'knex_migrations'\",\n    [srcConn.database],\n  );\n  if (migrations.count > 0) {\n    execSync(\n      `mysqldump -h${srcConn.host} -u${srcConn.user} -p${srcConn.password} --single-transaction --no-create-db --triggers ${srcConn.database} knex_migrations knex_migrations_lock > ${migrationsDump}`,\n    );\n  }\n\n  // 2. 대상DB 각각에 대하여 존재여부 확인 후 붓기\n  for await (const { label, config, toSkip } of targets) {\n    const conn = config.connection as Knex.ConnectionConfig;\n\n    if (toSkip === true) {\n      console.log(chalk.red(`${label}: Skipped!`));\n      continue;\n    }\n\n    const db = knex({\n      ...config,\n      connection: {\n        ...((config.connection ?? {}) as Knex.ConnectionConfig),\n        database: undefined,\n      },\n    });\n    const [[row]] = await db.raw(`SHOW DATABASES LIKE \"${conn.database}\"`);\n    if (row) {\n      console.log(chalk.yellow(`${label}: Database \"${conn.database}\" Already exists`));\n      await db.destroy();\n      continue;\n    }\n\n    console.log(`SYNC to ${label}...`);\n    const mysqlCmd = `mysql -h${conn.host} -u${conn.user} -p${conn.password}`;\n    execSync(`${mysqlCmd} -e 'DROP DATABASE IF EXISTS \\`${conn.database}\\`'`);\n    execSync(`${mysqlCmd} -e 'CREATE DATABASE \\`${conn.database}\\`'`);\n    execSync(`${mysqlCmd} ${conn.database} < ${dumpFilename}`);\n    if (await exists(migrationsDump)) {\n      execSync(`${mysqlCmd} ${conn.database} < ${migrationsDump}`);\n    }\n\n    await db.destroy();\n  }\n\n  await _db.destroy();\n}\n\nasync function fixture_import(entityId: string, recordIds: number[]) {\n  await setupFixtureManager();\n\n  await FixtureManager.importFixture(entityId, recordIds);\n  await FixtureManager.sync();\n}\n\nasync function fixture_sync() {\n  await setupFixtureManager();\n\n  await FixtureManager.sync();\n}\n\n/**\n * fixture gen 명령어\n * 옵션을 process.argv에서 파싱\n */\nasync function fixture_gen() {\n  const options = parseOptions(process.argv);\n  await fixtureGenCommand(options);\n}\n\n/**\n * fixture fetch 명령어\n * 옵션을 process.argv에서 파싱\n */\nasync function fixture_fetch() {\n  const options = parseOptions(process.argv);\n  await fixtureFetchCommand(options);\n}\n\n/**\n * fixture explore 명령어\n * 옵션을 process.argv에서 파싱\n */\nasync function fixture_explore() {\n  const options = parseOptions(process.argv);\n  await fixtureExploreCommand(options);\n}\n\n/**\n * 간단한 옵션 파서\n */\nfunction parseOptions(\n  argv: string[],\n): Record<string, string | boolean | string[]> & { _: string[] } {\n  const options: Record<string, string | boolean | string[]> & { _: string[] } = { _: [] };\n\n  for (let i = 0; i < argv.length; i++) {\n    const arg = argv[i];\n\n    if (arg.startsWith(\"--\")) {\n      const key = arg.slice(2);\n\n      if (key.includes(\"=\")) {\n        const [k, v] = key.split(\"=\");\n        options[k] = v;\n      } else {\n        const next = argv[i + 1];\n        if (next && !next.startsWith(\"--\")) {\n          options[key] = next;\n          i++;\n        } else {\n          options[key] = true;\n        }\n      }\n    } else if (arg.startsWith(\"-\")) {\n      const key = arg.slice(1);\n      const next = argv[i + 1];\n\n      if (next && !next.startsWith(\"-\")) {\n        options[key] = next;\n        i++;\n      } else {\n        options[key] = true;\n      }\n    } else {\n      options._.push(arg);\n    }\n  }\n\n  return options;\n}\n\nasync function stub_practice(name: string) {\n  const practiceDir = path.join(Sonamu.apiRootPath, \"src\", \"practices\");\n  const fileNames = await readdir(practiceDir);\n\n  const maxSeqNo = await (async () => {\n    if (!(await exists(practiceDir))) {\n      await mkdir(practiceDir, { recursive: true });\n    }\n\n    const filteredSeqs = fileNames\n      .filter((fileName) => fileName.startsWith(\"p\") && fileName.endsWith(\".ts\"))\n      .map((fileName) => {\n        const [, seqNo] = fileName.match(/^p([0-9]+)-/) ?? [\"0\", \"0\"];\n        return parseInt(seqNo);\n      })\n      .sort((a, b) => b - a);\n\n    if (filteredSeqs.length > 0) {\n      return filteredSeqs[0];\n    }\n\n    return 0;\n  })();\n\n  const currentSeqNo = maxSeqNo + 1;\n  const fileName = `p${currentSeqNo}-${name}.ts`;\n  const dstPath = path.join(practiceDir, fileName);\n\n  const code = [\n    `import { Sonamu } from \"sonamu\";`,\n    \"\",\n    `console.clear();`,\n    `console.log(\"${fileName}\");`,\n    \"\",\n    `Sonamu.runScript(async () => {`,\n    ` // TODO`,\n    `});`,\n    \"\",\n  ].join(\"\\n\");\n  await writeFile(dstPath, code);\n\n  execSync(`code ${dstPath}`);\n\n  const runCode = `yarn node -r dotenv/config --enable-source-maps dist/practices/${fileName.replace(\n    \".ts\",\n    \".js\",\n  )}`;\n  console.log(`${chalk.blue(runCode)} copied to clipboard.`);\n  execSync(`echo \"${runCode}\" | pbcopy`);\n}\n\nasync function stub_entity(entityId: string) {\n  await Sonamu.syncer.createEntity({ entityId, title: entityId });\n\n  const { flags } = parseCliOptions();\n  const useAI = flags.has(\"ai\");\n  const noCones = flags.has(\"no-cones\");\n\n  // --no-cones: cone 생성 스킵\n  if (noCones) {\n    console.log(`✓ Entity '${entityId}' created without cones`);\n    return;\n  }\n\n  const { EntityManager } = await import(\"../entity/entity-manager\");\n  const entity = EntityManager.get(entityId);\n  if (!entity) {\n    console.error(`Entity not found: ${entityId}`);\n    return;\n  }\n\n  // --ai: LLM으로 cone 생성\n  if (useAI) {\n    console.log(`✓ Entity '${entityId}' created`);\n    console.log(`🌟 Generating AI-powered cones...`);\n    try {\n      const configLocale = Sonamu.config.i18n?.defaultLocale;\n      const locale =\n        configLocale === \"ko\" || configLocale === \"en\" || configLocale === \"ja\"\n          ? configLocale\n          : \"ko\";\n\n      const result = await entity.generateCones({\n        preserveExisting: false,\n        onlyEmpty: false,\n        locale,\n      });\n\n      console.log(`✅ Done (${result.tokensUsed} tokens)`);\n    } catch (error) {\n      if (error instanceof Error && error.message.includes(\"ANTHROPIC_API_KEY\")) {\n        console.error(`\\n❌ ${error.message}`);\n        console.error(`\\n💡 Remove --ai flag to use template cones instead`);\n      } else {\n        throw error;\n      }\n    }\n    return;\n  }\n\n  // 기본: 템플릿 cone 자동 생성\n  // LLM 없이 faker-mappings.ts를 활용하여 기본 cone 메타데이터를 생성합니다.\n  // 이를 통해 ANTHROPIC_API_KEY가 없어도 Sonamu를 사용할 수 있으며,\n  // 생성된 템플릿 cone은 나중에 'cone gen' 명령어로 AI를 통해 업그레이드할 수 있습니다.\n  console.log(`🌟 Generating template cones...`);\n  await entity.generateTemplateCones();\n  console.log(`✓ Entity '${entityId}' created with template cones`);\n  console.log(`💡 Tip: Run 'pnpm sonamu cone gen ${entityId}' to improve with AI`);\n}\n\n/**\n * AI를 사용하여 entity의 cone 메타데이터를 생성하거나 업그레이드합니다.\n *\n * 옵션:\n * - --regenerate: 전체 재생성 (기존 cone 덮어쓰기)\n * - --locale <ko|en|ja>: 생성 언어 지정\n * - 기본: onlyEmpty 모드 (기존 fixtureHint 보존)\n *\n * ANTHROPIC_API_KEY 필요 (sonamu.secret.ts 또는 환경변수)\n */\nasync function cone_gen(entityId: string) {\n  const { EntityManager } = await import(\"../entity/entity-manager\");\n  const { flags, options } = parseCliOptions();\n\n  // --all 옵션: 모든 entity cone 생성\n  if (flags.has(\"all\") || entityId === \"all\") {\n    const allEntities = EntityManager.getAllEntities();\n    console.log(`🌟 Generating AI-powered cones for ${allEntities.length} entities...\\n`);\n\n    let totalTokens = 0;\n    const errors: string[] = [];\n\n    for (const entity of allEntities) {\n      try {\n        console.log(`Processing ${entity.id}...`);\n        const configLocale = options.locale || Sonamu.config.i18n?.defaultLocale;\n        const locale =\n          configLocale === \"ko\" || configLocale === \"en\" || configLocale === \"ja\"\n            ? configLocale\n            : \"ko\";\n\n        const result = await entity.generateCones({\n          preserveExisting: !flags.has(\"regenerate\"),\n          onlyEmpty: !flags.has(\"regenerate\"),\n          locale,\n        });\n\n        totalTokens += result.tokensUsed;\n        console.log(`  ✓ ${entity.id} (${result.tokensUsed} tokens)\\n`);\n      } catch (error) {\n        const message = error instanceof Error ? error.message : \"Unknown error\";\n        errors.push(`${entity.id}: ${message}`);\n        console.error(`  ✗ ${entity.id}: ${message}\\n`);\n      }\n    }\n\n    console.log(`\\n✅ Done! Total: ${totalTokens} tokens used`);\n    const estimatedCost = (totalTokens * 9) / 1_000_000;\n    console.log(`💰 Estimated cost: ~$${estimatedCost.toFixed(4)}`);\n\n    if (errors.length > 0) {\n      console.error(`\\n❌ Failed entities (${errors.length}):`);\n      for (const err of errors) {\n        console.error(`  - ${err}`);\n      }\n    }\n    return;\n  }\n\n  // 단일 entity cone 생성\n  const entity = EntityManager.get(entityId);\n  if (!entity) {\n    console.error(`Entity not found: ${entityId}`);\n    return;\n  }\n\n  const mode = flags.has(\"regenerate\") ? \"regenerating\" : \"generating\";\n  console.log(\n    `🌟 ${mode === \"regenerating\" ? \"Regenerating\" : \"Generating\"} AI-powered cones for ${entityId}...`,\n  );\n\n  try {\n    const configLocale = options.locale || Sonamu.config.i18n?.defaultLocale;\n    const locale =\n      configLocale === \"ko\" || configLocale === \"en\" || configLocale === \"ja\" ? configLocale : \"ko\";\n\n    const result = await entity.generateCones({\n      preserveExisting: !flags.has(\"regenerate\"),\n      onlyEmpty: !flags.has(\"regenerate\"),\n      locale,\n    });\n\n    console.log(`✅ Done! (${result.tokensUsed} tokens used)`);\n\n    // 토큰 비용 계산 (대략적인 추정)\n    // Claude Sonnet 4.5: input $3/M tokens, output $15/M tokens\n    // 간단하게 평균 $9/M tokens로 계산\n    const estimatedCost = (result.tokensUsed * 9) / 1_000_000;\n    console.log(`💰 Estimated cost: ~$${estimatedCost.toFixed(4)}`);\n  } catch (error) {\n    if (error instanceof Error) {\n      if (error.message.includes(\"ANTHROPIC_API_KEY\")) {\n        console.error(`\\n❌ ${error.message}`);\n        console.error(`\\n💡 To use AI-powered cone generation:`);\n        console.error(`   1. Get an API key from https://console.anthropic.com/`);\n        console.error(\n          `   2. Add it to sonamu.secret.ts or set ANTHROPIC_API_KEY environment variable`,\n        );\n      } else if (error.message.includes(\"Rate limit\")) {\n        console.error(`\\n❌ ${error.message}`);\n        console.error(`\\n💡 Please wait a moment and try again.`);\n      } else {\n        console.error(`\\n❌ Failed to generate cones: ${error.message}`);\n      }\n    } else {\n      console.error(`\\n❌ Failed to generate cones: Unknown error`);\n    }\n  }\n}\n\nasync function scaffold_model(entityId: string) {\n  await Sonamu.syncer.generateTemplate(\"model\", {\n    entityId,\n  });\n}\n\nasync function scaffold_model_test(entityId: string) {\n  await Sonamu.syncer.generateTemplate(\"model_test\", {\n    entityId,\n  });\n}\n\n/**\n * pnpm sonamu skills sync 하면 실행되는 함수입니다.\n * 공식 Skills를 로컬 프로젝트로 동기화합니다.\n */\nasync function skills_sync() {\n  const workspaceRoot = await findWorkspaceRoot();\n  const claudeDir = path.join(workspaceRoot, \".claude\");\n  const targetSkillsDir = path.join(claudeDir, \"skills\", \"sonamu\");\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  // 기존 디렉토리/symlink 삭제 후 symlink 생성\n  // exists()는 broken symlink를 감지하지 못하므로 rm을 무조건 시도합니다\n  try {\n    await rm(targetSkillsDir, { recursive: true, force: true });\n  } catch {\n    // 파일이 없으면 무시\n  }\n\n  // 대상 디렉토리 생성\n  await mkdir(path.dirname(targetSkillsDir), { recursive: true });\n\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    try {\n      await cp(sourceSkillsDir, targetSkillsDir, { 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  // project 디렉토리 초기화 (없으면 생성, 있으면 유지)\n  const sourceProjectDir = path.join(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  // CLAUDE.md 복사/업데이트\n  if (await exists(sourceClaudeMd)) {\n    try {\n      const targetClaudeMd = path.join(claudeDir, \"CLAUDE.md\");\n      const sourceContent = await readFile(sourceClaudeMd, \"utf-8\");\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          // marker 영역만 교체합니다.\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        }\n      } else {\n        await writeFile(targetClaudeMd, sourceContent);\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\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 * 워크스페이스 루트를 찾습니다.\n * 우선순위: pnpm-workspace.yaml > CLAUDE.md > 루트 package.json (workspaces 필드)\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. CLAUDE.md 파일이 있는지 확인. 있으면 프로젝트 루트로 간주함.\n    if (await exists(path.join(dir, \"CLAUDE.md\"))) {\n      return dir;\n    }\n\n    // 3. package.json에 workspaces 필드가 있으면 루트.\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    dir = path.dirname(dir);\n  }\n\n  // 찾지 못하면 api 폴더의 부모 사용\n  return findAppRootPath();\n}\n"],"names":["chalk","dotenv","config","assert","execSync","spawn","cp","mkdir","readdir","readFile","rm","symlink","writeFile","knex","createRequire","path","process","tsicli","Sonamu","generateBetterAuthEntities","isValidPluginId","SUPPORTED_PLUGIN_IDS","EntityManager","Migrator","FixtureManager","execWithLinePrefix","printBuildSummary","printTaskFailed","printTaskHeader","printTaskStart","printTaskSuccess","exists","findApiRootPath","findAppRootPath","API_ARTIFACTS","WEB_ARTIFACTS","fixtureExploreCommand","fixtureFetchCommand","fixtureGenCommand","migrator","parseCliOptions","argv","flags","Set","options","i","length","arg","startsWith","includes","key","value","slice","split","nextArg","add","bootstrap","notToInit","init","filteredArgv","skipNext","afterDoubleDash","push","cmd","types","type","name","message","choices","getAllParentIds","map","entityId","title","args","runners","migrate_status","migrate_run","migrate_apply","fixture_init","fixture_import","fixture_sync","fixture_gen","fixture_fetch","fixture_explore","stub_practice","stub_entity","scaffold_model","scaffold_model_test","cone_gen","sync","build_all","build_api","build_web","dev_all","dev_api","dev_web","start","skills_sync","skills_create","auth_generate","destroy","finally","syncer","spawnApiDevServer","apiRoot","entryPoint","hotRunnerBinPath","url","resolve","serverProcess","execPath","join","cwd","stdio","env","NODE_ENV","HOT","API_ROOT_PATH","extraEnv","cleanup","console","log","yellow","kill","exit","on","code","error","red","bold","SONAMU_DISABLE_INTEGRATED_WEB","appRoot","webPath","doubleDashIndex","indexOf","passthroughArgs","viteArgs","viteProcess","signal","resolveSwcConfigPath","swcFilePath","dim","dirname","skipIfMissing","apiStartedAt","Date","now","artifact","projectPath","description","runBuildSteps","buildCommandArgs","configFilePath","e","gray","webStartedAt","steps","preBuildCommand","buildCommand","postBuildCommand","filter","step","isLast","Error","cause","blue","setupMigrator","setupFixtureManager","targets","runAction","localHosts","Object","keys","dbConfig","target","targetConfig","host","connection","toLowerCase","status","getStatus","srcConfig","development_master","label","fixture","test","toSkip","remoteConn","localConn","database","dumpFilename","srcConn","migrationsDump","user","password","_db","migrations","raw","count","conn","db","undefined","row","mysqlCmd","recordIds","importFixture","parseOptions","_","k","v","next","practiceDir","apiRootPath","fileNames","maxSeqNo","recursive","filteredSeqs","fileName","endsWith","seqNo","match","parseInt","sort","a","b","currentSeqNo","dstPath","runCode","replace","createEntity","useAI","has","noCones","entity","get","configLocale","i18n","defaultLocale","locale","result","generateCones","preserveExisting","onlyEmpty","tokensUsed","generateTemplateCones","allEntities","getAllEntities","totalTokens","errors","id","estimatedCost","toFixed","err","mode","generateTemplate","workspaceRoot","findWorkspaceRoot","claudeDir","targetSkillsDir","sourceBase","sourceSkillsDir","sourceClaudeMd","force","green","String","copyError","sourceProjectDir","targetProjectDir","targetClaudeMd","sourceContent","targetContent","startMarker","endMarker","startIdx","endIdx","before","substring","after","newContent","localDir","trim","sanitized","MAX_LENGTH","RESERVED_NAMES","toUpperCase","filePath","template","toISOString","pluginsArg","find","plugins","pluginValue","pluginIds","p","dir","packagePath","packageJson","JSON","parse","workspaces"],"mappings":"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"}