@cachly-dev/mcp-server 0.10.64 → 0.10.66

package/apps/travel-chaos-organizer/frontend/hooks/useInbox.ts

@@ -1,24 +0,0 @@
-import { useEffect, useState, useCallback } from "react";
-import { inboxApi, InboxItem } from "../lib/api";
-
-export function useInbox(statusFilter = "pending") {
-  const [items, setItems] = useState<InboxItem[]>([]);
-  const [loading, setLoading] = useState(true);
-  const [error, setError] = useState<string | null>(null);
-
-  const refresh = useCallback(async () => {
-    setLoading(true);
-    setError(null);
-    try {
-      setItems(await inboxApi.list(statusFilter));
-    } catch (e) {
-      setError(String(e));
-    } finally {
-      setLoading(false);
-    }
-  }, [statusFilter]);
-
-  useEffect(() => { refresh(); }, [refresh]);
-
-  return { items, loading, error, refresh };
-}

package/apps/travel-chaos-organizer/frontend/hooks/useNetworkSync.ts

@@ -1,60 +0,0 @@
-/**
- * Runs the offline queue drain whenever the app comes to foreground
- * or network connectivity is restored.
- *
- * Import once in the root layout — all other screens benefit automatically.
- */
-import { useEffect, useRef } from "react";
-import { AppState, AppStateStatus } from "react-native";
-import * as Network from "expo-network";
-import { drainQueue, processQueue, setQueueErrorCallback } from "../lib/offlineQueue";
-import { getAccessToken } from "../lib/auth";
-import { useToast } from "../components/ToastContext";
-
-const BASE_URL = process.env.EXPO_PUBLIC_API_URL!;
-
-async function authHeaders(): Promise<Record<string, string>> {
-  const token = await getAccessToken();
-  if (!token) return {};
-  return { Authorization: `Bearer ${token}` };
-}
-
-export function useNetworkSync(onSynced?: (result: { succeeded: number; failed: number }) => void) {
-  const appState = useRef<AppStateStatus>(AppState.currentState);
-  const wasOffline = useRef(false);
-  const { showToast } = useToast();
-
-  useEffect(() => {
-    setQueueErrorCallback((count) => {
-      showToast(`${count} gespeicherte Änderungen konnten nicht synchronisiert werden`, "error");
-    });
-    // Drain on foreground
-    const appStateSub = AppState.addEventListener("change", async (next) => {
-      if (appState.current.match(/inactive|background/) && next === "active") {
-        const result = await drainQueue(authHeaders, BASE_URL);
-        if (result.succeeded > 0) onSynced?.(result);
-      }
-      appState.current = next;
-    });
-
-    // Drain on network recovery by polling every 5 s (expo-network has no push listener)
-    const interval = setInterval(async () => {
-      if (appState.current !== "active") return;
-      const net = await Network.getNetworkStateAsync();
-      if (!net.isConnected) {
-        wasOffline.current = true;
-        return;
-      }
-      if (wasOffline.current) {
-        wasOffline.current = false;
-        const result = await processQueue(authHeaders, BASE_URL);
-        if (result.succeeded > 0) onSynced?.(result);
-      }
-    }, 5000);
-
-    return () => {
-      appStateSub.remove();
-      clearInterval(interval);
-    };
-  }, []);
-}

package/apps/travel-chaos-organizer/frontend/hooks/useTrips.ts

