calendit 1.0.0

package/dist/core/applier.js

@@ -0,0 +1,141 @@
+import { ValidationError } from "./errors.js";
+import { logger } from "./logger.js";
+export class Applier {
+    service;
+    constructor(service) {
+        this.service = service;
+    }
+    /**
+     * カレンダーに予定を適用する
+     */
+    async apply(calendarId, inputEvents, timerange, options = {}) {
+        // 1. バリデーション
+        const errors = [];
+        const seenIds = new Set();
+        for (let i = 0; i < inputEvents.length; i++) {
+            const event = inputEvents[i];
+            const label = event.summary || `Event #${i + 1}`;
+            if (event.id) {
+                if (seenIds.has(event.id)) {
+                    errors.push(`Duplicate ID found: ${event.id} (${label})`);
+                }
+                seenIds.add(event.id);
+            }
+            if (event.start && event.end) {
+                if (new Date(event.start) >= new Date(event.end)) {
+                    errors.push(`Invalid time range: ${label} (${event.start} - ${event.end})`);
+                }
+            }
+        }
+        if (errors.length > 0) {
+            throw new ValidationError(`入力イベントに不整合があります:\n${errors.map((e) => `  - ${e}`).join("\n")}`, "重複ID・開始終了時刻の逆転を修正してから再実行してください。");
+        }
+        let range = timerange;
+        if (!range && inputEvents.length > 0) {
+            // 入力された予定から期間を自動計算
+            let minStart = Infinity;
+            let maxEnd = -Infinity;
+            for (const event of inputEvents) {
+                if (event.start) {
+                    const s = new Date(event.start).getTime();
+                    if (s < minStart)
+                        minStart = s;
+                }
+                if (event.end) {
+                    const e = new Date(event.end).getTime();
+                    if (e > maxEnd)
+                        maxEnd = e;
+                }
+            }
+            if (minStart !== Infinity && maxEnd !== -Infinity) {
+                // 当日の開始・終了までバッファを持たせる
+                const start = new Date(minStart);
+                start.setHours(0, 0, 0, 0);
+                const end = new Date(maxEnd);
+                end.setHours(23, 59, 59, 999);
+                range = { start, end };
+                logger.info(`Auto-detected sync range: ${range.start.toISOString()} to ${range.end.toISOString()}`);
+            }
+        }
+        if (!range) {
+            if (options.sync) {
+                const now = new Date();
+                const start = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+                const end = new Date(now.getFullYear(), now.getMonth(), now.getDate(), 23, 59, 59, 999);
+                range = { start, end };
+                logger.info(`Sync range fallback applied: ${start.toISOString()} to ${end.toISOString()}`);
+            }
+        }
+        if (!range) {
+            // 範囲を特定できない場合は空の実行とする（安全のため全削除は行わない）
+            return { created: [], updated: [], deleted: [] };
+        }
+        // 現在の予定を取得
+        const existingEvents = await this.service.listEvents(calendarId, range.start, range.end);
+        const existingMap = new Map(existingEvents.map((e) => [e.id, e]));
+        const results = {
+            created: [],
+            updated: [],
+            deleted: [],
+        };
+        // 1. 追加・更新
+        for (const input of inputEvents) {
+            if (input.id && existingMap.has(input.id)) {
+                // 更新
+                const existing = existingMap.get(input.id);
+                const diffs = [];
+                if (input.summary && input.summary !== existing.summary) {
+                    diffs.push(`Summary: "${existing.summary}" -> "${input.summary}"`);
+                }
+                // Compare as timestamps to avoid false diffs from timezone format differences
+                if (input.start && new Date(input.start).getTime() !== new Date(existing.start).getTime()) {
+                    diffs.push(`Start: ${existing.start} -> ${input.start}`);
+                }
+                if (input.end && new Date(input.end).getTime() !== new Date(existing.end).getTime()) {
+                    diffs.push(`End: ${existing.end} -> ${input.end}`);
+                }
+                if (diffs.length > 0) {
+                    if (options.dryRun) {
+                        logger.info(`[Dry Run] Update: ${input.summary || existing.summary} (${input.id})`);
+                        diffs.forEach(d => logger.info(`  └ ${d}`));
+                    }
+                    else {
+                        await this.service.updateEvent(calendarId, input.id, input);
+                    }
+                    results.updated.push({ input, existing, diffs });
+                }
+                existingMap.delete(input.id); // 処理済みとして削除
+            }
+            else {
+                // 新規作成
+                if (options.dryRun) {
+                    logger.info(`[Dry Run] Create: ${input.summary}`);
+                }
+                else {
+                    // 型の整合性のために必要な情報を補完
+                    await this.service.createEvent(calendarId, {
+                        summary: input.summary || "(No Title)",
+                        start: input.start,
+                        end: input.end,
+                        location: input.location,
+                        description: input.description,
+                    });
+                }
+                results.created.push(input);
+            }
+        }
+        // 2. 削除 (Sync モード時)
+        if (options.sync) {
+            for (const [id, event] of existingMap.entries()) {
+                if (options.dryRun) {
+                    logger.info(`[Dry Run] Delete: ${event.summary} (${id})`);
+                }
+                else {
+                    await this.service.deleteEvent(calendarId, id);
+                }
+                results.deleted.push(event);
+            }
+        }
+        return results;
+    }
+}

