@mandujs/cli 0.9.20 → 0.9.22

package/README.md

@@ -109,6 +109,7 @@ That's it!
 |---------|-------------|
 | `mandu doctor` | Analyze Guard failures + suggest patches |
 | `mandu watch` | Real-time file monitoring |
+| `mandu monitor` | MCP Activity Monitor log stream |
 | `mandu brain setup` | Configure sLLM (optional) |
 | `mandu brain status` | Check Brain status |
 
@@ -256,6 +257,16 @@ bunx mandu guard arch --preset fsd
 | `--no-llm` | Template mode (no LLM) |
 | `--output <path>` | Output file path |
 
+### `mandu monitor`
+
+| Option | Description |
+|--------|-------------|
+| `--format <f>` | Output: console, agent, json |
+| `--summary` | Print summary (JSON log only) |
+| `--since <d>` | Summary window: 5m, 30s, 1h |
+| `--follow <bool>` | Follow mode (default: true) |
+| `--file <path>` | Use custom log file |
+
 ---
 
 ## Examples
@@ -287,6 +298,10 @@ bunx mandu change rollback
 bunx mandu doctor
 bunx mandu doctor --format json
 
+# Monitor
+bunx mandu monitor
+bunx mandu monitor --summary --since 5m
+
 # Build
 bunx mandu build --minify --sourcemap
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mandujs/cli",
-  "version": "0.9.20",
+  "version": "0.9.22",
   "description": "Agent-Native Fullstack Framework - 에이전트가 코딩해도 아키텍처가 무너지지 않는 개발 OS",
   "type": "module",
   "main": "./src/main.ts",
@@ -32,7 +32,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@mandujs/core": "0.9.38"
+    "@mandujs/core": "0.9.39"
   },
   "engines": {
     "bun": ">=1.0.0"

package/src/commands/monitor.ts

@@ -0,0 +1,280 @@
+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 === "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(() => {});
+}

package/src/main.ts

@@ -19,9 +19,10 @@ import {
   changePrune,
 } from "./commands/change";
 import { doctor } from "./commands/doctor";
-import { watch } from "./commands/watch";
-import { brainSetup, brainStatus } from "./commands/brain";
-import { routesGenerate, routesList, routesWatch } from "./commands/routes";
+import { watch } from "./commands/watch";
+import { brainSetup, brainStatus } from "./commands/brain";
+import { routesGenerate, routesList, routesWatch } from "./commands/routes";
+import { monitor } from "./commands/monitor";
 
 const HELP_TEXT = `
 🥟 Mandu CLI - Agent-Native Fullstack Framework
@@ -47,9 +48,10 @@ Commands:
   generate       Spec에서 코드 생성 (레거시)
 
   doctor         Guard 실패 분석 + 패치 제안 (Brain)
-  watch          실시간 파일 감시 - 경고만 (Brain)
-
-  brain setup    sLLM 설정 (선택)
+  watch          실시간 파일 감시 - 경고만 (Brain)
+  monitor        MCP Activity Monitor 로그 스트림
+
+  brain setup    sLLM 설정 (선택)
   brain status   Brain 상태 확인
 
   contract create <routeId>  라우트에 대한 Contract 생성
@@ -83,8 +85,12 @@ Options:
   --show-trend       guard arch 트렌드 분석 표시
   --minify           build 시 코드 압축
   --sourcemap        build 시 소스맵 생성
-  --watch            build/guard arch 파일 감시 모드
-  --message <msg>    change begin 시 설명 메시지
+  --watch            build/guard arch 파일 감시 모드
+  --summary          monitor 요약 출력 (JSON 로그에서만)
+  --since <duration> monitor 요약 기간 (예: 5m, 30s, 1h)
+  --follow <bool>    monitor follow 모드 (기본: true)
+  --file <path>      monitor 로그 파일 직접 지정
+  --message <msg>    change begin 시 설명 메시지
   --id <id>          change rollback 시 특정 변경 ID
   --keep <n>         change prune 시 유지할 스냅샷 수 (기본: 5)
   --output <path>    openapi/doctor 출력 경로
@@ -107,8 +113,10 @@ Examples:
   bunx mandu guard
   bunx mandu guard arch --preset fsd
   bunx mandu guard arch --watch
-  bunx mandu guard arch --ci --format json
-  bunx mandu doctor
+  bunx mandu guard arch --ci --format json
+  bunx mandu monitor
+  bunx mandu monitor --summary --since 5m
+  bunx mandu doctor
   bunx mandu brain setup --model codellama
   bunx mandu contract create users
   bunx mandu openapi generate --output docs/api.json
@@ -375,13 +383,23 @@ async function main(): Promise<void> {
       });
       break;
 
-    case "watch":
-      success = await watch({
-        status: options.status === "true",
-        debounce: options.debounce ? Number(options.debounce) : undefined,
-      });
-      break;
-
+    case "watch":
+      success = await watch({
+        status: options.status === "true",
+        debounce: options.debounce ? Number(options.debounce) : undefined,
+      });
+      break;
+
+    case "monitor":
+      success = await monitor({
+        format: options.format as any,
+        summary: options.summary === "true",
+        since: options.since,
+        follow: options.follow === "false" ? false : true,
+        file: options.file,
+      });
+      break;
+
     case "brain": {
       const subCommand = args[1];
       switch (subCommand) {

package/templates/default/package.json

@@ -8,14 +8,14 @@
     "test": "bun test"
   },
   "dependencies": {
-    "@mandujs/core": "^0.9.38",
-    "react": "^18.2.0",
-    "react-dom": "^18.2.0"
+    "@mandujs/core": "^0.9.39",
+    "react": "^19.2.0",
+    "react-dom": "^19.2.0"
   },
   "devDependencies": {
-    "@mandujs/cli": "^0.9.18",
-    "@types/react": "^18.2.0",
-    "@types/react-dom": "^18.2.0",
+    "@mandujs/cli": "^0.9.21",
+    "@types/react": "^19.2.0",
+    "@types/react-dom": "^19.2.0",
     "typescript": "^5.0.0"
   }
 }