@@ -1,112 +0,0 @@
-import { useEffect, useState, useCallback } from "react";
-import * as Network from "expo-network";
-import { tripsApi, itemsApi, Trip, TripItem } from "../lib/api";
-import { upsertTrips, upsertItems, getLocalTrips, getLocalItems, deleteLocalItem } from "../lib/db";
-import { enqueue } from "../lib/offlineQueue";
-import { cancelItemReminders } from "../lib/notifications";
-
-export function useTrips() {
-  const [trips, setTrips] = useState<Trip[]>([]);
-  const [loading, setLoading] = useState(true);
-  const [error, setError] = useState<string | null>(null);
-
-  const sync = useCallback(async () => {
-    setLoading(true);
-    setError(null);
-    try {
-      const net = await Network.getNetworkStateAsync();
-      if (net.isConnected) {
-        const remote = await tripsApi.list();
-        upsertTrips(remote);
-        setTrips(remote);
-      } else {
-        setTrips(getLocalTrips());
-      }
-    } catch (e) {
-      setError(String(e));
-      setTrips(getLocalTrips());
-    } finally {
-      setLoading(false);
-    }
-  }, []);
-
-  useEffect(() => { sync(); }, [sync]);
-
-  async function createOffline(data: Pick<Trip, "name" | "description" | "start_date" | "end_date">) {
-    const net = await Network.getNetworkStateAsync();
-    if (net.isConnected) {
-      const trip = await tripsApi.create(data);
-      upsertTrips([trip]);
-      setTrips((prev) => [...prev, trip]);
-      return trip;
-    }
-    enqueue("POST", "/api/v1/trips", data);
-    const temp: Trip = { id: `temp-${Date.now()}`, user_id: "local", created_at: new Date().toISOString(), updated_at: new Date().toISOString(), ...data };
-    upsertTrips([temp]);
-    setTrips((prev) => [...prev, temp]);
-    return temp;
-  }
-
-  async function updateOffline(id: string, data: Partial<Pick<Trip, "name" | "description" | "start_date" | "end_date">>) {
-    const net = await Network.getNetworkStateAsync();
-    if (net.isConnected) {
-      const updated = await tripsApi.update(id, data);
-      upsertTrips([updated]);
-      setTrips((prev) => prev.map((t) => (t.id === id ? updated : t)));
-      return updated;
-    }
-    enqueue("PATCH", `/api/v1/trips/${id}`, data);
-    setTrips((prev) => prev.map((t) => (t.id === id ? { ...t, ...data } : t)));
-  }
-
-  async function deleteTrip(id: string) {
-    const net = await Network.getNetworkStateAsync();
-    if (net.isConnected) {
-      await tripsApi.delete(id);
-    } else {
-      enqueue("DELETE", `/api/v1/trips/${id}`, {});
-    }
-    setTrips((prev) => prev.filter((t) => t.id !== id));
-  }
-
-  return { trips, loading, error, refresh: sync, createOffline, updateOffline, deleteTrip };
-}
-
-export function useTripItems(tripId: string) {
-  const [items, setItems] = useState<TripItem[]>([]);
-  const [loading, setLoading] = useState(true);
-
-  const sync = useCallback(async () => {
-    setLoading(true);
-    try {
-      const net = await Network.getNetworkStateAsync();
-      if (net.isConnected) {
-        const remote = await itemsApi.list(tripId);
-        upsertItems(remote);
-        setItems(remote);
-      } else {
-        setItems(getLocalItems(tripId));
-      }
-    } catch {
-      setItems(getLocalItems(tripId));
-    } finally {
-      setLoading(false);
-    }
-  }, [tripId]);
-
-  useEffect(() => { sync(); }, [sync]);
-
-  async function deleteItem(itemId: string) {
-    const net = await Network.getNetworkStateAsync();
-    if (net.isConnected) {
-      await itemsApi.delete(tripId, itemId);
-    } else {
-      enqueue("DELETE", `/api/v1/trips/${tripId}/items/${itemId}`, {});
-    }
-    deleteLocalItem(itemId);
-    await cancelItemReminders(itemId);
-    setItems((prev) => prev.filter((i) => i.id !== itemId));
-  }
-
-  return { items, loading, refresh: sync, deleteItem };
-}

package/apps/travel-chaos-organizer/frontend/lib/api.ts

