Merge pull request #44 from Penn-Electric-Racing/ops-tasks-link-meeting

Ops tasks: link every task to its meeting page

Author: arjunsharma6251

PERBot/src/config.ts

@@ -101,6 +101,9 @@ export const config = {
     // 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'),
+    // Ops Meetings database (one row per Saturday meeting page, Date property). Tasks link to a
+    // row via the `Meeting` relation; each page's "This week" table filters on that relation.
+    meetingsDataSourceId: optionalString('OPS_MEETINGS_DS_ID', 'f0e637cd-db29-4a8d-883f-c8c5603db02f'),
     // The database's "My open" view (Owner = me, Status != Done) — linked from the digest DM.
     myOpenViewUrl: optionalString(
       'OPS_TASKS_MY_OPEN_URL',

PERBot/src/opsTasks/__tests__/meetings.test.ts

@@ -0,0 +1,47 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { pickMeeting, saturdayOnOrAfter } from '../meetings.js';
+
+test('saturdayOnOrAfter: weekdays roll forward, Saturday stays put', () => {
+  assert.equal(saturdayOnOrAfter('2026-09-13'), '2026-09-19'); // Sunday
+  assert.equal(saturdayOnOrAfter('2026-09-14'), '2026-09-19'); // Monday
+  assert.equal(saturdayOnOrAfter('2026-09-18'), '2026-09-19'); // Friday
+  assert.equal(saturdayOnOrAfter('2026-09-19'), '2026-09-19'); // Saturday
+  assert.equal(saturdayOnOrAfter('2026-09-19T21:30:00.000Z'), '2026-09-19'); // datetime tolerated
+});
+
+const meetings = [
+  { id: 'm0919', date: '2026-09-19' },
+  { id: 'm0912', date: '2026-09-12' },
+  { id: 'm0829', date: '2026-08-29' },
+];
+
+test('pickMeeting: a mid-week task belongs to the coming Saturday', () => {
+  assert.equal(pickMeeting(meetings, '2026-09-14')?.id, 'm0919');
+  assert.equal(pickMeeting(meetings, '2026-09-13')?.id, 'm0919');
+});
+
+test('pickMeeting: a task dated on the Saturday belongs to that meeting', () => {
+  assert.equal(pickMeeting(meetings, '2026-09-12')?.id, 'm0912');
+  assert.equal(pickMeeting(meetings, '2026-09-19')?.id, 'm0919');
+});
+
+test('pickMeeting: never links to a past meeting or a later week', () => {
+  assert.equal(pickMeeting(meetings, '2026-09-20'), null); // Sunday after the last page
+  assert.equal(pickMeeting(meetings, '2026-09-05'), null); // week with no page (9/5 skipped)
+  assert.equal(pickMeeting([], '2026-09-14'), null);
+});
+
+test('pickMeeting: a page stamped with its Sunday creation time still counts for that week', () => {
+  const sundayStamped = [{ id: 'm0919', date: '2026-09-19' }, { id: 'm0926', date: '2026-09-20T13:00:00.000Z' }];
+  assert.equal(pickMeeting(sundayStamped, '2026-09-21')?.id, 'm0926'); // Monday → the page created Sunday
+  assert.equal(pickMeeting(sundayStamped, '2026-09-26')?.id, 'm0926'); // the Saturday itself
+  assert.equal(pickMeeting(sundayStamped, '2026-09-19')?.id, 'm0919'); // previous week unaffected
+  assert.equal(pickMeeting(sundayStamped, '2026-09-27'), null); // following week has no page yet
+});
+
+test('pickMeeting: a Thursday-stamped page (old repeat schedule) maps to its Saturday', () => {
+  const odd = [{ id: 'thu', date: '2026-09-17' }];
+  assert.equal(pickMeeting(odd, '2026-09-14')?.id, 'thu');
+  assert.equal(pickMeeting(odd, '2026-09-19')?.id, 'thu');
+});

PERBot/src/opsTasks/assign.ts

@@ -114,7 +114,17 @@ async function createAndAnnounce(
   client: WebClient,
   opts: { assignerSlackId: string; assigneeSlackIds: string[]; ownerNotionIds: string[]; task: string; dueIso: string | null }
 ): Promise<{ task: OpsTask; publicText: string }> {
-  const task = await notion.createTask({ title: opts.task, ownerIds: opts.ownerNotionIds, dueIso: opts.dueIso });
+  // Link to the week's meeting page so the task shows under "This week" there. The page is
+  // created ahead of time by the repeating template; if it isn't there yet the task is
+  // created unlinked and the Sunday digest links it once the page exists.
+  let meetingId: string | null = null;
+  try {
+    meetingId = (await notion.meetingForDate(todayIsoET()))?.id ?? null;
+    if (!meetingId) logger.warn(`/assign: no Ops Meetings page for the week of ${todayIsoET()} yet — creating "${opts.task}" unlinked.`);
+  } catch (err) {
+    logger.warn('/assign: meeting lookup failed — creating the task unlinked.', err);
+  }
+  const task = await notion.createTask({ title: opts.task, ownerIds: opts.ownerNotionIds, dueIso: opts.dueIso, meetingId });
   const who = opts.assigneeSlackIds.map((id) => `<@${id}>`).join(', ');
   const publicText = `:pushpin: <@${opts.assignerSlackId}> assigned ${who}: *${task.title}*${task.due ? ` · due ${shortDate(task.due)}` : ''} · <${task.url}|Open in Notion>`;
   for (const assignee of opts.assigneeSlackIds) {

PERBot/src/opsTasks/digest.ts

@@ -6,6 +6,7 @@ import { fetchSlackDirectory, notionUserToSlackId } from '../sponsorship/identit
 import { makeSlackClient } from '../sponsorship/jobs/shared.js';
 import { buildDigestBlocks } from './blocks.js';
 import { isOverdue, sortTasks, taskLine } from './format.js';
+import { pickMeeting } from './meetings.js';
 import { OpsTask, OpsTasksNotion } from './notion.js';
 
 // Formatting helpers live in format.ts (shared with blocks.ts); re-exported for existing importers.
@@ -34,6 +35,37 @@ export function isPlaceholder(task: OpsTask): boolean {
   return task.title === '' || PLACEHOLDER_RE.test(task.title);
 }
 
+/**
+ * Link open tasks that have no Meeting relation to the meeting page their date falls in
+ * (see meetings.ts). Such tasks come from `/assign` runs before the week's page existed and
+ * from rows added on the old Week-filtered pages; unlinked, they never appear in any
+ * "This week" table and look carried over on every page. Mutates the passed tasks so the
+ * DMs sent right after use the linked meeting's date for "carried N wks". Returns the count.
+ */
+export async function linkOrphanTasks(notion: OpsTasksNotion, tasks: OpsTask[], dryRun = false): Promise<number> {
+  const orphans = tasks.filter((t) => t.meetingIds.length === 0 && t.week);
+  if (orphans.length === 0) return 0;
+  const meetings = await notion.listMeetings();
+  let linked = 0;
+  for (const task of orphans) {
+    const meeting = pickMeeting(meetings, task.week!);
+    if (!meeting) {
+      logger.info(`Ops digest: "${task.title}" (dated ${task.week}) has no meeting page to link to yet.`);
+      continue;
+    }
+    try {
+      if (!dryRun) await notion.linkMeeting(task, meeting.id);
+      task.meetingIds.push(meeting.id);
+      task.week = meeting.date;
+      linked++;
+    } catch (err) {
+      logger.warn(`Ops digest: could not link "${task.title}" to meeting ${meeting.date}.`, err);
+    }
+  }
+  logger.info(`Ops digest: linked ${linked}/${orphans.length} unlinked task(s) to their meeting page${dryRun ? ' (dry run)' : ''}.`);
+  return linked;
+}
+
 export function buildDigest(tasks: OpsTask[]): string {
   const sorted = sortTasks(tasks);
   const overdue = sorted.filter(isOverdue).length;
@@ -55,6 +87,7 @@ export async function runOpsDigest(force = process.env.FORCE_OPS_DIGEST?.toLower
   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.`);
+  await linkOrphanTasks(notion, real, dryRun);
 
   // 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[] }>();

PERBot/src/opsTasks/meetings.ts

@@ -0,0 +1,39 @@
+import { isoAddDays } from '../sponsorship/dates.js';
+
+/**
+ * Which Saturday meeting page a task belongs to. Pure helpers (no Notion) so they're
+ * testable; `OpsTasksNotion` supplies the meeting list.
+ *
+ * Rule: a task dated D (created / assigned on D) belongs to the first meeting on or after
+ * D, up to and including the Saturday of that week. So something assigned from Slack on
+ * Monday lands in the coming Saturday's "This week" table instead of looking carried, and
+ * something typed on the Saturday itself belongs to that day's meeting.
+ */
+
+export interface OpsMeeting {
+  id: string;
+  /** YYYY-MM-DD from the meeting row's Date property. */
+  date: string;
+}
+
+/** The Saturday on or after `iso` (YYYY-MM-DD); `iso` itself when it is a Saturday. */
+export function saturdayOnOrAfter(iso: string): string {
+  const day = iso.slice(0, 10);
+  const dow = new Date(`${day}T12:00:00Z`).getUTCDay();
+  return isoAddDays(day, (6 - dow + 7) % 7);
+}
+
+/**
+ * The meeting a task anchored at `anchorIso` belongs to: the meeting page whose Date falls
+ * in the same Sunday–Saturday week as the anchor (earliest such page if several). Matching
+ * by week, not exact date, tolerates the repeating template stamping Date with the page's
+ * creation moment (Sunday morning) before the lead sets it to the Saturday. `null` when no
+ * page for that week exists yet.
+ */
+export function pickMeeting(meetings: OpsMeeting[], anchorIso: string): OpsMeeting | null {
+  const week = saturdayOnOrAfter(anchorIso);
+  const candidates = meetings
+    .filter((m) => saturdayOnOrAfter(m.date) === week)
+    .sort((a, b) => a.date.localeCompare(b.date));
+  return candidates[0] ?? null;
+}

PERBot/src/opsTasks/notion.ts

@@ -1,15 +1,20 @@
 import { Client } from '@notionhq/client';
 import { config } from '../config.js';
 import { logger } from '../utils/logger.js';
+import { OpsMeeting, pickMeeting } from './meetings.js';
 
 /**
  * Notion access for the Ops Tasks database (child of "REV12 Operations"). Reads feed the
  * Sunday digest; the small writers below back the digest's Slack buttons (Done / In
  * progress / Push a week) so members can update from Slack instead of opening Notion.
  * 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.
+ * Done) · Due (date, convention = next Saturday) · Meeting (relation → Ops Meetings row;
+ * the meeting page's "This week" table is `Meeting contains this page`, its "Carried over"
+ * table is `Status ≠ Done AND Meeting does not contain this page`) · Week (legacy date) ·
+ * Created. Only Status matters for "open": anything not Done is open. A task with NO
+ * Meeting never appears in any "This week" table and looks carried on every page, so the
+ * Slack writers link it (see `meetingForDate`) and the digest relinks stragglers.
  */
 
 export interface OpsTaskOwner {
@@ -32,6 +37,8 @@ export interface OpsTask {
    */
   week: string | null;
   owners: OpsTaskOwner[];
+  /** Ops Meetings row ids in the Meeting relation (empty = not linked to any meeting page). */
+  meetingIds: string[];
 }
 
 function readTitle(prop: any): string {
@@ -58,6 +65,9 @@ function readCreated(page: any): string | null {
   const t = page?.created_time;
   return typeof t === 'string' ? t.slice(0, 10) : null;
 }
+function readRelationIds(prop: any): string[] {
+  return (prop?.relation ?? []).map((r: any) => r?.id).filter((id: any) => typeof id === 'string');
+}
 function readOwners(prop: any): OpsTaskOwner[] {
   return (prop?.people ?? [])
     .filter((p: any) => typeof p?.id === 'string')
@@ -79,9 +89,15 @@ export function parseOpsTask(page: any): OpsTask {
     due: readDate(p['Due']),
     week: readRollupDate(p['Meeting date']) ?? readDate(p['Week']) ?? readCreated(page),
     owners: readOwners(p['Owner']),
+    meetingIds: readRelationIds(p['Meeting']),
   };
 }
 
+function parseMeeting(page: any): OpsMeeting | null {
+  const date = readDate(page?.properties?.['Date']);
+  return date ? { id: page.id, date } : null;
+}
+
 export class OpsTasksNotion {
   private client: Client;
 
@@ -106,19 +122,52 @@ export class OpsTasksNotion {
     return tasks;
   }
 
-  /** Create a task (powers `/assign`): Status = Not started, Owner(s), optional Due. Not linked to a meeting page. */
-  async createTask(input: { title: string; ownerIds: string[]; dueIso: string | null }): Promise<OpsTask> {
+  /** Every Ops Meetings row with a Date, oldest first (a handful of rows — no need to filter server-side). */
+  async listMeetings(): Promise<OpsMeeting[]> {
+    const meetings: OpsMeeting[] = [];
+    let cursor: string | undefined;
+    do {
+      const response: any = await this.client.dataSources.query({
+        data_source_id: config.opsTasks.meetingsDataSourceId,
+        filter: { property: 'Date', date: { is_not_empty: true } },
+        sorts: [{ property: 'Date', direction: 'ascending' }],
+        page_size: 100,
+        start_cursor: cursor,
+      });
+      for (const page of response.results ?? []) {
+        const m = parseMeeting(page);
+        if (m) meetings.push(m);
+      }
+      cursor = response.has_more ? response.next_cursor ?? undefined : undefined;
+    } while (cursor);
+    return meetings;
+  }
+
+  /** The meeting page a task dated `anchorIso` belongs to (see meetings.ts), or null if that page doesn't exist yet. */
+  async meetingForDate(anchorIso: string): Promise<OpsMeeting | null> {
+    return pickMeeting(await this.listMeetings(), anchorIso);
+  }
+
+  /**
+   * Create a task (powers `/assign`): Status = Not started, Owner(s), optional Due, and the
+   * Meeting relation when the caller found the week's page (so it shows in that page's
+   * "This week" table instead of looking carried over).
+   */
+  async createTask(input: { title: string; ownerIds: string[]; dueIso: string | null; meetingId?: string | null }): Promise<OpsTask> {
     const properties: Record<string, any> = {
       Task: { title: [{ text: { content: input.title.slice(0, 200) } }] },
       Owner: { people: input.ownerIds.map((id) => ({ id })) },
       Status: { status: { name: 'Not started' } },
     };
     if (input.dueIso) properties['Due'] = { date: { start: input.dueIso } };
+    if (input.meetingId) properties['Meeting'] = { relation: [{ id: input.meetingId }] };
     const page: any = await this.client.pages.create({
       parent: { type: 'data_source_id', data_source_id: config.opsTasks.dataSourceId },
       properties: properties as any,
     });
-    logger.info(`Ops task created: "${input.title}" → ${input.ownerIds.length} owner(s), due ${input.dueIso ?? 'none'}.`);
+    logger.info(
+      `Ops task created: "${input.title}" → ${input.ownerIds.length} owner(s), due ${input.dueIso ?? 'none'}, meeting ${input.meetingId ?? 'none'}.`
+    );
     return parseOpsTask(page);
   }
 
@@ -134,6 +183,14 @@ export class OpsTasksNotion {
     logger.info(`Ops task ${pageId} → Status ${status}.`);
   }
 
+  /** Add a meeting page to the task's Meeting relation (keeps existing links; no-op if already linked). */
+  async linkMeeting(task: OpsTask, meetingId: string): Promise<void> {
+    if (task.meetingIds.includes(meetingId)) return;
+    const relation = [...task.meetingIds, meetingId].map((id) => ({ id }));
+    await this.client.pages.update({ page_id: task.id, properties: { Meeting: { relation } } as any });
+    logger.info(`Ops task ${task.id} → linked to meeting ${meetingId}.`);
+  }
+
   /** Set the Due date (YYYY-MM-DD). */
   async setDue(pageId: string, dueIso: string): Promise<void> {
     await this.client.pages.update({ page_id: pageId, properties: { Due: { date: { start: dueIso } } } as any });