@shin1ohno/sage 0.7.8 → 0.8.4

package/dist/index.js

@@ -13,12 +13,12 @@ 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";
 // Global state
@@ -26,12 +26,12 @@ 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
@@ -149,12 +149,33 @@ 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();
 }
 /**
@@ -622,9 +643,9 @@ async function createServer() {
     });
     /**
      * find_available_slots - Find available time slots in calendar
-     * Requirement: 3.3-3.6, 6.1-6.6
+     * Requirement: 3.3-3.6, 6.1-6.6, 7 (Task 28: Multi-source support)
      */
-    server.tool("find_available_slots", "Find available time slots in the calendar for scheduling tasks.", {
+    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,7 +659,15 @@ async function createServer() {
             .boolean()
             .optional()
             .describe("Prefer deep work time slots"),
-    }, async ({ durationMinutes, startDate, endDate, preferDeepWork }) => {
+        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 }) => {
         if (!config) {
             return {
                 content: [
@@ -652,70 +681,62 @@ async function createServer() {
                 ],
             };
         }
-        if (!calendarService) {
+        if (!calendarSourceManager) {
             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]);
+            // Get enabled sources
+            const enabledSources = calendarSourceManager.getEnabledSources();
+            if (enabledSources.length === 0) {
                 return {
                     content: [
                         {
                             type: "text",
                             text: JSON.stringify({
                                 success: false,
-                                platform: platformInfo.platform,
-                                method: platformInfo.recommendedMethod,
-                                message: "カレンダー統合がこのプラットフォームで利用できません。手動で予定を入力してください。",
-                                manualPrompt,
+                                message: "有効なカレンダーソースがありません。設定でEventKitまたはGoogle Calendarを有効にしてください。",
                             }, null, 2),
                         },
                     ],
                 };
             }
-            // Fetch events from calendar
+            // Prepare date range
             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
+            // Get working hours from config
             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));
+            // Use durationMinutes as default min duration for backwards compatibility
+            // New parameters minDurationMinutes and maxDurationMinutes take precedence
+            const minDuration = minDurationMinutes ?? durationMinutes ?? 25;
+            const maxDuration = maxDurationMinutes ?? 480;
+            // Find available slots using CalendarSourceManager
+            // This automatically fetches from all enabled sources, merges, and deduplicates
+            const slots = await calendarSourceManager.findAvailableSlots({
+                startDate: searchStart,
+                endDate: searchEnd,
+                minDurationMinutes: minDuration,
+                maxDurationMinutes: maxDuration,
+                workingHours,
+            });
             // 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]);
+                ? slots.filter((s) => s.dayType === "deep-work")
+                : slots;
             return {
                 content: [
                     {
                         type: "text",
                         text: JSON.stringify({
                             success: true,
-                            platform: platformInfo.platform,
-                            method: platformInfo.recommendedMethod,
+                            sources: enabledSources,
                             searchRange: { start: searchStart, end: searchEnd },
-                            eventsFound: events.length,
+                            totalSlots: filteredSlots.length,
                             slots: filteredSlots.slice(0, 10).map((slot) => ({
                                 start: slot.start,
                                 end: slot.end,
@@ -725,7 +746,7 @@ async function createServer() {
                                 reason: slot.reason,
                             })),
                             message: filteredSlots.length > 0
-                                ? `${filteredSlots.length}件の空き時間が見つかりました。`
+                                ? `${filteredSlots.length}件の空き時間が見つかりました (ソース: ${enabledSources.join(', ')})。`
                                 : "指定した条件に合う空き時間が見つかりませんでした。",
                         }, null, 2),
                     },
@@ -748,20 +769,20 @@ async function createServer() {
     });
     /**
      * list_calendar_events - List calendar events for a specified period
-     * Requirement: 16.1-16.12
+     * Requirement: 16.1-16.12, Task 27 (Multi-source support)
      */
-    server.tool("list_calendar_events", "List calendar events for a specified period. Returns events with details including calendar name and location.", {
+    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 }) => {
+            .describe("Optional: filter events by calendar ID or name"),
+    }, async ({ startDate, endDate, calendarId }) => {
         if (!config) {
             return {
                 content: [
@@ -775,55 +796,49 @@ async function createServer() {
                 ],
             };
         }
-        if (!calendarService) {
+        if (!calendarSourceManager) {
             initializeServices(config);
         }
         try {
-            // Check platform availability
-            const platformInfo = await calendarService.detectPlatform();
-            const isAvailable = await calendarService.isAvailable();
-            if (!isAvailable) {
+            // Get enabled sources
+            const enabledSources = calendarSourceManager.getEnabledSources();
+            if (enabledSources.length === 0) {
                 return {
                     content: [
                         {
                             type: "text",
                             text: JSON.stringify({
                                 success: false,
-                                platform: platformInfo.platform,
-                                method: platformInfo.recommendedMethod,
-                                message: "カレンダー統合がこのプラットフォームで利用できません。macOSで実行してください。",
+                                message: "有効なカレンダーソースがありません。設定でEventKitまたはGoogle Calendarを有効にしてください。",
                             }, null, 2),
                         },
                     ],
                 };
             }
-            // List events
-            const result = await calendarService.listEvents({
-                startDate,
-                endDate,
-                calendarName,
-            });
+            // Get events from all enabled sources (already merged/deduplicated)
+            const events = await calendarSourceManager.getEvents(startDate, endDate, calendarId);
             return {
                 content: [
                     {
                         type: "text",
                         text: JSON.stringify({
                             success: true,
-                            platform: platformInfo.platform,
-                            method: platformInfo.recommendedMethod,
-                            events: result.events.map((event) => ({
+                            sources: enabledSources,
+                            events: events.map((event) => ({
                                 id: event.id,
                                 title: event.title,
                                 start: event.start,
                                 end: event.end,
                                 isAllDay: event.isAllDay,
+                                // Note: calendar and location are optional fields added in Task 25
                                 calendar: event.calendar,
                                 location: event.location,
+                                source: event.source,
                             })),
-                            period: result.period,
-                            totalEvents: result.totalEvents,
-                            message: result.totalEvents > 0
-                                ? `${result.totalEvents}件のイベントが見つかりました。`
+                            period: { start: startDate, end: endDate },
+                            totalEvents: events.length,
+                            message: events.length > 0
+                                ? `${events.length}件のイベントが見つかりました (ソース: ${enabledSources.join(', ')})。`
                                 : "指定した期間にイベントが見つかりませんでした。",
                         }, null, 2),
                     },
@@ -846,9 +861,9 @@ async function createServer() {
     });
     /**
      * respond_to_calendar_event - Respond to a single calendar event
-     * Requirement: 17.1, 17.2, 17.5-17.11
+     * Requirement: 17.1, 17.2, 17.5-17.11, 6 (Google Calendar support)
      */
-    server.tool("respond_to_calendar_event", "Respond to a calendar event with accept, decline, or tentative. Use this to RSVP to meeting invitations.", {
+    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,8 +871,16 @@ async function createServer() {
         comment: z
             .string()
             .optional()
-            .describe("Optional comment to include with the response (e.g., '年末年始休暇のため')"),
-    }, async ({ eventId, response, comment }) => {
+            .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 }) => {
         if (!config) {
             return {
                 content: [
@@ -871,64 +894,117 @@ async function createServer() {
                 ],
             };
         }
-        if (!calendarEventResponseService) {
+        if (!calendarSourceManager || !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),
-                        },
-                    ],
-                };
+            // If source is explicitly Google Calendar, or if source is not specified, try Google Calendar first
+            if (source === 'google' || !source) {
+                try {
+                    const result = await calendarSourceManager.respondToEvent(eventId, response, source === 'google' ? 'google' : undefined, calendarId);
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: JSON.stringify({
+                                    success: true,
+                                    eventId,
+                                    source: result.source || 'google',
+                                    message: result.message,
+                                }, null, 2),
+                            },
+                        ],
+                    };
+                }
+                catch (error) {
+                    // If source was explicitly 'google', don't try EventKit
+                    if (source === 'google') {
+                        return {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: JSON.stringify({
+                                        error: true,
+                                        message: `Google Calendarイベント返信に失敗しました: ${error instanceof Error ? error.message : "Unknown error"}`,
+                                    }, null, 2),
+                                },
+                            ],
+                        };
+                    }
+                    // If source was not specified, continue to try EventKit
+                }
             }
-            // Respond to the event
-            const result = await calendarEventResponseService.respondToEvent({
-                eventId,
-                response,
-                comment,
-            });
-            if (result.success) {
+            // Try EventKit (either explicitly requested or as fallback)
+            if (source === 'eventkit' || !source) {
+                // Check platform availability
+                const isAvailable = await calendarEventResponseService.isEventKitAvailable();
+                if (!isAvailable) {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: JSON.stringify({
+                                    success: false,
+                                    message: "EventKitカレンダーイベント返信機能はmacOSでのみ利用可能です。Google Calendarイベントの場合は、source='google'を指定してください。",
+                                }, null, 2),
+                            },
+                        ],
+                    };
+                }
+                // Respond to the event via EventKit
+                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,
+                                    source: 'eventkit',
+                                    message: result.message,
+                                }, null, 2),
+                            },
+                        ],
+                    };
+                }
+                // Handle skipped or failed response
                 return {
                     content: [
                         {
                             type: "text",
                             text: JSON.stringify({
-                                success: true,
+                                success: false,
                                 eventId: result.eventId,
                                 eventTitle: result.eventTitle,
-                                newStatus: result.newStatus,
-                                method: result.method,
-                                instanceOnly: result.instanceOnly,
-                                message: result.message,
+                                skipped: result.skipped,
+                                reason: result.reason,
+                                error: result.error,
+                                source: 'eventkit',
+                                message: result.skipped
+                                    ? `イベントをスキップしました: ${result.reason}`
+                                    : `イベント返信に失敗しました: ${result.error}`,
                             }, null, 2),
                         },
                     ],
                 };
             }
