@auxiora/ambient 1.0.0 → 1.3.1

package/src/pattern-engine.ts

@@ -1,212 +0,0 @@
-import * as crypto from 'node:crypto';
-import type { AmbientPattern, AmbientPatternType, ObservedEvent } from './types.js';
-
-/** Sliding window size for frequency analysis. */
-const DEFAULT_WINDOW_SIZE = 7 * 24 * 60 * 60 * 1000; // 7 days
-/** Minimum occurrences to consider something a pattern. */
-const MIN_OCCURRENCES = 3;
-/** Minimum confidence to emit a pattern. */
-const MIN_CONFIDENCE = 0.3;
-
-/**
- * Ambient pattern engine — observes events and detects behavioral patterns
- * using sliding window frequency analysis.
- */
-export class AmbientPatternEngine {
-  private events: ObservedEvent[] = [];
-  private patterns: Map<string, AmbientPattern> = new Map();
-  private windowSize: number;
-
-  constructor(windowSize?: number) {
-    this.windowSize = windowSize ?? DEFAULT_WINDOW_SIZE;
-  }
-
-  /** Observe a new event. */
-  observe(event: ObservedEvent): void {
-    this.events.push(event);
-    // Prune events outside the window
-    const cutoff = Date.now() - this.windowSize;
-    this.events = this.events.filter(e => e.timestamp >= cutoff);
-  }
-
-  /** Run pattern detection on observed events. */
-  detectPatterns(): AmbientPattern[] {
-    const detected: AmbientPattern[] = [];
-
-    // Group events by type
-    const byType = new Map<string, ObservedEvent[]>();
-    for (const event of this.events) {
-      const existing = byType.get(event.type) ?? [];
-      existing.push(event);
-      byType.set(event.type, existing);
-    }
-
-    // Detect schedule patterns (recurring events at similar times)
-    for (const [type, events] of byType) {
-      if (events.length >= MIN_OCCURRENCES) {
-        const schedulePattern = this.detectSchedulePattern(type, events);
-        if (schedulePattern) detected.push(schedulePattern);
-
-        const frequencyPattern = this.detectFrequencyPattern(type, events);
-        if (frequencyPattern) detected.push(frequencyPattern);
-      }
-    }
-
-    // Detect correlations between event types
-    const correlations = this.detectCorrelations(byType);
-    detected.push(...correlations);
-
-    // Update stored patterns
-    for (const pattern of detected) {
-      const existing = this.patterns.get(pattern.id);
-      if (existing) {
-        existing.lastConfirmedAt = Date.now();
-        existing.occurrences++;
-        existing.confidence = Math.min(1, existing.confidence + 0.05);
-      } else {
-        this.patterns.set(pattern.id, pattern);
-      }
-    }
-
-    return detected;
-  }
-
-  /** Get all detected patterns above minimum confidence. */
-  getPatterns(): AmbientPattern[] {
-    return Array.from(this.patterns.values())
-      .filter(p => p.confidence >= MIN_CONFIDENCE)
-      .sort((a, b) => b.confidence - a.confidence);
-  }
-
-  /** Get a pattern by ID. */
-  getPattern(id: string): AmbientPattern | undefined {
-    return this.patterns.get(id);
-  }
-
-  /** Get the number of observed events in the window. */
-  getEventCount(): number {
-    return this.events.length;
-  }
-
-  /** Clear all events and patterns. */
-  reset(): void {
-    this.events = [];
-    this.patterns.clear();
-  }
-
-  private detectSchedulePattern(type: string, events: ObservedEvent[]): AmbientPattern | null {
-    // Check if events happen at similar hours of the day
-    const hours = events.map(e => new Date(e.timestamp).getHours());
-    const hourCounts = new Map<number, number>();
-    for (const h of hours) {
-      hourCounts.set(h, (hourCounts.get(h) ?? 0) + 1);
-    }
-
-    // Find the most common hour
-    let maxHour = 0;
-    let maxCount = 0;
-    for (const [hour, count] of hourCounts) {
-      if (count > maxCount) {
-        maxHour = hour;
-        maxCount = count;
-      }
-    }
-
-    const ratio = maxCount / events.length;
-    if (ratio < 0.5 || maxCount < MIN_OCCURRENCES) return null;
-
-    const id = crypto.randomUUID();
-    return {
-      id,
-      type: 'schedule',
-      description: `"${type}" events frequently occur around ${maxHour}:00`,
-      confidence: Math.min(1, ratio * 0.8 + (maxCount / 10) * 0.2),
-      evidence: events.slice(-3).map(e => `${type} at ${new Date(e.timestamp).toISOString()}`),
-      detectedAt: Date.now(),
-      lastConfirmedAt: Date.now(),
-      occurrences: maxCount,
-    };
-  }
-
-  private detectFrequencyPattern(type: string, events: ObservedEvent[]): AmbientPattern | null {
-    if (events.length < MIN_OCCURRENCES) return null;
-
-    // Calculate average interval between events
-    const sorted = [...events].sort((a, b) => a.timestamp - b.timestamp);
-    const intervals: number[] = [];
-    for (let i = 1; i < sorted.length; i++) {
-      intervals.push(sorted[i].timestamp - sorted[i - 1].timestamp);
-    }
-
-    if (intervals.length === 0) return null;
-
-    const avgInterval = intervals.reduce((a, b) => a + b, 0) / intervals.length;
-    const stdDev = Math.sqrt(
-      intervals.reduce((sum, iv) => sum + (iv - avgInterval) ** 2, 0) / intervals.length
-    );
-
-    // Low variance means regular frequency
-    const cv = avgInterval > 0 ? stdDev / avgInterval : Infinity;
-    if (cv > 0.5) return null; // Too irregular
-
-    const confidence = Math.min(1, 1 - cv);
-    if (confidence < MIN_CONFIDENCE) return null;
-
-    const hours = Math.round(avgInterval / (60 * 60 * 1000) * 10) / 10;
-    const id = crypto.randomUUID();
-    return {
-      id,
-      type: 'preference',
-      description: `"${type}" occurs roughly every ${hours} hours`,
-      confidence,
-      evidence: [`${events.length} occurrences over window`, `Average interval: ${hours}h`],
-      detectedAt: Date.now(),
-      lastConfirmedAt: Date.now(),
-      occurrences: events.length,
-    };
-  }
-
-  private detectCorrelations(byType: Map<string, ObservedEvent[]>): AmbientPattern[] {
-    const patterns: AmbientPattern[] = [];
-    const types = Array.from(byType.keys());
-
-    // Check pairs of event types for temporal correlation
-    for (let i = 0; i < types.length; i++) {
-      for (let j = i + 1; j < types.length; j++) {
-        const eventsA = byType.get(types[i])!;
-        const eventsB = byType.get(types[j])!;
-
-        if (eventsA.length < 2 || eventsB.length < 2) continue;
-
-        // Count how often B follows A within 5 minutes
-        const followWindow = 5 * 60 * 1000;
-        let follows = 0;
-        for (const a of eventsA) {
-          for (const b of eventsB) {
-            if (b.timestamp > a.timestamp && b.timestamp - a.timestamp <= followWindow) {
-              follows++;
-              break;
-            }
-          }
-        }
-
-        const followRatio = follows / eventsA.length;
-        if (followRatio >= 0.5 && follows >= 2) {
-          const id = crypto.randomUUID();
-          patterns.push({
-            id,
-            type: 'correlation',
-            description: `"${types[j]}" often follows "${types[i]}" within 5 minutes`,
-            confidence: Math.min(1, followRatio * 0.9),
-            evidence: [`${follows} of ${eventsA.length} "${types[i]}" events followed by "${types[j]}"`],
-            detectedAt: Date.now(),
-            lastConfirmedAt: Date.now(),
-            occurrences: follows,
-          });
-        }
-      }
-    }
-
-    return patterns;
-  }
-}

