@robbeverhelst/do 1.64.0 → 1.66.0

package/dist/do.js

@@ -19768,26 +19768,24 @@ var taskAreaNameSchema = exports_external.string().trim().min(1).nullish();
 var createTaskInputSchema = createInsertSchema(tasks, {
   id: ulidSchema,
   scheduledAt: exports_external.coerce.date().nullish(),
-  startAt: exports_external.coerce.date().nullish(),
   dueAt: exports_external.coerce.date().nullish(),
   durationMinutes: exports_external.number().int().positive().nullish(),
   tags: exports_external.array(exports_external.string()).optional(),
   projectId: taskProjectIdSchema,
   areaId: taskAreaIdSchema
-}).omit({ tenantId: true, recurrenceRuleId: true }).extend({
+}).omit({ tenantId: true, recurrenceRuleId: true, startAt: true }).extend({
   title: exports_external.string().min(1),
   parentId: ulidSchema.nullish(),
   areaName: taskAreaNameSchema
 });
 var updateTaskInputSchema = createUpdateSchema(tasks, {
   scheduledAt: exports_external.coerce.date().nullish(),
-  startAt: exports_external.coerce.date().nullish(),
   dueAt: exports_external.coerce.date().nullish(),
   durationMinutes: exports_external.number().int().positive().nullish(),
   tags: exports_external.array(exports_external.string()).optional(),
   projectId: taskProjectIdSchema,
   areaId: taskAreaIdSchema
-}).omit({ id: true, tenantId: true, recurrenceRuleId: true }).extend({
+}).omit({ id: true, tenantId: true, recurrenceRuleId: true, startAt: true }).extend({
   title: exports_external.string().min(1).optional(),
   parentId: ulidSchema.nullish()
 }).strict();
@@ -20603,6 +20601,11 @@ var createCollectionEntryInputSchema = createInsertSchema(collectionEntries, {
   rating: exports_external.number().int().min(1).max(5).nullish(),
   note: exports_external.string().max(2000).nullish()
 }).omit({ tenantId: true, itemId: true, createdAt: true });
