Wakeve is a modern, collaborative event planning application that solves the scheduling problem for distributed teams. With intelligent availability polling, automatic best-time calculation, and offline-first synchronization, Wakeve makes it easy to find a time that works for everyone.

✅ Event Organization

• Create events with multiple time slot options
• Invite participants and manage RSVPs
• Real-time availability polling
• Weighted voting system (YES=2, MAYBE=1, NO=-1)
• Automatic best-time calculation
• Offline-first database persistence

✅ Virtual Meetings

• MeetingService with support for Zoom, Google Meet, FaceTime
• Secure meeting link generation via backend proxy
• Meeting invitation and reminder scheduling
• Integration with native calendar
• Meeting lifecycle management (create, update, cancel, start, end)

✅ Multiplatform Support

• Android with Jetpack Compose UI
• iOS with native database driver (UI in Phase 2)
• JVM/Desktop support
• Single shared codebase via Kotlin Multiplatform

✅ Backend Infrastructure

• Production-ready Ktor REST API
• SQLDelight type-safe database
• 8 comprehensive endpoints + 4 MeetingProxy endpoints
• Role-based access control
• Secure API key management for external platforms

⏳ User Authentication - OAuth2 with Google/Apple ⏳ Offline Sync - Automatic change synchronization ⏳ Push Notifications - Deadline reminders and updates ✅ Calendar Integration - Native calendar app support (Android & iOS), ICS export and share

# Clone repository
git clone https://github.com/guyghost/wakeve.git
cd wakeve

# Build and test
./gradlew build
./gradlew shared:test  # 36 tests passing ✅

# Start server
./gradlew server:run   # http://localhost:8080

# Build Android app
./gradlew wakeveApp:assembleDebug

See QUICK_START.md for detailed setup instructions.

wakeve/
├── shared/               # Kotlin Multiplatform shared code
│   ├── src/commonMain/  # Cross-platform models & logic
│   ├── src/jvmTest/     # JVM-specific tests
│   └── sqldelight/      # Type-safe database schema
├── wakeveApp/          # Android app with Jetpack Compose
├── server/              # Ktor REST backend server
├── wakeveApp/wakeveApp/ # iOS app entry point (SwiftUI)
├── openspec/            # Specification documents
└── docs/                # Documentation

┌─────────────────────────────────────┐
│  UI Layer (Compose/SwiftUI)         │
├─────────────────────────────────────┤
│  Business Logic (EventRepository)   │
├─────────────────────────────────────┤
│  Persistence (SQLDelight)           │
├─────────────────────────────────────┤
│  Platform Drivers (Android/iOS/JVM) │
└─────────────────────────────────────┘

Wakeve follows the Functional Core, Imperative Shell pattern to ensure testability and separation of concerns:

┌─────────────────────────────────────────────────────────┐
│                    IMPERATIVE SHELL                  │
│  ┌───────────────────────────────────────────────────┐  │
│  │  Services (MeetingService, EventRepository)      │  │
│  │  State Machines (MVI FSM)                      │  │
│  │  External APIs (MeetingProxyRoutes)              │  │
│  └───────────────────────────────────────────────────┘  │
│  Handles side effects: I/O, async, state mutations   │
└─────────────────────────────────────────────────────────┘
                        ↓
┌─────────────────────────────────────────────────────────┐
│                     FUNCTIONAL CORE                   │
│  ┌───────────────────────────────────────────────────┐  │
│  │  Pure Functions (logic, validators, transforms)  │  │
│  │  Domain Models (Event, Meeting, Vote)           │  │
│  │  Business Rules (scoring, eligibility)           │  │
│  └───────────────────────────────────────────────────┘  │
│  No side effects, 100% testable                      │
└─────────────────────────────────────────────────────────┘

Key Principles:

• ✅ Shell CAN call Core
• ✅ Core CANNOT call Shell
• ✅ Core ignores Shell's existence
• ✅ Pure functions in Core are easily testable
• ✅ Side effects isolated in Shell (database, network, API)

See docs/architecture/meeting-service.md for detailed MeetingService architecture.

• Language: Kotlin 2.2.20 with Multiplatform support
• UI: Jetpack Compose (Android), SwiftUI (iOS)
• Database: SQLDelight with type-safe queries
• Backend: Ktor 3.3.1 REST server
• Testing: Kotlin test framework, 36+ tests
• Serialization: kotlinx-serialization for JSON

• QUICK_START.md - 5-minute setup guide
• CONTRIBUTING.md - Development guidelines
• AGENTS.md - OpenSpec workflow and AI agents

For comprehensive documentation, visit docs/:

• Architecture - System architecture and KMP patterns
• API Documentation - REST API endpoints
• Testing - Testing strategy and reports
• Integrations - Calendar, OAuth, and external services
• Migration Guides - Design system migrations
• Refactoring Docs - Major refactorings
• Implementation Status - PRD feature tracking

• openspec/specs/ - Detailed specifications
• openspec/AGENTS.md - Specification-driven development workflow

• Java 11+
• Kotlin 2.2.20
• Gradle 8.14+
• Android SDK (for Android development)
• Xcode 15+ (for iOS development)

# Run all tests
./gradlew shared:test

