@infograb/notion-cli 5.9.0

package/dist/cache.js

@@ -0,0 +1,351 @@
+"use strict";
+/**
+ * Simple in-memory caching layer for Notion API responses
+ * Supports TTL (time-to-live) and cache invalidation
+ * Integrated with disk cache for persistence across CLI invocations
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cacheManager = exports.CacheManager = void 0;
+const disk_cache_1 = require("./utils/disk-cache");
+/**
+ * Check if verbose logging is enabled
+ */
+function isVerboseEnabled() {
+    return process.env.DEBUG === 'true' ||
+        process.env.NOTION_CLI_DEBUG === 'true' ||
+        process.env.NOTION_CLI_VERBOSE === 'true';
+}
+/**
+ * Log structured cache event to stderr
+ * Never pollutes stdout - safe for JSON output
+ */
+function logCacheEvent(event) {
+    // Only log if verbose mode is enabled
+    if (!isVerboseEnabled()) {
+        return;
+    }
+    // Always write to stderr, never stdout
+    console.error(JSON.stringify(event));
+}
+class CacheManager {
+    constructor(config) {
+        this.cache = new Map();
+        this.stats = {
+            hits: 0,
+            misses: 0,
+            sets: 0,
+            evictions: 0,
+            size: 0,
+        };
+        // Default configuration
+        this.config = {
+            enabled: process.env.NOTION_CLI_CACHE_ENABLED !== 'false',
+            defaultTtl: parseInt(process.env.NOTION_CLI_CACHE_TTL || '300000', 10), // 5 minutes default
+            maxSize: parseInt(process.env.NOTION_CLI_CACHE_MAX_SIZE || '1000', 10),
+            ttlByType: {
+                dataSource: parseInt(process.env.NOTION_CLI_CACHE_DS_TTL || '600000', 10), // 10 min
+                database: parseInt(process.env.NOTION_CLI_CACHE_DB_TTL || '600000', 10), // 10 min
+                user: parseInt(process.env.NOTION_CLI_CACHE_USER_TTL || '3600000', 10), // 1 hour
+                page: parseInt(process.env.NOTION_CLI_CACHE_PAGE_TTL || '60000', 10), // 1 min
+                block: parseInt(process.env.NOTION_CLI_CACHE_BLOCK_TTL || '30000', 10), // 30 sec
+            },
+            ...config,
+        };
+    }
+    /**
+     * Generate a cache key from resource type and identifiers
+     */
+    generateKey(type, ...identifiers) {
+        return `${type}:${identifiers.map(id => typeof id === 'object' ? JSON.stringify(id) : String(id)).join(':')}`;
+    }
+    /**
+     * Check if a cache entry is still valid
+     */
+    isValid(entry) {
+        const now = Date.now();
+        return now - entry.timestamp < entry.ttl;
+    }
+    /**
+     * Evict expired entries
+     */
+    evictExpired() {
+        let evictedCount = 0;
+        for (const [key, entry] of this.cache.entries()) {
+            if (!this.isValid(entry)) {
+                this.cache.delete(key);
+                this.stats.evictions++;
+                evictedCount++;
+            }
+        }
+        this.stats.size = this.cache.size;
+        // Log eviction event if any entries were evicted
+        if (evictedCount > 0 && isVerboseEnabled()) {
+            logCacheEvent({
+                level: 'debug',
+                event: 'cache_evict',
+                namespace: 'expired',
+                cache_size: this.cache.size,
+                timestamp: new Date().toISOString(),
+            });
+        }
+    }
+    /**
+     * Evict oldest entries if cache is full
+     */
+    evictOldest() {
+        if (this.cache.size >= this.config.maxSize) {
+            // Find and remove oldest entry
+            let oldestKey = null;
+            let oldestTime = Infinity;
+            for (const [key, entry] of this.cache.entries()) {
+                if (entry.timestamp < oldestTime) {
+                    oldestTime = entry.timestamp;
+                    oldestKey = key;
+                }
+            }
+            if (oldestKey) {
+                this.cache.delete(oldestKey);
+                this.stats.evictions++;
+                // Log LRU eviction
+                logCacheEvent({
+                    level: 'debug',
+                    event: 'cache_evict',
+                    namespace: 'lru',
+                    key: oldestKey,
+                    cache_size: this.cache.size,
+                    timestamp: new Date().toISOString(),
+                });
+            }
+        }
+    }
+    /**
+     * Get a value from cache (checks memory, then disk)
+     */
+    async get(type, ...identifiers) {
+        if (!this.config.enabled) {
+            return null;
+        }
+        const key = this.generateKey(type, ...identifiers);
+        const entry = this.cache.get(key);
+        // Check memory cache first
+        if (entry && this.isValid(entry)) {
+            this.stats.hits++;
+            // Log cache hit
+            logCacheEvent({
+                level: 'debug',
+                event: 'cache_hit',
+                namespace: type,
+                key: identifiers.join(':'),
+                age_ms: Date.now() - entry.timestamp,
+                ttl_ms: entry.ttl,
+                timestamp: new Date().toISOString(),
+            });
+            return entry.data;
+        }
+        // Remove invalid memory entry
+        if (entry) {
+            this.cache.delete(key);
+            this.stats.evictions++;
+            // Log eviction event
+            logCacheEvent({
+                level: 'debug',
+                event: 'cache_evict',
+                namespace: type,
+                key: identifiers.join(':'),
+                cache_size: this.cache.size,
+                timestamp: new Date().toISOString(),
+            });
+        }
+        // Check disk cache (only if enabled)
+        const diskEnabled = process.env.NOTION_CLI_DISK_CACHE_ENABLED !== 'false';
+        if (diskEnabled) {
+            try {
+                const diskEntry = await disk_cache_1.diskCacheManager.get(key);
+                if (diskEntry && diskEntry.data) {
+                    const entry = diskEntry.data;
+                    // Validate disk entry
+                    if (this.isValid(entry)) {
+                        // Promote to memory cache
+                        this.cache.set(key, entry);
+                        this.stats.hits++;
+                        // Log cache hit (from disk)
+                        logCacheEvent({
+                            level: 'debug',
+                            event: 'cache_hit',
+                            namespace: type,
+                            key: identifiers.join(':'),
+                            age_ms: Date.now() - entry.timestamp,
+                            ttl_ms: entry.ttl,
+                            timestamp: new Date().toISOString(),
+                        });
+                        return entry.data;
+                    }
+                    else {
+                        // Remove expired disk entry
+                        disk_cache_1.diskCacheManager.invalidate(key).catch(() => { });
+                    }
+                }
+            }
+            catch (error) {
+                // Silently ignore disk cache errors
+            }
+        }
+        // Cache miss
+        this.stats.misses++;
+        // Log cache miss
+        logCacheEvent({
+            level: 'debug',
+            event: 'cache_miss',
+            namespace: type,
+            key: identifiers.join(':'),
+            timestamp: new Date().toISOString(),
+        });
+        return null;
+    }
+    /**
+     * Set a value in cache with optional custom TTL (writes to memory and disk)
+     */
+    set(type, data, customTtl, ...identifiers) {
+        if (!this.config.enabled) {
+            return;
+        }
+        // Evict expired entries periodically
+        if (this.cache.size > 0 && Math.random() < 0.1) {
+            this.evictExpired();
+        }
+        // Evict oldest if at capacity
+        this.evictOldest();
+        const key = this.generateKey(type, ...identifiers);
+        const ttl = customTtl || this.config.ttlByType[type] || this.config.defaultTtl;
+        const entry = {
+            data,
+            timestamp: Date.now(),
+            ttl,
+        };
+        this.cache.set(key, entry);
+        this.stats.sets++;
+        this.stats.size = this.cache.size;
+        // Log cache set
+        logCacheEvent({
+            level: 'debug',
+            event: 'cache_set',
+            namespace: type,
+            key: identifiers.join(':'),
+            ttl_ms: ttl,
+            cache_size: this.cache.size,
+            timestamp: new Date().toISOString(),
+        });
+        // Async write to disk cache (fire-and-forget)
+        const diskEnabled = process.env.NOTION_CLI_DISK_CACHE_ENABLED !== 'false';
+        if (diskEnabled) {
+            disk_cache_1.diskCacheManager.set(key, entry, ttl).catch(() => {
+                // Silently ignore disk cache errors
+            });
+        }
+    }
+    /**
+     * Invalidate specific cache entries by type and optional identifiers
+     */
+    invalidate(type, ...identifiers) {
+        const diskEnabled = process.env.NOTION_CLI_DISK_CACHE_ENABLED !== 'false';
+        if (identifiers.length === 0) {
+            // Invalidate all entries of this type
+            const pattern = `${type}:`;
+            let invalidatedCount = 0;
+            for (const key of this.cache.keys()) {
+                if (key.startsWith(pattern)) {
+                    this.cache.delete(key);
+                    this.stats.evictions++;
+                    invalidatedCount++;
+                    // Also invalidate from disk (fire-and-forget)
+                    if (diskEnabled) {
+                        disk_cache_1.diskCacheManager.invalidate(key).catch(() => { });
+                    }
+                }
+            }
+            // Log bulk invalidation
+            if (invalidatedCount > 0) {
+                logCacheEvent({
+                    level: 'debug',
+                    event: 'cache_invalidate',
+                    namespace: type,
+                    cache_size: this.cache.size,
+                    timestamp: new Date().toISOString(),
+                });
+            }
+        }
+        else {
+            // Invalidate specific entry
+            const key = this.generateKey(type, ...identifiers);
+            if (this.cache.delete(key)) {
+                this.stats.evictions++;
+                // Also invalidate from disk (fire-and-forget)
+                if (diskEnabled) {
+                    disk_cache_1.diskCacheManager.invalidate(key).catch(() => { });
+                }
+                // Log specific invalidation
+                logCacheEvent({
+                    level: 'debug',
+                    event: 'cache_invalidate',
+                    namespace: type,
+                    key: identifiers.join(':'),
+                    cache_size: this.cache.size,
+                    timestamp: new Date().toISOString(),
+                });
+            }
+        }
+        this.stats.size = this.cache.size;
+    }
+    /**
+     * Clear all cache entries (memory and disk)
+     */
+    clear() {
+        const previousSize = this.cache.size;
+        this.cache.clear();
+        this.stats.evictions += this.stats.size;
+        this.stats.size = 0;
+        // Also clear disk cache (fire-and-forget)
+        const diskEnabled = process.env.NOTION_CLI_DISK_CACHE_ENABLED !== 'false';
+        if (diskEnabled) {
+            disk_cache_1.diskCacheManager.clear().catch(() => { });
+        }
+        // Log cache clear
+        if (previousSize > 0) {
+            logCacheEvent({
+                level: 'info',
+                event: 'cache_invalidate',
+                namespace: 'all',
+                cache_size: 0,
+                timestamp: new Date().toISOString(),
+            });
+        }
+    }
+    /**
+     * Get cache statistics
+     */
+    getStats() {
+        return { ...this.stats };
+    }
+    /**
+     * Get cache hit rate
+     */
+    getHitRate() {
+        const total = this.stats.hits + this.stats.misses;
+        return total > 0 ? this.stats.hits / total : 0;
+    }
+    /**
+     * Check if cache is enabled
+     */
+    isEnabled() {
+        return this.config.enabled;
+    }
+    /**
+     * Get current configuration
+     */
+    getConfig() {
+        return { ...this.config };
+    }
+}
+exports.CacheManager = CacheManager;
+// Singleton instance
+exports.cacheManager = new CacheManager();

