todoosy 0.3.3 → 0.3.5

package/dist/cjs/query.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Todoosy Query Engine
+ */
+import type { UpcomingResult, MiscResult, Scheme } from './types.js';
+export declare function queryUpcoming(text: string, scheme?: Scheme): UpcomingResult;
+export declare function queryMisc(text: string, scheme?: Scheme): MiscResult;
+export interface HashtagItem {
+    id: string;
+    title_text: string;
+    path: string;
+    item_span: [number, number];
+    hashtags: string[];
+    effective_hashtags: string[];
+}
+export interface HashtagResult {
+    items: HashtagItem[];
+}
+export interface HashtagListResult {
+    hashtags: string[];
+}
+export declare function queryByHashtag(text: string, hashtag: string): HashtagResult;
+export declare function listHashtags(text: string): HashtagListResult;

package/dist/cjs/query.js

@@ -0,0 +1,153 @@
+"use strict";
+/**
+ * Todoosy Query Engine
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.queryUpcoming = queryUpcoming;
+exports.queryMisc = queryMisc;
+exports.queryByHashtag = queryByHashtag;
+exports.listHashtags = listHashtags;
+const parser_js_1 = require("./parser.js");
+function buildPath(itemId, ast) {
+    const itemMap = new Map();
+    const parentMap = new Map();
+    for (const item of ast.items) {
+        itemMap.set(item.id, item);
+        for (const childId of item.children) {
+            parentMap.set(childId, item.id);
+        }
+    }
+    const parts = [];
+    let currentId = itemId;
+    while (currentId !== undefined) {
+        const item = itemMap.get(currentId);
+        if (item) {
+            parts.unshift(item.title_text);
+        }
+        currentId = parentMap.get(currentId);
+    }
+    return parts.join(' > ');
+}
+function queryUpcoming(text, scheme) {
+    const { ast } = (0, parser_js_1.parse)(text);
+    const items = [];
+    // Find all items with due dates
+    for (const item of ast.items) {
+        if (item.metadata.due) {
+            const upcomingItem = {
+                id: item.id,
+                due: item.metadata.due,
+                priority: item.metadata.priority,
+                path: buildPath(item.id, ast),
+                item_span: item.item_span,
+            };
+            // Add priority label if scheme is provided
+            if (scheme && item.metadata.priority !== null) {
+                const label = scheme.priorities[String(item.metadata.priority)];
+                if (label) {
+                    upcomingItem.priority_label = label;
+                }
+            }
+            items.push(upcomingItem);
+        }
+    }
+    // Sort by:
+    // 1. Due date ascending
+    // 2. Priority ascending (lower is higher priority, nulls last)
+    // 3. Document order (by item_span start)
+    items.sort((a, b) => {
+        // Due date comparison
+        const dateCompare = a.due.localeCompare(b.due);
+        if (dateCompare !== 0)
+            return dateCompare;
+        // Priority comparison (null treated as infinity)
+        const aPri = a.priority ?? Infinity;
+        const bPri = b.priority ?? Infinity;
+        if (aPri !== bPri)
+            return aPri - bPri;
+        // Document order
+        return a.item_span[0] - b.item_span[0];
+    });
+    return { items };
+}
+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 queryMisc(text, scheme) {
+    const { ast } = (0, parser_js_1.parse)(text);
+    const items = [];
+    // Determine the heading name from scheme or use default
+    const miscLocation = parseMiscLocation(scheme?.misc ?? 'todoosy.md/Misc');
+    // Find the Misc section
+    let miscSectionId = null;
+    for (const item of ast.items) {
+        if (item.type === 'heading' && item.title_text === miscLocation.heading && item.level === 1) {
+            miscSectionId = item.id;
+            break;
+        }
+    }
+    if (miscSectionId === null) {
+        return { items };
+    }
+    // Get all direct children of the Misc section
+    const miscSection = ast.items.find(i => i.id === miscSectionId);
+    if (!miscSection) {
+        return { items };
+    }
+    const itemMap = new Map();
+    for (const item of ast.items) {
+        itemMap.set(item.id, item);
+    }
+    for (const childId of miscSection.children) {
+        const child = itemMap.get(childId);
+        if (child) {
+            items.push({
+                id: child.id,
+                title_text: child.title_text,
+                item_span: child.item_span,
+            });
+        }
+    }
+    return { items };
+}
+function queryByHashtag(text, hashtag) {
+    const { ast } = (0, parser_js_1.parse)(text);
+    const items = [];
+    // Normalize hashtag (lowercase, remove # if present)
+    const normalizedHashtag = hashtag.replace(/^#/, '').toLowerCase();
+    // Find all items with the hashtag (using effective_hashtags for inheritance)
+    for (const item of ast.items) {
+        if (item.metadata.effective_hashtags.includes(normalizedHashtag)) {
+            items.push({
+                id: item.id,
+                title_text: item.title_text,
+                path: buildPath(item.id, ast),
+                item_span: item.item_span,
+                hashtags: item.metadata.hashtags,
+                effective_hashtags: item.metadata.effective_hashtags,
+            });
+        }
+    }
+    // Sort by document order
+    items.sort((a, b) => a.item_span[0] - b.item_span[0]);
+    return { items };
+}
+function listHashtags(text) {
+    const { ast } = (0, parser_js_1.parse)(text);
+    const hashtagSet = new Set();
+    // Collect all unique hashtags from all items
+    for (const item of ast.items) {
+        for (const tag of item.metadata.hashtags) {
+            hashtagSet.add(tag);
+        }
+    }
+    // Return sorted list
+    return { hashtags: [...hashtagSet].sort() };
+}

package/dist/cjs/scheme.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Todoosy Scheme Parser
+ *
+ * @deprecated This module is deprecated. Use settings.ts instead.
+ * This file is maintained for backwards compatibility.
+ */
+export { parseScheme, parseSettings, VALID_CALENDAR_FORMATS, VALID_FORMATTING_STYLES, } from './settings.js';

