@catafal/notion-cli 5.9.0

package/dist/utils/markdown-to-blocks.js

@@ -0,0 +1,333 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.markdownToBlocks = markdownToBlocks;
+/**
+ * Converts markdown text to Notion block objects
+ *
+ * This is a simple, secure replacement for @tryfabric/martian's markdownToBlocks
+ * to eliminate security vulnerabilities from the katex dependency chain.
+ *
+ * Supports:
+ * - Headings (h1, h2, h3)
+ * - Paragraphs
+ * - Bulleted lists
+ * - Numbered lists
+ * - Checkboxes (to_do blocks)
+ * - Code blocks
+ * - Tables (with header detection)
+ * - Quotes
+ * - Bold, italic, strikethrough, and inline code formatting
+ *
+ * @param markdown - The markdown string to convert
+ * @returns Array of Notion block objects
+ */
+function markdownToBlocks(markdown) {
+    var _a;
+    const blocks = [];
+    const lines = markdown.split('\n');
+    let i = 0;
+    while (i < lines.length) {
+        const line = lines[i];
+        const trimmedLine = line.trim();
+        // Skip empty lines at the top level
+        if (!trimmedLine) {
+            i++;
+            continue;
+        }
+        // Headings
+        const headingMatch = trimmedLine.match(/^(#{1,3})\s+(.+)$/);
+        if (headingMatch) {
+            const level = headingMatch[1].length;
+            const text = headingMatch[2];
+            const headingType = level === 1 ? 'heading_1' : level === 2 ? 'heading_2' : 'heading_3';
+            blocks.push({
+                object: 'block',
+                type: headingType,
+                [headingType]: {
+                    rich_text: parseRichText(text),
+                },
+            });
+            i++;
+            continue;
+        }
+        // Code blocks
+        if (trimmedLine.startsWith('```')) {
+            const language = trimmedLine.slice(3).trim() || 'plain text';
+            const codeLines = [];
+            i++;
+            while (i < lines.length && !lines[i].trim().startsWith('```')) {
+                codeLines.push(lines[i]);
+                i++;
+            }
+            blocks.push({
+                object: 'block',
+                type: 'code',
+                code: {
+                    rich_text: [{
+                            type: 'text',
+                            text: { content: codeLines.join('\n') },
+                        }],
+                    language: language,
+                },
+            });
+            i++; // Skip closing ```
+            continue;
+        }
+        // Tables: collect consecutive | rows, detect header via separator (|---|)
+        if (trimmedLine.match(/^\|.+\|$/)) {
+            const tableLines = [trimmedLine];
+            let j = i + 1;
+            while (j < lines.length && lines[j].trim().match(/^\|.+\|$/)) {
+                tableLines.push(lines[j].trim());
+                j++;
+            }
+            // Separator row like |---|---| means the first row is a header
+            const hasHeader = tableLines.length > 1 && /^\|[\s\-:|]+\|$/.test(tableLines[1]);
+            // Filter out separator rows — they're structural, not data
+            const dataRows = tableLines.filter(l => !/^\|[\s\-:|]+\|$/.test(l));
+            // Split each row into cells: "| A | B |" → ["A", "B"]
+            const parsedRows = dataRows.map(row => row.split('|').slice(1, -1).map(cell => cell.trim()));
+            const columnCount = ((_a = parsedRows[0]) === null || _a === void 0 ? void 0 : _a.length) || 1;
+            blocks.push({
+                object: 'block',
+                type: 'table',
+                table: {
+                    table_width: columnCount,
+                    has_column_header: hasHeader,
+                    has_row_header: false,
+                    children: parsedRows.map(cells => ({
+                        object: 'block',
+                        type: 'table_row',
+                        table_row: {
+                            cells: cells.map(cell => parseRichText(cell)),
+                        },
+                    })),
+                },
+            });
+            i = j;
+            continue;
+        }
+        // Block quotes
+        if (trimmedLine.startsWith('>')) {
+            const quoteText = trimmedLine.slice(1).trim();
+            blocks.push({
+                object: 'block',
+                type: 'quote',
+                quote: {
+                    rich_text: parseRichText(quoteText),
+                },
+            });
+            i++;
+            continue;
+        }
+        // Checkboxes: - [ ] or - [x] / - [X] → Notion to_do block
+        // Must be checked before bullet lists since "- [ ]" also matches "^[-*]\s+"
+        const checkboxMatch = trimmedLine.match(/^-\s+\[([ xX])\]\s+(.*)$/);
+        if (checkboxMatch) {
+            const checked = checkboxMatch[1].toLowerCase() === 'x';
+            const text = checkboxMatch[2];
+            blocks.push({
+                object: 'block',
+                type: 'to_do',
+                to_do: {
+                    rich_text: parseRichText(text),
+                    checked,
+                },
+            });
+            i++;
+            continue;
+        }
+        // Bulleted lists
+        if (trimmedLine.match(/^[-*]\s+/)) {
+            const text = trimmedLine.replace(/^[-*]\s+/, '');
+            blocks.push({
+                object: 'block',
+                type: 'bulleted_list_item',
+                bulleted_list_item: {
+                    rich_text: parseRichText(text),
+                },
+            });
+            i++;
+            continue;
+        }
+        // Numbered lists
+        if (trimmedLine.match(/^\d+\.\s+/)) {
+            const text = trimmedLine.replace(/^\d+\.\s+/, '');
+            blocks.push({
+                object: 'block',
+                type: 'numbered_list_item',
+                numbered_list_item: {
+                    rich_text: parseRichText(text),
+                },
+            });
+            i++;
+            continue;
+        }
+        // Horizontal rule
+        if (trimmedLine.match(/^(-{3,}|\*{3,}|_{3,})$/)) {
+            blocks.push({
+                object: 'block',
+                type: 'divider',
+                divider: {},
+            });
+            i++;
+            continue;
+        }
+        // Regular paragraph
+        blocks.push({
+            object: 'block',
+            type: 'paragraph',
+            paragraph: {
+                rich_text: parseRichText(trimmedLine),
+            },
+        });
+        i++;
+    }
+    return blocks;
+}
+/**
+ * Parse markdown text into Notion rich text format
+ * Supports: **bold**, *italic*, ~~strikethrough~~, `code`, and [links](url)
+ */
+function parseRichText(text) {
+    if (!text) {
+        return [{ type: 'text', text: { content: '' } }];
+    }
+    const richText = [];
+    let currentText = '';
+    let i = 0;
+    while (i < text.length) {
+        // Bold: **text**
+        if (text[i] === '*' && text[i + 1] === '*') {
+            // Save any accumulated plain text
+            if (currentText) {
+                richText.push({ type: 'text', text: { content: currentText } });
+                currentText = '';
+            }
+            // Find closing **
+            i += 2;
+            let boldText = '';
+            while (i < text.length && !(text[i] === '*' && text[i + 1] === '*')) {
+                boldText += text[i];
+                i++;
+            }
+            richText.push({
+                type: 'text',
+                text: { content: boldText },
+                annotations: { bold: true },
+            });
+            i += 2; // Skip closing **
+            continue;
+        }
+        // Strikethrough: ~~text~~ (same two-char delimiter pattern as bold)
+        if (text[i] === '~' && text[i + 1] === '~') {
+            if (currentText) {
+                richText.push({ type: 'text', text: { content: currentText } });
+                currentText = '';
+            }
+            i += 2;
+            let stText = '';
+            while (i < text.length && !(text[i] === '~' && text[i + 1] === '~')) {
+                stText += text[i];
+                i++;
+            }
+            richText.push({
+                type: 'text',
+                text: { content: stText },
+                annotations: { strikethrough: true },
+            });
+            i += 2; // Skip closing ~~
+            continue;
+        }
+        // Italic: *text* or _text_
+        if ((text[i] === '*' || text[i] === '_') && text[i + 1] !== text[i]) {
+            const marker = text[i];
+            // Save any accumulated plain text
+            if (currentText) {
+                richText.push({ type: 'text', text: { content: currentText } });
+                currentText = '';
+            }
+            // Find closing marker
+            i++;
+            let italicText = '';
+            while (i < text.length && text[i] !== marker) {
+                italicText += text[i];
+                i++;
+            }
+            richText.push({
+                type: 'text',
+                text: { content: italicText },
+                annotations: { italic: true },
+            });
+            i++; // Skip closing marker
+            continue;
+        }
+        // Inline code: `text`
+        if (text[i] === '`') {
+            // Save any accumulated plain text
+            if (currentText) {
+                richText.push({ type: 'text', text: { content: currentText } });
+                currentText = '';
+            }
+            // Find closing `
+            i++;
+            let codeText = '';
+            while (i < text.length && text[i] !== '`') {
+                codeText += text[i];
+                i++;
+            }
+            richText.push({
+                type: 'text',
+                text: { content: codeText },
+                annotations: { code: true },
+            });
+            i++; // Skip closing `
+            continue;
+        }
+        // Links: [text](url)
+        if (text[i] === '[') {
+            const linkStart = i;
+            let linkText = '';
+            i++;
+            // Find closing ]
+            while (i < text.length && text[i] !== ']') {
+                linkText += text[i];
+                i++;
+            }
+            // Check if followed by (url)
+            if (i < text.length && text[i] === ']' && text[i + 1] === '(') {
+                i += 2; // Skip ](
+                let url = '';
+                while (i < text.length && text[i] !== ')') {
+                    url += text[i];
+                    i++;
+                }
+                // Save any accumulated plain text
+                if (currentText) {
+                    richText.push({ type: 'text', text: { content: currentText } });
+                    currentText = '';
+                }
+                richText.push({
+                    type: 'text',
+                    text: { content: linkText, link: { url } },
+                });
+                i++; // Skip closing )
+                continue;
+            }
+            else {
+                // Not a link, treat as plain text
+                currentText += text.slice(linkStart, i + 1);
+                i++;
+                continue;
+            }
+        }
+        // Regular character
+        currentText += text[i];
+        i++;
+    }
+    // Add any remaining text
+    if (currentText) {
+        richText.push({ type: 'text', text: { content: currentText } });
+    }
+    return richText.length > 0 ? richText : [{ type: 'text', text: { content: '' } }];
+}

package/dist/utils/notion-resolver.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Notion ID Resolver
+ *
+ * Hybrid resolution system that supports:
+ * - URLs: https://www.notion.so/database-id
+ * - Direct IDs: database-id
+ * - Names: "Tasks Database" (via cache lookup and API fallback)
+ * - Smart database_id → data_source_id conversion
+ *
+ * Resolution stages:
+ * 1. URL extraction
+ * 2. Direct ID validation
+ * 2.5. Bookmark lookup (user-defined shortcuts)
+ * 3. Cache lookup (exact → alias → substring → fuzzy)
+ * 4. API search fallback
+ * 5. Smart database_id → data_source_id resolution (for databases)
+ */
+/**
+ * Resolve Notion input (URL, ID, or name) to a clean Notion ID
+ *
+ * Supports URLs, IDs, and name-based lookups via cache and API search.
+ * For databases, automatically detects and converts database_id to data_source_id.
+ *
+ * @param input - Database/page name, ID, or URL
+ * @param type - Resource type (for better error messages)
+ * @returns Clean Notion ID (32 hex characters without dashes)
+ * @throws NotionCLIError if input cannot be resolved
+ *
+ * @example
+ * // URL
+ * await resolveNotionId('https://notion.so/1fb79d4c71bb8032b722c82305b63a00')
+ * // Returns: '1fb79d4c71bb8032b722c82305b63a00'
+ *
+ * @example
+ * // Direct ID
+ * await resolveNotionId('1fb79d4c71bb8032b722c82305b63a00')
+ * // Returns: '1fb79d4c71bb8032b722c82305b63a00'
+ *
+ * @example
+ * // Name (via cache or API)
+ * await resolveNotionId('Tasks Database', 'database')
+ * // Returns: '1fb79d4c71bb8032b722c82305b63a00'
+ *
+ * @example
+ * // database_id auto-conversion
+ * await resolveNotionId('abc123...', 'database')
+ * // If abc123 is a database_id, auto-resolves to data_source_id
+ */
+export declare function resolveNotionId(input: string, type?: 'database' | 'page'): Promise<string>;

package/dist/utils/notion-resolver.js

@@ -0,0 +1,278 @@
+"use strict";
+/**
+ * Notion ID Resolver
+ *
+ * Hybrid resolution system that supports:
+ * - URLs: https://www.notion.so/database-id
+ * - Direct IDs: database-id
+ * - Names: "Tasks Database" (via cache lookup and API fallback)
+ * - Smart database_id → data_source_id conversion
+ *
+ * Resolution stages:
+ * 1. URL extraction
+ * 2. Direct ID validation
+ * 2.5. Bookmark lookup (user-defined shortcuts)
+ * 3. Cache lookup (exact → alias → substring → fuzzy)
+ * 4. API search fallback
+ * 5. Smart database_id → data_source_id resolution (for databases)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveNotionId = resolveNotionId;
+const notion_url_parser_1 = require("./notion-url-parser");
+const errors_1 = require("../errors");
+const workspace_cache_1 = require("./workspace-cache");
+const fuzzy_1 = require("./fuzzy");
+const bookmarks_1 = require("./bookmarks");
+const notion_1 = require("../notion");
+const client_1 = require("@notionhq/client");
+/**
+ * Resolve Notion input (URL, ID, or name) to a clean Notion ID
+ *
+ * Supports URLs, IDs, and name-based lookups via cache and API search.
+ * For databases, automatically detects and converts database_id to data_source_id.
+ *
+ * @param input - Database/page name, ID, or URL
+ * @param type - Resource type (for better error messages)
+ * @returns Clean Notion ID (32 hex characters without dashes)
+ * @throws NotionCLIError if input cannot be resolved
+ *
+ * @example
+ * // URL
+ * await resolveNotionId('https://notion.so/1fb79d4c71bb8032b722c82305b63a00')
+ * // Returns: '1fb79d4c71bb8032b722c82305b63a00'
+ *
+ * @example
+ * // Direct ID
+ * await resolveNotionId('1fb79d4c71bb8032b722c82305b63a00')
+ * // Returns: '1fb79d4c71bb8032b722c82305b63a00'
+ *
+ * @example
+ * // Name (via cache or API)
+ * await resolveNotionId('Tasks Database', 'database')
+ * // Returns: '1fb79d4c71bb8032b722c82305b63a00'
+ *
+ * @example
+ * // database_id auto-conversion
+ * await resolveNotionId('abc123...', 'database')
+ * // If abc123 is a database_id, auto-resolves to data_source_id
+ */
+async function resolveNotionId(input, type = 'database') {
+    if (!input || typeof input !== 'string') {
+        throw new errors_1.NotionCLIError(errors_1.NotionCLIErrorCode.VALIDATION_ERROR, `Invalid input: expected a ${type} name, ID, or URL`, [], { resourceType: type, userInput: String(input) });
+    }
+    const trimmed = input.trim();
+    // Stage 1: URL extraction
+    if ((0, notion_url_parser_1.isNotionUrl)(trimmed)) {
+        try {
+            const extractedId = (0, notion_url_parser_1.extractNotionId)(trimmed);
+            // For databases, try smart resolution in case URL contains database_id
+            if (type === 'database') {
+                return await trySmartDatabaseResolution(extractedId);
+            }
+            return extractedId;
+        }
+        catch {
+            throw errors_1.NotionCLIErrorFactory.invalidIdFormat(trimmed, type);
+        }
+    }
+    // Stage 2: Direct ID validation
+    if (isValidNotionId(trimmed)) {
+        const extractedId = (0, notion_url_parser_1.extractNotionId)(trimmed);
+        // For databases, try smart resolution in case it's a database_id
+        if (type === 'database') {
+            return await trySmartDatabaseResolution(extractedId);
+        }
+        return extractedId;
+    }
+    // Stage 2.5: Bookmark lookup — user-defined shortcuts (e.g. "inbox", "tasks")
+    const bookmark = await (0, bookmarks_1.getBookmark)(trimmed);
+    if (bookmark)
+        return bookmark.id;
+    // Stage 3: Cache lookup (exact + aliases)
+    const fromCache = await searchCache(trimmed);
+    if (fromCache)
+        return fromCache;
+    // Stage 4: API search as fallback
+    const fromApi = await searchNotionApi(trimmed, type);
+    if (fromApi)
+        return fromApi;
+    // Nothing found - throw helpful error
+    if (type === 'database') {
+        throw errors_1.NotionCLIErrorFactory.workspaceNotSynced(trimmed);
+    }
+    throw errors_1.NotionCLIErrorFactory.resourceNotFound(type, trimmed);
+}
+/**
+ * Smart database resolution: handles database_id → data_source_id conversion
+ *
+ * When a user provides a database_id (from parent.database_id field),
+ * this function detects the error and automatically resolves it to the
+ * correct data_source_id.
+ *
+ * @param databaseId - Potential database_id or data_source_id
+ * @returns data_source_id if valid, throws error otherwise
+ */
+async function trySmartDatabaseResolution(databaseId) {
+    try {
+        // Try direct lookup with data_source_id
+        await (0, notion_1.retrieveDataSource)(databaseId);
+        // If successful, it's a valid data_source_id
+        return databaseId;
+    }
+    catch (error) {
+        // Check if this is an object_not_found error (404)
+        const isNotFound = error.status === 404 ||
+            error.code === 'object_not_found' ||
+            (error.notionError && error.notionError.code === 'object_not_found');
+        if (isNotFound) {
+            // Try to resolve database_id → data_source_id
+            const dataSourceId = await resolveDatabaseIdToDataSourceId(databaseId);
+            if (dataSourceId) {
+                // Log helpful message about conversion
+                console.log(`\nInfo: Resolved database_id to data_source_id`);
+                console.log(`  database_id:    ${databaseId}`);
+                console.log(`  data_source_id: ${dataSourceId}`);
+                console.log(`\nNote: Use data_source_id for database operations.`);
+                console.log(`      The database_id from parent.database_id won't work directly.\n`);
+                return dataSourceId;
+            }
+        }
+        // If we can't resolve it, throw the original error
+        throw (0, errors_1.wrapNotionError)(error);
+    }
+}
+/**
+ * Resolve database_id to data_source_id by searching for pages
+ *
+ * When a user provides a database_id (from parent.database_id field),
+ * we search for pages that have this database as their parent, and
+ * extract the data_source_id from the parent field.
+ *
+ * @param databaseId - The database_id to resolve
+ * @returns data_source_id if found, null otherwise
+ */
+async function resolveDatabaseIdToDataSourceId(databaseId) {
+    try {
+        // Search for pages with this database_id as parent
+        const response = await (0, notion_1.search)({
+            filter: {
+                property: 'object',
+                value: 'page'
+            },
+            page_size: 100 // Search more pages to increase chance of finding one
+        });
+        if (!response || !response.results || response.results.length === 0) {
+            return null;
+        }
+        // Look through results for a page with matching parent.database_id
+        for (const result of response.results) {
+            if (result.object !== 'page')
+                continue;
+            // Use type guard to ensure we have a full page with parent
+            if (!(0, client_1.isFullPage)(result))
+                continue;
+            // Check if parent type is database_id and matches our search
+            if (result.parent &&
+                result.parent.type === 'database_id' &&
+                result.parent.database_id === databaseId) {
+                // Extract data_source_id from the same parent object
+                // In the Notion API v5, pages have both database_id and data_source_id in parent
+                if ('data_source_id' in result.parent) {
+                    return result.parent.data_source_id;
+                }
+            }
+        }
+        return null;
+    }
+    catch (error) {
+        // If search fails, return null and let the main error handling deal with it
+        if (process.env.DEBUG) {
+            console.error('Debug: Failed to resolve database_id to data_source_id:', error);
+        }
+        return null;
+    }
+}
+/**
+ * Check if a string is a valid Notion ID (32 hex chars with optional dashes)
+ */
+function isValidNotionId(input) {
+    const cleaned = input.replace(/-/g, '');
+    return /^[a-f0-9]{32}$/i.test(cleaned);
+}
+/**
+ * Search cache for database/page by name
+ *
+ * Searches in this order:
+ * 1. Exact title match (case-insensitive)
+ * 2. Alias match (case-insensitive)
+ * 3. Partial title match (case-insensitive substring)
+ * 4. Fuzzy match (Levenshtein distance for typo tolerance)
+ *
+ * @param query - Search query (database/page name)
+ * @returns Database/page ID if found, null otherwise
+ */
+async function searchCache(query) {
+    const cache = await (0, workspace_cache_1.loadCache)();
+    if (!cache)
+        return null;
+    const normalized = query.toLowerCase().trim();
+    // 1. Try exact title match
+    for (const db of cache.databases) {
+        if (db.titleNormalized === normalized) {
+            return db.id;
+        }
+    }
+    // 2. Try alias match
+    for (const db of cache.databases) {
+        if (db.aliases.includes(normalized)) {
+            return db.id;
+        }
+    }
+    // 3. Try partial match (substring in title)
+    for (const db of cache.databases) {
+        if (db.titleNormalized.includes(normalized)) {
+            return db.id;
+        }
+    }
+    // 4. Try fuzzy match (typo tolerance via Levenshtein distance)
+    const candidates = cache.databases.flatMap(db => [
+        { key: db.id, value: db.titleNormalized },
+        ...db.aliases.map(alias => ({ key: db.id, value: alias })),
+    ]);
+    const fuzzyResult = (0, fuzzy_1.fuzzyMatch)(normalized, candidates);
+    if (fuzzyResult)
+        return fuzzyResult.match;
+    return null;
+}
+/**
+ * Search Notion API for database/page by name
+ *
+ * Uses Notion's search API as a fallback when cache lookup fails.
+ *
+ * @param query - Search query (database/page name)
+ * @param type - Resource type ('database' or 'page')
+ * @returns Database/page ID if found, null otherwise
+ */
+async function searchNotionApi(query, type) {
+    try {
+        // Search Notion API
+        const response = await (0, notion_1.search)({
+            query,
+            filter: {
+                property: 'object',
+                value: type === 'database' ? 'data_source' : 'page'
+            },
+            page_size: 10
+        });
+        // Return first match
+        if (response && response.results && response.results.length > 0) {
+            return response.results[0].id;
+        }
+        return null;
+    }
+    catch {
+        // API search failed, return null
+        // The caller will throw a more helpful error message
+        return null;
+    }
+}