@tashks/core 0.1.0 → 0.1.2

package/dist/src/query.d.ts

@@ -9,286 +9,127 @@ export declare const isDeferred: (today: string) => (task: Task) => boolean;
 export declare const hasEnergy: (level: TaskEnergy) => (task: Task) => boolean;
 export declare const hasTag: (tag: string) => (task: Task) => boolean;
 export declare const hasProject: (project: string) => (task: Task) => boolean;
-export declare const isStalerThan: (
-	days: number,
-	today: string,
-) => (task: Task) => boolean;
+export declare const isStalerThan: (days: number, today: string) => (task: Task) => boolean;
 export declare const wasCompletedOn: (date: string) => (task: Task) => boolean;
-export declare const wasCompletedBetween: (
-	start: string,
-	end: string,
-) => (task: Task) => boolean;
+export declare const wasCompletedBetween: (start: string, end: string) => (task: Task) => boolean;
 export declare const byDueAsc: (a: Task, b: Task) => number;
 export declare const byEnergyAsc: (a: Task, b: Task) => number;
 export declare const byCreatedAsc: (a: Task, b: Task) => number;
 export declare const byUpdatedDescThenTitle: (a: Task, b: Task) => number;
-export declare const resolveRelativeDate: (
-	value: string,
-	today: string,
-) => string | null;
+export declare const resolveRelativeDate: (value: string, today: string) => string | null;
 export declare const PerspectiveFilters: Schema.Struct<{
-	status: Schema.optionalWith<
-		Schema.Literal<
-			["active", "backlog", "blocked", "done", "dropped", "on-hold"]
-		>,
-		{
-			exact: true;
-		}
-	>;
-	area: Schema.optionalWith<
-		Schema.Literal<
-			[
-				"health",
-				"infrastructure",
-				"work",
-				"personal",
-				"blog",
-				"code",
-				"home",
-				"side-projects",
-			]
-		>,
-		{
-			exact: true;
-		}
-	>;
-	project: Schema.optionalWith<
-		typeof Schema.String,
-		{
-			exact: true;
-		}
-	>;
-	tags: Schema.optionalWith<
-		Schema.Array$<typeof Schema.String>,
-		{
-			exact: true;
-		}
-	>;
-	due_before: Schema.optionalWith<
-		typeof Schema.String,
-		{
-			exact: true;
-		}
-	>;
-	due_after: Schema.optionalWith<
-		typeof Schema.String,
-		{
-			exact: true;
-		}
-	>;
-	unblocked_only: Schema.optionalWith<
-		typeof Schema.Boolean,
-		{
-			exact: true;
-		}
-	>;
-	energy: Schema.optionalWith<
-		Schema.Literal<["low", "medium", "high"]>,
-		{
-			exact: true;
-		}
-	>;
-	stale_days: Schema.optionalWith<
-		typeof Schema.Number,
-		{
-			exact: true;
-		}
-	>;
-	completed_on: Schema.optionalWith<
-		typeof Schema.String,
-		{
-			exact: true;
-		}
-	>;
+    status: Schema.optionalWith<Schema.Literal<["active", "backlog", "blocked", "done", "dropped", "on-hold"]>, {
+        exact: true;
+    }>;
+    area: Schema.optionalWith<Schema.Literal<["health", "infrastructure", "work", "personal", "blog", "code", "home", "side-projects"]>, {
+        exact: true;
+    }>;
+    project: Schema.optionalWith<typeof Schema.String, {
+        exact: true;
+    }>;
+    tags: Schema.optionalWith<Schema.Array$<typeof Schema.String>, {
+        exact: true;
+    }>;
+    due_before: Schema.optionalWith<typeof Schema.String, {
+        exact: true;
+    }>;
+    due_after: Schema.optionalWith<typeof Schema.String, {
+        exact: true;
+    }>;
+    unblocked_only: Schema.optionalWith<typeof Schema.Boolean, {
+        exact: true;
+    }>;
+    energy: Schema.optionalWith<Schema.Literal<["low", "medium", "high"]>, {
+        exact: true;
+    }>;
+    stale_days: Schema.optionalWith<typeof Schema.Number, {
+        exact: true;
+    }>;
+    completed_on: Schema.optionalWith<typeof Schema.String, {
+        exact: true;
+    }>;
 }>;
 export type PerspectiveFilters = Schema.Schema.Type<typeof PerspectiveFilters>;
 export declare const PerspectiveSort: typeof Schema.String;
 export type PerspectiveSort = Schema.Schema.Type<typeof PerspectiveSort>;
 export declare const Perspective: Schema.Struct<{
-	filters: Schema.Struct<{
-		status: Schema.optionalWith<
-			Schema.Literal<
-				["active", "backlog", "blocked", "done", "dropped", "on-hold"]
-			>,
-			{
-				exact: true;
-			}
-		>;
-		area: Schema.optionalWith<
-			Schema.Literal<
-				[
-					"health",
-					"infrastructure",
-					"work",
-					"personal",
-					"blog",
-					"code",
-					"home",
-					"side-projects",
-				]
-			>,
-			{
-				exact: true;
-			}
-		>;
-		project: Schema.optionalWith<
-			typeof Schema.String,
-			{
-				exact: true;
-			}
-		>;
-		tags: Schema.optionalWith<
-			Schema.Array$<typeof Schema.String>,
-			{
-				exact: true;
-			}
-		>;
-		due_before: Schema.optionalWith<
-			typeof Schema.String,
-			{
-				exact: true;
-			}
-		>;
-		due_after: Schema.optionalWith<
-			typeof Schema.String,
-			{
-				exact: true;
-			}
-		>;
-		unblocked_only: Schema.optionalWith<
-			typeof Schema.Boolean,
-			{
-				exact: true;
-			}
-		>;
-		energy: Schema.optionalWith<
-			Schema.Literal<["low", "medium", "high"]>,
-			{
-				exact: true;
-			}
-		>;
-		stale_days: Schema.optionalWith<
-			typeof Schema.Number,
-			{
-				exact: true;
-			}
-		>;
-		completed_on: Schema.optionalWith<
-			typeof Schema.String,
-			{
-				exact: true;
-			}
-		>;
-	}>;
-	sort: Schema.optionalWith<
-		typeof Schema.String,
-		{
-			exact: true;
-		}
-	>;
+    filters: Schema.Struct<{
+        status: Schema.optionalWith<Schema.Literal<["active", "backlog", "blocked", "done", "dropped", "on-hold"]>, {
+            exact: true;
+        }>;
+        area: Schema.optionalWith<Schema.Literal<["health", "infrastructure", "work", "personal", "blog", "code", "home", "side-projects"]>, {
+            exact: true;
+        }>;
+        project: Schema.optionalWith<typeof Schema.String, {
+            exact: true;
+        }>;
+        tags: Schema.optionalWith<Schema.Array$<typeof Schema.String>, {
+            exact: true;
+        }>;
+        due_before: Schema.optionalWith<typeof Schema.String, {
+            exact: true;
+        }>;
+        due_after: Schema.optionalWith<typeof Schema.String, {
+            exact: true;
+        }>;
+        unblocked_only: Schema.optionalWith<typeof Schema.Boolean, {
+            exact: true;
+        }>;
+        energy: Schema.optionalWith<Schema.Literal<["low", "medium", "high"]>, {
+            exact: true;
+        }>;
+        stale_days: Schema.optionalWith<typeof Schema.Number, {
+            exact: true;
+        }>;
+        completed_on: Schema.optionalWith<typeof Schema.String, {
+            exact: true;
+        }>;
+    }>;
+    sort: Schema.optionalWith<typeof Schema.String, {
+        exact: true;
+    }>;
 }>;
 export type Perspective = Schema.Schema.Type<typeof Perspective>;
