Hot Take: Remote Work Is Dying – Use RTO with Google and Meta Instead

import os
import json
from datetime import datetime, timedelta
from google.oauth2 import service_account
from googleapiclient.discovery import build
from googleapiclient.errors import HttpError

# Configuration constants
SCOPES = ['https://www.googleapis.com/auth/admin.directory.user.readonly']
SERVICE_ACCOUNT_FILE = 'google-rto-creds.json'
ADMIN_USER = 'admin@yourdomain.com'  # Super admin for directory access
RTO_DAYS_REQUIRED = 3  # Google's minimum on-site days per week
SPRINT_LENGTH_DAYS = 14  # Standard sprint length

def get_google_directory_service():
    """Initialize and return Google Admin Directory API service client."""
    try:
        creds = service_account.Credentials.from_service_account_file(
            SERVICE_ACCOUNT_FILE, scopes=SCOPES
        )
        # Delegate to admin user to access directory data
        delegated_creds = creds.with_subject(ADMIN_USER)
        service = build('admin', 'directory_v1', credentials=delegated_creds)
        return service
    except FileNotFoundError:
        raise RuntimeError(f"Service account file {SERVICE_ACCOUNT_FILE} not found. Download from Google Cloud Console.")
    except Exception as e:
        raise RuntimeError(f"Failed to initialize Google Directory service: {str(e)}")

def fetch_user_rto_attendance(service, user_email, sprint_start):
    """Fetch RTO attendance records for a single user over a sprint."""
    sprint_end = sprint_start + timedelta(days=SPRINT_LENGTH_DAYS)
    try:
        # Call Google Calendar API to get office check-in events
        # Assumes office check-ins are tagged with 'rto-checkin' label
        calendar_service = build('calendar', 'v3', credentials=service._credentials)
        events_result = calendar_service.events().list(
            calendarId=user_email,
            timeMin=sprint_start.isoformat() + 'Z',
            timeMax=sprint_end.isoformat() + 'Z',
            q='rto-checkin',
            maxResults=50
        ).execute()
        events = events_result.get('items', [])
        # Count unique days with at least one check-in
        attendance_days = set()
        for event in events:
            event_date = datetime.fromisoformat(event['start']['dateTime'].replace('Z', '+00:00')).date()
            attendance_days.add(event_date)
        return len(attendance_days)
    except HttpError as e:
        if e.resp.status == 404:
            print(f"Warning: Calendar not found for {user_email}, skipping")
            return 0
        raise RuntimeError(f"Failed to fetch attendance for {user_email}: {str(e)}")

def calculate_team_productivity(attendance_data, commit_data):
    """Correlate RTO attendance with sprint commit counts."""
    results = {}
    for user, days_attended in attendance_data.items():
        commits = commit_data.get(user, 0)
        if days_attended >= RTO_DAYS_REQUIRED:
            productivity = commits / days_attended
        else:
            productivity = commits / RTO_DAYS_REQUIRED * 0.7  # Penalty for non-compliance
        results[user] = {
            'attendance_days': days_attended,
            'commits': commits,
            'productivity_score': round(productivity, 2),
            'meets_rto': days_attended >= RTO_DAYS_REQUIRED
        }
    return results

if __name__ == '__main__':
    # Initialize service
    try:
        dir_service = get_google_directory_service()
    except RuntimeError as e:
        print(f"Fatal error: {e}")
        exit(1)

    # Fetch all engineering users (filter by department)
    try:
        users_result = dir_service.users().list(
            domain='yourdomain.com',
            query='department:Engineering',
            maxResults=100
        ).execute()
        users = users_result.get('users', [])
    except HttpError as e:
        print(f"Failed to fetch users: {e}")
        exit(1)

    # Process attendance for current sprint
    sprint_start = datetime.now() - timedelta(days=datetime.now().weekday())  # Monday of current week
    attendance_data = {}
    for user in users:
        user_email = user['primaryEmail']
        days_attended = fetch_user_rto_attendance(dir_service, user_email, sprint_start)
        attendance_data[user_email] = days_attended

    # Mock commit data (replace with actual Git API call)
    commit_data = {user['primaryEmail']: 42 for user in users}  # Placeholder

    # Calculate productivity
    productivity_report = calculate_team_productivity(attendance_data, commit_data)

    # Output report
    print(json.dumps(productivity_report, indent=2))