package/dist/cjs/scheme.js

@@ -0,0 +1,14 @@
+"use strict";
+/**
+ * Todoosy Scheme Parser
+ *
+ * @deprecated This module is deprecated. Use settings.ts instead.
+ * This file is maintained for backwards compatibility.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VALID_FORMATTING_STYLES = exports.VALID_CALENDAR_FORMATS = exports.parseSettings = exports.parseScheme = void 0;
+var settings_js_1 = require("./settings.js");
+Object.defineProperty(exports, "parseScheme", { enumerable: true, get: function () { return settings_js_1.parseScheme; } });
+Object.defineProperty(exports, "parseSettings", { enumerable: true, get: function () { return settings_js_1.parseSettings; } });
+Object.defineProperty(exports, "VALID_CALENDAR_FORMATS", { enumerable: true, get: function () { return settings_js_1.VALID_CALENDAR_FORMATS; } });
+Object.defineProperty(exports, "VALID_FORMATTING_STYLES", { enumerable: true, get: function () { return settings_js_1.VALID_FORMATTING_STYLES; } });

package/dist/cjs/sequence.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Todoosy Sequence Utilities
+ *
+ * Functions for working with sequenced (numbered) task lists.
+ */
+import type { AST, ItemNode } from './types.js';
+export interface SequenceInfo {
+    parentId: string;
+    hasSequence: boolean;
+    numberedChildren: {
+        id: string;
+        sequenceNumber: number;
+    }[];
+    gaps: {
+        position: number;
+        expected: number;
+        actual: number;
+    }[];
+    duplicates: {
+        number: number;
+        ids: string[];
+    }[];
+}
+/**
+ * Analyze the sequence of numbered children under a parent item.
+ * Returns information about gaps and duplicates in the sequence.
+ */
+export declare function analyzeSequence(ast: AST, parentId: string): SequenceInfo;
+/**
+ * Renumber children of a parent to have consecutive sequence numbers starting from 1.
+ * Returns a new AST with the renumbered items.
+ */
+export declare function renumberChildren(ast: AST, parentId: string): AST;
+/**
+ * Insert a new item into a sequenced list at a specific position and renumber.
+ * Position is 0-indexed. Returns a new AST with the inserted and renumbered items.
+ */
+export declare function insertSequencedItem(ast: AST, parentId: string, position: number, newItem: Omit<ItemNode, 'id' | 'sequence_number'>): AST;
+/**
+ * Remove an item from a sequenced list and renumber siblings.
+ * Returns a new AST with the item removed and siblings renumbered.
+ */
+export declare function removeSequencedItem(ast: AST, itemId: string): AST;
+/**
+ * Convert bullet children of a parent to numbered items.
+ * Returns a new AST with bullet items converted to numbered.
+ */
+export declare function convertToSequence(ast: AST, parentId: string): AST;
+/**
+ * Convert numbered children of a parent to bullet items.
+ * Returns a new AST with numbered items converted to bullets.
+ */
+export declare function convertToBullets(ast: AST, parentId: string): AST;

package/dist/cjs/sequence.js

