@todu/pi-extensions 0.1.0

package/dist/services/todu/default-task-service.js

@@ -0,0 +1,109 @@
+import { createRepoContextService } from "../repo-context.js";
+import { createToduDaemonClient } from "./daemon-client.js";
+import { createToduDaemonConnection, } from "./daemon-connection.js";
+import { createToduProjectIntegrationService } from "./todu-project-integration-service.js";
+import { createToduProjectService } from "./todu-project-service.js";
+import { createToduHabitService } from "./todu-habit-service.js";
+import { createToduNoteService } from "./todu-note-service.js";
+import { createToduRecurringService } from "./todu-recurring-service.js";
+import { createToduTaskService } from "./todu-task-service.js";
+export const DEFAULT_TODU_INITIAL_CONNECT_TIMEOUT_MS = 2_000;
+const createToduTaskServiceRuntime = (options = {}) => {
+    const connection = createToduDaemonConnection(options);
+    const client = createToduDaemonClient({ connection });
+    const taskService = createToduTaskService({ client });
+    const projectService = createToduProjectService({ client });
+    const recurringService = createToduRecurringService({ client });
+    const habitService = createToduHabitService({ client });
+    const noteService = createToduNoteService({ client });
+    const projectIntegrationService = createToduProjectIntegrationService({
+        client,
+        projectService,
+        repoContextService: createRepoContextService(),
+    });
+    const initialConnectTimeoutMs = normalizeTimeout(options.initialConnectTimeoutMs, DEFAULT_TODU_INITIAL_CONNECT_TIMEOUT_MS);
+    return {
+        connection,
+        client,
+        taskService,
+        projectService,
+        recurringService,
+        habitService,
+        noteService,
+        projectIntegrationService,
+        ensureConnected: async () => {
+            if (connection.getState().status !== "connected") {
+                await connectWithinTimeout(connection, initialConnectTimeoutMs);
+            }
+            return taskService;
+        },
+        ensureProjectServiceConnected: async () => {
+            if (connection.getState().status !== "connected") {
+                await connectWithinTimeout(connection, initialConnectTimeoutMs);
+            }
+            return projectService;
+        },
+        ensureRecurringServiceConnected: async () => {
+            if (connection.getState().status !== "connected") {
+                await connectWithinTimeout(connection, initialConnectTimeoutMs);
+            }
+            return recurringService;
+        },
+        ensureHabitServiceConnected: async () => {
+            if (connection.getState().status !== "connected") {
+                await connectWithinTimeout(connection, initialConnectTimeoutMs);
+            }
+            return habitService;
+        },
+        ensureNoteServiceConnected: async () => {
+            if (connection.getState().status !== "connected") {
+                await connectWithinTimeout(connection, initialConnectTimeoutMs);
+            }
+            return noteService;
+        },
+        ensureProjectIntegrationServiceConnected: async () => {
+            if (connection.getState().status !== "connected") {
+                await connectWithinTimeout(connection, initialConnectTimeoutMs);
+            }
+            return projectIntegrationService;
+        },
+        disconnect: () => connection.disconnect(),
+    };
+};
+let defaultToduTaskServiceRuntime = null;
+const getDefaultToduTaskServiceRuntime = () => {
+    if (!defaultToduTaskServiceRuntime) {
+        defaultToduTaskServiceRuntime = createToduTaskServiceRuntime();
+    }
+    return defaultToduTaskServiceRuntime;
+};
+const resetDefaultToduTaskServiceRuntime = async () => {
+    if (defaultToduTaskServiceRuntime) {
+        await defaultToduTaskServiceRuntime.disconnect();
+        defaultToduTaskServiceRuntime = null;
+    }
+};
+const connectWithinTimeout = async (connection, timeoutMs) => {
+    let timeoutHandle = null;
+    try {
+        await Promise.race([
+            connection.connect(),
+            new Promise((_, reject) => {
+                timeoutHandle = setTimeout(() => {
+                    reject(new Error(`Timed out connecting to the todu daemon after ${timeoutMs}ms`));
+                }, timeoutMs);
+            }),
+        ]);
+    }
+    catch (error) {
+        await connection.disconnect();
+        throw error;
+    }
+    finally {
+        if (timeoutHandle) {
+            clearTimeout(timeoutHandle);
+        }
+    }
+};
+const normalizeTimeout = (value, fallback) => typeof value === "number" && Number.isFinite(value) && value > 0 ? value : fallback;
+export { connectWithinTimeout, createToduTaskServiceRuntime, getDefaultToduTaskServiceRuntime, resetDefaultToduTaskServiceRuntime, };