import { WebClient } from '@slack/web-api';
import { DateTime, Interval } from 'luxon';
import fetch from 'node-fetch';
import { writeFileSync } from 'fs';

// Meta RTO API configuration (internal endpoint, mocked for example)
const META_RTO_API_BASE = 'https://meta-rto-api.internal/v1';
const META_API_TOKEN = process.env.META_RTO_TOKEN || '';
const SLACK_TOKEN = process.env.SLACK_BOT_TOKEN || '';
const OFFICE_LOCATIONS = ['menlo-park', 'seattle', 'new-york'];

interface RtoShift {
  userId: string;
  date: string;
  location: string;
  startTime: string;
  endTime: string;
}

interface SlackUserProfile {
  id: string;
  email: string;
  tz: string;
}

class MetaRtoSlackSync {
  private slackClient: WebClient;
  private rtoCache: Map = new Map();

  constructor() {
    if (!META_API_TOKEN) throw new Error('META_RTO_TOKEN environment variable is required');
    if (!SLACK_TOKEN) throw new Error('SLACK_BOT_TOKEN environment variable is required');
    this.slackClient = new WebClient(SLACK_TOKEN);
  }

  /**
   * Fetch RTO shifts for a given date range from Meta's internal API
   */
  async fetchRtoShifts(startDate: DateTime, endDate: DateTime): Promise {
    const url = `${META_RTO_API_BASE}/shifts`;
    const params = new URLSearchParams({
      start_date: startDate.toISODate() || '',
      end_date: endDate.toISODate() || '',
      locations: OFFICE_LOCATIONS.join(',')
    });

    try {
      const response = await fetch(`${url}?${params}`, {
        headers: {
          'Authorization': `Bearer ${META_API_TOKEN}`,
          'Content-Type': 'application/json'
        }
      });

      if (!response.ok) {
        throw new Error(`Meta RTO API returned ${response.status}: ${await response.text()}`);
      }

      const data = await response.json() as { shifts: RtoShift[] };
      return data.shifts || [];
    } catch (error) {
      console.error(`Failed to fetch RTO shifts: ${error}`);
      throw error;
    }
  }

  /**
   * Sync RTO shifts to Slack user statuses
   */
  async syncShiftsToSlack(shifts: RtoShift[]): Promise {
    // Group shifts by user to avoid duplicate API calls
    const shiftsByUser = shifts.reduce((acc, shift) => {
      if (!acc[shift.userId]) acc[shift.userId] = [];
      acc[shift.userId].push(shift);
      return acc;
    }, {} as Record);

    for (const [userId, userShifts] of Object.entries(shiftsByUser)) {
      try {
        // Get Slack user ID from Meta user ID (assumes mapping exists)
        const slackUser = await this.getSlackUserFromMetaId(userId);
        if (!slackUser) {
          console.warn(`No Slack user found for Meta user ${userId}, skipping`);
          continue;
        }

        // Build status text from shifts
        const shiftDates = userShifts.map(s => DateTime.fromISO(s.date).toFormat('ccc, LLL d'));
        const statusText = `In office: ${shiftDates.join(', ')}`;
        const statusEmoji = ':office:';

        // Set Slack status for the shift interval
        const firstShift = userShifts[0];
        const lastShift = userShifts[userShifts.length - 1];
        const statusExpiration = DateTime.fromISO(lastShift.date).plus({ days: 1 }).toSeconds();

        await this.slackClient.users.profile.set({
          user: slackUser.id,
          profile: {
            status_text: statusText,
            status_emoji: statusEmoji,
            status_expiration: statusExpiration
          }
        });

        console.log(`Updated Slack status for ${slackUser.email}`);
      } catch (error) {
        console.error(`Failed to sync shifts for user ${userId}: ${error}`);
      }
    }
  }

