@kononenko-e/email-mcp 0.2.3

package/dist/services/event-bus.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Typed event bus for internal email events.
+ *
+ * Decouples the IMAP IDLE watcher from MCP notification hooks.
+ * Uses Node's built-in EventEmitter with typed event maps.
+ */
+import { EventEmitter } from 'node:events';
+import type { EmailMeta } from '../types/index.js';
+export interface NewEmailEvent {
+    account: string;
+    mailbox: string;
+    emails: EmailMeta[];
+}
+export interface ExpungeEvent {
+    account: string;
+    mailbox: string;
+    count: number;
+}
+interface EmailEventMap {
+    'email:new': [NewEmailEvent];
+    'email:expunge': [ExpungeEvent];
+}
+export declare class EmailEventBus extends EventEmitter<EmailEventMap> {
+}
+/** Singleton event bus shared across the application. */
+declare const eventBus: EmailEventBus;
+export default eventBus;
+//# sourceMappingURL=event-bus.d.ts.map

package/dist/services/event-bus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-bus.d.ts","sourceRoot":"","sources":["../../src/services/event-bus.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAMnD,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,SAAS,EAAE,CAAC;CACrB;AAED,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;CACf;AAMD,UAAU,aAAa;IACrB,WAAW,EAAE,CAAC,aAAa,CAAC,CAAC;IAC7B,eAAe,EAAE,CAAC,YAAY,CAAC,CAAC;CACjC;AAMD,qBAAa,aAAc,SAAQ,YAAY,CAAC,aAAa,CAAC;CAAG;AAEjE,yDAAyD;AACzD,QAAA,MAAM,QAAQ,eAAsB,CAAC;AACrC,eAAe,QAAQ,CAAC"}

package/dist/services/event-bus.js

@@ -0,0 +1,16 @@
+/**
+ * Typed event bus for internal email events.
+ *
+ * Decouples the IMAP IDLE watcher from MCP notification hooks.
+ * Uses Node's built-in EventEmitter with typed event maps.
+ */
+import { EventEmitter } from 'node:events';
+// ---------------------------------------------------------------------------
+// Typed EventBus
+// ---------------------------------------------------------------------------
+export class EmailEventBus extends EventEmitter {
+}
+/** Singleton event bus shared across the application. */
+const eventBus = new EmailEventBus();
+export default eventBus;
+//# sourceMappingURL=event-bus.js.map

package/dist/services/event-bus.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-bus.js","sourceRoot":"","sources":["../../src/services/event-bus.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AA4B3C,8EAA8E;AAC9E,iBAAiB;AACjB,8EAA8E;AAE9E,MAAM,OAAO,aAAc,SAAQ,YAA2B;CAAG;AAEjE,yDAAyD;AACzD,MAAM,QAAQ,GAAG,IAAI,aAAa,EAAE,CAAC;AACrC,eAAe,QAAQ,CAAC"}

package/dist/services/hooks.service.d.ts