package/dist/core/auth.d.ts

@@ -0,0 +1,22 @@
+import { PublicClientApplication } from "@azure/msal-node";
+import { OAuth2Client } from "google-auth-library";
+export declare class AuthManager {
+    private msalClient?;
+    constructor();
+    /**
+     * Outlook (Microsoft Graph) 認証の初期化と取得
+     */
+    getOutlookClient(clientId: string, tenantId?: string): Promise<PublicClientApplication>;
+    /**
+     * Google 認証クライアントの取得
+     */
+    getGoogleAuth(clientId: string, clientSecret: string, accountId?: string): Promise<OAuth2Client>;
+    /**
+     * Google の対話型ログインフロー
+     */
+    loginGoogle(clientId: string, clientSecret: string, accountId?: string): Promise<void>;
+    /**
+     * Outlook の対話型ログインフロー
+     */
+    loginOutlook(clientId: string, tenantId?: string, accountId?: string): Promise<void>;
+}

package/dist/core/auth.js

@@ -0,0 +1,153 @@
+import { PublicClientApplication } from "@azure/msal-node";
+import { KeychainPersistence, PersistenceCachePlugin } from "@azure/msal-node-extensions";
+import { google } from "googleapis";
+import * as path from "path";
+import * as os from "os";
+import * as fs from "fs/promises";
+import * as http from "http";
+import open from "open";
+import { AuthError } from "./errors.js";
+import { logger } from "./logger.js";
+const CONFIG_DIR = path.join(os.homedir(), ".config", "calendit");
+function getTokenPath(name) {
+    const filename = name ? `google_token_${name}.json` : "google_token.json";
+    return path.join(CONFIG_DIR, filename);
+}
+export class AuthManager {
+    msalClient;
+    constructor() { }
+    /**
+     * Outlook (Microsoft Graph) 認証の初期化と取得
+     */
+    async getOutlookClient(clientId, tenantId = "common") {
+        if (!this.msalClient) {
+            await fs.mkdir(CONFIG_DIR, { recursive: true });
+            const cachePath = path.join(CONFIG_DIR, "msal_cache.json");
+            const persistence = await KeychainPersistence.create(cachePath, "calendit-service", "outlook-account");
+            const cachePlugin = new PersistenceCachePlugin(persistence);
+            const msalConfig = {
+                auth: {
+                    clientId,
+                    authority: `https://login.microsoftonline.com/${tenantId}`,
+                },
+                cache: {
+                    cachePlugin,
+                },
+            };
+            this.msalClient = new PublicClientApplication(msalConfig);
+        }
+        return this.msalClient;
+    }
+    /**
+     * Google 認証クライアントの取得
+     */
+    async getGoogleAuth(clientId, clientSecret, accountId) {
+        const oauth2Client = new google.auth.OAuth2(clientId, clientSecret, "http://localhost:3000");
+        const tokenPath = getTokenPath(accountId);
+        try {
+            const tokenData = await fs.readFile(tokenPath, "utf-8");
+            oauth2Client.setCredentials(JSON.parse(tokenData));
+        }
+        catch (e) {
+            // トークンがない場合は何もしない
+        }
+        return oauth2Client;
+    }
+    /**
+     * Google の対話型ログインフロー
+     */
+    async loginGoogle(clientId, clientSecret, accountId) {
+        const oauth2Client = new google.auth.OAuth2(clientId, clientSecret, "http://localhost:3000");
+        const tokenPath = getTokenPath(accountId);
+        const authUrl = oauth2Client.generateAuthUrl({
+            access_type: "offline",
+            scope: ["https://www.googleapis.com/auth/calendar"],
+            prompt: "consent",
+        });
+        logger.info(`Opening browser for Google Authentication (${accountId || "default"})...`);
+        logger.info("URL:", authUrl);
+        logger.info("ブラウザが開かない場合は上記URLを手動で開いてください。3分以内に認証を完了してください。");
+        return new Promise((resolve, reject) => {
+            let server;
+            const timeout = setTimeout(() => {
+                server.close();
+                reject(new AuthError("Google 認証がタイムアウトしました。", "再度 `calendit auth login google` を実行して、3分以内に認証を完了してください。"));
+            }, 180_000);
+            server = http.createServer(async (req, res) => {
+                try {
+                    const url = new URL(req.url, `http://${req.headers.host}`);
+                    const code = url.searchParams.get("code");
+                    if (code) {
+                        const { tokens } = await oauth2Client.getToken(code);
+                        await fs.mkdir(CONFIG_DIR, { recursive: true });
+                        await fs.writeFile(tokenPath, JSON.stringify(tokens, null, 2));
+                        res.end("Authentication successful! You can close this tab and return to the terminal.");
+                        clearTimeout(timeout);
+                        server.close();
+                        resolve();
+                    }
+                    else {
+                        res.end("No code found in the redirect.");
+                    }
+                }
+                catch (e) {
+                    res.end("Authentication failed.");
+                    clearTimeout(timeout);
+                    reject(e);
+                }
+            });
+            server.listen(3000, () => {
+                open(authUrl);
+            });
+        });
+    }
+    /**
+     * Outlook の対話型ログインフロー
+     */
+    async loginOutlook(clientId, tenantId = "common", accountId) {
+        const pca = await this.getOutlookClient(clientId, tenantId);
+        const authCodeUrlParameters = {
+            scopes: ["https://graph.microsoft.com/Calendars.ReadWrite"],
+            redirectUri: "http://localhost:3000",
+        };
+        const authUrl = await pca.getAuthCodeUrl(authCodeUrlParameters);
+        logger.info(`Opening browser for Outlook Authentication (${accountId || "default"})...`);
+        logger.info("URL:", authUrl);
+        logger.info("ブラウザが開かない場合は上記URLを手動で開いてください。3分以内に認証を完了してください。");
+        return new Promise((resolve, reject) => {
+            let server;
+            const timeout = setTimeout(() => {
+                server.close();
+                reject(new AuthError("Outlook 認証がタイムアウトしました。", "再度 `calendit auth login outlook` を実行して、3分以内に認証を完了してください。"));
+            }, 180_000);
+            server = http.createServer(async (req, res) => {
+                try {
+                    const url = new URL(req.url, `http://${req.headers.host}`);
+                    const code = url.searchParams.get("code");
+                    if (code) {
+                        await pca.acquireTokenByCode({
+                            code,
+                            scopes: ["https://graph.microsoft.com/Calendars.ReadWrite"],
+                            redirectUri: "http://localhost:3000",
+                        });
+                        res.end("Authentication successful! You can close this tab and return to the terminal.");
+                        clearTimeout(timeout);
+                        server.close();
+                        resolve();
+                    }
+                    else {
+                        res.end("No code found in the redirect.");
+                    }
+                }
+                catch (e) {
+                    res.end("Authentication failed.");
+                    clearTimeout(timeout);
+                    reject(e);
+                }
+            });
+            server.listen(3000, () => {
+                open(authUrl);
+            });
+        });
+    }
+}