  /**
   * Map Meta user ID to Slack user ID via email
   */
  private async getSlackUserFromMetaId(metaUserId: string): Promise {
    // Mock mapping: in production, use Meta's directory API to get user email
    const mockMetaToEmail: Record = {
      'meta-123': 'dev1@meta.com',
      'meta-456': 'dev2@meta.com'
    };
    const email = mockMetaToEmail[metaUserId];
    if (!email) return null;

    try {
      const response = await this.slackClient.users.lookupByEmail({ email });
      return response.user as unknown as SlackUserProfile;
    } catch (error) {
      console.error(`Slack user lookup failed for ${email}: ${error}`);
      return null;
    }
  }
}

// Main execution
(async () => {
  const sync = new MetaRtoSlackSync();
  const now = DateTime.now();
  const nextWeek = now.plus({ weeks: 1 });

  try {
    console.log('Fetching RTO shifts for next week...');
    const shifts = await sync.fetchRtoShifts(now, nextWeek);
    console.log(`Found ${shifts.length} shifts to sync`);

    await sync.syncShiftsToSlack(shifts);
    console.log('Sync complete');
  } catch (error) {
    console.error(`Fatal sync error: ${error}`);
    process.exit(1);
  }
})();

package main

import (
    "encoding/csv"
    "encoding/json"
    "fmt"
    "log"
    "os"
    "time"
)

// TeamMetric represents a single team's performance data
type TeamMetric struct {
    TeamName        string  `json:"team_name"`
    IsRemote        bool    `json:"is_remote"`
    MemberCount     int     `json:"member_count"`
    SprintCommits   int     `json:"sprint_commits"`
    MergeTimeHours  float64 `json:"merge_time_hours"`
    OnboardingCost  float64 `json:"onboarding_cost_usd"`
    BurnoutScore    float64 `json:"burnout_score"` // 1-10, 10 = highest burnout
}

// Report aggregates comparison data between remote and RTO teams
type Report struct {
    RemoteTeams     []TeamMetric `json:"remote_teams"`
    RtoTeams        []TeamMetric `json:"rto_teams"`
    AvgRemoteCommits float64     `json:"avg_remote_commits"`
    AvgRtoCommits   float64      `json:"avg_rto_commits"`
    CommitDiffPct   float64      `json:"commit_diff_pct"`
    AvgRemoteMerge  float64      `json:"avg_remote_merge_hours"`
    AvgRtoMerge     float64      `json:"avg_rto_merge_hours"`
    MergeDiffPct    float64      `json:"merge_diff_pct"`
}

func loadTeamMetrics(filepath string) ([]TeamMetric, error) {
    file, err := os.Open(filepath)
    if err != nil {
        return nil, fmt.Errorf("failed to open metrics file: %w", err)
    }
    defer file.Close()

    reader := csv.NewReader(file)
    records, err := reader.ReadAll()
    if err != nil {
        return nil, fmt.Errorf("failed to read CSV: %w", err)
    }

    // Skip header row
    var metrics []TeamMetric
    for i, record := range records[1:] {
        if len(record) < 7 {
            log.Printf("Skipping invalid row %d: insufficient columns", i+1)
            continue
        }

        var m TeamMetric
        m.TeamName = record[0]
        m.IsRemote = record[1] == "true"
        fmt.Sscanf(record[2], "%d", &m.MemberCount)
        fmt.Sscanf(record[3], "%d", &m.SprintCommits)
        fmt.Sscanf(record[4], "%f", &m.MergeTimeHours)
        fmt.Sscanf(record[5], "%f", &m.OnboardingCost)
        fmt.Sscanf(record[6], "%f", &m.BurnoutScore)

        metrics = append(metrics, m)
    }

    return metrics, nil
}

