@mandujs/cli 0.9.21 → 0.9.23

package/src/commands/init.ts

@@ -1,30 +1,137 @@
 import path from "path";
 import fs from "fs/promises";
 
+export type CSSFramework = "tailwind" | "panda" | "none";
+export type UILibrary = "shadcn" | "ark" | "none";
+
 export interface InitOptions {
   name?: string;
   template?: string;
+  css?: CSSFramework;
+  ui?: UILibrary;
+  theme?: boolean;
+  minimal?: boolean;
+}
+
+// Files to skip based on CSS/UI options
+const CSS_FILES = [
+  "tailwind.config.ts",
+  "postcss.config.js",
+  "app/globals.css",
+];
+
+const UI_FILES = [
+  "src/client/shared/ui/button.tsx",
+  "src/client/shared/ui/card.tsx",
+  "src/client/shared/ui/input.tsx",
+  "src/client/shared/ui/index.ts",
+  "src/client/shared/lib/utils.ts",
+];
+
+interface CopyOptions {
+  projectName: string;
+  css: CSSFramework;
+  ui: UILibrary;
+  theme: boolean;
+}
+
+function shouldSkipFile(relativePath: string, options: CopyOptions): boolean {
+  const normalizedPath = relativePath.replace(/\\/g, "/");
+
+  // Skip CSS files if css is none
+  if (options.css === "none") {
+    if (CSS_FILES.some((f) => normalizedPath.endsWith(f))) {
+      return true;
+    }
+  }
+
+  // Skip UI files if ui is none
+  if (options.ui === "none") {
+    if (UI_FILES.some((f) => normalizedPath.endsWith(f))) {
+      return true;
+    }
+    // Skip UI/shared directories
+    if (normalizedPath.includes("src/client/shared/ui/")) return true;
+    if (normalizedPath.includes("src/client/shared/lib/")) return true;
+  }
+
+  return false;
 }
 
