@shin1ohno/sage 0.8.4 → 0.8.7

package/dist/cli/mcp-handler.js

@@ -6,17 +6,22 @@
  */
 import { VERSION, SERVER_NAME } from '../version.js';
 import { ConfigLoader } from '../config/loader.js';
-import { SetupWizard } from '../setup/wizard.js';
-import { TaskAnalyzer } from '../tools/analyze-tasks.js';
 import { ReminderManager } from '../integrations/reminder-manager.js';
 import { CalendarService } from '../integrations/calendar-service.js';
 import { NotionMCPService } from '../integrations/notion-mcp.js';
 import { TodoListManager } from '../integrations/todo-list-manager.js';
 import { TaskSynchronizer } from '../integrations/task-synchronizer.js';
 import { CalendarEventResponseService } from '../integrations/calendar-event-response.js';
-import { CalendarEventCreatorService } from '../integrations/calendar-event-creator.js';
-import { CalendarEventDeleterService } from '../integrations/calendar-event-deleter.js';
 import { WorkingCadenceService } from '../services/working-cadence.js';
+import { CalendarSourceManager } from '../integrations/calendar-source-manager.js';
+import { GoogleCalendarService } from '../integrations/google-calendar-service.js';
+import { GoogleOAuthHandler } from '../oauth/google-oauth-handler.js';
+// Extracted tool handlers
+import { handleCheckSetupStatus, handleStartSetupWizard, handleAnswerWizardQuestion, handleSaveConfig, } from '../tools/setup/index.js';
+import { handleAnalyzeTasks, handleUpdateTaskStatus, handleSyncTasks, handleDetectDuplicates, } from '../tools/tasks/index.js';
+import { handleSetReminder, handleListTodos, } from '../tools/reminders/index.js';
+import { handleSyncToNotion, handleUpdateConfig, } from '../tools/integrations/index.js';
+import { handleListCalendarSources, handleListCalendarEvents, handleFindAvailableSlots, handleCreateCalendarEvent, handleRespondToCalendarEvent, handleRespondToCalendarEventsBatch, handleDeleteCalendarEvent, handleDeleteCalendarEventsBatch, } from '../tools/calendar/handlers.js';
 // Protocol version
 const PROTOCOL_VERSION = '2024-11-05';
 /**
@@ -31,9 +36,9 @@ class MCPHandlerImpl {
     todoListManager = null;
     taskSynchronizer = null;
     calendarEventResponseService = null;
-    calendarEventCreatorService = null;
-    calendarEventDeleterService = null;
     workingCadenceService = null;
+    calendarSourceManager = null;
+    googleCalendarService = null;
     initialized = false;
     tools = new Map();
     constructor() {
@@ -68,14 +73,92 @@ class MCPHandlerImpl {
             notionDatabaseId: userConfig.integrations.notion.databaseId,
         });
         this.calendarService = new CalendarService();
+        // Initialize Google Calendar service with OAuth handler
+        const oauthConfig = {
+            clientId: process.env.GOOGLE_CLIENT_ID || '',
+            clientSecret: process.env.GOOGLE_CLIENT_SECRET || '',
+            redirectUri: process.env.GOOGLE_REDIRECT_URI || 'http://localhost:3000/oauth/callback',
+        };
+        const oauthHandler = new GoogleOAuthHandler(oauthConfig);
+        this.googleCalendarService = new GoogleCalendarService(oauthHandler);
+        this.calendarSourceManager = new CalendarSourceManager({
+            calendarService: this.calendarService,
+            googleCalendarService: this.googleCalendarService,
+            config: userConfig,
+        });
         this.notionService = new NotionMCPService();
         this.todoListManager = new TodoListManager();
         this.taskSynchronizer = new TaskSynchronizer();
         this.calendarEventResponseService = new CalendarEventResponseService();
-        this.calendarEventCreatorService = new CalendarEventCreatorService();
-        this.calendarEventDeleterService = new CalendarEventDeleterService();
         this.workingCadenceService = new WorkingCadenceService();
     }
+    /**
+     * Create SetupContext for setup tool handlers
+     */
+    createSetupContext() {
+        return {
+            getConfig: () => this.config,
+            setConfig: (config) => {
+                this.config = config;
+            },
+            getWizardSession: () => this.wizardSession,
+            setWizardSession: (session) => {
+                this.wizardSession = session;
+            },
+            initializeServices: (config) => this.initializeServices(config),
+        };
+    }
+    /**
+     * Create TaskToolsContext for task tool handlers
+     */
+    createTaskToolsContext() {
+        return {
+            getConfig: () => this.config,
+            getTodoListManager: () => this.todoListManager,
+            getTaskSynchronizer: () => this.taskSynchronizer,
+            initializeServices: (config) => this.initializeServices(config),
+        };
+    }
+    /**
+     * Create ReminderTodoContext for reminder/todo tool handlers
+     */
+    createReminderTodoContext() {
+        return {
+            getConfig: () => this.config,
+            getReminderManager: () => this.reminderManager,
+            getTodoListManager: () => this.todoListManager,
+            initializeServices: (config) => this.initializeServices(config),
+        };
+    }
+    /**
+     * Create IntegrationToolsContext for integration tool handlers
+     */
+    createIntegrationToolsContext() {
+        return {
+            getConfig: () => this.config,
+            setConfig: (config) => {
+                this.config = config;
+            },
+            getNotionService: () => this.notionService,
+            initializeServices: (config) => this.initializeServices(config),
+        };
+    }
+    /**
+     * Create CalendarToolsContext for calendar tool handlers
+     */
+    createCalendarToolsContext() {
+        return {
+            getConfig: () => this.config,
+            getCalendarSourceManager: () => this.calendarSourceManager,
+            getCalendarEventResponseService: () => this.calendarEventResponseService,
+            getGoogleCalendarService: () => this.googleCalendarService,
+            getWorkingCadenceService: () => this.workingCadenceService,
+            setWorkingCadenceService: (service) => {
+                this.workingCadenceService = service;
+            },
+            initializeServices: (config) => this.initializeServices(config),
+        };
+    }
     /**
      * Handle an MCP request
      */
