@mandujs/cli 0.13.1 → 0.14.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mandujs/cli",
-  "version": "0.13.1",
+  "version": "0.14.0",
   "description": "Agent-Native Fullstack Framework - 에이전트가 코딩해도 아키텍처가 무너지지 않는 개발 OS",
   "type": "module",
   "main": "./src/main.ts",

package/src/commands/check.ts

@@ -36,7 +36,7 @@ export async function check(): Promise<boolean> {
   const quiet = false;
   const strictWarnings = process.env.CI === "true";
   const enableFsRoutes = await isDirectory(path.resolve(rootDir, "app"));
-  const specPath = resolveFromCwd("spec/routes.manifest.json");
+  const specPath = resolveFromCwd(".mandu/routes.manifest.json");
   const hasSpec = await pathExists(specPath);
 
   let success = true;
@@ -71,8 +71,6 @@ export async function check(): Promise<boolean> {
       if (format === "console") {
         const result = await generateManifest(rootDir, {
           scanner: config.fsRoutes,
-          outputPath: ".mandu/routes.manifest.json",
-          skipLegacy: true,
         });
         routesSummary.count = result.manifest.routes.length;
         routesSummary.warnings = result.warnings;
@@ -217,9 +215,9 @@ export async function check(): Promise<boolean> {
     }
   } else {
     if (quiet) {
-      print("ℹ️  spec/routes.manifest.json 없음 - 레거시 Guard 스킵");
+      print("ℹ️  .mandu/routes.manifest.json 없음 - Guard 스킵");
     } else {
-      log("ℹ️  spec/routes.manifest.json 없음 - 레거시 Guard 스킵");
+      log("ℹ️  .mandu/routes.manifest.json 없음 - Guard 스킵");
     }
   }
 

package/src/commands/dev.ts

@@ -344,7 +344,6 @@ export async function dev(options: DevOptions = {}): Promise<void> {
 
   // FS Routes 실시간 감시
   const routesWatcher = await watchFSRoutes(rootDir, {
-    skipLegacy: true,
     onChange: async (result) => {
       const timestamp = new Date().toLocaleTimeString();
       console.log(`\n🔄 [${timestamp}] 라우트 변경 감지`);

package/src/commands/doctor.ts

@@ -32,7 +32,7 @@ export async function doctor(options: DoctorOptions = {}): Promise<boolean> {
   const inferredFormat = format ?? (output ? (path.extname(output).toLowerCase() === ".json" ? "json" : "markdown") : undefined);
   const resolvedFormat = inferredFormat ?? "console";
 
-  const specPath = resolveFromCwd("spec/routes.manifest.json");
+  const specPath = resolveFromCwd(".mandu/routes.manifest.json");
   const rootDir = getRootDir();
 
   console.log(`🩺 Mandu Doctor`);

package/src/commands/generate-apply.ts

@@ -1,22 +1,25 @@
-import { loadManifest, generateRoutes, buildGenerateReport, printReportSummary, writeReport } from "@mandujs/core";
+import { loadManifest, generateManifest, generateRoutes, buildGenerateReport, printReportSummary, writeReport } from "@mandujs/core";
 import { resolveFromCwd, getRootDir } from "../util/fs";
 
 export async function generateApply(): Promise<boolean> {
-  const specPath = resolveFromCwd("spec/routes.manifest.json");
   const rootDir = getRootDir();
+  const manifestPath = resolveFromCwd(".mandu/routes.manifest.json");
 
   console.log(`🥟 Mandu Generate`);
-  console.log(`📄 Spec 파일: ${specPath}\n`);
+  console.log(`📄 FS Routes 기반 코드 생성\n`);
 
-  const result = await loadManifest(specPath);
+  // Regenerate manifest from FS Routes
+  const fsResult = await generateManifest(rootDir);
+  console.log(`✅ 매니페스트 생성 완료 (${fsResult.fsRoutesCount}개 라우트)`);
+
+  const result = await loadManifest(manifestPath);
 
   if (!result.success || !result.data) {
-    console.error("❌ Spec 로드 실패:");
+    console.error("❌ 매니페스트 로드 실패:");
     result.errors?.forEach((e) => console.error(`  - ${e}`));
     return false;
   }
 
-  console.log(`✅ Spec 로드 완료 (${result.data.routes.length}개 라우트)`);
   console.log(`🔄 코드 생성 중...\n`);
 
   const generateResult = await generateRoutes(result.data, rootDir);

package/src/commands/guard-check.ts

@@ -16,7 +16,7 @@ export interface GuardCheckOptions {
 export async function guardCheck(options: GuardCheckOptions = {}): Promise<boolean> {
   const { autoCorrect = true } = options;
 
-  const specPath = resolveFromCwd("spec/routes.manifest.json");
+  const specPath = resolveFromCwd(".mandu/routes.manifest.json");
   const rootDir = getRootDir();
 
   console.log(`🥟 Mandu Guard (Legacy Spec)`);

package/src/commands/init.ts

@@ -252,23 +252,11 @@ export async function init(options: InitOptions = {}): Promise<boolean> {
     console.log(`   src/client/shared/lib/utils.ts → 유틸리티 (cn 함수)`);
   }
 
-  // MCP 설정 안내
-  console.log(`\n🤖 AI 에이전트 통합:`);
-  if (mcpResult.status === "created") {
-    console.log(`   .mcp.json 생성됨 (Claude Code 자동 연결)`);
-  } else if (mcpResult.status === "updated") {
-    console.log(`   .mcp.json에 mandu 서버 추가/업데이트됨`);
-  } else if (mcpResult.status === "unchanged") {
-    console.log(`   .mcp.json 이미 최신`);
-  } else if (mcpResult.status === "backed-up") {
-    console.log(`   .mcp.json 파싱 실패 → 백업 후 새로 생성됨`);
-    if (mcpResult.backupPath) {
-      console.log(`   백업: ${mcpResult.backupPath}`);
-    }
-  } else if (mcpResult.status === "error") {
-    console.log(`   .mcp.json 설정 실패: ${mcpResult.error}`);
-  }
-  console.log(`   AGENTS.md → 에이전트 가이드 (Bun 사용 명시)`);
+  // MCP 설정 안내
+  console.log(`\n🤖 AI 에이전트 통합:`);
+  logMcpConfigStatus(".mcp.json", mcpResult.mcpJson, "Claude Code 자동 연결");
+  logMcpConfigStatus(".claude.json", mcpResult.claudeJson, "Claude MCP 로컬 범위");
+  console.log(`   AGENTS.md → 에이전트 가이드 (Bun 사용 명시)`);
 
   // Lockfile 안내
   console.log(`\n🔒 설정 무결성:`);
@@ -382,97 +370,144 @@ async function updatePackageJson(
   await fs.writeFile(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
 }
 
-type McpConfigStatus = "created" | "updated" | "unchanged" | "backed-up" | "error";
-
-interface McpConfigResult {
-  status: McpConfigStatus;
-  backupPath?: string;
-  error?: string;
-}
-
-/**
- * .mcp.json 설정 (AI 에이전트 통합)
- * - 파일 없으면 새로 생성
- * - 파일 있으면 mandu 서버만 추가/업데이트 (다른 설정 유지)
- */
-async function setupMcpConfig(targetDir: string): Promise<McpConfigResult> {
-  const mcpPath = path.join(targetDir, ".mcp.json");
-
-  const manduServer = {
-    command: "bunx",
-    args: ["@mandujs/mcp"],
-  };
-
-  const writeConfig = async (data: Record<string, unknown>) => {
-    await fs.writeFile(mcpPath, JSON.stringify(data, null, 2) + "\n");
-  };
-
-  const fileExists = async (filePath: string) => {
-    try {
-      await fs.access(filePath);
-      return true;
-    } catch {
-      return false;
-    }
-  };
-
-  const getBackupPath = async (basePath: string) => {
-    const base = `${basePath}.bak`;
-    if (!(await fileExists(base))) {
-      return base;
-    }
-    for (let i = 1; i <= 50; i++) {
-      const candidate = `${basePath}.bak.${i}`;
-      if (!(await fileExists(candidate))) {
-        return candidate;
-      }
-    }
-    return `${basePath}.bak.${Date.now()}`;
-  };
-
-  try {
-    const existingContent = await fs.readFile(mcpPath, "utf-8");
-    let existing: Record<string, unknown>;
-
-    try {
-      existing = JSON.parse(existingContent) as Record<string, unknown>;
-    } catch {
-      const backupPath = await getBackupPath(mcpPath);
-      await fs.writeFile(backupPath, existingContent);
-      await writeConfig({ mcpServers: { mandu: manduServer } });
-      return { status: "backed-up", backupPath };
-    }
-
-    if (!existing || typeof existing !== "object") {
-      existing = {};
-    }
-
-    if (!existing.mcpServers || typeof existing.mcpServers !== "object") {
-      existing.mcpServers = {};
-    }
-
-    const current = (existing.mcpServers as Record<string, unknown>).mandu;
-    const isSame =
-      current && JSON.stringify(current) === JSON.stringify(manduServer);
-
-    if (isSame) {
-      return { status: "unchanged" };
-    }
-
-    (existing.mcpServers as Record<string, unknown>).mandu = manduServer;
-    await writeConfig(existing);
-    return { status: "updated" };
-  } catch (error) {
-    if (error && typeof error === "object" && "code" in error && (error as { code?: string }).code === "ENOENT") {
-      await writeConfig({ mcpServers: { mandu: manduServer } });
-      return { status: "created" };
-    }
-    return {
-      status: "error",
-      error: error instanceof Error ? error.message : String(error),
-    };
-  }
-}
+type McpConfigStatus = "created" | "updated" | "unchanged" | "backed-up" | "error";
+
+interface McpConfigFileResult {
+  status: McpConfigStatus;
+  backupPath?: string;
+  error?: string;
+}
+
+interface McpConfigResult {
+  mcpJson: McpConfigFileResult;
+  claudeJson: McpConfigFileResult;
+}
+
+function logMcpConfigStatus(
+  label: string,
+  result: McpConfigFileResult,
+  createdNote?: string
+): void {
+  if (result.status === "created") {
+    console.log(`   ${label} 생성됨${createdNote ? ` (${createdNote})` : ""}`);
+    return;
+  }
+
+  if (result.status === "updated") {
+    console.log(`   ${label}에 mandu 서버 추가/업데이트됨`);
+    return;
+  }
+
+  if (result.status === "unchanged") {
+    console.log(`   ${label} 이미 최신`);
+    return;
+  }
+
+  if (result.status === "backed-up") {
+    console.log(`   ${label} 파싱 실패 → 백업 후 새로 생성됨`);
+    if (result.backupPath) {
+      console.log(`   백업: ${result.backupPath}`);
+    }
+    return;
+  }
+
+  if (result.status === "error") {
+    console.log(`   ${label} 설정 실패: ${result.error}`);
+  }
+}
+
+/**
+ * .mcp.json / .claude.json 설정 (AI 에이전트 통합)
+ * - 파일 없으면 새로 생성
+ * - 파일 있으면 mandu 서버만 추가/업데이트 (다른 설정 유지)
+ */
+async function setupMcpConfig(targetDir: string): Promise<McpConfigResult> {
+  const mcpPath = path.join(targetDir, ".mcp.json");
+  const claudePath = path.join(targetDir, ".claude.json");
+
+  const manduServer = {
+    command: "bunx",
+    args: ["@mandujs/mcp"],
+    cwd: ".",
+  };
+
+  const updateMcpFile = async (filePath: string): Promise<McpConfigFileResult> => {
+    const writeConfig = async (data: Record<string, unknown>) => {
+      await fs.writeFile(filePath, JSON.stringify(data, null, 2) + "\n");
+    };
+
+    const fileExists = async (candidatePath: string) => {
+      try {
+        await fs.access(candidatePath);
+        return true;
+      } catch {
+        return false;
+      }
+    };
+
+    const getBackupPath = async (basePath: string) => {
+      const base = `${basePath}.bak`;
+      if (!(await fileExists(base))) {
+        return base;
+      }
+      for (let i = 1; i <= 50; i++) {
+        const candidate = `${basePath}.bak.${i}`;
+        if (!(await fileExists(candidate))) {
+          return candidate;
+        }
+      }
+      return `${basePath}.bak.${Date.now()}`;
+    };
+
+    try {
+      const existingContent = await fs.readFile(filePath, "utf-8");
+      let existing: Record<string, unknown>;
+
+      try {
+        existing = JSON.parse(existingContent) as Record<string, unknown>;
+      } catch {
+        const backupPath = await getBackupPath(filePath);
+        await fs.writeFile(backupPath, existingContent);
+        await writeConfig({ mcpServers: { mandu: manduServer } });
+        return { status: "backed-up", backupPath };
+      }
+
+      if (!existing || typeof existing !== "object") {
+        existing = {};
+      }
+
+      if (!existing.mcpServers || typeof existing.mcpServers !== "object") {
+        existing.mcpServers = {};
+      }
+
+      const current = (existing.mcpServers as Record<string, unknown>).mandu;
+      const isSame =
+        current && JSON.stringify(current) === JSON.stringify(manduServer);
+
+      if (isSame) {
+        return { status: "unchanged" };
+      }
+
+      (existing.mcpServers as Record<string, unknown>).mandu = manduServer;
+      await writeConfig(existing);
+      return { status: "updated" };
+    } catch (error) {
+      if (error && typeof error === "object" && "code" in error && (error as { code?: string }).code === "ENOENT") {
+        await writeConfig({ mcpServers: { mandu: manduServer } });
+        return { status: "created" };
+      }
+      return {
+        status: "error",
+        error: error instanceof Error ? error.message : String(error),
+      };
+    }
+  };
+
+  const mcpJson = await updateMcpFile(mcpPath);
+  const claudeJson = await updateMcpFile(claudePath);
+
+  return { mcpJson, claudeJson };
+}
 
 interface LockfileResult {
   success: boolean;

package/src/commands/registry.ts

@@ -347,10 +347,10 @@ registerCommand({
   },
 });
 
-// 레거시 명령어
+// 레거시 명령어 (DEPRECATED)
 registerCommand({
   id: "spec-upsert",
-  description: "Spec 파일 검증 및 lock 갱신 (레거시)",
+  description: "[DEPRECATED] Spec 파일 검증 및 lock 갱신 → routes generate 사용",
   async run(ctx) {
     const { specUpsert } = await import("./spec-upsert");
     return specUpsert({ file: ctx.options.file });
@@ -359,7 +359,7 @@ registerCommand({
 
 registerCommand({
   id: "generate",
-  description: "Spec에서 코드 생성 (레거시)",
+  description: "FS Routes 기반 코드 생성",
   async run() {
     const { generateApply } = await import("./generate-apply");
     return generateApply();

package/src/commands/routes.ts

@@ -55,8 +55,7 @@ export async function routesGenerate(options: RoutesGenerateOptions = {}): Promi
   try {
     const generateOptions: GenerateOptions = {
       scanner: config.fsRoutes,
-      outputPath: options.output ?? ".mandu/routes.manifest.json",
-      skipLegacy: true, // 레거시 병합 비활성화
+      outputPath: options.output,
     };
 
     const result = await generateManifest(rootDir, generateOptions);

package/src/commands/spec-upsert.ts

@@ -7,9 +7,13 @@ export interface SpecUpsertOptions {
 }
 
 export async function specUpsert(options: SpecUpsertOptions): Promise<boolean> {
+  console.warn("⚠️  DEPRECATED: spec-upsert는 더 이상 필요하지 않습니다.");
+  console.warn("   FS Routes(app/)가 유일한 라우트 소스입니다.");
+  console.warn("   대신 'bunx mandu routes generate'를 사용하세요.\n");
+
   const specPath = options.file
     ? resolveFromCwd(options.file)
-    : resolveFromCwd("spec/routes.manifest.json");
+    : resolveFromCwd(".mandu/routes.manifest.json");
 
   console.log(`🥟 Mandu Spec Upsert`);
   console.log(`📄 Spec 파일: ${specPath}\n`);
@@ -31,7 +35,7 @@ export async function specUpsert(options: SpecUpsertOptions): Promise<boolean> {
     console.log(`   ${kindIcon} ${route.id}: ${route.pattern} (${route.kind})`);
   }
 
-  const lockPath = resolveFromCwd("spec/spec.lock.json");
+  const lockPath = resolveFromCwd(".mandu/spec.lock.json");
   const previousLock = await readLock(lockPath);
   const newLock = await writeLock(lockPath, result.data);
 

package/src/util/manifest.ts

@@ -7,7 +7,7 @@ import {
 } from "@mandujs/core";
 import { isDirectory } from "./fs";
 
-export type ManifestSource = "fs" | "spec";
+export type ManifestSource = "fs";
 
 export interface ResolvedManifest {
   manifest: RoutesManifest;
@@ -22,31 +22,17 @@ export async function resolveManifest(
   const appDir = path.resolve(rootDir, "app");
   const hasApp = await isDirectory(appDir);
 
-  if (hasApp) {
-    const result = await generateManifest(rootDir, {
-      scanner: options.fsRoutes,
-      outputPath: options.outputPath,
-      skipLegacy: true,
-    });
-    return {
-      manifest: result.manifest,
-      source: "fs",
-      warnings: result.warnings,
-    };
+  if (!hasApp) {
+    throw new Error("No app/ directory found. Create app/ routes to get started.");
   }
 
-  const specPath = path.join(rootDir, "spec", "routes.manifest.json");
-  if (await Bun.file(specPath).exists()) {
-    const result = await loadManifest(specPath);
-    if (!result.success) {
-      throw new Error(result.errors?.join(", ") || "Failed to load routes manifest");
-    }
-    return {
-      manifest: result.data!,
-      source: "spec",
-      warnings: [],
-    };
-  }
-
-  throw new Error("No routes found. Create app/ routes or spec/routes.manifest.json");
+  const result = await generateManifest(rootDir, {
+    scanner: options.fsRoutes,
+    outputPath: options.outputPath,
+  });
+  return {
+    manifest: result.manifest,
+    source: "fs",
+    warnings: result.warnings,
+  };
 }