-export declare const PerspectiveConfig: Schema.Record$<
-	typeof Schema.String,
-	Schema.Struct<{
-		filters: Schema.Struct<{
-			status: Schema.optionalWith<
-				Schema.Literal<
-					["active", "backlog", "blocked", "done", "dropped", "on-hold"]
-				>,
-				{
-					exact: true;
-				}
-			>;
-			area: Schema.optionalWith<
-				Schema.Literal<
-					[
-						"health",
-						"infrastructure",
-						"work",
-						"personal",
-						"blog",
-						"code",
-						"home",
-						"side-projects",
-					]
-				>,
-				{
-					exact: true;
-				}
-			>;
-			project: Schema.optionalWith<
-				typeof Schema.String,
-				{
-					exact: true;
-				}
-			>;
-			tags: Schema.optionalWith<
-				Schema.Array$<typeof Schema.String>,
-				{
-					exact: true;
-				}
-			>;
-			due_before: Schema.optionalWith<
-				typeof Schema.String,
-				{
-					exact: true;
-				}
-			>;
-			due_after: Schema.optionalWith<
-				typeof Schema.String,
-				{
-					exact: true;
-				}
-			>;
-			unblocked_only: Schema.optionalWith<
-				typeof Schema.Boolean,
-				{
-					exact: true;
-				}
-			>;
-			energy: Schema.optionalWith<
-				Schema.Literal<["low", "medium", "high"]>,
-				{
-					exact: true;
-				}
-			>;
-			stale_days: Schema.optionalWith<
-				typeof Schema.Number,
-				{
-					exact: true;
-				}
-			>;
-			completed_on: Schema.optionalWith<
-				typeof Schema.String,
-				{
-					exact: true;
-				}
-			>;
-		}>;
-		sort: Schema.optionalWith<
-			typeof Schema.String,
-			{
-				exact: true;
-			}
-		>;
-	}>
->;
+export declare const PerspectiveConfig: Schema.Record$<typeof Schema.String, Schema.Struct<{
+    filters: Schema.Struct<{
+        status: Schema.optionalWith<Schema.Literal<["active", "backlog", "blocked", "done", "dropped", "on-hold"]>, {
+            exact: true;
+        }>;
+        area: Schema.optionalWith<Schema.Literal<["health", "infrastructure", "work", "personal", "blog", "code", "home", "side-projects"]>, {
+            exact: true;
+        }>;
+        project: Schema.optionalWith<typeof Schema.String, {
+            exact: true;
+        }>;
+        tags: Schema.optionalWith<Schema.Array$<typeof Schema.String>, {
+            exact: true;
+        }>;
+        due_before: Schema.optionalWith<typeof Schema.String, {
+            exact: true;
+        }>;
+        due_after: Schema.optionalWith<typeof Schema.String, {
+            exact: true;
+        }>;
+        unblocked_only: Schema.optionalWith<typeof Schema.Boolean, {
+            exact: true;
+        }>;
+        energy: Schema.optionalWith<Schema.Literal<["low", "medium", "high"]>, {
+            exact: true;
+        }>;
+        stale_days: Schema.optionalWith<typeof Schema.Number, {
+            exact: true;
+        }>;
+        completed_on: Schema.optionalWith<typeof Schema.String, {
+            exact: true;
+        }>;
+    }>;
+    sort: Schema.optionalWith<typeof Schema.String, {
+        exact: true;
+    }>;
+}>>;
 export type PerspectiveConfig = Schema.Schema.Type<typeof PerspectiveConfig>;
