@catafal/notion-cli 5.9.0

package/dist/commands/stats.js

@@ -0,0 +1,274 @@
+"use strict";
+/**
+ * Stats Dashboard Command
+ *
+ * Shows a bird's-eye view of the Notion workspace: database count, user count,
+ * property type breakdown, and per-database details. Data comes primarily from
+ * the workspace cache (fast), with optional --live flag for page counts (slower).
+ *
+ *   notion-cli stats              # fast dashboard from cache
+ *   notion-cli stats --live       # also fetch page counts per DB
+ *   notion-cli stats --relations  # show database relation graph
+ *   notion-cli stats --json       # JSON output for automation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const workspace_cache_1 = require("../utils/workspace-cache");
+const base_flags_1 = require("../base-flags");
+const errors_1 = require("../errors");
+const notion = require("../notion");
+class Stats extends core_1.Command {
+    async run() {
+        var _a, _b;
+        const { flags } = await this.parse(Stats);
+        try {
+            // 1. Load workspace cache — the primary data source (free, no API calls)
+            const cache = await (0, workspace_cache_1.loadCache)();
+            if (!cache || cache.databases.length === 0) {
+                throw errors_1.NotionCLIErrorFactory.workspaceNotSynced('');
+            }
+            // 2. Fetch workspace info + users (cached API calls, fast)
+            //    Both calls can fail if the token lacks permissions — handle gracefully.
+            let workspaceName = 'Unknown';
+            let userCount = null;
+            try {
+                const botInfo = await notion.botUser();
+                workspaceName = ((_a = botInfo === null || botInfo === void 0 ? void 0 : botInfo.bot) === null || _a === void 0 ? void 0 : _a.workspace_name) || 'Unknown';
+            }
+            catch { /* bot info unavailable — non-critical */ }
+            try {
+                const usersResponse = await notion.listUser();
+                userCount = usersResponse.results.length;
+            }
+            catch { /* users endpoint needs extra permissions — skip gracefully */ }
+            // 3. Aggregate property types across all databases (from cache, no API)
+            const propertyTypeCounts = {};
+            const dbDetails = [];
+            for (const db of cache.databases) {
+                const propCount = db.properties ? Object.keys(db.properties).length : 0;
+                dbDetails.push({ title: db.title, shortId: db.id.slice(0, 8), propertyCount: propCount });
+                // Count each property type across the workspace
+                if (db.properties) {
+                    for (const prop of Object.values(db.properties)) {
+                        const type = prop.type || 'unknown';
+                        propertyTypeCounts[type] = (propertyTypeCounts[type] || 0) + 1;
+                    }
+                }
+            }
+            // Sort databases by property count (most complex first)
+            dbDetails.sort((a, b) => b.propertyCount - a.propertyCount);
+            // 3b. Extract database relation edges (from cache, no API calls).
+            //     Each relation property points to a target database via database_id or data_source_id.
+            //     We resolve the target name by looking it up in the cache.
+            const idToTitle = new Map(cache.databases.flatMap(db => [
+                [db.id, db.title],
+                // Also index by database_id (relation properties may use either ID format)
+                ...(db.url ? [[db.url, db.title]] : []),
+            ]));
+            const relationEdges = [];
+            for (const db of cache.databases) {
+                if (!db.properties)
+                    continue;
+                for (const prop of Object.values(db.properties)) {
+                    const p = prop;
+                    if (p.type !== 'relation' || !p.relation)
+                        continue;
+                    // Resolve target name — try data_source_id first, then database_id
+                    const targetId = p.relation.data_source_id || p.relation.database_id || '';
+                    const target = idToTitle.get(targetId) || `Unknown (${targetId.slice(0, 8)})`;
+                    relationEdges.push({
+                        source: db.title,
+                        sourceId: db.id.slice(0, 8),
+                        property: p.name || Object.keys(db.properties).find(k => db.properties[k] === prop) || '?',
+                        target,
+                        targetId: targetId.slice(0, 8),
+                    });
+                }
+            }
+            // 4. Optional: fetch page counts per database (expensive, behind --live flag)
+            let totalPages;
+            if (flags.live) {
+                totalPages = 0;
+                for (const db of cache.databases) {
+                    try {
+                        const pages = await notion.fetchAllPagesInDS(db.id);
+                        const count = pages.length;
+                        totalPages += count;
+                        // Update the matching entry in dbDetails
+                        const detail = dbDetails.find(d => d.title === db.title);
+                        if (detail)
+                            detail.pages = count;
+                    }
+                    catch {
+                        // If a DB query fails (permissions, deleted), skip it gracefully
+                        const detail = dbDetails.find(d => d.title === db.title);
+                        if (detail)
+                            detail.pages = -1;
+                    }
+                }
+                // Re-sort by page count when live data is available
+                dbDetails.sort((a, b) => { var _a, _b; return ((_a = b.pages) !== null && _a !== void 0 ? _a : 0) - ((_b = a.pages) !== null && _b !== void 0 ? _b : 0); });
+            }
+            // 5. Calculate cache age for display
+            const cacheAgeMs = Date.now() - new Date(cache.lastSync).getTime();
+            const cacheAgeLabel = this.formatAge(cacheAgeMs);
+            // 6. Sort property types by count (most used first)
+            const sortedTypes = Object.entries(propertyTypeCounts)
+                .sort(([, a], [, b]) => b - a);
+            // --- Output ---
+            if (flags.json) {
+                this.log(JSON.stringify({
+                    success: true,
+                    data: {
+                        workspace: workspaceName,
+                        databases: {
+                            count: cache.databases.length,
+                            items: dbDetails,
+                        },
+                        ...(userCount !== null && { users: { count: userCount } }),
+                        property_types: propertyTypeCounts,
+                        ...(totalPages !== undefined && { pages: { total: totalPages } }),
+                        ...(flags.relations && { relations: relationEdges }),
+                        cache: {
+                            last_sync: cache.lastSync,
+                            age_ms: cacheAgeMs,
+                        },
+                    },
+                    timestamp: new Date().toISOString(),
+                }, null, 2));
+                process.exit(0);
+                return;
+            }
+            // Human-readable dashboard
+            this.log('');
+            const userLabel = userCount !== null ? ` | Users: ${userCount}` : '';
+            const summary = totalPages !== undefined
+                ? `Databases: ${cache.databases.length}${userLabel} | Total Pages: ${totalPages}`
+                : `Databases: ${cache.databases.length}${userLabel}`;
+            this.log(`Workspace: ${workspaceName}`);
+            this.log(summary);
+            // Database table — includes short ID to disambiguate duplicate names
+            this.log('\nDatabases');
+            this.log('─'.repeat(65));
+            const nameWidth = 36;
+            const header = flags.live
+                ? `${'Name'.padEnd(nameWidth)}  ${'ID'.padEnd(8)}  ${'Props'.padStart(5)}  ${'Pages'.padStart(5)}`
+                : `${'Name'.padEnd(nameWidth)}  ${'ID'.padEnd(8)}  ${'Props'.padStart(5)}`;
+            this.log(header);
+            for (const db of dbDetails) {
+                const name = db.title.length > nameWidth
+                    ? db.title.slice(0, nameWidth - 1) + '…'
+                    : db.title.padEnd(nameWidth);
+                const props = String(db.propertyCount).padStart(5);
+                if (flags.live) {
+                    const pages = db.pages === -1 ? '  err' : String((_b = db.pages) !== null && _b !== void 0 ? _b : '-').padStart(5);
+                    this.log(`${name}  ${db.shortId}  ${props}  ${pages}`);
+                }
+                else {
+                    this.log(`${name}  ${db.shortId}  ${props}`);
+                }
+            }
+            // Property type breakdown
+            this.log('\nProperty Types');
+            this.log('─'.repeat(30));
+            for (const [type, count] of sortedTypes) {
+                this.log(`${type.padEnd(20)}  ${String(count).padStart(4)}`);
+            }
+            // Relation graph — shows which databases connect to which
+            if (flags.relations) {
+                this.log('\nRelation Graph');
+                this.log('─'.repeat(55));
+                // Group edges by source database
+                const bySource = new Map();
+                for (const edge of relationEdges) {
+                    const key = edge.source;
+                    if (!bySource.has(key))
+                        bySource.set(key, []);
+                    bySource.get(key).push(edge);
+                }
+                // Databases with relations
+                for (const [source, edges] of bySource) {
+                    const srcId = edges[0].sourceId;
+                    this.log(`${source}  ${srcId}`);
+                    for (const edge of edges) {
+                        this.log(`  → ${edge.target}  (via "${edge.property}")`);
+                    }
+                }
+                // Databases without any relations
+                const sourcesWithRelations = new Set(bySource.keys());
+                const isolated = cache.databases
+                    .filter(db => !sourcesWithRelations.has(db.title))
+                    .map(db => db.title);
+                if (isolated.length > 0) {
+                    this.log(`\nIsolated (no relations): ${isolated.join(', ')}`);
+                }
+            }
+            // Footer
+            this.log(`\nCache: synced ${cacheAgeLabel}`);
+            if (!flags.live) {
+                this.log('Tip: Run with --live to fetch page counts per database.');
+            }
+            process.exit(0);
+        }
+        catch (error) {
+            const cliError = error instanceof errors_1.NotionCLIError
+                ? error
+                : (0, errors_1.wrapNotionError)(error, {
+                    endpoint: 'workspace.stats',
+                    resourceType: 'workspace',
+                });
+            if (flags.json) {
+                this.log(JSON.stringify(cliError.toJSON(), null, 2));
+            }
+            else {
+                this.error(cliError.toHumanString());
+            }
+            process.exit(1);
+        }
+    }
+    /** Convert milliseconds to a human-friendly age string (e.g. "2h ago"). */
+    formatAge(ms) {
+        const minutes = Math.floor(ms / 60000);
+        if (minutes < 1)
+            return 'just now';
+        if (minutes < 60)
+            return `${minutes}m ago`;
+        const hours = Math.floor(minutes / 60);
+        if (hours < 24)
+            return `${hours}h ago`;
+        const days = Math.floor(hours / 24);
+        return `${days}d ago`;
+    }
+}
+Stats.description = 'Show workspace statistics dashboard';
+Stats.aliases = ['dashboard'];
+Stats.examples = [
+    {
+        description: 'Show workspace statistics',
+        command: '$ notion-cli stats',
+    },
+    {
+        description: 'Include page counts per database (slower)',
+        command: '$ notion-cli stats --live',
+    },
+    {
+        description: 'Show database relation graph',
+        command: '$ notion-cli stats --relations',
+    },
+    {
+        description: 'JSON output for automation',
+        command: '$ notion-cli stats --json',
+    },
+];
+Stats.flags = {
+    ...base_flags_1.AutomationFlags,
+    live: core_1.Flags.boolean({
+        description: 'Fetch page counts per database (requires API calls)',
+        default: false,
+    }),
+    relations: core_1.Flags.boolean({
+        description: 'Show database relation graph (from cache, no API calls)',
+        default: false,
+    }),
+};
+exports.default = Stats;

