mcp-adr-analysis-server 2.0.21 → 2.1.0

package/dist/src/tools/interactive-adr-planning-tool.js

@@ -34,8 +34,10 @@
  */
 import { z } from 'zod';
 import { promises as fs } from 'fs';
-import { join } from 'path';
+import { join, basename } from 'path';
+import * as os from 'os';
 import { McpAdrError } from '../types/index.js';
+import { findFiles, findRelatedCode } from '../utils/file-system.js';
 // Planning session schema
 const PlanningSessionSchema = z.object({
     sessionId: z.string(),
@@ -47,57 +49,69 @@ const PlanningSessionSchema = z.object({
         'impact_assessment',
         'implementation_planning',
         'adr_generation',
-        'completed'
+        'completed',
     ]),
     context: z.object({
         projectPath: z.string(),
         adrDirectory: z.string().default('docs/adrs'),
         problemStatement: z.string().optional(),
-        researchFindings: z.array(z.object({
+        researchFindings: z
+            .array(z.object({
             source: z.string(),
             insight: z.string(),
-            relevance: z.string()
-        })).default([]),
-        options: z.array(z.object({
+            relevance: z.string(),
+        }))
+            .default([]),
+        options: z
+            .array(z.object({
             name: z.string(),
             description: z.string(),
             pros: z.array(z.string()),
             cons: z.array(z.string()),
             risks: z.array(z.string()),
             effort: z.enum(['low', 'medium', 'high']),
-            confidence: z.number().min(0).max(100)
-        })).default([]),
-        selectedOption: z.object({
+            confidence: z.number().min(0).max(100),
+        }))
+            .default([]),
+        selectedOption: z
+            .object({
             name: z.string(),
             rationale: z.string(),
-            tradeoffs: z.array(z.string())
-        }).optional(),
-        impacts: z.object({
+            tradeoffs: z.array(z.string()),
+        })
+            .optional(),
+        impacts: z
+            .object({
             technical: z.array(z.string()).default([]),
             business: z.array(z.string()).default([]),
             team: z.array(z.string()).default([]),
             risks: z.array(z.string()).default([]),
-            dependencies: z.array(z.string()).default([])
-        }).optional(),
-        implementation: z.object({
+            dependencies: z.array(z.string()).default([]),
+        })
+            .optional(),
+        implementation: z
+            .object({
             phases: z.array(z.string()).default([]),
-            tasks: z.array(z.object({
+            tasks: z
+                .array(z.object({
                 description: z.string(),
                 priority: z.enum(['low', 'medium', 'high', 'critical']),
                 effort: z.string(),
-                assignee: z.string().optional()
-            })).default([]),
+                assignee: z.string().optional(),
+            }))
+                .default([]),
             timeline: z.string().optional(),
-            successCriteria: z.array(z.string()).default([])
-        }).optional(),
-        adrContent: z.string().optional()
+            successCriteria: z.array(z.string()).default([]),
+        })
+            .optional(),
+        adrContent: z.string().optional(),
     }),
     metadata: z.object({
         createdAt: z.string(),
         updatedAt: z.string(),
         lastAction: z.string(),
-        nextSteps: z.array(z.string()).default([])
-    })
+        nextSteps: z.array(z.string()).default([]),
+    }),
 });
 // Input schema for tool operations
 const InteractiveAdrPlanningSchema = z.object({
@@ -114,13 +128,16 @@ const InteractiveAdrPlanningSchema = z.object({
         'update_todos',
         'get_guidance',
         'save_session',
-        'complete_session'
+        'complete_session',
     ]),
     sessionId: z.string().optional(),
     input: z.any().optional(),
     projectPath: z.string(),
     autoResearch: z.boolean().default(true).describe('Automatically trigger research when needed'),
-    generateTodos: z.boolean().default(true).describe('Automatically generate TODO items from decisions')
+    generateTodos: z
+        .boolean()
+        .default(true)
+        .describe('Automatically generate TODO items from decisions'),
 });
 // Session storage
 const sessions = new Map();
@@ -128,7 +145,8 @@ const sessions = new Map();
  * Get or create cache directory
  */
 async function getCacheDir(projectPath) {
-    const cacheDir = join(projectPath, '.mcp-adr-cache');
+    const projectName = basename(projectPath);
+    const cacheDir = join(os.tmpdir(), projectName, 'cache');
     await fs.mkdir(cacheDir, { recursive: true });
     return cacheDir;
 }
