@mandujs/mcp 0.8.1 → 0.9.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mandujs/mcp",
-  "version": "0.8.1",
+  "version": "0.9.0",
   "description": "Mandu MCP Server - Agent-native interface for Mandu framework operations",
   "type": "module",
   "main": "./src/index.ts",
@@ -32,7 +32,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@mandujs/core": "^0.8.1",
+    "@mandujs/core": "^0.9.0",
     "@modelcontextprotocol/sdk": "^1.25.3"
   },
   "engines": {

package/src/server.ts

@@ -17,6 +17,7 @@ import { guardTools, guardToolDefinitions } from "./tools/guard.js";
 import { slotTools, slotToolDefinitions } from "./tools/slot.js";
 import { hydrationTools, hydrationToolDefinitions } from "./tools/hydration.js";
 import { contractTools, contractToolDefinitions } from "./tools/contract.js";
+import { brainTools, brainToolDefinitions } from "./tools/brain.js";
 import { resourceHandlers, resourceDefinitions } from "./resources/handlers.js";
 import { findProjectRoot } from "./utils/project.js";
 
@@ -53,6 +54,7 @@ export class ManduMcpServer {
       ...slotToolDefinitions,
       ...hydrationToolDefinitions,
       ...contractToolDefinitions,
+      ...brainToolDefinitions,
     ];
   }
 
@@ -66,6 +68,7 @@ export class ManduMcpServer {
       ...slotTools(this.projectRoot),
       ...hydrationTools(this.projectRoot),
       ...contractTools(this.projectRoot),
+      ...brainTools(this.projectRoot),
     };
   }
 

package/src/tools/brain.ts

