From 0ed52b2fb5c1a48c71b4644f31d5cbc63d761f92 Mon Sep 17 00:00:00 2001 From: Benjamin Mestrallet Date: Sat, 14 Nov 2026 22:54:50 +0100 Subject: [PATCH 1/2] fix: list_project_activity_since lists at most 20 tasks, with has_more EXO-94377 The tool paged through every task of the project and returned each one with its change log and comments of the period, so one answer for a large project reached about a megabyte. It now returns at most 20 tasks in all: the ones updated in the period, the most recently active first, then as many older uncompleted ones as there is room for. has_more says that the project holds more such tasks; uncompleted_count gives its uncompleted tasks. Only the tasks returned are read in full. The period still starts at midnight of the user's day, in the user's zone. The description changes, so the upgrades file lists the tool's one earlier definition, the only one any ref ever shipped. Co-Authored-By: Claude Opus 5.5 --- .../java/io/meeds/task/mcp/TaskMcpTool.java | 100 +++++++---- .../task/mcp/model/ProjectActivityModel.java | 8 + .../ai-tool-definition-upgrades.json | 6 + .../main/resources/ai-tool-definitions.json | 2 +- .../io/meeds/task/mcp/TaskMcpToolTest.java | 169 ++++++++++++++++++ .../mcp/TaskToolDefinitionUpgradesTest.java | 19 +- 6 files changed, 268 insertions(+), 36 deletions(-) diff --git a/services/src/main/java/io/meeds/task/mcp/TaskMcpTool.java b/services/src/main/java/io/meeds/task/mcp/TaskMcpTool.java index d0021b68f2..6ad4a73d49 100644 --- a/services/src/main/java/io/meeds/task/mcp/TaskMcpTool.java +++ b/services/src/main/java/io/meeds/task/mcp/TaskMcpTool.java @@ -165,6 +165,15 @@ public class TaskMcpTool implements McpToolPlugin { private static final int MAX_TO_LOAD = 100; + /** + * The most tasks list_project_activity_since returns, both lists together: + * each one carries its change log and comments of the period. + */ + private static final int MAX_ACTIVITY_TASKS = 20; + + /** The page size list_project_activity_since reads the tasks by. */ + private static final int ACTIVITY_PAGE_SIZE = 10; + private static final String MSG_TASK_NOT_EDITABLE = "Task with identifier '%s' is not editable for user '%s'"; @@ -1742,10 +1751,19 @@ private TaskDto getAccessibleTask(long taskId) throws ObjectNotFoundException, I * number of days ago, in the user's time zone, the server's when they have * none: the day's first instant when a daylight-saving switch skips its * midnight. A task updated at that very instant is in the period. + *

