Google Meet Integration - Project Plan v2.0

Project: CODITECT Google Meet Integration Version: 2.0.0 Status: Planning Last Updated: December 17, 2025

---

Executive Summary

This project delivers a zero-cost Google Meet integration as an optional CODITECT component, enabling customers to schedule meetings, retrieve transcripts, and process meeting artifacts through the CODITECT AI pipeline.

Key Objectives

1. Zero External Cost - Use only free-tier Google APIs
2. Optional Component - Activatable only when needed
3. Provider Agnostic - Abstract interface for multi-provider support
4. CODITECT Native - Follow framework patterns and conventions

Success Criteria

• All free-tier APIs integrated and tested
• 80%+ unit test coverage
• Documentation complete (SDD, TDD, ADRs)
• Component activation workflow functional
• AI pipeline integration working

---

Phase 0: GCP Project Setup (Prerequisites)

0.1 Google Cloud Project Configuration

Duration: 1 day

• Create or select GCP project

  • Project ID: coditect-integrations (or existing)
  • Enable billing (required for API access, but free tier used)
  • Console: https://console.cloud.google.com/

• Enable required APIs via GCP Console or CLI

  # Enable Google Calendar API (for meeting scheduling)
  gcloud services enable calendar-json.googleapis.com
  
  # Enable Google Meet REST API (for transcripts/recordings)
  gcloud services enable meet.googleapis.com
  
  # Enable Google Drive API (for recording downloads)
  gcloud services enable drive.googleapis.com
  
  # Enable Cloud Pub/Sub (for event notifications)
  gcloud services enable pubsub.googleapis.com
  
  # Enable IAM API (for service accounts)
  gcloud services enable iam.googleapis.com
  
  # Verify enabled APIs
  gcloud services list --enabled

0.2 API Endpoints Reference

API	Endpoint Base	Documentation
Google Calendar API v3	https://www.googleapis.com/calendar/v3	https://developers.google.com/calendar/api
Google Meet REST API v2	https://meet.googleapis.com/v2	https://developers.google.com/meet/api
Google Drive API v3	https://www.googleapis.com/drive/v3	https://developers.google.com/drive/api
Cloud Pub/Sub v1	https://pubsub.googleapis.com/v1	https://cloud.google.com/pubsub/docs
OAuth 2.0	https://oauth2.googleapis.com	https://developers.google.com/identity

0.3 OAuth 2.0 Credentials Setup

Duration: 2 hours

• Create OAuth 2.0 Client ID

  • Go to: APIs & Services → Credentials
  • Click "Create Credentials" → "OAuth client ID"
  • Application type: "Web application"
  • Authorized redirect URIs:
    • http://localhost:8080/oauth/callback (development)
    • https://your-domain.com/oauth/callback (production)
  • Download client credentials JSON

• Configure OAuth Consent Screen

  • Go to: APIs & Services → OAuth consent screen
  • User type: External (or Internal for Workspace)
  • App name: "CODITECT Meet Integration"
  • User support email: support@coditect.ai
  • Scopes: Add required scopes (see below)
  • Test users: Add test Gmail accounts

• Required OAuth Scopes

  # Calendar API (meeting scheduling)
  https://www.googleapis.com/auth/calendar
  https://www.googleapis.com/auth/calendar.events
  
  # Meet API (transcripts, recordings, participants)
  https://www.googleapis.com/auth/meetings.space.readonly
  https://www.googleapis.com/auth/meetings.space.created
  
  # Drive API (recording downloads)
  https://www.googleapis.com/auth/drive.readonly

0.4 Service Account Setup (Optional - Enterprise)

Duration: 1 hour

• Create Service Account

  # Create service account
  gcloud iam service-accounts create meet-integration \
      --display-name="CODITECT Meet Integration"
  
  # Download key file
  gcloud iam service-accounts keys create meet-sa-key.json \
      --iam-account=meet-integration@PROJECT_ID.iam.gserviceaccount.com

