codingbuddy 2.0.0 → 2.1.0

package/dist/src/mcp/handlers/skill.handler.js

@@ -0,0 +1,111 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SkillHandler = void 0;
+const common_1 = require("@nestjs/common");
+const skill_recommendation_service_1 = require("../../skill/skill-recommendation.service");
+const response_utils_1 = require("../response.utils");
+const security_utils_1 = require("../../shared/security.utils");
+const validation_constants_1 = require("../../shared/validation.constants");
+let SkillHandler = class SkillHandler {
+    constructor(skillRecommendationService) {
+        this.skillRecommendationService = skillRecommendationService;
+        this.handledTools = ['recommend_skills', 'list_skills'];
+    }
+    async handle(toolName, args) {
+        if (!this.handledTools.includes(toolName)) {
+            return null;
+        }
+        const validation = (0, security_utils_1.sanitizeHandlerArgs)(args);
+        if (!validation.safe) {
+            return (0, response_utils_1.createErrorResponse)(validation.error);
+        }
+        switch (toolName) {
+            case 'recommend_skills':
+                return this.handleRecommendSkills(args);
+            case 'list_skills':
+                return this.handleListSkills(args);
+            default:
+                return null;
+        }
+    }
+    getToolDefinitions() {
+        return [
+            {
+                name: 'recommend_skills',
+                description: 'Recommend skills based on user prompt with multi-language support',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        prompt: {
+                            type: 'string',
+                            description: 'User prompt to analyze for skill recommendations',
+                        },
+                    },
+                    required: ['prompt'],
+                },
+            },
+            {
+                name: 'list_skills',
+                description: 'List all available skills with optional filtering',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        minPriority: {
+                            type: 'number',
+                            description: 'Minimum priority threshold (inclusive)',
+                        },
+                        maxPriority: {
+                            type: 'number',
+                            description: 'Maximum priority threshold (inclusive)',
+                        },
+                    },
+                    required: [],
+                },
+            },
+        ];
+    }
+    handleRecommendSkills(args) {
+        const prompt = (0, validation_constants_1.extractRequiredString)(args, 'prompt');
+        if (prompt === null) {
+            return (0, response_utils_1.createErrorResponse)('Missing required parameter: prompt');
+        }
+        try {
+            const result = this.skillRecommendationService.recommendSkills(prompt);
+            return (0, response_utils_1.createJsonResponse)(result);
+        }
+        catch (error) {
+            return (0, response_utils_1.createErrorResponse)(`Failed to recommend skills: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    handleListSkills(args) {
+        try {
+            const options = {};
+            if (typeof args?.minPriority === 'number') {
+                options.minPriority = args.minPriority;
+            }
+            if (typeof args?.maxPriority === 'number') {
+                options.maxPriority = args.maxPriority;
+            }
+            const result = this.skillRecommendationService.listSkills(options);
+            return (0, response_utils_1.createJsonResponse)(result);
+        }
+        catch (error) {
+            return (0, response_utils_1.createErrorResponse)(`Failed to list skills: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+};
+exports.SkillHandler = SkillHandler;
+exports.SkillHandler = SkillHandler = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [skill_recommendation_service_1.SkillRecommendationService])
+], SkillHandler);
+//# sourceMappingURL=skill.handler.js.map

