calendit 1.0.0

package/dist/core/formatter.js

@@ -0,0 +1,164 @@
+import { parse as parseCsv } from "csv-parse/sync";
+import { stringify as stringifyCsv } from "csv-stringify/sync";
+import { z } from "zod";
+import { ValidationError } from "./errors.js";
+import { logger } from "./logger.js";
+const partialEventSchema = z.object({
+    id: z.string().optional(),
+    summary: z.string().min(1, "summary is required"),
+    start: z.string().datetime({ local: true }),
+    end: z.string().datetime({ local: true }),
+    location: z.string().optional(),
+    description: z.string().optional(),
+});
+export class Formatter {
+    /**
+     * 予定の配列を CSV 文字列に変換
+     */
+    static toCsv(events) {
+        return stringifyCsv(events, {
+            header: true,
+            columns: ["id", "summary", "start", "end", "location", "description", "service", "calendarId"],
+        });
+    }
+    /**
+     * CSV 文字列を予定の配列に変換
+     */
+    static fromCsv(csv) {
+        const records = parseCsv(csv, {
+            columns: true,
+            skip_empty_lines: true,
+        });
+        return records;
+    }
+    /**
+     * 予定の配列を Markdown 文字列に変換
+     */
+    static toMarkdown(events) {
+        let md = "# 予定一覧\n\n";
+        const grouped = this.groupByDate(events);
+        for (const [date, dayEvents] of Object.entries(grouped)) {
+            md += `## ${date}\n`;
+            for (const e of dayEvents) {
+                const timeRange = `${this.formatTime(e.start)} - ${this.formatTime(e.end)}`;
+                md += `- [ ] **${e.summary}** (${timeRange}) (ID: ${e.id || "new"})\n`;
+                if (e.description)
+                    md += `  - ${e.description.replace(/\n/g, "\n    ")}\n`;
+            }
+            md += "\n";
+        }
+        return md;
+    }
+    /**
+     * Markdown 文字列から予定を抽出
+     * 形式: - [ ] **Title** (HH:mm - HH:mm) (ID: id)
+     * インデントされた行は説明文として扱う
+     */
+    static fromMarkdown(md, strict = false) {
+        const events = [];
+        const warnings = [];
+        const lines = md.split("\n");
+        let currentDate = "";
+        let currentEvent = null;
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            const dateMatch = line.match(/^##\s+(\d{4}-\d{2}-\d{2})/);
+            if (dateMatch) {
+                currentDate = dateMatch[1];
+                currentEvent = null;
+                continue;
+            }
+            // イベント行のパース: - [ ] **Summary** (HH:mm - HH:mm) (ID: id)
+            // より柔軟に、末尾の (ID: ...) を優先的に探す。ID内のスペースや末尾のスペースを許容。
+            const eventRowMatch = line.match(/^-\s+\[.\]\s+(.+)\((ID:\s*[^)]+)\)\s*$/);
+            if (eventRowMatch && currentDate) {
+                const fullContent = eventRowMatch[1].trim();
+                const idPart = eventRowMatch[2];
+                const idMatch = idPart.match(/ID:\s+(.+)/);
+                const id = idMatch ? idMatch[1] : undefined;
+                // タイトルと時間帯を分離: **Summary** (HH:mm - HH:mm)
+                // 後ろから最初の (XX:XX - XX:XX) を探す
+                const timeMatch = fullContent.match(/\((?:\d{1,2}:\d{2})\s*-\s*(?:\d{1,2}:\d{2})\)$/);
+                if (timeMatch) {
+                    const timeRangeStr = timeMatch[0];
+                    const summaryPart = fullContent.replace(timeRangeStr, "").trim();
+                    const summary = summaryPart.replace(/^\*\*(.+)\*\*$/, "$1"); // ** で囲まれていれば外す
+                    const times = timeRangeStr.slice(1, -1).split("-").map(t => t.trim());
+                    const start = `${currentDate}T${times[0]}:00`;
+                    let end = `${currentDate}T${times[1]}:00`;
+                    if (times[1] < times[0]) {
+                        // End time is earlier than start time -> assume next day
+                        const d = new Date(currentDate);
+                        d.setDate(d.getDate() + 1);
+                        const nextDay = d.toISOString().split("T")[0];
+                        end = `${nextDay}T${times[1]}:00`;
+                    }
+                    currentEvent = {
+                        id: id === "new" ? undefined : id,
+                        summary,
+                        start,
+                        end,
+                        description: "",
+                    };
+                    events.push(currentEvent);
+                }
+                else {
+                    warnings.push(`[Line ${i + 1}] Skip: Time range format is invalid.`);
+                }
+                continue;
+            }
+            else if (line.trim().startsWith("- [ ]")) {
+                warnings.push(`[Line ${i + 1}] Skip: Line matches event pattern but ID or Date is missing.`);
+            }
+            // 説明文のパース: インデントされた行 かつ 直前にイベントがある場合
+            if (currentEvent && line.startsWith("  ")) {
+                const descMatch = line.match(/^\s+-\s+(.+)$/);
+                const descLine = descMatch ? descMatch[1] : line.trim();
+                if (currentEvent.description) {
+                    currentEvent.description += "\n" + descLine;
+                }
+                else {
+                    currentEvent.description = descLine;
+                }
+            }
+            else {
+                // それ以外の行はイベントの説明文モードを終了
+                if (line.trim() !== "" && !line.startsWith("- ")) {
+                    // currentEvent = null;
+                }
+            }
+        }
+        for (const [index, event] of events.entries()) {
+            const parsed = partialEventSchema.safeParse(event);
+            if (!parsed.success) {
+                const detail = parsed.error.issues.map((issue) => issue.message).join(", ");
+                const message = `Event #${index + 1} validation failed: ${detail}`;
+                if (strict) {
+                    throw new ValidationError(message, "Markdown の予定行と時刻形式を確認してください。");
+                }
+                warnings.push(message);
+            }
+        }
+        warnings.forEach((warning) => logger.warn(warning));
+        return { events, warnings };
+    }
+    static groupByDate(events) {
+        const groups = {};
+        for (const e of events) {
+            const date = e.start.split("T")[0];
+            if (!groups[date])
+                groups[date] = [];
+            groups[date].push(e);
+        }
+        return groups;
+    }
+    static formatTime(iso) {
+        if (!iso)
+            return "??:??";
+        const date = new Date(iso);
+        // システムのタイムゾーンで HH:mm 形式にする
+        const hours = String(date.getHours()).padStart(2, "0");
+        const minutes = String(date.getMinutes()).padStart(2, "0");
+        return `${hours}:${minutes}`;
+    }
+}