-export declare const parsePerspectiveConfig: (
-	record: unknown,
-) => PerspectiveConfig | null;
-export declare const resolvePerspectiveConfigRelativeDates: (
-	config: PerspectiveConfig,
-	today: string,
-) => PerspectiveConfig | null;
-export declare const applyPerspectiveToTasks: (
-	tasks: ReadonlyArray<Task>,
-	perspective: Perspective,
-	today?: string,
-) => Array<Task>;
-export declare const loadPerspectiveConfig: (
-	dataDir: string,
-	today?: string,
-) => Effect.Effect<PerspectiveConfig, string>;
-//# sourceMappingURL=query.d.ts.map
+export declare const parsePerspectiveConfig: (record: unknown) => PerspectiveConfig | null;
+export declare const resolvePerspectiveConfigRelativeDates: (config: PerspectiveConfig, today: string) => PerspectiveConfig | null;
+export declare const applyPerspectiveToTasks: (tasks: ReadonlyArray<Task>, perspective: Perspective, today?: string) => Array<Task>;
+export declare const loadPerspectiveConfig: (dataDir: string, today?: string) => Effect.Effect<PerspectiveConfig, string>;
+//# sourceMappingURL=query.d.ts.map

package/dist/src/query.test.d.ts

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=query.test.d.ts.map
+//# sourceMappingURL=query.test.d.ts.map

package/dist/src/recurrence.d.ts

