floq 1.2.0 → 1.3.0

package/README.ja.md

@@ -16,6 +16,7 @@ MS-DOSスタイルのテーマを備えたターミナルベースのGTD（Getti
 - **タスク検索**: `/` キーで全タスクを素早く検索
 - **コメント**: タスクにメモやコメントを追加
 - **クラウド同期**: [Turso](https://turso.tech/)のembedded replicasによるオプションの同期機能
+- **Googleカレンダー**: iCal URLまたはOAuth連携で今日の予定を表示
 - **テーマ**: MS-DOSノスタルジックスタイルやドラクエRPG風を含む複数テーマ
 - **スプラッシュ画面**: 起動時のスプラッシュ画面（レトロテーマではドラクエ風）
 - **多言語対応**: 英語・日本語サポート
@@ -259,6 +260,95 @@ floq config turso --disable
 - TUIヘッダーに接続状態を表示（Tursoはクラウドアイコン、ローカルはローカルアイコン）
 - CLIコマンド実行時、Turso有効時は`🔄 Turso sync: hostname`を表示
 
+## Googleカレンダー連携
+
+FloqはGoogleカレンダーの予定をTUIに表示できます。2つの方法があります:
+
+### 方法1: iCal URL（シンプル、認証不要）
+
+GoogleカレンダーのシークレットiCal URLを使用して、OAuth設定なしで読み取り専用アクセスができます。
+
+```bash
+# GoogleカレンダーからiCal URLを取得:
+# 設定 > (カレンダー名) > カレンダーの統合 > "iCal形式の非公開URL"
+
+floq calendar add "https://calendar.google.com/calendar/ical/..." -n "マイカレンダー"
+floq calendar show
+```
+
+### 方法2: Google OAuth（フルAPIアクセス）
+
+OAuthを使用すると、より信頼性が高く、すべてのカレンダーにアクセスできます。
+
+#### セットアップ
+
+1. [Google Cloud Console](https://console.cloud.google.com/)にアクセス
+2. プロジェクトを作成（または既存のものを選択）
+3. **Google Calendar API を有効化**:
+   - **APIとサービス > ライブラリ**に移動
+   - 「Google Calendar API」を検索
+   - **有効にする**をクリック
+4. **OAuth 同意画面を設定**:
+   - **APIとサービス > OAuth 同意画面**に移動
+   - **外部**を選択して作成
+   - アプリ名と必須フィールドを入力
+   - **テストユーザー**に自分のメールアドレスを追加
+5. **OAuth 認証情報を作成**:
+   - **APIとサービス > 認証情報**に移動
+   - **認証情報を作成 > OAuth クライアント ID**をクリック
+   - アプリケーションの種類: **テレビと制限付き入力デバイス**（「デスクトップアプリ」ではない）
+   - クライアント ID とクライアントシークレットをコピー
+
+#### 設定
+
+```bash
+# OAuth認証情報を設定（または環境変数を使用）
+floq calendar config --client-id "your-client-id.apps.googleusercontent.com" --client-secret "your-secret"
+
+# または環境変数を使用
+export GOOGLE_CLIENT_ID="your-client-id.apps.googleusercontent.com"
+export GOOGLE_CLIENT_SECRET="your-secret"
+
+# Googleでログイン
+floq calendar login
+# → ブラウザが開いて認証画面へ
+# → 表示されたコードを入力
+
+# カレンダーを選択
+floq calendar select
+# → カレンダー一覧が表示される
+# → 番号を入力して選択
+
+# 設定と今日の予定を表示
+floq calendar show
+
+# カレンダーキャッシュを更新
+floq calendar sync
+
+# ログアウト
+floq calendar logout
+```
+
+### カレンダーコマンド
+
+```bash
+# iCalモード
+floq calendar add <url> [-n name]   # iCal URLを追加
+floq calendar remove                 # カレンダーを削除
+
+# OAuthモード
+floq calendar config --client-id <id> --client-secret <secret>
+floq calendar login                  # Google OAuthログイン
+floq calendar logout                 # OAuthトークンをクリア
+floq calendar select                 # カレンダー選択（対話式）
+
+# 共通コマンド
+floq calendar show                   # 設定と今日の予定を表示
+floq calendar sync                   # キャッシュを更新
+floq calendar enable                 # 表示を有効化
+floq calendar disable                # 表示を無効化
+```
+
 ## テーマ
 
 26種類のテーマが利用可能。`floq config theme` でインタラクティブに選択（j/kで移動）。

package/README.md

@@ -16,6 +16,7 @@ A terminal-based GTD (Getting Things Done) task manager with MS-DOS style themes
 - **Task Search**: Quick search across all tasks with `/`
 - **Comments**: Add notes and comments to tasks
 - **Cloud Sync**: Optional sync with [Turso](https://turso.tech/) using embedded replicas
+- **Google Calendar**: Display today's events via iCal URL or OAuth integration
 - **Themes**: Multiple themes including MS-DOS nostalgic styles and Dragon Quest RPG style
 - **Splash Screen**: Configurable startup splash with Dragon Quest style for retro themes
 - **i18n**: English and Japanese support
@@ -259,6 +260,95 @@ floq config turso --disable
 - TUI header shows connection status (cloud icon for Turso, local icon for local mode)
 - CLI commands display `🔄 Turso sync: hostname` when Turso is enabled
 
+## Google Calendar Integration
+
+Floq can display your Google Calendar events in the TUI. Two methods are available:
+
+### Option 1: iCal URL (Simple, No Authentication)
+
+Use Google Calendar's secret iCal URL for read-only access without OAuth setup.
+
+```bash
+# Get your iCal URL from Google Calendar:
+# Settings > (Your Calendar) > Integrate calendar > "Secret address in iCal format"
+
+floq calendar add "https://calendar.google.com/calendar/ical/..." -n "My Calendar"
+floq calendar show
+```
+
+### Option 2: Google OAuth (Full API Access)
+
+Use OAuth for better reliability and access to all your calendars.
+
+#### Setup
+
+1. Go to [Google Cloud Console](https://console.cloud.google.com/)
+2. Create a project (or select an existing one)
+3. **Enable Google Calendar API**:
+   - Go to **APIs & Services > Library**
+   - Search for "Google Calendar API"
+   - Click **Enable**
+4. **Configure OAuth consent screen**:
+   - Go to **APIs & Services > OAuth consent screen**
+   - Select **External** and click Create
+   - Fill in app name and required fields
+   - Add your email to **Test users**
+5. **Create OAuth credentials**:
+   - Go to **APIs & Services > Credentials**
+   - Click **Create Credentials > OAuth client ID**
+   - Application type: **TV and Limited Input devices** (not "Desktop app")
+   - Copy the Client ID and Client Secret
+
+#### Configuration
+
+```bash
+# Set OAuth credentials (or use environment variables)
+floq calendar config --client-id "your-client-id.apps.googleusercontent.com" --client-secret "your-secret"
+
+# Or use environment variables
+export GOOGLE_CLIENT_ID="your-client-id.apps.googleusercontent.com"
+export GOOGLE_CLIENT_SECRET="your-secret"
+
+# Login with Google
+floq calendar login
+# → Opens browser for authentication
+# → Enter the displayed code when prompted
+
+# Select a calendar
+floq calendar select
+# → Shows list of your calendars
+# → Enter the number to select
+
+# View configuration and today's events
+floq calendar show
+
+# Refresh calendar cache
+floq calendar sync
+
+# Logout
+floq calendar logout
+```
+
+### Calendar Commands
+
+```bash
+# iCal mode
+floq calendar add <url> [-n name]   # Add iCal URL
+floq calendar remove                 # Remove calendar
+
+# OAuth mode
+floq calendar config --client-id <id> --client-secret <secret>
+floq calendar login                  # Google OAuth login
+floq calendar logout                 # Clear OAuth tokens
+floq calendar select                 # Select calendar (interactive)
+
+# Common commands
+floq calendar show                   # Show config and today's events
+floq calendar sync                   # Refresh cache
+floq calendar enable                 # Enable display
+floq calendar disable                # Disable display
+```
+
 ## Themes
 
 26 themes available. Use `floq config theme` for interactive selection (j/k to navigate).

package/dist/calendar/google-api.d.ts

@@ -0,0 +1,16 @@
+import type { CalendarEvent } from './index.js';
+export interface GoogleCalendar {
+    id: string;
+    summary: string;
+    primary?: boolean;
+    backgroundColor?: string;
+    foregroundColor?: string;
+}
+/**
+ * List all calendars the user has access to
+ */
+export declare function listCalendars(accessToken: string): Promise<GoogleCalendar[]>;
+/**
+ * List events from a specific calendar
+ */
+export declare function listEvents(accessToken: string, calendarId: string, timeMin: Date, timeMax: Date): Promise<CalendarEvent[]>;

package/dist/calendar/google-api.js

@@ -0,0 +1,65 @@
+const GOOGLE_CALENDAR_API_BASE = 'https://www.googleapis.com/calendar/v3';
+/**
+ * List all calendars the user has access to
+ */
+export async function listCalendars(accessToken) {
+    const response = await fetch(`${GOOGLE_CALENDAR_API_BASE}/users/me/calendarList`, {
+        headers: {
+            Authorization: `Bearer ${accessToken}`,
+        },
+    });
+    if (!response.ok) {
+        const error = await response.text();
+        throw new Error(`Failed to list calendars: ${error}`);
+    }
+    const data = await response.json();
+    return data.items.map(item => ({
+        id: item.id,
+        summary: item.summary,
+        primary: item.primary,
+        backgroundColor: item.backgroundColor,
+        foregroundColor: item.foregroundColor,
+    }));
+}
+/**
+ * List events from a specific calendar
+ */
+export async function listEvents(accessToken, calendarId, timeMin, timeMax) {
+    const params = new URLSearchParams({
+        timeMin: timeMin.toISOString(),
+        timeMax: timeMax.toISOString(),
+        singleEvents: 'true', // Expand recurring events
+        orderBy: 'startTime',
+        maxResults: '100',
+    });
+    const encodedCalendarId = encodeURIComponent(calendarId);
+    const response = await fetch(`${GOOGLE_CALENDAR_API_BASE}/calendars/${encodedCalendarId}/events?${params}`, {
+        headers: {
+            Authorization: `Bearer ${accessToken}`,
+        },
+    });
+    if (!response.ok) {
+        const error = await response.text();
+        throw new Error(`Failed to list events: ${error}`);
+    }
+    const data = await response.json();
+    return data.items
+        .filter(item => item.status !== 'cancelled')
+        .map(item => {
+        const isAllDay = !item.start.dateTime;
+        const start = isAllDay
+            ? new Date(item.start.date + 'T00:00:00')
+            : new Date(item.start.dateTime);
+        const end = isAllDay
+            ? new Date(item.end.date + 'T00:00:00')
+            : new Date(item.end.dateTime);
+        return {
+            id: item.id,
+            title: item.summary || 'Untitled',
+            start,
+            end,
+            allDay: isAllDay,
+            location: item.location,
+        };
+    });
+}

package/dist/calendar/index.d.ts

@@ -0,0 +1,40 @@
+export interface CalendarEvent {
+    id: string;
+    title: string;
+    start: Date;
+    end: Date;
+    allDay: boolean;
+    location?: string;
+}
+/**
+ * Fetch calendar events from the configured source (iCal URL or OAuth)
+ */
+export declare function fetchCalendarEvents(url?: string): Promise<CalendarEvent[]>;
+/**
+ * Get cached events or fetch if cache is stale
+ */
+export declare function getCalendarEvents(): Promise<CalendarEvent[]>;
+/**
+ * Get today's events from cache (synchronous)
+ */
+export declare function getTodayEvents(): CalendarEvent[];
+/**
+ * Get upcoming events (next event for each hour slot)
+ */
+export declare function getUpcomingEvents(limit?: number): CalendarEvent[];
+/**
+ * Clear the events cache
+ */
+export declare function clearCalendarCache(): void;
+/**
+ * Format time for display (HH:MM format)
+ */
+export declare function formatEventTime(date: Date): string;
+/**
+ * Check if an event is currently happening
+ */
+export declare function isEventOngoing(event: CalendarEvent): boolean;
+/**
+ * Get time until event starts (in minutes)
+ */
+export declare function getMinutesUntilEvent(event: CalendarEvent): number;

package/dist/calendar/index.js

@@ -0,0 +1,253 @@
+import ICAL from 'ical.js';
+import { getCalendarConfig, isCalendarEnabled, getCalendarType, getCalendarOAuthConfig } from '../config.js';
+import { getValidAccessToken } from './oauth.js';
+import { listEvents as listGoogleEvents } from './google-api.js';
+const CACHE_TTL_MS = 5 * 60 * 1000; // 5 minutes
+let eventsCache = null;
+/**
+ * Parse iCal data and extract events
+ */
+function parseICalData(icalData) {
+    const events = [];
+    try {
+        const jcalData = ICAL.parse(icalData);
+        const vcalendar = new ICAL.Component(jcalData);
+        const vevents = vcalendar.getAllSubcomponents('vevent');
+        for (const vevent of vevents) {
+            const event = new ICAL.Event(vevent);
+            // Handle recurring events - get occurrences for today and next 7 days
+            const now = new Date();
+            const startOfToday = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+            const endOfWeek = new Date(startOfToday);
+            endOfWeek.setDate(endOfWeek.getDate() + 7);
+            if (event.isRecurring()) {
+                try {
+                    const iter = event.iterator();
+                    let next = iter.next();
+                    let count = 0;
+                    const maxOccurrences = 100; // Safety limit
+                    while (next && count < maxOccurrences) {
+                        const occurrenceStart = next.toJSDate();
+                        const occurrenceEnd = new Date(occurrenceStart.getTime() + event.duration.toSeconds() * 1000);
+                        // Only include occurrences within our time window
+                        if (occurrenceStart >= startOfToday && occurrenceStart < endOfWeek) {
+                            events.push({
+                                id: `${event.uid}-${occurrenceStart.getTime()}`,
+                                title: event.summary || 'Untitled',
+                                start: occurrenceStart,
+                                end: occurrenceEnd,
+                                allDay: event.startDate.isDate,
+                                location: event.location || undefined,
+                            });
+                        }
+                        // Stop if we're past our window
+                        if (occurrenceStart >= endOfWeek)
+                            break;
+                        next = iter.next();
+                        count++;
+                    }
+                }
+                catch {
+                    // If recurring expansion fails, fall back to single event
+                    const startDate = event.startDate.toJSDate();
+                    const endDate = event.endDate?.toJSDate() || startDate;
+                    events.push({
+                        id: event.uid,
+                        title: event.summary || 'Untitled',
+                        start: startDate,
+                        end: endDate,
+                        allDay: event.startDate.isDate,
+                        location: event.location || undefined,
+                    });
+                }
+            }
+            else {
+                // Non-recurring event
+                const startDate = event.startDate.toJSDate();
+                const endDate = event.endDate?.toJSDate() || startDate;
+                events.push({
+                    id: event.uid,
+                    title: event.summary || 'Untitled',
+                    start: startDate,
+                    end: endDate,
+                    allDay: event.startDate.isDate,
+                    location: event.location || undefined,
+                });
+            }
+        }
+    }
+    catch (error) {
+        // Silently fail on parse errors
+        console.error('Failed to parse iCal data:', error);
+    }
+    return events;
+}
+/**
+ * Normalize iCal URL (convert webcal:// to https://)
+ */
+function normalizeUrl(url) {
+    if (url.startsWith('webcal://')) {
+        return url.replace('webcal://', 'https://');
+    }
+    return url;
+}
+/**
+ * Fetch calendar events via OAuth (Google Calendar API)
+ */
+async function fetchEventsViaOAuth() {
+    const oauthConfig = getCalendarOAuthConfig();
+    if (!oauthConfig) {
+        return [];
+    }
+    const accessToken = await getValidAccessToken();
+    if (!accessToken) {
+        return [];
+    }
+    const now = new Date();
+    const startOfToday = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+    const endOfWeek = new Date(startOfToday);
+    endOfWeek.setDate(endOfWeek.getDate() + 7);
+    try {
+        return await listGoogleEvents(accessToken, oauthConfig.calendarId, startOfToday, endOfWeek);
+    }
+    catch (error) {
+        console.error('Failed to fetch Google Calendar events:', error);
+        return [];
+    }
+}
+/**
+ * Fetch calendar events via iCal URL
+ */
+async function fetchEventsViaIcal(url) {
+    const normalizedUrl = normalizeUrl(url);
+    const response = await fetch(normalizedUrl, {
+        headers: {
+            'User-Agent': 'Floq GTD CLI',
+        },
+    });
+    if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+    }
+    const icalData = await response.text();
+    return parseICalData(icalData);
+}
+/**
+ * Fetch calendar events from the configured source (iCal URL or OAuth)
+ */
+export async function fetchCalendarEvents(url) {
+    try {
+        let events;
+        const calendarType = getCalendarType();
+        if (url) {
+            // Explicit URL provided, use iCal mode
+            events = await fetchEventsViaIcal(url);
+        }
+        else if (calendarType === 'oauth') {
+            // OAuth mode
+            events = await fetchEventsViaOAuth();
+        }
+        else {
+            // iCal mode
+            const targetUrl = getCalendarConfig()?.url;
+            if (!targetUrl) {
+                return [];
+            }
+            events = await fetchEventsViaIcal(targetUrl);
+        }
+        // Update cache
+        eventsCache = {
+            events,
+            timestamp: Date.now(),
+        };
+        return events;
+    }
+    catch (error) {
+        // Silently fail on errors
+        console.error('Failed to fetch calendar:', error);
+        return eventsCache?.events || [];
+    }
+}
+/**
+ * Get cached events or fetch if cache is stale
+ */
+export async function getCalendarEvents() {
+    if (!isCalendarEnabled()) {
+        return [];
+    }
+    // Check if cache is valid
+    if (eventsCache && Date.now() - eventsCache.timestamp < CACHE_TTL_MS) {
+        return eventsCache.events;
+    }
+    // Fetch fresh data
+    return fetchCalendarEvents();
+}
+/**
+ * Get today's events from cache (synchronous)
+ */
+export function getTodayEvents() {
+    if (!eventsCache) {
+        return [];
+    }
+    const now = new Date();
+    const startOfToday = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+    const endOfToday = new Date(startOfToday);
+    endOfToday.setDate(endOfToday.getDate() + 1);
+    return eventsCache.events
+        .filter(event => {
+        // Event starts today or spans today
+        return (event.start >= startOfToday && event.start < endOfToday) ||
+            (event.start < startOfToday && event.end >= startOfToday);
+    })
+        .sort((a, b) => {
+        // All-day events first, then by start time
+        if (a.allDay && !b.allDay)
+            return -1;
+        if (!a.allDay && b.allDay)
+            return 1;
+        return a.start.getTime() - b.start.getTime();
+    });
+}
+/**
+ * Get upcoming events (next event for each hour slot)
+ */
+export function getUpcomingEvents(limit = 5) {
+    if (!eventsCache) {
+        return [];
+    }
+    const now = new Date();
+    return eventsCache.events
+        .filter(event => {
+        // Future events or ongoing events
+        return event.end > now;
+    })
+        .sort((a, b) => a.start.getTime() - b.start.getTime())
+        .slice(0, limit);
+}
+/**
+ * Clear the events cache
+ */
+export function clearCalendarCache() {
+    eventsCache = null;
+}
+/**
+ * Format time for display (HH:MM format)
+ */
+export function formatEventTime(date) {
+    const hours = String(date.getHours()).padStart(2, '0');
+    const minutes = String(date.getMinutes()).padStart(2, '0');
+    return `${hours}:${minutes}`;
+}
+/**
+ * Check if an event is currently happening
+ */
+export function isEventOngoing(event) {
+    const now = new Date();
+    return event.start <= now && event.end > now;
+}
+/**
+ * Get time until event starts (in minutes)
+ */
+export function getMinutesUntilEvent(event) {
+    const now = new Date();
+    return Math.floor((event.start.getTime() - now.getTime()) / (1000 * 60));
+}

package/dist/calendar/oauth.d.ts

@@ -0,0 +1,32 @@
+import { type CalendarOAuthTokens } from '../config.js';
+export interface DeviceCodeResponse {
+    deviceCode: string;
+    userCode: string;
+    verificationUrl: string;
+    expiresIn: number;
+    interval: number;
+}
+/**
+ * Start the OAuth Device Code flow
+ */
+export declare function startOAuthFlow(): Promise<DeviceCodeResponse>;
+/**
+ * Poll for tokens after user has authorized
+ */
+export declare function pollForTokens(deviceCode: string, interval?: number): Promise<CalendarOAuthTokens>;
+/**
+ * Refresh the access token using the refresh token
+ */
+export declare function refreshAccessToken(refreshToken: string): Promise<CalendarOAuthTokens>;
+/**
+ * Check if the token is expired (with 5-minute buffer)
+ */
+export declare function isTokenExpired(tokens: CalendarOAuthTokens): boolean;
+/**
+ * Get a valid access token, refreshing if necessary
+ */
+export declare function getValidAccessToken(): Promise<string | null>;
+/**
+ * Clear OAuth tokens (logout)
+ */
+export declare function clearOAuthTokens(): void;