@md2do/core 0.2.2 → 0.2.3

package/dist/index.js

@@ -235,6 +235,42 @@ function cleanTaskText(text) {
 }
 function parseTask(line, lineNumber, file, context) {
   const warnings = [];
+  if (/^\s*[*+]\s+\[[ xX]\]/.test(line)) {
+    warnings.push({
+      file,
+      line: lineNumber,
+      text: line.trim(),
+      reason: "Unsupported bullet marker (* or +). Use dash (-) for task lists."
+    });
+    return { task: null, warnings };
+  }
+  if (/^\s*-\s+\[[xX]\s+\]/.test(line) || /^\s*-\s+\[\s+[xX]\]/.test(line)) {
+    warnings.push({
+      file,
+      line: lineNumber,
+      text: line.trim(),
+      reason: "Malformed checkbox with extra spaces. Use [x] or [ ] without extra spaces."
+    });
+    return { task: null, warnings };
+  }
+  if (/^\s*-\s+\[[ xX]\][^\s]/.test(line)) {
+    warnings.push({
+      file,
+      line: lineNumber,
+      text: line.trim(),
+      reason: 'Missing space after checkbox. Use "- [x] Task" format.'
+    });
+    return { task: null, warnings };
+  }
+  if (/^\s*-\[[ xX]\]/.test(line)) {
+    warnings.push({
+      file,
+      line: lineNumber,
+      text: line.trim(),
+      reason: 'Missing space before checkbox. Use "- [x] Task" format.'
+    });
+    return { task: null, warnings };
+  }
   const taskMatch = line.match(PATTERNS.TASK_CHECKBOX);
   if (!taskMatch?.[0] || !taskMatch[2]) {
     return { task: null, warnings };
@@ -254,6 +290,22 @@ function parseTask(line, lineNumber, file, context) {
       line: lineNumber
     });
   }
