How to Integrate Replit with RescueTime

1import os
2import requests
3from datetime import datetime, timedelta
4from typing import Optional
5
6API_KEY = os.environ["RESCUETIME_API_KEY"]
7BASE_URL = "https://www.rescuetime.com/anapi"
8
9def get_daily_summary(date: str = None) -> dict:
10    """
11    Get the productivity summary for a specific date.
12    date format: YYYY-MM-DD (defaults to yesterday)
13    """
14    if not date:
15        date = (datetime.now() - timedelta(days=1)).strftime("%Y-%m-%d")
16
17    params = {
18        "key": API_KEY,
19        "perspective": "interval",
20        "resolution_time": "day",
21        "restrict_begin": date,
22        "restrict_end": date,
23        "format": "json"
24    }
25    response = requests.get(f"{BASE_URL}/data", params=params)
26    response.raise_for_status()
27    return response.json()
28
29def get_activity_breakdown(restrict_begin: str, restrict_end: str,
30                           limit: int = 20) -> dict:
31    """
32    Get activities ranked by total time spent.
33    Returns applications and websites sorted by time.
34    """
35    params = {
36        "key": API_KEY,
37        "perspective": "rank",
38        "resolution_time": "day",
39        "restrict_begin": restrict_begin,
40        "restrict_end": restrict_end,
41        "restrict_kind": "activity",
42        "restrict_count": limit,
43        "format": "json"
44    }
45    response = requests.get(f"{BASE_URL}/data", params=params)
46    response.raise_for_status()
47    return response.json()
48
49def get_efficiency_data(restrict_begin: str, restrict_end: str) -> dict:
50    """Get productivity score data — time by productivity level."""
51    params = {
52        "key": API_KEY,
53        "perspective": "interval",
54        "resolution_time": "day",
55        "restrict_begin": restrict_begin,
56        "restrict_end": restrict_end,
57        "restrict_kind": "efficiency",
58        "format": "json"
59    }
60    response = requests.get(f"{BASE_URL}/data", params=params)
61    response.raise_for_status()
62    return response.json()
63
64def parse_daily_summary(data: dict) -> dict:
65    """Parse the raw API response into a readable summary dict."""
66    headers = data.get("row_headers", [])
67    rows = data.get("rows", [])
68    if not rows:
69        return {"message": "No data for this date"}
70
71    result = {}
72    for row in rows:
73        for i, header in enumerate(headers):
74            result[header] = row[i]
75    return result
76
77# Example usage
78if __name__ == "__main__":
79    yesterday = (datetime.now() - timedelta(days=1)).strftime("%Y-%m-%d")
80    print(f"Fetching RescueTime data for {yesterday}...\n")
81
82    summary = get_daily_summary(yesterday)
83    parsed = parse_daily_summary(summary)
84    print("Yesterday's summary:")
85    for key, value in parsed.items():
86        print(f"  {key}: {value}")
87
88    print("\nTop 10 activities:")
89    activities = get_activity_breakdown(yesterday, yesterday)
90    headers = activities.get("row_headers", [])
91    for row in activities.get("rows", [])[:10]:
92        activity = dict(zip(headers, row))
93        seconds = activity.get("Time Spent (seconds)", 0)
94        name = activity.get("Activity", "Unknown")
95        print(f"  {name}: {seconds // 3600}h {(seconds % 3600) // 60}m")

