import { TaskNode, TASK_ID_PATTERN } from '../types.js'; import { VisualFormatter } from './visual-formatter.js'; export class TaskParser { /** * Parse markdown task list into hierarchical TaskNode array */ static parseMarkdownTasks(markdown: string): TaskNode[] { const lines = markdown.split('\n'); const tasks: TaskNode[] = []; const stack: TaskNode[][] = [tasks]; // Stack for nested levels for (let i = 0; i < lines.length; i++) { const line = lines[i]; const trimmed = line.trim(); // Skip empty lines and non-task lines if (!trimmed || !trimmed.startsWith('- [') || trimmed.length < 7) { continue; } // Extract task info const checkboxMatch = trimmed.match(/- \[([ x])\]\s*(.+)/); if (!checkboxMatch) continue; const [, status, description] = checkboxMatch; // Determine task level by counting leading tabs const leadingTabs = (line.match(/^\t*/) || [''])[0].length; const level = leadingTabs + 1; // level 1 = 0 tabs, level 2 = 1 tab, etc. // Extract task ID from description (e.g., "1.0.0 Setup project") const idMatch = description.match(/^(\d+(?:\.\d+)*)\s+(.+)/); if (!idMatch) continue; const [, taskId, taskDesc] = idMatch; // Validate task ID format if (!TASK_ID_PATTERN.test(taskId)) continue; // Check if next line is a description (indented with 1 more tab) let fullDescription = taskDesc; if (i + 1 < lines.length) { const nextLine = lines[i + 1]; const nextTrimmed = nextLine.trim(); const nextLeadingTabs = (nextLine.match(/^\t*/) || [''])[0].length; if (nextTrimmed.startsWith('- ') && nextLeadingTabs === leadingTabs + 1) { // Next line is a description fullDescription = nextTrimmed.substring(1).trim(); i++; // Skip the description line } } const taskNode: TaskNode = { id: taskId, description: fullDescription, status: status === 'x' ? 'completed' : 'pending', children: [], level, createdAt: new Date().toISOString(), updatedAt: new Date().toISOString() }; // Set parent ID based on level if (level > 0) { const parentLevel = level - 1; if (stack[parentLevel] && stack[parentLevel].length > 0) { const parent = stack[parentLevel][stack[parentLevel].length - 1]; taskNode.parentId = parent.id; parent.children.push(taskNode); } } // Ensure stack has enough levels while (stack.length <= level) { stack.push([]); } // Add to current level stack[level].push(taskNode); // If this is a root task (level 0), add to main tasks array if (level === 0) { tasks.push(taskNode); } } return tasks; } /** * Convert TaskNode array to markdown format with visual tree structure */ static toMarkdown(tasks: TaskNode[]): string { let markdown = '# Tasks\n\n'; // Create visual header markdown += VisualFormatter.createBoxHeader('TAREFAS PRINCIPAIS', '📋') + '\n\n'; // Sort tasks by ID to ensure proper order const sortedTasks = tasks.sort((a, b) => this.compareTaskIds(a.id, b.id)); // Create simple hierarchical structure let result = ''; // Group by main tasks (1.0.0, 2.0.0, etc.) const mainTasks = sortedTasks.filter(task => { const parts = task.id.split('.'); return parts.length === 3 && parts[1] === '0' && parts[2] === '0'; }); for (let i = 0; i < mainTasks.length; i++) { const mainTask = mainTasks[i]; const isLastMain = i === mainTasks.length - 1; const mainPrefix = isLastMain ? '└─ ' : '├─ '; const checkbox = mainTask.status === 'completed' ? '[x]' : '[ ]'; const statusEmoji = this.getStatusEmoji(mainTask.status); result += `${mainPrefix}${checkbox} ${mainTask.id} ${mainTask.description} ${statusEmoji}\n`; // Find subtasks for this main task const mainId = mainTask.id.split('.')[0]; const subtasks = sortedTasks.filter(task => { const parts = task.id.split('.'); return parts.length === 3 && parts[0] === mainId && parts[1] !== '0' && parts[2] === '0'; }); for (let j = 0; j < subtasks.length; j++) { const subtask = subtasks[j]; const isLastSub = j === subtasks.length - 1; const subPrefix = isLastMain ? ' ' : '│ '; const subTreePrefix = isLastSub ? '└─ ' : '├─ '; const subCheckbox = subtask.status === 'completed' ? '[x]' : '[ ]'; const subStatusEmoji = this.getStatusEmoji(subtask.status); result += `${subPrefix}${subTreePrefix}${subCheckbox} ${subtask.id} ${subtask.description} ${subStatusEmoji}\n`; // Find sub-subtasks for this subtask const subId = subtask.id.split('.')[1]; const subSubtasks = sortedTasks.filter(task => { const parts = task.id.split('.'); return parts.length === 3 && parts[0] === mainId && parts[1] === subId && parts[2] !== '0'; }); for (let k = 0; k < subSubtasks.length; k++) { const subSubtask = subSubtasks[k]; const isLastSubSub = k === subSubtasks.length - 1; const subSubPrefix = isLastMain ? ' ' : '│ '; const subSubTreePrefix = isLastSub ? ' ' : '│ '; const subSubCheckbox = subSubtask.status === 'completed' ? '[x]' : '[ ]'; const subSubStatusEmoji = this.getStatusEmoji(subSubtask.status); result += `${subSubPrefix}${subSubTreePrefix}${isLastSub ? ' ' : '│ '}${isLastSubSub ? '└─ ' : '├─ '}${subSubCheckbox} ${subSubtask.id} ${subSubtask.description} ${subSubStatusEmoji}\n`; } } if (!isLastMain) { result += '│\n'; } } return markdown + result; } /** * Get status emoji based on status */ private static getStatusEmoji(status?: string): string { switch (status) { case 'completed': return '✅'; case 'in-progress': return '🔄'; case 'pending': return '⏳'; default: return '📋'; } } /** * Create hierarchical structure based on task IDs */ private static createHierarchicalStructure(tasks: TaskNode[]): Array<{ id: string; title: string; description?: string; status?: string; children?: Array; }> { const result: Array<{ id: string; title: string; description?: string; status?: string; children?: Array; }> = []; // Group tasks by main level (1.0.0, 2.0.0, etc.) const mainTasks = tasks.filter(task => { const parts = task.id.split('.'); return parts.length === 3 && parts[2] === '0' && parts[1] === '0'; }); for (const mainTask of mainTasks) { const mainTaskItem = { id: mainTask.id, title: mainTask.description, description: mainTask.description, status: mainTask.status, children: [] as Array }; // Find subtasks for this main task (1.1.0, 1.2.0, etc.) const mainId = mainTask.id.split('.')[0]; const subtasks = tasks.filter(task => { const parts = task.id.split('.'); return parts.length === 3 && parts[0] === mainId && parts[1] !== '0' && parts[2] === '0'; }); for (const subtask of subtasks) { const subtaskItem = { id: subtask.id, title: subtask.description, description: subtask.description, status: subtask.status, children: [] as Array }; // Find sub-subtasks for this subtask (1.1.1, 1.1.2, etc.) const subId = subtask.id.split('.')[1]; const subSubtasks = tasks.filter(task => { const parts = task.id.split('.'); return parts.length === 3 && parts[0] === mainId && parts[1] === subId && parts[2] !== '0'; }); for (const subSubtask of subSubtasks) { subtaskItem.children.push({ id: subSubtask.id, title: subSubtask.description, description: subSubtask.description, status: subSubtask.status, children: undefined }); } mainTaskItem.children.push(subtaskItem); } result.push(mainTaskItem); } return result; } /** * Flatten hierarchical tasks into a flat array maintaining order */ private static flattenTasks(tasks: TaskNode[]): TaskNode[] { const result: TaskNode[] = []; const flatten = (taskList: TaskNode[]) => { for (const task of taskList) { result.push(task); if (task.children && task.children.length > 0) { flatten(task.children); } } }; flatten(tasks); return result; } /** * Compare task IDs for sorting (1.0.0, 1.1.0, 1.1.1, 1.2.0, 2.0.0, etc.) */ private static compareTaskIds(a: string, b: string): number { const aParts = a.split('.').map(Number); const bParts = b.split('.').map(Number); for (let i = 0; i < Math.max(aParts.length, bParts.length); i++) { const aPart = aParts[i] || 0; const bPart = bParts[i] || 0; if (aPart !== bPart) { return aPart - bPart; } } return 0; } /** * Get the hierarchy level of a task ID * 1.0.0 = level 1 (main task) * 1.1.0 = level 2 (subtask) * 1.1.1 = level 3 (sub-subtask) */ private static getTaskLevel(taskId: string): number { return taskId.split('.').length; } /** * Generate next task ID based on parent */ static generateNextTaskId(parentId?: string): string { if (!parentId) { // Generate next root task (1.0.0, 2.0.0, 3.0.0, etc.) return '1.0.0'; // Semantic versioning style } else { // Generate next subtask (1.1.0, 1.2.0, 2.1.0, etc.) const parts = parentId.split('.'); if (parts.length === 3) { // If parent is x.y.z, increment y return `${parts[0]}.${parseInt(parts[1]) + 1}.0`; } else { // If parent is x.y, make it x.y.1 return `${parentId}.1`; } } } /** * Validate task hierarchy */ static validateHierarchy(tasks: TaskNode[]): { valid: boolean; errors: string[] } { const errors: string[] = []; const validateTask = (task: TaskNode, seenIds: Set) => { // Check for duplicate IDs if (seenIds.has(task.id)) { errors.push(`Duplicate task ID: ${task.id}`); } seenIds.add(task.id); // Check ID format if (!TASK_ID_PATTERN.test(task.id + '.')) { errors.push(`Invalid task ID format: ${task.id}`); } // Check parent-child relationships if (task.parentId) { const parentParts = task.parentId.split('.'); const childParts = task.id.split('.'); if (childParts.length !== parentParts.length + 1) { errors.push(`Invalid parent-child relationship: ${task.parentId} -> ${task.id}`); } // Check if parent ID matches for (let i = 0; i < parentParts.length; i++) { if (parentParts[i] !== childParts[i]) { errors.push(`Parent ID mismatch: ${task.parentId} -> ${task.id}`); break; } } } // Validate children for (const child of task.children) { validateTask(child, seenIds); } }; const seenIds = new Set(); for (const task of tasks) { validateTask(task, seenIds); } return { valid: errors.length === 0, errors }; } }