@mandujs/mcp 0.18.6 → 0.18.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mandujs/mcp",
-  "version": "0.18.6",
+  "version": "0.18.8",
   "description": "Mandu MCP Server - Agent-native interface for Mandu framework operations",
   "type": "module",
   "main": "./src/index.ts",
@@ -32,8 +32,8 @@
     "access": "public"
   },
   "dependencies": {
-    "@mandujs/core": "^0.18.14",
-    "@mandujs/ate": "^0.17.0",
+    "@mandujs/core": "^0.18.22",
+    "@mandujs/ate": "^0.17.2",
     "@modelcontextprotocol/sdk": "^1.25.3"
   },
   "engines": {

package/src/adapters/tool-adapter.ts

@@ -5,7 +5,7 @@
  */
 
 import type { Tool } from "@modelcontextprotocol/sdk/types.js";
-import type { McpToolPlugin } from "@mandujs/core";
+import type { McpToolPlugin } from "@mandujs/core/plugins";
 
 /**
  * MCP SDK Tool을 McpToolPlugin으로 변환
@@ -25,8 +25,8 @@ export function toolToPlugin(
   return {
     name: definition.name,
     description: definition.description ?? "",
-    inputSchema: definition.inputSchema as Record<string, unknown>,
-    execute: handler,
+    inputSchema: definition.inputSchema as unknown as Record<string, unknown>,
+    execute: handler as (input: unknown) => Promise<unknown>,
   };
 }
 
@@ -37,7 +37,7 @@ export function pluginToTool(plugin: McpToolPlugin): Tool {
   return {
     name: plugin.name,
     description: plugin.description,
-    inputSchema: plugin.inputSchema,
+    inputSchema: plugin.inputSchema as Tool["inputSchema"],
   };
 }
 

package/src/executor/tool-executor.ts

@@ -4,7 +4,8 @@
  * 도구 실행 + 훅 + 에러 처리 통합
  */
 
-import type { McpToolPlugin, ManduConfig } from "@mandujs/core";
+import type { McpToolPlugin } from "@mandujs/core/plugins";
+import type { ManduConfig } from "@mandujs/core";
 import { mcpToolRegistry } from "../registry/mcp-tool-registry.js";
 import { mcpHookRegistry, type McpToolContext } from "../hooks/mcp-hooks.js";
 import { createToolResponse, logToolError, type McpToolResponse } from "./error-handler.js";

package/src/hooks/config-watcher.ts

@@ -5,7 +5,7 @@
  */
 
 import type { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { watchConfig, hasConfigChanged, type ManduConfig } from "@mandujs/core";
+import { watchConfig, hasConfigChanged, getChangedSections, type ManduConfig } from "@mandujs/core";
 import { mcpToolRegistry } from "../registry/mcp-tool-registry.js";
 
 /**
@@ -75,7 +75,7 @@ export async function startMcpConfigWatcher(
             logger: "mandu-config",
             data: {
               type: "config_reload",
-              changedSections: event.changedSections,
+              changedSections: getChangedSections(event.previous, event.current),
               path: event.path,
             },
           });
@@ -86,7 +86,7 @@ export async function startMcpConfigWatcher(
 
       // MCP 관련 설정 변경 확인
       if (event.previous && event.current) {
-        if (hasConfigChanged(event.previous, event.current, "mcp")) {
+        if (needsToolReregistration(event.previous, event.current)) {
           // MCP 설정 변경 시 도구 재초기화 등 필요한 작업
           if (server) {
             try {

package/src/registry/mcp-tool-registry.ts

@@ -8,7 +8,7 @@
  */
 
 import type { Tool } from "@modelcontextprotocol/sdk/types.js";
-import type { McpToolPlugin } from "@mandujs/core";
+import type { McpToolPlugin } from "@mandujs/core/plugins";
 import { pluginToTool } from "../adapters/tool-adapter.js";
 
 /**

package/src/server.ts

@@ -16,6 +16,7 @@ import {
   ListToolsRequestSchema,
   ListResourcesRequestSchema,
   ReadResourceRequestSchema,
+  type CallToolResult,
 } from "@modelcontextprotocol/sdk/types.js";
 
 import { loadManduConfig, startWatcher, type ManduConfig } from "@mandujs/core";
@@ -113,13 +114,13 @@ export class ManduMcpServer {
     });
 
     // 도구 실행 요청
-    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    this.server.setRequestHandler(CallToolRequestSchema, async (request, _extra) => {
       const { name, arguments: args } = request.params;
 
       // DNA-007 + DNA-016: Tool Executor로 실행
       const result = await this.toolExecutor.execute(name, args || {});
 
-      return result.response;
+      return result.response as unknown as CallToolResult;
     });
   }
 

package/src/tools/ate.ts

@@ -10,6 +10,7 @@ import {
   analyzeFeedback,
   applyHeal,
 } from "@mandujs/ate";
+import type { OracleLevel } from "@mandujs/ate";
 
 export const ateToolDefinitions: Tool[] = [
   {
@@ -248,38 +249,95 @@ export const ateToolDefinitions: Tool[] = [
 export function ateTools(projectRoot: string) {
   return {
     "mandu.ate.extract": async (args: Record<string, unknown>) => {
-      return await ateExtract(args as any);
+      const { repoRoot, tsconfigPath, routeGlobs, buildSalt } = args as {
+        repoRoot: string;
+        tsconfigPath?: string;
+        routeGlobs?: string[];
+        buildSalt?: string;
+      };
+      return await ateExtract({ repoRoot, tsconfigPath, routeGlobs, buildSalt });
     },
     "mandu.ate.generate": async (args: Record<string, unknown>) => {
-      return ateGenerate(args as any);
+      const { repoRoot, oracleLevel, onlyRoutes } = args as {
+        repoRoot: string;
+        oracleLevel?: OracleLevel;
+        onlyRoutes?: string[];
+      };
+      return ateGenerate({ repoRoot, oracleLevel, onlyRoutes });
     },
     "mandu.ate.run": async (args: Record<string, unknown>) => {
-      return await ateRun(args as any);
+      const { repoRoot, baseURL, ci, headless, browsers } = args as {
+        repoRoot: string;
+        baseURL?: string;
+        ci?: boolean;
+        headless?: boolean;
+        browsers?: ("chromium" | "firefox" | "webkit")[];
+      };
+      return await ateRun({ repoRoot, baseURL, ci, headless, browsers });
     },
     "mandu.ate.report": async (args: Record<string, unknown>) => {
-      const input = args as any;
+      const { repoRoot, runId, startedAt, finishedAt, exitCode, oracleLevel, format, impact } = args as {
+        repoRoot: string;
+        runId: string;
+        startedAt: string;
+        finishedAt: string;
+        exitCode: number;
+        oracleLevel?: OracleLevel;
+        format?: "json" | "html" | "both";
+        impact?: { changedFiles: string[]; selectedRoutes: string[]; mode: "full" | "subset" };
+      };
       return await ateReport({
-        repoRoot: input.repoRoot,
-        runId: input.runId,
-        startedAt: input.startedAt,
-        finishedAt: input.finishedAt,
-        exitCode: input.exitCode,
-        oracleLevel: input.oracleLevel ?? "L1",
-        format: input.format ?? "both",
-        impact: input.impact,
+        repoRoot,
+        runId,
+        startedAt,
+        finishedAt,
+        exitCode,
+        oracleLevel: oracleLevel ?? "L1",
+        format: format ?? "both",
+        impact,
       });
     },
     "mandu.ate.heal": async (args: Record<string, unknown>) => {
-      return ateHeal(args as any);
+      const { repoRoot, runId } = args as { repoRoot: string; runId: string };
+      return ateHeal({ repoRoot, runId });
     },
     "mandu.ate.impact": async (args: Record<string, unknown>) => {
-      return ateImpact(args as any);
+      const { repoRoot, base, head } = args as {
+        repoRoot: string;
+        base?: string;
+        head?: string;
+      };
+      return ateImpact({ repoRoot, base, head });
     },
     "mandu.ate.auto_pipeline": async (args: Record<string, unknown>) => {
-      return await runFullPipeline(args as any);
+      const {
+        repoRoot, baseURL, oracleLevel, ci, useImpactAnalysis,
+        base, head, autoHeal, tsconfigPath, routeGlobs, buildSalt,
+      } = args as {
+        repoRoot: string;
+        baseURL?: string;
+        oracleLevel?: OracleLevel;
+        ci?: boolean;
+        useImpactAnalysis?: boolean;
+        base?: string;
+        head?: string;
+        autoHeal?: boolean;
+        tsconfigPath?: string;
+        routeGlobs?: string[];
+        buildSalt?: string;
+      };
+      return await runFullPipeline({
+        repoRoot, baseURL, oracleLevel, ci, useImpactAnalysis,
+        base, head, autoHeal, tsconfigPath, routeGlobs, buildSalt,
+      });
     },
     "mandu.ate.feedback": async (args: Record<string, unknown>) => {
-      const result = analyzeFeedback(args as any);
+      const { repoRoot, runId, autoApply } = args as {
+        repoRoot: string;
+        runId: string;
+        autoApply?: boolean;
+      };
+      const result = analyzeFeedback({ repoRoot, runId, autoApply });
       return {
         ok: true,
         category: result.category,
@@ -290,7 +348,13 @@ export function ateTools(projectRoot: string) {
       };
     },
     "mandu.ate.apply_heal": async (args: Record<string, unknown>) => {
-      const result = applyHeal(args as any);
+      const { repoRoot, runId, healIndex, createBackup } = args as {
+        repoRoot: string;
+        runId: string;
+        healIndex: number;
+        createBackup?: boolean;
+      };
+      const result = applyHeal({ repoRoot, runId, healIndex, createBackup });
       return {
         ok: result.success,
         ...result,

package/src/tools/brain.ts

@@ -198,7 +198,7 @@ export function brainTools(projectRoot: string, server?: Server, monitor?: Activ
             file: p.file,
             type: p.type,
             description: p.description,
-            command: p.command,
+            ...(p.type === "command" ? { command: p.command } : {}),
             confidence: p.confidence,
           })),
           nextCommand: analysis.nextCommand,

package/src/tools/contract.ts

@@ -8,6 +8,7 @@ import {
   openAPIToJSON,
   type RouteSpec,
   type RoutesManifest,
+  type SpecHttpMethod,
 } from "@mandujs/core";
 import { getProjectPaths, readJsonFile, writeJsonFile } from "../utils/project.js";
 import path from "path";
@@ -295,7 +296,7 @@ export function contractTools(projectRoot: string) {
       // Generate contract with custom methods if provided
       const routeWithMethods: RouteSpec = {
         ...route,
-        methods: methods as any || route.methods || ["GET", "POST"],
+        methods: (methods as SpecHttpMethod[] | undefined) || route.methods || ["GET", "POST"],
       };
 
       const contractContent = generateContractTemplate(routeWithMethods);

package/src/tools/guard.ts

@@ -1,10 +1,9 @@
 import type { Tool } from "@modelcontextprotocol/sdk/types.js";
+import { ErrorClassifier, type ManduError } from "@mandujs/core/error";
 import {
   loadManifest,
   runGuardCheck,
   runAutoCorrect,
-  ErrorClassifier,
-  type ManduError,
   type GeneratedMap,
   // Self-Healing Guard imports
   checkWithHealing,

package/src/tools/hydration.ts

@@ -6,8 +6,9 @@ import {
   needsHydration,
   getRouteHydration,
   type BundleManifest,
-  type HydrationStrategy,
+  type SpecHydrationStrategy,
   type HydrationPriority,
+  type HydrationConfig,
 } from "@mandujs/core";
 import { getProjectPaths, readJsonFile, writeJsonFile } from "../utils/project.js";
 import path from "path";
@@ -238,7 +239,7 @@ export function hydrationTools(projectRoot: string) {
     mandu_set_hydration: async (args: Record<string, unknown>) => {
       const { routeId, strategy, priority, preload } = args as {
         routeId: string;
-        strategy?: HydrationStrategy;
+        strategy?: SpecHydrationStrategy;
         priority?: HydrationPriority;
         preload?: boolean;
       };
@@ -263,7 +264,7 @@ export function hydrationTools(projectRoot: string) {
       }
 
       // Update hydration config
-      const currentHydration = route.hydration || {};
+      const currentHydration: Partial<HydrationConfig> = route.hydration || {};
       const newHydration = {
         strategy: strategy || currentHydration.strategy || "island",
         priority: priority || currentHydration.priority || "visible",
@@ -297,7 +298,7 @@ export function hydrationTools(projectRoot: string) {
     mandu_add_client_slot: async (args: Record<string, unknown>) => {
       const { routeId, strategy = "island", priority = "visible" } = args as {
         routeId: string;
-        strategy?: HydrationStrategy;
+        strategy?: SpecHydrationStrategy;
         priority?: HydrationPriority;
       };
 
@@ -349,7 +350,7 @@ export function hydrationTools(projectRoot: string) {
         ...route,
         clientModule: clientModulePath,
         hydration: {
-          strategy: strategy as HydrationStrategy,
+          strategy: strategy as SpecHydrationStrategy,
           priority: priority as HydrationPriority,
           preload: false,
         },

package/src/tools/index.ts

@@ -4,6 +4,7 @@
  * 도구 정의 및 레지스트리 등록
  */
 
+import type { Tool } from "@modelcontextprotocol/sdk/types.js";
 import type { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import type { ActivityMonitor } from "../activity-monitor.js";
 import { mcpToolRegistry } from "../registry/mcp-tool-registry.js";
@@ -48,7 +49,7 @@ import { componentTools, componentToolDefinitions } from "./component.js";
  */
 interface ToolModule {
   category: string;
-  definitions: any;
+  definitions: Tool[];
   handlers: (
     projectRoot: string,
     server?: Server,
@@ -73,7 +74,7 @@ const TOOL_MODULES: ToolModule[] = [
   { category: "runtime", definitions: runtimeToolDefinitions, handlers: runtimeTools },
   { category: "seo", definitions: seoToolDefinitions, handlers: seoTools },
   { category: "project", definitions: projectToolDefinitions, handlers: projectTools as ToolModule["handlers"], requiresServer: true },
-  { category: "ate", definitions: ateToolDefinitions as any, handlers: ateTools as any },
+  { category: "ate", definitions: ateToolDefinitions, handlers: ateTools as ToolModule["handlers"] },
   { category: "resource", definitions: resourceToolDefinitions, handlers: resourceTools },
   { category: "component", definitions: componentToolDefinitions, handlers: componentTools },
 ];

package/src/tools/seo.ts

@@ -247,10 +247,10 @@ export function seoTools(projectRoot: string) {
             jsonLd = createOrganizationJsonLd(data as Parameters<typeof createOrganizationJsonLd>[0]);
             break;
           case "Breadcrumb":
-            jsonLd = createBreadcrumbJsonLd(data as Array<{ name: string; url: string }>);
+            jsonLd = createBreadcrumbJsonLd(data as unknown as Array<{ name: string; url: string }>);
             break;
           case "FAQ":
-            jsonLd = createFAQJsonLd(data as Array<{ question: string; answer: string }>);
+            jsonLd = createFAQJsonLd(data as unknown as Array<{ question: string; answer: string }>);
             break;
           case "Product":
             jsonLd = createProductJsonLd(data as Parameters<typeof createProductJsonLd>[0]);