package/dist/services/todu/todu-habit-service.d.ts

@@ -0,0 +1,24 @@
+import type { HabitDetail, HabitFilter, HabitSummary, HabitSummaryWithStreak } from "../../domain/habit";
+import type { HabitService } from "../habit-service";
+import { type ToduDaemonClient } from "./daemon-client";
+export declare class ToduHabitServiceError extends Error {
+    readonly operation: string;
+    readonly causeCode: string;
+    readonly details?: Record<string, unknown>;
+    constructor(options: {
+        operation: string;
+        causeCode: string;
+        message: string;
+        details?: Record<string, unknown>;
+        cause?: unknown;
+    });
+}
+export interface ToduHabitServiceDependencies {
+    client: ToduDaemonClient;
+}
+declare const createToduHabitService: ({ client }: ToduHabitServiceDependencies) => HabitService;
+declare const listHabitsWithProjectNames: (client: ToduDaemonClient, filter?: HabitFilter) => Promise<HabitSummary[]>;
+declare const hydrateHabitProjectName: (client: ToduDaemonClient, habit: HabitDetail) => Promise<HabitDetail>;
+declare const runHabitServiceOperation: <TResult>(operation: string, action: () => Promise<TResult>) => Promise<TResult>;
+declare const listHabitsWithStreaks: (client: ToduDaemonClient, filter?: HabitFilter) => Promise<HabitSummaryWithStreak[]>;
+export { createToduHabitService, hydrateHabitProjectName, listHabitsWithProjectNames, listHabitsWithStreaks, runHabitServiceOperation, };

package/dist/services/todu/todu-habit-service.js

@@ -0,0 +1,80 @@
+import { ToduDaemonClientError } from "./daemon-client.js";
+export class ToduHabitServiceError extends Error {
+    operation;
+    causeCode;
+    details;
+    constructor(options) {
+        super(options.message, options.cause ? { cause: options.cause } : undefined);
+        this.name = "ToduHabitServiceError";
+        this.operation = options.operation;
+        this.causeCode = options.causeCode;
+        this.details = options.details;
+    }
+}
+const createToduHabitService = ({ client }) => ({
+    listHabits: (filter) => runHabitServiceOperation("listHabits", () => listHabitsWithProjectNames(client, filter)),
+    getHabit: (habitId) => runHabitServiceOperation("getHabit", async () => {
+        const habit = await client.getHabit(habitId);
+        if (!habit) {
+            return null;
+        }
+        return hydrateHabitProjectName(client, habit);
+    }),
+    createHabit: (input) => runHabitServiceOperation("createHabit", async () => {
+        const habit = await client.createHabit(input);
+        return hydrateHabitProjectName(client, habit);
+    }),
+    updateHabit: (input) => runHabitServiceOperation("updateHabit", async () => {
+        const habit = await client.updateHabit(input);
+        return hydrateHabitProjectName(client, habit);
+    }),
+    listHabitsWithStreaks: (filter) => runHabitServiceOperation("listHabitsWithStreaks", () => listHabitsWithStreaks(client, filter)),
+    getHabitStreak: (habitId) => runHabitServiceOperation("getHabitStreak", () => client.getHabitStreak(habitId)),
+    checkHabit: (habitId) => runHabitServiceOperation("checkHabit", () => client.checkHabit(habitId)),
+    deleteHabit: (habitId) => runHabitServiceOperation("deleteHabit", () => client.deleteHabit(habitId)),
+    addHabitNote: (input) => runHabitServiceOperation("addHabitNote", () => client.addHabitNote(input)),
+});
+const listHabitsWithProjectNames = async (client, filter) => {
+    const [habits, projects] = await Promise.all([client.listHabits(filter), client.listProjects()]);
+    const projectNames = new Map(projects.map((project) => [project.id, project.name]));
+    return habits.map((habit) => ({
+        ...habit,
+        projectName: projectNames.get(habit.projectId) ?? null,
+    }));
+};
+const hydrateHabitProjectName = async (client, habit) => {
+    const project = await client.getProject(habit.projectId);
+    return {
+        ...habit,
+        projectName: project?.name ?? null,
+    };
+};
+const runHabitServiceOperation = async (operation, action) => {
+    try {
+        return await action();
+    }
+    catch (error) {
+        if (error instanceof ToduDaemonClientError) {
+            throw new ToduHabitServiceError({
+                operation,
+                causeCode: error.code,
+                message: `${operation} failed: ${error.message}`,
+                details: error.details,
+                cause: error,
+            });
+        }
+        throw error;
+    }
+};
+const listHabitsWithStreaks = async (client, filter) => {
+    const habits = await listHabitsWithProjectNames(client, filter);
+    const streakResults = await Promise.allSettled(habits.map((habit) => client.getHabitStreak(habit.id)));
+    return habits.map((habit, index) => {
+        const streakResult = streakResults[index];
+        return {
+            ...habit,
+            streak: streakResult?.status === "fulfilled" ? streakResult.value : null,
+        };
+    });
+};
+export { createToduHabitService, hydrateHabitProjectName, listHabitsWithProjectNames, listHabitsWithStreaks, runHabitServiceOperation, };