@@ -0,0 +1,21 @@
+import * as Effect from "effect/Effect";
+import { type Task } from "./schema.js";
+export interface CompletionRecurrenceInterval {
+    readonly frequency: "DAILY" | "WEEKLY" | "MONTHLY" | "YEARLY";
+    readonly interval: number;
+}
+export declare const parseCompletionRecurrenceInterval: (recurrence: string) => Effect.Effect<CompletionRecurrenceInterval, string>;
+export declare const addRecurrenceInterval: (date: Date, recurrenceInterval: CompletionRecurrenceInterval) => Date;
+export declare const shiftIsoDateByRecurrenceInterval: (date: string, recurrenceInterval: CompletionRecurrenceInterval) => Effect.Effect<string, string>;
+export declare const shiftIsoDateTimeToDateByRecurrenceInterval: (dateTime: string, recurrenceInterval: CompletionRecurrenceInterval) => Effect.Effect<string, string>;
+export declare const toIsoDateTime: (value: Date, label: string) => Effect.Effect<string, string>;
+export declare const parseIsoDateToUtcStart: (value: string, label: string) => Effect.Effect<Date, string>;
+export declare const parseIsoDateTime: (value: string, label: string) => Effect.Effect<Date, string>;
+export declare const buildCompletionRecurrenceTask: (completedTask: Task, completedAt: string) => Effect.Effect<Task | null, string>;
+export declare const isClockRecurrenceDue: (task: Task, now: Date) => Effect.Effect<boolean, string>;
+export declare const buildNextClockRecurrenceTask: (existingTask: Task, generatedAt: Date) => Effect.Effect<{
+    readonly nextTask: Task;
+    readonly updatedCurrent: Task | null;
+    readonly shouldReplaceCurrent: boolean;
+}, string>;
+//# sourceMappingURL=recurrence.d.ts.map

package/dist/src/recurrence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recurrence.d.ts","sourceRoot":"","sources":["../../src/recurrence.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAIxC,OAAO,EAAsB,KAAK,IAAI,EAAE,MAAM,aAAa,CAAC;AAQ5D,MAAM,WAAW,4BAA4B;IAC5C,QAAQ,CAAC,SAAS,EAAE,OAAO,GAAG,QAAQ,GAAG,SAAS,GAAG,QAAQ,CAAC;IAC9D,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC1B;AAYD,eAAO,MAAM,iCAAiC,GAC7C,YAAY,MAAM,KAChB,MAAM,CAAC,MAAM,CAAC,4BAA4B,EAAE,MAAM,CA8BlD,CAAC;AAEJ,eAAO,MAAM,qBAAqB,GACjC,MAAM,IAAI,EACV,oBAAoB,4BAA4B,KAC9C,IAmBF,CAAC;AAEF,eAAO,MAAM,gCAAgC,GAC5C,MAAM,MAAM,EACZ,oBAAoB,4BAA4B,KAC9C,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAc5B,CAAC;AAEJ,eAAO,MAAM,0CAA0C,GACtD,UAAU,MAAM,EAChB,oBAAoB,4BAA4B,KAC9C,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAc5B,CAAC;AAEJ,eAAO,MAAM,aAAa,GACzB,OAAO,IAAI,EACX,OAAO,MAAM,KACX,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAW5B,CAAC;AAEJ,eAAO,MAAM,sBAAsB,GAClC,OAAO,MAAM,EACb,OAAO,MAAM,KACX,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,CAW1B,CAAC;AAEJ,eAAO,MAAM,gBAAgB,GAC5B,OAAO,MAAM,EACb,OAAO,MAAM,KACX,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,CAW1B,CAAC;AAEJ,eAAO,MAAM,6BAA6B,GACzC,eAAe,IAAI,EACnB,aAAa,MAAM,KACjB,MAAM,CAAC,MAAM,CAAC,IAAI,GAAG,IAAI,EAAE,MAAM,CAwCnC,CAAC;AAEF,eAAO,MAAM,oBAAoB,GAChC,MAAM,IAAI,EACV,KAAK,IAAI,KACP,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,MAAM,CA8B7B,CAAC;AAEJ,eAAO,MAAM,4BAA4B,GACxC,cAAc,IAAI,EAClB,aAAa,IAAI,KACf,MAAM,CAAC,MAAM,CACf;IACC,QAAQ,CAAC,QAAQ,EAAE,IAAI,CAAC;IACxB,QAAQ,CAAC,cAAc,EAAE,IAAI,GAAG,IAAI,CAAC;IACrC,QAAQ,CAAC,oBAAoB,EAAE,OAAO,CAAC;CACvC,EACD,MAAM,CAuDJ,CAAC"}

package/dist/src/recurrence.js

