vibefast-cli 0.2.4 → 0.3.1

package/2/apps/native/src/core/cache/index.ts

@@ -0,0 +1,45 @@
+import { MMKV } from 'react-native-mmkv';
+
+import { warn } from '@/core/logging';
+
+import { CacheService } from './cache-service';
+
+/**
+ * Default instance of CacheService, initialized with a new MMKV instance.
+ * Use this for most common caching needs throughout the application.
+ */
+const createSafeMMKV = (): MMKV => {
+  try {
+    return new MMKV();
+  } catch (err) {
+    warn(
+      '[CacheService] MMKV unavailable, using in-memory fallback for this session.',
+      {
+        feature: 'cache',
+        error: err,
+        fallback: 'in-memory',
+      },
+    );
+    const store = new Map<string, string>();
+    return {
+      set: (key: string, value: string) => {
+        store.set(key, value);
+      },
+      getString: (key: string) => store.get(key),
+      delete: (key: string) => {
+        store.delete(key);
+      },
+      clearAll: () => {
+        store.clear();
+      },
+    } as unknown as MMKV;
+  }
+};
+
+const mmkvInstance = createSafeMMKV();
+
+export const defaultCacheService = new CacheService({
+  mmkvInstance,
+});
+
+export { CacheService } from './cache-service';

package/2/apps/native/src/core/config/config.service.ts

