@infograb/notion-cli 5.9.0

package/dist/utils/disk-cache.js

@@ -0,0 +1,291 @@
+"use strict";
+/**
+ * Disk Cache Manager
+ *
+ * Provides persistent caching to disk, maintaining cache across CLI invocations.
+ * Cache entries are stored in ~/.notion-cli/cache/ directory.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.diskCacheManager = exports.DiskCacheManager = void 0;
+const fs = require("fs/promises");
+const path = require("path");
+const os = require("os");
+const crypto = require("crypto");
+const CACHE_DIR_NAME = '.notion-cli';
+const CACHE_SUBDIR = 'cache';
+const DEFAULT_MAX_SIZE = 100 * 1024 * 1024; // 100MB
+const DEFAULT_SYNC_INTERVAL = 5000; // 5 seconds
+class DiskCacheManager {
+    constructor(options = {}) {
+        this.dirtyKeys = new Set();
+        this.syncTimer = null;
+        this.initialized = false;
+        this.cacheDir = options.cacheDir || path.join(os.homedir(), CACHE_DIR_NAME, CACHE_SUBDIR);
+        this.maxSize = options.maxSize || parseInt(process.env.NOTION_CLI_DISK_CACHE_MAX_SIZE || String(DEFAULT_MAX_SIZE), 10);
+        this.syncInterval = options.syncInterval || parseInt(process.env.NOTION_CLI_DISK_CACHE_SYNC_INTERVAL || String(DEFAULT_SYNC_INTERVAL), 10);
+    }
+    /**
+     * Initialize disk cache (create directory, start sync timer)
+     */
+    async initialize() {
+        if (this.initialized) {
+            return;
+        }
+        await this.ensureCacheDir();
+        await this.enforceMaxSize();
+        // Start periodic sync timer
+        if (this.syncInterval > 0) {
+            this.syncTimer = setInterval(() => {
+                this.sync().catch(error => {
+                    if (process.env.DEBUG) {
+                        console.warn('Disk cache sync error:', error);
+                    }
+                });
+            }, this.syncInterval);
+            // Don't keep the process alive
+            if (this.syncTimer.unref) {
+                this.syncTimer.unref();
+            }
+        }
+        this.initialized = true;
+    }
+    /**
+     * Get a cache entry from disk
+     */
+    async get(key) {
+        try {
+            const filePath = this.getFilePath(key);
+            const content = await fs.readFile(filePath, 'utf-8');
+            const entry = JSON.parse(content);
+            // Check if expired
+            if (Date.now() > entry.expiresAt) {
+                // Delete expired entry
+                await this.invalidate(key);
+                return null;
+            }
+            return entry;
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                return null;
+            }
+            if (process.env.DEBUG) {
+                console.warn(`Failed to read cache entry ${key}:`, error.message);
+            }
+            return null;
+        }
+    }
+    /**
+     * Set a cache entry to disk
+     */
+    async set(key, data, ttl) {
+        const entry = {
+            key,
+            data,
+            expiresAt: Date.now() + ttl,
+            createdAt: Date.now(),
+            size: JSON.stringify(data).length,
+        };
+        const filePath = this.getFilePath(key);
+        const tmpPath = `${filePath}.tmp`;
+        try {
+            // Write to temporary file
+            await fs.writeFile(tmpPath, JSON.stringify(entry), 'utf-8');
+            // Atomic rename
+            await fs.rename(tmpPath, filePath);
+            this.dirtyKeys.delete(key);
+        }
+        catch (error) {
+            // Clean up temp file if it exists
+            try {
+                await fs.unlink(tmpPath);
+            }
+            catch {
+                // Ignore cleanup errors
+            }
+            if (process.env.DEBUG) {
+                console.warn(`Failed to write cache entry ${key}:`, error.message);
+            }
+        }
+        // Check if we need to enforce size limits
+        const stats = await this.getStats();
+        if (stats.totalSize > this.maxSize) {
+            await this.enforceMaxSize();
+        }
+    }
+    /**
+     * Invalidate (delete) a cache entry
+     */
+    async invalidate(key) {
+        try {
+            const filePath = this.getFilePath(key);
+            await fs.unlink(filePath);
+            this.dirtyKeys.delete(key);
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT') {
+                if (process.env.DEBUG) {
+                    console.warn(`Failed to delete cache entry ${key}:`, error.message);
+                }
+            }
+        }
+    }
+    /**
+     * Clear all cache entries
+     */
+    async clear() {
+        try {
+            const files = await fs.readdir(this.cacheDir);
+            await Promise.all(files
+                .filter(file => !file.endsWith('.tmp'))
+                .map(file => fs.unlink(path.join(this.cacheDir, file)).catch(() => { })));
+            this.dirtyKeys.clear();
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT') {
+                if (process.env.DEBUG) {
+                    console.warn('Failed to clear cache:', error.message);
+                }
+            }
+        }
+    }
+    /**
+     * Sync dirty entries to disk
+     */
+    async sync() {
+        // In our implementation, writes are immediate (no write buffering)
+        // This method is here for API compatibility
+        this.dirtyKeys.clear();
+    }
+    /**
+     * Shutdown (flush and cleanup)
+     */
+    async shutdown() {
+        if (this.syncTimer) {
+            clearInterval(this.syncTimer);
+            this.syncTimer = null;
+        }
+        await this.sync();
+        this.initialized = false;
+    }
+    /**
+     * Get cache statistics
+     */
+    async getStats() {
+        try {
+            const files = await fs.readdir(this.cacheDir);
+            const entries = [];
+            for (const file of files) {
+                if (file.endsWith('.tmp')) {
+                    continue;
+                }
+                try {
+                    const content = await fs.readFile(path.join(this.cacheDir, file), 'utf-8');
+                    const entry = JSON.parse(content);
+                    entries.push(entry);
+                }
+                catch {
+                    // Skip corrupted entries
+                }
+            }
+            const totalSize = entries.reduce((sum, entry) => sum + entry.size, 0);
+            const timestamps = entries.map(e => e.createdAt);
+            return {
+                totalEntries: entries.length,
+                totalSize,
+                oldestEntry: timestamps.length > 0 ? Math.min(...timestamps) : null,
+                newestEntry: timestamps.length > 0 ? Math.max(...timestamps) : null,
+            };
+        }
+        catch (error) {
+            return {
+                totalEntries: 0,
+                totalSize: 0,
+                oldestEntry: null,
+                newestEntry: null,
+            };
+        }
+    }
+    /**
+     * Enforce maximum cache size by removing oldest entries
+     */
+    async enforceMaxSize() {
+        try {
+            const files = await fs.readdir(this.cacheDir);
+            const entries = [];
+            // Load all entries
+            for (const file of files) {
+                if (file.endsWith('.tmp')) {
+                    continue;
+                }
+                try {
+                    const filePath = path.join(this.cacheDir, file);
+                    const content = await fs.readFile(filePath, 'utf-8');
+                    const entry = JSON.parse(content);
+                    // Remove expired entries
+                    if (Date.now() > entry.expiresAt) {
+                        await fs.unlink(filePath);
+                        continue;
+                    }
+                    entries.push({ file, entry });
+                }
+                catch {
+                    // Skip corrupted entries
+                }
+            }
+            // Calculate total size
+            const totalSize = entries.reduce((sum, { entry }) => sum + entry.size, 0);
+            // If under limit, we're done
+            if (totalSize <= this.maxSize) {
+                return;
+            }
+            // Sort by creation time (oldest first)
+            entries.sort((a, b) => a.entry.createdAt - b.entry.createdAt);
+            // Remove oldest entries until under limit
+            let currentSize = totalSize;
+            for (const { file, entry } of entries) {
+                if (currentSize <= this.maxSize) {
+                    break;
+                }
+                try {
+                    await fs.unlink(path.join(this.cacheDir, file));
+                    currentSize -= entry.size;
+                }
+                catch {
+                    // Skip deletion errors
+                }
+            }
+        }
+        catch (error) {
+            if (process.env.DEBUG) {
+                console.warn('Failed to enforce max size:', error.message);
+            }
+        }
+    }
+    /**
+     * Ensure cache directory exists
+     */
+    async ensureCacheDir() {
+        try {
+            await fs.mkdir(this.cacheDir, { recursive: true });
+        }
+        catch (error) {
+            if (error.code !== 'EEXIST') {
+                throw new Error(`Failed to create cache directory: ${error.message}`);
+            }
+        }
+    }
+    /**
+     * Get file path for a cache key
+     */
+    getFilePath(key) {
+        // Hash the key to create a safe filename
+        const hash = crypto.createHash('sha256').update(key).digest('hex');
+        return path.join(this.cacheDir, `${hash}.json`);
+    }
+}
+exports.DiskCacheManager = DiskCacheManager;
+/**
+ * Global singleton instance
+ */
+exports.diskCacheManager = new DiskCacheManager();

package/dist/utils/markdown-to-blocks.d.ts

@@ -0,0 +1,19 @@
+/**
+ * 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
+ * - Code blocks
+ * - Quotes
+ * - Bold, italic, and inline code formatting
+ *
+ * @param markdown - The markdown string to convert
+ * @returns Array of Notion block objects
+ */
+export declare function markdownToBlocks(markdown: string): any[];

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

@@ -0,0 +1,259 @@
+"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
+ * - Code blocks
+ * - Quotes
+ * - Bold, italic, and inline code formatting
+ *
+ * @param markdown - The markdown string to convert
+ * @returns Array of Notion block objects
+ */
+function markdownToBlocks(markdown) {
+    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;
+        }
+        // Block quotes
+        if (trimmedLine.startsWith('>')) {
+            const quoteText = trimmedLine.slice(1).trim();
+            blocks.push({
+                object: 'block',
+                type: 'quote',
+                quote: {
+                    rich_text: parseRichText(quoteText),
+                },
+            });
+            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*, `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;
+        }
+        // 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,48 @@
+/**
+ * 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
+ * 3. Cache lookup (exact + aliases)
+ * 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>;