• Enable Domain-Wide Delegation (Workspace only)

  • Go to: IAM & Admin → Service Accounts
  • Click on service account → Edit → Show Advanced Settings
  • Enable "Domain-wide Delegation"
  • Copy Client ID for Admin Console

• Configure in Google Workspace Admin Console

  • Go to: admin.google.com → Security → API Controls → Domain-wide Delegation
  • Add new → Client ID from service account
  • OAuth Scopes: (same as user OAuth)

0.5 Cloud Pub/Sub Setup (for Workspace Events)

Duration: 1 hour

• Create Pub/Sub Topic

  # Create topic for Meet event notifications
  gcloud pubsub topics create meet-events
  
  # Create subscription
  gcloud pubsub subscriptions create meet-events-sub \
      --topic=meet-events \
      --ack-deadline=60

• Configure Workspace Events API (if using)

  • Enable Workspace Events API
  • Subscribe to Meet events via Workspace Events

0.6 Environment Variables

Duration: 30 minutes

• Create .env file with credentials

  # OAuth 2.0
  GOOGLE_CLIENT_ID=your-client-id.apps.googleusercontent.com
  GOOGLE_CLIENT_SECRET=your-client-secret
  GOOGLE_REDIRECT_URI=http://localhost:8080/oauth/callback
  
  # Service Account (optional)
  GOOGLE_APPLICATION_CREDENTIALS=/path/to/meet-sa-key.json
  MEET_DELEGATED_USER=admin@yourdomain.com
  
  # Pub/Sub (optional)
  GOOGLE_CLOUD_PROJECT=your-project-id
  MEET_PUBSUB_TOPIC=meet-events
  MEET_PUBSUB_SUBSCRIPTION=meet-events-sub
  
  # Security
  TOKEN_ENCRYPTION_KEY=<32-byte-base64-key>

• Add .env to .gitignore

• Create .env.example with placeholder values

0.7 API Endpoints Quick Reference

Operation	Endpoint
Create Calendar Event with Meet	POST https://www.googleapis.com/calendar/v3/calendars/{calendarId}/events
Get Calendar Event	GET https://www.googleapis.com/calendar/v3/calendars/{calendarId}/events/{eventId}
List Calendar Events	GET https://www.googleapis.com/calendar/v3/calendars/{calendarId}/events
Free/Busy Query	POST https://www.googleapis.com/calendar/v3/freeBusy
Create Meet Space	POST https://meet.googleapis.com/v2/spaces
Get Meet Space	GET https://meet.googleapis.com/v2/spaces/{name}
List Conference Records	GET https://meet.googleapis.com/v2/conferenceRecords
Get Transcript	GET https://meet.googleapis.com/v2/conferenceRecords/{id}/transcripts/{transcriptId}
List Transcript Entries	GET https://meet.googleapis.com/v2/conferenceRecords/{id}/transcripts/{transcriptId}/entries
Get Recording	GET https://meet.googleapis.com/v2/conferenceRecords/{id}/recordings/{recordingId}
List Participants	GET https://meet.googleapis.com/v2/conferenceRecords/{id}/participants
OAuth Token	POST https://oauth2.googleapis.com/token
OAuth Revoke	POST https://oauth2.googleapis.com/revoke

---

Project Phases

Phase 1: Foundation (Week 1-2)

Goal: Core infrastructure and authentication

Phase 2: API Integration (Week 3-4)

Goal: Calendar and Meet API implementations

Phase 3: AI Pipeline (Week 5)

Goal: Connect to CODITECT AI processing

Phase 4: Testing & Documentation (Week 6)

Goal: Comprehensive testing and docs

---

Detailed Timeline

Week 1  │ Week 2  │ Week 3  │ Week 4  │ Week 5  │ Week 6
────────┼─────────┼─────────┼─────────┼─────────┼─────────
Phase 1: Foundation        │ Phase 2: API Integration
████████████████████████████│██████████████████████████
                           │
        OAuth │ Models     │ Calendar │ Meet API
        ██████│████████████│██████████│███████████
                                      │
                                      │ Phase 3: AI
                                      │ ██████████
                                                │
                                                │ Phase 4
                                                │ ████████

