@todu/pi-extensions 0.1.0

package/dist/services/todu/daemon-client.js

@@ -0,0 +1,660 @@
+export class ToduDaemonClientError extends Error {
+    code;
+    method;
+    details;
+    constructor(options) {
+        super(options.message);
+        this.name = "ToduDaemonClientError";
+        this.code = options.code;
+        this.method = options.method;
+        this.details = options.details;
+    }
+}
+const createToduDaemonClient = ({ connection, }) => ({
+    async listTasks(filter = {}) {
+        const tasks = await listRawTasks(connection, filter);
+        return tasks.map(mapTaskSummary);
+    },
+    async getTask(taskId) {
+        const taskResult = await connection.request("task.get", { id: taskId });
+        if (!taskResult.ok) {
+            if (taskResult.error.code === "NOT_FOUND") {
+                return null;
+            }
+            throw mapDaemonErrorToClientError("task.get", taskResult.error);
+        }
+        const comments = await fetchTaskComments(connection, taskId);
+        return mapTaskDetail(taskResult.value, comments);
+    },
+    async createTask(input) {
+        const taskResult = await connection.request("task.create", {
+            input: mapCreateTaskInput(input),
+        });
+        if (!taskResult.ok) {
+            throw mapDaemonErrorToClientError("task.create", taskResult.error);
+        }
+        return mapTaskDetail(taskResult.value, []);
+    },
+    async updateTask(input) {
+        const taskResult = await connection.request("task.update", {
+            id: input.taskId,
+            input: mapUpdateTaskInput(input),
+        });
+        if (!taskResult.ok) {
+            throw mapDaemonErrorToClientError("task.update", taskResult.error);
+        }
+        const comments = await fetchTaskComments(connection, input.taskId);
+        return mapTaskDetail(taskResult.value, comments);
+    },
+    async addTaskComment(input) {
+        const noteResult = await connection.request("note.create", {
+            input: {
+                content: input.content,
+                entityType: "task",
+                entityId: input.taskId,
+            },
+        });
+        if (!noteResult.ok) {
+            throw mapDaemonErrorToClientError("note.create", noteResult.error);
+        }
+        return mapTaskComment(noteResult.value);
+    },
+    async deleteTask(taskId) {
+        const result = await connection.request("task.delete", { id: taskId });
+        if (!result.ok) {
+            throw mapDaemonErrorToClientError("task.delete", result.error);
+        }
+        return {
+            taskId,
+            deleted: true,
+        };
+    },
+    async moveTask(input) {
+        const result = await connection.request("task.move", {
+            id: input.taskId,
+            targetProjectId: input.targetProjectId,
+        });
+        if (!result.ok) {
+            throw mapDaemonErrorToClientError("task.move", result.error);
+        }
+        const comments = await fetchTaskComments(connection, result.value.id);
+        return {
+            sourceTaskId: input.taskId,
+            targetTask: mapTaskDetail(result.value, comments),
+        };
+    },
+    async listProjects() {
+        const result = await connection.request("project.list", {});
+        if (!result.ok) {
+            throw mapDaemonErrorToClientError("project.list", result.error);
+        }
+        return result.value.map(mapProjectSummary);
+    },
+    async getProject(projectId) {
+        const result = await connection.request("project.get", { id: projectId });
+        if (!result.ok) {
+            if (result.error.code === "NOT_FOUND") {
+                return null;
+            }
+            throw mapDaemonErrorToClientError("project.get", result.error);
+        }
+        return mapProjectSummary(result.value);
+    },
+    async createProject(input) {
+        const result = await connection.request("project.create", {
+            input: mapCreateProjectInput(input),
+        });
+        if (!result.ok) {
+            throw mapDaemonErrorToClientError("project.create", result.error);
+        }
+        return mapProjectSummary(result.value);
+    },
+    async updateProject(input) {
+        const result = await connection.request("project.update", {
+            id: input.projectId,
+            input: mapUpdateProjectInput(input),
+        });
+        if (!result.ok) {
+            throw mapDaemonErrorToClientError("project.update", result.error);
+        }
+        return mapProjectSummary(result.value);
+    },
+    async deleteProject(projectId) {
+        const result = await connection.request("project.delete", { id: projectId });
+        if (!result.ok) {
+            throw mapDaemonErrorToClientError("project.delete", result.error);
+        }
+        return {
+            projectId,
+            deleted: true,
+        };
+    },
+    async listRecurring(filter = {}) {
+        const result = await connection.request("recurring.list", {
+            filter: mapRecurringFilter(filter),
+        });
+        if (!result.ok) {
+            throw mapDaemonErrorToClientError("recurring.list", result.error);
+        }
+        return result.value.map(mapRecurringTemplateSummary);
+    },
+    async getRecurring(recurringId) {
+        const result = await connection.request("recurring.get", {
+            id: recurringId,
+        });
+        if (!result.ok) {
+            if (result.error.code === "NOT_FOUND") {
+                return null;
+            }
+            throw mapDaemonErrorToClientError("recurring.get", result.error);
+        }
+        return mapRecurringTemplateDetail(result.value);
+    },
+    async createRecurring(input) {
+        const result = await connection.request("recurring.create", {
+            input: mapCreateRecurringInput(input),
+        });
+        if (!result.ok) {
+            throw mapDaemonErrorToClientError("recurring.create", result.error);
+        }
+        return mapRecurringTemplateDetail(result.value);
+    },
+    async updateRecurring(input) {
+        const result = await connection.request("recurring.update", {
+            id: input.recurringId,
+            input: mapUpdateRecurringInput(input),
+        });
+        if (!result.ok) {
+            throw mapDaemonErrorToClientError("recurring.update", result.error);
+        }
+        return mapRecurringTemplateDetail(result.value);
+    },
+    async deleteRecurring(recurringId) {
+        const result = await connection.request("recurring.delete", { id: recurringId });
+        if (!result.ok) {
+            throw mapDaemonErrorToClientError("recurring.delete", result.error);
+        }
+        return {
+            recurringId,
+            deleted: true,
+        };
+    },
+    async listIntegrationBindings(filter = {}) {
+        const result = await connection.request("integration.list", {
+            filter: mapIntegrationBindingFilter(filter),
+        });
+        if (!result.ok) {
+            throw mapDaemonErrorToClientError("integration.list", result.error);
+        }
+        return result.value.map(mapIntegrationBinding);
+    },
+    async createIntegrationBinding(input) {
+        const result = await connection.request("integration.create", {
+            input: mapCreateIntegrationBindingInput(input),
+        });
+        if (!result.ok) {
+            throw mapDaemonErrorToClientError("integration.create", result.error);
+        }
+        return mapIntegrationBinding(result.value);
+    },
+    async listHabits(filter = {}) {
+        const result = await connection.request("habit.list", {
+            filter: mapHabitFilter(filter),
+        });
+        if (!result.ok) {
+            throw mapDaemonErrorToClientError("habit.list", result.error);
+        }
+        return result.value.map(mapHabitSummary);
+    },
+    async getHabit(habitId) {
+        const result = await connection.request("habit.get", { id: habitId });
+        if (!result.ok) {
+            if (result.error.code === "NOT_FOUND") {
+                return null;
+            }
+            throw mapDaemonErrorToClientError("habit.get", result.error);
+        }
+        return mapHabitDetail(result.value);
+    },
+    async createHabit(input) {
+        const result = await connection.request("habit.create", {
+            input: mapCreateHabitInput(input),
+        });
+        if (!result.ok) {
+            throw mapDaemonErrorToClientError("habit.create", result.error);
+        }
+        return mapHabitDetail(result.value);
+    },
+    async updateHabit(input) {
+        const result = await connection.request("habit.update", {
+            id: input.habitId,
+            input: mapUpdateHabitInput(input),
+        });
+        if (!result.ok) {
+            throw mapDaemonErrorToClientError("habit.update", result.error);
+        }
+        return mapHabitDetail(result.value);
+    },
+    async checkHabit(habitId) {
+        const result = await connection.request("habit.check", {
+            id: habitId,
+        });
+        if (!result.ok) {
+            throw mapDaemonErrorToClientError("habit.check", result.error);
+        }
+        return mapHabitCheckResult(result.value, habitId);
+    },
+    async getHabitStreak(habitId) {
+        const result = await connection.request("habit.streak", {
+            id: habitId,
+        });
+        if (!result.ok) {
+            throw mapDaemonErrorToClientError("habit.streak", result.error);
+        }
+        return {
+            current: result.value.current,
+            longest: result.value.longest,
+            completedToday: result.value.completedToday,
+            totalCheckins: result.value.totalCheckins,
+        };
+    },
+    async addHabitNote(input) {
+        const noteResult = await connection.request("note.create", {
+            input: {
+                content: input.content,
+                entityType: "habit",
+                entityId: input.habitId,
+            },
+        });
+        if (!noteResult.ok) {
+            throw mapDaemonErrorToClientError("note.create", noteResult.error);
+        }
+        return mapNoteSummary(noteResult.value);
+    },
+    async deleteHabit(habitId) {
+        const result = await connection.request("habit.delete", { id: habitId });
+        if (!result.ok) {
+            throw mapDaemonErrorToClientError("habit.delete", result.error);
+        }
+        return {
+            habitId,
+            deleted: true,
+        };
+    },
+    async getNote(noteId) {
+        const result = await connection.request("note.get", { id: noteId });
+        if (!result.ok) {
+            if (result.error.code === "NOT_FOUND") {
+                return null;
+            }
+            throw mapDaemonErrorToClientError("note.get", result.error);
+        }
+        return mapNoteSummary(result.value);
+    },
+    async listNotes(filter = {}) {
+        const result = await connection.request("note.list", {
+            filter: mapNoteFilter(filter),
+        });
+        if (!result.ok) {
+            throw mapDaemonErrorToClientError("note.list", result.error);
+        }
+        return result.value.map(mapNoteSummary);
+    },
+    async listTaskComments(taskId) {
+        return fetchTaskComments(connection, taskId);
+    },
+    on(eventName, listener) {
+        return connection.subscribeToEvents([eventName], (event) => {
+            if (event.name === eventName) {
+                listener(event);
+            }
+        });
+    },
+});
+const listRawTasks = async (connection, filter) => {
+    let tasks;
+    if (filter.query && filter.query.trim().length > 0) {
+        const result = await connection.request("task.search", {
+            query: filter.query,
+        });
+        if (!result.ok) {
+            throw mapDaemonErrorToClientError("task.search", result.error);
+        }
+        tasks = result.value.filter((task) => matchesTaskFilter(task, filter));
+    }
+    else {
+        const result = await connection.request("task.list", {
+            filter: mapTaskFilter(filter),
+        });
+        if (!result.ok) {
+            throw mapDaemonErrorToClientError("task.list", result.error);
+        }
+        tasks = result.value.filter((task) => matchesTaskFilter(task, filter));
+    }
+    if (filter.sort) {
+        tasks = sortTasks(tasks, filter.sort, filter.sortDirection ?? "desc");
+    }
+    return tasks;
+};
+const sortTasks = (tasks, field, direction) => {
+    const sorted = [...tasks].sort((a, b) => {
+        const aVal = getTaskSortValue(a, field);
+        const bVal = getTaskSortValue(b, field);
+        if (aVal < bVal)
+            return -1;
+        if (aVal > bVal)
+            return 1;
+        return 0;
+    });
+    return direction === "asc" ? sorted : sorted.reverse();
+};
+const PRIORITY_ORDER = { urgent: 0, high: 1, medium: 2, low: 3, none: 4 };
+const getTaskSortValue = (task, field) => {
+    switch (field) {
+        case "priority":
+            return PRIORITY_ORDER[task.priority] ?? 99;
+        case "dueDate":
+            return task.dueDate ?? "9999-12-31";
+        case "createdAt":
+            return task.createdAt;
+        case "updatedAt":
+            return task.updatedAt;
+        case "title":
+            return task.title.toLowerCase();
+        default:
+            return task.createdAt;
+    }
+};
+const fetchTaskComments = async (connection, taskId) => {
+    const result = await connection.request("note.list", {
+        filter: {
+            entityType: "task",
+            entityId: taskId,
+        },
+    });
+    if (!result.ok) {
+        throw mapDaemonErrorToClientError("note.list", result.error);
+    }
+    return result.value.map(mapTaskComment);
+};
+const mapTaskSummary = (task) => ({
+    id: task.id,
+    title: task.title,
+    status: toLocalTaskStatus(task.status),
+    priority: toLocalTaskPriority(task.priority),
+    projectId: task.projectId ?? null,
+    projectName: null,
+    labels: [...task.labels],
+});
+const mapTaskDetail = (task, comments) => ({
+    ...mapTaskSummary(task),
+    description: task.description ?? null,
+    comments,
+});
+const mapTaskComment = (note) => ({
+    id: note.id,
+    taskId: note.entityId ?? "",
+    content: note.content,
+    author: note.author,
+    createdAt: note.createdAt,
+});
+const mapNoteSummary = (note) => ({
+    id: note.id,
+    content: note.content,
+    author: note.author,
+    entityType: note.entityType ?? null,
+    entityId: note.entityId ?? null,
+    tags: [...note.tags],
+    createdAt: note.createdAt,
+});
+const mapNoteFilter = (filter) => ({
+    entityType: filter.entityType,
+    entityId: filter.entityId,
+    tag: filter.tag,
+    author: filter.author,
+    createdFrom: filter.from,
+    createdTo: filter.to,
+    journal: filter.journal,
+    timezone: filter.timezone,
+});
+const mapProjectSummary = (project) => ({
+    id: project.id,
+    name: project.name,
+    status: toLocalProjectStatus(project.status),
+    priority: toLocalTaskPriority(project.priority),
+    description: project.description ?? null,
+});
+const mapIntegrationBinding = (binding) => ({
+    id: binding.id,
+    provider: binding.provider,
+    projectId: binding.projectId,
+    targetKind: binding.targetKind,
+    targetRef: binding.targetRef,
+    strategy: binding.strategy,
+    enabled: binding.enabled,
+    options: binding.options,
+    createdAt: binding.createdAt,
+    updatedAt: binding.updatedAt,
+});
+const mapRecurringTemplateSummary = (template) => ({
+    id: template.id,
+    title: template.title,
+    projectId: template.projectId,
+    projectName: null,
+    priority: toLocalTaskPriority(template.priority),
+    schedule: template.schedule,
+    timezone: template.timezone,
+    startDate: template.startDate,
+    endDate: template.endDate ?? null,
+    nextDue: template.nextDue,
+    missPolicy: toLocalRecurringMissPolicy(template.missPolicy),
+    paused: template.paused,
+});
+const mapRecurringTemplateDetail = (template) => ({
+    ...mapRecurringTemplateSummary(template),
+    description: template.description ?? null,
+    labels: [...template.labels],
+    skippedDates: [...template.skippedDates],
+    createdAt: template.createdAt,
+    updatedAt: template.updatedAt,
+});
+const mapHabitSummary = (habit) => ({
+    id: habit.id,
+    title: habit.title,
+    projectId: habit.projectId,
+    projectName: null,
+    schedule: habit.schedule,
+    timezone: habit.timezone,
+    startDate: habit.startDate,
+    endDate: habit.endDate ?? null,
+    nextDue: habit.nextDue,
+    paused: habit.paused,
+});
+const mapHabitDetail = (habit) => ({
+    ...mapHabitSummary(habit),
+    description: habit.description ?? null,
+    createdAt: habit.createdAt,
+    updatedAt: habit.updatedAt,
+});
+const mapHabitCheckResult = (result, habitId) => ({
+    habitId,
+    date: result.date,
+    completed: result.completed,
+    streak: result.streak
+        ? {
+            current: result.streak.current,
+            longest: result.streak.longest,
+            completedToday: result.streak.completedToday,
+            totalCheckins: result.streak.totalCheckins,
+        }
+        : undefined,
+});
+const mapCreateHabitInput = (input) => ({
+    title: input.title,
+    projectId: input.projectId,
+    schedule: input.schedule,
+    timezone: input.timezone,
+    startDate: input.startDate,
+    description: input.description ?? undefined,
+    endDate: input.endDate ?? undefined,
+});
+const mapUpdateHabitInput = (input) => ({
+    title: input.title ?? undefined,
+    schedule: input.schedule ?? undefined,
+    timezone: input.timezone ?? undefined,
+    description: input.description ?? undefined,
+    endDate: input.endDate ?? undefined,
+});
+const mapHabitFilter = (filter) => ({
+    paused: filter.paused,
+    projectId: filter.projectId,
+    search: filter.query,
+});
+const mapCreateProjectInput = (input) => ({
+    name: input.name,
+    description: input.description ?? undefined,
+    priority: input.priority ?? undefined,
+});
+const mapUpdateProjectInput = (input) => ({
+    name: input.name ?? undefined,
+    description: input.description ?? undefined,
+    status: input.status ? toRemoteProjectStatus(input.status) : undefined,
+    priority: input.priority ?? undefined,
+});
+const mapCreateRecurringInput = (input) => ({
+    title: input.title,
+    projectId: input.projectId,
+    schedule: input.schedule,
+    timezone: input.timezone,
+    startDate: input.startDate,
+    description: input.description ?? undefined,
+    priority: input.priority ?? undefined,
+    endDate: input.endDate ?? undefined,
+    missPolicy: input.missPolicy ? toRemoteRecurringMissPolicy(input.missPolicy) : undefined,
+});
+const mapUpdateRecurringInput = (input) => ({
+    title: input.title ?? undefined,
+    projectId: input.projectId ?? undefined,
+    schedule: input.schedule ?? undefined,
+    timezone: input.timezone ?? undefined,
+    startDate: input.startDate ?? undefined,
+    description: input.description ?? undefined,
+    priority: input.priority ?? undefined,
+    endDate: input.endDate ?? undefined,
+    missPolicy: input.missPolicy ? toRemoteRecurringMissPolicy(input.missPolicy) : undefined,
+    paused: input.paused ?? undefined,
+});
+const mapIntegrationBindingFilter = (filter) => ({
+    provider: filter.provider,
+    projectId: filter.projectId,
+    enabled: filter.enabled,
+});
+const mapRecurringFilter = (filter) => ({
+    paused: filter.paused,
+    projectId: filter.projectId,
+    search: filter.query,
+});
+const mapCreateIntegrationBindingInput = (input) => ({
+    provider: input.provider,
+    projectId: input.projectId,
+    targetKind: input.targetKind,
+    targetRef: input.targetRef,
+    strategy: input.strategy,
+    enabled: input.enabled,
+    options: input.options,
+});
+const mapTaskFilter = (filter) => {
+    const status = filter.statuses && filter.statuses.length > 0
+        ? filter.statuses.map(toRemoteTaskStatus)
+        : undefined;
+    const priority = filter.priorities && filter.priorities.length > 0
+        ? toRemoteTaskPriority(filter.priorities[0])
+        : undefined;
+    return {
+        projectId: filter.projectId,
+        status: status?.length === 1 ? status[0] : status,
+        priority,
+        label: filter.label,
+        overdue: filter.overdue,
+        today: filter.today,
+        createdFrom: filter.from,
+        createdTo: filter.to,
+        updatedFrom: filter.updatedFrom,
+        updatedTo: filter.updatedTo,
+        timezone: filter.timezone,
+    };
+};
+const mapCreateTaskInput = (input) => ({
+    title: input.title,
+    description: input.description ?? undefined,
+    projectId: input.projectId ?? undefined,
+    labels: input.labels,
+});
+const mapUpdateTaskInput = (input) => ({
+    title: input.title ?? undefined,
+    status: input.status ? toRemoteTaskStatus(input.status) : undefined,
+    priority: input.priority ? toRemoteTaskPriority(input.priority) : undefined,
+    description: input.description ?? undefined,
+});
+const matchesTaskFilter = (task, filter) => {
+    if (filter.projectId && task.projectId !== filter.projectId) {
+        return false;
+    }
+    if (filter.statuses &&
+        filter.statuses.length > 0 &&
+        !filter.statuses.includes(toLocalTaskStatus(task.status))) {
+        return false;
+    }
+    if (filter.priorities &&
+        filter.priorities.length > 0 &&
+        !filter.priorities.includes(toLocalTaskPriority(task.priority))) {
+        return false;
+    }
+    if (filter.query && filter.query.trim().length > 0) {
+        const normalizedQuery = filter.query.trim().toLowerCase();
+        if (!task.title.toLowerCase().includes(normalizedQuery)) {
+            return false;
+        }
+    }
+    if (filter.label && !task.labels.includes(filter.label)) {
+        return false;
+    }
+    return true;
+};
+const mapDaemonErrorToClientError = (method, error) => {
+    const code = toClientErrorCode(error.code);
+    return new ToduDaemonClientError({
+        code,
+        method,
+        message: `${method} failed (${error.code}): ${error.message}`,
+        details: error.details,
+    });
+};
+const toClientErrorCode = (code) => {
+    switch (code) {
+        case "NOT_FOUND":
+            return "not-found";
+        case "VALIDATION_ERROR":
+        case "BAD_REQUEST":
+            return "validation";
+        case "CONFLICT":
+            return "conflict";
+        case "PRECONDITION_FAILED":
+            return "precondition-failed";
+        case "DAEMON_UNAVAILABLE":
+            return "unavailable";
+        case "TIMEOUT":
+            return "timeout";
+        default:
+            return "internal";
+    }
+};
+const toLocalTaskStatus = (status) => status === "canceled" ? "cancelled" : status;
+const toRemoteTaskStatus = (status) => status === "cancelled" ? "canceled" : status;
+const toLocalProjectStatus = (status) => status === "canceled" ? "cancelled" : status === "done" ? "done" : "active";
+const toLocalTaskPriority = (priority) => priority;
+const toRemoteTaskPriority = (priority) => priority;
+const toLocalRecurringMissPolicy = (missPolicy) => missPolicy ?? "accumulate";
+const toRemoteRecurringMissPolicy = (missPolicy) => missPolicy;
+const toRemoteProjectStatus = (status) => status === "cancelled" ? "canceled" : status;
+export { createToduDaemonClient, mapCreateHabitInput, mapCreateIntegrationBindingInput, mapCreateProjectInput, mapCreateRecurringInput, mapDaemonErrorToClientError, mapHabitCheckResult, mapHabitDetail, mapHabitFilter, mapHabitSummary, mapIntegrationBindingFilter, mapRecurringFilter, mapRecurringTemplateDetail, mapRecurringTemplateSummary, mapUpdateHabitInput, mapUpdateProjectInput, mapUpdateRecurringInput, toLocalTaskStatus, toRemoteProjectStatus, toRemoteTaskStatus, };