package/dist/core/logger.d.ts

@@ -0,0 +1,9 @@
+export type LogLevel = "debug" | "info" | "warn" | "error";
+export declare function setLogLevel(level: LogLevel): void;
+export declare function setDebugDump(filePath: string): void;
+export declare const logger: {
+    debug: (...args: unknown[]) => void;
+    info: (...args: unknown[]) => void;
+    warn: (...args: unknown[]) => void;
+    error: (...args: unknown[]) => void;
+};

package/dist/core/logger.js

@@ -0,0 +1,68 @@
+import * as fs from "fs";
+const LEVEL_PRIORITY = {
+    debug: 10,
+    info: 20,
+    warn: 30,
+    error: 40,
+};
+let currentLevel = process.env.DEBUG === "calendit" ? "debug" : "info";
+let debugStream = null;
+export function setLogLevel(level) {
+    currentLevel = level;
+}
+export function setDebugDump(filePath) {
+    if (debugStream) {
+        debugStream.end();
+        debugStream = null;
+    }
+    debugStream = fs.createWriteStream(filePath, { flags: "a" });
+}
+function shouldLog(level) {
+    return LEVEL_PRIORITY[level] >= LEVEL_PRIORITY[currentLevel];
+}
+function writeToDebugDump(line) {
+    if (!debugStream)
+        return;
+    debugStream.write(`${line}\n`);
+}
+function stringifyArgs(args) {
+    return args
+        .map((arg) => {
+        if (typeof arg === "string")
+            return arg;
+        try {
+            return JSON.stringify(arg);
+        }
+        catch {
+            return String(arg);
+        }
+    })
+        .join(" ");
+}
+function emit(level, ...allArgs) {
+    const timestamp = new Date().toISOString().slice(11, 23);
+    const moduleOrMessage = allArgs[0];
+    const args = allArgs.slice(1);
+    const moduleTag = typeof moduleOrMessage === "string" && args.length > 0 ? `[${moduleOrMessage}]` : "";
+    const payload = moduleTag ? args : [moduleOrMessage, ...args];
+    const prefix = `[${level.toUpperCase()} ${timestamp}]${moduleTag}`;
+    const lineForDump = `${prefix} ${stringifyArgs(payload)}`.trim();
+    writeToDebugDump(lineForDump);
+    if (!shouldLog(level))
+        return;
+    if (level === "error") {
+        console.error(prefix, ...payload);
+        return;
+    }
+    if (level === "warn") {
+        console.warn(prefix, ...payload);
+        return;
+    }
+    console.log(prefix, ...payload);
+}
+export const logger = {
+    debug: (...args) => emit("debug", ...args),
+    info: (...args) => emit("info", ...args),
+    warn: (...args) => emit("warn", ...args),
+    error: (...args) => emit("error", ...args),
+};