@@ -0,0 +1,78 @@
+/**
+ * AI Hooks Service — intelligent email triage via MCP sampling.
+ *
+ * Listens for new email events on the event bus and:
+ * - Matches static rules FIRST (fast, free, deterministic)
+ * - Falls through to AI triage via `sampling/createMessage` if no rule matched
+ * - Uses preset system prompts + custom instructions for AI triage
+ * - Auto-applies labels and flags based on AI response
+ * - Falls back to logging if sampling is unavailable
+ */
+import type { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import type { EmailMeta, HookRule, HooksConfig } from '../types/index.js';
+import type ImapService from './imap.service.js';
+import NotifierService from './notifier.service.js';
+interface TriageResult {
+    priority?: 'urgent' | 'high' | 'normal' | 'low';
+    labels?: string[];
+    flag?: boolean;
+    action?: string;
+    addToCalendar?: boolean;
+}
+interface BatchEmail {
+    account: string;
+    mailbox: string;
+    meta: EmailMeta;
+}
+interface RuleMatchResult {
+    matched: true;
+    rule: HookRule;
+}
+interface RuleNoMatch {
+    matched: false;
+}
+type StaticMatchOutcome = RuleMatchResult | RuleNoMatch;
+export default class HooksService {
+    private config;
+    private imapService;
+    private lowLevelServer;
+    private samplingSupported;
+    private pendingEmails;
+    private batchTimer;
+    private rateCounter;
+    private rateResetTimer;
+    private started;
+    private readonly resolvedSystemPrompt;
+    private readonly notifier;
+    private readonly localCalendar;
+    private static readonly MAX_SAMPLING_PER_MIN;
+    constructor(config: HooksConfig, imapService: ImapService);
+    /** Returns the NotifierService instance for direct tool access. */
+    getNotifier(): NotifierService;
+    /** Returns the current hooks configuration. */
+    getHooksConfig(): HooksConfig;
+    /**
+     * Start listening for email events.
+     * Call after MCP server is connected so we can access the low-level server.
+     */
+    start(lowLevelServer: Server, clientCapabilities: {
+        sampling?: boolean;
+    }): void;
+    stop(): void;
+    private onNewEmail;
+    private flushBatch;
+    static matchStaticRules(email: BatchEmail, rules: HookRule[]): StaticMatchOutcome;
+    private static emailMatchesRule;
+    private applyStaticRule;
+    private sendResourceUpdates;
+    private notifyBatch;
+    private triageBatch;
+    private static formatEmailSummary;
+    private applyTriageResults;
+    private applySingleTriage;
+    private applyCalendarAction;
+    static parseTriageResponse(text: string, expectedCount: number): TriageResult[];
+    static sanitizeTriageResult(raw: unknown): TriageResult;
+}
+export {};
+//# sourceMappingURL=hooks.service.d.ts.map

package/dist/services/hooks.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hooks.service.d.ts","sourceRoot":"","sources":["../../src/services/hooks.service.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,2CAA2C,CAAC;AAExE,OAAO,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAG1E,OAAO,KAAK,WAAW,MAAM,mBAAmB,CAAC;AAGjD,OAAO,eAAe,MAAM,uBAAuB,CAAC;AAQpD,UAAU,YAAY;IACpB,QAAQ,CAAC,EAAE,QAAQ,GAAG,MAAM,GAAG,QAAQ,GAAG,KAAK,CAAC;IAChD,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAED,UAAU,UAAU;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,SAAS,CAAC;CACjB;AAED,UAAU,eAAe;IACvB,OAAO,EAAE,IAAI,CAAC;IACd,IAAI,EAAE,QAAQ,CAAC;CAChB;AAED,UAAU,WAAW;IACnB,OAAO,EAAE,KAAK,CAAC;CAChB;AAED,KAAK,kBAAkB,GAAG,eAAe,GAAG,WAAW,CAAC;AAgCxD,MAAM,CAAC,OAAO,OAAO,YAAY;IAC/B,OAAO,CAAC,MAAM,CAAc;IAE5B,OAAO,CAAC,WAAW,CAAc;IAEjC,OAAO,CAAC,cAAc,CAAuB;IAE7C,OAAO,CAAC,iBAAiB,CAAS;IAElC,OAAO,CAAC,aAAa,CAAoB;IAEzC,OAAO,CAAC,UAAU,CAA8C;IAEhE,OAAO,CAAC,WAAW,CAAK;IAExB,OAAO,CAAC,cAAc,CAA+C;IAErE,OAAO,CAAC,OAAO,CAAS;IAExB,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAAS;IAE9C,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAkB;IAE3C,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAuB;IAErD,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,oBAAoB,CAAM;gBAEtC,MAAM,EAAE,WAAW,EAAE,WAAW,EAAE,WAAW;IAWzD,mEAAmE;IACnE,WAAW,IAAI,eAAe;IAI9B,+CAA+C;IAC/C,cAAc,IAAI,WAAW;IAI7B;;;OAGG;IACH,KAAK,CAAC,cAAc,EAAE,MAAM,EAAE,kBAAkB,EAAE;QAAE,QAAQ,CAAC,EAAE,OAAO,CAAA;KAAE,GAAG,IAAI;IAmC/E,IAAI,IAAI,IAAI;IAmBZ,OAAO,CAAC,UAAU;YAaJ,UAAU;IAyCxB,MAAM,CAAC,gBAAgB,CAAC,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,QAAQ,EAAE,GAAG,kBAAkB;IAKjF,OAAO,CAAC,MAAM,CAAC,gBAAgB;YA0BjB,eAAe;YAuEf,mBAAmB;YAiBnB,WAAW;YAiBX,WAAW;IA4CzB,OAAO,CAAC,MAAM,CAAC,kBAAkB;YAkBnB,kBAAkB;YAKlB,iBAAiB;YA+DjB,mBAAmB;IAuGjC,MAAM,CAAC,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,YAAY,EAAE;IAiB/E,MAAM,CAAC,oBAAoB,CAAC,GAAG,EAAE,OAAO,GAAG,YAAY;CAexD"}

package/dist/services/hooks.service.js

@@ -0,0 +1,497 @@
+/**
+ * AI Hooks Service — intelligent email triage via MCP sampling.
+ *
+ * Listens for new email events on the event bus and:
+ * - Matches static rules FIRST (fast, free, deterministic)
+ * - Falls through to AI triage via `sampling/createMessage` if no rule matched
+ * - Uses preset system prompts + custom instructions for AI triage
+ * - Auto-applies labels and flags based on AI response
+ * - Falls back to logging if sampling is unavailable
+ */
+import { mcpLog } from '../logging.js';
+import eventBus from './event-bus.js';
+import LocalCalendarService from './local-calendar.service.js';
+import NotifierService from './notifier.service.js';
+import { buildSystemPrompt } from './presets.js';
+// ---------------------------------------------------------------------------
+// Pattern matching helpers
+// ---------------------------------------------------------------------------
+/** Convert a glob-like pattern (with `*` wildcards and `|` OR) to a RegExp. */
+function globToRegex(pattern) {
+    const parts = pattern
+        .split('|')
+        .map((p) => p.trim())
+        .filter(Boolean);
+    const regexParts = parts.map((part) => {
+        const escaped = part.replace(/[.+?^${}()[\]\\]/g, '\\$&');
+        return escaped.replace(/\*/g, '.*');
+    });
+    return new RegExp(`^(?:${regexParts.join('|')})$`, 'i');
+}
+/** Test whether a value matches a glob pattern (case-insensitive). */
+function matchesPattern(pattern, value) {
+    try {
+        return globToRegex(pattern).test(value);
+    }
+    catch {
+        return false;
+    }
+}
+// ---------------------------------------------------------------------------
+// HooksService
+// ---------------------------------------------------------------------------
+export default class HooksService {
+    config;
+    imapService;
+    lowLevelServer = null;
+    samplingSupported = false;
+    pendingEmails = [];
+    batchTimer = null;
+    rateCounter = 0;
+    rateResetTimer = null;
+    started = false;
+    resolvedSystemPrompt;
+    notifier;
+    localCalendar;
+    static MAX_SAMPLING_PER_MIN = 10;
+    constructor(config, imapService) {
+        this.config = config;
+        this.imapService = imapService;
+        this.notifier = new NotifierService(config.alerts);
+        this.localCalendar = new LocalCalendarService();
+        this.resolvedSystemPrompt = buildSystemPrompt(config.preset, {
+            customInstructions: config.customInstructions,
+            systemPrompt: config.systemPrompt,
+        });
+    }
+    /** Returns the NotifierService instance for direct tool access. */
+    getNotifier() {
+        return this.notifier;
+    }
+    /** Returns the current hooks configuration. */
+    getHooksConfig() {
+        return this.config;
+    }
+    /**
+     * Start listening for email events.
+     * Call after MCP server is connected so we can access the low-level server.
+     */
+    start(lowLevelServer, clientCapabilities) {
+        this.lowLevelServer = lowLevelServer;
+        this.samplingSupported = clientCapabilities.sampling === true;
+        if (this.started) {
+            // Client reconnected — server reference updated above, no need to re-register listeners.
+            mcpLog('info', 'hooks', `Hooks reconnected: sampling=${this.samplingSupported ? 'yes' : 'no'}`).catch(() => { });
+            return;
+        }
+        this.started = true;
+        if (this.config.onNewEmail === 'none')
+            return;
+        eventBus.on('email:new', (event) => {
+            this.onNewEmail(event);
+        });
+        // Rate limit reset every 60s
+        this.rateResetTimer = setInterval(() => {
+            this.rateCounter = 0;
+        }, 60_000);
+        const ruleCount = this.config.rules.length;
+        mcpLog('info', 'hooks', `Hooks active: mode=${this.config.onNewEmail}, preset=${this.config.preset}, ` +
+            `rules=${ruleCount}, sampling=${this.samplingSupported ? 'yes' : 'no'}`).catch(() => { });
+    }
+    stop() {
+        this.started = false;
+        if (this.batchTimer) {
+            clearTimeout(this.batchTimer);
+            this.batchTimer = null;
+        }
+        this.pendingEmails = [];
+        if (this.rateResetTimer) {
+            clearInterval(this.rateResetTimer);
+            this.rateResetTimer = null;
+        }
+        this.notifier.stop();
+        eventBus.removeAllListeners('email:new');
+    }
+    // -------------------------------------------------------------------------
+    // Event handling + batching
+    // -------------------------------------------------------------------------
+    onNewEmail(event) {
+        const items = event.emails.map((meta) => ({
+            account: event.account,
+            mailbox: event.mailbox,
+            meta,
+        }));
+        this.pendingEmails.push(...items);
+        this.batchTimer ??= setTimeout(() => {
+            this.flushBatch().catch(() => { });
+        }, this.config.batchDelay * 1000);
+    }
+    async flushBatch() {
+        this.batchTimer = null;
+        const batch = [...this.pendingEmails];
+        this.pendingEmails = [];
+        if (batch.length === 0)
+            return;
+        await this.sendResourceUpdates(batch);
+        // Partition: static-rule-matched vs needs-AI-triage
+        const ruleMatched = [];
+        const needsTriage = [];
+        batch.forEach((email) => {
+            const outcome = HooksService.matchStaticRules(email, this.config.rules);
+            if (outcome.matched) {
+                ruleMatched.push({ email, rule: outcome.rule });
+            }
+            else {
+                needsTriage.push(email);
+            }
+        });
+        // Apply static rule actions
+        if (ruleMatched.length > 0) {
+            const ruleOps = ruleMatched.map(async ({ email, rule }) => this.applyStaticRule(email, rule));
+            await Promise.allSettled(ruleOps);
+        }
+        // AI triage for remaining emails
+        if (needsTriage.length > 0) {
+            if (this.config.onNewEmail === 'triage' && this.samplingSupported) {
+                await this.triageBatch(needsTriage);
+            }
+            else {
+                await this.notifyBatch(needsTriage);
+            }
+        }
+    }
+    // -------------------------------------------------------------------------
+    // Static rule matching
+    // -------------------------------------------------------------------------
+    static matchStaticRules(email, rules) {
+        const matched = rules.find((rule) => HooksService.emailMatchesRule(email, rule));
+        return matched ? { matched: true, rule: matched } : { matched: false };
+    }
+    static emailMatchesRule(email, rule) {
+        const { match } = rule;
+        const fromAddr = email.meta.from.address;
+        const fromFull = email.meta.from.name ? `${email.meta.from.name} <${fromAddr}>` : fromAddr;
+        const toAddrs = email.meta.to.map((t) => t.address).join(', ');
+        const { subject } = email.meta;
+        // All specified match conditions must pass (AND logic)
+        if (match.from &&
+            !matchesPattern(match.from, fromAddr) &&
+            !matchesPattern(match.from, fromFull)) {
+            return false;
+        }
+        if (match.to && !matchesPattern(match.to, toAddrs)) {
+            return false;
+        }
+        if (match.subject && !matchesPattern(match.subject, subject)) {
+            return false;
+        }
+        // At least one match condition must be specified
+        return Boolean(match.from ?? match.to ?? match.subject);
+    }
+    async applyStaticRule(email, rule) {
+        const { actions } = rule;
+        // Apply labels
+        if (actions.labels?.length) {
+            const labelOps = actions.labels.map(async (label) => {
+                try {
+                    await this.imapService.addLabel(email.account, email.meta.id, email.mailbox, label);
+                }
+                catch {
+                    await mcpLog('warning', 'hooks', `Could not add label "${label}" to email ${email.meta.id}`);
+                }
+            });
+            await Promise.allSettled(labelOps);
+        }
+        // Apply flag
+        if (actions.flag) {
+            try {
+                await this.imapService.setFlags(email.account, email.mailbox, email.meta.id, 'flag');
+            }
+            catch {
+                await mcpLog('warning', 'hooks', `Could not flag email ${email.meta.id}`);
+            }
+        }
+        // Mark read
+        if (actions.markRead) {
+            try {
+                await this.imapService.setFlags(email.account, email.mailbox, email.meta.id, 'read');
+            }
+            catch {
+                await mcpLog('warning', 'hooks', `Could not mark email ${email.meta.id} as read`);
+            }
+        }
+        // Send alert via notifier (rule with alert=true forces desktop notification)
+        const payload = {
+            account: email.account,
+            sender: email.meta.from,
+            subject: email.meta.subject,
+            priority: actions.flag ? 'high' : 'normal',
+            labels: actions.labels,
+            ruleName: rule.name,
+        };
+        await this.notifier.alert(payload, actions.alert === true);
+        // Add to calendar if rule requests it or global auto_calendar is on
+        if (actions.addToCalendar ?? this.config.autoCalendar) {
+            const { isCalendarProcessed, markCalendarProcessed } = await import('../utils/calendar-state.js');
+            const already = await isCalendarProcessed(email.account, email.meta.id);
+            if (!already) {
+                await this.applyCalendarAction(email);
+                await markCalendarProcessed(email.account, email.meta.id, 'event', email.meta.subject);
+            }
+            else {
+                await mcpLog('info', 'hooks', `Calendar: skipping auto-add for ${email.meta.id} (already processed once)`);
+            }
+        }
+    }
+    // -------------------------------------------------------------------------
+    // Resource subscription notifications
+    // -------------------------------------------------------------------------
+    async sendResourceUpdates(emails) {
+        if (!this.lowLevelServer)
+            return;
+        const accounts = [...new Set(emails.map((e) => e.account))];
+        const srv = this.lowLevelServer;
+        const ops = accounts.flatMap((account) => [
+            srv.sendResourceUpdated({ uri: `email://${account}/unread` }).catch(() => { }),
+            srv.sendResourceUpdated({ uri: `email://${account}/mailboxes` }).catch(() => { }),
+        ]);
+        await Promise.allSettled(ops);
+    }
+    // -------------------------------------------------------------------------
+    // Notify mode (alerts-aware fallback)
+    // -------------------------------------------------------------------------
+    async notifyBatch(emails) {
+        const ops = emails.map(async (e) => {
+            const payload = {
+                account: e.account,
+                sender: e.meta.from,
+                subject: e.meta.subject,
+                priority: 'normal',
+            };
+            return this.notifier.alert(payload);
+        });
+        await Promise.allSettled(ops);
+    }
+    // -------------------------------------------------------------------------
+    // Triage mode (AI sampling with preset prompts)
+    // -------------------------------------------------------------------------
+    async triageBatch(emails) {
+        if (this.rateCounter >= HooksService.MAX_SAMPLING_PER_MIN) {
+            await mcpLog('warning', 'hooks', 'Sampling rate limit reached — falling back to notify');
+            await this.notifyBatch(emails);
+            return;
+        }
+        // Skip AI for notification-only preset
+        if (this.config.preset === 'notification-only' || !this.resolvedSystemPrompt) {
+            await this.notifyBatch(emails);
+            return;
+        }
+        this.rateCounter += 1;
+        const emailSummaries = emails.map((e, i) => HooksService.formatEmailSummary(e, i)).join('\n\n');
+        const userPrompt = `Analyze these ${emails.length} new email(s):\n\n${emailSummaries}`;
+        try {
+            const srv = this.lowLevelServer;
+            if (!srv)
+                throw new Error('Server not available');
+            const result = await srv.createMessage({
+                messages: [{ role: 'user', content: { type: 'text', text: userPrompt } }],
+                systemPrompt: this.resolvedSystemPrompt,
+                maxTokens: 1000,
+                modelPreferences: {
+                    hints: [{ name: 'fast' }],
+                    speedPriority: 0.8,
+                    intelligencePriority: 0.5,
+                },
+            });
+            const text = result.model && result.content?.type === 'text' ? result.content.text : '';
+            const triageResults = HooksService.parseTriageResponse(text, emails.length);
+            await this.applyTriageResults(emails, triageResults);
+        }
+        catch (err) {
+            const errMsg = err instanceof Error ? err.message : String(err);
+            await mcpLog('warning', 'hooks', `Sampling failed: ${errMsg} — falling back to notify`);
+            await this.notifyBatch(emails);
+        }
+    }
+    static formatEmailSummary(e, index) {
+        const flagIcons = [
+            e.meta.flagged ? '⭐' : '',
+            e.meta.seen ? '👁️' : '🆕',
+            e.meta.hasAttachments ? '📎' : '',
+        ].join('');
+        return (`[${index + 1}] From: ${e.meta.from.name ?? e.meta.from.address}\n` +
+            `    Subject: ${e.meta.subject}\n` +
+            `    Date: ${e.meta.date}\n` +
+            `    Flags: ${flagIcons}`);
+    }
+    // -------------------------------------------------------------------------
+    // Triage application
+    // -------------------------------------------------------------------------
+    async applyTriageResults(emails, results) {
+        const ops = emails.map(async (email, i) => this.applySingleTriage(email, results[i] ?? {}));
+        await Promise.allSettled(ops);
+    }
+    async applySingleTriage(email, triage) {
+        // Auto-label
+        if (this.config.autoLabel && triage.labels?.length) {
+            const labelOps = triage.labels.map(async (label) => {
+                try {
+                    await this.imapService.addLabel(email.account, email.meta.id, email.mailbox, label);
+                }
+                catch {
+                    await mcpLog('warning', 'hooks', `Could not add label "${label}" to email ${email.meta.id}`);
+                }
+            });
+            await Promise.allSettled(labelOps);
+        }
+        // Auto-flag
+        if (this.config.autoFlag && triage.flag) {
+            try {
+                await this.imapService.setFlags(email.account, email.mailbox, email.meta.id, 'flag');
+            }
+            catch {
+                await mcpLog('warning', 'hooks', `Could not flag email ${email.meta.id}`);
+            }
+        }
+        // Route through notifier for urgency-based alerts
+        const priority = triage.priority ?? 'normal';
+        const payload = {
+            account: email.account,
+            sender: email.meta.from,
+            subject: email.meta.subject,
+            priority,
+            labels: triage.labels,
+        };
+        await this.notifier.alert(payload);
+        if (triage.action) {
+            await mcpLog('info', 'hooks', `   Action: ${triage.action}`);
+        }
+        // Add to calendar if AI triage requested it or global auto_calendar is on
+        if (triage.addToCalendar ?? this.config.autoCalendar) {
+            const { isCalendarProcessed, markCalendarProcessed } = await import('../utils/calendar-state.js');
+            const already = await isCalendarProcessed(email.account, email.meta.id);
+            if (!already) {
+                await this.applyCalendarAction(email);
+                await markCalendarProcessed(email.account, email.meta.id, 'event', email.meta.subject);
+            }
+            else {
+                await mcpLog('info', 'hooks', `Calendar: skipping auto-add for ${email.meta.id} (already processed once — instruct AI to add again)`);
+            }
+        }
+    }
+    // -------------------------------------------------------------------------
+    // Calendar auto-add helper
+    // -------------------------------------------------------------------------
+    async applyCalendarAction(email) {
+        const { buildCalendarNotes } = await import('../utils/calendar-notes.js');
+        const { extractConferenceDetails } = await import('../utils/conference-details.js');
+        const { extractMeetingUrl } = await import('../utils/meeting-url.js');
+        const { CALENDAR_ATTACHMENTS_DIR } = await import('../config/xdg.js');
+        const path = await import('node:path');
+        try {
+            const full = await this.imapService.getEmail(email.account, email.meta.id, email.mailbox);
+            const bodyText = full.bodyText ?? '';
+            const bodyHtml = full.bodyHtml ?? '';
+            const combined = `${bodyText}\n${bodyHtml}`;
+            // Try ICS extraction
+            let start = new Date(full.date);
+            let end = new Date(start.getTime() + 60 * 60 * 1000);
+            let location;
+            let icsUid;
+            try {
+                const { default: CalSvc } = await import('./calendar.service.js');
+                const calSvc = new CalSvc();
+                const icsContents = await this.imapService.getCalendarParts(email.account, email.mailbox, email.meta.id);
+                if (icsContents.length > 0) {
+                    const events = calSvc.extractFromParts(icsContents);
+                    if (events.length > 0) {
+                        start = new Date(events[0].start);
+                        end = new Date(events[0].end);
+                        location = events[0].location;
+                        icsUid = events[0].uid;
+                    }
+                }
+            }
+            catch {
+                // ICS extraction is best-effort
+            }
+            const meetingUrl = extractMeetingUrl(combined);
+            const conference = extractConferenceDetails(bodyText !== '' ? bodyText : bodyHtml);
+            // Save attachments
+            let savedAttachments = [];
+            if (full.attachments.length > 0) {
+                const destDir = path.join(CALENDAR_ATTACHMENTS_DIR, `${email.account}-${email.meta.id}`.replace(/[^a-zA-Z0-9-_]/g, '_'));
+                savedAttachments = await this.imapService.saveEmailAttachments(email.account, email.meta.id, email.mailbox, destDir);
+            }
+            const notes = buildCalendarNotes({
+                emailFrom: full.from.name ? `${full.from.name} <${full.from.address}>` : full.from.address,
+                emailSubject: full.subject,
+                emailDate: new Date(full.date).toLocaleString(),
+                meetingUrl: meetingUrl?.url,
+                meetingUrlLabel: meetingUrl?.label,
+                dialIn: conference?.dialIn,
+                meetingId: conference?.meetingId,
+                passcode: conference?.passcode,
+                conferenceProvider: conference?.provider,
+                bodyExcerpt: bodyText !== '' ? bodyText : bodyHtml,
+                savedAttachments,
+            });
+            const result = await this.localCalendar.addEvent({
+                title: full.subject,
+                start,
+                end,
+                location,
+                notes,
+                url: meetingUrl?.url,
+                urlLabel: meetingUrl?.label,
+                alarmMinutes: this.config.calendarAlarmMinutes ?? 15,
+                savedAttachments,
+                dialIn: conference?.dialIn,
+                meetingId: conference?.meetingId,
+                passcode: conference?.passcode,
+                icsUid,
+            }, this.config.calendarName !== '' ? this.config.calendarName : undefined, { confirm: this.config.calendarConfirm !== false });
+            await mcpLog('info', 'hooks', `Calendar: ${result.message}`);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            await mcpLog('warning', 'hooks', `Calendar auto-add failed: ${msg}`);
+        }
+    }
+    // -------------------------------------------------------------------------
+    // Response parsing
+    // -------------------------------------------------------------------------
+    static parseTriageResponse(text, expectedCount) {
+        try {
+            const cleaned = text.replace(/```(?:json)?\n?/g, '').trim();
+            const parsed = JSON.parse(cleaned);
+            if (Array.isArray(parsed)) {
+                return parsed.slice(0, expectedCount).map(HooksService.sanitizeTriageResult);
+            }
+            if (typeof parsed === 'object' && parsed !== null) {
+                return [HooksService.sanitizeTriageResult(parsed)];
+            }
+        }
+        catch {
+            // Parse failure — return empty results
+        }
+        return Array.from({ length: expectedCount }, () => ({}));
+    }
+    static sanitizeTriageResult(raw) {
+        if (typeof raw !== 'object' || raw === null)
+            return {};
+        const obj = raw;
+        return {
+            priority: ['urgent', 'high', 'normal', 'low'].includes(obj.priority)
+                ? obj.priority
+                : undefined,
+            labels: Array.isArray(obj.labels)
+                ? obj.labels.filter((l) => typeof l === 'string').slice(0, 5)
+                : undefined,
+            flag: typeof obj.flag === 'boolean' ? obj.flag : undefined,
+            action: typeof obj.action === 'string' ? obj.action.slice(0, 200) : undefined,
+            addToCalendar: typeof obj.add_to_calendar === 'boolean' ? obj.add_to_calendar : undefined,
+        };
+    }
+}
+//# sourceMappingURL=hooks.service.js.map