package/dist/src/mcp/handlers/skill.handler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"skill.handler.js","sourceRoot":"","sources":["../../../../src/mcp/handlers/skill.handler.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,2CAA4C;AAE5C,2FAAsF;AAEtF,sDAA4E;AAC5E,gEAAkE;AAClE,4EAA0E;AAQnE,IAAM,YAAY,GAAlB,MAAM,YAAY;IAGvB,YACmB,0BAAsD;QAAtD,+BAA0B,GAA1B,0BAA0B,CAA4B;QAHxD,iBAAY,GAAG,CAAC,kBAAkB,EAAE,aAAa,CAAC,CAAC;IAIjE,CAAC;IAEJ,KAAK,CAAC,MAAM,CACV,QAAgB,EAChB,IAAyC;QAEzC,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE,CAAC;YAC1C,OAAO,IAAI,CAAC;QACd,CAAC;QAGD,MAAM,UAAU,GAAG,IAAA,oCAAmB,EAAC,IAAI,CAAC,CAAC;QAC7C,IAAI,CAAC,UAAU,CAAC,IAAI,EAAE,CAAC;YACrB,OAAO,IAAA,oCAAmB,EAAC,UAAU,CAAC,KAAM,CAAC,CAAC;QAChD,CAAC;QAED,QAAQ,QAAQ,EAAE,CAAC;YACjB,KAAK,kBAAkB;gBACrB,OAAO,IAAI,CAAC,qBAAqB,CAAC,IAAI,CAAC,CAAC;YAC1C,KAAK,aAAa;gBAChB,OAAO,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,CAAC;YACrC;gBACE,OAAO,IAAI,CAAC;QAChB,CAAC;IACH,CAAC;IAED,kBAAkB;QAChB,OAAO;YACL;gBACE,IAAI,EAAE,kBAAkB;gBACxB,WAAW,EACT,mEAAmE;gBACrE,WAAW,EAAE;oBACX,IAAI,EAAE,QAAQ;oBACd,UAAU,EAAE;wBACV,MAAM,EAAE;4BACN,IAAI,EAAE,QAAQ;4BACd,WAAW,EAAE,kDAAkD;yBAChE;qBACF;oBACD,QAAQ,EAAE,CAAC,QAAQ,CAAC;iBACrB;aACF;YACD;gBACE,IAAI,EAAE,aAAa;gBACnB,WAAW,EAAE,mDAAmD;gBAChE,WAAW,EAAE;oBACX,IAAI,EAAE,QAAQ;oBACd,UAAU,EAAE;wBACV,WAAW,EAAE;4BACX,IAAI,EAAE,QAAQ;4BACd,WAAW,EAAE,wCAAwC;yBACtD;wBACD,WAAW,EAAE;4BACX,IAAI,EAAE,QAAQ;4BACd,WAAW,EAAE,wCAAwC;yBACtD;qBACF;oBACD,QAAQ,EAAE,EAAE;iBACb;aACF;SACF,CAAC;IACJ,CAAC;IAEO,qBAAqB,CAC3B,IAAyC;QAEzC,MAAM,MAAM,GAAG,IAAA,4CAAqB,EAAC,IAAI,EAAE,QAAQ,CAAC,CAAC;QACrD,IAAI,MAAM,KAAK,IAAI,EAAE,CAAC;YACpB,OAAO,IAAA,oCAAmB,EAAC,oCAAoC,CAAC,CAAC;QACnE,CAAC;QACD,IAAI,CAAC;YACH,MAAM,MAAM,GAAG,IAAI,CAAC,0BAA0B,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC;YACvE,OAAO,IAAA,mCAAkB,EAAC,MAAM,CAAC,CAAC;QACpC,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,OAAO,IAAA,oCAAmB,EACxB,+BAA+B,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,eAAe,EAAE,CAC1F,CAAC;QACJ,CAAC;IACH,CAAC;IAEO,gBAAgB,CACtB,IAAyC;QAEzC,IAAI,CAAC;YACH,MAAM,OAAO,GAAsB,EAAE,CAAC;YAEtC,IAAI,OAAO,IAAI,EAAE,WAAW,KAAK,QAAQ,EAAE,CAAC;gBAC1C,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC,WAAW,CAAC;YACzC,CAAC;YACD,IAAI,OAAO,IAAI,EAAE,WAAW,KAAK,QAAQ,EAAE,CAAC;gBAC1C,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC,WAAW,CAAC;YACzC,CAAC;YAED,MAAM,MAAM,GAAG,IAAI,CAAC,0BAA0B,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;YACnE,OAAO,IAAA,mCAAkB,EAAC,MAAM,CAAC,CAAC;QACpC,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,OAAO,IAAA,oCAAmB,EACxB,0BAA0B,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,eAAe,EAAE,CACrF,CAAC;QACJ,CAAC;IACH,CAAC;CACF,CAAA;AA3GY,oCAAY;uBAAZ,YAAY;IADxB,IAAA,mBAAU,GAAE;qCAKoC,yDAA0B;GAJ9D,YAAY,CA2GxB"}

