mcp-adr-analysis-server 2.0.21 → 2.1.0

package/dist/src/tools/troubleshoot-guided-workflow-tool.js

@@ -2,13 +2,29 @@
  * MCP Tool for guided troubleshooting workflow
  * Provides systematic troubleshooting with ADR/TODO alignment
  * Integrates with other MCP tools for comprehensive analysis
+ * Enhanced with memory integration and intelligent decision capabilities
  */
 import { z } from 'zod';
 import { McpAdrError } from '../types/index.js';
+import { MemoryEntityManager } from '../utils/memory-entity-manager.js';
+// Note: Memory entity types are imported implicitly through MemoryEntityManager
+import { EnhancedLogger } from '../utils/enhanced-logging.js';
+import { findFiles, findRelatedCode } from '../utils/file-system.js';
 // Structured failure schema
 const FailureInfoSchema = z.object({
-    failureType: z.enum(['test_failure', 'deployment_failure', 'build_failure', 'runtime_error', 'performance_issue', 'security_issue', 'other']).describe('Type of failure'),
-    failureDetails: z.object({
+    failureType: z
+        .enum([
+        'test_failure',
+        'deployment_failure',
+        'build_failure',
+        'runtime_error',
+        'performance_issue',
+        'security_issue',
+        'other',
+    ])
+        .describe('Type of failure'),
+    failureDetails: z
+        .object({
         command: z.string().optional().describe('Command that failed'),
         exitCode: z.number().optional().describe('Exit code of failed process'),
         errorMessage: z.string().describe('Primary error message'),
@@ -16,27 +32,378 @@ const FailureInfoSchema = z.object({
         logOutput: z.string().optional().describe('Relevant log output'),
         environment: z.string().optional().describe('Environment where failure occurred'),
         timestamp: z.string().optional().describe('When the failure occurred'),
-        affectedFiles: z.array(z.string()).optional().describe('Files involved in the failure')
-    }).describe('Detailed failure information'),
-    context: z.object({
+        affectedFiles: z.array(z.string()).optional().describe('Files involved in the failure'),
+    })
+        .describe('Detailed failure information'),
+    context: z
+        .object({
         recentChanges: z.string().optional().describe('Recent changes that might be related'),
         reproducible: z.boolean().optional().describe('Whether the failure is reproducible'),
         frequency: z.string().optional().describe('How often this failure occurs'),
-        impact: z.enum(['low', 'medium', 'high', 'critical']).optional().describe('Impact level of the failure')
-    }).optional().describe('Additional context about the failure')
+        impact: z
+            .enum(['low', 'medium', 'high', 'critical'])
+            .optional()
+            .describe('Impact level of the failure'),
+    })
+        .optional()
+        .describe('Additional context about the failure'),
 });
 // Troubleshooting operation schema
 const TroubleshootSchema = z.object({
-    operation: z.enum(['analyze_failure', 'generate_test_plan', 'full_workflow']).describe('Type of troubleshooting operation'),
+    operation: z
+        .enum(['analyze_failure', 'generate_test_plan', 'full_workflow'])
+        .describe('Type of troubleshooting operation'),
     failure: FailureInfoSchema.optional().describe('Structured failure information (required for analyze_failure and generate_test_plan)'),
     projectPath: z.string().optional().describe('Path to project directory'),
     adrDirectory: z.string().default('docs/adrs').describe('ADR directory path'),
-    todoPath: z.string().default('TODO.md').describe('Path to TODO.md file')
+    todoPath: z.string().default('TODO.md').describe('Path to TODO.md file'),
 });
+/**
+ * Enhanced Troubleshooting Memory Manager with Intelligence
+ * Handles memory persistence and intelligent decision-making for troubleshooting
+ */
+class TroubleshootingMemoryManager {
+    memoryManager;
+    logger;
+    constructor() {
+        this.memoryManager = new MemoryEntityManager();
+        this.logger = new EnhancedLogger();
+    }
+    async initialize() {
+        await this.memoryManager.initialize();
+    }
+    /**
+     * Store troubleshooting session as memory entity
+     */
+    async storeTroubleshootingSession(failure, analysisSteps, effectiveness, resolutionTimeMinutes) {
+        try {
+            const sessionData = {
+                failurePattern: {
+                    failureType: failure.failureType,
+                    errorSignature: this.generateErrorSignature(failure),
+                    frequency: await this.calculateFailureFrequency(failure.failureType),
+                    environments: failure.failureDetails.environment
+                        ? [failure.failureDetails.environment]
+                        : [],
+                },
+                failureDetails: {
+                    command: failure.failureDetails.command,
+                    exitCode: failure.failureDetails.exitCode,
+                    errorMessage: failure.failureDetails.errorMessage,
+                    stackTrace: failure.failureDetails.stackTrace,
+                    logOutput: failure.failureDetails.logOutput,
+                    environment: failure.failureDetails.environment,
+                    timestamp: failure.failureDetails.timestamp || new Date().toISOString(),
+                    affectedFiles: failure.failureDetails.affectedFiles || [],
+                },
+                analysisSteps,
+                solutionEffectiveness: effectiveness,
+                resolutionTimeMinutes: resolutionTimeMinutes,
+                preventionMeasures: this.generatePreventionMeasures(failure),
+                relatedADRs: await this.findRelatedADRs(failure),
+                environmentContext: this.extractEnvironmentContext(failure),
+                followUpActions: await this.determineFollowUpActions(failure, effectiveness),
+            };
+            await this.memoryManager.upsertEntity({
+                type: 'troubleshooting_session',
+                title: `Troubleshooting: ${failure.failureType} - ${failure.failureDetails.errorMessage.substring(0, 50)}...`,
+                description: `Troubleshooting session for ${failure.failureType} failure in ${failure.failureDetails.environment || 'unknown environment'}`,
+                tags: [
+                    'troubleshooting',
+                    failure.failureType,
+                    failure.failureDetails.environment || 'unknown-env',
+                    effectiveness > 0.7 ? 'effective-solution' : 'needs-improvement',
+                ],
+                sessionData,
+                relationships: [],
+                context: {
+                    projectPhase: 'troubleshooting',
+                    technicalStack: [],
+                    environmentalFactors: failure.failureDetails.environment
+                        ? [failure.failureDetails.environment]
+                        : [],
+                    stakeholders: [],
+                },
+                accessPattern: {
+                    lastAccessed: new Date().toISOString(),
+                    accessCount: 1,
+                    accessContext: ['troubleshooting-session'],
+                },
+                evolution: {
+                    origin: 'created',
+                    transformations: [
+                        {
+                            timestamp: new Date().toISOString(),
+                            type: 'session_creation',
+                            description: 'Troubleshooting session created from failure analysis',
+                            agent: 'troubleshoot-guided-workflow-tool',
+                        },
+                    ],
+                },
+                validation: {
+                    isVerified: effectiveness > 0.5,
+                    verificationMethod: 'solution-effectiveness-score',
+                    verificationTimestamp: new Date().toISOString(),
+                },
+            });
+            this.logger.info(`Troubleshooting session stored for ${failure.failureType}`, 'TroubleshootingMemoryManager', {
+                failureType: failure.failureType,
+                effectiveness,
+                followUpActions: sessionData.followUpActions.length,
+            });
+        }
+        catch (error) {
+            this.logger.error('Failed to store troubleshooting session', 'TroubleshootingMemoryManager', error);
+            throw error;
+        }
+    }
+    /**
+     * Analyze failure patterns and determine intelligent suggestions
+     */
+    async analyzeFailurePatterns() {
+        try {
+            const sessions = await this.memoryManager.queryEntities({
+                entityTypes: ['troubleshooting_session'],
+                limit: 100,
+                sortBy: 'lastModified',
+            });
+            // Analyze patterns across sessions
+            const failureTypes = sessions.entities.map((s) => s.sessionData.failurePattern.failureType);
+            const repeatedFailures = this.detectRepeatedFailures(failureTypes);
+            const environmentalFactors = this.extractEnvironmentalFactors(sessions.entities);
+            const knowledgeGaps = this.detectKnowledgeGaps(sessions.entities);
+            // Decision logic for suggestions
+            const suggestADR = repeatedFailures.length > 2 || this.detectArchitecturalGaps(sessions.entities);
+            const suggestResearch = knowledgeGaps.length > 0;
+            return {
+                suggestADR,
+                suggestResearch,
+                patterns: repeatedFailures,
+                recommendations: this.generateRecommendations(repeatedFailures, environmentalFactors),
+                knowledgeGaps,
+            };
+        }
+        catch (error) {
+            this.logger.error('Failed to analyze failure patterns', 'TroubleshootingMemoryManager', error);
+            throw error;
+        }
+    }
+    /**
+     * Trigger ADR suggestion based on failure patterns
+     */
+    async triggerADRSuggestion(failureContext) {
+        try {
+            const { suggestAdrs } = await import('./adr-suggestion-tool.js');
+            return await suggestAdrs({
+                analysisType: 'comprehensive',
+                enhancedMode: true,
+                knowledgeEnhancement: true,
+                conversationContext: {
+                    userGoals: ['Address recurring failures', 'Improve system reliability'],
+                    focusAreas: ['architecture', 'reliability', 'troubleshooting'],
+                    humanRequest: `Create ADR to address recurring ${failureContext.failureType} failures: ${failureContext.failureDetails.errorMessage}`,
+                    projectPhase: 'improvement',
+                    constraints: ['Must address root cause', 'Should prevent future occurrences'],
+                },
+            });
+        }
+        catch (error) {
+            this.logger.error('Failed to trigger ADR suggestion', 'TroubleshootingMemoryManager', error);
+            throw error;
+        }
+    }
+    /**
+     * Trigger research question generation for knowledge gaps
+     */
+    async triggerResearchGeneration(knowledgeGaps) {
+        try {
+            const { generateResearchQuestions } = await import('./research-question-tool.js');
+            return await generateResearchQuestions({
+                analysisType: 'comprehensive',
+                researchContext: {
+                    topic: 'Troubleshooting and System Reliability',
+                    category: 'operational_excellence',
+                    scope: 'failure_analysis',
+                    objectives: [
+                        'Understand root causes of recurring failures',
+                        'Identify system reliability improvements',
+                        'Document troubleshooting best practices',
+                        'Develop proactive monitoring strategies',
+                    ],
+                    constraints: ['Must be actionable', 'Should be measurable'],
+                    timeline: '2-4 weeks',
+                },
+                problems: knowledgeGaps.map(gap => ({
+                    id: gap.id,
+                    description: gap.description,
+                    category: 'troubleshooting',
+                    severity: gap.severity,
+                    context: gap.context,
+                })),
+                knowledgeEnhancement: true,
+                enhancedMode: true,
+            });
+        }
+        catch (error) {
+            this.logger.error('Failed to trigger research generation', 'TroubleshootingMemoryManager', error);
+            throw error;
+        }
+    }
+    // Private helper methods
+    generateErrorSignature(failure) {
+        const errorMsg = failure.failureDetails.errorMessage.toLowerCase();
+        const command = failure.failureDetails.command?.toLowerCase() || '';
+        return `${failure.failureType}:${command}:${errorMsg.substring(0, 100)}`;
+    }
+    async calculateFailureFrequency(failureType) {
+        try {
+            const sessions = await this.memoryManager.queryEntities({
+                entityTypes: ['troubleshooting_session'],
+                limit: 50,
+            });
+            return sessions.entities.filter((s) => s.sessionData.failurePattern.failureType === failureType).length;
+        }
+        catch {
+            return 1;
+        }
+    }
+    generatePreventionMeasures(failure) {
+        const measures = [];
+        switch (failure.failureType) {
+            case 'deployment_failure':
+                measures.push('Implement deployment health checks');
+                measures.push('Add environment validation scripts');
+                measures.push('Create deployment rollback procedures');
+                break;
+            case 'test_failure':
+                measures.push('Improve test environment consistency');
+                measures.push('Add test data validation');
+                measures.push('Implement test isolation mechanisms');
+                break;
+            case 'build_failure':
+                measures.push('Standardize build environment');
+                measures.push('Add dependency locking');
+                measures.push('Implement build reproducibility checks');
+                break;
+            case 'performance_issue':
+                measures.push('Add performance monitoring');
+                measures.push('Implement resource usage alerts');
+                measures.push('Create performance regression tests');
+                break;
+            case 'security_issue':
+                measures.push('Enhance security scanning');
+                measures.push('Implement security policy enforcement');
+                measures.push('Add vulnerability monitoring');
+                break;
+            default:
+                measures.push('Improve monitoring and alerting');
+                measures.push('Document troubleshooting procedures');
+                measures.push('Create failure response playbooks');
+        }
+        return measures;
+    }
+    async findRelatedADRs(_failure) {
+        // This would typically search for ADRs related to the failure context
+        // For now, return empty array - this will be enhanced when ADR search is integrated
+        return [];
+    }
+    extractEnvironmentContext(failure) {
+        return {
+            environment: failure.failureDetails.environment,
+            command: failure.failureDetails.command,
+            exitCode: failure.failureDetails.exitCode,
+            timestamp: failure.failureDetails.timestamp,
+            reproducible: failure.context?.reproducible,
+            frequency: failure.context?.frequency,
+            impact: failure.context?.impact,
+        };
+    }
+    async determineFollowUpActions(failure, effectiveness) {
+        const actions = [];
+        // Low effectiveness suggests need for research
+        if (effectiveness < 0.7) {
+            actions.push({
+                action: 'Generate research questions to improve troubleshooting approach',
+                type: 'research_generation',
+                priority: effectiveness < 0.5 ? 'high' : 'medium',
+                triggered: false,
+                reason: `Solution effectiveness (${effectiveness}) indicates knowledge gaps`,
+            });
+        }
+        // Architectural failure types suggest ADR needs
+        const architecturalTypes = ['deployment_failure', 'performance_issue', 'security_issue'];
+        if (architecturalTypes.includes(failure.failureType)) {
+            actions.push({
+                action: 'Suggest ADR to address architectural concerns',
+                type: 'adr_suggestion',
+                priority: 'medium',
+                triggered: false,
+                reason: `${failure.failureType} suggests architectural decision needed`,
+            });
+        }
+        // Always suggest process improvement for repeated failures
+        const frequency = await this.calculateFailureFrequency(failure.failureType);
+        if (frequency >= 3) {
+            actions.push({
+                action: 'Implement process improvements to prevent recurring failures',
+                type: 'process_improvement',
+                priority: 'high',
+                triggered: false,
+                reason: `${failure.failureType} has occurred ${frequency} times`,
+            });
+        }
+        return actions;
+    }
+    detectRepeatedFailures(failureTypes) {
+        const frequency = {};
+        failureTypes.forEach(type => {
+            frequency[type] = (frequency[type] || 0) + 1;
+        });
+        return Object.entries(frequency)
+            .filter(([_, count]) => count >= 3)
+            .map(([type, count]) => ({ type, frequency: count }));
+    }
+    detectArchitecturalGaps(sessions) {
+        const architecturalIndicators = ['deployment_failure', 'performance_issue', 'security_issue'];
+        return sessions.some(session => architecturalIndicators.includes(session.sessionData.failurePattern.failureType));
+    }
+    detectKnowledgeGaps(sessions) {
+        const patterns = sessions.filter(session => session.sessionData.solutionEffectiveness < 0.7);
+        return patterns.map(pattern => ({
+            id: pattern.id,
+            description: `Low solution effectiveness for ${pattern.sessionData.failurePattern.failureType}`,
+            severity: pattern.sessionData.solutionEffectiveness < 0.5 ? 'high' : 'medium',
+            context: pattern.sessionData.failurePattern.failureDetails.errorMessage,
+        }));
+    }
+    extractEnvironmentalFactors(sessions) {
+        const factors = new Set();
+        sessions.forEach(session => {
+            const env = session.sessionData.failurePattern.environments;
+            if (env && Array.isArray(env)) {
+                env.forEach(e => factors.add(e));
+            }
+        });
+        return Array.from(factors);
+    }
+    generateRecommendations(repeatedFailures, environmentalFactors) {
+        const recommendations = [];
+        if (repeatedFailures.length > 0) {
+            recommendations.push(`Address recurring ${repeatedFailures[0].type} failures with architectural decision`);
+            recommendations.push('Implement prevention measures for top failure patterns');
+        }
+        if (environmentalFactors.length > 1) {
+            recommendations.push('Standardize environments to reduce environment-specific failures');
+        }
+        recommendations.push('Build knowledge base from troubleshooting sessions');
+        recommendations.push('Create automated monitoring for detected failure patterns');
+        return recommendations;
+    }
+}
 /**
  * Analyze structured failure information
  */
-async function analyzeFailure(failure) {
+async function analyzeFailure(failure, projectPath = process.cwd()) {
     const report = [
         '# 🚨 Failure Analysis',
         '',
@@ -44,8 +411,57 @@ async function analyzeFailure(failure) {
         '',
         '## Error Details',
         `**Primary Error**: ${failure.failureDetails.errorMessage}`,
-        ''
+        '',
     ];
+    // Smart Code Linking - find files related to the failure
+    let relatedCodeAnalysis = '';
+    try {
+        // Create context from failure information for Smart Code Linking
+        const failureContext = [
+            `Failure Type: ${failure.failureType}`,
+            `Error Message: ${failure.failureDetails.errorMessage}`,
+            failure.failureDetails.command ? `Failed Command: ${failure.failureDetails.command}` : '',
+            failure.failureDetails.environment
+                ? `Environment: ${failure.failureDetails.environment}`
+                : '',
+            failure.context?.recentChanges ? `Recent Changes: ${failure.context.recentChanges}` : '',
+        ]
+            .filter(Boolean)
+            .join('\n');
+        // Find related code files using Smart Code Linking
+        const relatedCodeResult = await findRelatedCode('troubleshooting-failure-analysis', failureContext, projectPath, {
+            useAI: true,
+            useRipgrep: true,
+            maxFiles: 15,
+            includeContent: false,
+        });
+        if (relatedCodeResult.relatedFiles.length > 0) {
+            relatedCodeAnalysis = [
+                '',
+                '## 🔗 Smart Code Linking Analysis',
+                '',
+                `Found **${relatedCodeResult.relatedFiles.length}** files potentially related to this failure:`,
+                '',
+                ...relatedCodeResult.relatedFiles
+                    .slice(0, 10)
+                    .map((file, index) => `${index + 1}. **${file.path}**`),
+                '',
+                relatedCodeResult.relatedFiles.length > 10
+                    ? `*Showing top 10 of ${relatedCodeResult.relatedFiles.length} related files*`
+                    : '',
+                '',
+                `**Analysis Confidence**: ${(relatedCodeResult.confidence * 100).toFixed(0)}%`,
+                `**Keywords Used**: ${relatedCodeResult.keywords?.slice(0, 8).join(', ') || 'N/A'}`,
+                '',
+            ]
+                .filter(Boolean)
+                .join('\n');
+        }
+    }
+    catch (error) {
+        // Don't fail the analysis if Smart Code Linking fails
+        console.warn('Smart Code Linking failed for failure analysis:', error);
+    }
     // Add command and exit code if available
     if (failure.failureDetails.command) {
         report.push(`**Failed Command**: \`${failure.failureDetails.command}\``);
@@ -134,6 +550,10 @@ async function analyzeFailure(failure) {
             report.push('3. **Verify configuration and dependencies**');
             report.push('4. **Test in isolated environment**');
     }
+    // Add Smart Code Linking analysis to the report
+    if (relatedCodeAnalysis) {
+        report.push(relatedCodeAnalysis);
+    }
     report.push('');
     report.push('*Use `generate_test_plan` operation to get specific commands and validation steps.*');
     return report.join('\n');
@@ -147,6 +567,40 @@ async function generateTestPlan(failure, args) {
     if (!isAIExecutionEnabled(aiConfig)) {
         return generateFallbackTestPlan(failure, args);
     }
+    // Smart Code Linking - gather project context for better test plan generation
+    let projectContext = '';
+    try {
+        const projectPath = args.projectPath || process.cwd();
+        // Find files related to the failure for better context
+        const failureContext = [
+            `Failure Type: ${failure.failureType}`,
+            `Error Message: ${failure.failureDetails.errorMessage}`,
+            failure.failureDetails.command ? `Failed Command: ${failure.failureDetails.command}` : '',
+            failure.failureDetails.environment
+                ? `Environment: ${failure.failureDetails.environment}`
+                : '',
+        ]
+            .filter(Boolean)
+            .join('\n');
+        const relatedCodeResult = await findRelatedCode('test-plan-generation', failureContext, projectPath, {
+            useAI: true,
+            useRipgrep: true,
+            maxFiles: 8,
+            includeContent: false,
+        });
+        if (relatedCodeResult.relatedFiles.length > 0) {
+            projectContext =
+                `\n\nProject Context (Smart Code Linking found ${relatedCodeResult.relatedFiles.length} related files):\n` +
+                    relatedCodeResult.relatedFiles
+                        .slice(0, 5)
+                        .map(file => `- ${file.path}`)
+                        .join('\n');
+        }
+    }
+    catch (error) {
+        // Don't fail test plan generation if Smart Code Linking fails
+        console.warn('Smart Code Linking failed for test plan generation:', error);
+    }
     const systemPrompt = `You are an expert debugging assistant. Analyze the structured failure information and generate specific, actionable test commands.
 
 Return a JSON response with this exact structure:
@@ -183,28 +637,28 @@ Be specific and contextual based on the actual failure details provided.`;
 - Environment: ${failure.failureDetails.environment || 'N/A'}
 - Project Path: ${args.projectPath || '.'}
 ${failure.failureDetails.stackTrace ? `- Stack Trace: ${failure.failureDetails.stackTrace.substring(0, 500)}...` : ''}
-${failure.context?.recentChanges ? `- Recent Changes: ${failure.context.recentChanges}` : ''}
+${failure.context?.recentChanges ? `- Recent Changes: ${failure.context.recentChanges}` : ''}${projectContext}
 
-Generate specific test commands to diagnose and resolve this failure.`;
+Generate specific test commands to diagnose and resolve this failure. Use the project context above to provide more targeted and relevant test commands.`;
     try {
         const response = await fetch(aiConfig.baseURL + '/chat/completions', {
             method: 'POST',
             headers: {
-                'Authorization': `Bearer ${aiConfig.apiKey}`,
+                Authorization: `Bearer ${aiConfig.apiKey}`,
                 'Content-Type': 'application/json',
                 'HTTP-Referer': aiConfig.siteUrl || '',
-                'X-Title': aiConfig.siteName || ''
+                'X-Title': aiConfig.siteName || '',
             },
             body: JSON.stringify({
                 model: getRecommendedModel('analysis'),
                 messages: [
                     { role: 'system', content: systemPrompt },
-                    { role: 'user', content: failureContext }
+                    { role: 'user', content: failureContext },
                 ],
                 temperature: 0.2,
                 max_tokens: 2000,
-                response_format: { type: 'json_object' }
-            })
+                response_format: { type: 'json_object' },
+            }),
         });
         if (!response.ok) {
             throw new Error(`OpenRouter API error: ${response.status}`);
@@ -217,7 +671,7 @@ Generate specific test commands to diagnose and resolve this failure.`;
         const aiPlan = JSON.parse(planContent);
         return formatAITestPlan(aiPlan.testPlan, args.projectPath || '.');
     }
-    catch (error) {
+    catch {
         // Fallback to hardcoded templates if AI fails
         return generateFallbackTestPlan(failure, args);
     }
@@ -233,7 +687,7 @@ function formatAITestPlan(testPlan, projectPath) {
         testPlan.summary || 'AI analysis of the failure',
         '',
         `**Priority**: ${testPlan.priority?.toUpperCase() || 'MEDIUM'}`,
-        ''
+        '',
     ];
     if (testPlan.testSections && Array.isArray(testPlan.testSections)) {
         testPlan.testSections.forEach((section, index) => {
@@ -300,7 +754,7 @@ function generateFallbackTestPlan(failure, args) {
         `## For Failure Type: ${failure.failureType.toUpperCase()}`,
         '',
         '## Specific Commands to Execute',
-        ''
+        '',
     ];
     const projectPath = args.projectPath || '.';
     switch (failure.failureType) {
@@ -436,7 +890,8 @@ function generateFallbackTestPlan(failure, args) {
 /**
  * Run the full troubleshooting workflow with actual tool integration
  */
-async function runFullWorkflow(_args) {
+async function runFullWorkflow(args) {
+    const projectPath = args.projectPath || process.cwd();
     const report = [
         '# 🔧 Guided Troubleshooting Workflow',
         '',
@@ -447,8 +902,67 @@ async function runFullWorkflow(_args) {
         '4. 🔄 Generate targeted questions',
         '5. 🔄 ADR validation',
         '6. 🔄 Guided recommendations',
-        ''
+        '',
     ];
+    // Smart Code Linking - discover project structure for troubleshooting context
+    try {
+        // Find project files for comprehensive analysis
+        const findResult = await findFiles(projectPath, [
+            '**/*.{ts,js,py,yml,yaml,json,md}',
+            '!**/node_modules/**',
+            '!**/dist/**',
+            '!**/build/**',
+        ]);
+        if (findResult.files.length > 0) {
+            report.push('## 📊 Project Discovery');
+            report.push(`Found **${findResult.files.length}** relevant files in project:`);
+            // Categorize files by type for troubleshooting context
+            const filesByType = findResult.files.reduce((acc, file) => {
+                const ext = file.path.split('.').pop()?.toLowerCase() || 'other';
+                acc[ext] = (acc[ext] || 0) + 1;
+                return acc;
+            }, {});
+            report.push('');
+            Object.entries(filesByType)
+                .sort(([, a], [, b]) => b - a)
+                .slice(0, 8)
+                .forEach(([ext, count]) => {
+                report.push(`- **${ext.toUpperCase()}**: ${count} files`);
+            });
+            report.push('');
+            // Smart Code Linking for general troubleshooting context
+            const troubleshootingContext = [
+                'troubleshooting workflow',
+                'error handling',
+                'logging',
+                'monitoring',
+                'testing',
+                'deployment',
+                'configuration',
+            ].join(' ');
+            const relatedCodeResult = await findRelatedCode('troubleshooting-workflow-context', troubleshootingContext, projectPath, {
+                useAI: true,
+                useRipgrep: true,
+                maxFiles: 10,
+                includeContent: false,
+            });
+            if (relatedCodeResult.relatedFiles.length > 0) {
+                report.push('## 🔗 Troubleshooting-Relevant Files');
+                report.push('Files that may be relevant for troubleshooting:');
+                report.push('');
+                relatedCodeResult.relatedFiles.slice(0, 8).forEach((file, index) => {
+                    report.push(`${index + 1}. **${file.path}**`);
+                });
+                report.push('');
+                report.push(`**Analysis Confidence**: ${(relatedCodeResult.confidence * 100).toFixed(0)}%`);
+                report.push('');
+            }
+        }
+    }
+    catch (error) {
+        // Don't fail the workflow if Smart Code Linking fails
+        console.warn('Smart Code Linking failed for workflow analysis:', error);
+    }
     // Legacy workflow - simplified for backwards compatibility
     // Legacy full workflow - provides overview of troubleshooting approach
     report.push('## Step 2: Baseline Reality Check');
@@ -478,7 +992,123 @@ async function runFullWorkflow(_args) {
     return report.join('\n');
 }
 /**
- * Main troubleshooting workflow function
+ * Enhanced troubleshooting workflow with memory integration and intelligent decision triggering
+ */
+export async function troubleshootGuidedWorkflowEnhanced(args) {
+    try {
+        const validatedArgs = TroubleshootSchema.parse(args);
+        // Initialize memory manager if enabled
+        let memoryManager = null;
+        if (args.enableMemoryIntegration !== false) {
+            memoryManager = new TroubleshootingMemoryManager();
+            await memoryManager.initialize();
+        }
+        // Execute original troubleshooting logic
+        const result = await troubleshootGuidedWorkflow(validatedArgs);
+        // Enhanced memory integration and intelligent suggestions
+        if (memoryManager && validatedArgs.failure && args.solutionEffectiveness !== undefined) {
+            try {
+                // Store troubleshooting session
+                await memoryManager.storeTroubleshootingSession(validatedArgs.failure, ['Analysis completed', 'Test plan generated', 'Solution provided'], args.solutionEffectiveness, args.resolutionTimeMinutes);
+                // Analyze patterns and trigger intelligent suggestions
+                const patternAnalysis = await memoryManager.analyzeFailurePatterns();
+                // Enhance result with intelligent suggestions
+                const enhancedResult = {
+                    ...result,
+                    memoryIntegration: {
+                        sessionStored: true,
+                        patternAnalysis: {
+                            repeatedFailures: patternAnalysis.patterns.length,
+                            suggestionsTriggered: [],
+                            recommendations: patternAnalysis.recommendations,
+                        },
+                    },
+                };
+                // Trigger ADR suggestion if patterns detected
+                if (patternAnalysis.suggestADR) {
+                    try {
+                        const adrSuggestion = await memoryManager.triggerADRSuggestion(validatedArgs.failure);
+                        enhancedResult.memoryIntegration.patternAnalysis.suggestionsTriggered.push({
+                            type: 'adr_suggestion',
+                            reason: 'Recurring failure patterns detected',
+                            patterns: patternAnalysis.patterns,
+                            suggestion: adrSuggestion,
+                        });
+                    }
+                    catch (error) {
+                        console.warn('Failed to trigger ADR suggestion:', error);
+                    }
+                }
+                // Trigger research generation if knowledge gaps detected
+                if (patternAnalysis.suggestResearch) {
+                    try {
+                        const researchSuggestion = await memoryManager.triggerResearchGeneration(patternAnalysis.knowledgeGaps);
+                        enhancedResult.memoryIntegration.patternAnalysis.suggestionsTriggered.push({
+                            type: 'research_suggestion',
+                            reason: 'Knowledge gaps identified in troubleshooting',
+                            gaps: patternAnalysis.knowledgeGaps,
+                            suggestion: researchSuggestion,
+                        });
+                    }
+                    catch (error) {
+                        console.warn('Failed to trigger research generation:', error);
+                    }
+                }
+                // Add intelligent suggestions to the content
+                if (enhancedResult.memoryIntegration.patternAnalysis.suggestionsTriggered.length > 0) {
+                    const originalContent = enhancedResult.content[0].text;
+                    const suggestions = enhancedResult.memoryIntegration.patternAnalysis.suggestionsTriggered;
+                    const suggestionText = [
+                        '',
+                        '---',
+                        '',
+                        '## 🧠 Intelligent Suggestions (Memory-Enhanced)',
+                        '',
+                        'Based on analysis of historical troubleshooting patterns:',
+                        '',
+                    ];
+                    suggestions.forEach((suggestion) => {
+                        suggestionText.push(`### ${suggestion.type === 'adr_suggestion' ? '📋 ADR Suggestion' : '🔬 Research Suggestion'}`);
+                        suggestionText.push(`**Reason**: ${suggestion.reason}`);
+                        suggestionText.push('');
+                        if (suggestion.type === 'adr_suggestion' && suggestion.patterns) {
+                            suggestionText.push(`**Patterns Detected**: ${suggestion.patterns.map((p) => `${p.type} (${p.frequency}x)`).join(', ')}`);
+                            suggestionText.push('**Recommendation**: Create architectural decision to address recurring failures');
+                        }
+                        else if (suggestion.type === 'research_suggestion' && suggestion.gaps) {
+                            suggestionText.push(`**Knowledge Gaps**: ${suggestion.gaps.length} areas identified`);
+                            suggestionText.push('**Recommendation**: Generate research questions to improve troubleshooting effectiveness');
+                        }
+                        suggestionText.push('');
+                    });
+                    if (enhancedResult.memoryIntegration.patternAnalysis.recommendations.length > 0) {
+                        suggestionText.push('### 💡 Additional Recommendations');
+                        enhancedResult.memoryIntegration.patternAnalysis.recommendations.forEach((rec) => {
+                            suggestionText.push(`- ${rec}`);
+                        });
+                        suggestionText.push('');
+                    }
+                    suggestionText.push('*These suggestions are generated automatically based on troubleshooting session analysis and failure pattern recognition.*');
+                    enhancedResult.content[0].text = originalContent + suggestionText.join('\n');
+                }
+                return enhancedResult;
+            }
+            catch (memoryError) {
+                console.warn('Memory integration failed, continuing with standard workflow:', memoryError);
+                return result;
+            }
+        }
+        return result;
+    }
+    catch (error) {
+        if (error instanceof z.ZodError) {
+            throw new McpAdrError(`Invalid input: ${error.errors.map(e => e.message).join(', ')}`, 'INVALID_INPUT');
+        }
+        throw new McpAdrError(`Enhanced troubleshooting workflow failed: ${error instanceof Error ? error.message : String(error)}`, 'TROUBLESHOOTING_ERROR');
+    }
+}
+/**
+ * Main troubleshooting workflow function (original implementation)
  */
 export async function troubleshootGuidedWorkflow(args) {
     try {
@@ -489,7 +1119,7 @@ export async function troubleshootGuidedWorkflow(args) {
                 if (!validatedArgs.failure) {
                     throw new McpAdrError('Failure information is required for analyze_failure operation', 'INVALID_INPUT');
                 }
-                result = await analyzeFailure(validatedArgs.failure);
+                result = await analyzeFailure(validatedArgs.failure, validatedArgs.projectPath);
                 break;
             case 'generate_test_plan':
                 if (!validatedArgs.failure) {
@@ -504,10 +1134,12 @@ export async function troubleshootGuidedWorkflow(args) {
                 throw new McpAdrError(`Unknown operation: ${validatedArgs.operation}`, 'INVALID_INPUT');
         }
         return {
-            content: [{
+            content: [
+                {
                     type: 'text',
-                    text: result
-                }]
+                    text: result,
+                },
+            ],
         };
     }
     catch (error) {