---

Phase 1: Foundation

1.1 Project Setup

Duration: 2 days

• Create project structure
  • src/ directory with __init__.py
  • tests/ directory with __init__.py
  • config/ directory with default.yaml
  • docs/ directory (already created)
• Set up pyproject.toml with dependencies
• Configure pytest and coverage
• Set up pre-commit hooks
• Create .gitignore for secrets

1.2 Provider Interface

Duration: 2 days

• Define MeetingProviderInterface abstract base class
  • authenticate() method
  • create_meeting() method
  • get_meeting() method
  • list_meetings() method
  • get_transcript() method
  • get_recording() method
  • get_participants() method
• Create data models
  • Meeting dataclass
  • Transcript dataclass
  • TranscriptEntry dataclass
  • Recording dataclass
  • Participant dataclass
• Define exception hierarchy
  • MeetingIntegrationError base
  • AuthenticationError
  • RateLimitError
  • ProviderError

1.3 OAuth Implementation

Duration: 3 days

• Implement GoogleOAuthManager
  • Load credentials from file
  • Token refresh logic
  • Save credentials to file
  • Revoke credentials
• Implement ServiceAccountAuth
  • Load service account credentials
  • Domain-wide delegation support
  • User impersonation
• Create token storage abstraction
  • Secure storage interface
  • File-based implementation
  • Encryption at rest
• Write unit tests for OAuth
  • Test token refresh
  • Test credential loading
  • Test error handling

1.4 Rate Limiting

Duration: 2 days

• Implement TokenBucketRateLimiter
  • Async support
  • Configurable rate and burst
  • Token refill logic
• Implement GoogleMeetRateLimiter
  • Read limiter (6000/min)
  • Write limiter (1000/min)
  • Create space limiter (100/min)
• Create retry decorator with backoff
  • Exponential backoff
  • Jitter
  • Configurable max retries
• Write unit tests
  • Test rate limiting behavior
  • Test retry logic

---

Phase 2: API Integration

2.1 Calendar API Integration

Duration: 3 days

• Implement CalendarMeetingScheduler
  • create_meeting() with Meet conferencing
  • update_meeting() for modifications
  • delete_meeting() for cancellation
  • list_meetings() with date range
• Handle attendee management
  • Add attendees
  • Send notifications
  • Handle optional attendees
• Implement response parsing
  • Extract Meet link
  • Extract meeting code
  • Extract dial-in numbers
• Write unit tests
  • Mock Calendar API responses
  • Test error handling
  • Test edge cases

2.2 Meet REST API Integration

Duration: 4 days

• Implement MeetArtifactsClient
  • Space operations
    • create_space()
    • get_space()
    • update_space()
  • Conference record operations
    • list_conference_records()
    • get_conference_record()
  • Transcript operations
    • list_transcripts()
    • get_transcript()
    • get_transcript_entries()
  • Recording operations
    • list_recordings()
    • get_recording()
  • Participant operations
    • list_participants()
    • get_participant()
• Implement response caching
  • Cache key generation
  • TTL management
  • Cache invalidation
• Write unit tests
  • Mock Meet API responses
  • Test pagination
  • Test filtering

2.3 Google Meet Provider

Duration: 2 days

• Implement GoogleMeetProvider
  • Implement all interface methods
  • Combine Calendar + Meet APIs
  • Handle authentication
  • Apply rate limiting
• Create configuration loader
  • YAML configuration parsing
  • Environment variable support
  • Validation
• Write integration tests
  • Test full workflow
  • Test error scenarios

2.4 Event Handling (Optional)

Duration: 2 days

• Implement MeetingEventSubscriber
  • Create subscription
  • Handle Pub/Sub messages
  • Event type routing
• Create event handlers
  • Meeting started handler
  • Meeting ended handler
  • Recording available handler
  • Transcript available handler
• Write unit tests

---

