sonamu 0.7.53 → 0.8.0

package/src/bin/build-config.ts

@@ -9,7 +9,7 @@ export type BuildArtifact<BuildCommandArgs = {}> = {
 
 /**
  * API 프로젝트 빌드 산출물에 대한 규칙들.
- * cli.ts의 build 함수가 이것을 보고 그대로 실행합니다.
+ * cli.ts의 build_api 함수가 이것을 보고 그대로 실행합니다.
  */
 export const API_ARTIFACTS: BuildArtifact<{ configFilePath: string }>[] = [
   {
@@ -24,24 +24,24 @@ export const API_ARTIFACTS: BuildArtifact<{ configFilePath: string }>[] = [
 
 /**
  * 웹 프로젝트 빌드 산출물에 대한 규칙들.
- * cli.ts의 build 함수가 이것을 보고 그대로 실행합니다.
+ * cli.ts의 build_web 함수가 이것을 보고 그대로 실행합니다.
  */
 export const WEB_ARTIFACTS: BuildArtifact[] = [
   {
     name: "Web Client",
     description: "Web 프로젝트 클라이언트 빌드 산출물",
     projectPath: "web",
-    preBuildCommand: () => "rm -rf dist/client && rm -rf ../api/public/web",
+    preBuildCommand: () => "rm -rf dist/client",
     buildCommand: () => "tsc --noEmit && vite build --outDir dist/client",
-    postBuildCommand: () => "mkdir -p ../api/public/web && cp -r dist/client/* ../api/public/web",
   },
   {
     name: "Web Server",
     description: "Web 프로젝트 서버 빌드 산출물",
     projectPath: "web",
-    preBuildCommand: () => "rm -rf dist/server", // api/dist/ssr은 안 지웁니다! 거기는 api의 빌드 결과물이 들어있음!
+    preBuildCommand: () => "rm -rf dist/server",
     buildCommand: () =>
       "tsc --noEmit && vite build --ssr src/entry-server.generated.tsx --outDir dist/server",
-    postBuildCommand: () => "mkdir -p ../api/dist/ssr && cp -r dist/server/* ../api/dist/ssr",
+    postBuildCommand: () =>
+      "rm -rf ../api/web-dist && mkdir -p ../api/web-dist && cp -r dist/* ../api/web-dist",
   },
 ];

package/src/bin/cli.ts

@@ -33,9 +33,45 @@ import {
 import { exists } from "../utils/fs-utils";
 import { findApiRootPath, findAppRootPath } from "../utils/utils";
 import { API_ARTIFACTS, type BuildArtifact, WEB_ARTIFACTS } from "./build-config";
+import { fixtureExploreCommand, fixtureFetchCommand, fixtureGenCommand } from "./fixture";
 
 let migrator: Migrator;
 
+/**
+ * CLI 옵션을 파싱하는 헬퍼 함수
+ */
+function parseCliOptions(argv: string[] = process.argv): {
+  flags: Set<string>; // --regenerate, --ai, --no-cones 등
+  options: Record<string, string>; // --locale ko 등
+} {
+  const flags = new Set<string>();
+  const options: Record<string, string> = {};
+
+  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", "build", "start", "skills"].includes(process.argv[2] ?? "");
   if (!notToInit) {
@@ -45,23 +81,43 @@ async function bootstrap() {
   try {
     // tsicli는 정확한 명령어 매칭만 지원하므로, --로 시작하는 옵션과 그 값을 필터링합니다.
     // 옵션 파싱은 각 runner 함수에서 원본 process.argv를 사용하여 수행합니다.
+    // "--"(bare double dash)는 passthrough 구분자이므로, 그 뒤의 모든 인자도 제외합니다.
     const filteredArgv: string[] = [];
     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": {
@@ -91,6 +147,9 @@ async function bootstrap() {
         ["fixture", "init"],
         ["fixture", "import", "#entityId", "#recordIds"],
         ["fixture", "sync"],
+        ["fixture", "gen"],
+        ["fixture", "fetch"],
+        ["fixture", "explore"],
         ["migrate", "run"],
         ["migrate", "apply", "#targets"],
         ["migrate", "status"],
@@ -100,9 +159,14 @@ async function bootstrap() {
         ["scaffold", "model_test", "#entityId"],
         ["scaffold", "view_list", "#entityId"],
         ["scaffold", "view_form", "#entityId"],
+        ["cone", "gen", "#entityId"],
         ["sync"],
-        ["dev"],
-        ["build"],
+        ["build", "all"],
+        ["build", "api"],
+        ["build", "web"],
+        ["dev", "all"],
+        ["dev", "api"],
+        ["dev", "web"],
         ["start"],
         ["skills", "sync"],
         ["skills", "create", "#name"],
@@ -115,15 +179,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,
@@ -148,8 +220,8 @@ async function sync() {
 }
 
 /**
- * pnpm dev 하면 실행되는 함수입니다.
- * 프로젝트에 대해 HMR 지원하는 개발 서버를 띄워줍니다.
+ * API 개발 서버를 실행하는 공통 로직입니다.
+ * dev_all과 dev_api에서 공유합니다.
  *
  * TypeScript를 바로 실행할 수 있도록 @sonamu-kit/ts-loader를,
  * HMR을 지원하기 위해 @sonamu-kit/hmr-hook을 import하며,
@@ -158,15 +230,11 @@ async function sync() {
  * 이때 @sonamu-kit/ts-loader와 @sonamu-kit/hmr-hook는 sonamu가 자체적으로 가지고 있는 dependency입니다.
  * 또한 실행에 사용하는 @sonamu-kit/hmr-runner도 마찬가지로 sonamu가 자체적으로 가지고 있는 dependency입니다.
  * 따라서 사용자 프로젝트에서는 이 세 패키지를 직접 설치할 필요가 없습니다.
- *
- * Sonamu.init 없이 호출될 것을 상정하여 구현되었습니다.
  */
-async function dev() {
+function spawnApiDevServer(options?: { extraEnv?: Record<string, string> }) {
   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(
@@ -196,6 +264,7 @@ async function dev() {
         NODE_ENV: "development",
         HOT: "yes", // 얘가 있어야 HMR이 활성화됩니다.
         API_ROOT_PATH: apiRoot, // 이 경로가 hmr-hook의 루트 디렉토리가 됩니다.
+        ...options?.extraEnv,
       },
     },
   );
@@ -212,34 +281,88 @@ async function dev() {
 
   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();
+  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",
+  });
 
-  // .swcrc 파일을 지정합니다.
+  viteProcess.on("exit", (code) => {
+    process.exit(code ?? 0);
+  });
+
+  // SIGINT/SIGTERM 시 Vite 프로세스를 gracefully 종료합니다.
+  for (const signal of ["SIGINT", "SIGTERM"] as const) {
+    process.on(signal, () => {
+      viteProcess.kill(signal);
+    });
+  }
+}
+
+/**
+ * SWC 설정 파일 경로를 결정합니다. API 빌드(SWC)에서만 사용됩니다.
+ * 프로젝트 루트에 .swcrc가 있으면 그것을, 없으면 sonamu 기본 설정을 사용합니다.
+ */
+async function resolveSwcConfigPath(): Promise<string> {
   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");
     }
@@ -247,8 +370,28 @@ async function build() {
     console.error(chalk.red("Setting up swc config file failed."), error);
     process.exit(1);
   }
+  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();
 
-  // API 프로젝트를 빌드합니다.
   const apiStartedAt = Date.now();
   try {
     for (const artifact of API_ARTIFACTS) {
@@ -258,12 +401,32 @@ async function build() {
       await runBuildSteps(artifact, { cwd, buildCommandArgs: { configFilePath: swcFilePath } });
     }
     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) {
@@ -273,8 +436,9 @@ async function build() {
       await runBuildSteps(artifact, { cwd, buildCommandArgs: {} });
     }
     printBuildSummary("Web", true, Date.now() - webStartedAt);
-  } catch {
+  } catch (e) {
     printBuildSummary("Web", false, Date.now() - webStartedAt);
+    console.error(e);
     process.exit(1);
   }
 }
@@ -301,9 +465,9 @@ async function runBuildSteps<T>(
       printTaskStart(step.name, step.cmd, isLast);
       await execWithLinePrefix(step.cmd, { 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 });
     }
   }
 }
@@ -323,7 +487,7 @@ async function start() {
 
   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;
   }
 
@@ -470,6 +634,77 @@ async function fixture_sync() {
   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: string[],
+): Record<string, string | boolean | string[]> & { _: string[] } {
+  const options: Record<string, string | boolean | string[]> & { _: string[] } = { _: [] };
+
+  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: string) {
   const practiceDir = path.join(Sonamu.apiRootPath, "src", "practices");
   const fileNames = await readdir(practiceDir);
@@ -523,6 +758,171 @@ async function stub_practice(name: string) {
 
 async function stub_entity(entityId: string) {
   await Sonamu.syncer.createEntity({ entityId, title: entityId });
+
+  const { flags } = parseCliOptions();
+  const useAI = flags.has("ai");
+  const noCones = flags.has("no-cones");
+
+  // --no-cones: cone 생성 스킵
+  if (noCones) {
+    console.log(`✓ Entity '${entityId}' created without cones`);
+    return;
+  }
+
+  const { EntityManager } = await import("../entity/entity-manager");
+  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: string) {
+  const { EntityManager } = await import("../entity/entity-manager");
+  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: string[] = [];
+
+    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: string) {
@@ -590,6 +990,27 @@ async function skills_sync() {
     }
   }
 
+  // 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 {