@@ -0,0 +1,194 @@
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import pkg from "rrule";
+const { Frequency, RRule, rrulestr } = pkg;
+import { Task as TaskSchema } from "./schema.js";
+import { generateTaskId } from "./id.js";
+const decodeTask = Schema.decodeUnknownSync(TaskSchema);
+const toErrorMessage = (error) => error instanceof Error ? error.message : String(error);
+const completionRecurrenceFrequencies = new Map([
+    [Frequency.DAILY, "DAILY"],
+    [Frequency.WEEKLY, "WEEKLY"],
+    [Frequency.MONTHLY, "MONTHLY"],
+    [Frequency.YEARLY, "YEARLY"],
+]);
+export const parseCompletionRecurrenceInterval = (recurrence) => Effect.try({
+    try: () => {
+        const parsedRule = rrulestr(recurrence, { forceset: false });
+        if (!(parsedRule instanceof RRule)) {
+            throw new Error("Unsupported completion recurrence: expected a single RRULE");
+        }
+        const frequency = completionRecurrenceFrequencies.get(parsedRule.options.freq);
+        if (frequency === undefined) {
+            const frequencyLabel = Frequency[parsedRule.options.freq] ?? String(parsedRule.options.freq);
+            throw new Error(`Unsupported completion recurrence frequency: ${frequencyLabel}`);
+        }
+        const interval = parsedRule.options.interval;
+        if (!Number.isFinite(interval) || interval < 1) {
+            throw new Error(`Invalid recurrence interval: ${String(interval)}`);
+        }
+        return { frequency, interval };
+    },
+    catch: (error) => `TaskRepository failed to parse recurrence interval: ${toErrorMessage(error)}`,
+});
+export const addRecurrenceInterval = (date, recurrenceInterval) => {
+    const next = new Date(date.getTime());
+    switch (recurrenceInterval.frequency) {
+        case "DAILY":
+            next.setUTCDate(next.getUTCDate() + recurrenceInterval.interval);
+            break;
+        case "WEEKLY":
+            next.setUTCDate(next.getUTCDate() + recurrenceInterval.interval * 7);
+            break;
+        case "MONTHLY":
+            next.setUTCMonth(next.getUTCMonth() + recurrenceInterval.interval);
+            break;
+        case "YEARLY":
+            next.setUTCFullYear(next.getUTCFullYear() + recurrenceInterval.interval);
+            break;
+    }
+    return next;
+};
+export const shiftIsoDateByRecurrenceInterval = (date, recurrenceInterval) => Effect.try({
+    try: () => {
+        const parsed = new Date(`${date}T00:00:00.000Z`);
+        if (Number.isNaN(parsed.getTime())) {
+            throw new Error(`Invalid ISO date: ${date}`);
+        }
+        return addRecurrenceInterval(parsed, recurrenceInterval)
+            .toISOString()
+            .slice(0, 10);
+    },
+    catch: (error) => `TaskRepository failed to shift ISO date: ${toErrorMessage(error)}`,
+});
+export const shiftIsoDateTimeToDateByRecurrenceInterval = (dateTime, recurrenceInterval) => Effect.try({
+    try: () => {
+        const parsed = new Date(dateTime);
+        if (Number.isNaN(parsed.getTime())) {
+            throw new Error(`Invalid ISO datetime: ${dateTime}`);
+        }
+        return addRecurrenceInterval(parsed, recurrenceInterval)
+            .toISOString()
+            .slice(0, 10);
+    },
+    catch: (error) => `TaskRepository failed to shift ISO datetime: ${toErrorMessage(error)}`,
+});
+export const toIsoDateTime = (value, label) => Effect.try({
+    try: () => {
+        const timestamp = value.getTime();
+        if (Number.isNaN(timestamp)) {
+            throw new Error(`Invalid ${label} datetime`);
+        }
+        return value.toISOString();
+    },
+    catch: (error) => `TaskRepository failed to normalize ${label} datetime: ${toErrorMessage(error)}`,
+});
+export const parseIsoDateToUtcStart = (value, label) => Effect.try({
+    try: () => {
+        const parsed = new Date(`${value}T00:00:00.000Z`);
+        if (Number.isNaN(parsed.getTime())) {
+            throw new Error(`Invalid ISO date: ${value}`);
+        }
+        return parsed;
+    },
+    catch: (error) => `TaskRepository failed to parse ${label} date: ${toErrorMessage(error)}`,
+});
+export const parseIsoDateTime = (value, label) => Effect.try({
+    try: () => {
+        const parsed = new Date(value);
+        if (Number.isNaN(parsed.getTime())) {
+            throw new Error(`Invalid ISO datetime: ${value}`);
+        }
+        return parsed;
+    },
+    catch: (error) => `TaskRepository failed to parse ${label} datetime: ${toErrorMessage(error)}`,
+});
+export const buildCompletionRecurrenceTask = (completedTask, completedAt) => {
+    const recurrence = completedTask.recurrence;
+    if (recurrence === null ||
+        completedTask.recurrence_trigger !== "completion") {
+        return Effect.succeed(null);
+    }
+    return Effect.gen(function* () {
+        const recurrenceInterval = yield* parseCompletionRecurrenceInterval(recurrence);
+        const deferUntil = yield* shiftIsoDateTimeToDateByRecurrenceInterval(completedAt, recurrenceInterval);
+        const shiftedDue = completedTask.due === null
+            ? null
+            : yield* shiftIsoDateByRecurrenceInterval(completedTask.due, recurrenceInterval);
+        const completedDate = completedAt.slice(0, 10);
+        return decodeTask({
+            ...completedTask,
+            id: generateTaskId(completedTask.title),
+            status: "active",
+            created: completedDate,
+            updated: completedDate,
+            due: shiftedDue,
+            actual_minutes: null,
+            completed_at: null,
+            last_surfaced: null,
+            defer_until: deferUntil,
+            nudge_count: 0,
+            recurrence_last_generated: completedAt,
+        });
+    });
+};
+export const isClockRecurrenceDue = (task, now) => Effect.gen(function* () {
+    const recurrence = task.recurrence;
+    if (recurrence === null || task.recurrence_trigger !== "clock") {
+        return false;
+    }
+    const nowIso = yield* toIsoDateTime(now, "recurrence check");
+    const nowDate = new Date(nowIso);
+    const createdAt = yield* parseIsoDateToUtcStart(task.created, "task created");
+    const lastGeneratedAt = task.recurrence_last_generated === null
+        ? createdAt
+        : yield* parseIsoDateTime(task.recurrence_last_generated, "recurrence_last_generated");
+    const rule = yield* Effect.try({
+        try: () => rrulestr(recurrence, { dtstart: createdAt, forceset: false }),
+        catch: (error) => `TaskRepository failed to parse recurrence for ${task.id}: ${toErrorMessage(error)}`,
+    });
+    const nextOccurrence = rule.after(lastGeneratedAt, false);
+    return (nextOccurrence !== null && nextOccurrence.getTime() <= nowDate.getTime());
+});
+export const buildNextClockRecurrenceTask = (existingTask, generatedAt) => Effect.gen(function* () {
+    const recurrence = existingTask.recurrence;
+    if (recurrence === null) {
+        return yield* Effect.fail(`TaskRepository failed to generate next recurrence for ${existingTask.id}: task is not recurring`);
+    }
+    const generatedAtIso = yield* toIsoDateTime(generatedAt, "recurrence generation");
+    const generatedDate = generatedAtIso.slice(0, 10);
+    const nextTask = decodeTask({
+        ...existingTask,
+        id: generateTaskId(existingTask.title),
+        status: "active",
+        created: generatedDate,
+        updated: generatedDate,
+        actual_minutes: null,
+        completed_at: null,
+        last_surfaced: null,
+        defer_until: null,
+        nudge_count: 0,
+        recurrence_last_generated: generatedAtIso,
+    });
+    let updatedCurrent = null;
+    let shouldReplaceCurrent = false;
+    if (existingTask.recurrence_strategy === "replace" &&
+        existingTask.status !== "done" &&
+        existingTask.status !== "dropped") {
+        updatedCurrent = decodeTask({
+            ...existingTask,
+            status: "dropped",
+            updated: generatedDate,
+            recurrence_last_generated: generatedAtIso,
+        });
+        shouldReplaceCurrent = true;
+    }
+    if (existingTask.recurrence_strategy === "accumulate") {
+        updatedCurrent = decodeTask({
+            ...existingTask,
+            updated: generatedDate,
+            recurrence_last_generated: generatedAtIso,
+        });
+    }
+    return { nextTask, updatedCurrent, shouldReplaceCurrent };
+});