@tashks/core 0.1.0

package/dist/src/repository.js

@@ -0,0 +1,742 @@
+import { randomBytes } from "node:crypto";
+import { spawnSync } from "node:child_process";
+import { constants as fsConstants } from "node:fs";
+import { access, mkdir, readdir, readFile, rm, writeFile, } from "node:fs/promises";
+import { join } from "node:path";
+import * as Context from "effect/Context";
+import * as Either from "effect/Either";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Schema from "effect/Schema";
+import { Frequency, RRule, rrulestr } from "rrule";
+import YAML from "yaml";
+import { Task as TaskSchema, TaskCreateInput as TaskCreateInputSchema, TaskPatch as TaskPatchSchema, WorkLogCreateInput as WorkLogCreateInputSchema, WorkLogEntry as WorkLogEntrySchema, WorkLogPatch as WorkLogPatchSchema, } from "./schema.js";
+import { byUpdatedDescThenTitle, isDueBefore, isStalerThan, isUnblocked, } from "./query.js";
+const idSuffixAlphabet = "abcdefghijklmnopqrstuvwxyz0123456789";
+const idSuffixLength = 6;
+const slugifyTitle = (title) => {
+    const slug = title
+        .toLowerCase()
+        .normalize("NFKD")
+        .replace(/[\u0300-\u036f]/g, "")
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+    return slug.length > 0 ? slug : "task";
+};
+const randomIdSuffix = () => {
+    const random = randomBytes(idSuffixLength);
+    return Array.from(random, (value) => idSuffixAlphabet[value % idSuffixAlphabet.length]).join("");
+};
+const decodeTask = Schema.decodeUnknownSync(TaskSchema);
+const decodeTaskEither = Schema.decodeUnknownEither(TaskSchema);
+const decodeTaskCreateInput = Schema.decodeUnknownSync(TaskCreateInputSchema);
+const decodeTaskPatch = Schema.decodeUnknownSync(TaskPatchSchema);
+const decodeWorkLogCreateInput = Schema.decodeUnknownSync(WorkLogCreateInputSchema);
+const decodeWorkLogEntry = Schema.decodeUnknownSync(WorkLogEntrySchema);
+const decodeWorkLogEntryEither = Schema.decodeUnknownEither(WorkLogEntrySchema);
+const decodeWorkLogPatch = Schema.decodeUnknownSync(WorkLogPatchSchema);
+const toErrorMessage = (error) => error instanceof Error ? error.message : String(error);
+const taskFilePath = (dataDir, id) => join(dataDir, "tasks", `${id}.yaml`);
+const legacyTaskFilePath = (dataDir, id) => join(dataDir, "tasks", `${id}.yml`);
+const workLogFilePath = (dataDir, id) => join(dataDir, "work-log", `${id}.yaml`);
+const legacyWorkLogFilePath = (dataDir, id) => join(dataDir, "work-log", `${id}.yml`);
+const dailyHighlightFilePath = (dataDir) => join(dataDir, "daily-highlight.yaml");
+const ensureTasksDir = (dataDir) => Effect.tryPromise({
+    try: () => mkdir(join(dataDir, "tasks"), { recursive: true }),
+    catch: (error) => `TaskRepository failed to create tasks directory: ${toErrorMessage(error)}`,
+});
+const ensureWorkLogDir = (dataDir) => Effect.tryPromise({
+    try: () => mkdir(join(dataDir, "work-log"), { recursive: true }),
+    catch: (error) => `TaskRepository failed to create work-log directory: ${toErrorMessage(error)}`,
+});
+const writeDailyHighlightToDisk = (dataDir, id) => Effect.tryPromise({
+    try: async () => {
+        await mkdir(dataDir, { recursive: true });
+        await writeFile(dailyHighlightFilePath(dataDir), YAML.stringify({ id }), "utf8");
+    },
+    catch: (error) => `TaskRepository failed to write daily highlight ${id}: ${toErrorMessage(error)}`,
+});
+const readTaskByIdFromDisk = (dataDir, id) => Effect.tryPromise({
+    try: async () => {
+        const candidatePaths = [
+            taskFilePath(dataDir, id),
+            legacyTaskFilePath(dataDir, id),
+        ];
+        for (const path of candidatePaths) {
+            const source = await readFile(path, "utf8").catch((error) => {
+                if (error !== null &&
+                    typeof error === "object" &&
+                    "code" in error &&
+                    error.code === "ENOENT") {
+                    return null;
+                }
+                throw error;
+            });
+            if (source === null) {
+                continue;
+            }
+            const parsed = YAML.parse(source);
+            const task = parseTaskRecord(parsed);
+            if (task === null) {
+                throw new Error(`Invalid task record in ${path}`);
+            }
+            return { path, task };
+        }
+        throw new Error(`Task not found: ${id}`);
+    },
+    catch: (error) => `TaskRepository failed to read task ${id}: ${toErrorMessage(error)}`,
+});
+const writeTaskToDisk = (path, task) => Effect.tryPromise({
+    try: () => writeFile(path, YAML.stringify(task), "utf8"),
+    catch: (error) => `TaskRepository failed to write task ${task.id}: ${toErrorMessage(error)}`,
+});
+const deleteTaskFromDisk = (path, id) => Effect.tryPromise({
+    try: () => rm(path),
+    catch: (error) => `TaskRepository failed to delete task ${id}: ${toErrorMessage(error)}`,
+});
+const readTasksFromDisk = (dataDir) => Effect.tryPromise({
+    try: async () => {
+        const tasksDir = join(dataDir, "tasks");
+        const entries = await readdir(tasksDir, { withFileTypes: true }).catch((error) => {
+            if (error !== null &&
+                typeof error === "object" &&
+                "code" in error &&
+                error.code === "ENOENT") {
+                return [];
+            }
+            throw error;
+        });
+        const taskFiles = entries
+            .filter((entry) => entry.isFile() &&
+            (entry.name.endsWith(".yaml") || entry.name.endsWith(".yml")))
+            .map((entry) => entry.name);
+        const tasks = [];
+        for (const fileName of taskFiles) {
+            const filePath = join(tasksDir, fileName);
+            const source = await readFile(filePath, "utf8");
+            const parsed = YAML.parse(source);
+            const task = parseTaskRecord(parsed);
+            if (task === null) {
+                throw new Error(`Invalid task record in ${filePath}`);
+            }
+            tasks.push(task);
+        }
+        return tasks;
+    },
+    catch: (error) => `TaskRepository.listTasks failed to read task files: ${toErrorMessage(error)}`,
+});
+const readWorkLogEntryByIdFromDisk = (dataDir, id) => Effect.tryPromise({
+    try: async () => {
+        const candidatePaths = [
+            workLogFilePath(dataDir, id),
+            legacyWorkLogFilePath(dataDir, id),
+        ];
+        for (const path of candidatePaths) {
+            const source = await readFile(path, "utf8").catch((error) => {
+                if (error !== null &&
+                    typeof error === "object" &&
+                    "code" in error &&
+                    error.code === "ENOENT") {
+                    return null;
+                }
+                throw error;
+            });
+            if (source === null) {
+                continue;
+            }
+            const parsed = YAML.parse(source);
+            const entry = parseWorkLogRecord(parsed);
+            if (entry === null) {
+                throw new Error(`Invalid work log record in ${path}`);
+            }
+            return { path, entry };
+        }
+        throw new Error(`Work log entry not found: ${id}`);
+    },
+    catch: (error) => `TaskRepository failed to read work log entry ${id}: ${toErrorMessage(error)}`,
+});
+const readWorkLogEntriesFromDisk = (dataDir) => Effect.tryPromise({
+    try: async () => {
+        const workLogDir = join(dataDir, "work-log");
+        const entries = await readdir(workLogDir, { withFileTypes: true }).catch((error) => {
+            if (error !== null &&
+                typeof error === "object" &&
+                "code" in error &&
+                error.code === "ENOENT") {
+                return [];
+            }
+            throw error;
+        });
+        const workLogFiles = entries
+            .filter((entry) => entry.isFile() &&
+            (entry.name.endsWith(".yaml") || entry.name.endsWith(".yml")))
+            .map((entry) => entry.name);
+        const workLogEntries = [];
+        for (const fileName of workLogFiles) {
+            const filePath = join(workLogDir, fileName);
+            const source = await readFile(filePath, "utf8");
+            const parsed = YAML.parse(source);
+            const workLogEntry = parseWorkLogRecord(parsed);
+            if (workLogEntry === null) {
+                throw new Error(`Invalid work log record in ${filePath}`);
+            }
+            workLogEntries.push(workLogEntry);
+        }
+        return workLogEntries;
+    },
+    catch: (error) => `TaskRepository.listWorkLog failed to read work log files: ${toErrorMessage(error)}`,
+});
+const writeWorkLogEntryToDisk = (path, entry) => Effect.tryPromise({
+    try: () => writeFile(path, YAML.stringify(entry), "utf8"),
+    catch: (error) => `TaskRepository failed to write work log entry ${entry.id}: ${toErrorMessage(error)}`,
+});
+const deleteWorkLogEntryFromDisk = (path, id) => Effect.tryPromise({
+    try: () => rm(path),
+    catch: (error) => `TaskRepository failed to delete work log entry ${id}: ${toErrorMessage(error)}`,
+});
+const toWorkLogTimestamp = (startedAt) => Effect.try({
+    try: () => {
+        const parsed = new Date(startedAt);
+        if (Number.isNaN(parsed.getTime())) {
+            throw new Error(`Invalid started_at: ${startedAt}`);
+        }
+        const iso = parsed.toISOString();
+        return `${iso.slice(0, 4)}${iso.slice(5, 7)}${iso.slice(8, 10)}T${iso.slice(11, 13)}${iso.slice(14, 16)}`;
+    },
+    catch: (error) => `TaskRepository failed to derive work log timestamp: ${toErrorMessage(error)}`,
+});
+const toWorkLogDate = (startedAt) => Effect.try({
+    try: () => {
+        const parsed = new Date(startedAt);
+        if (Number.isNaN(parsed.getTime())) {
+            throw new Error(`Invalid started_at: ${startedAt}`);
+        }
+        return parsed.toISOString().slice(0, 10);
+    },
+    catch: (error) => `TaskRepository failed to derive work log date: ${toErrorMessage(error)}`,
+});
+const completionRecurrenceFrequencies = new Map([
+    [Frequency.DAILY, "DAILY"],
+    [Frequency.WEEKLY, "WEEKLY"],
+    [Frequency.MONTHLY, "MONTHLY"],
+    [Frequency.YEARLY, "YEARLY"],
+]);
+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)}`,
+});
+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;
+};
+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)}`,
+});
+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)}`,
+});
+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,
+        });
+    });
+};
+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)}`,
+});
+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)}`,
+});
+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)}`,
+});
+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());
+});
+const generateNextClockRecurrence = (dataDir, existing, generatedAt) => Effect.gen(function* () {
+    const recurrence = existing.task.recurrence;
+    if (recurrence === null) {
+        return yield* Effect.fail(`TaskRepository failed to generate next recurrence for ${existing.task.id}: task is not recurring`);
+    }
+    const generatedAtIso = yield* toIsoDateTime(generatedAt, "recurrence generation");
+    const generatedDate = generatedAtIso.slice(0, 10);
+    const nextTask = decodeTask({
+        ...existing.task,
+        id: generateTaskId(existing.task.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 replacedId = null;
+    if (existing.task.recurrence_strategy === "replace" &&
+        existing.task.status !== "done" &&
+        existing.task.status !== "dropped") {
+        const droppedTask = decodeTask({
+            ...existing.task,
+            status: "dropped",
+            updated: generatedDate,
+            recurrence_last_generated: generatedAtIso,
+        });
+        yield* writeTaskToDisk(existing.path, droppedTask);
+        replacedId = existing.task.id;
+    }
+    if (existing.task.recurrence_strategy === "accumulate") {
+        const updatedCurrent = decodeTask({
+            ...existing.task,
+            updated: generatedDate,
+            recurrence_last_generated: generatedAtIso,
+        });
+        yield* writeTaskToDisk(existing.path, updatedCurrent);
+    }
+    yield* ensureTasksDir(dataDir);
+    yield* writeTaskToDisk(taskFilePath(dataDir, nextTask.id), nextTask);
+    return { nextTask, replacedId };
+});
+const byStartedAtDescThenId = (a, b) => {
+    const byStartedAtDesc = b.started_at.localeCompare(a.started_at);
+    if (byStartedAtDesc !== 0) {
+        return byStartedAtDesc;
+    }
+    return a.id.localeCompare(b.id);
+};
+const applyListTaskFilters = (tasks, filters = {}) => {
+    const dueBeforePredicate = filters.due_before !== undefined ? isDueBefore(filters.due_before) : null;
+    return tasks
+        .filter((task) => {
+        if (filters.status !== undefined && task.status !== filters.status) {
+            return false;
+        }
+        if (filters.area !== undefined && task.area !== filters.area) {
+            return false;
+        }
+        if (filters.project !== undefined && task.project !== filters.project) {
+            return false;
+        }
+        if (filters.tags !== undefined &&
+            filters.tags.length > 0 &&
+            !filters.tags.some((tag) => task.tags.includes(tag))) {
+            return false;
+        }
+        if (dueBeforePredicate !== null && !dueBeforePredicate(task)) {
+            return false;
+        }
+        if (filters.due_after !== undefined &&
+            (task.due === null || task.due < filters.due_after)) {
+            return false;
+        }
+        if (filters.date !== undefined &&
+            task.defer_until !== null &&
+            task.defer_until > filters.date) {
+            return false;
+        }
+        if (filters.unblocked_only === true && !isUnblocked(task, tasks)) {
+            return false;
+        }
+        return true;
+    })
+        .sort(byUpdatedDescThenTitle);
+};
+const defaultHooksDir = (env = process.env) => {
+    const xdgConfigHome = env.XDG_CONFIG_HOME;
+    if (xdgConfigHome !== undefined && xdgConfigHome.length > 0) {
+        return join(xdgConfigHome, "tashks", "hooks");
+    }
+    const home = env.HOME;
+    return home !== undefined && home.length > 0
+        ? join(home, ".config", "tashks", "hooks")
+        : join(".config", "tashks", "hooks");
+};
+const hookNamePattern = (event) => new RegExp(`^on-${event}(?:\\..+)?$`);
+const isHookCandidate = (event, fileName) => hookNamePattern(event).test(fileName);
+const isExecutableFile = (path) => Effect.tryPromise({
+    try: async () => {
+        try {
+            await access(path, fsConstants.X_OK);
+            return true;
+        }
+        catch (error) {
+            if (error !== null &&
+                typeof error === "object" &&
+                "code" in error &&
+                (error.code === "EACCES" ||
+                    error.code === "EPERM" ||
+                    error.code === "ENOENT")) {
+                return false;
+            }
+            throw error;
+        }
+    },
+    catch: (error) => `TaskRepository failed to inspect hook executable bit for ${path}: ${toErrorMessage(error)}`,
+});
+export const discoverHooksForEvent = (event, options = {}) => {
+    const hooksDir = options.hooksDir ?? defaultHooksDir(options.env);
+    return Effect.gen(function* () {
+        const entries = yield* Effect.tryPromise({
+            try: () => readdir(hooksDir, { withFileTypes: true }).catch((error) => {
+                if (error !== null &&
+                    typeof error === "object" &&
+                    "code" in error &&
+                    error.code === "ENOENT") {
+                    return [];
+                }
+                throw error;
+            }),
+            catch: (error) => `TaskRepository failed to read hooks directory ${hooksDir}: ${toErrorMessage(error)}`,
+        });
+        const candidatePaths = entries
+            .filter((entry) => (entry.isFile() || entry.isSymbolicLink()) &&
+            isHookCandidate(event, entry.name))
+            .map((entry) => join(hooksDir, entry.name))
+            .sort((a, b) => a.localeCompare(b));
+        const discovered = [];
+        for (const candidatePath of candidatePaths) {
+            const executable = yield* isExecutableFile(candidatePath);
+            if (executable) {
+                discovered.push(candidatePath);
+            }
+        }
+        return discovered;
+    });
+};
+const parseTaskFromHookStdout = (event, hookPath, stdout) => Effect.try({
+    try: () => decodeTask(JSON.parse(stdout)),
+    catch: (error) => `TaskRepository hook ${hookPath} returned invalid JSON for on-${event}: ${toErrorMessage(error)}`,
+});
+const buildHookEnv = (event, taskId, options) => ({
+    ...process.env,
+    ...options.env,
+    TASHKS_EVENT: event,
+    TASHKS_ID: taskId,
+    TASHKS_DATA_DIR: options.dataDir,
+});
+const runHookExecutable = (hookPath, stdin, env) => Effect.gen(function* () {
+    const result = yield* Effect.try({
+        try: () => spawnSync(hookPath, [], {
+            input: stdin,
+            encoding: "utf8",
+            stdio: ["pipe", "pipe", "pipe"],
+            env,
+        }),
+        catch: (error) => `TaskRepository failed to execute hook ${hookPath}: ${toErrorMessage(error)}`,
+    });
+    if (result.error !== undefined) {
+        return yield* Effect.fail(`TaskRepository failed to execute hook ${hookPath}: ${toErrorMessage(result.error)}`);
+    }
+    if (result.status !== 0) {
+        const stderr = typeof result.stderr === "string" ? result.stderr.trim() : "";
+        const signal = result.signal !== null ? `terminated by signal ${result.signal}` : null;
+        const status = result.status === null
+            ? "unknown"
+            : `exited with code ${result.status}`;
+        const details = stderr.length > 0 ? stderr : (signal ?? status);
+        return yield* Effect.fail(`TaskRepository hook ${hookPath} failed: ${details}`);
+    }
+    return typeof result.stdout === "string" ? result.stdout : "";
+});
+const runCreateHooks = (task, options) => Effect.gen(function* () {
+    const hooks = yield* discoverHooksForEvent("create", options);
+    let currentTask = task;
+    for (const hookPath of hooks) {
+        const stdout = yield* runHookExecutable(hookPath, JSON.stringify(currentTask), buildHookEnv("create", currentTask.id, options));
+        if (stdout.trim().length === 0) {
+            continue;
+        }
+        currentTask = yield* parseTaskFromHookStdout("create", hookPath, stdout);
+    }
+    return currentTask;
+});
+const runModifyHooks = (oldTask, newTask, options) => Effect.gen(function* () {
+    const hooks = yield* discoverHooksForEvent("modify", options);
+    let currentTask = newTask;
+    for (const hookPath of hooks) {
+        const stdout = yield* runHookExecutable(hookPath, JSON.stringify({ old: oldTask, new: currentTask }), buildHookEnv("modify", currentTask.id, options));
+        if (stdout.trim().length === 0) {
+            continue;
+        }
+        const hookedTask = yield* parseTaskFromHookStdout("modify", hookPath, stdout);
+        if (hookedTask.id !== oldTask.id) {
+            return yield* Effect.fail(`TaskRepository hook ${hookPath} failed: on-modify hooks cannot change task id`);
+        }
+        currentTask = hookedTask;
+    }
+    return currentTask;
+});
+const runNonMutatingHooks = (event, task, options) => Effect.gen(function* () {
+    const hooks = yield* discoverHooksForEvent(event, options).pipe(Effect.catchAll(() => Effect.succeed([])));
+    for (const hookPath of hooks) {
+        yield* runHookExecutable(hookPath, JSON.stringify(task), buildHookEnv(event, task.id, options)).pipe(Effect.ignore);
+    }
+});
+export class TaskRepository extends Context.Tag("TaskRepository")() {
+}
+const defaultDataDir = () => {
+    const home = process.env.HOME;
+    return home !== undefined && home.length > 0
+        ? `${home}/.local/share/tashks`
+        : ".local/share/tashks";
+};
+const makeTaskRepositoryLive = (options = {}) => {
+    const dataDir = options.dataDir ?? defaultDataDir();
+    const hookRuntimeOptions = {
+        hooksDir: options.hooksDir,
+        env: options.hookEnv,
+        dataDir,
+    };
+    return {
+        listTasks: (filters) => Effect.map(readTasksFromDisk(dataDir), (tasks) => applyListTaskFilters(tasks, filters)),
+        getTask: (id) => Effect.map(readTaskByIdFromDisk(dataDir, id), (result) => result.task),
+        createTask: (input) => Effect.gen(function* () {
+            yield* ensureTasksDir(dataDir);
+            const created = createTaskFromInput(input);
+            const taskFromHooks = yield* runCreateHooks(created, hookRuntimeOptions);
+            yield* writeTaskToDisk(taskFilePath(dataDir, taskFromHooks.id), taskFromHooks);
+            return taskFromHooks;
+        }),
+        updateTask: (id, patch) => Effect.gen(function* () {
+            const existing = yield* readTaskByIdFromDisk(dataDir, id);
+            const updated = applyTaskPatch(existing.task, patch);
+            const taskFromHooks = yield* runModifyHooks(existing.task, updated, hookRuntimeOptions);
+            yield* writeTaskToDisk(existing.path, taskFromHooks);
+            return taskFromHooks;
+        }),
+        completeTask: (id) => Effect.gen(function* () {
+            const existing = yield* readTaskByIdFromDisk(dataDir, id);
+            const completedAt = new Date().toISOString();
+            const completedDate = completedAt.slice(0, 10);
+            const completedTask = decodeTask({
+                ...existing.task,
+                status: "done",
+                updated: completedDate,
+                completed_at: completedAt,
+            });
+            const nextRecurringTask = yield* buildCompletionRecurrenceTask(completedTask, completedAt);
+            yield* writeTaskToDisk(existing.path, completedTask);
+            yield* runNonMutatingHooks("complete", completedTask, hookRuntimeOptions);
+            if (nextRecurringTask !== null) {
+                yield* ensureTasksDir(dataDir);
+                yield* writeTaskToDisk(taskFilePath(dataDir, nextRecurringTask.id), nextRecurringTask);
+            }
+            return completedTask;
+        }),
+        generateNextRecurrence: (id) => Effect.gen(function* () {
+            const existing = yield* readTaskByIdFromDisk(dataDir, id);
+            const generated = yield* generateNextClockRecurrence(dataDir, existing, new Date());
+            return generated.nextTask;
+        }),
+        processDueRecurrences: (now) => Effect.gen(function* () {
+            const tasks = yield* readTasksFromDisk(dataDir);
+            const recurringTasks = tasks.filter((task) => task.recurrence !== null &&
+                task.recurrence_trigger === "clock" &&
+                task.status !== "done" &&
+                task.status !== "dropped");
+            const created = [];
+            const replaced = [];
+            for (const task of recurringTasks) {
+                const due = yield* isClockRecurrenceDue(task, now);
+                if (!due) {
+                    continue;
+                }
+                const existing = yield* readTaskByIdFromDisk(dataDir, task.id);
+                const generated = yield* generateNextClockRecurrence(dataDir, existing, now);
+                created.push(generated.nextTask);
+                if (generated.replacedId !== null) {
+                    replaced.push(generated.replacedId);
+                }
+            }
+            return { created, replaced };
+        }),
+        deleteTask: (id) => Effect.gen(function* () {
+            const existing = yield* readTaskByIdFromDisk(dataDir, id);
+            yield* deleteTaskFromDisk(existing.path, id);
+            yield* runNonMutatingHooks("delete", existing.task, hookRuntimeOptions);
+            return { deleted: true };
+        }),
+        setDailyHighlight: (id) => Effect.gen(function* () {
+            const existing = yield* readTaskByIdFromDisk(dataDir, id);
+            yield* writeDailyHighlightToDisk(dataDir, id);
+            return existing.task;
+        }),
+        listStale: (days) => Effect.map(readTasksFromDisk(dataDir), (tasks) => {
+            const stalePredicate = isStalerThan(days, todayIso());
+            return tasks
+                .filter((task) => task.status === "active" && stalePredicate(task))
+                .sort(byUpdatedDescThenTitle);
+        }),
+        listWorkLog: (filters) => Effect.map(readWorkLogEntriesFromDisk(dataDir), (entries) => entries
+            .filter((entry) => filters?.date !== undefined ? entry.date === filters.date : true)
+            .sort(byStartedAtDescThenId)),
+        createWorkLogEntry: (input) => Effect.gen(function* () {
+            yield* ensureWorkLogDir(dataDir);
+            const normalizedInput = decodeWorkLogCreateInput(input);
+            const timestamp = yield* toWorkLogTimestamp(normalizedInput.started_at);
+            const date = yield* toWorkLogDate(normalizedInput.started_at);
+            const created = decodeWorkLogEntry({
+                id: `${normalizedInput.task_id}-${timestamp}`,
+                task_id: normalizedInput.task_id,
+                started_at: normalizedInput.started_at,
+                ended_at: normalizedInput.ended_at,
+                date,
+            });
+            yield* writeWorkLogEntryToDisk(workLogFilePath(dataDir, created.id), created);
+            return created;
+        }),
+        updateWorkLogEntry: (id, patch) => Effect.gen(function* () {
+            const existing = yield* readWorkLogEntryByIdFromDisk(dataDir, id);
+            const updated = applyWorkLogPatch(existing.entry, patch);
+            yield* writeWorkLogEntryToDisk(existing.path, updated);
+            return updated;
+        }),
+        deleteWorkLogEntry: (id) => Effect.gen(function* () {
+            const existing = yield* readWorkLogEntryByIdFromDisk(dataDir, id);
+            yield* deleteWorkLogEntryFromDisk(existing.path, id);
+            return { deleted: true };
+        }),
+    };
+};
+export const TaskRepositoryLive = (options = {}) => Layer.succeed(TaskRepository, makeTaskRepositoryLive(options));
+export const generateTaskId = (title) => `${slugifyTitle(title)}-${randomIdSuffix()}`;
+export const todayIso = () => new Date().toISOString().slice(0, 10);
+export const parseTaskRecord = (record) => {
+    const result = decodeTaskEither(record);
+    return Either.isRight(result) ? result.right : null;
+};
+export const parseWorkLogRecord = (record) => {
+    const result = decodeWorkLogEntryEither(record);
+    return Either.isRight(result) ? result.right : null;
+};
+export const createTaskFromInput = (input) => {
+    const normalizedInput = decodeTaskCreateInput(input);
+    return decodeTask({
+        ...normalizedInput,
+        id: generateTaskId(normalizedInput.title),
+    });
+};
+export const applyTaskPatch = (task, patch) => {
+    const normalizedTask = decodeTask(task);
+    const normalizedPatch = decodeTaskPatch(patch);
+    return decodeTask({
+        ...normalizedTask,
+        ...normalizedPatch,
+        updated: todayIso(),
+    });
+};
+export const applyWorkLogPatch = (entry, patch) => {
+    const normalizedEntry = decodeWorkLogEntry(entry);
+    const normalizedPatch = decodeWorkLogPatch(patch);
+    return decodeWorkLogEntry({
+        ...normalizedEntry,
+        ...normalizedPatch,
+    });
+};