Merge pull request #33 from Penn-Electric-Racing/ops-tasks-digest

Add Sunday Ops-tasks digest DM

Author: arjunsharma6251

.github/workflows/ops-tasks-digest.yml

@@ -0,0 +1,48 @@
+name: Ops Tasks — Sunday Digest DM
+
+# Sunday ~10am ET: DM each Ops member their own open tasks from the Ops Tasks Notion
+# database (🔴 past due, "carried N wks" on rollovers). DMs only — never a channel post.
+# Two cron triggers cover the EDT/EST offset; the script's isSunday10amET() time-check
+# makes double-fires safe. Members with nothing open get no DM (silence is valid).
+on:
+  schedule:
+    - cron: '0 14 * * 0' # 10am EDT
+    - cron: '0 15 * * 0' # 10am EST
+  workflow_dispatch:
+    inputs:
+      force:
+        description: 'Run even if it is not Sunday 10am ET'
+        type: boolean
+        default: false
+      dry_run:
+        description: 'Print the DMs to the log instead of sending them'
+        type: boolean
+        default: false
+
+jobs:
+  ops-digest:
+    runs-on: ubuntu-latest
+    concurrency:
+      group: ops-tasks-digest
+      cancel-in-progress: false
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+          cache: 'npm'
+          cache-dependency-path: PERBot/package-lock.json
+
+      - name: Install dependencies
+        working-directory: PERBot
+        run: npm ci
+
+      - name: DM members their open Ops tasks
+        working-directory: PERBot
+        run: npm run job:ops-digest
+        env:
+          SLACK_BOT_TOKEN: ${{ secrets.SLACK_BOT_TOKEN }}
+          NOTION_API_KEY: ${{ secrets.NOTION_API_KEY }}
+          FORCE_OPS_DIGEST: ${{ inputs.force }}
+          OPS_DIGEST_DRY_RUN: ${{ inputs.dry_run }}

PERBot/package.json

@@ -19,6 +19,7 @@
     "job:sponsor-digest": "tsx src/sponsorship/jobs/weeklyDigest.ts",
     "job:sponsor-quota": "tsx src/sponsorship/jobs/quotaAudit.ts",
     "job:sponsor-dri-sync": "tsx src/sponsorship/jobs/driSync.ts",
