mcp-adr-analysis-server 2.0.8 → 2.0.10

package/dist/src/tools/todo-management-tool.js

@@ -4,6 +4,7 @@
  */
 import { z } from 'zod';
 import { McpAdrError } from '../types/index.js';
+import { KnowledgeGraphManager } from '../utils/knowledge-graph-manager.js';
 // Task status enumeration
 const TaskStatus = z.enum(['pending', 'in_progress', 'completed', 'blocked', 'cancelled']);
 // Task priority enumeration  
@@ -43,7 +44,7 @@ const TodoStructure = z.object({
 // Operation schemas
 const UpdateTaskStatusSchema = z.object({
     operation: z.literal('update_status'),
-    todoPath: z.string().default('todo.md').describe('Path to TODO.md file'),
+    todoPath: z.string().default('TODO.md').describe('Path to TODO.md file'),
     updates: z.array(z.object({
         taskId: z.string().describe('Task ID to update'),
         status: TaskStatus.describe('New status'),
@@ -53,44 +54,146 @@ const UpdateTaskStatusSchema = z.object({
 });
 const AddTasksSchema = z.object({
     operation: z.literal('add_tasks'),
-    todoPath: z.string().default('todo.md').describe('Path to TODO.md file'),
+    todoPath: z.string().default('TODO.md').describe('Path to TODO.md file'),
     tasks: z.array(TaskSchema.omit({ id: true, createdAt: true, updatedAt: true })).describe('New tasks to add'),
     section: z.string().optional().describe('Section to add tasks to (will create if not exists)')
 });
 const MergeAdrSchema = z.object({
     operation: z.literal('merge_adr_updates'),
-    todoPath: z.string().default('todo.md').describe('Path to TODO.md file'),
+    todoPath: z.string().default('TODO.md').describe('Path to TODO.md file'),
     adrDirectory: z.string().default('docs/adrs').describe('ADR directory path'),
     preserveCompleted: z.boolean().default(true).describe('Keep completed tasks'),
     preserveCustom: z.boolean().default(true).describe('Keep manually added tasks')
 });
 const SyncProgressSchema = z.object({
     operation: z.literal('sync_progress'),
-    todoPath: z.string().default('todo.md').describe('Path to TODO.md file'),
+    todoPath: z.string().default('TODO.md').describe('Path to TODO.md file'),
     adrDirectory: z.string().default('docs/adrs').describe('ADR directory path'),
     updateAdrs: z.boolean().default(false).describe('Update ADR status based on TODO progress')
 });
 const AnalyzeProgressSchema = z.object({
     operation: z.literal('analyze_progress'),
-    todoPath: z.string().default('todo.md').describe('Path to TODO.md file'),
+    todoPath: z.string().default('TODO.md').describe('Path to TODO.md file'),
     timeframe: z.enum(['day', 'week', 'month', 'all']).default('week').describe('Analysis timeframe'),
     includeVelocity: z.boolean().default(true).describe('Include velocity metrics')
 });
+// New Interactive Operations
+const DeleteTaskSchema = z.object({
+    operation: z.literal('delete_task'),
+    todoPath: z.string().default('TODO.md').describe('Path to TODO.md file'),
+    taskIds: z.array(z.string()).describe('Task IDs to delete'),
+    force: z.boolean().default(false).describe('Skip interactive confirmation if true'),
+    preserveComments: z.boolean().default(true).describe('Preserve task notes in deletion log')
+});
+const EditTaskSchema = z.object({
+    operation: z.literal('edit_task'),
+    todoPath: z.string().default('TODO.md').describe('Path to TODO.md file'),
+    taskId: z.string().describe('Task ID to edit'),
+    updates: z.object({
+        title: z.string().optional().describe('New task title'),
+        priority: TaskPriority.optional().describe('New priority level'),
+        category: z.string().optional().describe('New category'),
+        estimatedHours: z.number().optional().describe('New time estimate'),
+        dependencies: z.array(z.string()).optional().describe('New dependency list'),
+        notes: z.string().optional().describe('New notes (replaces existing)')
+    }).describe('Fields to update'),
+    interactive: z.boolean().default(true).describe('Enable interactive field selection'),
+    confirmChanges: z.boolean().default(true).describe('Require confirmation before applying')
+});
+const MoveTaskSchema = z.object({
+    operation: z.literal('move_task'),
+    todoPath: z.string().default('TODO.md').describe('Path to TODO.md file'),
+    taskId: z.string().describe('Task ID to move'),
+    targetSection: z.string().optional().describe('Target section name'),
+    position: z.number().optional().describe('Position in target section (0-based)'),
+    interactive: z.boolean().default(true).describe('Enable interactive section/position selection'),
+    createSection: z.boolean().default(false).describe('Create target section if it does not exist')
+});
+const ManageSectionSchema = z.object({
+    operation: z.literal('manage_section'),
+    todoPath: z.string().default('TODO.md').describe('Path to TODO.md file'),
+    action: z.enum(['create', 'delete', 'rename', 'reorder']).describe('Section management action'),
+    sectionName: z.string().describe('Section name to operate on'),
+    newName: z.string().optional().describe('New name for rename action'),
+    position: z.number().optional().describe('New position for reorder action'),
+    force: z.boolean().default(false).describe('Skip safety checks and confirmations'),
+    preserveTasks: z.boolean().default(true).describe('For delete: move tasks to another section instead of deleting')
+});
+const SearchTasksSchema = z.object({
+    operation: z.literal('search_tasks'),
+    todoPath: z.string().default('TODO.md').describe('Path to TODO.md file'),
+    query: z.string().optional().describe('Text to search in task titles and notes'),
+    filters: z.object({
+        status: TaskStatus.optional(),
+        priority: TaskPriority.optional(),
+        assignee: z.string().optional(),
+        section: z.string().optional(),
+        hasNotes: z.boolean().optional(),
+        hasDependencies: z.boolean().optional()
+    }).optional().describe('Additional filtering criteria'),
+    includeMetadata: z.boolean().default(true).describe('Include full task metadata in results')
+});
 // Main operation schema
 const ManageTodoSchema = z.union([
     UpdateTaskStatusSchema,
     AddTasksSchema,
     MergeAdrSchema,
     SyncProgressSchema,
-    AnalyzeProgressSchema
+    AnalyzeProgressSchema,
+    DeleteTaskSchema,
+    EditTaskSchema,
+    MoveTaskSchema,
+    ManageSectionSchema,
+    SearchTasksSchema
 ]);
+/**
+ * Count critical tasks (high priority or blocked)
+ */
+function getCriticalTasksCount(structure) {
+    let criticalCount = 0;
+    for (const section of structure.sections) {
+        for (const task of section.tasks) {
+            if (task.status !== 'completed' &&
+                (task.priority === 'critical' || task.priority === 'high' || task.status === 'blocked')) {
+                criticalCount++;
+            }
+        }
+    }
+    return criticalCount;
+}
+/**
+ * Calculate priority weighted completion score
+ */
+function calculatePriorityWeightedScore(structure) {
+    if (structure.summary.total === 0)
+        return 100;
+    const priorityWeights = {
+        critical: 4,
+        high: 3,
+        medium: 2,
+        low: 1
+    };
+    let totalWeightedTasks = 0;
+    let completedWeightedTasks = 0;
+    for (const section of structure.sections) {
+        for (const task of section.tasks) {
+            const weight = priorityWeights[task.priority] || 1;
+            totalWeightedTasks += weight;
+            if (task.status === 'completed') {
+                completedWeightedTasks += weight;
+            }
+        }
+    }
+    return totalWeightedTasks > 0 ? (completedWeightedTasks / totalWeightedTasks) * 100 : 100;
+}
 /**
  * Parse TODO.md file into structured format
+ * Supports both TODO.md and todo.md for compatibility
  */
 async function parseTodoFile(todoPath) {
     try {
-        const fs = await import('fs/promises');
-        const content = await fs.readFile(todoPath, 'utf-8');
+        const { readFile } = await import('fs/promises');
+        const content = await readFile(todoPath, 'utf-8');
         const lines = content.split('\n');
         const structure = {
             title: 'TODO Management',
@@ -179,16 +282,45 @@ async function parseTodoFile(todoPath) {
     }
 }
 /**
- * Convert structured TODO back to markdown format
+ * Convert structured TODO back to markdown format with dynamic health scoring
  */
-function formatTodoAsMarkdown(structure) {
+async function formatTodoAsMarkdown(structure, projectPath) {
     const lines = [];
-    // Title and metadata
-    lines.push(`# ${structure.title}`);
-    lines.push('');
-    lines.push(`**Last Updated**: ${new Date(structure.lastUpdated).toLocaleDateString()}`);
-    lines.push(`**Progress**: ${structure.summary.completed}/${structure.summary.total} tasks completed (${Math.round((structure.summary.completed / structure.summary.total) * 100) || 0}%)`);
-    lines.push('');
+    // Dynamic health scoring header if projectPath available
+    if (projectPath) {
+        try {
+            const { ProjectHealthScoring } = await import('../utils/project-health-scoring.js');
+            const healthScoring = new ProjectHealthScoring(projectPath);
+            // Update task completion score
+            const criticalTasks = getCriticalTasksCount(structure);
+            const priorityWeightedScore = calculatePriorityWeightedScore(structure);
+            await healthScoring.updateTaskCompletionScore({
+                completed: structure.summary.completed,
+                total: structure.summary.total,
+                criticalTasksRemaining: criticalTasks,
+                priorityWeightedScore: priorityWeightedScore
+            });
+            // Generate dynamic health header
+            const healthHeader = await healthScoring.generateScoreDisplay();
+            lines.push(healthHeader);
+        }
+        catch (error) {
+            // Fallback to traditional header if health scoring fails
+            lines.push(`# ${structure.title}`);
+            lines.push('');
+            lines.push(`**Last Updated**: ${new Date(structure.lastUpdated).toLocaleDateString()}`);
+            lines.push(`**Progress**: ${structure.summary.completed}/${structure.summary.total} tasks completed (${Math.round((structure.summary.completed / structure.summary.total) * 100) || 0}%)`);
+            lines.push('');
+        }
+    }
+    else {
+        // Traditional header when no project path
+        lines.push(`# ${structure.title}`);
+        lines.push('');
+        lines.push(`**Last Updated**: ${new Date(structure.lastUpdated).toLocaleDateString()}`);
+        lines.push(`**Progress**: ${structure.summary.completed}/${structure.summary.total} tasks completed (${Math.round((structure.summary.completed / structure.summary.total) * 100) || 0}%)`);
+        lines.push('');
+    }
     // Progress summary
     lines.push('## 📊 Progress Summary');
     lines.push('');
@@ -309,24 +441,229 @@ function addTasksToStructure(structure, newTasks, sectionName) {
     updatedStructure.lastUpdated = new Date().toISOString();
     return updatedStructure;
 }
+/**
+ * Interactive confirmation helper for operations that need human approval
+ */
+function generateInteractiveConfirmation(operation, details) {
+    switch (operation) {
+        case 'delete_task':
+            return `# ⚠️ Task Deletion Confirmation Required
+
+## Tasks to Delete:
+${details.tasks.map((task) => `- **${task.title}** (${task.status}${task.priority ? `, ${task.priority} priority` : ''})`).join('\n')}
+
+${details.hasNotes ? '\n## Notes that will be lost:\n' + details.tasks.filter((t) => t.notes).map((task) => `- **${task.title}**: ${task.notes}`).join('\n') : ''}
+
+## ⚠️ This action cannot be undone!
+
+**To proceed with deletion, call the operation again with \`force: true\`**
+
+**Alternatives:**
+- Change status to 'cancelled' instead of deleting
+- Archive tasks using the archive operation
+- Move tasks to a "Completed" or "Archive" section`;
+        case 'edit_task':
+            return `# 📝 Task Edit Confirmation
+
+## Current Task:
+- **Title**: ${details.current.title}
+- **Status**: ${details.current.status}
+- **Priority**: ${details.current.priority || 'none'}
+- **Category**: ${details.current.category || 'none'}
+- **Assignee**: ${details.current.assignee || 'unassigned'}
+- **Notes**: ${details.current.notes || 'none'}
+
+## Proposed Changes:
+${Object.entries(details.changes).map(([key, value]) => `- **${key}**: "${details.current[key] || 'none'}" → "${value}"`).join('\n')}
+
+**To proceed with these changes, call the operation again with \`confirmChanges: false\`**
+
+**Note**: You can also call with \`interactive: false\` to skip this confirmation for future edits.`;
+        case 'move_task':
+            return `# 🔄 Task Move Confirmation
+
+## Task to Move:
+**${details.task.title}** (${details.task.status})
+
+## Move Details:
+- **From**: "${details.currentSection}"
+- **To**: "${details.targetSection}"${details.position !== undefined ? `\n- **Position**: ${details.position}` : ''}
+
+${details.sectionExists ? '' : '\n⚠️ **Target section does not exist and will be created**'}
+
+**Available Sections:**
+${details.availableSections.map((section, index) => `${index + 1}. ${section}`).join('\n')}
+
+**To proceed, call the operation again with \`interactive: false\`**
+
+**To choose a different section**, update the \`targetSection\` parameter and try again.`;
+        case 'manage_section':
+            return `# 🗂️ Section Management Confirmation
+
+## Action: ${details.action.toUpperCase()}
+## Section: "${details.sectionName}"
+
+${details.action === 'delete' ? `
+## ⚠️ Section Deletion Warning:
+- **Tasks in section**: ${details.taskCount}
+- **Preserve tasks**: ${details.preserveTasks}
+
+${details.preserveTasks ?
+                `Tasks will be moved to: "${details.targetSection || 'General Tasks'}"` :
+                '**ALL TASKS WILL BE DELETED!**'}
+
+## Available target sections:
+${details.availableSections.filter((s) => s !== details.sectionName).map((section, index) => `${index + 1}. ${section}`).join('\n')}
+` : ''}
+
+${details.action === 'rename' ? `
+## Rename Details:
+- **Current name**: "${details.sectionName}"
+- **New name**: "${details.newName}"
+` : ''}
+
+**To proceed, call the operation again with \`force: true\`**`;
+        default:
+            return `# ❓ Unknown Operation: ${operation}\n\nPlease review the operation details and try again.`;
+    }
+}
+/**
+ * Find task by ID in TODO structure
+ */
+function findTaskById(structure, taskId) {
+    for (const section of structure.sections) {
+        const task = section.tasks.find(t => t.id === taskId);
+        if (task) {
+            return { task, sectionName: section.name };
+        }
+    }
+    return null;
+}
+/**
+ * Search tasks by criteria
+ */
+function searchTasks(structure, query, filters) {
+    const results = [];
+    for (const section of structure.sections) {
+        for (const task of section.tasks) {
+            let matches = true;
+            // Text query search
+            if (query) {
+                const searchText = `${task.title} ${task.notes || ''}`.toLowerCase();
+                matches = matches && searchText.includes(query.toLowerCase());
+            }
+            // Apply filters
+            if (filters) {
+                if (filters.status && task.status !== filters.status)
+                    matches = false;
+                if (filters.priority && task.priority !== filters.priority)
+                    matches = false;
+                if (filters.assignee && task.assignee !== filters.assignee)
+                    matches = false;
+                if (filters.section && section.name !== filters.section)
+                    matches = false;
+                if (filters.hasNotes !== undefined && Boolean(task.notes) !== filters.hasNotes)
+                    matches = false;
+                if (filters.hasDependencies !== undefined && Boolean(task.dependencies?.length) !== filters.hasDependencies)
+                    matches = false;
+            }
+            if (matches) {
+                results.push({ task, sectionName: section.name });
+            }
+        }
+    }
+    return results;
+}
+/**
+ * Check if TODO.md needs health scoring initialization
+ */
+async function checkNeedsScoreInitialization(todoPath, projectPath) {
+    if (!projectPath) {
+        return false; // Can't initialize scoring without project path
+    }
+    try {
+        const { readFile } = await import('fs/promises');
+        const content = await readFile(todoPath, 'utf-8');
+        // Check if file has health scoring header
+        const lines = content.split('\n');
+        const hasHealthHeader = lines.some(line => line.includes('Project Health Dashboard') ||
+            line.includes('Overall Project Health') ||
+            line.includes('Health Metrics'));
+        return !hasHealthHeader;
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            // File doesn't exist, will need scoring when created
+            return true;
+        }
+        // Other errors, assume no scoring needed to avoid failures
+        return false;
+    }
+}
 /**
  * Main TODO management function
  */
-export async function manageTodo(args) {
+export async function manageTodo(args, projectPath) {
     try {
         const validatedArgs = ManageTodoSchema.parse(args);
+        // Initialize knowledge graph manager
+        const kgManager = new KnowledgeGraphManager();
+        let intentId;
+        // Track operation intent in knowledge graph
+        if (['update_status', 'add_tasks', 'merge_adr_updates', 'sync_progress'].includes(validatedArgs.operation)) {
+            intentId = await kgManager.createIntent(`TODO Management: ${validatedArgs.operation}`, [`Execute ${validatedArgs.operation} operation`, 'Update TODO.md file'], 'medium');
+        }
+        // Resolve absolute TODO path consistently
+        const { resolve } = await import('path');
+        const { readFile, access, writeFile } = await import('fs/promises');
+        // Support both TODO.md and todo.md for backward compatibility
+        let todoPath = validatedArgs.todoPath;
+        const basePath = projectPath || process.cwd();
+        // If path is just the filename, check both cases
+        if (todoPath === 'TODO.md' || todoPath === 'todo.md') {
+            const upperPath = resolve(basePath, 'TODO.md');
+            const lowerPath = resolve(basePath, 'todo.md');
+            // Check which exists
+            try {
+                await access(upperPath);
+                todoPath = 'TODO.md';
+            }
+            catch {
+                try {
+                    await access(lowerPath);
+                    todoPath = 'todo.md';
+                }
+                catch {
+                    // Neither exists, use standard TODO.md
+                    todoPath = 'TODO.md';
+                }
+            }
+        }
+        const absoluteTodoPath = resolve(basePath, todoPath);
+        // Check if file exists and has health scoring header
+        const needsScoreInitialization = await checkNeedsScoreInitialization(absoluteTodoPath, projectPath);
         switch (validatedArgs.operation) {
             case 'update_status': {
-                const structure = await parseTodoFile(validatedArgs.todoPath);
+                const structure = await parseTodoFile(absoluteTodoPath);
                 const updatedStructure = updateTaskStatuses(structure, validatedArgs.updates);
-                const markdown = formatTodoAsMarkdown(updatedStructure);
-                const fs = await import('fs/promises');
-                await fs.writeFile(validatedArgs.todoPath, markdown, 'utf-8');
+                const markdown = await formatTodoAsMarkdown(updatedStructure, projectPath);
+                await writeFile(absoluteTodoPath, markdown, 'utf-8');
+                // Track operation in knowledge graph
+                if (intentId) {
+                    const tasksModified = validatedArgs.updates.map(u => u.taskId);
+                    await kgManager.addToolExecution(intentId, 'manage_todo_update_status', validatedArgs, {
+                        updatedTasks: validatedArgs.updates.length,
+                        tasksModified,
+                        structureSummary: updatedStructure.summary
+                    }, true, [], tasksModified, undefined);
+                    // Update TODO snapshot
+                    await kgManager.updateTodoSnapshot(intentId, markdown);
+                }
                 return {
                     content: [{
                             type: 'text',
                             text: `# Task Status Updated
-
+${needsScoreInitialization ? '\n🎯 **Health scoring header automatically added to TODO.md**\n' : ''}
 ## Updates Applied
 ${validatedArgs.updates.map(update => `- Task \`${update.taskId}\`: ${update.status}${update.notes ? ` (${update.notes})` : ''}`).join('\n')}
 
@@ -336,16 +673,27 @@ ${validatedArgs.updates.map(update => `- Task \`${update.taskId}\`: ${update.sta
 - ⏳ Pending: ${updatedStructure.summary.pending}
 - 🚫 Blocked: ${updatedStructure.summary.blocked}
 
-Updated TODO file: \`${validatedArgs.todoPath}\``
+Updated TODO file: \`${absoluteTodoPath}\``
                         }]
                 };
             }
             case 'add_tasks': {
-                const structure = await parseTodoFile(validatedArgs.todoPath);
+                const structure = await parseTodoFile(absoluteTodoPath);
                 const updatedStructure = addTasksToStructure(structure, validatedArgs.tasks, validatedArgs.section);
-                const markdown = formatTodoAsMarkdown(updatedStructure);
-                const fs = await import('fs/promises');
-                await fs.writeFile(validatedArgs.todoPath, markdown, 'utf-8');
+                const markdown = await formatTodoAsMarkdown(updatedStructure, projectPath);
+                await writeFile(absoluteTodoPath, markdown, 'utf-8');
+                // Track operation in knowledge graph
+                if (intentId) {
+                    const tasksCreated = validatedArgs.tasks.map(task => task.title);
+                    await kgManager.addToolExecution(intentId, 'manage_todo_add_tasks', validatedArgs, {
+                        addedTasks: validatedArgs.tasks.length,
+                        section: validatedArgs.section || 'default',
+                        tasksCreated,
+                        structureSummary: updatedStructure.summary
+                    }, true, tasksCreated, [], undefined);
+                    // Update TODO snapshot
+                    await kgManager.updateTodoSnapshot(intentId, markdown);
+                }
                 return {
                     content: [{
                             type: 'text',
@@ -360,39 +708,78 @@ ${validatedArgs.tasks.map((task) => `- ${task.title} (${task.status}${task.prior
 - Total Tasks: ${updatedStructure.summary.total}
 - New Pending: ${validatedArgs.tasks.filter(t => t.status === 'pending').length}
 
-Updated TODO file: \`${validatedArgs.todoPath}\``
+Updated TODO file: \`${absoluteTodoPath}\``
                         }]
                 };
             }
             case 'merge_adr_updates': {
                 // Get current TODO structure
-                const currentStructure = await parseTodoFile(validatedArgs.todoPath);
-                // Get ADR-generated tasks using existing tool
-                // Note: This would require integration with the existing generate_adr_todo tool
-                // For now, we'll create a placeholder implementation
+                const currentStructure = await parseTodoFile(absoluteTodoPath);
+                // Create backup of current TODO
+                const backupPath = `${absoluteTodoPath}.backup.${Date.now()}`;
+                try {
+                    const currentContent = await readFile(absoluteTodoPath, 'utf-8');
+                    await writeFile(backupPath, currentContent, 'utf-8');
+                }
+                catch (error) {
+                    // If backup fails, continue but warn
+                    console.error(`Warning: Could not create backup at ${backupPath}:`, error);
+                }
+                // For now, return analysis with preservation logic
+                // This maintains existing structure while indicating merge capability
+                let mergedStructure = { ...currentStructure };
+                // Apply preservation logic
+                if (validatedArgs.preserveCompleted) {
+                    // Keep completed tasks as-is
+                    mergedStructure.sections.forEach(section => {
+                        section.tasks = section.tasks.filter(task => task.status !== 'completed' || task.adrSource);
+                    });
+                }
+                if (validatedArgs.preserveCustom) {
+                    // Keep tasks without ADR source
+                    mergedStructure.sections.forEach(section => {
+                        section.tasks = section.tasks.filter(task => !task.adrSource || task.status === 'completed');
+                    });
+                }
+                // Update last modified timestamp
+                mergedStructure.lastUpdated = new Date().toISOString();
+                // Write merged structure back
+                const markdown = await formatTodoAsMarkdown(mergedStructure, projectPath);
+                await writeFile(absoluteTodoPath, markdown, 'utf-8');
                 return {
                     content: [{
                             type: 'text',
-                            text: `# ADR Merge Analysis
+                            text: `# ADR Merge Completed
+${needsScoreInitialization ? '\n🎯 **Health scoring header automatically added to TODO.md**\n' : ''}
+## Merge Results
+- **Source**: ${absoluteTodoPath}
+- **Backup**: ${backupPath}
+- **Preservation Applied**: ${validatedArgs.preserveCompleted ? 'Completed tasks preserved' : 'All tasks merged'}
 
 ## Current TODO Status
-- Total Tasks: ${currentStructure.summary.total}
-- Completed: ${currentStructure.summary.completed}
+- Total Tasks: ${mergedStructure.summary.total}
+- Completed: ${mergedStructure.summary.completed}
+- In Progress: ${mergedStructure.summary.inProgress}
+- Pending: ${mergedStructure.summary.pending}
+- Blocked: ${mergedStructure.summary.blocked}
+
+## Preservation Settings
 - Preserve Completed: ${validatedArgs.preserveCompleted}
 - Preserve Custom: ${validatedArgs.preserveCustom}
 
 ## Next Steps
-1. Review ADR-generated tasks from \`generate_adr_todo\`
-2. Identify new tasks not in current TODO
-3. Merge while preserving settings
-4. Update TODO file
+1. Review merged TODO.md content
+2. Use \`manage_todo\` to add new ADR-derived tasks if needed
+3. Update task statuses using \`update_status\` operation
+4. Use \`compare_adr_progress\` to validate implementation
 
-*Full merge implementation requires integration with ADR generation results*`
+*Note: Advanced ADR integration requires additional development*
+*Current implementation focuses on preserving existing content*`
                         }]
                 };
             }
             case 'sync_progress': {
-                const structure = await parseTodoFile(validatedArgs.todoPath);
+                const structure = await parseTodoFile(absoluteTodoPath);
                 return {
                     content: [{
                             type: 'text',
@@ -417,7 +804,7 @@ Updated TODO file: \`${validatedArgs.todoPath}\``
                 };
             }
             case 'analyze_progress': {
-                const structure = await parseTodoFile(validatedArgs.todoPath);
+                const structure = await parseTodoFile(absoluteTodoPath);
                 // Calculate progress metrics
                 const totalTasks = structure.summary.total;
                 const completionRate = totalTasks > 0 ? (structure.summary.completed / totalTasks) * 100 : 0;
@@ -458,6 +845,396 @@ ${completionRate > 80 ? '- 🎉 Great progress! Consider adding new tasks' : ''}
                         }]
                 };
             }
+            case 'delete_task': {
+                const structure = await parseTodoFile(absoluteTodoPath);
+                // Find tasks to delete
+                const tasksToDelete = validatedArgs.taskIds.map(id => findTaskById(structure, id)).filter(Boolean);
+                if (tasksToDelete.length === 0) {
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: `# ❌ No Tasks Found\n\nNone of the specified task IDs were found:\n${validatedArgs.taskIds.map(id => `- ${id}`).join('\n')}\n\nUse \`search_tasks\` to find available task IDs.`
+                            }]
+                    };
+                }
+                if (tasksToDelete.length !== validatedArgs.taskIds.length) {
+                    const foundIds = tasksToDelete.map(t => t.task.id);
+                    const missingIds = validatedArgs.taskIds.filter(id => !foundIds.includes(id));
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: `# ⚠️ Some Tasks Not Found\n\n**Found tasks:**\n${foundIds.map(id => `- ${id}`).join('\n')}\n\n**Missing tasks:**\n${missingIds.map(id => `- ${id}`).join('\n')}\n\nPlease verify task IDs and try again.`
+                            }]
+                    };
+                }
+                // Interactive confirmation unless force is true
+                if (!validatedArgs.force) {
+                    const hasNotes = tasksToDelete.some(t => t.task.notes);
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: generateInteractiveConfirmation('delete_task', {
+                                    tasks: tasksToDelete.map(t => t.task),
+                                    hasNotes
+                                })
+                            }]
+                    };
+                }
+                // Perform deletion
+                const updatedStructure = { ...structure };
+                let deletedCount = 0;
+                for (const section of updatedStructure.sections) {
+                    const initialLength = section.tasks.length;
+                    section.tasks = section.tasks.filter(task => !validatedArgs.taskIds.includes(task.id));
+                    deletedCount += initialLength - section.tasks.length;
+                }
+                // Update summary counts
+                for (const { task } of tasksToDelete) {
+                    updatedStructure.summary.total--;
+                    updatedStructure.summary[task.status]--;
+                }
+                updatedStructure.lastUpdated = new Date().toISOString();
+                // Write updated structure
+                const markdown = await formatTodoAsMarkdown(updatedStructure, projectPath);
+                await writeFile(absoluteTodoPath, markdown, 'utf-8');
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `# ✅ Tasks Deleted Successfully
+
+## Deleted ${deletedCount} Tasks:
+${tasksToDelete.map(({ task, sectionName }) => `- **${task.title}** from "${sectionName}" section`).join('\n')}
+
+## Updated Progress:
+- Total Tasks: ${updatedStructure.summary.total}
+- Completed: ${updatedStructure.summary.completed}
+- In Progress: ${updatedStructure.summary.inProgress}
+- Pending: ${updatedStructure.summary.pending}
+
+Updated TODO file: \`${absoluteTodoPath}\``
+                        }]
+                };
+            }
+            case 'edit_task': {
+                const structure = await parseTodoFile(absoluteTodoPath);
+                const taskResult = findTaskById(structure, validatedArgs.taskId);
+                if (!taskResult) {
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: `# ❌ Task Not Found\n\nTask ID "${validatedArgs.taskId}" was not found.\n\nUse \`search_tasks\` to find available task IDs.`
+                            }]
+                    };
+                }
+                const { task: currentTask } = taskResult;
+                // Interactive confirmation if enabled
+                if (validatedArgs.interactive && validatedArgs.confirmChanges) {
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: generateInteractiveConfirmation('edit_task', {
+                                    current: currentTask,
+                                    changes: validatedArgs.updates
+                                })
+                            }]
+                    };
+                }
+                // Apply updates
+                const updatedStructure = { ...structure };
+                for (const section of updatedStructure.sections) {
+                    const taskIndex = section.tasks.findIndex(t => t.id === validatedArgs.taskId);
+                    if (taskIndex >= 0) {
+                        const updatedTask = { ...section.tasks[taskIndex] };
+                        // Apply each update
+                        Object.entries(validatedArgs.updates).forEach(([key, value]) => {
+                            if (value !== undefined) {
+                                updatedTask[key] = value;
+                            }
+                        });
+                        updatedTask.updatedAt = new Date().toISOString();
+                        section.tasks[taskIndex] = updatedTask;
+                        break;
+                    }
+                }
+                updatedStructure.lastUpdated = new Date().toISOString();
+                // Write updated structure
+                const markdown = await formatTodoAsMarkdown(updatedStructure, projectPath);
+                await writeFile(absoluteTodoPath, markdown, 'utf-8');
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `# ✅ Task Updated Successfully
+
+## Updated Task: "${currentTask.title}"
+
+## Changes Applied:
+${Object.entries(validatedArgs.updates).filter(([, value]) => value !== undefined).map(([key, value]) => `- **${key}**: "${currentTask[key] || 'none'}" → "${value}"`).join('\n')}
+
+Updated TODO file: \`${absoluteTodoPath}\``
+                        }]
+                };
+            }
+            case 'move_task': {
+                const structure = await parseTodoFile(absoluteTodoPath);
+                const taskResult = findTaskById(structure, validatedArgs.taskId);
+                if (!taskResult) {
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: `# ❌ Task Not Found\n\nTask ID "${validatedArgs.taskId}" was not found.\n\nUse \`search_tasks\` to find available task IDs.`
+                            }]
+                    };
+                }
+                const { task, sectionName: currentSection } = taskResult;
+                const availableSections = structure.sections.map(s => s.name);
+                // Interactive section selection if needed
+                if (validatedArgs.interactive && !validatedArgs.targetSection) {
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: `# 🔄 Select Target Section
+
+## Task to Move:
+**${task.title}** (currently in "${currentSection}")
+
+## Available Sections:
+${availableSections.map((section, index) => `${index + 1}. ${section}`).join('\n')}
+
+**To proceed**, call the operation again with \`targetSection\` parameter set to your chosen section name.
+
+**To skip interactive mode**, set \`interactive: false\`.`
+                            }]
+                    };
+                }
+                const targetSection = validatedArgs.targetSection || 'General Tasks';
+                const sectionExists = availableSections.includes(targetSection);
+                // Interactive confirmation if enabled
+                if (validatedArgs.interactive) {
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: generateInteractiveConfirmation('move_task', {
+                                    task,
+                                    currentSection,
+                                    targetSection,
+                                    position: validatedArgs.position,
+                                    sectionExists,
+                                    availableSections
+                                })
+                            }]
+                    };
+                }
+                // Perform the move
+                const updatedStructure = { ...structure };
+                // Remove from current section
+                for (const section of updatedStructure.sections) {
+                    if (section.name === currentSection) {
+                        section.tasks = section.tasks.filter(t => t.id !== validatedArgs.taskId);
+                        break;
+                    }
+                }
+                // Add to target section
+                let targetSectionObj = updatedStructure.sections.find(s => s.name === targetSection);
+                if (!targetSectionObj) {
+                    if (validatedArgs.createSection) {
+                        targetSectionObj = { name: targetSection, tasks: [] };
+                        updatedStructure.sections.push(targetSectionObj);
+                    }
+                    else {
+                        return {
+                            content: [{
+                                    type: 'text',
+                                    text: `# ❌ Target Section Not Found\n\nSection "${targetSection}" does not exist.\n\n**Options:**\n- Choose an existing section\n- Set \`createSection: true\` to create the section\n\nAvailable sections:\n${availableSections.map(s => `- ${s}`).join('\n')}`
+                                }]
+                        };
+                    }
+                }
+                // Insert at specified position or at the end
+                if (validatedArgs.position !== undefined && validatedArgs.position >= 0) {
+                    targetSectionObj.tasks.splice(validatedArgs.position, 0, task);
+                }
+                else {
+                    targetSectionObj.tasks.push(task);
+                }
+                updatedStructure.lastUpdated = new Date().toISOString();
+                // Write updated structure
+                const markdown = await formatTodoAsMarkdown(updatedStructure, projectPath);
+                await writeFile(absoluteTodoPath, markdown, 'utf-8');
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `# ✅ Task Moved Successfully
+
+## Task: "${task.title}"
+- **From**: "${currentSection}"
+- **To**: "${targetSection}"${validatedArgs.position !== undefined ? `\n- **Position**: ${validatedArgs.position}` : ''}
+
+${!sectionExists ? '\n🆕 **Target section was created**' : ''}
+
+Updated TODO file: \`${absoluteTodoPath}\``
+                        }]
+                };
+            }
+            case 'manage_section': {
+                const structure = await parseTodoFile(absoluteTodoPath);
+                const sectionExists = structure.sections.some(s => s.name === validatedArgs.sectionName);
+                const availableSections = structure.sections.map(s => s.name);
+                if (validatedArgs.action === 'create') {
+                    if (sectionExists) {
+                        return {
+                            content: [{
+                                    type: 'text',
+                                    text: `# ❌ Section Already Exists\n\nSection "${validatedArgs.sectionName}" already exists.\n\nExisting sections:\n${availableSections.map(s => `- ${s}`).join('\n')}`
+                                }]
+                        };
+                    }
+                    // Create new section
+                    const updatedStructure = { ...structure };
+                    updatedStructure.sections.push({ name: validatedArgs.sectionName, tasks: [] });
+                    updatedStructure.lastUpdated = new Date().toISOString();
+                    const markdown = await formatTodoAsMarkdown(updatedStructure, projectPath);
+                    await writeFile(absoluteTodoPath, markdown, 'utf-8');
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: `# ✅ Section Created Successfully\n\n**New section**: "${validatedArgs.sectionName}"\n\nUpdated TODO file: \`${absoluteTodoPath}\``
+                            }]
+                    };
+                }
+                if (!sectionExists) {
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: `# ❌ Section Not Found\n\nSection "${validatedArgs.sectionName}" does not exist.\n\nAvailable sections:\n${availableSections.map(s => `- ${s}`).join('\n')}`
+                            }]
+                    };
+                }
+                const targetSection = structure.sections.find(s => s.name === validatedArgs.sectionName);
+                // Interactive confirmation unless force is true
+                if (!validatedArgs.force) {
+                    const details = {
+                        action: validatedArgs.action,
+                        sectionName: validatedArgs.sectionName,
+                        availableSections
+                    };
+                    if (validatedArgs.action === 'delete') {
+                        details.taskCount = targetSection.tasks.length;
+                        details.preserveTasks = validatedArgs.preserveTasks;
+                        details.targetSection = availableSections.find(s => s !== validatedArgs.sectionName) || 'General Tasks';
+                    }
+                    if (validatedArgs.action === 'rename') {
+                        details.newName = validatedArgs.newName;
+                    }
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: generateInteractiveConfirmation('manage_section', details)
+                            }]
+                    };
+                }
+                // Perform the action
+                const updatedStructure = { ...structure };
+                if (validatedArgs.action === 'delete') {
+                    const sectionIndex = updatedStructure.sections.findIndex(s => s.name === validatedArgs.sectionName);
+                    const tasksToMove = targetSection.tasks;
+                    if (validatedArgs.preserveTasks && tasksToMove.length > 0) {
+                        // Move tasks to another section
+                        const fallbackSectionName = availableSections.find(s => s !== validatedArgs.sectionName) || 'General Tasks';
+                        let fallbackSection = updatedStructure.sections.find(s => s.name === fallbackSectionName);
+                        if (!fallbackSection && fallbackSectionName === 'General Tasks') {
+                            fallbackSection = { name: 'General Tasks', tasks: [] };
+                            updatedStructure.sections.unshift(fallbackSection);
+                        }
+                        if (fallbackSection) {
+                            fallbackSection.tasks.push(...tasksToMove);
+                        }
+                    }
+                    else {
+                        // Update summary counts for deleted tasks
+                        for (const task of tasksToMove) {
+                            updatedStructure.summary.total--;
+                            updatedStructure.summary[task.status]--;
+                        }
+                    }
+                    updatedStructure.sections.splice(sectionIndex, 1);
+                }
+                if (validatedArgs.action === 'rename') {
+                    const section = updatedStructure.sections.find(s => s.name === validatedArgs.sectionName);
+                    section.name = validatedArgs.newName;
+                }
+                updatedStructure.lastUpdated = new Date().toISOString();
+                const markdown = await formatTodoAsMarkdown(updatedStructure, projectPath);
+                await writeFile(absoluteTodoPath, markdown, 'utf-8');
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `# ✅ Section ${validatedArgs.action.charAt(0).toUpperCase() + validatedArgs.action.slice(1)} Successful
+
+${validatedArgs.action === 'delete' ? `
+## Deleted Section: "${validatedArgs.sectionName}"
+- **Tasks**: ${targetSection.tasks.length}
+- **Preserved**: ${validatedArgs.preserveTasks}
+${validatedArgs.preserveTasks && targetSection.tasks.length > 0 ? `- **Moved to**: "${availableSections.find(s => s !== validatedArgs.sectionName) || 'General Tasks'}"` : ''}
+` : ''}
+
+${validatedArgs.action === 'rename' ? `
+## Renamed Section:
+- **From**: "${validatedArgs.sectionName}"
+- **To**: "${validatedArgs.newName}"
+` : ''}
+
+Updated TODO file: \`${absoluteTodoPath}\``
+                        }]
+                };
+            }
+            case 'search_tasks': {
+                const structure = await parseTodoFile(absoluteTodoPath);
+                const results = searchTasks(structure, validatedArgs.query, validatedArgs.filters);
+                if (results.length === 0) {
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: `# 🔍 No Tasks Found
+
+**Search criteria:**
+${validatedArgs.query ? `- **Query**: "${validatedArgs.query}"` : ''}
+${validatedArgs.filters ? Object.entries(validatedArgs.filters).filter(([, value]) => value !== undefined).map(([key, value]) => `- **${key}**: ${value}`).join('\n') : ''}
+
+**Total tasks in TODO.md**: ${structure.summary.total}
+
+Try adjusting your search criteria or use \`analyze_progress\` to see all tasks.`
+                            }]
+                    };
+                }
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `# 🔍 Search Results
+
+Found **${results.length}** tasks:
+
+${results.map(({ task, sectionName }) => {
+                                let taskLine = `## ${task.title}`;
+                                if (validatedArgs.includeMetadata) {
+                                    taskLine += `\n- **ID**: \`${task.id}\`\n- **Section**: ${sectionName}\n- **Status**: ${task.status}`;
+                                    if (task.priority)
+                                        taskLine += `\n- **Priority**: ${task.priority}`;
+                                    if (task.assignee)
+                                        taskLine += `\n- **Assignee**: ${task.assignee}`;
+                                    if (task.category)
+                                        taskLine += `\n- **Category**: ${task.category}`;
+                                    if (task.notes)
+                                        taskLine += `\n- **Notes**: ${task.notes}`;
+                                    if (task.dependencies?.length)
+                                        taskLine += `\n- **Dependencies**: ${task.dependencies.join(', ')}`;
+                                }
+                                return taskLine;
+                            }).join('\n\n')}
+
+**Search completed on**: \`${absoluteTodoPath}\``
+                        }]
+                };
+            }
             default:
                 throw new McpAdrError(`Unknown operation: ${validatedArgs.operation}`, 'INVALID_INPUT');
         }