@mandujs/cli 0.9.12 → 0.9.18

package/src/commands/dev.ts

@@ -1,28 +1,44 @@
 import {
-  loadManifest,
   startServer,
   registerApiHandler,
   registerPageLoader,
   registerPageHandler,
+  registerLayoutLoader,
   startDevBundler,
   createHMRServer,
   needsHydration,
   loadEnv,
+  generateManifest,
+  watchFSRoutes,
+  clearDefaultRegistry,
+  createGuardWatcher,
+  getPreset,
+  type RoutesManifest,
+  type GuardConfig,
+  type GuardPreset,
 } from "@mandujs/core";
-import { resolveFromCwd } from "../util/fs";
+import { isDirectory, resolveFromCwd } from "../util/fs";
+import { resolveOutputFormat, type OutputFormat } from "../util/output";
 import path from "path";
 
-export interface DevOptions {
-  port?: number;
-  /** HMR 비활성화 */
-  noHmr?: boolean;
-}
+export interface DevOptions {
+  port?: number;
+  /** HMR 비활성화 */
+  noHmr?: boolean;
+  /** FS Routes 비활성화 (레거시 모드) */
+  legacy?: boolean;
+  /** Architecture Guard 활성화 */
+  guard?: boolean;
+  /** Guard 프리셋 */
+  guardPreset?: GuardPreset;
+  /** Guard 출력 형식 */
+  guardFormat?: OutputFormat;
+}
 
 export async function dev(options: DevOptions = {}): Promise<void> {
-  const specPath = resolveFromCwd("spec/routes.manifest.json");
   const rootDir = resolveFromCwd(".");
 
-  console.log(`🥟 Mandu Dev Server`);
+  console.log(`🥟 Mandu Dev Server (FS Routes)`);
 
   // .env 파일 로드
   const envResult = await loadEnv({
@@ -34,50 +50,93 @@ export async function dev(options: DevOptions = {}): Promise<void> {
     console.log(`🔐 환경 변수 로드: ${envResult.loaded.join(", ")}`);
   }
 
-  console.log(`📄 Spec 파일: ${specPath}\n`);
+  // FS Routes 스캔
+  console.log(`📂 app/ 폴더 스캔 중...`);
 
-  const result = await loadManifest(specPath);
+  const result = await generateManifest(rootDir, {
+    skipLegacy: true,
+  });
 
-  if (!result.success || !result.data) {
-    console.error("❌ Spec 로드 실패:");
-    result.errors?.forEach((e) => console.error(`  - ${e}`));
+  if (result.manifest.routes.length === 0) {
+    console.log("");
+    console.log("📭 라우트가 없습니다.");
+    console.log("");
+    console.log("💡 app/ 폴더에 page.tsx 파일을 생성하세요:");
+    console.log("");
+    console.log("  app/page.tsx        → /");
+    console.log("  app/blog/page.tsx   → /blog");
+    console.log("  app/api/users/route.ts → /api/users");
+    console.log("");
     process.exit(1);
   }
 
-  const manifest = result.data;
-  console.log(`✅ Spec 로드 완료: ${manifest.routes.length}개 라우트`);
-
-  // 핸들러 등록
-  for (const route of manifest.routes) {
-    if (route.kind === "api") {
-      const modulePath = path.resolve(rootDir, route.module);
-      try {
-        const module = await import(modulePath);
-        registerApiHandler(route.id, module.default || module.handler);
-        console.log(`  📡 API: ${route.pattern} -> ${route.id}`);
-      } catch (error) {
-        console.error(`  ❌ API 핸들러 로드 실패: ${route.id}`, error);
-      }
-    } else if (route.kind === "page" && route.componentModule) {
-      const componentPath = path.resolve(rootDir, route.componentModule);
-      const isIsland = needsHydration(route);
-
-      // slotModule이 있으면 PageHandler 사용 (filling.loader 지원)
-      if (route.slotModule) {
-        registerPageHandler(route.id, async () => {
-          const module = await import(componentPath);
-          // module.default = { component, filling }
-          return module.default;
-        });
-        console.log(`  📄 Page: ${route.pattern} -> ${route.id} (with loader)${isIsland ? " 🏝️" : ""}`);
-      } else {
-        // slotModule이 없으면 기존 PageLoader 사용
-        registerPageLoader(route.id, () => import(componentPath));
-        console.log(`  📄 Page: ${route.pattern} -> ${route.id}${isIsland ? " 🏝️" : ""}`);
+  let manifest = result.manifest;
+  console.log(`✅ ${manifest.routes.length}개 라우트 발견\n`);
+
+  // Layout 경로 추적 (중복 등록 방지)
+  const registeredLayouts = new Set<string>();
+
+  // 핸들러 등록 함수
+  const registerHandlers = async (manifest: RoutesManifest, isReload = false) => {
+    // 리로드 시 레이아웃 캐시 클리어
+    if (isReload) {
+      registeredLayouts.clear();
+    }
+
+    for (const route of manifest.routes) {
+      if (route.kind === "api") {
+        const modulePath = path.resolve(rootDir, route.module);
+        try {
+          // 캐시 무효화 (HMR용)
+          delete require.cache[modulePath];
+          const module = await import(modulePath);
+          registerApiHandler(route.id, module.default || module.handler || module);
+          console.log(`  📡 API: ${route.pattern} -> ${route.id}`);
+        } catch (error) {
+          console.error(`  ❌ API 핸들러 로드 실패: ${route.id}`, error);
+        }
+      } else if (route.kind === "page" && route.componentModule) {
+        const componentPath = path.resolve(rootDir, route.componentModule);
+        const isIsland = needsHydration(route);
+        const hasLayout = route.layoutChain && route.layoutChain.length > 0;
+
+        // Layout 로더 등록
+        if (route.layoutChain) {
+          for (const layoutPath of route.layoutChain) {
+            if (!registeredLayouts.has(layoutPath)) {
+              const absLayoutPath = path.resolve(rootDir, layoutPath);
+              registerLayoutLoader(layoutPath, async () => {
+                // 캐시 무효화 (HMR용)
+                delete require.cache[absLayoutPath];
+                return import(absLayoutPath);
+              });
+              registeredLayouts.add(layoutPath);
+              console.log(`  🎨 Layout: ${layoutPath}`);
+            }
+          }
+        }
+
+        // slotModule이 있으면 PageHandler 사용 (filling.loader 지원)
+        if (route.slotModule) {
+          registerPageHandler(route.id, async () => {
+            delete require.cache[componentPath];
+            const module = await import(componentPath);
+            return module.default;
+          });
+          console.log(`  📄 Page: ${route.pattern} -> ${route.id} (with loader)${isIsland ? " 🏝️" : ""}${hasLayout ? " 🎨" : ""}`);
+        } else {
+          registerPageLoader(route.id, () => {
+            delete require.cache[componentPath];
+            return import(componentPath);
+          });
+          console.log(`  📄 Page: ${route.pattern} -> ${route.id}${isIsland ? " 🏝️" : ""}${hasLayout ? " 🎨" : ""}`);
+        }
       }
     }
-  }
+  };
 
+  // 초기 핸들러 등록
+  await registerHandlers(manifest);
   console.log("");
 
   const port = options.port || Number(process.env.PORT) || 3000;
@@ -98,28 +157,28 @@ export async function dev(options: DevOptions = {}): Promise<void> {
     devBundler = await startDevBundler({
       rootDir,
       manifest,
-      onRebuild: (result) => {
-        if (result.success) {
-          if (result.routeId === "*") {
-            hmrServer?.broadcast({
-              type: "reload",
-              data: {
-                timestamp: Date.now(),
-              },
-            });
-          } else {
-            hmrServer?.broadcast({
-              type: "island-update",
-              data: {
-                routeId: result.routeId,
-                timestamp: Date.now(),
-              },
-            });
-          }
-        } else {
-          hmrServer?.broadcast({
-            type: "error",
-            data: {
+      onRebuild: (result) => {
+        if (result.success) {
+          if (result.routeId === "*") {
+            hmrServer?.broadcast({
+              type: "reload",
+              data: {
+                timestamp: Date.now(),
+              },
+            });
+          } else {
+            hmrServer?.broadcast({
+              type: "island-update",
+              data: {
+                routeId: result.routeId,
+                timestamp: Date.now(),
+              },
+            });
+          }
+        } else {
+          hmrServer?.broadcast({
+            type: "error",
+            data: {
               routeId: result.routeId,
               message: result.error,
             },
@@ -147,12 +206,90 @@ export async function dev(options: DevOptions = {}): Promise<void> {
     bundleManifest: devBundler?.initialBuild.manifest,
   });
 
+  // Architecture Guard 실시간 감시 (선택적)
+  let archGuardWatcher: ReturnType<typeof createGuardWatcher> | null = null;
+
+  if (options.guard !== false) {
+    const guardPreset = options.guardPreset || "mandu";
+    const guardFormat = resolveOutputFormat(options.guardFormat);
+    const enableFsRoutes = !options.legacy && await isDirectory(path.resolve(rootDir, "app"));
+    const guardConfig: GuardConfig = {
+      preset: guardPreset,
+      srcDir: "src",
+      realtime: true,
+      realtimeOutput: guardFormat,
+      fsRoutes: enableFsRoutes
+        ? {
+            noPageToPage: true,
+            pageCanImport: ["widgets", "features", "entities", "shared"],
+            layoutCanImport: ["widgets", "shared"],
+          }
+        : undefined,
+    };
+
+    console.log(`🛡️  Architecture Guard 활성화 (${guardPreset})`);
+
+    archGuardWatcher = createGuardWatcher({
+      config: guardConfig,
+      rootDir,
+      onViolation: (violation) => {
+        // 실시간 경고는 watcher 내부에서 처리
+      },
+      onFileAnalyzed: (analysis, violations) => {
+        if (violations.length > 0) {
+          // HMR 에러로 브로드캐스트
+          hmrServer?.broadcast({
+            type: "guard-violation",
+            data: {
+              file: analysis.filePath,
+              violations: violations.map((v) => ({
+                line: v.line,
+                message: `${v.fromLayer} → ${v.toLayer}: ${v.ruleDescription}`,
+              })),
+            },
+          });
+        }
+      },
+    });
+
+    archGuardWatcher.start();
+  }
+
+  // FS Routes 실시간 감시
+  const routesWatcher = await watchFSRoutes(rootDir, {
+    skipLegacy: true,
+    onChange: async (result) => {
+      const timestamp = new Date().toLocaleTimeString();
+      console.log(`\n🔄 [${timestamp}] 라우트 변경 감지`);
+
+      // 레지스트리 클리어 (layout 캐시 포함)
+      clearDefaultRegistry();
+
+      // 새 매니페스트로 서버 업데이트
+      manifest = result.manifest;
+      console.log(`   📋 라우트: ${manifest.routes.length}개`);
+
+      // 라우트 재등록 (isReload = true)
+      await registerHandlers(manifest, true);
+
+      // HMR 브로드캐스트 (전체 리로드)
+      if (hmrServer) {
+        hmrServer.broadcast({
+          type: "reload",
+          data: { timestamp: Date.now() },
+        });
+      }
+    },
+  });
+
   // 정리 함수
   const cleanup = () => {
     console.log("\n🛑 서버 종료 중...");
     server.stop();
     devBundler?.close();
     hmrServer?.close();
+    routesWatcher.close();
+    archGuardWatcher?.close();
     process.exit(0);
   };
 

package/src/commands/doctor.ts

@@ -10,7 +10,7 @@ import {
   runGuardCheck,
   analyzeViolations,
   printDoctorReport,
-  generateMarkdownReport,
+  generateDoctorMarkdownReport,
   initializeBrain,
   getBrain,
 } from "../../../core/src/index";
@@ -108,7 +108,7 @@ export async function doctor(options: DoctorOptions = {}): Promise<boolean> {
     }
 
     case "markdown": {
-      const md = generateMarkdownReport(analysis);
+      const md = generateDoctorMarkdownReport(analysis);
 
       if (output) {
         await fs.writeFile(output, md, "utf-8");

package/src/commands/guard-arch.ts

@@ -0,0 +1,256 @@
+/**
+ * mandu guard arch - Architecture Guard Command
+ *
+ * 실시간 아키텍처 감시 및 일회성 검사
+ */
+
+import {
+  createGuardWatcher,
+  checkDirectory,
+  printReport,
+  formatReportForAgent,
+  formatReportAsAgentJSON,
+  getPreset,
+  listPresets,
+  createScanRecord,
+  addScanRecord,
+  loadStatistics,
+  analyzeTrend,
+  calculateLayerStatistics,
+  generateGuardMarkdownReport,
+  generateHTMLReport,
+  type GuardConfig,
+  type GuardPreset,
+} from "@mandujs/core";
+import { writeFile } from "fs/promises";
+import { isDirectory, resolveFromCwd } from "../util/fs";
+import { resolveOutputFormat, type OutputFormat } from "../util/output";
+import path from "path";
+
+export interface GuardArchOptions {
+  /** 프리셋 이름 */
+  preset?: GuardPreset;
+  /** 실시간 감시 모드 */
+  watch?: boolean;
+  /** CI 모드 (에러 시 exit 1) */
+  ci?: boolean;
+  /** 출력 형식: console, agent, json */
+  format?: OutputFormat;
+  /** 조용히 (요약만 출력) */
+  quiet?: boolean;
+  /** 소스 디렉토리 */
+  srcDir?: string;
+  /** 프리셋 목록 출력 */
+  listPresets?: boolean;
+  /** 리포트 파일 출력 */
+  output?: string;
+  /** 리포트 형식: json, markdown, html */
+  reportFormat?: "json" | "markdown" | "html";
+  /** 통계 저장 (트렌드 분석용) */
+  saveStats?: boolean;
+  /** 트렌드 분석 표시 */
+  showTrend?: boolean;
+}
+
+export async function guardArch(options: GuardArchOptions = {}): Promise<boolean> {
+  const {
+    preset = "mandu",
+    watch = false,
+    ci = false,
+    format,
+    quiet = false,
+    srcDir = "src",
+    listPresets: showPresets = false,
+    output,
+    reportFormat = "markdown",
+    saveStats = false,
+    showTrend = false,
+  } = options;
+
+  const rootDir = resolveFromCwd(".");
+  const resolvedFormat = resolveOutputFormat(format);
+  const enableFsRoutes = await isDirectory(path.resolve(rootDir, "app"));
+
+  // 프리셋 목록 출력
+  if (showPresets) {
+    console.log("");
+    console.log("🛡️  Mandu Guard - Available Presets");
+    console.log("");
+
+    const presets = listPresets();
+    for (const p of presets) {
+      const presetDef = getPreset(p.name);
+      console.log(`  ${p.name === "fsd" ? "✨ " : "  "}${p.name}`);
+      console.log(`     ${p.description}`);
+      console.log(`     Layers: ${presetDef.hierarchy.join(" → ")}`);
+      console.log("");
+    }
+
+    console.log("Usage: bunx mandu guard arch --preset <name>");
+    return true;
+  }
+
+  if (resolvedFormat === "console") {
+    console.log("");
+    console.log("🛡️  Mandu Guard - Architecture Checker");
+    console.log("");
+    console.log(`📋 Preset: ${preset}`);
+    console.log(`📂 Source: ${srcDir}/`);
+    console.log(`🔧 Mode: ${watch ? "Watch" : "Check"}`);
+    console.log("");
+  }
+
+  // Guard 설정
+  const config: GuardConfig = {
+    preset,
+    srcDir,
+    realtime: watch,
+    realtimeOutput: resolvedFormat,
+    fsRoutes: enableFsRoutes
+      ? {
+          noPageToPage: true,
+          pageCanImport: ["widgets", "features", "entities", "shared"],
+          layoutCanImport: ["widgets", "shared"],
+        }
+      : undefined,
+  };
+
+  // 실시간 감시 모드
+  if (watch) {
+    if (resolvedFormat === "console") {
+      console.log("👁️  Watching for architecture violations...");
+      console.log("   Press Ctrl+C to stop\n");
+    }
+
+    const watcher = createGuardWatcher({
+      config,
+      rootDir,
+      onViolation: (violation) => {
+        // 실시간 위반 출력은 watcher 내부에서 처리됨
+      },
+      onFileAnalyzed: (analysis, violations) => {
+        if (resolvedFormat === "console" && violations.length > 0 && !quiet) {
+          const timestamp = new Date().toLocaleTimeString();
+          console.log(`[${timestamp}] ${analysis.filePath}: ${violations.length} violation(s)`);
+        }
+      },
+    });
+
+    watcher.start();
+
+    // Ctrl+C 핸들링
+    process.on("SIGINT", () => {
+      console.log("\n🛑 Guard stopped");
+      watcher.close();
+      process.exit(0);
+    });
+
+    // 계속 실행
+    return new Promise(() => {});
+  }
+
+  // 일회성 검사 모드
+  if (resolvedFormat === "console" && !quiet) {
+    console.log("🔍 Scanning for architecture violations...\n");
+  }
+
+  const report = await checkDirectory(config, rootDir);
+  const presetDef = getPreset(preset);
+
+  // 출력 형식에 따른 리포트 출력
+  switch (resolvedFormat) {
+    case "json":
+      console.log(formatReportAsAgentJSON(report, preset));
+      break;
+
+    case "agent":
+      console.log(formatReportForAgent(report, preset));
+      break;
+
+    case "console":
+    default:
+      if (quiet) {
+        // 요약만 출력
+        console.log(`Files analyzed: ${report.filesAnalyzed}`);
+        console.log(`Violations: ${report.totalViolations}`);
+        console.log(`  Errors: ${report.bySeverity.error}`);
+        console.log(`  Warnings: ${report.bySeverity.warn}`);
+        console.log(`  Info: ${report.bySeverity.info}`);
+      } else {
+        printReport(report, presetDef.hierarchy);
+      }
+      break;
+  }
+
+  // 통계 저장
+  if (saveStats) {
+    const scanRecord = createScanRecord(report, preset);
+    await addScanRecord(rootDir, scanRecord);
+    console.log("📊 Statistics saved to .mandu/guard-stats.json");
+  }
+
+  // 트렌드 분석
+  let trend = null;
+  let layerStats = null;
+
+  if (showTrend) {
+    const store = await loadStatistics(rootDir);
+    trend = analyzeTrend(store.records, 7);
+    layerStats = calculateLayerStatistics(report.violations, presetDef.hierarchy);
+
+    if (trend) {
+      console.log("");
+      console.log("📈 Trend Analysis (7 days):");
+      const trendEmoji = trend.trend === "improving" ? "📉" : trend.trend === "degrading" ? "📈" : "➡️";
+      console.log(`   Status: ${trendEmoji} ${trend.trend.toUpperCase()}`);
+      console.log(`   Change: ${trend.violationDelta >= 0 ? "+" : ""}${trend.violationDelta} (${trend.violationChangePercent >= 0 ? "+" : ""}${trend.violationChangePercent}%)`);
+
+      if (trend.recommendations.length > 0) {
+        console.log("   💡 Recommendations:");
+        for (const rec of trend.recommendations) {
+          console.log(`      - ${rec}`);
+        }
+      }
+    }
+  }
+
+  // 리포트 파일 출력
+  if (output) {
+    let reportContent: string;
+
+    switch (reportFormat) {
+      case "json":
+        reportContent = formatReportAsAgentJSON(report, preset);
+        break;
+      case "html":
+        reportContent = generateHTMLReport(report, trend, layerStats ?? undefined);
+        break;
+      case "markdown":
+      default:
+        reportContent = generateGuardMarkdownReport(report, trend, layerStats ?? undefined);
+        break;
+    }
+
+    await writeFile(output, reportContent);
+    console.log(`\n📄 Report saved to ${output}`);
+  }
+
+  // CI 모드에서 에러가 있으면 실패
+  if (ci && report.bySeverity.error > 0) {
+    console.log("\n❌ Architecture check failed");
+    return false;
+  }
+
+  if (report.totalViolations === 0) {
+    console.log("\n✅ Architecture check passed");
+    return true;
+  }
+
+  if (report.bySeverity.error > 0) {
+    console.log(`\n⚠️  ${report.bySeverity.error} error(s) found - please fix before continuing`);
+    return !ci;
+  }
+
+  console.log(`\n⚠️  ${report.totalViolations} issue(s) found`);
+  return true;
+}