mcp-adr-analysis-server 2.0.21 → 2.1.0

package/dist/src/tools/mcp-planning-tool.js

@@ -21,9 +21,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 { TodoJsonManager } from '../utils/todo-json-manager.js';
+// TodoJsonManager removed - use mcp-shrimp-task-manager for task management
 // Project phase schema
 const ProjectPhaseSchema = z.object({
     id: z.string(),
@@ -42,13 +43,15 @@ const ProjectPhaseSchema = z.object({
     completion: z.number().min(0).max(100).default(0),
     riskLevel: z.enum(['low', 'medium', 'high', 'critical']).default('medium'),
     riskFactors: z.array(z.string()).default([]),
-    resources: z.array(z.object({
+    resources: z
+        .array(z.object({
         role: z.string(),
         capacity: z.string(), // e.g., "40h/week"
-        allocation: z.number().min(0).max(100) // percentage allocated to this phase
-    })).default([]),
+        allocation: z.number().min(0).max(100), // percentage allocated to this phase
+    }))
+        .default([]),
     createdAt: z.string(),
-    updatedAt: z.string()
+    updatedAt: z.string(),
 });
 // Team member schema
 const TeamMemberSchema = z.object({
@@ -58,11 +61,13 @@ const TeamMemberSchema = z.object({
     skills: z.array(z.string()).default([]),
     capacity: z.string(), // e.g., "40h/week"
     currentWorkload: z.number().min(0).max(100).default(0), // percentage utilization
-    availability: z.object({
+    availability: z
+        .object({
         startDate: z.string().optional(),
         endDate: z.string().optional(),
-        unavailableDates: z.array(z.string()).default([])
-    }).optional()
+        unavailableDates: z.array(z.string()).default([]),
+    })
+        .optional(),
 });
 // Project schema
 const ProjectPlanSchema = z.object({
@@ -72,37 +77,43 @@ const ProjectPlanSchema = z.object({
     status: z.enum(['planning', 'active', 'completed', 'on_hold', 'cancelled']),
     phases: z.array(ProjectPhaseSchema).default([]),
     team: z.array(TeamMemberSchema).default([]),
-    milestones: z.array(z.object({
+    milestones: z
+        .array(z.object({
         id: z.string(),
         name: z.string(),
         description: z.string().optional(),
         dueDate: z.string(),
         status: z.enum(['pending', 'achieved', 'delayed', 'cancelled']),
         criteria: z.array(z.string()).default([]),
-        linkedPhases: z.array(z.string()).default([])
-    })).default([]),
-    risks: z.array(z.object({
+        linkedPhases: z.array(z.string()).default([]),
+    }))
+        .default([]),
+    risks: z
+        .array(z.object({
         id: z.string(),
         description: z.string(),
         impact: z.enum(['low', 'medium', 'high', 'critical']),
         probability: z.enum(['low', 'medium', 'high']),
         mitigation: z.string().optional(),
         owner: z.string().optional(),
-        status: z.enum(['open', 'mitigated', 'closed'])
-    })).default([]),
+        status: z.enum(['open', 'mitigated', 'closed']),
+    }))
+        .default([]),
     metadata: z.object({
         createdAt: z.string(),
         updatedAt: z.string(),
         createdBy: z.string(),
         projectPath: z.string(),
         adrDirectory: z.string().default('docs/adrs'),
-        linkedAdrs: z.array(z.string()).default([])
+        linkedAdrs: z.array(z.string()).default([]),
     }),
-    settings: z.object({
+    settings: z
+        .object({
         autoPhaseTransition: z.boolean().default(false),
         riskAssessmentInterval: z.string().default('weekly'),
-        progressUpdateFrequency: z.string().default('daily')
-    }).default({})
+        progressUpdateFrequency: z.string().default('daily'),
+    })
+        .default({}),
 });
 // Operation schemas
 const CreateProjectSchema = z.object({
@@ -110,76 +121,111 @@ const CreateProjectSchema = z.object({
     projectPath: z.string().describe('Project root path'),
     projectName: z.string().describe('Project name'),
     description: z.string().optional().describe('Project description'),
-    phases: z.array(z.object({
+    phases: z
+        .array(z.object({
         name: z.string(),
         duration: z.string(),
         dependencies: z.array(z.string()).default([]),
-        milestones: z.array(z.string()).default([])
-    })).describe('Initial project phases'),
-    team: z.array(z.object({
+        milestones: z.array(z.string()).default([]),
+    }))
+        .describe('Initial project phases'),
+    team: z
+        .array(z.object({
         name: z.string(),
         role: z.string(),
         skills: z.array(z.string()).default([]),
-        capacity: z.string()
-    })).default([]).describe('Team structure'),
+        capacity: z.string(),
+    }))
+        .default([])
+        .describe('Team structure'),
     importFromAdrs: z.boolean().default(true).describe('Import phases from existing ADRs'),
-    importFromTodos: z.boolean().default(true).describe('Import tasks from TODO system')
+    importFromTodos: z.boolean().default(true).describe('Import tasks from TODO system'),
 });
 const ManagePhasesSchema = z.object({
     operation: z.literal('manage_phases'),
     projectPath: z.string().describe('Project root path'),
-    action: z.enum(['list', 'create', 'update', 'delete', 'transition']).describe('Phase management action'),
+    action: z
+        .enum(['list', 'create', 'update', 'delete', 'transition'])
+        .describe('Phase management action'),
     phaseId: z.string().optional().describe('Phase ID for update/delete/transition'),
-    phaseData: z.object({
+    phaseData: z
+        .object({
         name: z.string().optional(),
         description: z.string().optional(),
         estimatedDuration: z.string().optional(),
         dependencies: z.array(z.string()).optional(),
         milestones: z.array(z.string()).optional(),
-        linkedAdrs: z.array(z.string()).optional()
-    }).optional().describe('Phase data for create/update'),
-    targetStatus: z.enum(['planning', 'active', 'completed', 'blocked', 'cancelled']).optional().describe('Target status for transition')
+        linkedAdrs: z.array(z.string()).optional(),
+    })
+        .optional()
+        .describe('Phase data for create/update'),
+    targetStatus: z
+        .enum(['planning', 'active', 'completed', 'blocked', 'cancelled'])
+        .optional()
+        .describe('Target status for transition'),
 });
 const TrackProgressSchema = z.object({
     operation: z.literal('track_progress'),
     projectPath: z.string().describe('Project root path'),
-    reportType: z.enum(['summary', 'detailed', 'gantt', 'milestones', 'risks']).default('summary').describe('Type of progress report'),
-    timeframe: z.enum(['current', 'weekly', 'monthly', 'quarterly']).default('current').describe('Time frame for progress tracking'),
+    reportType: z
+        .enum(['summary', 'detailed', 'gantt', 'milestones', 'risks'])
+        .default('summary')
+        .describe('Type of progress report'),
+    timeframe: z
+        .enum(['current', 'weekly', 'monthly', 'quarterly'])
+        .default('current')
+        .describe('Time frame for progress tracking'),
     includeVisuals: z.boolean().default(true).describe('Include visual progress indicators'),
-    updateTaskProgress: z.boolean().default(true).describe('Sync progress from TODO system')
+    updateTaskProgress: z.boolean().default(true).describe('Sync progress from TODO system'),
 });
 const ManageResourcesSchema = z.object({
     operation: z.literal('manage_resources'),
     projectPath: z.string().describe('Project root path'),
-    action: z.enum(['list', 'add', 'update', 'remove', 'allocate', 'optimize']).describe('Resource management action'),
+    action: z
+        .enum(['list', 'add', 'update', 'remove', 'allocate', 'optimize'])
+        .describe('Resource management action'),
     memberId: z.string().optional().describe('Team member ID for individual actions'),
-    memberData: z.object({
+    memberData: z
+        .object({
         name: z.string().optional(),
         role: z.string().optional(),
         skills: z.array(z.string()).optional(),
-        capacity: z.string().optional()
-    }).optional().describe('Team member data'),
-    allocationData: z.object({
+        capacity: z.string().optional(),
+    })
+        .optional()
+        .describe('Team member data'),
+    allocationData: z
+        .object({
         phaseId: z.string(),
-        allocation: z.number().min(0).max(100)
-    }).optional().describe('Resource allocation data')
+        allocation: z.number().min(0).max(100),
+    })
+        .optional()
+        .describe('Resource allocation data'),
 });
 const RiskAnalysisSchema = z.object({
     operation: z.literal('risk_analysis'),
     projectPath: z.string().describe('Project root path'),
-    analysisType: z.enum(['automated', 'manual', 'comprehensive']).default('comprehensive').describe('Type of risk analysis'),
+    analysisType: z
+        .enum(['automated', 'manual', 'comprehensive'])
+        .default('comprehensive')
+        .describe('Type of risk analysis'),
     includeAdrRisks: z.boolean().default(true).describe('Analyze risks from ADR complexity'),
     includeDependencyRisks: z.boolean().default(true).describe('Analyze dependency chain risks'),
     includeResourceRisks: z.boolean().default(true).describe('Analyze resource allocation risks'),
-    generateMitigation: z.boolean().default(true).describe('Generate mitigation strategies')
+    generateMitigation: z.boolean().default(true).describe('Generate mitigation strategies'),
 });
 const GenerateReportsSchema = z.object({
     operation: z.literal('generate_reports'),
     projectPath: z.string().describe('Project root path'),
-    reportType: z.enum(['executive', 'status', 'health', 'team_performance', 'milestone_tracking']).describe('Type of report to generate'),
+    reportType: z
+        .enum(['executive', 'status', 'health', 'team_performance', 'milestone_tracking'])
+        .describe('Type of report to generate'),
     format: z.enum(['markdown', 'json', 'html']).default('markdown').describe('Report output format'),
     includeCharts: z.boolean().default(true).describe('Include progress charts and graphs'),
-    timeframe: z.enum(['week', 'month', 'quarter', 'project']).default('month').describe('Report time frame')
+    timeframe: z
+        .enum(['week', 'month', 'quarter', 'project'])
+        .default('month')
+        .describe('Report time frame'),
 });
 // Main operation schema
 const McpPlanningSchema = z.union([
@@ -188,13 +234,14 @@ const McpPlanningSchema = z.union([
     TrackProgressSchema,
     ManageResourcesSchema,
     RiskAnalysisSchema,
-    GenerateReportsSchema
+    GenerateReportsSchema,
 ]);
 /**
  * Get planning cache directory
  */
 function getPlanningCacheDir(projectPath) {
-    return join(projectPath, '.mcp-adr-cache');
+    const projectName = basename(projectPath);
+    return join(os.tmpdir(), projectName, 'cache');
 }
 /**
  * Get planning data file path
@@ -210,7 +257,7 @@ async function ensureCacheDir(projectPath) {
     try {
         await fs.mkdir(cacheDir, { recursive: true });
     }
-    catch (error) {
+    catch {
         // Directory might already exist, that's ok
     }
 }
@@ -223,7 +270,7 @@ async function loadPlanningData(projectPath) {
         const data = await fs.readFile(planningPath, 'utf-8');
         return ProjectPlanSchema.parse(JSON.parse(data));
     }
-    catch (error) {
+    catch {
         return null;
     }
 }
@@ -272,7 +319,7 @@ async function createProject(args) {
         riskFactors: [],
         resources: [],
         createdAt: now,
-        updatedAt: now
+        updatedAt: now,
     }));
     // Create team members
     const teamMembers = team.map(member => ({
@@ -281,7 +328,7 @@ async function createProject(args) {
         role: member.role,
         skills: member.skills,
         capacity: member.capacity,
-        currentWorkload: 0
+        currentWorkload: 0,
     }));
     // Import from ADRs if requested
     if (importFromAdrs) {
@@ -302,8 +349,10 @@ async function createProject(args) {
     // Import from TODO system if requested
     if (importFromTodos) {
         try {
-            const todoManager = new TodoJsonManager();
-            const todoData = await todoManager.loadTodoData();
+            // TodoJsonManager removed - use mcp-shrimp-task-manager for task management
+            console.warn('⚠️ TodoJsonManager is deprecated and was removed in memory-centric transformation');
+            // todoManager removed - skip loading todo data
+            const todoData = null;
             if (todoData && todoData.tasks && Object.values(todoData.tasks).length > 0) {
                 // Distribute tasks across phases based on categories or ADR links
                 const tasksArray = Object.values(todoData.tasks);
@@ -334,17 +383,18 @@ async function createProject(args) {
             createdBy: 'mcp-planning-tool',
             projectPath,
             adrDirectory: 'docs/adrs',
-            linkedAdrs: projectPhases.flatMap(p => p.linkedAdrs)
+            linkedAdrs: projectPhases.flatMap(p => p.linkedAdrs),
         },
         settings: {
             autoPhaseTransition: false,
             riskAssessmentInterval: 'weekly',
-            progressUpdateFrequency: 'daily'
-        }
+            progressUpdateFrequency: 'daily',
+        },
     };
     await savePlanningData(projectPath, projectPlan);
     return {
-        content: [{
+        content: [
+            {
                 type: 'text',
                 text: `# Project Created Successfully
 
@@ -356,22 +406,26 @@ async function createProject(args) {
 - **Team Members**: ${teamMembers.length}
 
 ## Project Phases
-${projectPhases.map((phase, index) => `
+${projectPhases
+                    .map((phase, index) => `
 ### Phase ${index + 1}: ${phase.name}
 - **Duration**: ${phase.estimatedDuration}
 - **Dependencies**: ${phase.dependencies.length > 0 ? phase.dependencies.join(', ') : 'None'}
 - **Milestones**: ${phase.milestones.length > 0 ? phase.milestones.join(', ') : 'None'}
 - **Linked ADRs**: ${phase.linkedAdrs.length}
 - **Tasks**: ${phase.tasks.length}
-`).join('')}
+`)
+                    .join('')}
 
 ## Team Structure
-${teamMembers.map(member => `
+${teamMembers
+                    .map(member => `
 ### ${member.name} - ${member.role}
 - **Capacity**: ${member.capacity}
 - **Skills**: ${member.skills.join(', ')}
 - **Current Workload**: ${member.currentWorkload}%
-`).join('')}
+`)
+                    .join('')}
 
 ## Next Steps
 1. Use \`manage_phases\` to refine phase details
@@ -384,8 +438,9 @@ ${teamMembers.map(member => `
 - **TODO Import**: ${importFromTodos ? `✅ Imported tasks from TODO system` : '❌ Skipped'}
 
 Project planning data saved to: \`.mcp-adr-cache/project-planning.json\`
-`
-            }]
+`,
+            },
+        ],
     };
 }
 /**
@@ -401,13 +456,15 @@ async function managePhases(args) {
     switch (action) {
         case 'list':
             return {
-                content: [{
+                content: [
+                    {
                         type: 'text',
                         text: `# Project Phases
 
 ## ${projectPlan.name}
 
-${projectPlan.phases.map((phase, index) => `
+${projectPlan.phases
+                            .map((phase, index) => `
 ### Phase ${index + 1}: ${phase.name}
 - **Status**: ${phase.status}
 - **Progress**: ${phase.completion}%
@@ -417,13 +474,15 @@ ${projectPlan.phases.map((phase, index) => `
 - **Risk Level**: ${phase.riskLevel}
 - **Tasks**: ${phase.tasks.length}
 - **Linked ADRs**: ${phase.linkedAdrs.length}
-`).join('')}
+`)
+                            .join('')}
 
 Total phases: ${projectPlan.phases.length}
-`
-                    }]
+`,
+                    },
+                ],
             };
-        case 'create':
+        case 'create': {
             if (!phaseData?.name) {
                 throw new McpAdrError('Phase name is required for creation', 'INVALID_INPUT');
             }
@@ -443,12 +502,13 @@ Total phases: ${projectPlan.phases.length}
                 riskFactors: [],
                 resources: [],
                 createdAt: now,
-                updatedAt: now
+                updatedAt: now,
             };
             projectPlan.phases.push(newPhase);
             await savePlanningData(projectPath, projectPlan);
             return {
-                content: [{
+                content: [
+                    {
                         type: 'text',
                         text: `# Phase Created
 
@@ -460,10 +520,12 @@ Total phases: ${projectPlan.phases.length}
 - **Dependencies**: ${newPhase.dependencies.join(', ') || 'None'}
 
 Use \`manage_resources\` to allocate team members to this phase.
-`
-                    }]
+`,
+                    },
+                ],
             };
-        case 'update':
+        }
+        case 'update': {
             if (!phaseId) {
                 throw new McpAdrError('Phase ID is required for update', 'INVALID_INPUT');
             }
@@ -478,22 +540,25 @@ Use \`manage_resources\` to allocate team members to this phase.
             if (phaseData) {
                 Object.assign(phase, {
                     ...phaseData,
-                    updatedAt: now
+                    updatedAt: now,
                 });
             }
             await savePlanningData(projectPath, projectPlan);
             return {
-                content: [{
+                content: [
+                    {
                         type: 'text',
                         text: `# Phase Updated
 
 **${phase.name}** has been updated successfully.
 
 Updated fields: ${Object.keys(phaseData || {}).join(', ')}
-`
-                    }]
+`,
+                    },
+                ],
             };
-        case 'transition':
+        }
+        case 'transition': {
             if (!phaseId || !targetStatus) {
                 throw new McpAdrError('Phase ID and target status are required for transition', 'INVALID_INPUT');
             }
@@ -517,17 +582,20 @@ Updated fields: ${Object.keys(phaseData || {}).join(', ')}
             }
             await savePlanningData(projectPath, projectPlan);
             return {
-                content: [{
+                content: [
+                    {
                         type: 'text',
                         text: `# Phase Transition Complete
 
 **${transitionPhase.name}** status changed from **${oldStatus}** to **${targetStatus}**.
 
 Current completion: ${transitionPhase.completion}%
-`
-                    }]
+`,
+                    },
+                ],
             };
-        case 'delete':
+        }
+        case 'delete': {
             if (!phaseId) {
                 throw new McpAdrError('Phase ID is required for deletion', 'INVALID_INPUT');
             }
@@ -541,16 +609,19 @@ Current completion: ${transitionPhase.completion}%
             }
             await savePlanningData(projectPath, projectPlan);
             return {
-                content: [{
+                content: [
+                    {
                         type: 'text',
                         text: `# Phase Deleted
 
 **${deletedPhase.name}** has been removed from the project.
 
 Remaining phases: ${projectPlan.phases.length}
-`
-                    }]
+`,
+                    },
+                ],
             };
+        }
         default:
             throw new McpAdrError(`Unknown phase action: ${action}`, 'INVALID_INPUT');
     }
@@ -567,8 +638,10 @@ async function trackProgress(args) {
     // Update task progress from TODO system if requested
     if (updateTaskProgress) {
         try {
-            const todoManager = new TodoJsonManager();
-            const todoData = await todoManager.loadTodoData();
+            // TodoJsonManager removed - use mcp-shrimp-task-manager for task management
+            console.warn('⚠️ TodoJsonManager is deprecated and was removed in memory-centric transformation');
+            // todoManager removed - skip loading todo data
+            const todoData = null;
             if (todoData && todoData.tasks) {
                 const tasksArray = Object.values(todoData.tasks);
                 for (const phase of projectPlan.phases) {
@@ -590,11 +663,14 @@ async function trackProgress(args) {
     const completedPhases = projectPlan.phases.filter(p => p.status === 'completed').length;
     const activePhases = projectPlan.phases.filter(p => p.status === 'active').length;
     const blockedPhases = projectPlan.phases.filter(p => p.status === 'blocked').length;
-    const overallProgress = totalPhases > 0 ? Math.round(projectPlan.phases.reduce((sum, phase) => sum + phase.completion, 0) / totalPhases) : 0;
+    const overallProgress = totalPhases > 0
+        ? Math.round(projectPlan.phases.reduce((sum, phase) => sum + phase.completion, 0) / totalPhases)
+        : 0;
     switch (reportType) {
         case 'summary':
             return {
-                content: [{
+                content: [
+                    {
                         type: 'text',
                         text: `# Project Progress Summary
 
@@ -609,28 +685,38 @@ async function trackProgress(args) {
 - **Blocked**: ${blockedPhases}
 
 ### Phase Progress
-${projectPlan.phases.map(phase => `
+${projectPlan.phases
+                            .map(phase => `
 #### ${phase.name}
 - **Status**: ${phase.status}
 - **Progress**: ${phase.completion}% ${includeVisuals ? getProgressBar(phase.completion) : ''}
 - **Tasks**: ${phase.tasks.length}
 - **Blockers**: ${phase.blockers.length}
-`).join('')}
+`)
+                            .join('')}
 
 ### Current Focus
-${activePhases > 0 ?
-                            `Currently working on ${activePhases} phase(s):\n${projectPlan.phases.filter(p => p.status === 'active').map(p => `- ${p.name}`).join('\n')}` :
-                            'No active phases'}
+${activePhases > 0
+                            ? `Currently working on ${activePhases} phase(s):\n${projectPlan.phases
+                                .filter(p => p.status === 'active')
+                                .map(p => `- ${p.name}`)
+                                .join('\n')}`
+                            : 'No active phases'}
 
-${blockedPhases > 0 ?
-                            `\n⚠️ **Blocked Phases**: ${projectPlan.phases.filter(p => p.status === 'blocked').map(p => p.name).join(', ')}` :
-                            ''}
-`
-                    }]
+${blockedPhases > 0
+                            ? `\n⚠️ **Blocked Phases**: ${projectPlan.phases
+                                .filter(p => p.status === 'blocked')
+                                .map(p => p.name)
+                                .join(', ')}`
+                            : ''}
+`,
+                    },
+                ],
             };
         case 'detailed':
             return {
-                content: [{
+                content: [
+                    {
                         type: 'text',
                         text: `# Detailed Progress Report
 
@@ -642,7 +728,8 @@ ${blockedPhases > 0 ?
 - **Risk Level**: ${calculateProjectRisk(projectPlan)}
 - **Timeline Status**: ${calculateTimelineStatus(projectPlan)}
 
-${projectPlan.phases.map(phase => `
+${projectPlan.phases
+                            .map(phase => `
 ### ${phase.name}
 - **Status**: ${phase.status}
 - **Progress**: ${phase.completion}% ${includeVisuals ? getProgressBar(phase.completion) : ''}
@@ -655,45 +742,55 @@ ${projectPlan.phases.map(phase => `
 - **Resources**: ${phase.resources.length} team members allocated
 
 ${phase.riskFactors.length > 0 ? `**Risk Factors**:\n${phase.riskFactors.map(r => `- ${r}`).join('\n')}` : ''}
-`).join('')}
-`
-                    }]
+`)
+                            .join('')}
+`,
+                    },
+                ],
             };
         case 'milestones':
             return {
-                content: [{
+                content: [
+                    {
                         type: 'text',
                         text: `# Milestone Tracking
 
 ## ${projectPlan.name}
 
 ### Project Milestones
-${projectPlan.milestones.length > 0 ?
-                            projectPlan.milestones.map(milestone => `
+${projectPlan.milestones.length > 0
+                            ? projectPlan.milestones
+                                .map(milestone => `
 #### ${milestone.name}
 - **Status**: ${milestone.status}
 - **Due Date**: ${milestone.dueDate}
 - **Linked Phases**: ${milestone.linkedPhases.join(', ') || 'None'}
 - **Criteria**: ${milestone.criteria.join(', ') || 'None'}
-`).join('') :
-                            'No project milestones defined'}
+`)
+                                .join('')
+                            : 'No project milestones defined'}
 
 ### Phase Milestones
-${projectPlan.phases.map(phase => `
+${projectPlan.phases
+                            .map(phase => `
 #### ${phase.name}
-${phase.milestones.length > 0 ?
-                            phase.milestones.map(m => `- ${m}`).join('\n') :
-                            '- No milestones defined'}
-`).join('')}
-`
-                    }]
+${phase.milestones.length > 0
+                            ? phase.milestones.map(m => `- ${m}`).join('\n')
+                            : '- No milestones defined'}
+`)
+                            .join('')}
+`,
+                    },
+                ],
             };
         default:
             return {
-                content: [{
+                content: [
+                    {
                         type: 'text',
-                        text: `Progress tracking for report type "${reportType}" is not yet implemented.`
-                    }]
+                        text: `Progress tracking for report type "${reportType}" is not yet implemented.`,
+                    },
+                ],
             };
     }
 }
@@ -709,34 +806,42 @@ async function manageResources(args) {
     switch (action) {
         case 'list':
             return {
-                content: [{
+                content: [
+                    {
                         type: 'text',
                         text: `# Team Resources
 
 ## ${projectPlan.name}
 
 ### Team Members
-${projectPlan.team.map(member => `
+${projectPlan.team
+                            .map(member => `
 #### ${member.name} - ${member.role}
 - **Capacity**: ${member.capacity}
 - **Current Workload**: ${member.currentWorkload}%
 - **Skills**: ${member.skills.join(', ') || 'None specified'}
 - **Availability**: ${member.availability ? 'Configured' : 'Not set'}
-`).join('')}
+`)
+                            .join('')}
 
 ### Resource Allocation
-${projectPlan.phases.map(phase => `
+${projectPlan.phases
+                            .map(phase => `
 #### ${phase.name}
-${phase.resources.length > 0 ?
-                            phase.resources.map(resource => `- ${resource.role}: ${resource.allocation}% (${resource.capacity})`).join('\n') :
-                            '- No resources allocated'}
-`).join('')}
+${phase.resources.length > 0
+                            ? phase.resources
+                                .map(resource => `- ${resource.role}: ${resource.allocation}% (${resource.capacity})`)
+                                .join('\n')
+                            : '- No resources allocated'}
+`)
+                            .join('')}
 
 Total team members: ${projectPlan.team.length}
-`
-                    }]
+`,
+                    },
+                ],
             };
-        case 'add':
+        case 'add': {
             if (!memberData?.name || !memberData?.role) {
                 throw new McpAdrError('Member name and role are required', 'INVALID_INPUT');
             }
@@ -746,12 +851,13 @@ Total team members: ${projectPlan.team.length}
                 role: memberData.role,
                 skills: memberData.skills || [],
                 capacity: memberData.capacity || '40h/week',
-                currentWorkload: 0
+                currentWorkload: 0,
             };
             projectPlan.team.push(newMember);
             await savePlanningData(projectPath, projectPlan);
             return {
-                content: [{
+                content: [
+                    {
                         type: 'text',
                         text: `# Team Member Added
 
@@ -762,15 +868,19 @@ Total team members: ${projectPlan.team.length}
 - **Skills**: ${newMember.skills.join(', ') || 'None specified'}
 
 Use \`allocate\` action to assign them to project phases.
-`
-                    }]
+`,
+                    },
+                ],
             };
+        }
         default:
             return {
-                content: [{
+                content: [
+                    {
                         type: 'text',
-                        text: `Resource management for action "${action}" is not yet implemented.`
-                    }]
+                        text: `Resource management for action "${action}" is not yet implemented.`,
+                    },
+                ],
             };
     }
 }
@@ -778,7 +888,7 @@ Use \`allocate\` action to assign them to project phases.
  * Risk analysis operation
  */
 async function riskAnalysis(args) {
-    const { projectPath, includeAdrRisks, includeDependencyRisks, includeResourceRisks, generateMitigation } = args;
+    const { projectPath, includeAdrRisks, includeDependencyRisks, includeResourceRisks, generateMitigation, } = args;
     const projectPlan = await loadPlanningData(projectPath);
     if (!projectPlan) {
         throw new McpAdrError(`No project found at ${projectPath}. Use create_project first.`, 'PROJECT_NOT_FOUND');
@@ -792,7 +902,7 @@ async function riskAnalysis(args) {
                     category: 'Architecture',
                     description: `Phase "${phase.name}" has no linked ADRs - architectural decisions may be unclear`,
                     impact: 'medium',
-                    probability: 'high'
+                    probability: 'high',
                 };
                 if (generateMitigation) {
                     riskObj.mitigation = 'Review and create ADRs for architectural decisions in this phase';
@@ -804,10 +914,11 @@ async function riskAnalysis(args) {
                     category: 'Complexity',
                     description: `Phase "${phase.name}" has many ADRs (${phase.linkedAdrs.length}) - high complexity risk`,
                     impact: 'high',
-                    probability: 'medium'
+                    probability: 'medium',
                 };
                 if (generateMitigation) {
-                    riskObj.mitigation = 'Consider breaking this phase into smaller, more manageable sub-phases';
+                    riskObj.mitigation =
+                        'Consider breaking this phase into smaller, more manageable sub-phases';
                 }
                 risks.push(riskObj);
             }
@@ -821,10 +932,11 @@ async function riskAnalysis(args) {
                     category: 'Dependencies',
                     description: `Phase "${phase.name}" has multiple dependencies (${phase.dependencies.length}) - high coordination risk`,
                     impact: 'high',
-                    probability: 'medium'
+                    probability: 'medium',
                 };
                 if (generateMitigation) {
-                    riskObj.mitigation = 'Review and simplify dependencies, create detailed coordination plan';
+                    riskObj.mitigation =
+                        'Review and simplify dependencies, create detailed coordination plan';
                 }
                 risks.push(riskObj);
             }
@@ -835,10 +947,11 @@ async function riskAnalysis(args) {
                     category: 'Dependencies',
                     description: `Potential circular dependency detected between "${phase.name}" and other phases`,
                     impact: 'critical',
-                    probability: 'high'
+                    probability: 'high',
                 };
                 if (generateMitigation) {
-                    riskObj.mitigation = 'Review and restructure phase dependencies to eliminate circular references';
+                    riskObj.mitigation =
+                        'Review and restructure phase dependencies to eliminate circular references';
                 }
                 risks.push(riskObj);
             }
@@ -853,7 +966,7 @@ async function riskAnalysis(args) {
                 category: 'Resources',
                 description: `Team is overallocated (${avgWorkload.toFixed(1)}% average workload)`,
                 impact: 'high',
-                probability: 'high'
+                probability: 'high',
             };
             if (generateMitigation) {
                 riskObj.mitigation = 'Rebalance workload or consider adding team members';
@@ -865,7 +978,7 @@ async function riskAnalysis(args) {
                 category: 'Resources',
                 description: `Limited team size (${projectPlan.team.length} members) for ${projectPlan.phases.length} phases`,
                 impact: 'medium',
-                probability: 'medium'
+                probability: 'medium',
             };
             if (generateMitigation) {
                 riskObj.mitigation = 'Consider increasing team size or extending timeline';
@@ -877,7 +990,7 @@ async function riskAnalysis(args) {
     const criticalRisks = risks.filter(r => r.impact === 'critical').length;
     const highRisks = risks.filter(r => r.impact === 'high').length;
     const mediumRisks = risks.filter(r => r.impact === 'medium').length;
-    const riskScore = (criticalRisks * 10) + (highRisks * 5) + (mediumRisks * 2);
+    const riskScore = criticalRisks * 10 + highRisks * 5 + mediumRisks * 2;
     let riskLevel = 'low';
     if (riskScore > 20)
         riskLevel = 'critical';
@@ -886,7 +999,8 @@ async function riskAnalysis(args) {
     else if (riskScore > 5)
         riskLevel = 'medium';
     return {
-        content: [{
+        content: [
+            {
                 type: 'text',
                 text: `# Risk Analysis Report
 
@@ -902,29 +1016,32 @@ async function riskAnalysis(args) {
 
 ### Identified Risks
 
-${risks.map((risk, index) => `
+${risks
+                    .map((risk, index) => `
 #### Risk ${index + 1}: ${risk.category}
 - **Description**: ${risk.description}
 - **Impact**: ${risk.impact}
 - **Probability**: ${risk.probability}
 ${risk.mitigation ? `- **Mitigation**: ${risk.mitigation}` : ''}
-`).join('')}
+`)
+                    .join('')}
 
 ### Recommendations
 
-${riskLevel === 'critical' ?
-                    '🚨 **Critical risks detected** - Immediate action required before proceeding' :
-                    riskLevel === 'high' ?
-                        '⚠️ **High risks present** - Review and mitigate before major milestones' :
-                        '✅ **Manageable risk level** - Continue with normal monitoring'}
+${riskLevel === 'critical'
+                    ? '🚨 **Critical risks detected** - Immediate action required before proceeding'
+                    : riskLevel === 'high'
+                        ? '⚠️ **High risks present** - Review and mitigate before major milestones'
+                        : '✅ **Manageable risk level** - Continue with normal monitoring'}
 
 ### Next Steps
 1. Review and prioritize risk mitigation strategies
 2. Assign risk owners for high-impact items
 3. Schedule regular risk assessment reviews
 4. Update project timeline if necessary
-`
-            }]
+`,
+            },
+        ],
     };
 }
 /**
@@ -937,12 +1054,13 @@ async function generateReports(args) {
         throw new McpAdrError(`No project found at ${projectPath}. Use create_project first.`, 'PROJECT_NOT_FOUND');
     }
     switch (reportType) {
-        case 'executive':
+        case 'executive': {
             const overallProgress = calculateOverallProgress(projectPlan);
             const teamUtilization = calculateTeamUtilization(projectPlan);
             const riskLevel = calculateProjectRisk(projectPlan);
             return {
-                content: [{
+                content: [
+                    {
                         type: 'text',
                         text: `# Executive Summary
 
@@ -956,11 +1074,11 @@ async function generateReports(args) {
 - **Completed Phases**: ${projectPlan.phases.filter(p => p.status === 'completed').length}
 
 ### Current Status
-${projectPlan.status === 'active' ?
-                            '🟢 Project is actively progressing' :
-                            projectPlan.status === 'completed' ?
-                                '✅ Project completed successfully' :
-                                '🟡 Project in planning phase'}
+${projectPlan.status === 'active'
+                            ? '🟢 Project is actively progressing'
+                            : projectPlan.status === 'completed'
+                                ? '✅ Project completed successfully'
+                                : '🟡 Project in planning phase'}
 
 ### Key Highlights
 - Total phases: ${projectPlan.phases.length}
@@ -969,56 +1087,70 @@ ${projectPlan.status === 'active' ?
 - Risk level: ${riskLevel}
 
 ### Next Milestones
-${projectPlan.milestones.filter(m => m.status === 'pending').slice(0, 3).map(milestone => `- ${milestone.name} (Due: ${milestone.dueDate})`).join('\n') || 'No upcoming milestones'}
+${projectPlan.milestones
+                            .filter(m => m.status === 'pending')
+                            .slice(0, 3)
+                            .map(milestone => `- ${milestone.name} (Due: ${milestone.dueDate})`)
+                            .join('\n') || 'No upcoming milestones'}
 
 ### Blockers & Risks
-${projectPlan.phases.filter(p => p.blockers.length > 0).length > 0 ?
-                            `⚠️ ${projectPlan.phases.filter(p => p.blockers.length > 0).length} phases have blockers` :
-                            '✅ No major blockers reported'}
+${projectPlan.phases.filter(p => p.blockers.length > 0).length > 0
+                            ? `⚠️ ${projectPlan.phases.filter(p => p.blockers.length > 0).length} phases have blockers`
+                            : '✅ No major blockers reported'}
 
 *Report generated: ${new Date().toISOString()}*
-`
-                    }]
+`,
+                    },
+                ],
             };
+        }
         case 'status':
             return {
-                content: [{
+                content: [
+                    {
                         type: 'text',
                         text: `# Status Report - ${timeframe}
 
 ## ${projectPlan.name}
 
 ### Phase Status
-${projectPlan.phases.map(phase => `
+${projectPlan.phases
+                            .map(phase => `
 #### ${phase.name}
 - **Status**: ${phase.status}
 - **Progress**: ${phase.completion}%
 - **Timeline**: ${phase.estimatedDuration}
 - **Team**: ${phase.resources.length} members
 - **Blockers**: ${phase.blockers.length}
-`).join('')}
+`)
+                            .join('')}
 
 ### Team Status
-${projectPlan.team.map(member => `
+${projectPlan.team
+                            .map(member => `
 #### ${member.name}
 - **Role**: ${member.role}
 - **Workload**: ${member.currentWorkload}%
 - **Capacity**: ${member.capacity}
-`).join('')}
+`)
+                            .join('')}
 
 ### Recent Updates
 - Last updated: ${projectPlan.metadata.updatedAt}
 - Total phases: ${projectPlan.phases.length}
 - Active work streams: ${projectPlan.phases.filter(p => p.status === 'active').length}
-`
-                    }]
+`,
+                    },
+                ],
             };
         default:
             return {
-                content: [{
+                content: [
+                    {
                         type: 'text',
-                        text: `Report generation for type "${reportType}" is not yet implemented.`
-                    }]
+                        text: `Report generation for type "${reportType}" is not yet implemented.`,
+                    },
+                ],
             };
     }
 }
@@ -1038,7 +1170,8 @@ function calculateOverallProgress(projectPlan) {
 function calculateTeamUtilization(projectPlan) {
     if (projectPlan.team.length === 0)
         return 0;
-    return Math.round(projectPlan.team.reduce((sum, member) => sum + member.currentWorkload, 0) / projectPlan.team.length);
+    return Math.round(projectPlan.team.reduce((sum, member) => sum + member.currentWorkload, 0) /
+        projectPlan.team.length);
 }
 function calculateProjectRisk(projectPlan) {
     const blockedPhases = projectPlan.phases.filter(p => p.status === 'blocked').length;