@infograb/notion-cli 5.9.0

package/dist/commands/block/retrieve.js

@@ -0,0 +1,98 @@
+"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");
+class BlockRetrieve extends core_1.Command {
+    async run() {
+        const { args, flags } = await this.parse(BlockRetrieve);
+        try {
+            let res = await notion.retrieveBlock(args.block_id);
+            // Apply minimal flag to strip metadata
+            if (flags.minimal) {
+                res = (0, helper_1.stripMetadata)(res);
+            }
+            // Handle JSON output for automation
+            if (flags.json) {
+                this.log(JSON.stringify({
+                    success: true,
+                    data: res,
+                    timestamp: new Date().toISOString()
+                }, null, 2));
+                process.exit(0);
+                return;
+            }
+            // Handle raw JSON output (legacy)
+            if (flags.raw) {
+                (0, helper_1.outputRawJson)(res);
+                process.exit(0);
+                return;
+            }
+            // Handle table output
+            const columns = {
+                object: {},
+                id: {},
+                type: {},
+                parent: {},
+                content: {
+                    get: (row) => {
+                        return (0, helper_1.getBlockPlainText)(row);
+                    },
+                },
+            };
+            const options = {
+                printLine: this.log.bind(this),
+                ...flags,
+            };
+            (0, table_formatter_1.formatTable)([res], columns, options);
+            process.exit(0);
+        }
+        catch (error) {
+            const cliError = error instanceof errors_1.NotionCLIError
+                ? error
+                : (0, errors_1.wrapNotionError)(error, {
+                    resourceType: 'block',
+                    attemptedId: args.block_id,
+                    endpoint: 'blocks.retrieve'
+                });
+            if (flags.json) {
+                this.log(JSON.stringify(cliError.toJSON(), null, 2));
+            }
+            else {
+                this.error(cliError.toHumanString());
+            }
+            process.exit(1);
+        }
+    }
+}
+BlockRetrieve.description = 'Retrieve a block';
+BlockRetrieve.aliases = ['block:r'];
+BlockRetrieve.examples = [
+    {
+        description: 'Retrieve a block',
+        command: `$ notion-cli block retrieve BLOCK_ID`,
+    },
+    {
+        description: 'Retrieve a block and output raw json',
+        command: `$ notion-cli block retrieve BLOCK_ID -r`,
+    },
+    {
+        description: 'Retrieve a block and output JSON for automation',
+        command: `$ notion-cli block retrieve BLOCK_ID --json`,
+    },
+];
+BlockRetrieve.args = {
+    block_id: core_1.Args.string({ required: true }),
+};
+BlockRetrieve.flags = {
+    raw: core_1.Flags.boolean({
+        char: 'r',
+        description: 'output raw json',
+    }),
+    ...table_formatter_1.tableFlags,
+    ...base_flags_1.AutomationFlags,
+};
+exports.default = BlockRetrieve;

package/dist/commands/block/update.d.ts

