Merge main into dev: resolve all conflicts, keep dev improvements

IMPROVEMENTS.md

@@ -0,0 +1,335 @@
+# MirrorMatch - Improvement Ideas & Future Enhancements
+
+This document contains ideas, suggestions, and potential enhancements to make MirrorMatch better, faster, and more professional.
+
+## 🚀 Performance Optimizations
+
+### Database & Query Optimization
+- [ ] **Add database indexes** - Create indexes on frequently queried fields (`Photo.createdAt`, `User.points`) to speed up queries
+  - **Why:** As your database grows, queries without indexes become exponentially slower. Indexes can make queries 10-100x faster, especially for leaderboard and photo listing queries that run frequently.
+
+- [ ] **Implement pagination** - Add pagination to photos list to handle large datasets efficiently
+  - **Why:** Loading all photos at once becomes slow and memory-intensive as you scale. Pagination improves load times, reduces server load, and provides better UX by showing manageable chunks of data.
+
+- [ ] **Database connection pooling** - Configure connection pooling to optimize database connections
+  - **Why:** Without pooling, each request creates a new database connection, which is expensive. Connection pooling reuses connections, reducing latency and allowing your app to handle more concurrent users.
+
+- [ ] **Cache leaderboard data** - Use Redis or in-memory cache with TTL (1-5 minutes) to reduce database load
+  - **Why:** The leaderboard is queried frequently but changes infrequently. Caching it reduces database load by 90%+ and makes the page load instantly, improving user experience significantly.
+
+- [ ] **Lazy loading for photos** - Load images as user scrolls to improve initial page load
+  - **Why:** Loading all images upfront is slow and wastes bandwidth. Lazy loading makes pages load 3-5x faster and reduces server costs, especially important for mobile users.
+
+- [ ] **Query optimization** - Use `select` to fetch only needed fields, reducing data transfer
+  - **Why:** Fetching entire records when you only need a few fields wastes bandwidth and memory. This simple change can reduce data transfer by 50-80% and speed up queries.
+
+### Frontend Performance
+- [ ] **Image optimization** - Use Next.js Image component with proper sizing and automatic format optimization
+  - **Why:** Unoptimized images can be 5-10x larger than needed. Next.js Image automatically serves WebP/AVIF formats and resizes images, reducing bandwidth by 60-80% and improving page load times dramatically.
+
+- [ ] **Image lazy loading** - Implement lazy loading for photo thumbnails to improve page load times
+  - **Why:** Loading all thumbnails at once slows initial page load. Lazy loading defers off-screen images, making pages load 2-3x faster and improving Core Web Vitals scores.
+
+- [ ] **Virtual scrolling** - Use virtual scrolling for large photo lists to maintain performance
+  - **Why:** Rendering hundreds of DOM elements causes lag. Virtual scrolling only renders visible items, keeping the UI smooth even with thousands of photos.
+
+- [ ] **Code splitting** - Implement route-based code splitting to reduce initial bundle size
+  - **Why:** Large JavaScript bundles slow initial page load. Code splitting loads only what's needed per route, reducing initial bundle by 40-60% and improving Time to Interactive.
+
+- [ ] **React.memo() optimization** - Wrap expensive components with React.memo() to prevent unnecessary re-renders
+  - **Why:** Unnecessary re-renders waste CPU and cause UI lag. Memoization prevents re-renders when props haven't changed, making the UI more responsive, especially on lower-end devices.
+
+- [ ] **Bundle size optimization** - Analyze and optimize bundle size using webpack-bundle-analyzer
+  - **Why:** Large bundles slow page loads and hurt SEO. Identifying and removing unused code can reduce bundle size by 20-40%, improving load times and user experience.
+
+- [ ] **Progressive image loading** - Show blur placeholder while images load, then transition to full image
+  - **Why:** Blank spaces while images load feel slow. Progressive loading provides immediate visual feedback, making the app feel faster and more polished, improving perceived performance.
+
+### API & Backend
+- [ ] **Rate limiting** - Add rate limiting to prevent abuse and protect API endpoints
+  - **Why:** Without rate limiting, malicious users can overwhelm your server or abuse features. Rate limiting protects against DDoS, prevents spam, and ensures fair resource usage for all users.
+
+- [ ] **Request caching** - Implement caching for static data and frequently accessed endpoints
+  - **Why:** Many API calls return the same data repeatedly. Caching reduces database queries by 70-90%, lowers server costs, and makes responses 10-100x faster.
+
+- [ ] **Compression middleware** - Add gzip/brotli compression to reduce response sizes
+  - **Why:** Text responses (JSON, HTML) compress by 70-90%. Compression reduces bandwidth costs, speeds up transfers (especially on mobile), and improves user experience with minimal effort.
+
+- [ ] **Email queue system** - Use Bull/BullMQ to queue email sending and prevent blocking
+  - **Why:** Sending emails synchronously blocks requests and can cause timeouts. A queue system makes email sending non-blocking, improves response times, and provides retry logic for failed emails.
+
+- [ ] **Batch photo uploads** - Optimize bulk photo upload operations for better performance
+  - **Why:** Uploading photos one-by-one is slow and inefficient. Batch uploads reduce overhead, improve upload speeds by 2-3x, and provide better progress feedback to users.
+
+- [ ] **CDN integration** - Add CDN for static assets and uploaded images to reduce server load
+  - **Why:** Serving files from your server uses bandwidth and slows responses. A CDN serves files from locations closer to users, reducing latency by 50-80% and offloading server load.
+
+## 🎨 UI/UX Enhancements
+
+### User Interface
+- [ ] **Dark mode support** - Add dark mode toggle with user preference persistence
+  - **Why:** Many users prefer dark mode for reduced eye strain, especially in low-light. It's become an expected feature and can increase user satisfaction and retention.
+
+- [ ] **Mobile responsiveness** - Improve mobile experience with better touch targets and swipe gestures
+  - **Why:** A significant portion of users access from mobile. Poor mobile UX leads to frustration and abandonment. Better touch targets and gestures make the app feel native and professional.
+
+- [ ] **Loading skeletons** - Replace blank screens with loading skeletons for better perceived performance
+  - **Why:** Blank screens make the app feel broken or slow. Skeletons show structure immediately, making wait times feel shorter and the app more responsive, improving user confidence.
+
+- [ ] **Toast notifications** - Implement toast notifications for user feedback (success, error, info)
+  - **Why:** Users need clear feedback for their actions. Toast notifications are non-intrusive, provide immediate feedback, and improve UX by clearly communicating success/error states.
+
+- [ ] **Smooth page transitions** - Add smooth transitions between pages for better user experience
+  - **Why:** Abrupt page changes feel jarring. Smooth transitions create a polished, professional feel and make navigation feel faster and more cohesive.
+
+- [ ] **Inline form validation** - Show validation errors inline as user types for better feedback
+  - **Why:** Waiting until form submission to show errors is frustrating. Inline validation provides immediate feedback, reduces errors, and improves form completion rates.
+
+- [ ] **Keyboard navigation** - Add full keyboard navigation support for accessibility
+  - **Why:** Keyboard navigation is essential for accessibility (WCAG compliance) and power users. It makes your app usable for people with disabilities and improves efficiency for all users.
+
+- [ ] **Drag-and-drop uploads** - Allow users to drag and drop photos for easier uploads
+  - **Why:** Drag-and-drop is faster and more intuitive than clicking "Choose File". It's a modern UX pattern users expect and can increase upload engagement.
+
+- [ ] **Empty states** - Create better empty states for when there are no photos, guesses, etc.
+  - **Why:** Empty screens confuse users. Well-designed empty states guide users on what to do next, reduce confusion, and make the app feel more polished and helpful.
+
+- [ ] **Animations and micro-interactions** - Add subtle animations to improve user engagement
+  - **Why:** Subtle animations provide visual feedback, make interactions feel responsive, and create a premium, polished feel that increases user satisfaction and engagement.
+
+- [ ] **Infinite scroll** - Implement infinite scroll for photos list instead of pagination
+  - **Why:** Infinite scroll feels more modern and seamless, especially on mobile. It reduces friction and can increase engagement by making it easier to browse through photos.
+
+- [ ] **Photo filters and search** - Add filtering and search functionality to find photos easily
+  - **Why:** As the photo library grows, finding specific photos becomes difficult. Filters and search help users quickly find what they're looking for, improving usability and engagement.
+
+### User Experience
+- [ ] **Onboarding tour** - Create interactive tour for new users explaining key features
+  - **Why:** New users often don't understand how to use the app. An onboarding tour reduces confusion, increases feature discovery, and improves user retention by helping users get value quickly.
+
+- [ ] **Remember me option** - Add "Remember me" checkbox to login for longer session duration
+  - **Why:** Frequent logouts frustrate users. A "Remember me" option improves convenience, reduces friction, and increases user satisfaction, especially for regular users.
+
+- [ ] **Guess history display** - Show user's guess history for each photo (correct/wrong attempts)
+  - **Why:** Users want to see their past attempts. Showing guess history provides context, helps users learn, and adds transparency that increases trust and engagement.
+
+- [ ] **Already guessed indicator** - Display clear indicator when user has already guessed a photo
+  - **Why:** Without indicators, users waste time trying to guess photos they've already attempted. Clear indicators prevent confusion and improve efficiency.
+
+- [ ] **Photo tags system** - Allow users to tag photos for better organization and filtering
+  - **Why:** Tags help organize and categorize photos, making them easier to find and filter. This improves discoverability and allows for better content organization as the library grows.
+
+- [ ] **Photo descriptions/clues** - Add optional descriptions or clues to photos for hints
+  - **Why:** Some photos are too difficult without context. Optional clues make the game more accessible, increase engagement, and allow for more creative photo challenges.
+
+- [ ] **Confirmation dialogs** - Add confirmation dialogs for destructive actions (delete, etc.)
+  - **Why:** Accidental deletions are frustrating and can't be undone. Confirmation dialogs prevent mistakes, protect user data, and reduce support requests from accidental actions.
+
+- [ ] **Photo filtering** - Add filters to show: unguessed photos, correct guesses, wrong guesses, and photos by specific users
+  - **Why:** Users want to focus on specific subsets of photos. Filtering helps users find unguessed photos to play, review their performance, or follow specific uploaders, significantly improving usability.
+
+## 🔒 Security Improvements
+
+- [ ] **CSRF protection** - Implement CSRF tokens for all state-changing operations
+  - **Why:** CSRF attacks can trick users into performing unwanted actions. CSRF protection is a security best practice that prevents unauthorized state changes and protects user accounts.
+
+- [ ] **Input sanitization** - Sanitize all user inputs to prevent XSS attacks
+  - **Why:** Malicious scripts in user input can steal data or hijack sessions. Input sanitization prevents XSS attacks, protects user data, and is essential for any app accepting user input.
+
+- [ ] **File type validation** - Validate actual file content (not just extension) to prevent malicious uploads
+  - **Why:** Attackers can rename malicious files with safe extensions. Content validation ensures only legitimate image files are uploaded, preventing security vulnerabilities and server compromise.
+
+- [ ] **Virus scanning** - Add virus scanning for uploaded files before storing
+  - **Why:** Malicious files can harm your server or other users. Virus scanning protects your infrastructure and users, especially important if files are shared or downloaded by others.
+
+- [ ] **Session timeout** - Implement automatic session timeout for inactive users
+  - **Why:** Long-lived sessions increase security risk if devices are compromised. Session timeouts reduce risk of unauthorized access and are a security best practice for sensitive applications.
+
+- [ ] **Security headers** - Add security headers (CSP, HSTS, X-Frame-Options, etc.)
+  - **Why:** Security headers prevent common attacks (clickjacking, XSS, MITM). They're easy to implement, provide significant security benefits, and are recommended by security standards.
+
+- [ ] **Audit logging** - Log all admin actions for security auditing and compliance
+  - **Why:** Admin actions can have significant impact. Audit logs provide accountability, help detect unauthorized access, and are essential for security compliance and incident investigation.
+
+## 📊 Features & Functionality
+
+### Game Mechanics
+- [ ] **Streak tracking** - Track consecutive correct guesses and display current streak
+  - **Why:** Streaks add excitement and encourage daily engagement. They create a sense of achievement and competition, increasing user retention and making the game more addictive.
+
+- [ ] **Achievements/badges system** - Create achievement system with badges for milestones
+  - **Why:** Achievements provide goals and recognition. They increase engagement, encourage exploration of features, and create a sense of progression that keeps users coming back.
+
+- [ ] **Hints system** - Allow optional hints for photos (earn fewer points when using hints)
+  - **Why:** Some photos are too difficult, leading to frustration. Hints make the game more accessible while still rewarding skill, increasing engagement and reducing abandonment.
+
+### Social Features
+- [ ] **Photo comments** - Allow users to comment on photos
+  - **Why:** Comments add social interaction and context. They increase engagement, create community, and make photos more interesting by adding discussion and stories.
+
+- [ ] **Reactions/emojis** - Add emoji reactions to photos for quick feedback
+  - **Why:** Reactions are quick, low-friction ways to engage. They increase interaction rates, add fun, and provide feedback to uploaders without requiring comments.
+
+- [ ] **User mentions** - Support @username mentions in comments
+  - **Why:** Mentions notify users and create conversations. They increase engagement, enable discussions, and help build community by connecting users.
+
+- [ ] **Activity feed** - Display recent activity feed (guesses, uploads, achievements)
+  - **Why:** Activity feeds show what's happening in real-time. They increase engagement, help users discover new content, and create a sense of community and activity.
+
+### Admin Features
+- [ ] **User activity logs dashboard** - Create admin dashboard showing user activity logs
+  - **Why:** Admins need visibility into user behavior. Activity logs help identify issues, understand usage patterns, detect abuse, and make data-driven decisions about the platform.
+
+- [ ] **Analytics dashboard** - Build analytics dashboard showing uploads, guesses, engagement metrics
+  - **Why:** Data-driven decisions require visibility. Analytics help understand what's working, identify trends, measure growth, and optimize features based on actual usage.
+
+- [ ] **System health monitoring** - Add system health monitoring and status page
+  - **Why:** Proactive monitoring prevents downtime. Health checks help catch issues before users notice, reduce support requests, and provide transparency about system status.
+
+- [ ] **Backup/export functionality** - Create tools to backup and export data
+  - **Why:** Data loss is catastrophic. Backups protect against disasters, and export functionality helps with migrations, compliance, and gives users control over their data.
+
+### Photo Management
+- [ ] **Photo editing tools** - Add basic editing (crop, rotate, filters) before upload
+  - **Why:** Users often need to adjust photos before uploading. Built-in editing reduces friction, improves photo quality, and eliminates the need for external editing tools.
+
+- [ ] **Improved duplicate detection** - Enhance duplicate photo detection beyond hash matching
+  - **Why:** Current hash matching only catches exact duplicates. Better detection (visual similarity) prevents near-duplicates, keeps content fresh, and improves user experience.
+
+- [ ] **Photo tagging system** - Implement tagging system for better organization
+  - **Why:** Tags enable better organization and discovery. They make it easier to find photos, create themed collections, and improve search functionality as content grows.
+
+- [ ] **Photo search functionality** - Add full-text search for photos by tags, descriptions, answers
+  - **Why:** As the library grows, finding photos becomes difficult. Search enables quick discovery, improves usability, and is essential for a good user experience at scale.
+
+- [ ] **Photo archiving** - Allow archiving old photos while keeping them accessible
+  - **Why:** Old photos clutter the main view but shouldn't be deleted. Archiving keeps content organized, maintains history, and improves the browsing experience for active content.
+
+- [ ] **Photo approval workflow** - Add optional admin approval workflow (can be toggled on/off)
+  - **Why:** Content moderation ensures quality and safety. An approval workflow lets admins control what goes public, prevents inappropriate content, and maintains content standards.
+
+## 🧪 Testing & Quality
+
+- [ ] **Increase test coverage** - Expand test coverage to all critical paths and edge cases
+  - **Why:** Bugs in production are expensive and damage trust. Comprehensive tests catch issues early, reduce regressions, and give confidence when making changes.
+
+- [ ] **E2E tests** - Add end-to-end tests using Playwright or Cypress
+  - **Why:** Unit tests don't catch integration issues. E2E tests verify the full user flow works, catch real-world bugs, and prevent breaking changes from reaching users.
+
+- [ ] **Visual regression testing** - Implement visual regression testing to catch UI changes
+  - **Why:** UI bugs are easy to miss in code review. Visual regression tests catch unintended visual changes, ensure consistency, and save time in QA.
+
+- [ ] **Performance testing** - Add Lighthouse CI for continuous performance monitoring
+  - **Why:** Performance degrades over time. Automated performance testing catches regressions early, ensures good Core Web Vitals, and maintains fast user experience.
+
+- [ ] **Load testing** - Create load testing scenarios to test system under stress
+  - **Why:** Systems behave differently under load. Load testing reveals bottlenecks, ensures the app can handle traffic spikes, and prevents crashes during high usage.
+
+- [ ] **API integration tests** - Add comprehensive integration tests for all API routes
+  - **Why:** API bugs affect all clients. Integration tests verify API contracts, catch breaking changes, and ensure APIs work correctly with the database and auth.
+
+- [ ] **Accessibility testing** - Implement automated accessibility testing (a11y)
+  - **Why:** Accessibility is a legal requirement and moral obligation. Automated testing catches a11y issues early, ensures WCAG compliance, and makes the app usable for everyone.
+
+- [ ] **Error boundaries** - Add React error boundaries to gracefully handle component errors
+  - **Why:** One component error shouldn't crash the entire app. Error boundaries isolate failures, show helpful error messages, and keep the rest of the app functional.
+
+- [ ] **Error logging and monitoring** - Create comprehensive error logging and monitoring system
+  - **Why:** You can't fix what you can't see. Error monitoring catches production bugs, provides context for debugging, and helps prioritize fixes based on impact.
+
+## 🔧 Technical Improvements
+
+### Architecture
+- [ ] **Microservices migration** - Consider migrating to microservices if scale requires it
+  - **Why:** Monoliths become hard to scale and maintain at large scale. Microservices enable independent scaling, faster deployments, and better fault isolation, but only if needed.
+
+- [ ] **Event-driven architecture** - Implement event-driven architecture for notifications
+  - **Why:** Tight coupling makes systems brittle. Event-driven architecture decouples components, improves scalability, and makes it easier to add new features without modifying existing code.
+
+- [ ] **Message queue** - Add message queue (RabbitMQ, Redis Queue) for async operations
+  - **Why:** Synchronous operations block requests. Message queues enable async processing, improve response times, provide retry logic, and handle traffic spikes better.
+
+- [ ] **GraphQL API** - Consider GraphQL API for more flexible querying
+  - **Why:** REST APIs often over-fetch or under-fetch data. GraphQL lets clients request exactly what they need, reduces bandwidth, and simplifies frontend development.
+
+- [ ] **API versioning** - Implement API versioning for backward compatibility
+  - **Why:** API changes break clients. Versioning allows gradual migration, prevents breaking changes, and enables supporting multiple client versions simultaneously.
+
+- [ ] **Health check endpoints** - Add health check endpoints for monitoring
+  - **Why:** Monitoring systems need to check if the app is healthy. Health endpoints enable automated monitoring, load balancer health checks, and quick status verification.
+
+- [ ] **Monitoring and alerting** - Create comprehensive monitoring and alerting system
+  - **Why:** Issues caught early are easier to fix. Monitoring provides visibility, alerts notify of problems immediately, and helps maintain uptime and performance.
+
+### Code Quality
+- [ ] **ESLint strict rules** - Add stricter ESLint rules for better code quality
+  - **Why:** Code quality issues lead to bugs. Stricter linting catches problems early, enforces best practices, and maintains consistent code style across the team.
+
+- [ ] **Prettier formatting** - Implement Prettier for consistent code formatting
+  - **Why:** Inconsistent formatting wastes time in reviews. Prettier automates formatting, eliminates style debates, and ensures consistent code across the codebase.
+
+- [ ] **Pre-commit hooks** - Add Husky pre-commit hooks to run linters and tests
+  - **Why:** Catching issues before commit saves time. Pre-commit hooks prevent bad code from entering the repo, enforce quality standards, and reduce CI failures.
+
+- [ ] **Component library/storybook** - Create component library with Storybook documentation
+  - **Why:** Reusable components reduce duplication. Storybook documents components, enables isolated development, and helps maintain design consistency.
+
+- [ ] **TypeScript strict mode** - Enable TypeScript strict mode for better type safety
+  - **Why:** Type errors cause runtime bugs. Strict mode catches more errors at compile time, improves code quality, and provides better IDE support and refactoring safety.
+
+- [ ] **Error tracking** - Integrate error tracking (Sentry, LogRocket) for production monitoring
+  - **Why:** Production errors are hard to debug without context. Error tracking provides stack traces, user context, and helps prioritize and fix bugs quickly.
+
+- [ ] **Performance monitoring** - Add performance monitoring (New Relic, Datadog)
+  - **Why:** Slow performance hurts user experience. Performance monitoring identifies bottlenecks, tracks metrics over time, and helps optimize critical paths.
+
+### DevOps & Infrastructure
+- [ ] **CI/CD pipeline** - Set up continuous integration and deployment pipeline
+  - **Why:** Manual deployments are error-prone and slow. CI/CD automates testing and deployment, reduces human error, enables faster releases, and improves confidence in changes.
+
+- [ ] **Automated deployments** - Implement automated deployments on merge to main
+  - **Why:** Manual deployments delay releases and can be forgotten. Automation ensures consistent deployments, reduces downtime, and enables rapid iteration.
+
+- [ ] **Blue-green deployments** - Set up blue-green deployment strategy for zero downtime
+  - **Why:** Deployments cause downtime and risk. Blue-green deployments enable zero-downtime updates, instant rollbacks, and reduce deployment risk significantly.
+
+- [ ] **Database migration strategy** - Create proper database migration strategy and rollback plan
+  - **Why:** Database changes are risky and hard to undo. A migration strategy ensures safe, reversible changes and prevents data loss or corruption during updates.
+
+- [ ] **Staging environment** - Create staging environment for testing before production
+  - **Why:** Testing in production is dangerous. Staging mirrors production, allows safe testing, and catches issues before they affect real users.
+
+- [ ] **Automated backups** - Implement automated database and file backups
+  - **Why:** Data loss is catastrophic. Automated backups protect against disasters, enable recovery, and are essential for any production system.
+
+- [ ] **Monitoring and logging** - Set up ELK stack or Grafana for centralized logging and monitoring
+  - **Why:** Logs are essential for debugging and monitoring. Centralized logging makes logs searchable, enables alerting, and provides visibility into system behavior.
+
+- [ ] **Container orchestration** - Set up Docker and Kubernetes for container orchestration
+  - **Why:** Containers provide consistency and scalability. Kubernetes enables easy scaling, rolling updates, and manages infrastructure, making deployment and operations easier.
+
+---
+
+## Priority Recommendations
+
+### High Priority (Quick Wins)
+1. **Image Optimization** - Use Next.js Image component for automatic optimization
+3. **Loading States** - Add loading skeletons for better UX
+4. **Toast Notifications** - Implement toast notifications for user feedback
+5. **Error Boundaries** - Add error boundaries for graceful error handling
+6. **Rate Limiting** - Add rate limiting to prevent abuse
+
+### Medium Priority (Significant Impact)
+1. **Caching** - Implement Redis caching for leaderboard and frequently accessed data
+2. **Dark Mode** - Add dark mode support for user preference
+3. **Search Functionality** - Add photo search and filtering capabilities
+4. **Achievements System** - Implement achievements/badges for increased engagement
+5. **Analytics Dashboard** - Create admin analytics dashboard for insights
+
+### Low Priority (Nice to Have)
+1. **Social Features** - Add comments, reactions, and activity feed
+2. **Advanced Gamification** - Implement levels, ranks, and advanced gamification features
+
+---
+
+**Note:** This is a living document. Add new ideas as they come up, and mark items as completed when implemented.