+  if (!completed && !dueDateResult.date && !context.currentDate) {
+    warnings.push({
+      file,
+      line: lineNumber,
+      text: fullText.trim(),
+      reason: "Task has no due date. Add [due: YYYY-MM-DD] or place under a heading with a date."
+    });
+  }
+  if (completed && !completedDate) {
+    warnings.push({
+      file,
+      line: lineNumber,
+      text: fullText.trim(),
+      reason: "Completed task missing completion date. Add [completed: YYYY-MM-DD]."
+    });
+  }
   const cleanText = cleanTaskText(fullText);
   const id = generateTaskId(file, lineNumber, cleanText);
   const task = {
@@ -299,6 +351,7 @@ var MarkdownScanner = class {
   scanFile(filePath, content) {
     const tasks = [];
     const warnings = [];
+    const todoistIds = /* @__PURE__ */ new Map();
     const context = {};
     const project = extractProjectFromPath(filePath);
     if (project !== void 0) context.project = project;
@@ -318,6 +371,22 @@ var MarkdownScanner = class {
       const result = parseTask(line, lineNumber, filePath, context);
       if (result.task) {
         tasks.push(result.task);
+        if (result.task.todoistId) {
+          const existing = todoistIds.get(result.task.todoistId);
+          if (existing) {
+            warnings.push({
+              file: filePath,
+              line: lineNumber,
+              text: result.task.text,
+              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) {
         warnings.push(...result.warnings);
@@ -337,10 +406,29 @@ var MarkdownScanner = class {
   scanFiles(files) {
     const allTasks = [];
     const allWarnings = [];
+    const todoistIds = /* @__PURE__ */ new Map();
     for (const file of files) {
       const result = this.scanFile(file.path, file.content);
       allTasks.push(...result.tasks);
       allWarnings.push(...result.warnings);
+      for (const task of result.tasks) {
+        if (task.todoistId) {
+          const existing = todoistIds.get(task.todoistId);
+          if (existing && existing.file !== task.file) {
+            allWarnings.push({
+              file: task.file,
+              line: task.line,
+              text: task.text,
+              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 {
       tasks: allTasks,

package/dist/index.mjs

@@ -178,6 +178,42 @@ function cleanTaskText(text) {
 }
 function parseTask(line, lineNumber, file, context) {
   const warnings = [];
+  if (/^\s*[*+]\s+\[[ xX]\]/.test(line)) {
+    warnings.push({
+      file,
+      line: lineNumber,
+      text: line.trim(),
+      reason: "Unsupported bullet marker (* or +). Use dash (-) for task lists."
+    });
+    return { task: null, warnings };
+  }
+  if (/^\s*-\s+\[[xX]\s+\]/.test(line) || /^\s*-\s+\[\s+[xX]\]/.test(line)) {
+    warnings.push({
+      file,
+      line: lineNumber,
+      text: line.trim(),
+      reason: "Malformed checkbox with extra spaces. Use [x] or [ ] without extra spaces."
+    });
+    return { task: null, warnings };
+  }
+  if (/^\s*-\s+\[[ xX]\][^\s]/.test(line)) {
+    warnings.push({
+      file,
+      line: lineNumber,
+      text: line.trim(),
+      reason: 'Missing space after checkbox. Use "- [x] Task" format.'
+    });
+    return { task: null, warnings };
+  }
+  if (/^\s*-\[[ xX]\]/.test(line)) {
+    warnings.push({
+      file,
+      line: lineNumber,
+      text: line.trim(),
+      reason: 'Missing space before checkbox. Use "- [x] Task" format.'
+    });
+    return { task: null, warnings };
+  }
   const taskMatch = line.match(PATTERNS.TASK_CHECKBOX);
   if (!taskMatch?.[0] || !taskMatch[2]) {
     return { task: null, warnings };
@@ -197,6 +233,22 @@ function parseTask(line, lineNumber, file, context) {
       line: lineNumber
     });
   }
+  if (!completed && !dueDateResult.date && !context.currentDate) {
+    warnings.push({
+      file,
+      line: lineNumber,
+      text: fullText.trim(),
+      reason: "Task has no due date. Add [due: YYYY-MM-DD] or place under a heading with a date."
+    });
+  }
+  if (completed && !completedDate) {
+    warnings.push({
+      file,
+      line: lineNumber,
+      text: fullText.trim(),
+      reason: "Completed task missing completion date. Add [completed: YYYY-MM-DD]."
+    });
+  }
   const cleanText = cleanTaskText(fullText);
   const id = generateTaskId(file, lineNumber, cleanText);
   const task = {
@@ -242,6 +294,7 @@ var MarkdownScanner = class {
   scanFile(filePath, content) {
     const tasks = [];
     const warnings = [];
+    const todoistIds = /* @__PURE__ */ new Map();
     const context = {};
     const project = extractProjectFromPath(filePath);
     if (project !== void 0) context.project = project;
@@ -261,6 +314,22 @@ var MarkdownScanner = class {
       const result = parseTask(line, lineNumber, filePath, context);
       if (result.task) {
         tasks.push(result.task);
+        if (result.task.todoistId) {
+          const existing = todoistIds.get(result.task.todoistId);
+          if (existing) {
+            warnings.push({
+              file: filePath,
+              line: lineNumber,
+              text: result.task.text,
+              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) {
         warnings.push(...result.warnings);
@@ -280,10 +349,29 @@ var MarkdownScanner = class {
   scanFiles(files) {
     const allTasks = [];
     const allWarnings = [];
+    const todoistIds = /* @__PURE__ */ new Map();
     for (const file of files) {
       const result = this.scanFile(file.path, file.content);
       allTasks.push(...result.tasks);
       allWarnings.push(...result.warnings);
+      for (const task of result.tasks) {
+        if (task.todoistId) {
+          const existing = todoistIds.get(task.todoistId);
+          if (existing && existing.file !== task.file) {
+            allWarnings.push({
+              file: task.file,
+              line: task.line,
+              text: task.text,
+              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 {
       tasks: allTasks,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@md2do/core",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "description": "Core parsing, filtering, scanning, and file writing for md2do",
   "keywords": [
     "markdown",

package/src/parser/index.ts

@@ -208,6 +208,53 @@ 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({
+      file,
+      line: lineNumber,
+      text: line.trim(),
+      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({
+      file,
+      line: lineNumber,
+      text: line.trim(),
+      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({
+      file,
+      line: lineNumber,
+      text: line.trim(),
+      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({
+      file,
+      line: lineNumber,
+      text: line.trim(),
+      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 +284,29 @@ 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({
+      file,
+      line: lineNumber,
+      text: fullText.trim(),
+      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({
+      file,
+      line: lineNumber,
+      text: fullText.trim(),
+      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,24 @@ 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({
+              file: filePath,
+              line: lineNumber,
+              text: result.task.text,
+              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 +152,35 @@ 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({
+              file: task.file,
+              line: task.line,
+              text: task.text,
+              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/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');
+    });
+  });
 });