@@ -1,223 +0,0 @@
-import { getAccessToken } from "./auth";
-import { enqueueRequest } from "./offlineQueue";
-
-const BASE_URL = process.env.EXPO_PUBLIC_API_URL!;
-
-/** Default timeout for regular API calls (trips, items, users, etc.) */
-const DEFAULT_TIMEOUT_MS = 30_000;
-/** Extended timeout for AI parse calls (Ollama can be slow on first run) */
-const PARSE_TIMEOUT_MS = 120_000;
-
-export class ApiError extends Error {
-  constructor(
-    message: string,
-    public readonly status: number,
-    public readonly body: string,
-  ) {
-    super(message);
-    this.name = "ApiError";
-  }
-}
-
-async function authHeaders(): Promise<Record<string, string>> {
-  const token = await getAccessToken();
-  if (!token) throw new Error("Not authenticated");
-  return { Authorization: `Bearer ${token}`, "Content-Type": "application/json" };
-}
-
-async function request<T>(path: string, init: RequestInit = {}): Promise<T> {
-  const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), DEFAULT_TIMEOUT_MS);
-  try {
-    const headers = await authHeaders();
-    const res = await fetch(`${BASE_URL}${path}`, {
-      ...init,
-      headers: { ...headers, ...init.headers },
-      signal: controller.signal,
-    });
-    if (!res.ok) {
-      const body = await res.text();
-      throw new ApiError(`API ${res.status}: ${body}`, res.status, body);
-    }
-    return res.json() as Promise<T>;
-  } catch (err) {
-    if (err instanceof Error && err.name === "AbortError") {
-      throw new ApiError("Timeout: Server antwortet nicht", 408, "timeout");
-    }
-    // Network error (no status) — queue for offline retry
-    if (!(err instanceof ApiError) && init.method && ["POST","PATCH","DELETE"].includes(init.method)) {
-      const bodyObj = init.body ? (() => { try { return JSON.parse(init.body as string) as object; } catch { return undefined; } })() : undefined;
-      enqueueRequest(init.method as "POST" | "PATCH" | "DELETE", path, bodyObj);
-    }
-    throw err;
-  } finally {
-    clearTimeout(timer);
-  }
-}
-
-// ── Trips ──────────────────────────────────────────────────────────────────
-
-export type Trip = {
-  id: string;
-  user_id: string;
-  name: string;
-  description: string | null;
-  start_date: string | null;
-  end_date: string | null;
-  created_at: string;
-  updated_at: string;
-};
-
-export const tripsApi = {
-  list: () => request<Trip[]>("/api/v1/trips"),
-  get: (id: string) => request<Trip>(`/api/v1/trips/${id}`),
-  create: (data: Pick<Trip, "name" | "description" | "start_date" | "end_date">) =>
-    request<Trip>("/api/v1/trips", { method: "POST", body: JSON.stringify(data) }),
-  update: (id: string, data: Partial<Trip>) =>
-    request<Trip>(`/api/v1/trips/${id}`, { method: "PATCH", body: JSON.stringify(data) }),
-  delete: (id: string) => request<void>(`/api/v1/trips/${id}`, { method: "DELETE" }),
-  search: (q: string) => request<Trip[]>(`/api/v1/trips/search?q=${encodeURIComponent(q)}`),
-};
-
-// ── Trip Items ─────────────────────────────────────────────────────────────
-
-export type TripItem = {
-  id: string;
-  trip_id: string;
-  type: string;
-  title: string;
-  raw_text: string | null;
-  parsed_data: Record<string, unknown> | null;
-  event_at: string | null;
-  event_end_at: string | null;
-  booking_ref: string | null;
-  provider: string | null;
-  created_at: string;
-};
-
-export const itemsApi = {
-  list: (tripId: string) => request<TripItem[]>(`/api/v1/trips/${tripId}/items`),
-  delete: (tripId: string, itemId: string) =>
-    request<void>(`/api/v1/trips/${tripId}/items/${itemId}`, { method: "DELETE" }),
-};
-
-// ── Chaos Inbox ────────────────────────────────────────────────────────────
-
-export type InboxItem = {
-  id: string;
-  raw_content: string | null;
-  source: string | null;
-  status: string;
-  parsed_data: Record<string, unknown> | null;
-  created_at: string;
-};
-
-export const inboxApi = {
-  list: (status = "pending") => request<InboxItem[]>(`/api/v1/inbox?status_filter=${status}`),
-  assign: (inboxId: string, tripId: string, type = "other") =>
-    request<{ trip_item_id: string; title: string; event_at: string | null }>(`/api/v1/inbox/${inboxId}/assign`, {
-      method: "POST",
-      body: JSON.stringify({ trip_id: tripId, type }),
-    }),
-  reject: (inboxId: string) => request<void>(`/api/v1/inbox/${inboxId}`, { method: "DELETE" }),
-};
-
-// ── User / Plan ────────────────────────────────────────────────────────────
-
-export type UserPlan = {
-  id: string;
-  plan: "free" | "pro";
-  plan_expires_at: string | null;
-  free_daily_parses: number;
-  free_max_trips: number;
-  is_pro: boolean;
-  telegram_linked: boolean;
-};
-
-export const usersApi = {
-  me: () => request<UserPlan>("/api/v1/users/me"),
-  telegramPin: () => request<{ pin: string; expires_in_seconds: number }>("/api/v1/users/telegram-pin", { method: "POST" }),
-  telegramUnlink: () => request<{ ok: boolean }>("/api/v1/users/telegram-unlink", { method: "DELETE" }),
-};
-
-export type CacheStats = {
-  configured: boolean;
-  hits: number;
-  misses: number;
-  key_count: number;
-  hit_rate: number;
-  ttl_days: number;
-};
-
-export const cacheApi = {
-  stats: () => request<CacheStats>("/api/v1/cache/stats"),
-};
-
-// ── Parse ──────────────────────────────────────────────────────────────────
-
-export const mailApi = {
-  import: async (rawEmail: string, tripId?: string): Promise<unknown> => {
-    const token = await getAccessToken();
-    if (!token) throw new Error("Not authenticated");
-    const qs = tripId ? `?trip_id=${encodeURIComponent(tripId)}` : "";
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), PARSE_TIMEOUT_MS);
-    try {
-      const res = await fetch(`${BASE_URL}/api/v1/mail/import${qs}`, {
-        method: "POST",
-        headers: { Authorization: `Bearer ${token}`, "Content-Type": "text/plain" },
-        body: rawEmail,
-        signal: controller.signal,
-      });
-      if (!res.ok) {
-        const body = await res.text();
-        throw new ApiError(`Mail import failed: ${res.status}`, res.status, body);
-      }
-      return res.json();
-    } catch (err) {
-      if (err instanceof Error && err.name === "AbortError") {
-        throw new ApiError("Timeout: KI antwortet nicht", 408, "timeout");
-      }
-      throw err;
-    } finally {
-      clearTimeout(timer);
-    }
-  },
-};
-
-export async function parseFile(
-  fileUri: string,
-  mimeType: string,
-  fileName: string,
-  tripId?: string
-): Promise<unknown> {
-  const token = await getAccessToken();
-  if (!token) throw new Error("Not authenticated");
-
-  const form = new FormData();
-  form.append("file", { uri: fileUri, type: mimeType, name: fileName } as unknown as Blob);
-  if (tripId) form.append("trip_id", tripId);
-
-  const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), PARSE_TIMEOUT_MS);
-  try {
-    const res = await fetch(`${BASE_URL}/api/v1/parse/file`, {
-      method: "POST",
-      headers: { Authorization: `Bearer ${token}` },
-      body: form,
-      signal: controller.signal,
-    });
-    if (!res.ok) {
-      const body = await res.text();
-      throw new ApiError(`Parse failed: ${res.status}`, res.status, body);
-    }
-    return res.json();
-  } catch (err) {
-    if (err instanceof Error && err.name === "AbortError") {
-      throw new ApiError("Timeout: KI antwortet nicht", 408, "timeout");
-    }
-    throw err;
-  } finally {
-    clearTimeout(timer);
-  }
-}

