@grec0/memory-bank-mcp 0.0.3 → 0.0.4

package/dist/operations/tasks.js

@@ -0,0 +1,238 @@
+/**
+ * @fileoverview Task operations for the MCP Kanban server
+ *
+ * This module provides functions for interacting with tasks in the Planka Kanban board,
+ * including creating, retrieving, updating, and deleting tasks, as well as batch operations.
+ */
+import { z } from "zod";
+import { plankaRequest } from "../common/utils.js";
+import { PlankaTaskSchema } from "../common/types.js";
+// Schema definitions
+/**
+ * Schema for creating a new task
+ * @property {string} cardId - The ID of the card to create the task in
+ * @property {string} name - The name of the task
+ * @property {number} [position] - The position of the task in the card (default: 65535)
+ */
+export const CreateTaskSchema = z.object({
+    cardId: z.string().describe("Card ID"),
+    name: z.string().describe("Task name"),
+    position: z.number().optional().describe("Task position (default: 65535)"),
+});
+/**
+ * Schema for batch creating multiple tasks
+ * @property {Array<CreateTaskSchema>} tasks - Array of tasks to create
+ */
+export const BatchCreateTasksSchema = z.object({
+    tasks: z.array(CreateTaskSchema).describe("Array of tasks to create"),
+});
+/**
+ * Schema for retrieving tasks from a card
+ * @property {string} cardId - The ID of the card to get tasks from
+ */
+export const GetTasksSchema = z.object({
+    cardId: z.string().describe("Card ID"),
+});
+/**
+ * Schema for retrieving a specific task
+ * @property {string} id - The ID of the task to retrieve
+ * @property {string} [cardId] - The ID of the card containing the task
+ */
+export const GetTaskSchema = z.object({
+    id: z.string().describe("Task ID"),
+    cardId: z.string().optional().describe("Card ID containing the task"),
+});
+/**
+ * Schema for updating a task
+ * @property {string} id - The ID of the task to update
+ * @property {string} [name] - The new name for the task
+ * @property {boolean} [isCompleted] - Whether the task is completed
+ * @property {number} [position] - The new position for the task
+ */
+export const UpdateTaskSchema = z.object({
+    id: z.string().describe("Task ID"),
+    name: z.string().optional().describe("Task name"),
+    isCompleted: z.boolean().optional().describe("Whether the task is completed"),
+    position: z.number().optional().describe("Task position"),
+});
+/**
+ * Schema for deleting a task
+ * @property {string} id - The ID of the task to delete
+ */
+export const DeleteTaskSchema = z.object({
+    id: z.string().describe("Task ID"),
+});
+// Response schemas
+const TasksResponseSchema = z.object({
+    items: z.array(PlankaTaskSchema),
+    included: z.record(z.any()).optional(),
+});
+const TaskResponseSchema = z.object({
+    item: PlankaTaskSchema,
+    included: z.record(z.any()).optional(),
+});
+// Map to store task ID to card ID mapping
+const taskCardIdMap = {};
+// Function implementations
+/**
+ * Creates a new task for a card
+ *
+ * @param {object} params - The task creation parameters
+ * @param {string} params.cardId - The ID of the card to create the task in
+ * @param {string} params.name - The name of the new task
+ * @param {number} params.position - The position of the task in the card
+ * @returns {Promise<object>} The created task
+ */
+export async function createTask(params) {
+    try {
+        const { cardId, name, position = 65535 } = params;
+        const response = await plankaRequest(`/api/cards/${cardId}/tasks`, {
+            method: "POST",
+            body: { name, position },
+        });
+        // Store the task ID to card ID mapping for getTask
+        if (response.item && response.item.id) {
+            taskCardIdMap[response.item.id] = cardId;
+        }
+        return response.item;
+    }
+    catch (error) {
+        console.error("Error creating task:", error);
+        throw new Error(`Failed to create task: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/**
+ * Creates multiple tasks for cards in a single operation
+ *
+ * @param {BatchCreateTasksOptions} options - The batch create tasks options
+ * @returns {Promise<{results: any[], successes: any[], failures: TaskError[]}>} The results of the batch operation
+ * @throws {Error} If the batch operation fails completely
+ */
+export async function batchCreateTasks(options) {
+    try {
+        const results = [];
+        const successes = [];
+        const failures = [];
+        // Process each task in sequence
+        for (let i = 0; i < options.tasks.length; i++) {
+            const task = options.tasks[i];
+            // Ensure position is set if not provided
+            if (!task.position) {
+                task.position = 65535 * (i + 1);
+            }
+            try {
+                const result = await createTask(task);
+                results.push({
+                    success: true,
+                    result,
+                });
+                successes.push(result);
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error
+                    ? error.message
+                    : String(error);
+                results.push({
+                    success: false,
+                    error: { message: errorMessage },
+                });
+                failures.push({
+                    index: i,
+                    task,
+                    error: errorMessage,
+                });
+            }
+        }
+        return {
+            results,
+            successes,
+            failures,
+        };
+    }
+    catch (error) {
+        throw new Error(`Failed to batch create tasks: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/**
+ * Retrieves all tasks for a specific card
+ *
+ * @param {string} cardId - The ID of the card to get tasks from
+ * @returns {Promise<Array<object>>} Array of tasks in the card
+ */
+export async function getTasks(cardId) {
+    try {
+        // Instead of using the tasks endpoint which returns HTML,
+        // we'll get the card details which includes tasks
+        const response = await plankaRequest(`/api/cards/${cardId}`);
+        // Extract tasks from the card response
+        if (response?.included?.tasks && Array.isArray(response.included.tasks)) {
+            const tasks = response.included.tasks;
+            return tasks;
+        }
+        return [];
+    }
+    catch (error) {
+        console.error(`Error getting tasks for card ${cardId}:`, error);
+        // If there's an error, return an empty array
+        return [];
+    }
+}
+/**
+ * Retrieves a specific task by ID
+ *
+ * @param {string} id - The ID of the task to retrieve
+ * @param {string} [cardId] - Optional card ID to help find the task
+ * @returns {Promise<object>} The requested task
+ */
+export async function getTask(id, cardId) {
+    try {
+        // Tasks in Planka are always part of a card, so we need the card ID
+        const taskCardId = cardId || taskCardIdMap[id];
+        if (!taskCardId) {
+            throw new Error("Card ID is required to get a task. Either provide it directly or create the task first.");
+        }
+        // Get the card details which includes tasks
+        const response = await plankaRequest(`/api/cards/${taskCardId}`);
+        if (!response?.included?.tasks ||
+            !Array.isArray(response.included.tasks)) {
+            throw new Error(`Failed to get tasks for card ${taskCardId}`);
+        }
+        // Find the task with the matching ID
+        const task = response.included.tasks.find((task) => task.id === id);
+        if (!task) {
+            throw new Error(`Task with ID ${id} not found in card ${taskCardId}`);
+        }
+        return task;
+    }
+    catch (error) {
+        console.error(`Error getting task with ID ${id}:`, error);
+        throw new Error(`Failed to get task: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/**
+ * Updates a task's properties
+ *
+ * @param {string} id - The ID of the task to update
+ * @param {Partial<Omit<CreateTaskOptions, "cardId">>} options - The properties to update
+ * @returns {Promise<object>} The updated task
+ */
+export async function updateTask(id, options) {
+    const response = await plankaRequest(`/api/tasks/${id}`, {
+        method: "PATCH",
+        body: options,
+    });
+    const parsedResponse = TaskResponseSchema.parse(response);
+    return parsedResponse.item;
+}
+/**
+ * Deletes a task by ID
+ *
+ * @param {string} id - The ID of the task to delete
+ * @returns {Promise<{success: boolean}>} Success indicator
+ */
+export async function deleteTask(id) {
+    await plankaRequest(`/api/tasks/${id}`, {
+        method: "DELETE",
+    });
+    return { success: true };
+}

package/dist/tools/analyzeCoverage.js

@@ -21,22 +21,18 @@ function buildDirectoryTree(files, indexedFiles, pendingFiles, rootPath) {
     // Build tree structure
     const dirMap = new Map();
     dirMap.set("", root);
-    // Helper to normalize paths to forward slashes
-    const normalize = (p) => p.replace(/\\/g, "/");
     // Sort files by path for consistent tree building
-    const sortedFiles = [...files].sort((a, b) => normalize(a.path).localeCompare(normalize(b.path)));
+    const sortedFiles = [...files].sort((a, b) => a.path.localeCompare(b.path));
     for (const file of sortedFiles) {
-        const normalizedPath = normalize(file.path);
-        const parts = normalizedPath.split("/");
+        const parts = file.path.split(path.sep);
         let currentPath = "";
         // Create directory nodes
         for (let i = 0; i < parts.length - 1; i++) {
-            const part = parts[i];
             const parentPath = currentPath;
-            currentPath = currentPath ? `${currentPath}/${part}` : part;
+            currentPath = currentPath ? path.join(currentPath, parts[i]) : parts[i];
             if (!dirMap.has(currentPath)) {
                 const dirNode = {
-                    name: part,
+                    name: parts[i],
                     path: currentPath,
                     type: "directory",
                     status: "indexed",
@@ -54,10 +50,10 @@ function buildDirectoryTree(files, indexedFiles, pendingFiles, rootPath) {
         }
         // Add file node
         const fileName = parts[parts.length - 1];
-        const fileDir = parts.length > 1 ? parts.slice(0, -1).join("/") : "";
+        const fileDir = parts.length > 1 ? path.dirname(file.path) : "";
         const parentDir = dirMap.get(fileDir);
         if (parentDir && parentDir.children) {
-            const indexed = indexedFiles.has(normalize(file.path)); // Use normalized path for lookup
+            const indexed = indexedFiles.has(file.path);
             const pending = pendingFiles.has(file.path);
             const fileNode = {
                 name: fileName,
@@ -70,43 +66,33 @@ function buildDirectoryTree(files, indexedFiles, pendingFiles, rootPath) {
                 chunkCount: indexed ? indexedFiles.get(file.path).chunks : 0,
             };
             parentDir.children.push(fileNode);
+            // Update parent stats
+            let current = parentDir;
+            while (current) {
+                current.fileCount = (current.fileCount || 0) + 1;
+                if (indexed)
+                    current.indexedCount = (current.indexedCount || 0) + 1;
+                if (pending)
+                    current.pendingCount = (current.pendingCount || 0) + 1;
+                // Find parent
+                const parentPath = path.dirname(current.path);
+                current = parentPath !== current.path ? dirMap.get(parentPath === "." ? "" : parentPath) : null;
+            }
         }
     }
-    // Calculate stats bottom-up
-    const calculateNodeStats = (node) => {
-        if (node.type === "file") {
-            return;
-        }
-        let fileCount = 0;
-        let indexedCount = 0;
-        let pendingCount = 0;
+    // Sort children (directories first, then files)
+    const sortChildren = (node) => {
         if (node.children) {
             node.children.sort((a, b) => {
-                if (a.type !== b.type)
+                if (a.type !== b.type) {
                     return a.type === "directory" ? -1 : 1;
+                }
                 return a.name.localeCompare(b.name);
             });
-            for (const child of node.children) {
-                if (child.type === "directory") {
-                    calculateNodeStats(child);
-                    fileCount += child.fileCount || 0;
-                    indexedCount += child.indexedCount || 0;
-                    pendingCount += child.pendingCount || 0;
-                }
-                else {
-                    fileCount++;
-                    if (child.status === "indexed")
-                        indexedCount++;
-                    if (child.status === "pending_reindex")
-                        pendingCount++;
-                }
-            }
+            node.children.forEach(sortChildren);
         }
-        node.fileCount = fileCount;
-        node.indexedCount = indexedCount;
-        node.pendingCount = pendingCount;
     };
-    calculateNodeStats(root);
+    sortChildren(root);
     return root;
 }
 /**
@@ -126,11 +112,9 @@ function calculateStats(files, indexedFiles, pendingFiles, totalChunks) {
         languageBreakdown: {},
         directoryBreakdown: {},
     };
-    // Helper to normalize paths
-    const normalize = (p) => p.replace(/\\/g, "/");
     for (const file of files) {
         stats.totalSize += file.size;
-        const indexed = indexedFiles.has(normalize(file.path));
+        const indexed = indexedFiles.has(file.path);
         const pending = pendingFiles.has(file.path);
         if (pending) {
             stats.pendingReindexFiles++;
@@ -153,7 +137,7 @@ function calculateStats(files, indexedFiles, pendingFiles, totalChunks) {
         stats.languageBreakdown[file.language].total++;
         if (indexed) {
             stats.languageBreakdown[file.language].indexed++;
-            stats.languageBreakdown[file.language].chunks += indexedFiles.get(normalize(file.path)).chunks;
+            stats.languageBreakdown[file.language].chunks += indexedFiles.get(file.path).chunks;
         }
         // Directory breakdown
         const dir = path.dirname(file.path);
@@ -230,7 +214,7 @@ export async function analyzeCoverage(indexManager, vectorStore, workspaceRoot)
         const maxScanTime = 10000; // 10 seconds max
         let allFiles = [];
         try {
-            allFiles = await scanFiles({
+            allFiles = scanFiles({
                 rootPath: workspaceRoot,
                 recursive: true
             });
@@ -247,37 +231,33 @@ export async function analyzeCoverage(indexManager, vectorStore, workspaceRoot)
             console.error(`Error escaneando archivos: ${error}`);
             throw error;
         }
-        // 2. Get indexed files stats in ONE batch query (Optimized)
-        console.error("Obteniendo estadísticas de archivos indexados...");
+        // 2. Get indexed files from vector store
+        console.error("Obteniendo archivos indexados...");
         await vectorStore.initialize();
-        // This single call replaces thousands of potential DB queries
-        // It returns Map<filePath, { lastIndexed, chunkCount, fileHash }>
-        const indexedFileStats = await vectorStore.getIndexedFileStats();
+        const fileHashes = await vectorStore.getFileHashes();
         // 3. Get index metadata
         const indexStats = await indexManager.getStats();
-        // 4. Adapt to expected format for efficient loopups
-        // Helper to normalize paths to forward slashes
-        const normalize = (p) => p.replace(/\\/g, "/");
-        // 4. Adapt to expected format for efficient loopups
+        // 4. Build indexed files map with chunk counts
         const indexedFiles = new Map();
-        const normalizedStats = new Map();
-        for (const [path, stats] of indexedFileStats) {
-            const normPath = normalize(path);
-            normalizedStats.set(normPath, stats);
-            indexedFiles.set(normPath, {
-                lastIndexed: stats.lastIndexed,
-                chunks: stats.chunkCount
-            });
+        // Get chunks grouped by file from vector store
+        for (const [filePath, hash] of fileHashes) {
+            const chunks = await vectorStore.getChunksByFile(filePath);
+            if (chunks.length > 0) {
+                indexedFiles.set(filePath, {
+                    lastIndexed: chunks[0].timestamp,
+                    chunks: chunks.length,
+                });
+            }
         }
         // 5. Identify pending files (files that changed)
         const pendingFiles = new Set();
         for (const file of allFiles) {
-            const normPath = normalize(file.path);
-            const stats = normalizedStats.get(normPath);
-            if (stats) {
-                // Check if file hash matches the one in DB
-                if (stats.fileHash !== file.hash) {
-                    pendingFiles.add(file.path); // keep original path for file system ops if needed
+            const indexed = indexedFiles.get(file.path);
+            if (indexed) {
+                // Check if file hash matches
+                const chunks = await vectorStore.getChunksByFile(file.path);
+                if (chunks.length > 0 && chunks[0].file_hash !== file.hash) {
+                    pendingFiles.add(file.path);
                 }
             }
         }

package/dist/tools/board-summary.js

@@ -0,0 +1,151 @@
+import { z } from "zod";
+// Import functions from operations directory
+import { getBoard } from "../operations/boards.js";
+import { getLists } from "../operations/lists.js";
+import { getCards } from "../operations/cards.js";
+import { getTasks } from "../operations/tasks.js";
+import { getLabels } from "../operations/labels.js";
+import { getComments } from "../operations/comments.js";
+/**
+ * Zod schema for the getBoardSummary function parameters
+ * @property {string} boardId - The ID of the board to get a summary for
+ * @property {boolean} [includeTaskDetails=false] - Whether to include detailed task information for each card
+ * @property {boolean} [includeComments=false] - Whether to include comments for each card
+ */
+export const getBoardSummarySchema = z.object({
+    boardId: z.string().describe("The ID of the board to get a summary for"),
+    includeTaskDetails: z.boolean().optional().default(false).describe("Whether to include detailed task information for each card"),
+    includeComments: z.boolean().optional().default(false).describe("Whether to include comments for each card"),
+});
+/**
+ * Retrieves a comprehensive summary of a board including lists, cards, tasks, and statistics
+ *
+ * This function aggregates data from multiple sources to provide a complete view of a board,
+ * including its lists, cards, tasks, and labels. It also calculates various statistics and
+ * provides workflow state analysis.
+ *
+ * @param {GetBoardSummaryParams} params - Parameters for retrieving board summary
+ * @param {string} params.boardId - The ID of the board to get a summary for
+ * @param {boolean} [params.includeTaskDetails=false] - Whether to include detailed task information for each card
+ * @param {boolean} [params.includeComments=false] - Whether to include comments for each card
+ * @returns {Promise<object>} Comprehensive board summary including lists, cards, tasks, statistics, and workflow state
+ * @throws {Error} If the board is not found
+ */
+export async function getBoardSummary(params) {
+    const { boardId, includeTaskDetails, includeComments } = params;
+    try {
+        // Get the board details
+        const board = await getBoard(boardId);
+        if (!board) {
+            throw new Error(`Board with ID ${boardId} not found`);
+        }
+        // Get all lists on the board
+        const allLists = await getLists(boardId);
+        // Get all cards for each list
+        const listsWithCards = await Promise.all(allLists.map(async (list) => {
+            const listCards = await getCards(list.id);
+            // Get tasks for each card if requested
+            const cardsWithDetails = await Promise.all(listCards.map(async (card) => {
+                let taskDetails = [];
+                if (includeTaskDetails) {
+                    taskDetails = await getTasks(card.id);
+                }
+                // Get comments if requested
+                let cardComments = [];
+                if (includeComments) {
+                    cardComments = await getComments(card.id);
+                }
+                // Calculate task completion percentage
+                const completedTasks = taskDetails.filter((task) => task.isCompleted).length;
+                const totalTasks = taskDetails.length;
+                const completionPercentage = totalTasks > 0
+                    ? Math.round((completedTasks / totalTasks) * 100)
+                    : 0;
+                return {
+                    ...card,
+                    tasks: includeTaskDetails
+                        ? {
+                            items: taskDetails,
+                            total: totalTasks,
+                            completed: completedTasks,
+                            completionPercentage,
+                        }
+                        : undefined,
+                    comments: includeComments
+                        ? cardComments
+                        : undefined,
+                };
+            }));
+            return {
+                ...list,
+                cards: cardsWithDetails,
+                cardCount: cardsWithDetails.length,
+            };
+        }));
+        // Get all labels for the board
+        const boardLabels = await getLabels(boardId);
+        // Calculate overall statistics
+        const totalCards = listsWithCards.reduce((sum, list) => sum + list.cardCount, 0);
+        // Find specific lists by name
+        const backlogList = listsWithCards.find((list) => list.name.toLowerCase() === "backlog");
+        const inProgressList = listsWithCards.find((list) => list.name.toLowerCase() === "in progress");
+        const testingList = listsWithCards.find((list) => list.name.toLowerCase() === "testing");
+        const doneList = listsWithCards.find((list) => list.name.toLowerCase() === "done");
+        // Count cards with specific labels
+        const urgentCards = listsWithCards.flatMap((list) => list.cards)
+            .filter((card) => card.labelIds?.some((labelId) => boardLabels.find((label) => label.id === labelId &&
+            label.name.toLowerCase() === "urgent"))).length;
+        const bugCards = listsWithCards.flatMap((list) => list.cards)
+            .filter((card) => card.labelIds?.some((labelId) => boardLabels.find((label) => label.id === labelId &&
+            label.name.toLowerCase() === "bug"))).length;
+        return {
+            board,
+            lists: listsWithCards,
+            labels: boardLabels,
+            stats: {
+                totalCards,
+                backlogCount: backlogList?.cardCount || 0,
+                inProgressCount: inProgressList?.cardCount || 0,
+                testingCount: testingList?.cardCount || 0,
+                doneCount: doneList?.cardCount || 0,
+                urgentCount: urgentCards,
+                bugCount: bugCards,
+                completionPercentage: totalCards > 0
+                    ? Math.round((doneList?.cardCount || 0) / totalCards * 100)
+                    : 0,
+            },
+            workflowState: {
+                hasCardsInBacklog: (backlogList?.cardCount || 0) > 0,
+                hasCardsInProgress: (inProgressList?.cardCount || 0) > 0,
+                hasCardsInTesting: (testingList?.cardCount || 0) > 0,
+                nextActionSuggestion: getNextActionSuggestion(backlogList?.cardCount || 0, inProgressList?.cardCount || 0, testingList?.cardCount || 0),
+            },
+        };
+    }
+    catch (error) {
+        console.error("Error in getBoardSummary:", error);
+        throw error;
+    }
+}
+/**
+ * Helper function to suggest the next action based on board state
+ *
+ * @param {number} backlogCount - Number of cards in the Backlog list
+ * @param {number} inProgressCount - Number of cards in the In Progress list
+ * @param {number} testingCount - Number of cards in the Testing list
+ * @returns {string} A suggestion for the next action to take
+ */
+function getNextActionSuggestion(backlogCount, inProgressCount, testingCount) {
+    if (testingCount > 0) {
+        return "Review cards in Testing that need feedback";
+    }
+    else if (inProgressCount > 0) {
+        return "Continue working on cards in In Progress";
+    }
+    else if (backlogCount > 0) {
+        return "Start working on a card from Backlog";
+    }
+    else {
+        return "All tasks complete! Create new cards or projects";
+    }
+}

package/dist/tools/card-details.js

@@ -0,0 +1,106 @@
+import { z } from "zod";
+import { getCard } from "../operations/cards.js";
+import { getTasks } from "../operations/tasks.js";
+import { getComments } from "../operations/comments.js";
+import { getLabels } from "../operations/labels.js";
+import { getProjects } from "../operations/projects.js";
+import { getBoards } from "../operations/boards.js";
+import { getLists } from "../operations/lists.js";
+/**
+ * Zod schema for the getCardDetails function parameters
+ * @property {string} cardId - The ID of the card to get details for
+ */
+export const getCardDetailsSchema = z.object({
+    cardId: z.string().describe("The ID of the card to get details for"),
+});
+/**
+ * Retrieves comprehensive details about a card including tasks, comments, labels, and analysis
+ *
+ * This function aggregates data from multiple sources to provide a complete view of a card,
+ * including its tasks, comments, and labels. It also calculates task completion percentage
+ * and performs analysis on the card's status.
+ *
+ * @param {GetCardDetailsParams} params - Parameters for retrieving card details
+ * @param {string} params.cardId - The ID of the card to get details for
+ * @returns {Promise<object>} Comprehensive card details including tasks, comments, labels, and analysis
+ * @throws {Error} If the card is not found or if the board ID cannot be determined
+ */
+export async function getCardDetails(params) {
+    const { cardId } = params;
+    try {
+        // Get the card details
+        const card = await getCard(cardId);
+        if (!card) {
+            throw new Error(`Card with ID ${cardId} not found`);
+        }
+        // Get tasks for the card
+        const tasks = await getTasks(card.id);
+        // Get comments for the card
+        const comments = await getComments(card.id);
+        // Find the board ID by searching through all projects and boards
+        let boardId = null;
+        // Get all projects
+        const projectsResponse = await getProjects(1, 100);
+        const projects = projectsResponse.items;
+        // For each project, get its boards
+        for (const project of projects) {
+            if (boardId)
+                break; // Stop if we already found the board ID
+            const boards = await getBoards(project.id);
+            // For each board, get its lists
+            for (const board of boards) {
+                if (boardId)
+                    break; // Stop if we already found the board ID
+                const lists = await getLists(board.id);
+                // Check if the card's list ID is in this board
+                const matchingList = lists.find((list) => list.id === card.listId);
+                if (matchingList) {
+                    boardId = board.id;
+                    break;
+                }
+            }
+        }
+        if (!boardId) {
+            throw new Error(`Could not determine board ID for card ${cardId}`);
+        }
+        const labels = await getLabels(boardId);
+        // Filter to just the labels assigned to this card
+        // Note: We need to get the labelIds from the card's data
+        // This might require additional API calls or data structure knowledge
+        // For now, we'll return all labels for the board
+        // Calculate task completion percentage
+        const completedTasks = tasks.filter((task) => task.isCompleted).length;
+        const totalTasks = tasks.length;
+        const completionPercentage = totalTasks > 0
+            ? Math.round((completedTasks / totalTasks) * 100)
+            : 0;
+        // Sort comments by date (newest first)
+        const sortedComments = comments.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+        // Check if the most recent comment is likely from a human (not the LLM)
+        // This is a heuristic and might need adjustment
+        const hasRecentHumanFeedback = sortedComments.length > 0 &&
+            sortedComments[0].data &&
+            !sortedComments[0].data.text.includes("Implemented feature") &&
+            !sortedComments[0].data.text.includes("Awaiting human review");
+        return {
+            card,
+            taskItems: tasks,
+            taskStats: {
+                total: totalTasks,
+                completed: completedTasks,
+                completionPercentage,
+            },
+            comments: sortedComments,
+            labels,
+            analysis: {
+                hasRecentHumanFeedback,
+                isComplete: completionPercentage === 100,
+                needsAttention: hasRecentHumanFeedback || completedTasks === 0,
+            },
+        };
+    }
+    catch (error) {
+        console.error("Error in getCardDetails:", error);
+        throw error;
+    }
+}