mcp-adr-analysis-server 2.0.9 → 2.0.11

package/dist/src/index.js

@@ -16,6 +16,7 @@ import { McpAdrError } from './types/index.js';
 import { CONVERSATION_CONTEXT_SCHEMA } from './types/conversation-context.js';
 import { maskMcpResponse, createMaskingConfig } from './utils/output-masking.js';
 import { loadConfig, validateProjectPath, createLogger, printConfigSummary } from './utils/config.js';
+import { KnowledgeGraphManager } from './utils/knowledge-graph-manager.js';
 /**
  * Get version from package.json
  */
@@ -74,10 +75,12 @@ export class McpAdrAnalysisServer {
     maskingConfig;
     config;
     logger;
+    kgManager;
     constructor() {
         // Load and validate configuration
         this.config = loadConfig();
         this.logger = createLogger(this.config);
+        this.kgManager = new KnowledgeGraphManager();
         // Print configuration summary
         printConfigSummary(this.config);
         // Note: Validation will be done during startup
@@ -195,7 +198,8 @@ export class McpAdrAnalysisServer {
                                     type: 'boolean',
                                     description: 'Include compliance checks in the analysis',
                                     default: true
-                                }
+                                },
+                                conversationContext: CONVERSATION_CONTEXT_SCHEMA
                             }
                         }
                     },
@@ -233,14 +237,15 @@ export class McpAdrAnalysisServer {
                                     enum: ['web-application', 'mobile-app', 'microservices', 'data-platform', 'api-service', 'general'],
                                     description: 'Type of PRD for optimized knowledge generation',
                                     default: 'general'
-                                }
+                                },
+                                conversationContext: CONVERSATION_CONTEXT_SCHEMA
                             },
                             required: ['prdPath']
                         }
                     },
                     {
                         name: 'generate_adr_todo',
-                        description: 'Generate TDD-focused todo.md from existing ADRs with two-phase approach: test generation and production code',
+                        description: 'Generate TDD-focused todo.md from existing ADRs with JSON-first approach: creates structured JSON TODO and syncs to markdown',
                         inputSchema: {
                             type: 'object',
                             properties: {
@@ -262,7 +267,7 @@ export class McpAdrAnalysisServer {
                                 },
                                 linkAdrs: {
                                     type: 'boolean',
-                                    description: 'Link all ADRs to create comprehensive system test coverage',
+                                    description: 'Auto-detect and link ADR dependencies in task creation',
                                     default: true
                                 },
                                 includeRules: {
@@ -275,7 +280,32 @@ export class McpAdrAnalysisServer {
                                     enum: ['adrs', 'patterns', 'both'],
                                     description: 'Source for architectural rules (only used if includeRules is true)',
                                     default: 'both'
-                                }
+                                },
+                                todoPath: {
+                                    type: 'string',
+                                    description: 'Path to TODO.md file (relative to project root)',
+                                    default: 'TODO.md'
+                                },
+                                preserveExisting: {
+                                    type: 'boolean',
+                                    description: 'Preserve existing TODO.md content by merging instead of overwriting',
+                                    default: true
+                                },
+                                forceSyncToMarkdown: {
+                                    type: 'boolean',
+                                    description: 'Force sync JSON to markdown even if markdown is newer',
+                                    default: false
+                                },
+                                intentId: {
+                                    type: 'string',
+                                    description: 'Link generated tasks to specific knowledge graph intent'
+                                },
+                                createJsonBackup: {
+                                    type: 'boolean',
+                                    description: 'Create backup of existing JSON TODO data before import',
+                                    default: true
+                                },
+                                conversationContext: CONVERSATION_CONTEXT_SCHEMA
                             }
                         }
                     },