+ * At most {@value #MAX_ACTIVITY_TASKS} tasks in all, each with its change + * log and comments of the period: the updated ones first, the most recently + * active first, then as many other uncompleted ones as there is room for. + * The tasks are read in their last-activity order, in which the updated ones + * come first, and only the tasks returned are read in full. The answer says + * whether more tasks exist than it holds, and how many uncompleted tasks the + * project has. * * @param projectId the project, or null for every project the user sees * @param days the number of days to look back - * @return the tasks updated in the period, then the other uncompleted ones + * @return the tasks updated in the period, then the other uncompleted ones, + * whether more exist and the count of uncompleted tasks * @throws IllegalAccessException when the user can't view the project * @throws ObjectNotFoundException when the project doesn't exist */ @@ -1753,47 +1771,67 @@ public ProjectActivityModel listProjectActivitySince(Long projectId, Integer day ObjectNotFoundException { long count = countTaskModels(projectId, false); if (count == 0) { - return new ProjectActivityModel(Collections.emptyList(), Collections.emptyList()); + return new ProjectActivityModel(Collections.emptyList(), Collections.emptyList(), false, 0L); } else { - List updatedTasks = new ArrayList<>(); - List uncompletedTasks = new ArrayList<>(); ZoneId zone = getCurrentUserZone(); LocalDate today = getToday(zone); // the period starts at midnight of the user's day, in the user's zone Instant sinceInstant = today.minusDays(days).atStartOfDay(zone).toInstant(); + // the updated tasks come first in the last-activity order: stop at the + // first page they don't fill, or once one more than the cap is found + List updatedTasks = new ArrayList<>(); + boolean hasMore = false; int offset = 0; - int limit = 10; + int updatedInPage; do { - List taskModels = getTasks(projectId, offset, limit, false).stream() - .filter(t -> !Instant.ofEpochMilli(getLastUpdateDate(t).getTime()) - .isBefore(sinceInstant)) - .map(t -> toTaskWithChangeLogModel(t, - sinceInstant, - zone, - today)) - .toList(); - updatedTasks.addAll(taskModels); - if (taskModels.size() < limit) { - break; - } else { - offset += limit; + updatedInPage = 0; + for (TaskDto task : getTasks(projectId, offset, ACTIVITY_PAGE_SIZE, false)) { + if (!Instant.ofEpochMilli(getLastUpdateDate(task).getTime()).isBefore(sinceInstant)) { + updatedInPage++; + if (updatedTasks.size() < MAX_ACTIVITY_TASKS) { + updatedTasks.add(task); + } else { + hasMore = true; + break; + } + } } - } while (offset < count); - - count = countTaskModels(projectId, false); + offset += ACTIVITY_PAGE_SIZE; + } while (!hasMore && updatedInPage == ACTIVITY_PAGE_SIZE && offset < count); + + // then the other uncompleted tasks, as many as there is room for, and + // one more to tell whether more exist + long uncompletedCount = countTaskModels(projectId, true); + int room = MAX_ACTIVITY_TASKS - updatedTasks.size(); + List uncompletedTasks = new ArrayList<>(); offset = 0; - limit = 10; - do { - getTasks(projectId, offset, limit, true).stream() - .filter(t -> Instant.ofEpochMilli(getLastUpdateDate(t).getTime()) - .isBefore(sinceInstant)) - .map(t -> toTaskWithChangeLogModel(t, sinceInstant, zone, today)) - .forEach(uncompletedTasks::add); - offset += limit; - } while (offset < count); - return new ProjectActivityModel(updatedTasks, uncompletedTasks); + while (!hasMore && offset < uncompletedCount) { + List page = getTasks(projectId, offset, ACTIVITY_PAGE_SIZE, true); + for (TaskDto task : page) { + if (Instant.ofEpochMilli(getLastUpdateDate(task).getTime()).isBefore(sinceInstant)) { + if (uncompletedTasks.size() < room) { + uncompletedTasks.add(task); + } else { + hasMore = true; + break; + } + } + } + if (page.size() < ACTIVITY_PAGE_SIZE) { + break; + } + offset += ACTIVITY_PAGE_SIZE; + } + return new ProjectActivityModel(updatedTasks.stream() + .map(t -> toTaskWithChangeLogModel(t, sinceInstant, zone, today)) + .toList(), + uncompletedTasks.stream() + .map(t -> toTaskWithChangeLogModel(t, sinceInstant, zone, today)) + .toList(), + hasMore, + uncompletedCount); } } diff --git a/services/src/main/java/io/meeds/task/mcp/model/ProjectActivityModel.java b/services/src/main/java/io/meeds/task/mcp/model/ProjectActivityModel.java index 9c2c61539b..77ebbdacdd 100644 --- a/services/src/main/java/io/meeds/task/mcp/model/ProjectActivityModel.java +++ b/services/src/main/java/io/meeds/task/mcp/model/ProjectActivityModel.java @@ -37,4 +37,12 @@ public class ProjectActivityModel { @JsonProperty("other_uncompleted_tasks") private List otherUncompletedTasks; + /** Whether the project has more such tasks than the answer holds. */ + @JsonProperty("has_more") + private boolean hasMore; + + /** The project's uncompleted tasks, whatever their last activity. */ + @JsonProperty("uncompleted_count") + private long uncompletedCount; + } diff --git a/services/src/main/resources/ai-tool-definition-upgrades.json b/services/src/main/resources/ai-tool-definition-upgrades.json index 3fb17900d0..6530702a52 100644 --- a/services/src/main/resources/ai-tool-definition-upgrades.json +++ b/services/src/main/resources/ai-tool-definition-upgrades.json @@ -1,5 +1,11 @@ { "tools": [ + { + "name": "list_project_activity_since", + "replaced_definitions": [ + "0648b6b3cc88c4567304a1730b8a9ac39b7f69a62acddd8c2aa2235831c15b04" + ] + }, { "name": "list_assigned_tasks", "replaced_definitions": [ diff --git a/services/src/main/resources/ai-tool-definitions.json b/services/src/main/resources/ai-tool-definitions.json index 13dc4014e3..743ea04015 100644 --- a/services/src/main/resources/ai-tool-definitions.json +++ b/services/src/main/resources/ai-tool-definitions.json @@ -178,7 +178,7 @@ { "name": "list_project_activity_since", "title": "Get Project Activity since last days", - "description": "Retrieve a project activity since a designated date and list all other uncompleted tasks.", + "description": "Lists a project's tasks updated in the last days, the most recently active first, each with its changes and comments of the period, then its other uncompleted tasks: at most 20 tasks in all. The period starts at midnight of the user's day, that number of days ago. has_more is true when the project has more such tasks than shown: to list every uncompleted task of the project, page list_tasks with project_id and hide_completed_tasks true. uncompleted_count is the count of the project's uncompleted tasks.", "input_schema": { "type": "object", "properties": { diff --git a/services/src/test/java/io/meeds/task/mcp/TaskMcpToolTest.java b/services/src/test/java/io/meeds/task/mcp/TaskMcpToolTest.java index 6d7bd03264..0201c4c33e 100644 --- a/services/src/test/java/io/meeds/task/mcp/TaskMcpToolTest.java +++ b/services/src/test/java/io/meeds/task/mcp/TaskMcpToolTest.java @@ -59,6 +59,7 @@ import java.util.ResourceBundle; import java.util.Set; import java.util.TimeZone; +import java.util.stream.LongStream; import org.junit.Before; import org.junit.Test; @@ -1981,6 +1982,8 @@ public void listProjectActivitySinceWhenNoTasksShouldReturnEmptyLists() throws E assertEquals(0, result.getLastUpdatedTasks().size()); assertEquals(0, result.getOtherUncompletedTasks().size()); + assertFalse(result.isHasMore()); + assertEquals(0, result.getUncompletedCount()); } @Test @@ -3458,6 +3461,172 @@ protected LocalDate getToday(ZoneId zone) { assertEquals(Set.of("editTitle", "commented"), Set.copyOf(actions)); } + /** + * list_project_activity_since returns at most 20 tasks: of 25 updated in the + * period, the 20 most recently active, no older one, and has_more; only + * those 20 are read in full. Mutants: the cap at 21; the tasks read in full + * before the cap. + */ + @Test + public void listProjectActivitySinceListsAtMostTwentyUpdatedTasks() throws Exception { // NOSONAR + mockProjectActivity(25, 0, 0); + + ProjectActivityModel result = runWithDateFormatMockResult(() -> tool.listProjectActivitySince(null, 7)); + + assertEquals(LongStream.range(100, 120).boxed().toList(), + result.getLastUpdatedTasks().stream().map(TaskWithChangeLogModel::getId).toList()); + assertEquals(List.of(), result.getOtherUncompletedTasks()); + assertTrue(result.isHasMore()); + verify(commentService, times(20)).countComments(anyLong()); + } + + /** + * Below the cap, the older uncompleted tasks fill the room the updated ones + * leave, the most recently active first, never a completed one: 15 + * updated and 10 older give 15 and 5, and has_more. The read of all tasks + * stops at the first page the updated ones don't fill. Mutants: the older + * tasks past the room; the completed tasks read among the older ones; the + * read of all tasks past that page. + */ + @Test + public void listProjectActivitySinceFillsTheRestWithOlderUncompletedTasks() throws Exception { // NOSONAR + mockProjectActivity(15, 10, 3); + + ProjectActivityModel result = runWithDateFormatMockResult(() -> tool.listProjectActivitySince(null, 7)); + + assertEquals(15, result.getLastUpdatedTasks().size()); + assertEquals(LongStream.range(200, 205).boxed().toList(), + result.getOtherUncompletedTasks().stream().map(TaskWithChangeLogModel::getId).toList()); + assertTrue(result.isHasMore()); + verify(taskService, times(2)).findLastUpdatedTasks(argThat(query -> !isUncompletedOnly(query)), anyInt(), anyInt()); + } + + /** + * A project of exactly 20 such tasks fits: 15 updated and 5 older are all + * returned, without has_more, whatever completed tasks the project holds. + * Mutants: has_more set at the cap rather than past it; the completed tasks + * read among the older ones. + */ + @Test + public void listProjectActivitySinceHasNoMoreWhenTheTasksFitTheCap() throws Exception { // NOSONAR + mockProjectActivity(15, 5, 3); + + ProjectActivityModel result = runWithDateFormatMockResult(() -> tool.listProjectActivitySince(null, 7)); + + assertEquals(15, result.getLastUpdatedTasks().size()); + assertEquals(LongStream.range(200, 205).boxed().toList(), + result.getOtherUncompletedTasks().stream().map(TaskWithChangeLogModel::getId).toList()); + assertFalse(result.isHasMore()); + } + + /** + * Twenty updated tasks fill the cap: one older uncompleted task left out + * sets has_more, which none does not. Mutant: the older tasks not read once + * the updated ones fill the cap. + */ + @Test + public void listProjectActivitySinceHasMoreWhenAnOlderTaskIsLeftOut() throws Exception { // NOSONAR + mockProjectActivity(20, 1, 0); + + ProjectActivityModel result = runWithDateFormatMockResult(() -> tool.listProjectActivitySince(null, 7)); + + assertEquals(20, result.getLastUpdatedTasks().size()); + assertEquals(List.of(), result.getOtherUncompletedTasks()); + assertTrue(result.isHasMore()); + } + + /** + * Twenty updated tasks and no older one: all are returned, without + * has_more. + */ + @Test + public void listProjectActivitySinceHasNoMoreWhenTwentyUpdatedTasksAreAll() throws Exception { // NOSONAR + mockProjectActivity(20, 0, 0); + + ProjectActivityModel result = runWithDateFormatMockResult(() -> tool.listProjectActivitySince(null, 7)); + + assertEquals(20, result.getLastUpdatedTasks().size()); + assertFalse(result.isHasMore()); + } + + /** + * uncompleted_count is the count of the project's uncompleted tasks, not of + * all its tasks. Mutant: the count of all tasks. + */ + @Test + public void listProjectActivitySinceCountsTheUncompletedTasks() throws Exception { // NOSONAR + mockProjectActivity(3, 2, 4); + + ProjectActivityModel result = runWithDateFormatMockResult(() -> tool.listProjectActivitySince(null, 7)); + + assertEquals(5, result.getUncompletedCount()); + assertFalse(result.isHasMore()); + } + + /** + * Stubs a project for list_project_activity_since: uncompleted tasks updated + * yesterday (ids from 100), then completed ones updated 20 days ago (ids + * from 300) and uncompleted ones updated 30 days ago (ids from 200), in the + * last-activity order. The read of all tasks pages through every one, the + * read of the uncompleted ones leaves the completed out, and each count + * counts what its read pages through. + * + * @param updated the uncompleted tasks updated in the period + * @param older the uncompleted tasks updated before it + * @param completed the completed tasks updated before it + */ + @SneakyThrows + private void mockProjectActivity(int updated, int older, int completed) { + List uncompletedTasks = new ArrayList<>(); + List allTasks = new ArrayList<>(); + Date yesterday = Date.from(TODAY.minusDays(1).atTime(12, 0).atZone(USER_ZONE).toInstant()); + Date twentyDaysAgo = Date.from(TODAY.minusDays(20).atTime(12, 0).atZone(USER_ZONE).toInstant()); + Date monthAgo = Date.from(TODAY.minusDays(30).atTime(12, 0).atZone(USER_ZONE).toInstant()); + for (int i = 0; i < updated; i++) { + uncompletedTasks.add(mockTaskWithProject(100L + i, yesterday)); + } + allTasks.addAll(uncompletedTasks); + for (int i = 0; i < completed; i++) { + allTasks.add(mockTaskWithProject(300L + i, twentyDaysAgo)); + } + for (int i = 0; i < older; i++) { + TaskDto task = mockTaskWithProject(200L + i, monthAgo); + uncompletedTasks.add(task); + allTasks.add(task); + } + when(taskService.countTasks(any())).thenAnswer(invocation -> isUncompletedOnly(invocation.getArgument(0)) ? uncompletedTasks.size() + : allTasks.size()); + when(taskService.findLastUpdatedTasks(any(), anyInt(), anyInt())).thenAnswer(invocation -> { + List tasks = isUncompletedOnly(invocation.getArgument(0)) ? uncompletedTasks : allTasks; + int offset = invocation.getArgument(1); + int limit = invocation.getArgument(2); + return tasks.subList(Math.min(offset, tasks.size()), Math.min(offset + limit, tasks.size())); + }); + when(taskService.getTaskLogs(anyLong(), anyInt(), anyInt())).thenReturn(Collections.emptyList()); + when(commentService.getLastComment(anyLong())).thenReturn(null); + when(commentService.countComments(anyLong())).thenReturn(0); + } + + /** + * @param query a task query + * @return true when it leaves the completed tasks out + */ + private static boolean isUncompletedOnly(TaskQuery query) { + return query != null && restrictsField(query.getCondition(), "completed"); + } + + /** + * @param condition a query condition, null for none + * @param field a task field + * @return true when it, or one of its conditions, is on that field + */ + private static boolean restrictsField(Condition condition, String field) { + if (condition instanceof AggregateCondition aggregate) { + return aggregate.getConditions().stream().anyMatch(c -> restrictsField(c, field)); + } + return condition instanceof SingleCondition single && field.equals(single.getField()); + } + /** * @param createdTime when the comment was posted * @return a comment of another user, posted then, with no reply diff --git a/services/src/test/java/io/meeds/task/mcp/TaskToolDefinitionUpgradesTest.java b/services/src/test/java/io/meeds/task/mcp/TaskToolDefinitionUpgradesTest.java index 66097b2b1d..acc7211f66 100644 --- a/services/src/test/java/io/meeds/task/mcp/TaskToolDefinitionUpgradesTest.java +++ b/services/src/test/java/io/meeds/task/mcp/TaskToolDefinitionUpgradesTest.java @@ -58,7 +58,9 @@ public class TaskToolDefinitionUpgradesTest { "list_assigned_tasks", 15, "list_projects", - 5); + 5, + "list_project_activity_since", + 1); /** * The definitions feature/rtd shipped before EXO-94250, which the @@ -96,10 +98,18 @@ public class TaskToolDefinitionUpgradesTest { Map.of("list_assigned_tasks", "b184d4331d207cc11557d2a50596ca5a9f1ee9e178a8ad29a257188bcd309c63"); + /** + * The definition every line shipped before list_project_activity_since was + * capped (EXO-94377), the only one it ever had. + */ + private static final Map DEFINITIONS_BEFORE_94377 = + Map.of("list_project_activity_since", + "0648b6b3cc88c4567304a1730b8a9ac39b7f69a62acddd8c2aa2235831c15b04"); + /** * Each changed tool lists every earlier definition, those shipped before - * EXO-94250, before EXO-94284, before managed_only and before the relation - * included, and not its + * EXO-94250, before EXO-94284, before managed_only, before the relation and + * before EXO-94377 included, and not its * shipped one, which an instance already holding it keeps anyway. Mutants: * a digest removed, the shipped digest added, a tool's entry dropped. * @@ -118,7 +128,8 @@ public void eachChangedToolListsItsEarlierDefinitionsOnly() throws Exception { / for (Map pinned : List.of(DEFINITIONS_BEFORE_94250, DEFINITIONS_BEFORE_94284, DEFINITIONS_BEFORE_MANAGED_ONLY, - DEFINITIONS_BEFORE_RELATION)) { + DEFINITIONS_BEFORE_RELATION, + DEFINITIONS_BEFORE_94377)) { if (pinned.containsKey(name)) { assertTrue(name, digests.contains(pinned.get(name))); } From 739444dfa4823a18eb2a472a570b539be0a2db76 Mon Sep 17 00:00:00 2001 From: Benjamin Mestrallet Date: Sun, 15 Nov 2026 12:33:10 +0100 Subject: [PATCH 2/2] feat: The grouped list_tasks answer adds open boards, unlisted boards, personal tasks and a summary EXO-94360 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - group_by_project also returns open_project_count (the boards holding open tasks the user can access), projects_not_listed (the boards past the list's cap), personal_count (the selected tasks on no board) and summary, one sentence naming the filters the call applied, such as « 260 overdue open tasks in 29 of 86 boards ». It says « open », and counts the boards « of » the open boards, only when the listing selects open tasks only: overdue_only, or hide_completed_tasks without completed_since. - The open tasks are counted once on every board the user can access: that count gives open_project_count, and the listed boards read their open_count from it, instead of a second count on the listed boards. - has_more: a grouped call with limit 1, made for the counts, returns at most one task, with has_more false and no next_offset. A grouped call reading a real page keeps has_more and next_offset, since list_tasks also serves agents and MCP clients that read the page and the counts in one call. A grouped shape without a has_more key would break those callers' paging. - The list_tasks description names the new fields, says to answer from them about the call's own filters, and states the limit-1 rule for grouped calls. Its shipped definition joins the upgrades list. Co-Authored-By: Claude Opus 5.5 --- .../java/io/meeds/task/mcp/TaskMcpTool.java | 158 +++++++++++++- .../task/mcp/model/TaskCollectionModel.java | 33 ++- .../ai-tool-definition-upgrades.json | 1 + .../main/resources/ai-tool-definitions.json | 4 +- .../io/meeds/task/mcp/TaskMcpToolTest.java | 195 ++++++++++++++++-- .../mcp/TaskToolDefinitionUpgradesTest.java | 17 +- 6 files changed, 368 insertions(+), 40 deletions(-) diff --git a/services/src/main/java/io/meeds/task/mcp/TaskMcpTool.java b/services/src/main/java/io/meeds/task/mcp/TaskMcpTool.java index 6ad4a73d49..5b992161e3 100644 --- a/services/src/main/java/io/meeds/task/mcp/TaskMcpTool.java +++ b/services/src/main/java/io/meeds/task/mcp/TaskMcpTool.java @@ -841,7 +841,11 @@ private long countAssignedTasks(TaskQuery taskQuery, String username) { * access, so that one call tells which boards hold such tasks and how many * of those open tasks they are, whatever the number of boards (EXO-94250). * A personal task, on - * no board, is listed but counted on none. + * no board, is listed but counted on none. The grouped answer also counts + * the boards holding open tasks, the boards left out of the list and the + * personal tasks, and states them in a summary naming the filters applied; + * a grouped call with a limit of 1, made for the counts, returns at most + * one task and says no next page remains (EXO-94360). *

* Each task comes as a list item, without its description or coworkers, * which {@link #getTaskById(Long)} returns; with {@code includeDescription}, @@ -935,7 +939,24 @@ public TaskCollectionModel listTasks(Long projectId, // NOSONAR the tool's param } TaskCollectionModel collection = toTaskCollection(taskModels, usedOffset, usedLimit, countTasks(taskQuery)); if (Boolean.TRUE.equals(groupByProject)) { + if (usedLimit == 1) { + // a call for the counts, its one task aside, asks no next page (EXO-94360) + collection.setHasMore(false); + collection.setNextOffset(null); + } setProjectCounts(collection, taskQuery, projectId, zone); + collection.setSummary(getGroupedSummary(collection, + new ListingFilters(Boolean.TRUE.equals(overdueOnly), + Boolean.TRUE.equals(hideCompletedTasks), + Boolean.TRUE.equals(withoutDueDate), + dueFrom, + dueTo, + priority, + assignee, + statusId, + title, + changedSince, + completedSince))); } return collection; } @@ -2401,7 +2422,9 @@ private void checkNotOverdueAndCompleted(Boolean overdueOnly, Date completedSinc * open tasks, the boards with the most selected tasks first, then by name * and identifier, so that two calls list them in the same order, at most * {@value #MAX_PROJECT_COUNTS}. The open tasks are counted with the - * listing's own accessibility, among the boards listed only (EXO-94250). + * listing's own accessibility on every board, which counts the boards that + * hold open tasks too; the boards left out of the list and the personal + * tasks, on no board, are counted (EXO-94360). * * @param collection the listing's answer, to which the counts are added * @param taskQuery the listing's query @@ -2423,23 +2446,136 @@ private void setProjectCounts(TaskCollectionModel collection, .thenComparingLong(ProjectTaskCountDto::getProjectId)) .limit(MAX_PROJECT_COUNTS) .toList(); - Map openCounts = Collections.emptyMap(); - if (!kept.isEmpty()) { - TaskQuery openQuery = getTaskQuery(projectId, true, false, zone); - openQuery.setProjectIds(kept.stream().map(ProjectTaskCountDto::getProjectId).toList()); - openCounts = taskService.countTasksByProject(openQuery) - .stream() - .collect(Collectors.toMap(ProjectTaskCountDto::getProjectId, ProjectTaskCountDto::getCount)); - } - Map open = openCounts; + // the open tasks of every board the user can access: their boards are + // counted, and the listed boards read their open count from them + Map open = taskService.countTasksByProject(getTaskQuery(projectId, true, false, zone)) + .stream() + .collect(Collectors.toMap(ProjectTaskCountDto::getProjectId, + ProjectTaskCountDto::getCount)); List projects = kept.stream() .map(count -> new ProjectTaskCountModel(count.getProjectId(), count.getProjectName(), count.getCount(), open.getOrDefault(count.getProjectId(), 0L))) .toList(); + long onBoards = counts.stream().mapToLong(ProjectTaskCountDto::getCount).sum(); collection.setProjects(projects); collection.setProjectCount(counts.size()); + collection.setOpenProjectCount(open.size()); + collection.setProjectsNotListed(counts.size() - kept.size()); + collection.setPersonalCount(Math.max(0L, collection.getCount() - onBoards)); + } + + /** + * States a grouped listing in one sentence: the count, the filters applied, + * the boards holding the tasks among the boards holding open tasks when only + * open tasks are selected, the personal tasks and the boards left out of the + * list, such as « 260 overdue open tasks in 29 of 86 boards » (EXO-94360). + * + * @param collection the grouped answer, its counts set + * @param filters the filters the listing applied + * @return the sentence + */ + static String getGroupedSummary(TaskCollectionModel collection, ListingFilters filters) { + long count = collection.getCount(); + long personal = collection.getPersonalCount() == null ? 0L : collection.getPersonalCount(); + // hide_completed_tasks keeps the completed tasks when completed_since is + // given (TaskServiceImpl#addChangeFilter): the tasks are open only without it + boolean openOnly = filters.overdueOnly() || filters.hideCompleted() && StringUtils.isBlank(filters.completedSince()); + StringBuilder summary = new StringBuilder().append(count).append(' '); + if (filters.overdueOnly()) { + summary.append("overdue open "); + } else if (openOnly) { + summary.append("open "); + } + summary.append(count == 1 ? "task" : "tasks").append(describeFilters(filters)); + int boards = collection.getProjectCount(); + StringBuilder where = new StringBuilder(" in ").append(boards); + int last = boards; + if (openOnly) { + last = collection.getOpenProjectCount(); + where.append(" of ").append(last); + } + where.append(last == 1 ? " board" : " boards"); + if (personal > 0 && personal == count) { + summary.append(", all personal, on no board"); + } else if (personal > 0) { + summary.append(": ").append(count - personal).append(where).append(", ").append(personal).append(" personal"); + } else { + summary.append(where); + } + if (collection.getProjectsNotListed() != null && collection.getProjectsNotListed() > 0) { + summary.append("; the ").append(collection.getProjects().size()).append(" boards with the most are listed"); + } + return summary.toString(); + } + + /** + * @param filters the filters a listing applied + * @return the filters other than overdue and open, each as the words that + * follow « tasks », in the order of the tool's arguments + */ + private static String describeFilters(ListingFilters filters) { + StringBuilder words = new StringBuilder(); + if (filters.priority() == Priority.NONE) { + words.append(" with no priority"); + } else if (filters.priority() != null) { + words.append(" of priority ").append(filters.priority().name().toLowerCase(Locale.ROOT)); + } + if (StringUtils.isNotBlank(filters.title())) { + words.append(" whose title contains \"").append(filters.title().trim()).append('"'); + } + if (StringUtils.isNotBlank(filters.assignee())) { + words.append(" assigned to ").append(filters.assignee().trim()); + } + if (filters.statusId() != null) { + words.append(" in status ").append(filters.statusId()); + } + if (filters.withoutDueDate()) { + words.append(" with no due date"); + } + if (StringUtils.isNotBlank(filters.dueFrom())) { + words.append(" due from ").append(filters.dueFrom().trim()); + } + if (StringUtils.isNotBlank(filters.dueTo())) { + words.append(StringUtils.isNotBlank(filters.dueFrom()) ? " to " : " due until ").append(filters.dueTo().trim()); + } + if (StringUtils.isNotBlank(filters.changedSince())) { + words.append(" changed since ").append(filters.changedSince().trim()); + } + if (StringUtils.isNotBlank(filters.completedSince())) { + words.append(" completed since ").append(filters.completedSince().trim()); + } + return words.toString(); + } + + /** + * The filters a listing applied, as its tool call gave them, for the + * summary of a grouped answer (EXO-94360). + * + * @param overdueOnly whether only the overdue tasks are listed + * @param hideCompleted whether the completed tasks are left out + * @param withoutDueDate whether only the tasks with no due date are listed + * @param dueFrom the first day or instant of the due range, blank for none + * @param dueTo the last day or instant of the due range, blank for none + * @param priority the priority, null for any + * @param assignee the username of the assignee, blank for any + * @param statusId the status, null for any + * @param title a part of the title, blank for any + * @param changedSince the change date, blank for none + * @param completedSince the completion date, blank for none + */ + record ListingFilters(boolean overdueOnly, // NOSONAR the tool's filters, each one its own + boolean hideCompleted, + boolean withoutDueDate, + String dueFrom, + String dueTo, + Priority priority, + String assignee, + Long statusId, + String title, + String changedSince, + String completedSince) { } /** diff --git a/services/src/main/java/io/meeds/task/mcp/model/TaskCollectionModel.java b/services/src/main/java/io/meeds/task/mcp/model/TaskCollectionModel.java index c834aca31a..19d0a2210f 100644 --- a/services/src/main/java/io/meeds/task/mcp/model/TaskCollectionModel.java +++ b/services/src/main/java/io/meeds/task/mcp/model/TaskCollectionModel.java @@ -90,6 +90,37 @@ public class TaskCollectionModel { @JsonInclude(Include.NON_NULL) private Long coworkerCount; + /** + * With {@code group_by_project}, the number of boards the user can access + * that hold at least one open task (EXO-94360). + */ + @JsonProperty("open_project_count") + @JsonInclude(Include.NON_NULL) + private Integer openProjectCount; + + /** + * With {@code group_by_project}, the boards holding selected tasks that + * {@code projects} leaves out, past its cap (EXO-94360). + */ + @JsonProperty("projects_not_listed") + @JsonInclude(Include.NON_NULL) + private Integer projectsNotListed; + + /** + * With {@code group_by_project}, how many of the tasks counted by + * {@code count} are personal tasks, on no board (EXO-94360). + */ + @JsonProperty("personal_count") + @JsonInclude(Include.NON_NULL) + private Long personalCount; + + /** + * With {@code group_by_project}, one sentence stating the count, the + * filters applied and the boards, built from the fields above (EXO-94360). + */ + @JsonInclude(Include.NON_NULL) + private String summary; + /** * A page of tasks, with no count per board. * @@ -101,7 +132,7 @@ public class TaskCollectionModel { * @param nextOffset the offset of the next page, null when none remains */ public TaskCollectionModel(List tasks, int usedOffset, int usedLimit, long count, boolean hasMore, Integer nextOffset) { - this(tasks, usedOffset, usedLimit, count, hasMore, nextOffset, null, null, null, null); + this(tasks, usedOffset, usedLimit, count, hasMore, nextOffset, null, null, null, null, null, null, null, null); } } diff --git a/services/src/main/resources/ai-tool-definition-upgrades.json b/services/src/main/resources/ai-tool-definition-upgrades.json index 6530702a52..b82e8a102a 100644 --- a/services/src/main/resources/ai-tool-definition-upgrades.json +++ b/services/src/main/resources/ai-tool-definition-upgrades.json @@ -34,6 +34,7 @@ "10abeb66b8198e0d58c2a6912dd9fa52206b6c2f7fe52580ad35ef6164748fd5", "145e138e197cb987638d1861ae78e2afb5657e21544a30f0a20080bf338b7988", "252681e7e18cb7d368b2b2057465564e5c407751768dccb753233f86b31214f4", + "2b53f023e39465e999c43f9d33f7ae28dc3e78340a9e53d79f9c5f8eee831642", "3762d94cb1d5a4d859a6160b4851d45b04f5167424a9c918b2ef07d93b0a78fb", "391321c06ae52b6c4f483cd44d91168bcb31ede13535969a64069eb2d7b631a8", "444ebb6dcec142ec858fdbd0328f7074d8cbeffb93ac7ea6004a3a2646097159", diff --git a/services/src/main/resources/ai-tool-definitions.json b/services/src/main/resources/ai-tool-definitions.json index 743ea04015..66cb4e4d36 100644 --- a/services/src/main/resources/ai-tool-definitions.json +++ b/services/src/main/resources/ai-tool-definitions.json @@ -144,7 +144,7 @@ { "name": "list_tasks", "title": "List Tasks", - "description": "List tasks, optionally filtered by project; without project_id, every task the user can access, personal tasks included. With overdue_only, only the open tasks past their due date, the most overdue first; an overdue task carries days_overdue. With title, only the tasks whose title contains it, ignoring case. With changed_since, only the tasks whose status, project, due date, assignee or completion changed since that date, completed tasks included unless hide_completed_tasks; an assignee change of a task created since that date is not counted. With completed_since, only the tasks completed since that date. A task listed with either carries changes: each change since that date, oldest first, with its field (status, project, due_date, assignee or completed), its old_value and new_value when the change log records them, its date and its author; to tell what moved, use them instead of comparing dates. With assignee, only the tasks assigned to that user; with status_id, only the tasks in that status. With without_due_date, only the tasks with no due date; with due_from and due_to, only those due in that range. With priority, only the tasks of that priority: for a question on priority, filter with it and answer from count and the items, never by reading pages for it. With group_by_project, projects counts board by board the tasks selected (count) beside the board's open tasks the user can access (open_count), the most first: to tell which boards have tasks with no due date, or due in a range, call it once without project_id, never once per project; in a run limited to a space, once per project of that space. Compact items (status is the board column); get_task_by_id for details. A commented task carries last_comment_date and last_comment_author, its latest comment or reply; comments_count counts the replies. count is the total. While has_more, call again with offset=next_offset. In a run limited to a space, project_id is required and must be a project of that space, as list_projects returns them; to find a task by its title, list the tasks of each of those projects with title. Elsewhere, to find a task by words of its title or description, call search_tasks instead of listing a whole project.", + "description": "List tasks, optionally filtered by project; without project_id, every task the user can access, personal tasks included. With overdue_only, only the open tasks past their due date, the most overdue first; an overdue task carries days_overdue. With title, only the tasks whose title contains it, ignoring case. With changed_since, only the tasks whose status, project, due date, assignee or completion changed since that date, completed tasks included unless hide_completed_tasks; an assignee change of a task created since that date is not counted. With completed_since, only the tasks completed since that date. A task listed with either carries changes: each change since that date, oldest first, with its field (status, project, due_date, assignee or completed), its old_value and new_value when the change log records them, its date and its author; to tell what moved, use them instead of comparing dates. With assignee, only the tasks assigned to that user; with status_id, only the tasks in that status. With without_due_date, only the tasks with no due date; with due_from and due_to, only those due in that range. With priority, only the tasks of that priority: for a question on priority, filter with it and answer from count and the items, never by reading pages for it. With group_by_project, projects counts board by board the tasks selected (count) beside the board's open tasks the user can access (open_count), the most first: to tell which boards have tasks with no due date, or due in a range, call it once without project_id, never once per project; in a run limited to a space, once per project of that space. The grouped answer also gives project_count, the boards holding the tasks selected; open_project_count, the boards holding open tasks the user can access; projects_not_listed, the boards left out of projects; personal_count, the personal tasks, on no board, among count; and summary, one sentence stating them with the filters of this call: answer from these fields about this call's filters, never reuse a summary for another question. A grouped call with limit 1 returns at most one task beside the counts, and has_more false; a grouped call with a larger limit pages as usual. Compact items (status is the board column); get_task_by_id for details. A commented task carries last_comment_date and last_comment_author, its latest comment or reply; comments_count counts the replies. count is the total. While has_more, call again with offset=next_offset. In a run limited to a space, project_id is required and must be a project of that space, as list_projects returns them; to find a task by its title, list the tasks of each of those projects with title. Elsewhere, to find a task by words of its title or description, call search_tasks instead of listing a whole project.", "input_schema": { "type": "object", "properties": { @@ -163,7 +163,7 @@ "without_due_date": { "type": "boolean", "description": "Only the tasks with no due date; not together with overdue_only, due_from or due_to." }, "due_from": { "type": "string", "description": "Only the tasks due at or after this date: a date such as 2026-11-09, from the start of that day in the user's time zone, or a date and time with its offset." }, "due_to": { "type": "string", "description": "Only the tasks due at or before this date: a date such as 2026-11-15, to the end of that day in the user's time zone, or a date and time with its offset." }, - "group_by_project": { "type": "boolean", "description": "true: also projects, the count of the tasks the filters select on each board (hide_completed_tasks included) and its open_count, the board's open tasks the user can access, and project_count." }, + "group_by_project": { "type": "boolean", "description": "true: also projects, the count of the tasks the filters select on each board (hide_completed_tasks included) and its open_count, the board's open tasks the user can access, project_count, open_project_count, projects_not_listed, personal_count and summary." }, "priority": { "type": "string", "enum": ["HIGH", "NORMAL", "LOW", "NONE"], "description": "Only the tasks of this priority; NONE also selects the tasks with no priority. count then counts those tasks, and with group_by_project so does each board's count." } } }, diff --git a/services/src/test/java/io/meeds/task/mcp/TaskMcpToolTest.java b/services/src/test/java/io/meeds/task/mcp/TaskMcpToolTest.java index 0201c4c33e..85aaf9cb71 100644 --- a/services/src/test/java/io/meeds/task/mcp/TaskMcpToolTest.java +++ b/services/src/test/java/io/meeds/task/mcp/TaskMcpToolTest.java @@ -3937,12 +3937,14 @@ && isSingle(or.getConditions().get(0), SingleCondition.EQ, "priority", Priority. /** * group_by_project counts board by board with the listing's own query, then - * the open tasks of those boards only, with the same accessibility: the - * boards with the most selected tasks first, ties by name ignoring case, - * each with its open count, and project_count counting them all. Mutants: - * the counts read from another query than the listing's, the open count - * taken from the selected count, the open query not restricted to the - * boards or keeping the completed tasks, the order reversed or by id. + * the open tasks of every board the user can access, with the same + * accessibility: the boards with the most selected tasks first, ties by + * name ignoring case, each with its open count, project_count counting them + * all and open_project_count the boards holding open tasks, a board with + * none selected included (EXO-94360). Mutants: the counts read from another + * query than the listing's, the open count taken from the selected count, + * the open query restricted to the listed boards or keeping the completed + * tasks, the order reversed or by id. * * @throws Exception never */ @@ -3956,13 +3958,15 @@ public void listTasksGroupedByProjectCountsEachBoardBesideItsOpenTasks() throws new ProjectTaskCountDto(8L, "Alpha", 3L)), List.of(new ProjectTaskCountDto(7L, "Beta", 5L), new ProjectTaskCountDto(8L, "Alpha", 3L), - new ProjectTaskCountDto(9L, "zeta", 4L))); + new ProjectTaskCountDto(9L, "zeta", 4L), + new ProjectTaskCountDto(10L, "Gamma", 2L))); TaskCollectionModel result = tool.listTasks(null, true, false, null, null, null, null, null, null, null, null, null, true, null, null, true, null); assertSame(listed.getValue(), counted.getAllValues().get(0)); TaskQuery open = counted.getAllValues().get(1); - assertTrue(conjunction(open).stream().anyMatch(c -> isSingle(c, SingleCondition.IN, "status.project.id", List.of(8L, 9L, 7L)))); + assertFalse("the open tasks are counted on every board", + conjunction(open).stream().anyMatch(c -> c instanceof SingleCondition in && "status.project.id".equals(in.getField()))); assertTrue(selectsOpenTasksOnly(open)); assertTrue(scopedToTheUser(open)); assertFalse("the open count is every open task of the board the user can access", hasDueDateCondition(open)); @@ -3971,13 +3975,14 @@ public void listTasksGroupedByProjectCountsEachBoardBesideItsOpenTasks() throws new ProjectTaskCountModel(7L, "Beta", 1L, 5L)), result.getProjects()); assertEquals(Integer.valueOf(3), result.getProjectCount()); + assertEquals(Integer.valueOf(4), result.getOpenProjectCount()); } /** - * Without group_by_project, the answer carries no board counts and no - * grouped count runs; with it and no board holding a selected task, the - * counts are empty and the open tasks are not counted. Mutants: the counts - * always computed, or the open count run on an empty set of boards. + * Without group_by_project, the answer carries no board counts, no summary + * and no grouped count runs; with it and no board holding a selected task, + * the counts are empty and the open tasks are still counted, for + * open_project_count (EXO-94360). Mutant: the counts always computed. * * @throws Exception never */ @@ -3988,21 +3993,26 @@ public void listTasksCountsBoardsOnlyWhenAsked() throws Exception { // NOSONAR TaskCollectionModel plain = tool.listTasks(null, true, false, null, null, null, null, null, null, null, null, null, true, null, null, null, null); assertNull(plain.getProjects()); assertNull(plain.getProjectCount()); + assertNull(plain.getSummary()); + assertNull(plain.getOpenProjectCount()); verify(taskService, never()).countTasksByProject(any()); when(taskService.countTasksByProject(any())).thenReturn(List.of()); TaskCollectionModel none = tool.listTasks(null, true, false, null, null, null, null, null, null, null, null, null, true, null, null, true, null); assertEquals(List.of(), none.getProjects()); assertEquals(Integer.valueOf(0), none.getProjectCount()); - verify(taskService, times(1)).countTasksByProject(any()); + assertEquals(Integer.valueOf(0), none.getOpenProjectCount()); + verify(taskService, times(2)).countTasksByProject(any()); } /** * The board counts list {@value TaskMcpTool#MAX_PROJECT_COUNTS} boards at * most, those with the most selected tasks, while project_count counts - * every board, and the open tasks are counted on the listed boards only. - * Mutants: the cap dropped, or applied before the sort; the open count - * run on every board. + * every board and projects_not_listed the boards left out, and the + * personal tasks are the count less the tasks of every board, the board + * left out included (EXO-94360). Mutants: the cap dropped, or applied + * before the sort; the boards left out not counted; the personal tasks + * counted from the listed boards only. * * @throws Exception never */ @@ -4015,22 +4025,163 @@ public void listTasksGroupedByProjectListsTheBusiestBoardsFirst() throws Excepti } ArgumentCaptor counted = ArgumentCaptor.forClass(TaskQuery.class); when(taskService.countTasksByProject(counted.capture())).thenReturn(counts, List.of()); + long onBoards = counts.stream().mapToLong(ProjectTaskCountDto::getCount).sum(); + when(taskService.countTasks(any())).thenReturn((int) onBoards + 7); TaskCollectionModel result = tool.listTasks(null, true, false, null, null, null, null, null, null, null, null, null, true, null, null, true, null); - List listedBoards = new ArrayList<>(); - for (long id = TaskMcpTool.MAX_PROJECT_COUNTS + 1L; id >= 2; id--) { - listedBoards.add(id); - } - assertTrue(conjunction(counted.getAllValues().get(1)).stream() - .anyMatch(c -> isSingle(c, SingleCondition.IN, "status.project.id", listedBoards))); assertEquals(TaskMcpTool.MAX_PROJECT_COUNTS, result.getProjects().size()); + assertEquals(Integer.valueOf(1), result.getProjectsNotListed()); + assertEquals("the board left out holds 1 task, not a personal one", Long.valueOf(7L), result.getPersonalCount()); assertEquals(TaskMcpTool.MAX_PROJECT_COUNTS + 1L, result.getProjects().get(0).getProjectId()); assertEquals(2L, result.getProjects().get(TaskMcpTool.MAX_PROJECT_COUNTS - 1).getProjectId()); assertEquals(0L, result.getProjects().get(0).getOpenCount()); assertEquals(Integer.valueOf(TaskMcpTool.MAX_PROJECT_COUNTS + 1), result.getProjectCount()); } + /** + * A grouped call with a limit of 1 is made for the counts: it returns at + * most one task and says no next page remains, though more tasks match; a + * grouped call reading a real page, and an ungrouped call with a limit of + * 1, keep has_more and next_offset (EXO-94360). Mutants: has_more left on + * the counting call; has_more dropped on every grouped call; the rule + * applied without group_by_project. + * + * @throws Exception never + */ + @Test + public void listTasksGroupedCountingCallSaysNoNextPage() throws Exception { // NOSONAR + List ten = new ArrayList<>(); + for (long id = 1; id <= 10; id++) { + ten.add(mockTaskWithProject(id, new Date())); + } + when(taskService.findLastUpdatedTasks(any(), eq(0), eq(1))).thenReturn(ten.subList(0, 1)); + when(taskService.findLastUpdatedTasks(any(), eq(0), eq(10))).thenReturn(ten); + when(taskService.countTasks(any())).thenReturn(25); + when(taskService.countTasksByProject(any())).thenReturn(List.of(new ProjectTaskCountDto(8L, "Alpha", 25L))); + + TaskCollectionModel counting = runWithDateFormatMockResult(() -> tool.listTasks(null, true, false, null, 0, 1, null, null, null, null, null, null, null, null, null, true, null)); + assertFalse(counting.isHasMore()); + assertNull(counting.getNextOffset()); + JsonNode json = JSON.readTree(JSON.writeValueAsString(counting)); + assertFalse(json.path("has_more").asBoolean()); + assertFalse(json.has("next_offset")); + assertEquals(25, json.path("count").asInt()); + + TaskCollectionModel page = runWithDateFormatMockResult(() -> tool.listTasks(null, true, false, null, 0, 10, null, null, null, null, null, null, null, null, null, true, null)); + assertTrue(page.isHasMore()); + assertEquals(Integer.valueOf(10), page.getNextOffset()); + + TaskCollectionModel plain = runWithDateFormatMockResult(() -> tool.listTasks(null, true, false, null, 0, 1, null, null, null, null, null, null, null, null, null, null, null)); + assertTrue(plain.isHasMore()); + assertEquals(Integer.valueOf(1), plain.getNextOffset()); + } + + /** + * The grouped answer counts the boards holding open tasks the user can + * access, the boards left out of the list and the selected personal tasks, + * which are on no board: the count less the tasks of every board, those + * left out of the list included; its summary states them, under the JSON + * names the definition gives (EXO-94360). Mutants: the personal tasks not + * subtracted; the open boards counted from the selected ones. + * + * @throws Exception never + */ + @Test + public void listTasksGroupedCountsOpenBoardsAndPersonalTasks() throws Exception { // NOSONAR + when(taskService.findLastUpdatedTasks(any(), eq(0), eq(10))).thenReturn(Collections.emptyList()); + when(taskService.countTasks(any())).thenReturn(60); + when(taskService.countTasksByProject(any())).thenReturn(List.of(new ProjectTaskCountDto(8L, "Alpha", 30L), + new ProjectTaskCountDto(9L, "Beta", 20L)), + List.of(new ProjectTaskCountDto(8L, "Alpha", 50L), + new ProjectTaskCountDto(9L, "Beta", 20L), + new ProjectTaskCountDto(10L, "Gamma", 5L))); + + TaskCollectionModel result = tool.listTasks(null, true, false, null, null, null, null, null, null, null, null, null, null, null, null, true, null); + + assertEquals(Long.valueOf(10L), result.getPersonalCount()); + assertEquals(Integer.valueOf(3), result.getOpenProjectCount()); + assertEquals(Integer.valueOf(0), result.getProjectsNotListed()); + assertEquals(50L, result.getProjects().get(0).getOpenCount()); + assertEquals("60 open tasks: 50 in 2 of 3 boards, 10 personal", result.getSummary()); + JsonNode json = JSON.readTree(JSON.writeValueAsString(result)); + assertEquals(3, json.path("open_project_count").asInt()); + assertEquals(0, json.path("projects_not_listed").asInt()); + assertEquals(10, json.path("personal_count").asInt()); + assertEquals(result.getSummary(), json.path("summary").asText()); + } + + /** + * The summary names the filters the call applied: overdue and open before + * « tasks », the others after it in the tool's order; it counts the boards + * among the boards holding open tasks only when the listing selects open + * tasks only, which hide_completed_tasks with completed_since does not, and + * says when the list leaves boards out (EXO-94360). Mutants: « overdue » + * always written; « open » or « of » the open boards when completed tasks + * are included; a filter left out; the singular lost; « 0 in 0 boards » + * written when every task is personal. + */ + @Test + public void groupedSummaryNamesTheFiltersApplied() { // NOSONAR + assertEquals("260 overdue open tasks in 29 of 86 boards", + TaskMcpTool.getGroupedSummary(grouped(260, 29, 86, 0, 0), + new TaskMcpTool.ListingFilters(true, false, false, null, null, null, null, null, null, null, null))); + assertEquals("41 tasks in 12 boards", + TaskMcpTool.getGroupedSummary(grouped(41, 12, 86, 0, 0), + new TaskMcpTool.ListingFilters(false, false, false, null, null, null, null, null, null, null, null))); + assertEquals("1 task in 1 board", + TaskMcpTool.getGroupedSummary(grouped(1, 1, 5, 0, 0), + new TaskMcpTool.ListingFilters(false, false, false, null, null, null, null, null, null, null, null))); + assertEquals("7 open tasks of priority high whose title contains \"Report\" assigned to john in status 4 due from 2026-11-01 to 2026-11-30" + + " changed since 2026-11-02 in 3 of 9 boards", + TaskMcpTool.getGroupedSummary(grouped(7, 3, 9, 0, 0), + new TaskMcpTool.ListingFilters(false, + true, + false, + "2026-11-01", + "2026-11-30", + Priority.HIGH, + "john", + 4L, + " Report ", + "2026-11-02", + null))); + assertEquals("2 open tasks with no priority with no due date in 1 of 1 board", + TaskMcpTool.getGroupedSummary(grouped(2, 1, 1, 0, 0), + new TaskMcpTool.ListingFilters(false, true, true, null, null, Priority.NONE, null, null, null, null, null))); + assertEquals("3 tasks due until 2026-11-30 completed since 2026-11-01 in 2 boards", + TaskMcpTool.getGroupedSummary(grouped(3, 2, 9, 0, 0), + new TaskMcpTool.ListingFilters(false, true, false, null, "2026-11-30", null, null, null, null, null, "2026-11-01"))); + assertEquals("3 overdue open tasks, all personal, on no board", + TaskMcpTool.getGroupedSummary(grouped(3, 0, 4, 3, 0), + new TaskMcpTool.ListingFilters(true, false, false, null, null, null, null, null, null, null, null))); + assertEquals("150 tasks in 101 boards; the 100 boards with the most are listed", + TaskMcpTool.getGroupedSummary(grouped(150, 101, 120, 0, 1), + new TaskMcpTool.ListingFilters(false, false, false, null, null, null, null, null, null, null, null))); + } + + /** + * @param count the count of the tasks selected + * @param boards the boards holding them + * @param openBoards the boards holding open tasks + * @param personal the personal tasks among them + * @param notListed the boards left out of the list + * @return a grouped answer with those counts, listing every other board + */ + private static TaskCollectionModel grouped(long count, int boards, int openBoards, long personal, int notListed) { + TaskCollectionModel collection = new TaskCollectionModel(Collections.emptyList(), 0, 1, count, false, null); + List listed = new ArrayList<>(); + for (long id = 1; id <= boards - notListed; id++) { + listed.add(new ProjectTaskCountModel(id, "Board " + id, 1L, 1L)); + } + collection.setProjects(listed); + collection.setProjectCount(boards); + collection.setOpenProjectCount(openBoards); + collection.setPersonalCount(personal); + collection.setProjectsNotListed(notListed); + return collection; + } + /** * A due range on list_assigned_tasks narrows the user's open tasks to those * due in it, both whole days in the user's time zone; without one, no diff --git a/services/src/test/java/io/meeds/task/mcp/TaskToolDefinitionUpgradesTest.java b/services/src/test/java/io/meeds/task/mcp/TaskToolDefinitionUpgradesTest.java index acc7211f66..a76e2d8ca7 100644 --- a/services/src/test/java/io/meeds/task/mcp/TaskToolDefinitionUpgradesTest.java +++ b/services/src/test/java/io/meeds/task/mcp/TaskToolDefinitionUpgradesTest.java @@ -54,7 +54,7 @@ public class TaskToolDefinitionUpgradesTest { /** How many earlier definitions of each changed tool the history of every ref holds. */ private static final Map EARLIER_DEFINITIONS = Map.of("list_tasks", - 22, + 23, "list_assigned_tasks", 15, "list_projects", @@ -106,10 +106,18 @@ public class TaskToolDefinitionUpgradesTest { Map.of("list_project_activity_since", "0648b6b3cc88c4567304a1730b8a9ac39b7f69a62acddd8c2aa2235831c15b04"); + /** + * The definition of list_tasks feature/rtd shipped before the grouped + * answer's board counts and summary (EXO-94360). + */ + private static final Map DEFINITIONS_BEFORE_94360 = + Map.of("list_tasks", + "2b53f023e39465e999c43f9d33f7ae28dc3e78340a9e53d79f9c5f8eee831642"); + /** * Each changed tool lists every earlier definition, those shipped before - * EXO-94250, before EXO-94284, before managed_only, before the relation and - * before EXO-94377 included, and not its + * EXO-94250, before EXO-94284, before managed_only, before the relation, + * before EXO-94377 and before EXO-94360 included, and not its * shipped one, which an instance already holding it keeps anyway. Mutants: * a digest removed, the shipped digest added, a tool's entry dropped. * @@ -129,7 +137,8 @@ public void eachChangedToolListsItsEarlierDefinitionsOnly() throws Exception { / DEFINITIONS_BEFORE_94284, DEFINITIONS_BEFORE_MANAGED_ONLY, DEFINITIONS_BEFORE_RELATION, - DEFINITIONS_BEFORE_94377)) { + DEFINITIONS_BEFORE_94377, + DEFINITIONS_BEFORE_94360)) { if (pinned.containsKey(name)) { assertTrue(name, digests.contains(pinned.get(name))); }