Phase 3: AI Pipeline Integration

3.1 Transcript Processing

Duration: 2 days

• Implement TranscriptProcessor
  • Format transcript for AI
  • Speaker diarization formatting
  • Timestamp handling
• Create AI prompt templates
  • Summarization prompt
  • Action items prompt
  • Key decisions prompt
• Connect to CODITECT AI service
  • Use existing AI pipeline
  • Handle response parsing

3.2 Context Database Integration

Duration: 2 days

• Implement MeetingContextStore
  • Store meeting metadata
  • Store transcript text
  • Store AI-generated insights
• Create search capabilities
  • Full-text search on transcripts
  • Filter by date range
  • Filter by participants
• Write integration tests

3.3 Component Activation

Duration: 1 day

• Create component activation entry
  • Add to component-activation-status.json
  • Define dependencies
  • Set default to disabled
• Create activation script
  • Validate dependencies
  • Run configuration
  • Test connectivity

---

Phase 4: Testing & Documentation

4.1 Comprehensive Testing

Duration: 3 days

• Unit tests (80%+ coverage)
  • OAuth tests
  • Rate limiter tests
  • Calendar API tests
  • Meet API tests
  • Provider tests
• Integration tests
  • End-to-end meeting creation
  • Transcript retrieval flow
  • Error handling scenarios
• Performance tests
  • Rate limiting effectiveness
  • Cache hit rates
  • Response times

4.2 Documentation

Duration: 2 days

• Complete SDD (done)
• Complete TDD (done)
• Complete ADRs (done)
• Create user guide
  • Setup instructions
  • Configuration reference
  • Troubleshooting guide
• Create API reference
  • Python API documentation
  • Code examples
• Update README.md
  • Quick start
  • Feature list
  • Requirements

4.3 Final Review

Duration: 1 day

• Code review
• Documentation review
• Security review
• Performance review
• Final testing

---

Phase 5: Scheduling Components (integration-core)

5.1 Unified Scheduling Orchestrator

Duration: 2 days

• Integrate with coditect-integrations package
  • Install integration-core as dependency: pip install coditect-integrations[google]
  • Import orchestrator: from coditect_integrations import MeetingSchedulerOrchestrator
  • Import models: from coditect_integrations.models import ScheduledMeeting, Attendee, RecurrenceRule
  • Configure MeetingSchedulerOrchestrator with GoogleMeetProvider
• Implement GoogleMeetProvider(MeetingProviderInterface)
  • Implement provider_name property → "google_meet"
  • Implement authenticate() → OAuth credential loading
  • Implement create_meeting() → Calendar API with conferenceData
  • Implement get_meeting() → Calendar event + Meet space lookup
  • Implement get_transcript() → Meet REST API transcript retrieval
  • Implement get_recording() → Drive API recording download
  • Implement get_participants() → Meet REST API participants
• Register provider with orchestrator
  • orchestrator.register_provider("google_meet", GoogleMeetProvider())
  • Return unified ScheduledMeeting dataclass

5.2 Calendar Synchronization

Duration: 3 days

• Implement GoogleCalendarClient(CalendarClient) protocol
  • Import: from coditect_integrations.calendar import CalendarSyncManager, CalendarClient
  • Implement create_event() → Calendar API events.insert()
  • Implement update_event() → Calendar API events.update()
  • Implement delete_event() → Calendar API events.delete()
  • Implement get_freebusy() → Calendar API freebusy.query()
  • Implement incremental sync with sync tokens
• Configure CalendarSyncManager
  • Instantiate: CalendarSyncManager(google_calendar=GoogleCalendarClient())
  • Call sync() with SyncDirection.BIDIRECTIONAL
  • Handle ConflictResolutionStrategy (REMOTE_WINS, LOCAL_WINS, MERGE)
  • Persist SyncState between runs
• Write integration tests for CalendarSyncManager

5.3 Recurring Meetings

Duration: 2 days