@@ -0,0 +1,231 @@
+/**
+ * Mandu MCP - Brain Tools
+ *
+ * MCP tools for Brain functionality:
+ * - mandu_doctor: Guard failure analysis + patch suggestions
+ * - mandu_watch_start: Start file watching
+ * - mandu_watch_status: Get watch status
+ */
+
+import type { Tool } from "@modelcontextprotocol/sdk/types.js";
+import {
+  loadManifest,
+  runGuardCheck,
+  analyzeViolations,
+  generateJsonReport,
+  initializeBrain,
+  getBrain,
+  startWatcher,
+  stopWatcher,
+  getWatcher,
+  generateJsonStatus,
+} from "../../../core/src/index.js";
+import { getProjectPaths } from "../utils/project.js";
+
+export const brainToolDefinitions: Tool[] = [
+  {
+    name: "mandu_doctor",
+    description:
+      "Analyze Guard failures and suggest patches. Works with or without LLM - template-based analysis is always available.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        useLLM: {
+          type: "boolean",
+          description:
+            "Whether to use LLM for enhanced analysis (default: true if available)",
+        },
+      },
+      required: [],
+    },
+  },
+  {
+    name: "mandu_watch_start",
+    description:
+      "Start file watching with architecture rule warnings. Watches for common mistakes and emits warnings (no blocking).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        debounceMs: {
+          type: "number",
+          description: "Debounce delay in milliseconds (default: 300)",
+        },
+      },
+      required: [],
+    },
+  },
+  {
+    name: "mandu_watch_status",
+    description:
+      "Get the current watch status including recent warnings and active rules.",
+    inputSchema: {
+      type: "object",
+      properties: {},
+      required: [],
+    },
+  },
+];
+
+export function brainTools(projectRoot: string) {
+  const paths = getProjectPaths(projectRoot);
+
+  return {
+    mandu_doctor: async (args: Record<string, unknown>) => {
+      const { useLLM = true } = args as { useLLM?: boolean };
+
+      try {
+        // Initialize Brain
+        await initializeBrain();
+        const brain = getBrain();
+        const llmAvailable = await brain.isLLMAvailable();
+
+        // Load manifest
+        const manifestResult = await loadManifest(paths.manifestPath);
+        if (!manifestResult.success || !manifestResult.data) {
+          return {
+            error: "Failed to load manifest",
+            details: manifestResult.errors,
+          };
+        }
+
+        // Run guard check
+        const checkResult = await runGuardCheck(
+          manifestResult.data,
+          projectRoot
+        );
+
+        if (checkResult.passed) {
+          return {
+            passed: true,
+            message: "All guard checks passed - no violations found",
+            llmAvailable,
+          };
+        }
+
+        // Analyze violations
+        const analysis = await analyzeViolations(checkResult.violations, {
+          useLLM: useLLM && brain.enabled && llmAvailable,
+        });
+
+        return {
+          passed: false,
+          summary: analysis.summary,
+          violationCount: analysis.violations.length,
+          violations: analysis.violations.map((v) => ({
+            ruleId: v.ruleId,
+            file: v.file,
+            message: v.message,
+            suggestion: v.suggestion,
+            line: v.line,
+            severity: v.severity || "error",
+          })),
+          patches: analysis.patches.map((p) => ({
+            file: p.file,
+            type: p.type,
+            description: p.description,
+            command: p.command,
+            confidence: p.confidence,
+          })),
+          nextCommand: analysis.nextCommand,
+          llmAssisted: analysis.llmAssisted,
+          tip: "Run the suggested patches or nextCommand to fix violations",
+        };
+      } catch (error) {
+        return {
+          error: "Doctor analysis failed",
+          details: error instanceof Error ? error.message : "Unknown error",
+        };
+      }
+    },
+
+    mandu_watch_start: async (args: Record<string, unknown>) => {
+      const { debounceMs } = args as { debounceMs?: number };
+
+      try {
+        // Check if already watching
+        const existingWatcher = getWatcher();
+        if (existingWatcher) {
+          const status = existingWatcher.getStatus();
+          if (status.active) {
+            return {
+              success: false,
+              message: "Watch is already running",
+              status: JSON.parse(generateJsonStatus(status)),
+            };
+          }
+        }
+
+        // Start watcher
+        const watcher = await startWatcher({
+          rootDir: projectRoot,
+          debounceMs,
+        });
+
+        const status = watcher.getStatus();
+
+        return {
+          success: true,
+          message: "Watch started successfully",
+          status: {
+            active: status.active,
+            rootDir: status.rootDir,
+            fileCount: status.fileCount,
+            startedAt: status.startedAt?.toISOString(),
+          },
+          rules: [
+            "GENERATED_DIRECT_EDIT - Generated 파일 직접 수정 감지",
+            "WRONG_SLOT_LOCATION - 잘못된 위치의 Slot 파일 감지",
+            "SLOT_NAMING - Slot 파일 네이밍 규칙",
+            "CONTRACT_NAMING - Contract 파일 네이밍 규칙",
+            "FORBIDDEN_IMPORT - Generated 파일의 금지된 import 감지",
+          ],
+          tip: "Watch emits warnings only - it never blocks operations",
+        };
+      } catch (error) {
+        return {
+          error: "Failed to start watch",
+          details: error instanceof Error ? error.message : "Unknown error",
+        };
+      }
+    },
+
+    mandu_watch_status: async () => {
+      try {
+        const watcher = getWatcher();
+
+        if (!watcher) {
+          return {
+            active: false,
+            message: "Watch is not running",
+            tip: "Use mandu_watch_start to begin watching",
+          };
+        }
+
+        const status = watcher.getStatus();
+
+        return {
+          active: status.active,
+          rootDir: status.rootDir,
+          fileCount: status.fileCount,
+          startedAt: status.startedAt?.toISOString() || null,
+          uptime: status.startedAt
+            ? Math.floor((Date.now() - status.startedAt.getTime()) / 1000)
+            : 0,
+          recentWarnings: status.recentWarnings.map((w) => ({
+            ruleId: w.ruleId,
+            file: w.file,
+            message: w.message,
+            event: w.event,
+            timestamp: w.timestamp.toISOString(),
+          })),
+          warningCount: status.recentWarnings.length,
+        };
+      } catch (error) {
+        return {
+          error: "Failed to get watch status",
+          details: error instanceof Error ? error.message : "Unknown error",
+        };
+      }
+    },
+  };
+}

package/src/tools/index.ts

@@ -6,3 +6,4 @@ export { guardTools, guardToolDefinitions } from "./guard.js";
 export { slotTools, slotToolDefinitions } from "./slot.js";
 export { hydrationTools, hydrationToolDefinitions } from "./hydration.js";
 export { contractTools, contractToolDefinitions } from "./contract.js";
+export { brainTools, brainToolDefinitions } from "./brain.js";