package/dist/services/todu/todu-note-service.d.ts

@@ -0,0 +1,20 @@
+import type { NoteService } from "../note-service";
+import { type ToduDaemonClient } from "./daemon-client";
+export declare class ToduNoteServiceError extends Error {
+    readonly operation: string;
+    readonly causeCode: string;
+    readonly details?: Record<string, unknown>;
+    constructor(options: {
+        operation: string;
+        causeCode: string;
+        message: string;
+        details?: Record<string, unknown>;
+        cause?: unknown;
+    });
+}
+export interface ToduNoteServiceDependencies {
+    client: ToduDaemonClient;
+}
+declare const createToduNoteService: ({ client }: ToduNoteServiceDependencies) => NoteService;
+declare const runNoteServiceOperation: <TResult>(operation: string, action: () => Promise<TResult>) => Promise<TResult>;
+export { createToduNoteService, runNoteServiceOperation };

package/dist/services/todu/todu-note-service.js

@@ -0,0 +1,35 @@
+import { ToduDaemonClientError } from "./daemon-client.js";
+export class ToduNoteServiceError extends Error {
+    operation;
+    causeCode;
+    details;
+    constructor(options) {
+        super(options.message, options.cause ? { cause: options.cause } : undefined);
+        this.name = "ToduNoteServiceError";
+        this.operation = options.operation;
+        this.causeCode = options.causeCode;
+        this.details = options.details;
+    }
+}
+const createToduNoteService = ({ client }) => ({
+    listNotes: (filter) => runNoteServiceOperation("listNotes", () => client.listNotes(filter)),
+    getNote: (noteId) => runNoteServiceOperation("getNote", () => client.getNote(noteId)),
+});
+const runNoteServiceOperation = async (operation, action) => {
+    try {
+        return await action();
+    }
+    catch (error) {
+        if (error instanceof ToduDaemonClientError) {
+            throw new ToduNoteServiceError({
+                operation,
+                causeCode: error.code,
+                message: `${operation} failed: ${error.message}`,
+                details: error.details,
+                cause: error,
+            });
+        }
+        throw error;
+    }
+};
+export { createToduNoteService, runNoteServiceOperation };

package/dist/services/todu/todu-project-integration-service.d.ts