package/apps/travel-chaos-organizer/frontend/lib/auth.ts

@@ -1,93 +0,0 @@
-import * as AuthSession from "expo-auth-session";
-import * as WebBrowser from "expo-web-browser";
-import AsyncStorage from "@react-native-async-storage/async-storage";
-
-// NOTE: maybeCompleteAuthSession() must also be called in app/auth.tsx
-// (the callback route). The call here is a belt-and-suspenders fallback.
-WebBrowser.maybeCompleteAuthSession();
-
-const KEYCLOAK_URL = process.env.EXPO_PUBLIC_KEYCLOAK_URL!;
-const REALM = process.env.EXPO_PUBLIC_KEYCLOAK_REALM!;
-const CLIENT_ID = process.env.EXPO_PUBLIC_KEYCLOAK_CLIENT_ID!;
-
-const discovery = {
-  authorizationEndpoint: `${KEYCLOAK_URL}/realms/${REALM}/protocol/openid-connect/auth`,
-  tokenEndpoint: `${KEYCLOAK_URL}/realms/${REALM}/protocol/openid-connect/token`,
-  revocationEndpoint: `${KEYCLOAK_URL}/realms/${REALM}/protocol/openid-connect/logout`,
-};
-
-const TOKEN_KEY = "tco_tokens";
-
-export let onAuthFailure: (() => void) | null = null;
-export function setAuthFailureCallback(cb: () => void) { onAuthFailure = cb; }
-
-export type Tokens = {
-  accessToken: string;
-  refreshToken: string;
-  expiresAt: number;
-};
-
-export async function login(): Promise<Tokens | null> {
-  const redirectUri = AuthSession.makeRedirectUri({ scheme: "tco", path: "auth" });
-  // Let expo-auth-session generate a cryptographically secure code verifier.
-  // Manual generation with Math.random() + BASE64 produces non-URL-safe chars
-  // (+, /, =) that are invalid in PKCE and cause Keycloak to reject the exchange.
-  const request = new AuthSession.AuthRequest({
-    clientId: CLIENT_ID,
-    redirectUri,
-    scopes: ["openid", "profile", "email", "offline_access"],
-    usePKCE: true,
-  });
-
-  const result = await request.promptAsync(discovery);
-  if (result.type !== "success") return null;
-
-  const tokenResult = await AuthSession.exchangeCodeAsync(
-    {
-      clientId: CLIENT_ID,
-      code: result.params.code,
-      redirectUri,
-      extraParams: { code_verifier: request.codeVerifier! },
-    },
-    discovery
-  );
-
-  const tokens: Tokens = {
-    accessToken: tokenResult.accessToken,
-    refreshToken: tokenResult.refreshToken!,
-    expiresAt: Date.now() + (tokenResult.expiresIn ?? 300) * 1000,
-  };
-  await AsyncStorage.setItem(TOKEN_KEY, JSON.stringify(tokens));
-  return tokens;
-}
-
-export async function getAccessToken(): Promise<string | null> {
-  const raw = await AsyncStorage.getItem(TOKEN_KEY);
-  if (!raw) return null;
-  const tokens: Tokens = JSON.parse(raw);
-
-  if (Date.now() < tokens.expiresAt - 30_000) return tokens.accessToken;
-
-  // refresh
-  try {
-    const refreshed = await AuthSession.refreshAsync(
-      { clientId: CLIENT_ID, refreshToken: tokens.refreshToken },
-      discovery
-    );
-    const updated: Tokens = {
-      accessToken: refreshed.accessToken,
-      refreshToken: refreshed.refreshToken ?? tokens.refreshToken,
-      expiresAt: Date.now() + (refreshed.expiresIn ?? 300) * 1000,
-    };
-    await AsyncStorage.setItem(TOKEN_KEY, JSON.stringify(updated));
-    return updated.accessToken;
-  } catch {
-    await AsyncStorage.removeItem(TOKEN_KEY);
-    onAuthFailure?.();
-    return null;
-  }
-}
-
-export async function logout(): Promise<void> {
-  await AsyncStorage.removeItem(TOKEN_KEY);
-}

