mcp-adr-analysis-server 2.0.21 → 2.0.24

package/dist/src/utils/knowledge-graph-manager.d.ts

@@ -3,13 +3,15 @@ export declare class KnowledgeGraphManager {
     private cacheDir;
     private snapshotsFile;
     private syncStateFile;
-    private healthScoring;
+    private memoryScoring;
     constructor();
     ensureCacheDirectory(): Promise<void>;
     loadKnowledgeGraph(): Promise<KnowledgeGraphSnapshot>;
     saveKnowledgeGraph(snapshot: KnowledgeGraphSnapshot): Promise<void>;
     createIntent(humanRequest: string, parsedGoals: string[], priority?: 'high' | 'medium' | 'low'): Promise<string>;
     addToolExecution(intentId: string, toolName: string, parameters: Record<string, any>, result: Record<string, any>, success: boolean, todoTasksCreated?: string[], todoTasksModified?: string[], error?: string): Promise<void>;
+    addMemoryExecution(toolName: string, action: string, entityType: string, success: boolean, details?: Record<string, any>): Promise<void>;
+    private updateMemoryAnalytics;
     updateIntentStatus(intentId: string, status: 'planning' | 'executing' | 'completed' | 'failed'): Promise<void>;
     updateTodoSnapshot(intentId: string, todoContent: string): Promise<void>;
     getSyncState(): Promise<TodoSyncState>;
@@ -74,5 +76,25 @@ export declare class KnowledgeGraphManager {
         timestamp: string;
         structureData: any;
     }): Promise<void>;
+    /**
+     * Calculate memory-based health score from knowledge graph
+     */
+    private calculateMemoryScore;
+    /**
+     * Extract memory representations from knowledge graph
+     */
+    private extractMemoriesFromKG;
+    /**
+     * Calculate retrieval metrics from tool execution patterns
+     */
+    private calculateRetrievalMetrics;
+    /**
+     * Build entity graph from knowledge graph
+     */
+    private buildEntityGraph;
+    /**
+     * Calculate relevance score for an intent
+     */
+    private calculateIntentRelevance;
 }
 //# sourceMappingURL=knowledge-graph-manager.d.ts.map

