npm - @masslessai/push-todo - Versions diffs - 4.3.0 → 4.5.0 - Mend

@masslessai/push-todo 4.3.0 → 4.5.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (6) hide show

package/lib/api.js CHANGED Viewed

@@ -154,9 +154,12 @@ export async function markTaskCompleted(taskId, comment = '') {
  * @param {string} options.title - Todo title (required)
  * @param {string|null} options.content - Detailed content (optional)
  * @param {boolean} options.backlog - Whether to create as backlog item
- * @returns {Promise<Object>} Created todo with { id, displayNumber, title, createdAt }
+ * @param {string|null} options.reminderDate - ISO8601 reminder date (optional)
+ * @param {string|null} options.reminderTimeSource - Time source enum (optional)
+ * @param {boolean} options.alarmEnabled - Whether to mark as urgent (optional)
+ * @returns {Promise<Object>} Created todo with { id, displayNumber, title, createdAt, reminderDate, reminderEnabled }
  */
-export async function createTodo({ title, content = null, backlog = false }) {
+export async function createTodo({ title, content = null, backlog = false, reminderDate = null, reminderTimeSource = null, alarmEnabled = false }) {
   const response = await apiRequest('create-todo', {
     method: 'POST',
     body: JSON.stringify({
@@ -164,6 +167,10 @@ export async function createTodo({ title, content = null, backlog = false }) {
       normalizedContent: content || null,
       isBacklog: backlog,
       createdByClient: 'cli',
+      reminderDate: reminderDate || null,
+      reminderEnabled: reminderDate != null,
+      reminderTimeSource: reminderTimeSource || null,
+      alarmEnabled,
     }),
   });

package/lib/cli.js CHANGED Viewed

@@ -19,6 +19,7 @@ import { install as installLaunchAgent, uninstall as uninstallLaunchAgent, getSt
 import { getScreenshotPath, screenshotExists, openScreenshot } from './utils/screenshots.js';
 import { bold, red, cyan, dim, green } from './utils/colors.js';
 import { getMachineId } from './machine-id.js';
+import { parseReminder } from './reminder-parser.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -45,6 +46,9 @@ ${bold('USAGE:')}
   push-todo [options]              List active tasks
   push-todo <number>               Show specific task
   push-todo create <title>         Create a new todo
+    --remind <text>                Set reminder ("tomorrow night", "in 2 hours")
+    --remind-at <iso>              Set reminder at exact ISO8601 time
+    --alarm                        Mark as urgent (bypasses Focus)
   push-todo connect                Run connection doctor
   push-todo search <query>         Search tasks
   push-todo review                 Review completed tasks
@@ -92,6 +96,8 @@ ${bold('EXAMPLES:')}
   push-todo                        List active tasks for current project
   push-todo 427                    Show task #427
   push-todo create "Fix auth bug"  Create a new todo
+  push-todo create "Debug" --remind "tomorrow night"
+  push-todo create "Call" --remind "at 3pm" --alarm
   push-todo create "Item" --backlog Create as backlog item
   push-todo -a                     List all tasks across projects
   push-todo --queue 1,2,3          Queue tasks 1, 2, 3 for daemon
@@ -126,6 +132,7 @@ ${bold('SCHEDULE (remote scheduled jobs):')}
     --create-todo <title>            Create a new todo each fire
     --queue-todo <todoId>            Re-queue an existing todo each fire
     --git-remote <remote>            Route created todos to a project
+    --agent-type <type>              Agent: claude-code, openclaw, openai-codex
     --content <body>                 Expanded content for created todos
   push-todo schedule list            List all schedules
   push-todo schedule remove <id>     Remove a schedule
@@ -178,6 +185,10 @@ const options = {
   'store-e2ee-key': { type: 'string' },
   'description': { type: 'string' },
   'auto': { type: 'boolean' },
+  // Create command options
+  'remind': { type: 'string' },
+  'remind-at': { type: 'string' },
+  'alarm': { type: 'boolean' },
   // Confirm command options
   'type': { type: 'string' },
   'title': { type: 'string' },
@@ -191,6 +202,7 @@ const options = {
   'cron': { type: 'string' },
   'create-todo': { type: 'string' },
   'git-remote': { type: 'string' },
+  'agent-type': { type: 'string' },
   'queue-todo': { type: 'string' },
   // Skill CLI options (Phase 3)
   'report-progress': { type: 'string' },
@@ -684,22 +696,74 @@ export async function run(argv) {
       console.error('');
       console.error('Usage:');
       console.error('  push-todo create "Fix the auth bug"');
-      console.error('  push-todo create "Fix the auth bug" --backlog');
-      console.error('  push-todo create "Fix the auth bug" --content "Detailed description"');
+      console.error('  push-todo create "Debug daemon" --remind "tomorrow night"');
+      console.error('  push-todo create "Call dentist" --remind "at 3pm" --alarm');
+      console.error('  push-todo create "Deploy" --remind-at "2026-03-03T14:00:00"');
       process.exit(1);
     }
+    // Conflict check
+    if (values.remind && values['remind-at']) {
+      console.error(red('Error: Use --remind OR --remind-at, not both.'));
+      process.exit(1);
+    }
+    // Parse reminder
+    let reminderDate = null;
+    let reminderTimeSource = null;
+    const alarmEnabled = values.alarm || false;
+    if (values['remind-at']) {
+      const parsed = new Date(values['remind-at']);
+      if (isNaN(parsed.getTime())) {
+        console.error(red('Error: --remind-at must be a valid ISO8601 date.'));
+        console.error(dim('  Example: 2026-03-03T14:00:00'));
+        process.exit(1);
+      }
+      if (parsed <= new Date()) {
+        console.error(red('Error: --remind-at must be in the future.'));
+        process.exit(1);
+      }
+      reminderDate = parsed.toISOString();
+      reminderTimeSource = 'userSpecified';
+    } else if (values.remind) {
+      const result = parseReminder(values.remind);
+      if (!result.date) {
+        console.error(red(`Error: Could not parse reminder: "${values.remind}"`));
+        console.error('');
+        console.error('Examples:');
+        console.error('  --remind "tomorrow"');
+        console.error('  --remind "tonight"');
+        console.error('  --remind "in 2 hours"');
+        console.error('  --remind "next monday at 3pm"');
+        process.exit(1);
+      }
+      reminderDate = result.date.toISOString();
+      reminderTimeSource = result.timeSource;
+    }
     try {
       const todo = await api.createTodo({
         title,
         content: values.content || null,
         backlog: values.backlog || false,
+        reminderDate,
+        reminderTimeSource,
+        alarmEnabled,
       });
       if (values.json) {
         console.log(JSON.stringify(todo, null, 2));
       } else {
-        console.log(green(`Created todo #${todo.displayNumber}: ${todo.title}`));
+        let msg = green(`Created todo #${todo.displayNumber}: ${todo.title}`);
+        if (reminderDate) {
+          const d = new Date(reminderDate);
+          msg += `\n  ${dim('Reminder:')} ${d.toLocaleString()}`;
+        }
+        if (alarmEnabled) {
+          msg += `  ${dim('(urgent)')}`;
+        }
+        console.log(msg);
       }
     } catch (error) {
       console.error(red(`Failed to create todo: ${error.message}`));
@@ -763,6 +827,9 @@ export async function run(argv) {
         process.exit(1);
       }
+      // Resolve agent type: explicit flag > auto-detect from caller
+      const agentType = values['agent-type'] || null;
       try {
         const response = await api.apiRequest('manage-schedules', {
           method: 'POST',
@@ -771,6 +838,7 @@ export async function run(argv) {
             scheduleType,
             scheduleValue,
             actionType,
+            agentType,
             actionTitle,
             actionContent,
             gitRemote,
@@ -822,7 +890,8 @@ export async function run(argv) {
           const actionStr = s.action_type === 'create-todo'
             ? `create-todo: ${s.action_title || ''}`
             : `queue-todo: ${s.todo_id || '?'}`;
-          console.log(`  ${status} ${s.name} [${schedStr}] → ${actionStr}`);
+          const agentStr = s.agent_type && s.agent_type !== 'claude-code' ? ` (${s.agent_type})` : '';
+          console.log(`  ${status} ${s.name} [${schedStr}] → ${actionStr}${agentStr}`);
           console.log(dim(`     ID: ${s.id.slice(0, 8)} | Next: ${s.next_run_at || 'N/A'} | Last: ${s.last_run_at || 'never'}`));
         }
       } catch (error) {
@@ -896,6 +965,7 @@ ${bold('Examples:')}
   push-todo schedule add --name "Daily standup" --every 24h --create-todo "Write standup update"
   push-todo schedule add --name "Weekly review" --cron "0 9 * * 1" --create-todo "Weekly code review" --git-remote github.com/user/repo
   push-todo schedule add --name "Re-run task" --every 4h --queue-todo <todoId>
+  push-todo schedule add --name "Codex review" --every 12h --create-todo "Review PRs" --git-remote github.com/user/repo --agent-type openai-codex
     `);
     return;
   }

package/lib/cron.js CHANGED Viewed

@@ -196,16 +196,21 @@ export function computeNextRun(schedule, fromDate = new Date()) {
  * @param {Function} [logFn] - Optional log function
  * @param {Object} [context] - Injected dependencies from daemon
  * @param {Function} [context.apiRequest] - API request function
+ * @param {string} [context.machineId] - This machine's ID for targeted schedule filtering
  */
 export async function checkAndRunRemoteSchedules(logFn, context = {}) {
   const log = logFn || (() => {});
   if (!context.apiRequest) return;
-  // 1. Fetch due schedules
+  // 1. Fetch due schedules (filtered by machine if available)
   let schedules;
   try {
-    const response = await context.apiRequest('manage-schedules?due=true', {
+    let endpoint = 'manage-schedules?due=true';
+    if (context.machineId) {
+      endpoint += `&machine_id=${encodeURIComponent(context.machineId)}`;
+    }
+    const response = await context.apiRequest(endpoint, {
       method: 'GET',
     });
     if (!response.ok) {
@@ -226,6 +231,7 @@ export async function checkAndRunRemoteSchedules(logFn, context = {}) {
   // 2. Fire each due schedule
   for (const schedule of schedules) {
     const expectedNextRunAt = schedule.next_run_at;
+    let actionSucceeded = false;
     try {
       if (schedule.action_type === 'create-todo') {
@@ -238,7 +244,8 @@ export async function checkAndRunRemoteSchedules(logFn, context = {}) {
         };
         if (schedule.git_remote) {
           payload.gitRemote = schedule.git_remote;
-          payload.actionType = 'claude-code';
+          // Use schedule's agent_type instead of hardcoding claude-code
+          payload.actionType = schedule.agent_type || 'claude-code';
         }
         const todoResponse = await context.apiRequest('create-todo', {
@@ -248,6 +255,7 @@ export async function checkAndRunRemoteSchedules(logFn, context = {}) {
         if (todoResponse.ok) {
           const todoData = await todoResponse.json();
           log(`Schedule "${schedule.name}": created todo #${todoData.todo?.displayNumber || '?'}`);
+          actionSucceeded = true;
         } else {
           log(`Schedule "${schedule.name}": create-todo failed (HTTP ${todoResponse.status})`);
         }
@@ -277,6 +285,7 @@ export async function checkAndRunRemoteSchedules(logFn, context = {}) {
         });
         if (queueResponse.ok) {
           log(`Schedule "${schedule.name}": queued todo ${schedule.todo_id}`);
+          actionSucceeded = true;
         } else {
           log(`Schedule "${schedule.name}": queue-todo failed (HTTP ${queueResponse.status})`);
         }
@@ -285,7 +294,12 @@ export async function checkAndRunRemoteSchedules(logFn, context = {}) {
       log(`Schedule "${schedule.name}": execution error: ${error.message}`);
     }
-    // 3. Advance next_run_at (with optimistic lock)
+    // 3. Advance next_run_at only if action succeeded (prevents silent lost fires)
+    if (!actionSucceeded) {
+      log(`Schedule "${schedule.name}": action failed, will retry next cycle`);
+      continue;
+    }
     const now = new Date();
     const scheduleConfig = { type: schedule.schedule_type, value: schedule.schedule_value };

package/lib/daemon.js CHANGED Viewed

@@ -550,85 +550,6 @@ async function fetchQueuedTasks() {
   }
 }
-// ==================== Scheduled Reminder Bridge ====================
-async function fetchScheduledTodos() {
-  try {
-    const machineId = getMachineId();
-    const params = new URLSearchParams();
-    params.set('scheduled_before', new Date().toISOString());
-    if (machineId) {
-      params.set('machine_id', machineId);
-    }
-    // Include registered git_remotes so backend can scope to this machine's projects
-    const projects = getListedProjects();
-    const gitRemotes = Object.keys(projects);
-    const headers = {};
-    if (machineId && gitRemotes.length > 0) {
-      headers['X-Machine-Id'] = machineId;
-      headers['X-Git-Remotes'] = gitRemotes.join(',');
-    }
-    const response = await apiRequest(`synced-todos?${params}`, { headers });
-    if (!response.ok) return [];
-    const data = await response.json();
-    return data.todos || [];
-  } catch (error) {
-    logError(`Failed to fetch scheduled todos: ${error.message}`);
-    return [];
-  }
-}
-async function checkAndQueueScheduledTodos() {
-  const scheduledTodos = await fetchScheduledTodos();
-  if (scheduledTodos.length === 0) return;
-  const registeredProjects = getListedProjects();
-  for (const todo of scheduledTodos) {
-    const dn = todo.displayNumber || todo.display_number;
-    const todoId = todo.id;
-    // Skip tasks already in an execution state (running, queued, completed, failed, etc.)
-    const execStatus = todo.executionStatus || todo.execution_status;
-    if (execStatus && execStatus !== 'none') {
-      continue;
-    }
-    // Skip completed tasks
-    if (todo.isCompleted || todo.is_completed) {
-      continue;
-    }
-    // Skip tasks whose project is not registered on this machine
-    const gitRemote = todo.gitRemote || todo.git_remote;
-    if (gitRemote && Object.keys(registeredProjects).length > 0) {
-      if (!(gitRemote in registeredProjects)) {
-        log(`Schedule skipped #${dn}: project ${gitRemote} not registered on this machine`);
-        continue;
-      }
-    }
-    log(`Schedule triggered for #${dn} (reminder_date: ${todo.reminderDate || todo.reminder_date})`);
-    try {
-      await updateTaskStatus(dn, 'queued', {
-        event: {
-          type: 'scheduled_trigger',
-          timestamp: new Date().toISOString(),
-          summary: 'Auto-queued: reminder time reached',
-        }
-      }, todoId);
-      log(`Queued #${dn} via schedule trigger`);
-    } catch (error) {
-      logError(`Failed to queue scheduled todo #${dn}: ${error.message}`);
-    }
-  }
-}
 // ==================== Task Status Updates ====================
 async function updateTaskStatus(displayNumber, status, extra = {}, todoId = null) {
@@ -3239,18 +3160,11 @@ async function mainLoop() {
     try {
       await checkTimeouts();
-      // Schedule bridge: auto-queue todos whose reminder time has arrived
-      try {
-        await checkAndQueueScheduledTodos();
-      } catch (error) {
-        logError(`Scheduled todo check error: ${error.message}`);
-      }
       await pollAndExecute();
       // Remote schedules from Supabase
       try {
-        await checkAndRunRemoteSchedules(log, { apiRequest });
+        await checkAndRunRemoteSchedules(log, { apiRequest, machineId: getMachineId() });
       } catch (error) {
         logError(`Remote schedules error: ${error.message}`);
       }

package/lib/reminder-parser.js ADDED Viewed

@@ -0,0 +1,418 @@
+/**
+ * Reminder parser for Push CLI.
+ *
+ * Ports the iOS three-tier agent scheduling model to JavaScript.
+ * Source of truth: App/Data/TodoItem+ReminderParsing.swift
+ *
+ * Three tiers:
+ *   Tier 1 — ASAP: "today", "now", "asap" → now + 1 minute
+ *   Tier 2 — Deferred: "tomorrow", "next week", "morning" → target day at default hour
+ *   Tier 3 — Precise: "at 3pm", "in 2 hours" → exact requested time
+ *
+ * Key difference from iOS: CLI cannot access user-configurable ReminderSettings.
+ * Uses factory defaults from ReminderSettings.swift instead.
+ */
+// Fixed defaults matching iOS ReminderSettings factory values
+const DEFAULTS = {
+  general: 9,     // ReminderSettings.swift:32 — defaultReminderHour
+  morning: 9,     // ReminderSettings.swift:45 — defaultMorningHour
+  evening: 18,    // ReminderSettings.swift:53 — defaultEveningHour
+  night: 21,      // ReminderParsing.swift:223 — hardcoded
+  afternoon: 14,  // ReminderParsing.swift:200 — hardcoded
+  endOfDay: 17,   // ReminderParsing.swift:171 — hardcoded
+  noon: 12,       // ReminderParsing.swift:233 — hardcoded
+};
+/**
+ * Parse a natural language reminder description into a concrete Date.
+ *
+ * @param {string|null} description - Natural language like "tomorrow night", "at 3pm"
+ * @param {Date} [now] - Current time (for testing). Defaults to new Date().
+ * @returns {{ date: Date|null, timeSource: string|null }}
+ */
+export function parseReminder(description, now = new Date()) {
+  if (!description || typeof description !== 'string') {
+    return { date: null, timeSource: null };
+  }
+  const text = description.toLowerCase().trim();
+  if (!text) {
+    return { date: null, timeSource: null };
+  }
+  // Tier 1 anchor: 1-minute buffer so reminderDate is always > now after sync latency.
+  const asapDate = new Date(now.getTime() + 60_000);
+  // ============================================================
+  // PHASE 1: Precise relative patterns (Tier 3)
+  // "in X minutes/hours" — inherently future, no rollover needed.
+  // "in X days" — day-level, uses defaultReminderHour on target day.
+  // ============================================================
+  if (text.startsWith('in ') || text.includes('half an hour') || text.includes('half hour')) {
+    if (text.includes('half an hour') || text.includes('half hour')) {
+      return { date: addMinutes(now, 30), timeSource: 'userSpecified' };
+    }
+    if (text.includes('an hour') && !text.includes('half')) {
+      return { date: addHours(now, 1), timeSource: 'userSpecified' };
+    }
+    if (text.includes('minute')) {
+      const n = extractNumber(text);
+      if (n) return { date: addMinutes(now, n), timeSource: 'userSpecified' };
+    }
+    if (text.includes('hour')) {
+      const n = extractNumber(text);
+      if (n) return { date: addHours(now, n), timeSource: 'userSpecified' };
+    }
+    if (text.includes('day')) {
+      const n = extractNumber(text);
+      if (n) {
+        const future = addDays(now, n);
+        return { date: setTime(future, DEFAULTS.general, 0), timeSource: 'defaultGeneral' };
+      }
+    }
+  }
+  // ============================================================
+  // PHASE 2: ASAP (Tier 1) — execute on next daemon poll
+  // ============================================================
+  if (text.includes('right now') || text === 'now' ||
+      text.includes('asap') || text === 'soon' ||
+      text.includes('immediately')) {
+    return { date: asapDate, timeSource: 'userSpecified' };
+  }
+  if (text === 'today') {
+    return { date: asapDate, timeSource: 'userSpecified' };
+  }
+  if (text.includes('later today') || text.includes('later on')) {
+    return { date: asapDate, timeSource: 'userSpecified' };
+  }
+  // ============================================================
+  // PHASE 3: End-of-day expressions (Tier 2)
+  // ============================================================
+  if (text.includes('end of day') || text.includes('eod') ||
+      text.includes('close of business') || text.includes('cob') ||
+      text.includes('by end of')) {
+    const baseDate = extractBaseDate(text, now);
+    const eodDate = setTime(baseDate, DEFAULTS.endOfDay, 0);
+    return { date: ensureFutureTime(eodDate, now), timeSource: 'userSpecified' };
+  }
+  // ============================================================
+  // PHASE 4: Time-of-day patterns (Tier 2, with day-anchor awareness)
+  // ============================================================
+  if (text.includes('morning')) {
+    const baseDate = extractBaseDate(text, now);
+    const morningDate = setTime(baseDate, DEFAULTS.morning, 0);
+    if (isDayAnchored(text) && morningDate <= now) {
+      return { date: asapDate, timeSource: 'userSpecified' };
+    }
+    return { date: ensureFutureTime(morningDate, now), timeSource: 'defaultMorning' };
+  }
+  if (text.includes('afternoon')) {
+    const baseDate = extractBaseDate(text, now);
+    const afternoonDate = setTime(baseDate, DEFAULTS.afternoon, 0);
+    if (isDayAnchored(text) && afternoonDate <= now) {
+      return { date: asapDate, timeSource: 'userSpecified' };
+    }
+    return { date: ensureFutureTime(afternoonDate, now), timeSource: 'userSpecified' };
+  }
+  if (text.includes('evening') || text.includes('tonight')) {
+    const baseDate = extractBaseDate(text, now);
+    const eveningDate = setTime(baseDate, DEFAULTS.evening, 0);
+    if (isDayAnchored(text) && eveningDate <= now) {
+      return { date: asapDate, timeSource: 'defaultEvening' };
+    }
+    return { date: ensureFutureTime(eveningDate, now), timeSource: 'defaultEvening' };
+  }
+  // "night" without "tonight" (checked after evening/tonight to avoid double-match)
+  if (text.includes('night') && !text.includes('tonight')) {
+    const baseDate = extractBaseDate(text, now);
+    const nightDate = setTime(baseDate, DEFAULTS.night, 0);
+    if (isDayAnchored(text) && nightDate <= now) {
+      return { date: asapDate, timeSource: 'userSpecified' };
+    }
+    return { date: ensureFutureTime(nightDate, now), timeSource: 'userSpecified' };
+  }
+  if (text.includes('noon') || text.includes('midday')) {
+    const baseDate = extractBaseDate(text, now);
+    const noonDate = setTime(baseDate, DEFAULTS.noon, 0);
+    if (isDayAnchored(text) && noonDate <= now) {
+      return { date: asapDate, timeSource: 'userSpecified' };
+    }
+    return { date: ensureFutureTime(noonDate, now), timeSource: 'userSpecified' };
+  }
+  // ============================================================
+  // PHASE 5: Specific time patterns (Tier 3 — Precise)
+  // ============================================================
+  const time = extractTime(text, now);
+  if (time) {
+    const baseDate = extractBaseDate(text, now);
+    const specificDate = setTime(baseDate, time.hour, time.minute);
+    return { date: ensureFutureTime(specificDate, now), timeSource: 'userSpecified' };
+  }
+  // ============================================================
+  // PHASE 6: Deferred day references (Tier 2)
+  // Note: compound forms like "tomorrow morning" are caught in Phase 4.
+  // ============================================================
+  if (text.includes('tomorrow')) {
+    const tomorrow = addDays(now, 1);
+    return { date: setTime(tomorrow, DEFAULTS.general, 0), timeSource: 'defaultGeneral' };
+  }
+  if (text.includes('next week')) {
+    const nextWeek = addDays(now, 7);
+    return { date: setTime(nextWeek, DEFAULTS.general, 0), timeSource: 'defaultGeneral' };
+  }
+  if (text.includes('this week')) {
+    const friday = thisFriday(now, DEFAULTS.general);
+    if (friday === null) {
+      // It's Saturday — this week's Friday is yesterday
+      return { date: asapDate, timeSource: 'defaultGeneral' };
+    }
+    if (friday <= now) {
+      return { date: asapDate, timeSource: 'defaultGeneral' };
+    }
+    return { date: friday, timeSource: 'defaultGeneral' };
+  }
+  // Weekday names
+  const weekdays = ['sunday', 'monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday'];
+  for (let i = 0; i < weekdays.length; i++) {
+    if (text.includes(weekdays[i])) {
+      const currentWeekday = now.getDay(); // 0=Sunday
+      if (currentWeekday === i) {
+        // Today IS the named weekday
+        const weekdayTime = extractTime(text, now);
+        if (weekdayTime) {
+          const specificDate = setTime(now, weekdayTime.hour, weekdayTime.minute);
+          return { date: ensureFutureTime(specificDate, now), timeSource: 'userSpecified' };
+        }
+        // No time specified → ASAP (user means "this [weekday]" = today)
+        return { date: asapDate, timeSource: 'userSpecified' };
+      }
+      // Different weekday → next occurrence
+      const nextDate = nextWeekday(i, now);
+      if (nextDate) {
+        const weekdayTime = extractTime(text, now);
+        if (weekdayTime) {
+          return { date: setTime(nextDate, weekdayTime.hour, weekdayTime.minute), timeSource: 'userSpecified' };
+        }
+        return { date: setTime(nextDate, DEFAULTS.general, 0), timeSource: 'defaultGeneral' };
+      }
+    }
+  }
+  // No pattern matched
+  return { date: null, timeSource: null };
+}
+// ==================== Helper Functions ====================
+/**
+ * Extract a positive integer from text. Handles digits and word numbers.
+ * Port of iOS extractNumber(from:)
+ */
+function extractNumber(text) {
+  // Try numeric digits
+  const digits = text.replace(/[^\d]/g, '');
+  if (digits) {
+    const n = parseInt(digits, 10);
+    if (n > 0) return n;
+  }
+  // Word numbers
+  const wordNumbers = {
+    'one': 1, 'two': 2, 'three': 3, 'four': 4, 'five': 5,
+    'six': 6, 'seven': 7, 'eight': 8, 'nine': 9, 'ten': 10,
+    'fifteen': 15, 'twenty': 20, 'thirty': 30, 'forty five': 45,
+  };
+  for (const [word, number] of Object.entries(wordNumbers)) {
+    if (text.includes(word)) return number;
+  }
+  return null;
+}
+/**
+ * Extract hour:minute from time expressions.
+ * Port of iOS extractTime(from:now:)
+ */
+function extractTime(text, now = new Date()) {
+  // Pattern 1: X:XX am/pm or X:XX p.m.
+  const colonAmPm = text.match(/(\d{1,2}):(\d{2})\s*(a\.?m\.?|p\.?m\.?)/i);
+  if (colonAmPm) {
+    let hour = parseInt(colonAmPm[1], 10);
+    const minute = parseInt(colonAmPm[2], 10);
+    const period = colonAmPm[3].toLowerCase();
+    if (period.startsWith('p') && hour < 12) hour += 12;
+    if (period.startsWith('a') && hour === 12) hour = 0;
+    if (hour >= 0 && hour <= 23 && minute >= 0 && minute <= 59) {
+      return { hour, minute };
+    }
+  }
+  // Pattern 2: X am/pm or X p.m.
+  const bareAmPm = text.match(/(\d{1,2})\s*(a\.?m\.?|p\.?m\.?)/i);
+  if (bareAmPm) {
+    let hour = parseInt(bareAmPm[1], 10);
+    const period = bareAmPm[2].toLowerCase();
+    if (period.startsWith('p') && hour < 12) hour += 12;
+    if (period.startsWith('a') && hour === 12) hour = 0;
+    if (hour >= 0 && hour <= 23) {
+      return { hour, minute: 0 };
+    }
+  }
+  // Pattern 3: 24-hour format X:XX (no am/pm)
+  const twentyFour = text.match(/(\d{1,2}):(\d{2})(?!\s*(a|p))/i);
+  if (twentyFour) {
+    const hour = parseInt(twentyFour[1], 10);
+    const minute = parseInt(twentyFour[2], 10);
+    if (hour >= 0 && hour <= 23 && minute >= 0 && minute <= 59) {
+      return { hour, minute };
+    }
+  }
+  // Pattern 4: Bare number with "at" prefix — infer AM/PM from current time
+  const bareNumber = text.match(/(?:at\s+)?(\d{1,2})(?:\s*o'?clock)?/i);
+  if (bareNumber) {
+    const num = parseInt(bareNumber[1], 10);
+    if (num >= 1 && num <= 12) {
+      const currentHour = now.getHours();
+      const amHour = num === 12 ? 0 : num;
+      const pmHour = num === 12 ? 12 : num + 12;
+      let inferredHour;
+      if (currentHour < amHour) {
+        inferredHour = amHour;
+      } else if (currentHour < pmHour) {
+        inferredHour = pmHour;
+      } else {
+        inferredHour = amHour; // Both passed → AM tomorrow (ensureFutureTime will roll)
+      }
+      return { hour: inferredHour, minute: 0 };
+    }
+  }
+  return null;
+}
+/**
+ * Extract the base date from compound expressions.
+ * Port of iOS extractBaseDate(from:calendar:now:)
+ */
+function extractBaseDate(text, now) {
+  if (text.includes('tomorrow')) {
+    return addDays(now, 1);
+  }
+  if (text.includes('today') || text.includes('tonight') || text.includes('this')) {
+    return now;
+  }
+  const weekdays = ['sunday', 'monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday'];
+  for (let i = 0; i < weekdays.length; i++) {
+    if (text.includes(weekdays[i])) {
+      return nextWeekday(i, now) || now;
+    }
+  }
+  return now;
+}
+/**
+ * Check if the description is explicitly pinned to this calendar day.
+ * Port of iOS isDayAnchored(_:)
+ */
+function isDayAnchored(text) {
+  if (text.includes('tonight')) return true;
+  const phrases = [
+    'this morning', 'this afternoon', 'this evening', 'this night', 'this noon',
+    'today morning', 'today afternoon', 'today evening', 'today night', 'today noon',
+  ];
+  return phrases.some(p => text.includes(p));
+}
+/**
+ * Returns this week's Friday at the given hour, or null if it's Saturday.
+ * Port of iOS thisFriday(from:calendar:defaultHour:)
+ */
+function thisFriday(now, defaultHour) {
+  const fridayWeekday = 5; // JS: 0=Sun, 5=Fri
+  const currentWeekday = now.getDay();
+  const daysToFriday = fridayWeekday - currentWeekday;
+  if (daysToFriday < 0) {
+    // It's Saturday — this week's Friday is yesterday
+    return null;
+  }
+  const startOfDay = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+  const targetDay = addDays(startOfDay, daysToFriday);
+  return setTime(targetDay, defaultHour, 0);
+}
+/**
+ * Returns the next occurrence of the given weekday.
+ * Port of iOS nextWeekday(_:from:)
+ */
+function nextWeekday(weekday, now) {
+  const currentWeekday = now.getDay();
+  let daysToAdd = weekday - currentWeekday;
+  if (daysToAdd <= 0) {
+    daysToAdd += 7;
+  }
+  const startOfDay = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+  return addDays(startOfDay, daysToAdd);
+}
+/**
+ * Rolls a past time to the next day at the same time.
+ * Port of iOS ensureFutureTime(_:now:calendar:)
+ */
+function ensureFutureTime(date, now) {
+  if (date > now) return date;
+  return addDays(date, 1);
+}
+// ==================== Date Utilities ====================
+function addMinutes(date, minutes) {
+  return new Date(date.getTime() + minutes * 60_000);
+}
+function addHours(date, hours) {
+  return new Date(date.getTime() + hours * 3_600_000);
+}
+function addDays(date, days) {
+  const result = new Date(date);
+  result.setDate(result.getDate() + days);
+  return result;
+}
+function setTime(date, hour, minute) {
+  const result = new Date(date);
+  result.setHours(hour, minute, 0, 0);
+  return result;
+}

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@masslessai/push-todo",
-  "version": "4.3.0",
+  "version": "4.5.0",
   "description": "Voice tasks from Push iOS app for Claude Code",
   "type": "module",
   "bin": {