package/dist/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.js

@@ -0,0 +1,95 @@
+import { Command } from "commander";
+import { AuthManager } from "./core/auth.js";
+import { ConfigManager } from "./core/config.js";
+import { ApiError, AuthError, CalendarError, ConfigError, ValidationError } from "./core/errors.js";
+import { logger, setDebugDump, setLogLevel } from "./core/logger.js";
+import { registerAuthCommands } from "./commands/auth.js";
+import { registerConfigCommands } from "./commands/config.js";
+import { registerQueryCommand } from "./commands/query.js";
+import { registerApplyCommand } from "./commands/apply.js";
+import { registerAddCommand } from "./commands/add.js";
+import { registerCalCommands } from "./commands/cal.js";
+const program = new Command();
+const deps = {
+    config: new ConfigManager(),
+    auth: new AuthManager(),
+};
+program
+    .name("calendit")
+    .description("Terminal-based Calendar Management Tool")
+    .version("2026-0416-01.02")
+    .option("--verbose", "Enable verbose debug logs", false)
+    .option("--debug-dump <file>", "Write all logs to a file");
+program.hook("preAction", (thisCommand) => {
+    const opts = thisCommand.optsWithGlobals();
+    if (opts.debugDump) {
+        setDebugDump(opts.debugDump);
+        setLogLevel("debug");
+        logger.debug("Logger", `Debug dump enabled: ${opts.debugDump}`);
+    }
+    if (opts.verbose || process.env.DEBUG === "calendit" || opts.debugDump) {
+        setLogLevel("debug");
+        logger.debug("Logger", "Verbose mode enabled.");
+    }
+});
+registerAuthCommands(program, deps);
+registerConfigCommands(program, deps);
+registerQueryCommand(program, deps);
+registerApplyCommand(program, deps);
+registerAddCommand(program, deps);
+registerCalCommands(program, deps);
+function handleError(error) {
+    const isVerbose = process.argv.includes("--verbose") || process.env.DEBUG === "calendit";
+    if (error instanceof ValidationError) {
+        logger.error(`入力エラー: ${error.message}`);
+        if (error.hint)
+            logger.info(`ヒント: ${error.hint}`);
+        if (isVerbose && error.stack)
+            logger.debug("STACK", error.stack);
+        process.exit(1);
+    }
+    if (error instanceof ConfigError) {
+        logger.error(`設定エラー: ${error.message}`);
+        if (error.hint)
+            logger.info(`ヒント: ${error.hint}`);
+        if (isVerbose && error.stack)
+            logger.debug("STACK", error.stack);
+        process.exit(1);
+    }
+    if (error instanceof AuthError) {
+        logger.error(`認証エラー: ${error.message}`);
+        if (error.hint)
+            logger.info(`ヒント: ${error.hint}`);
+        if (isVerbose && error.stack)
+            logger.debug("STACK", error.stack);
+        process.exit(1);
+    }
+    if (error instanceof ApiError) {
+        const statusPart = error.statusCode ? ` (${error.statusCode})` : "";
+        logger.error(`API エラー${statusPart}: ${error.message}`);
+        if (error.hint)
+            logger.info(`ヒント: ${error.hint}`);
+        logger.debug("ApiError", "API error details", error.details);
+        if (isVerbose && error.stack)
+            logger.debug("STACK", error.stack);
+        process.exit(1);
+    }
+    if (error instanceof CalendarError) {
+        logger.error(error.message);
+        if (error.hint)
+            logger.info(`ヒント: ${error.hint}`);
+        if (isVerbose && error.stack)
+            logger.debug("STACK", error.stack);
+        process.exit(1);
+    }
+    const unknown = error;
+    logger.error(`予期しないエラー: ${unknown?.message || String(error)}`);
+    if (isVerbose && error instanceof Error && error.stack) {
+        logger.debug("STACK", error.stack);
+    }
+    else {
+        logger.debug("UnknownError", error);
+    }
+    process.exit(1);
+}
+program.parseAsync(process.argv).catch(handleError);

