@grec0/memory-bank-mcp 0.2.6 → 0.2.8

package/dist/common/agentBoardSqlite.js

@@ -5,6 +5,9 @@
  */
 import { databaseManager } from './database.js';
 import * as crypto from 'crypto';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
 // ============================================================================
 // Agent Board SQLite Implementation
 // ============================================================================
@@ -20,6 +23,7 @@ export class AgentBoardSqlite {
      * Register a new agent for this project.
      * Automatically deactivates any previous active agent.
      * The MCP generates the hash suffix - client only provides base ID.
+     * Also syncs project keywords/responsibilities from registry to SQLite.
      */
     registerAgent(baseAgentId, sessionId) {
         const db = databaseManager.getConnection();
@@ -29,6 +33,23 @@ export class AgentBoardSqlite {
         // Generate session ID if not provided
         const effectiveSessionId = sessionId || crypto.randomUUID();
         const now = new Date().toISOString();
+        // Get project metadata from registry (keywords, responsibilities) - sync read
+        let keywords = [];
+        let responsibilities = [];
+        try {
+            const registryPath = path.join(os.homedir(), '.memorybank', 'global_registry.json');
+            if (fs.existsSync(registryPath)) {
+                const registryData = JSON.parse(fs.readFileSync(registryPath, 'utf-8'));
+                const project = registryData.projects?.find((p) => p.projectId === this.projectId);
+                if (project) {
+                    keywords = project.keywords || [];
+                    responsibilities = project.responsibilities || [];
+                }
+            }
+        }
+        catch (e) {
+            // Registry not available, continue without metadata
+        }
         return databaseManager.transaction(() => {
             // Deactivate any currently active agents for this project
             db.prepare(`
@@ -36,11 +57,11 @@ export class AgentBoardSqlite {
                 SET status = 'INACTIVE', last_heartbeat = ?
                 WHERE project_id = ? AND status = 'ACTIVE'
             `).run(now, this.projectId);
-            // Insert new agent as ACTIVE
+            // Insert new agent as ACTIVE with project metadata
             db.prepare(`
-                INSERT INTO agents (id, project_id, session_id, status, focus, last_heartbeat)
-                VALUES (?, ?, ?, 'ACTIVE', '-', ?)
-            `).run(fullAgentId, this.projectId, effectiveSessionId, now);
+                INSERT INTO agents (id, project_id, session_id, status, focus, last_heartbeat, keywords, responsibilities)
+                VALUES (?, ?, ?, 'ACTIVE', '-', ?, ?, ?)
+            `).run(fullAgentId, this.projectId, effectiveSessionId, now, JSON.stringify(keywords), JSON.stringify(responsibilities));
             // Log the registration
             this.logMessage(fullAgentId, `Agent registered and activated`);
             return { agentId: fullAgentId, sessionId: effectiveSessionId };

package/dist/common/database.js

@@ -7,7 +7,7 @@ import Database from 'better-sqlite3';
 import * as path from 'path';
 import * as os from 'os';
 import * as fs from 'fs';
-const SCHEMA_VERSION = 2; // v2: Added orchestrator_logs table
+const SCHEMA_VERSION = 3; // v2: Added orchestrator_logs table, v3: Added keywords/responsibilities to agents
 /**
  * SQL Schema for Agent Board
  */
@@ -21,6 +21,8 @@ CREATE TABLE IF NOT EXISTS agents (
     status TEXT NOT NULL DEFAULT 'ACTIVE',  -- ACTIVE, INACTIVE
     focus TEXT DEFAULT '-',                 -- Current task/file being worked on
     last_heartbeat TEXT NOT NULL,           -- ISO timestamp of last activity
+    keywords TEXT,                          -- JSON array of project keywords (synced from registry)
+    responsibilities TEXT,                  -- JSON array of project responsibilities (synced from registry)
     created_at TEXT NOT NULL DEFAULT (datetime('now')),
     PRIMARY KEY (id, project_id)
 );
@@ -180,6 +182,26 @@ class DatabaseManager {
             console.error(`[Database] Migrating schema from v${currentVersion} to v${SCHEMA_VERSION}`);
             // Run schema creation (IF NOT EXISTS makes it safe)
             this.db.exec(SCHEMA_SQL);
+            // v3 migration: Add keywords and responsibilities columns to agents table
+            if (currentVersion < 3) {
+                try {
+                    // Check if columns already exist
+                    const tableInfo = this.db.prepare("PRAGMA table_info(agents)").all();
+                    const hasKeywords = tableInfo.some(col => col.name === 'keywords');
+                    const hasResponsibilities = tableInfo.some(col => col.name === 'responsibilities');
+                    if (!hasKeywords) {
+                        this.db.exec('ALTER TABLE agents ADD COLUMN keywords TEXT');
+                        console.error('[Database] Added keywords column to agents table');
+                    }
+                    if (!hasResponsibilities) {
+                        this.db.exec('ALTER TABLE agents ADD COLUMN responsibilities TEXT');
+                        console.error('[Database] Added responsibilities column to agents table');
+                    }
+                }
+                catch (alterError) {
+                    console.error(`[Database] Warning during v3 migration: ${alterError.message}`);
+                }
+            }
             // Record/update schema version
             this.db.prepare('INSERT OR REPLACE INTO schema_version (version) VALUES (?)').run(SCHEMA_VERSION);
             console.error(`[Database] Schema initialized at v${SCHEMA_VERSION}`);

package/dist/common/version.js

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

package/dist/tools/routeTask.js

@@ -41,28 +41,26 @@ function buildProjectsContext(projects, currentProjectId) {
     return context;
 }
 /**
- * Tools available to the orchestrator for verification
+ * Tools available to the orchestrator for verification (Responses API format)
  */
 const ORCHESTRATOR_TOOLS = [
     {
         type: "function",
-        function: {
-            name: "semantic_search",
-            description: "Search for code semantically in a specific project. Use this to verify if code already exists, where implementations are located, or to understand project structure before routing decisions.",
-            parameters: {
-                type: "object",
-                properties: {
-                    projectId: {
-                        type: "string",
-                        description: "The project ID to search in",
-                    },
-                    query: {
-                        type: "string",
-                        description: "Natural language query describing what you're looking for (e.g., 'UserDTO class', 'authentication service', 'database connection')",
-                    },
+        name: "semantic_search",
+        description: "Search for code semantically in a specific project. Use this to verify if code already exists, where implementations are located, or to understand project structure before routing decisions.",
+        parameters: {
+            type: "object",
+            properties: {
+                projectId: {
+                    type: "string",
+                    description: "The project ID to search in",
+                },
+                query: {
+                    type: "string",
+                    description: "Natural language query describing what you're looking for (e.g., 'UserDTO class', 'authentication service', 'database connection')",
                 },
-                required: ["projectId", "query"],
             },
+            required: ["projectId", "query"],
         },
     },
 ];
@@ -227,21 +225,18 @@ export async function routeTaskTool(params, indexManager) {
             warning: 'AI routing unavailable. Proceeding without validation.',
         };
     }
-    // Model used for routing (needed for logging both success and error cases)
-    const model = process.env.MEMORYBANK_ROUTING_MODEL || "gpt-4o";
+    // Model and reasoning config (use same as project knowledge service)
+    const model = process.env.MEMORYBANK_REASONING_MODEL || "gpt-5-mini";
+    const reasoningEffort = process.env.MEMORYBANK_REASONING_EFFORT || "medium";
     try {
         const client = new OpenAI({ apiKey });
         const prompt = ROUTING_PROMPT
             .replace('{projectsContext}', projectsContext)
             .replace('{currentProject}', projectId)
             .replace('{taskDescription}', taskDescription);
-        console.error(`Calling AI orchestrator with tool access (${model})...`);
-        // Initialize conversation
-        const messages = [
-            {
-                role: "system",
-                content: "You are a Task Routing Orchestrator. Analyze tasks and route them to appropriate projects. You can use semantic_search to verify where code exists before making decisions. Always respond with JSON after your analysis.",
-            },
+        console.error(`Calling AI orchestrator with Responses API (${model}, effort: ${reasoningEffort})...`);
+        // Build initial input for Responses API
+        const input = [
             {
                 role: "user",
                 content: prompt,
@@ -254,42 +249,67 @@ export async function routeTaskTool(params, indexManager) {
         while (iterations < maxIterations) {
             iterations++;
             console.error(`  Iteration ${iterations}/${maxIterations}`);
-            const response = await client.chat.completions.create({
+            // Call Responses API with reasoning
+            const response = await client.responses.create({
                 model,
-                messages,
+                reasoning: {
+                    effort: reasoningEffort,
+                },
+                instructions: "You are a Task Routing Orchestrator. Analyze tasks and route them to appropriate projects. You can use semantic_search to verify where code exists before making decisions. Always respond with JSON after your analysis.",
+                input,
                 tools: ORCHESTRATOR_TOOLS,
                 tool_choice: "auto",
-                max_tokens: 4000,
+                max_output_tokens: 8000,
             });
-            const message = response.choices[0]?.message;
-            if (!message) {
-                console.error(`  No message in response`);
-                break;
+            // Process output items from Responses API
+            let hasToolCalls = false;
+            const toolCalls = [];
+            for (const item of response.output || []) {
+                if (item.type === "function_call") {
+                    hasToolCalls = true;
+                    toolCalls.push({
+                        id: item.call_id,
+                        name: item.name,
+                        arguments: item.arguments,
+                    });
+                }
+                else if (item.type === "message" && item.content) {
+                    // Extract text content from message
+                    for (const contentItem of item.content) {
+                        if (contentItem.type === "output_text") {
+                            finalResponse = contentItem.text;
+                        }
+                    }
+                }
             }
-            // Check if there are tool calls
-            if (message.tool_calls && message.tool_calls.length > 0) {
-                console.error(`  Model requested ${message.tool_calls.length} tool call(s)`);
-                // Add assistant message with tool calls
-                messages.push(message);
-                // Execute each tool call
-                for (const toolCall of message.tool_calls) {
-                    const toolName = toolCall.function.name;
-                    const toolArgs = JSON.parse(toolCall.function.arguments);
-                    const toolResult = await executeToolCall(toolName, toolArgs, allProjects, indexManager);
-                    // Add tool result to messages
-                    messages.push({
-                        role: "tool",
-                        tool_call_id: toolCall.id,
-                        content: toolResult,
+            if (hasToolCalls) {
+                console.error(`  Model requested ${toolCalls.length} tool call(s)`);
+                // Execute each tool call and add results to input
+                for (const toolCall of toolCalls) {
+                    const toolArgs = JSON.parse(toolCall.arguments);
+                    const toolResult = await executeToolCall(toolCall.name, toolArgs, allProjects, indexManager);
+                    // Add function call and result to input for next iteration
+                    input.push({
+                        type: "function_call",
+                        call_id: toolCall.id,
+                        name: toolCall.name,
+                        arguments: toolCall.arguments,
+                    });
+                    input.push({
+                        type: "function_call_output",
+                        call_id: toolCall.id,
+                        output: toolResult,
                     });
                 }
             }
-            else {
-                // No tool calls, this is the final response
-                finalResponse = message.content;
+            else if (finalResponse) {
                 console.error(`  Final response received`);
                 break;
             }
+            else {
+                console.error(`  No response or tool calls`);
+                break;
+            }
         }
         if (!finalResponse) {
             console.error(`  No final response after ${iterations} iterations`);

package/package.json

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