@tashks/core 0.1.0 → 0.1.2

package/dist/src/hooks.d.ts

@@ -0,0 +1,18 @@
+import * as Effect from "effect/Effect";
+import { type Task } from "./schema.js";
+export type HookEvent = "create" | "modify" | "complete" | "delete";
+export interface HookDiscoveryOptions {
+    readonly hooksDir?: string;
+    readonly env?: NodeJS.ProcessEnv;
+}
+export interface HookRuntimeOptions extends HookDiscoveryOptions {
+    readonly dataDir: string;
+}
+export declare const defaultHooksDir: (env?: NodeJS.ProcessEnv) => string;
+export declare const discoverHooksForEvent: (event: HookEvent, options?: HookDiscoveryOptions) => Effect.Effect<Array<string>, string>;
+export declare const buildHookEnv: (event: HookEvent, taskId: string, options: HookRuntimeOptions) => NodeJS.ProcessEnv;
+export declare const runHookExecutable: (hookPath: string, stdin: string, env: NodeJS.ProcessEnv) => Effect.Effect<string, string>;
+export declare const runCreateHooks: (task: Task, options: HookRuntimeOptions) => Effect.Effect<Task, string>;
+export declare const runModifyHooks: (oldTask: Task, newTask: Task, options: HookRuntimeOptions) => Effect.Effect<Task, string>;
+export declare const runNonMutatingHooks: (event: "complete" | "delete", task: Task, options: HookRuntimeOptions) => Effect.Effect<void, never>;
+//# sourceMappingURL=hooks.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"hooks.d.ts","sourceRoot":"","sources":["../../src/hooks.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAExC,OAAO,EAAsB,KAAK,IAAI,EAAE,MAAM,aAAa,CAAC;AAO5D,MAAM,MAAM,SAAS,GAAG,QAAQ,GAAG,QAAQ,GAAG,UAAU,GAAG,QAAQ,CAAC;AAEpE,MAAM,WAAW,oBAAoB;IACpC,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;CACjC;AAED,MAAM,WAAW,kBAAmB,SAAQ,oBAAoB;IAC/D,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CACzB;AAID,eAAO,MAAM,eAAe,GAC3B,MAAK,MAAM,CAAC,UAAwB,KAClC,MAUF,CAAC;AAgCF,eAAO,MAAM,qBAAqB,GACjC,OAAO,SAAS,EAChB,UAAS,oBAAyB,KAChC,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE,MAAM,CAyCrC,CAAC;AAaF,eAAO,MAAM,YAAY,GACxB,OAAO,SAAS,EAChB,QAAQ,MAAM,EACd,SAAS,kBAAkB,KACzB,MAAM,CAAC,UAMR,CAAC;AAEH,eAAO,MAAM,iBAAiB,GAC7B,UAAU,MAAM,EAChB,OAAO,MAAM,EACb,KAAK,MAAM,CAAC,UAAU,KACpB,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAqC5B,CAAC;AAEJ,eAAO,MAAM,cAAc,GAC1B,MAAM,IAAI,EACV,SAAS,kBAAkB,KACzB,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,CAoB1B,CAAC;AAEJ,eAAO,MAAM,cAAc,GAC1B,SAAS,IAAI,EACb,SAAS,IAAI,EACb,SAAS,kBAAkB,KACzB,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,CA8B1B,CAAC;AAEJ,eAAO,MAAM,mBAAmB,GAC/B,OAAO,UAAU,GAAG,QAAQ,EAC5B,MAAM,IAAI,EACV,SAAS,kBAAkB,KACzB,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,KAAK,CAazB,CAAC"}

package/dist/src/hooks.js