package/dist/services/base.d.ts

@@ -0,0 +1,52 @@
+import { CalendarEvent, CalendarInfo, ProviderCapabilities } from "../types/index.js";
+export interface ICalendarService {
+    getProviderId(): string;
+    getCapabilities(): ProviderCapabilities;
+    /**
+     * カレンダーの一覧を取得
+     */
+    listCalendars(): Promise<CalendarInfo[]>;
+    /**
+     * カレンダーを作成
+     */
+    createCalendar(name: string): Promise<CalendarInfo>;
+    /**
+     * カレンダーを削除
+     */
+    deleteCalendar(calendarId: string): Promise<void>;
+    /**
+     * 指定期間の予定を取得
+     */
+    listEvents(calendarId: string, start: Date, end: Date): Promise<CalendarEvent[]>;
+    /**
+     * 予定を追加
+     */
+    createEvent(calendarId: string, event: Omit<CalendarEvent, "id" | "service" | "calendarId">): Promise<CalendarEvent>;
+    /**
+     * 予定を更新
+     */
+    updateEvent(calendarId: string, eventId: string, event: Partial<CalendarEvent>): Promise<CalendarEvent>;
+    /**
+     * 予定を削除
+     */
+    deleteEvent(calendarId: string, eventId: string): Promise<void>;
+}
+export declare abstract class AbstractCalendarService implements ICalendarService {
+    abstract getProviderId(): string;
+    abstract getCapabilities(): ProviderCapabilities;
+    abstract listCalendars(): Promise<CalendarInfo[]>;
+    abstract createCalendar(name: string): Promise<CalendarInfo>;
+    abstract deleteCalendar(calendarId: string): Promise<void>;
+    abstract listEvents(calendarId: string, start: Date, end: Date): Promise<CalendarEvent[]>;
+    abstract createEvent(calendarId: string, event: Omit<CalendarEvent, "id" | "service" | "calendarId">): Promise<CalendarEvent>;
+    abstract updateEvent(calendarId: string, eventId: string, event: Partial<CalendarEvent>): Promise<CalendarEvent>;
+    abstract deleteEvent(calendarId: string, eventId: string): Promise<void>;
+    /**
+     * 予定データの正規化 (共通処理)
+     */
+    protected normalizeEvent(event: Partial<CalendarEvent>): Partial<CalendarEvent>;
+    /**
+     * エラーの正規化 (各サービスでオーバーライド可能)
+     */
+    protected normalizeError(error: any): Error;
+}

