@md2do/core 0.2.2 → 0.3.0

package/src/parser/index.ts

@@ -126,9 +126,14 @@ export function extractDueDate(
       return {
         date: undefined,
         warning: {
+          severity: 'warning',
+          source: 'md2do',
+          ruleId: 'relative-date-no-context',
           file: '', // Will be filled in by caller
           line: 0, // Will be filled in by caller
           text: text.trim(),
+          message:
+            'Relative due date without context date from heading. Add a heading with a date above this task.',
           reason:
             'Relative due date without context date from heading. Add a heading with a date above this task.',
         },
@@ -208,6 +213,71 @@ export function parseTask(
 ): { task: Task | null; warnings: Warning[] } {
   const warnings: Warning[] = [];
 
+  // Detect malformed checkboxes and provide helpful warnings
+  // Check for asterisk/plus bullet markers (not supported)
+  if (/^\s*[*+]\s+\[[ xX]\]/.test(line)) {
+    warnings.push({
+      severity: 'warning',
+      source: 'md2do',
+      ruleId: 'unsupported-bullet',
+      file,
+      line: lineNumber,
+      text: line.trim(),
+      message:
+        'Unsupported bullet marker (* or +). Use dash (-) for task lists.',
+      reason:
+        'Unsupported bullet marker (* or +). Use dash (-) for task lists.',
+    });
+    return { task: null, warnings };
+  }
+
+  // Check for extra spaces inside checkbox: [x ] or [ x]
+  if (/^\s*-\s+\[[xX]\s+\]/.test(line) || /^\s*-\s+\[\s+[xX]\]/.test(line)) {
+    warnings.push({
+      severity: 'warning',
+      source: 'md2do',
+      ruleId: 'malformed-checkbox',
+      file,
+      line: lineNumber,
+      text: line.trim(),
+      message:
+        'Malformed checkbox with extra spaces. Use [x] or [ ] without extra spaces.',
+      reason:
+        'Malformed checkbox with extra spaces. Use [x] or [ ] without extra spaces.',
+    });
+    return { task: null, warnings };
+  }
+
+  // Check for missing space after checkbox: [x]Task
+  if (/^\s*-\s+\[[ xX]\][^\s]/.test(line)) {
+    warnings.push({
+      severity: 'warning',
+      source: 'md2do',
+      ruleId: 'missing-space-after',
+      file,
+      line: lineNumber,
+      text: line.trim(),
+      message: 'Missing space after checkbox. Use "- [x] Task" format.',
+      reason: 'Missing space after checkbox. Use "- [x] Task" format.',
+    });
+    return { task: null, warnings };
+  }
+
+  // Check for missing space before checkbox: -[x]
+  if (/^\s*-\[[ xX]\]/.test(line)) {
+    warnings.push({
+      severity: 'warning',
+      source: 'md2do',
+      ruleId: 'missing-space-before',
+      file,
+      line: lineNumber,
+      text: line.trim(),
+      message: 'Missing space before checkbox. Use "- [x] Task" format.',
+      reason: 'Missing space before checkbox. Use "- [x] Task" format.',
+    });
+    return { task: null, warnings };
+  }
+
   // Check if line is a task
   const taskMatch = line.match(PATTERNS.TASK_CHECKBOX);
   if (!taskMatch?.[0] || !taskMatch[2]) {
@@ -237,6 +307,39 @@ export function parseTask(
     });
   }
 
+  // Warn about missing dates
+  // Incomplete tasks without any date (no explicit due date and no context date)
+  if (!completed && !dueDateResult.date && !context.currentDate) {
+    warnings.push({
+      severity: 'info',
+      source: 'md2do',
+      ruleId: 'missing-due-date',
+      file,
+      line: lineNumber,
+      text: fullText.trim(),
+      message:
+        'Task has no due date. Add [due: YYYY-MM-DD] or place under a heading with a date.',
+      reason:
+        'Task has no due date. Add [due: YYYY-MM-DD] or place under a heading with a date.',
+    });
+  }
+
+  // Completed tasks should have completion dates
+  if (completed && !completedDate) {
+    warnings.push({
+      severity: 'info',
+      source: 'md2do',
+      ruleId: 'missing-completed-date',
+      file,
+      line: lineNumber,
+      text: fullText.trim(),
+      message:
+        'Completed task missing completion date. Add [completed: YYYY-MM-DD].',
+      reason:
+        'Completed task missing completion date. Add [completed: YYYY-MM-DD].',
+    });
+  }
+
   // Clean text (remove metadata markers)
   const cleanText = cleanTaskText(fullText);
 

package/src/scanner/index.ts

@@ -74,6 +74,9 @@ export class MarkdownScanner {
     const tasks: Task[] = [];
     const warnings: Warning[] = [];
 
+    // Track Todoist IDs to detect duplicates
+    const todoistIds = new Map<string, { file: string; line: number }>();
+
     // Initialize context from file path
     const context: ParsingContext = {};
 
@@ -105,6 +108,28 @@ export class MarkdownScanner {
 
       if (result.task) {
         tasks.push(result.task);
+
+        // Check for duplicate Todoist IDs
+        if (result.task.todoistId) {
+          const existing = todoistIds.get(result.task.todoistId);
+          if (existing) {
+            warnings.push({
+              severity: 'error',
+              source: 'md2do',
+              ruleId: 'duplicate-todoist-id',
+              file: filePath,
+              line: lineNumber,
+              text: result.task.text,
+              message: `Duplicate Todoist ID [todoist:${result.task.todoistId}]. Also found at ${existing.file}:${existing.line}.`,
+              reason: `Duplicate Todoist ID [todoist:${result.task.todoistId}]. Also found at ${existing.file}:${existing.line}.`,
+            });
+          } else {
+            todoistIds.set(result.task.todoistId, {
+              file: filePath,
+              line: lineNumber,
+            });
+          }
+        }
       }
 
       if (result.warnings.length > 0) {
@@ -131,10 +156,39 @@ export class MarkdownScanner {
     const allTasks: Task[] = [];
     const allWarnings: Warning[] = [];
 
+    // Track Todoist IDs across all files
+    const todoistIds = new Map<string, { file: string; line: number }>();
+
     for (const file of files) {
       const result = this.scanFile(file.path, file.content);
       allTasks.push(...result.tasks);
       allWarnings.push(...result.warnings);
+
+      // Check for duplicate Todoist IDs across files
+      for (const task of result.tasks) {
+        if (task.todoistId) {
+          const existing = todoistIds.get(task.todoistId);
+          if (existing && existing.file !== task.file) {
+            // Only add warning if duplicate is in a different file
+            // (same-file duplicates are already caught by scanFile)
+            allWarnings.push({
+              severity: 'error',
+              source: 'md2do',
+              ruleId: 'duplicate-todoist-id',
+              file: task.file,
+              line: task.line,
+              text: task.text,
+              message: `Duplicate Todoist ID [todoist:${task.todoistId}] across files. Also found at ${existing.file}:${existing.line}.`,
+              reason: `Duplicate Todoist ID [todoist:${task.todoistId}] across files. Also found at ${existing.file}:${existing.line}.`,
+            });
+          } else if (!existing) {
+            todoistIds.set(task.todoistId, {
+              file: task.file,
+              line: task.line,
+            });
+          }
+        }
+      }
     }
 
     return {

package/src/types/index.ts

@@ -65,9 +65,38 @@ export interface ScanResult {
   };
 }
 
+export type WarningSeverity = 'info' | 'warning' | 'error';
+
+export type WarningCode =
+  | 'unsupported-bullet' // * or + instead of -
+  | 'malformed-checkbox' // [x ] or [ x]
+  | 'missing-space-after' // -[x]Task
+  | 'missing-space-before' // -[x] Task
+  | 'relative-date-no-context' // [due: tomorrow] without heading date
+  | 'missing-due-date' // Incomplete task with no due date
+  | 'missing-completed-date' // [x] without [completed: date]
+  | 'duplicate-todoist-id' // Same Todoist ID in multiple tasks
+  | 'file-read-error'; // Failed to read file
+
 export interface Warning {
+  // Position
   file: string;
   line: number;
-  text: string;
-  reason: string;
+  column?: number;
+
+  // Classification
+  severity: WarningSeverity;
+  source: 'md2do';
+  ruleId: WarningCode;
+
+  // Content
+  message: string; // User-facing message
+  text?: string; // The actual text that triggered it
+
+  // Documentation (optional - for future use)
+  url?: string;
+
+  // Legacy field for backward compatibility (deprecated)
+  /** @deprecated Use message instead */
+  reason?: string;
 }

package/src/warnings/filter.ts

@@ -0,0 +1,93 @@
+import type { Warning } from '../types/index.js';
+
+export interface WarningFilterConfig {
+  enabled?: boolean | undefined;
+  rules?: Record<string, 'error' | 'warn' | 'info' | 'off'> | undefined;
+}
+
+/**
+ * Filter warnings based on configuration rules
+ *
+ * This function applies warning configuration rules to filter out disabled warnings
+ * and optionally all warnings if globally disabled.
+ *
+ * @param warnings - Array of warnings to filter
+ * @param config - Warning configuration with enabled flag and rule overrides
+ * @returns Filtered array of warnings
+ *
+ * @example
+ * ```typescript
+ * const config = {
+ *   enabled: true,
+ *   rules: {
+ *     'missing-due-date': 'off',
+ *     'duplicate-todoist-id': 'error',
+ *   },
+ * };
+ *
+ * const filtered = filterWarnings(allWarnings, config);
+ * // Returns warnings except those with ruleId 'missing-due-date'
+ * ```
+ */
+export function filterWarnings(
+  warnings: Warning[],
+  config: WarningFilterConfig = {},
+): Warning[] {
+  // If warnings are globally disabled, return empty array
+  if (config.enabled === false) {
+    return [];
+  }
+
+  // If no rules specified, return all warnings
+  if (!config.rules) {
+    return warnings;
+  }
+
+  // Filter based on rule configuration
+  return warnings.filter((warning) => {
+    const level = config.rules?.[warning.ruleId];
+
+    // If rule is not configured, include the warning (default: show)
+    if (level === undefined) {
+      return true;
+    }
+
+    // Exclude if rule is set to 'off'
+    return level !== 'off';
+  });
+}
+
+/**
+ * Group warnings by severity
+ *
+ * Useful for displaying warnings in order of importance or
+ * treating errors differently from warnings.
+ *
+ * @param warnings - Array of warnings to group
+ * @returns Object with warnings grouped by severity level
+ *
+ * @example
+ * ```typescript
+ * const grouped = groupWarningsBySeverity(warnings);
+ * console.log(`${grouped.error.length} errors`);
+ * console.log(`${grouped.warning.length} warnings`);
+ * console.log(`${grouped.info.length} info messages`);
+ * ```
+ */
+export function groupWarningsBySeverity(warnings: Warning[]): {
+  error: Warning[];
+  warning: Warning[];
+  info: Warning[];
+} {
+  return warnings.reduce(
+    (acc, warning) => {
+      acc[warning.severity].push(warning);
+      return acc;
+    },
+    { error: [], warning: [], info: [] } as {
+      error: Warning[];
+      warning: Warning[];
+      info: Warning[];
+    },
+  );
+}

package/tests/parser/index.test.ts

@@ -419,7 +419,7 @@ describe('parseTask', () => {
       const result = parseTask('- [ ] Task [due: tomorrow]', 1, file, {});
 
       expect(result.task?.dueDate).toBeUndefined();
-      expect(result.warnings).toHaveLength(1);
+      expect(result.warnings).toHaveLength(2); // Relative date + missing date warnings
       expect(result.warnings[0]?.reason).toContain(
         'Relative due date without context',
       );
@@ -535,4 +535,110 @@ describe('parseTask', () => {
       expect(result.task?.completedDate).toBeInstanceOf(Date);
     });
   });
+
+  describe('Malformed checkbox warnings', () => {
+    it('should warn on asterisk bullet marker', () => {
+      const result = parseTask('* [x] Task with asterisk', 1, file, {});
+      expect(result.task).toBeNull();
+      expect(result.warnings).toHaveLength(1);
+      expect(result.warnings[0]?.reason).toContain(
+        'Unsupported bullet marker (* or +)',
+      );
+      expect(result.warnings[0]?.file).toBe(file);
+      expect(result.warnings[0]?.line).toBe(1);
+    });
+
+    it('should warn on plus bullet marker', () => {
+      const result = parseTask('+ [ ] Task with plus', 1, file, {});
+      expect(result.task).toBeNull();
+      expect(result.warnings).toHaveLength(1);
+      expect(result.warnings[0]?.reason).toContain(
+        'Unsupported bullet marker (* or +)',
+      );
+    });
+
+    it('should warn on extra space after x', () => {
+      const result = parseTask('- [x ] Task with extra space', 1, file, {});
+      expect(result.task).toBeNull();
+      expect(result.warnings).toHaveLength(1);
+      expect(result.warnings[0]?.reason).toContain('Malformed checkbox');
+    });
+
+    it('should warn on extra space before x', () => {
+      const result = parseTask('- [ x] Task with extra space', 1, file, {});
+      expect(result.task).toBeNull();
+      expect(result.warnings).toHaveLength(1);
+      expect(result.warnings[0]?.reason).toContain('Malformed checkbox');
+    });
+
+    it('should warn on missing space before checkbox', () => {
+      const result = parseTask('-[x] Task without space', 1, file, {});
+      expect(result.task).toBeNull();
+      expect(result.warnings).toHaveLength(1);
+      expect(result.warnings[0]?.reason).toContain(
+        'Missing space before checkbox',
+      );
+    });
+
+    it('should warn on missing space after checkbox', () => {
+      const result = parseTask('- [x]Task without space', 1, file, {});
+      expect(result.task).toBeNull();
+      expect(result.warnings).toHaveLength(1);
+      expect(result.warnings[0]?.reason).toContain(
+        'Missing space after checkbox',
+      );
+    });
+  });
+
+  describe('Missing date warnings', () => {
+    it('should warn on incomplete task without date or context', () => {
+      const result = parseTask('- [ ] Task without date', 1, file, {});
+      expect(result.task).not.toBeNull();
+      expect(result.warnings).toHaveLength(1);
+      expect(result.warnings[0]?.reason).toContain('Task has no due date');
+    });
+
+    it('should not warn on task with explicit due date', () => {
+      const result = parseTask('- [ ] Task [due: 2026-01-30]', 1, file, {});
+      expect(result.task).not.toBeNull();
+      expect(result.warnings).toHaveLength(0);
+    });
+
+    it('should not warn on task with context date', () => {
+      const context: ParsingContext = {
+        currentDate: new Date('2026-01-30'),
+      };
+      const result = parseTask('- [ ] Task with context', 1, file, context);
+      expect(result.task).not.toBeNull();
+      expect(result.warnings).toHaveLength(0);
+    });
+
+    it('should not warn on completed tasks without date', () => {
+      const result = parseTask('- [x] Completed task', 1, file, {});
+      expect(result.task).not.toBeNull();
+      // Should only warn about missing completion date, not due date
+      expect(result.warnings).toHaveLength(1);
+      expect(result.warnings[0]?.reason).toContain('completion date');
+    });
+
+    it('should warn on completed task without completion date', () => {
+      const result = parseTask('- [x] Completed task', 1, file, {});
+      expect(result.task).not.toBeNull();
+      expect(result.warnings).toHaveLength(1);
+      expect(result.warnings[0]?.reason).toContain(
+        'Completed task missing completion date',
+      );
+    });
+
+    it('should not warn on completed task with completion date', () => {
+      const result = parseTask(
+        '- [x] Task [completed: 2026-01-25]',
+        1,
+        file,
+        {},
+      );
+      expect(result.task).not.toBeNull();
+      expect(result.warnings).toHaveLength(0);
+    });
+  });
 });

package/tests/scanner/index.test.ts

@@ -65,7 +65,7 @@ describe('MarkdownScanner', () => {
 
   describe('Basic task scanning', () => {
     it('should scan simple unchecked task', () => {
-      const content = '- [ ] Simple task';
+      const content = '- [ ] Simple task [due: 2026-01-30]';
       const result = scanner.scanFile('test.md', content);
 
       expect(result.tasks).toHaveLength(1);
@@ -281,7 +281,7 @@ No tasks at all.
       const result = scanner.scanFile('test.md', content);
 
       expect(result.tasks[0]?.dueDate).toBeUndefined();
-      expect(result.warnings).toHaveLength(1);
+      expect(result.warnings).toHaveLength(2); // Relative date + missing date warnings
       expect(result.warnings[0]?.reason).toContain(
         'Relative due date without context',
       );
@@ -461,9 +461,9 @@ Line 4
 
       const result = scanner.scanFiles(files);
 
-      expect(result.warnings).toHaveLength(2);
+      expect(result.warnings).toHaveLength(4); // 2 relative date + 2 missing date warnings
       expect(result.warnings[0]?.file).toBe('file1.md');
-      expect(result.warnings[1]?.file).toBe('file2.md');
+      expect(result.warnings[2]?.file).toBe('file2.md');
     });
 
     it('should handle empty file array', () => {
@@ -558,4 +558,94 @@ Line 4
       expect(result.tasks).toHaveLength(0);
     });
   });
+
+  describe('Duplicate Todoist ID warnings', () => {
+    it('should warn on duplicate Todoist ID within same file', () => {
+      const content = `
+- [ ] First task [todoist:123456] [due: 2026-01-30]
+- [ ] Second task [todoist:123456] [due: 2026-01-31]
+`.trim();
+      const result = scanner.scanFile('test.md', content);
+
+      expect(result.tasks).toHaveLength(2);
+      expect(result.warnings).toHaveLength(1);
+      expect(result.warnings[0]?.reason).toContain('Duplicate Todoist ID');
+      expect(result.warnings[0]?.reason).toContain('123456');
+      expect(result.warnings[0]?.line).toBe(2);
+    });
+
+    it('should not warn on unique Todoist IDs', () => {
+      const content = `
+- [ ] First task [todoist:111111] [due: 2026-01-30]
+- [ ] Second task [todoist:222222] [due: 2026-01-31]
+- [ ] Third task [todoist:333333] [due: 2026-02-01]
+`.trim();
+      const result = scanner.scanFile('test.md', content);
+
+      expect(result.tasks).toHaveLength(3);
+      expect(result.warnings).toHaveLength(0);
+    });
+
+    it('should warn on multiple duplicates', () => {
+      const content = `
+- [ ] Task A [todoist:111] [due: 2026-01-30]
+- [ ] Task B [todoist:222] [due: 2026-01-31]
+- [ ] Task C [todoist:111] [due: 2026-02-01]
+- [ ] Task D [todoist:222] [due: 2026-02-02]
+- [ ] Task E [todoist:111] [due: 2026-02-03]
+`.trim();
+      const result = scanner.scanFile('test.md', content);
+
+      expect(result.tasks).toHaveLength(5);
+      // Should have 3 warnings: C duplicates A, D duplicates B, E duplicates A
+      expect(result.warnings).toHaveLength(3);
+    });
+
+    it('should track duplicates across multiple files', () => {
+      const files = [
+        {
+          path: 'file1.md',
+          content: '- [ ] Task in file 1 [todoist:123456] [due: 2026-01-30]',
+        },
+        {
+          path: 'file2.md',
+          content: '- [ ] Task in file 2 [todoist:123456] [due: 2026-01-31]',
+        },
+      ];
+
+      const result = scanner.scanFiles(files);
+
+      expect(result.tasks).toHaveLength(2);
+      expect(result.warnings).toHaveLength(1);
+      expect(result.warnings[0]?.reason).toContain('Duplicate Todoist ID');
+      expect(result.warnings[0]?.reason).toContain('across files');
+      expect(result.warnings[0]?.file).toBe('file2.md');
+    });
+
+    it('should not warn when same file scanned separately', () => {
+      const content = '- [ ] Task [todoist:123456] [due: 2026-01-30]';
+
+      // Scan same file multiple times as if they were different files
+      const result1 = scanner.scanFile('test1.md', content);
+      const result2 = scanner.scanFile('test2.md', content);
+
+      // Each scan should have no warnings (they're separate scans)
+      expect(result1.warnings).toHaveLength(0);
+      expect(result2.warnings).toHaveLength(0);
+    });
+
+    it('should include location information in warning', () => {
+      const content = `
+- [ ] First task [todoist:999] [due: 2026-01-30]
+- [ ] Second task [due: 2026-01-31]
+- [ ] Third task [todoist:999] [due: 2026-02-01]
+`.trim();
+      const result = scanner.scanFile('backlog.md', content);
+
+      expect(result.warnings).toHaveLength(1);
+      expect(result.warnings[0]?.file).toBe('backlog.md');
+      expect(result.warnings[0]?.line).toBe(3);
+      expect(result.warnings[0]?.reason).toContain('backlog.md:1');
+    });
+  });
 });