package/dist/commands/sync.d.ts

@@ -0,0 +1,24 @@
+import { Command } from '@oclif/core';
+export default class Sync 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>;
+        force: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+    /**
+     * Fetch all databases from Notion API with pagination
+     */
+    private fetchAllDatabases;
+}

package/dist/commands/sync.js

@@ -0,0 +1,183 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const notion_1 = require("../notion");
+const retry_1 = require("../retry");
+const workspace_cache_1 = require("../utils/workspace-cache");
+const base_flags_1 = require("../base-flags");
+const errors_1 = require("../errors");
+const token_validator_1 = require("../utils/token-validator");
+class Sync extends core_1.Command {
+    async run() {
+        const { flags } = await this.parse(Sync);
+        const startTime = Date.now();
+        try {
+            // Verify NOTION_TOKEN is set (throws if not)
+            (0, token_validator_1.validateNotionToken)();
+            if (!flags.json) {
+                core_1.ux.action.start('Syncing workspace databases');
+            }
+            // Fetch all databases from Notion API with progress updates
+            const databases = await this.fetchAllDatabases(flags.json);
+            // const _fetchTime = Date.now() - startTime
+            if (!flags.json) {
+                core_1.ux.action.stop(`Found ${databases.length} database${databases.length === 1 ? '' : 's'}`);
+                core_1.ux.action.start('Generating search aliases');
+            }
+            // Build cache entries
+            const cacheEntries = databases.map(db => (0, workspace_cache_1.buildCacheEntry)(db));
+            if (!flags.json) {
+                core_1.ux.action.stop();
+                core_1.ux.action.start('Saving cache');
+            }
+            // Save to cache
+            const cache = {
+                version: '1.0.0',
+                lastSync: new Date().toISOString(),
+                databases: cacheEntries,
+            };
+            await (0, workspace_cache_1.saveCache)(cache);
+            const cachePath = await (0, workspace_cache_1.getCachePath)();
+            const executionTime = Date.now() - startTime;
+            // Build comprehensive metadata
+            const metadata = {
+                sync_time: new Date().toISOString(),
+                execution_time_ms: executionTime,
+                databases_found: databases.length,
+                cache_ttls: {
+                    in_memory: {
+                        data_source_ms: parseInt(process.env.NOTION_CLI_CACHE_DS_TTL || '600000', 10),
+                        page_ms: parseInt(process.env.NOTION_CLI_CACHE_PAGE_TTL || '60000', 10),
+                        user_ms: parseInt(process.env.NOTION_CLI_CACHE_USER_TTL || '3600000', 10),
+                        block_ms: parseInt(process.env.NOTION_CLI_CACHE_BLOCK_TTL || '30000', 10),
+                    },
+                    workspace: {
+                        persistence: 'until next sync',
+                        recommended_sync_interval_hours: 24,
+                    },
+                },
+                next_recommended_sync: new Date(Date.now() + 24 * 60 * 60 * 1000).toISOString(),
+                cache_location: cachePath,
+            };
+            if (flags.json) {
+                this.log(JSON.stringify({
+                    success: true,
+                    data: {
+                        databases: cacheEntries.map(db => ({
+                            id: db.id,
+                            title: db.title,
+                            aliases: db.aliases,
+                            url: db.url,
+                        })),
+                        summary: {
+                            total: databases.length,
+                            cached_at: cache.lastSync,
+                            cache_version: cache.version,
+                        },
+                    },
+                    metadata,
+                }, null, 2));
+            }
+            else {
+                core_1.ux.action.stop();
+                // Enhanced completion summary
+                const elapsedSeconds = (executionTime / 1000).toFixed(2);
+                this.log(`\n✓ Synced ${databases.length} database${databases.length === 1 ? '' : 's'} in ${elapsedSeconds}s`);
+                this.log('');
+                this.log(`📁 Cache: ${cachePath}`);
+                this.log(`🕐 Last updated: ${new Date(cache.lastSync).toLocaleString()}`);
+                this.log(`📊 Databases: ${databases.length} total`);
+                this.log('');
+                this.log(`Next sync recommended: ${new Date(metadata.next_recommended_sync).toLocaleString()}`);
+                if (databases.length > 0) {
+                    this.log('\nIndexed databases:');
+                    cacheEntries.slice(0, 10).forEach(db => {
+                        const aliasesStr = db.aliases.slice(0, 3).join(', ');
+                        this.log(`  • ${db.title} (aliases: ${aliasesStr})`);
+                    });
+                    if (databases.length > 10) {
+                        this.log(`  ... and ${databases.length - 10} more`);
+                    }
+                    this.log('\nTry: notion-cli list');
+                }
+                else {
+                    this.log('\nNo databases found in workspace.');
+                    this.log('Make sure your integration has access to databases.');
+                }
+            }
+            process.exit(0);
+        }
+        catch (error) {
+            const cliError = error instanceof errors_1.NotionCLIError
+                ? error
+                : (0, errors_1.wrapNotionError)(error, {
+                    endpoint: 'search',
+                    resourceType: 'database'
+                });
+            if (flags.json) {
+                this.log(JSON.stringify(cliError.toJSON(), null, 2));
+            }
+            else {
+                core_1.ux.action.stop('failed');
+                this.error(cliError.toHumanString());
+            }
+            process.exit(1);
+        }
+    }
+    /**
+     * Fetch all databases from Notion API with pagination
+     */
+    async fetchAllDatabases(isJsonMode) {
+        const databases = [];
+        let cursor = undefined;
+        while (true) {
+            const response = await (0, retry_1.fetchWithRetry)(() => notion_1.client.search({
+                filter: {
+                    value: 'data_source',
+                    property: 'object',
+                },
+                start_cursor: cursor,
+                page_size: 100, // Max allowed by API
+            }), {
+                context: 'sync:fetchAllDatabases',
+                config: { maxRetries: 5 }, // Higher retries for sync
+            });
+            databases.push(...response.results);
+            // Show progress update (only in non-JSON mode)
+            if (!isJsonMode && response.has_more) {
+                // Update the spinner text to show current count
+                core_1.ux.action.start(`Syncing workspace databases (found ${databases.length} so far)`);
+            }
+            if (!response.has_more || !response.next_cursor) {
+                break;
+            }
+            cursor = response.next_cursor;
+        }
+        return databases;
+    }
+}
+Sync.description = 'Sync workspace databases to local cache for fast lookups';
+Sync.aliases = ['db:sync'];
+Sync.examples = [
+    {
+        description: 'Sync all workspace databases',
+        command: 'notion-cli sync',
+    },
+    {
+        description: 'Force resync even if cache exists',
+        command: 'notion-cli sync --force',
+    },
+    {
+        description: 'Sync and output as JSON',
+        command: 'notion-cli sync --json',
+    },
+];
+Sync.flags = {
+    force: core_1.Flags.boolean({
+        char: 'f',
+        description: 'Force resync even if cache is fresh',
+        default: false,
+    }),
+    ...base_flags_1.AutomationFlags,
+};
+exports.default = Sync;

