@shin1ohno/sage 0.7.9 → 0.8.6

package/dist/index.js

@@ -9,135 +9,35 @@ import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod";
 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 { CalendarSourceManager } from "./integrations/calendar-source-manager.js";
+import { GoogleCalendarService } from "./integrations/google-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 { VERSION, SERVER_NAME } from "./version.js";
+import { createErrorFromCatch } from "./utils/mcp-response.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 { handleFindAvailableSlots, handleListCalendarEvents, handleRespondToCalendarEvent, handleRespondToCalendarEventsBatch, handleCreateCalendarEvent, handleDeleteCalendarEvent, handleDeleteCalendarEventsBatch, handleListCalendarSources, handleGetWorkingCadence, } from "./tools/calendar/index.js";
+import { handleSetReminder, handleListTodos, } from "./tools/reminders/index.js";
+import { handleSyncToNotion, handleUpdateConfig, } from "./tools/integrations/index.js";
 // Global state
 let config = null;
 let wizardSession = null;
 let reminderManager = null;
 let calendarService = null;
+let googleCalendarService = null;
+let calendarSourceManager = null;
 let notionService = null;
 let todoListManager = null;
 let taskSynchronizer = null;
 let calendarEventResponseService = null;
-let calendarEventCreatorService = null;
-let calendarEventDeleterService = null;
 let workingCadenceService = null;
-/**
- * Validate config updates for a specific section
- */
-function 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 to a specific section
- */
-function 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":
-            // Deep merge for 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;
-}
 /**
  * Initialize services with config
  */
@@ -149,14 +49,90 @@ function initializeServices(userConfig) {
         notionDatabaseId: userConfig.integrations.notion.databaseId,
     });
     calendarService = new CalendarService();
+    // Initialize Google Calendar service if configured
+    // Note: GoogleCalendarService requires GoogleOAuthHandler which needs OAuth config
+    // For now, we initialize with a stub handler. Full OAuth setup will be done in Task 33.
+    try {
+        const { GoogleOAuthHandler } = require('./oauth/google-oauth-handler.js');
+        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);
+        googleCalendarService = new GoogleCalendarService(oauthHandler);
+    }
+    catch (error) {
+        // If Google Calendar initialization fails, continue without it
+        console.error('Google Calendar service initialization failed:', error);
+        googleCalendarService = null;
+    }
+    calendarSourceManager = new CalendarSourceManager({
+        calendarService,
+        googleCalendarService: googleCalendarService || undefined,
+        config: userConfig,
+    });
     notionService = new NotionMCPService();
     todoListManager = new TodoListManager();
     taskSynchronizer = new TaskSynchronizer();
     calendarEventResponseService = new CalendarEventResponseService();
-    calendarEventCreatorService = new CalendarEventCreatorService();
-    calendarEventDeleterService = new CalendarEventDeleterService();
     workingCadenceService = new WorkingCadenceService();
 }
+// ============================================
+// Context Factory Functions
+// ============================================
+function createSetupContext() {
+    return {
+        getConfig: () => config,
+        setConfig: (c) => {
+            config = c;
+        },
+        getWizardSession: () => wizardSession,
+        setWizardSession: (session) => {
+            wizardSession = session;
+        },
+        initializeServices,
+    };
+}
+function createTaskToolsContext() {
+    return {
+        getConfig: () => config,
+        getTodoListManager: () => todoListManager,
+        getTaskSynchronizer: () => taskSynchronizer,
+        initializeServices,
+    };
+}
+function createCalendarToolsContext() {
+    return {
+        getConfig: () => config,
+        getCalendarSourceManager: () => calendarSourceManager,
+        getCalendarEventResponseService: () => calendarEventResponseService,
+        getGoogleCalendarService: () => googleCalendarService,
+        getWorkingCadenceService: () => workingCadenceService,
+        setWorkingCadenceService: (service) => {
+            workingCadenceService = service;
+        },
+        initializeServices,
+    };
+}
+function createReminderTodoContext() {
+    return {
+        getConfig: () => config,
+        getReminderManager: () => reminderManager,
+        getTodoListManager: () => todoListManager,
+        initializeServices,
+    };
+}
+function createIntegrationToolsContext() {
+    return {
+        getConfig: () => config,
+        setConfig: (c) => {
+            config = c;
+        },
+        getNotionService: () => notionService,
+        initializeServices,
+    };
+}
 /**
  * Initialize the MCP server with all tools
  */
@@ -176,257 +152,27 @@ async function createServer() {
         config = null;
     }
     // ============================================
-    // Setup & Configuration Tools
+    // Setup & Configuration Tools - uses extracted handlers
     // ============================================