@@ -0,0 +1,27 @@
+import type { ProjectIntegrationGateway, ProjectIntegrationService } from "../project-integration-service";
+import type { ProjectService } from "../project-service";
+import type { RepoContextService } from "../repo-context";
+import { type ToduDaemonClient } from "./daemon-client";
+export declare class ToduProjectIntegrationServiceError extends Error {
+    readonly operation: string;
+    readonly causeCode: string;
+    readonly details?: Record<string, unknown>;
+    constructor(options: {
+        operation: string;
+        causeCode: string;
+        message: string;
+        details?: Record<string, unknown>;
+        cause?: unknown;
+    });
+}
+export interface ToduProjectIntegrationGatewayDependencies {
+    client: ToduDaemonClient;
+}
+declare const createToduProjectIntegrationGateway: ({ client, }: ToduProjectIntegrationGatewayDependencies) => ProjectIntegrationGateway;
+declare const createToduProjectIntegrationService: ({ client, projectService, repoContextService, }: {
+    client: ToduDaemonClient;
+    projectService: ProjectService;
+    repoContextService: RepoContextService;
+}) => ProjectIntegrationService;
+declare const runProjectIntegrationServiceOperation: <TResult>(operation: string, action: () => Promise<TResult>) => Promise<TResult>;
+export { createToduProjectIntegrationGateway, createToduProjectIntegrationService, runProjectIntegrationServiceOperation, };

package/dist/services/todu/todu-project-integration-service.js

@@ -0,0 +1,45 @@
+import { createProjectIntegrationService } from "../project-integration-service.js";
+import { ToduDaemonClientError } from "./daemon-client.js";
+export class ToduProjectIntegrationServiceError extends Error {
+    operation;
+    causeCode;
+    details;
+    constructor(options) {
+        super(options.message, options.cause ? { cause: options.cause } : undefined);
+        this.name = "ToduProjectIntegrationServiceError";
+        this.operation = options.operation;
+        this.causeCode = options.causeCode;
+        this.details = options.details;
+    }
+}
+const createToduProjectIntegrationGateway = ({ client, }) => ({
+    listIntegrationBindings: (filter) => client.listIntegrationBindings(filter),
+    createIntegrationBinding: (input) => client.createIntegrationBinding(input),
+});
+const createToduProjectIntegrationService = ({ client, projectService, repoContextService, }) => {
+    const gateway = createToduProjectIntegrationGateway({ client });
+    const service = createProjectIntegrationService({ projectService, repoContextService, gateway });
+    return {
+        listIntegrationBindings: (filter) => runProjectIntegrationServiceOperation("listIntegrationBindings", () => service.listIntegrationBindings(filter)),
+        checkRepositoryBinding: (input) => runProjectIntegrationServiceOperation("checkRepositoryBinding", () => service.checkRepositoryBinding(input)),
+        registerRepositoryProject: (input) => runProjectIntegrationServiceOperation("registerRepositoryProject", () => service.registerRepositoryProject(input)),
+    };
+};
+const runProjectIntegrationServiceOperation = async (operation, action) => {
+    try {
+        return await action();
+    }
+    catch (error) {
+        if (error instanceof ToduDaemonClientError) {
+            throw new ToduProjectIntegrationServiceError({
+                operation,
+                causeCode: error.code,
+                message: `${operation} failed: ${error.message}`,
+                details: error.details,
+                cause: error,
+            });
+        }
+        throw error;
+    }
+};
+export { createToduProjectIntegrationGateway, createToduProjectIntegrationService, runProjectIntegrationServiceOperation, };

package/dist/services/todu/todu-project-service.d.ts

@@ -0,0 +1,24 @@
+import type { CreateProjectInput, DeleteProjectResult, ProjectService, UpdateProjectInput } from "../project-service";
+import { type ToduDaemonClient } from "./daemon-client";
+export declare class ToduProjectServiceError extends Error {
+    readonly operation: string;
+    readonly causeCode: string;
+    readonly details?: Record<string, unknown>;
+    constructor(options: {
+        operation: string;
+        causeCode: string;
+        message: string;
+        details?: Record<string, unknown>;
+        cause?: unknown;
+    });
+}
+export interface ToduProjectServiceDependencies {
+    client: ToduDaemonClient;
+}
+declare const createToduProjectService: ({ client }: ToduProjectServiceDependencies) => ProjectService;
+declare const runProjectServiceOperation: <TProjectResult>(operation: string, action: () => Promise<TProjectResult>) => Promise<TProjectResult>;
+declare const listProjects: (projectService: ProjectService) => Promise<import("../../domain/task").ProjectSummary[]>;
+declare const createProject: (projectService: ProjectService, input: CreateProjectInput) => Promise<import("../../domain/task").ProjectSummary>;
+declare const updateProject: (projectService: ProjectService, input: UpdateProjectInput) => Promise<import("../../domain/task").ProjectSummary>;
+declare const deleteProject: (projectService: ProjectService, projectId: string) => Promise<DeleteProjectResult>;
+export { createProject, createToduProjectService, deleteProject, listProjects, runProjectServiceOperation, updateProject, };