package/dist/services/todu/daemon-config.d.ts

@@ -0,0 +1,17 @@
+import { type ConfigResolutionOptions, type ToduFileConfig } from "@todu/core";
+declare const TODU_DAEMON_SOCKET_ENV = "TODU_DAEMON_SOCKET";
+declare const TODUAI_DAEMON_SOCKET_ENV = "TODUAI_DAEMON_SOCKET";
+declare const DEFAULT_TODU_DAEMON_SOCKET_FILENAME = "daemon.sock";
+export interface ToduDaemonConfig {
+    configPath: string;
+    dataDir: string;
+    socketPath: string;
+    fileConfig: ToduFileConfig;
+}
+export interface ResolveToduDaemonConfigOptions extends ConfigResolutionOptions {
+    configPath?: string;
+}
+declare const loadToduFileConfig: (configPath: string) => ToduFileConfig;
+declare const resolveDaemonSocketPath: (dataDir: string, env?: NodeJS.ProcessEnv) => string;
+declare const resolveToduDaemonConfig: (options?: ResolveToduDaemonConfigOptions) => ToduDaemonConfig;
+export { DEFAULT_TODU_DAEMON_SOCKET_FILENAME, TODUAI_DAEMON_SOCKET_ENV, TODU_DAEMON_SOCKET_ENV, loadToduFileConfig, resolveDaemonSocketPath, resolveToduDaemonConfig, };