package/apps/travel-chaos-organizer/frontend/lib/db.ts

@@ -1,86 +0,0 @@
-/**
- * Local SQLite — offline mirror of trips and trip_items.
- * Syncs from API when online, reads locally when offline.
- */
-import * as SQLite from "expo-sqlite";
-import { Trip, TripItem } from "./api";
-
-const db = SQLite.openDatabaseSync("tco.db");
-
-export function initDb(): void {
-  db.execSync(`
-    CREATE TABLE IF NOT EXISTS trips (
-      id TEXT PRIMARY KEY,
-      user_id TEXT,
-      name TEXT NOT NULL,
-      description TEXT,
-      start_date TEXT,
-      end_date TEXT,
-      created_at TEXT,
-      updated_at TEXT,
-      synced_at INTEGER
-    );
-
-    CREATE TABLE IF NOT EXISTS trip_items (
-      id TEXT PRIMARY KEY,
-      trip_id TEXT NOT NULL,
-      type TEXT,
-      title TEXT,
-      raw_text TEXT,
-      parsed_data TEXT,
-      event_at TEXT,
-      event_end_at TEXT,
-      booking_ref TEXT,
-      provider TEXT,
-      created_at TEXT,
-      synced_at INTEGER
-    );
-  `);
-}
-
-export function upsertTrips(trips: Trip[]): void {
-  const now = Date.now();
-  for (const t of trips) {
-    db.runSync(
-      `INSERT OR REPLACE INTO trips
-        (id, user_id, name, description, start_date, end_date, created_at, updated_at, synced_at)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
-      [t.id, t.user_id, t.name, t.description ?? null, t.start_date ?? null,
-       t.end_date ?? null, t.created_at, t.updated_at, now]
-    );
-  }
-}
-
-export function upsertItems(items: TripItem[]): void {
-  const now = Date.now();
-  for (const i of items) {
-    db.runSync(
-      `INSERT OR REPLACE INTO trip_items
-        (id, trip_id, type, title, raw_text, parsed_data, event_at, event_end_at, booking_ref, provider, created_at, synced_at)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
-      [i.id, i.trip_id, i.type, i.title, i.raw_text ?? null,
-       i.parsed_data ? JSON.stringify(i.parsed_data) : null,
-       i.event_at ?? null, i.event_end_at ?? null, i.booking_ref ?? null,
-       i.provider ?? null, i.created_at, now]
-    );
-  }
-}
-
-export function getLocalTrips(): Trip[] {
-  return db.getAllSync<Trip>("SELECT * FROM trips ORDER BY start_date ASC");
-}
-
-export function deleteLocalItem(itemId: string): void {
-  db.runSync("DELETE FROM trip_items WHERE id = ?", [itemId]);
-}
-
-export function getLocalItems(tripId: string): TripItem[] {
-  const rows = db.getAllSync<Record<string, unknown>>(
-    "SELECT * FROM trip_items WHERE trip_id = ? ORDER BY event_at ASC",
-    [tripId]
-  );
-  return rows.map((r) => ({
-    ...r,
-    parsed_data: r.parsed_data ? JSON.parse(r.parsed_data as string) : null,
-  })) as TripItem[];
-}