package/dist/commands/template/get.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Template Get Command
+ *
+ * Displays the full contents of a saved template — properties, body content,
+ * and icon. Useful for inspecting a template before using it.
+ */
+import { Command } from '@oclif/core';
+export default class TemplateGet extends Command {
+    static description: string;
+    static aliases: string[];
+    static examples: {
+        description: string;
+        command: string;
+    }[];
+    static args: {
+        name: 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>;
+}

package/dist/commands/template/get.js

@@ -0,0 +1,59 @@
+"use strict";
+/**
+ * Template Get Command
+ *
+ * Displays the full contents of a saved template — properties, body content,
+ * and icon. Useful for inspecting a template before using it.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const templates_1 = require("../../utils/templates");
+const base_flags_1 = require("../../base-flags");
+class TemplateGet extends core_1.Command {
+    async run() {
+        const { args, flags } = await this.parse(TemplateGet);
+        const template = await (0, templates_1.getTemplate)(args.name);
+        if (!template) {
+            this.error(`Template "${args.name}" not found.\nRun \`notion-cli template list\` to see saved templates.`);
+            process.exit(1);
+            return;
+        }
+        if (flags.json) {
+            this.log(JSON.stringify({
+                success: true,
+                data: { name: args.name, ...template },
+                timestamp: new Date().toISOString()
+            }, null, 2));
+            process.exit(0);
+            return;
+        }
+        // Human-readable output
+        this.log(`Template: ${args.name}`);
+        if (template.icon)
+            this.log(`Icon: ${template.icon}`);
+        if (template.properties) {
+            this.log(`Properties:`);
+            this.log(JSON.stringify(template.properties, null, 2));
+        }
+        if (template.content) {
+            this.log(`Content:`);
+            this.log(template.content);
+        }
+        process.exit(0);
+    }
+}
+TemplateGet.description = 'View a saved template';
+TemplateGet.aliases = ['tpl:get'];
+TemplateGet.examples = [
+    {
+        description: 'View a template',
+        command: '$ notion-cli template get "meeting"',
+    },
+];
+TemplateGet.args = {
+    name: core_1.Args.string({ required: true, description: 'Template name' }),
+};
+TemplateGet.flags = {
+    ...base_flags_1.AutomationFlags,
+};
+exports.default = TemplateGet;

package/dist/commands/template/list.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Template List Command
+ *
+ * Shows all saved templates in a table with name, property count,
+ * content indicator, and icon.
+ */
+import { Command } from '@oclif/core';
+export default class TemplateList 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>;
+        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>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/template/list.js

@@ -0,0 +1,62 @@
+"use strict";
+/**
+ * Template List Command
+ *
+ * Shows all saved templates in a table with name, property count,
+ * content indicator, and icon.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const templates_1 = require("../../utils/templates");
+const table_formatter_1 = require("../../utils/table-formatter");
+const base_flags_1 = require("../../base-flags");
+class TemplateList extends core_1.Command {
+    async run() {
+        const { flags } = await this.parse(TemplateList);
+        const data = await (0, templates_1.loadTemplates)();
+        const entries = Object.entries(data.templates);
+        if (flags.json) {
+            this.log(JSON.stringify({
+                success: true,
+                data: { templates: data.templates },
+                timestamp: new Date().toISOString()
+            }, null, 2));
+            process.exit(0);
+            return;
+        }
+        if (entries.length === 0) {
+            this.log('No templates saved yet.');
+            this.log('Create one with: notion-cli template save <name> --properties \'{"Status": "To Do"}\'');
+            process.exit(0);
+            return;
+        }
+        // Build rows for table display
+        const rows = entries.map(([name, tmpl]) => ({
+            name,
+            properties: tmpl.properties ? Object.keys(tmpl.properties).length : 0,
+            content: tmpl.content ? 'yes' : '',
+            icon: tmpl.icon || '',
+        }));
+        const columns = {
+            name: {},
+            properties: { header: '# props' },
+            content: {},
+            icon: {},
+        };
+        (0, table_formatter_1.formatTable)(rows, columns, { printLine: this.log.bind(this), ...flags });
+        process.exit(0);
+    }
+}
+TemplateList.description = 'List all saved templates';
+TemplateList.aliases = ['tpl:ls'];
+TemplateList.examples = [
+    {
+        description: 'List all templates',
+        command: '$ notion-cli template list',
+    },
+];
+TemplateList.flags = {
+    ...table_formatter_1.tableFlags,
+    ...base_flags_1.AutomationFlags,
+};
+exports.default = TemplateList;