@starasia/task-management-mcp 1.0.0

package/dist/tools.js

@@ -0,0 +1,739 @@
+import { z } from "zod";
+import { TaskManagementApiError } from "./api.js";
+import { categorySchema, dryRunSchema, paginationSchema, prioritySchema, } from "./schemas.js";
+const json = (data) => ({
+    content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+});
+const taskFilters = {
+    search: z.string().optional(),
+    statusId: z.union([z.string(), z.array(z.string())]).optional(),
+    category: z.union([categorySchema, z.array(categorySchema)]).optional(),
+    priority: z.union([prioritySchema, z.array(prioritySchema)]).optional(),
+};
+function normalizeArray(value) {
+    if (value === undefined)
+        return undefined;
+    return Array.isArray(value) ? value : [value];
+}
+function stripBearerPrefix(token) {
+    const trimmed = token.trim();
+    return trimmed.toLowerCase().startsWith("bearer ")
+        ? trimmed.slice(7).trim()
+        : trimmed;
+}
+function decodeJwtSubject(token) {
+    const normalized = stripBearerPrefix(token);
+    const [, payloadSegment] = normalized.split(".");
+    if (!payloadSegment)
+        return undefined;
+    try {
+        const payload = JSON.parse(Buffer.from(payloadSegment, "base64url").toString("utf8"));
+        return typeof payload.sub === "string" && payload.sub.trim()
+            ? payload.sub.trim()
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function resolveUserId(bearerToken, userId) {
+    const explicitUserId = userId?.trim();
+    if (explicitUserId)
+        return explicitUserId;
+    const jwtSubject = decodeJwtSubject(bearerToken);
+    if (jwtSubject)
+        return jwtSubject;
+    throw new Error("Unable to derive userId from bearer token JWT subject. Provide userId explicitly or use a JWT access token with a string sub claim.");
+}
+const authStatus = (context) => ({
+    configured: Boolean(context),
+    environment: context?.environment,
+    userId: context?.userId,
+    organizationId: context?.organizationId,
+    hasToken: Boolean(context?.bearerToken),
+    expiresAt: context?.expiresAt,
+});
+export function registerTools(server, api, maxBulkSize, authTtlMs) {
+    let activeContext;
+    const requireContext = () => {
+        if (!activeContext) {
+            throw new Error("Authentication context is not configured. Ask the user for bearerToken and organizationId, then call set_auth_context first. userId is derived from the token JWT sub claim unless explicitly provided.");
+        }
+        if (new Date(activeContext.expiresAt).getTime() <= Date.now()) {
+            activeContext = undefined;
+            throw new Error("Authentication context expired. Ask the user for bearerToken and organizationId, then call set_auth_context again. userId is derived from the token JWT sub claim unless explicitly provided.");
+        }
+        return activeContext;
+    };
+    server.registerTool("set_auth_context", {
+        title: "Set Auth Context",
+        description: "Set the active user authentication context for this MCP process. Ask the user for bearerToken and organizationId before calling this tool. userId is derived from the token JWT sub claim unless explicitly provided. The token is kept only in process memory and is never returned.",
+        inputSchema: {
+            bearerToken: z
+                .string()
+                .min(1)
+                .describe("Bearer token supplied by the active user. Do not log or repeat it."),
+            userId: z
+                .string()
+                .min(1)
+                .optional()
+                .describe("Optional explicit userId override. When omitted, the MCP derives userId from the bearer token JWT sub claim."),
+            organizationId: z.string().min(1),
+            environment: z
+                .string()
+                .optional()
+                .describe("Optional label such as dev or prod. The API URL comes from the MCP instance configuration."),
+            validate: z
+                .boolean()
+                .default(true)
+                .optional()
+                .describe("When true, verify the context with GET /spaces before saving."),
+        },
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+            openWorldHint: true,
+        },
+    }, async (args) => {
+        const bearerToken = args.bearerToken;
+        const organizationId = args.organizationId;
+        if (!bearerToken || !organizationId) {
+            throw new Error("bearerToken and organizationId are required.");
+        }
+        const nextContext = {
+            bearerToken,
+            userId: resolveUserId(bearerToken, args.userId),
+            organizationId,
+            environment: args.environment,
+            expiresAt: new Date(Date.now() + authTtlMs).toISOString(),
+        };
+        if (args.validate ?? true) {
+            try {
+                await api.get("spaces", undefined, nextContext);
+            }
+            catch (error) {
+                if (error instanceof TaskManagementApiError) {
+                    throw new Error(`Auth context validation failed with API status ${error.status}. Verify the bearer token, organizationId, derived/explicit userId, and environment-specific API URL.`, { cause: error });
+                }
+                throw error;
+            }
+        }
+        activeContext = nextContext;
+        return json({
+            ...authStatus(activeContext),
+            validated: args.validate ?? true,
+        });
+    });
+    server.registerTool("get_auth_context_status", {
+        title: "Get Auth Context Status",
+        description: "Return whether an auth context is configured. Never returns the bearer token.",
+        inputSchema: {},
+        annotations: { readOnlyHint: true, openWorldHint: false },
+    }, async () => json(authStatus(activeContext)));
+    server.registerTool("clear_auth_context", {
+        title: "Clear Auth Context",
+        description: "Clear the active user authentication context from process memory.",
+        inputSchema: {},
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+    }, async () => {
+        activeContext = undefined;
+        return json(authStatus(activeContext));
+    });
+    server.registerTool("list_spaces", {
+        title: "List Spaces",
+        description: "List spaces visible to the authenticated user.",
+        inputSchema: {},
+        annotations: { readOnlyHint: true, openWorldHint: true },
+    }, async () => json(await api.get("spaces", undefined, requireContext())));
+    server.registerTool("list_projects", {
+        title: "List Projects",
+        description: "List projects in a space. includeStats returns total/complete/inProgress/toDo/overdue/memberCount when supported by the API.",
+        inputSchema: {
+            spaceId: z.string(),
+            archived: z.boolean().default(false),
+            includeStats: z.boolean().default(true),
+        },
+        annotations: { readOnlyHint: true, openWorldHint: true },
+    }, async (args) => json(await api.get(`spaces/${args.spaceId}/projects`, { archived: args.archived, includeStats: args.includeStats }, requireContext())));
+    server.registerTool("get_project", {
+        title: "Get Project",
+        description: "Get one project by id within a space.",
+        inputSchema: { spaceId: z.string(), projectId: z.string() },
+        annotations: { readOnlyHint: true, openWorldHint: true },
+    }, async (args) => json(await api.get(`spaces/${args.spaceId}/projects/${args.projectId}`, undefined, requireContext())));
+    server.registerTool("list_statuses", {
+        title: "List Statuses",
+        description: "List workflow statuses for a project. Useful before create_task or change_task_status.",
+        inputSchema: { projectId: z.string() },
+        annotations: { readOnlyHint: true, openWorldHint: true },
+    }, async (args) => json(await api.get(`projects/${args.projectId}/statuses`, undefined, requireContext())));
+    server.registerTool("list_project_members", {
+        title: "List Project Members",
+        description: "List project members and their numeric projectMemberId values for assignment.",
+        inputSchema: { projectId: z.string() },
+        annotations: { readOnlyHint: true, openWorldHint: true },
+    }, async (args) => json(await api.get(`project-members/${args.projectId}`, undefined, requireContext())));
+    server.registerTool("list_tasks", {
+        title: "List Tasks",
+        description: "List tasks in a project with filtering/sorting. Defaults to top-level tasks unless includeSubtasks is true.",
+        inputSchema: {
+            ...paginationSchema,
+            ...taskFilters,
+            projectId: z.string(),
+            tagIds: z.union([z.string(), z.array(z.string())]).optional(),
+            sortBy: z
+                .enum(["createdAt", "dueDate"])
+                .default("createdAt")
+                .optional(),
+            sortDir: z.enum(["asc", "desc"]).default("asc"),
+            createdBy: z.string().optional(),
+            assignedTo: z
+                .string()
+                .optional()
+                .describe("User id, not projectMemberId."),
+            includeSubtasks: z.boolean().default(false),
+        },
+        annotations: { readOnlyHint: true, openWorldHint: true },
+    }, async (args) => json(await api.get(`projects/${args.projectId}/tasks`, {
+        page: args.page,
+        perPage: args.perPage,
+        search: args.search,
+        statusId: normalizeArray(args.statusId),
+        category: normalizeArray(args.category),
+        priority: normalizeArray(args.priority),
+        tagIds: normalizeArray(args.tagIds),
+        sortBy: args.sortBy,
+        sortDir: args.sortDir,
+        createdBy: args.createdBy,
+        assignedTo: args.assignedTo,
+        includeSubtasks: args.includeSubtasks,
+    }, requireContext())));
+    server.registerTool("get_task", {
+        title: "Get Task",
+        description: "Get task detail including status, assignees, tags, attachments and children when returned by the API.",
+        inputSchema: { projectId: z.string(), taskId: z.string() },
+        annotations: { readOnlyHint: true, openWorldHint: true },
+    }, async (args) => json(await api.get(`projects/${args.projectId}/tasks/${args.taskId}`, undefined, requireContext())));
+    server.registerTool("summarize_my_tasks", {
+        title: "Summarize My Tasks",
+        description: "Fetch /my-tasks and return grouped counts plus the raw task list for agent-side reporting.",
+        inputSchema: {
+            ...paginationSchema,
+            ...taskFilters,
+            scope: z.enum(["me", "all"]).default("me"),
+            spaceId: z.string().optional(),
+            projectId: z.string().optional(),
+        },
+        annotations: { readOnlyHint: true, openWorldHint: true },
+    }, async (args) => {
+        const result = await api.get("my-tasks", {
+            scope: args.scope,
+            page: args.page,
+            perPage: args.perPage,
+            search: args.search,
+            statusId: normalizeArray(args.statusId),
+            category: normalizeArray(args.category),
+            priority: normalizeArray(args.priority),
+            spaceId: args.spaceId,
+            projectId: args.projectId,
+        }, requireContext());
+        return json({ summary: summarizeTasks(result.data), ...result });
+    });
+    server.registerTool("summarize_project_progress", {
+        title: "Summarize Project Progress",
+        description: "Summarize status/category/priority/overdue distribution for a project by reading all tasks up to perPage.",
+        inputSchema: {
+            projectId: z.string(),
+            perPage: z.number().int().positive().max(500).default(200),
+        },
+        annotations: { readOnlyHint: true, openWorldHint: true },
+    }, async (args) => {
+        const result = await api.get(`projects/${args.projectId}/tasks`, { page: 1, perPage: args.perPage, includeSubtasks: true }, requireContext());
+        return json({ summary: summarizeTasks(result.data), ...result });
+    });
+    server.registerTool("create_task", {
+        title: "Create Task",
+        description: "Create a task. Uses dryRun by default; set dryRun=false to write. createdBy defaults to the active auth userId.",
+        inputSchema: {
+            ...dryRunSchema,
+            projectId: z.string(),
+            title: z.string().min(1),
+            description: z.string().optional(),
+            statusId: z.string().optional(),
+            priority: prioritySchema.default("Normal"),
+            startDate: z.string().optional(),
+            dueDate: z.string().optional(),
+            parentId: z.string().optional(),
+            createdBy: z.string().min(1).optional(),
+            assigneeIds: z
+                .array(z.number().int().positive())
+                .optional()
+                .describe("ProjectMember.id values."),
+        },
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+            openWorldHint: true,
+        },
+    }, async (args) => {
+        const context = requireContext();
+        const body = taskCreateBody({
+            ...args,
+            createdBy: args.createdBy ?? context.userId,
+        });
+        if (args.dryRun ?? true)
+            return json({
+                dryRun: true,
+                method: "POST",
+                path: `projects/${args.projectId}/tasks`,
+                body,
+            });
+        return json(await api.post(`projects/${args.projectId}/tasks`, body, undefined, context));
+    });
+    server.registerTool("bulk_create_tasks", {
+        title: "Bulk Create Tasks",
+        description: "Create many tasks sequentially with dry-run by default. Stops on first API error. Supports idempotency by prechecking existing title in project.",
+        inputSchema: {
+            ...dryRunSchema,
+            projectId: z.string(),
+            idempotency: z.enum(["none", "title"]).default("title"),
+            tasks: z.array(z.object({
+                title: z.string().min(1),
+                description: z.string().optional(),
+                statusId: z.string().optional(),
+                priority: prioritySchema.default("Normal"),
+                startDate: z.string().optional(),
+                dueDate: z.string().optional(),
+                parentId: z.string().optional(),
+                createdBy: z.string().min(1).optional(),
+                assigneeIds: z.array(z.number().int().positive()).optional(),
+            })),
+        },
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
+    }, async (args) => {
+        if (args.tasks.length > maxBulkSize)
+            throw new Error(`Bulk limit exceeded: ${args.tasks.length}/${maxBulkSize}`);
+        const context = requireContext();
+        const bodies = args.tasks.map((task) => taskCreateBody({
+            ...task,
+            projectId: args.projectId,
+            createdBy: task.createdBy ?? context.userId,
+        }));
+        if (args.dryRun ?? true)
+            return json({
+                dryRun: true,
+                count: bodies.length,
+                method: "POST",
+                path: `projects/${args.projectId}/tasks`,
+                bodies,
+            });
+        const created = [];
+        const skipped = [];
+        for (const body of bodies) {
+            if ((args.idempotency ?? "title") === "title") {
+                const existing = await api.get(`projects/${args.projectId}/tasks`, { search: body.title, includeSubtasks: true, perPage: 100 }, context);
+                const match = existing.data.find((task) => task.title.trim().toLowerCase() ===
+                    body.title.trim().toLowerCase());
+                if (match) {
+                    skipped.push({ reason: "title_exists", task: match });
+                    continue;
+                }
+            }
+            created.push(await api.post(`projects/${args.projectId}/tasks`, body, undefined, context));
+        }
+        return json({
+            createdCount: created.length,
+            skippedCount: skipped.length,
+            created,
+            skipped,
+        });
+    });
+    server.registerTool("update_task", {
+        title: "Update Task",
+        description: "Update mutable task fields. Uses dryRun by default.",
+        inputSchema: {
+            ...dryRunSchema,
+            projectId: z.string(),
+            taskId: z.string(),
+            title: z.string().min(1).optional(),
+            description: z.string().nullable().optional(),
+            statusId: z.string().optional(),
+            priority: prioritySchema.optional(),
+            startDate: z.string().nullable().optional(),
+            dueDate: z.string().nullable().optional(),
+            parentId: z.string().nullable().optional(),
+        },
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
+    }, async (args) => {
+        const context = requireContext();
+        const body = stripUndefined({
+            title: args.title,
+            description: args.description,
+            statusId: args.statusId,
+            priority: args.priority,
+            startDate: args.startDate,
+            dueDate: args.dueDate,
+            parentId: args.parentId,
+        });
+        if (args.dryRun ?? true)
+            return json({
+                dryRun: true,
+                method: "PUT",
+                path: `projects/${args.projectId}/tasks/${args.taskId}`,
+                body,
+            });
+        return json(await api.put(`projects/${args.projectId}/tasks/${args.taskId}`, body, undefined, context));
+    });
+    server.registerTool("change_task_status", {
+        title: "Change Task Status",
+        description: "Convenience wrapper to update only statusId.",
+        inputSchema: {
+            ...dryRunSchema,
+            projectId: z.string(),
+            taskId: z.string(),
+            statusId: z.string(),
+        },
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
+    }, async (args) => {
+        const context = requireContext();
+        const body = { statusId: args.statusId };
+        if (args.dryRun ?? true)
+            return json({
+                dryRun: true,
+                method: "PUT",
+                path: `projects/${args.projectId}/tasks/${args.taskId}`,
+                body,
+            });
+        return json(await api.put(`projects/${args.projectId}/tasks/${args.taskId}`, body, undefined, context));
+    });
+    server.registerTool("assign_task", {
+        title: "Assign Task",
+        description: "Batch assign project members to a task. projectMemberIds are numeric ProjectMember.id values.",
+        inputSchema: {
+            ...dryRunSchema,
+            taskId: z.string(),
+            projectMemberIds: z.array(z.number().int().positive()).min(1),
+            assignedBy: z.string().min(1).optional(),
+        },
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
+    }, async (args) => {
+        const context = requireContext();
+        const body = {
+            projectMemberIds: args.projectMemberIds,
+            assignedBy: args.assignedBy ?? context.userId,
+        };
+        if (args.dryRun ?? true)
+            return json({
+                dryRun: true,
+                method: "POST",
+                path: `tasks/${args.taskId}/assignees/batch-assign`,
+                body,
+            });
+        return json(await api.post(`tasks/${args.taskId}/assignees/batch-assign`, body, undefined, context));
+    });
+    server.registerTool("unassign_task", {
+        title: "Unassign Task",
+        description: "Remove one project member assignee from a task. projectMemberId is the numeric ProjectMember.id value, not userId.",
+        inputSchema: {
+            ...dryRunSchema,
+            taskId: z.string(),
+            projectMemberId: z.number().int().positive(),
+        },
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: true,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
+    }, async (args) => {
+        const context = requireContext();
+        const body = { projectMemberId: args.projectMemberId };
+        if (args.dryRun ?? true)
+            return json({
+                dryRun: true,
+                method: "DELETE",
+                path: `tasks/${args.taskId}/assignees`,
+                body,
+            });
+        return json(await api.delete(`tasks/${args.taskId}/assignees`, body, undefined, context));
+    });
+    server.registerTool("replace_task_assignees", {
+        title: "Replace Task Assignees",
+        description: "Replace a task's assignee set so only the provided projectMemberIds remain. Adds missing members and removes extra members.",
+        inputSchema: {
+            ...dryRunSchema,
+            projectId: z.string(),
+            taskId: z.string(),
+            projectMemberIds: z.array(z.number().int().positive()),
+            assignedBy: z.string().min(1).optional(),
+        },
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: true,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
+    }, async (args) => {
+        const context = requireContext();
+        const before = await api.get(`projects/${args.projectId}/tasks/${args.taskId}`, undefined, context);
+        const currentProjectMemberIds = Array.from(new Set((before.data.taskAssignees ?? []).map((assignee) => assignee.projectMemberId)));
+        const targetProjectMemberIds = Array.from(new Set(args.projectMemberIds));
+        const currentSet = new Set(currentProjectMemberIds);
+        const targetSet = new Set(targetProjectMemberIds);
+        const addedProjectMemberIds = targetProjectMemberIds.filter((projectMemberId) => !currentSet.has(projectMemberId));
+        const removedProjectMemberIds = currentProjectMemberIds.filter((projectMemberId) => !targetSet.has(projectMemberId));
+        if (args.dryRun ?? true) {
+            return json({
+                dryRun: true,
+                currentProjectMemberIds,
+                targetProjectMemberIds,
+                addedProjectMemberIds,
+                removedProjectMemberIds,
+                operations: [
+                    ...(addedProjectMemberIds.length > 0
+                        ? [
+                            {
+                                method: "POST",
+                                path: `tasks/${args.taskId}/assignees/batch-assign`,
+                                body: {
+                                    projectMemberIds: addedProjectMemberIds,
+                                    assignedBy: args.assignedBy ?? context.userId,
+                                },
+                            },
+                        ]
+                        : []),
+                    ...removedProjectMemberIds.map((projectMemberId) => ({
+                        method: "DELETE",
+                        path: `tasks/${args.taskId}/assignees`,
+                        body: { projectMemberId },
+                    })),
+                ],
+            });
+        }
+        if (addedProjectMemberIds.length > 0) {
+            await api.post(`tasks/${args.taskId}/assignees/batch-assign`, {
+                projectMemberIds: addedProjectMemberIds,
+                assignedBy: args.assignedBy ?? context.userId,
+            }, undefined, context);
+        }
+        for (const projectMemberId of removedProjectMemberIds) {
+            await api.delete(`tasks/${args.taskId}/assignees`, { projectMemberId }, undefined, context);
+        }
+        const after = await api.get(`projects/${args.projectId}/tasks/${args.taskId}`, undefined, context);
+        return json({
+            currentProjectMemberIds,
+            targetProjectMemberIds,
+            addedProjectMemberIds,
+            removedProjectMemberIds,
+            finalAssigneeProjectMemberIds: (after.data.taskAssignees ?? []).map((assignee) => assignee.projectMemberId),
+            task: after.data,
+        });
+    });
+    server.registerTool("monitor_overdue_tasks", {
+        title: "Monitor Overdue Tasks",
+        description: "Find non-complete tasks with dueDate before now from /my-tasks. Use scope=all if permitted by user permission.",
+        inputSchema: {
+            scope: z.enum(["me", "all"]).default("me"),
+            projectId: z.string().optional(),
+            spaceId: z.string().optional(),
+            perPage: z.number().int().positive().max(500).default(200),
+        },
+        annotations: { readOnlyHint: true, openWorldHint: true },
+    }, async (args) => {
+        const result = await api.get("my-tasks", {
+            scope: args.scope,
+            projectId: args.projectId,
+            spaceId: args.spaceId,
+            perPage: args.perPage,
+        }, requireContext());
+        const now = Date.now();
+        const overdue = result.data.filter((task) => task.dueDate &&
+            new Date(task.dueDate).getTime() < now &&
+            !isComplete(task));
+        return json({ count: overdue.length, tasks: overdue });
+    });
+    server.registerTool("monitor_stale_tasks", {
+        title: "Monitor Stale Tasks",
+        description: "Find non-complete tasks not updated for N days from /my-tasks.",
+        inputSchema: {
+            scope: z.enum(["me", "all"]).default("me"),
+            days: z.number().int().positive().default(7),
+            projectId: z.string().optional(),
+            spaceId: z.string().optional(),
+            perPage: z.number().int().positive().max(500).default(200),
+        },
+        annotations: { readOnlyHint: true, openWorldHint: true },
+    }, async (args) => {
+        const result = await api.get("my-tasks", {
+            scope: args.scope,
+            projectId: args.projectId,
+            spaceId: args.spaceId,
+            perPage: args.perPage,
+        }, requireContext());
+        const cutoff = Date.now() - (args.days ?? 7) * 24 * 60 * 60 * 1000;
+        const stale = result.data.filter((task) => task.updatedAt &&
+            new Date(task.updatedAt).getTime() < cutoff &&
+            !isComplete(task));
+        return json({ count: stale.length, tasks: stale });
+    });
+    server.registerTool("workload_by_user", {
+        title: "Workload By User",
+        description: "Group tasks by assignee from /my-tasks scope=all/me.",
+        inputSchema: {
+            scope: z.enum(["me", "all"]).default("all"),
+            projectId: z.string().optional(),
+            spaceId: z.string().optional(),
+            perPage: z.number().int().positive().max(500).default(200),
+        },
+        annotations: { readOnlyHint: true, openWorldHint: true },
+    }, async (args) => {
+        const result = await api.get("my-tasks", {
+            scope: args.scope,
+            projectId: args.projectId,
+            spaceId: args.spaceId,
+            perPage: args.perPage,
+        }, requireContext());
+        return json({ workload: workloadByUser(result.data), meta: result.meta });
+    });
+    server.registerTool("generate_work_report", {
+        title: "Generate Work Report",
+        description: "Generate a compact JSON work report from /my-tasks for daily/weekly reporting.",
+        inputSchema: {
+            scope: z.enum(["me", "all"]).default("me"),
+            projectId: z.string().optional(),
+            spaceId: z.string().optional(),
+            perPage: z.number().int().positive().max(500).default(200),
+        },
+        annotations: { readOnlyHint: true, openWorldHint: true },
+    }, async (args) => {
+        const result = await api.get("my-tasks", {
+            scope: args.scope,
+            projectId: args.projectId,
+            spaceId: args.spaceId,
+            perPage: args.perPage,
+        }, requireContext());
+        return json({
+            generatedAt: new Date().toISOString(),
+            summary: summarizeTasks(result.data),
+            workload: workloadByUser(result.data),
+            tasks: result.data,
+            meta: result.meta,
+        });
+    });
+}
+function taskCreateBody(args) {
+    return stripUndefined({
+        title: args.title,
+        description: args.description,
+        statusId: args.statusId,
+        priority: args.priority,
+        startDate: args.startDate,
+        dueDate: args.dueDate,
+        projectId: args.projectId,
+        parentId: args.parentId,
+        createdBy: args.createdBy,
+        assigneeIds: args.assigneeIds,
+    });
+}
+function stripUndefined(obj) {
+    return Object.fromEntries(Object.entries(obj).filter(([, value]) => value !== undefined));
+}
+function summarizeTasks(tasks) {
+    const summary = {
+        total: tasks.length,
+        byCategory: { ToDo: 0, InProgress: 0, Complete: 0 },
+        byPriority: { Low: 0, Normal: 0, High: 0, Urgent: 0 },
+        overdue: 0,
+        unassigned: 0,
+    };
+    const now = Date.now();
+    for (const task of tasks) {
+        const category = task.statusRef?.category ?? "ToDo";
+        summary.byCategory[category] += 1;
+        summary.byPriority[task.priority] += 1;
+        if (task.dueDate &&
+            new Date(task.dueDate).getTime() < now &&
+            !isComplete(task))
+            summary.overdue += 1;
+        if (!task.taskAssignees?.length)
+            summary.unassigned += 1;
+    }
+    return summary;
+}
+function workloadByUser(tasks) {
+    const map = new Map();
+    const now = Date.now();
+    for (const task of tasks) {
+        const assignees = task.taskAssignees?.length
+            ? task.taskAssignees
+            : [
+                {
+                    id: 0,
+                    taskId: task.id,
+                    projectMemberId: 0,
+                    projectMember: {
+                        id: 0,
+                        projectId: task.projectId,
+                        userId: "unassigned",
+                        employeeName: "Unassigned",
+                    },
+                },
+            ];
+        for (const assignee of assignees) {
+            const userId = assignee.projectMember?.userId ??
+                `projectMember:${assignee.projectMemberId}`;
+            const current = map.get(userId) ?? {
+                userId,
+                name: assignee.projectMember?.employeeName,
+                total: 0,
+                complete: 0,
+                overdue: 0,
+                urgent: 0,
+                tasks: [],
+            };
+            current.total += 1;
+            if (task.statusRef?.category === "Complete")
+                current.complete += 1;
+            if (task.dueDate &&
+                new Date(task.dueDate).getTime() < now &&
+                !isComplete(task))
+                current.overdue += 1;
+            if (task.priority === "Urgent")
+                current.urgent += 1;
+            current.tasks.push(task);
+            map.set(userId, current);
+        }
+    }
+    return [...map.values()].sort((a, b) => b.total - a.total);
+}
+function isComplete(task) {
+    return task.statusRef?.category === "Complete";
+}
+//# sourceMappingURL=tools.js.map