• Integrate RecurrenceEngine from integration-core
  • Import: from coditect_integrations.scheduling import RecurrenceEngine
  • Import models: from coditect_integrations.models import RecurrenceRule, Frequency, Weekday
• Implement Google Calendar RRULE conversion
  • Use RecurrenceEngine.to_provider_format(rule, "google_meet") → RRULE string
  • Use RecurrenceRule.to_rrule_string() for RFC 5545 format
  • Parse RRULE from events into RecurrenceRule dataclass
  • Handle EXDATE (exception dates) via RecurrenceRule.exceptions
• Test recurrence patterns via RecurrenceEngine.generate_instances()
  • Frequency.DAILY with interval
  • Frequency.WEEKLY with by_day=[Weekday.MO, Weekday.WE, Weekday.FR]
  • Frequency.MONTHLY with by_month_day=[1, 15]
  • Validate count and until termination

5.4 Attendee Management

Duration: 2 days

• Integrate AttendeeManager from integration-core
  • Import: from coditect_integrations.attendee import AttendeeManager
  • Import models: from coditect_integrations.models import Attendee, ResponseStatus, AttendeeResponse
• Implement GoogleCalendarNotificationService(NotificationService)
  • Use Calendar API sendUpdates parameter for native invitations
  • Implement send_invitation() → Calendar event with attendees
  • Implement send_update() → Calendar event.update() with notification
  • Implement send_cancellation() → Calendar event.delete() with notification
• Configure AttendeeManager
  • AttendeeManager(notification_service=GoogleCalendarNotificationService())
  • Track RSVP via update_rsvp() with ResponseStatus.ACCEPTED/DECLINED/TENTATIVE
  • Query get_attendee_responses() for meeting attendance status

5.5 Availability Checking

Duration: 2 days

• Implement GoogleCalendarFreeBusyClient(CalendarFreeBusyClient)
  • Import: from coditect_integrations.availability import AvailabilityService, CalendarFreeBusyClient
  • Implement get_freebusy() → Calendar API freebusy.query()
  • Parse response into List[BusyPeriod] per attendee
  • Handle privacy settings (respect freeBusyStatus)
• Integrate AvailabilityService
  • Instantiate: AvailabilityService(google_calendar=GoogleCalendarFreeBusyClient())
  • Use get_free_busy(attendees, TimeRange) → merged busy periods
  • Use find_available_slots(attendees, TimeRange, duration_minutes, WorkingHours)
  • Use suggest_meeting_times() with preferred_times=["morning", "afternoon"]
• Configure WorkingHours
  • Default: WorkingHours.business_hours() (9-17, Mon-Fri)
  • Custom: WorkingHours(start_hour=8, end_hour=18, working_days=[0,1,2,3,4])

5.6 Reminder System

Duration: 1 day

• Integrate ReminderService from integration-core
  • Import: from coditect_integrations.reminders import ReminderService
  • Import models: from coditect_integrations.models import Reminder, ScheduledReminder, ReminderMethod
• Implement notification channels
  • EmailNotificationChannel(NotificationChannel) → SMTP/SendGrid
  • PushNotificationChannel(NotificationChannel) → Firebase/APNs (optional)
• Implement ReminderStorage for persistence
  • Store ScheduledReminder in CODITECT database
  • Query get_due_reminders() for background processing
• Configure ReminderService
  • ReminderService(email_service=EmailChannel(), storage=ReminderStorage(), scheduler=TaskScheduler())
  • Use schedule_reminder(meeting_id, Reminder(minutes_before=15, method=ReminderMethod.EMAIL))
  • Run process_due_reminders() via background worker (Celery/APScheduler)

---

Resource Requirements

Team

• 1 Backend Engineer (primary)
• 0.5 DevOps Engineer (CI/CD setup)
• 0.25 Tech Writer (documentation review)

Infrastructure

• Google Cloud Project (free tier)
• CI/CD pipeline (existing)
• Test environment (existing)

Dependencies

[project.dependencies]
coditect-integrations = ">=1.0.0"