package/dist/services/todu/todu-project-service.js

@@ -0,0 +1,42 @@
+import { ToduDaemonClientError } from "./daemon-client.js";
+export class ToduProjectServiceError extends Error {
+    operation;
+    causeCode;
+    details;
+    constructor(options) {
+        super(options.message, options.cause ? { cause: options.cause } : undefined);
+        this.name = "ToduProjectServiceError";
+        this.operation = options.operation;
+        this.causeCode = options.causeCode;
+        this.details = options.details;
+    }
+}
+const createToduProjectService = ({ client }) => ({
+    listProjects: () => runProjectServiceOperation("listProjects", () => client.listProjects()),
+    getProject: (projectId) => runProjectServiceOperation("getProject", () => client.getProject(projectId)),
+    createProject: (input) => runProjectServiceOperation("createProject", () => client.createProject(input)),
+    updateProject: (input) => runProjectServiceOperation("updateProject", () => client.updateProject(input)),
+    deleteProject: (projectId) => runProjectServiceOperation("deleteProject", () => client.deleteProject(projectId)),
+});
+const runProjectServiceOperation = async (operation, action) => {
+    try {
+        return await action();
+    }
+    catch (error) {
+        if (error instanceof ToduDaemonClientError) {
+            throw new ToduProjectServiceError({
+                operation,
+                causeCode: error.code,
+                message: `${operation} failed: ${error.message}`,
+                details: error.details,
+                cause: error,
+            });
+        }
+        throw error;
+    }
+};
+const listProjects = async (projectService) => projectService.listProjects();
+const createProject = async (projectService, input) => projectService.createProject(input);
+const updateProject = async (projectService, input) => projectService.updateProject(input);
+const deleteProject = async (projectService, projectId) => projectService.deleteProject(projectId);
+export { createProject, createToduProjectService, deleteProject, listProjects, runProjectServiceOperation, updateProject, };

package/dist/services/todu/todu-recurring-service.d.ts

@@ -0,0 +1,27 @@
+import type { RecurringFilter, RecurringTemplateDetail, RecurringTemplateSummary } from "../../domain/recurring";
+import type { RecurringService, CreateRecurringInput, DeleteRecurringResult, UpdateRecurringInput } from "../recurring-service";
+import { type ToduDaemonClient } from "./daemon-client";
+export declare class ToduRecurringServiceError extends Error {
+    readonly operation: string;
+    readonly causeCode: string;
+    readonly details?: Record<string, unknown>;
+    constructor(options: {
+        operation: string;
+        causeCode: string;
+        message: string;
+        details?: Record<string, unknown>;
+        cause?: unknown;
+    });
+}
+export interface ToduRecurringServiceDependencies {
+    client: ToduDaemonClient;
+}
+declare const createToduRecurringService: ({ client, }: ToduRecurringServiceDependencies) => RecurringService;
+declare const listRecurringWithProjectNames: (client: ToduDaemonClient, filter?: RecurringFilter) => Promise<RecurringTemplateSummary[]>;
+declare const hydrateRecurringProjectName: (client: ToduDaemonClient, template: RecurringTemplateDetail) => Promise<RecurringTemplateDetail>;
+declare const runRecurringServiceOperation: <TResult>(operation: string, action: () => Promise<TResult>) => Promise<TResult>;
+declare const listRecurring: (recurringService: RecurringService, filter?: RecurringFilter) => Promise<RecurringTemplateSummary[]>;
+declare const createRecurring: (recurringService: RecurringService, input: CreateRecurringInput) => Promise<RecurringTemplateDetail>;
+declare const updateRecurring: (recurringService: RecurringService, input: UpdateRecurringInput) => Promise<RecurringTemplateDetail>;
+declare const deleteRecurring: (recurringService: RecurringService, recurringId: string) => Promise<DeleteRecurringResult>;
+export { createRecurring, createToduRecurringService, deleteRecurring, hydrateRecurringProjectName, listRecurring, listRecurringWithProjectNames, runRecurringServiceOperation, updateRecurring, };

