calendar-mcp 1.0.0

package/dist/utils/ical.js

@@ -0,0 +1,249 @@
+import { readFile, writeFile } from 'fs/promises';
+import { v4 as uuidv4 } from 'uuid';
+import { getCalendarPath, ensureCalendarDir, pathExists } from './paths.js';
+import { formatICalDateTime, formatICalDate, parseICalDate, toISO } from './dates.js';
+const PRODID = '-//Calendar MCP//EN';
+const VERSION = '2.0';
+const CALNAME = 'My Calendar';
+const TIMEZONE = 'UTC';
+const UID_DOMAIN = 'calendar.local';
+/**
+ * Generate a unique event ID
+ */
+export function generateUID() {
+    return `${uuidv4()}@${UID_DOMAIN}`;
+}
+/**
+ * Extract the ID part from a UID (without domain)
+ */
+export function extractId(uid) {
+    const atIndex = uid.indexOf('@');
+    return atIndex > 0 ? uid.slice(0, atIndex) : uid;
+}
+/**
+ * Create a full UID from an ID
+ */
+export function createUID(id) {
+    if (id.includes('@')) {
+        return id;
+    }
+    return `${id}@${UID_DOMAIN}`;
+}
+/**
+ * Escape special characters for iCal text fields
+ */
+export function escapeICalText(text) {
+    return text
+        .replace(/\\/g, '\\\\')
+        .replace(/;/g, '\\;')
+        .replace(/,/g, '\\,')
+        .replace(/\n/g, '\\n');
+}
+/**
+ * Unescape special characters from iCal text fields
+ */
+export function unescapeICalText(text) {
+    return text
+        .replace(/\\n/g, '\n')
+        .replace(/\\,/g, ',')
+        .replace(/\\;/g, ';')
+        .replace(/\\\\/g, '\\');
+}
+/**
+ * Fold long lines according to iCal spec (max 75 chars per line)
+ */
+export function foldLine(line) {
+    if (line.length <= 75) {
+        return line;
+    }
+    const result = [];
+    let remaining = line;
+    // First line can be 75 chars
+    result.push(remaining.slice(0, 75));
+    remaining = remaining.slice(75);
+    // Continuation lines start with space and can be 74 chars of content
+    while (remaining.length > 0) {
+        result.push(' ' + remaining.slice(0, 74));
+        remaining = remaining.slice(74);
+    }
+    return result.join('\r\n');
+}
+/**
+ * Unfold lines that were folded according to iCal spec
+ */
+export function unfoldLines(content) {
+    // Replace CRLF + space/tab with nothing (unfold)
+    return content.replace(/\r?\n[ \t]/g, '');
+}
+/**
+ * Parse iCalendar content to events
+ */
+export function parseICalendar(content) {
+    const unfolded = unfoldLines(content);
+    const lines = unfolded.split(/\r?\n/);
+    const events = [];
+    let currentEvent = null;
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        if (trimmed === 'BEGIN:VEVENT') {
+            currentEvent = { allDay: false };
+            continue;
+        }
+        if (trimmed === 'END:VEVENT') {
+            if (currentEvent && currentEvent.uid && currentEvent.dtstart && currentEvent.summary) {
+                events.push(icalEventToCalendarEvent(currentEvent));
+            }
+            currentEvent = null;
+            continue;
+        }
+        if (!currentEvent)
+            continue;
+        // Parse property
+        const colonIndex = trimmed.indexOf(':');
+        if (colonIndex === -1)
+            continue;
+        const propertyPart = trimmed.slice(0, colonIndex);
+        const valuePart = trimmed.slice(colonIndex + 1);
+        // Handle properties with parameters (e.g., DTSTART;VALUE=DATE:20250125)
+        const semiIndex = propertyPart.indexOf(';');
+        const propertyName = semiIndex > 0 ? propertyPart.slice(0, semiIndex) : propertyPart;
+        const params = semiIndex > 0 ? propertyPart.slice(semiIndex + 1) : '';
+        switch (propertyName.toUpperCase()) {
+            case 'UID':
+                currentEvent.uid = valuePart;
+                break;
+            case 'SUMMARY':
+                currentEvent.summary = unescapeICalText(valuePart);
+                break;
+            case 'DESCRIPTION':
+                currentEvent.description = unescapeICalText(valuePart);
+                break;
+            case 'LOCATION':
+                currentEvent.location = unescapeICalText(valuePart);
+                break;
+            case 'DTSTART': {
+                const isAllDay = params.toUpperCase().includes('VALUE=DATE');
+                const parsed = parseICalDate(valuePart);
+                currentEvent.dtstart = parsed.date;
+                currentEvent.allDay = isAllDay || parsed.allDay;
+                break;
+            }
+            case 'DTEND': {
+                const parsed = parseICalDate(valuePart);
+                currentEvent.dtend = parsed.date;
+                break;
+            }
+            case 'DTSTAMP': {
+                const parsed = parseICalDate(valuePart);
+                currentEvent.dtstamp = parsed.date;
+                break;
+            }
+            case 'CREATED': {
+                const parsed = parseICalDate(valuePart);
+                currentEvent.created = parsed.date;
+                break;
+            }
+            case 'LAST-MODIFIED': {
+                const parsed = parseICalDate(valuePart);
+                currentEvent.lastModified = parsed.date;
+                break;
+            }
+            case 'STATUS':
+                currentEvent.status = valuePart.toUpperCase();
+                break;
+        }
+    }
+    return events;
+}
+/**
+ * Convert internal ICalEvent to CalendarEvent format
+ */
+function icalEventToCalendarEvent(event) {
+    return {
+        id: extractId(event.uid),
+        title: event.summary,
+        start: toISO(event.dtstart),
+        end: event.dtend ? toISO(event.dtend) : undefined,
+        location: event.location,
+        description: event.description,
+        allDay: event.allDay,
+        status: event.status ?? 'CONFIRMED',
+        created: event.created ? toISO(event.created) : undefined,
+        lastModified: event.lastModified ? toISO(event.lastModified) : undefined,
+    };
+}
+/**
+ * Generate iCalendar content from events
+ */
+export function generateICalendar(events) {
+    const lines = [
+        'BEGIN:VCALENDAR',
+        `VERSION:${VERSION}`,
+        `PRODID:${PRODID}`,
+        'CALSCALE:GREGORIAN',
+        'METHOD:PUBLISH',
+        `X-WR-CALNAME:${CALNAME}`,
+        `X-WR-TIMEZONE:${TIMEZONE}`,
+    ];
+    for (const event of events) {
+        lines.push('BEGIN:VEVENT');
+        lines.push(`UID:${createUID(event.id)}`);
+        lines.push(`DTSTAMP:${formatICalDateTime(new Date())}`);
+        const startDate = new Date(event.start);
+        if (event.allDay) {
+            lines.push(`DTSTART;VALUE=DATE:${formatICalDate(startDate)}`);
+            if (event.end) {
+                lines.push(`DTEND;VALUE=DATE:${formatICalDate(new Date(event.end))}`);
+            }
+        }
+        else {
+            lines.push(`DTSTART:${formatICalDateTime(startDate)}`);
+            if (event.end) {
+                lines.push(`DTEND:${formatICalDateTime(new Date(event.end))}`);
+            }
+        }
+        lines.push(`SUMMARY:${escapeICalText(event.title)}`);
+        if (event.description) {
+            lines.push(foldLine(`DESCRIPTION:${escapeICalText(event.description)}`));
+        }
+        if (event.location) {
+            lines.push(foldLine(`LOCATION:${escapeICalText(event.location)}`));
+        }
+        lines.push(`STATUS:${event.status}`);
+        if (event.created) {
+            lines.push(`CREATED:${formatICalDateTime(new Date(event.created))}`);
+        }
+        if (event.lastModified) {
+            lines.push(`LAST-MODIFIED:${formatICalDateTime(new Date(event.lastModified))}`);
+        }
+        lines.push('END:VEVENT');
+    }
+    lines.push('END:VCALENDAR');
+    // iCal uses CRLF line endings
+    return lines.join('\r\n') + '\r\n';
+}
+/**
+ * Read the calendar file and return parsed events
+ * Returns empty array if file doesn't exist
+ */
+export async function readCalendarFile() {
+    const calendarPath = getCalendarPath();
+    const exists = await pathExists(calendarPath);
+    if (!exists) {
+        return [];
+    }
+    const content = await readFile(calendarPath, 'utf-8');
+    return parseICalendar(content);
+}
+/**
+ * Write events to the calendar file
+ * Creates the Calendar directory if it doesn't exist
+ */
+export async function writeCalendarFile(events) {
+    await ensureCalendarDir();
+    const calendarPath = getCalendarPath();
+    const content = generateICalendar(events);
+    await writeFile(calendarPath, content, 'utf-8');
+}

package/dist/utils/paths.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Get the vault path from environment variable
+ * @throws Error if VAULT_PATH is not set
+ */
+export declare function getVaultPath(): string;
+/**
+ * Get the Calendar directory path within the vault
+ */
+export declare function getCalendarDir(): string;
+/**
+ * Get the full path to the events.ics file
+ */
+export declare function getCalendarPath(): string;
+/**
+ * Check if a path exists
+ */
+export declare function pathExists(path: string): Promise<boolean>;
+/**
+ * Ensure the Calendar directory exists, creating it if necessary
+ */
+export declare function ensureCalendarDir(): Promise<void>;

package/dist/utils/paths.js

@@ -0,0 +1,50 @@
+import { join } from 'path';
+import { mkdir, access } from 'fs/promises';
+import { constants } from 'fs';
+const CALENDAR_FOLDER = 'Calendar';
+const CALENDAR_FILE = 'events.ics';
+/**
+ * Get the vault path from environment variable
+ * @throws Error if VAULT_PATH is not set
+ */
+export function getVaultPath() {
+    const vaultPath = process.env.VAULT_PATH;
+    if (!vaultPath) {
+        throw new Error('VAULT_PATH environment variable is not set');
+    }
+    return vaultPath;
+}
+/**
+ * Get the Calendar directory path within the vault
+ */
+export function getCalendarDir() {
+    return join(getVaultPath(), CALENDAR_FOLDER);
+}
+/**
+ * Get the full path to the events.ics file
+ */
+export function getCalendarPath() {
+    return join(getCalendarDir(), CALENDAR_FILE);
+}
+/**
+ * Check if a path exists
+ */
+export async function pathExists(path) {
+    try {
+        await access(path, constants.F_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Ensure the Calendar directory exists, creating it if necessary
+ */
+export async function ensureCalendarDir() {
+    const calendarDir = getCalendarDir();
+    const exists = await pathExists(calendarDir);
+    if (!exists) {
+        await mkdir(calendarDir, { recursive: true });
+    }
+}

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "calendar-mcp",
+  "version": "1.0.0",
+  "description": "MCP server for calendar management via Claude Code - uses iCalendar format",
+  "main": "dist/index.js",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Masbuc53/PersonalCalendar.git",
+    "directory": "calendar-mcp"
+  },
+  "homepage": "https://github.com/Masbuc53/PersonalCalendar/tree/main/calendar-mcp#readme",
+  "bugs": {
+    "url": "https://github.com/Masbuc53/PersonalCalendar/issues"
+  },
+  "bin": {
+    "calendar-mcp": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "dev": "tsc --watch",
+    "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js",
+    "test:coverage": "node --experimental-vm-modules node_modules/jest/bin/jest.js --coverage",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "claude",
+    "claude-code",
+    "calendar",
+    "icalendar",
+    "obsidian"
+  ],
+  "author": "Mason Buchanan",
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "chrono-node": "^2.7.0",
+    "ical.js": "^2.0.0",
+    "simple-git": "^3.22.0",
+    "uuid": "^9.0.0"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.0",
+    "@types/node": "^20.10.0",
+    "@types/uuid": "^9.0.0",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.1.0",
+    "typescript": "^5.3.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}