-    /**
-     * check_setup_status - Check if initial setup is complete
-     * Requirement: 1.1, 1.2
-     */
-    server.tool("check_setup_status", "Check if sage has been configured. Returns setup status and guidance.", {}, async () => {
-        const exists = await ConfigLoader.exists();
-        const isValid = 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: config?.user.name,
-                        message: "sageは設定済みです。タスク分析やリマインド設定を開始できます。",
-                        availableTools: [
-                            "analyze_tasks",
-                            "set_reminder",
-                            "find_available_slots",
-                            "sync_to_notion",
-                            "update_config",
-                        ],
-                    }, null, 2),
-                },
-            ],
-        };
-    });
-    /**
-     * start_setup_wizard - Begin the interactive setup process
-     * Requirement: 1.3
-     */
+    server.tool("check_setup_status", "Check if sage has been configured. Returns setup status and guidance.", {}, async () => handleCheckSetupStatus(createSetupContext()));
     server.tool("start_setup_wizard", "Start the interactive setup wizard for sage. Returns the first question.", {
         mode: z
             .enum(["full", "quick"])
             .optional()
             .describe("Setup mode: full (all questions) or quick (essential only)"),
-    }, async ({ mode = "full" }) => {
-        wizardSession = SetupWizard.createSession(mode);
-        const question = SetupWizard.getCurrentQuestion(wizardSession);
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: JSON.stringify({
-                        sessionId: wizardSession.sessionId,
-                        currentStep: wizardSession.currentStep,
-                        totalSteps: wizardSession.totalSteps,
-                        progress: Math.round((wizardSession.currentStep / 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 - Answer a setup wizard question
-     * Requirement: 1.3, 1.4
-     */
+    }, async ({ mode }) => handleStartSetupWizard(createSetupContext(), { mode: mode ?? "full" }));
     server.tool("answer_wizard_question", "Answer a question in the setup wizard and get the next question.", {
         questionId: z.string().describe("The ID of the question being answered"),
         answer: z
             .union([z.string(), z.array(z.string())])
             .describe("The answer to the question"),
-    }, async ({ questionId, answer }) => {
-        if (!wizardSession) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            error: true,
-                            message: "セットアップセッションが見つかりません。start_setup_wizardを実行してください。",
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-        const result = SetupWizard.answerQuestion(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: wizardSession.sessionId,
-                            answers: wizardSession.answers,
-                            message: "すべての質問に回答しました。save_configを実行して設定を保存してください。",
-                            nextAction: "save_config",
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-        const nextQuestion = SetupWizard.getCurrentQuestion(wizardSession);
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: JSON.stringify({
-                        success: true,
-                        currentStep: wizardSession.currentStep,
-                        totalSteps: wizardSession.totalSteps,
-                        progress: Math.round((wizardSession.currentStep / 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 - Save the configuration from the setup wizard
-     * Requirement: 1.4, 1.5, 1.6
-     */
+    }, async ({ questionId, answer }) => handleAnswerWizardQuestion(createSetupContext(), { questionId, answer }));
     server.tool("save_config", "Save the configuration after completing the setup wizard.", {
         confirm: z.boolean().describe("Confirm saving the configuration"),
-    }, async ({ confirm }) => {
-        if (!confirm) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            saved: false,
-                            message: "設定の保存がキャンセルされました。",
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-        if (!wizardSession) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            error: true,
-                            message: "セットアップセッションが見つかりません。start_setup_wizardを実行してください。",
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-        try {
-            const newConfig = SetupWizard.buildConfig(wizardSession);
-            await ConfigLoader.save(newConfig);
-            config = newConfig;
-            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),
-                    },
-                ],
-            };
-        }
-    });
+    }, async ({ confirm }) => handleSaveConfig(createSetupContext(), { confirm }));
     // ============================================
-    // Task Analysis Tools (placeholder)
+    // Task Analysis Tools - uses extracted handlers
     // ============================================
-    /**
-     * analyze_tasks - Analyze tasks and provide prioritization
-     * Requirement: 2.1-2.6, 3.1-3.2, 4.1-4.5
-     */
     server.tool("analyze_tasks", "Analyze tasks to determine priority, estimate time, and identify stakeholders.", {
         tasks: z
             .array(z.object({
@@ -438,63 +184,8 @@ async function createServer() {
                 .describe("Task deadline (ISO 8601 format)"),
         }))
             .describe("List of tasks to analyze"),
-    }, async ({ tasks }) => {
-        if (!config) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            error: true,
-                            message: "sageが設定されていません。check_setup_statusを実行してください。",
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-        try {
-            const result = await TaskAnalyzer.analyzeTasks(tasks, 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 - Set a reminder for a task
-     * Requirement: 5.1-5.6
-     */
+    }, async ({ tasks }) => handleAnalyzeTasks(createTaskToolsContext(), { tasks }));
+    // set_reminder - uses extracted handler
     server.tool("set_reminder", "Set a reminder for a task in Apple Reminders or Notion.", {
         taskTitle: z.string().describe("Title of the task"),
         dueDate: z
@@ -523,108 +214,16 @@ async function createServer() {
             .string()
             .optional()
             .describe("Additional notes for the reminder"),
-    }, async ({ taskTitle, dueDate, reminderType, list, priority, notes }) => {
-        if (!config) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            error: true,
-                            message: "sageが設定されていません。check_setup_statusを実行してください。",
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-        if (!reminderManager) {
-            initializeServices(config);
-        }
-        try {
-            const result = await reminderManager.setReminder({
-                taskTitle,
-                targetDate: dueDate,
-                reminderType,
-                list: list ?? config.integrations.appleReminders.defaultList,
-                priority: priority,
-                notes,
-            });
-            if (result.success) {
-                // Check if this is a delegation request for Notion
-                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ツールを使用してください。`,
-                                    instruction: `notion-create-pagesツールを以下のパラメータで呼び出してください:
-- parent: { "type": "data_source_id", "data_source_id": "${result.notionRequest.databaseId.replace(/-/g, "")}" }
-- pages: [{ "properties": ${JSON.stringify(result.notionRequest.properties)} }]`,
-                                }, 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にリマインダーを作成しました: ${taskTitle}`
-                                    : `Notionにタスクを作成しました: ${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 - Find available time slots in calendar
-     * Requirement: 3.3-3.6, 6.1-6.6
-     */
-    server.tool("find_available_slots", "Find available time slots in the calendar for scheduling tasks.", {
+    }, async ({ taskTitle, dueDate, reminderType, list, priority, notes }) => handleSetReminder(createReminderTodoContext(), {
+        taskTitle,
+        dueDate,
+        reminderType,
+        list,
+        priority,
+        notes,
+    }));
+    // find_available_slots - uses extracted handler
+    server.tool("find_available_slots", "Find available time slots in the calendar for scheduling tasks from all enabled calendar sources.", {
         durationMinutes: z.number().describe("Required duration in minutes"),
         startDate: z
             .string()
@@ -638,217 +237,41 @@ async function createServer() {
             .boolean()
             .optional()
             .describe("Prefer deep work time slots"),
-    }, async ({ durationMinutes, startDate, endDate, preferDeepWork }) => {
-        if (!config) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            error: true,
-                            message: "sageが設定されていません。check_setup_statusを実行してください。",
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-        if (!calendarService) {
-            initializeServices(config);
-        }
-        try {
-            // Check platform availability
-            const platformInfo = await calendarService.detectPlatform();
-            const isAvailable = await calendarService.isAvailable();
-            if (!isAvailable) {
-                // Return manual input prompt for unsupported platforms
-                const manualPrompt = calendarService.generateManualInputPrompt(startDate ?? new Date().toISOString().split("T")[0], endDate ??
-                    new Date(Date.now() + 7 * 24 * 60 * 60 * 1000)
-                        .toISOString()
-                        .split("T")[0]);
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: JSON.stringify({
-                                success: false,
-                                platform: platformInfo.platform,
-                                method: platformInfo.recommendedMethod,
-                                message: "カレンダー統合がこのプラットフォームで利用できません。手動で予定を入力してください。",
-                                manualPrompt,
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-            // Fetch events from calendar
-            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 calendarService.fetchEvents(searchStart, searchEnd);
-            // Find available slots
-            const workingHours = {
-                start: config.calendar.workingHours.start,
-                end: config.calendar.workingHours.end,
-            };
-            const slots = calendarService.findAvailableSlotsFromEvents(events, durationMinutes, workingHours, searchStart);
-            // Apply suitability scoring
-            const suitabilityConfig = {
-                deepWorkDays: config.calendar.deepWorkDays,
-                meetingHeavyDays: config.calendar.meetingHeavyDays,
-            };
-            const scoredSlots = slots.map((slot) => calendarService.calculateSuitability(slot, suitabilityConfig));
-            // Filter for deep work preference if requested
-            const filteredSlots = preferDeepWork
-                ? scoredSlots.filter((s) => s.dayType === "deep-work")
-                : scoredSlots;
-            // Sort by suitability (excellent > good > acceptable)
-            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 - List calendar events for a specified period
-     * Requirement: 16.1-16.12
-     */
-    server.tool("list_calendar_events", "List calendar events for a specified period. Returns events with details including calendar name and location.", {
+        minDurationMinutes: z
+            .number()
+            .optional()
+            .describe("Minimum slot duration in minutes (default: 25)"),
+        maxDurationMinutes: z
+            .number()
+            .optional()
+            .describe("Maximum slot duration in minutes (default: 480)"),
+    }, async ({ durationMinutes, startDate, endDate, preferDeepWork, minDurationMinutes, maxDurationMinutes }) => handleFindAvailableSlots(createCalendarToolsContext(), {
+        durationMinutes,
+        startDate,
+        endDate,
+        preferDeepWork,
+        minDurationMinutes,
+        maxDurationMinutes,
+    }));
+    // list_calendar_events - uses extracted handler
+    server.tool("list_calendar_events", "List calendar events for a specified period from enabled sources (EventKit, Google Calendar, or both). Returns events with details including calendar name and location.", {
         startDate: z
             .string()
             .describe("Start date in ISO 8601 format (e.g., 2025-01-15)"),
         endDate: z
             .string()
             .describe("End date in ISO 8601 format (e.g., 2025-01-20)"),
-        calendarName: z
+        calendarId: z
             .string()
             .optional()
-            .describe("Optional: filter events by calendar name"),
-    }, async ({ startDate, endDate, calendarName }) => {
-        if (!config) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            error: true,
-                            message: "sageが設定されていません。check_setup_statusを実行してください。",
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-        if (!calendarService) {
-            initializeServices(config);
-        }
-        try {
-            // Check platform availability
-            const platformInfo = await calendarService.detectPlatform();
-            const isAvailable = await calendarService.isAvailable();
-            if (!isAvailable) {
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: JSON.stringify({
-                                success: false,
-                                platform: platformInfo.platform,
-                                method: platformInfo.recommendedMethod,
-                                message: "カレンダー統合がこのプラットフォームで利用できません。macOSで実行してください。",
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-            // List events
-            const result = await 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),
-                    },
-                ],
-            };
-        }
-    });
-    /**
-     * respond_to_calendar_event - Respond to a single calendar event
-     * Requirement: 17.1, 17.2, 17.5-17.11
-     */
-    server.tool("respond_to_calendar_event", "Respond to a calendar event with accept, decline, or tentative. Use this to RSVP to meeting invitations.", {
+            .describe("Optional: filter events by calendar ID or name"),
+    }, async ({ startDate, endDate, calendarId }) => handleListCalendarEvents(createCalendarToolsContext(), {
+        startDate,
+        endDate,
+        calendarId,
+    }));
+    // respond_to_calendar_event - uses extracted handler
+    server.tool("respond_to_calendar_event", "Respond to a calendar event with accept, decline, or tentative. Supports both EventKit (macOS) and Google Calendar events. Use this to RSVP to meeting invitations from any enabled calendar source.", {
         eventId: z.string().describe("The ID of the calendar event to respond to"),
         response: z
             .enum(["accept", "decline", "tentative"])
@@ -856,102 +279,23 @@ async function createServer() {
         comment: z
             .string()
             .optional()
-            .describe("Optional comment to include with the response (e.g., '年末年始休暇のため')"),
-    }, async ({ eventId, response, comment }) => {
-        if (!config) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            error: true,
-                            message: "sageが設定されていません。check_setup_statusを実行してください。",
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-        if (!calendarEventResponseService) {
-            initializeServices(config);
-        }
-        try {
-            // Check platform availability
-            const isAvailable = await calendarEventResponseService.isEventKitAvailable();
-            if (!isAvailable) {
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: JSON.stringify({
-                                success: false,
-                                message: "カレンダーイベント返信機能はmacOSでのみ利用可能です。",
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-            // Respond to the event
-            const result = await 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),
-                        },
-                    ],
-                };
-            }
-            // Handle skipped or failed response
-            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),
-                    },
-                ],
-            };
-        }
-    });
-    /**
-     * respond_to_calendar_events_batch - Respond to multiple calendar events
-     * Requirement: 17.3, 17.4, 17.12
-     */
+            .describe("Optional comment to include with the response (e.g., '年末年始休暇のため'). Note: Comments are only supported for EventKit events."),
+        source: z
+            .enum(["eventkit", "google"])
+            .optional()
+            .describe("Optional: Specify the calendar source explicitly. If not provided, will try Google Calendar first, then EventKit."),
+        calendarId: z
+            .string()
+            .optional()
+            .describe("Optional: Google Calendar ID (defaults to 'primary'). Only used for Google Calendar events."),
+    }, async ({ eventId, response, comment, source, calendarId }) => handleRespondToCalendarEvent(createCalendarToolsContext(), {
+        eventId,
+        response,
+        comment,
+        source,
+        calendarId,
+    }));
+    // respond_to_calendar_events_batch - uses extracted handler
     server.tool("respond_to_calendar_events_batch", "Respond to multiple calendar events at once. Useful for declining all events during vacation or leave periods.", {
         eventIds: z
             .array(z.string())
@@ -963,82 +307,13 @@ async function createServer() {
             .string()
             .optional()
             .describe("Optional comment to include with all responses (e.g., '年末年始休暇のため')"),
-    }, async ({ eventIds, response, comment }) => {
-        if (!config) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            error: true,
-                            message: "sageが設定されていません。check_setup_statusを実行してください。",
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-        if (!calendarEventResponseService) {
-            initializeServices(config);
-        }
-        try {
-            // Check platform availability
-            const isAvailable = await calendarEventResponseService.isEventKitAvailable();
-            if (!isAvailable) {
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: JSON.stringify({
-                                success: false,
-                                message: "カレンダーイベント返信機能はmacOSでのみ利用可能です。",
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-            // Respond to all events in batch
-            const result = await 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),
-                    },
-                ],
-            };
-        }
-    });
-    /**
-     * create_calendar_event - Create a new calendar event
-     * Requirement: 18.1-18.11
-     */
-    server.tool("create_calendar_event", "Create a new calendar event with optional location, notes, and alarms.", {
+    }, async ({ eventIds, response, comment }) => handleRespondToCalendarEventsBatch(createCalendarToolsContext(), {
+        eventIds,
+        response,
+        comment,
+    }));
+    // create_calendar_event - uses extracted handler
+    server.tool("create_calendar_event", "Create a new calendar event in the appropriate calendar source with optional location, notes, and alarms.", {
         title: z.string().describe("Event title"),
         startDate: z
             .string()
@@ -1056,429 +331,62 @@ async function createServer() {
             .array(z.string())
             .optional()
             .describe("Optional: Override default alarms with custom settings (e.g., ['-15m', '-1h']). If omitted, calendar's default alarm settings apply."),
-    }, async ({ title, startDate, endDate, location, notes, calendarName, alarms }) => {
-        if (!config) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            error: true,
-                            message: "sageが設定されていません。check_setup_statusを実行してください。",
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-        if (!calendarEventCreatorService) {
-            initializeServices(config);
-        }
-        try {
-            // Check platform availability
-            const isAvailable = await calendarEventCreatorService.isEventKitAvailable();
-            if (!isAvailable) {
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: JSON.stringify({
-                                success: false,
-                                message: "カレンダーイベント作成機能はmacOSでのみ利用可能です。",
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-            // Create the event
-            const result = await 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),
-                        },
-                    ],
-                };
-            }
-            // Handle creation failure
-            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),
-                    },
-                ],
-            };
-        }
-    });
-    /**
-     * delete_calendar_event - Delete a calendar event
-     * Requirement: 19.1-19.9
-     */
-    server.tool("delete_calendar_event", "Delete a calendar event by its ID.", {
+        preferredSource: z
+            .enum(['eventkit', 'google'])
+            .optional()
+            .describe("Preferred calendar source to create the event in. If not specified, uses the first enabled source."),
+    }, async ({ title, startDate, endDate, location, notes, calendarName, alarms, preferredSource }) => handleCreateCalendarEvent(createCalendarToolsContext(), {
+        title,
+        startDate,
+        endDate,
+        location,
+        notes,
+        calendarName,
+        alarms,
+        preferredSource,
+    }));
+    // delete_calendar_event - uses extracted handler
+    server.tool("delete_calendar_event", "Delete a calendar event from enabled calendar sources by its ID. If source not specified, attempts deletion from all enabled sources.", {
         eventId: z.string().describe("Event ID (UUID or full ID from list_calendar_events)"),
-        calendarName: z
-            .string()
+        source: z
+            .enum(['eventkit', 'google'])
             .optional()
-            .describe("Calendar name (searches all calendars if not specified)"),
-    }, async ({ eventId, calendarName }) => {
-        if (!config) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            error: true,
-                            message: "sageが設定されていません。check_setup_statusを実行してください。",
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-        if (!calendarEventDeleterService) {
-            initializeServices(config);
-        }
-        try {
-            // Check platform availability
-            const isAvailable = await calendarEventDeleterService.isEventKitAvailable();
-            if (!isAvailable) {
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: JSON.stringify({
-                                error: true,
-                                message: "カレンダー統合がこのプラットフォームで利用できません。macOSで実行してください。",
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-            // Delete the event
-            const result = await 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),
-                        },
-                    ],
-                };
-            }
-            // Handle deletion failure
-            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),
-                    },
-                ],
-            };
-        }
-    });
-    /**
-     * delete_calendar_events_batch - Delete multiple calendar events
-     * Requirement: 19.10-19.11
-     */
-    server.tool("delete_calendar_events_batch", "Delete multiple calendar events by their IDs.", {
+            .describe("Calendar source to delete from. If not specified, attempts deletion from all enabled sources."),
+    }, async ({ eventId, source }) => handleDeleteCalendarEvent(createCalendarToolsContext(), { eventId, source }));
+    // delete_calendar_events_batch - uses extracted handler
+    server.tool("delete_calendar_events_batch", "Delete multiple calendar events from enabled calendar sources by their IDs. If source not specified, attempts deletion from all enabled sources.", {
         eventIds: z.array(z.string()).describe("Array of event IDs to delete"),
-        calendarName: z
-            .string()
+        source: z
+            .enum(['eventkit', 'google'])
             .optional()
-            .describe("Calendar name (searches all calendars if not specified)"),
-    }, async ({ eventIds, calendarName }) => {
-        if (!config) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            error: true,
-                            message: "sageが設定されていません。check_setup_statusを実行してください。",
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-        if (!calendarEventDeleterService) {
-            initializeServices(config);
-        }
-        try {
-            // Check platform availability
-            const isAvailable = await calendarEventDeleterService.isEventKitAvailable();
-            if (!isAvailable) {
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: JSON.stringify({
-                                error: true,
-                                message: "カレンダー統合がこのプラットフォームで利用できません。macOSで実行してください。",
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-            // Delete events in batch
-            const result = await 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),
-                    },
-                ],
-            };
-        }
-    });
-    /**
-     * sync_to_notion - Sync a task to Notion
-     * Requirement: 8.1-8.5
-     */
+            .describe("Calendar source to delete from. If not specified, attempts deletion from all enabled sources."),
+    }, async ({ eventIds, source }) => handleDeleteCalendarEventsBatch(createCalendarToolsContext(), { eventIds, source }));
+    // sync_to_notion - uses extracted handler
     server.tool("sync_to_notion", "Sync a task to Notion database for long-term tracking.", {
         taskTitle: z.string().describe("Title of the task"),
-        description: z.string().optional().describe("Task description"),
-        priority: z
-            .enum(["P0", "P1", "P2", "P3"])
-            .optional()
-            .describe("Task priority"),
-        dueDate: z.string().optional().describe("Due date (ISO 8601 format)"),
-        stakeholders: z
-            .array(z.string())
-            .optional()
-            .describe("List of stakeholders"),
-        estimatedMinutes: z
-            .number()
-            .optional()
-            .describe("Estimated duration in minutes"),
-    }, async ({ taskTitle, description, priority, dueDate, stakeholders, estimatedMinutes, }) => {
-        if (!config) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            error: true,
-                            message: "sageが設定されていません。check_setup_statusを実行してください。",
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-        if (!config.integrations.notion.enabled) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            error: true,
-                            message: "Notion統合が有効になっていません。update_configでNotion設定を更新してください。",
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-        if (!notionService) {
-            initializeServices(config);
-        }
-        try {
-            // Check if Notion MCP is available
-            const isAvailable = await notionService.isAvailable();
-            // Build properties for Notion page
-            const properties = notionService.buildNotionProperties({
-                title: taskTitle,
-                priority,
-                deadline: dueDate,
-                stakeholders,
-                estimatedMinutes,
-                description,
-            });
-            if (!isAvailable) {
-                // Generate fallback template for manual copy
-                const fallbackText = 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),
-                        },
-                    ],
-                };
-            }
-            // Create page in Notion via MCP
-            const result = await notionService.createPage({
-                databaseId: 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),
-                        },
-                    ],
-                };
-            }
-            // MCP call failed, provide fallback
-            const fallbackText = 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 - Update configuration
-     * Requirement: 10.1-10.6
-     */
+        description: z.string().optional().describe("Task description"),
+        priority: z
+            .enum(["P0", "P1", "P2", "P3"])
+            .optional()
+            .describe("Task priority"),
+        dueDate: z.string().optional().describe("Due date (ISO 8601 format)"),
+        stakeholders: z
+            .array(z.string())
+            .optional()
+            .describe("List of stakeholders"),
+        estimatedMinutes: z
+            .number()
+            .optional()
+            .describe("Estimated duration in minutes"),
+    }, async ({ taskTitle, description, priority, dueDate, stakeholders, estimatedMinutes }) => handleSyncToNotion(createIntegrationToolsContext(), {
+        taskTitle,
+        description,
+        priority,
+        dueDate,
+        stakeholders,
+        estimatedMinutes,
+    }));
+    // update_config - uses extracted handler
     server.tool("update_config", "Update sage configuration settings.", {
         section: z
             .enum([
@@ -1491,81 +399,13 @@ async function createServer() {
         ])
             .describe("Configuration section to update"),
         updates: z.record(z.unknown()).describe("Key-value pairs to update"),
-    }, async ({ section, updates }) => {
-        if (!config) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            error: true,
-                            message: "sageが設定されていません。check_setup_statusを実行してください。",
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-        try {
-            // Validate section-specific updates
-            const validationResult = validateConfigUpdate(section, updates);
-            if (!validationResult.valid) {
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: JSON.stringify({
-                                error: true,
-                                message: `設定の検証に失敗しました: ${validationResult.error}`,
-                                invalidFields: validationResult.invalidFields,
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-            // Apply updates to config
-            const updatedConfig = applyConfigUpdates(config, section, updates);
-            // Save the updated config
-            await ConfigLoader.save(updatedConfig);
-            config = updatedConfig;
-            // Re-initialize services if integrations changed
-            if (section === "integrations") {
-                initializeServices(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),
-                    },
-                ],
-            };
-        }
-    });
+    }, async ({ section, updates }) => handleUpdateConfig(createIntegrationToolsContext(), {
+        section,
+        updates: updates,
+    }));
     // ============================================
-    // TODO List Management Tools
+    // TODO List Management Tools - uses extracted handlers
     // ============================================
-    /**
-     * list_todos - List all TODO items with optional filtering
-     * Requirement: 12.1, 12.2, 12.3, 12.4, 12.7, 12.8
-     */
     server.tool("list_todos", "List TODO items from Apple Reminders and Notion with optional filtering.", {
         priority: z
             .array(z.enum(["P0", "P1", "P2", "P3"]))
@@ -1581,89 +421,14 @@ async function createServer() {
             .describe("Filter by source"),
         todayOnly: z.boolean().optional().describe("Show only tasks due today"),
         tags: z.array(z.string()).optional().describe("Filter by tags"),
-    }, async ({ priority, status, source, todayOnly, tags }) => {
-        if (!config) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            error: true,
-                            message: "sageが設定されていません。check_setup_statusを実行してください。",
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-        if (!todoListManager) {
-            initializeServices(config);
-        }
-        try {
-            let todos;
-            if (todayOnly) {
-                todos = await todoListManager.getTodaysTasks();
-            }
-            else {
-                todos = await todoListManager.listTodos({
-                    priority: priority,
-                    status,
-                    source,
-                    tags,
-                });
-            }
-            // Format todos for display
-            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 - Update the status of a task
-     * Requirement: 12.5, 12.6
-     */
+    }, async ({ priority, status, source, todayOnly, tags }) => handleListTodos(createReminderTodoContext(), {
+        priority,
+        status,
+        source,
+        todayOnly,
+        tags,
+    }));
+    // update_task_status - uses extracted handler
     server.tool("update_task_status", "Update the status of a task in Apple Reminders or Notion.", {
         taskId: z.string().describe("ID of the task to update"),
         status: z
@@ -1676,7 +441,35 @@ async function createServer() {
             .boolean()
             .optional()
             .describe("Whether to sync the status across all sources"),
-    }, async ({ taskId, status, source, syncAcrossSources }) => {
+    }, async ({ taskId, status, source, syncAcrossSources }) => handleUpdateTaskStatus(createTaskToolsContext(), {
+        taskId,
+        status,
+        source,
+        syncAcrossSources,
+    }));
+    // sync_tasks - uses extracted handler
+    server.tool("sync_tasks", "Synchronize tasks between Apple Reminders and Notion, detecting and resolving conflicts.", {}, async () => handleSyncTasks(createTaskToolsContext()));
+    // detect_duplicates - uses extracted handler
+    server.tool("detect_duplicates", "Detect duplicate tasks between Apple Reminders and Notion.", {
+        autoMerge: z
+            .boolean()
+            .optional()
+            .describe("Whether to automatically merge high-confidence duplicates"),
+    }, async ({ autoMerge }) => handleDetectDuplicates(createTaskToolsContext(), { autoMerge }));
+    // list_calendar_sources - uses extracted handler
+    server.tool("list_calendar_sources", "List available and enabled calendar sources (EventKit, Google Calendar) with their health status. Shows which sources can be used and their current state.", {}, async () => handleListCalendarSources(createCalendarToolsContext()));
+    /**
+     * set_calendar_source - Enable or disable a calendar source
+     * Requirement: 9, 11, Task 33
+     */
+    server.tool("set_calendar_source", "Enable or disable a calendar source (EventKit or Google Calendar). When enabling Google Calendar for the first time, this will initiate the OAuth flow. Returns authorization URL if OAuth is required.", {
+        source: z
+            .enum(['eventkit', 'google'])
+            .describe("Calendar source to configure: 'eventkit' (macOS only) or 'google' (all platforms)"),
+        enabled: z
+            .boolean()
+            .describe("Whether to enable (true) or disable (false) the source"),
+    }, async ({ source, enabled }) => {
         if (!config) {
             return {
                 content: [
@@ -1690,68 +483,152 @@ async function createServer() {
                 ],
             };
         }
-        if (!todoListManager) {
+        if (!calendarSourceManager) {
             initializeServices(config);
         }
         try {
-            // Update the task status
-            const result = await todoListManager.updateTaskStatus(taskId, status, source);
-            if (!result.success) {
+            // Check if source is available on this platform
+            const availableSources = await calendarSourceManager.detectAvailableSources();
+            if (source === 'eventkit' && !availableSources.eventkit) {
                 return {
                     content: [
                         {
                             type: "text",
                             text: JSON.stringify({
                                 success: false,
-                                taskId,
-                                error: result.error,
-                                message: `タスクステータスの更新に失敗しました: ${result.error}`,
+                                message: "EventKitはこのプラットフォームでは利用できません。EventKitはmacOSでのみ利用可能です。",
+                            }, null, 2),
+                        },
+                    ],
+                };
+            }
+            if (enabled) {
+                // Enable the source
+                await calendarSourceManager.enableSource(source);
+                // If enabling Google Calendar for the first time, check if OAuth is needed
+                if (source === 'google' && googleCalendarService) {
+                    try {
+                        // Check if tokens already exist
+                        const { GoogleOAuthHandler } = await import('./oauth/google-oauth-handler.js');
+                        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',
+                        };
+                        if (!oauthConfig.clientId || !oauthConfig.clientSecret) {
+                            return {
+                                content: [
+                                    {
+                                        type: "text",
+                                        text: JSON.stringify({
+                                            success: false,
+                                            message: "Google Calendar OAuth設定が見つかりません。環境変数GOOGLE_CLIENT_IDとGOOGLE_CLIENT_SECRETを設定してください。",
+                                            requiredEnvVars: [
+                                                'GOOGLE_CLIENT_ID',
+                                                'GOOGLE_CLIENT_SECRET',
+                                                'GOOGLE_REDIRECT_URI (optional, defaults to http://localhost:3000/oauth/callback)',
+                                            ],
+                                        }, null, 2),
+                                    },
+                                ],
+                            };
+                        }
+                        const oauthHandler = new GoogleOAuthHandler(oauthConfig);
+                        // Try to get existing tokens
+                        const existingTokens = await oauthHandler.getTokens();
+                        if (!existingTokens) {
+                            // Need to initiate OAuth flow
+                            const authUrl = await oauthHandler.getAuthorizationUrl();
+                            // Save config before OAuth flow
+                            await ConfigLoader.save(config);
+                            return {
+                                content: [
+                                    {
+                                        type: "text",
+                                        text: JSON.stringify({
+                                            success: true,
+                                            source,
+                                            enabled: true,
+                                            oauthRequired: true,
+                                            authorizationUrl: authUrl,
+                                            message: `Google Calendarを有効化しました。OAuth認証が必要です。以下のURLにアクセスして認証を完了してください: ${authUrl}`,
+                                            instructions: [
+                                                '1. 上記のURLをブラウザで開く',
+                                                '2. Googleアカウントでログイン',
+                                                '3. sage アプリケーションにカレンダーへのアクセスを許可',
+                                                '4. リダイレクトされたURLから認証コードを取得',
+                                                '5. 認証コードを使用してトークンを取得（別途実装予定）',
+                                            ],
+                                        }, null, 2),
+                                    },
+                                ],
+                            };
+                        }
+                    }
+                    catch (error) {
+                        // OAuth check failed, but source is enabled in config
+                        await ConfigLoader.save(config);
+                        return {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: JSON.stringify({
+                                        success: true,
+                                        source,
+                                        enabled: true,
+                                        warning: `Google Calendarを有効化しましたが、OAuth設定の確認に失敗しました: ${error instanceof Error ? error.message : "Unknown error"}`,
+                                        message: "設定は保存されましたが、OAuth認証が必要な場合があります。",
+                                    }, null, 2),
+                                },
+                            ],
+                        };
+                    }
+                }
+                // Save the updated config
+                await ConfigLoader.save(config);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                source,
+                                enabled: true,
+                                message: `${source === 'eventkit' ? 'EventKit' : 'Google Calendar'}を有効化しました。`,
                             }, null, 2),
                         },
                     ],
                 };
             }
-            // Optionally sync across sources
-            let syncResult;
-            if (syncAcrossSources) {
-                syncResult = await todoListManager.syncTaskAcrossSources(taskId);
+            else {
+                // Disable the source
+                await calendarSourceManager.disableSource(source);
+                // Save the updated config
+                await ConfigLoader.save(config);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                source,
+                                enabled: false,
+                                message: `${source === 'eventkit' ? 'EventKit' : 'Google Calendar'}を無効化しました。`,
+                            }, null, 2),
+                        },
+                    ],
+                };
             }
-            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),
-                    },
-                ],
-            };
+            return createErrorFromCatch('カレンダーソース設定に失敗しました', error);
         }
     });
     /**
-     * sync_tasks - Sync tasks across all sources
-     * Requirement: 12.6
+     * sync_calendar_sources - Sync events between EventKit and Google Calendar
+     * Requirement: 8, Task 34
      */
-    server.tool("sync_tasks", "Synchronize tasks between Apple Reminders and Notion, detecting and resolving conflicts.", {}, async () => {
+    server.tool("sync_calendar_sources", "Synchronize calendar events between EventKit and Google Calendar. Both sources must be enabled for sync to work. Returns the number of events added, updated, and deleted.", {}, async () => {
         if (!config) {
             return {
                 content: [
@@ -1765,54 +642,73 @@ async function createServer() {
                 ],
             };
         }
-        if (!taskSynchronizer) {
+        if (!calendarSourceManager) {
             initializeServices(config);
         }
         try {
-            const result = await taskSynchronizer.syncAllTasks();
+            // Check if both sources are enabled
+            const enabledSources = calendarSourceManager.getEnabledSources();
+            if (enabledSources.length < 2) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                success: false,
+                                message: "同期を実行するには、EventKitとGoogle Calendarの両方を有効化する必要があります。現在有効なソース: " +
+                                    enabledSources.join(", "),
+                                enabledSources,
+                            }, null, 2),
+                        },
+                    ],
+                };
+            }
+            // Execute sync
+            const result = await calendarSourceManager.syncCalendars();
+            if (result.success) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                eventsAdded: result.eventsAdded,
+                                eventsUpdated: result.eventsUpdated,
+                                eventsDeleted: result.eventsDeleted,
+                                conflicts: result.conflicts,
+                                errors: result.errors,
+                                message: `カレンダー同期が完了しました。追加: ${result.eventsAdded}件、更新: ${result.eventsUpdated}件、削除: ${result.eventsDeleted}件`,
+                            }, null, 2),
+                        },
+                    ],
+                };
+            }
             return {
                 content: [
                     {
                         type: "text",
                         text: JSON.stringify({
-                            success: true,
-                            totalTasks: result.totalTasks,
-                            syncedTasks: result.syncedTasks,
+                            success: false,
+                            eventsAdded: result.eventsAdded,
+                            eventsUpdated: result.eventsUpdated,
+                            eventsDeleted: result.eventsDeleted,
                             conflicts: result.conflicts,
                             errors: result.errors,
-                            durationMs: result.duration,
-                            message: result.conflicts.length > 0
-                                ? `${result.syncedTasks}件のタスクを同期しました。${result.conflicts.length}件の競合が検出されました。`
-                                : `${result.syncedTasks}件のタスクを同期しました。`,
+                            message: "カレンダー同期中にエラーが発生しました。",
                         }, null, 2),
                     },
                 ],
             };
         }
         catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            error: true,
-                            message: `タスク同期に失敗しました: ${error instanceof Error ? error.message : "Unknown error"}`,
-                        }, null, 2),
-                    },
-                ],
-            };
+            return createErrorFromCatch('カレンダー同期に失敗しました', error);
         }
     });
     /**
-     * detect_duplicates - Detect duplicate tasks across sources
-     * Requirement: 12.5
+     * get_calendar_sync_status - Check sync status between calendar sources
+     * Requirement: 8, Task 35
      */
-    server.tool("detect_duplicates", "Detect duplicate tasks between Apple Reminders and Notion.", {
-        autoMerge: z
-            .boolean()
-            .optional()
-            .describe("Whether to automatically merge high-confidence duplicates"),
-    }, async ({ autoMerge }) => {
+    server.tool("get_calendar_sync_status", "Check the synchronization status between EventKit and Google Calendar. Returns last sync time, next sync time, and source availability.", {}, async () => {
         if (!config) {
             return {
                 content: [
@@ -1826,72 +722,42 @@ async function createServer() {
                 ],
             };
         }
-        if (!taskSynchronizer) {
+        if (!calendarSourceManager) {
             initializeServices(config);
         }
         try {
-            const duplicates = await taskSynchronizer.detectDuplicates();
-            // Format duplicates for display
-            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,
-                },
-            }));
-            // Auto-merge high-confidence duplicates if requested
-            let mergeResults;
-            if (autoMerge) {
-                const highConfidenceDuplicates = duplicates.filter((d) => d.confidence === "high");
-                if (highConfidenceDuplicates.length > 0) {
-                    mergeResults = await taskSynchronizer.mergeDuplicates(highConfidenceDuplicates);
-                }
-            }
+            const status = await calendarSourceManager.getSyncStatus();
             return {
                 content: [
                     {
                         type: "text",
                         text: JSON.stringify({
-                            success: true,
-                            duplicatesFound: duplicates.length,
-                            duplicates: formattedDuplicates,
-                            mergeResults: autoMerge ? mergeResults : undefined,
-                            message: duplicates.length > 0
-                                ? `${duplicates.length}件の重複タスクが検出されました。`
-                                : "重複タスクは見つかりませんでした。",
+                            isEnabled: status.isEnabled,
+                            lastSyncTime: status.lastSyncTime || "未実行",
+                            nextSyncTime: status.nextSyncTime || "N/A",
+                            sources: {
+                                eventkit: {
+                                    available: status.sources.eventkit.available,
+                                    lastError: status.sources.eventkit.lastError,
+                                },
+                                google: {
+                                    available: status.sources.google.available,
+                                    lastError: status.sources.google.lastError,
+                                },
+                            },
+                            message: status.isEnabled
+                                ? "カレンダー同期が有効です。"
+                                : "カレンダー同期を有効にするには、EventKitとGoogle Calendarの両方を有効化してください。",
                         }, null, 2),
                     },
                 ],
             };
         }
         catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            error: true,
-                            message: `重複検出に失敗しました: ${error instanceof Error ? error.message : "Unknown error"}`,
-                        }, null, 2),
-                    },
-                ],
-            };
+            return createErrorFromCatch('同期状態の取得に失敗しました', error);
         }
     });
-    /**
-     * get_working_cadence - Get user's working rhythm information
-     * Requirement: 32.1-32.10
-     */
+    // get_working_cadence - uses extracted handler
     server.tool("get_working_cadence", "Get user's working rhythm including deep work days, meeting-heavy days, and scheduling recommendations.", {
         dayOfWeek: z
             .enum([
@@ -1909,62 +775,7 @@ async function createServer() {
             .string()
             .optional()
             .describe("Get info for a specific date in ISO 8601 format (e.g., 2025-01-15)"),
-    }, async ({ dayOfWeek, date }) => {
-        // Initialize service if not already done
-        if (!workingCadenceService) {
-            workingCadenceService = new WorkingCadenceService();
-        }
-        try {
-            const result = await workingCadenceService.getWorkingCadence({
-                dayOfWeek,
-                date,
-            });
-            if (!result.success) {
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: JSON.stringify({
-                                error: true,
-                                message: result.error || "勤務リズム情報の取得に失敗しました。",
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            success: true,
-                            user: result.user,
-                            workingHours: result.workingHours,
-                            weeklyPattern: result.weeklyPattern,
-                            deepWorkBlocks: result.deepWorkBlocks,
-                            weeklyReview: result.weeklyReview,
-                            specificDay: result.specificDay,
-                            recommendations: result.recommendations,
-                            summary: result.summary,
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            error: true,
-                            message: `勤務リズム情報の取得に失敗しました: ${error instanceof Error ? error.message : "Unknown error"}`,
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-    });
+    }, async ({ dayOfWeek, date }) => handleGetWorkingCadence(createCalendarToolsContext(), { dayOfWeek, date }));
     return server;
 }
 /**