evaldoc 1.0.0

package/docs/THREAD_IMPLEMENTATION_GUIDE.md

@@ -0,0 +1,345 @@
+# Thread-Based Conversation System - Implementation Guide
+
+## Overview
+
+This guide covers the implementation of a WhatsApp-style thread-based conversation system where patients can maintain persistent conversations with multiple doctors using Google Sign-In.
+
+## Architecture Summary
+
+```
+Patient (Google Auth) ←→ Thread ←→ Doctor (Provider)
+         ↓                  ↓              ↓
+    patients/          threads/       providers/
+                    messages (subcollection)
+```
+
+## What's Been Created
+
+### 1. Frontend Changes
+
+#### [public/chat.html](public/chat.html)
+- ✅ Added Google Sign-In modal
+- ✅ Added Firebase Auth scripts
+- ✅ Added user info display in header
+
+#### [public/js/chat-threads.js](public/js/chat-threads.js) (NEW)
+- ✅ Google authentication flow
+- ✅ Thread-based messaging
+- ✅ Load conversation history
+- ✅ Real-time message display
+- ✅ Payment integration
+
+### 2. Backend Changes
+
+#### [functions/src/patient-api.js](functions/src/patient-api.js) (NEW)
+New API endpoints for patients:
+- `GET /api/patient/me` - Get patient profile
+- `POST /api/patient/create` - Create patient profile
+- `POST /api/patient/thread` - Get or create thread with doctor
+- `GET /api/patient/threads` - Get all patient threads
+- `GET /api/patient/thread/:threadId/messages` - Get messages
+- `POST /api/patient/message` - Send message
+- `POST /api/patient/thread/:threadId/read` - Mark as read
+
+### 3. Security Rules
+
+#### [firestore.rules](firestore.rules)
+- ✅ Added `patients` collection rules
+- ✅ Added `threads` collection rules
+- ✅ Added `messages` subcollection rules
+
+## Implementation Steps
+
+### Step 1: Enable Google Sign-In in Firebase Console
+
+1. Go to Firebase Console → Authentication → Sign-in method
+2. Enable **Google** provider
+3. Add your authorized domains:
+   - `localhost` (for testing)
+   - Your production domain (e.g., `evaldoc.com`)
+
+### Step 2: Update Firebase Functions
+
+Add the patient API to your main index.js:
+
+```javascript
+// In functions/src/index.js
+const { handlePatientAPI } = require("./patient-api");
+
+exports.api = functions
+  .runWith({
+    secrets: ['GEMINI_API_KEY', 'DEEPSEEK_API_KEY']
+  })
+  .https.onRequest(async (req, res) => {
+  res.set("Access-Control-Allow-Origin", "*");
+  res.set("Access-Control-Allow-Methods", "POST, GET, OPTIONS");
+  res.set("Access-Control-Allow-Headers", "Content-Type, Authorization");
+
+  if (req.method === "OPTIONS") {
+    res.status(204).send("");
+    return;
+  }
+
+  // ... existing routes ...
+
+  // Patient API routes
+  if (req.path.startsWith("/patient/")) {
+    const user = await requireAuth(req, res);
+    if (!user) return;
+    await handlePatientAPI(req, res, user);
+    return;
+  }
+
+  // ... rest of routes ...
+});
+```
+
+### Step 3: Update chat.html to use new script
+
+Change the script tag in [chat.html](public/chat.html:120):
+
+```html
+<!-- OLD -->
+<script src="/js/chat.js?v=3"></script>
+
+<!-- NEW -->
+<script src="/js/chat-threads.js?v=1"></script>
+```
+
+### Step 4: Deploy Firestore Rules
+
+```bash
+firebase deploy --only firestore:rules
+```
+
+### Step 5: Deploy Functions
+
+```bash
+cd functions
+npm install
+cd ..
+firebase deploy --only functions
+```
+
+### Step 6: Test the Flow
+
+1. Go to `localhost:3000/dr-john-cardiology` (or your doctor's handle)
+2. Try to send a message
+3. Should see "Sign in to continue" modal
+4. Click "Continue with Google"
+5. Sign in with Google account
+6. Message should send and AI should respond
+7. Refresh page - conversation should persist
+
+## Data Models
+
+### Patient Document
+```javascript
+// firestore: patients/{patientId}
+{
+  email: "john@gmail.com",
+  displayName: "John Doe",
+  photoURL: "https://...",
+  doctorIds: ["dr_john", "dr_jane"],
+  notificationsEnabled: true,
+  fcmToken: null,
+  createdAt: Timestamp,
+  lastActiveAt: Timestamp
+}
+```
+
+### Thread Document
+```javascript
+// firestore: threads/{thread_patientId_doctorId}
+{
+  // Patient info
+  patientId: "google_uid_xyz",
+  patientEmail: "john@gmail.com",
+  patientName: "John Doe",
+  patientPhoto: "https://...",
+
+  // Doctor info
+  doctorId: "dr_john",
+  doctorName: "Dr. John Smith",
+  doctorHandle: "dr-john-cardiology",
+
+  // Status
+  status: "active",
+  isEscalated: false,
+  doctorOverride: false,
+
+  // Last message
+  lastMessageAt: Timestamp,
+  lastMessageText: "Thank you...",
+  lastMessageRole: "patient",
+
+  // Counts
+  unreadByPatient: 0,
+  unreadByDoctor: 2,
+  messageCount: 15,
+
+  // Current
+  currentTopic: "medication_info_safety",
+
+  // Billing
+  isPaid: true,
+  paymentId: "pi_xxx",
+
+  createdAt: Timestamp,
+  updatedAt: Timestamp
+}
+```
+
+### Message Document
+```javascript
+// firestore: threads/{threadId}/messages/{messageId}
+{
+  threadId: "thread_googleuid_drjohn",
+  role: "patient", // patient, doctor, ai
+  message: "Hello doctor...",
+
+  // Doctor-specific
+  isDoctorManual: false,
+  doctorUserId: null,
+
+  // Read status
+  readByPatient: true,
+  readByDoctor: false,
+
+  // Safety
+  wasFiltered: false,
+  isAiGenerated: true,
+
+  createdAt: Timestamp
+}
+```
+
+## Next Steps (TODO)
+
+### Phase 2: Doctor Inbox Updates
+
+Update [public/app/inbox.html](public/app/inbox.html) and [inbox.js](public/app/inbox.js) to:
+1. Show threads instead of conversations
+2. Group by patient (not sessionId)
+3. Show patient name/email instead of sessionId
+4. Add "Reply" button for manual doctor responses
+
+### Phase 3: Doctor Manual Reply
+
+Add to inbox:
+```javascript
+// Enable doctor to reply manually
+POST /api/doctor/message
+Body: {
+  threadId: "thread_...",
+  message: "This is my response",
+  override: true // Disable AI for this thread
+}
+```
+
+### Phase 4: Web Push Notifications
+
+1. Add FCM (Firebase Cloud Messaging) to frontend
+2. Request notification permission
+3. Save FCM token to patient profile
+4. Send notification when new message arrives
+
+Example:
+```javascript
+// In patient-api.js, after AI responds
+const patient = await getPatient(thread.patientId);
+if (patient.fcmToken && patient.notificationsEnabled) {
+  await admin.messaging().send({
+    token: patient.fcmToken,
+    notification: {
+      title: `New message from ${thread.doctorName}`,
+      body: aiResponse.substring(0, 100)
+    }
+  });
+}
+```
+
+## Migration Strategy
+
+### Option A: Fresh Start (Recommended)
+- Keep existing `conversations` collection as-is
+- New chats use `threads` system
+- Old conversations remain in old dashboard
+- Clean separation
+
+### Option B: Gradual Migration
+- Add migration script to convert conversations → threads
+- Link by email/phone if available
+- Otherwise create anonymous patient profiles
+
+## Testing Checklist
+
+- [ ] Patient can sign in with Google
+- [ ] Patient profile created on first sign-in
+- [ ] Thread created when sending first message
+- [ ] Messages persist after refresh
+- [ ] AI responds correctly
+- [ ] Escalation works
+- [ ] Payment flow works (if enabled)
+- [ ] Doctor can see threads in inbox
+- [ ] Firestore rules prevent unauthorized access
+
+## Troubleshooting
+
+### "Unauthorized" error
+- Check Firebase Auth is enabled
+- Verify `Authorization: Bearer <token>` header is sent
+- Check Firestore rules are deployed
+
+### Messages not persisting
+- Check Firebase console → Firestore
+- Verify `threads` and `messages` collections exist
+- Check browser console for errors
+
+### Google Sign-In not working
+- Verify Google provider is enabled in Firebase Console
+- Check authorized domains include your testing domain
+- Clear browser cache/cookies
+
+## Performance Considerations
+
+1. **Message pagination**: Currently loads last 50 messages. Add pagination for longer threads.
+2. **Real-time updates**: Use Firestore `onSnapshot()` for live updates instead of polling.
+3. **Indexes**: Create composite indexes for queries:
+   ```
+   threads: (patientId, lastMessageAt DESC)
+   threads: (doctorId, lastMessageAt DESC)
+   ```
+
+## Security Notes
+
+1. All writes go through backend API (Firestore rules block direct writes)
+2. Patients can only read their own threads
+3. Doctors can only read threads where they are the doctor
+4. Use custom claims for doctor authentication
+5. All messages are authenticated via Firebase Auth
+
+## Cost Estimation
+
+**Firestore Operations per Chat:**
+- Patient sends message: 3 writes (message, thread update, patient update)
+- AI responds: 2 writes (message, thread update)
+- Load conversation: 1 read (thread) + N reads (messages)
+
+**Monthly costs (1000 active users, 10 messages each):**
+- Writes: 50,000 writes = $0.58
+- Reads: 100,000 reads = $0.18
+- Total: ~$0.76/month
+
+## Support
+
+For questions or issues:
+1. Check Firebase Console logs
+2. Check browser developer console
+3. Review Firestore rules
+4. Test API endpoints with Postman/curl
+
+---
+
+**Status**: Core implementation complete ✅
+**Next**: Update doctor inbox + manual replies + push notifications

package/docs/firebasefiles.md

@@ -0,0 +1,21 @@
+// Import the functions you need from the SDKs you need
+import { initializeApp } from "firebase/app";
+import { getAnalytics } from "firebase/analytics";
+// TODO: Add SDKs for Firebase products that you want to use
+// https://firebase.google.com/docs/web/setup#available-libraries
+
+// Your web app's Firebase configuration
+// For Firebase JS SDK v7.20.0 and later, measurementId is optional
+const firebaseConfig = {
+  apiKey: "AIzaSyCLkOkhDZhB2m9bO-VxNmvI4Y179DhjmcQ",
+  authDomain: "evaldocplatform.firebaseapp.com",
+  projectId: "evaldocplatform",
+  storageBucket: "evaldocplatform.firebasestorage.app",
+  messagingSenderId: "1028185105722",
+  appId: "1:1028185105722:web:4a306dc90dd8af8b2e9c03",
+  measurementId: "G-NPWYSPFSVG"
+};
+
+// Initialize Firebase
+const app = initializeApp(firebaseConfig);
+const analytics = getAnalytics(app);