package/src/scheduler.ts

@@ -1,238 +0,0 @@
-import type { Scheduler } from '@auxiora/behaviors';
-import type { ConnectorRegistry, TriggerManager } from '@auxiora/connectors';
-import type { BriefingGenerator } from './briefing.js';
-import type { NotificationOrchestrator } from './orchestrator.js';
-import type { QuietNotification } from './types.js';
-import { formatBriefingAsText } from './briefing.js';
-
-/** Configuration for the ambient scheduler. */
-export interface AmbientSchedulerConfig {
-  /** Cron expression for morning briefing. */
-  morningCron: string;
-  /** Cron expression for evening summary. */
-  eveningCron: string;
-  /** Cron expression for email polling. */
-  emailPollCron: string;
-  /** Cron expression for calendar polling. */
-  calendarPollCron: string;
-  /** Cron expression for notification polling. */
-  notificationPollCron: string;
-  /** Calendar alert window in minutes. */
-  calendarAlertMinutes: number;
-  /** Whether the scheduler is enabled. */
-  enabled: boolean;
-  /** Categories to include in briefings. */
-  categories: string[];
-}
-
-export const DEFAULT_AMBIENT_SCHEDULER_CONFIG: AmbientSchedulerConfig = {
-  morningCron: '0 7 * * *',
-  eveningCron: '0 18 * * *',
-  emailPollCron: '*/2 * * * *',
-  calendarPollCron: '*/5 * * * *',
-  notificationPollCron: '*/1 * * * *',
-  calendarAlertMinutes: 15,
-  enabled: true,
-  categories: ['calendar', 'email', 'tasks'],
-};
-
-/** Dependencies for the ambient scheduler. */
-export interface AmbientSchedulerDeps {
-  scheduler: Scheduler;
-  connectorRegistry: ConnectorRegistry;
-  triggerManager: TriggerManager;
-  briefingGenerator: BriefingGenerator;
-  emailIntelligence?: { triage?: { getTriageSummary(opts: { maxResults: number }): Promise<{ items: Array<{ subject: string; priority: string }> }> } };
-  calendarIntelligence?: { analyzeDay(date: string): Promise<{ events: Array<{ title: string; time: string }> }> };
-  notificationOrchestrator?: NotificationOrchestrator;
-  deliveryChannel: (message: string) => Promise<void>;
-  userId: string;
-  config?: Partial<AmbientSchedulerConfig>;
-}
-
-const JOB_IDS = {
-  emailPoll: 'ambient:email-poll',
-  calendarPoll: 'ambient:calendar-poll',
-  morningBriefing: 'ambient:morning-briefing',
-  eveningSummary: 'ambient:evening-summary',
-  notificationPoll: 'ambient:notification-poll',
-} as const;
-
-/**
- * Schedules ambient polling and briefing generation using cron jobs.
- */
-export class AmbientScheduler {
-  private readonly scheduler: Scheduler;
-  private readonly connectorRegistry: ConnectorRegistry;
-  private readonly triggerManager: TriggerManager;
-  private readonly briefingGenerator: BriefingGenerator;
-  private readonly emailIntelligence: AmbientSchedulerDeps['emailIntelligence'];
-  private readonly calendarIntelligence: AmbientSchedulerDeps['calendarIntelligence'];
-  private readonly notificationOrchestrator: NotificationOrchestrator | undefined;
-  private readonly deliveryChannel: (message: string) => Promise<void>;
-  private readonly userId: string;
-  private readonly config: AmbientSchedulerConfig;
-  private running = false;
-
-  constructor(deps: AmbientSchedulerDeps) {
-    this.scheduler = deps.scheduler;
-    this.connectorRegistry = deps.connectorRegistry;
-    this.triggerManager = deps.triggerManager;
-    this.briefingGenerator = deps.briefingGenerator;
-    this.emailIntelligence = deps.emailIntelligence;
-    this.calendarIntelligence = deps.calendarIntelligence;
-    this.notificationOrchestrator = deps.notificationOrchestrator;
-    this.deliveryChannel = deps.deliveryChannel;
-    this.userId = deps.userId;
-    this.config = { ...DEFAULT_AMBIENT_SCHEDULER_CONFIG, ...deps.config };
-  }
-
-  /** Start all scheduled cron jobs. */
-  start(): void {
-    if (!this.config.enabled || this.running) return;
-
-    this.scheduler.schedule(JOB_IDS.emailPoll, this.config.emailPollCron, () => {
-      void this.triggerManager.pollAll();
-    });
-
-    this.scheduler.schedule(JOB_IDS.calendarPoll, this.config.calendarPollCron, () => {
-      void this.pollCalendar();
-    });
-
-    this.scheduler.schedule(JOB_IDS.morningBriefing, this.config.morningCron, () => {
-      void this.generateAndDeliverBriefing('morning');
-    });
-
-    this.scheduler.schedule(JOB_IDS.eveningSummary, this.config.eveningCron, () => {
-      void this.generateAndDeliverBriefing('evening');
-    });
-
-    this.scheduler.schedule(JOB_IDS.notificationPoll, this.config.notificationPollCron, () => {
-      void this.pollAndNotify();
-    });
-
-    this.running = true;
-  }
-
-  /** Stop all scheduled cron jobs. */
-  stop(): void {
-    this.scheduler.stop(JOB_IDS.emailPoll);
-    this.scheduler.stop(JOB_IDS.calendarPoll);
-    this.scheduler.stop(JOB_IDS.morningBriefing);
-    this.scheduler.stop(JOB_IDS.eveningSummary);
-    this.scheduler.stop(JOB_IDS.notificationPoll);
-    this.running = false;
-  }
-
-  /** Whether the scheduler is currently running. */
-  isRunning(): boolean {
-    return this.running;
-  }
-
-  /** Get the current configuration. */
-  getConfig(): AmbientSchedulerConfig {
-    return { ...this.config };
-  }
-
-  /** Generate and deliver a briefing for the specified time of day. */
-  async generateAndDeliverBriefing(time: 'morning' | 'evening'): Promise<void> {
-    const calendarEvents = await this.fetchCalendarEvents(time);
-    const emailNotifications = await this.fetchEmailSummary();
-
-    const briefing = this.briefingGenerator.generateBriefing(
-      this.userId,
-      time,
-      {
-        calendarEvents,
-        notifications: emailNotifications,
-      },
-    );
-
-    const formatted = formatBriefingAsText(briefing);
-    await this.deliveryChannel(formatted);
-  }
-
-  private async pollAndNotify(): Promise<void> {
-    if (!this.notificationOrchestrator) return;
-
-    const events = await this.triggerManager.pollAll();
-    if (events.length > 0) {
-      this.notificationOrchestrator.processTriggerEvents(events);
-    }
-
-    // Check for upcoming calendar events
-    if (this.calendarIntelligence) {
-      try {
-        const today = new Date().toISOString().split('T')[0]!;
-        const result = await this.calendarIntelligence.analyzeDay(today);
-        const now = Date.now();
-        const alertWindowMs = this.config.calendarAlertMinutes * 60_000;
-
-        const upcomingEvents = (result.events ?? [])
-          .map((e) => ({
-            title: e.title,
-            startTime: this.parseTimeToTimestamp(e.time),
-          }))
-          .filter((e) => {
-            const timeUntil = e.startTime - now;
-            return timeUntil > 0 && timeUntil <= alertWindowMs;
-          });
-
-        if (upcomingEvents.length > 0) {
-          this.notificationOrchestrator.processCalendarCheck(upcomingEvents, now);
-        }
-      } catch {
-        // Calendar fetch errors are silently ignored
-      }
-    }
-  }
-
-  private parseTimeToTimestamp(time: string): number {
-    const [hours, minutes] = time.split(':').map(Number);
-    const d = new Date();
-    d.setHours(hours ?? 0, minutes ?? 0, 0, 0);
-    return d.getTime();
-  }
-
-  private async pollCalendar(): Promise<void> {
-    if (!this.calendarIntelligence) return;
-
-    const today = new Date().toISOString().split('T')[0]!;
-    await this.calendarIntelligence.analyzeDay(today);
-  }
-
-  private async fetchCalendarEvents(
-    time: 'morning' | 'evening',
-  ): Promise<Array<{ title: string; time: string }>> {
-    if (!this.calendarIntelligence) return [];
-
-    const targetDate = time === 'evening'
-      ? new Date(Date.now() + 86_400_000).toISOString().split('T')[0]!
-      : new Date().toISOString().split('T')[0]!;
-
-    try {
-      const result = await this.calendarIntelligence.analyzeDay(targetDate);
-      return result.events ?? [];
-    } catch {
-      return [];
-    }
-  }
-
-  private async fetchEmailSummary(): Promise<QuietNotification[]> {
-    if (!this.emailIntelligence?.triage) return [];
-
-    try {
-      const result = await this.emailIntelligence.triage.getTriageSummary({ maxResults: 10 });
-      return (result.items ?? []).map((item, i) => ({
-        id: `email-${i}`,
-        priority: item.priority === 'urgent' ? 'alert' as const : 'nudge' as const,
-        message: item.subject,
-        createdAt: Date.now(),
-        dismissed: false,
-        source: 'email',
-      }));
-    } catch {
-      return [];
-    }
-  }
-}