@@ -166,7 +184,7 @@ async function startSession(args) {
             projectPath: args.projectPath,
             adrDirectory: 'docs/adrs',
             researchFindings: [],
-            options: []
+            options: [],
         },
         metadata: {
             createdAt: new Date().toISOString(),
@@ -175,9 +193,9 @@ async function startSession(args) {
             nextSteps: [
                 'Define the architectural problem or decision point',
                 'Identify key stakeholders and constraints',
-                'Determine success criteria'
-            ]
-        }
+                'Determine success criteria',
+            ],
+        },
     };
     sessions.set(sessionId, session);
     await saveSession(session);
@@ -202,7 +220,7 @@ Please provide:
 ${session.metadata.nextSteps.map(step => `- ${step}`).join('\n')}
 
 Use \`provide_input\` with your problem statement to continue.`,
-        nextAction: 'provide_input'
+        nextAction: 'provide_input',
     };
 }
 /**
@@ -229,7 +247,7 @@ async function continueSession(args) {
         impact_assessment: 'Analyze the impacts and risks of the decision',
         implementation_planning: 'Plan the implementation with tasks and timeline',
         adr_generation: 'Generate the final ADR document',
-        completed: 'Session completed - ADR has been generated'
+        completed: 'Session completed - ADR has been generated',
     };
     return {
         success: true,
@@ -238,7 +256,7 @@ async function continueSession(args) {
         context: session.context,
         guidance: phaseGuidance[session.phase],
         nextSteps: session.metadata.nextSteps,
-        progress: getSessionProgress(session)
+        progress: getSessionProgress(session),
     };
 }
 /**
@@ -292,7 +310,7 @@ async function handleProblemDefinition(session, input) {
     session.metadata.nextSteps = [
         'Research existing solutions',
         'Analyze current architecture',
-        'Identify relevant patterns and practices'
+        'Identify relevant patterns and practices',
     ];
     return {
         success: true,
@@ -314,7 +332,7 @@ Would you like me to:
 - Automatically research this topic? (use \`request_research\`)
 - Or provide your own research findings? (use \`provide_input\` with findings)`,
         nextAction: 'request_research',
-        autoResearch: true
+        autoResearch: true,
     };
 }
 /**
@@ -329,7 +347,7 @@ async function handleResearchAnalysis(session, input) {
     session.metadata.nextSteps = [
         'Identify possible solutions',
         'Evaluate pros and cons',
-        'Assess implementation effort'
+        'Assess implementation effort',
     ];
     return {
         success: true,
@@ -363,7 +381,7 @@ Please provide options in this format:
 \`\`\`
 
 Or use \`evaluate_options\` to have me help generate options based on the research.`,
-        nextAction: 'evaluate_options'
+        nextAction: 'evaluate_options',
     };
 }
 /**
@@ -378,14 +396,16 @@ async function handleOptionExploration(session, input) {
     session.metadata.nextSteps = [
         'Compare options against criteria',
         'Select best approach',
-        'Document rationale'
+        'Document rationale',
     ];
-    const optionComparison = session.context.options.map(opt => `### ${opt.name} (Confidence: ${opt.confidence}%)
+    const optionComparison = session.context.options
+        .map(opt => `### ${opt.name} (Confidence: ${opt.confidence}%)
 **Description:** ${opt.description}
 **Pros:** ${opt.pros.join(', ')}
 **Cons:** ${opt.cons.join(', ')}
 **Effort:** ${opt.effort}
-**Risks:** ${opt.risks.join(', ')}`).join('\n\n');
+**Risks:** ${opt.risks.join(', ')}`)
+        .join('\n\n');
     return {
         success: true,
         sessionId: session.sessionId,
@@ -412,7 +432,7 @@ Provide your decision with:
 \`\`\`
 
 Use \`make_decision\` to proceed.`,
-        nextAction: 'make_decision'
+        nextAction: 'make_decision',
     };
 }
 /**
@@ -427,7 +447,7 @@ async function handleDecisionMaking(session, input) {
     session.metadata.nextSteps = [
         'Assess technical impacts',
         'Evaluate business impacts',
-        'Identify risks and dependencies'
+        'Identify risks and dependencies',
     ];
     return {
         success: true,
@@ -457,7 +477,7 @@ Provide impact analysis:
 \`\`\`
 
 Use \`assess_impact\` to continue.`,
-        nextAction: 'assess_impact'
+        nextAction: 'assess_impact',
     };
 }
 /**
@@ -472,7 +492,7 @@ async function handleImpactAssessment(session, input) {
     session.metadata.nextSteps = [
         'Define implementation phases',
         'Create task list',
-        'Set timeline and milestones'
+        'Set timeline and milestones',
     ];
     return {
         success: true,
@@ -512,7 +532,7 @@ Provide implementation details:
 \`\`\`
 
 Use \`plan_implementation\` to continue.`,
-        nextAction: 'plan_implementation'
+        nextAction: 'plan_implementation',
     };
 }
 /**
@@ -527,7 +547,7 @@ async function handleImplementationPlanning(session, input) {
     session.metadata.nextSteps = [
         'Generate ADR document',
         'Create TODO items',
-        'Update project plan'
+        'Update project plan',
     ];
     return {
         success: true,
@@ -555,7 +575,7 @@ The ADR will include:
 
 Use \`generate_adr\` to create the ADR document.`,
         nextAction: 'generate_adr',
-        readyToGenerate: true
+        readyToGenerate: true,
     };
 }
 /**
@@ -597,7 +617,7 @@ You can:
 - Use \`complete_session\` to finish and clean up
 - Make manual edits to the ADR file as needed`,
         nextAction: 'update_todos',
-        completed: true
+        completed: true,
     };
 }
 /**
@@ -611,23 +631,50 @@ async function requestResearch(args) {
     if (!session) {
         throw new McpAdrError(`Session ${args.sessionId} not found`, 'SESSION_NOT_FOUND');
     }
-    // Simulate research integration (would integrate with actual research tools)
+    // Smart Code Linking - discover relevant code and architecture files for the problem
+    const problemContext = session.context.problemStatement || 'architectural decision';
+    const relatedCodeResult = await findRelatedCode('adr-problem-research', problemContext, session.context.projectPath, {
+        useAI: true,
+        useRipgrep: true,
+        maxFiles: 20,
+        includeContent: false,
+    });
+    // Smart Code Linking - discover project structure and documentation
+    const projectFilesResult = await findFiles(session.context.projectPath, ['*.md', '*.json', '*.yaml', '*.yml', '*.txt', '*.rst'], {
+        limit: 100,
+    });
+    // Enhanced research findings with actual code context
     const researchFindings = [
         {
             source: 'Industry Best Practices',
-            insight: `For ${session.context.problemStatement}, microservices architecture is commonly used for scalability`,
-            relevance: 'High - Addresses core scalability concerns'
+            insight: `For architectural decisions like "${problemContext}", common patterns include layered architecture, microservices, and domain-driven design`,
+            relevance: 'High - Provides proven solution patterns',
         },
         {
             source: 'Current Codebase Analysis',
-            insight: 'Existing monolithic structure with clear domain boundaries',
-            relevance: 'High - Shows feasibility of decomposition'
+            insight: `Found ${relatedCodeResult.relatedFiles.length} files potentially related to the problem. Key areas: ${relatedCodeResult.relatedFiles
+                .slice(0, 5)
+                .map(f => f.path.split('/').pop())
+                .join(', ')}`,
+            relevance: 'High - Shows current implementation context',
         },
         {
-            source: 'Team Experience',
-            insight: 'Team has limited microservices experience but strong domain knowledge',
-            relevance: 'Medium - Impacts implementation approach'
-        }
+            source: 'Project Structure Analysis',
+            insight: `Project contains ${projectFilesResult.files.length} documentation/config files. Architecture appears to use ${detectArchitecturalPatterns(projectFilesResult.files.map(f => f.path))}`,
+            relevance: 'High - Indicates current architectural style',
+        },
+        {
+            source: 'Related Code Context',
+            insight: relatedCodeResult.relatedFiles.length > 0
+                ? `Found relevant code in: ${relatedCodeResult.relatedFiles
+                    .slice(0, 3)
+                    .map(f => f.path)
+                    .join(', ')}`
+                : 'No directly related code files found - this may be a greenfield decision',
+            relevance: relatedCodeResult.relatedFiles.length > 0
+                ? 'High - Direct code impact'
+                : 'Medium - New implementation area',
+        },
     ];
     session.context.researchFindings = researchFindings;
     session.phase = 'option_exploration';
@@ -637,8 +684,13 @@ async function requestResearch(args) {
         success: true,
         sessionId: args.sessionId,
         researchFindings,
-        guidance: 'Research complete. Moving to option exploration phase.',
-        nextAction: 'evaluate_options'
+        codeContext: {
+            relatedFiles: relatedCodeResult.relatedFiles.length,
+            projectFiles: projectFilesResult.files.length,
+            keyFiles: relatedCodeResult.relatedFiles.slice(0, 5).map(f => f.path),
+        },
+        guidance: `Research complete with actual code context analysis. Found ${relatedCodeResult.relatedFiles.length} related files. Moving to option exploration phase.`,
+        nextAction: 'evaluate_options',
     };
 }
 /**
@@ -652,46 +704,89 @@ async function evaluateOptions(args) {
     if (!session) {
         throw new McpAdrError(`Session ${args.sessionId} not found`, 'SESSION_NOT_FOUND');
     }
-    // Generate options based on problem and research
-    const options = [
+    // Smart Code Linking - find implementation examples and patterns in the codebase
+    const problemContext = session.context.problemStatement || 'architectural decision';
+    const patternContext = [
+        'architectural patterns',
+        'design patterns',
+        'implementation examples',
+        problemContext,
+        'configuration',
+        'setup',
+        'structure',
+    ].join(' ');
+    const patternFiles = await findRelatedCode('adr-pattern-analysis', patternContext, session.context.projectPath, {
+        useAI: true,
+        useRipgrep: true,
+        maxFiles: 15,
+        includeContent: false,
+    });
+    // Smart Code Linking - find similar architectural decisions or configurations
+    const configFilesResult = await findFiles(session.context.projectPath, [
+        '*.config.*',
+        'package.json',
+        'tsconfig.json',
+        '*.dockerfile',
+        'docker-compose.*',
+        '*.yaml',
+        '*.yml',
+    ], {
+        limit: 50,
+    });
+    // Generate contextual options based on actual codebase analysis
+    const baseOptions = [
         {
-            name: 'Full Microservices Migration',
-            description: 'Complete decomposition into microservices',
-            pros: ['Maximum scalability', 'Independent deployment', 'Technology flexibility'],
-            cons: ['High complexity', 'Significant refactoring', 'Operational overhead'],
-            risks: ['Team learning curve', 'Integration complexity', 'Data consistency'],
-            effort: 'high',
-            confidence: 60
+            name: 'Incremental Refactoring',
+            description: 'Gradually improve the existing architecture with minimal disruption',
+            pros: ['Low risk', 'Continuous delivery', 'Builds on existing patterns'],
+            cons: ['Slower progress', 'Technical debt accumulation', 'May not address root issues'],
+            risks: ['Incomplete transformation', 'Legacy constraints'],
+            effort: 'low',
+            confidence: 90,
         },
         {
-            name: 'Modular Monolith',
-            description: 'Keep monolithic deployment but enforce module boundaries',
-            pros: ['Simpler operations', 'Easier data consistency', 'Gradual evolution path'],
-            cons: ['Limited scalability', 'Shared deployment', 'Technology constraints'],
-            risks: ['Module boundary violations', 'Scaling limitations'],
+            name: 'Targeted Modernization',
+            description: 'Focus on specific components or areas identified through code analysis',
+            pros: ['Focused impact', 'Measurable improvements', 'Leverages existing structure'],
+            cons: ['Partial solution', 'Integration complexity'],
+            risks: ['Component boundaries', 'Data consistency'],
             effort: 'medium',
-            confidence: 80
+            confidence: 85,
         },
         {
-            name: 'Selective Service Extraction',
-            description: 'Extract only high-traffic components as services',
-            pros: ['Targeted scalability', 'Lower complexity', 'Pragmatic approach'],
-            cons: ['Partial benefits', 'Mixed architecture'],
-            risks: ['Service boundary decisions', 'Integration points'],
-            effort: 'medium',
-            confidence: 85
-        }
+            name: 'Comprehensive Redesign',
+            description: 'Complete architectural overhaul based on modern patterns',
+            pros: ['Clean slate approach', 'Modern best practices', 'Long-term maintainability'],
+            cons: ['High risk', 'Significant effort', 'Team learning curve'],
+            risks: ['Project timeline', 'Resource requirements', 'Knowledge transfer'],
+            effort: 'high',
+            confidence: 60,
+        },
     ];
-    session.context.options = options;
+    // Enhance options with code context insights
+    const enhancedOptions = baseOptions.map(option => ({
+        ...option,
+        codeContext: {
+            relatedFiles: patternFiles.relatedFiles.slice(0, 3).map(f => f.path),
+            configFiles: configFilesResult.files.slice(0, 3).map(f => f.path),
+            feasibilityNotes: generateFeasibilityNotes(option, patternFiles.relatedFiles, configFilesResult.files.map(f => f.path)),
+        },
+    }));
+    session.context.options = enhancedOptions;
     session.phase = 'decision_making';
     session.metadata.updatedAt = new Date().toISOString();
     await saveSession(session);
     return {
         success: true,
         sessionId: args.sessionId,
-        options,
-        guidance: 'Options evaluated. Ready for decision making.',
-        nextAction: 'make_decision'
+        options: enhancedOptions,
+        codeAnalysis: {
+            patternFiles: patternFiles.relatedFiles.length,
+            configFiles: configFilesResult.files.length,
+            keyPatterns: patternFiles.relatedFiles.slice(0, 5).map(f => f.path),
+        },
+        guidance: `Options evaluated with codebase context. Found ${patternFiles.relatedFiles.length} pattern-related files and ${configFilesResult.files.length} configuration files. Ready for decision making.`,
+        nextAction: 'make_decision',
     };
 }
 /**
@@ -716,14 +811,14 @@ async function updateTodos(args) {
         effort: task.effort,
         assignee: task.assignee,
         adrLink: session.context.adrContent ? 'Generated ADR' : undefined,
-        status: 'pending'
+        status: 'pending',
     }));
     return {
         success: true,
         sessionId: args.sessionId,
         todosGenerated: todos.length,
         todos,
-        guidance: `Generated ${todos.length} TODO items from the implementation plan.`
+        guidance: `Generated ${todos.length} TODO items from the implementation plan.`,
     };
 }
 /**
@@ -743,52 +838,52 @@ async function getGuidance(args) {
                 'Be specific about the problem',
                 'Include quantifiable metrics if possible',
                 'Identify all stakeholders',
-                'Define clear success criteria'
+                'Define clear success criteria',
             ],
             questions: [
                 'What specific problem are we solving?',
                 'Why does this need to be addressed now?',
                 'What happens if we do nothing?',
-                'How will we measure success?'
+                'How will we measure success?',
             ],
             examples: [
                 'Application response time exceeds 3 seconds under load',
                 'Cannot deploy services independently',
-                'Database becoming a bottleneck for scaling'
-            ]
+                'Database becoming a bottleneck for scaling',
+            ],
         },
         research_analysis: {
             tips: [
                 'Look for industry patterns',
                 'Analyze similar problems in your codebase',
                 'Consider team capabilities',
-                'Research tooling and frameworks'
+                'Research tooling and frameworks',
             ],
             questions: [
                 'What solutions have others used?',
                 'What patterns apply to our context?',
                 'What are the technical constraints?',
-                'What skills does the team have?'
-            ]
+                'What skills does the team have?',
+            ],
         },
         option_exploration: {
             tips: [
                 'Consider at least 3 options',
                 'Include a "do nothing" option if relevant',
                 'Be honest about pros and cons',
-                'Estimate effort realistically'
+                'Estimate effort realistically',
             ],
             questions: [
                 'What are all possible approaches?',
                 'What are the tradeoffs?',
                 'How much effort is each option?',
-                'What are the risks?'
-            ]
-        }
+                'What are the risks?',
+            ],
+        },
     };
     const currentGuidance = phaseGuidance[session.phase] || {
         tips: ['Follow the structured process'],
-        questions: ['What do you need help with?']
+        questions: ['What do you need help with?'],
     };
     return {
         success: true,
@@ -796,7 +891,7 @@ async function getGuidance(args) {
         phase: session.phase,
         guidance: currentGuidance,
         progress: getSessionProgress(session),
-        nextSteps: session.metadata.nextSteps
+        nextSteps: session.metadata.nextSteps,
     };
 }
 /**
@@ -830,9 +925,9 @@ async function completeSession(args) {
             decision: session.context.selectedOption?.name,
             adrGenerated: !!session.context.adrContent,
             tasksCreated: session.context.implementation?.tasks.length || 0,
-            duration: calculateDuration(session.metadata.createdAt, session.metadata.updatedAt)
+            duration: calculateDuration(session.metadata.createdAt, session.metadata.updatedAt),
         },
-        message: 'Planning session completed successfully!'
+        message: 'Planning session completed successfully!',
     };
 }
 /**
@@ -869,7 +964,8 @@ ${session.context.selectedOption?.tradeoffs.map(t => `- ${t}`).join('\n')}
 
 ## Considered Options
 
-${session.context.options.map(opt => `
+${session.context.options
+        .map(opt => `
 ### ${opt.name}
 
 ${opt.description}
@@ -882,7 +978,8 @@ ${opt.cons.map(c => `- ${c}`).join('\n')}
 
 **Effort:** ${opt.effort}  
 **Confidence:** ${opt.confidence}%
-`).join('\n')}
+`)
+        .join('\n')}
 
 ## Consequences
 
@@ -907,7 +1004,9 @@ ${session.context.impacts?.dependencies.map(d => `- ${d}`).join('\n')}
 ${session.context.implementation?.phases.map((p, i) => `${i + 1}. ${p}`).join('\n')}
 
 ### Tasks
-${session.context.implementation?.tasks.map(t => `- [ ] ${t.description} (Priority: ${t.priority}, Effort: ${t.effort}${t.assignee ? `, Assignee: ${t.assignee}` : ''})`).join('\n')}
+${session.context.implementation?.tasks
+        .map(t => `- [ ] ${t.description} (Priority: ${t.priority}, Effort: ${t.effort}${t.assignee ? `, Assignee: ${t.assignee}` : ''})`)
+        .join('\n')}
 
 ### Timeline
 ${session.context.implementation?.timeline}
@@ -953,7 +1052,7 @@ function getSessionProgress(session) {
         'decision_making',
         'impact_assessment',
         'implementation_planning',
-        'adr_generation'
+        'adr_generation',
     ];
     const currentIndex = phases.indexOf(session.phase);
     if (currentIndex === -1)
@@ -974,6 +1073,68 @@ function calculateDuration(start, end) {
     }
     return `${minutes}m`;
 }
+/**
+ * Helper function to detect architectural patterns from project files
+ */
+function detectArchitecturalPatterns(projectFiles) {
+    const patterns = [];
+    const filenames = projectFiles.map(f => f.toLowerCase());
+    // Check for common architectural patterns
+    if (filenames.some(f => f.includes('microservice') || f.includes('service'))) {
+        patterns.push('microservices');
+    }
+    if (filenames.some(f => f.includes('docker') || f.includes('container'))) {
+        patterns.push('containerization');
+    }
+    if (filenames.some(f => f.includes('api') || f.includes('rest') || f.includes('graphql'))) {
+        patterns.push('API-driven');
+    }
+    if (filenames.some(f => f.includes('module') || f.includes('component'))) {
+        patterns.push('modular architecture');
+    }
+    if (filenames.some(f => f.includes('config') || f.includes('env'))) {
+        patterns.push('configuration management');
+    }
+    if (filenames.some(f => f.includes('test') || f.includes('spec'))) {
+        patterns.push('test-driven development');
+    }
+    return patterns.length > 0 ? patterns.join(', ') : 'standard architecture';
+}
+/**
+ * Helper function to generate feasibility notes based on code context
+ */
+function generateFeasibilityNotes(option, relatedFiles, configFiles) {
+    const notes = [];
+    // Analyze based on option effort level
+    if (option.effort === 'low') {
+        if (relatedFiles.length > 0) {
+            notes.push(`Existing code patterns can be leveraged for gradual improvements`);
+        }
+        if (configFiles.length > 0) {
+            notes.push(`Current configuration structure supports incremental changes`);
+        }
+    }
+    else if (option.effort === 'medium') {
+        if (relatedFiles.length > 5) {
+            notes.push(`Substantial existing code base provides good foundation for targeted changes`);
+        }
+        else {
+            notes.push(`Limited existing code may require more new development than expected`);
+        }
+    }
+    else if (option.effort === 'high') {
+        if (configFiles.length > 3) {
+            notes.push(`Complex configuration setup indicates significant integration work`);
+        }
+        if (relatedFiles.length > 10) {
+            notes.push(`Large codebase will require careful migration planning and phased approach`);
+        }
+        else {
+            notes.push(`Smaller codebase may allow for more rapid comprehensive changes`);
+        }
+    }
+    return notes.length > 0 ? notes.join('. ') : 'Standard implementation approach recommended';
+}
 /**
  * Main entry point for the interactive ADR planning tool
  */
@@ -1006,12 +1167,13 @@ export async function interactiveAdrPlanning(args) {
                 return await updateTodos(input);
             case 'get_guidance':
                 return await getGuidance(input);
-            case 'save_session':
+            case 'save_session': {
                 const session = sessions.get(input.sessionId);
                 if (!session)
                     throw new McpAdrError('Session not found', 'SESSION_NOT_FOUND');
                 await saveSession(session);
                 return { success: true, message: 'Session saved' };
+            }
             case 'complete_session':
                 return await completeSession(input);
             default: