todoosy 0.3.3 → 0.3.5

package/dist/cjs/linter.js

@@ -0,0 +1,518 @@
+"use strict";
+/**
+ * Todoosy Linter
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lint = lint;
+exports.lintScheme = lintScheme;
+const parser_js_1 = require("./parser.js");
+const VALID_DATE_FORMATS = [
+    /^\d{4}-\d{1,2}-\d{1,2}$/, // YYYY-MM-DD or YYYY-M-D
+    /^\d{2}-\d{1,2}-\d{1,2}$/, // YY-MM-DD or YY-M-D
+    /^\d{4}\/\d{1,2}\/\d{1,2}$/, // YYYY/MM/DD
+    /^\d{2}\/\d{1,2}\/\d{1,2}$/, // YY/MM/DD or MM/DD/YY (ambiguous but accepted)
+    /^\d{1,2}\/\d{1,2}\/\d{4}$/, // MM/DD/YYYY or DD/MM/YYYY
+    /^\d{1,2}\/\d{1,2}\/\d{2}$/, // MM/DD/YY or DD/MM/YY
+];
+const MONTH_NAMES = new Set([
+    'january', 'jan',
+    'february', 'feb',
+    'march', 'mar',
+    'april', 'apr',
+    'may',
+    'june', 'jun',
+    'july', 'jul',
+    'august', 'aug',
+    'september', 'sep',
+    'october', 'oct',
+    'november', 'nov',
+    'december', 'dec',
+]);
+// Regex for text dates: Month Day [Year] or Day Month [Year] (Year can be 2 or 4 digits)
+const TEXT_DATE_REGEX = /^(january|jan|february|feb|march|mar|april|apr|may|june|jun|july|jul|august|aug|september|sep|october|oct|november|nov|december|dec)\s+(\d{1,2})(?:\s+(\d{2,4}))?$/i;
+const TEXT_DATE_DAY_FIRST_REGEX = /^(\d{1,2})\s+(january|jan|february|feb|march|mar|april|apr|may|june|jun|july|jul|august|aug|september|sep|october|oct|november|nov|december|dec)(?:\s+(\d{2,4}))?$/i;
+const VALID_CALENDAR_FORMATS = new Set(['yyyy-mm-dd', 'yyyy/mm/dd', 'mm/dd/yyyy', 'dd/mm/yyyy']);
+const VALID_FORMATTING_STYLES = new Set(['roomy', 'balanced', 'tight']);
+const PRIORITY_REGEX = /\bp(\d+)\b/gi;
+const ESTIMATE_REGEX = /\b(\d+)([mhd])\b/gi;
+const INVALID_PRIORITY_REGEX = /\bp([^0-9\s)][^\s)]*)\b/gi;
+const INVALID_ESTIMATE_REGEX = /\b(\d+)([^mhd\s)0-9][^\s)]*)\b/gi;
+const VALID_HASHTAG_REGEX = /^#[a-zA-Z][a-zA-Z0-9_-]*$/;
+const HASHTAG_LIKE_REGEX = /#[^\s,)]*/g;
+// Built-in progress states (normalized to lowercase)
+const PROGRESS_STATES = new Set(['done', 'deleted', 'in progress', 'blocked', 'progress']);
+function isValidDate(dateStr) {
+    // Strip soft date prefix (~) for validation
+    const normalizedDateStr = dateStr.startsWith('~') ? dateStr.slice(1) : dateStr;
+    // Check standard formats
+    if (VALID_DATE_FORMATS.some(regex => regex.test(normalizedDateStr))) {
+        return true;
+    }
+    // Check text date format (Month Day [Year])
+    if (TEXT_DATE_REGEX.test(normalizedDateStr)) {
+        const match = normalizedDateStr.match(TEXT_DATE_REGEX);
+        if (match) {
+            const day = parseInt(match[2], 10);
+            return day >= 1 && day <= 31;
+        }
+    }
+    // Check text date format (Day Month [Year])
+    if (TEXT_DATE_DAY_FIRST_REGEX.test(normalizedDateStr)) {
+        const match = normalizedDateStr.match(TEXT_DATE_DAY_FIRST_REGEX);
+        if (match) {
+            const day = parseInt(match[1], 10);
+            return day >= 1 && day <= 31;
+        }
+    }
+    return false;
+}
+function parseMiscLocation(misc) {
+    const slashIndex = misc.indexOf('/');
+    if (slashIndex === -1) {
+        return { filename: misc, heading: 'Misc' };
+    }
+    return {
+        filename: misc.substring(0, slashIndex),
+        heading: misc.substring(slashIndex + 1),
+    };
+}
+function lint(text, scheme, filename) {
+    const { ast } = (0, parser_js_1.parse)(text);
+    const warnings = [];
+    const lines = text.split('\n');
+    // Determine misc location from scheme or use default
+    const miscLocation = parseMiscLocation(scheme?.misc ?? 'todoosy.md/Misc');
+    // If no filename provided, assume it could be the misc file (backward compatibility)
+    const isMiscFile = filename === undefined || filename === miscLocation.filename;
+    let miscSectionLine = null;
+    let miscSectionSpan = null;
+    const headingsAfterMisc = [];
+    // Check each item
+    for (const item of ast.items) {
+        const lineIndex = item.line - 1;
+        const rawLine = item.raw_line;
+        // Check for Misc section (only relevant for the misc file)
+        if (isMiscFile && item.type === 'heading') {
+            if (miscSectionLine !== null) {
+                // Any heading after Misc (including duplicate Misc) is an error
+                headingsAfterMisc.push({ line: item.line, span: item.item_span });
+            }
+            else if (item.title_text === miscLocation.heading && item.level === 1) {
+                miscSectionLine = item.line;
+                miscSectionSpan = item.item_span;
+            }
+        }
+        // Check for invalid date formats in parentheses
+        const parenMatches = rawLine.matchAll(/\(([^)]+)\)/g);
+        for (const match of parenMatches) {
+            const content = match[1];
+            const parenStart = item.item_span[0] + (match.index || 0);
+            // Check for due dates - try text date format first (captures more), then standard format
+            // Text date: due [~]Month Day [Year] (Year can be 2 or 4 digits, ~ for soft dates)
+            const textDueMatches = content.matchAll(/\bdue\s+(~?(?:january|jan|february|feb|march|mar|april|apr|may|june|jun|july|jul|august|aug|september|sep|october|oct|november|nov|december|dec)\s+\d{1,2}(?:\s+\d{2,4})?)/gi);
+            const textDueIndices = new Set();
+            for (const textDueMatch of textDueMatches) {
+                textDueIndices.add(textDueMatch.index || 0);
+                const dateStr = textDueMatch[1];
+                if (!isValidDate(dateStr)) {
+                    const tokenStart = parenStart + 1 + (textDueMatch.index || 0);
+                    warnings.push({
+                        code: 'INVALID_DATE_FORMAT',
+                        message: `Invalid due date format: ${dateStr}`,
+                        line: item.line,
+                        column: tokenStart - item.item_span[0] + 1,
+                        span: [tokenStart + 4, tokenStart + 4 + dateStr.length],
+                    });
+                }
+            }
+            // Day-first text date: due [~]Day Month [Year] (Year can be 2 or 4 digits, ~ for soft dates)
+            const textDueDayFirstMatches = content.matchAll(/\bdue\s+(~?\d{1,2}\s+(?:january|jan|february|feb|march|mar|april|apr|may|june|jun|july|jul|august|aug|september|sep|october|oct|november|nov|december|dec)(?:\s+\d{2,4})?)/gi);
+            for (const textDueMatch of textDueDayFirstMatches) {
+                textDueIndices.add(textDueMatch.index || 0);
+                const dateStr = textDueMatch[1];
+                if (!isValidDate(dateStr)) {
+                    const tokenStart = parenStart + 1 + (textDueMatch.index || 0);
+                    warnings.push({
+                        code: 'INVALID_DATE_FORMAT',
+                        message: `Invalid due date format: ${dateStr}`,
+                        line: item.line,
+                        column: tokenStart - item.item_span[0] + 1,
+                        span: [tokenStart + 4, tokenStart + 4 + dateStr.length],
+                    });
+                }
+            }
+            // Standard date formats (single token)
+            // Allow optional ~ prefix for soft dates
+            const dueMatches = content.matchAll(/\bdue\s+(~?[^\s,)]+)/gi);
+            for (const dueMatch of dueMatches) {
+                // Skip if this was already matched as a text date
+                if (textDueIndices.has(dueMatch.index || 0))
+                    continue;
+                const dateStr = dueMatch[1];
+                // Skip if this looks like the start of a text date (month name, with or without ~)
+                const strippedDateStr = dateStr.startsWith('~') ? dateStr.slice(1) : dateStr;
+                if (MONTH_NAMES.has(strippedDateStr.toLowerCase()))
+                    continue;
+                // Skip if this looks like a day number (could be start of day-first date, with or without ~)
+                if (/^~?\d{1,2}$/.test(dateStr))
+                    continue;
+                if (!isValidDate(dateStr)) {
+                    const tokenStart = parenStart + 1 + (dueMatch.index || 0);
+                    warnings.push({
+                        code: 'INVALID_DATE_FORMAT',
+                        message: `Invalid due date format: ${dateStr}`,
+                        line: item.line,
+                        column: tokenStart - item.item_span[0] + 1,
+                        span: [tokenStart + 4, tokenStart + 4 + dateStr.length], // Skip 'due '
+                    });
+                }
+            }
+            // Check for multiple due dates across all paren groups
+            const allDueDates = [];
+            const allParenMatches = rawLine.matchAll(/\(([^)]+)\)/g);
+            for (const pMatch of allParenMatches) {
+                const pContent = pMatch[1];
+                const pStart = item.item_span[0] + (pMatch.index || 0);
+                const matchedPositions = new Set();
+                // Check text dates first (month-first, year can be 2 or 4 digits) with "due" prefix
+                // Allow optional ~ prefix for soft dates
+                const textDueDatesInGroup = pContent.matchAll(/\bdue\s+(~?(?:january|jan|february|feb|march|mar|april|apr|may|june|jun|july|jul|august|aug|september|sep|october|oct|november|nov|december|dec)\s+\d{1,2}(?:\s+\d{2,4})?)/gi);
+                for (const tdm of textDueDatesInGroup) {
+                    const ds = tdm[1];
+                    if (isValidDate(ds)) {
+                        matchedPositions.add(tdm.index || 0);
+                        const dStart = pStart + 1 + (tdm.index || 0);
+                        allDueDates.push({
+                            dateStr: ds,
+                            span: [dStart, dStart + tdm[0].length],
+                        });
+                    }
+                }
+                // Check day-first text dates (year can be 2 or 4 digits) with "due" prefix
+                // Allow optional ~ prefix for soft dates
+                const textDueDayFirstInGroup = pContent.matchAll(/\bdue\s+(~?\d{1,2}\s+(?:january|jan|february|feb|march|mar|april|apr|may|june|jun|july|jul|august|aug|september|sep|october|oct|november|nov|december|dec)(?:\s+\d{2,4})?)/gi);
+                for (const tdm of textDueDayFirstInGroup) {
+                    const ds = tdm[1];
+                    if (isValidDate(ds)) {
+                        matchedPositions.add(tdm.index || 0);
+                        const dStart = pStart + 1 + (tdm.index || 0);
+                        allDueDates.push({
+                            dateStr: ds,
+                            span: [dStart, dStart + tdm[0].length],
+                        });
+                    }
+                }
+                // Check standard dates with "due" prefix
+                // Allow optional ~ prefix for soft dates
+                const dueDatesInGroup = pContent.matchAll(/\bdue\s+(~?[^\s,)]+)/gi);
+                for (const dm of dueDatesInGroup) {
+                    // Skip if already matched as text date
+                    if (matchedPositions.has(dm.index || 0))
+                        continue;
+                    const ds = dm[1];
+                    // Skip if it's a month name (part of text date, with or without ~)
+                    const strippedDs = ds.startsWith('~') ? ds.slice(1) : ds;
+                    if (MONTH_NAMES.has(strippedDs.toLowerCase()))
+                        continue;
+                    // Skip if it's a day number (part of day-first text date, with or without ~)
+                    if (/^~?\d{1,2}$/.test(ds))
+                        continue;
+                    if (isValidDate(ds)) {
+                        matchedPositions.add(dm.index || 0);
+                        const dStart = pStart + 1 + (dm.index || 0);
+                        allDueDates.push({
+                            dateStr: ds,
+                            span: [dStart, dStart + dm[0].length],
+                        });
+                    }
+                }
+                // Check standalone text dates (without "due" prefix, not preceded by digit+space which indicates day-first)
+                // Allow optional ~ prefix for soft dates
+                // Exclude if preceded by "due " or "due ~"
+                const standaloneTextDatesInGroup = pContent.matchAll(/(?<!\bdue\s)(?<!\bdue\s~)(?<!\d\s)(~?(?:january|jan|february|feb|march|mar|april|apr|may|june|jun|july|jul|august|aug|september|sep|october|oct|november|nov|december|dec)\s+\d{1,2}(?:\s+\d{2,4})?)/gi);
+                for (const stm of standaloneTextDatesInGroup) {
+                    // Skip if already matched
+                    if (matchedPositions.has(stm.index || 0))
+                        continue;
+                    const ds = stm[1];
+                    if (isValidDate(ds)) {
+                        matchedPositions.add(stm.index || 0);
+                        const dStart = pStart + 1 + (stm.index || 0);
+                        allDueDates.push({
+                            dateStr: ds,
+                            span: [dStart, dStart + stm[0].length],
+                        });
+                    }
+                }
+                // Check standalone day-first text dates (without "due" prefix, not preceded by digit)
+                // Note: Day-first soft dates would be like ~15 Feb, but this is unusual; keep pattern simple
+                // Exclude if preceded by "due " or "due ~"
+                const standaloneDayFirstInGroup = pContent.matchAll(/(?<!\bdue\s)(?<!\bdue\s~)(?<!\d)(~?\d{1,2}\s+(?:january|jan|february|feb|march|mar|april|apr|may|june|jun|july|jul|august|aug|september|sep|october|oct|november|nov|december|dec)(?:\s+\d{2,4})?)/gi);
+                for (const stm of standaloneDayFirstInGroup) {
+                    // Skip if already matched
+                    if (matchedPositions.has(stm.index || 0))
+                        continue;
+                    const ds = stm[1];
+                    if (isValidDate(ds)) {
+                        matchedPositions.add(stm.index || 0);
+                        const dStart = pStart + 1 + (stm.index || 0);
+                        allDueDates.push({
+                            dateStr: ds,
+                            span: [dStart, dStart + stm[0].length],
+                        });
+                    }
+                }
+                // Check standalone ISO/slash dates (without "due" prefix)
+                // Use word boundary to avoid matching partial dates
+                // Allow optional ~ prefix for soft dates
+                // Exclude if preceded by "due " or "due ~"
+                const standaloneNumericDates = pContent.matchAll(/(?<!\bdue\s)(?<!\bdue\s~)(?<!\d)(~?\d{2,4}[-\/]\d{1,2}[-\/]\d{1,4})(?!\d)/gi);
+                for (const snm of standaloneNumericDates) {
+                    // Skip if already matched
+                    if (matchedPositions.has(snm.index || 0))
+                        continue;
+                    const ds = snm[1];
+                    if (isValidDate(ds)) {
+                        matchedPositions.add(snm.index || 0);
+                        const dStart = pStart + 1 + (snm.index || 0);
+                        allDueDates.push({
+                            dateStr: ds,
+                            span: [dStart, dStart + snm[0].length],
+                        });
+                    }
+                }
+            }
+            if (allDueDates.length > 1) {
+                // Warn for the second and subsequent ones
+                for (let i = 1; i < allDueDates.length; i++) {
+                    warnings.push({
+                        code: 'DUPLICATE_DUE_DATE',
+                        message: 'Multiple due dates found, using last value',
+                        line: item.line,
+                        column: allDueDates[i].span[0] - item.item_span[0] + 1,
+                        span: allDueDates[i].span,
+                    });
+                }
+                break; // Only warn once per item
+            }
+            // Check for standalone dates (without "due" prefix)
+            // Standalone text dates: Month Day [Year] (not preceded by "due" or digit+space)
+            // Allow optional ~ prefix for soft dates
+            // Exclude if preceded by "due " or "due ~"
+            const standaloneTextDates = content.matchAll(/(?<!\bdue\s)(?<!\bdue\s~)(?<!\d\s)(~?(?:january|jan|february|feb|march|mar|april|apr|may|june|jun|july|jul|august|aug|september|sep|october|oct|november|nov|december|dec)\s+\d{1,2}(?:\s+\d{2,4})?)/gi);
+            for (const stdMatch of standaloneTextDates) {
+                const dateStr = stdMatch[1];
+                if (!isValidDate(dateStr)) {
+                    const tokenStart = parenStart + 1 + (stdMatch.index || 0);
+                    warnings.push({
+                        code: 'INVALID_DATE_FORMAT',
+                        message: `Invalid date format: ${dateStr}`,
+                        line: item.line,
+                        column: tokenStart - item.item_span[0] + 1,
+                        span: [tokenStart, tokenStart + dateStr.length],
+                    });
+                }
+            }
+            // Standalone day-first text dates: Day Month [Year] (not preceded by "due" or a digit)
+            // Allow optional ~ prefix for soft dates
+            // Exclude if preceded by "due " or "due ~"
+            const standaloneDayFirstDates = content.matchAll(/(?<!\bdue\s)(?<!\bdue\s~)(?<!\d)(~?\d{1,2}\s+(?:january|jan|february|feb|march|mar|april|apr|may|june|jun|july|jul|august|aug|september|sep|october|oct|november|nov|december|dec)(?:\s+\d{2,4})?)/gi);
+            for (const stdMatch of standaloneDayFirstDates) {
+                const dateStr = stdMatch[1];
+                if (!isValidDate(dateStr)) {
+                    const tokenStart = parenStart + 1 + (stdMatch.index || 0);
+                    warnings.push({
+                        code: 'INVALID_DATE_FORMAT',
+                        message: `Invalid date format: ${dateStr}`,
+                        line: item.line,
+                        column: tokenStart - item.item_span[0] + 1,
+                        span: [tokenStart, tokenStart + dateStr.length],
+                    });
+                }
+            }
+            // Check for invalid priority tokens (e.g., pX)
+            // Use negative lookbehind to exclude hashtags (e.g., #personal)
+            const invalidPriorities = content.matchAll(/(?<!#)\bp([a-zA-Z][^\s,)]*)/gi);
+            for (const ipMatch of invalidPriorities) {
+                // Skip if this is "progress" (part of "in progress" progress state)
+                if (ipMatch[0].toLowerCase() === 'progress')
+                    continue;
+                const tokenStart = parenStart + 1 + (ipMatch.index || 0);
+                warnings.push({
+                    code: 'INVALID_TOKEN',
+                    message: `Unrecognized token in parentheses: ${ipMatch[0]}`,
+                    line: item.line,
+                    column: tokenStart - item.item_span[0] + 1,
+                    span: [tokenStart, tokenStart + ipMatch[0].length],
+                });
+            }
+            // Check for invalid estimate tokens (e.g., 5q)
+            const invalidEstimates = content.matchAll(/\b(\d+)([a-zA-Z])(?![mhdMHD])\b/gi);
+            for (const ieMatch of invalidEstimates) {
+                const unit = ieMatch[2].toLowerCase();
+                if (unit !== 'm' && unit !== 'h' && unit !== 'd') {
+                    const tokenStart = parenStart + 1 + (ieMatch.index || 0);
+                    warnings.push({
+                        code: 'INVALID_TOKEN',
+                        message: `Unrecognized token in parentheses: ${ieMatch[0]}`,
+                        line: item.line,
+                        column: tokenStart - item.item_span[0] + 1,
+                        span: [tokenStart, tokenStart + ieMatch[0].length],
+                    });
+                }
+            }
+            // Check for invalid hashtags (e.g., #123, #)
+            const hashtagLikeMatches = content.matchAll(HASHTAG_LIKE_REGEX);
+            for (const htMatch of hashtagLikeMatches) {
+                const hashtag = htMatch[0];
+                if (!VALID_HASHTAG_REGEX.test(hashtag)) {
+                    const tokenStart = parenStart + 1 + (htMatch.index || 0);
+                    warnings.push({
+                        code: 'INVALID_HASHTAG',
+                        message: `Invalid hashtag format: ${hashtag} (must start with # followed by a letter)`,
+                        line: item.line,
+                        column: tokenStart - item.item_span[0] + 1,
+                        span: [tokenStart, tokenStart + hashtag.length],
+                    });
+                }
+            }
+        }
+        // Check for comment indentation (list items only)
+        if (item.type === 'list' && item.comments.length > 0) {
+            const listMatch = rawLine.match(/^(\s*)([-*]|\d+\.)\s/);
+            const expectedIndent = listMatch ? listMatch[1].length + listMatch[2].length + 1 : 2;
+            // Find comment lines in the original text
+            let currentOffset = item.item_span[0] + rawLine.length + 1;
+            for (let i = 0; i < item.comments.length; i++) {
+                const commentLineIndex = item.line + i;
+                if (commentLineIndex < lines.length) {
+                    const commentLine = lines[commentLineIndex];
+                    const leadingSpaces = commentLine.match(/^(\s*)/)?.[1].length || 0;
+                    if (leadingSpaces < expectedIndent && commentLine.trim().length > 0) {
+                        warnings.push({
+                            code: 'COMMENT_INDENTATION',
+                            message: 'List item comment should be indented',
+                            line: commentLineIndex + 1,
+                            column: 1,
+                            span: [currentOffset, currentOffset + commentLine.length],
+                        });
+                    }
+                }
+                currentOffset += (lines[commentLineIndex]?.length || 0) + 1;
+            }
+        }
+    }
+    // Check for Misc section issues (only for the misc file)
+    if (isMiscFile) {
+        if (miscSectionLine === null) {
+            warnings.push({
+                code: 'MISC_MISSING',
+                message: `Document is missing required '# ${miscLocation.heading}' section`,
+                line: null,
+                column: null,
+                span: null,
+            });
+        }
+        else if (headingsAfterMisc.length > 0) {
+            // Misc is not at EOF
+            warnings.push({
+                code: 'MISC_NOT_AT_EOF',
+                message: `'# ${miscLocation.heading}' section must be at end of file`,
+                line: miscSectionLine,
+                column: 1,
+                span: miscSectionSpan,
+            });
+            // Content after Misc warning for each heading
+            for (const heading of headingsAfterMisc) {
+                warnings.push({
+                    code: 'CONTENT_AFTER_MISC',
+                    message: `Heading found after '# ${miscLocation.heading}' section`,
+                    line: heading.line,
+                    column: 1,
+                    span: heading.span,
+                });
+            }
+        }
+    }
+    // Check for sequence issues (gaps and duplicates in numbered lists)
+    const itemMap = new Map();
+    for (const item of ast.items) {
+        itemMap.set(item.id, item);
+    }
+    for (const item of ast.items) {
+        if (item.children.length === 0)
+            continue;
+        // Collect numbered children
+        const numberedChildren = [];
+        for (const childId of item.children) {
+            const child = itemMap.get(childId);
+            if (child && child.marker_type === 'numbered' && child.sequence_number !== undefined) {
+                numberedChildren.push({ id: childId, seqNum: child.sequence_number, item: child });
+            }
+        }
+        if (numberedChildren.length === 0)
+            continue;
+        // Check for gaps - numbers should be consecutive starting from 1
+        for (let i = 0; i < numberedChildren.length; i++) {
+            const expected = i + 1;
+            const actual = numberedChildren[i].seqNum;
+            if (actual !== expected) {
+                const child = numberedChildren[i].item;
+                warnings.push({
+                    code: 'SEQUENCE_GAP',
+                    message: `Sequence gap: expected ${expected}, found ${actual}`,
+                    line: child.line,
+                    column: child.column,
+                    span: child.item_span,
+                });
+            }
+        }
+        // Check for duplicates
+        const seqNumCounts = new Map();
+        for (const child of numberedChildren) {
+            const existing = seqNumCounts.get(child.seqNum) || [];
+            existing.push(child);
+            seqNumCounts.set(child.seqNum, existing);
+        }
+        for (const [seqNum, children] of seqNumCounts) {
+            if (children.length > 1) {
+                // Warn for all but the first occurrence
+                for (let i = 1; i < children.length; i++) {
+                    const child = children[i].item;
+                    warnings.push({
+                        code: 'SEQUENCE_DUPLICATE',
+                        message: `Duplicate sequence number: ${seqNum}`,
+                        line: child.line,
+                        column: child.column,
+                        span: child.item_span,
+                    });
+                }
+            }
+        }
+    }
+    return { warnings };
+}
+function lintScheme(scheme) {
+    const warnings = [];
+    // Check if calendar_format is valid
+    if (!VALID_CALENDAR_FORMATS.has(scheme.calendar_format.toLowerCase())) {
+        warnings.push({
+            code: 'INVALID_CALENDAR_FORMAT',
+            message: `Invalid calendar format: '${scheme.calendar_format}'. Valid formats are: ${[...VALID_CALENDAR_FORMATS].sort().join(', ')}`,
+            line: null,
+            column: null,
+            span: null,
+        });
+    }
+    // Check if formatting_style is valid
+    if (!VALID_FORMATTING_STYLES.has(scheme.formatting_style.toLowerCase())) {
+        warnings.push({
+            code: 'INVALID_FORMATTING_STYLE',
+            message: `Invalid formatting style: '${scheme.formatting_style}'. Valid styles are: ${[...VALID_FORMATTING_STYLES].sort().join(', ')}`,
+            line: null,
+            column: null,
+            span: null,
+        });
+    }
+    return { warnings };
+}

package/dist/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/dist/cjs/parser.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Todoosy Parser
+ */
+import type { AST, ParenGroup, Warning } from './types.js';
+export interface ParseResult {
+    ast: AST;
+    warnings: Warning[];
+}
+export declare function parseTokensInParenGroup(content: string, groupStart: number): ParenGroup;
+export declare function extractParenGroups(line: string, lineStart: number): ParenGroup[];
+export declare function parse(text: string): ParseResult;