package/src/types.ts

@@ -1,85 +0,0 @@
-/** Types of patterns the ambient engine can detect. */
-export type AmbientPatternType = 'schedule' | 'preference' | 'trigger' | 'correlation';
-
-/** Notification priority levels for quiet notifications. */
-export type NotificationPriority = 'whisper' | 'nudge' | 'alert';
-
-/** A detected ambient pattern from user behavior. */
-export interface AmbientPattern {
-  id: string;
-  /** Pattern type. */
-  type: AmbientPatternType;
-  /** Human-readable description. */
-  description: string;
-  /** Confidence score (0-1). */
-  confidence: number;
-  /** Evidence supporting this pattern. */
-  evidence: string[];
-  /** When the pattern was first detected. */
-  detectedAt: number;
-  /** When the pattern was last confirmed. */
-  lastConfirmedAt: number;
-  /** Number of times this pattern has been observed. */
-  occurrences: number;
-}
-
-/** An anticipated user need based on detected patterns. */
-export interface Anticipation {
-  id: string;
-  /** What the user might need. */
-  description: string;
-  /** When this need is expected. */
-  expectedAt: number;
-  /** Confidence that this anticipation is correct (0-1). */
-  confidence: number;
-  /** Patterns that led to this anticipation. */
-  sourcePatterns: string[];
-  /** Suggested action to fulfill the need. */
-  suggestedAction?: string;
-}
-
-/** A quiet notification queued for the user. */
-export interface QuietNotification {
-  id: string;
-  /** Priority level. */
-  priority: NotificationPriority;
-  /** Notification message. */
-  message: string;
-  /** Detailed content (optional). */
-  detail?: string;
-  /** When the notification was created. */
-  createdAt: number;
-  /** Whether the notification has been dismissed. */
-  dismissed: boolean;
-  /** Source of the notification. */
-  source: string;
-}
-
-/** Configuration for personalized briefings. */
-export interface BriefingConfig {
-  /** Whether briefings are enabled. */
-  enabled: boolean;
-  /** Time of day for morning briefing (HH:MM). */
-  morningTime: string;
-  /** Time of day for evening summary (HH:MM). */
-  eveningTime: string;
-  /** Categories to include in briefings. */
-  categories: string[];
-  /** Maximum number of items per section. */
-  maxItemsPerSection: number;
-}
-
-export const DEFAULT_BRIEFING_CONFIG: BriefingConfig = {
-  enabled: true,
-  morningTime: '08:00',
-  eveningTime: '20:00',
-  categories: ['calendar', 'tasks', 'weather', 'news', 'patterns'],
-  maxItemsPerSection: 5,
-};
-
-/** An observed event for the pattern engine. */
-export interface ObservedEvent {
-  type: string;
-  timestamp: number;
-  data?: Record<string, unknown>;
-}