@mandujs/mcp 0.9.0 → 0.9.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mandujs/mcp",
-  "version": "0.9.0",
+  "version": "0.9.2",
   "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.9.0",
+    "@mandujs/core": "^0.9.2",
     "@modelcontextprotocol/sdk": "^1.25.3"
   },
   "engines": {

package/src/tools/brain.ts

@@ -5,6 +5,9 @@
  * - mandu_doctor: Guard failure analysis + patch suggestions
  * - mandu_watch_start: Start file watching
  * - mandu_watch_status: Get watch status
+ * - mandu_check_location: Check if file location is valid (v0.2)
+ * - mandu_check_import: Check if imports are valid (v0.2)
+ * - mandu_get_architecture: Get project architecture rules (v0.2)
  */
 
 import type { Tool } from "@modelcontextprotocol/sdk/types.js";
@@ -19,6 +22,8 @@ import {
   stopWatcher,
   getWatcher,
   generateJsonStatus,
+  initializeArchitectureAnalyzer,
+  getArchitectureAnalyzer,
 } from "../../../core/src/index.js";
 import { getProjectPaths } from "../utils/project.js";
 
@@ -64,6 +69,61 @@ export const brainToolDefinitions: Tool[] = [
       required: [],
     },
   },
+  // Architecture tools (v0.2)
+  {
+    name: "mandu_check_location",
+    description:
+      "Check if a file location follows project architecture rules. Call this BEFORE creating or moving files to ensure proper placement.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        path: {
+          type: "string",
+          description: "File path to check (relative to project root)",
+        },
+        content: {
+          type: "string",
+          description: "Optional file content for import validation",
+        },
+      },
+      required: ["path"],
+    },
+  },
+  {
+    name: "mandu_check_import",
+    description:
+      "Check if imports in a file follow architecture rules. Call this to validate imports before adding them.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        sourceFile: {
+          type: "string",
+          description: "Source file path (relative to project root)",
+        },
+        imports: {
+          type: "array",
+          items: { type: "string" },
+          description: "List of import paths to check",
+        },
+      },
+      required: ["sourceFile", "imports"],
+    },
+  },
+  {
+    name: "mandu_get_architecture",
+    description:
+      "Get the project architecture rules and folder structure. Use this to understand where to place new files.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        includeStructure: {
+          type: "boolean",
+          description: "Include folder tree in response (default: true)",
+        },
+      },
+      required: [],
+    },
+  },
 ];
 
 export function brainTools(projectRoot: string) {
@@ -227,5 +287,156 @@ export function brainTools(projectRoot: string) {
         };
       }
     },
+
+    // Architecture tools (v0.2)
+    mandu_check_location: async (args: Record<string, unknown>) => {
+      const { path: filePath, content } = args as {
+        path: string;
+        content?: string;
+      };
+
+      try {
+        // Initialize analyzer if needed
+        let analyzer = getArchitectureAnalyzer();
+        if (!analyzer) {
+          await initializeBrain();
+          analyzer = initializeArchitectureAnalyzer(projectRoot);
+        }
+
+        const result = await analyzer.checkLocation({
+          path: filePath,
+          content,
+        });
+
+        if (result.allowed) {
+          return {
+            allowed: true,
+            message: `✅ '${filePath}'는 올바른 위치입니다`,
+            tip: "파일을 생성해도 됩니다",
+          };
+        }
+
+        return {
+          allowed: false,
+          violations: result.violations.map((v) => ({
+            rule: v.ruleId,
+            message: v.message,
+            severity: v.severity,
+          })),
+          suggestion: result.suggestion,
+          recommendedPath: result.recommendedPath,
+          tip: result.recommendedPath
+            ? `권장 경로: ${result.recommendedPath}`
+            : "위반 사항을 확인하고 적절한 위치에 파일을 생성하세요",
+        };
+      } catch (error) {
+        return {
+          error: "Location check failed",
+          details: error instanceof Error ? error.message : "Unknown error",
+        };
+      }
+    },
+
+    mandu_check_import: async (args: Record<string, unknown>) => {
+      const { sourceFile, imports } = args as {
+        sourceFile: string;
+        imports: string[];
+      };
+
+      try {
+        let analyzer = getArchitectureAnalyzer();
+        if (!analyzer) {
+          await initializeBrain();
+          analyzer = initializeArchitectureAnalyzer(projectRoot);
+        }
+
+        const result = await analyzer.checkImports({
+          sourceFile,
+          imports,
+        });
+
+        if (result.allowed) {
+          return {
+            allowed: true,
+            message: "✅ 모든 import가 허용됩니다",
+            checkedImports: imports,
+          };
+        }
+
+        return {
+          allowed: false,
+          violations: result.violations.map((v) => ({
+            import: v.import,
+            reason: v.reason,
+            suggestion: v.suggestion,
+          })),
+          tip: "금지된 import를 제거하거나 대안을 사용하세요",
+        };
+      } catch (error) {
+        return {
+          error: "Import check failed",
+          details: error instanceof Error ? error.message : "Unknown error",
+        };
+      }
+    },
+
+    mandu_get_architecture: async (args: Record<string, unknown>) => {
+      const { includeStructure = true } = args as {
+        includeStructure?: boolean;
+      };
+
+      try {
+        let analyzer = getArchitectureAnalyzer();
+        if (!analyzer) {
+          await initializeBrain();
+          analyzer = initializeArchitectureAnalyzer(projectRoot);
+        }
+
+        const config = analyzer.getConfig();
+        const structure = includeStructure
+          ? await analyzer.getProjectStructure()
+          : null;
+
+        return {
+          folders: Object.entries(config.folders || {}).map(([key, rule]) => {
+            const folderRule =
+              typeof rule === "string"
+                ? { pattern: key, description: rule }
+                : rule;
+            return {
+              pattern: folderRule.pattern,
+              description: folderRule.description,
+              readonly: folderRule.readonly || false,
+              allowedFiles: folderRule.allowedFiles,
+            };
+          }),
+          importRules: (config.imports || []).map((rule) => ({
+            source: rule.source,
+            forbid: rule.forbid,
+            allow: rule.allow,
+            reason: rule.reason,
+          })),
+          namingRules: (config.naming || []).map((rule) => ({
+            folder: rule.folder,
+            pattern: rule.filePattern,
+            description: rule.description,
+            examples: rule.examples,
+          })),
+          structure: structure
+            ? {
+                rootDir: structure.rootDir,
+                folders: structure.folders,
+                indexedAt: structure.indexedAt,
+              }
+            : null,
+          tip: "이 규칙을 따라 파일을 생성하세요. mandu_check_location으로 검증할 수 있습니다.",
+        };
+      } catch (error) {
+        return {
+          error: "Failed to get architecture",
+          details: error instanceof Error ? error.message : "Unknown error",
+        };
+      }
+    },
   };
 }