@@ -209,7 +292,7 @@ class MCPHandlerImpl {
      * Register all tools
      */
     registerTools() {
-        // check_setup_status
+        // check_setup_status - uses extracted handler
         this.registerTool({
             name: 'check_setup_status',
             description: 'Check if sage has been configured. Returns setup status and guidance.',
@@ -217,61 +300,8 @@ class MCPHandlerImpl {
                 type: 'object',
                 properties: {},
             },
-        }, async () => {
-            const exists = await ConfigLoader.exists();
-            const isValid = this.config !== null;
-            if (!exists) {
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                setupComplete: false,
-                                configExists: false,
-                                message: 'sageの初期設定が必要です。start_setup_wizardを実行してセットアップを開始してください。',
-                                nextAction: 'start_setup_wizard',
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-            if (!isValid) {
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                setupComplete: false,
-                                configExists: true,
-                                message: '設定ファイルが見つかりましたが、読み込みに失敗しました。設定を再作成してください。',
-                                nextAction: 'start_setup_wizard',
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            setupComplete: true,
-                            configExists: true,
-                            userName: this.config?.user.name,
-                            message: 'sageは設定済みです。タスク分析やリマインド設定を開始できます。',
-                            availableTools: [
-                                'analyze_tasks',
-                                'set_reminder',
-                                'find_available_slots',
-                                'sync_to_notion',
-                                'update_config',
-                            ],
-                        }, null, 2),
-                    },
-                ],
-            };
-        });
-        // start_setup_wizard
+        }, async () => handleCheckSetupStatus(this.createSetupContext()));
+        // start_setup_wizard - uses extracted handler
         this.registerTool({
             name: 'start_setup_wizard',
             description: 'Start the interactive setup wizard for sage. Returns the first question.',
@@ -285,34 +315,10 @@ class MCPHandlerImpl {
                     },
                 },
             },