# Run specific test
./gradlew shared:test --tests "EventRepositoryTest"

# Build Android app
./gradlew wakeveApp:assembleDebug

# Start server
./gradlew server:run

# Format code
./gradlew spotlessApply

Wakeve has comprehensive test coverage:

EventRepositoryTest          10 tests
PollLogicTest               6 tests
DatabaseEventRepositoryTest 13 tests
OfflineScenarioTest         7 tests
───────────────────────────────────
Unit Tests                  36 tests ✅

PrdWorkflowE2ETest          6 tests
ServiceIntegrationE2ETest    5 tests
MultiUserCollaborationTest   10 tests
DeleteEventE2ETest           6 tests
AuthFlowE2ETest              4 tests
───────────────────────────────────
E2E Tests                  35 tests ✅

TOTAL                      71 tests ✅

All tests cover:

• ✅ Event creation and lifecycle
• ✅ Participant management
• ✅ Vote submission and aggregation
• ✅ Database persistence
• ✅ Offline data recovery
• ✅ API endpoints
• ✅ Complete PRD workflow (DRAFT → FINALIZED)
• ✅ Multi-user collaboration scenarios
• ✅ Virtual meeting link generation
• ✅ Service integration (Budget, Transport, Meeting, Suggestion)

GET    /health                    # Health check
GET    /api/events                # List all events
GET    /api/events/{id}           # Get event details
POST   /api/events                # Create event
PUT    /api/events/{id}/status    # Update event status
GET    /api/events/{id}/participants   # List participants
POST   /api/events/{id}/participants   # Add participant
GET    /api/events/{id}/poll      # Get poll results
POST   /api/events/{id}/poll/votes    # Submit vote

POST   /api/meetings/proxy/zoom/create              # Create Zoom meeting
POST   /api/meetings/proxy/google-meet/create       # Create Google Meet meeting
POST   /api/meetings/proxy/zoom/{id}/cancel        # Cancel Zoom meeting
GET    /api/meetings/proxy/zoom/{id}/status        # Get Zoom meeting status

Security Note: Meeting proxy endpoints secure external API keys (Zoom, Google Meet) by handling all external API calls server-side.

See docs/api/meeting-api.md for detailed MeetingProxy API documentation.

curl -X POST http://localhost:8080/api/events \
  -H "Content-Type: application/json" \
  -d '{
    "title": "Team Meeting",
    "description": "Q4 Planning",
    "organizerId": "user-1",
    "deadline": "2025-11-20T18:00:00Z",
    "proposedSlots": [{
      "id": "slot-1",
      "start": "2025-12-01T10:00:00Z",
      "end": "2025-12-01T12:00:00Z",
      "timezone": "UTC"
    }]
  }'

• Static user IDs (for development)
• Role-based access control (organizer vs participant)
• Input validation on all endpoints
• Error handling with appropriate HTTP status codes

• OAuth2 authentication (Google, Apple)
• Secure token storage and refresh
• HTTPS enforcement
• Rate limiting and request validation

• UI Framework: Jetpack Compose
• Target: API 24+
• Build: ./gradlew wakeveApp:assembleDebug

• Framework: Swift/SwiftUI (planned Phase 2)
• Target: iOS 13+
• Database: Native SQLite driver

• Framework: Ktor REST server
• Database: SQLDelight with JDBC driver
• Run: ./gradlew server:run

1. Create feature branch: change/<feature-name>
2. Follow OpenSpec process (see CONTRIBUTING.md)
3. Write tests for all new code
4. Submit PR with issue reference

[#<issue>] <type>: <description>

<optional body>

Examples:

[#2] feat: Implement event creation API
[#15] fix: Handle timezone conversion
[#20] test: Add offline sync scenarios

Build Fails

./gradlew clean build  # Clean rebuild
java -version          # Verify Java 11+

Tests Failing

./gradlew shared:test --info  # Verbose output
./gradlew shared:test --tests "TestName" -d  # Debug mode

Server Won't Start

lsof -i :8080          # Check port 8080
./gradlew server:run --info  # Debug mode

See QUICK_START.md for more solutions.

Wakeve follows the OpenSpec specification-driven development process:

1. Create Issue → 2. Create Proposal → 3. Create Spec → 
4. Get Approval → 5. Implement with Tests → 6. Merge & Deploy

See openspec/PROCESS.md for detailed workflow.

We welcome contributions! Please see CONTRIBUTING.md for:

• Development setup
• Code style guidelines
• Testing requirements
• Commit conventions
• Pull request process

• Issues: Create GitHub Issue for bugs/features
• Discussions: Use GitHub Discussions for questions
• Documentation: See full docs in repository
• Email: Contact maintainers for security issues

Wakeve is licensed under the MIT License. See LICENSE file for details.

Built with:

• Kotlin Multiplatform
• Jetpack Compose
• Ktor
• SQLDelight

Wakeve's mission is to make collaborative scheduling effortless. By combining intelligent polling, automatic scheduling, and offline-first principles, we're building the event planning tool for distributed teams.

Ready to contribute? Start with QUICK_START.md and CONTRIBUTING.md!

Questions? Check openspec/ for detailed specifications and documentation.