package/dist/core/config.d.ts

@@ -0,0 +1,14 @@
+import { ContextConfig, GoogleCredentials, OutlookCredentials } from "../types/index.js";
+export declare class ConfigManager {
+    private config;
+    constructor();
+    load(): Promise<void>;
+    save(): Promise<void>;
+    getContext(name: string): ContextConfig | undefined;
+    setContext(name: string, context: ContextConfig): void;
+    getAllContexts(): Record<string, ContextConfig>;
+    getGoogleCreds(): GoogleCredentials | undefined;
+    setGoogleCreds(id: string, secret: string): void;
+    getOutlookCreds(): OutlookCredentials | undefined;
+    setOutlookCreds(id: string, tenantId: string): void;
+}

package/dist/core/config.js

@@ -0,0 +1,75 @@
+import * as fs from "fs/promises";
+import * as path from "path";
+import * as os from "os";
+import { z } from "zod";
+import { ConfigError } from "./errors.js";
+const CONFIG_DIR = process.env.CALENDIT_CONFIG_DIR || path.join(os.homedir(), ".config", "calendit");
+const CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
+const contextConfigSchema = z.object({
+    service: z.enum(["google", "outlook"]),
+    calendarId: z.string().min(1),
+    accountId: z.string().optional(),
+    fields: z.array(z.string()).optional(),
+    defaultFormat: z.enum(["csv", "md", "json"]).optional(),
+});
+const fullAppConfigSchema = z.object({
+    contexts: z.record(z.string(), contextConfigSchema),
+    google_creds: z
+        .object({
+        id: z.string().min(1),
+        secret: z.string().min(1),
+    })
+        .optional(),
+    outlook_creds: z
+        .object({
+        id: z.string().min(1),
+        tenantId: z.string().min(1).default("common"),
+    })
+        .optional(),
+});
+export class ConfigManager {
+    config = { contexts: {} };
+    constructor() { }
+    async load() {
+        await fs.mkdir(CONFIG_DIR, { recursive: true });
+        try {
+            const data = await fs.readFile(CONFIG_FILE, "utf-8");
+            const parsed = JSON.parse(data);
+            this.config = fullAppConfigSchema.parse(parsed);
+        }
+        catch (e) {
+            if (e && (e.code === "ENOENT" || /no such file/i.test(String(e.message)))) {
+                throw new ConfigError("設定ファイルが見つかりません。", "初回は `calendit config set-google --id <id> --secret <secret>` などでセットアップしてください。");
+            }
+            if (e instanceof z.ZodError) {
+                throw new ConfigError("設定ファイルの形式が不正です。", `config.json を確認してください。詳細: ${e.issues.map((issue) => issue.message).join(", ")}`);
+            }
+            throw new ConfigError("設定ファイルの読み込みに失敗しました。", "config.json のJSON形式を確認してください。");
+        }
+    }
+    async save() {
+        await fs.mkdir(CONFIG_DIR, { recursive: true });
+        await fs.writeFile(CONFIG_FILE, JSON.stringify(this.config, null, 2), "utf-8");
+    }
+    getContext(name) {
+        return this.config.contexts[name];
+    }
+    setContext(name, context) {
+        this.config.contexts[name] = context;
+    }
+    getAllContexts() {
+        return this.config.contexts;
+    }
+    getGoogleCreds() {
+        return this.config.google_creds;
+    }
+    setGoogleCreds(id, secret) {
+        this.config.google_creds = { id, secret };
+    }
+    getOutlookCreds() {
+        return this.config.outlook_creds;
+    }
+    setOutlookCreds(id, tenantId) {
+        this.config.outlook_creds = { id, tenantId };
+    }
+}