package/dist/commands/batch/retrieve.d.ts

@@ -0,0 +1,43 @@
+import { Command } from '@oclif/core';
+export default class BatchRetrieve extends Command {
+    static description: string;
+    static aliases: string[];
+    static examples: {
+        description: string;
+        command: string;
+    }[];
+    static args: {
+        ids: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        'page-size': import("@oclif/core/lib/interfaces").OptionFlag<number, import("@oclif/core/lib/interfaces").CustomOptions>;
+        retry: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        timeout: import("@oclif/core/lib/interfaces").OptionFlag<number, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'no-cache': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        verbose: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        minimal: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        markdown: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        'compact-json': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        pretty: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        columns: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        sort: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        filter: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        csv: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        extended: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        'no-truncate': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        'no-header': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        ids: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        type: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        raw: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    /**
+     * Read IDs from stdin
+     */
+    private readStdin;
+    /**
+     * Retrieve a single resource and handle errors
+     */
+    private retrieveResource;
+    run(): Promise<void>;
+}

package/dist/commands/batch/retrieve.js

@@ -0,0 +1,265 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const table_formatter_1 = require("../../utils/table-formatter");
+const notion = require("../../notion");
+const helper_1 = require("../../helper");
+const base_flags_1 = require("../../base-flags");
+const errors_1 = require("../../errors");
+const client_1 = require("@notionhq/client");
+const readline = require("readline");
+class BatchRetrieve extends core_1.Command {
+    /**
+     * Read IDs from stdin
+     */
+    async readStdin() {
+        return new Promise((resolve, reject) => {
+            const ids = [];
+            const rl = readline.createInterface({
+                input: process.stdin,
+                output: process.stdout,
+                terminal: false,
+            });
+            rl.on('line', (line) => {
+                const trimmed = line.trim();
+                if (trimmed) {
+                    ids.push(trimmed);
+                }
+            });
+            rl.on('close', () => {
+                resolve(ids);
+            });
+            rl.on('error', (err) => {
+                reject(err);
+            });
+            // Timeout after 5 seconds if no input
+            setTimeout(() => {
+                rl.close();
+                resolve(ids);
+            }, 5000);
+        });
+    }
+    /**
+     * Retrieve a single resource and handle errors
+     */
+    async retrieveResource(id, type) {
+        try {
+            let data;
+            switch (type) {
+                case 'page': {
+                    const pageResponse = await notion.retrievePage({ page_id: id });
+                    if (!(0, client_1.isFullPage)(pageResponse)) {
+                        throw new errors_1.NotionCLIError(errors_1.NotionCLIErrorCode.API_ERROR, 'Received partial page response instead of full page', [], { attemptedId: id });
+                    }
+                    data = pageResponse;
+                    break;
+                }
+                case 'block': {
+                    const blockResponse = await notion.retrieveBlock(id);
+                    if (!(0, client_1.isFullBlock)(blockResponse)) {
+                        throw new errors_1.NotionCLIError(errors_1.NotionCLIErrorCode.API_ERROR, 'Received partial block response instead of full block', [], { attemptedId: id });
+                    }
+                    data = blockResponse;
+                    break;
+                }
+                case 'database':
+                    data = await notion.retrieveDataSource(id);
+                    break;
+                default:
+                    throw new errors_1.NotionCLIError(errors_1.NotionCLIErrorCode.VALIDATION_ERROR, `Invalid resource type: ${type}`, [], { userInput: type, resourceType: type });
+            }
+            return {
+                id,
+                success: true,
+                data,
+            };
+        }
+        catch (error) {
+            const cliError = error instanceof errors_1.NotionCLIError
+                ? error
+                : (0, errors_1.wrapNotionError)(error, {
+                    attemptedId: id,
+                    userInput: id
+                });
+            return {
+                id,
+                success: false,
+                error: cliError.code,
+                message: cliError.userMessage,
+            };
+        }
+    }
+    async run() {
+        const { args, flags } = await this.parse(BatchRetrieve);
+        try {
+            // Get IDs from args, flags, or stdin
+            let ids = [];
+            if (args.ids) {
+                // From positional argument
+                ids = args.ids.split(',').map(id => id.trim()).filter(id => id);
+            }
+            else if (flags.ids) {
+                // From --ids flag
+                ids = flags.ids.split(',').map(id => id.trim()).filter(id => id);
+            }
+            else if (!process.stdin.isTTY) {
+                // From stdin
+                ids = await this.readStdin();
+            }
+            if (ids.length === 0) {
+                throw new errors_1.NotionCLIError(errors_1.NotionCLIErrorCode.VALIDATION_ERROR, 'No IDs provided. Use --ids flag, positional argument, or pipe IDs via stdin', [
+                    {
+                        description: 'Provide IDs via --ids flag',
+                        command: 'notion-cli batch retrieve --ids ID1,ID2,ID3'
+                    },
+                    {
+                        description: 'Or pipe IDs from a file',
+                        command: 'cat ids.txt | notion-cli batch retrieve'
+                    }
+                ]);
+            }
+            // Fetch all resources in parallel
+            const results = await Promise.all(ids.map(id => this.retrieveResource(id, flags.type)));
+            // Count successes and failures
+            const successCount = results.filter(r => r.success).length;
+            const failureCount = results.filter(r => !r.success).length;
+            // Handle JSON output for automation (takes precedence)
+            if (flags.json) {
+                this.log(JSON.stringify({
+                    success: successCount > 0,
+                    total: results.length,
+                    succeeded: successCount,
+                    failed: failureCount,
+                    results: results,
+                    timestamp: new Date().toISOString(),
+                }, null, 2));
+                process.exit(failureCount === 0 ? 0 : 1);
+                return;
+            }
+            // Handle compact JSON output
+            if (flags['compact-json']) {
+                (0, helper_1.outputCompactJson)({
+                    total: results.length,
+                    succeeded: successCount,
+                    failed: failureCount,
+                    results: results,
+                });
+                process.exit(failureCount === 0 ? 0 : 1);
+                return;
+            }
+            // Handle raw JSON output
+            if (flags.raw) {
+                (0, helper_1.outputRawJson)(results);
+                process.exit(failureCount === 0 ? 0 : 1);
+                return;
+            }
+            // Handle table output (default)
+            const tableData = results.map(result => {
+                if (result.success && result.data) {
+                    let title = '';
+                    if ('object' in result.data) {
+                        if (result.data.object === 'page') {
+                            title = (0, helper_1.getPageTitle)(result.data);
+                        }
+                        else if (result.data.object === 'data_source') {
+                            title = (0, helper_1.getDataSourceTitle)(result.data);
+                        }
+                        else if (result.data.object === 'block') {
+                            title = (0, helper_1.getBlockPlainText)(result.data);
+                        }
+                    }
+                    return {
+                        id: result.id,
+                        status: 'success',
+                        type: result.data.object || flags.type,
+                        title: title || '-',
+                    };
+                }
+                else {
+                    return {
+                        id: result.id,
+                        status: 'failed',
+                        type: flags.type,
+                        title: result.message || result.error || 'Unknown error',
+                    };
+                }
+            });
+            const columns = {
+                id: {},
+                status: {},
+                type: {},
+                title: {},
+            };
+            const options = {
+                printLine: this.log.bind(this),
+                ...flags,
+            };
+            (0, table_formatter_1.formatTable)(tableData, columns, options);
+            // Print summary
+            this.log(`\nTotal: ${results.length} | Succeeded: ${successCount} | Failed: ${failureCount}`);
+            process.exit(failureCount === 0 ? 0 : 1);
+        }
+        catch (error) {
+            const cliError = error instanceof errors_1.NotionCLIError
+                ? error
+                : (0, errors_1.wrapNotionError)(error, {
+                    endpoint: 'batch.retrieve'
+                });
+            if (flags.json) {
+                this.log(JSON.stringify(cliError.toJSON(), null, 2));
+            }
+            else {
+                this.error(cliError.toHumanString());
+            }
+            process.exit(1);
+        }
+    }
+}
+BatchRetrieve.description = 'Batch retrieve multiple pages, blocks, or data sources';
+BatchRetrieve.aliases = ['batch:r'];
+BatchRetrieve.examples = [
+    {
+        description: 'Retrieve multiple pages via --ids flag',
+        command: '$ notion-cli batch retrieve --ids PAGE_ID_1,PAGE_ID_2,PAGE_ID_3 --compact-json',
+    },
+    {
+        description: 'Retrieve multiple pages from stdin (one ID per line)',
+        command: '$ cat page_ids.txt | notion-cli batch retrieve --compact-json',
+    },
+    {
+        description: 'Retrieve multiple blocks',
+        command: '$ notion-cli batch retrieve --ids BLOCK_ID_1,BLOCK_ID_2 --type block --json',
+    },
+    {
+        description: 'Retrieve multiple data sources',
+        command: '$ notion-cli batch retrieve --ids DS_ID_1,DS_ID_2 --type database --json',
+    },
+    {
+        description: 'Retrieve with raw output',
+        command: '$ notion-cli batch retrieve --ids ID1,ID2,ID3 -r',
+    },
+];
+BatchRetrieve.args = {
+    ids: core_1.Args.string({
+        required: false,
+        description: 'Comma-separated list of IDs to retrieve (or use --ids flag or stdin)',
+    }),
+};
+BatchRetrieve.flags = {
+    ids: core_1.Flags.string({
+        description: 'Comma-separated list of IDs to retrieve',
+    }),
+    type: core_1.Flags.string({
+        description: 'Resource type to retrieve (page, block, database)',
+        options: ['page', 'block', 'database'],
+        default: 'page',
+    }),
+    raw: core_1.Flags.boolean({
+        char: 'r',
+        description: 'output raw json (recommended for AI assistants - returns all fields)',
+    }),
+    ...table_formatter_1.tableFlags,
+    ...base_flags_1.OutputFormatFlags,
+    ...base_flags_1.AutomationFlags,
+};
+exports.default = BatchRetrieve;