package/apps/travel-chaos-organizer/frontend/lib/fileCache.ts

@@ -1,54 +0,0 @@
-/**
- * Local file cache — downloads attachments and stores them in expo-file-system.
- * Tickets, PDFs and QR-source files are available offline after first fetch.
- */
-import * as FileSystem from "expo-file-system";
-
-const CACHE_DIR = `${FileSystem.documentDirectory}tco-cache/`;
-
-export async function ensureCacheDir(): Promise<void> {
-  const info = await FileSystem.getInfoAsync(CACHE_DIR);
-  if (!info.exists) await FileSystem.makeDirectoryAsync(CACHE_DIR, { intermediates: true });
-}
-
-function cacheKey(url: string): string {
-  // stable filename from URL — replace slashes/colons so it's a valid filename
-  return url.replace(/[^a-zA-Z0-9._-]/g, "_");
-}
-
-export async function getCachedPath(url: string): Promise<string | null> {
-  const path = CACHE_DIR + cacheKey(url);
-  const info = await FileSystem.getInfoAsync(path);
-  return info.exists ? path : null;
-}
-
-export async function downloadAndCache(
-  url: string,
-  authToken: string
-): Promise<string> {
-  await ensureCacheDir();
-  const path = CACHE_DIR + cacheKey(url);
-
-  const info = await FileSystem.getInfoAsync(path);
-  if (info.exists) return path;
-
-  const result = await FileSystem.downloadAsync(url, path, {
-    headers: { Authorization: `Bearer ${authToken}` },
-  });
-
-  if (result.status !== 200) {
-    await FileSystem.deleteAsync(path, { idempotent: true });
-    throw new Error(`Download failed: ${result.status}`);
-  }
-
-  return path;
-}
-
-export async function clearCache(): Promise<void> {
-  await FileSystem.deleteAsync(CACHE_DIR, { idempotent: true });
-}
-
-export async function cacheSizeBytes(): Promise<number> {
-  const info = await FileSystem.getInfoAsync(CACHE_DIR, { size: true });
-  return (info.exists && "size" in info) ? (info.size ?? 0) : 0;
-}

package/apps/travel-chaos-organizer/frontend/lib/haptics.ts

@@ -1,13 +0,0 @@
-/**
- * Centralised haptic helpers — one import, consistent feel across the app.
- * expo-haptics is a soft dependency; if unavailable (web/simulator) we no-op.
- */
-import * as Haptics from "expo-haptics";
-
-export const haptics = {
-  tap: () => Haptics.impactAsync(Haptics.ImpactFeedbackStyle.Light),
-  confirm: () => Haptics.impactAsync(Haptics.ImpactFeedbackStyle.Medium),
-  success: () => Haptics.notificationAsync(Haptics.NotificationFeedbackType.Success),
-  error: () => Haptics.notificationAsync(Haptics.NotificationFeedbackType.Error),
-  warning: () => Haptics.notificationAsync(Haptics.NotificationFeedbackType.Warning),
-};