@c4t4/heyamigo 0.9.19 → 0.9.21

package/dist/queue/time-expr.js

@@ -0,0 +1,192 @@
+// Time expression parsing and resolution.
+//
+// Split into two stages so timezone application happens at resolve
+// time, not parse time. The parser doesn't know whose timezone to
+// use — it just produces a structured TimeExpression. The worker
+// looks up the sender's timezone and calls resolveTimeExpression()
+// to get a unix-second timestamp.
+//
+// Grammars supported (case-insensitive, trimmed):
+//   in <n>(s|m|h|d)              relative
+//   in <n> second(s)|minute(s)|hour(s)|day(s)
+//   at <H>(:MM)?(am|pm)?         today, user-tz
+//   tomorrow at <H>(:MM)?(am|pm)?
+//   <mon|tue|wed|thu|fri|sat|sun> at <H>(:MM)?(am|pm)?
+//   YYYY-MM-DD HH:MM             ISO-style, user-tz
+//
+// Past times today (e.g. user says "at 9am" at 11am) shift to
+// tomorrow. Weekday targets land on the NEXT occurrence of that
+// weekday including today if it's still in the future.
+const DOW_INDEX = {
+    sun: 0, mon: 1, tue: 2, wed: 3, thu: 4, fri: 5, sat: 6,
+};
+const UNIT_SECONDS = {
+    s: 1, second: 1, seconds: 1,
+    m: 60, minute: 60, minutes: 60,
+    h: 3600, hour: 3600, hours: 3600,
+    d: 86400, day: 86400, days: 86400,
+};
+const REL_RE = /^in\s+(\d+)\s*([a-z]+)$/i;
+const TODAY_RE = /^at\s+(\d{1,2})(?::(\d{2}))?\s*(am|pm)?$/i;
+const TOMORROW_RE = /^tomorrow(?:\s+at)?\s+(\d{1,2})(?::(\d{2}))?\s*(am|pm)?$/i;
+const WEEKDAY_RE = /^(mon|tue|wed|thu|fri|sat|sun)(?:day)?(?:\s+at)?\s+(\d{1,2})(?::(\d{2}))?\s*(am|pm)?$/i;
+const ISO_RE = /^(\d{4})-(\d{2})-(\d{2})\s+(\d{1,2}):(\d{2})$/;
+export function parseTimeExpression(input) {
+    const s = input.trim();
+    const m1 = REL_RE.exec(s);
+    if (m1) {
+        const n = parseInt(m1[1], 10);
+        const unit = m1[2].toLowerCase();
+        const mult = UNIT_SECONDS[unit];
+        if (!mult || n <= 0)
+            return null;
+        return { kind: 'relative', seconds: n * mult };
+    }
+    const m2 = TODAY_RE.exec(s);
+    if (m2) {
+        const hm = parseHourMinute(m2[1], m2[2], m2[3]);
+        if (!hm)
+            return null;
+        return { kind: 'today', hour: hm.hour, minute: hm.minute };
+    }
+    const m3 = TOMORROW_RE.exec(s);
+    if (m3) {
+        const hm = parseHourMinute(m3[1], m3[2], m3[3]);
+        if (!hm)
+            return null;
+        return { kind: 'tomorrow', hour: hm.hour, minute: hm.minute };
+    }
+    const m4 = WEEKDAY_RE.exec(s);
+    if (m4) {
+        const dow = DOW_INDEX[m4[1].toLowerCase()];
+        if (dow === undefined)
+            return null;
+        const hm = parseHourMinute(m4[2], m4[3], m4[4]);
+        if (!hm)
+            return null;
+        return { kind: 'weekday', dayOfWeek: dow, hour: hm.hour, minute: hm.minute };
+    }
+    const m5 = ISO_RE.exec(s);
+    if (m5) {
+        const year = parseInt(m5[1], 10);
+        const month = parseInt(m5[2], 10);
+        const day = parseInt(m5[3], 10);
+        const hour = parseInt(m5[4], 10);
+        const minute = parseInt(m5[5], 10);
+        if (month < 1 || month > 12 || day < 1 || day > 31)
+            return null;
+        if (hour < 0 || hour > 23 || minute < 0 || minute > 59)
+            return null;
+        return { kind: 'iso', year, month, day, hour, minute };
+    }
+    return null;
+}
+function parseHourMinute(hStr, mStr, ampm) {
+    let h = parseInt(hStr, 10);
+    const m = mStr ? parseInt(mStr, 10) : 0;
+    if (m < 0 || m > 59)
+        return null;
+    if (ampm) {
+        const meridiem = ampm.toLowerCase();
+        if (h < 1 || h > 12)
+            return null;
+        if (meridiem === 'am')
+            h = h === 12 ? 0 : h;
+        else
+            h = h === 12 ? 12 : h + 12;
+    }
+    else {
+        // 24h form when no am/pm
+        if (h < 0 || h > 23)
+            return null;
+    }
+    return { hour: h, minute: m };
+}
+// Resolve to absolute unix seconds in the given timezone. Always
+// returns a moment strictly in the future relative to `nowSec`.
+export function resolveTimeExpression(expr, tz, nowSec) {
+    if (expr.kind === 'relative') {
+        return nowSec + expr.seconds;
+    }
+    if (expr.kind === 'today') {
+        const today = localCalendarDate(nowSec, tz);
+        const candidate = makeDateInTz(today.year, today.month, today.day, expr.hour, expr.minute, tz);
+        // If already past today, roll to tomorrow.
+        return candidate > nowSec
+            ? candidate
+            : makeDateInTz(today.year, today.month, today.day + 1, expr.hour, expr.minute, tz);
+    }
+    if (expr.kind === 'tomorrow') {
+        const today = localCalendarDate(nowSec, tz);
+        return makeDateInTz(today.year, today.month, today.day + 1, expr.hour, expr.minute, tz);
+    }
+    if (expr.kind === 'weekday') {
+        // Walk forward 0..7 days in user-tz until day-of-week matches AND
+        // the resulting moment is in the future.
+        const today = localCalendarDate(nowSec, tz);
+        for (let offset = 0; offset < 8; offset++) {
+            const candidate = makeDateInTz(today.year, today.month, today.day + offset, expr.hour, expr.minute, tz);
+            const candidateDow = localCalendarDate(candidate, tz).dayOfWeek;
+            if (candidateDow === expr.dayOfWeek && candidate > nowSec) {
+                return candidate;
+            }
+        }
+        // Shouldn't reach — fallback to a week from now.
+        return nowSec + 7 * 86400;
+    }
+    // ISO
+    return makeDateInTz(expr.year, expr.month - 1, expr.day, expr.hour, expr.minute, tz);
+}
+// Build a unix-seconds for a given Y/M/D HH:MM interpreted in a named
+// timezone. Guess-and-correct via Intl.DateTimeFormat — same technique
+// the cron parser uses. Handles DST seamlessly.
+function makeDateInTz(year, month, day, hour, minute, tz) {
+    const guessUtcMs = Date.UTC(year, month, day, hour, minute, 0);
+    const fmt = new Intl.DateTimeFormat('en-US', {
+        timeZone: tz,
+        year: 'numeric', month: '2-digit', day: '2-digit',
+        hour: '2-digit', minute: '2-digit', second: '2-digit',
+        hour12: false,
+    });
+    const parts = fmt.formatToParts(new Date(guessUtcMs));
+    const get = (type) => parts.find((p) => p.type === type)?.value ?? '0';
+    let parsedHour = parseInt(get('hour'), 10);
+    // Intl formats midnight as "24" in some locale/version combos; normalize.
+    if (parsedHour === 24)
+        parsedHour = 0;
+    const renderedUtcMs = Date.UTC(parseInt(get('year'), 10), parseInt(get('month'), 10) - 1, parseInt(get('day'), 10), parsedHour, parseInt(get('minute'), 10), parseInt(get('second'), 10));
+    const offsetMs = guessUtcMs - renderedUtcMs;
+    return Math.floor((guessUtcMs + offsetMs) / 1000);
+}
+// Decompose a unix-second into Y/M/D and day-of-week in a named
+// timezone. Returns calendar fields as the local user would see
+// them — used to compute "today" anchors before applying HH:MM.
+function localCalendarDate(sec, tz) {
+    const fmt = new Intl.DateTimeFormat('en-CA', {
+        timeZone: tz,
+        year: 'numeric', month: '2-digit', day: '2-digit',
+        weekday: 'short',
+    });
+    const parts = fmt.formatToParts(new Date(sec * 1000));
+    const get = (type) => parts.find((p) => p.type === type)?.value ?? '';
+    return {
+        year: parseInt(get('year'), 10),
+        month: parseInt(get('month'), 10) - 1, // 0-indexed for makeDateInTz Date.UTC compat
+        day: parseInt(get('day'), 10),
+        dayOfWeek: (DOW_INDEX[get('weekday').toLowerCase()] ?? 0),
+    };
+}
+// Human-readable formatter used in chat acks. Renders an absolute
+// resolved time back into the user's local time.
+export function formatLocalTime(unixSec, tz) {
+    return new Intl.DateTimeFormat('en-GB', {
+        timeZone: tz,
+        weekday: 'short',
+        year: 'numeric',
+        month: 'short',
+        day: '2-digit',
+        hour: '2-digit',
+        minute: '2-digit',
+        hour12: false,
+    }).format(new Date(unixSec * 1000));
+}

