mcp-adr-analysis-server 2.0.21 → 2.0.24

package/dist/src/tools/smart-score-tool.js

@@ -1,681 +0,0 @@
-/**
- * Smart Score Tool - Central Coordination for Project Health Scoring
- *
- * Provides comprehensive scoring coordination across all MCP tools:
- * - Cross-tool score synchronization
- * - Manual score recalculation and rebalancing
- * - Health score diagnostics and validation
- * - Automated score updates and maintenance
- *
- * IMPORTANT FOR AI ASSISTANTS: This tool depends on cache infrastructure and
- * works best when other tools have already populated data.
- *
- * Cache Dependencies:
- * - Requires: .mcp-adr-cache/project-health-scores.json (main scoring data)
- * - May read: .mcp-adr-cache/todo-data.json (for task completion scoring)
- * - Updates: .mcp-adr-cache/project-health-scores.json (with new scores)
- *
- * Workflow Timing:
- * - Run AFTER other tools have populated cache data
- * - Use 'recalculate_scores' to refresh stale data
- * - Use 'sync_scores' to synchronize across tools
- * - Use 'optimize_weights' for score tuning
- */
-import { z } from 'zod';
-import { McpAdrError } from '../types/index.js';
-// Operation schemas for smart scoring
-const RecalculateScoresSchema = z.object({
-    operation: z.literal('recalculate_scores'),
-    projectPath: z.string().describe('Path to project directory'),
-    components: z.array(z.enum(['task_completion', 'deployment_readiness', 'architecture_compliance', 'security_posture', 'code_quality', 'all'])).default(['all']).describe('Score components to recalculate'),
-    forceUpdate: z.boolean().default(false).describe('Force update even if data is fresh'),
-    updateSources: z.boolean().default(true).describe('Trigger source tool updates before recalculating')
-});
-const SyncScoresSchema = z.object({
-    operation: z.literal('sync_scores'),
-    projectPath: z.string().describe('Path to project directory'),
-    todoPath: z.string().default('TODO.md').describe('Path to TODO.md file'),
-    triggerTools: z.array(z.enum(['manage_todo', 'smart_git_push', 'compare_adr_progress', 'analyze_content_security', 'validate_rules'])).optional().describe('Tools to trigger for fresh data'),
-    rebalanceWeights: z.boolean().default(false).describe('Recalculate optimal scoring weights')
-});
-const DiagnoseScoresSchema = z.object({
-    operation: z.literal('diagnose_scores'),
-    projectPath: z.string().describe('Path to project directory'),
-    includeHistory: z.boolean().default(true).describe('Include score history analysis'),
-    checkDataFreshness: z.boolean().default(true).describe('Validate data freshness across tools'),
-    suggestImprovements: z.boolean().default(true).describe('Provide score improvement suggestions')
-});
-const OptimizeWeightsSchema = z.object({
-    operation: z.literal('optimize_weights'),
-    projectPath: z.string().describe('Path to project directory'),
-    analysisMode: z.enum(['current_state', 'historical_data', 'project_type']).default('current_state').describe('Method for weight optimization'),
-    customWeights: z.object({
-        taskCompletion: z.number().min(0).max(1).optional(),
-        deploymentReadiness: z.number().min(0).max(1).optional(),
-        architectureCompliance: z.number().min(0).max(1).optional(),
-        securityPosture: z.number().min(0).max(1).optional(),
-        codeQuality: z.number().min(0).max(1).optional()
-    }).optional().describe('Custom weight overrides'),
-    previewOnly: z.boolean().default(false).describe('Preview changes without applying')
-});
-const ResetScoresSchema = z.object({
-    operation: z.literal('reset_scores'),
-    projectPath: z.string().describe('Path to project directory'),
-    component: z.enum(['task_completion', 'deployment_readiness', 'architecture_compliance', 'security_posture', 'code_quality', 'all']).default('all').describe('Score component to reset'),
-    preserveHistory: z.boolean().default(true).describe('Preserve score history in backup'),
-    recalculateAfterReset: z.boolean().default(true).describe('Immediately recalculate after reset')
-});
-// Main operation schema
-const GetScoreTrendsSchema = z.object({
-    operation: z.literal('get_score_trends'),
-    projectPath: z.string().describe('Path to project directory')
-});
-const GetIntentScoresSchema = z.object({
-    operation: z.literal('get_intent_scores'),
-    projectPath: z.string().describe('Path to project directory'),
-    intentId: z.string().describe('Intent ID to get score trends for')
-});
-const SmartScoreSchema = z.union([
-    RecalculateScoresSchema,
-    SyncScoresSchema,
-    DiagnoseScoresSchema,
-    OptimizeWeightsSchema,
-    ResetScoresSchema,
-    GetScoreTrendsSchema,
-    GetIntentScoresSchema
-]);
-/**
- * Trigger score updates from source tools
- */
-async function triggerSourceToolUpdates(projectPath, tools) {
-    const results = {};
-    for (const tool of tools) {
-        try {
-            switch (tool) {
-                case 'manage_todo':
-                    // Trigger TODO analysis to update task completion scores
-                    const { manageTodoV2 } = await import('./todo-management-tool-v2.js');
-                    results[tool] = await manageTodoV2({
-                        operation: 'get_analytics',
-                        projectPath,
-                        timeframe: 'all',
-                        includeVelocity: true,
-                        includeScoring: true
-                    });
-                    break;
-                case 'smart_git_push':
-                    // Trigger git release readiness analysis
-                    const { smartGitPush } = await import('./smart-git-push-tool.js');
-                    results[tool] = await smartGitPush({
-                        projectPath,
-                        checkReleaseReadiness: true,
-                        dryRun: true // Don't actually push, just analyze
-                    });
-                    break;
-                case 'compare_adr_progress':
-                    // Trigger ADR progress comparison
-                    // This would need to be implemented in the main server
-                    results[tool] = { status: 'tool_not_available', message: 'compare_adr_progress integration pending' };
-                    break;
-                case 'analyze_content_security':
-                    // Trigger content security analysis
-                    // This would need to be implemented in the main server
-                    results[tool] = { status: 'tool_not_available', message: 'analyze_content_security integration pending' };
-                    break;
-                case 'validate_rules':
-                    // Trigger rule validation
-                    // This would need to be implemented in the main server
-                    results[tool] = { status: 'tool_not_available', message: 'validate_rules integration pending' };
-                    break;
-                default:
-                    results[tool] = { status: 'unknown_tool', message: `Tool ${tool} not recognized` };
-            }
-        }
-        catch (error) {
-            results[tool] = {
-                status: 'error',
-                message: `Failed to trigger ${tool}: ${error instanceof Error ? error.message : String(error)}`
-            };
-        }
-    }
-    return results;
-}
-/**
- * Calculate optimal weights based on project characteristics
- */
-async function calculateOptimalWeights(projectPath, _analysisMode) {
-    const fs = await import('fs/promises');
-    const path = await import('path');
-    // Default weights
-    const defaultWeights = {
-        taskCompletion: 0.25,
-        deploymentReadiness: 0.30,
-        architectureCompliance: 0.20,
-        securityPosture: 0.15,
-        codeQuality: 0.10
-    };
-    try {
-        // Analyze project characteristics
-        const packageJsonPath = path.join(projectPath, 'package.json');
-        let projectType = 'general';
-        let hasTests = false;
-        let hasCi = false;
-        try {
-            const packageJson = JSON.parse(await fs.readFile(packageJsonPath, 'utf-8'));
-            // Determine project type
-            if (packageJson.dependencies?.['express'] || packageJson.dependencies?.['fastify']) {
-                projectType = 'backend_api';
-            }
-            else if (packageJson.dependencies?.['react'] || packageJson.dependencies?.['vue'] || packageJson.dependencies?.['angular']) {
-                projectType = 'frontend';
-            }
-            else if (packageJson.dependencies?.['electron']) {
-                projectType = 'desktop_app';
-            }
-            else if (packageJson.type === 'module' || packageJson.main?.endsWith('.mjs')) {
-                projectType = 'library';
-            }
-            // Check for testing setup
-            hasTests = Boolean(packageJson.scripts?.test ||
-                packageJson.devDependencies?.jest ||
-                packageJson.devDependencies?.mocha ||
-                packageJson.devDependencies?.vitest);
-            // Check for CI/CD
-            const ciFiles = ['.github/workflows', '.gitlab-ci.yml', 'azure-pipelines.yml', '.circleci'];
-            hasCi = false;
-            for (const ciFile of ciFiles) {
-                try {
-                    await fs.access(path.join(projectPath, ciFile));
-                    hasCi = true;
-                    break;
-                }
-                catch { }
-            }
-        }
-        catch (error) {
-            // Fall back to default weights if package.json analysis fails
-        }
-        // Adjust weights based on project characteristics
-        let optimizedWeights = { ...defaultWeights };
-        switch (projectType) {
-            case 'backend_api':
-                // APIs prioritize security and deployment
-                optimizedWeights = {
-                    taskCompletion: 0.20,
-                    deploymentReadiness: 0.35,
-                    architectureCompliance: 0.15,
-                    securityPosture: 0.25,
-                    codeQuality: 0.05
-                };
-                break;
-            case 'frontend':
-                // Frontend prioritizes task completion and code quality
-                optimizedWeights = {
-                    taskCompletion: 0.35,
-                    deploymentReadiness: 0.25,
-                    architectureCompliance: 0.15,
-                    securityPosture: 0.10,
-                    codeQuality: 0.15
-                };
-                break;
-            case 'library':
-                // Libraries prioritize code quality and architecture
-                optimizedWeights = {
-                    taskCompletion: 0.20,
-                    deploymentReadiness: 0.20,
-                    architectureCompliance: 0.30,
-                    securityPosture: 0.15,
-                    codeQuality: 0.15
-                };
-                break;
-            case 'desktop_app':
-                // Desktop apps balance all aspects
-                optimizedWeights = {
-                    taskCompletion: 0.25,
-                    deploymentReadiness: 0.25,
-                    architectureCompliance: 0.20,
-                    securityPosture: 0.15,
-                    codeQuality: 0.15
-                };
-                break;
-        }
-        // Adjust for testing maturity
-        if (hasTests) {
-            optimizedWeights.codeQuality += 0.05;
-            optimizedWeights.taskCompletion -= 0.05;
-        }
-        // Adjust for CI/CD maturity
-        if (hasCi) {
-            optimizedWeights.deploymentReadiness += 0.05;
-            optimizedWeights.taskCompletion -= 0.05;
-        }
-        // Ensure weights sum to 1.0
-        const total = Object.values(optimizedWeights).reduce((sum, weight) => sum + weight, 0);
-        if (total !== 1.0) {
-            const factor = 1.0 / total;
-            Object.keys(optimizedWeights).forEach(key => {
-                optimizedWeights[key] *= factor;
-            });
-        }
-        return optimizedWeights;
-    }
-    catch (error) {
-        return defaultWeights;
-    }
-}
-/**
- * Main smart score function
- */
-export async function smartScore(args) {
-    try {
-        const validatedArgs = SmartScoreSchema.parse(args);
-        switch (validatedArgs.operation) {
-            case 'recalculate_scores': {
-                const { ProjectHealthScoring } = await import('../utils/project-health-scoring.js');
-                const healthScoring = new ProjectHealthScoring(validatedArgs.projectPath);
-                // Trigger source updates if requested
-                let sourceResults = {};
-                let todoData = null;
-                if (validatedArgs.updateSources) {
-                    const allTools = ['manage_todo', 'smart_git_push', 'compare_adr_progress', 'analyze_content_security', 'validate_rules'];
-                    sourceResults = await triggerSourceToolUpdates(validatedArgs.projectPath, allTools);
-                    // Extract TODO data if available
-                    if (sourceResults['manage_todo']?.content?.[0]?.text) {
-                        const analysisText = sourceResults['manage_todo'].content[0].text;
-                        const completionMatch = analysisText.match(/(\d+)\/(\d+) tasks? completed \((\d+)%\)/);
-                        if (completionMatch) {
-                            todoData = {
-                                completed: parseInt(completionMatch[1]),
-                                total: parseInt(completionMatch[2]),
-                                percentage: parseInt(completionMatch[3])
-                            };
-                        }
-                    }
-                }
-                // Get current scores
-                const currentScores = await healthScoring.getProjectHealthScore();
-                return {
-                    content: [{
-                            type: 'text',
-                            text: `# 🔄 Scores Recalculated Successfully
-
-## Updated Project Health Scores:
-- 🎯 **Overall**: ${currentScores.overall}% (${currentScores.confidence}% confidence)
-- 📋 **Task Completion**: ${currentScores.taskCompletion}%
-- 🚀 **Deployment Readiness**: ${currentScores.deploymentReadiness}%
-- 🏗️ **Architecture Compliance**: ${currentScores.architectureCompliance}%
-- 🔒 **Security Posture**: ${currentScores.securityPosture}%
-- 🛠️ **Code Quality**: ${currentScores.codeQuality}%
-
-## Components Recalculated:
-${validatedArgs.components.includes('all') ? '- All components updated' : validatedArgs.components.map(c => `- ${c.replace('_', ' ')}`).join('\n')}${todoData ? `\n\n## TODO.md Balance Check:
-- Task Completion from TODO.md: ${todoData.percentage}%
-- Health Score Task Completion: ${currentScores.taskCompletion}%
-- ${Math.abs(todoData.percentage - currentScores.taskCompletion) > 10 ? '⚠️ Significant difference detected - consider running sync_scores' : '✅ Scores are well balanced'}` : ''}
-
-## Source Tool Updates:
-${Object.entries(sourceResults).map(([tool, result]) => `- **${tool}**: ${result.status || 'success'}`).join('\n')}
-
-## Data Freshness:
-- **Last Updated**: ${new Date(currentScores.lastUpdated).toLocaleString()}
-- **Contributing Tools**: ${currentScores.influencingTools.join(', ') || 'None'}
-
-*All TODO.md files will automatically display updated health scores on next access.*`
-                        }]
-                };
-            }
-            case 'sync_scores': {
-                const { ProjectHealthScoring } = await import('../utils/project-health-scoring.js');
-                const healthScoring = new ProjectHealthScoring(validatedArgs.projectPath);
-                // Trigger specific tools if requested
-                let triggerResults = {};
-                if (validatedArgs.triggerTools && validatedArgs.triggerTools.length > 0) {
-                    triggerResults = await triggerSourceToolUpdates(validatedArgs.projectPath, validatedArgs.triggerTools);
-                }
-                // Force a TODO update to sync task completion scores
-                const { manageTodoV2 } = await import('./todo-management-tool-v2.js');
-                const todoAnalysis = await manageTodoV2({
-                    operation: 'get_analytics',
-                    projectPath: validatedArgs.projectPath,
-                    timeframe: 'all',
-                    includeVelocity: true,
-                    includeScoring: true
-                });
-                // Extract task completion data from TODO analysis
-                let todoCompletionData = null;
-                if (todoAnalysis?.content?.[0]?.text) {
-                    const analysisText = todoAnalysis.content[0].text;
-                    // Parse completion metrics from the analysis
-                    const completionMatch = analysisText.match(/(\d+)\/(\d+) tasks? completed \((\d+)%\)/);
-                    const criticalMatch = analysisText.match(/(\d+) critical\/high priority tasks? remaining/);
-                    if (completionMatch) {
-                        todoCompletionData = {
-                            completed: parseInt(completionMatch[1]),
-                            total: parseInt(completionMatch[2]),
-                            percentage: parseInt(completionMatch[3]),
-                            criticalRemaining: criticalMatch ? parseInt(criticalMatch[1]) : 0
-                        };
-                    }
-                }
-                // Get synchronized scores
-                const syncedScores = await healthScoring.getProjectHealthScore();
-                // Optimize weights if requested
-                let weightOptimization = null;
-                if (validatedArgs.rebalanceWeights) {
-                    const optimalWeights = await calculateOptimalWeights(validatedArgs.projectPath, 'current_state');
-                    weightOptimization = {
-                        current: {
-                            taskCompletion: 0.25,
-                            deploymentReadiness: 0.30,
-                            architectureCompliance: 0.20,
-                            securityPosture: 0.15,
-                            codeQuality: 0.10
-                        },
-                        optimal: optimalWeights
-                    };
-                }
-                return {
-                    content: [{
-                            type: 'text',
-                            text: `# 🔄 Cross-Tool Score Synchronization Complete
-
-## Synchronized Health Scores:
-- 🎯 **Overall Project Health**: ${syncedScores.overall}% (${syncedScores.confidence}% confidence)
-
-### 📊 Component Breakdown:
-- 📋 **Task Completion**: ${syncedScores.taskCompletion}% (${syncedScores.breakdown.taskCompletion.completed}/${syncedScores.breakdown.taskCompletion.total} tasks)${todoCompletionData ? `
-  - TODO.md Analysis: ${todoCompletionData.completed}/${todoCompletionData.total} (${todoCompletionData.percentage}%)
-  - Critical/High Priority Remaining: ${todoCompletionData.criticalRemaining}` : ''}
-- 🚀 **Deployment Readiness**: ${syncedScores.deploymentReadiness}% (${syncedScores.breakdown.deploymentReadiness.criticalBlockers} critical blockers)
-- 🏗️ **Architecture Compliance**: ${syncedScores.architectureCompliance}%
-- 🔒 **Security Posture**: ${syncedScores.securityPosture}% (${syncedScores.breakdown.securityPosture.vulnerabilityCount} vulnerabilities)
-- 🛠️ **Code Quality**: ${syncedScores.codeQuality}% (${syncedScores.breakdown.codeQuality.ruleViolations} violations)
-
-## Tool Synchronization Results:
-${Object.entries(triggerResults).map(([tool, result]) => `- **${tool}**: ${result.status === 'error' ? '❌ Failed' : '✅ Updated'}`).join('\n')}
-
-${weightOptimization ? `
-## Weight Optimization Analysis:
-### Current Weights vs Optimal:
-${Object.entries(weightOptimization.optimal).map(([key, value]) => `- **${key}**: ${(weightOptimization.current[key] * 100).toFixed(0)}% → ${(Number(value) * 100).toFixed(0)}%`).join('\n')}
-
-*Use \`optimize_weights\` operation to apply optimal weights.*
-` : ''}
-
-## Data Status:
-- **Last Synchronized**: ${new Date().toLocaleString()}
-- **Data Confidence**: ${syncedScores.confidence}%
-- **Contributing Tools**: ${syncedScores.influencingTools.join(', ') || 'manage_todo (default)'}
-
-*All health dashboards will reflect these synchronized scores.*`
-                        }]
-                };
-            }
-            case 'diagnose_scores': {
-                const { ProjectHealthScoring } = await import('../utils/project-health-scoring.js');
-                const healthScoring = new ProjectHealthScoring(validatedArgs.projectPath);
-                const currentScores = await healthScoring.getProjectHealthScore();
-                // Check data freshness
-                const now = new Date();
-                const lastUpdate = new Date(currentScores.lastUpdated);
-                const hoursSinceUpdate = (now.getTime() - lastUpdate.getTime()) / (1000 * 60 * 60);
-                const dataFreshness = hoursSinceUpdate < 1 ? 'Fresh' :
-                    hoursSinceUpdate < 24 ? 'Recent' :
-                        hoursSinceUpdate < 72 ? 'Stale' : 'Very Stale';
-                // Analyze component health
-                const componentAnalysis = [
-                    { name: 'Task Completion', score: currentScores.taskCompletion, threshold: 70 },
-                    { name: 'Deployment Readiness', score: currentScores.deploymentReadiness, threshold: 75 },
-                    { name: 'Architecture Compliance', score: currentScores.architectureCompliance, threshold: 60 },
-                    { name: 'Security Posture', score: currentScores.securityPosture, threshold: 80 },
-                    { name: 'Code Quality', score: currentScores.codeQuality, threshold: 65 }
-                ];
-                const weakComponents = componentAnalysis.filter(c => c.score < c.threshold);
-                const strongComponents = componentAnalysis.filter(c => c.score >= c.threshold + 15);
-                // Generate improvement suggestions
-                const suggestions = [];
-                if (currentScores.breakdown.taskCompletion.criticalTasksRemaining > 0) {
-                    suggestions.push('🔴 Address critical/blocked tasks to improve task completion score');
-                }
-                if (currentScores.breakdown.deploymentReadiness.criticalBlockers > 0) {
-                    suggestions.push('🚀 Resolve deployment blockers to improve readiness score');
-                }
-                if (currentScores.breakdown.securityPosture.vulnerabilityCount > 0) {
-                    suggestions.push('🔒 Fix security vulnerabilities to boost security posture');
-                }
-                if (currentScores.breakdown.codeQuality.ruleViolations > 3) {
-                    suggestions.push('🛠️ Address code quality violations to improve standards');
-                }
-                if (currentScores.confidence < 70) {
-                    suggestions.push('🔄 Run score synchronization to refresh stale data');
-                }
-                return {
-                    content: [{
-                            type: 'text',
-                            text: `# 🔍 Project Health Score Diagnostics
-
-## Overall Assessment:
-- 🎯 **Overall Health**: ${currentScores.overall}% ${currentScores.overall >= 80 ? '🟢 Excellent' : currentScores.overall >= 60 ? '🟡 Good' : '🔴 Needs Improvement'}
-- 📊 **Data Confidence**: ${currentScores.confidence}% (${dataFreshness})
-- ⏰ **Last Updated**: ${lastUpdate.toLocaleString()} (${Math.round(hoursSinceUpdate)} hours ago)
-
-## Component Analysis:
-
-### 💪 Strong Areas:
-${strongComponents.length > 0 ? strongComponents.map(c => `- **${c.name}**: ${c.score}% 🟢`).join('\n') : '- No components currently exceeding excellence thresholds'}
-
-### ⚠️ Areas for Improvement:
-${weakComponents.length > 0 ? weakComponents.map(c => `- **${c.name}**: ${c.score}% (target: ${c.threshold}%)`).join('\n') : '- All components meeting target thresholds! 🎉'}
-
-## Detailed Breakdown:
-- 📋 **Task Completion**: ${currentScores.taskCompletion}% | ${currentScores.breakdown.taskCompletion.completed}/${currentScores.breakdown.taskCompletion.total} tasks | ${currentScores.breakdown.taskCompletion.criticalTasksRemaining} critical remaining
-- 🚀 **Deployment**: ${currentScores.deploymentReadiness}% | ${currentScores.breakdown.deploymentReadiness.criticalBlockers} critical blockers | ${currentScores.breakdown.deploymentReadiness.warningBlockers} warnings
-- 🏗️ **Architecture**: ${currentScores.architectureCompliance}% | ADR compliance tracking
-- 🔒 **Security**: ${currentScores.securityPosture}% | ${currentScores.breakdown.securityPosture.vulnerabilityCount} vulnerabilities | ${currentScores.breakdown.securityPosture.contentMaskingEffectiveness}% masking effectiveness
-- 🛠️ **Code Quality**: ${currentScores.codeQuality}% | ${currentScores.breakdown.codeQuality.ruleViolations} violations | ${currentScores.breakdown.codeQuality.patternAdherence}% pattern adherence
-
-## Data Source Status:
-${currentScores.influencingTools.length > 0 ?
-                                currentScores.influencingTools.map(tool => `- ✅ **${tool}**: Contributing data`).join('\n') :
-                                '- ⚠️ **Limited data sources**: Only basic scoring available'}
-
-${validatedArgs.suggestImprovements && suggestions.length > 0 ? `
-## 🎯 Recommended Actions:
-${suggestions.map(s => `${s}`).join('\n')}
-
-## Quick Fixes:
-1. Run \`sync_scores\` to refresh all data sources
-2. Use \`recalculate_scores\` with \`updateSources: true\` for comprehensive refresh
-3. Address highest-impact issues first (critical tasks, security vulnerabilities)
-` : ''}
-
-*Use \`sync_scores\` or \`recalculate_scores\` to refresh diagnostic data.*`
-                        }]
-                };
-            }
-            case 'optimize_weights': {
-                const optimalWeights = await calculateOptimalWeights(validatedArgs.projectPath, validatedArgs.analysisMode);
-                // Apply custom weight overrides if provided
-                let finalWeights = { ...optimalWeights };
-                if (validatedArgs.customWeights) {
-                    Object.entries(validatedArgs.customWeights).forEach(([key, value]) => {
-                        if (value !== undefined) {
-                            finalWeights[key] = value;
-                        }
-                    });
-                    // Renormalize to ensure sum = 1.0
-                    const total = Object.values(finalWeights).reduce((sum, weight) => sum + weight, 0);
-                    if (total !== 1.0) {
-                        const factor = 1.0 / total;
-                        Object.keys(finalWeights).forEach(key => {
-                            finalWeights[key] *= factor;
-                        });
-                    }
-                }
-                if (!validatedArgs.previewOnly) {
-                    // Apply the optimized weights
-                    const { ProjectHealthScoring } = await import('../utils/project-health-scoring.js');
-                    new ProjectHealthScoring(validatedArgs.projectPath, finalWeights);
-                    // Note: Weight application would require updating the ProjectHealthScoring class constructor
-                    // For now, we return the preview showing what would change
-                    return {
-                        content: [{
-                                type: 'text',
-                                text: `# ⚖️ Scoring Weights Preview
-
-## New Weight Configuration Would Be Applied:
-${Object.entries(finalWeights).map(([key, value]) => `- **${key.replace(/([A-Z])/g, ' $1').toLowerCase()}**: ${(Number(value) * 100).toFixed(1)}%`).join('\n')}
-
-## Optimization Method: ${validatedArgs.analysisMode}
-${validatedArgs.customWeights ? '## Custom Overrides Applied: Yes' : ''}
-
-*Note: Weight application requires ProjectHealthScoring class enhancement.*
-*For now, this shows the optimal configuration that would be applied.*`
-                            }]
-                    };
-                }
-                else {
-                    // Preview mode - show what would change
-                    const currentWeights = {
-                        taskCompletion: 0.25,
-                        deploymentReadiness: 0.30,
-                        architectureCompliance: 0.20,
-                        securityPosture: 0.15,
-                        codeQuality: 0.10
-                    };
-                    return {
-                        content: [{
-                                type: 'text',
-                                text: `# ⚖️ Weight Optimization Preview
-
-## Current vs Optimal Weights:
-${Object.entries(finalWeights).map(([key, value]) => {
-                                    const current = currentWeights[key] * 100;
-                                    const optimal = Number(value) * 100;
-                                    const change = optimal - current;
-                                    const arrow = change > 0 ? '↗️' : change < 0 ? '↘️' : '➡️';
-                                    return `- **${key.replace(/([A-Z])/g, ' $1').toLowerCase()}**: ${current.toFixed(1)}% ${arrow} ${optimal.toFixed(1)}% ${change !== 0 ? `(${change > 0 ? '+' : ''}${change.toFixed(1)}%)` : ''}`;
-                                }).join('\n')}
-
-## Optimization Rationale:
-- **Analysis Method**: ${validatedArgs.analysisMode}
-- **Project Type**: Detected from package.json and project structure
-- **Customizations**: ${validatedArgs.customWeights ? 'Custom weights provided' : 'Auto-detected optimal weights'}
-
-**To apply these weights, run the same command with \`previewOnly: false\`**`
-                            }]
-                    };
-                }
-            }
-            case 'reset_scores': {
-                const { ProjectHealthScoring } = await import('../utils/project-health-scoring.js');
-                // Create backup if preserving history
-                let backupPath = null;
-                if (validatedArgs.preserveHistory) {
-                    const fs = await import('fs/promises');
-                    const path = await import('path');
-                    const cachePath = path.join(validatedArgs.projectPath, '.mcp-adr-cache', 'project-health-scores.json');
-                    backupPath = `${cachePath}.backup.${Date.now()}`;
-                    try {
-                        const currentScores = await fs.readFile(cachePath, 'utf-8');
-                        await fs.writeFile(backupPath, currentScores, 'utf-8');
-                    }
-                    catch (error) {
-                        // Backup failed, but continue with reset
-                        backupPath = null;
-                    }
-                }
-                // Reset scores by creating fresh instance
-                const resetScoring = new ProjectHealthScoring(validatedArgs.projectPath);
-                const resetScores = await resetScoring.getProjectHealthScore();
-                // Recalculate if requested
-                if (validatedArgs.recalculateAfterReset) {
-                    const allTools = ['manage_todo', 'smart_git_push'];
-                    await triggerSourceToolUpdates(validatedArgs.projectPath, allTools);
-                }
-                return {
-                    content: [{
-                            type: 'text',
-                            text: `# 🔄 Scores Reset Successfully
-
-## Reset Component: ${validatedArgs.component}
-
-## Fresh Baseline Scores:
-- 🎯 **Overall**: ${resetScores.overall}%
-- 📋 **Task Completion**: ${resetScores.taskCompletion}%
-- 🚀 **Deployment Readiness**: ${resetScores.deploymentReadiness}%
-- 🏗️ **Architecture Compliance**: ${resetScores.architectureCompliance}%
-- 🔒 **Security Posture**: ${resetScores.securityPosture}%
-- 🛠️ **Code Quality**: ${resetScores.codeQuality}%
-
-${backupPath ? `## Backup Created: \`${backupPath}\`` : ''}
-${validatedArgs.recalculateAfterReset ? '## Recalculation: ✅ Fresh data collected from available tools' : '## Recalculation: ⏸️ Skipped (use recalculate_scores to refresh)'}
-
-*Health scoring system has been reset to baseline values.*`
-                        }]
-                };
-            }
-            case 'get_score_trends': {
-                const { KnowledgeGraphManager } = await import('../utils/knowledge-graph-manager.js');
-                const kgManager = new KnowledgeGraphManager();
-                const trends = await kgManager.getProjectScoreTrends();
-                return {
-                    content: [{
-                            type: 'text',
-                            text: `# 📊 Project Score Trends
-
-## Current Score: ${trends.currentScore}%
-
-## Score History (${trends.scoreHistory.length} entries):
-${trends.scoreHistory.slice(-10).map(entry => `- **${new Date(entry.timestamp).toLocaleString()}**: ${entry.score}% (${entry.triggerEvent})`).join('\n')}
-
-## Performance Analytics:
-- **Average Improvement**: ${trends.averageImprovement.toFixed(1)}%
-- **Score Entries**: ${trends.scoreHistory.length}
-
-## Top Impacting Intents:
-${trends.topImpactingIntents.map(intent => `- **${intent.scoreImprovement > 0 ? '+' : ''}${intent.scoreImprovement.toFixed(1)}%**: ${intent.humanRequest.substring(0, 80)}...`).join('\n')}
-
-*Score trends track the impact of human intents on project health over time.*`
-                        }]
-                };
-            }
-            case 'get_intent_scores': {
-                const { KnowledgeGraphManager } = await import('../utils/knowledge-graph-manager.js');
-                const kgManager = new KnowledgeGraphManager();
-                if (!validatedArgs.intentId) {
-                    throw new McpAdrError('intentId is required for get_intent_scores operation', 'INVALID_INPUT');
-                }
-                const intentTrends = await kgManager.getIntentScoreTrends(validatedArgs.intentId);
-                return {
-                    content: [{
-                            type: 'text',
-                            text: `# 🎯 Intent Score Analysis
-
-## Intent Progress:
-- **Initial Score**: ${intentTrends.initialScore}%
-- **Current Score**: ${intentTrends.currentScore}%
-- **Progress**: ${intentTrends.progress.toFixed(1)}%
-
-## Component Scores:
-${Object.entries(intentTrends.componentTrends).map(([component, score]) => `- **${component.replace(/([A-Z])/g, ' $1').replace(/^./, str => str.toUpperCase())}**: ${score}%`).join('\n')}
-
-## Score History for this Intent:
-${intentTrends.scoreHistory.map(entry => `- **${new Date(entry.timestamp).toLocaleString()}**: ${entry.score}% (${entry.triggerEvent})`).join('\n')}
-
-*Intent scores track how specific human requests impact project health metrics.*`
-                        }]
-                };
-            }
-            default:
-                throw new McpAdrError(`Unknown smart score operation: ${validatedArgs.operation}`, 'INVALID_INPUT');
-        }
-    }
-    catch (error) {
-        if (error instanceof z.ZodError) {
-            throw new McpAdrError(`Invalid input: ${error.errors.map(e => e.message).join(', ')}`, 'INVALID_INPUT');
-        }
-        throw new McpAdrError(`Smart score operation failed: ${error instanceof Error ? error.message : String(error)}`, 'SMART_SCORE_ERROR');
-    }
-}
-//# sourceMappingURL=smart-score-tool.js.map