@robbeverhelst/do 1.341.0 → 1.342.0

package/dist/do.js

@@ -14418,7 +14418,7 @@ var configError = (message) => new CliError("config", message, EXIT.CONFIG);
 
 // src/meta.ts
 var CLI_NAME = "do";
-var VERSION = "1.341.0";
+var VERSION = "1.342.0";
 var API_PREFIX = "/api/v1";
 var DEFAULT_API_URL = "http://localhost:3001";
 
@@ -18020,7 +18020,10 @@ var habits = pgTable("habits", {
   pausedFrom: date5("paused_from", { mode: "string" }),
   pausedUntil: date5("paused_until", { mode: "string" }),
   remind: boolean4("remind").notNull().default(false),
-  retiredAt: timestamp("retired_at", { withTimezone: true })
+  retiredAt: timestamp("retired_at", { withTimezone: true }),
+  eventSourceId: text("event_source_id"),
+  eventMatch: text("event_match"),
+  eventOffset: text("event_offset")
 }, (t) => [
   index("habits_tenant_idx").on(t.tenantId),
   index("habits_tenant_area_idx").on(t.tenantId, t.areaId),
@@ -18050,6 +18053,8 @@ var recurrenceRules = pgTable("recurrence_rules", {
   interval: integer2("interval").notNull().default(1),
   freq: recurrenceFreq("freq"),
   byDay: text("by_day").array(),
+  byMonthDay: integer2("by_month_day"),
+  startsOn: date5("starts_on", { mode: "string" }),
   timeOfDay: text("time_of_day"),
   until: timestamp("until", { withTimezone: true }),
   count: integer2("count"),
@@ -21269,6 +21274,75 @@ var animalOperations = defineOperations({
 // ../../packages/schema/src/contracts/habit-sources.ts
 var habitSourceSchema = _enum2(["manual", "google_fit", "strava", "github"]);
 
+// ../../packages/schema/src/contracts/recurrence.ts
+var recurrenceRuleSchema = createSelectSchema(recurrenceRules, {
+  until: exports_coerce.date().nullable(),
+  byMonthDay: number2().int().nullable().default(null),
+  startsOn: exports_iso.date().nullable().default(null)
+});
+var occurrenceSchema = createSelectSchema(occurrences, {
+  occurrenceDate: exports_coerce.date(),
+  completedAt: exports_coerce.date().nullable()
+});
+var byDayCodeSchema = _enum2(["MO", "TU", "WE", "TH", "FR", "SA", "SU"]);
+var byDayOrdinalSchema = _enum2(["1", "2", "3", "4", "-1"]);
+var byDaySchema = union([
+  byDayCodeSchema,
+  templateLiteral([byDayOrdinalSchema, byDayCodeSchema])
+]);
+var BY_DAY_RE = /^(-1|[1-4])?(MO|TU|WE|TH|FR|SA|SU)$/;
+function parseByDay(code) {
+  const m = BY_DAY_RE.exec(code);
+  if (!m)
+    return null;
+  return { ordinal: m[1] ? Number(m[1]) : null, weekday: m[2] };
+}
+var recurrenceRuleParams = {
+  timezone: string2().min(1).default("UTC"),
+  interval: number2().int().positive().default(1),
+  mode: recurrenceModeSchema,
+  timeOfDay: string2().regex(/^([01]\d|2[0-3]):[0-5]\d$/, "time-of-day must be HH:MM (24h)").nullish(),
+  freq: recurrenceFreqSchema.optional(),
+  byDay: array(byDaySchema).optional(),
+  until: exports_coerce.date().optional(),
+  count: number2().int().positive().optional(),
+  unit: recurrenceUnitSchema.optional(),
+  anchor: recurrenceAnchorSchema.optional()
+};
+function refineRecurrenceRule(v, ctx) {
+  if (v.mode === "rigid" && !v.freq) {
+    ctx.addIssue({ code: "custom", path: ["freq"], message: "rigid rules require a freq" });
+  }
+  const ordinal = v.byDay?.findIndex((code) => parseByDay(code)?.ordinal != null) ?? -1;
+  if (ordinal >= 0 && v.freq !== "monthly" && v.freq !== "yearly") {
+    ctx.addIssue({
+      code: "custom",
+      path: ["byDay", ordinal],
+      message: "an ordinal weekday (1SU, -1FR) needs a monthly or yearly freq"
+    });
+  }
+  if (v.mode === "flexible") {
+    if (!v.unit) {
+      ctx.addIssue({ code: "custom", path: ["unit"], message: "flexible rules require a unit" });
+    }
+    if (!v.anchor) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["anchor"],
+        message: "flexible rules require an anchor"
+      });
+    }
+  }
+}
+var createRecurrenceRuleInputSchema = object({
+  templateId: ulidSchema,
+  ...recurrenceRuleParams
+}).superRefine(refineRecurrenceRule);
+var updateRecurrenceRuleInputSchema = object({ ...recurrenceRuleParams }).superRefine(refineRecurrenceRule);
+var updateOccurrenceInputSchema = createUpdateSchema(occurrences, {
+  occurrenceDate: exports_coerce.date().optional()
+}).pick({ occurrenceDate: true, status: true }).strict();
+
 // ../../packages/schema/src/contracts/habits.ts
 var habitSchema = createSelectSchema(habits, {
   source: habitSourceSchema.default("manual"),
@@ -21278,7 +21352,10 @@ var habitSchema = createSelectSchema(habits, {
   pausedFrom: exports_iso.date().nullable().default(null),
   pausedUntil: exports_iso.date().nullable().default(null),
   remind: boolean2().default(false),
-  retiredAt: exports_coerce.date().nullable().default(null)
+  retiredAt: exports_coerce.date().nullable().default(null),
+  eventSourceId: string2().nullable().default(null),
+  eventMatch: string2().nullable().default(null),
+  eventOffset: string2().nullable().default(null)
 });
 var habitEntrySchema = createSelectSchema(habitEntries, {
   occurredAt: exports_coerce.date(),
@@ -21297,6 +21374,30 @@ var habitTimeOfDaySchema = union([
 ]);
 var habitAliasSchema = string2().trim().min(1).max(60);
 var habitAliasesSchema = array(habitAliasSchema).max(12).transform((aliases) => aliases.filter((a, i) => aliases.findIndex((b) => b.toLowerCase() === a.toLowerCase()) === i));
+var habitScheduleSchema = discriminatedUnion("kind", [
+  object({ kind: literal("daily") }),
+  object({
+    kind: literal("weekdays"),
+    days: array(byDayCodeSchema).min(1).max(7).refine((days) => new Set(days).size === days.length, "each weekday once")
+  }),
+  object({
+    kind: literal("every"),
+    interval: number2().int().min(2),
+    unit: _enum2(["day", "week"]),
+    anchor: exports_iso.date()
+  }),
+  object({
+    kind: literal("monthly"),
+    dayOfMonth: union([number2().int().min(1).max(31), literal(-1)])
+  }),
+  object({
+    kind: literal("event"),
+    sourceId: ulidSchema,
+    match: string2().trim().min(1).max(120),
+    offset: _enum2(["day_before_evening", "same_day"])
+  })
+]);
+var eventColumns = { eventSourceId: true, eventMatch: true, eventOffset: true };
 var createHabitInputSchema = createInsertSchema(habits, {
   id: ulidSchema,
   source: habitSourceSchema.optional(),
@@ -21310,8 +21411,9 @@ var createHabitInputSchema = createInsertSchema(habits, {
   aliases: habitAliasesSchema.optional(),
   timeOfDay: habitTimeOfDaySchema.nullish(),
   remind: boolean2().optional()
-}).omit({ tenantId: true, recurrenceRuleId: true, retiredAt: true }).extend({
+}).omit({ tenantId: true, recurrenceRuleId: true, retiredAt: true, ...eventColumns }).extend({
   title: string2().min(1),
+  schedule: habitScheduleSchema.optional(),
   displayKind: string2().min(1).nullish()
 });
 var updateHabitInputSchema = createUpdateSchema(habits, {
@@ -21332,8 +21434,12 @@ var updateHabitInputSchema = createUpdateSchema(habits, {
   recurrenceRuleId: true,
   pausedFrom: true,
   pausedUntil: true,
-  retiredAt: true
-}).extend({ title: string2().min(1).optional() });
+  retiredAt: true,
+  ...eventColumns
+}).extend({
+  title: string2().min(1).optional(),
+  schedule: habitScheduleSchema.optional()
+});
 var HABIT_ENTRY_NOTE_MAX = 280;
 var habitEntryNoteSchema = string2().trim().max(HABIT_ENTRY_NOTE_MAX).transform((note) => note === "" ? null : note);
 var createHabitEntryInputSchema = createInsertSchema(habitEntries, {
@@ -21387,7 +21493,9 @@ var habitSummarySchema = habitSchema.extend({
   inRoutines: array(habitRoutineRefSchema).default([]),
   lastCheckIn: habitLastCheckInSchema.nullable().default(null),
   pause: habitPauseSchema.nullable().default(null),
-  today: habitTodaySchema.default({ due: true, done: false })
+  today: habitTodaySchema.default({ due: true, done: false }),
+  schedule: habitScheduleSchema.default({ kind: "daily" }),
+  nextDue: array(exports_iso.date()).default([])
 });
 var habitHeatmapCellSchema = object({
   date: string2(),
@@ -22194,73 +22302,6 @@ var projectDetailSchema = projectViewSchema.extend({
 });
 var attachTaskInputSchema = object({ taskId: ulidSchema });
 
-// ../../packages/schema/src/contracts/recurrence.ts
-var recurrenceRuleSchema = createSelectSchema(recurrenceRules, {
-  until: exports_coerce.date().nullable()
-});
-var occurrenceSchema = createSelectSchema(occurrences, {
-  occurrenceDate: exports_coerce.date(),
-  completedAt: exports_coerce.date().nullable()
-});
-var byDayCodeSchema = _enum2(["MO", "TU", "WE", "TH", "FR", "SA", "SU"]);
-var byDayOrdinalSchema = _enum2(["1", "2", "3", "4", "-1"]);
-var byDaySchema = union([
-  byDayCodeSchema,
-  templateLiteral([byDayOrdinalSchema, byDayCodeSchema])
-]);
-var BY_DAY_RE = /^(-1|[1-4])?(MO|TU|WE|TH|FR|SA|SU)$/;
-function parseByDay(code) {
-  const m = BY_DAY_RE.exec(code);
-  if (!m)
-    return null;
-  return { ordinal: m[1] ? Number(m[1]) : null, weekday: m[2] };
-}
-var recurrenceRuleParams = {
-  timezone: string2().min(1).default("UTC"),
-  interval: number2().int().positive().default(1),
-  mode: recurrenceModeSchema,
-  timeOfDay: string2().regex(/^([01]\d|2[0-3]):[0-5]\d$/, "time-of-day must be HH:MM (24h)").nullish(),
-  freq: recurrenceFreqSchema.optional(),
-  byDay: array(byDaySchema).optional(),
-  until: exports_coerce.date().optional(),
-  count: number2().int().positive().optional(),
-  unit: recurrenceUnitSchema.optional(),
-  anchor: recurrenceAnchorSchema.optional()
-};
-function refineRecurrenceRule(v, ctx) {
-  if (v.mode === "rigid" && !v.freq) {
-    ctx.addIssue({ code: "custom", path: ["freq"], message: "rigid rules require a freq" });
-  }
-  const ordinal = v.byDay?.findIndex((code) => parseByDay(code)?.ordinal != null) ?? -1;
-  if (ordinal >= 0 && v.freq !== "monthly" && v.freq !== "yearly") {
-    ctx.addIssue({
-      code: "custom",
-      path: ["byDay", ordinal],
-      message: "an ordinal weekday (1SU, -1FR) needs a monthly or yearly freq"
-    });
-  }
-  if (v.mode === "flexible") {
-    if (!v.unit) {
-      ctx.addIssue({ code: "custom", path: ["unit"], message: "flexible rules require a unit" });
-    }
-    if (!v.anchor) {
-      ctx.addIssue({
-        code: "custom",
-        path: ["anchor"],
-        message: "flexible rules require an anchor"
-      });
-    }
-  }
-}
-var createRecurrenceRuleInputSchema = object({
-  templateId: ulidSchema,
-  ...recurrenceRuleParams
-}).superRefine(refineRecurrenceRule);
-var updateRecurrenceRuleInputSchema = object({ ...recurrenceRuleParams }).superRefine(refineRecurrenceRule);
-var updateOccurrenceInputSchema = createUpdateSchema(occurrences, {
-  occurrenceDate: exports_coerce.date().optional()
-}).pick({ occurrenceDate: true, status: true }).strict();
-
 // ../../packages/schema/src/contracts/routines.ts
 var routineDayTimesSchema = partialRecord(_enum2(["MO", "TU", "WE", "TH", "FR", "SA", "SU"]), string2().regex(/^([01]\d|2[0-3]):[0-5]\d$/));
 var routineSchema = createSelectSchema(routines);
@@ -46989,7 +47030,144 @@ var commands19 = [
 ];
 
 // src/commands/habits.ts
+var SCHEDULE_FLAGS = [
+  { name: "every-day", type: "boolean", description: "Due every day." },
+  {
+    name: "on",
+    type: "string",
+    description: "Due on these weekdays, comma-separated (mo,we,fr)."
+  },
+  {
+    name: "every",
+    type: "string",
+    description: "Due every N days or weeks (3d, 2w), counted in calendar days from --from, never from the last check-in."
+  },
+  {
+    name: "from",
+    type: "string",
+    description: "The day --every counts from, YYYY-MM-DD (default today)."
+  },
+  {
+    name: "monthly",
+    type: "string",
+    description: "Due monthly on this day of the month: 1\u201331 (a 31 falls on a shorter month's last day), or last."
+  },
+  { name: "data", type: "string", description: "JSON for any other field of the contract." }
+];
+var SCHEDULE_NOTES = "One of --every-day, --on mo,we,fr, --every 3d|2w [--from YYYY-MM-DD], --monthly 1|last sets its schedule; days it isn't due never break the streak. Without one, it keeps `period` + `frequencyCount` (3\xD7 a week). The reply's `nextDue` lists its next 4 due days.";
+function localToday() {
+  const now = new Date;
+  const pad = (n) => String(n).padStart(2, "0");
+  return `${now.getFullYear()}-${pad(now.getMonth() + 1)}-${pad(now.getDate())}`;
+}
+function scheduleFromFlags(flags, today = localToday()) {
+  const on = flagString(flags, "on");
+  const every = flagString(flags, "every");
+  const monthly = flagString(flags, "monthly");
+  const given = [flagBool(flags, "every-day"), on, every, monthly].filter((v) => v !== undefined && v !== false);
+  if (given.length > 1)
+    throw usageError("pick one schedule: --every-day, --on, --every or --monthly");
+  if (flagString(flags, "from") !== undefined && every === undefined)
+    throw usageError("--from goes with --every");
+  if (flagBool(flags, "every-day"))
+    return { kind: "daily" };
+  if (on !== undefined) {
+    const days = on.split(",").map((d) => d.trim().toUpperCase()).filter((d) => d.length > 0);
+    return { kind: "weekdays", days };
+  }
+  if (every !== undefined) {
+    const m = /^(\d+)\s*([dw])$/i.exec(every.trim());
+    if (!m)
+      throw usageError("--every takes a number of days or weeks: 3d or 2w");
+    return {
+      kind: "every",
+      interval: Number(m[1]),
+      unit: m[2]?.toLowerCase() === "w" ? "week" : "day",
+      anchor: flagString(flags, "from") ?? today
+    };
+  }
+  if (monthly !== undefined) {
+    const day = monthly.trim().toLowerCase() === "last" ? -1 : Number(monthly);
+    if (!Number.isInteger(day))
+      throw usageError("--monthly takes a day of the month (1\u201331) or last");
+    return { kind: "monthly", dayOfMonth: day };
+  }
+  return;
+}
 var commands20 = [
+  {
+    spec: {
+      path: ["habits", "create"],
+      summary: "Create a habit, with an optional schedule (every day, weekdays, every N, monthly).",
+      args: [{ name: "title", required: false, description: "The habit's title." }],
+      flags: SCHEDULE_FLAGS,
+      scopes: [...habitOperations.create.scopes],
+      returns: "HabitSummary",
+      notes: `${routeOf(habitOperations.create)}. --data carries the rest of a CreateHabitInput; the id is minted and a yes/no measurement assumed when omitted. ${SCHEDULE_NOTES} e.g. \`do habits create "Water the plants" --every 3d\`.`
+    },
+    run: async ({ args, flags, requireClient }) => {
+      const title = args.join(" ").trim();
+      const schedule = scheduleFromFlags(flags);
+      const body = parseInput(createHabitInputSchema, {
+        id: ulid3(),
+        measurementType: "binary",
+        ...title ? { title } : {},
+        ...readDataFlag(flags),
+        ...schedule ? { schedule } : {}
+      });
+      if (flagBool(flags, "dry-run")) {
+        return {
+          data: { dryRun: true, op: "create", entity: "habits", after: body },
+          render: renderRecord
+        };
+      }
+      return {
+        data: await requireClient().post(pathOf(habitOperations.create), body),
+        render: renderRecord
+      };
+    }
+  },
+  {
+    spec: {
+      path: ["habits", "update"],
+      summary: "Change a habit: its schedule (--every-day, --on, --every, --monthly) or --data.",
+      args: [{ name: "id", required: true, description: "Habit ULID." }],
+      flags: SCHEDULE_FLAGS,
+      scopes: [...habitOperations.update.scopes],
+      returns: "HabitSummary",
+      notes: `${routeOf(habitOperations.update)}. Only what you pass changes. ${SCHEDULE_NOTES}`
+    },
+    run: async ({ args, flags, requireClient }) => {
+      const id = requireArg(args, 0, "habit id");
+      const schedule = scheduleFromFlags(flags);
+      const body = parseInput(updateHabitInputSchema, {
+        ...readDataFlag(flags),
+        ...schedule ? { schedule } : {}
+      });
+      if (Object.keys(body).length === 0)
+        throw usageError("nothing to change \u2014 pass a schedule flag such as --on mo,we, or --data");
+      const client = requireClient();
+      if (flagBool(flags, "dry-run")) {
+        const before = await client.get(pathOf(habitOperations.get, { id }));
+        return {
+          data: {
+            dryRun: true,
+            op: "update",
+            entity: "habits",
+            id,
+            before,
+            after: mergePreview(before, body),
+            changes: body
+          },
+          render: renderRecord
+        };
+      }
+      return {
+        data: await client.patch(pathOf(habitOperations.update, { id }), body),
+        render: renderRecord
+      };
+    }
+  },
   {
     spec: {
       path: ["habit", "log"],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@robbeverhelst/do",
-  "version": "1.341.0",
+  "version": "1.342.0",
   "private": false,
   "description": "do — the agent-drivable CLI over the public /api/v1 surface",
   "homepage": "https://github.com/robbeverhelst/do/tree/main/apps/cli",