package/dist/services/base.js

@@ -0,0 +1,24 @@
+export class AbstractCalendarService {
+    /**
+     * 予定データの正規化 (共通処理)
+     */
+    normalizeEvent(event) {
+        const normalized = { ...event };
+        if (normalized.summary)
+            normalized.summary = normalized.summary.trim();
+        if (normalized.location)
+            normalized.location = normalized.location.trim();
+        return normalized;
+    }
+    /**
+     * エラーの正規化 (各サービスでオーバーライド可能)
+     */
+    normalizeError(error) {
+        const providerId = this.getProviderId();
+        if (error instanceof Error) {
+            error.message = `[${providerId}] ${error.message}`;
+            return error;
+        }
+        return new Error(`[${providerId}] Unknown error: ${JSON.stringify(error)}`);
+    }
+}

package/dist/services/google.d.ts

@@ -0,0 +1,16 @@
+import { AbstractCalendarService } from "./base.js";
+import { CalendarEvent, CalendarInfo, ProviderCapabilities } from "../types/index.js";
+export declare class GoogleCalendarService extends AbstractCalendarService {
+    private calendar;
+    constructor(auth: any);
+    private wrapApiError;
+    getProviderId(): string;
+    getCapabilities(): ProviderCapabilities;
+    listCalendars(): Promise<CalendarInfo[]>;
+    createCalendar(name: string): Promise<CalendarInfo>;
+    deleteCalendar(calendarId: string): Promise<void>;
+    listEvents(calendarId: string, start: Date, end: Date): Promise<CalendarEvent[]>;
+    createEvent(calendarId: string, event: Omit<CalendarEvent, "id" | "service" | "calendarId">): Promise<CalendarEvent>;
+    updateEvent(calendarId: string, eventId: string, event: Partial<CalendarEvent>): Promise<CalendarEvent>;
+    deleteEvent(calendarId: string, eventId: string): Promise<void>;
+}

package/dist/services/google.js

