@grec0/memory-bank-mcp 0.2.11 → 0.2.12

package/dist/common/agentBoard.js

@@ -129,6 +129,18 @@ export class AgentBoard {
     getPendingTasks() {
         return this.sqlite.getPendingTasks();
     }
+    /**
+     * Get all tasks for this project (regardless of status)
+     */
+    getAllTasks() {
+        return this.sqlite.getAllTasks();
+    }
+    /**
+     * Get completed tasks for this project
+     */
+    getCompletedTasks() {
+        return this.sqlite.getCompletedTasks();
+    }
     /**
      * Claim a task
      */

package/dist/common/agentBoardSqlite.js

@@ -219,6 +219,30 @@ export class AgentBoardSqlite {
         `).all(this.projectId);
         return rows.map(this.mapTaskRow);
     }
+    /**
+     * Get all tasks for this project (regardless of status)
+     */
+    getAllTasks() {
+        const db = databaseManager.getConnection();
+        const rows = db.prepare(`
+            SELECT * FROM tasks
+            WHERE project_id = ?
+            ORDER BY created_at DESC
+        `).all(this.projectId);
+        return rows.map(this.mapTaskRow);
+    }
+    /**
+     * Get completed tasks for this project
+     */
+    getCompletedTasks() {
+        const db = databaseManager.getConnection();
+        const rows = db.prepare(`
+            SELECT * FROM tasks
+            WHERE project_id = ? AND status = 'COMPLETED'
+            ORDER BY completed_at DESC
+        `).all(this.projectId);
+        return rows.map(this.mapTaskRow);
+    }
     /**
      * Claim a task (agent takes ownership)
      */

package/dist/common/textSimilarity.js

@@ -0,0 +1,102 @@
+/**
+ * @fileoverview Text Similarity Utilities
+ * Provides functions to compare text similarity for task deduplication
+ */
+/**
+ * Calculates Levenshtein distance between two strings
+ * (minimum number of single-character edits to transform one string into another)
+ */
+function levenshteinDistance(str1, str2) {
+    const len1 = str1.length;
+    const len2 = str2.length;
+    // Create a 2D array for dynamic programming
+    const dp = Array(len1 + 1).fill(null).map(() => Array(len2 + 1).fill(0));
+    // Initialize base cases
+    for (let i = 0; i <= len1; i++) {
+        dp[i][0] = i;
+    }
+    for (let j = 0; j <= len2; j++) {
+        dp[0][j] = j;
+    }
+    // Fill the dp table
+    for (let i = 1; i <= len1; i++) {
+        for (let j = 1; j <= len2; j++) {
+            if (str1[i - 1] === str2[j - 1]) {
+                dp[i][j] = dp[i - 1][j - 1];
+            }
+            else {
+                dp[i][j] = Math.min(dp[i - 1][j] + 1, // deletion
+                dp[i][j - 1] + 1, // insertion
+                dp[i - 1][j - 1] + 1 // substitution
+                );
+            }
+        }
+    }
+    return dp[len1][len2];
+}
+/**
+ * Calculates similarity score between two strings (0-1 range)
+ * 1.0 = identical, 0.0 = completely different
+ */
+export function textSimilarity(str1, str2) {
+    if (!str1 && !str2)
+        return 1.0; // Both empty = identical
+    if (!str1 || !str2)
+        return 0; // One empty, one not = different
+    // Normalize: lowercase, trim, and remove extra spaces
+    const s1 = str1.toLowerCase().trim().replace(/\s+/g, ' ');
+    const s2 = str2.toLowerCase().trim().replace(/\s+/g, ' ');
+    // After normalization, check again
+    if (s1 === s2)
+        return 1.0;
+    if (s1.length === 0 && s2.length === 0)
+        return 1.0;
+    if (s1.length === 0 || s2.length === 0)
+        return 0;
+    const maxLen = Math.max(s1.length, s2.length);
+    const distance = levenshteinDistance(s1, s2);
+    return 1 - (distance / maxLen);
+}
+/**
+ * Checks if two texts are similar based on a threshold
+ * @param str1 First string
+ * @param str2 Second string
+ * @param threshold Similarity threshold (0-1), default 0.8
+ * @returns true if similarity >= threshold
+ */
+export function areSimilar(str1, str2, threshold = 0.8) {
+    return textSimilarity(str1, str2) >= threshold;
+}
+/**
+ * Finds the most similar text from a list
+ * @param target Target text to compare
+ * @param candidates List of candidate texts
+ * @param minScore Minimum similarity score to consider (default 0.7)
+ * @returns Object with best match and score, or null if no match above threshold
+ */
+export function findMostSimilar(target, candidates, minScore = 0.7) {
+    if (!target || !candidates || candidates.length === 0) {
+        return null;
+    }
+    let bestMatch = null;
+    for (let i = 0; i < candidates.length; i++) {
+        const score = textSimilarity(target, candidates[i]);
+        if (score >= minScore && (!bestMatch || score > bestMatch.score)) {
+            bestMatch = { text: candidates[i], score, index: i };
+        }
+    }
+    return bestMatch;
+}
+/**
+ * Normalizes a text for comparison (lowercase, trim, remove extra spaces)
+ */
+export function normalizeText(text) {
+    return text.toLowerCase().trim().replace(/\s+/g, ' ');
+}
+/**
+ * Checks if text contains all keywords (case-insensitive)
+ */
+export function containsAllKeywords(text, keywords) {
+    const normalized = normalizeText(text);
+    return keywords.every(keyword => normalized.includes(normalizeText(keyword)));
+}

package/dist/common/version.js

@@ -1,2 +1,2 @@
 // Version of the MCP Kanban server
-export const VERSION = "0.2.11";
+export const VERSION = "0.2.12";

package/dist/tools/delegateTask.js

@@ -1,5 +1,6 @@
 import { RegistryManager } from '../common/registryManager.js';
 import { AgentBoard } from '../common/agentBoard.js';
+import { textSimilarity } from '../common/textSimilarity.js';
 export async function delegateTaskTool(params) {
     const registryManager = new RegistryManager();
     const targetProject = await registryManager.getProject(params.targetProjectId);
@@ -11,12 +12,33 @@ export async function delegateTaskTool(params) {
     }
     try {
         // Initialize board for the TARGET project path
-        // We use targetProject.path as the workspace root for that board
         const targetBoard = new AgentBoard(targetProject.path, targetProject.projectId);
+        // ========================================================================
+        // DOUBLE CHECK: Verify no duplicate task exists before creating
+        // (Protection against race conditions between route and delegate)
+        // ========================================================================
+        const existingTasks = targetBoard.getAllTasks();
+        const TITLE_SIMILARITY_THRESHOLD = 0.85;
+        for (const existingTask of existingTasks) {
+            const similarity = textSimilarity(params.title, existingTask.title);
+            if (similarity >= TITLE_SIMILARITY_THRESHOLD) {
+                // Found a duplicate - don't create
+                console.error(`  ⚠️  Duplicate task detected during delegation: ${existingTask.id} (similarity: ${(similarity * 100).toFixed(0)}%)`);
+                return {
+                    success: true, // Not an error, just already exists
+                    taskId: existingTask.id,
+                    isDuplicate: true,
+                    existingStatus: existingTask.status,
+                    message: `Task already exists in '${params.targetProjectId}' as ${existingTask.id} (status: ${existingTask.status}). No duplicate created.`
+                };
+            }
+        }
+        // No duplicate found - safe to create
         const taskId = await targetBoard.createExternalTask(params.title, params.projectId, `${params.description}\n\nContext:\n${params.context}`);
         return {
             success: true,
             taskId,
+            isDuplicate: false,
             message: `Task successfully delegated to project '${params.targetProjectId}' (Task ID: ${taskId})`
         };
     }

package/dist/tools/routeTask.js

@@ -10,6 +10,8 @@ import OpenAI from "openai";
 import { RegistryManager } from "../common/registryManager.js";
 import { searchMemory } from "./searchMemory.js";
 import { saveOrchestratorLog } from "../common/agentBoardSqlite.js";
+import { AgentBoard } from "../common/agentBoard.js";
+import { textSimilarity } from "../common/textSimilarity.js";
 /**
  * Builds a context string describing all projects and their responsibilities
  */
@@ -172,6 +174,104 @@ IMPORTANT:
 - Responde siempre en ESPAÑOL
 
 Respond ONLY with the JSON object after completing your analysis.`;
+/**
+ * Checks if a delegation is a duplicate of an existing task in the target project
+ * @param delegation The proposed delegation
+ * @param targetProject The target project card
+ * @param registryManager Registry manager for resolving project paths
+ * @returns Updated delegation with deduplication metadata
+ */
+async function checkDelegationDuplicate(delegation, targetProject, registryManager) {
+    try {
+        // Initialize AgentBoard for the target project
+        const targetBoard = new AgentBoard(targetProject.path, targetProject.projectId);
+        // Get all tasks (pending, in-progress, and completed)
+        const allTasks = targetBoard.getAllTasks();
+        if (!allTasks || allTasks.length === 0) {
+            // No tasks in the target project, no duplicates
+            return delegation;
+        }
+        // Check for duplicates based on title and description similarity
+        const TITLE_SIMILARITY_THRESHOLD = 0.85; // 85% similar titles = likely duplicate
+        const DESC_SIMILARITY_THRESHOLD = 0.75; // 75% similar descriptions = likely duplicate
+        for (const existingTask of allTasks) {
+            // Calculate similarities
+            const titleSimilarity = textSimilarity(delegation.taskTitle, existingTask.title);
+            const descSimilarity = existingTask.description
+                ? textSimilarity(delegation.taskDescription, existingTask.description)
+                : 0;
+            // Check if it's a duplicate
+            const isDuplicateByTitle = titleSimilarity >= TITLE_SIMILARITY_THRESHOLD;
+            const isDuplicateByDesc = descSimilarity >= DESC_SIMILARITY_THRESHOLD;
+            if (isDuplicateByTitle || (isDuplicateByDesc && descSimilarity > 0.5)) {
+                // Found a duplicate!
+                const maxSimilarity = Math.max(titleSimilarity, descSimilarity);
+                let skipReason = `Task already exists in ${targetProject.projectId}: `;
+                if (existingTask.status === 'COMPLETED') {
+                    skipReason += `completed as ${existingTask.id}`;
+                }
+                else if (existingTask.status === 'IN_PROGRESS') {
+                    skipReason += `in progress as ${existingTask.id}${existingTask.claimedBy ? ` (claimed by ${existingTask.claimedBy})` : ''}`;
+                }
+                else {
+                    skipReason += `pending as ${existingTask.id}`;
+                }
+                skipReason += ` (similarity: ${(maxSimilarity * 100).toFixed(0)}%)`;
+                return {
+                    ...delegation,
+                    isDuplicate: true,
+                    existingTaskId: existingTask.id,
+                    existingTaskStatus: existingTask.status,
+                    skipReason,
+                    similarity: maxSimilarity,
+                };
+            }
+        }
+        // No duplicates found
+        return delegation;
+    }
+    catch (error) {
+        console.error(`  Warning: Failed to check duplicates for ${delegation.targetProject}: ${error.message}`);
+        // In case of error, proceed without deduplication metadata
+        return delegation;
+    }
+}
+/**
+ * Filters delegations by checking against existing tasks in target projects
+ * @param delegations Array of proposed delegations
+ * @param registryManager Registry manager for resolving projects
+ * @returns Object with filtered delegations and skipped ones with reasons
+ */
+async function filterDuplicateDelegations(delegations, registryManager) {
+    if (!delegations || delegations.length === 0) {
+        return { validDelegations: [], duplicateDelegations: [] };
+    }
+    console.error(`\n=== Checking for duplicate delegations ===`);
+    const validDelegations = [];
+    const duplicateDelegations = [];
+    for (const delegation of delegations) {
+        // Resolve target project
+        const targetProject = await registryManager.getProject(delegation.targetProject);
+        if (!targetProject) {
+            console.error(`  Warning: Target project '${delegation.targetProject}' not found. Keeping delegation.`);
+            validDelegations.push(delegation);
+            continue;
+        }
+        // Check for duplicates
+        const checkedDelegation = await checkDelegationDuplicate(delegation, targetProject, registryManager);
+        if (checkedDelegation.isDuplicate) {
+            console.error(`  ✗ DUPLICATE: ${delegation.taskTitle} → ${delegation.targetProject}`);
+            console.error(`    ${checkedDelegation.skipReason}`);
+            duplicateDelegations.push(checkedDelegation);
+        }
+        else {
+            console.error(`  ✓ VALID: ${delegation.taskTitle} → ${delegation.targetProject}`);
+            validDelegations.push(checkedDelegation);
+        }
+    }
+    console.error(`\nDeduplication results: ${validDelegations.length} valid, ${duplicateDelegations.length} duplicates`);
+    return { validDelegations, duplicateDelegations };
+}
 /**
  * Routes a task to the appropriate project(s) based on responsibilities
  * Uses function calling to allow the AI to perform semantic searches when needed
@@ -387,13 +487,40 @@ export async function routeTaskTool(params, indexManager) {
                 console.error(`    → ${d.targetProject}: ${d.taskTitle}`);
             }
         }
+        // ========================================================================
+        // DEDUPLICATION: Check against existing tasks in target project boards
+        // ========================================================================
+        let finalDelegations = result.delegations || [];
+        let duplicateDelegations = [];
+        if (finalDelegations.length > 0) {
+            const { validDelegations, duplicateDelegations: duplicates } = await filterDuplicateDelegations(finalDelegations, registryManager);
+            finalDelegations = validDelegations;
+            duplicateDelegations = duplicates;
+            // Update action if all delegations were duplicates
+            if (validDelegations.length === 0 && result.delegations.length > 0) {
+                if (result.myResponsibilities && result.myResponsibilities.length > 0) {
+                    result.action = 'proceed'; // Had delegations but all were duplicates, only local work remains
+                }
+                else {
+                    result.action = 'proceed'; // Everything was a duplicate, nothing to do
+                }
+            }
+        }
+        // Build architecture notes with deduplication info
+        let architectureNotes = result.architectureNotes || '';
+        if (duplicateDelegations.length > 0) {
+            architectureNotes += `\n\n**Delegaciones filtradas (duplicadas):**\n`;
+            for (const dup of duplicateDelegations) {
+                architectureNotes += `- ${dup.taskTitle} → ${dup.targetProject}: ${dup.skipReason}\n`;
+            }
+        }
         const routeResult = {
             success: true,
             action: result.action || 'proceed',
             myResponsibilities: result.myResponsibilities || [],
-            delegations: result.delegations || [],
+            delegations: finalDelegations, // Only non-duplicate delegations
             suggestedImports: result.suggestedImports || [],
-            architectureNotes: result.architectureNotes || '',
+            architectureNotes,
             warning: result.warning,
         };
         // Persist to SQLite for extension visualization

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@grec0/memory-bank-mcp",
-  "version": "0.2.11",
+  "version": "0.2.12",
   "description": "MCP server for semantic code indexing with Memory Bank - AI-powered codebase understanding",
   "license": "MIT",
   "author": "@grec0",