package/dist/services/todu/todu-recurring-service.js

@@ -0,0 +1,72 @@
+import { ToduDaemonClientError } from "./daemon-client.js";
+export class ToduRecurringServiceError extends Error {
+    operation;
+    causeCode;
+    details;
+    constructor(options) {
+        super(options.message, options.cause ? { cause: options.cause } : undefined);
+        this.name = "ToduRecurringServiceError";
+        this.operation = options.operation;
+        this.causeCode = options.causeCode;
+        this.details = options.details;
+    }
+}
+const createToduRecurringService = ({ client, }) => ({
+    listRecurring: (filter) => runRecurringServiceOperation("listRecurring", () => listRecurringWithProjectNames(client, filter)),
+    getRecurring: (recurringId) => runRecurringServiceOperation("getRecurring", async () => {
+        const template = await client.getRecurring(recurringId);
+        if (!template) {
+            return null;
+        }
+        return hydrateRecurringProjectName(client, template);
+    }),
+    createRecurring: (input) => runRecurringServiceOperation("createRecurring", async () => {
+        const template = await client.createRecurring(input);
+        return hydrateRecurringProjectName(client, template);
+    }),
+    updateRecurring: (input) => runRecurringServiceOperation("updateRecurring", async () => {
+        const template = await client.updateRecurring(input);
+        return hydrateRecurringProjectName(client, template);
+    }),
+    deleteRecurring: (recurringId) => runRecurringServiceOperation("deleteRecurring", () => client.deleteRecurring(recurringId)),
+});
+const listRecurringWithProjectNames = async (client, filter) => {
+    const [templates, projects] = await Promise.all([
+        client.listRecurring(filter),
+        client.listProjects(),
+    ]);
+    const projectNames = new Map(projects.map((project) => [project.id, project.name]));
+    return templates.map((template) => ({
+        ...template,
+        projectName: projectNames.get(template.projectId) ?? null,
+    }));
+};
+const hydrateRecurringProjectName = async (client, template) => {
+    const project = await client.getProject(template.projectId);
+    return {
+        ...template,
+        projectName: project?.name ?? null,
+    };
+};
+const runRecurringServiceOperation = async (operation, action) => {
+    try {
+        return await action();
+    }
+    catch (error) {
+        if (error instanceof ToduDaemonClientError) {
+            throw new ToduRecurringServiceError({
+                operation,
+                causeCode: error.code,
+                message: `${operation} failed: ${error.message}`,
+                details: error.details,
+                cause: error,
+            });
+        }
+        throw error;
+    }
+};
+const listRecurring = async (recurringService, filter) => recurringService.listRecurring(filter);
+const createRecurring = async (recurringService, input) => recurringService.createRecurring(input);
+const updateRecurring = async (recurringService, input) => recurringService.updateRecurring(input);
+const deleteRecurring = async (recurringService, recurringId) => recurringService.deleteRecurring(recurringId);
+export { createRecurring, createToduRecurringService, deleteRecurring, hydrateRecurringProjectName, listRecurring, listRecurringWithProjectNames, runRecurringServiceOperation, updateRecurring, };

package/dist/services/todu/todu-task-service.d.ts