func generateReport(metrics []TeamMetric) Report {
    var remote, rto []TeamMetric
    var totalRemoteCommits, totalRtoCommits int
    var totalRemoteMerge, totalRtoMerge float64
    var remoteCount, rtoCount int

    for _, m := range metrics {
        if m.IsRemote {
            remote = append(remote, m)
            totalRemoteCommits += m.SprintCommits
            totalRemoteMerge += m.MergeTimeHours
            remoteCount++
        } else {
            r to = append(rto, m)
            totalRtoCommits += m.SprintCommits
            totalRtoMerge += m.MergeTimeHours
            r toCount++
        }
    }

    // Calculate averages
    avgRemoteCommits := float64(totalRemoteCommits) / float64(remoteCount)
    avgRtoCommits := float64(totalRtoCommits) / float64(rtoCount)
    commitDiffPct := ((avgRtoCommits - avgRemoteCommits) / avgRemoteCommits) * 100

    avgRemoteMerge := totalRemoteMerge / float64(remoteCount)
    avgRtoMerge := totalRtoMerge / float64(rtoCount)
    mergeDiffPct := ((avgRemoteMerge - avgRtoMerge) / avgRemoteMerge) * 100

    return Report{
        RemoteTeams:     remote,
        RtoTeams:        rto,
        AvgRemoteCommits: round(avgRemoteCommits, 2),
        AvgRtoCommits:   round(avgRtoCommits, 2),
        CommitDiffPct:   round(commitDiffPct, 2),
        AvgRemoteMerge:  round(avgRemoteMerge, 2),
        AvgRtoMerge:     round(avgRtoMerge, 2),
        MergeDiffPct:    round(mergeDiffPct, 2),
    }
}

func round(val float64, precision uint) float64 {
    ratio := pow(10, float64(precision))
    return float64(int(val*ratio+0.5)) / ratio
}

func pow(base, exponent float64) float64 {
    result := 1.0
    for i := 0; i < int(exponent); i++ {
        result *= base
    }
    return result
}

func saveReport(report Report, outputPath string) error {
    data, err := json.MarshalIndent(report, "", "  ")
    if err != nil {
        return fmt.Errorf("failed to marshal report: %w", err)
    }

    if err := os.WriteFile(outputPath, data, 0644); err != nil {
        return fmt.Errorf("failed to write report: %w", err)
    }

    return nil
}

func main() {
    start := time.Now()
    const metricsPath = "team_metrics.csv"
    const reportPath = "rto_comparison_report.json"

    // Load metrics
    metrics, err := loadTeamMetrics(metricsPath)
    if err != nil {
        log.Fatalf("Error loading metrics: %v", err)
    }

    // Generate report
    report := generateReport(metrics)

    // Save report
    if err := saveReport(report, reportPath); err != nil {
        log.Fatalf("Error saving report: %v", err)
    }

    // Print summary
    fmt.Printf("Report generated in %v\n", time.Since(start))
    fmt.Printf("Remote teams: %d, RTO teams: %d\n", len(report.RemoteTeams), len(report.RtoTeams))
    fmt.Printf("RTO teams have %.2f%% more commits per sprint\n", report.CommitDiffPct)
    fmt.Printf("RTO teams have %.2f%% faster merge times\n", report.MergeDiffPct)
}

# Short snippet to fetch RTO attendance for a single user
from google.oauth2 import service_account
from googleapiclient.discovery import build

SCOPES = ['https://www.googleapis.com/auth/admin.directory.user.readonly']
CREDS = service_account.Credentials.from_service_account_file('creds.json', scopes=SCOPES)

service = build('admin', 'directory_v1', credentials=CREDS.with_subject('admin@domain.com'))
result = service.users().get(userKey='dev@domain.com', fields='customSchemas').execute()
print(result.get('customSchemas', {}).get('rtoAttendance', {}))

// Short snippet to update Slack status with RTO shift
import { WebClient } from '@slack/web-api';

const slack = new WebClient(process.env.SLACK_TOKEN);
await slack.users.profile.set({
  user: 'U123456',
  profile: {
    status_text: 'In Menlo Park office today',
    status_emoji: ':office:',
    status_expiration: DateTime.now().plus({ hours: 8 }).toSeconds()
  }
});

# Short PromQL query to compare RTO vs remote sprint velocity
avg(
  sprint_commits_total{team="backend", rto="true"}
) by (team) 
/ 
avg(
  sprint_commits_total{team="backend", rto="false"}
) by (team)