@@ -0,0 +1,45 @@
+import { Command } from '@oclif/core';
+export default class BlockUpdate extends Command {
+    static description: string;
+    static aliases: string[];
+    static examples: {
+        description: string;
+        command: string;
+    }[];
+    static args: {
+        block_id: 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>;
+        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>;
+        archived: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        content: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        text: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'heading-1': import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'heading-2': import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'heading-3': import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        bullet: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        numbered: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        todo: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        toggle: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        code: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        language: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        quote: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        callout: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        color: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        raw: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/block/update.js

@@ -0,0 +1,241 @@
+"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 client_1 = require("@notionhq/client");
+const helper_1 = require("../../helper");
+const notion_resolver_1 = require("../../utils/notion-resolver");
+const base_flags_1 = require("../../base-flags");
+const errors_1 = require("../../errors");
+class BlockUpdate extends core_1.Command {
+    async run() {
+        const { args, flags } = await this.parse(BlockUpdate);
+        try {
+            // Resolve block ID from URL or direct ID
+            const blockId = await (0, notion_resolver_1.resolveNotionId)(args.block_id, 'page');
+            const params = {
+                block_id: blockId,
+            };
+            // Handle archived flag
+            if (flags.archived !== undefined) {
+                params.archived = flags.archived;
+            }
+            // Check if using simple text-based flags or complex JSON
+            const hasTextFlags = flags.text || flags['heading-1'] || flags['heading-2'] || flags['heading-3'] ||
+                flags.bullet || flags.numbered || flags.todo || flags.toggle ||
+                flags.code || flags.quote || flags.callout;
+            if (hasTextFlags && flags.content) {
+                this.error('Cannot use both text-based flags (--text, --heading-1, etc.) and --content flag together. Choose one approach.');
+            }
+            // Handle content updates
+            if (hasTextFlags) {
+                // Use simple text-based flags
+                const blockUpdate = (0, helper_1.buildBlockUpdateFromTextFlags)('', {
+                    text: flags.text,
+                    heading1: flags['heading-1'],
+                    heading2: flags['heading-2'],
+                    heading3: flags['heading-3'],
+                    bullet: flags.bullet,
+                    numbered: flags.numbered,
+                    todo: flags.todo,
+                    toggle: flags.toggle,
+                    code: flags.code,
+                    language: flags.language,
+                    quote: flags.quote,
+                    callout: flags.callout,
+                });
+                if (blockUpdate) {
+                    Object.assign(params, blockUpdate);
+                }
+            }
+            else if (flags.content) {
+                // Use complex JSON
+                try {
+                    const content = JSON.parse(flags.content);
+                    Object.assign(params, content);
+                }
+                catch (error) {
+                    throw errors_1.NotionCLIErrorFactory.invalidJson(flags.content, error);
+                }
+            }
+            // Handle color updates
+            if (flags.color) {
+                // Retrieve the block to determine its type
+                const blockResponse = await notion.retrieveBlock(blockId);
+                // Ensure we have a full block response
+                if (!(0, client_1.isFullBlock)(blockResponse)) {
+                    throw new errors_1.NotionCLIError(errors_1.NotionCLIErrorCode.API_ERROR, 'Received partial block response. Cannot determine block type for color update.', [], { attemptedId: blockId });
+                }
+                // Color is only supported for certain block types
+                const colorSupportedTypes = [
+                    'paragraph', 'heading_1', 'heading_2', 'heading_3',
+                    'bulleted_list_item', 'numbered_list_item', 'toggle',
+                    'quote', 'callout'
+                ];
+                if (!colorSupportedTypes.includes(blockResponse.type)) {
+                    this.error(`Color property is not supported for block type: ${blockResponse.type}. Supported types: ${colorSupportedTypes.join(', ')}`);
+                }
+                // Color must be nested within the block type property
+                params[blockResponse.type] = {
+                    ...params[blockResponse.type],
+                    color: flags.color
+                };
+            }
+            const res = await notion.updateBlock(params);
+            // Handle JSON output for automation
+            if (flags.json) {
+                this.log(JSON.stringify({
+                    success: true,
+                    data: res,
+                    timestamp: new Date().toISOString()
+                }, null, 2));
+                process.exit(0);
+                return;
+            }
+            // Handle raw JSON output (legacy)
+            if (flags.raw) {
+                (0, helper_1.outputRawJson)(res);
+                process.exit(0);
+                return;
+            }
+            // Handle table output
+            const columns = {
+                object: {},
+                id: {},
+                type: {},
+                parent: {},
+                content: {
+                    get: (row) => {
+                        return (0, helper_1.getBlockPlainText)(row);
+                    },
+                },
+            };
+            const options = {
+                printLine: this.log.bind(this),
+                ...flags,
+            };
+            (0, table_formatter_1.formatTable)([res], columns, options);
+            process.exit(0);
+        }
+        catch (error) {
+            const cliError = error instanceof errors_1.NotionCLIError
+                ? error
+                : (0, errors_1.wrapNotionError)(error, {
+                    resourceType: 'block',
+                    attemptedId: args.block_id,
+                    endpoint: 'blocks.update',
+                    userInput: flags.content
+                });
+            if (flags.json) {
+                this.log(JSON.stringify(cliError.toJSON(), null, 2));
+            }
+            else {
+                this.error(cliError.toHumanString());
+            }
+            process.exit(1);
+        }
+    }
+}
+BlockUpdate.description = 'Update a block';
+BlockUpdate.aliases = ['block:u'];
+BlockUpdate.examples = [
+    {
+        description: 'Update block with simple text',
+        command: `$ notion-cli block update BLOCK_ID --text "Updated content"`,
+    },
+    {
+        description: 'Update heading content',
+        command: `$ notion-cli block update BLOCK_ID --heading-1 "New Title"`,
+    },
+    {
+        description: 'Update code block',
+        command: `$ notion-cli block update BLOCK_ID --code "const x = 42;" --language javascript`,
+    },
+    {
+        description: 'Archive a block',
+        command: `$ notion-cli block update BLOCK_ID -a`,
+    },
+    {
+        description: 'Archive a block via URL',
+        command: `$ notion-cli block update https://notion.so/BLOCK_ID -a`,
+    },
+    {
+        description: 'Update block content with complex JSON (for advanced cases)',
+        command: `$ notion-cli block update BLOCK_ID -c '{"paragraph":{"rich_text":[{"text":{"content":"Updated text"}}]}}'`,
+    },
+    {
+        description: 'Update block color',
+        command: `$ notion-cli block update BLOCK_ID --color blue`,
+    },
+    {
+        description: 'Update a block and output raw json',
+        command: `$ notion-cli block update BLOCK_ID --text "Updated" -r`,
+    },
+    {
+        description: 'Update a block and output JSON for automation',
+        command: `$ notion-cli block update BLOCK_ID --text "Updated" --json`,
+    },
+];
+BlockUpdate.args = {
+    block_id: core_1.Args.string({ description: 'Block ID or URL', required: true }),
+};
+BlockUpdate.flags = {
+    archived: core_1.Flags.boolean({
+        char: 'a',
+        description: 'Archive the block',
+    }),
+    content: core_1.Flags.string({
+        char: 'c',
+        description: 'Updated block content (JSON object with block type properties) - for complex cases',
+    }),
+    // Simple text-based flags
+    text: core_1.Flags.string({
+        description: 'Update paragraph text',
+    }),
+    'heading-1': core_1.Flags.string({
+        description: 'Update H1 heading text',
+    }),
+    'heading-2': core_1.Flags.string({
+        description: 'Update H2 heading text',
+    }),
+    'heading-3': core_1.Flags.string({
+        description: 'Update H3 heading text',
+    }),
+    bullet: core_1.Flags.string({
+        description: 'Update bulleted list item text',
+    }),
+    numbered: core_1.Flags.string({
+        description: 'Update numbered list item text',
+    }),
+    todo: core_1.Flags.string({
+        description: 'Update to-do item text',
+    }),
+    toggle: core_1.Flags.string({
+        description: 'Update toggle block text',
+    }),
+    code: core_1.Flags.string({
+        description: 'Update code block content',
+    }),
+    language: core_1.Flags.string({
+        description: 'Update code block language (used with --code)',
+        default: 'plain text',
+    }),
+    quote: core_1.Flags.string({
+        description: 'Update quote block text',
+    }),
+    callout: core_1.Flags.string({
+        description: 'Update callout block text',
+    }),
+    color: core_1.Flags.string({
+        description: 'Block color (for supported block types)',
+        options: ['default', 'gray', 'brown', 'orange', 'yellow', 'green', 'blue', 'purple', 'pink', 'red'],
+    }),
+    raw: core_1.Flags.boolean({
+        char: 'r',
+        description: 'output raw json',
+    }),
+    ...table_formatter_1.tableFlags,
+    ...base_flags_1.AutomationFlags,
+};
+exports.default = BlockUpdate;

package/dist/commands/cache/info.d.ts

@@ -0,0 +1,19 @@
+import { Command } from '@oclif/core';
+export default class CacheInfo extends Command {
+    static description: string;
+    static aliases: string[];
+    static examples: {
+        description: string;
+        command: string;
+    }[];
+    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>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/cache/info.js

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const base_flags_1 = require("../../base-flags");
+const workspace_cache_1 = require("../../utils/workspace-cache");
+const cache_1 = require("../../cache");
+const errors_1 = require("../../errors");
+class CacheInfo extends core_1.Command {
+    async run() {
+        const { flags } = await this.parse(CacheInfo);
+        try {
+            // Get workspace cache
+            const workspaceCache = await (0, workspace_cache_1.loadCache)();
+            const cachePath = await (0, workspace_cache_1.getCachePath)();
+            // Get in-memory cache stats
+            const inMemoryStats = cache_1.cacheManager.getStats();
+            const hitRate = cache_1.cacheManager.getHitRate();
+            // Calculate workspace cache age if available
+            let workspaceInfo = null;
+            if (workspaceCache) {
+                const lastSyncTime = new Date(workspaceCache.lastSync);
+                const cacheAgeMs = Date.now() - lastSyncTime.getTime();
+                const cacheAgeHours = cacheAgeMs / (1000 * 60 * 60);
+                const isStale = cacheAgeHours > 24;
+                workspaceInfo = {
+                    databases_cached: workspaceCache.databases.length,
+                    last_sync: workspaceCache.lastSync,
+                    cache_age_ms: cacheAgeMs,
+                    cache_age_hours: parseFloat(cacheAgeHours.toFixed(2)),
+                    is_stale: isStale,
+                    stale_threshold_hours: 24,
+                    cache_version: workspaceCache.version,
+                    cache_location: cachePath,
+                };
+            }
+            // Build comprehensive cache info
+            const cacheInfo = {
+                in_memory: {
+                    enabled: cache_1.cacheManager.isEnabled(),
+                    stats: {
+                        size: inMemoryStats.size,
+                        hits: inMemoryStats.hits,
+                        misses: inMemoryStats.misses,
+                        sets: inMemoryStats.sets,
+                        evictions: inMemoryStats.evictions,
+                        hit_rate: parseFloat((hitRate * 100).toFixed(2)),
+                    },
+                    ttls_ms: {
+                        data_source: parseInt(process.env.NOTION_CLI_CACHE_DS_TTL || '600000', 10),
+                        page: parseInt(process.env.NOTION_CLI_CACHE_PAGE_TTL || '60000', 10),
+                        user: parseInt(process.env.NOTION_CLI_CACHE_USER_TTL || '3600000', 10),
+                        block: parseInt(process.env.NOTION_CLI_CACHE_BLOCK_TTL || '30000', 10),
+                    },
+                    max_size: parseInt(process.env.NOTION_CLI_CACHE_MAX_SIZE || '1000', 10),
+                },
+                workspace: workspaceInfo,
+                recommendations: {
+                    sync_interval_hours: 24,
+                    next_sync: workspaceCache ?
+                        new Date(new Date(workspaceCache.lastSync).getTime() + 24 * 60 * 60 * 1000).toISOString() :
+                        null,
+                    action_needed: !workspaceCache ? 'Run "notion-cli sync" to initialize cache' :
+                        (workspaceInfo && workspaceInfo.is_stale) ? 'Cache is stale, run "notion-cli sync"' :
+                            'Cache is fresh',
+                },
+            };
+            // JSON output
+            if (flags.json) {
+                this.log(JSON.stringify({
+                    success: true,
+                    data: cacheInfo,
+                    metadata: {
+                        timestamp: new Date().toISOString(),
+                        command: 'cache:info',
+                    },
+                }, null, 2));
+                process.exit(0);
+            }
+            // Human-readable output
+            this.log('Cache Configuration');
+            this.log('='.repeat(60));
+            this.log('\nIn-Memory Cache:');
+            this.log(`  Enabled: ${cacheInfo.in_memory.enabled ? 'Yes' : 'No'}`);
+            this.log(`  Size: ${inMemoryStats.size} / ${cacheInfo.in_memory.max_size}`);
+            this.log(`  Hits: ${inMemoryStats.hits}`);
+            this.log(`  Misses: ${inMemoryStats.misses}`);
+            this.log(`  Hit Rate: ${(hitRate * 100).toFixed(1)}%`);
+            this.log(`  Evictions: ${inMemoryStats.evictions}`);
+            this.log('\n  TTLs (milliseconds):');
+            this.log(`    Data Sources: ${cacheInfo.in_memory.ttls_ms.data_source} (${(cacheInfo.in_memory.ttls_ms.data_source / 60000).toFixed(0)} min)`);
+            this.log(`    Pages: ${cacheInfo.in_memory.ttls_ms.page} (${(cacheInfo.in_memory.ttls_ms.page / 1000).toFixed(0)} sec)`);
+            this.log(`    Users: ${cacheInfo.in_memory.ttls_ms.user} (${(cacheInfo.in_memory.ttls_ms.user / 60000).toFixed(0)} min)`);
+            this.log(`    Blocks: ${cacheInfo.in_memory.ttls_ms.block} (${(cacheInfo.in_memory.ttls_ms.block / 1000).toFixed(0)} sec)`);
+            this.log('\nWorkspace Cache:');
+            if (workspaceInfo) {
+                this.log(`  Databases: ${workspaceInfo.databases_cached}`);
+                this.log(`  Last Sync: ${new Date(workspaceInfo.last_sync).toLocaleString()}`);
+                this.log(`  Age: ${workspaceInfo.cache_age_hours} hours`);
+                this.log(`  Status: ${workspaceInfo.is_stale ? '⚠️  STALE' : '✓ Fresh'}`);
+                this.log(`  Location: ${workspaceInfo.cache_location}`);
+            }
+            else {
+                this.log(`  Status: Not initialized`);
+                this.log(`  Action: Run "notion-cli sync"`);
+            }
+            this.log('\nRecommendations:');
+            this.log(`  Sync Interval: Every ${cacheInfo.recommendations.sync_interval_hours} hours`);
+            if (cacheInfo.recommendations.next_sync) {
+                this.log(`  Next Sync: ${new Date(cacheInfo.recommendations.next_sync).toLocaleString()}`);
+            }
+            this.log(`  Action: ${cacheInfo.recommendations.action_needed}`);
+            process.exit(0);
+        }
+        catch (error) {
+            const cliError = error instanceof errors_1.NotionCLIError
+                ? error
+                : (0, errors_1.wrapNotionError)(error instanceof Error ? error : new Error(String(error)), {
+                    endpoint: 'cache.info'
+                });
+            if (flags.json) {
+                this.log(JSON.stringify(cliError.toJSON(), null, 2));
+            }
+            else {
+                this.error(cliError.toHumanString());
+            }
+            process.exit(1);
+        }
+    }
+}
+CacheInfo.description = 'Show cache statistics and configuration';
+CacheInfo.aliases = ['cache:stats', 'cache:status'];
+CacheInfo.examples = [
+    {
+        description: 'Show cache info in JSON format',
+        command: 'notion-cli cache:info --json',
+    },
+    {
+        description: 'Show cache statistics',
+        command: 'notion-cli cache:info',
+    },
+];
+CacheInfo.flags = {
+    ...base_flags_1.AutomationFlags,
+};
+exports.default = CacheInfo;

package/dist/commands/config/set-token.d.ts

@@ -0,0 +1,30 @@
+import { Command } from "@oclif/core";
+export default class ConfigSetToken extends Command {
+    static description: string;
+    static aliases: string[];
+    static examples: {
+        description: string;
+        command: string;
+    }[];
+    static args: {
+        token: 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>;
+    };
+    run(): Promise<void>;
+    /**
+     * Detect the current shell
+     */
+    private detectShell;
+    /**
+     * Get the rc file path for the detected shell
+     */
+    private getRcFilePath;
+}