@@ -0,0 +1,140 @@
+import { constants as fsConstants } from "node:fs";
+import { spawnSync } from "node:child_process";
+import { access, readdir } from "node:fs/promises";
+import { join } from "node:path";
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import { Task as TaskSchema } from "./schema.js";
+const decodeTask = Schema.decodeUnknownSync(TaskSchema);
+const toErrorMessage = (error) => error instanceof Error ? error.message : String(error);
+export 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)}`,
+});
+export const buildHookEnv = (event, taskId, options) => ({
+    ...process.env,
+    ...options.env,
+    TASHKS_EVENT: event,
+    TASHKS_ID: taskId,
+    TASHKS_DATA_DIR: options.dataDir,
+});
+export 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 : "";
+});
+export 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;
+});
+export 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;
+});
+export 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);
+    }
+});

package/dist/src/id.d.ts

@@ -0,0 +1,2 @@
+export declare const generateTaskId: (title: string) => string;
+//# sourceMappingURL=id.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"id.d.ts","sourceRoot":"","sources":["../../src/id.ts"],"names":[],"mappings":"AAwBA,eAAO,MAAM,cAAc,GAAI,OAAO,MAAM,KAAG,MACF,CAAC"}

package/dist/src/id.js

@@ -0,0 +1,17 @@
+import { randomBytes } from "node:crypto";
+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("");
+};
+export const generateTaskId = (title) => `${slugifyTitle(title)}-${randomIdSuffix()}`;

package/dist/src/proseql-repository.d.ts

@@ -0,0 +1,12 @@
+import * as Layer from "effect/Layer";
+import { TaskRepository } from "./repository.js";
+export interface ProseqlRepositoryOptions {
+    readonly tasksFile: string;
+    readonly workLogFile: string;
+    readonly tasksFormat?: string;
+    readonly workLogFormat?: string;
+    readonly hooksDir?: string;
+    readonly hookEnv?: NodeJS.ProcessEnv;
+}
+export declare const ProseqlRepositoryLive: (options: ProseqlRepositoryOptions) => Layer.Layer<TaskRepository, string>;
+//# sourceMappingURL=proseql-repository.d.ts.map

package/dist/src/proseql-repository.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"proseql-repository.d.ts","sourceRoot":"","sources":["../../src/proseql-repository.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AA4BtC,OAAO,EACN,cAAc,EAMd,MAAM,iBAAiB,CAAC;AA2CzB,MAAM,WAAW,wBAAwB;IACxC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;CACrC;AAyWD,eAAO,MAAM,qBAAqB,GACjC,SAAS,wBAAwB,KAC/B,KAAK,CAAC,KAAK,CAAC,cAAc,EAAE,MAAM,CACwB,CAAC"}

package/dist/src/proseql-repository.js

@@ -0,0 +1,255 @@
+import { dirname, join } from "node:path";
+import { mkdir, writeFile } from "node:fs/promises";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Schema from "effect/Schema";
+import { createNodeDatabase } from "@proseql/node";
+import YAML from "yaml";
+import { Task as TaskSchema, WorkLogCreateInput as WorkLogCreateInputSchema, WorkLogEntry as WorkLogEntrySchema, } from "./schema.js";
+import { byUpdatedDescThenTitle, isStalerThan, } from "./query.js";
+import { runCreateHooks, runModifyHooks, runNonMutatingHooks, } from "./hooks.js";
+import { buildCompletionRecurrenceTask, buildNextClockRecurrenceTask, isClockRecurrenceDue, } from "./recurrence.js";
+import { TaskRepository, applyListTaskFilters, todayIso, applyTaskPatch, applyWorkLogPatch, createTaskFromInput, } from "./repository.js";
+const decodeTask = Schema.decodeUnknownSync(TaskSchema);
+const decodeWorkLogCreateInput = Schema.decodeUnknownSync(WorkLogCreateInputSchema);
+const decodeWorkLogEntry = Schema.decodeUnknownSync(WorkLogEntrySchema);
+const toErrorMessage = (error) => {
+    if (error !== null && typeof error === "object" && "_tag" in error) {
+        const tagged = error;
+        return tagged.message ?? tagged._tag;
+    }
+    return error instanceof Error ? error.message : String(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 makeDbConfig = (options) => ({
+    tasks: {
+        schema: TaskSchema,
+        file: options.tasksFile,
+        ...(options.tasksFormat !== undefined
+            ? { format: options.tasksFormat }
+            : {}),
+        relationships: {},
+    },
+    workLog: {
+        schema: WorkLogEntrySchema,
+        file: options.workLogFile,
+        ...(options.workLogFormat !== undefined
+            ? { format: options.workLogFormat }
+            : {}),
+        relationships: {},
+    },
+});
+const makeProseqlRepository = (options) => Effect.gen(function* () {
+    const config = makeDbConfig(options);
+    const db = yield* createNodeDatabase(config).pipe(Effect.mapError((error) => `ProseqlRepository failed to initialize database: ${toErrorMessage(error)}`));
+    const dataDir = dirname(options.tasksFile);
+    const hookRuntimeOptions = {
+        hooksDir: options.hooksDir,
+        env: options.hookEnv,
+        dataDir,
+    };
+    const collectTasks = () => Effect.tryPromise({
+        try: () => db.tasks.query().runPromise.then((results) => results),
+        catch: (error) => `ProseqlRepository.listTasks failed: ${toErrorMessage(error)}`,
+    });
+    const collectWorkLog = () => Effect.tryPromise({
+        try: () => db.workLog.query().runPromise.then((results) => results),
+        catch: (error) => `ProseqlRepository.listWorkLog failed: ${toErrorMessage(error)}`,
+    });
+    const findTask = (id) => Effect.tryPromise({
+        try: () => db.tasks.findById(id).runPromise,
+        catch: (error) => `ProseqlRepository failed to read task ${id}: ${toErrorMessage(error)}`,
+    });
+    const findWorkLogEntry = (id) => Effect.tryPromise({
+        try: () => db.workLog.findById(id).runPromise,
+        catch: (error) => `ProseqlRepository failed to read work log entry ${id}: ${toErrorMessage(error)}`,
+    });
+    const saveTask = (task) => Effect.tryPromise({
+        try: () => db.tasks
+            .upsert({
+            where: { id: task.id },
+            create: task,
+            update: task,
+        })
+            .runPromise.then((r) => r),
+        catch: (error) => `ProseqlRepository failed to write task ${task.id}: ${toErrorMessage(error)}`,
+    });
+    const removeTask = (id) => Effect.tryPromise({
+        try: () => db.tasks.delete(id).runPromise,
+        catch: (error) => `ProseqlRepository failed to delete task ${id}: ${toErrorMessage(error)}`,
+    });
+    const saveWorkLogEntry = (entry) => Effect.tryPromise({
+        try: () => db.workLog
+            .upsert({
+            where: { id: entry.id },
+            create: entry,
+            update: entry,
+        })
+            .runPromise.then((r) => r),
+        catch: (error) => `ProseqlRepository failed to write work log entry ${entry.id}: ${toErrorMessage(error)}`,
+    });
+    const removeWorkLogEntry = (id) => Effect.tryPromise({
+        try: () => db.workLog.delete(id).runPromise,
+        catch: (error) => `ProseqlRepository failed to delete work log entry ${id}: ${toErrorMessage(error)}`,
+    });
+    const writeDailyHighlight = (id) => Effect.tryPromise({
+        try: async () => {
+            const highlightPath = join(dataDir, "daily-highlight.yaml");
+            await mkdir(dataDir, { recursive: true });
+            await writeFile(highlightPath, YAML.stringify({ id }), "utf8");
+        },
+        catch: (error) => `ProseqlRepository failed to write daily highlight ${id}: ${toErrorMessage(error)}`,
+    });
+    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 service = {
+        listTasks: (filters) => Effect.map(collectTasks(), (tasks) => applyListTaskFilters(tasks, filters)),
+        getTask: (id) => findTask(id),
+        createTask: (input) => Effect.gen(function* () {
+            const created = createTaskFromInput(input);
+            const taskFromHooks = yield* runCreateHooks(created, hookRuntimeOptions);
+            yield* saveTask(taskFromHooks);
+            return taskFromHooks;
+        }),
+        updateTask: (id, patch) => Effect.gen(function* () {
+            const existing = yield* findTask(id);
+            const updated = applyTaskPatch(existing, patch);
+            const taskFromHooks = yield* runModifyHooks(existing, updated, hookRuntimeOptions);
+            yield* saveTask(taskFromHooks);
+            return taskFromHooks;
+        }),
+        completeTask: (id) => Effect.gen(function* () {
+            const existing = yield* findTask(id);
+            const completedAt = new Date().toISOString();
+            const completedDate = completedAt.slice(0, 10);
+            const completedTask = decodeTask({
+                ...existing,
+                status: "done",
+                updated: completedDate,
+                completed_at: completedAt,
+            });
+            const nextRecurringTask = yield* buildCompletionRecurrenceTask(completedTask, completedAt);
+            yield* saveTask(completedTask);
+            yield* runNonMutatingHooks("complete", completedTask, hookRuntimeOptions);
+            if (nextRecurringTask !== null) {
+                yield* saveTask(nextRecurringTask);
+            }
+            return completedTask;
+        }),
+        generateNextRecurrence: (id) => Effect.gen(function* () {
+            const existing = yield* findTask(id);
+            const result = yield* buildNextClockRecurrenceTask(existing, new Date());
+            if (result.updatedCurrent !== null) {
+                yield* saveTask(result.updatedCurrent);
+            }
+            yield* saveTask(result.nextTask);
+            return result.nextTask;
+        }),
+        processDueRecurrences: (now) => Effect.gen(function* () {
+            const tasks = yield* collectTasks();
+            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 result = yield* buildNextClockRecurrenceTask(task, now);
+                if (result.updatedCurrent !== null) {
+                    yield* saveTask(result.updatedCurrent);
+                }
+                yield* saveTask(result.nextTask);
+                created.push(result.nextTask);
+                if (result.shouldReplaceCurrent) {
+                    replaced.push(task.id);
+                }
+            }
+            return { created, replaced };
+        }),
+        deleteTask: (id) => Effect.gen(function* () {
+            const existing = yield* findTask(id);
+            yield* removeTask(id);
+            yield* runNonMutatingHooks("delete", existing, hookRuntimeOptions);
+            return { deleted: true };
+        }),
+        setDailyHighlight: (id) => Effect.gen(function* () {
+            const existing = yield* findTask(id);
+            yield* writeDailyHighlight(id);
+            return existing;
+        }),
+        listStale: (days) => Effect.map(collectTasks(), (tasks) => {
+            const stalePredicate = isStalerThan(days, todayIso());
+            return tasks
+                .filter((task) => task.status === "active" && stalePredicate(task))
+                .sort(byUpdatedDescThenTitle);
+        }),
+        listWorkLog: (filters) => Effect.map(collectWorkLog(), (entries) => entries
+            .filter((entry) => filters?.date !== undefined
+            ? entry.date === filters.date
+            : true)
+            .sort(byStartedAtDescThenId)),
+        createWorkLogEntry: (input) => Effect.gen(function* () {
+            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* saveWorkLogEntry(created);
+            return created;
+        }),
+        updateWorkLogEntry: (id, patch) => Effect.gen(function* () {
+            const existing = yield* findWorkLogEntry(id);
+            const updated = applyWorkLogPatch(existing, patch);
+            yield* saveWorkLogEntry(updated);
+            return updated;
+        }),
+        deleteWorkLogEntry: (id) => Effect.gen(function* () {
+            yield* removeWorkLogEntry(id);
+            return { deleted: true };
+        }),
+        importTask: (task) => Effect.gen(function* () {
+            yield* saveTask(task);
+            return task;
+        }),
+        importWorkLogEntry: (entry) => Effect.gen(function* () {
+            yield* saveWorkLogEntry(entry);
+            return entry;
+        }),
+    };
+    return service;
+});
+export const ProseqlRepositoryLive = (options) => Layer.scoped(TaskRepository, makeProseqlRepository(options));