@grec0/memory-bank-mcp 0.1.40 → 0.2.0

package/dist/common/astChunker.js

@@ -7,9 +7,11 @@ import * as path from "path";
 import * as fs from "fs";
 import * as crypto from "crypto";
 import { fileURLToPath } from "url";
+import { createRequire } from "module";
 import { encode } from "gpt-tokenizer";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
+const require = createRequire(import.meta.url);
 // Constants
 const MAX_TOKENS_PER_CHUNK = 6000;
 const DEFAULT_CHUNK_OVERLAP_TOKENS = 200;
@@ -131,6 +133,7 @@ const SEMANTIC_NODE_TYPES = {
 // Cache for loaded languages
 // Using 'any' types because web-tree-sitter's TypeScript types don't work well with dynamic imports
 let ParserClass = null;
+let LanguageClass = null;
 const loadedLanguages = new Map();
 let treeSitterInitialized = false;
 /**
@@ -155,15 +158,28 @@ function generateChunkId(filePath, content, startLine) {
  * Initializes Tree-sitter WASM module
  */
 async function initTreeSitter() {
-    if (treeSitterInitialized && ParserClass) {
+    if (treeSitterInitialized && ParserClass && LanguageClass) {
         return true;
     }
     try {
         // Dynamic import of web-tree-sitter
-        // web-tree-sitter exports Parser as a named export, not default
         const TreeSitterModule = await import("web-tree-sitter");
-        // Get Parser from named export
-        ParserClass = TreeSitterModule.Parser;
+        // Handle different export formats across web-tree-sitter versions:
+        // - v0.20.x: exports Parser as default, Language is Parser.Language
+        // - v0.26.x: exports Parser and Language as separate named exports
+        if (TreeSitterModule.Parser) {
+            // v0.26.x style: named exports
+            ParserClass = TreeSitterModule.Parser;
+            LanguageClass = TreeSitterModule.Language;
+        }
+        else if (TreeSitterModule.default) {
+            // v0.20.x style: default export is Parser, Language is a static property
+            ParserClass = TreeSitterModule.default;
+            LanguageClass = null; // Will use ParserClass.Language after init
+        }
+        else {
+            throw new Error('Could not find Parser in web-tree-sitter module');
+        }
         if (!ParserClass) {
             throw new Error('Parser class not found in web-tree-sitter module');
         }
@@ -171,6 +187,13 @@ async function initTreeSitter() {
         if (typeof ParserClass.init === 'function') {
             await ParserClass.init();
         }
+        // For v0.20.x, Language becomes available after init
+        if (!LanguageClass && ParserClass.Language) {
+            LanguageClass = ParserClass.Language;
+        }
+        if (!LanguageClass) {
+            throw new Error('Language class not found in web-tree-sitter module');
+        }
         treeSitterInitialized = true;
         console.error("[AST Chunker] Tree-sitter initialized successfully");
         return true;
@@ -179,6 +202,7 @@ async function initTreeSitter() {
         console.error(`[AST Chunker] Failed to initialize Tree-sitter: ${error}`);
         treeSitterInitialized = false;
         ParserClass = null;
+        LanguageClass = null;
         return false;
     }
 }
@@ -190,26 +214,46 @@ function getWasmPath(language) {
     if (!wasmFile) {
         return null;
     }
-    // Try to find in node_modules
+    // Build comprehensive list of possible paths
+    // The compiled JS runs from dist/common/, so we need to account for various scenarios:
+    // 1. Local development: dist/common/../node_modules = dist/node_modules (wrong)
+    // 2. Local development: __dirname/../../node_modules = node_modules (correct)
+    // 3. NPM installed package: need to resolve from the package location
+    // 4. Global install or monorepo: process.cwd() based paths
     const possiblePaths = [
-        path.join(__dirname, "..", "node_modules", "tree-sitter-wasms", "out", wasmFile),
-        path.join(process.cwd(), "node_modules", "tree-sitter-wasms", "out", wasmFile),
+        // From dist/common/ go up two levels to project root then into node_modules
         path.join(__dirname, "..", "..", "node_modules", "tree-sitter-wasms", "out", wasmFile),
+        // From current working directory
+        path.join(process.cwd(), "node_modules", "tree-sitter-wasms", "out", wasmFile),
+        // From dist/ go up one level (in case __dirname is dist/)
+        path.join(__dirname, "..", "node_modules", "tree-sitter-wasms", "out", wasmFile),
+        // Three levels up (for nested structures like dist/common/subdir)
+        path.join(__dirname, "..", "..", "..", "node_modules", "tree-sitter-wasms", "out", wasmFile),
     ];
+    // Try to use require.resolve to find the package (works in most Node.js scenarios)
+    try {
+        const treeSitterWasmsPath = require.resolve("tree-sitter-wasms/package.json");
+        const packageDir = path.dirname(treeSitterWasmsPath);
+        possiblePaths.unshift(path.join(packageDir, "out", wasmFile));
+    }
+    catch {
+        // Package not found via require.resolve, continue with file-based search
+    }
     for (const p of possiblePaths) {
         if (fs.existsSync(p)) {
             return p;
         }
     }
     console.error(`[AST Chunker] WASM file not found for ${language}: ${wasmFile}`);
+    console.error(`[AST Chunker] Searched paths: ${possiblePaths.map(p => `\n  - ${p}`).join('')}`);
     return null;
 }
 /**
  * Loads a language parser
  */
 async function loadLanguage(language) {
-    if (!ParserClass) {
-        console.error("[AST Chunker] Parser not initialized");
+    if (!ParserClass || !LanguageClass) {
+        console.error("[AST Chunker] Parser or Language not initialized");
         return null;
     }
     const langKey = language.toLowerCase();
@@ -220,15 +264,19 @@ async function loadLanguage(language) {
     if (!wasmPath) {
         return null;
     }
+    console.error(`[AST Chunker] Attempting to load WASM from: ${wasmPath}`);
     try {
         // Use the Language.load static method
-        const lang = await ParserClass.Language.load(wasmPath);
+        const lang = await LanguageClass.load(wasmPath);
         loadedLanguages.set(langKey, lang);
         console.error(`[AST Chunker] Loaded language: ${language}`);
         return lang;
     }
     catch (error) {
-        console.error(`[AST Chunker] Failed to load language ${language}: ${error}`);
+        console.error(`[AST Chunker] Failed to load language ${language}: ${error instanceof Error ? error.message : error}`);
+        if (error instanceof Error && error.stack) {
+            console.error(`[AST Chunker] Stack: ${error.stack}`);
+        }
         return null;
     }
 }
@@ -556,5 +604,6 @@ export function disposeASTChunker() {
     loadedLanguages.clear();
     treeSitterInitialized = false;
     ParserClass = null;
+    LanguageClass = null;
     console.error("[AST Chunker] Disposed");
 }

package/dist/common/projectKnowledgeService.js

@@ -1008,6 +1008,72 @@ ${chunk.content}
         const files = fs.readdirSync(docsPath);
         return files.filter(f => f.endsWith(".md"));
     }
+    // ==========================================
+    // Project Summary Generation (for Registry)
+    // ==========================================
+    /**
+     * Generates a structured summary of the project for the global registry.
+     * Extracts responsibilities, ownership patterns, and project type from projectBrief.
+     * This is called automatically after generateAllDocuments.
+     */
+    async generateProjectSummary(projectId) {
+        const projectBrief = this.getDocument(projectId, "projectBrief");
+        const techContext = this.getDocument(projectId, "techContext");
+        if (!projectBrief) {
+            console.error(`Cannot generate project summary: projectBrief not found for ${projectId}`);
+            return null;
+        }
+        console.error(`Generating project summary for registry: ${projectId}`);
+        const prompt = `Analyze the following project documentation and extract a structured summary.
+
+PROJECT BRIEF:
+${projectBrief.content}
+
+${techContext ? `TECHNICAL CONTEXT:\n${techContext.content}` : ''}
+
+Extract the following information in JSON format:
+{
+  "description": "A concise 1-2 sentence description of what this project does",
+  "responsibilities": ["List of 3-5 specific things this project is responsible for"],
+  "owns": ["File patterns or types this project owns, e.g., '*DTO.ts', 'services/', 'controllers/'"],
+  "projectType": "One of: api, library, frontend, backend, cli, service, monorepo, fullstack",
+  "exports": "Package name if it's a library (e.g., '@company/lib-dtos'), or null if not applicable",
+  "keywords": ["5-8 keywords describing this project"]
+}
+
+IMPORTANT:
+- Be specific about responsibilities - they help the orchestrator decide where code belongs
+- For "owns", think about what file patterns ONLY this project should create
+- If it's a library, identify what it exports/provides to other projects
+
+Respond ONLY with the JSON object, no markdown or explanation.`;
+        try {
+            const result = await this.callResponsesAPI(prompt);
+            // Parse JSON response
+            const jsonMatch = result.content.match(/\{[\s\S]*\}/);
+            if (!jsonMatch) {
+                console.error(`Failed to parse project summary JSON for ${projectId}`);
+                return null;
+            }
+            const summary = JSON.parse(jsonMatch[0]);
+            console.error(`Project summary generated for ${projectId}:`);
+            console.error(`  - Type: ${summary.projectType}`);
+            console.error(`  - Responsibilities: ${summary.responsibilities?.length || 0}`);
+            console.error(`  - Owns: ${summary.owns?.length || 0}`);
+            return {
+                description: summary.description || '',
+                responsibilities: summary.responsibilities || [],
+                owns: summary.owns || [],
+                projectType: summary.projectType || 'unknown',
+                exports: summary.exports || undefined,
+                keywords: summary.keywords || [],
+            };
+        }
+        catch (error) {
+            console.error(`Error generating project summary: ${error}`);
+            return null;
+        }
+    }
 }
 /**
  * Creates a Project Knowledge Service from environment variables

package/dist/common/registryManager.js

@@ -22,10 +22,10 @@ export class RegistryManager {
     async saveRegistry(registry) {
         await fs.writeFile(this.globalPath, JSON.stringify(registry, null, 2), 'utf-8');
     }
-    async registerProject(projectId, workspacePath, description, keywords = [], embeddingService) {
+    async registerProject(projectId, workspacePath, description, keywords = [], embeddingService, enhancedInfo) {
         const registry = await this.ensureRegistry();
         const idx = registry.projects.findIndex(p => p.projectId === projectId);
-        // Preserve existing description/keywords if not provided
+        // Preserve existing data if not provided
         const existing = idx >= 0 ? registry.projects[idx] : null;
         const card = {
             projectId,
@@ -33,7 +33,12 @@ export class RegistryManager {
             description: description || existing?.description || '',
             keywords: keywords.length > 0 ? keywords : (existing?.keywords || []),
             lastActive: new Date().toISOString(),
-            status: 'ACTIVE'
+            status: 'ACTIVE',
+            // Enhanced fields - preserve existing if not provided
+            responsibilities: enhancedInfo?.responsibilities || existing?.responsibilities,
+            owns: enhancedInfo?.owns || existing?.owns,
+            exports: enhancedInfo?.exports || existing?.exports,
+            projectType: enhancedInfo?.projectType || existing?.projectType,
         };
         if (idx >= 0) {
             registry.projects[idx] = card;
@@ -53,12 +58,30 @@ export class RegistryManager {
         }
     }
     async updateProjectEmbedding(card, embeddingService) {
-        const text = `Project: ${card.projectId}\nDescription: ${card.description || ''}\nKeywords: ${card.keywords.join(', ')}`;
+        // Build rich text for embedding including responsibilities
+        const textParts = [
+            `Project: ${card.projectId}`,
+            `Description: ${card.description || ''}`,
+            `Keywords: ${card.keywords.join(', ')}`,
+        ];
+        if (card.responsibilities && card.responsibilities.length > 0) {
+            textParts.push(`Responsibilities: ${card.responsibilities.join('. ')}`);
+        }
+        if (card.owns && card.owns.length > 0) {
+            textParts.push(`Owns: ${card.owns.join(', ')}`);
+        }
+        if (card.projectType) {
+            textParts.push(`Type: ${card.projectType}`);
+        }
+        if (card.exports) {
+            textParts.push(`Exports: ${card.exports}`);
+        }
+        const text = textParts.join('\n');
         const result = await embeddingService.generateEmbedding(card.projectId, text);
         await this.projectVectorStore.upsertProject({
             id: card.projectId,
             vector: result.vector,
-            name: card.projectId, // Using ID as name for now if name not available
+            name: card.projectId,
             description: card.description || '',
             tags: card.keywords,
             path: card.path,
@@ -101,6 +124,14 @@ export class RegistryManager {
         const registry = await this.ensureRegistry();
         return registry.projects.find(p => p.projectId === projectId);
     }
+    /**
+     * Gets all projects from the registry.
+     * Useful for the orchestrator to analyze responsibilities across all projects.
+     */
+    async getAllProjects() {
+        const registry = await this.ensureRegistry();
+        return registry.projects;
+    }
     /**
      * Syncs all projects from the JSON registry to the vector store.
      * Useful for migrating existing projects to the new semantic discovery system.

package/dist/index.js

@@ -83,6 +83,7 @@ import { manageAgentsTool, manageAgentsToolDefinition } from "./tools/manageAgen
 import { discoverProjectsTool, discoverProjectsToolDefinition } from "./tools/discoverProjects.js";
 import { delegateTaskTool, delegateTaskToolDefinition } from "./tools/delegateTask.js";
 import { syncProjectsTool, syncProjectsToolDefinition } from "./tools/syncProjects.js";
+import { routeTaskTool, routeTaskToolDefinition } from "./tools/routeTask.js";
 import { RegistryManager } from "./common/registryManager.js";
 import { VERSION } from "./common/version.js";
 // Global services
@@ -864,6 +865,19 @@ server.tool(delegateTaskToolDefinition.name, delegateTaskToolDefinition.descript
         content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
     };
 });
+// Tool: Route Task (Orchestrator)
+server.tool(routeTaskToolDefinition.name, routeTaskToolDefinition.description, {
+    projectId: z.string().describe("ID del proyecto que está solicitando el enrutamiento"),
+    taskDescription: z.string().describe("Descripción detallada de la tarea a implementar")
+}, async (args) => {
+    const result = await routeTaskTool({
+        projectId: args.projectId,
+        taskDescription: args.taskDescription
+    });
+    return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+    };
+});
 /**
  * Starts the stdio server
  */
@@ -900,6 +914,7 @@ async function startStdioServer() {
         console.error("    - memorybank_complete_task: Marcar una tarea como completada");
         console.error("    - memorybank_discover_projects: Descubrir otros proyectos en el ecosistema");
         console.error("    - memorybank_delegate_task: Delegar tareas a otros proyectos");
+        console.error("    - memorybank_route_task: Orquestador - analiza y distribuye tareas");
         console.error("");
         console.error("Available resources:");
         console.error("    - memory://{projectId}/active: Contexto activo");

package/dist/tools/generateProjectDocs.js

@@ -4,6 +4,8 @@
  */
 import { AgentBoard } from "../common/agentBoard.js";
 import { sessionLogger } from "../common/sessionLogger.js";
+import { RegistryManager } from "../common/registryManager.js";
+import { EmbeddingService } from "../common/embeddingService.js";
 import { sessionState } from "../common/sessionState.js";
 /**
  * Generates project documentation using AI reasoning
@@ -94,6 +96,41 @@ export async function generateProjectDocs(params, projectKnowledgeService, vecto
         console.error(`  - Reasoning tokens: ${result.totalReasoningTokens}`);
         console.error(`  - Output tokens: ${result.totalOutputTokens}`);
         console.error(`  - Estimated cost: $${totalCost.toFixed(4)}`);
+        // === AUTO-UPDATE GLOBAL REGISTRY ===
+        // Generate project summary and update registry with enriched info
+        if (result.documentsGenerated.length > 0 || result.documentsUpdated.length > 0) {
+            try {
+                console.error(`\n=== Updating Global Registry ===`);
+                const summary = await projectKnowledgeService.generateProjectSummary(projectId);
+                if (summary) {
+                    const registryManager = new RegistryManager();
+                    let embeddingService;
+                    if (process.env.OPENAI_API_KEY) {
+                        try {
+                            embeddingService = new EmbeddingService(process.env.OPENAI_API_KEY);
+                        }
+                        catch (e) {
+                            console.error(`Warning: Could not init embedding service: ${e}`);
+                        }
+                    }
+                    await registryManager.registerProject(projectId, workspaceRoot, summary.description, summary.keywords, embeddingService, {
+                        responsibilities: summary.responsibilities,
+                        owns: summary.owns,
+                        exports: summary.exports,
+                        projectType: summary.projectType,
+                    });
+                    console.error(`Registry updated for ${projectId}:`);
+                    console.error(`  - Description: ${summary.description.slice(0, 80)}...`);
+                    console.error(`  - Type: ${summary.projectType}`);
+                    console.error(`  - Responsibilities: ${summary.responsibilities.length}`);
+                    message += ` Registry updated with project summary.`;
+                }
+            }
+            catch (regError) {
+                console.error(`Warning: Failed to update registry: ${regError}`);
+                // Don't fail the whole operation if registry update fails
+            }
+        }
         return {
             success: result.success,
             message,

package/dist/tools/index.js

@@ -15,3 +15,5 @@ export * from "./syncProjects.js";
 export * from "./generateProjectDocs.js";
 export * from "./getProjectDocs.js";
 export * from "./manageAgents.js";
+// Export Task Orchestration tools
+export * from "./routeTask.js";

package/dist/tools/routeTask.js

@@ -0,0 +1,302 @@
+/**
+ * @fileoverview Task Routing Orchestrator
+ * Uses AI reasoning to analyze tasks and distribute work across projects
+ * based on their responsibilities. MANDATORY before any implementation.
+ */
+import OpenAI from "openai";
+import { RegistryManager } from "../common/registryManager.js";
+/**
+ * Builds a context string describing all projects and their responsibilities
+ */
+function buildProjectsContext(projects, currentProjectId) {
+    if (projects.length === 0) {
+        return "No other projects registered in the workspace.";
+    }
+    let context = "## Registered Projects in Workspace\n\n";
+    for (const project of projects) {
+        const isCurrent = project.projectId === currentProjectId;
+        context += `### ${project.projectId}${isCurrent ? ' (CURRENT - requesting agent)' : ''}\n`;
+        context += `- **Path**: ${project.path}\n`;
+        context += `- **Type**: ${project.projectType || 'unknown'}\n`;
+        context += `- **Description**: ${project.description || 'No description'}\n`;
+        if (project.responsibilities && project.responsibilities.length > 0) {
+            context += `- **Responsibilities**:\n`;
+            for (const resp of project.responsibilities) {
+                context += `  - ${resp}\n`;
+            }
+        }
+        if (project.owns && project.owns.length > 0) {
+            context += `- **Owns (file patterns)**: ${project.owns.join(', ')}\n`;
+        }
+        if (project.exports) {
+            context += `- **Exports**: ${project.exports}\n`;
+        }
+        context += '\n';
+    }
+    return context;
+}
+/**
+ * The main routing prompt for the AI orchestrator
+ */
+const ROUTING_PROMPT = `You are a Task Routing Orchestrator for a multi-project workspace. Your job is to analyze a task and determine which parts belong to which project based on their responsibilities.
+
+{projectsContext}
+
+## Task to Analyze
+**From Project**: {currentProject}
+**Task Description**: {taskDescription}
+
+## Your Analysis
+
+Analyze the task and determine:
+1. What components/code need to be created or modified?
+2. Which project is responsible for each component based on their declared responsibilities?
+3. If something doesn't exist in any project, it can be created by the requesting project
+4. If something SHOULD exist in another project (based on responsibilities), it must be delegated
+
+## Rules
+- If a project is responsible for DTOs, ALL DTOs must be created there, not in the API
+- If a project is responsible for services, shared services go there
+- If a project is responsible for utils/common code, shared utilities go there
+- The requesting project can ONLY implement what falls within its responsibilities
+- When in doubt, check the "owns" patterns to see what file types belong where
+
+## Response Format
+Respond with a JSON object:
+{
+  "action": "proceed" | "delegate" | "mixed",
+  "myResponsibilities": ["List of things the requesting project should implement"],
+  "delegations": [
+    {
+      "targetProject": "project-id",
+      "taskTitle": "Short title for the task",
+      "taskDescription": "Detailed description of what to create",
+      "reasoning": "Why this belongs to this project"
+    }
+  ],
+  "suggestedImports": ["packages or modules to import after delegations complete"],
+  "architectureNotes": "Explanation of the distribution decision",
+  "warning": "Optional warning if something seems off"
+}
+
+IMPORTANT:
+- "action" is "proceed" if everything can be done by the requesting project
+- "action" is "delegate" if everything needs to go to other projects
+- "action" is "mixed" if some work is local and some needs delegation
+- Be specific in taskDescription so the receiving project knows exactly what to create
+- Always explain the reasoning based on project responsibilities
+
+Respond ONLY with the JSON object.`;
+/**
+ * Routes a task to the appropriate project(s) based on responsibilities
+ */
+export async function routeTaskTool(params) {
+    const { projectId, taskDescription } = params;
+    if (!taskDescription || taskDescription.trim() === '') {
+        return {
+            success: false,
+            action: 'proceed',
+            myResponsibilities: [],
+            delegations: [],
+            suggestedImports: [],
+            architectureNotes: 'No task description provided.',
+            warning: 'Please provide a task description to analyze.',
+        };
+    }
+    console.error(`\n=== Task Routing Orchestrator ===`);
+    console.error(`Project: ${projectId}`);
+    console.error(`Task: ${taskDescription.slice(0, 100)}...`);
+    // Get all projects with their responsibilities
+    const registryManager = new RegistryManager();
+    const allProjects = await registryManager.getAllProjects();
+    console.error(`Found ${allProjects.length} projects in registry`);
+    // Check if we have any projects with responsibilities defined
+    const projectsWithResponsibilities = allProjects.filter(p => p.responsibilities && p.responsibilities.length > 0);
+    if (projectsWithResponsibilities.length === 0) {
+        console.error(`Warning: No projects have responsibilities defined`);
+        return {
+            success: true,
+            action: 'proceed',
+            myResponsibilities: ['All components (no other project responsibilities defined)'],
+            delegations: [],
+            suggestedImports: [],
+            architectureNotes: 'No other projects have responsibilities defined. You can proceed with the full implementation. Consider running memorybank_generate_project_docs on other projects to define their responsibilities.',
+            warning: 'No project responsibilities found in workspace. Run generate_project_docs on all projects first.',
+        };
+    }
+    // Build context for the AI
+    const projectsContext = buildProjectsContext(allProjects, projectId);
+    // Call AI to analyze and route
+    const apiKey = process.env.OPENAI_API_KEY;
+    if (!apiKey) {
+        return {
+            success: false,
+            action: 'proceed',
+            myResponsibilities: [],
+            delegations: [],
+            suggestedImports: [],
+            architectureNotes: 'OPENAI_API_KEY not configured. Cannot analyze task routing.',
+            warning: 'AI routing unavailable. Proceeding without validation.',
+        };
+    }
+    try {
+        const client = new OpenAI({ apiKey });
+        const prompt = ROUTING_PROMPT
+            .replace('{projectsContext}', projectsContext)
+            .replace('{currentProject}', projectId)
+            .replace('{taskDescription}', taskDescription);
+        console.error(`Calling AI orchestrator...`);
+        // Use reasoning model for better analysis
+        const model = process.env.MEMORYBANK_REASONING_MODEL || "gpt-5-mini";
+        const response = await client.responses.create({
+            model,
+            reasoning: {
+                effort: "medium",
+            },
+            input: [
+                {
+                    role: "user",
+                    content: prompt,
+                },
+            ],
+            max_output_tokens: 4000,
+        });
+        // Extract content from response
+        let content = "";
+        for (const item of response.output || []) {
+            if (item.type === "message" && item.content) {
+                for (const contentItem of item.content) {
+                    if (contentItem.type === "output_text") {
+                        content += contentItem.text;
+                    }
+                }
+            }
+        }
+        // Parse JSON response
+        const jsonMatch = content.match(/\{[\s\S]*\}/);
+        if (!jsonMatch) {
+            console.error(`Failed to parse orchestrator response`);
+            return {
+                success: false,
+                action: 'proceed',
+                myResponsibilities: [],
+                delegations: [],
+                suggestedImports: [],
+                architectureNotes: 'Failed to parse AI response.',
+                warning: 'Orchestrator analysis failed. Review task manually.',
+            };
+        }
+        const result = JSON.parse(jsonMatch[0]);
+        console.error(`\nOrchestrator Decision:`);
+        console.error(`  Action: ${result.action}`);
+        console.error(`  My responsibilities: ${result.myResponsibilities?.length || 0}`);
+        console.error(`  Delegations: ${result.delegations?.length || 0}`);
+        if (result.delegations && result.delegations.length > 0) {
+            console.error(`\n  Delegations:`);
+            for (const d of result.delegations) {
+                console.error(`    → ${d.targetProject}: ${d.taskTitle}`);
+            }
+        }
+        return {
+            success: true,
+            action: result.action || 'proceed',
+            myResponsibilities: result.myResponsibilities || [],
+            delegations: result.delegations || [],
+            suggestedImports: result.suggestedImports || [],
+            architectureNotes: result.architectureNotes || '',
+            warning: result.warning,
+        };
+    }
+    catch (error) {
+        console.error(`Error in task routing: ${error.message}`);
+        // Fallback to chat completions if responses API fails
+        if (error?.status === 404 || error?.code === "model_not_found") {
+            try {
+                const client = new OpenAI({ apiKey });
+                const prompt = ROUTING_PROMPT
+                    .replace('{projectsContext}', projectsContext)
+                    .replace('{currentProject}', projectId)
+                    .replace('{taskDescription}', taskDescription);
+                const response = await client.chat.completions.create({
+                    model: "gpt-4o",
+                    messages: [
+                        {
+                            role: "system",
+                            content: "You are a Task Routing Orchestrator. Analyze tasks and route them to the appropriate projects based on responsibilities. Respond with JSON only.",
+                        },
+                        {
+                            role: "user",
+                            content: prompt,
+                        },
+                    ],
+                    max_tokens: 4000,
+                });
+                const content = response.choices[0]?.message?.content || "";
+                const jsonMatch = content.match(/\{[\s\S]*\}/);
+                if (jsonMatch) {
+                    const result = JSON.parse(jsonMatch[0]);
+                    return {
+                        success: true,
+                        action: result.action || 'proceed',
+                        myResponsibilities: result.myResponsibilities || [],
+                        delegations: result.delegations || [],
+                        suggestedImports: result.suggestedImports || [],
+                        architectureNotes: result.architectureNotes || '',
+                        warning: result.warning,
+                    };
+                }
+            }
+            catch (fallbackError) {
+                console.error(`Fallback also failed: ${fallbackError}`);
+            }
+        }
+        return {
+            success: false,
+            action: 'proceed',
+            myResponsibilities: [],
+            delegations: [],
+            suggestedImports: [],
+            architectureNotes: `Error analyzing task: ${error.message}`,
+            warning: 'Orchestrator failed. Review task distribution manually.',
+        };
+    }
+}
+/**
+ * Tool definition for MCP
+ */
+export const routeTaskToolDefinition = {
+    name: "memorybank_route_task",
+    description: `🚨 OBLIGATORIO antes de implementar cualquier código.
+
+Analiza una tarea y determina qué partes corresponden a qué proyecto según sus responsabilidades.
+
+El orquestador:
+1. Lee las responsabilidades de TODOS los proyectos del workspace
+2. Analiza qué componentes necesita la tarea (DTOs, services, controllers, etc.)
+3. Asigna cada componente al proyecto responsable
+4. Devuelve un plan de acción con delegaciones
+
+DEBES llamar esta herramienta ANTES de escribir código para evitar:
+- Crear DTOs en un API cuando existe una lib-dtos
+- Duplicar services que ya existen en otro proyecto
+- Violar la separación de responsabilidades
+
+La respuesta incluye:
+- myResponsibilities: Lo que TÚ debes implementar
+- delegations: Tareas a delegar a otros proyectos
+- suggestedImports: Dependencias a usar tras las delegaciones`,
+    inputSchema: {
+        type: "object",
+        properties: {
+            projectId: {
+                type: "string",
+                description: "ID del proyecto que solicita el análisis (tu proyecto actual)",
+            },
+            taskDescription: {
+                type: "string",
+                description: "Descripción completa de la tarea a realizar",
+            },
+        },
+        required: ["projectId", "taskDescription"],
+    },
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@grec0/memory-bank-mcp",
-  "version": "0.1.40",
+  "version": "0.2.0",
   "description": "MCP server for semantic code indexing with Memory Bank - AI-powered codebase understanding",
   "license": "MIT",
   "author": "@grec0",
@@ -40,14 +40,14 @@
     "@lancedb/lancedb": "^0.9.0",
     "@modelcontextprotocol/sdk": "1.25.2",
     "@types/node": "^22",
+    "better-sqlite3": "^11.7.0",
     "gpt-tokenizer": "3.4.0",
     "ignore": "^5.3.0",
     "openai": "^4.0.0",
     "tree-sitter-wasms": "0.1.13",
-    "web-tree-sitter": "0.26.3",
+    "web-tree-sitter": "0.20.8",
     "zod": "^3.22.4",
-    "zod-to-json-schema": "^3.23.5",
-    "better-sqlite3": "^11.7.0"
+    "zod-to-json-schema": "^3.23.5"
   },
   "devDependencies": {
     "@jest/globals": "^29.7.0",