@grec0/memory-bank-mcp 0.1.21 → 0.1.22

package/dist/common/projectKnowledgeService.js

@@ -152,14 +152,18 @@ Generate a markdown document useful for setting up the development environment.`
         filename: "activeContext.md",
         title: "Active Context",
         description: "Current development state, recent changes, and work in progress",
-        promptTemplate: `Analyze the following recently modified code chunks and generate an Active Context document.
+        promptTemplate: `Analyze the following recently modified code chunks and current session history to generate an Active Context document.
 
 Document:
-1. **Recent Changes**: What parts of the code were recently modified?
-2. **Work in Progress**: Features or fixes that appear incomplete
-3. **Hot Areas**: Parts of the code with high activity
-4. **Potential Issues**: Code that might need attention (TODOs, FIXMEs)
-5. **Current Focus**: What seems to be the current development focus?
+1. **Current Session Status**: Summary of actions performed in the current session (from history).
+2. **Recent Changes**: What parts of the code were recently modified?
+3. **Work in Progress**: Features or fixes that appear incomplete
+4. **Hot Areas**: Parts of the code with high activity
+5. **Potential Issues**: Code that might need attention (TODOs, FIXMEs)
+6. **Current Focus**: What seems to be the current development focus?
+
+Recent session history:
+{sessionHistory}
 
 Recent code chunks:
 {chunks}
@@ -320,6 +324,9 @@ export class ProjectKnowledgeService {
             .join("|");
         return crypto.createHash("md5").update(content).digest("hex");
     }
+    hashString(str) {
+        return crypto.createHash("md5").update(str).digest("hex");
+    }
     /**
      * Prepares chunks for inclusion in a prompt
      * Uses Map-Reduce summarization if content exceeds context window threshold
@@ -603,9 +610,9 @@ ${chunk.content}
     /**
      * Generates a single document for a specific project
      */
-    async generateDocument(projectId, type, chunks, force = false, previousProgress) {
+    async generateDocument(projectId, type, chunks, force = false, previousProgress, sessionHistory) {
         const definition = DOC_DEFINITIONS[type];
-        const inputHash = this.hashChunks(chunks);
+        const inputHash = this.hashChunks(chunks) + (sessionHistory ? this.hashString(sessionHistory) : 0);
         const docsPath = this.ensureProjectDocsDirectory(projectId);
         const metadataCache = this.loadProjectMetadata(projectId);
         // Check if regeneration is needed
@@ -620,6 +627,12 @@ ${chunk.content}
         const preparedChunks = await this.prepareChunksForPrompt(chunks, this.options.maxChunksPerDoc);
         console.error(`  Chunks text length: ${preparedChunks.text.length} chars${preparedChunks.usedMapReduce ? ' (after Map-Reduce)' : ''}`);
         let prompt = definition.promptTemplate.replace("{chunks}", preparedChunks.text);
+        if (sessionHistory) {
+            prompt = prompt.replace("{sessionHistory}", sessionHistory);
+        }
+        else {
+            prompt = prompt.replace("{sessionHistory}", "No recent session history available.");
+        }
         if (type === "progress" && previousProgress) {
             prompt = prompt.replace("{previousProgress}", previousProgress);
         }
@@ -655,7 +668,7 @@ ${chunk.content}
     /**
      * Generates all project documents (in parallel for speed)
      */
-    async generateAllDocuments(projectId, chunks, force = false) {
+    async generateAllDocuments(projectId, chunks, force = false, sessionHistory) {
         const result = {
             success: true,
             documentsGenerated: [],
@@ -694,7 +707,7 @@ ${chunk.content}
                 const docChunks = docType === "activeContext" ? recentChunks : chunks;
                 const existingMetadata = metadataCache.get(docType);
                 const isNew = !existingMetadata;
-                const doc = await this.generateDocument(projectId, docType, docChunks, force, docType === "progress" ? previousProgress : undefined);
+                const doc = await this.generateDocument(projectId, docType, docChunks, force, docType === "progress" ? previousProgress : undefined, sessionHistory);
                 return { docType, doc, isNew, error: null };
             }
             catch (error) {

package/dist/common/sessionState.js

@@ -0,0 +1,24 @@
+export class SessionState {
+    static instance;
+    currentAgentId = null;
+    currentProjectId = null;
+    constructor() { }
+    static getInstance() {
+        if (!SessionState.instance) {
+            SessionState.instance = new SessionState();
+        }
+        return SessionState.instance;
+    }
+    setCurrentAgent(agentId, projectId) {
+        this.currentAgentId = agentId;
+        this.currentProjectId = projectId;
+        console.error(`[SessionState] Set Active Agent: ${agentId} for Project: ${projectId}`);
+    }
+    getCurrentAgentId() {
+        return this.currentAgentId;
+    }
+    getCurrentProjectId() {
+        return this.currentProjectId;
+    }
+}
+export const sessionState = SessionState.getInstance();

package/dist/common/version.js

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

package/dist/index.js

@@ -159,10 +159,6 @@ server.tool("memorybank_search", "Busca código relevante mediante búsqueda sem
         .string()
         .optional()
         .describe("Filtrar resultados por lenguaje de programación (ej: 'typescript', 'python')"),
-    agentId: z
-        .string()
-        .optional()
-        .describe("Identificador del agente (para logging de sesión)"),
 }, async (args) => {
     const result = await searchMemory({
         projectId: args.projectId,
@@ -171,7 +167,6 @@ server.tool("memorybank_search", "Busca código relevante mediante búsqueda sem
         minScore: args.minScore,
         filterByFile: args.filterByFile,
         filterByLanguage: args.filterByLanguage,
-        agentId: args.agentId,
     }, indexManager, workspaceRoot);
     return {
         content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
@@ -193,11 +188,16 @@ Ejemplo: "C:/workspaces/proyecto/src/index.ts"`, {
         .number()
         .optional()
         .describe("Línea final (opcional)"),
+    projectId: z
+        .string()
+        .optional()
+        .describe("Identificador del proyecto (Opcional, pero necesario para logging de sesión)"),
 }, async (args) => {
     const result = await readFile({
         path: args.path,
         startLine: args.startLine,
         endLine: args.endLine,
+        projectId: args.projectId,
     }, workspaceRoot);
     return {
         content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
@@ -314,7 +314,7 @@ server.tool(generateProjectDocsToolDefinition.name, generateProjectDocsToolDefin
     const result = await generateProjectDocs({
         projectId: args.projectId,
         force: args.force,
-    }, projectKnowledgeService, vectorStore);
+    }, projectKnowledgeService, vectorStore, workspaceRoot);
     return {
         content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
     };

package/dist/tools/generateProjectDocs.js

@@ -2,15 +2,43 @@
  * @fileoverview Tool for generating project documentation
  * Uses the Project Knowledge Service to create structured markdown docs
  */
+import { AgentBoard } from "../common/agentBoard.js";
+import { sessionLogger } from "../common/sessionLogger.js";
+import { sessionState } from "../common/sessionState.js";
 /**
  * Generates project documentation using AI reasoning
  */
-export async function generateProjectDocs(params, projectKnowledgeService, vectorStore) {
+export async function generateProjectDocs(params, projectKnowledgeService, vectorStore, workspaceRoot = process.cwd() // Add workspaceRoot
+) {
     try {
         console.error("\n=== Generating Project Documentation ===");
-        console.error(`Project ID: ${params.projectId || "default"}`);
+        const projectId = params.projectId || "default";
+        console.error(`Project ID: ${projectId}`);
+        // Fetch Session History via Session State
+        let sessionHistory;
+        const activeAgentId = sessionState.getCurrentAgentId();
+        if (activeAgentId) {
+            try {
+                const board = new AgentBoard(workspaceRoot, projectId);
+                const sessionId = await board.getSessionId(activeAgentId);
+                if (sessionId) {
+                    console.error(`Fetching session history for session: ${sessionId}`);
+                    const history = await sessionLogger.getSessionHistory(projectId, sessionId);
+                    if (history && history.length > 0) {
+                        // Summarize last 20 events
+                        const recentEvents = history.slice(-20);
+                        sessionHistory = recentEvents.map(e => {
+                            const dataStr = JSON.stringify(e.data).slice(0, 200); // Truncate data
+                            return `- [${e.timestamp.split('T')[1].split('.')[0]}] ${e.type}: ${dataStr}`;
+                        }).join('\n');
+                    }
+                }
+            }
+            catch (e) {
+                console.error(`Warning: Failed to fetch session history: ${e}`);
+            }
+        }
         console.error(`Force regeneration: ${params.force || false}`);
-        // Get all chunks from the vector store
         const chunks = await vectorStore.getAllChunks(params.projectId);
         if (chunks.length === 0) {
             return {
@@ -34,8 +62,7 @@ export async function generateProjectDocs(params, projectKnowledgeService, vecto
         }
         console.error(`Found ${chunks.length} code chunks to analyze`);
         // Generate documents - projectId is required
-        const projectId = params.projectId || "default";
-        const result = await projectKnowledgeService.generateAllDocuments(projectId, chunks, params.force || false);
+        const result = await projectKnowledgeService.generateAllDocuments(projectId, chunks, params.force || false, sessionHistory);
         // Calculate estimated cost (approximate rates for gpt-5-mini)
         // Reasoning tokens are typically more expensive
         const reasoningCostPer1K = 0.003; // $0.003 per 1K reasoning tokens

package/dist/tools/getProjectDocs.js

@@ -4,6 +4,7 @@
  */
 import { AgentBoard } from "../common/agentBoard.js";
 import { sessionLogger } from "../common/sessionLogger.js";
+import { sessionState } from "../common/sessionState.js";
 const VALID_DOC_TYPES = [
     "projectBrief",
     "productContext",
@@ -17,25 +18,25 @@ const VALID_DOC_TYPES = [
  */
 export async function getProjectDocs(params, projectKnowledgeService, workspaceRoot) {
     const logSession = async (outputSummary) => {
-        if (params.agentId && workspaceRoot) {
+        const activeAgentId = sessionState.getCurrentAgentId();
+        if (activeAgentId && workspaceRoot) {
             try {
                 const board = new AgentBoard(workspaceRoot, params.projectId);
-                const sessionId = await board.getSessionId(params.agentId);
+                const sessionId = await board.getSessionId(activeAgentId);
                 if (sessionId) {
-                    // Use singleton sessionLogger
                     await sessionLogger.logSessionEvent(params.projectId, sessionId, {
                         timestamp: new Date().toISOString(),
                         type: 'read_doc',
                         data: {
-                            document: params.document || 'all',
-                            format: params.format || 'full',
+                            document: params.document,
+                            format: params.format,
                             summary: outputSummary
                         }
                     });
                 }
             }
-            catch (error) {
-                console.error(`Failed to log doc session: ${error}`);
+            catch (logError) {
+                console.error(`Failed to log read_doc session: ${logError}`);
             }
         }
     };

package/dist/tools/indexCode.js

@@ -3,6 +3,9 @@
  * Indexes code files semantically
  */
 import * as path from "path";
+import { AgentBoard } from "../common/agentBoard.js";
+import { sessionLogger } from "../common/sessionLogger.js";
+import { sessionState } from "../common/sessionState.js";
 /**
  * Indexes code from a directory or file
  */
@@ -16,6 +19,28 @@ export async function indexCode(params, indexManager, workspaceRoot) {
             : workspaceRoot;
         console.error(`\nIndexing code at: ${targetPath}`);
         console.error(`Project ID: ${params.projectId}`);
+        // Session Logging via Session State
+        const activeAgentId = sessionState.getCurrentAgentId();
+        if (activeAgentId) {
+            try {
+                const board = new AgentBoard(workspaceRoot, params.projectId);
+                const sessionId = await board.getSessionId(activeAgentId);
+                if (sessionId) {
+                    await sessionLogger.logSessionEvent(params.projectId, sessionId, {
+                        timestamp: new Date().toISOString(),
+                        type: 'index',
+                        data: {
+                            path: targetPath,
+                            recursive: params.recursive !== false,
+                            force: params.forceReindex || false
+                        }
+                    });
+                }
+            }
+            catch (logError) {
+                console.error(`Failed to log session event: ${logError}`);
+            }
+        }
         console.error(`Workspace root: ${workspaceRoot}`);
         console.error(`Recursive: ${params.recursive !== false}`);
         console.error(`Force reindex: ${params.forceReindex || false}`);

package/dist/tools/manageAgents.js

@@ -1,5 +1,6 @@
 import { AgentBoard } from '../common/agentBoard.js';
 import { RegistryManager } from '../common/registryManager.js';
+import { sessionState } from '../common/sessionState.js';
 import * as crypto from 'crypto';
 const WORKSPACE_ROOT = process.cwd(); // Will be overridden by actual workspace logic if passed
 export async function manageAgentsTool(params, workspaceRoot = WORKSPACE_ROOT) {
@@ -10,6 +11,8 @@ export async function manageAgentsTool(params, workspaceRoot = WORKSPACE_ROOT) {
             case 'register':
                 if (!agentId)
                     throw new Error('agentId is required for register');
+                // Set Global Session State
+                sessionState.setCurrentAgent(agentId, projectId);
                 // Auto-generate session ID if not provided.
                 const effectiveSessionId = sessionId || crypto.randomUUID();
                 // 1. Register agent on local board

package/dist/tools/readFile.js

@@ -4,6 +4,9 @@
  */
 import * as fs from "fs";
 import * as path from "path";
+import { AgentBoard } from "../common/agentBoard.js";
+import { sessionLogger } from "../common/sessionLogger.js";
+import { sessionState } from "../common/sessionState.js";
 /**
  * Reads a file from the workspace
  */
@@ -13,6 +16,27 @@ export async function readFile(params, workspaceRoot) {
         const filePath = path.isAbsolute(params.path)
             ? params.path
             : path.join(workspaceRoot, params.path);
+        // Session Logging via Session State
+        const activeAgentId = sessionState.getCurrentAgentId();
+        if (activeAgentId && params.projectId) {
+            try {
+                const board = new AgentBoard(workspaceRoot, params.projectId);
+                const sessionId = await board.getSessionId(activeAgentId);
+                if (sessionId) {
+                    await sessionLogger.logSessionEvent(params.projectId, sessionId, {
+                        timestamp: new Date().toISOString(),
+                        type: 'read_file',
+                        data: {
+                            path: params.path,
+                            lines: params.startLine && params.endLine ? `${params.startLine}-${params.endLine}` : 'all'
+                        }
+                    });
+                }
+            }
+            catch (logError) {
+                console.error(`Failed to log session event: ${logError}`);
+            }
+        }
         // Check if file exists
         if (!fs.existsSync(filePath)) {
             return {

package/dist/tools/searchMemory.js

@@ -4,6 +4,7 @@
  */
 import { AgentBoard } from "../common/agentBoard.js";
 import { sessionLogger } from "../common/sessionLogger.js";
+import { sessionState } from "../common/sessionState.js";
 /**
  * Searches the Memory Bank for relevant code
  */
@@ -36,11 +37,12 @@ export async function searchMemory(params, indexManager, workspaceRoot) {
             filterByFile: params.filterByFile,
             filterByLanguage: params.filterByLanguage,
         });
-        // Session Logging
-        if (params.agentId && workspaceRoot) {
+        // Session Logging via Session State
+        const activeAgentId = sessionState.getCurrentAgentId();
+        if (activeAgentId && workspaceRoot) {
             try {
                 const board = new AgentBoard(workspaceRoot, params.projectId);
-                const sessionId = await board.getSessionId(params.agentId);
+                const sessionId = await board.getSessionId(activeAgentId);
                 if (sessionId) {
                     await sessionLogger.logSessionEvent(params.projectId, sessionId, {
                         timestamp: new Date().toISOString(),

package/dist/tools/writeFile.js

@@ -4,6 +4,9 @@
  */
 import * as fs from "fs";
 import * as path from "path";
+import { AgentBoard } from "../common/agentBoard.js";
+import { sessionLogger } from "../common/sessionLogger.js";
+import { sessionState } from "../common/sessionState.js";
 /**
  * Writes a file and optionally reindexes it
  */
@@ -13,6 +16,40 @@ export async function writeFile(params, indexManager, workspaceRoot) {
         const filePath = path.isAbsolute(params.path)
             ? params.path
             : path.join(workspaceRoot, params.path);
+        // Auto-Locking & Logging via Session State
+        const activeAgentId = sessionState.getCurrentAgentId();
+        if (activeAgentId) {
+            const board = new AgentBoard(workspaceRoot, params.projectId);
+            // 1. Check/Claim Lock
+            // Normalize path for locking (relative to workspace)
+            const relativePath = path.relative(workspaceRoot, filePath).replace(/\\/g, '/');
+            const canWrite = await board.claimResource(activeAgentId, relativePath);
+            if (!canWrite) {
+                return {
+                    success: false,
+                    filePath: params.path,
+                    message: `File is locked by another agent. Write rejected.`
+                };
+            }
+            // 2. Log Session Event
+            try {
+                const sessionId = await board.getSessionId(activeAgentId);
+                if (sessionId) {
+                    await sessionLogger.logSessionEvent(params.projectId, sessionId, {
+                        timestamp: new Date().toISOString(),
+                        type: 'decision',
+                        data: {
+                            action: 'write_file',
+                            path: params.path,
+                            byteSize: Buffer.byteLength(params.content, "utf-8")
+                        }
+                    });
+                }
+            }
+            catch (e) {
+                console.error("Failed to log session event:", e);
+            }
+        }
         // Ensure directory exists
         const dir = path.dirname(filePath);
         if (!fs.existsSync(dir)) {

package/package.json

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