app/api/photos/upload/route.ts

@@ -93,6 +93,7 @@ export async function POST(req: NextRequest) {
         // DEBUG level: directory creation is normal operation
         logger.debug("Created uploads directory", { path: uploadsDir })
       }
+      console.log(`[UPLOAD] Using uploads directory: ${uploadsDir} (exists: ${existsSync(uploadsDir)})`)
 
       // Filename is generated server-side (timestamp + random), safe for path.join
       const filepath = join(uploadsDir, filename)

merge-main-into-dev.sh

@@ -0,0 +1,51 @@
+#!/bin/bash
+# Merge main into dev to resolve conflicts before merging dev into main
+
+set -e
+
+echo "========================================="
+echo "Merging main into dev to resolve conflicts"
+echo "========================================="
+
+cd /home/beast/Code/mirrormatch
+
+# 1. Make sure we're on dev
+echo ""
+echo "Step 1: Checking out dev branch..."
+git checkout dev
+git pull gitea dev
+
+# 2. Fetch latest main
+echo ""
+echo "Step 2: Fetching latest main..."
+git fetch gitea main
+
+# 3. Try to merge main into dev
+echo ""
+echo "Step 3: Merging main into dev..."
+echo "This may show conflicts that need to be resolved manually."
+echo ""
+
+if git merge gitea/main --no-commit; then
+  echo "✓ No conflicts! Merging..."
+  git commit -m "Merge main into dev: resolve conflicts before MR"
+  echo ""
+  echo "✓ Merge complete! Now push dev:"
+  echo "  git push gitea dev"
+  echo ""
+  echo "Then your MR from dev → main should work without conflicts."
+else
+  echo ""
+  echo "⚠ Conflicts detected! You need to resolve them manually:"
+  echo ""
+  echo "Conflicting files:"
+  git diff --name-only --diff-filter=U
+  echo ""
+  echo "To resolve:"
+  echo "  1. Edit the conflicting files"
+  echo "  2. git add <resolved-files>"
+  echo "  3. git commit -m 'Merge main into dev: resolve conflicts'"
+  echo "  4. git push gitea dev"
+  echo ""
+  echo "Then your MR from dev → main should work."
+fi

watch-activity.sh

@@ -1,5 +1,6 @@
 #!/bin/bash
 # Watch user activity logs in real-time
+<<<<<<< HEAD
 # 
 # This script monitors logs for MirrorMatch activity.
 # It can watch systemd journal logs OR application log files.
@@ -14,11 +15,15 @@
 #   - If running as systemd service: ./watch-activity.sh (uses journalctl)
 
 LOG_FILE="${1:-}"
+=======
+# Usage: ./watch-activity.sh
+>>>>>>> gitea/main
 
 echo "Watching user activity logs..."
 echo "Press Ctrl+C to stop"
 echo ""
 
+<<<<<<< HEAD
 if [ -n "$LOG_FILE" ]; then
   # Watch log file
   if [ ! -f "$LOG_FILE" ]; then
@@ -81,3 +86,7 @@ else
     exit 1
   fi
 fi
+=======
+# Watch for activity logs (ACTIVITY, PHOTO_UPLOAD, GUESS_SUBMIT)
+sudo journalctl -u app-backend -f | grep -E "\[ACTIVITY\]|\[PHOTO_UPLOAD\]|\[GUESS_SUBMIT\]"
+>>>>>>> gitea/main