package/dist/src/utils/knowledge-graph-manager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"knowledge-graph-manager.d.ts","sourceRoot":"","sources":["../../../src/utils/knowledge-graph-manager.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"knowledge-graph-manager.d.ts","sourceRoot":"","sources":["../../../src/utils/knowledge-graph-manager.ts"],"names":[],"mappings":"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"}

package/dist/src/utils/knowledge-graph-manager.js

@@ -1,20 +1,21 @@
 import * as fs from 'fs/promises';
 import path from 'path';
 import crypto from 'crypto';
-import { TodoSyncStateSchema, KnowledgeGraphSnapshotSchema } from '../types/knowledge-graph-schemas.js';
+import { TodoSyncStateSchema, KnowledgeGraphSnapshotSchema, } from '../types/knowledge-graph-schemas.js';
 import { loadConfig } from './config.js';
-import { ProjectHealthScoring } from './project-health-scoring.js';
+// Using new MemoryHealthScoring instead of deprecated ProjectHealthScoring
+import { MemoryHealthScoring } from './memory-health-scoring.js';
 export class KnowledgeGraphManager {
     cacheDir;
     snapshotsFile;
     syncStateFile;
-    healthScoring;
+    memoryScoring;
     constructor() {
         const config = loadConfig();
         this.cacheDir = path.join(config.projectPath, '.mcp-adr-cache');
         this.snapshotsFile = path.join(this.cacheDir, 'knowledge-graph-snapshots.json');
         this.syncStateFile = path.join(this.cacheDir, 'todo-sync-state.json');
-        this.healthScoring = new ProjectHealthScoring(config.projectPath);
+        this.memoryScoring = new MemoryHealthScoring();
     }
     async ensureCacheDirectory() {
         try {
@@ -44,9 +45,9 @@ export class KnowledgeGraphManager {
                     activeIntents: 0,
                     averageGoalCompletion: 0,
                     mostUsedTools: [],
-                    successfulPatterns: []
+                    successfulPatterns: [],
                 },
-                scoreHistory: []
+                scoreHistory: [],
             };
             await this.saveKnowledgeGraph(defaultSnapshot);
             // Also create the separate sync state file
@@ -62,7 +63,9 @@ export class KnowledgeGraphManager {
         const intentId = crypto.randomUUID();
         const timestamp = new Date().toISOString();
         // Get current score as baseline
-        const currentScore = await this.healthScoring.getProjectHealthScore();
+        // Calculate memory-based health score
+        const kgData = await this.loadKnowledgeGraph();
+        const currentScore = await this.calculateMemoryScore(kgData);
         const intent = {
             intentId,
             humanRequest,
@@ -76,37 +79,37 @@ export class KnowledgeGraphManager {
                 initialScore: currentScore.overall,
                 currentScore: currentScore.overall,
                 componentScores: {
-                    taskCompletion: currentScore.taskCompletion,
-                    deploymentReadiness: currentScore.deploymentReadiness,
-                    architectureCompliance: currentScore.architectureCompliance,
-                    securityPosture: currentScore.securityPosture,
-                    codeQuality: currentScore.codeQuality
+                    taskCompletion: currentScore.memoryQuality,
+                    deploymentReadiness: currentScore.retrievalPerformance,
+                    architectureCompliance: currentScore.entityCoherence,
+                    securityPosture: currentScore.contextUtilization,
+                    codeQuality: currentScore.decisionAlignment,
                 },
-                lastScoreUpdate: timestamp
-            }
+                lastScoreUpdate: timestamp,
+            },
         };
-        const kg = await this.loadKnowledgeGraph();
-        kg.intents.push(intent);
-        kg.analytics.totalIntents = kg.intents.length;
-        kg.analytics.activeIntents = kg.intents.filter(i => i.currentStatus !== 'completed').length;
+        const kgUpdate = await this.loadKnowledgeGraph();
+        kgUpdate.intents.push(intent);
+        kgUpdate.analytics.totalIntents = kgUpdate.intents.length;
+        kgUpdate.analytics.activeIntents = kgUpdate.intents.filter(i => i.currentStatus !== 'completed').length;
         // Add score history entry
-        if (!kg.scoreHistory)
-            kg.scoreHistory = [];
-        kg.scoreHistory.push({
+        if (!kgUpdate.scoreHistory)
+            kgUpdate.scoreHistory = [];
+        kgUpdate.scoreHistory.push({
             timestamp,
             intentId,
             overallScore: currentScore.overall,
             componentScores: {
-                taskCompletion: currentScore.taskCompletion,
-                deploymentReadiness: currentScore.deploymentReadiness,
-                architectureCompliance: currentScore.architectureCompliance,
-                securityPosture: currentScore.securityPosture,
-                codeQuality: currentScore.codeQuality
+                taskCompletion: currentScore.memoryQuality,
+                deploymentReadiness: currentScore.retrievalPerformance,
+                architectureCompliance: currentScore.entityCoherence,
+                securityPosture: currentScore.contextUtilization,
+                codeQuality: currentScore.decisionAlignment,
             },
             triggerEvent: `Intent created: ${humanRequest.substring(0, 100)}...`,
-            confidence: currentScore.confidence
+            confidence: currentScore.confidence,
         });
-        await this.saveKnowledgeGraph(kg);
+        await this.saveKnowledgeGraph(kgUpdate);
         return intentId;
     }
     async addToolExecution(intentId, toolName, parameters, result, success, todoTasksCreated = [], todoTasksModified = [], error) {
@@ -116,7 +119,8 @@ export class KnowledgeGraphManager {
             throw new Error(`Intent ${intentId} not found`);
         }
         // Capture before score
-        const beforeScore = await this.healthScoring.getProjectHealthScore();
+        // ProjectHealthScoring removed - get current memory score
+        const beforeScore = await this.memoryScoring.calculateMemoryHealth([], {}, {});
         const execution = {
             toolName,
             parameters,
@@ -125,7 +129,7 @@ export class KnowledgeGraphManager {
             todoTasksModified,
             executionTime: new Date().toISOString(),
             success,
-            error
+            error,
         };
         intent.toolChain.push(execution);
         intent.currentStatus = success ? 'executing' : 'failed';
@@ -134,6 +138,74 @@ export class KnowledgeGraphManager {
         this.updateAnalytics(kg);
         await this.saveKnowledgeGraph(kg);
     }
+    async addMemoryExecution(toolName, action, entityType, success, details) {
+        try {
+            const kg = await this.loadKnowledgeGraph();
+            // Create memory execution record
+            const memoryExecution = {
+                toolName,
+                action,
+                entityType,
+                success,
+                details: details || {},
+                timestamp: new Date().toISOString(),
+            };
+            // Initialize memory operations array if it doesn't exist
+            if (!kg.memoryOperations) {
+                kg.memoryOperations = [];
+            }
+            // Add memory execution to knowledge graph
+            kg.memoryOperations.push(memoryExecution);
+            // Limit memory operations history to last 1000 entries
+            if (kg.memoryOperations.length > 1000) {
+                kg.memoryOperations = kg.memoryOperations.slice(-1000);
+            }
+            // Update analytics to include memory operation metrics
+            this.updateMemoryAnalytics(kg);
+            await this.saveKnowledgeGraph(kg);
+        }
+        catch (error) {
+            console.error('[WARN] Failed to track memory execution:', error);
+            // Don't throw - memory tracking shouldn't break tool execution
+        }
+    }
+    updateMemoryAnalytics(kg) {
+        if (!kg.memoryOperations || kg.memoryOperations.length === 0) {
+            return;
+        }
+        // Calculate memory operation statistics
+        const totalOps = kg.memoryOperations.length;
+        const successfulOps = kg.memoryOperations.filter((op) => op.success).length;
+        const successRate = totalOps > 0 ? successfulOps / totalOps : 0;
+        // Group by entity type
+        const byEntityType = {};
+        const byAction = {};
+        const byTool = {};
+        for (const op of kg.memoryOperations) {
+            byEntityType[op.entityType] = (byEntityType[op.entityType] || 0) + 1;
+            byAction[op.action] = (byAction[op.action] || 0) + 1;
+            byTool[op.toolName] = (byTool[op.toolName] || 0) + 1;
+        }
+        // Add memory analytics to knowledge graph
+        if (!kg.analytics) {
+            kg.analytics = {
+                totalIntents: 0,
+                completedIntents: 0,
+                activeIntents: 0,
+                averageGoalCompletion: 0,
+                mostUsedTools: [],
+                successfulPatterns: [],
+            };
+        }
+        kg.analytics.memoryOperations = {
+            totalOperations: totalOps,
+            successRate,
+            byEntityType,
+            byAction,
+            byTool,
+            lastMemoryOperation: kg.memoryOperations[kg.memoryOperations.length - 1]?.timestamp,
+        };
+    }
     async updateIntentStatus(intentId, status) {
         const kg = await this.loadKnowledgeGraph();
         const intent = kg.intents.find(i => i.intentId === intentId);
@@ -190,7 +262,7 @@ export class KnowledgeGraphManager {
             knowledgeGraphHash: '',
             syncStatus: 'synced',
             lastModifiedBy: 'tool',
-            version: 1
+            version: 1,
         };
     }
     updateAnalytics(kg) {
@@ -199,7 +271,8 @@ export class KnowledgeGraphManager {
         kg.analytics.completedIntents = intents.filter(i => i.currentStatus === 'completed').length;
         kg.analytics.activeIntents = intents.filter(i => i.currentStatus !== 'completed' && i.currentStatus !== 'failed').length;
         if (kg.analytics.totalIntents > 0) {
-            kg.analytics.averageGoalCompletion = kg.analytics.completedIntents / kg.analytics.totalIntents;
+            kg.analytics.averageGoalCompletion =
+                kg.analytics.completedIntents / kg.analytics.totalIntents;
         }
         const toolUsage = new Map();
         intents.forEach(intent => {
@@ -227,7 +300,7 @@ export class KnowledgeGraphManager {
         return {
             hasChanges: currentHash !== syncState.todoMdHash,
             currentHash,
-            lastHash: syncState.todoMdHash
+            lastHash: syncState.todoMdHash,
         };
     }
     /**
@@ -239,31 +312,31 @@ export class KnowledgeGraphManager {
         if (!intent)
             return;
         // Get current score after tool execution
-        const afterScore = await this.healthScoring.getProjectHealthScore();
-        // Calculate score impact
+        const afterScore = await this.calculateMemoryScore(kg);
+        // Calculate score impact - map memory scores to legacy component names
         const scoreImpact = {
             beforeScore: beforeScore.overall,
             afterScore: afterScore.overall,
             componentImpacts: {
-                taskCompletion: afterScore.taskCompletion - beforeScore.taskCompletion,
-                deploymentReadiness: afterScore.deploymentReadiness - beforeScore.deploymentReadiness,
-                architectureCompliance: afterScore.architectureCompliance - beforeScore.architectureCompliance,
-                securityPosture: afterScore.securityPosture - beforeScore.securityPosture,
-                codeQuality: afterScore.codeQuality - beforeScore.codeQuality
+                taskCompletion: afterScore.memoryQuality - beforeScore.memoryQuality,
+                deploymentReadiness: afterScore.retrievalPerformance - beforeScore.retrievalPerformance,
+                architectureCompliance: afterScore.entityCoherence - beforeScore.entityCoherence,
+                securityPosture: afterScore.contextUtilization - beforeScore.contextUtilization,
+                codeQuality: afterScore.decisionAlignment - beforeScore.decisionAlignment,
             },
-            scoreConfidence: afterScore.confidence
+            scoreConfidence: afterScore.confidence,
         };
         // Update execution with score impact
         execution.scoreImpact = scoreImpact;
-        // Update intent score tracking
+        // Update intent score tracking - map memory scores to legacy component names
         if (intent.scoreTracking) {
             intent.scoreTracking.currentScore = afterScore.overall;
             intent.scoreTracking.componentScores = {
-                taskCompletion: afterScore.taskCompletion,
-                deploymentReadiness: afterScore.deploymentReadiness,
-                architectureCompliance: afterScore.architectureCompliance,
-                securityPosture: afterScore.securityPosture,
-                codeQuality: afterScore.codeQuality
+                taskCompletion: afterScore.memoryQuality,
+                deploymentReadiness: afterScore.retrievalPerformance,
+                architectureCompliance: afterScore.entityCoherence,
+                securityPosture: afterScore.contextUtilization,
+                codeQuality: afterScore.decisionAlignment,
             };
             intent.scoreTracking.lastScoreUpdate = new Date().toISOString();
             // Calculate progress if we have initial score
@@ -274,9 +347,10 @@ export class KnowledgeGraphManager {
                 // Calculate progress as percentage of improvement toward target
                 const totalPossibleImprovement = targetScore - initialScore;
                 const actualImprovement = currentScore - initialScore;
-                intent.scoreTracking.scoreProgress = totalPossibleImprovement > 0
-                    ? Math.min(100, (actualImprovement / totalPossibleImprovement) * 100)
-                    : 0;
+                intent.scoreTracking.scoreProgress =
+                    totalPossibleImprovement > 0
+                        ? Math.min(100, (actualImprovement / totalPossibleImprovement) * 100)
+                        : 0;
             }
         }
         // Add to score history
@@ -287,14 +361,14 @@ export class KnowledgeGraphManager {
             intentId,
             overallScore: afterScore.overall,
             componentScores: {
-                taskCompletion: afterScore.taskCompletion,
-                deploymentReadiness: afterScore.deploymentReadiness,
-                architectureCompliance: afterScore.architectureCompliance,
-                securityPosture: afterScore.securityPosture,
-                codeQuality: afterScore.codeQuality
+                taskCompletion: afterScore.memoryQuality,
+                deploymentReadiness: afterScore.retrievalPerformance,
+                architectureCompliance: afterScore.entityCoherence,
+                securityPosture: afterScore.contextUtilization,
+                codeQuality: afterScore.decisionAlignment,
             },
             triggerEvent: `Tool executed: ${toolName}`,
-            confidence: afterScore.confidence
+            confidence: afterScore.confidence,
         });
         // Keep only last 100 score history entries
         if (kg.scoreHistory.length > 100) {
@@ -319,8 +393,8 @@ export class KnowledgeGraphManager {
             scoreHistory: scoreHistory.map(h => ({
                 timestamp: h.timestamp,
                 score: h.overallScore,
-                triggerEvent: h.triggerEvent
-            }))
+                triggerEvent: h.triggerEvent,
+            })),
         };
     }
     /**
@@ -328,14 +402,16 @@ export class KnowledgeGraphManager {
      */
     async getProjectScoreTrends() {
         const kg = await this.loadKnowledgeGraph();
-        const currentScore = await this.healthScoring.getProjectHealthScore();
+        // Calculate memory-based health score
+        const kgData = await this.loadKnowledgeGraph();
+        const currentScore = await this.calculateMemoryScore(kgData);
         const scoreHistory = kg.scoreHistory || [];
         const intentImpacts = kg.intents
             .filter(i => i.scoreTracking?.initialScore !== undefined && i.scoreTracking?.currentScore !== undefined)
             .map(i => ({
             intentId: i.intentId,
             humanRequest: i.humanRequest,
-            scoreImprovement: (i.scoreTracking.currentScore - i.scoreTracking.initialScore)
+            scoreImprovement: i.scoreTracking.currentScore - i.scoreTracking.initialScore,
         }))
             .sort((a, b) => b.scoreImprovement - a.scoreImprovement)
             .slice(0, 5);
@@ -348,10 +424,10 @@ export class KnowledgeGraphManager {
                 timestamp: h.timestamp,
                 score: h.overallScore,
                 triggerEvent: h.triggerEvent,
-                ...(h.intentId && { intentId: h.intentId })
+                ...(h.intentId && { intentId: h.intentId }),
             })),
             averageImprovement,
-            topImpactingIntents: intentImpacts
+            topImpactingIntents: intentImpacts,
         };
     }
     /**
@@ -365,11 +441,12 @@ export class KnowledgeGraphManager {
             parsedGoals: [
                 `Analyze project structure at ${structureSnapshot.projectPath}`,
                 `Record directory structure and technology patterns`,
-                `Track architectural decisions and dependencies`
+                `Track architectural decisions and dependencies`,
             ],
             priority: 'medium',
             timestamp: structureSnapshot.timestamp,
-            toolChain: [{
+            toolChain: [
+                {
                     toolName: 'analyze_project_ecosystem',
                     parameters: {
                         projectPath: structureSnapshot.projectPath,
@@ -377,22 +454,173 @@ export class KnowledgeGraphManager {
                         recursiveDepth: structureSnapshot.recursiveDepth,
                         technologyFocus: structureSnapshot.technologyFocus,
                         analysisScope: structureSnapshot.analysisScope,
-                        includeEnvironment: structureSnapshot.includeEnvironment
+                        includeEnvironment: structureSnapshot.includeEnvironment,
                     },
                     result: {
                         structureData: structureSnapshot.structureData,
-                        timestamp: structureSnapshot.timestamp
+                        timestamp: structureSnapshot.timestamp,
                     },
                     todoTasksCreated: [],
                     todoTasksModified: [],
                     executionTime: structureSnapshot.timestamp,
-                    success: true
-                }],
+                    success: true,
+                },
+            ],
             currentStatus: 'completed',
             todoMdSnapshot: '', // No specific TODO.md impact for structure analysis
-            tags: ['project-structure', 'ecosystem-analysis', 'architecture']
+            tags: ['project-structure', 'ecosystem-analysis', 'architecture'],
         };
         await this.createIntent(intent.humanRequest, intent.parsedGoals, intent.priority);
     }
+    /**
+     * Calculate memory-based health score from knowledge graph
+     */
+    async calculateMemoryScore(kg) {
+        // Extract memories from intents and their tool executions
+        const memories = this.extractMemoriesFromKG(kg);
+        // Calculate retrieval metrics from tool execution patterns
+        const retrievalMetrics = this.calculateRetrievalMetrics(kg);
+        // Build entity graph from intents and relationships
+        const entityGraph = this.buildEntityGraph(kg);
+        return this.memoryScoring.calculateMemoryHealth(memories, retrievalMetrics, entityGraph);
+    }
+    /**
+     * Extract memory representations from knowledge graph
+     */
+    extractMemoriesFromKG(kg) {
+        const memories = [];
+        kg.intents.forEach(intent => {
+            // Each intent is a memory
+            memories.push({
+                id: intent.intentId,
+                content: intent.humanRequest,
+                context: {
+                    goals: intent.parsedGoals,
+                    priority: intent.priority,
+                    status: intent.currentStatus,
+                },
+                timestamp: intent.timestamp,
+                metadata: {
+                    relevanceScore: this.calculateIntentRelevance(intent),
+                    toolExecutions: intent.toolChain.length,
+                },
+                relatedDecisions: intent.adrsCreated || [],
+            });
+            // Each tool execution is also a memory
+            intent.toolChain.forEach(tool => {
+                memories.push({
+                    id: `${intent.intentId}-${tool.toolName}`,
+                    content: `${tool.toolName} execution`,
+                    context: {
+                        parameters: tool.parameters,
+                        result: tool.result,
+                        success: tool.success,
+                    },
+                    timestamp: tool.executionTime,
+                    metadata: {
+                        relevanceScore: tool.success ? 0.8 : 0.3,
+                        parentIntent: intent.intentId,
+                    },
+                });
+            });
+        });
+        return memories;
+    }
+    /**
+     * Calculate retrieval metrics from tool execution patterns
+     */
+    calculateRetrievalMetrics(kg) {
+        let totalRetrievals = 0;
+        let successfulRetrievals = 0;
+        let totalTime = 0;
+        kg.intents.forEach(intent => {
+            intent.toolChain.forEach(tool => {
+                totalRetrievals++;
+                if (tool.success)
+                    successfulRetrievals++;
+                // Estimate retrieval time (would be actual in production)
+                totalTime += tool.executionTime ? 50 : 100;
+            });
+        });
+        return {
+            totalRetrievals,
+            successfulRetrievals,
+            averageRetrievalTime: totalRetrievals > 0 ? totalTime / totalRetrievals : 0,
+            precisionScore: 0.8, // Placeholder - would calculate from actual retrievals
+            recallScore: 0.7, // Placeholder - would calculate from actual retrievals
+        };
+    }
+    /**
+     * Build entity graph from knowledge graph
+     */
+    buildEntityGraph(kg) {
+        const entities = [];
+        const relationships = [];
+        // Intents as entities
+        kg.intents.forEach(intent => {
+            entities.push({
+                id: intent.intentId,
+                type: 'intent',
+                name: intent.humanRequest.substring(0, 50),
+            });
+            // Create relationships between intents and their tools
+            intent.toolChain.forEach(tool => {
+                entities.push({
+                    id: `tool-${tool.toolName}`,
+                    type: 'tool',
+                    name: tool.toolName,
+                });
+                relationships.push({
+                    sourceId: intent.intentId,
+                    targetId: `tool-${tool.toolName}`,
+                    type: 'uses',
+                    strength: tool.success ? 0.9 : 0.3,
+                });
+            });
+        });
+        // Add ADR entities and relationships
+        kg.intents.forEach(intent => {
+            (intent.adrsCreated || []).forEach((adrId) => {
+                entities.push({
+                    id: `adr-${adrId}`,
+                    type: 'decision',
+                    name: `ADR ${adrId}`,
+                });
+                relationships.push({
+                    sourceId: intent.intentId,
+                    targetId: `adr-${adrId}`,
+                    type: 'created',
+                    strength: 0.95,
+                });
+            });
+        });
+        return {
+            entities,
+            relationships,
+            decisions: entities.filter(e => e.type === 'decision'),
+        };
+    }
+    /**
+     * Calculate relevance score for an intent
+     */
+    calculateIntentRelevance(intent) {
+        const now = new Date();
+        const age = now.getTime() - new Date(intent.timestamp).getTime();
+        const ageInDays = age / (24 * 60 * 60 * 1000);
+        // Base relevance on status and age
+        let relevance = 0.5;
+        if (intent.currentStatus === 'executing')
+            relevance = 0.9;
+        else if (intent.currentStatus === 'planning')
+            relevance = 0.8;
+        else if (intent.currentStatus === 'completed')
+            relevance = 0.6;
+        // Decay relevance over time
+        relevance *= Math.max(0.3, 1 - ageInDays / 30);
+        // Boost relevance if it has successful tool executions
+        const successRate = intent.toolChain.filter(t => t.success).length / (intent.toolChain.length || 1);
+        relevance = (relevance + successRate) / 2;
+        return relevance;
+    }
 }
 //# sourceMappingURL=knowledge-graph-manager.js.map