@@ -0,0 +1,23 @@
+import type { TaskDetail, TaskFilter, TaskSummary } from "../../domain/task";
+import type { TaskService } from "../task-service";
+import { type ToduDaemonClient } from "./daemon-client";
+export declare class ToduTaskServiceError extends Error {
+    readonly operation: string;
+    readonly causeCode: string;
+    readonly details?: Record<string, unknown>;
+    constructor(options: {
+        operation: string;
+        causeCode: string;
+        message: string;
+        details?: Record<string, unknown>;
+        cause?: unknown;
+    });
+}
+export interface ToduTaskServiceDependencies {
+    client: ToduDaemonClient;
+}
+declare const createToduTaskService: ({ client }: ToduTaskServiceDependencies) => TaskService;
+declare const listTasksWithProjectNames: (client: ToduDaemonClient, filter?: TaskFilter) => Promise<TaskSummary[]>;
+declare const hydrateTaskDetailProjectName: (client: ToduDaemonClient, task: TaskDetail) => Promise<TaskDetail>;
+declare const runTaskServiceOperation: <T>(operation: string, action: () => Promise<T>) => Promise<T>;
+export { createToduTaskService, hydrateTaskDetailProjectName, listTasksWithProjectNames, runTaskServiceOperation, };

package/dist/services/todu/todu-task-service.js

@@ -0,0 +1,80 @@
+import { ToduDaemonClientError } from "./daemon-client.js";
+export class ToduTaskServiceError extends Error {
+    operation;
+    causeCode;
+    details;
+    constructor(options) {
+        super(options.message, options.cause ? { cause: options.cause } : undefined);
+        this.name = "ToduTaskServiceError";
+        this.operation = options.operation;
+        this.causeCode = options.causeCode;
+        this.details = options.details;
+    }
+}
+const createToduTaskService = ({ client }) => ({
+    listTasks: (filter) => runTaskServiceOperation("listTasks", () => listTasksWithProjectNames(client, filter)),
+    getTask: (taskId) => runTaskServiceOperation("getTask", async () => {
+        const task = await client.getTask(taskId);
+        if (!task) {
+            return null;
+        }
+        return hydrateTaskDetailProjectName(client, task);
+    }),
+    createTask: (input) => runTaskServiceOperation("createTask", async () => {
+        const task = await client.createTask(input);
+        return hydrateTaskDetailProjectName(client, task);
+    }),
+    updateTask: (input) => runTaskServiceOperation("updateTask", async () => {
+        const task = await client.updateTask(input);
+        return hydrateTaskDetailProjectName(client, task);
+    }),
+    addTaskComment: (input) => runTaskServiceOperation("addTaskComment", () => client.addTaskComment(input)),
+    deleteTask: (taskId) => runTaskServiceOperation("deleteTask", () => client.deleteTask(taskId)),
+    moveTask: (input) => runTaskServiceOperation("moveTask", async () => {
+        const result = await client.moveTask(input);
+        const targetTask = await hydrateTaskDetailProjectName(client, result.targetTask);
+        return { ...result, targetTask };
+    }),
+    listProjects: () => runTaskServiceOperation("listProjects", () => client.listProjects()),
+    getProject: (projectId) => runTaskServiceOperation("getProject", () => client.getProject(projectId)),
+    listTaskComments: (taskId) => runTaskServiceOperation("listTaskComments", () => client.listTaskComments(taskId)),
+});
+const listTasksWithProjectNames = async (client, filter) => {
+    const [tasks, projects] = await Promise.all([client.listTasks(filter), client.listProjects()]);
+    const projectNames = new Map(projects.map((project) => [project.id, project.name]));
+    return tasks.map((task) => ({
+        ...task,
+        projectName: task.projectId ? (projectNames.get(task.projectId) ?? null) : null,
+    }));
+};
+const hydrateTaskDetailProjectName = async (client, task) => {
+    if (!task.projectId) {
+        return {
+            ...task,
+            projectName: null,
+        };
+    }
+    const project = await client.getProject(task.projectId);
+    return {
+        ...task,
+        projectName: project?.name ?? null,
+    };
+};
+const runTaskServiceOperation = async (operation, action) => {
+    try {
+        return await action();
+    }
+    catch (error) {
+        if (error instanceof ToduDaemonClientError) {
+            throw new ToduTaskServiceError({
+                operation,
+                causeCode: error.code,
+                message: `${operation} failed: ${error.message}`,
+                details: error.details,
+                cause: error,
+            });
+        }
+        throw error;
+    }
+};
+export { createToduTaskService, hydrateTaskDetailProjectName, listTasksWithProjectNames, runTaskServiceOperation, };