package/dist/core/datetime.d.ts

@@ -0,0 +1,12 @@
+/**
+ * サポート形式:
+ * - today
+ * - tomorrow
+ * - today HH:mm
+ * - tomorrow HH:mm
+ * - HH:mm
+ * - YYYY-MM-DD
+ * - YYYY-MM-DD HH:mm
+ * - ISO 8601
+ */
+export declare function parseDateTime(input: string | undefined, defaultOffset?: number): Date;

package/dist/core/datetime.js

@@ -0,0 +1,61 @@
+import { formatInTimeZone } from "date-fns-tz";
+import { ValidationError } from "./errors.js";
+import { logger } from "./logger.js";
+/**
+ * サポート形式:
+ * - today
+ * - tomorrow
+ * - today HH:mm
+ * - tomorrow HH:mm
+ * - HH:mm
+ * - YYYY-MM-DD
+ * - YYYY-MM-DD HH:mm
+ * - ISO 8601
+ */
+export function parseDateTime(input, defaultOffset = 0) {
+    const now = new Date();
+    const timeZone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+    const today = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+    const tomorrow = new Date(now.getFullYear(), now.getMonth(), now.getDate() + 1);
+    const todayStr = formatInTimeZone(today, timeZone, "yyyy-MM-dd");
+    const tomorrowStr = formatInTimeZone(tomorrow, timeZone, "yyyy-MM-dd");
+    let date;
+    const raw = input?.trim();
+    if (!raw || raw === "today") {
+        date = new Date(today.getTime() + defaultOffset * 24 * 60 * 60 * 1000);
+    }
+    else if (raw === "tomorrow") {
+        date = new Date(tomorrow.getTime() + defaultOffset * 24 * 60 * 60 * 1000);
+    }
+    else if (/^tomorrow\s+\d{1,2}:\d{2}$/.test(raw)) {
+        const time = raw.split(/\s+/)[1];
+        date = new Date(`${tomorrowStr}T${time}:00`);
+    }
+    else if (/^today\s+\d{1,2}:\d{2}$/.test(raw)) {
+        const time = raw.split(/\s+/)[1];
+        date = new Date(`${todayStr}T${time}:00`);
+    }
+    else if (/^\d{1,2}:\d{2}$/.test(raw)) {
+        date = new Date(`${todayStr}T${raw}:00`);
+    }
+    else if (/^\d{4}-\d{2}-\d{2}$/.test(raw)) {
+        const [y, m, d] = raw.split("-").map(Number);
+        date = new Date(y, m - 1, d);
+    }
+    else if (/^\d{4}-\d{2}-\d{2}\s+\d{1,2}:\d{2}$/.test(raw)) {
+        // YYYY-MM-DD HH:mm (スペース区切り)
+        const [datePart, timePart] = raw.split(/\s+/);
+        date = new Date(`${datePart}T${timePart}:00`);
+    }
+    else if (/^\d{4}-\d{2}-\d{2}T/.test(raw)) {
+        date = new Date(raw);
+    }
+    else {
+        throw new ValidationError(`日時フォーマットが不正です: "${input}"`, "例: `today 10:00`, `tomorrow`, `2026-04-16`, `2026-04-16 10:00`, `2026-04-16T10:00:00+09:00`");
+    }
+    if (Number.isNaN(date.getTime())) {
+        throw new ValidationError(`日時として解釈できません: "${input}"`, "入力値を見直してください。時間は HH:mm 形式で指定してください。");
+    }
+    logger.debug("parseDateTime", { input, parsed: date.toISOString() });
+    return date;
+}