@@ -0,0 +1,153 @@
+import Constants from 'expo-constants';
+
+import { error, warn } from '@/core/logging';
+
+/**
+ * Defines the structure of the extra configuration loaded from app.config.ts.
+ * These are typically sourced from .env files.
+ */
+export type TelemetryMode = 'off' | 'sample' | 'debug';
+
+type AppConfigExtra = {
+  APP_ENV: 'local' | 'staging' | 'production';
+  VERSION: string;
+  CONVEX_URL: string;
+  CONVEX_SITE_URL: string; // Assuming this might be different from CONVEX_URL, e.g., for frontend dashboard
+  REVENUECAT_API_KEY_APPLE?: string;
+  REVENUECAT_API_KEY_GOOGLE?: string;
+  SENTRY_DSN?: string;
+  POSTHOG_API_KEY?: string;
+  POSTHOG_HOST?: string;
+  CHAT_LATENCY_TELEMETRY_MODE?: TelemetryMode;
+};
+
+/**
+ * Provides a type-safe way to access application configurations.
+ * Configurations are sourced from .env files via env.js and app.config.ts,
+ * and made available through Constants.expoConfig.extra.
+ */
+class ConfigServiceController {
+  private config: AppConfigExtra;
+
+  constructor() {
+    // It's crucial that env.js has already validated these.
+    // If Constants.expoConfig.extra is undefined or doesn't match AppConfigExtra,
+    // there's a problem earlier in the config loading pipeline.
+    this.config = Constants.expoConfig?.extra as AppConfigExtra;
+
+    if (!this.config) {
+      // This should ideally not happen if env.js and app.config.ts are set up correctly.
+      error(
+        '[ConfigService] Critical: Application configuration (Constants.expoConfig.extra) is not loaded.',
+        { feature: 'config', severity: 'critical' },
+      );
+      // Provide a default fallback or throw to prevent app from running with missing config
+      // For now, we'll let it proceed, but this state means getters will fail.
+      // A more robust solution might involve a "isConfigLoaded" check or throwing here.
+      this.config = {} as AppConfigExtra; // Fallback to prevent immediate crash on access
+    }
+  }
+
+  /**
+   * Retrieves the application environment.
+   * @returns The current application environment ('local', 'staging', or 'production').
+   */
+  public getAppEnv(): 'local' | 'staging' | 'production' {
+    return this.config.APP_ENV || 'local'; // Default to 'local' if somehow undefined
+  }
+
+  /**
+   * Retrieves the application version.
+   * @returns The current application version string.
+   */
+  public getVersion(): string {
+    return this.config.VERSION || '0.0.0'; // Default to '0.0.0'
+  }
+
+  /**
+   * Retrieves the Convex URL.
+   * @returns The Convex deployment URL.
+   */
+  public getConvexUrl(): string {
+    if (!this.config.CONVEX_URL) {
+      warn('[ConfigService] CONVEX_URL is not set.', {
+        feature: 'config',
+        missingConfig: 'CONVEX_URL',
+      });
+    }
+    return this.config.CONVEX_URL || '';
+  }
+
+  /**
+   * Retrieves the Convex Site URL (if different from CONVEX_URL).
+   * Useful if the dashboard or a related site has a different URL.
+   * @returns The Convex site URL.
+   */
+  public getConvexSiteUrl(): string {
+    if (!this.config.CONVEX_SITE_URL) {
+      // It's possible CONVEX_SITE_URL might be the same as CONVEX_URL
+      // or simply not defined if not needed.
+      // console.warn('[ConfigService] CONVEX_SITE_URL is not set, defaulting to CONVEX_URL or empty.');
+      return this.config.CONVEX_URL || ''; // Fallback to CONVEX_URL or empty if that's also missing
+    }
+    return this.config.CONVEX_SITE_URL;
+  }
+
+  /**
+   * Retrieves the RevenueCat API key for Apple.
+   * @returns The RevenueCat API key for Apple, or undefined if not set.
+   */
+  public getRevenueCatApiKeyApple(): string | undefined {
+    return this.config.REVENUECAT_API_KEY_APPLE;
+  }
+
+  /**
+   * Retrieves the RevenueCat API key for Google.
+   * @returns The RevenueCat API key for Google, or undefined if not set.
+   */
+  public getRevenueCatApiKeyGoogle(): string | undefined {
+    return this.config.REVENUECAT_API_KEY_GOOGLE;
+  }
+
+  /**
+   * Retrieves the Sentry DSN.
+   * @returns The Sentry DSN, or undefined if not set.
+   */
+  public getSentryDsn(): string | undefined {
+    return this.config.SENTRY_DSN;
+  }
+
+  /**
+   * Retrieves the PostHog API key.
+   * @returns The PostHog API key, or undefined if not set.
+   */
+  public getPostHogApiKey(): string | undefined {
+    return this.config.POSTHOG_API_KEY;
+  }
+
+  /**
+   * Retrieves the PostHog host URL.
+   * @returns The PostHog host URL, or undefined if not set.
+   */
+  public getPostHogHost(): string | undefined {
+    return this.config.POSTHOG_HOST;
+  }
+
+  public getChatLatencyTelemetryMode(): TelemetryMode {
+    const raw = this.config.CHAT_LATENCY_TELEMETRY_MODE ?? 'off';
+    if (raw === 'sample' || raw === 'debug') {
+      return raw;
+    }
+    return 'off';
+  }
+}
+
+/**
+ * Singleton instance of the ConfigService.
+ * Import this instance to access configuration values throughout the application.
+ * @example
+ * import { ConfigService } from '@/core/config';
+ * import { info } from '@/core/logging';
+ * info(ConfigService.getAppEnv(), { feature: 'config' });
+ */
+export const ConfigService = new ConfigServiceController();

package/2/apps/native/src/core/config/index.ts

@@ -0,0 +1,2 @@
+export type { TelemetryMode } from './config.service';
+export { ConfigService } from './config.service';

package/2/apps/native/src/core/config/telemetry.ts