-        }, async (args) => {
-            const mode = args.mode || 'full';
-            this.wizardSession = SetupWizard.createSession(mode);
-            const question = SetupWizard.getCurrentQuestion(this.wizardSession);
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            sessionId: this.wizardSession.sessionId,
-                            currentStep: this.wizardSession.currentStep,
-                            totalSteps: this.wizardSession.totalSteps,
-                            progress: Math.round((this.wizardSession.currentStep / this.wizardSession.totalSteps) * 100),
-                            question: {
-                                id: question.id,
-                                text: question.text,
-                                type: question.type,
-                                options: question.options,
-                                defaultValue: question.defaultValue,
-                                helpText: question.helpText,
-                            },
-                            message: 'セットアップを開始します。以下の質問に回答してください。',
-                        }, null, 2),
-                    },
-                ],
-            };
-        });
-        // answer_wizard_question
+        }, async (args) => handleStartSetupWizard(this.createSetupContext(), {
+            mode: args.mode,
+        }));
+        // answer_wizard_question - uses extracted handler
         this.registerTool({
             name: 'answer_wizard_question',
             description: 'Answer a question in the setup wizard and get the next question.',
@@ -330,77 +336,11 @@ class MCPHandlerImpl {
                 },
                 required: ['questionId', 'answer'],
             },
-        }, async (args) => {
-            const questionId = args.questionId;
-            const answer = args.answer;
-            if (!this.wizardSession) {
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                error: true,
-                                message: 'セットアップセッションが見つかりません。start_setup_wizardを実行してください。',
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-            const result = SetupWizard.answerQuestion(this.wizardSession, questionId, answer);
-            if (!result.success) {
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                error: true,
-                                message: result.error,
-                                currentQuestion: result.currentQuestion,
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-            if (result.isComplete) {
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                isComplete: true,
-                                sessionId: this.wizardSession.sessionId,
-                                answers: this.wizardSession.answers,
-                                message: 'すべての質問に回答しました。save_configを実行して設定を保存してください。',
-                                nextAction: 'save_config',
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-            const nextQuestion = SetupWizard.getCurrentQuestion(this.wizardSession);
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: true,
-                            currentStep: this.wizardSession.currentStep,
-                            totalSteps: this.wizardSession.totalSteps,
-                            progress: Math.round((this.wizardSession.currentStep / this.wizardSession.totalSteps) * 100),
-                            question: {
-                                id: nextQuestion.id,
-                                text: nextQuestion.text,
-                                type: nextQuestion.type,
-                                options: nextQuestion.options,
-                                defaultValue: nextQuestion.defaultValue,
-                                helpText: nextQuestion.helpText,
-                            },
-                        }, null, 2),
-                    },
-                ],
-            };
-        });
-        // save_config
+        }, async (args) => handleAnswerWizardQuestion(this.createSetupContext(), {
+            questionId: args.questionId,
+            answer: args.answer,
+        }));
+        // save_config - uses extracted handler
         this.registerTool({
             name: 'save_config',
             description: 'Save the configuration after completing the setup wizard.',
@@ -414,74 +354,10 @@ class MCPHandlerImpl {
                 },
                 required: ['confirm'],
             },
-        }, async (args) => {
-            const confirm = args.confirm;
-            if (!confirm) {
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                saved: false,
-                                message: '設定の保存がキャンセルされました。',
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-            if (!this.wizardSession) {
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                error: true,
-                                message: 'セットアップセッションが見つかりません。start_setup_wizardを実行してください。',
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-            try {
-                const newConfig = SetupWizard.buildConfig(this.wizardSession);
-                await ConfigLoader.save(newConfig);
-                this.config = newConfig;
-                this.wizardSession = null;
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                saved: true,
-                                configPath: ConfigLoader.getConfigPath(),
-                                userName: newConfig.user.name,
-                                message: `設定を保存しました。${newConfig.user.name}さん、sageをご利用いただきありがとうございます！`,
-                                availableTools: [
-                                    'analyze_tasks',
-                                    'set_reminder',
-                                    'find_available_slots',
-                                    'sync_to_notion',
-                                ],
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-            catch (error) {
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                error: true,
-                                message: `設定の保存に失敗しました: ${error instanceof Error ? error.message : 'Unknown error'}`,
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-        });
-        // analyze_tasks
+        }, async (args) => handleSaveConfig(this.createSetupContext(), {
+            confirm: args.confirm,
+        }));
+        // analyze_tasks - uses extracted handler
         this.registerTool({
             name: 'analyze_tasks',
             description: 'Analyze tasks to determine priority, estimate time, and identify stakeholders.',
@@ -507,61 +383,10 @@ class MCPHandlerImpl {
                 },
                 required: ['tasks'],
             },
-        }, async (args) => {
-            if (!this.config) {
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                error: true,
-                                message: 'sageが設定されていません。check_setup_statusを実行してください。',
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-            try {
-                const tasks = args.tasks;
-                const result = await TaskAnalyzer.analyzeTasks(tasks, this.config);
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                success: true,
-                                summary: result.summary,
-                                tasks: result.analyzedTasks.map((t) => ({
-                                    title: t.original.title,
-                                    description: t.original.description,
-                                    deadline: t.original.deadline,
-                                    priority: t.priority,
-                                    estimatedMinutes: t.estimatedMinutes,
-                                    stakeholders: t.stakeholders,
-                                    tags: t.tags,
-                                    reasoning: t.reasoning,
-                                    suggestedReminders: t.suggestedReminders,
-                                })),
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-            catch (error) {
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                error: true,
-                                message: `タスク分析に失敗しました: ${error instanceof Error ? error.message : 'Unknown error'}`,
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-        });
-        // set_reminder
+        }, async (args) => handleAnalyzeTasks(this.createTaskToolsContext(), {
+            tasks: args.tasks,
+        }));
+        // set_reminder - uses extracted handler
         this.registerTool({
             name: 'set_reminder',
             description: 'Set a reminder for a task in Apple Reminders or Notion.',
@@ -600,100 +425,15 @@ class MCPHandlerImpl {
                 },
                 required: ['taskTitle'],
             },
-        }, async (args) => {
-            if (!this.config) {
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                error: true,
-                                message: 'sageが設定されていません。check_setup_statusを実行してください。',
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-            if (!this.reminderManager) {
-                this.initializeServices(this.config);
-            }
-            try {
-                const result = await this.reminderManager.setReminder({
-                    taskTitle: args.taskTitle,
-                    targetDate: args.dueDate,
-                    reminderType: args.reminderType,
-                    list: args.list ?? this.config.integrations.appleReminders.defaultList,
-                    priority: args.priority,
-                    notes: args.notes,
-                });
-                if (result.success) {
-                    if (result.delegateToNotion && result.notionRequest) {
-                        return {
-                            content: [
-                                {
-                                    type: 'text',
-                                    text: JSON.stringify({
-                                        success: true,
-                                        destination: 'notion_mcp',
-                                        method: 'delegate',
-                                        delegateToNotion: true,
-                                        notionRequest: result.notionRequest,
-                                        message: `Notionへの追加はClaude Codeが直接notion-create-pagesツールを使用してください。`,
-                                    }, null, 2),
-                                },
-                            ],
-                        };
-                    }
-                    return {
-                        content: [
-                            {
-                                type: 'text',
-                                text: JSON.stringify({
-                                    success: true,
-                                    destination: result.destination,
-                                    method: result.method,
-                                    reminderId: result.reminderId,
-                                    reminderUrl: result.reminderUrl ?? result.pageUrl,
-                                    message: result.destination === 'apple_reminders'
-                                        ? `Apple Remindersにリマインダーを作成しました: ${args.taskTitle}`
-                                        : `Notionにタスクを作成しました: ${args.taskTitle}`,
-                                }, null, 2),
-                            },
-                        ],
-                    };
-                }
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                success: false,
-                                destination: result.destination,
-                                error: result.error,
-                                fallbackText: result.fallbackText,
-                                message: result.fallbackText
-                                    ? '自動作成に失敗しました。以下のテキストを手動でコピーしてください。'
-                                    : `リマインダー作成に失敗しました: ${result.error}`,
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-            catch (error) {
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                error: true,
-                                message: `リマインダー設定に失敗しました: ${error instanceof Error ? error.message : 'Unknown error'}`,
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-        });
-        // find_available_slots
+        }, async (args) => handleSetReminder(this.createReminderTodoContext(), {
+            taskTitle: args.taskTitle,
+            dueDate: args.dueDate,
+            reminderType: args.reminderType,
+            list: args.list,
+            priority: args.priority,
+            notes: args.notes,
+        }));
+        // find_available_slots - uses extracted handler
         this.registerTool({
             name: 'find_available_slots',
             description: 'Find available time slots in the calendar for scheduling tasks.',
@@ -719,110 +459,13 @@ class MCPHandlerImpl {
                 },
                 required: ['durationMinutes'],
             },
-        }, async (args) => {
-            if (!this.config) {
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                error: true,
-                                message: 'sageが設定されていません。check_setup_statusを実行してください。',
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-            if (!this.calendarService) {
-                this.initializeServices(this.config);
-            }
-            try {
-                const durationMinutes = args.durationMinutes;
-                const startDate = args.startDate;
-                const endDate = args.endDate;
-                const preferDeepWork = args.preferDeepWork;
-                const platformInfo = await this.calendarService.detectPlatform();
-                const isAvailable = await this.calendarService.isAvailable();
-                if (!isAvailable) {
-                    const searchStart = startDate ?? new Date().toISOString().split('T')[0];
-                    const searchEnd = endDate ??
-                        new Date(Date.now() + 7 * 24 * 60 * 60 * 1000).toISOString().split('T')[0];
-                    const manualPrompt = this.calendarService.generateManualInputPrompt(searchStart, searchEnd);
-                    return {
-                        content: [
-                            {
-                                type: 'text',
-                                text: JSON.stringify({
-                                    success: false,
-                                    platform: platformInfo.platform,
-                                    method: platformInfo.recommendedMethod,
-                                    message: 'カレンダー統合がこのプラットフォームで利用できません。手動で予定を入力してください。',
-                                    manualPrompt,
-                                }, null, 2),
-                            },
-                        ],
-                    };
-                }
-                const searchStart = startDate ?? new Date().toISOString().split('T')[0];
-                const searchEnd = endDate ??
-                    new Date(Date.now() + 7 * 24 * 60 * 60 * 1000).toISOString().split('T')[0];
-                const events = await this.calendarService.fetchEvents(searchStart, searchEnd);
-                const workingHours = {
-                    start: this.config.calendar.workingHours.start,
-                    end: this.config.calendar.workingHours.end,
-                };
-                const slots = this.calendarService.findAvailableSlotsFromEvents(events, durationMinutes, workingHours, searchStart);
-                const suitabilityConfig = {
-                    deepWorkDays: this.config.calendar.deepWorkDays,
-                    meetingHeavyDays: this.config.calendar.meetingHeavyDays,
-                };
-                const scoredSlots = slots.map((slot) => this.calendarService.calculateSuitability(slot, suitabilityConfig));
-                const filteredSlots = preferDeepWork
-                    ? scoredSlots.filter((s) => s.dayType === 'deep-work')
-                    : scoredSlots;
-                const suitabilityOrder = { excellent: 0, good: 1, acceptable: 2 };
-                filteredSlots.sort((a, b) => suitabilityOrder[a.suitability] - suitabilityOrder[b.suitability]);
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                success: true,
-                                platform: platformInfo.platform,
-                                method: platformInfo.recommendedMethod,
-                                searchRange: { start: searchStart, end: searchEnd },
-                                eventsFound: events.length,
-                                slots: filteredSlots.slice(0, 10).map((slot) => ({
-                                    start: slot.start,
-                                    end: slot.end,
-                                    durationMinutes: slot.durationMinutes,
-                                    suitability: slot.suitability,
-                                    dayType: slot.dayType,
-                                    reason: slot.reason,
-                                })),
-                                message: filteredSlots.length > 0
-                                    ? `${filteredSlots.length}件の空き時間が見つかりました。`
-                                    : '指定した条件に合う空き時間が見つかりませんでした。',
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-            catch (error) {
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                error: true,
-                                message: `カレンダー検索に失敗しました: ${error instanceof Error ? error.message : 'Unknown error'}`,
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-        });
-        // list_calendar_events
+        }, async (args) => handleFindAvailableSlots(this.createCalendarToolsContext(), {
+            durationMinutes: args.durationMinutes,
+            startDate: args.startDate,
+            endDate: args.endDate,
+            preferDeepWork: args.preferDeepWork,
+        }));
+        // list_calendar_events - uses extracted handler
         this.registerTool({
             name: 'list_calendar_events',
             description: 'List calendar events for a specified period. Returns events with details including calendar name and location.',
@@ -837,98 +480,19 @@ class MCPHandlerImpl {
                         type: 'string',
                         description: 'End date in ISO 8601 format (e.g., 2025-01-20)',
                     },
-                    calendarName: {
+                    calendarId: {
                         type: 'string',
-                        description: 'Optional: filter events by calendar name',
+                        description: 'Optional: filter events by calendar ID',
                     },
                 },
                 required: ['startDate', 'endDate'],
             },
-        }, async (args) => {
-            if (!this.config) {
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                error: true,
-                                message: 'sageが設定されていません。check_setup_statusを実行してください。',
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-            if (!this.calendarService) {
-                this.initializeServices(this.config);
-            }
-            try {
-                const startDate = args.startDate;
-                const endDate = args.endDate;
-                const calendarName = args.calendarName;
-                const platformInfo = await this.calendarService.detectPlatform();
-                const isAvailable = await this.calendarService.isAvailable();
-                if (!isAvailable) {
-                    return {
-                        content: [
-                            {
-                                type: 'text',
-                                text: JSON.stringify({
-                                    success: false,
-                                    platform: platformInfo.platform,
-                                    method: platformInfo.recommendedMethod,
-                                    message: 'カレンダー統合がこのプラットフォームで利用できません。macOSで実行してください。',
-                                }, null, 2),
-                            },
-                        ],
-                    };
-                }
-                const result = await this.calendarService.listEvents({
-                    startDate,
-                    endDate,
-                    calendarName,
-                });
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                success: true,
-                                platform: platformInfo.platform,
-                                method: platformInfo.recommendedMethod,
-                                events: result.events.map((event) => ({
-                                    id: event.id,
-                                    title: event.title,
-                                    start: event.start,
-                                    end: event.end,
-                                    isAllDay: event.isAllDay,
-                                    calendar: event.calendar,
-                                    location: event.location,
-                                })),
-                                period: result.period,
-                                totalEvents: result.totalEvents,
-                                message: result.totalEvents > 0
-                                    ? `${result.totalEvents}件のイベントが見つかりました。`
-                                    : '指定した期間にイベントが見つかりませんでした。',
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-            catch (error) {
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                error: true,
-                                message: `カレンダーイベントの取得に失敗しました: ${error instanceof Error ? error.message : 'Unknown error'}`,
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-        });
-        // sync_to_notion
+        }, async (args) => handleListCalendarEvents(this.createCalendarToolsContext(), {
+            startDate: args.startDate,
+            endDate: args.endDate,
+            calendarId: args.calendarId,
+        }));
+        // sync_to_notion - uses extracted handler
         this.registerTool({
             name: 'sync_to_notion',
             description: 'Sync a task to Notion database for long-term tracking.',
@@ -955,141 +519,15 @@ class MCPHandlerImpl {
                 },
                 required: ['taskTitle'],
             },
-        }, async (args) => {
-            if (!this.config) {
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                error: true,
-                                message: 'sageが設定されていません。check_setup_statusを実行してください。',
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-            if (!this.config.integrations.notion.enabled) {
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                error: true,
-                                message: 'Notion統合が有効になっていません。update_configでNotion設定を更新してください。',
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-            if (!this.notionService) {
-                this.initializeServices(this.config);
-            }
-            try {
-                const taskTitle = args.taskTitle;
-                const description = args.description;
-                const priority = args.priority;
-                const dueDate = args.dueDate;
-                const stakeholders = args.stakeholders;
-                const estimatedMinutes = args.estimatedMinutes;
-                const isAvailable = await this.notionService.isAvailable();
-                const properties = this.notionService.buildNotionProperties({
-                    title: taskTitle,
-                    priority,
-                    deadline: dueDate,
-                    stakeholders,
-                    estimatedMinutes,
-                    description,
-                });
-                if (!isAvailable) {
-                    const fallbackText = this.notionService.generateFallbackTemplate({
-                        title: taskTitle,
-                        priority,
-                        deadline: dueDate,
-                        stakeholders,
-                        estimatedMinutes,
-                        description,
-                    });
-                    return {
-                        content: [
-                            {
-                                type: 'text',
-                                text: JSON.stringify({
-                                    success: false,
-                                    method: 'fallback',
-                                    message: 'Notion MCP統合が利用できません。以下のテンプレートを手動でNotionにコピーしてください。',
-                                    fallbackText,
-                                    task: {
-                                        taskTitle,
-                                        priority: priority ?? 'P3',
-                                        dueDate,
-                                        stakeholders: stakeholders ?? [],
-                                        estimatedMinutes,
-                                    },
-                                }, null, 2),
-                            },
-                        ],
-                    };
-                }
-                const result = await this.notionService.createPage({
-                    databaseId: this.config.integrations.notion.databaseId,
-                    title: taskTitle,
-                    properties,
-                });
-                if (result.success) {
-                    return {
-                        content: [
-                            {
-                                type: 'text',
-                                text: JSON.stringify({
-                                    success: true,
-                                    method: 'mcp',
-                                    pageId: result.pageId,
-                                    pageUrl: result.pageUrl,
-                                    message: `Notionにタスクを同期しました: ${taskTitle}`,
-                                }, null, 2),
-                            },
-                        ],
-                    };
-                }
-                const fallbackText = this.notionService.generateFallbackTemplate({
-                    title: taskTitle,
-                    priority,
-                    deadline: dueDate,
-                    stakeholders,
-                    estimatedMinutes,
-                    description,
-                });
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                success: false,
-                                method: 'fallback',
-                                error: result.error,
-                                message: 'Notion MCP呼び出しに失敗しました。以下のテンプレートを手動でコピーしてください。',
-                                fallbackText,
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-            catch (error) {
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                error: true,
-                                message: `Notion同期に失敗しました: ${error instanceof Error ? error.message : 'Unknown error'}`,
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-        });
-        // update_config
+        }, async (args) => handleSyncToNotion(this.createIntegrationToolsContext(), {
+            taskTitle: args.taskTitle,
+            description: args.description,
+            priority: args.priority,
+            dueDate: args.dueDate,
+            stakeholders: args.stakeholders,
+            estimatedMinutes: args.estimatedMinutes,
+        }));
+        // update_config - uses extracted handler
         this.registerTool({
             name: 'update_config',
             description: 'Update sage configuration settings.',
@@ -1115,73 +553,11 @@ class MCPHandlerImpl {
                 },
                 required: ['section', 'updates'],
             },
-        }, async (args) => {
-            if (!this.config) {
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                error: true,
-                                message: 'sageが設定されていません。check_setup_statusを実行してください。',
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-            try {
-                const section = args.section;
-                const updates = args.updates;
-                const validationResult = this.validateConfigUpdate(section, updates);
-                if (!validationResult.valid) {
-                    return {
-                        content: [
-                            {
-                                type: 'text',
-                                text: JSON.stringify({
-                                    error: true,
-                                    message: `設定の検証に失敗しました: ${validationResult.error}`,
-                                    invalidFields: validationResult.invalidFields,
-                                }, null, 2),
-                            },
-                        ],
-                    };
-                }
-                const updatedConfig = this.applyConfigUpdates(this.config, section, updates);
-                await ConfigLoader.save(updatedConfig);
-                this.config = updatedConfig;
-                if (section === 'integrations') {
-                    this.initializeServices(this.config);
-                }
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                success: true,
-                                section,
-                                updatedFields: Object.keys(updates),
-                                message: `設定を更新しました: ${section}`,
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-            catch (error) {
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                error: true,
-                                message: `設定の更新に失敗しました: ${error instanceof Error ? error.message : 'Unknown error'}`,
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-        });
-        // list_todos
+        }, async (args) => handleUpdateConfig(this.createIntegrationToolsContext(), {
+            section: args.section,
+            updates: args.updates,
+        }));
+        // list_todos - uses extracted handler
         this.registerTool({
             name: 'list_todos',
             description: 'List TODO items from Apple Reminders and Notion with optional filtering.',
@@ -1214,90 +590,14 @@ class MCPHandlerImpl {
                     },
                 },
             },
-        }, async (args) => {
-            if (!this.config) {
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                error: true,
-                                message: 'sageが設定されていません。check_setup_statusを実行してください。',
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-            if (!this.todoListManager) {
-                this.initializeServices(this.config);
-            }
-            try {
-                const priority = args.priority;
-                const status = args.status;
-                const source = args.source;
-                const todayOnly = args.todayOnly;
-                const tags = args.tags;
-                let todos;
-                if (todayOnly) {
-                    todos = await this.todoListManager.getTodaysTasks();
-                }
-                else {
-                    todos = await this.todoListManager.listTodos({
-                        priority,
-                        status,
-                        source,
-                        tags,
-                    });
-                }
-                const formattedTodos = todos.map((todo) => ({
-                    id: todo.id,
-                    title: todo.title,
-                    priority: todo.priority,
-                    status: todo.status,
-                    dueDate: todo.dueDate,
-                    source: todo.source,
-                    tags: todo.tags,
-                    estimatedMinutes: todo.estimatedMinutes,
-                    stakeholders: todo.stakeholders,
-                }));
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                success: true,
-                                totalCount: todos.length,
-                                todos: formattedTodos,
-                                message: todos.length > 0
-                                    ? `${todos.length}件のタスクが見つかりました。`
-                                    : 'タスクが見つかりませんでした。',
-                                filters: {
-                                    priority,
-                                    status,
-                                    source,
-                                    todayOnly,
-                                    tags,
-                                },
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-            catch (error) {
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                error: true,
-                                message: `TODOリストの取得に失敗しました: ${error instanceof Error ? error.message : 'Unknown error'}`,
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-        });
-        // update_task_status
+        }, async (args) => handleListTodos(this.createReminderTodoContext(), {
+            priority: args.priority,
+            status: args.status,
+            source: args.source,
+            todayOnly: args.todayOnly,
+            tags: args.tags,
+        }));
+        // update_task_status - uses extracted handler
         this.registerTool({
             name: 'update_task_status',
             description: 'Update the status of a task in Apple Reminders or Notion.',
@@ -1322,80 +622,13 @@ class MCPHandlerImpl {
                 },
                 required: ['taskId', 'status', 'source'],
             },
-        }, async (args) => {
-            if (!this.config) {
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                error: true,
-                                message: 'sageが設定されていません。check_setup_statusを実行してください。',
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-            if (!this.todoListManager) {
-                this.initializeServices(this.config);
-            }
-            try {
-                const taskId = args.taskId;
-                const status = args.status;
-                const source = args.source;
-                const syncAcrossSources = args.syncAcrossSources;
-                const result = await this.todoListManager.updateTaskStatus(taskId, status, source);
-                if (!result.success) {
-                    return {
-                        content: [
-                            {
-                                type: 'text',
-                                text: JSON.stringify({
-                                    success: false,
-                                    taskId,
-                                    error: result.error,
-                                    message: `タスクステータスの更新に失敗しました: ${result.error}`,
-                                }, null, 2),
-                            },
-                        ],
-                    };
-                }
-                let syncResult;
-                if (syncAcrossSources) {
-                    syncResult = await this.todoListManager.syncTaskAcrossSources(taskId);
-                }
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                success: true,
-                                taskId,
-                                newStatus: status,
-                                updatedFields: result.updatedFields,
-                                syncedSources: result.syncedSources,
-                                syncResult: syncAcrossSources ? syncResult : undefined,
-                                message: `タスクのステータスを「${status}」に更新しました。`,
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-            catch (error) {
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                error: true,
-                                message: `タスクステータスの更新に失敗しました: ${error instanceof Error ? error.message : 'Unknown error'}`,
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-        });
-        // sync_tasks
+        }, async (args) => handleUpdateTaskStatus(this.createTaskToolsContext(), {
+            taskId: args.taskId,
+            status: args.status,
+            source: args.source,
+            syncAcrossSources: args.syncAcrossSources,
+        }));
+        // sync_tasks - uses extracted handler
         this.registerTool({
             name: 'sync_tasks',
             description: 'Synchronize tasks between Apple Reminders and Notion, detecting and resolving conflicts.',
@@ -1403,59 +636,8 @@ class MCPHandlerImpl {
                 type: 'object',
                 properties: {},
             },
-        }, async () => {
-            if (!this.config) {
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                error: true,
-                                message: 'sageが設定されていません。check_setup_statusを実行してください。',
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-            if (!this.taskSynchronizer) {
-                this.initializeServices(this.config);
-            }
-            try {
-                const result = await this.taskSynchronizer.syncAllTasks();
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                success: true,
-                                totalTasks: result.totalTasks,
-                                syncedTasks: result.syncedTasks,
-                                conflicts: result.conflicts,
-                                errors: result.errors,
-                                durationMs: result.duration,
-                                message: result.conflicts.length > 0
-                                    ? `${result.syncedTasks}件のタスクを同期しました。${result.conflicts.length}件の競合が検出されました。`
-                                    : `${result.syncedTasks}件のタスクを同期しました。`,
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-            catch (error) {
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                error: true,
-                                message: `タスク同期に失敗しました: ${error instanceof Error ? error.message : 'Unknown error'}`,
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-        });
-        // detect_duplicates
+        }, async () => handleSyncTasks(this.createTaskToolsContext()));
+        // detect_duplicates - uses extracted handler
         this.registerTool({
             name: 'detect_duplicates',
             description: 'Detect duplicate tasks between Apple Reminders and Notion.',
@@ -1468,82 +650,9 @@ class MCPHandlerImpl {
                     },
                 },
             },
-        }, async (args) => {
-            if (!this.config) {
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                error: true,
-                                message: 'sageが設定されていません。check_setup_statusを実行してください。',
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-            if (!this.taskSynchronizer) {
-                this.initializeServices(this.config);
-            }
-            try {
-                const autoMerge = args.autoMerge;
-                const duplicates = await this.taskSynchronizer.detectDuplicates();
-                const formattedDuplicates = duplicates.map((d) => ({
-                    tasks: d.tasks.map((t) => ({
-                        id: t.id,
-                        title: t.title,
-                        source: t.source,
-                        status: t.status,
-                        priority: t.priority,
-                    })),
-                    similarity: Math.round(d.similarity * 100),
-                    confidence: d.confidence,
-                    suggestedMerge: {
-                        title: d.suggestedMerge.title,
-                        priority: d.suggestedMerge.priority,
-                        status: d.suggestedMerge.status,
-                        tags: d.suggestedMerge.tags,
-                    },
-                }));
-                let mergeResults;
-                if (autoMerge) {
-                    const highConfidenceDuplicates = duplicates.filter((d) => d.confidence === 'high');
-                    if (highConfidenceDuplicates.length > 0) {
-                        mergeResults =
-                            await this.taskSynchronizer.mergeDuplicates(highConfidenceDuplicates);
-                    }
-                }
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                success: true,
-                                duplicatesFound: duplicates.length,
-                                duplicates: formattedDuplicates,
-                                mergeResults: autoMerge ? mergeResults : undefined,
-                                message: duplicates.length > 0
-                                    ? `${duplicates.length}件の重複タスクが検出されました。`
-                                    : '重複タスクは見つかりませんでした。',
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-            catch (error) {
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                error: true,
-                                message: `重複検出に失敗しました: ${error instanceof Error ? error.message : 'Unknown error'}`,
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-        });
+        }, async (args) => handleDetectDuplicates(this.createTaskToolsContext(), {
+            autoMerge: args.autoMerge,
+        }));
         // get_working_cadence
         this.registerTool({
             name: 'get_working_cadence',
@@ -1643,97 +752,11 @@ class MCPHandlerImpl {
                 },
                 required: ['eventId', 'response'],
             },
-        }, async (args) => {
-            if (!this.config) {
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                error: true,
-                                message: 'sageが設定されていません。check_setup_statusを実行してください。',
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-            if (!this.calendarEventResponseService) {
-                this.initializeServices(this.config);
-            }
-            try {
-                const eventId = args.eventId;
-                const response = args.response;
-                const comment = args.comment;
-                const isAvailable = await this.calendarEventResponseService.isEventKitAvailable();
-                if (!isAvailable) {
-                    return {
-                        content: [
-                            {
-                                type: 'text',
-                                text: JSON.stringify({
-                                    success: false,
-                                    message: 'カレンダーイベント返信機能はmacOSでのみ利用可能です。',
-                                }, null, 2),
-                            },
-                        ],
-                    };
-                }
-                const result = await this.calendarEventResponseService.respondToEvent({
-                    eventId,
-                    response,
-                    comment,
-                });
-                if (result.success) {
-                    return {
-                        content: [
-                            {
-                                type: 'text',
-                                text: JSON.stringify({
-                                    success: true,
-                                    eventId: result.eventId,
-                                    eventTitle: result.eventTitle,
-                                    newStatus: result.newStatus,
-                                    method: result.method,
-                                    instanceOnly: result.instanceOnly,
-                                    message: result.message,
-                                }, null, 2),
-                            },
-                        ],
-                    };
-                }
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                success: false,
-                                eventId: result.eventId,
-                                eventTitle: result.eventTitle,
-                                skipped: result.skipped,
-                                reason: result.reason,
-                                error: result.error,
-                                message: result.skipped
-                                    ? `イベントをスキップしました: ${result.reason}`
-                                    : `イベント返信に失敗しました: ${result.error}`,
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-            catch (error) {
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                error: true,
-                                message: `カレンダーイベント返信に失敗しました: ${error instanceof Error ? error.message : 'Unknown error'}`,
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-        });
+        }, async (args) => handleRespondToCalendarEvent(this.createCalendarToolsContext(), {
+            eventId: args.eventId,
+            response: args.response,
+            comment: args.comment,
+        }));
         // respond_to_calendar_events_batch
         this.registerTool({
             name: 'respond_to_calendar_events_batch',
@@ -1758,78 +781,11 @@ class MCPHandlerImpl {
                 },
                 required: ['eventIds', 'response'],
             },
-        }, async (args) => {
-            if (!this.config) {
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                error: true,
-                                message: 'sageが設定されていません。check_setup_statusを実行してください。',
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-            if (!this.calendarEventResponseService) {
-                this.initializeServices(this.config);
-            }
-            try {
-                const eventIds = args.eventIds;
-                const response = args.response;
-                const comment = args.comment;
-                const isAvailable = await this.calendarEventResponseService.isEventKitAvailable();
-                if (!isAvailable) {
-                    return {
-                        content: [
-                            {
-                                type: 'text',
-                                text: JSON.stringify({
-                                    success: false,
-                                    message: 'カレンダーイベント返信機能はmacOSでのみ利用可能です。',
-                                }, null, 2),
-                            },
-                        ],
-                    };
-                }
-                const result = await this.calendarEventResponseService.respondToEventsBatch({
-                    eventIds,
-                    response,
-                    comment,
-                });
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                success: result.success,
-                                summary: result.summary,
-                                details: {
-                                    succeeded: result.details.succeeded,
-                                    skipped: result.details.skipped,
-                                    failed: result.details.failed,
-                                },
-                                message: result.message,
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-            catch (error) {
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                error: true,
-                                message: `カレンダーイベント一括返信に失敗しました: ${error instanceof Error ? error.message : 'Unknown error'}`,
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-        });
+        }, async (args) => handleRespondToCalendarEventsBatch(this.createCalendarToolsContext(), {
+            eventIds: args.eventIds,
+            response: args.response,
+            comment: args.comment,
+        }));
         // create_calendar_event
         this.registerTool({
             name: 'create_calendar_event',
@@ -1860,100 +816,14 @@ class MCPHandlerImpl {
                 },
                 required: ['title', 'startDate', 'endDate'],
             },
-        }, async (args) => {
-            if (!this.config) {
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                error: true,
-                                message: 'sageが設定されていません。check_setup_statusを実行してください。',
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-            if (!this.calendarEventCreatorService) {
-                this.initializeServices(this.config);
-            }
-            try {
-                const title = args.title;
-                const startDate = args.startDate;
-                const endDate = args.endDate;
-                const location = args.location;
-                const notes = args.notes;
-                const calendarName = args.calendarName;
-                const alarms = args.alarms;
-                const isAvailable = await this.calendarEventCreatorService.isEventKitAvailable();
-                if (!isAvailable) {
-                    return {
-                        content: [
-                            {
-                                type: 'text',
-                                text: JSON.stringify({
-                                    success: false,
-                                    message: 'カレンダーイベント作成機能はmacOSでのみ利用可能です。',
-                                }, null, 2),
-                            },
-                        ],
-                    };
-                }
-                const result = await this.calendarEventCreatorService.createEvent({
-                    title,
-                    startDate,
-                    endDate,
-                    location,
-                    notes,
-                    calendarName,
-                    alarms,
-                });
-                if (result.success) {
-                    return {
-                        content: [
-                            {
-                                type: 'text',
-                                text: JSON.stringify({
-                                    success: true,
-                                    eventId: result.eventId,
-                                    title: result.title,
-                                    startDate: result.startDate,
-                                    endDate: result.endDate,
-                                    calendarName: result.calendarName,
-                                    isAllDay: result.isAllDay,
-                                    message: result.message,
-                                }, null, 2),
-                            },
-                        ],
-                    };
-                }
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                success: false,
-                                error: result.error,
-                                message: result.message,
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-            catch (error) {
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                error: true,
-                                message: `カレンダーイベント作成に失敗しました: ${error instanceof Error ? error.message : 'Unknown error'}`,
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-        });
+        }, async (args) => handleCreateCalendarEvent(this.createCalendarToolsContext(), {
+            title: args.title,
+            startDate: args.startDate,
+            endDate: args.endDate,
+            location: args.location,
+            notes: args.notes,
+            calendarName: args.calendarName,
+        }));
         // delete_calendar_event
         this.registerTool({
             name: 'delete_calendar_event',
@@ -1972,88 +842,9 @@ class MCPHandlerImpl {
                 },
                 required: ['eventId'],
             },
-        }, async (args) => {
-            if (!this.config) {
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                error: true,
-                                message: 'sageが設定されていません。check_setup_statusを実行してください。',
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-            if (!this.calendarEventDeleterService) {
-                this.initializeServices(this.config);
-            }
-            try {
-                const eventId = args.eventId;
-                const calendarName = args.calendarName;
-                const isAvailable = await this.calendarEventDeleterService.isEventKitAvailable();
-                if (!isAvailable) {
-                    return {
-                        content: [
-                            {
-                                type: 'text',
-                                text: JSON.stringify({
-                                    success: false,
-                                    message: 'カレンダーイベント削除機能はmacOSでのみ利用可能です。',
-                                }, null, 2),
-                            },
-                        ],
-                    };
-                }
-                const result = await this.calendarEventDeleterService.deleteEvent({
-                    eventId,
-                    calendarName,
-                });
-                if (result.success) {
-                    return {
-                        content: [
-                            {
-                                type: 'text',
-                                text: JSON.stringify({
-                                    success: true,
-                                    eventId: result.eventId,
-                                    title: result.title,
-                                    calendarName: result.calendarName,
-                                    message: result.message,
-                                }, null, 2),
-                            },
-                        ],
-                    };
-                }
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                success: false,
-                                eventId: result.eventId,
-                                error: result.error,
-                                message: result.message,
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-            catch (error) {
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                error: true,
-                                message: `カレンダーイベント削除に失敗しました: ${error instanceof Error ? error.message : 'Unknown error'}`,
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-        });
+        }, async (args) => handleDeleteCalendarEvent(this.createCalendarToolsContext(), {
+            eventId: args.eventId,
+        }));
         // delete_calendar_events_batch
         this.registerTool({
             name: 'delete_calendar_events_batch',
@@ -2073,80 +864,18 @@ class MCPHandlerImpl {
                 },
                 required: ['eventIds'],
             },
-        }, async (args) => {
-            if (!this.config) {
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                error: true,
-                                message: 'sageが設定されていません。check_setup_statusを実行してください。',
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-            if (!this.calendarEventDeleterService) {
-                this.initializeServices(this.config);
-            }
-            try {
-                const eventIds = args.eventIds;
-                const calendarName = args.calendarName;
-                const isAvailable = await this.calendarEventDeleterService.isEventKitAvailable();
-                if (!isAvailable) {
-                    return {
-                        content: [
-                            {
-                                type: 'text',
-                                text: JSON.stringify({
-                                    success: false,
-                                    message: 'カレンダーイベント削除機能はmacOSでのみ利用可能です。',
-                                }, null, 2),
-                            },
-                        ],
-                    };
-                }
-                const result = await this.calendarEventDeleterService.deleteEventsBatch({
-                    eventIds,
-                    calendarName,
-                });
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                success: result.success,
-                                totalCount: result.totalCount,
-                                successCount: result.successCount,
-                                failedCount: result.failedCount,
-                                results: result.results.map((r) => ({
-                                    eventId: r.eventId,
-                                    success: r.success,
-                                    title: r.title,
-                                    calendarName: r.calendarName,
-                                    error: r.error,
-                                })),
-                                message: result.message,
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-            catch (error) {
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                error: true,
-                                message: `カレンダーイベント一括削除に失敗しました: ${error instanceof Error ? error.message : 'Unknown error'}`,
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-        });
+        }, async (args) => handleDeleteCalendarEventsBatch(this.createCalendarToolsContext(), {
+            eventIds: args.eventIds,
+        }));
+        // list_calendar_sources - uses extracted handler
+        this.registerTool({
+            name: 'list_calendar_sources',
+            description: 'List available and enabled calendar sources.',
+            inputSchema: {
+                type: 'object',
+                properties: {},
+            },
+        }, async () => handleListCalendarSources(this.createCalendarToolsContext()));
     }
     /**
      * Register a tool
@@ -2154,108 +883,6 @@ class MCPHandlerImpl {
     registerTool(definition, handler) {
         this.tools.set(definition.name, { definition, handler });
     }
-    /**
-     * Validate config updates
-     */
-    validateConfigUpdate(section, updates) {
-        const invalidFields = [];
-        switch (section) {
-            case 'user':
-                if (updates.name !== undefined && typeof updates.name !== 'string') {
-                    invalidFields.push('name');
-                }
-                if (updates.timezone !== undefined && typeof updates.timezone !== 'string') {
-                    invalidFields.push('timezone');
-                }
-                break;
-            case 'calendar':
-                if (updates.workingHours !== undefined) {
-                    const wh = updates.workingHours;
-                    if (!wh.start || !wh.end) {
-                        invalidFields.push('workingHours');
-                    }
-                }
-                if (updates.deepWorkDays !== undefined && !Array.isArray(updates.deepWorkDays)) {
-                    invalidFields.push('deepWorkDays');
-                }
-                if (updates.meetingHeavyDays !== undefined &&
-                    !Array.isArray(updates.meetingHeavyDays)) {
-                    invalidFields.push('meetingHeavyDays');
-                }
-                break;
-            case 'integrations':
-                if (updates.notion !== undefined) {
-                    const notion = updates.notion;
-                    if (notion.enabled === true && !notion.databaseId) {
-                        invalidFields.push('notion.databaseId');
-                    }
-                }
-                break;
-            case 'team':
-                if (updates.members !== undefined && !Array.isArray(updates.members)) {
-                    invalidFields.push('members');
-                }
-                if (updates.managers !== undefined && !Array.isArray(updates.managers)) {
-                    invalidFields.push('managers');
-                }
-                break;
-        }
-        if (invalidFields.length > 0) {
-            return {
-                valid: false,
-                error: `無効なフィールド: ${invalidFields.join(', ')}`,
-                invalidFields,
-            };
-        }
-        return { valid: true };
-    }
-    /**
-     * Apply config updates
-     */
-    applyConfigUpdates(currentConfig, section, updates) {
-        const newConfig = { ...currentConfig };
-        switch (section) {
-            case 'user':
-                newConfig.user = { ...newConfig.user, ...updates };
-                break;
-            case 'calendar':
-                newConfig.calendar = {
-                    ...newConfig.calendar,
-                    ...updates,
-                };
-                break;
-            case 'priorityRules':
-                newConfig.priorityRules = {
-                    ...newConfig.priorityRules,
-                    ...updates,
-                };
-                break;
-            case 'integrations':
-                if (updates.appleReminders) {
-                    newConfig.integrations.appleReminders = {
-                        ...newConfig.integrations.appleReminders,
-                        ...updates.appleReminders,
-                    };
-                }
-                if (updates.notion) {
-                    newConfig.integrations.notion = {
-                        ...newConfig.integrations.notion,
-                        ...updates.notion,
-                    };
-                }
-                break;
-            case 'team':
-                newConfig.team = { ...newConfig.team, ...updates };
-                break;
-            case 'preferences':
-                newConfig.preferences = {
-                    ...newConfig.preferences,
-                    ...updates,
-                };
-                break;
-        }
-        return newConfig;
-    }
 }
 /**
  * Create an MCP handler