[project.optional-dependencies]
google-meet = [
    "coditect-integrations[google]>=1.0.0",
    "google-auth>=2.0.0",
    "google-auth-oauthlib>=1.0.0",
    "google-api-python-client>=2.0.0",
    "google-apps-meet>=0.1.0",
]

---

Integration-Core Components Reference

Core Imports

# Orchestrator
from coditect_integrations import MeetingSchedulerOrchestrator
from coditect_integrations.core import MeetingProviderInterface

# Models
from coditect_integrations.models import (
    Meeting, ScheduledMeeting, MeetingUpdate,
    Attendee, AttendeeResponse, ResponseStatus,
    RecurrenceRule, Frequency, Weekday,
    Reminder, ScheduledReminder, ReminderMethod,
    TimeRange, BusyPeriod, AvailableSlot, WorkingHours,
    Transcript, TranscriptEntry, Recording, Participant,
    CalendarEvent, SyncState, SyncDirection,
)

# Services
from coditect_integrations.scheduling import RecurrenceEngine
from coditect_integrations.calendar import CalendarSyncManager
from coditect_integrations.attendee import AttendeeManager
from coditect_integrations.availability import AvailabilityService
from coditect_integrations.reminders import ReminderService

Provider Implementation Pattern

class GoogleMeetProvider(MeetingProviderInterface):
    @property
    def provider_name(self) -> str:
        return "google_meet"

    async def create_meeting(self, title, start_time, duration_minutes, attendees=None, **kwargs) -> Meeting:
        # Calendar API: events.insert() with conferenceData
        pass

    async def get_transcript(self, meeting_id) -> Optional[Transcript]:
        # Meet REST API: conferenceRecords/{id}/transcripts
        pass

Orchestrator Usage

orchestrator = MeetingSchedulerOrchestrator(
    recurrence_engine=RecurrenceEngine(),
    calendar_sync=CalendarSyncManager(google_calendar=GoogleCalendarClient()),
    attendee_manager=AttendeeManager(notification_service=EmailService()),
    availability_service=AvailabilityService(google_calendar=FreeBusyClient()),
    reminder_service=ReminderService(email_service=EmailChannel(), storage=ReminderDB()),
)

# Schedule meeting
meeting = await orchestrator.schedule_meeting(
    provider="google_meet",
    title="Sprint Planning",
    start_time=datetime(2025, 12, 20, 10, 0),
    duration_minutes=60,
    attendees=[Attendee(email="user@example.com", name="User")],
    recurrence=RecurrenceRule(frequency=Frequency.WEEKLY, count=10),
    reminders=[Reminder(minutes_before=15, method=ReminderMethod.EMAIL)],
)

---

Risk Assessment

Risk	Probability	Impact	Mitigation
API rate limits hit	Medium	Low	Token bucket rate limiting
OAuth token expiry	Low	Medium	Automatic refresh logic
Transcript not available	Medium	Low	Graceful handling, retry
Google API changes	Low	High	Version pinning, monitoring
Workspace edition required	N/A	N/A	Document requirement clearly

---

Success Metrics

Metric	Target
Unit test coverage	80%+
Integration test pass rate	100%
API response time (p95)	<500ms
Documentation completeness	100%
Zero external costs	Verified

---

Acceptance Criteria

MVP (Minimum Viable Product)

1. Can authenticate with Google OAuth
2. Can create meeting with Meet link
3. Can retrieve meeting transcript
4. Can retrieve meeting participants
5. Component activation works
6. Documentation complete

Full Release

1. All MVP criteria met
2. Event subscriptions working
3. AI pipeline integration
4. Context database storage
5. Performance targets met
6. Security review passed

Scheduling Components (Phase 5)

1. Unified scheduling orchestrator integrated
2. Two-way calendar sync working
3. Recurring meetings supported
4. Attendee invitations/RSVPs working
5. Availability checking functional
6. Reminder system operational

---

Document Control:

• Created: December 17, 2025
• Owner: CODITECT Engineering Team
• Review Cycle: Weekly during development