package/dist/queue/worker.js

@@ -4,12 +4,15 @@ import { config } from '../config.js';
 import { formatAddress, jidToAddress } from '../db/address.js';
 import { logger } from '../logger.js';
 import { addDailyTokens } from '../store/usage.js';
+import { getTimezoneForSenderNumber } from '../db/identity-sync.js';
+import { estimate as estimateJob } from '../estimates/index.js';
 import { extractFlags, filterFlagsByRole } from '../memory/digest-flag.js';
 import { isValidSlug } from '../memory/journals.js';
 import { enqueueAsyncTask, enqueueBrowserTask } from './async-tasks.js';
 import { enqueueCron } from './crons.js';
 import { enqueueMemoryWrite } from './memory-writes.js';
 import { enqueueOutbound } from './outbound.js';
+import { formatLocalTime, resolveTimeExpression } from './time-expr.js';
 function isStaleSessionError(err) {
     return (err instanceof Error &&
         err.message.includes('No conversation found'));
@@ -171,7 +174,15 @@ async function callClaude(job) {
     //   [ASYNC:...] → general lane, stateless, concurrency 3, non-browser work
     //   [ASYNC-BROWSER:...] → browser lane, persistent session, concurrency 1
     // Both report back via initiate() when done.
-    for (const t of asyncTasks) {
+    //
+    // For each delegation, we also build a "job card" — a short ETA
+    // message that handleReply will emit after the agent's reply
+    // chunks. Gives the user a visible "doing X, ~Y min" instead of
+    // wondering whether anything's happening.
+    const jobCards = [];
+    const cardBase = `card-${job.jid}-${Date.now()}`;
+    for (let i = 0; i < asyncTasks.length; i++) {
+        const t = asyncTasks[i];
         enqueueAsyncTask({
             jid: job.jid,
             senderNumber: job.senderNumber,
@@ -179,8 +190,19 @@ async function callClaude(job) {
             originatingMessage: job.text,
             allowedTools: job.allowedTools ?? 'all',
         });
+        const est = estimateJob({
+            description: t.description,
+            taskKind: 'async',
+        });
+        if (est) {
+            jobCards.push({
+                text: formatJobCard(est.text, t.description),
+                idempotencyKey: `${cardBase}-async-${i}`,
+            });
+        }
     }
-    for (const t of asyncBrowserTasks) {
+    for (let i = 0; i < asyncBrowserTasks.length; i++) {
+        const t = asyncBrowserTasks[i];
         enqueueBrowserTask({
             jid: job.jid,
             senderNumber: job.senderNumber,
@@ -188,6 +210,16 @@ async function callClaude(job) {
             originatingMessage: job.text,
             allowedTools: job.allowedTools ?? 'all',
         });
+        const est = estimateJob({
+            description: t.description,
+            taskKind: 'async-browser',
+        });
+        if (est) {
+            jobCards.push({
+                text: formatJobCard(est.text, t.description),
+                idempotencyKey: `${cardBase}-browser-${i}`,
+            });
+        }
     }
     // SEND-TEXT: cross-chat text send. Agent specified the destination
     // address explicitly. Just drops a row in outbound; sender worker
@@ -204,8 +236,12 @@ async function callClaude(job) {
     }
     // [CRON: @every X — body] and [REMIND: in Nu — body] create cron
     // rows that fire into outbound at their scheduled time. The
-    // originating chat (job.jid) is the destination for both.
+    // originating chat (job.jid) is the destination for both. Sender's
+    // timezone drives "9am" / "today at..." resolution so the schedule
+    // lands in their wall-clock time, not the server's.
     const chatAddress = formatAddress(jidToAddress(job.jid));
+    const senderTz = getTimezoneForSenderNumber(job.senderNumber);
+    const nowSec = Math.floor(Date.now() / 1000);
     const cronBase = `chat-cron-${job.jid}-${Date.now()}`;
     for (let i = 0; i < crons.length; i++) {
         const c = crons[i];
@@ -215,24 +251,50 @@ async function callClaude(job) {
                 enqueueInto: 'outbound',
                 payload: { address: chatAddress, kind: 'text', text: c.body },
                 recurrence: c.recurrence,
+                // Sender's local timezone so @daily HH:MM fires in their
+                // wall-clock time, not the server's.
+                timezone: senderTz,
             });
-            logger.info({ jid: job.jid, recurrence: c.recurrence, chars: c.body.length }, 'CRON tag scheduled');
+            logger.info({
+                jid: job.jid,
+                recurrence: c.recurrence,
+                tz: senderTz,
+                chars: c.body.length,
+            }, 'CRON tag scheduled');
         }
         catch (err) {
             logger.warn({ err, jid: job.jid, recurrence: c.recurrence }, 'CRON tag failed (bad recurrence?)');
         }
     }
+    // REMIND resolution uses the same senderTz computed above.
     const remindBase = `chat-remind-${job.jid}-${Date.now()}`;
     for (let i = 0; i < reminds.length; i++) {
         const r = reminds[i];
+        let firstRunAt;
+        try {
+            firstRunAt = resolveTimeExpression(r.when, senderTz, nowSec);
+        }
+        catch (err) {
+            logger.warn({ err, jid: job.jid, when: r.when }, 'REMIND time resolution failed');
+            continue;
+        }
+        if (firstRunAt <= nowSec) {
+            logger.warn({ jid: job.jid, when: r.when, firstRunAt }, 'REMIND resolved to past — skipped');
+            continue;
+        }
         enqueueCron({
             name: `${remindBase}-${i}`,
             enqueueInto: 'outbound',
             payload: { address: chatAddress, kind: 'text', text: r.body },
             recurrence: null,
-            firstRunAt: Math.floor(Date.now() / 1000) + r.whenSecondsFromNow,
+            firstRunAt,
         });
-        logger.info({ jid: job.jid, inSeconds: r.whenSecondsFromNow, chars: r.body.length }, 'REMIND tag scheduled');
+        logger.info({
+            jid: job.jid,
+            fires: formatLocalTime(firstRunAt, senderTz),
+            tz: senderTz,
+            chars: r.body.length,
+        }, 'REMIND tag scheduled');
     }
     return {
         reply: clean,
@@ -250,8 +312,18 @@ async function callClaude(job) {
             journalSlugs: journals.map((j) => j.slug),
             asyncCount: asyncTasks.length + asyncBrowserTasks.length,
         },
+        jobCards: jobCards.length > 0 ? jobCards : undefined,
     };
 }
+// Compact card text. Emoji + ETA + a brief excerpt of what the agent
+// delegated, so the user knows which job each card refers to when
+// multiple are running.
+function formatJobCard(etaText, description) {
+    const excerpt = description.length > 100
+        ? description.slice(0, 97) + '...'
+        : description;
+    return `🔄 ${etaText}\n${excerpt}`;
+}
 function titleCase(slug) {
     return slug
         .split('-')

package/migrations/0008_crons_timezone.sql

@@ -0,0 +1 @@
+ALTER TABLE `crons` ADD `timezone` text;