@@ -0,0 +1,38 @@
+import { ConfigService, type TelemetryMode } from '@/core/config';
+
+export type { TelemetryMode };
+
+/**
+ * Returns the configured telemetry mode for chat latency instrumentation.
+ */
+export function getChatTelemetryMode(): TelemetryMode {
+  return ConfigService.getChatLatencyTelemetryMode();
+}
+
+/**
+ * Indicates whether chat latency telemetry is enabled in any capacity.
+ */
+export function isChatTelemetryEnabled(): boolean {
+  return getChatTelemetryMode() !== 'off';
+}
+
+/**
+ * Utility for probabilistic sampling. Returns true when the current mode allows
+ * telemetry capture for the supplied sampling probability (0-1 range).
+ *
+ * - `debug`: always true
+ * - `sample`: true when Math.random() < probability (defaults to 0.1)
+ * - `off`: always false
+ */
+export function shouldSampleChatTelemetry(probability = 0.1): boolean {
+  const mode = getChatTelemetryMode();
+  if (mode === 'off') {
+    return false;
+  }
+  if (mode === 'debug') {
+    return true;
+  }
+
+  const clampedProbability = Math.min(Math.max(probability, 0), 1);
+  return Math.random() < clampedProbability;
+}

package/2/apps/native/src/core/local-notifications/local-notification-manager.ts