@@ -0,0 +1,151 @@
+import { google } from "googleapis";
+import { AbstractCalendarService } from "./base.js";
+import { ApiError } from "../core/errors.js";
+import { logger } from "../core/logger.js";
+export class GoogleCalendarService extends AbstractCalendarService {
+    calendar;
+    constructor(auth) {
+        super();
+        this.calendar = google.calendar({ version: "v3", auth });
+    }
+    wrapApiError(error, operation) {
+        const message = error instanceof Error ? error.message : "Unknown Google API error";
+        throw new ApiError(`Google API Error during ${operation}: ${message}`, {
+            provider: "google",
+            details: error,
+        });
+    }
+    getProviderId() {
+        return "google";
+    }
+    getCapabilities() {
+        return {
+            webConferencing: true, // Google Meet support
+            bulkOperations: true,
+        };
+    }
+    async listCalendars() {
+        try {
+            const res = await this.calendar.calendarList.list();
+            return (res.data.items || []).map((item) => ({
+                id: item.id,
+                name: item.summary,
+                service: "google",
+                isPrimary: item.primary || false,
+                canEdit: item.accessRole === "owner" || item.accessRole === "writer",
+            }));
+        }
+        catch (error) {
+            this.wrapApiError(error, "listCalendars");
+        }
+    }
+    async createCalendar(name) {
+        try {
+            const res = await this.calendar.calendars.insert({
+                requestBody: { summary: name },
+            });
+            return {
+                id: res.data.id,
+                name: res.data.summary,
+                service: "google",
+                isPrimary: false,
+                canEdit: true,
+            };
+        }
+        catch (error) {
+            this.wrapApiError(error, "createCalendar");
+        }
+    }
+    async deleteCalendar(calendarId) {
+        try {
+            await this.calendar.calendars.delete({ calendarId });
+        }
+        catch (error) {
+            this.wrapApiError(error, "deleteCalendar");
+        }
+    }
+    async listEvents(calendarId, start, end) {
+        try {
+            logger.debug("Google listEvents", { calendarId, start: start.toISOString(), end: end.toISOString() });
+            const res = await this.calendar.events.list({
+                calendarId,
+                timeMin: start.toISOString(),
+                timeMax: end.toISOString(),
+                singleEvents: true,
+                orderBy: "startTime",
+            });
+            return (res.data.items || []).map((item) => ({
+                id: item.id,
+                summary: item.summary || "(No Title)",
+                start: item.start?.dateTime || item.start?.date,
+                end: item.end?.dateTime || item.end?.date,
+                location: item.location || undefined,
+                description: item.description || undefined,
+                service: "google",
+                calendarId,
+            }));
+        }
+        catch (error) {
+            this.wrapApiError(error, "listEvents");
+        }
+    }
+    async createEvent(calendarId, event) {
+        try {
+            const res = await this.calendar.events.insert({
+                calendarId,
+                requestBody: {
+                    summary: event.summary,
+                    start: { dateTime: event.start },
+                    end: { dateTime: event.end },
+                    location: event.location,
+                    description: event.description,
+                },
+            });
+            return {
+                id: res.data.id,
+                summary: res.data.summary,
+                start: res.data.start?.dateTime,
+                end: res.data.end?.dateTime,
+                service: "google",
+                calendarId,
+            };
+        }
+        catch (error) {
+            this.wrapApiError(error, "createEvent");
+        }
+    }
+    async updateEvent(calendarId, eventId, event) {
+        try {
+            const res = await this.calendar.events.patch({
+                calendarId,
+                eventId,
+                requestBody: {
+                    summary: event.summary,
+                    start: event.start ? { dateTime: event.start } : undefined,
+                    end: event.end ? { dateTime: event.end } : undefined,
+                    location: event.location,
+                    description: event.description,
+                },
+            });
+            return {
+                id: res.data.id,
+                summary: res.data.summary,
+                start: res.data.start?.dateTime,
+                end: res.data.end?.dateTime,
+                service: "google",
+                calendarId,
+            };
+        }
+        catch (error) {
+            this.wrapApiError(error, "updateEvent");
+        }
+    }
+    async deleteEvent(calendarId, eventId) {
+        try {
+            await this.calendar.events.delete({ calendarId, eventId });
+        }
+        catch (error) {
+            this.wrapApiError(error, "deleteEvent");
+        }
+    }
+}

package/dist/services/mock.d.ts

@@ -0,0 +1,18 @@
+import { AbstractCalendarService } from "./base.js";
+import { CalendarEvent, CalendarInfo, ProviderCapabilities } from "../types/index.js";
+export declare class MockCalendarService extends AbstractCalendarService {
+    private events;
+    private providerId;
+    constructor(providerId?: string);
+    private load;
+    private save;
+    getProviderId(): string;
+    getCapabilities(): ProviderCapabilities;
+    listCalendars(): Promise<CalendarInfo[]>;
+    createCalendar(name: string): Promise<CalendarInfo>;
+    deleteCalendar(calendarId: string): Promise<void>;
+    listEvents(calendarId: string, start: Date, end: Date): Promise<CalendarEvent[]>;
+    createEvent(calendarId: string, event: Omit<CalendarEvent, "id" | "service" | "calendarId">): Promise<CalendarEvent>;
+    updateEvent(calendarId: string, eventId: string, event: Partial<CalendarEvent>): Promise<CalendarEvent>;
+    deleteEvent(calendarId: string, eventId: string): Promise<void>;
+}