+    "job:ops-digest": "tsx src/opsTasks/digest.ts",
     "check": "tsc --noEmit"
   },
   "dependencies": {

PERBot/src/config.ts

@@ -94,6 +94,16 @@ export const config = {
     quotaChannel: optionalString('SPONSOR_QUOTA_CHANNEL', 'perbot_spam'),
     weeklyQuota: optionalNumber('SPONSOR_WEEKLY_QUOTA', 3),
   },
+  opsTasks: {
+    // Ops Tasks database under REV12 Operations (see CLAUDE.md "Notion IDs"): one row per
+    // action item a member types under their name on the Saturday meeting page.
+    dataSourceId: optionalString('OPS_TASKS_DS_ID', 'a8afc6ec-29d6-4308-b779-ad4235b35e80'),
+    // The database's "My open" view (Owner = me, Status != Done) — linked from the digest DM.
+    myOpenViewUrl: optionalString(
+      'OPS_TASKS_MY_OPEN_URL',
+      'https://www.notion.so/20cbf9381bcb45f99125e1468de321a3?v=3d8560bcc0398150b213000c6479f533'
+    ),
+  },
   github: {
     token: process.env.GITHUB_TOKEN?.trim() || '',
     repo: optionalString('GITHUB_REPO', 'Penn-Electric-Racing/PERBot'),

PERBot/src/opsTasks/digest.ts

@@ -0,0 +1,139 @@
+import { config } from '../config.js';
+import { logger } from '../utils/logger.js';
+import { daysUntil, todayIsoET } from '../sponsorship/dates.js';
+import { fetchSlackDirectory, notionUserToSlackId } from '../sponsorship/identity.js';
+import { makeSlackClient } from '../sponsorship/jobs/shared.js';
+import { OpsTask, OpsTasksNotion } from './notion.js';
+
+/**
+ * Sunday 10 AM ET Ops-tasks digest — DMs ONLY, never a channel post (Arjun's call,
+ * 2026-09-11). Each Ops member with an open task in the Ops Tasks database gets one
+ * short DM listing exactly their own open tasks: 🔴 on anything past Due, and a
+ * "carried N wks" tag on anything assigned before the most recent Saturday. Members
+ * with nothing open get nothing (silence is valid).
+ *
+ * Why "everything open" rather than "assigned this week": a Status-based query can't go
+ * silent if a meeting page is created late or a task never gets linked to a meeting, and
+ * it is the honest picture anyway.
+ *
+ * Idempotency: two DST cron triggers, and only the one landing on 10am ET does the work
+ * (same pattern as the sponsorship digest). DMs post straight to the user ID.
+ */
+
+/** Seed rows created so Notion would show every member's group; skipped until renamed. */
+export const PLACEHOLDER_RE = /^rename me/i;
+
+function isSunday10amET(): boolean {
+  const now = new Date();
+  const weekday = now.toLocaleDateString('en-US', { weekday: 'long', timeZone: 'America/New_York' });
+  const hour = Number(now.toLocaleString('en-US', { hour: '2-digit', hour12: false, timeZone: 'America/New_York' }));
+  return weekday === 'Sunday' && hour === 10;
+}
+
+export function isPlaceholder(task: OpsTask): boolean {
+  return task.title === '' || PLACEHOLDER_RE.test(task.title);
+}
+
+/** Whole Saturday meetings that have passed since the task was assigned (0 = fresh). */
+export function carriedWeeks(task: OpsTask): number {
+  if (!task.week) return 0;
+  const age = -daysUntil(task.week);
+  return age > 0 ? Math.floor(age / 7) : 0;
+}
+
+export function isOverdue(task: OpsTask): boolean {
+  return task.due !== null && daysUntil(task.due) < 0;
+}
+
+/** "9/19" — matches how the meeting pages are named. */
+function shortDate(iso: string): string {
+  const [, m, d] = iso.split('-');
+  return `${Number(m)}/${Number(d)}`;
+}
+
+/** Overdue first (oldest due first), then by due date, undated last. */
+export function sortTasks(tasks: OpsTask[]): OpsTask[] {
+  return [...tasks].sort((a, b) => {
+    const ao = isOverdue(a) ? 0 : 1;
+    const bo = isOverdue(b) ? 0 : 1;
+    if (ao !== bo) return ao - bo;
+    return (a.due ?? '9999').localeCompare(b.due ?? '9999');
+  });
+}
+
+export function taskLine(task: OpsTask): string {
+  const link = `<${task.url}|${task.title}>`;
+  const parts: string[] = [];
+  if (task.due) parts.push(`due ${shortDate(task.due)}${isOverdue(task) ? ' 🔴 overdue' : ''}`);
+  else parts.push('no due date');
+  const carried = carriedWeeks(task);
+  if (carried >= 1) parts.push(`carried ${carried} wk${carried === 1 ? '' : 's'}`);
+  return `• ${link} — ${parts.join(' · ')}`;
+}
+
+export function buildDigest(tasks: OpsTask[]): string {
+  const sorted = sortTasks(tasks);
+  const overdue = sorted.filter(isOverdue).length;
+  const header = `:clipboard: *Your open Ops tasks (${sorted.length}${overdue > 0 ? `, ${overdue} overdue` : ''})*`;
+  const footer = `_Set Status → Done in Notion as you finish — Saturday's walkthrough runs off this list. <${config.opsTasks.myOpenViewUrl}|My open>_`;
+  return [header, ...sorted.map(taskLine), footer].join('\n');
+}
+
+export async function runOpsDigest(force = process.env.FORCE_OPS_DIGEST?.toLowerCase() === 'true'): Promise<void> {
+  if (!force && !isSunday10amET()) {
+    logger.info('Ops digest: not Sunday 10am (ET) and not forced — skipping.');
+    return;
+  }
+  const dryRun = process.env.OPS_DIGEST_DRY_RUN?.toLowerCase() === 'true';
+
+  const notion = new OpsTasksNotion();
+  const open = await notion.queryOpenTasks();
+  const real = open.filter((t) => !isPlaceholder(t));
+  logger.info(`Ops digest (${todayIsoET()}): ${open.length} open rows, ${open.length - real.length} placeholders skipped.`);
+
+  // One list per owner; a co-owned task appears in every owner's DM.
+  const byOwner = new Map<string, { owner: OpsTask['owners'][number]; tasks: OpsTask[] }>();
+  for (const task of real) {
+    if (task.owners.length === 0) {
+      logger.warn(`Ops digest: "${task.title}" has no Owner — nobody to DM.`);
+      continue;
+    }
+    for (const owner of task.owners) {
+      const entry = byOwner.get(owner.id) ?? { owner, tasks: [] };
+      entry.tasks.push(task);
+      byOwner.set(owner.id, entry);
+    }
+  }
+  if (byOwner.size === 0) {
+    logger.info('Ops digest: nobody has open tasks — nothing to send.');
+    return;
+  }
+
+  const client = makeSlackClient();
+  const slackDir = await fetchSlackDirectory(client);
+
+  for (const { owner, tasks } of byOwner.values()) {
+    const slackUserId = await notionUserToSlackId(client, owner, slackDir);
+    const label = owner.name || owner.email || owner.id;
+    if (!slackUserId) {
+      logger.warn(`Ops digest: no Slack match for ${label} — skipping ${tasks.length} task(s).`);
+      continue;
+    }
+    const text = buildDigest(tasks);
+    if (dryRun) {
+      logger.info(`Ops digest (dry run) → ${label} (${slackUserId}):\n${text}`);
+      continue;
+    }
+    await client.chat.postMessage({ channel: slackUserId, text, unfurl_links: false });
+    logger.info(`Ops digest: sent ${tasks.length} task(s) to ${label}.`);
+  }
+}
+
+// Entrypoint when run directly (GitHub Actions).
+const isMain = process.argv[1] && import.meta.url === `file://${process.argv[1]}`;
+if (isMain) {
+  runOpsDigest().catch((err) => {
+    logger.error('Ops digest job failed.', err);
+    process.exitCode = 1;
+  });
+}

PERBot/src/opsTasks/notion.ts

@@ -0,0 +1,105 @@
+import { Client } from '@notionhq/client';
+import { config } from '../config.js';
+
+/**
+ * Read-only Notion access for the Ops Tasks database (child of "REV12 Operations").
+ * One row = one action item a member typed under their own name on a Saturday meeting
+ * page. Schema: Task (title) · Owner (person) · Status (Not started / In progress /
+ * Done) · Due (date, convention = next Saturday) · Week (date, the Saturday it was
+ * assigned) · Created. Only Status matters for "open": anything not Done is open.
+ */
+
+export interface OpsTaskOwner {
+  id: string;
+  name: string;
+  email: string | null;
+}
+
+export interface OpsTask {
+  id: string;
+  url: string;
+  title: string;
+  status: string;
+  /** YYYY-MM-DD or null when the member left Due blank. */
+  due: string | null;
+  /**
+   * YYYY-MM-DD the task was assigned at. Prefers the "Meeting date" rollup (from the
+   * Meeting relation set automatically inside a meeting page), then the legacy hand-set
+   * Week date, then the row's Created time — so carried-week counts never go blank.
+   */
+  week: string | null;
+  owners: OpsTaskOwner[];
+}
+
+function readTitle(prop: any): string {
+  return (prop?.title ?? []).map((t: any) => t?.plain_text ?? '').join('').trim();
+}
+function readDate(prop: any): string | null {
+  const start = prop?.date?.start;
+  return typeof start === 'string' ? start.slice(0, 10) : null;
+}
+/** A date rollup ("show original") arrives as rollup.date or rollup.array[0].date. */
+function readRollupDate(prop: any): string | null {
+  const r = prop?.rollup;
+  if (!r) return null;
+  if (r.type === 'date') return readDate(r);
+  if (r.type === 'array') {
+    for (const item of r.array ?? []) {
+      const d = readDate(item);
+      if (d) return d;
+    }
+  }
+  return null;
+}
+function readCreated(page: any): string | null {
+  const t = page?.created_time;
+  return typeof t === 'string' ? t.slice(0, 10) : null;
+}
+function readOwners(prop: any): OpsTaskOwner[] {
+  return (prop?.people ?? [])
+    .filter((p: any) => typeof p?.id === 'string')
+    .map((p: any) => ({
+      id: p.id as string,
+      name: typeof p.name === 'string' ? p.name : '',
+      // Present when the integration has the "read user emails" capability (it does).
+      email: typeof p?.person?.email === 'string' ? p.person.email : null,
+    }));
+}
+
+export function parseOpsTask(page: any): OpsTask {
+  const p = page?.properties ?? {};
+  return {
+    id: page.id,
+    url: page.url ?? '',
+    title: readTitle(p['Task']),
+    status: p['Status']?.status?.name ?? '',
+    due: readDate(p['Due']),
+    week: readRollupDate(p['Meeting date']) ?? readDate(p['Week']) ?? readCreated(page),
+    owners: readOwners(p['Owner']),
+  };
+}
+
+export class OpsTasksNotion {
+  private client: Client;
+
+  constructor(token: string = config.notion.token) {
+    this.client = new Client({ auth: token, notionVersion: config.notion.apiVersion });
+  }
+
+  /** Every row whose Status is not Done (paginated). */
+  async queryOpenTasks(): Promise<OpsTask[]> {
+    const tasks: OpsTask[] = [];
+    let cursor: string | undefined;
+    do {
+      const response: any = await this.client.dataSources.query({
+        data_source_id: config.opsTasks.dataSourceId,
+        filter: { property: 'Status', status: { does_not_equal: 'Done' } },
+        page_size: 100,
+        start_cursor: cursor,
+      });
+      for (const page of response.results ?? []) tasks.push(parseOpsTask(page));
+      cursor = response.has_more ? response.next_cursor ?? undefined : undefined;
+    } while (cursor);
+    return tasks;
+  }
+}