@@ -0,0 +1,233 @@
+"use strict";
+/**
+ * Todoosy Sequence Utilities
+ *
+ * Functions for working with sequenced (numbered) task lists.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeSequence = analyzeSequence;
+exports.renumberChildren = renumberChildren;
+exports.insertSequencedItem = insertSequencedItem;
+exports.removeSequencedItem = removeSequencedItem;
+exports.convertToSequence = convertToSequence;
+exports.convertToBullets = convertToBullets;
+/**
+ * Analyze the sequence of numbered children under a parent item.
+ * Returns information about gaps and duplicates in the sequence.
+ */
+function analyzeSequence(ast, parentId) {
+    const itemMap = new Map();
+    for (const item of ast.items) {
+        itemMap.set(item.id, item);
+    }
+    const parent = itemMap.get(parentId);
+    if (!parent) {
+        return {
+            parentId,
+            hasSequence: false,
+            numberedChildren: [],
+            gaps: [],
+            duplicates: [],
+        };
+    }
+    // Collect numbered children
+    const numberedChildren = [];
+    for (const childId of parent.children) {
+        const child = itemMap.get(childId);
+        if (child && child.marker_type === 'numbered' && child.sequence_number !== undefined) {
+            numberedChildren.push({ id: childId, sequenceNumber: child.sequence_number });
+        }
+    }
+    if (numberedChildren.length === 0) {
+        return {
+            parentId,
+            hasSequence: false,
+            numberedChildren: [],
+            gaps: [],
+            duplicates: [],
+        };
+    }
+    // Find gaps - numbers should be consecutive starting from 1
+    const gaps = [];
+    for (let i = 0; i < numberedChildren.length; i++) {
+        const expected = i + 1;
+        const actual = numberedChildren[i].sequenceNumber;
+        if (actual !== expected) {
+            gaps.push({ position: i, expected, actual });
+        }
+    }
+    // Find duplicates
+    const numberCounts = new Map();
+    for (const child of numberedChildren) {
+        const ids = numberCounts.get(child.sequenceNumber) || [];
+        ids.push(child.id);
+        numberCounts.set(child.sequenceNumber, ids);
+    }
+    const duplicates = [];
+    for (const [num, ids] of numberCounts) {
+        if (ids.length > 1) {
+            duplicates.push({ number: num, ids });
+        }
+    }
+    return {
+        parentId,
+        hasSequence: true,
+        numberedChildren,
+        gaps,
+        duplicates,
+    };
+}
+/**
+ * Renumber children of a parent to have consecutive sequence numbers starting from 1.
+ * Returns a new AST with the renumbered items.
+ */
+function renumberChildren(ast, parentId) {
+    const itemMap = new Map();
+    for (const item of ast.items) {
+        itemMap.set(item.id, { ...item });
+    }
+    const parent = itemMap.get(parentId);
+    if (!parent) {
+        return ast;
+    }
+    // Renumber numbered children
+    let nextNum = 1;
+    for (const childId of parent.children) {
+        const child = itemMap.get(childId);
+        if (child && child.marker_type === 'numbered') {
+            child.sequence_number = nextNum++;
+        }
+    }
+    return {
+        items: Array.from(itemMap.values()),
+        root_ids: [...ast.root_ids],
+    };
+}
+/**
+ * Insert a new item into a sequenced list at a specific position and renumber.
+ * Position is 0-indexed. Returns a new AST with the inserted and renumbered items.
+ */
+function insertSequencedItem(ast, parentId, position, newItem) {
+    const itemMap = new Map();
+    for (const item of ast.items) {
+        itemMap.set(item.id, { ...item });
+    }
+    const parent = itemMap.get(parentId);
+    if (!parent) {
+        return ast;
+    }
+    // Generate new ID
+    const maxId = Math.max(...ast.items.map(item => parseInt(item.id, 10)));
+    const newId = String(maxId + 1);
+    // Create new item
+    const item = {
+        ...newItem,
+        id: newId,
+        sequence_number: position + 1,
+        children: newItem.children || [],
+    };
+    // Insert into parent's children
+    const newChildren = [...parent.children];
+    newChildren.splice(position, 0, newId);
+    parent.children = newChildren;
+    // Add to items
+    itemMap.set(newId, item);
+    // Renumber all numbered children
+    let nextNum = 1;
+    for (const childId of parent.children) {
+        const child = itemMap.get(childId);
+        if (child && child.marker_type === 'numbered') {
+            child.sequence_number = nextNum++;
+        }
+    }
+    return {
+        items: Array.from(itemMap.values()),
+        root_ids: [...ast.root_ids],
+    };
+}
+/**
+ * Remove an item from a sequenced list and renumber siblings.
+ * Returns a new AST with the item removed and siblings renumbered.
+ */
+function removeSequencedItem(ast, itemId) {
+    const itemMap = new Map();
+    for (const item of ast.items) {
+        if (item.id !== itemId) {
+            itemMap.set(item.id, { ...item });
+        }
+    }
+    // Find and update parent
+    for (const [id, item] of itemMap) {
+        if (item.children.includes(itemId)) {
+            item.children = item.children.filter(c => c !== itemId);
+            // Renumber numbered children
+            let nextNum = 1;
+            for (const childId of item.children) {
+                const child = itemMap.get(childId);
+                if (child && child.marker_type === 'numbered') {
+                    child.sequence_number = nextNum++;
+                }
+            }
+            break;
+        }
+    }
+    // Update root_ids if necessary
+    const newRootIds = ast.root_ids.filter(id => id !== itemId);
+    return {
+        items: Array.from(itemMap.values()),
+        root_ids: newRootIds,
+    };
+}
+/**
+ * Convert bullet children of a parent to numbered items.
+ * Returns a new AST with bullet items converted to numbered.
+ */
+function convertToSequence(ast, parentId) {
+    const itemMap = new Map();
+    for (const item of ast.items) {
+        itemMap.set(item.id, { ...item });
+    }
+    const parent = itemMap.get(parentId);
+    if (!parent) {
+        return ast;
+    }
+    // Convert bullet children to numbered
+    let nextNum = 1;
+    for (const childId of parent.children) {
+        const child = itemMap.get(childId);
+        if (child && child.type === 'list') {
+            child.marker_type = 'numbered';
+            child.sequence_number = nextNum++;
+        }
+    }
+    return {
+        items: Array.from(itemMap.values()),
+        root_ids: [...ast.root_ids],
+    };
+}
+/**
+ * Convert numbered children of a parent to bullet items.
+ * Returns a new AST with numbered items converted to bullets.
+ */
+function convertToBullets(ast, parentId) {
+    const itemMap = new Map();
+    for (const item of ast.items) {
+        itemMap.set(item.id, { ...item });
+    }
+    const parent = itemMap.get(parentId);
+    if (!parent) {
+        return ast;
+    }
+    // Convert numbered children to bullets
+    for (const childId of parent.children) {
+        const child = itemMap.get(childId);
+        if (child && child.marker_type === 'numbered') {
+            child.marker_type = 'bullet';
+            child.sequence_number = undefined;
+        }
+    }
+    return {
+        items: Array.from(itemMap.values()),
+        root_ids: [...ast.root_ids],
+    };
+}