-async function copyDir(src: string, dest: string, projectName: string): Promise<void> {
+async function copyDir(
+  src: string,
+  dest: string,
+  options: CopyOptions,
+  relativePath = ""
+): Promise<void> {
   await fs.mkdir(dest, { recursive: true });
   const entries = await fs.readdir(src, { withFileTypes: true });
 
   for (const entry of entries) {
     const srcPath = path.join(src, entry.name);
     const destPath = path.join(dest, entry.name);
+    const currentRelativePath = relativePath
+      ? `${relativePath}/${entry.name}`
+      : entry.name;
 
     if (entry.isDirectory()) {
-      await copyDir(srcPath, destPath, projectName);
-    } else {
+      // Skip directories that would be empty when ui=none
+      if (options.ui === "none") {
+        if (entry.name === "ui" && relativePath === "src/client/shared") continue;
+        if (entry.name === "lib" && relativePath === "src/client/shared") continue;
+      }
+      await copyDir(srcPath, destPath, options, currentRelativePath);
+    } else {
+      // Check if file should be skipped
+      if (shouldSkipFile(currentRelativePath, options)) {
+        continue;
+      }
+
       let content = await fs.readFile(srcPath, "utf-8");
       // Replace template variables
-      content = content.replace(/\{\{PROJECT_NAME\}\}/g, projectName);
+      content = content.replace(/\{\{PROJECT_NAME\}\}/g, options.projectName);
+
+      // Add dark mode CSS variables if theme is enabled
+      if (options.theme && currentRelativePath === "app/globals.css") {
+        content = addDarkModeCSS(content);
+      }
+
       await fs.writeFile(destPath, content);
     }
   }
 }
 
+function addDarkModeCSS(content: string): string {
+  const darkModeCSS = `
+  .dark {
+    --background: 222.2 84% 4.9%;
+    --foreground: 210 40% 98%;
+    --card: 222.2 84% 4.9%;
+    --card-foreground: 210 40% 98%;
+    --popover: 222.2 84% 4.9%;
+    --popover-foreground: 210 40% 98%;
+    --primary: 210 40% 98%;
+    --primary-foreground: 222.2 47.4% 11.2%;
+    --secondary: 217.2 32.6% 17.5%;
+    --secondary-foreground: 210 40% 98%;
+    --muted: 217.2 32.6% 17.5%;
+    --muted-foreground: 215 20.2% 65.1%;
+    --accent: 217.2 32.6% 17.5%;
+    --accent-foreground: 210 40% 98%;
+    --destructive: 0 62.8% 30.6%;
+    --destructive-foreground: 210 40% 98%;
+    --border: 217.2 32.6% 17.5%;
+    --input: 217.2 32.6% 17.5%;
+    --ring: 212.7 26.8% 83.9%;
+  }`;
+
+  // Insert dark mode after :root block
+  return content.replace(
+    /(:root\s*\{[^}]+\})/,
+    `$1\n${darkModeCSS}`
+  );
+}
+
 function getTemplatesDir(): string {
   // When installed via npm, templates are in the CLI package
   const commandsDir = import.meta.dir;
@@ -37,9 +144,20 @@ export async function init(options: InitOptions = {}): Promise<boolean> {
   const template = options.template || "default";
   const targetDir = path.resolve(process.cwd(), projectName);
 
+  // Handle minimal flag (shortcut for --css none --ui none)
+  const css: CSSFramework = options.minimal ? "none" : (options.css || "tailwind");
+  const ui: UILibrary = options.minimal ? "none" : (options.ui || "shadcn");
+  const theme = options.theme || false;
+
   console.log(`🥟 Mandu Init`);
   console.log(`📁 프로젝트: ${projectName}`);
-  console.log(`📦 템플릿: ${template}\n`);
+  console.log(`📦 템플릿: ${template}`);
+  console.log(`🎨 CSS: ${css}${css !== "none" ? " (Tailwind CSS)" : ""}`);
+  console.log(`🧩 UI: ${ui}${ui !== "none" ? " (shadcn/ui)" : ""}`);
+  if (theme) {
+    console.log(`🌙 테마: Dark mode 지원`);
+  }
+  console.log();
 
   // Check if target directory exists
   try {
@@ -64,8 +182,15 @@ export async function init(options: InitOptions = {}): Promise<boolean> {
 
   console.log(`📋 템플릿 복사 중...`);
 
+  const copyOptions: CopyOptions = {
+    projectName,
+    css,
+    ui,
+    theme,
+  };
+
   try {
-    await copyDir(templateDir, targetDir, projectName);
+    await copyDir(templateDir, targetDir, copyOptions);
   } catch (error) {
     console.error(`❌ 템플릿 복사 실패:`, error);
     return false;
@@ -74,15 +199,145 @@ export async function init(options: InitOptions = {}): Promise<boolean> {
   // Create .mandu directory for build output
   await fs.mkdir(path.join(targetDir, ".mandu/client"), { recursive: true });
 
+  // Create minimal layout.tsx if css=none (without globals.css import)
+  if (css === "none") {
+    await createMinimalLayout(targetDir, projectName);
+  }
+
+  // Create minimal page.tsx if ui=none (without UI components)
+  if (ui === "none") {
+    await createMinimalPage(targetDir);
+  }
+
+  // Update package.json to remove unused dependencies
+  if (css === "none" || ui === "none") {
+    await updatePackageJson(targetDir, css, ui);
+  }
+
   console.log(`\n✅ 프로젝트 생성 완료!\n`);
   console.log(`📍 위치: ${targetDir}`);
   console.log(`\n🚀 시작하기:`);
   console.log(`   cd ${projectName}`);
   console.log(`   bun install`);
   console.log(`   bun run dev`);
-  console.log(`\n📂 파일 구조:`);
-  console.log(`   app/page.tsx      → http://localhost:3000/`);
-  console.log(`   app/api/*/route.ts → API endpoints`);
+  console.log(`\n📂 파일 구조:`);
+  console.log(`   app/layout.tsx    → 루트 레이아웃`);
+  console.log(`   app/page.tsx      → http://localhost:3000/`);
+  console.log(`   app/api/*/route.ts → API endpoints`);
+  console.log(`   src/client/*      → 클라이언트 레이어`);
+  console.log(`   src/server/*      → 서버 레이어`);
+  console.log(`   src/shared/contracts → 계약 (client-safe)`);
+  console.log(`   src/shared/types     → 공용 타입`);
+  console.log(`   src/shared/utils/client → 클라이언트 safe 유틸`);
+  console.log(`   src/shared/utils/server → 서버 전용 유틸`);
+  console.log(`   src/shared/schema    → 서버 전용 스키마`);
+  console.log(`   src/shared/env       → 서버 전용 환경`);
+  if (css !== "none") {
+    console.log(`   app/globals.css   → 전역 CSS (Tailwind)`);
+    console.log(`   tailwind.config.ts → Tailwind 설정`);
+  }
+  if (ui !== "none") {
+    console.log(`   src/client/shared/ui/ → UI 컴포넌트 (shadcn)`);
+    console.log(`   src/client/shared/lib/utils.ts → 유틸리티 (cn 함수)`);
+  }
 
   return true;
 }
+
+async function createMinimalLayout(targetDir: string, projectName: string): Promise<void> {
+  const layoutContent = `/**
+ * Root Layout (Minimal)
+ */
+
+interface RootLayoutProps {
+  children: React.ReactNode;
+}
+
+export default function RootLayout({ children }: RootLayoutProps) {
+  return (
+    <html lang="ko">
+      <head>
+        <meta charSet="UTF-8" />
+        <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+        <title>${projectName}</title>
+      </head>
+      <body>
+        {children}
+      </body>
+    </html>
+  );
+}
+`;
+  await fs.writeFile(path.join(targetDir, "app/layout.tsx"), layoutContent);
+}
+
+async function createMinimalPage(targetDir: string): Promise<void> {
+  const pageContent = `/**
+ * Home Page (Minimal)
+ *
+ * Edit this file and see changes at http://localhost:3000
+ */
+
+export default function HomePage() {
+  return (
+    <main style={{
+      display: "flex",
+      minHeight: "100vh",
+      flexDirection: "column",
+      alignItems: "center",
+      justifyContent: "center",
+      background: "linear-gradient(135deg, #667eea 0%, #764ba2 100%)",
+      padding: "2rem",
+    }}>
+      <div style={{
+        textAlign: "center",
+        color: "white",
+      }}>
+        <h1 style={{ fontSize: "3rem", marginBottom: "1rem" }}>🥟 Mandu</h1>
+        <p style={{ fontSize: "1.2rem", opacity: 0.9 }}>
+          Welcome to your new Mandu project!
+        </p>
+        <p style={{ fontSize: "1rem", opacity: 0.8, marginTop: "0.5rem" }}>
+          Edit <code style={{
+            background: "rgba(255,255,255,0.2)",
+            padding: "0.2rem 0.5rem",
+            borderRadius: "4px",
+          }}>app/page.tsx</code> to get started.
+        </p>
+        <p style={{ marginTop: "1rem" }}>
+          <a href="/api/health" style={{ color: "white" }}>API Health →</a>
+        </p>
+      </div>
+    </main>
+  );
+}
+`;
+  await fs.writeFile(path.join(targetDir, "app/page.tsx"), pageContent);
+}
+
+async function updatePackageJson(
+  targetDir: string,
+  css: CSSFramework,
+  ui: UILibrary
+): Promise<void> {
+  const pkgPath = path.join(targetDir, "package.json");
+  const content = await fs.readFile(pkgPath, "utf-8");
+  const pkg = JSON.parse(content);
+
+  if (css === "none") {
+    // Remove Tailwind dependencies
+    delete pkg.devDependencies?.tailwindcss;
+    delete pkg.devDependencies?.postcss;
+    delete pkg.devDependencies?.autoprefixer;
+  }
+
+  if (ui === "none") {
+    // Remove UI library dependencies
+    delete pkg.dependencies?.["@radix-ui/react-slot"];
+    delete pkg.dependencies?.["class-variance-authority"];
+    delete pkg.dependencies?.clsx;
+    delete pkg.dependencies?.["tailwind-merge"];
+  }
+
+  await fs.writeFile(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
+}

package/src/commands/monitor.ts

@@ -0,0 +1,301 @@
+import fs from "fs/promises";
+import fsSync from "fs";
+import path from "path";
+import { resolveFromCwd, pathExists } from "../util/fs";
+import { resolveOutputFormat, type OutputFormat } from "../util/output";
+
+type MonitorOutput = "console" | "json";
+
+export interface MonitorOptions {
+  format?: OutputFormat;
+  follow?: boolean;
+  summary?: boolean;
+  since?: string;
+  file?: string;
+}
+
+interface MonitorEvent {
+  ts?: string;
+  type?: string;
+  severity?: "info" | "warn" | "error";
+  source?: string;
+  message?: string;
+  data?: Record<string, unknown>;
+  count?: number;
+}
+
+function parseDuration(value?: string): number | undefined {
+  if (!value) return undefined;
+  const trimmed = value.trim();
+  const match = trimmed.match(/^(\d+)(ms|s|m|h|d)?$/);
+  if (!match) return undefined;
+  const amount = Number(match[1]);
+  const unit = match[2] ?? "m";
+  switch (unit) {
+    case "ms":
+      return amount;
+    case "s":
+      return amount * 1000;
+    case "m":
+      return amount * 60 * 1000;
+    case "h":
+      return amount * 60 * 60 * 1000;
+    case "d":
+      return amount * 24 * 60 * 60 * 1000;
+    default:
+      return undefined;
+  }
+}
+
+function formatTime(ts?: string): string {
+  const date = ts ? new Date(ts) : new Date();
+  return date.toLocaleTimeString("ko-KR", { hour12: false });
+}
+
+function formatEventForConsole(event: MonitorEvent): string {
+  const time = formatTime(event.ts);
+  const countSuffix = event.count && event.count > 1 ? ` x${event.count}` : "";
+  const type = event.type ?? "event";
+
+  if (type === "tool.call") {
+    const tag = (event.data?.tag as string | undefined) ?? "TOOL";
+    const argsSummary = event.data?.argsSummary as string | undefined;
+    return `${time} → [${tag}]${argsSummary ?? ""}${countSuffix}`;
+  }
+  if (type === "tool.error") {
+    const tag = (event.data?.tag as string | undefined) ?? "TOOL";
+    const argsSummary = event.data?.argsSummary as string | undefined;
+    const message = event.message ?? "ERROR";
+    return `${time} ✗ [${tag}]${argsSummary ?? ""}${countSuffix}\n       ${message}`;
+  }
+  if (type === "tool.result") {
+    const tag = (event.data?.tag as string | undefined) ?? "TOOL";
+    const summary = event.data?.summary as string | undefined;
+    return `${time} ✓ [${tag}]${summary ?? ""}${countSuffix}`;
+  }
+  if (type === "watch.warning") {
+    const ruleId = event.data?.ruleId as string | undefined;
+    const file = event.data?.file as string | undefined;
+    const message = event.message ?? "";
+    const icon = event.severity === "info" ? "ℹ" : "⚠";
+    return `${time} ${icon} [WATCH:${ruleId ?? "UNKNOWN"}] ${file ?? ""}${countSuffix}\n       ${message}`;
+  }
+  if (type === "guard.violation") {
+    const ruleId = event.data?.ruleId as string | undefined;
+    const file = event.data?.file as string | undefined;
+    const line = event.data?.line as number | undefined;
+    const message = event.message ?? (event.data?.message as string | undefined) ?? "";
+    const location = line ? `${file}:${line}` : file ?? "";
+    return `${time} 🚨 [GUARD:${ruleId ?? "UNKNOWN"}] ${location}${countSuffix}\n       ${message}`;
+  }
+  if (type === "guard.summary") {
+    const count = event.data?.count as number | undefined;
+    const passed = event.data?.passed as boolean | undefined;
+    return `${time} 🧱 [GUARD] ${passed ? "PASSED" : "FAILED"} (${count ?? 0} violations)`;
+  }
+  if (type === "routes.change") {
+    const action = event.data?.action as string | undefined;
+    const routeId = event.data?.routeId as string | undefined;
+    const pattern = event.data?.pattern as string | undefined;
+    const kind = event.data?.kind as string | undefined;
+    const detail = [routeId, pattern, kind].filter(Boolean).join(" ");
+    return `${time} 🛣️  [ROUTES:${action ?? "change"}] ${detail}${countSuffix}`;
+  }
+  if (type === "monitor.summary") {
+    return `${time} · SUMMARY ${event.message ?? ""}`;
+  }
+  if (type === "system.event") {
+    const category = event.data?.category as string | undefined;
+    return `${time}   [${category ?? "SYSTEM"}] ${event.message ?? ""}${countSuffix}`;
+  }
+
+  return `${time}   [${type}] ${event.message ?? ""}${countSuffix}`;
+}
+
+async function resolveLogFile(
+  rootDir: string,
+  output: MonitorOutput,
+  explicit?: string
+): Promise<string | null> {
+  if (explicit) return explicit;
+
+  const manduDir = path.join(rootDir, ".mandu");
+  const jsonPath = path.join(manduDir, "activity.jsonl");
+  const logPath = path.join(manduDir, "activity.log");
+
+  const hasJson = await pathExists(jsonPath);
+  const hasLog = await pathExists(logPath);
+
+  if (output === "json") {
+    if (hasJson) return jsonPath;
+    if (hasLog) return logPath;
+  } else {
+    if (hasLog) return logPath;
+    if (hasJson) return jsonPath;
+  }
+
+  return null;
+}
+
+async function readSummary(
+  filePath: string,
+  sinceMs: number
+): Promise<{
+  windowMs: number;
+  total: number;
+  bySeverity: { info: number; warn: number; error: number };
+  byType: Record<string, number>;
+}> {
+  const content = await fs.readFile(filePath, "utf-8");
+  const lines = content.split("\n").filter(Boolean);
+  const cutoff = Date.now() - sinceMs;
+  const counts = { total: 0, info: 0, warn: 0, error: 0 };
+  const byType: Record<string, number> = {};
+
+  for (const line of lines) {
+    try {
+      const event = JSON.parse(line) as MonitorEvent;
+      if (!event.ts) continue;
+      const ts = new Date(event.ts).getTime();
+      if (Number.isNaN(ts) || ts < cutoff) continue;
+      const count = event.count ?? 1;
+      counts.total += count;
+      if (event.severity) {
+        counts[event.severity] += count;
+      }
+      const type = event.type ?? "event";
+      byType[type] = (byType[type] ?? 0) + count;
+    } catch {
+      // ignore parse errors
+    }
+  }
+
+  return { windowMs: sinceMs, total: counts.total, bySeverity: counts, byType };
+}
+
+function printSummaryConsole(summary: {
+  windowMs: number;
+  total: number;
+  bySeverity: { info: number; warn: number; error: number };
+  byType: Record<string, number>;
+}): void {
+  const seconds = Math.round(summary.windowMs / 1000);
+  const topTypes = Object.entries(summary.byType)
+    .sort((a, b) => b[1] - a[1])
+    .slice(0, 5)
+    .map(([type, count]) => `${type}=${count}`)
+    .join(", ");
+
+  console.log(`Summary (last ${seconds}s)`);
+  console.log(`  total=${summary.total}`);
+  console.log(`  error=${summary.bySeverity.error} warn=${summary.bySeverity.warn} info=${summary.bySeverity.info}`);
+  if (topTypes) {
+    console.log(`  top=${topTypes}`);
+  }
+}
+
+function outputChunk(
+  chunk: string,
+  isJson: boolean,
+  output: MonitorOutput
+): void {
+  if (!isJson || output === "json") {
+    process.stdout.write(chunk);
+    return;
+  }
+
+  const lines = chunk.split("\n").filter(Boolean);
+  for (const line of lines) {
+    try {
+      const event = JSON.parse(line) as MonitorEvent;
+      const formatted = formatEventForConsole(event);
+      process.stdout.write(`${formatted}\n`);
+    } catch {
+      process.stdout.write(`${line}\n`);
+    }
+  }
+}
+
+async function followFile(
+  filePath: string,
+  isJson: boolean,
+  output: MonitorOutput,
+  startAtEnd: boolean
+): Promise<void> {
+  let position = 0;
+  let buffer = "";
+
+  try {
+    const stat = await fs.stat(filePath);
+    position = startAtEnd ? stat.size : 0;
+  } catch {
+    position = 0;
+  }
+
+  const fd = await fs.open(filePath, "r");
+
+  fsSync.watchFile(
+    filePath,
+    { interval: 500 },
+    async (curr) => {
+      if (curr.size < position) {
+        position = 0;
+        buffer = "";
+      }
+      if (curr.size === position) {
+        return;
+      }
+
+      const length = curr.size - position;
+      const chunk = Buffer.alloc(length);
+      await fd.read(chunk, 0, length, position);
+      position = curr.size;
+      buffer += chunk.toString("utf-8");
+
+      const lines = buffer.split("\n");
+      buffer = lines.pop() ?? "";
+      if (lines.length > 0) {
+        outputChunk(lines.join("\n"), isJson, output);
+      }
+    }
+  );
+}
+
+export async function monitor(options: MonitorOptions = {}): Promise<boolean> {
+  const rootDir = resolveFromCwd(".");
+  const resolved = resolveOutputFormat(options.format);
+  const output: MonitorOutput = resolved === "json" || resolved === "agent" ? "json" : "console";
+  const filePath = await resolveLogFile(rootDir, output, options.file);
+
+  if (!filePath) {
+    console.error("❌ activity log 파일을 찾을 수 없습니다. (.mandu/activity.log 또는 activity.jsonl)");
+    return false;
+  }
+
+  const isJson = filePath.endsWith(".jsonl");
+  const follow = options.follow !== false;
+
+  if (options.summary) {
+    if (!isJson) {
+      console.error("⚠️  summary는 JSON 로그(activity.jsonl)에서만 가능합니다.");
+    } else {
+      const windowMs = parseDuration(options.since) ?? 5 * 60 * 1000;
+      const summary = await readSummary(filePath, windowMs);
+      if (output === "json") {
+        console.log(JSON.stringify(summary, null, 2));
+      } else {
+        printSummaryConsole(summary);
+      }
+    }
+    if (!follow) return true;
+  }
+
+  if (!follow) {
+    const content = await fs.readFile(filePath, "utf-8");
+    outputChunk(content, isJson, output);
+    return true;
+  }
+
+  await followFile(filePath, isJson, output, true);
+  return new Promise(() => {});
+}