@@ -0,0 +1,409 @@
+/**
+ * Basic local notification manager with storage wrapper
+ */
+
+import * as Notifications from 'expo-notifications';
+
+import { error as logError, info } from '@/core/logging';
+import { deepLinkHandler } from '@/core/navigation/deep-link-handler';
+import {
+  notificationStorage,
+  type StoredNotification,
+} from '@/core/storage/notification-storage';
+
+export interface LocalNotification {
+  id?: string;
+  title: string;
+  body: string;
+  data?: Record<string, any>;
+  trigger?: Notifications.NotificationTriggerInput;
+  sound?: string | 'default';
+  category?: string;
+  priority?: 'default' | 'high' | 'low';
+}
+
+export interface ScheduledNotificationInfo {
+  id: string;
+  title: string;
+  body: string;
+  scheduledAt: Date;
+  triggerAt: Date;
+  data?: Record<string, any>;
+  category?: string;
+}
+
+export class LocalNotificationManager {
+  private static instance: LocalNotificationManager;
+  private isInitialized = false;
+
+  private constructor() {}
+
+  static getInstance(): LocalNotificationManager {
+    if (!LocalNotificationManager.instance) {
+      LocalNotificationManager.instance = new LocalNotificationManager();
+    }
+    return LocalNotificationManager.instance;
+  }
+
+  /**
+   * Initialize the local notification manager
+   */
+  async initialize(): Promise<void> {
+    if (this.isInitialized) {
+      return;
+    }
+
+    try {
+      info('Initializing local notification manager', {
+        feature: 'local-notifications.init',
+      });
+
+      // Set up notification handler
+      Notifications.setNotificationHandler({
+        handleNotification: async () => ({
+          shouldShowAlert: true,
+          shouldPlaySound: true,
+          shouldSetBadge: false,
+          shouldShowBanner: true,
+          shouldShowList: true,
+        }),
+      });
+
+      // Clean up old notifications
+      await notificationStorage.cleanupOldNotifications();
+
+      this.isInitialized = true;
+
+      info('Local notification manager initialized successfully', {
+        feature: 'local-notifications.init',
+      });
+    } catch (err) {
+      logError(err as Error, {
+        feature: 'local-notifications.init',
+      });
+      throw new Error('Failed to initialize local notification manager');
+    }
+  }
+
+  /**
+   * Schedule a local notification
+   */
+  async scheduleNotification(
+    notification: LocalNotification,
+  ): Promise<string | null> {
+    try {
+      await this.ensureInitialized();
+
+      // Validate notification content
+      if (!notification.title?.trim()) {
+        throw new Error('Notification title is required');
+      }
+
+      if (!notification.body?.trim()) {
+        throw new Error('Notification body is required');
+      }
+
+      // Check notification limit (iOS hard limit is 64)
+      const scheduledNotifications = await this.getScheduledNotifications();
+      if (scheduledNotifications.length >= 64) {
+        logError(new Error('Maximum scheduled notifications reached'), {
+          feature: 'local-notifications.schedule',
+          currentCount: scheduledNotifications.length,
+          limit: 64,
+        });
+        throw new Error('Cannot schedule more than 64 notifications');
+      }
+
+      // Prepare notification content
+      const notificationContent: Notifications.NotificationContentInput = {
+        title: notification.title,
+        body: notification.body,
+        data: notification.data || {},
+        sound: notification.sound || 'default',
+      };
+
+      // Schedule the notification
+      const notificationId = await Notifications.scheduleNotificationAsync({
+        content: notificationContent,
+        trigger: notification.trigger || null,
+      });
+
+      // Store notification locally for tracking
+      await notificationStorage.storeNotification({
+        title: notification.title,
+        body: notification.body,
+        data: notification.data,
+        type: 'local',
+        category: notification.category,
+      });
+
+      info('Local notification scheduled successfully', {
+        feature: 'local-notifications.schedule',
+        notificationId,
+        title: notification.title,
+        trigger: notification.trigger,
+      });
+
+      return notificationId;
+    } catch (err) {
+      logError(err as Error, {
+        feature: 'local-notifications.schedule',
+        notification,
+      });
+      return null;
+    }
+  }
+
+  /**
+   * Schedule a notification with relative time (e.g., "in 1 hour")
+   */
+  async scheduleNotificationWithDelay(
+    notification: Omit<LocalNotification, 'trigger'>,
+    delaySeconds: number,
+  ): Promise<string | null> {
+    return this.scheduleNotification({
+      ...notification,
+      trigger: {
+        type: Notifications.SchedulableTriggerInputTypes.TIME_INTERVAL,
+        seconds: delaySeconds,
+      },
+    });
+  }
+
+  /**
+   * Schedule a notification for a specific date
+   */
+  async scheduleNotificationForDate(
+    notification: Omit<LocalNotification, 'trigger'>,
+    date: Date,
+  ): Promise<string | null> {
+    // Don't schedule notifications in the past
+    if (date <= new Date()) {
+      throw new Error('Cannot schedule notifications for past dates');
+    }
+
+    return this.scheduleNotification({
+      ...notification,
+      trigger: {
+        type: Notifications.SchedulableTriggerInputTypes.DATE,
+        date,
+      },
+    });
+  }
+
+  /**
+   * Cancel a scheduled notification
+   */
+  async cancelNotification(notificationId: string): Promise<boolean> {
+    try {
+      await this.ensureInitialized();
+
+      // Cancel with Expo
+      await Notifications.cancelScheduledNotificationAsync(notificationId);
+
+      // Remove from local storage
+      await notificationStorage.deleteNotification(notificationId);
+
+      info('Local notification cancelled successfully', {
+        feature: 'local-notifications.cancel',
+        notificationId,
+      });
+
+      return true;
+    } catch (err) {
+      logError(err as Error, {
+        feature: 'local-notifications.cancel',
+        notificationId,
+      });
+      return false;
+    }
+  }
+
+  /**
+   * Get all scheduled notifications
+   */
+  async getScheduledNotifications(): Promise<
+    Notifications.NotificationRequest[]
+  > {
+    try {
+      await this.ensureInitialized();
+      return await Notifications.getAllScheduledNotificationsAsync();
+    } catch (err) {
+      logError(err as Error, {
+        feature: 'local-notifications.get-scheduled',
+      });
+      return [];
+    }
+  }
+
+  /**
+   * Get all stored notifications (history)
+   */
+  async getNotificationHistory(): Promise<StoredNotification[]> {
+    try {
+      return await notificationStorage.getAllNotifications();
+    } catch (err) {
+      logError(err as Error, {
+        feature: 'local-notifications.get-history',
+      });
+      return [];
+    }
+  }
+
+  /**
+   * Get unread notifications count
+   */
+  async getUnreadCount(): Promise<number> {
+    try {
+      return await notificationStorage.getUnreadCount();
+    } catch (err) {
+      logError(err as Error, {
+        feature: 'local-notifications.get-unread-count',
+      });
+      return 0;
+    }
+  }
+
+  /**
+   * Show an immediate notification (no scheduling)
+   */
+  async showImmediateNotification(
+    notification: Omit<LocalNotification, 'trigger'>,
+  ): Promise<void> {
+    try {
+      await this.ensureInitialized();
+
+      const notificationContent: Notifications.NotificationContentInput = {
+        title: notification.title,
+        body: notification.body,
+        data: notification.data || {},
+        sound: notification.sound || 'default',
+      };
+
+      await Notifications.scheduleNotificationAsync({
+        content: notificationContent,
+        trigger: null,
+      });
+
+      // Store in history
+      await notificationStorage.storeNotification({
+        title: notification.title,
+        body: notification.body,
+        data: notification.data,
+        type: 'local',
+        category: notification.category,
+      });
+
+      info('Immediate notification shown successfully', {
+        feature: 'local-notifications.immediate',
+        title: notification.title,
+      });
+    } catch (err) {
+      logError(err as Error, {
+        feature: 'local-notifications.immediate',
+        notification,
+      });
+      throw new Error('Failed to show immediate notification');
+    }
+  }
+
+  /**
+   * Clear all notifications
+   */
+  async clearAllNotifications(): Promise<void> {
+    try {
+      await this.ensureInitialized();
+
+      // Dismiss all presented notifications
+      await Notifications.dismissAllNotificationsAsync();
+
+      // Clear local storage
+      await notificationStorage.clearAllNotifications();
+
+      info('All notifications cleared successfully', {
+        feature: 'local-notifications.clear-all',
+      });
+    } catch (err) {
+      logError(err as Error, {
+        feature: 'local-notifications.clear-all',
+      });
+      throw new Error('Failed to clear all notifications');
+    }
+  }
+
+  /**
+   * Get notification permissions
+   */
+  async getPermissions(): Promise<Notifications.PermissionStatus> {
+    try {
+      const { status } = await Notifications.getPermissionsAsync();
+      return status;
+    } catch (err) {
+      logError(err as Error, {
+        feature: 'local-notifications.get-permissions',
+      });
+      return Notifications.PermissionStatus.UNDETERMINED;
+    }
+  }
+
+  /**
+   * Request notification permissions
+   */
+  async requestPermissions(): Promise<boolean> {
+    try {
+      const { status } = await Notifications.requestPermissionsAsync();
+      return status === 'granted';
+    } catch (err) {
+      logError(err as Error, {
+        feature: 'local-notifications.request-permissions',
+      });
+      return false;
+    }
+  }
+
+  /**
+   * Handle notification response (called from notification provider)
+   */
+  async handleNotificationResponse(
+    response: Notifications.NotificationResponse,
+  ): Promise<void> {
+    try {
+      const { notification } = response;
+      const notificationData = notification.request.content.data;
+
+      // Mark notification as read if it's stored
+      const notificationId = notification.request.identifier;
+      if (notificationId) {
+        await notificationStorage.markAsRead(notificationId);
+      }
+
+      // Handle deep link navigation
+      if (notificationData) {
+        await deepLinkHandler.handleNotificationPress(notificationData);
+      }
+
+      info('Notification response handled successfully', {
+        feature: 'local-notifications.handle-response',
+        notificationId: notification.request.identifier,
+        hasData: !!notificationData,
+      });
+    } catch (err) {
+      logError(err as Error, {
+        feature: 'local-notifications.handle-response',
+        response,
+      });
+    }
+  }
+
+  /**
+   * Ensure manager is initialized
+   */
+  private async ensureInitialized(): Promise<void> {
+    if (!this.isInitialized) {
+      await this.initialize();
+    }
+  }
+}
+
+// Export singleton instance
+export const localNotificationManager = LocalNotificationManager.getInstance();