-            // Handle skipped or failed response
+            // Should not reach here, but just in case
             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}`,
+                            error: true,
+                            message: "有効なカレンダーソースが見つかりません。",
                         }, null, 2),
                     },
                 ],
@@ -1036,9 +1112,9 @@ async function createServer() {
     });
     /**
      * create_calendar_event - Create a new calendar event
-     * Requirement: 18.1-18.11
+     * Requirement: 18.1-18.11, Task 29 (Multi-source support)
      */
-    server.tool("create_calendar_event", "Create a new calendar event with optional location, notes, and alarms.", {
+    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,7 +1132,11 @@ 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 }) => {
+        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: _calendarName, alarms: _alarms, preferredSource }) => {
         if (!config) {
             return {
                 content: [
@@ -1070,63 +1150,52 @@ async function createServer() {
                 ],
             };
         }
-        if (!calendarEventCreatorService) {
+        if (!calendarSourceManager) {
             initializeServices(config);
         }
         try {
-            // Check platform availability
-            const isAvailable = await calendarEventCreatorService.isEventKitAvailable();
-            if (!isAvailable) {
+            // Get enabled sources
+            const enabledSources = calendarSourceManager.getEnabledSources();
+            if (enabledSources.length === 0) {
                 return {
                     content: [
                         {
                             type: "text",
                             text: JSON.stringify({
                                 success: false,
-                                message: "カレンダーイベント作成機能はmacOSでのみ利用可能です。",
+                                message: "有効なカレンダーソースがありません。設定でEventKitまたはGoogle Calendarを有効にしてください。",
                             }, null, 2),
                         },
                     ],
                 };
             }
-            // Create the event
-            const result = await calendarEventCreatorService.createEvent({
+            // Build create event request
+            const request = {
                 title,
-                startDate,
-                endDate,
+                start: startDate,
+                end: 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
+                description: notes,
+                // Note: calendarId is passed separately to GoogleCalendarService.createEvent
+                // alarms parameter is not supported in CreateEventRequest interface (uses reminders instead)
+            };
+            // Create the event using CalendarSourceManager
+            // This automatically routes to the preferred source or falls back to other enabled sources
+            const event = await calendarSourceManager.createEvent(request, preferredSource);
             return {
                 content: [
                     {
                         type: "text",
                         text: JSON.stringify({
-                            success: false,
-                            error: result.error,
-                            message: result.message,
+                            success: true,
+                            eventId: event.id,
+                            title: event.title,
+                            startDate: event.start,
+                            endDate: event.end,
+                            source: event.source || 'unknown',
+                            calendarName: event.calendar,
+                            isAllDay: event.isAllDay,
+                            message: `カレンダーイベントを作成しました: ${event.title} (ソース: ${event.source || 'unknown'})`,
                         }, null, 2),
                     },
                 ],
@@ -1148,15 +1217,15 @@ async function createServer() {
     });
     /**
      * delete_calendar_event - Delete a calendar event
-     * Requirement: 19.1-19.9
+     * Requirement: 19.1-19.9, Task 30 (Multi-source support)
      */
-    server.tool("delete_calendar_event", "Delete a calendar event by its ID.", {
+    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 }) => {
+            .describe("Calendar source to delete from. If not specified, attempts deletion from all enabled sources."),
+    }, async ({ eventId, source }) => {
         if (!config) {
             return {
                 content: [
@@ -1170,55 +1239,39 @@ async function createServer() {
                 ],
             };
         }
-        if (!calendarEventDeleterService) {
+        if (!calendarSourceManager) {
             initializeServices(config);
         }
         try {
-            // Check platform availability
-            const isAvailable = await calendarEventDeleterService.isEventKitAvailable();
-            if (!isAvailable) {
+            // Get enabled sources
+            const enabledSources = calendarSourceManager.getEnabledSources();
+            if (enabledSources.length === 0) {
                 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,
+                                success: false,
+                                message: "有効なカレンダーソースがありません。設定でEventKitまたはGoogle Calendarを有効にしてください。",
                             }, null, 2),
                         },
                     ],
                 };
             }
-            // Handle deletion failure
+            // Delete the event using CalendarSourceManager
+            // This automatically handles deletion from specified source or all enabled sources
+            await calendarSourceManager.deleteEvent(eventId, source);
             return {
                 content: [
                     {
                         type: "text",
                         text: JSON.stringify({
-                            success: false,
-                            error: result.error,
-                            message: result.message,
+                            success: true,
+                            eventId,
+                            source: source || 'all enabled sources',
+                            message: source
+                                ? `カレンダーイベントを削除しました (ソース: ${source})`
+                                : `カレンダーイベントを削除しました (全ての有効なソースから)`,
                         }, null, 2),
                     },
                 ],
@@ -1240,15 +1293,15 @@ async function createServer() {
     });
     /**
      * delete_calendar_events_batch - Delete multiple calendar events
-     * Requirement: 19.10-19.11
+     * Requirement: 19.10-19.11, Task 30 (Multi-source support)
      */
-    server.tool("delete_calendar_events_batch", "Delete multiple calendar events by their IDs.", {
+    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 }) => {
+            .describe("Calendar source to delete from. If not specified, attempts deletion from all enabled sources."),
+    }, async ({ eventIds, source }) => {
         if (!config) {
             return {
                 content: [
@@ -1262,47 +1315,56 @@ async function createServer() {
                 ],
             };
         }
-        if (!calendarEventDeleterService) {
+        if (!calendarSourceManager) {
             initializeServices(config);
         }
         try {
-            // Check platform availability
-            const isAvailable = await calendarEventDeleterService.isEventKitAvailable();
-            if (!isAvailable) {
+            // Get enabled sources
+            const enabledSources = calendarSourceManager.getEnabledSources();
+            if (enabledSources.length === 0) {
                 return {
                     content: [
                         {
                             type: "text",
                             text: JSON.stringify({
-                                error: true,
-                                message: "カレンダー統合がこのプラットフォームで利用できません。macOSで実行してください。",
+                                success: false,
+                                message: "有効なカレンダーソースがありません。設定でEventKitまたはGoogle Calendarを有効にしてください。",
                             }, null, 2),
                         },
                     ],
                 };
             }
-            // Delete events in batch
-            const result = await calendarEventDeleterService.deleteEventsBatch({
-                eventIds,
-                calendarName,
-            });
+            // Delete events one by one using CalendarSourceManager
+            const results = [];
+            for (const eventId of eventIds) {
+                try {
+                    await calendarSourceManager.deleteEvent(eventId, source);
+                    results.push({ eventId, success: true });
+                }
+                catch (error) {
+                    results.push({
+                        eventId,
+                        success: false,
+                        error: error instanceof Error ? error.message : 'Unknown error',
+                    });
+                }
+            }
+            const successCount = results.filter((r) => r.success).length;
+            const failedCount = results.filter((r) => !r.success).length;
             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,
+                            success: failedCount === 0,
+                            totalCount: eventIds.length,
+                            successCount,
+                            failedCount,
+                            source: source || 'all enabled sources',
+                            results,
+                            message: source
+                                ? `${successCount}/${eventIds.length}件のイベントを削除しました (ソース: ${source})`
+                                : `${successCount}/${eventIds.length}件のイベントを削除しました (全ての有効なソースから)`,
                         }, null, 2),
                     },
                 ],
@@ -1888,6 +1950,407 @@ async function createServer() {
             };
         }
     });
+    /**
+     * list_calendar_sources - List available and enabled calendar sources
+     * Requirement: Google Calendar API integration (Task 32)
+     */
+    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 () => {
+        if (!config) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            error: true,
+                            message: "sageが設定されていません。check_setup_statusを実行してください。",
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        if (!calendarSourceManager) {
+            initializeServices(config);
+        }
+        try {
+            // Get available sources
+            const availableSources = await calendarSourceManager.detectAvailableSources();
+            // Get enabled sources
+            const enabledSources = calendarSourceManager.getEnabledSources();
+            // Get health status
+            const healthStatus = await calendarSourceManager.healthCheck();
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            success: true,
+                            sources: {
+                                eventkit: {
+                                    available: availableSources.eventkit,
+                                    enabled: enabledSources.includes('eventkit'),
+                                    healthy: healthStatus.eventkit,
+                                    description: "macOS EventKit calendar integration (macOS only)",
+                                },
+                                google: {
+                                    available: availableSources.google,
+                                    enabled: enabledSources.includes('google'),
+                                    healthy: healthStatus.google,
+                                    description: "Google Calendar API integration (all platforms)",
+                                },
+                            },
+                            summary: {
+                                totalAvailable: Object.values(availableSources).filter(Boolean).length,
+                                totalEnabled: enabledSources.length,
+                                allHealthy: Object.values(healthStatus).every(Boolean),
+                            },
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            error: true,
+                            message: `カレンダーソース情報の取得に失敗しました: ${error instanceof Error ? error.message : "Unknown error"}`,
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+    });
+    /**
+     * 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: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            error: true,
+                            message: "sageが設定されていません。check_setup_statusを実行してください。",
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        if (!calendarSourceManager) {
+            initializeServices(config);
+        }
+        try {
+            // 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,
+                                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),
+                        },
+                    ],
+                };
+            }
+            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),
+                        },
+                    ],
+                };
+            }
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            error: true,
+                            message: `カレンダーソース設定に失敗しました: ${error instanceof Error ? error.message : "Unknown error"}`,
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+    });
+    /**
+     * sync_calendar_sources - Sync events between EventKit and Google Calendar
+     * Requirement: 8, Task 34
+     */
+    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: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            error: true,
+                            message: "sageが設定されていません。check_setup_statusを実行してください。",
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        if (!calendarSourceManager) {
+            initializeServices(config);
+        }
+        try {
+            // 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: false,
+                            eventsAdded: result.eventsAdded,
+                            eventsUpdated: result.eventsUpdated,
+                            eventsDeleted: result.eventsDeleted,
+                            conflicts: result.conflicts,
+                            errors: result.errors,
+                            message: "カレンダー同期中にエラーが発生しました。",
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            error: true,
+                            message: `カレンダー同期に失敗しました: ${error instanceof Error ? error.message : "Unknown error"}`,
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+    });
+    /**
+     * get_calendar_sync_status - Check sync status between calendar sources
+     * Requirement: 8, Task 35
+     */
+    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: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            error: true,
+                            message: "sageが設定されていません。check_setup_statusを実行してください。",
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        if (!calendarSourceManager) {
+            initializeServices(config);
+        }
+        try {
+            const status = await calendarSourceManager.getSyncStatus();
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            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),
+                    },
+                ],
+            };
+        }
+    });
     /**
      * get_working_cadence - Get user's working rhythm information
      * Requirement: 32.1-32.10