package/dist/core/errors.d.ts

@@ -0,0 +1,21 @@
+export declare class CalendarError extends Error {
+    readonly hint?: string;
+    constructor(message: string, hint?: string);
+}
+export declare class ConfigError extends CalendarError {
+}
+export declare class AuthError extends CalendarError {
+}
+export declare class ValidationError extends CalendarError {
+}
+export declare class ApiError extends CalendarError {
+    readonly statusCode?: number;
+    readonly provider?: string;
+    readonly details?: unknown;
+    constructor(message: string, options?: {
+        statusCode?: number;
+        provider?: string;
+        details?: unknown;
+        hint?: string;
+    });
+}

package/dist/core/errors.js

@@ -0,0 +1,25 @@
+export class CalendarError extends Error {
+    hint;
+    constructor(message, hint) {
+        super(message);
+        this.name = new.target.name;
+        this.hint = hint;
+    }
+}
+export class ConfigError extends CalendarError {
+}
+export class AuthError extends CalendarError {
+}
+export class ValidationError extends CalendarError {
+}
+export class ApiError extends CalendarError {
+    statusCode;
+    provider;
+    details;
+    constructor(message, options = {}) {
+        super(message, options.hint);
+        this.statusCode = options.statusCode;
+        this.provider = options.provider;
+        this.details = options.details;
+    }
+}

package/dist/core/formatter.d.ts

@@ -0,0 +1,27 @@
+import { CalendarEvent } from "../types/index.js";
+export interface ParseResult {
+    events: Partial<CalendarEvent>[];
+    warnings: string[];
+}
+export declare class Formatter {
+    /**
+     * 予定の配列を CSV 文字列に変換
+     */
+    static toCsv(events: CalendarEvent[]): string;
+    /**
+     * CSV 文字列を予定の配列に変換
+     */
+    static fromCsv(csv: string): CalendarEvent[];
+    /**
+     * 予定の配列を Markdown 文字列に変換
+     */
+    static toMarkdown(events: CalendarEvent[]): string;
+    /**
+     * Markdown 文字列から予定を抽出
+     * 形式: - [ ] **Title** (HH:mm - HH:mm) (ID: id)
+     * インデントされた行は説明文として扱う
+     */
+    static fromMarkdown(md: string, strict?: boolean): ParseResult;
+    private static groupByDate;
+    private static formatTime;
+}