@@ -1029,7 +1059,8 @@ export class McpAdrAnalysisServer {
                                 },
                                 todoPath: {
                                     type: 'string',
-                                    description: 'Path to todo.md file for task identification'
+                                    description: 'Path to TODO.md file for task identification',
+                                    default: 'TODO.md'
                                 },
                                 cicdLogs: {
                                     type: 'string',
@@ -1234,86 +1265,178 @@ export class McpAdrAnalysisServer {
                         }
                     },
                     {
-                        name: 'manage_todo',
-                        description: 'Manage TODO.md files with incremental updates, task status tracking, and smart merging',
+                        name: 'manage_todo_json',
+                        description: 'JSON-first TODO management with consistent LLM interactions, automatic scoring sync, and knowledge graph integration',
                         inputSchema: {
                             type: 'object',
                             properties: {
                                 operation: {
                                     type: 'string',
-                                    enum: ['update_status', 'add_tasks', 'merge_adr_updates', 'sync_progress', 'analyze_progress'],
-                                    description: 'Operation to perform on TODO.md'
+                                    enum: ['create_task', 'update_task', 'bulk_update', 'get_tasks', 'get_analytics', 'import_adr_tasks', 'sync_knowledge_graph', 'sync_to_markdown', 'import_from_markdown'],
+                                    description: 'Operation to perform on TODO JSON backend'
                                 },
-                                todoPath: {
+                                projectPath: {
                                     type: 'string',
-                                    default: 'todo.md',
-                                    description: 'Path to TODO.md file'
+                                    description: 'Project root path (uses configured PROJECT_PATH if not provided)'
                                 },
-                                updates: {
+                                taskId: {
+                                    type: 'string',
+                                    description: 'Task ID for update operations'
+                                },
+                                title: {
+                                    type: 'string',
+                                    description: 'Task title for create operations'
+                                },
+                                description: {
+                                    type: 'string',
+                                    description: 'Task description'
+                                },
+                                priority: {
+                                    type: 'string',
+                                    enum: ['low', 'medium', 'high', 'critical'],
+                                    default: 'medium',
+                                    description: 'Task priority level'
+                                },
+                                assignee: {
+                                    type: 'string',
+                                    description: 'Task assignee'
+                                },
+                                dueDate: {
+                                    type: 'string',
+                                    description: 'Due date (ISO string format)'
+                                },
+                                category: {
+                                    type: 'string',
+                                    description: 'Task category'
+                                },
+                                tags: {
                                     type: 'array',
-                                    items: {
-                                        type: 'object',
-                                        properties: {
-                                            taskId: { type: 'string' },
-                                            status: { type: 'string', enum: ['pending', 'in_progress', 'completed', 'blocked', 'cancelled'] },
-                                            notes: { type: 'string' },
-                                            assignee: { type: 'string' }
-                                        },
-                                        required: ['taskId', 'status']
-                                    },
-                                    description: 'Status updates to apply (for update_status operation)'
+                                    items: { type: 'string' },
+                                    description: 'Task tags'
                                 },
-                                tasks: {
+                                dependencies: {
                                     type: 'array',
-                                    items: {
-                                        type: 'object',
-                                        properties: {
-                                            title: { type: 'string' },
-                                            status: { type: 'string', enum: ['pending', 'in_progress', 'completed', 'blocked', 'cancelled'] },
-                                            priority: { type: 'string', enum: ['low', 'medium', 'high', 'critical'] },
-                                            category: { type: 'string' },
-                                            assignee: { type: 'string' },
-                                            notes: { type: 'string' },
-                                            estimatedHours: { type: 'number' }
-                                        },
-                                        required: ['title', 'status']
+                                    items: { type: 'string' },
+                                    description: 'Task dependencies (task IDs)'
+                                },
+                                intentId: {
+                                    type: 'string',
+                                    description: 'Link to knowledge graph intent'
+                                },
+                                linkedAdrs: {
+                                    type: 'array',
+                                    items: { type: 'string' },
+                                    description: 'Related ADR files'
+                                },
+                                autoComplete: {
+                                    type: 'boolean',
+                                    default: false,
+                                    description: 'Auto-complete when criteria are met'
+                                },
+                                completionCriteria: {
+                                    type: 'string',
+                                    description: 'Auto-completion rules'
+                                },
+                                updates: {
+                                    type: 'object',
+                                    properties: {
+                                        title: { type: 'string' },
+                                        description: { type: 'string' },
+                                        status: { type: 'string', enum: ['pending', 'in_progress', 'completed', 'blocked', 'cancelled'] },
+                                        priority: { type: 'string', enum: ['low', 'medium', 'high', 'critical'] },
+                                        assignee: { type: 'string' },
+                                        dueDate: { type: 'string' },
+                                        progressPercentage: { type: 'number', minimum: 0, maximum: 100 },
+                                        notes: { type: 'string' },
+                                        tags: { type: 'array', items: { type: 'string' } }
+                                    },
+                                    description: 'Fields to update for update operations'
+                                },
+                                reason: {
+                                    type: 'string',
+                                    description: 'Reason for update (for changelog)'
+                                },
+                                filters: {
+                                    type: 'object',
+                                    properties: {
+                                        status: { type: 'string', enum: ['pending', 'in_progress', 'completed', 'blocked', 'cancelled'] },
+                                        priority: { type: 'string', enum: ['low', 'medium', 'high', 'critical'] },
+                                        assignee: { type: 'string' },
+                                        category: { type: 'string' },
+                                        hasDeadline: { type: 'boolean' },
+                                        overdue: { type: 'boolean' },
+                                        tags: { type: 'array', items: { type: 'string' } }
                                     },
-                                    description: 'New tasks to add (for add_tasks operation)'
+                                    description: 'Filter criteria for get_tasks operation'
+                                },
+                                sortBy: {
+                                    type: 'string',
+                                    enum: ['priority', 'dueDate', 'createdAt', 'updatedAt'],
+                                    default: 'priority',
+                                    description: 'Sort field for get_tasks operation'
+                                },
+                                sortOrder: {
+                                    type: 'string',
+                                    enum: ['asc', 'desc'],
+                                    default: 'desc',
+                                    description: 'Sort order for get_tasks operation'
                                 },
-                                section: {
+                                limit: {
+                                    type: 'number',
+                                    description: 'Maximum number of tasks to return'
+                                },
+                                timeframe: {
                                     type: 'string',
-                                    description: 'Section to add tasks to (for add_tasks operation)'
+                                    enum: ['day', 'week', 'month', 'all'],
+                                    default: 'week',
+                                    description: 'Analysis timeframe for analytics'
+                                },
+                                includeVelocity: {
+                                    type: 'boolean',
+                                    default: true,
+                                    description: 'Include velocity metrics in analytics'
+                                },
+                                includeScoring: {
+                                    type: 'boolean',
+                                    default: true,
+                                    description: 'Include scoring metrics in analytics'
                                 },
                                 adrDirectory: {
                                     type: 'string',
                                     default: 'docs/adrs',
-                                    description: 'ADR directory path (for merge_adr_updates and sync_progress operations)'
+                                    description: 'ADR directory path for imports'
                                 },
-                                preserveCompleted: {
+                                preserveExisting: {
                                     type: 'boolean',
                                     default: true,
-                                    description: 'Keep completed tasks during merge (for merge_adr_updates operation)'
+                                    description: 'Keep existing tasks during imports'
                                 },
-                                preserveCustom: {
+                                autoLinkDependencies: {
                                     type: 'boolean',
                                     default: true,
-                                    description: 'Keep manually added tasks during merge (for merge_adr_updates operation)'
+                                    description: 'Auto-detect task dependencies'
+                                },
+                                direction: {
+                                    type: 'string',
+                                    enum: ['to_kg', 'from_kg', 'bidirectional'],
+                                    default: 'bidirectional',
+                                    description: 'Knowledge graph sync direction'
                                 },
-                                updateAdrs: {
+                                force: {
                                     type: 'boolean',
                                     default: false,
-                                    description: 'Update ADR status based on TODO progress (for sync_progress operation)'
+                                    description: 'Force operation even if conflicts exist'
                                 },
-                                timeframe: {
+                                mergeStrategy: {
                                     type: 'string',
-                                    enum: ['day', 'week', 'month', 'all'],
-                                    default: 'week',
-                                    description: 'Analysis timeframe (for analyze_progress operation)'
+                                    enum: ['overwrite', 'merge', 'preserve_json'],
+                                    default: 'merge',
+                                    description: 'Merge strategy for imports'
                                 },
-                                includeVelocity: {
+                                backupExisting: {
                                     type: 'boolean',
                                     default: true,
-                                    description: 'Include velocity metrics in analysis (for analyze_progress operation)'
+                                    description: 'Create backup before destructive operations'
                                 }
                             },
                             required: ['operation']
@@ -1445,6 +1568,224 @@ export class McpAdrAnalysisServer {
                                 }
                             }
                         }
+                    },
+                    {
+                        name: 'troubleshoot_guided_workflow',
+                        description: 'Structured failure analysis and test plan generation - provide JSON failure info to get specific test commands',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                operation: {
+                                    type: 'string',
+                                    enum: ['analyze_failure', 'generate_test_plan', 'full_workflow'],
+                                    description: 'Type of troubleshooting operation'
+                                },
+                                failure: {
+                                    type: 'object',
+                                    properties: {
+                                        failureType: {
+                                            type: 'string',
+                                            enum: ['test_failure', 'deployment_failure', 'build_failure', 'runtime_error', 'performance_issue', 'security_issue', 'other'],
+                                            description: 'Type of failure'
+                                        },
+                                        failureDetails: {
+                                            type: 'object',
+                                            properties: {
+                                                command: {
+                                                    type: 'string',
+                                                    description: 'Command that failed (optional)'
+                                                },
+                                                exitCode: {
+                                                    type: 'number',
+                                                    description: 'Exit code of failed process (optional)'
+                                                },
+                                                errorMessage: {
+                                                    type: 'string',
+                                                    description: 'Primary error message'
+                                                },
+                                                stackTrace: {
+                                                    type: 'string',
+                                                    description: 'Stack trace if available (optional)'
+                                                },
+                                                logOutput: {
+                                                    type: 'string',
+                                                    description: 'Relevant log output (optional)'
+                                                },
+                                                environment: {
+                                                    type: 'string',
+                                                    description: 'Environment where failure occurred (optional)'
+                                                },
+                                                timestamp: {
+                                                    type: 'string',
+                                                    description: 'When the failure occurred (optional)'
+                                                },
+                                                affectedFiles: {
+                                                    type: 'array',
+                                                    items: { type: 'string' },
+                                                    description: 'Files involved in the failure (optional)'
+                                                }
+                                            },
+                                            required: ['errorMessage'],
+                                            description: 'Detailed failure information'
+                                        },
+                                        context: {
+                                            type: 'object',
+                                            properties: {
+                                                recentChanges: {
+                                                    type: 'string',
+                                                    description: 'Recent changes that might be related (optional)'
+                                                },
+                                                reproducible: {
+                                                    type: 'boolean',
+                                                    description: 'Whether the failure is reproducible (optional)'
+                                                },
+                                                frequency: {
+                                                    type: 'string',
+                                                    description: 'How often this failure occurs (optional)'
+                                                },
+                                                impact: {
+                                                    type: 'string',
+                                                    enum: ['low', 'medium', 'high', 'critical'],
+                                                    description: 'Impact level of the failure (optional)'
+                                                }
+                                            },
+                                            description: 'Additional context about the failure (optional)'
+                                        }
+                                    },
+                                    required: ['failureType', 'failureDetails'],
+                                    description: 'Structured failure information (required for analyze_failure and generate_test_plan)'
+                                },
+                                projectPath: {
+                                    type: 'string',
+                                    description: 'Path to project directory (optional)'
+                                },
+                                adrDirectory: {
+                                    type: 'string',
+                                    description: 'ADR directory path',
+                                    default: 'docs/adrs'
+                                },
+                                todoPath: {
+                                    type: 'string',
+                                    description: 'Path to TODO.md file',
+                                    default: 'TODO.md'
+                                },
+                                conversationContext: CONVERSATION_CONTEXT_SCHEMA
+                            },
+                            required: ['operation']
+                        }
+                    },
+                    {
+                        name: 'smart_score',
+                        description: 'Central coordination for project health scoring system - recalculate, sync, diagnose, optimize, and reset scores across all MCP tools',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                operation: {
+                                    type: 'string',
+                                    enum: ['recalculate_scores', 'sync_scores', 'diagnose_scores', 'optimize_weights', 'reset_scores', 'get_score_trends', 'get_intent_scores'],
+                                    description: 'Smart scoring operation to perform'
+                                },
+                                projectPath: {
+                                    type: 'string',
+                                    description: 'Path to project directory'
+                                },
+                                components: {
+                                    type: 'array',
+                                    items: {
+                                        type: 'string',
+                                        enum: ['task_completion', 'deployment_readiness', 'architecture_compliance', 'security_posture', 'code_quality', 'all']
+                                    },
+                                    default: ['all'],
+                                    description: 'Score components to recalculate (for recalculate_scores operation)'
+                                },
+                                forceUpdate: {
+                                    type: 'boolean',
+                                    default: false,
+                                    description: 'Force update even if data is fresh'
+                                },
+                                updateSources: {
+                                    type: 'boolean',
+                                    default: true,
+                                    description: 'Trigger source tool updates before recalculating'
+                                },
+                                todoPath: {
+                                    type: 'string',
+                                    default: 'TODO.md',
+                                    description: 'Path to TODO.md file (for sync_scores operation)'
+                                },
+                                triggerTools: {
+                                    type: 'array',
+                                    items: {
+                                        type: 'string',
+                                        enum: ['manage_todo_json', 'smart_git_push', 'compare_adr_progress', 'analyze_content_security', 'validate_rules']
+                                    },
+                                    description: 'Tools to trigger for fresh data (for sync_scores operation)'
+                                },
+                                rebalanceWeights: {
+                                    type: 'boolean',
+                                    default: false,
+                                    description: 'Recalculate optimal scoring weights (for sync_scores operation)'
+                                },
+                                includeHistory: {
+                                    type: 'boolean',
+                                    default: true,
+                                    description: 'Include score history analysis (for diagnose_scores operation)'
+                                },
+                                checkDataFreshness: {
+                                    type: 'boolean',
+                                    default: true,
+                                    description: 'Validate data freshness across tools (for diagnose_scores operation)'
+                                },
+                                suggestImprovements: {
+                                    type: 'boolean',
+                                    default: true,
+                                    description: 'Provide score improvement suggestions (for diagnose_scores operation)'
+                                },
+                                analysisMode: {
+                                    type: 'string',
+                                    enum: ['current_state', 'historical_data', 'project_type'],
+                                    default: 'current_state',
+                                    description: 'Method for weight optimization (for optimize_weights operation)'
+                                },
+                                customWeights: {
+                                    type: 'object',
+                                    properties: {
+                                        taskCompletion: { type: 'number', minimum: 0, maximum: 1 },
+                                        deploymentReadiness: { type: 'number', minimum: 0, maximum: 1 },
+                                        architectureCompliance: { type: 'number', minimum: 0, maximum: 1 },
+                                        securityPosture: { type: 'number', minimum: 0, maximum: 1 },
+                                        codeQuality: { type: 'number', minimum: 0, maximum: 1 }
+                                    },
+                                    description: 'Custom weight overrides (for optimize_weights operation)'
+                                },
+                                previewOnly: {
+                                    type: 'boolean',
+                                    default: false,
+                                    description: 'Preview changes without applying (for optimize_weights operation)'
+                                },
+                                component: {
+                                    type: 'string',
+                                    enum: ['task_completion', 'deployment_readiness', 'architecture_compliance', 'security_posture', 'code_quality', 'all'],
+                                    default: 'all',
+                                    description: 'Score component to reset (for reset_scores operation)'
+                                },
+                                preserveHistory: {
+                                    type: 'boolean',
+                                    default: true,
+                                    description: 'Preserve score history in backup (for reset_scores operation)'
+                                },
+                                recalculateAfterReset: {
+                                    type: 'boolean',
+                                    default: true,
+                                    description: 'Immediately recalculate after reset (for reset_scores operation)'
+                                },
+                                intentId: {
+                                    type: 'string',
+                                    description: 'Intent ID to get score trends for (for get_intent_scores operation)'
+                                }
+                            },
+                            required: ['operation', 'projectPath']
+                        }
                     }
                 ]
             };
@@ -1545,8 +1886,8 @@ export class McpAdrAnalysisServer {
                     case 'list_directory':
                         response = await this.listDirectory(args);
                         break;
-                    case 'manage_todo':
-                        response = await this.manageTodo(args);
+                    case 'manage_todo_json':
+                        response = await this.manageTodoJson(args);
                         break;
                     case 'generate_deployment_guidance':
                         response = await this.generateDeploymentGuidance(args);
@@ -1554,13 +1895,23 @@ export class McpAdrAnalysisServer {
                     case 'smart_git_push':
                         response = await this.smartGitPush(args);
                         break;
+                    case 'troubleshoot_guided_workflow':
+                        response = await this.troubleshootGuidedWorkflow(args);
+                        break;
+                    case 'smart_score':
+                        response = await this.smartScore(args);
+                        break;
                     default:
                         throw new McpAdrError(`Unknown tool: ${name}`, 'UNKNOWN_TOOL');
                 }
                 // Apply content masking to response
+                // Track tool execution in knowledge graph
+                await this.trackToolExecution(name, args, response, true);
                 return await this.applyOutputMasking(response);
             }
             catch (error) {
+                // Track failed execution
+                await this.trackToolExecution(name, args, {}, false, error instanceof Error ? error.message : String(error));
                 if (error instanceof McpAdrError) {
                     throw error;
                 }
@@ -2960,7 +3311,7 @@ The enhanced process maintains full traceability from PRD requirements to genera
         }
     }
     async generateAdrTodo(args) {
-        const { scope = 'all', phase = 'both', linkAdrs = true, includeRules = true, ruleSource = 'both' } = args;
+        const { scope = 'all', phase = 'both', linkAdrs = true, includeRules = true, ruleSource = 'both', preserveExisting = true, forceSyncToMarkdown = false, intentId, createJsonBackup = true } = args;
         const { getAdrDirectoryPath } = await import('./utils/config.js');
         const path = await import('path');
         // Use absolute ADR path relative to project
@@ -2969,307 +3320,93 @@ The enhanced process maintains full traceability from PRD requirements to genera
             getAdrDirectoryPath(this.config);
         // Keep relative path for display purposes
         const adrDirectory = args.adrDirectory || this.config.adrDirectory;
-        this.logger.info(`Generating TDD-focused todo for ADRs in: ${absoluteAdrPath} (phase: ${phase})`);
+        this.logger.info(`Generating JSON-first TODO for ADRs in: ${absoluteAdrPath} (phase: ${phase})`);
         try {
-            const { discoverAdrsInDirectory } = await import('./utils/adr-discovery.js');
-            const { scanProjectStructure } = await import('./utils/actual-file-operations.js');
-            // Use actual ADR discovery
-            const discoveryResult = await discoverAdrsInDirectory(absoluteAdrPath, true, this.config.projectPath);
-            let adrContent = `Found ${discoveryResult.adrs.length} ADRs in ${absoluteAdrPath}:\n\n`;
-            discoveryResult.adrs.forEach(adr => {
-                adrContent += `### ${adr.title}\n`;
-                adrContent += `- **File**: ${adr.filename}\n`;
-                adrContent += `- **Status**: ${adr.status}\n`;
-                adrContent += `- **Context**: ${adr.context}\n`;
-                adrContent += `- **Decision**: ${adr.decision}\n`;
-                adrContent += `- **Consequences**: ${adr.consequences}\n\n`;
-            });
-            // For ADR linking, also discover all project structure
-            let projectStructurePrompt = '';
-            if (linkAdrs) {
-                const projectStructure = await scanProjectStructure(this.config.projectPath, {
-                    readContent: false,
-                    includeHidden: false
-                });
-                const codeFiles = [
-                    ...projectStructure.buildFiles.filter(f => f.filename.match(/\.(ts|js|py|java|cs|go|rb|php|swift|kt|rs|cpp|c|h)$/)),
-                    ...projectStructure.configFiles.filter(f => f.filename.match(/\.(ts|js)$/))
-                ];
-                projectStructurePrompt = `
-## Project Structure (for ADR linking)
-Found ${codeFiles.length} code files:
-${codeFiles.map(f => `- ${f.relativePath} (${f.type})`).join('\n')}
-`;
-            }
-            // For rules integration, extract architectural rules from ADRs
-            let rulesPrompt = '';
-            if (includeRules) {
+            // Always use JSON-first TODO system
+            this.logger.info('Using JSON-first TODO system for ADR task generation');
+            const { manageTodoV2 } = await import('./tools/todo-management-tool-v2.js');
+            // Optional: Create backup if requested and JSON exists
+            if (createJsonBackup) {
                 try {
-                    const rulesResult = await this.generateRules({
-                        source: ruleSource,
-                        adrDirectory: adrDirectory,
+                    await manageTodoV2({
+                        operation: 'import_from_markdown',
                         projectPath: this.config.projectPath,
-                        outputFormat: 'json'
+                        mergeStrategy: 'preserve_json',
+                        backupExisting: true
                     });
-                    if (rulesResult.content) {
-                        rulesPrompt = `
-## Architectural Rules (for compliance validation)
-The following architectural rules have been extracted from ADRs and should be validated in tests:
-
-${Array.isArray(rulesResult.content) ? rulesResult.content.map((c) => c.text || c).join('\n') : rulesResult.content}
-`;
-                    }
+                    this.logger.info('Created backup of existing JSON TODO data');
                 }
                 catch (error) {
-                    this.logger.warn(`Failed to extract rules: ${error instanceof Error ? error.message : String(error)}`);
-                    rulesPrompt = `
-## Architectural Rules (failed to extract)
-Note: Could not extract architectural rules automatically. Manual rule validation may be needed.
-`;
+                    // Continue if backup fails - might be first time setup
+                    this.logger.debug('No existing JSON data to backup');
                 }
             }
-            // Generate TDD-focused todo creation prompt
-            const todoPrompt = `
-# TDD-Focused ADR Todo Generation Request
-
-## Step 1: ADR Discovery Results
-${adrContent}
-${projectStructurePrompt}
-${rulesPrompt}
-
-## Step 2: TDD Todo Generation Analysis
-
-Once you have discovered and read the ADR files, please analyze them and generate a comprehensive TDD-focused todo.md file.
-
-## TDD Phase: ${phase}
-${phase === 'test' ? '**Focus on Phase 1: Mock Test Generation Only**' : ''}
-${phase === 'production' ? '**Focus on Phase 2: Production Code Implementation (assumes tests exist)**' : ''}
-${phase === 'both' ? '**Generate both Phase 1 (Tests) and Phase 2 (Production) tasks**' : ''}
-
-## Requirements
-
-1. **Extract Tasks**: Identify all implementation tasks from ADRs
-2. **TDD Approach**: For each task, create:
-   - Phase 1: Mock test specifications
-   - Phase 2: Production implementation tasks
-3. **ADR Linking**: ${linkAdrs ? 'Link related ADRs to create comprehensive system tests' : 'Focus on individual ADR tasks'}
-4. **Rules Integration**: ${includeRules ? `Include architectural rules validation in tests (source: ${ruleSource})` : 'Skip architectural rules validation'}
-5. **Categorize**: Group tasks by ADR and testing phase
-6. **Status Detection**: Determine task completion status
-7. **Progress Tracking**: Calculate overall progress for both test and implementation phases
-8. **Scope Filter**: ${scope === 'all' ? 'Include all tasks' : `Focus on ${scope} tasks only`}
-
-## TDD Todo.md Format
-
-\`\`\`markdown
-# TDD-Focused ADR Implementation Progress
-
-**Last Updated**: [Date]
-**Overall Progress**: [X]% Complete
-**Test Coverage**: [X]% Complete
-**Implementation Coverage**: [X]% Complete
-
-## Summary
-- Total ADRs: [count]
-- Total Tasks: [count] (Tests: [count], Implementation: [count])
-- Completed: [count]
-- In Progress: [count]
-- Pending: [count]
-
-## System Architecture Overview (from linked ADRs)
-[Brief summary of how all ADRs connect to form the complete system]
-
-## Phase 1: Test Generation Tasks
-
-### ADR-001: [Title]
-#### Test Specifications
-- [ ] TEST: Unit test for [component/function]
-  - Mock: [what to mock]
-  - Expected: [expected behavior]
-  - Coverage: [what this tests]
-- [ ] TEST: Integration test for [feature]
-  - Setup: [test environment]
-  - Scenario: [test scenario]
-  - Assertions: [what to verify]
-${includeRules ? `- [ ] RULE: Architectural rule validation test for [rule name]
-  - Validation: [what rule to check]
-  - Pattern: [validation pattern/regex]
-  - Expected: [compliant behavior]` : ''}
-
-### ADR-002: [Title]
-#### Test Specifications
-- [ ] TEST: [test description]
-${includeRules ? '- [ ] RULE: [rule validation test]' : ''}
-...
-
-## Phase 2: Production Implementation Tasks
-
-### ADR-001: [Title]
-#### Implementation Tasks (after tests pass)
-- [ ] IMPL: Implement [component/function]
-  - Precondition: Unit test for [component] exists
-  - Definition: [what to implement]
-  - Acceptance: All related tests pass
-${includeRules ? `  - Compliance: Must pass architectural rule validation` : ''}
-- [ ] IMPL: [implementation task]
-
-### ADR-002: [Title]
-#### Implementation Tasks
-- [ ] IMPL: [implementation description]
-${includeRules ? '  - Compliance: [specific rule requirements]' : ''}
-...
-
-## ADR Dependencies and Links
-- ADR-001 → ADR-002: [relationship description]
-- ADR-002 → ADR-003: [relationship description]
-
-## Test-First Development Workflow
-1. Complete all Phase 1 tests for a component
-${includeRules ? '2. Complete architectural rule validation tests' : ''}
-${includeRules ? '3' : '2'}. Run tests (they should fail)
-${includeRules ? '4' : '3'}. Implement Phase 2 production code
-${includeRules ? '5' : '4'}. Run tests (they should pass)
-${includeRules ? '6. Validate architectural rule compliance' : ''}
-${includeRules ? '7' : '5'}. Refactor if needed while maintaining rule compliance
-\`\`\`
-
-Please provide:
-1. Comprehensive task extraction from all ADRs
-2. Test specifications for each implementation task
-${includeRules ? '3. Architectural rule validation tests and compliance checks' : ''}
-${includeRules ? '4' : '3'}. Clear separation of test and implementation phases
-${includeRules ? '5' : '4'}. ADR relationship mapping for system-wide test coverage
-${includeRules ? '6' : '5'}. TDD workflow recommendations with rule compliance integration
-`;
-            // Execute the todo generation with AI if enabled, otherwise return prompt
-            const { executePromptWithFallback, formatMCPResponse } = await import('./utils/prompt-execution.js');
-            const executionResult = await executePromptWithFallback(todoPrompt, 'Generate TDD-focused todo.md file from ADR analysis with test-first approach and system-wide coverage', {
-                temperature: 0.1,
-                maxTokens: 8000,
-                systemPrompt: `You are an expert in Test-Driven Development (TDD) and architectural implementation.
-Analyze the provided ADRs to extract actionable tasks following a strict TDD approach.
-
-Key responsibilities:
-1. For each implementation task, FIRST define the test specifications
-2. Create mock test descriptions that verify the expected behavior
-3. Link related ADRs to ensure comprehensive system test coverage
-4. Separate test generation (Phase 1) from production code (Phase 2)
-5. Ensure every production task has corresponding test coverage
-6. Map ADR dependencies to identify integration test requirements
-${includeRules ? '7. Include architectural rule validation in test specifications' : ''}
-${includeRules ? '8. Create compliance checks for extracted architectural rules' : ''}
-${includeRules ? '9. Ensure implementation tasks include rule compliance verification' : ''}
-
-Follow the TDD red-green-refactor cycle:
-- Red: Write failing tests first (Phase 1)${includeRules ? ' including rule validation tests' : ''}
-- Green: Implement minimal code to pass tests (Phase 2)
-- Refactor: Improve code while keeping tests green${includeRules ? ' and maintaining rule compliance' : ''}
-
-${includeRules ? 'The architectural rules provide constraints and patterns that must be validated in tests and followed in implementation.' : ''}
-
-The todo.md should serve as the glue connecting all ADRs into a cohesive, testable${includeRules ? ', rule-compliant' : ''} system.`,
-                responseFormat: 'text'
+            // Import ADR tasks into JSON system with enhanced parameters
+            const importResult = await manageTodoV2({
+                operation: 'import_adr_tasks',
+                projectPath: this.config.projectPath,
+                adrDirectory: absoluteAdrPath,
+                preserveExisting,
+                autoLinkDependencies: linkAdrs,
+                ...(intentId && { intentId })
             });
-            if (executionResult.isAIGenerated) {
-                // AI execution successful - return actual todo generation results
-                return formatMCPResponse({
-                    ...executionResult,
-                    content: `# TDD-Focused ADR Todo Generation Results
+            // Sync JSON data to markdown with force option
+            await manageTodoV2({
+                operation: 'sync_to_markdown',
+                projectPath: this.config.projectPath,
+                force: forceSyncToMarkdown
+            });
+            return {
+                content: [{
+                        type: 'text',
+                        text: `# ✅ JSON-First TODO Generated from ADRs
+
+## 🏗️ JSON-First TODO System Active
+✅ **todo-data.json** - JSON-first TODO backend created/updated  
+✅ **TODO.md** - Markdown frontend ${forceSyncToMarkdown ? 'synchronized' : 'available for sync'}  
 
-## Analysis Information
+## Configuration Applied
 - **ADR Directory**: ${adrDirectory}
 - **Scope**: ${scope}
 - **TDD Phase**: ${phase}
-- **ADR Linking**: ${linkAdrs ? 'Enabled' : 'Disabled'}
+- **ADR Dependency Linking**: ${linkAdrs ? 'Enabled' : 'Disabled'}
 - **Rules Integration**: ${includeRules ? `Enabled (${ruleSource})` : 'Disabled'}
-
-## AI-Generated TDD Todo Results
-
-${executionResult.content}
-
-## TDD Implementation Workflow
-
-### Phase 1: Test Generation (Red Phase)
-1. **Review Test Specifications**: Examine each test task for completeness
-2. **Create Mock Tests**: Implement test files with proper mocking
-3. **Define Assertions**: Ensure tests verify expected behavior
-4. **Run Tests**: Confirm all tests fail (red phase)
-
-### Phase 2: Production Implementation (Green Phase)
-1. **Implement Minimal Code**: Write just enough code to pass tests
-2. **Run Tests Again**: Verify tests now pass (green phase)
-3. **Check Coverage**: Ensure all ADR requirements are tested
-4. **Integration Testing**: Verify ADR interactions work correctly
-
-### Phase 3: Refactoring (Refactor Phase)
-1. **Improve Code Quality**: Refactor while keeping tests green
-2. **Update Documentation**: Keep ADRs and tests in sync
-3. **Performance Optimization**: Optimize without breaking tests
-
-## ADR System Integration
-
-The todo.md serves as the glue connecting all ADRs by:
-- **Mapping Dependencies**: Shows how ADRs relate to each other
-- **System-wide Coverage**: Ensures no gaps in test coverage
-- **Progress Tracking**: Monitors both test and implementation completion
-- **Working Environment**: Defines the expected system outcome
-
-## Integration Commands
-
-### Generate Test Phase Only:
-\`\`\`json
-{
-  "tool": "generate_adr_todo",
-  "args": {
-    "adrDirectory": "${adrDirectory}",
-    "phase": "test",
-    "linkAdrs": true,
-    "includeRules": true,
-    "ruleSource": "both"
-  }
-}
-\`\`\`
-
-### Generate Production Phase Only:
-\`\`\`json
-{
-  "tool": "generate_adr_todo",
-  "args": {
-    "adrDirectory": "${adrDirectory}",
-    "phase": "production",
-    "scope": "pending",
-    "includeRules": true
-  }
-}
-\`\`\`
-
-### Update Full TDD Todo with Rules:
-\`\`\`json
-{
-  "tool": "generate_adr_todo",
-  "args": {
-    "adrDirectory": "${adrDirectory}",
-    "phase": "both",
-    "linkAdrs": true,
-    "includeRules": true,
-    "ruleSource": "both"
-  }
-}
-\`\`\`
-`,
-                });
-            }
-            else {
-                // Fallback to prompt-only mode
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: `TDD-focused ADR todo generation for: ${adrDirectory}\n\nPhase: ${phase}\nADR Linking: ${linkAdrs ? 'Enabled' : 'Disabled'}\nRules Integration: ${includeRules ? `Enabled (${ruleSource})` : 'Disabled'}\nScope: ${scope}\n\nPlease generate a TDD-focused todo.md using the following prompt:\n\n${todoPrompt}`
-                        }
-                    ]
-                };
-            }
+- **Preserve Existing**: ${preserveExisting}
+- **Force Markdown Sync**: ${forceSyncToMarkdown ? 'Enabled' : 'Disabled'}
+- **Intent Linking**: ${intentId ? `Linked to ${intentId}` : 'None'}
+- **JSON Backup**: ${createJsonBackup ? 'Created' : 'Skipped'}
+
+## JSON-First Architecture Benefits
+✅ **Structured Data**: JSON backend ensures consistent LLM interactions
+✅ **Automatic Sync**: JSON-to-markdown conversion maintains TODO.md compatibility  
+✅ **Enhanced Metadata**: Full task lifecycle with dependencies, assignees, priorities
+✅ **Complete Integration**: Native support for scoring, git automation, and knowledge graph
+✅ **Backup Protection**: Automatic data preservation during updates
+✅ **No Manual Setup**: All cache files auto-generated, tests can immediately validate
+
+${importResult.content[0].text}
+
+## Available Operations (use manage_todo_v2 tool)
+1. **View Tasks**: \`get_tasks\` operation with filtering and sorting
+2. **Update Status**: \`update_task\` operation with status, progress, notes
+3. **Bulk Updates**: \`bulk_update\` operation for multiple tasks
+4. **Analytics**: \`get_analytics\` operation for progress metrics
+5. **Sync Control**: \`sync_to_markdown\` and \`sync_knowledge_graph\` operations
+
+## Validation & Progress Tracking
+- **Progress Check**: Use \`compare_adr_progress\` to validate implementation vs ADRs
+- **Git Integration**: Use \`smart_git_push\` for automatic task status updates
+- **Scoring**: Integrated with smart scoring for release readiness assessment
+
+## TDD Workflow Integration
+- **Phase 1**: Mock test generation tasks created
+- **Phase 2**: Production implementation tasks linked to tests
+- **Dependencies**: ADR relationships mapped to task dependencies
+- **Validation**: Architectural rules integrated into task criteria
+
+*All TODO data is now managed in JSON format with automatic markdown sync*`
+                    }]
+            };
         }
         catch (error) {
             throw new McpAdrError(`Failed to generate ADR todo: ${error instanceof Error ? error.message : String(error)}`, 'GENERATION_ERROR');
@@ -4146,6 +4283,71 @@ Please provide:
     /**
      * Apply content masking to MCP response
      */
+    /**
+     * Track tool execution in knowledge graph
+     */
+    async trackToolExecution(toolName, parameters, result, success, error) {
+        try {
+            // Extract intentId from metadata if available
+            let intentId;
+            if (result?.metadata?.intentId) {
+                intentId = result.metadata.intentId;
+            }
+            else {
+                // Check for active intents that might be related to this tool execution
+                const activeIntents = await this.kgManager.getActiveIntents();
+                if (activeIntents.length > 0) {
+                    // Use the most recent active intent
+                    const latestIntent = activeIntents[activeIntents.length - 1];
+                    if (latestIntent) {
+                        intentId = latestIntent.intentId;
+                    }
+                }
+            }
+            // If no intent found, create a standalone execution record
+            if (!intentId) {
+                // Extract human request from conversation context if available
+                let humanRequest = `Standalone tool execution: ${toolName}`;
+                if (parameters?.conversationContext?.humanRequest) {
+                    humanRequest = parameters.conversationContext.humanRequest;
+                }
+                intentId = await this.kgManager.createIntent(humanRequest, [`Execute ${toolName}`, 'Complete tool operation'], 'medium');
+            }
+            // Determine tasks created/modified from tool operation
+            const todoTasksCreated = [];
+            const todoTasksModified = [];
+            // Extract task information from result metadata
+            if (result?.metadata) {
+                if (result.metadata.tasksCreated) {
+                    todoTasksCreated.push(...result.metadata.tasksCreated);
+                }
+                if (result.metadata.tasksModified) {
+                    todoTasksModified.push(...result.metadata.tasksModified);
+                }
+                if (result.metadata.taskIds) {
+                    todoTasksModified.push(...result.metadata.taskIds);
+                }
+            }
+            // Store execution in knowledge graph
+            await this.kgManager.addToolExecution(intentId, toolName, parameters, result, success, todoTasksCreated, todoTasksModified, error);
+            // If execution completed successfully, update intent status
+            if (success && !error) {
+                // Check if this might be the final tool in a chain
+                const intent = await this.kgManager.getIntentById(intentId);
+                if (intent && intent.currentStatus === 'executing') {
+                    // Simple heuristic: if tool is a "completion" type tool, mark intent as completed
+                    const completionTools = ['smart_git_push', 'generate_deployment_guidance', 'smart_score'];
+                    if (completionTools.includes(toolName)) {
+                        await this.kgManager.updateIntentStatus(intentId, 'completed');
+                    }
+                }
+            }
+        }
+        catch (trackingError) {
+            // Don't let tracking errors break tool execution
+            console.error('[WARN] Knowledge graph tracking failed:', trackingError);
+        }
+    }
     async applyOutputMasking(response) {
         try {
             return await maskMcpResponse(response, this.maskingConfig);
@@ -4329,13 +4531,18 @@ Please provide:
             throw new McpAdrError(`Failed to list directory: ${error instanceof Error ? error.message : String(error)}`, 'DIRECTORY_LIST_ERROR');
         }
     }
-    async manageTodo(args) {
+    async manageTodoJson(args) {
         try {
-            const { manageTodo } = await import('./tools/todo-management-tool.js');
-            return await manageTodo(args);
+            const { manageTodoV2 } = await import('./tools/todo-management-tool-v2.js');
+            // Add projectPath to args if not provided
+            const argsWithPath = {
+                ...args,
+                projectPath: args.projectPath || this.config.projectPath
+            };
+            return await manageTodoV2(argsWithPath);
         }
         catch (error) {
-            throw new McpAdrError(`TODO management failed: ${error instanceof Error ? error.message : String(error)}`, 'TODO_MANAGEMENT_ERROR');
+            throw new McpAdrError(`JSON TODO management failed: ${error instanceof Error ? error.message : String(error)}`, 'TODO_JSON_MANAGEMENT_ERROR');
         }
     }
     async generateDeploymentGuidance(args) {
@@ -4356,6 +4563,24 @@ Please provide:
             throw new McpAdrError(`Smart git push failed: ${error instanceof Error ? error.message : String(error)}`, 'SMART_GIT_PUSH_ERROR');
         }
     }
+    async troubleshootGuidedWorkflow(args) {
+        try {
+            const { troubleshootGuidedWorkflow } = await import('./tools/troubleshoot-guided-workflow-tool.js');
+            return await troubleshootGuidedWorkflow(args);
+        }
+        catch (error) {
+            throw new McpAdrError(`Troubleshoot guided workflow failed: ${error instanceof Error ? error.message : String(error)}`, 'TROUBLESHOOT_GUIDED_WORKFLOW_ERROR');
+        }
+    }
+    async smartScore(args) {
+        try {
+            const { smartScore } = await import('./tools/smart-score-tool.js');
+            return await smartScore(args);
+        }
+        catch (error) {
+            throw new McpAdrError(`Smart score analysis failed: ${error instanceof Error ? error.message : String(error)}`, 'SMART_SCORE_ERROR');
+        }
+    }
 }
 /**
  * Main execution