package/dist/src/mcp/mcp.module.js

@@ -15,8 +15,20 @@ const keyword_module_1 = require("../keyword/keyword.module");
 const config_module_1 = require("../config/config.module");
 const analyzer_module_1 = require("../analyzer/analyzer.module");
 const agent_module_1 = require("../agent/agent.module");
+const checklist_module_1 = require("../checklist/checklist.module");
+const context_module_1 = require("../context/context.module");
 const skill_recommendation_service_1 = require("../skill/skill-recommendation.service");
 const language_service_1 = require("../shared/language.service");
+const model_1 = require("../model");
+const handlers_1 = require("./handlers");
+const handlers = [
+    handlers_1.RulesHandler,
+    handlers_1.ConfigHandler,
+    handlers_1.SkillHandler,
+    handlers_1.AgentHandler,
+    handlers_1.ModeHandler,
+    handlers_1.ChecklistContextHandler,
+];
 let McpModule = class McpModule {
 };
 exports.McpModule = McpModule;
@@ -28,9 +40,22 @@ exports.McpModule = McpModule = __decorate([
             config_module_1.CodingBuddyConfigModule,
             analyzer_module_1.AnalyzerModule,
             agent_module_1.AgentModule,
+            checklist_module_1.ChecklistModule,
+            context_module_1.ContextModule,
         ],
         controllers: [mcp_controller_1.McpController],
-        providers: [mcp_service_1.McpService, skill_recommendation_service_1.SkillRecommendationService, language_service_1.LanguageService],
+        providers: [
+            mcp_service_1.McpService,
+            skill_recommendation_service_1.SkillRecommendationService,
+            language_service_1.LanguageService,
+            model_1.ModelResolverService,
+            ...handlers,
+            {
+                provide: handlers_1.TOOL_HANDLERS,
+                useFactory: (...handlerInstances) => handlerInstances,
+                inject: handlers,
+            },
+        ],
         exports: [mcp_service_1.McpService],
     })
 ], McpModule);

package/dist/src/mcp/mcp.module.js.map

@@ -1 +1 @@
-{"version":3,"file":"mcp.module.js","sourceRoot":"","sources":["../../../src/mcp/mcp.module.ts"],"names":[],"mappings":";;;;;;;;;AAAA,2CAAwC;AACxC,+CAA2C;AAC3C,qDAAiD;AACjD,wDAAoD;AACpD,8DAA0D;AAC1D,2DAAkE;AAClE,iEAA6D;AAC7D,wDAAoD;AACpD,wFAAmF;AACnF,iEAA6D;AActD,IAAM,SAAS,GAAf,MAAM,SAAS;CAAG,CAAA;AAAZ,8BAAS;oBAAT,SAAS;IAZrB,IAAA,eAAM,EAAC;QACN,OAAO,EAAE;YACP,0BAAW;YACX,8BAAa;YACb,uCAAuB;YACvB,gCAAc;YACd,0BAAW;SACZ;QACD,WAAW,EAAE,CAAC,8BAAa,CAAC;QAC5B,SAAS,EAAE,CAAC,wBAAU,EAAE,yDAA0B,EAAE,kCAAe,CAAC;QACpE,OAAO,EAAE,CAAC,wBAAU,CAAC;KACtB,CAAC;GACW,SAAS,CAAG"}
+{"version":3,"file":"mcp.module.js","sourceRoot":"","sources":["../../../src/mcp/mcp.module.ts"],"names":[],"mappings":";;;;;;;;;AAAA,2CAAwC;AACxC,+CAA2C;AAC3C,qDAAiD;AACjD,wDAAoD;AACpD,8DAA0D;AAC1D,2DAAkE;AAClE,iEAA6D;AAC7D,wDAAoD;AACpD,oEAAgE;AAChE,8DAA0D;AAC1D,wFAAmF;AACnF,iEAA6D;AAC7D,oCAAgD;AAGhD,yCAQoB;AAEpB,MAAM,QAAQ,GAAG;IACf,uBAAY;IACZ,wBAAa;IACb,uBAAY;IACZ,uBAAY;IACZ,sBAAW;IACX,kCAAuB;CACxB,CAAC;AA6BK,IAAM,SAAS,GAAf,MAAM,SAAS;CAAG,CAAA;AAAZ,8BAAS;oBAAT,SAAS;IA3BrB,IAAA,eAAM,EAAC;QACN,OAAO,EAAE;YACP,0BAAW;YACX,8BAAa;YACb,uCAAuB;YACvB,gCAAc;YACd,0BAAW;YACX,kCAAe;YACf,8BAAa;SACd;QACD,WAAW,EAAE,CAAC,8BAAa,CAAC;QAC5B,SAAS,EAAE;YACT,wBAAU;YACV,yDAA0B;YAC1B,kCAAe;YACf,4BAAoB;YACpB,GAAG,QAAQ;YACX;gBACE,OAAO,EAAE,wBAAa;gBACtB,UAAU,EAAE,CACV,GAAG,gBAA2D,EAC9D,EAAE,CAAC,gBAAgB;gBACrB,MAAM,EAAE,QAAQ;aACjB;SACF;QACD,OAAO,EAAE,CAAC,wBAAU,CAAC;KACtB,CAAC;GACW,SAAS,CAAG"}

