@auxiora/ambient 1.0.0 → 1.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@auxiora/ambient",
-  "version": "1.0.0",
+  "version": "1.3.0",
   "description": "Ambient pattern detection, anticipation, briefings, and quiet notifications",
   "type": "module",
   "main": "dist/index.js",
@@ -12,15 +12,21 @@
     }
   },
   "dependencies": {
-    "@auxiora/memory": "1.0.0",
-    "@auxiora/behaviors": "1.0.0",
-    "@auxiora/personality": "1.0.0",
-    "@auxiora/notification-hub": "1.0.0",
-    "@auxiora/connectors": "1.0.0"
+    "@auxiora/behaviors": "1.3.0",
+    "@auxiora/memory": "1.3.0",
+    "@auxiora/personality": "1.3.0",
+    "@auxiora/notification-hub": "1.3.0",
+    "@auxiora/connectors": "1.3.0"
   },
   "engines": {
     "node": ">=22.0.0"
   },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist/"
+  ],
   "scripts": {
     "build": "tsc",
     "clean": "rm -rf dist",

package/src/anticipation.ts

@@ -1,141 +0,0 @@
-import * as crypto from 'node:crypto';
-import type { AmbientPattern, Anticipation } from './types.js';
-
-/**
- * Anticipation engine — predicts user needs based on detected patterns.
- */
-export class AnticipationEngine {
-  private anticipations: Map<string, Anticipation> = new Map();
-
-  /**
-   * Generate anticipations from detected patterns and current context.
-   * @param patterns - Currently detected patterns.
-   * @param context - Current context (time, active tasks, etc.).
-   */
-  generateAnticipations(
-    patterns: AmbientPattern[],
-    context?: { currentTime?: number; activeTaskCount?: number }
-  ): Anticipation[] {
-    const now = context?.currentTime ?? Date.now();
-    const generated: Anticipation[] = [];
-
-    for (const pattern of patterns) {
-      if (pattern.confidence < 0.4) continue;
-
-      switch (pattern.type) {
-        case 'schedule': {
-          const anticipation = this.anticipateSchedule(pattern, now);
-          if (anticipation) generated.push(anticipation);
-          break;
-        }
-        case 'preference': {
-          const anticipation = this.anticipatePreference(pattern, now);
-          if (anticipation) generated.push(anticipation);
-          break;
-        }
-        case 'correlation': {
-          const anticipation = this.anticipateCorrelation(pattern, now);
-          if (anticipation) generated.push(anticipation);
-          break;
-        }
-        case 'trigger': {
-          const anticipation = this.anticipateTrigger(pattern, now);
-          if (anticipation) generated.push(anticipation);
-          break;
-        }
-      }
-    }
-
-    // Store generated anticipations
-    for (const a of generated) {
-      this.anticipations.set(a.id, a);
-    }
-
-    return generated;
-  }
-
-  /** Get all current anticipations sorted by expected time. */
-  getAnticipations(): Anticipation[] {
-    return Array.from(this.anticipations.values())
-      .filter(a => a.expectedAt > Date.now())
-      .sort((a, b) => a.expectedAt - b.expectedAt);
-  }
-
-  /** Clear expired anticipations. */
-  prune(): number {
-    const now = Date.now();
-    let pruned = 0;
-    for (const [id, a] of this.anticipations) {
-      if (a.expectedAt < now) {
-        this.anticipations.delete(id);
-        pruned++;
-      }
-    }
-    return pruned;
-  }
-
-  /** Reset all anticipations. */
-  reset(): void {
-    this.anticipations.clear();
-  }
-
-  private anticipateSchedule(pattern: AmbientPattern, now: number): Anticipation | null {
-    // Extract hour from description like '... around 14:00'
-    const match = pattern.description.match(/around (\d+):00/);
-    if (!match) return null;
-
-    const hour = parseInt(match[1], 10);
-    const nextOccurrence = new Date(now);
-    nextOccurrence.setHours(hour, 0, 0, 0);
-    if (nextOccurrence.getTime() <= now) {
-      nextOccurrence.setDate(nextOccurrence.getDate() + 1);
-    }
-
-    return {
-      id: crypto.randomUUID(),
-      description: `Based on your pattern: ${pattern.description}`,
-      expectedAt: nextOccurrence.getTime(),
-      confidence: pattern.confidence * 0.8,
-      sourcePatterns: [pattern.id],
-      suggestedAction: `Prepare for upcoming "${pattern.description.split('"')[1]}" activity`,
-    };
-  }
-
-  private anticipatePreference(pattern: AmbientPattern, now: number): Anticipation | null {
-    // Extract interval from description like 'every 2.5 hours'
-    const match = pattern.description.match(/every ([\d.]+) hours/);
-    if (!match) return null;
-
-    const intervalHours = parseFloat(match[1]);
-    const expectedAt = now + intervalHours * 60 * 60 * 1000;
-
-    return {
-      id: crypto.randomUUID(),
-      description: `You typically do this every ${intervalHours} hours`,
-      expectedAt,
-      confidence: pattern.confidence * 0.7,
-      sourcePatterns: [pattern.id],
-    };
-  }
-
-  private anticipateCorrelation(pattern: AmbientPattern, now: number): Anticipation | null {
-    return {
-      id: crypto.randomUUID(),
-      description: `When this happens: ${pattern.description}`,
-      expectedAt: now + 5 * 60 * 1000, // 5 minutes from now
-      confidence: pattern.confidence * 0.6,
-      sourcePatterns: [pattern.id],
-      suggestedAction: `Proactively prepare the follow-up action`,
-    };
-  }
-
-  private anticipateTrigger(pattern: AmbientPattern, now: number): Anticipation | null {
-    return {
-      id: crypto.randomUUID(),
-      description: `Trigger detected: ${pattern.description}`,
-      expectedAt: now + 60 * 1000, // 1 minute
-      confidence: pattern.confidence * 0.9,
-      sourcePatterns: [pattern.id],
-    };
-  }
-}

package/src/briefing.ts

@@ -1,152 +0,0 @@
-import type { AmbientPattern, Anticipation, BriefingConfig, QuietNotification } from './types.js';
-import { DEFAULT_BRIEFING_CONFIG } from './types.js';
-
-/** A compiled briefing for the user. */
-export interface Briefing {
-  userId: string;
-  generatedAt: number;
-  timeOfDay: 'morning' | 'evening' | 'custom';
-  sections: BriefingSection[];
-}
-
-/** A section of a briefing. */
-export interface BriefingSection {
-  title: string;
-  items: string[];
-}
-
-/** Data sources for briefing generation. */
-export interface BriefingDataSources {
-  patterns?: AmbientPattern[];
-  anticipations?: Anticipation[];
-  notifications?: QuietNotification[];
-  calendarEvents?: Array<{ title: string; time: string }>;
-  tasks?: Array<{ title: string; status: string }>;
-}
-
-/**
- * Generates personalized briefings/digests for users.
- */
-export class BriefingGenerator {
-  private config: BriefingConfig;
-
-  constructor(config?: Partial<BriefingConfig>) {
-    this.config = { ...DEFAULT_BRIEFING_CONFIG, ...config };
-  }
-
-  /** Generate a briefing for the given user at the given time. */
-  generateBriefing(
-    userId: string,
-    time: 'morning' | 'evening' | 'custom',
-    sources: BriefingDataSources
-  ): Briefing {
-    const sections: BriefingSection[] = [];
-
-    // Notifications section
-    if (sources.notifications && sources.notifications.length > 0) {
-      const pending = sources.notifications.filter(n => !n.dismissed);
-      if (pending.length > 0) {
-        sections.push({
-          title: 'Notifications',
-          items: pending.slice(0, this.config.maxItemsPerSection).map(
-            n => `[${n.priority}] ${n.message}`
-          ),
-        });
-      }
-    }
-
-    // Calendar section
-    if (this.config.categories.includes('calendar') && sources.calendarEvents) {
-      const events = sources.calendarEvents.slice(0, this.config.maxItemsPerSection);
-      if (events.length > 0) {
-        sections.push({
-          title: time === 'morning' ? 'Today\'s Schedule' : 'Tomorrow\'s Schedule',
-          items: events.map(e => `${e.time} - ${e.title}`),
-        });
-      }
-    }
-
-    // Tasks section
-    if (this.config.categories.includes('tasks') && sources.tasks) {
-      const activeTasks = sources.tasks
-        .filter(t => t.status !== 'completed')
-        .slice(0, this.config.maxItemsPerSection);
-      if (activeTasks.length > 0) {
-        sections.push({
-          title: 'Active Tasks',
-          items: activeTasks.map(t => `${t.title} (${t.status})`),
-        });
-      }
-    }
-
-    // Patterns section
-    if (this.config.categories.includes('patterns') && sources.patterns) {
-      const topPatterns = sources.patterns
-        .filter(p => p.confidence >= 0.5)
-        .slice(0, this.config.maxItemsPerSection);
-      if (topPatterns.length > 0) {
-        sections.push({
-          title: 'Observed Patterns',
-          items: topPatterns.map(p => `${p.description} (${Math.round(p.confidence * 100)}% confidence)`),
-        });
-      }
-    }
-
-    // Anticipations section
-    if (sources.anticipations && sources.anticipations.length > 0) {
-      const upcoming = sources.anticipations
-        .filter(a => a.expectedAt > Date.now())
-        .slice(0, this.config.maxItemsPerSection);
-      if (upcoming.length > 0) {
-        sections.push({
-          title: 'Upcoming',
-          items: upcoming.map(a => {
-            const timeStr = new Date(a.expectedAt).toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' });
-            return `~${timeStr}: ${a.description}`;
-          }),
-        });
-      }
-    }
-
-    return {
-      userId,
-      generatedAt: Date.now(),
-      timeOfDay: time,
-      sections,
-    };
-  }
-
-  /** Check if it's time for a briefing. */
-  isBriefingTime(time: 'morning' | 'evening'): boolean {
-    if (!this.config.enabled) return false;
-    const now = new Date();
-    const currentTime = `${String(now.getHours()).padStart(2, '0')}:${String(now.getMinutes()).padStart(2, '0')}`;
-    const target = time === 'morning' ? this.config.morningTime : this.config.eveningTime;
-    return currentTime === target;
-  }
-
-  /** Get config. */
-  getConfig(): BriefingConfig {
-    return { ...this.config };
-  }
-}
-
-/** Format a briefing as human-readable text. */
-export function formatBriefingAsText(briefing: Briefing): string {
-  const greeting = briefing.timeOfDay === 'morning'
-    ? 'Good morning! Here\'s your day:'
-    : briefing.timeOfDay === 'evening'
-      ? 'Here\'s your evening summary:'
-      : 'Here\'s your briefing:';
-
-  if (briefing.sections.length === 0) {
-    return `${greeting}\n\nNo updates right now.`;
-  }
-
-  const sections = briefing.sections.map(s => {
-    const items = s.items.map(item => `  ${item}`).join('\n');
-    return `${s.title}\n${items}`;
-  }).join('\n\n');
-
-  return `${greeting}\n\n${sections}`;
-}

package/src/index.ts

@@ -1,26 +0,0 @@
-export type {
-  AmbientPattern,
-  AmbientPatternType,
-  Anticipation,
-  QuietNotification,
-  NotificationPriority,
-  BriefingConfig,
-  ObservedEvent,
-} from './types.js';
-export { DEFAULT_BRIEFING_CONFIG } from './types.js';
-export { AmbientPatternEngine } from './pattern-engine.js';
-export { AnticipationEngine } from './anticipation.js';
-export { BriefingGenerator, formatBriefingAsText, type Briefing, type BriefingSection, type BriefingDataSources } from './briefing.js';
-export { QuietNotificationManager } from './notification.js';
-export {
-  AmbientScheduler,
-  DEFAULT_AMBIENT_SCHEDULER_CONFIG,
-  type AmbientSchedulerConfig,
-  type AmbientSchedulerDeps,
-} from './scheduler.js';
-export {
-  NotificationOrchestrator,
-  type OrchestratorConfig,
-  type OrchestratorNotification,
-  type DeliveryChannelFn,
-} from './orchestrator.js';

package/src/notification.ts

@@ -1,101 +0,0 @@
-import * as crypto from 'node:crypto';
-import type { NotificationPriority, QuietNotification } from './types.js';
-
-/** Priority ordering for queue sorting. */
-const PRIORITY_ORDER: Record<NotificationPriority, number> = {
-  alert: 3,
-  nudge: 2,
-  whisper: 1,
-};
-
-/**
- * Priority-based queue for quiet notifications.
- */
-export class QuietNotificationManager {
-  private notifications: Map<string, QuietNotification> = new Map();
-
-  /** Create and queue a notification. */
-  notify(
-    priority: NotificationPriority,
-    message: string,
-    options?: { detail?: string; source?: string }
-  ): QuietNotification {
-    const notification: QuietNotification = {
-      id: crypto.randomUUID(),
-      priority,
-      message,
-      detail: options?.detail,
-      createdAt: Date.now(),
-      dismissed: false,
-      source: options?.source ?? 'ambient',
-    };
-
-    this.notifications.set(notification.id, notification);
-    return notification;
-  }
-
-  /** Get all pending notifications, sorted by priority (highest first). */
-  getQueue(): QuietNotification[] {
-    return Array.from(this.notifications.values())
-      .filter(n => !n.dismissed)
-      .sort((a, b) => PRIORITY_ORDER[b.priority] - PRIORITY_ORDER[a.priority]);
-  }
-
-  /** Get notifications filtered by priority. */
-  getByPriority(priority: NotificationPriority): QuietNotification[] {
-    return Array.from(this.notifications.values())
-      .filter(n => !n.dismissed && n.priority === priority);
-  }
-
-  /** Dismiss a notification. */
-  dismiss(id: string): boolean {
-    const n = this.notifications.get(id);
-    if (!n) return false;
-    n.dismissed = true;
-    return true;
-  }
-
-  /** Dismiss all notifications. */
-  dismissAll(): number {
-    let count = 0;
-    for (const n of this.notifications.values()) {
-      if (!n.dismissed) {
-        n.dismissed = true;
-        count++;
-      }
-    }
-    return count;
-  }
-
-  /** Get a notification by ID. */
-  get(id: string): QuietNotification | undefined {
-    return this.notifications.get(id);
-  }
-
-  /** Get count of pending notifications. */
-  getPendingCount(): number {
-    let count = 0;
-    for (const n of this.notifications.values()) {
-      if (!n.dismissed) count++;
-    }
-    return count;
-  }
-
-  /** Remove old dismissed notifications. */
-  prune(maxAge = 24 * 60 * 60 * 1000): number {
-    const cutoff = Date.now() - maxAge;
-    let pruned = 0;
-    for (const [id, n] of this.notifications) {
-      if (n.dismissed && n.createdAt < cutoff) {
-        this.notifications.delete(id);
-        pruned++;
-      }
-    }
-    return pruned;
-  }
-
-  /** Clear all notifications. */
-  clear(): void {
-    this.notifications.clear();
-  }
-}

package/src/orchestrator.ts

@@ -1,188 +0,0 @@
-import type { TriggerEvent } from '@auxiora/connectors';
-import type { NotificationHub, DoNotDisturbManager, NotificationPriority } from '@auxiora/notification-hub';
-
-/** Configuration for the NotificationOrchestrator. */
-export interface OrchestratorConfig {
-  /** Calendar alert window in ms (default 15 minutes). */
-  calendarAlertWindowMs?: number;
-}
-
-/** A pending orchestrator notification. */
-export interface OrchestratorNotification {
-  id: string;
-  source: string;
-  priority: NotificationPriority;
-  message: string;
-  createdAt: number;
-  delivered: boolean;
-}
-
-/** Function that delivers a notification to the user. */
-export type DeliveryChannelFn = (notification: OrchestratorNotification) => void;
-
-const URGENCY_KEYWORDS = ['urgent', 'asap', 'important', 'action required', 'deadline'];
-
-const DEFAULT_CALENDAR_ALERT_WINDOW_MS = 15 * 60 * 1000; // 15 minutes
-
-export class NotificationOrchestrator {
-  private hub: NotificationHub;
-  private dnd: DoNotDisturbManager;
-  private deliveryChannel: DeliveryChannelFn;
-  private pending: OrchestratorNotification[] = [];
-  private calendarAlertWindowMs: number;
-
-  constructor(
-    hub: NotificationHub,
-    dnd: DoNotDisturbManager,
-    deliveryChannel: DeliveryChannelFn,
-    config?: OrchestratorConfig,
-  ) {
-    this.hub = hub;
-    this.dnd = dnd;
-    this.deliveryChannel = deliveryChannel;
-    this.calendarAlertWindowMs = config?.calendarAlertWindowMs ?? DEFAULT_CALENDAR_ALERT_WINDOW_MS;
-  }
-
-  /** Map trigger events to notifications and deliver or queue them. */
-  processTriggerEvents(events: TriggerEvent[]): OrchestratorNotification[] {
-    const results: OrchestratorNotification[] = [];
-
-    for (const event of events) {
-      const { priority, message, source } = this.mapTriggerEvent(event);
-
-      const notification: OrchestratorNotification = {
-        id: crypto.randomUUID(),
-        source,
-        priority,
-        message,
-        createdAt: Date.now(),
-        delivered: false,
-      };
-
-      this.hub.send({
-        source: source as 'email' | 'calendar' | 'system',
-        priority,
-        title: event.triggerId,
-        body: message,
-      });
-
-      this.routeNotification(notification);
-      results.push(notification);
-    }
-
-    return results;
-  }
-
-  /** Check calendar events and create notifications for those starting soon. */
-  processCalendarCheck(
-    events: Array<{ title: string; startTime: number }>,
-    now?: number,
-  ): OrchestratorNotification[] {
-    const currentTime = now ?? Date.now();
-    const results: OrchestratorNotification[] = [];
-
-    for (const event of events) {
-      const timeUntilStart = event.startTime - currentTime;
-      if (timeUntilStart > 0 && timeUntilStart <= this.calendarAlertWindowMs) {
-        const minutesUntil = Math.round(timeUntilStart / 60_000);
-        const message = `"${event.title}" starts in ${minutesUntil} minute${minutesUntil === 1 ? '' : 's'}`;
-
-        const notification: OrchestratorNotification = {
-          id: crypto.randomUUID(),
-          source: 'calendar',
-          priority: 'important',
-          message,
-          createdAt: currentTime,
-          delivered: false,
-        };
-
-        this.hub.send({
-          source: 'calendar',
-          priority: 'important',
-          title: event.title,
-          body: message,
-        });
-
-        this.routeNotification(notification);
-        results.push(notification);
-      }
-    }
-
-    return results;
-  }
-
-  /** Get all pending (undelivered or queued) notifications. */
-  getPending(): OrchestratorNotification[] {
-    return this.pending.filter((n) => !n.delivered);
-  }
-
-  /** Dismiss a pending notification by ID. Returns true if found and removed. */
-  dismiss(id: string): boolean {
-    const index = this.pending.findIndex((n) => n.id === id);
-    if (index === -1) return false;
-    this.pending.splice(index, 1);
-    return true;
-  }
-
-  private mapTriggerEvent(event: TriggerEvent): {
-    priority: NotificationPriority;
-    message: string;
-    source: string;
-  } {
-    switch (event.triggerId) {
-      case 'new-email': {
-        const subject = String(event.data['subject'] ?? '');
-        const from = String(event.data['from'] ?? 'unknown sender');
-        const isUrgent = URGENCY_KEYWORDS.some((kw) =>
-          subject.toLowerCase().includes(kw),
-        );
-        return {
-          priority: isUrgent ? 'urgent' : 'important',
-          message: `New email from ${from}: ${subject}`,
-          source: 'email',
-        };
-      }
-
-      case 'event-starting-soon': {
-        const title = String(event.data['title'] ?? 'Untitled event');
-        return {
-          priority: 'important',
-          message: `Event starting soon: ${title}`,
-          source: 'calendar',
-        };
-      }
-
-      case 'file-shared': {
-        const fileName = String(event.data['fileName'] ?? 'a file');
-        const sharedBy = String(event.data['sharedBy'] ?? 'someone');
-        return {
-          priority: 'low',
-          message: `${sharedBy} shared ${fileName} with you`,
-          source: 'system',
-        };
-      }
-
-      default:
-        return {
-          priority: 'low',
-          message: `Notification from ${event.connectorId}: ${event.triggerId}`,
-          source: 'system',
-        };
-    }
-  }
-
-  private routeNotification(notification: OrchestratorNotification): void {
-    const dndActive = this.dnd.isActive();
-
-    if (dndActive && notification.priority !== 'urgent') {
-      // Queue silently — do not deliver
-      notification.delivered = false;
-      this.pending.push(notification);
-      return;
-    }
-
-    // Deliver immediately
-    notification.delivered = true;
-    this.deliveryChannel(notification);
-  }
-}