vibefast-cli 0.6.2 → 0.7.1

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

@@ -1,45 +0,0 @@
-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

@@ -1,153 +0,0 @@
-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

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

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

@@ -1,38 +0,0 @@
-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

@@ -1,409 +0,0 @@
-/**
- * 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();