package/dist/src/mcp/mcp.service.d.ts

@@ -1,25 +1,15 @@
 import { OnModuleInit } from '@nestjs/common';
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { RulesService } from '../rules/rules.service';
-import { KeywordService } from '../keyword/keyword.service';
 import { ConfigService } from '../config/config.service';
-import { ConfigDiffService } from '../config/config-diff.service';
-import { AnalyzerService } from '../analyzer/analyzer.service';
-import { SkillRecommendationService } from '../skill/skill-recommendation.service';
-import { LanguageService } from '../shared/language.service';
-import { AgentService } from '../agent/agent.service';
+import type { ToolHandler } from './handlers';
 export declare class McpService implements OnModuleInit {
     private rulesService;
-    private keywordService;
     private configService;
-    private configDiffService;
-    private analyzerService;
-    private skillRecommendationService;
-    private languageService;
-    private agentService;
+    private toolHandlers;
     private server;
     private readonly logger;
-    constructor(rulesService: RulesService, keywordService: KeywordService, configService: ConfigService, configDiffService: ConfigDiffService, analyzerService: AnalyzerService, skillRecommendationService: SkillRecommendationService, languageService: LanguageService, agentService: AgentService);
+    constructor(rulesService: RulesService, configService: ConfigService, toolHandlers: ToolHandler[]);
     onModuleInit(): void;
     startStdio(): Promise<void>;
     getServer(): Server<{
@@ -59,17 +49,5 @@ export declare class McpService implements OnModuleInit {
     private registerResources;
     private registerTools;
     private registerPrompts;
-    private handleSearchRules;
-    private handleGetAgentDetails;
-    private handleParseMode;
-    private resolveModelForMode;
-    private loadGlobalDefaultModel;
-    private loadModeModel;
-    private handleGetProjectConfig;
-    private handleSuggestConfigUpdates;
-    private handleRecommendSkills;
-    private handleListSkills;
-    private handleGetAgentSystemPrompt;
-    private handlePrepareParallelAgents;
     private formatProjectContext;
 }

package/dist/src/mcp/mcp.service.js

@@ -19,26 +19,13 @@ const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
 const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
 const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
 const rules_service_1 = require("../rules/rules.service");
-const keyword_service_1 = require("../keyword/keyword.service");
-const keyword_module_1 = require("../keyword/keyword.module");
 const config_service_1 = require("../config/config.service");
-const config_diff_service_1 = require("../config/config-diff.service");
-const analyzer_service_1 = require("../analyzer/analyzer.service");
-const skill_recommendation_service_1 = require("../skill/skill-recommendation.service");
-const language_service_1 = require("../shared/language.service");
-const agent_service_1 = require("../agent/agent.service");
-const response_utils_1 = require("./response.utils");
-const model_1 = require("../model");
+const handlers_1 = require("./handlers");
 let McpService = McpService_1 = class McpService {
-    constructor(rulesService, keywordService, configService, configDiffService, analyzerService, skillRecommendationService, languageService, agentService) {
+    constructor(rulesService, configService, toolHandlers) {
         this.rulesService = rulesService;
-        this.keywordService = keywordService;
         this.configService = configService;
-        this.configDiffService = configDiffService;
-        this.analyzerService = analyzerService;
-        this.skillRecommendationService = skillRecommendationService;
-        this.languageService = languageService;
-        this.agentService = agentService;
+        this.toolHandlers = toolHandlers;
         this.logger = new common_1.Logger(McpService_1.name);
         this.server = new index_js_1.Server({
             name: 'codingbuddy-rules-server',
@@ -139,190 +126,18 @@ let McpService = McpService_1 = class McpService {
     }
     registerTools() {
         this.server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => {
-            return {
-                tools: [
-                    {
-                        name: 'search_rules',
-                        description: 'Search for rules and guidelines',
-                        inputSchema: {
-                            type: 'object',
-                            properties: {
-                                query: { type: 'string', description: 'Search query' },
-                            },
-                            required: ['query'],
-                        },
-                    },
-                    {
-                        name: 'get_agent_details',
-                        description: 'Get detailed profile of a specific AI agent',
-                        inputSchema: {
-                            type: 'object',
-                            properties: {
-                                agentName: { type: 'string', description: 'Name of the agent' },
-                            },
-                            required: ['agentName'],
-                        },
-                    },
-                    {
-                        name: 'parse_mode',
-                        description: 'MANDATORY: When user message starts with PLAN, ACT, or EVAL keyword (or localized equivalents: Korean 계획/실행/평가, Japanese 計画/実行/評価, Chinese 计划/执行/评估, Spanish PLANIFICAR/ACTUAR/EVALUAR), you MUST call this tool FIRST before any other action. This tool parses the workflow mode and returns critical rules that MUST be followed. Failure to call this tool when these keywords are present is a protocol violation.',
-                        inputSchema: {
-                            type: 'object',
-                            properties: {
-                                prompt: {
-                                    type: 'string',
-                                    description: 'User prompt that may start with PLAN/ACT/EVAL keyword',
-                                },
-                            },
-                            required: ['prompt'],
-                        },
-                    },
-                    {
-                        name: 'get_project_config',
-                        description: 'Get project configuration including tech stack, architecture, conventions, and language settings',
-                        inputSchema: {
-                            type: 'object',
-                            properties: {},
-                            required: [],
-                        },
-                    },
-                    {
-                        name: 'suggest_config_updates',
-                        description: 'Analyze the project and suggest config updates based on detected changes (new frameworks, dependencies, patterns)',
-                        inputSchema: {
-                            type: 'object',
-                            properties: {
-                                projectRoot: {
-                                    type: 'string',
-                                    description: 'Project root directory (defaults to current working directory)',
-                                },
-                            },
-                            required: [],
-                        },
-                    },
-                    {
-                        name: 'recommend_skills',
-                        description: 'Recommend skills based on user prompt with multi-language support',
-                        inputSchema: {
-                            type: 'object',
-                            properties: {
-                                prompt: {
-                                    type: 'string',
-                                    description: 'User prompt to analyze for skill recommendations',
-                                },
-                            },
-                            required: ['prompt'],
-                        },
-                    },
-                    {
-                        name: 'list_skills',
-                        description: 'List all available skills with optional filtering',
-                        inputSchema: {
-                            type: 'object',
-                            properties: {
-                                minPriority: {
-                                    type: 'number',
-                                    description: 'Minimum priority threshold (inclusive)',
-                                },
-                                maxPriority: {
-                                    type: 'number',
-                                    description: 'Maximum priority threshold (inclusive)',
-                                },
-                            },
-                            required: [],
-                        },
-                    },
-                    {
-                        name: 'get_agent_system_prompt',
-                        description: 'Get complete system prompt for a specialist agent to be executed as a Claude Code subagent. Use this to prepare an agent for parallel execution via Task tool.',
-                        inputSchema: {
-                            type: 'object',
-                            properties: {
-                                agentName: {
-                                    type: 'string',
-                                    description: 'Name of the specialist agent (e.g., security-specialist, accessibility-specialist)',
-                                },
-                                context: {
-                                    type: 'object',
-                                    description: 'Context for the agent',
-                                    properties: {
-                                        mode: {
-                                            type: 'string',
-                                            enum: ['PLAN', 'ACT', 'EVAL'],
-                                            description: 'Current workflow mode',
-                                        },
-                                        targetFiles: {
-                                            type: 'array',
-                                            items: { type: 'string' },
-                                            description: 'Files to analyze or review',
-                                        },
-                                        taskDescription: {
-                                            type: 'string',
-                                            description: 'Description of the task',
-                                        },
-                                    },
-                                    required: ['mode'],
-                                },
-                            },
-                            required: ['agentName', 'context'],
-                        },
-                    },
-                    {
-                        name: 'prepare_parallel_agents',
-                        description: 'Prepare multiple specialist agents for parallel execution via Claude Code Task tool. Returns prompts and hints for launching agents concurrently.',
-                        inputSchema: {
-                            type: 'object',
-                            properties: {
-                                mode: {
-                                    type: 'string',
-                                    enum: ['PLAN', 'ACT', 'EVAL'],
-                                    description: 'Current workflow mode',
-                                },
-                                specialists: {
-                                    type: 'array',
-                                    items: { type: 'string' },
-                                    description: 'List of specialist agent names (e.g., ["security-specialist", "accessibility-specialist"])',
-                                },
-                                targetFiles: {
-                                    type: 'array',
-                                    items: { type: 'string' },
-                                    description: 'Files to analyze or review',
-                                },
-                                sharedContext: {
-                                    type: 'string',
-                                    description: 'Shared context or task description for all agents',
-                                },
-                            },
-                            required: ['mode', 'specialists'],
-                        },
-                    },
-                ],
-            };
+            const tools = this.toolHandlers.flatMap(handler => handler.getToolDefinitions());
+            return { tools };
         });
         this.server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
             const { name, arguments: args } = request.params;
-            switch (name) {
-                case 'search_rules':
-                    return this.handleSearchRules(args);
-                case 'get_agent_details':
-                    return this.handleGetAgentDetails(args);
-                case 'parse_mode':
-                    return this.handleParseMode(args);
-                case 'get_project_config':
-                    return this.handleGetProjectConfig();
-                case 'suggest_config_updates':
-                    return this.handleSuggestConfigUpdates(args);
-                case 'recommend_skills':
-                    return this.handleRecommendSkills(args);
-                case 'list_skills':
-                    return this.handleListSkills(args);
-                case 'get_agent_system_prompt':
-                    return this.handleGetAgentSystemPrompt(args);
-                case 'prepare_parallel_agents':
-                    return this.handlePrepareParallelAgents(args);
-                default:
-                    throw new types_js_1.McpError(types_js_1.ErrorCode.MethodNotFound, `Tool not found: ${name}`);
+            for (const handler of this.toolHandlers) {
+                const result = await handler.handle(name, args);
+                if (result !== null) {
+                    return result;
+                }
             }
+            throw new types_js_1.McpError(types_js_1.ErrorCode.MethodNotFound, `Tool not found: ${name}`);
         });
     }
     registerPrompts() {
@@ -372,168 +187,6 @@ let McpService = McpService_1 = class McpService {
             throw new types_js_1.McpError(types_js_1.ErrorCode.MethodNotFound, 'Prompt not found');
         });
     }
-    async handleSearchRules(args) {
-        const query = String(args?.query);
-        const results = await this.rulesService.searchRules(query);
-        return (0, response_utils_1.createJsonResponse)(results);
-    }
-    async handleGetAgentDetails(args) {
-        const agentName = String(args?.agentName);
-        try {
-            const agent = await this.rulesService.getAgent(agentName);
-            const agentModel = agent.model;
-            const resolvedModel = (0, model_1.resolveModel)({ agentModel });
-            return (0, response_utils_1.createJsonResponse)({
-                ...agent,
-                resolvedModel,
-            });
-        }
-        catch {
-            return (0, response_utils_1.createErrorResponse)(`Agent '${agentName}' not found.`);
-        }
-    }
-    async handleParseMode(args) {
-        const prompt = String(args?.prompt ?? '');
-        try {
-            const result = await this.keywordService.parseMode(prompt);
-            const language = await this.configService.getLanguage();
-            const languageInstructionResult = this.languageService.getLanguageInstruction(language || 'en');
-            const resolvedModel = await this.resolveModelForMode(result.agent);
-            return (0, response_utils_1.createJsonResponse)({
-                ...result,
-                language,
-                languageInstruction: languageInstructionResult.instruction,
-                resolvedModel,
-            });
-        }
-        catch (error) {
-            return (0, response_utils_1.createErrorResponse)(`Failed to parse mode: ${error instanceof Error ? error.message : 'Unknown error'}`);
-        }
-    }
-    async resolveModelForMode(modeAgentName) {
-        const globalDefaultModel = await this.loadGlobalDefaultModel();
-        const modeModel = await this.loadModeModel(modeAgentName);
-        return (0, model_1.resolveModel)({ modeModel, globalDefaultModel });
-    }
-    async loadGlobalDefaultModel() {
-        try {
-            const globalConfig = await this.configService.getSettings();
-            return globalConfig?.ai?.defaultModel;
-        }
-        catch (error) {
-            this.logger.warn(`Failed to load global config for model resolution: ${error instanceof Error ? error.message : 'Unknown error'}. Using system default.`);
-            return undefined;
-        }
-    }
-    async loadModeModel(agentName) {
-        if (!agentName)
-            return undefined;
-        try {
-            const modeAgent = await this.rulesService.getAgent(agentName);
-            return (0, model_1.isModelConfig)(modeAgent.model) ? modeAgent.model : undefined;
-        }
-        catch (error) {
-            this.logger.warn(`Failed to load mode agent '${agentName}' for model resolution: ${error instanceof Error ? error.message : 'Unknown error'}. Using fallback.`);
-            return undefined;
-        }
-    }
-    async handleGetProjectConfig() {
-        try {
-            const settings = await this.configService.getSettings();
-            return (0, response_utils_1.createJsonResponse)(settings);
-        }
-        catch (error) {
-            return (0, response_utils_1.createErrorResponse)(`Failed to get project config: ${error instanceof Error ? error.message : 'Unknown error'}`);
-        }
-    }
-    async handleSuggestConfigUpdates(args) {
-        try {
-            const projectRoot = String(args?.projectRoot ?? process.cwd());
-            const analysis = await this.analyzerService.analyzeProject(projectRoot);
-            await this.configService.reload();
-            const currentConfig = await this.configService.getSettings();
-            const result = this.configDiffService.compareConfig(analysis, currentConfig);
-            return (0, response_utils_1.createJsonResponse)(result);
-        }
-        catch (error) {
-            return (0, response_utils_1.createErrorResponse)(`Failed to suggest config updates: ${error instanceof Error ? error.message : 'Unknown error'}`);
-        }
-    }
-    handleRecommendSkills(args) {
-        const prompt = args?.prompt;
-        if (typeof prompt !== 'string') {
-            return (0, response_utils_1.createErrorResponse)('Missing required parameter: prompt');
-        }
-        try {
-            const result = this.skillRecommendationService.recommendSkills(prompt);
-            return (0, response_utils_1.createJsonResponse)(result);
-        }
-        catch (error) {
-            return (0, response_utils_1.createErrorResponse)(`Failed to recommend skills: ${error instanceof Error ? error.message : 'Unknown error'}`);
-        }
-    }
-    handleListSkills(args) {
-        try {
-            const options = {};
-            if (typeof args?.minPriority === 'number') {
-                options.minPriority = args.minPriority;
-            }
-            if (typeof args?.maxPriority === 'number') {
-                options.maxPriority = args.maxPriority;
-            }
-            const result = this.skillRecommendationService.listSkills(options);
-            return (0, response_utils_1.createJsonResponse)(result);
-        }
-        catch (error) {
-            return (0, response_utils_1.createErrorResponse)(`Failed to list skills: ${error instanceof Error ? error.message : 'Unknown error'}`);
-        }
-    }
-    async handleGetAgentSystemPrompt(args) {
-        const agentName = args?.agentName;
-        const context = args?.context;
-        if (typeof agentName !== 'string') {
-            return (0, response_utils_1.createErrorResponse)('Missing required parameter: agentName');
-        }
-        if (!context || typeof context.mode !== 'string') {
-            return (0, response_utils_1.createErrorResponse)('Missing required parameter: context.mode (PLAN, ACT, or EVAL)');
-        }
-        if (!['PLAN', 'ACT', 'EVAL'].includes(context.mode)) {
-            return (0, response_utils_1.createErrorResponse)(`Invalid mode: ${context.mode}. Must be PLAN, ACT, or EVAL`);
-        }
-        try {
-            const result = await this.agentService.getAgentSystemPrompt(agentName, {
-                mode: context.mode,
-                targetFiles: context.targetFiles,
-                taskDescription: context.taskDescription,
-            });
-            return (0, response_utils_1.createJsonResponse)(result);
-        }
-        catch (error) {
-            return (0, response_utils_1.createErrorResponse)(`Failed to get agent system prompt: ${error instanceof Error ? error.message : 'Unknown error'}`);
-        }
-    }
-    async handlePrepareParallelAgents(args) {
-        const mode = args?.mode;
-        const specialists = args?.specialists;
-        const targetFiles = args?.targetFiles;
-        const sharedContext = args?.sharedContext;
-        if (typeof mode !== 'string') {
-            return (0, response_utils_1.createErrorResponse)('Missing required parameter: mode (PLAN, ACT, or EVAL)');
-        }
-        if (!['PLAN', 'ACT', 'EVAL'].includes(mode)) {
-            return (0, response_utils_1.createErrorResponse)(`Invalid mode: ${mode}. Must be PLAN, ACT, or EVAL`);
-        }
-        if (!Array.isArray(specialists) || specialists.length === 0) {
-            return (0, response_utils_1.createErrorResponse)('Missing required parameter: specialists (array of agent names)');
-        }
-        try {
-            const result = await this.agentService.prepareParallelAgents(mode, specialists, targetFiles, sharedContext);
-            return (0, response_utils_1.createJsonResponse)(result);
-        }
-        catch (error) {
-            return (0, response_utils_1.createErrorResponse)(`Failed to prepare parallel agents: ${error instanceof Error ? error.message : 'Unknown error'}`);
-        }
-    }
     formatProjectContext(settings) {
         const sections = ['Project Context:'];
         if (settings.projectName) {
@@ -578,14 +231,8 @@ let McpService = McpService_1 = class McpService {
 exports.McpService = McpService;
 exports.McpService = McpService = McpService_1 = __decorate([
     (0, common_1.Injectable)(),
-    __param(1, (0, common_1.Inject)(keyword_module_1.KEYWORD_SERVICE)),
+    __param(2, (0, common_1.Inject)(handlers_1.TOOL_HANDLERS)),
     __metadata("design:paramtypes", [rules_service_1.RulesService,
-        keyword_service_1.KeywordService,
-        config_service_1.ConfigService,
-        config_diff_service_1.ConfigDiffService,
-        analyzer_service_1.AnalyzerService,
-        skill_recommendation_service_1.SkillRecommendationService,
-        language_service_1.LanguageService,
-        agent_service_1.AgentService])
+        config_service_1.ConfigService, Array])
 ], McpService);
 //# sourceMappingURL=mcp.service.js.map