package/dist/cjs/settings.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Todoosy Settings Parser
+ *
+ * Parses todoosy.settings.md files using a canonical Markdown-compatible format.
+ *
+ * ## Canonical Format
+ *
+ * Settings files use standard Markdown with level-1 headings as setting names:
+ *
+ * ```markdown
+ * # Setting Name
+ *
+ * value
+ * ```
+ *
+ * ## Value Types
+ *
+ * 1. **Single Value** - First non-empty line after heading
+ *    ```markdown
+ *    # Timezone
+ *
+ *    America/Denver
+ *    ```
+ *
+ * 2. **List Value** - Bulleted list items (- or *)
+ *    ```markdown
+ *    # Tags
+ *
+ *    - work
+ *    - personal
+ *    ```
+ *
+ * 3. **Key-Value Map** - Lines with `key - value` format
+ *    ```markdown
+ *    # Priorities
+ *
+ *    P0 - Critical
+ *    P1 - High
+ *    ```
+ *
+ * ## Known Settings
+ *
+ * - Timezone: Single value (IANA timezone identifier)
+ * - Priorities: Key-value map (P0 - Label)
+ * - Misc: Single value (filename/headingname)
+ * - Calendar Format: Single value (yyyy-mm-dd, mm/dd/yyyy, etc.)
+ * - Formatting Style: Single value (roomy, balanced, tight)
+ *
+ * ## Extended Settings
+ *
+ * Any heading not matching known settings is captured as an extended setting,
+ * with automatic value type inference.
+ */
+import type { Settings, Scheme } from './types.js';
+export declare const VALID_CALENDAR_FORMATS: Set<string>;
+export declare const VALID_FORMATTING_STYLES: Set<string>;
+/**
+ * Parse a settings file and return structured settings
+ */
+export declare function parseSettings(text: string): Settings;
+/**
+ * Parse a settings file and return legacy Scheme format
+ * @deprecated Use parseSettings instead
+ */
+export declare function parseScheme(text: string): Scheme;