1const express = require('express');
2const axios = require('axios');
3
4const app = express();
5app.use(express.json());
6
7const API_KEY = process.env.RESCUETIME_API_KEY;
8const BASE_URL = 'https://www.rescuetime.com/anapi';
9
10function formatDate(date) {
11  return date.toISOString().split('T')[0];
12}
13
14async function fetchRescueTime(params) {
15  const response = await axios.get(`${BASE_URL}/data`, {
16    params: { key: API_KEY, format: 'json', ...params }
17  });
18  return response.data;
19}
20
21// Get summary for a specific date (defaults to yesterday)
22app.get('/summary', async (req, res) => {
23  const date = req.query.date || formatDate(new Date(Date.now() - 86400000));
24  try {
25    const data = await fetchRescueTime({
26      perspective: 'interval',
27      resolution_time: 'day',
28      restrict_begin: date,
29      restrict_end: date
30    });
31    const headers = data.row_headers || [];
32    const rows = (data.rows || []).map(row => {
33      const obj = {};
34      headers.forEach((h, i) => { obj[h] = row[i]; });
35      return obj;
36    });
37    res.json({ date, summary: rows });
38  } catch (err) {
39    console.error('Summary error:', err.message);
40    res.status(500).json({ error: err.message });
41  }
42});
43
44// Get weekly productivity trend (last 7 days)
45app.get('/trend', async (req, res) => {
46  const endDate = new Date();
47  const startDate = new Date(Date.now() - 7 * 86400000);
48  try {
49    const data = await fetchRescueTime({
50      perspective: 'interval',
51      resolution_time: 'day',
52      restrict_begin: formatDate(startDate),
53      restrict_end: formatDate(endDate),
54      restrict_kind: 'efficiency'
55    });
56    const headers = data.row_headers || [];
57    const trend = (data.rows || []).map(row => {
58      const obj = {};
59      headers.forEach((h, i) => { obj[h] = row[i]; });
60      return obj;
61    });
62    res.json({ trend, period: '7d' });
63  } catch (err) {
64    res.status(500).json({ error: err.message });
65  }
66});
67
68// Get top activities ranked by time
69app.get('/activities', async (req, res) => {
70  const { date, limit = 15 } = req.query;
71  const targetDate = date || formatDate(new Date(Date.now() - 86400000));
72  try {
73    const data = await fetchRescueTime({
74      perspective: 'rank',
75      resolution_time: 'day',
76      restrict_begin: targetDate,
77      restrict_end: targetDate,
78      restrict_kind: 'activity',
79      restrict_count: parseInt(limit)
80    });
81    const headers = data.row_headers || [];
82    const activities = (data.rows || []).map(row => {
83      const obj = {};
84      headers.forEach((h, i) => { obj[h] = row[i]; });
85      const seconds = obj['Time Spent (seconds)'] || 0;
86      return {
87        activity: obj['Activity'],
88        category: obj['Category'],
89        productivity: obj['Productivity'],
90        hours: Math.floor(seconds / 3600),
91        minutes: Math.floor((seconds % 3600) / 60)
92      };
93    });
94    res.json({ date: targetDate, activities });
95  } catch (err) {
96    res.status(500).json({ error: err.message });
97  }
98});
99
100app.get('/health', (req, res) => res.json({ status: 'ok' }));
101
102app.listen(3000, '0.0.0.0', () => {
103  console.log('RescueTime dashboard server running on port 3000');
104});

1#!/usr/bin/env python3
2"""
3Daily productivity digest — designed to run as a scheduled task.
4Schedule: daily at 07:00 UTC in Replit Scheduled deployment.
5"""
6import os
7import requests
8from datetime import datetime, timedelta
9
10API_KEY = os.environ["RESCUETIME_API_KEY"]
11# Optional: SLACK_WEBHOOK_URL for sending to Slack
12SLACK_WEBHOOK = os.environ.get("SLACK_WEBHOOK_URL", "")
13
14def fetch_summary(date: str) -> dict:
15    response = requests.get(
16        "https://www.rescuetime.com/anapi/data",
17        params={
18            "key": API_KEY,
19            "perspective": "rank",
20            "resolution_time": "day",
21            "restrict_begin": date,
22            "restrict_end": date,
23            "restrict_kind": "activity",
24            "restrict_count": 5,
25            "format": "json"
26        }
27    )
28    response.raise_for_status()
29    return response.json()
30
31def fetch_efficiency(date: str) -> dict:
32    response = requests.get(
33        "https://www.rescuetime.com/anapi/data",
34        params={
35            "key": API_KEY,
36            "perspective": "interval",
37            "resolution_time": "day",
38            "restrict_begin": date,
39            "restrict_end": date,
40            "restrict_kind": "efficiency",
41            "format": "json"
42        }
43    )
44    response.raise_for_status()
45    return response.json()
46
47def generate_report(date: str) -> str:
48    lines = [f"RescueTime Daily Digest — {date}"]
49    lines.append("-" * 40)
50
51    efficiency = fetch_efficiency(date)
52    eff_headers = efficiency.get("row_headers", [])
53    for row in efficiency.get("rows", []):
54        eff = dict(zip(eff_headers, row))
55        total = eff.get("Total Seconds Logged", 0)
56        prod = eff.get("Very Productive + Productive Time (seconds)", 0)
57        score = eff.get("Productivity Pulse", 0)
58        lines.append(f"Productivity score: {score}/100")
59        lines.append(f"Total tracked: {total // 3600}h {(total % 3600) // 60}m")
60        lines.append(f"Productive time: {prod // 3600}h {(prod % 3600) // 60}m")
61
62    lines.append("\nTop 5 activities:")
63    activities = fetch_summary(date)
64    act_headers = activities.get("row_headers", [])
65    for i, row in enumerate(activities.get("rows", [])[:5], 1):
66        act = dict(zip(act_headers, row))
67        seconds = act.get("Time Spent (seconds)", 0)
68        name = act.get("Activity", "Unknown")
69        lines.append(f"  {i}. {name}: {seconds // 3600}h {(seconds % 3600) // 60}m")
70
71    return "\n".join(lines)
72
73if __name__ == "__main__":
74    yesterday = (datetime.now() - timedelta(days=1)).strftime("%Y-%m-%d")
75    report = generate_report(yesterday)
76    print(report)
77
78    if SLACK_WEBHOOK:
79        requests.post(SLACK_WEBHOOK, json={"text": f"```{report}```"})
80        print("\nReport sent to Slack.")