+var updateCollectionEntryInputSchema = exports_external.object({
+  occurredOn: exports_external.string().regex(/^\d{4}-\d{2}-\d{2}$/, "must be an ISO date (YYYY-MM-DD)").optional(),
+  rating: exports_external.number().int().min(1).max(5).nullish(),
+  note: exports_external.string().max(2000).nullish()
+}).strict();
 var collectionItemViewSchema = collectionItemSchema.extend({
   title: exports_external.string(),
   parentId: ulidSchema.nullable(),
@@ -21787,6 +21790,215 @@ var insightsOverviewSchema = exports_external.object({
   correlations: exports_external.array(insightsCorrelationSchema),
   streaks: exports_external.array(insightsStreakSchema)
 });
+// ../../packages/schema/src/when.ts
+var WEEKDAYS = [
+  { name: "sunday", dow: 0, code: "SU" },
+  { name: "monday", dow: 1, code: "MO" },
+  { name: "tuesday", dow: 2, code: "TU" },
+  { name: "wednesday", dow: 3, code: "WE" },
+  { name: "thursday", dow: 4, code: "TH" },
+  { name: "friday", dow: 5, code: "FR" },
+  { name: "saturday", dow: 6, code: "SA" }
+];
+var WEEKDAY_ALT = "monday|tuesday|wednesday|thursday|friday|saturday|sunday";
+var EVERY_N_RE = /\bevery\s+(\d+)\s+(day|days|week|weeks|month|months|year|years)\b/i;
+var EVERY_WEEKDAYS_RE = /\bevery\s+(?:weekday|weekdays|work\s?day|work\s?days)\b/i;
+var EVERY_WEEKDAY_RE = new RegExp(`\\bevery\\s+(${WEEKDAY_ALT})\\b`, "i");
+var EVERY_UNIT_RE = /\bevery\s+(day|week|month|year)\b/i;
+var ADVERB_RE = /\b(daily|weekly|monthly|yearly|annually)\b/i;
+var RELATIVE_RE = /\b(today|tonight|tomorrow|tmrw|tmr)\b/i;
+var IN_N_RE = /\bin\s+(\d+)\s+(day|days|week|weeks|month|months)\b/i;
+var NEXT_UNIT_RE = /\bnext\s+(week|month|year)\b/i;
+var NEXT_WEEKDAY_RE = new RegExp(`\\bnext\\s+(${WEEKDAY_ALT})\\b`, "i");
+var THIS_WEEKDAY_RE = new RegExp(`\\bthis\\s+(${WEEKDAY_ALT})\\b`, "i");
+var WEEKDAY_RE = new RegExp(`\\b(${WEEKDAY_ALT})\\b`, "i");
+var TIME_AMPM_RE = /\b(?:at\s+)?(\d{1,2})(?::(\d{2}))?\s*(am|pm)\b/i;
+var TIME_24H_RE = /\b(?:at\s+)?([01]?\d|2[0-3]):([0-5]\d)\b/;
+var NOON_RE = /\b(noon|midday)\b/i;
+var MIDNIGHT_RE = /\bmidnight\b/i;
+function blank(s, start, end) {
+  return s.slice(0, start) + " ".repeat(end - start) + s.slice(end);
+}
+function startOfDay(now) {
+  const d = new Date(now);
+  d.setHours(0, 0, 0, 0);
+  return d;
+}
+function addDays(d, days) {
+  const next = new Date(d);
+  next.setDate(next.getDate() + days);
+  return next;
+}
+function daysUntilWeekday(now, dow) {
+  return (dow - now.getDay() + 7) % 7;
+}
+var MONDAY = { name: "monday", dow: 1, code: "MO" };
+function weekdayByName(name) {
+  const hit = WEEKDAYS.find((w) => w.name === (name ?? "").toLowerCase());
+  return hit ?? MONDAY;
+}
+function parseWhen(input, now) {
+  const spans = [];
+  let scan = input;
+  const take = (m, kind) => {
+    if (!m || m.index === undefined)
+      return null;
+    const start = m.index;
+    const end = start + m[0].length;
+    const span = { start, end, kind };
+    spans.push(span);
+    scan = blank(scan, start, end);
+    return { span, index: start };
+  };
+  const recurrence2 = takeRecurrence(scan, take);
+  const date6 = takeDate(scan, take, now);
+  const time4 = takeTime(scan, take);
+  const { scheduledAt, allDay } = resolveWhen({ now, recurrence: recurrence2, date: date6, time: time4 });
+  spans.sort((a, b) => a.start - b.start);
+  return {
+    ...scheduledAt ? { scheduledAt } : {},
+    allDay,
+    ...recurrence2 ? { recurrence: recurrence2 } : {},
+    spans
+  };
+}
+function takeRecurrence(scan, take) {
+  const everyN = scan.match(EVERY_N_RE);
+  if (everyN && take(everyN, "recurrence")) {
+    const [, nStr = "1", unitRaw = "day"] = everyN;
+    const interval2 = Number(nStr);
+    const unit2 = unitRaw.toLowerCase();
+    const freq = unit2.startsWith("day") ? "daily" : unit2.startsWith("week") ? "weekly" : unit2.startsWith("month") ? "monthly" : "yearly";
+    return { mode: "rigid", freq, interval: interval2 > 0 ? interval2 : 1 };
+  }
+  const weekdays = scan.match(EVERY_WEEKDAYS_RE);
+  if (weekdays && take(weekdays, "recurrence")) {
+    return { mode: "rigid", freq: "weekly", interval: 1, byDay: ["MO", "TU", "WE", "TH", "FR"] };
+  }
+  const weekday = scan.match(EVERY_WEEKDAY_RE);
+  if (weekday && take(weekday, "recurrence")) {
+    return { mode: "rigid", freq: "weekly", interval: 1, byDay: [weekdayByName(weekday[1]).code] };
+  }
+  const unit = scan.match(EVERY_UNIT_RE);
+  if (unit && take(unit, "recurrence")) {
+    const u = (unit[1] ?? "").toLowerCase();
+    const freq = u === "day" ? "daily" : u === "week" ? "weekly" : u === "month" ? "monthly" : "yearly";
+    return { mode: "rigid", freq, interval: 1 };
+  }
+  const adverb = scan.match(ADVERB_RE);
+  if (adverb && take(adverb, "recurrence")) {
+    const word = (adverb[1] ?? "").toLowerCase();
+    const freq = word === "daily" ? "daily" : word === "weekly" ? "weekly" : word === "monthly" ? "monthly" : "yearly";
+    return { mode: "rigid", freq, interval: 1 };
+  }
+  return;
+}
+function takeDate(scan, take, now) {
+  const today2 = startOfDay(now);
+  const on = (day, tonight = false) => ({ day, tonight });
+  const inN = scan.match(IN_N_RE);
+  if (inN && take(inN, "date")) {
+    const [, nStr = "1", unitRaw = "day"] = inN;
+    const n = Number(nStr);
+    const unit = unitRaw.toLowerCase();
+    if (unit.startsWith("day"))
+      return on(addDays(today2, n));
+    if (unit.startsWith("week"))
+      return on(addDays(today2, n * 7));
+    return on(addMonths(today2, n));
+  }
+  const nextWeekday = scan.match(NEXT_WEEKDAY_RE);
+  if (nextWeekday && take(nextWeekday, "date")) {
+    const { dow } = weekdayByName(nextWeekday[1]);
+    const delta = daysUntilWeekday(now, dow) || 7;
+    return on(addDays(today2, delta));
+  }
+  const thisWeekday = scan.match(THIS_WEEKDAY_RE);
+  if (thisWeekday && take(thisWeekday, "date")) {
+    return on(addDays(today2, daysUntilWeekday(now, weekdayByName(thisWeekday[1]).dow)));
+  }
+  const nextUnit = scan.match(NEXT_UNIT_RE);
+  if (nextUnit && take(nextUnit, "date")) {
+    const u = (nextUnit[1] ?? "").toLowerCase();
+    if (u === "week")
+      return on(addDays(today2, 7));
+    if (u === "month")
+      return on(addMonths(today2, 1));
+    return on(addMonths(today2, 12));
+  }
+  const relative = scan.match(RELATIVE_RE);
+  if (relative && take(relative, "date")) {
+    const word = (relative[1] ?? "").toLowerCase();
+    if (word === "tonight")
+      return on(today2, true);
+    return on(word === "today" ? today2 : addDays(today2, 1));
+  }
+  const weekday = scan.match(WEEKDAY_RE);
+  if (weekday && take(weekday, "date")) {
+    return on(addDays(today2, daysUntilWeekday(now, weekdayByName(weekday[1]).dow)));
+  }
+  return null;
+}
+function takeTime(scan, take) {
+  const ampm = scan.match(TIME_AMPM_RE);
+  if (ampm && take(ampm, "time")) {
+    const [, hRaw = "0", mRaw, meridiem = "am"] = ampm;
+    let hours = Number(hRaw) % 12;
+    if (meridiem.toLowerCase() === "pm")
+      hours += 12;
+    return { hours, minutes: mRaw ? Number(mRaw) : 0 };
+  }
+  const h24 = scan.match(TIME_24H_RE);
+  if (h24 && take(h24, "time")) {
+    const [, hRaw = "0", mRaw = "0"] = h24;
+    return { hours: Number(hRaw), minutes: Number(mRaw) };
+  }
+  const noon = scan.match(NOON_RE);
+  if (noon && take(noon, "time"))
+    return { hours: 12, minutes: 0 };
+  const midnight = scan.match(MIDNIGHT_RE);
+  if (midnight && take(midnight, "time"))
+    return { hours: 0, minutes: 0 };
+  return null;
+}
+function resolveWhen(args) {
+  const { now, recurrence: recurrence2, date: date6, time: time4 } = args;
+  let day = date6?.day ?? null;
+  if (!day && recurrence2)
+    day = firstOccurrence(recurrence2, now);
+  if (!day && time4)
+    day = startOfDay(now);
+  if (!day)
+    return { allDay: true };
+  if (time4) {
+    const at = new Date(day);
+    at.setHours(time4.hours, time4.minutes, 0, 0);
+    return { scheduledAt: at, allDay: false };
+  }
+  if (date6?.tonight) {
+    const at = new Date(day);
+    at.setHours(18, 0, 0, 0);
+    return { scheduledAt: at, allDay: false };
+  }
+  return { scheduledAt: day, allDay: true };
+}
+function firstOccurrence(rule, now) {
+  const today2 = startOfDay(now);
+  if (rule.freq === "weekly" && rule.byDay && rule.byDay.length > 0) {
+    const deltas = rule.byDay.map((code) => {
+      const dow = WEEKDAYS.find((w) => w.code === code)?.dow ?? 1;
+      return daysUntilWeekday(now, dow);
+    });
+    return addDays(today2, Math.min(...deltas));
+  }
+  return today2;
+}
+function addMonths(d, months) {
+  const next = new Date(d);
+  next.setMonth(next.getMonth() + months);
+  return next;
+}
+
 // ../../packages/schema/src/capture.ts
 var TAG_RE = /(?:^|\s)#([\p{L}\p{N}][\p{L}\p{N}_-]*)/gu;
 var PRIORITY_RE = /(?:^|\s)!([\p{L}]+)/gu;
@@ -21803,7 +22015,7 @@ var PRIORITY_ALIASES = {
   h: "high",
   hi: "high"
 };
-function parseCapture(input) {
+function parseCapture(input, now) {
   const tags = [];
   for (const match of input.matchAll(TAG_RE)) {
     const tag = match[1]?.toLowerCase();
@@ -21825,8 +22037,29 @@ function parseCapture(input) {
       break;
     }
   }
-  const title = input.replace(TAG_RE, " ").replace(PRIORITY_RE, " ").replace(AREA_RE, " ").replace(/\s+/g, " ").trim();
-  return { title, tags, ...priority ? { priority } : {}, ...area ? { area } : {} };
+  let stripped = blankMatches(input, [TAG_RE, PRIORITY_RE, AREA_RE]);
+  const when = now ? parseWhen(stripped, now) : undefined;
+  if (when) {
+    for (const span of [...when.spans].sort((a, b) => b.start - a.start)) {
+      stripped = stripped.slice(0, span.start) + " ".repeat(span.end - span.start) + stripped.slice(span.end);
+    }
+  }
+  const title = stripped.replace(/\s+/g, " ").trim();
+  return {
+    title,
+    tags,
+    ...priority ? { priority } : {},
+    ...area ? { area } : {},
+    ...when?.scheduledAt ? { scheduledAt: when.scheduledAt, allDay: when.allDay } : {},
+    ...when?.recurrence ? { recurrence: when.recurrence } : {}
+  };
+}
+function blankMatches(input, regexes) {
+  let out = input;
+  for (const re of regexes) {
+    out = out.replace(re, (m) => " ".repeat(m.length));
+  }
+  return out;
 }
 // ../../packages/schema/src/export.ts
 var EXPORT_FORMAT = "do.export";
@@ -23981,8 +24214,8 @@ var usageError = (message, detail) => new CliError("usage", message, EXIT.USAGE,
 var configError = (message) => new CliError("config", message, EXIT.CONFIG);
 
 // src/capture.ts
-function parseCapture2(input) {
-  const parsed = parseCapture(input);
+function parseCapture2(input, now) {
+  const parsed = parseCapture(input, now);
   if (parsed.title.length === 0) {
     throw usageError("capture needs some text for the task title");
   }
@@ -23991,7 +24224,7 @@ function parseCapture2(input) {
 
 // src/meta.ts
 var CLI_NAME = "do";
-var VERSION = "1.64.0";
+var VERSION = "1.66.0";
 var API_PREFIX = "/api/v1";
 var DEFAULT_API_URL = "http://localhost:3001";
 
@@ -24062,9 +24295,17 @@ class DoClient {
     if (!res.ok) {
       throw httpError(res.status, parsed);
     }
-    return parsed;
+    return unwrapEnvelope(parsed);
   }
 }
+function unwrapEnvelope(body) {
+  if (typeof body === "object" && body !== null && !Array.isArray(body) && "nextCursor" in body) {
+    const record2 = body;
+    if (Array.isArray(record2.data))
+      return record2.data;
+  }
+  return body;
+}
 function safeJson(text2) {
   try {
     return JSON.parse(text2);
@@ -25110,8 +25351,8 @@ function renderTask(data, mode) {
   const t = data;
   const mark = STATUS_MARK[t.status ?? ""] ?? "\u2022";
   const prio = t.priority && t.priority !== "none" ? paint(mode, "yellow", `!${t.priority} `) : "";
-  const when = t.scheduledAt ?? t.dueAt;
-  const date6 = when ? paint(mode, "dim", `  (${shortDate(when)})`) : "";
+  const when2 = t.scheduledAt ?? t.dueAt;
+  const date6 = when2 ? paint(mode, "dim", `  (${shortDate(when2)})`) : "";
   return `${mark} ${prio}${t.title ?? "(untitled)"}${date6}
   ${paint(mode, "dim", t.id)}`;
 }
@@ -25399,19 +25640,30 @@ function runFixed(spec, ctx) {
   return handler(ctx);
 }
 var HANDLERS = {
-  capture: async ({ args, requireClient }) => {
+  capture: async ({ args, io, requireClient }) => {
     const text2 = args.join(" ").trim();
     if (text2.length === 0)
       throw usageError('capture needs some text, e.g. `do capture "call mum #family"`');
-    const parsed = parseCapture2(text2);
+    const parsed = parseCapture2(text2, io.now());
+    const id = ulid3();
     const input = parseInput(createTaskInputSchema, {
-      id: ulid3(),
+      id,
       title: parsed.title,
       tags: parsed.tags,
       ...parsed.priority ? { priority: parsed.priority } : {},
-      ...parsed.area ? { areaName: parsed.area } : {}
+      ...parsed.area ? { areaName: parsed.area } : {},
+      ...parsed.scheduledAt ? { scheduledAt: parsed.scheduledAt, allDay: parsed.allDay } : {}
     });
-    return { data: await requireClient().post("/tasks", input), render: renderTask };
+    const client = requireClient();
+    const task = await client.post("/tasks", input);
+    if (parsed.recurrence) {
+      const rule = parseInput(createRecurrenceRuleInputSchema, {
+        templateId: id,
+        ...parsed.recurrence
+      });
+      await client.post("/recurrence/rules", rule);
+    }
+    return { data: task, render: renderTask };
   },
   today: async ({ io, requireClient }) => {
     const tasks3 = await requireClient().get("/tasks", { query: { filter: "all" } });
@@ -25658,7 +25910,8 @@ var HANDLERS = {
   "link revoke": async ({ args, flags, requireClient }) => {
     const id = requireArg(args, 0, "share-link id");
     assertDestructiveAllowed(flags, `revoke share-link ${id}`);
-    return { data: await requireClient().delete(`/share-links/${id}`), render: renderRecord };
+    await requireClient().delete(`/share-links/${id}`);
+    return { data: { ok: true, revoked: id }, render: renderRecord };
   },
   whoami: async ({ requireClient }) => ({
     data: await requireClient().get("/whoami"),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@robbeverhelst/do",
-  "version": "1.64.0",
+  "version": "1.66.0",
   "private": false,
   "description": "do — the agent-drivable CLI over the public /api/v1 surface",
   "type": "module",