@eide/foir-cli 0.1.0

package/dist/commands/operations.js

@@ -0,0 +1,161 @@
+import { withErrorHandler } from '../lib/errors.js';
+import { createClient } from '../lib/client.js';
+import { formatOutput, formatList, timeAgo, success } from '../lib/output.js';
+import { parseInputData } from '../lib/input.js';
+import { OPERATIONS, OPERATION, EXECUTE_OPERATION, OPERATION_EXECUTION_STATS, DEAD_LETTER_OPERATIONS, RETRY_DEAD_LETTER, DISMISS_DEAD_LETTER, } from '../graphql/queries.js';
+export function registerOperationsCommands(program, globalOpts) {
+    const operations = program
+        .command('operations')
+        .description('Manage operations');
+    // list
+    operations
+        .command('list')
+        .description('List operations')
+        .option('--category <cat>', 'Filter by category')
+        .option('--active', 'Only active operations')
+        .option('--limit <n>', 'Max results', '50')
+        .action(withErrorHandler(globalOpts, async (cmdOpts) => {
+        const opts = globalOpts();
+        const client = await createClient(opts);
+        const data = await client.request(OPERATIONS, {
+            category: cmdOpts.category,
+            isActive: cmdOpts.active ? true : undefined,
+            limit: parseInt(String(cmdOpts.limit ?? '50'), 10),
+        });
+        formatList(data.operations, opts, {
+            columns: [
+                { key: 'key', header: 'Key', width: 24 },
+                { key: 'name', header: 'Name', width: 24 },
+                { key: 'category', header: 'Category', width: 14 },
+                {
+                    key: 'isActive',
+                    header: 'Active',
+                    width: 8,
+                    format: (v) => (v ? 'yes' : 'no'),
+                },
+                {
+                    key: 'updatedAt',
+                    header: 'Updated',
+                    width: 12,
+                    format: (v) => timeAgo(v),
+                },
+            ],
+        });
+    }));
+    // get
+    operations
+        .command('get <key>')
+        .description('Get an operation by key')
+        .action(withErrorHandler(globalOpts, async (key) => {
+        const opts = globalOpts();
+        const client = await createClient(opts);
+        const data = await client.request(OPERATION, { key });
+        if (!data.operation)
+            throw new Error(`Operation "${key}" not found.`);
+        formatOutput(data.operation, opts);
+    }));
+    // execute
+    operations
+        .command('execute <key>')
+        .description('Execute an operation')
+        .option('-d, --data <json>', 'Input data as JSON')
+        .option('-f, --file <path>', 'Read input from file')
+        .option('--async', 'Execute asynchronously')
+        .action(withErrorHandler(globalOpts, async (key, cmdOpts) => {
+        const opts = globalOpts();
+        const client = await createClient(opts);
+        let inputData = {};
+        if (cmdOpts.data || cmdOpts.file) {
+            inputData = await parseInputData(cmdOpts);
+        }
+        const data = await client.request(EXECUTE_OPERATION, {
+            input: {
+                operationKey: key,
+                input: inputData,
+                async: !!cmdOpts.async,
+            },
+        });
+        formatOutput(data.executeOperation, opts);
+        if (!(opts.json || opts.jsonl || opts.quiet)) {
+            const result = data.executeOperation;
+            if (result.success) {
+                success(`Operation completed in ${result.durationMs}ms`);
+            }
+            else {
+                const err = result.error;
+                console.error(`Operation failed: ${err?.message ?? 'Unknown error'}`);
+            }
+        }
+    }));
+    // stats
+    operations
+        .command('stats <key>')
+        .description('Get execution statistics for an operation')
+        .action(withErrorHandler(globalOpts, async (key) => {
+        const opts = globalOpts();
+        const client = await createClient(opts);
+        const data = await client.request(OPERATION_EXECUTION_STATS, { operationKey: key });
+        formatOutput(data.operationExecutionStats, opts);
+    }));
+    // dead-letters
+    operations
+        .command('dead-letters')
+        .description('List failed operations in the dead letter queue')
+        .option('--operation <key>', 'Filter by operation key')
+        .option('--status <status>', 'Filter by status (PENDING, RETRIED, DISMISSED)')
+        .option('--limit <n>', 'Max results', '20')
+        .action(withErrorHandler(globalOpts, async (cmdOpts) => {
+        const opts = globalOpts();
+        const client = await createClient(opts);
+        const data = await client.request(DEAD_LETTER_OPERATIONS, {
+            operationKey: cmdOpts.operation,
+            status: cmdOpts.status,
+            limit: parseInt(cmdOpts.limit ?? '20', 10),
+        });
+        formatList(data.deadLetterOperations.items, opts, {
+            columns: [
+                { key: 'id', header: 'ID', width: 28 },
+                { key: 'operationKey', header: 'Operation', width: 20 },
+                { key: 'attempts', header: 'Tries', width: 6 },
+                { key: 'lastError', header: 'Error', width: 36 },
+                { key: 'status', header: 'Status', width: 10 },
+                {
+                    key: 'failedAt',
+                    header: 'Failed',
+                    width: 12,
+                    format: (v) => timeAgo(v),
+                },
+            ],
+            total: data.deadLetterOperations.total,
+        });
+    }));
+    // retry-dead-letter
+    operations
+        .command('retry-dead-letter <id>')
+        .description('Retry a failed dead letter operation')
+        .action(withErrorHandler(globalOpts, async (id) => {
+        const opts = globalOpts();
+        const client = await createClient(opts);
+        const data = await client.request(RETRY_DEAD_LETTER, { id });
+        formatOutput(data.retryDeadLetterOperation, opts);
+        if (!(opts.json || opts.jsonl || opts.quiet)) {
+            const r = data.retryDeadLetterOperation;
+            if (r.success)
+                success('Retry succeeded');
+            else
+                console.error('Retry failed');
+        }
+    }));
+    // dismiss-dead-letter
+    operations
+        .command('dismiss-dead-letter <id>')
+        .description('Dismiss a dead letter operation without retrying')
+        .action(withErrorHandler(globalOpts, async (id) => {
+        const opts = globalOpts();
+        const client = await createClient(opts);
+        const data = await client.request(DISMISS_DEAD_LETTER, { id });
+        formatOutput(data.dismissDeadLetterOperation, opts);
+        if (!(opts.json || opts.jsonl || opts.quiet))
+            success(`Dismissed dead letter ${id}`);
+    }));
+}

package/dist/commands/records.d.ts

@@ -0,0 +1,4 @@
+import type { Command } from 'commander';
+import type { GlobalOptions } from '../lib/config.js';
+export declare function registerRecordsCommands(program: Command, globalOpts: () => GlobalOptions): void;
+//# sourceMappingURL=records.d.ts.map

package/dist/commands/records.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"records.d.ts","sourceRoot":"","sources":["../../src/commands/records.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACzC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAyBtD,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,OAAO,EAChB,UAAU,EAAE,MAAM,aAAa,GAC9B,IAAI,CA+SN"}

package/dist/commands/records.js

@@ -0,0 +1,216 @@
+import { withErrorHandler } from '../lib/errors.js';
+import { createClient } from '../lib/client.js';
+import { formatOutput, formatList, timeAgo, success } from '../lib/output.js';
+import { parseInputData, parseFilters, parseSort, isUUID, confirmAction, } from '../lib/input.js';
+import { RECORDS, RECORD, RECORD_BY_KEY, CREATE_RECORD, UPDATE_RECORD, DELETE_RECORD, PUBLISH_VERSION, UNPUBLISH_RECORD, DUPLICATE_RECORD, RECORD_VERSIONS, RECORD_VARIANTS, } from '../graphql/queries.js';
+export function registerRecordsCommands(program, globalOpts) {
+    const records = program.command('records').description('Manage records');
+    // list
+    records
+        .command('list <modelKey>')
+        .description('List records for a model')
+        .option('--filter <expr>', 'Filter expression (e.g. status=active)')
+        .option('--sort <expr>', 'Sort expression (e.g. createdAt:desc)')
+        .option('--limit <n>', 'Max results', '20')
+        .option('--offset <n>', 'Skip results', '0')
+        .action(withErrorHandler(globalOpts, async (modelKey, cmdOpts) => {
+        const opts = globalOpts();
+        const client = await createClient(opts);
+        const variables = {
+            modelKey,
+            limit: parseInt(cmdOpts.limit ?? '20', 10),
+            offset: parseInt(cmdOpts.offset ?? '0', 10),
+        };
+        if (cmdOpts.filter)
+            variables.filters = parseFilters(cmdOpts.filter);
+        if (cmdOpts.sort)
+            variables.sort = parseSort(cmdOpts.sort);
+        const data = await client.request(RECORDS, variables);
+        formatList(data.records.items, opts, {
+            columns: [
+                { key: 'id', header: 'ID', width: 28 },
+                { key: 'naturalKey', header: 'Key', width: 24 },
+                { key: 'recordType', header: 'Type', width: 10 },
+                { key: 'publishStatus', header: 'Status', width: 12 },
+                {
+                    key: 'updatedAt',
+                    header: 'Updated',
+                    width: 12,
+                    format: (v) => timeAgo(v),
+                },
+            ],
+            total: data.records.total,
+        });
+    }));
+    // get
+    records
+        .command('get <modelKey> <idOrKey>')
+        .description('Get a record by ID or natural key')
+        .action(withErrorHandler(globalOpts, async (modelKey, idOrKey) => {
+        const opts = globalOpts();
+        const client = await createClient(opts);
+        let result;
+        if (isUUID(idOrKey)) {
+            const data = await client.request(RECORD, { id: idOrKey });
+            result = data.record;
+        }
+        else {
+            const data = await client.request(RECORD_BY_KEY, { modelKey, naturalKey: idOrKey });
+            result = data.recordByKey;
+        }
+        if (!result) {
+            throw new Error(`Record "${idOrKey}" not found in model "${modelKey}".`);
+        }
+        formatOutput(result, opts);
+    }));
+    // create
+    records
+        .command('create <modelKey>')
+        .description('Create a new record')
+        .option('-d, --data <json>', 'Record data as JSON')
+        .option('-f, --file <path>', 'Read data from file')
+        .action(withErrorHandler(globalOpts, async (modelKey, cmdOpts) => {
+        const opts = globalOpts();
+        const client = await createClient(opts);
+        const inputData = await parseInputData(cmdOpts);
+        const input = { modelKey, ...inputData };
+        const data = await client.request(CREATE_RECORD, { input });
+        formatOutput(data.createRecord, opts);
+        if (!(opts.json || opts.jsonl || opts.quiet)) {
+            success(`Created record ${data.createRecord.record.id}`);
+        }
+    }));
+    // update
+    records
+        .command('update <modelKey> <id>')
+        .description('Update a record')
+        .option('-d, --data <json>', 'Record data as JSON')
+        .option('-f, --file <path>', 'Read data from file')
+        .action(withErrorHandler(globalOpts, async (_modelKey, id, cmdOpts) => {
+        const opts = globalOpts();
+        const client = await createClient(opts);
+        const inputData = await parseInputData(cmdOpts);
+        const input = { id, ...inputData };
+        const data = await client.request(UPDATE_RECORD, { input });
+        formatOutput(data.updateRecord, opts);
+        if (!(opts.json || opts.jsonl || opts.quiet)) {
+            success(`Updated record ${id}`);
+        }
+    }));
+    // delete
+    records
+        .command('delete <modelKey> <id>')
+        .description('Delete a record')
+        .option('--confirm', 'Skip confirmation prompt')
+        .action(withErrorHandler(globalOpts, async (_modelKey, id, cmdOpts) => {
+        const opts = globalOpts();
+        const confirmed = await confirmAction(`Delete record ${id}?`, {
+            confirm: !!cmdOpts.confirm,
+        });
+        if (!confirmed) {
+            console.log('Aborted.');
+            return;
+        }
+        const client = await createClient(opts);
+        const data = await client.request(DELETE_RECORD, { id });
+        formatOutput(data.deleteRecord, opts);
+        if (!(opts.json || opts.jsonl || opts.quiet)) {
+            success(`Deleted record ${id}`);
+        }
+    }));
+    // publish
+    records
+        .command('publish <versionId>')
+        .description('Publish a record version')
+        .action(withErrorHandler(globalOpts, async (versionId) => {
+        const opts = globalOpts();
+        const client = await createClient(opts);
+        await client.request(PUBLISH_VERSION, { versionId });
+        if (opts.json || opts.jsonl) {
+            formatOutput({ published: true, versionId }, opts);
+        }
+        else {
+            success(`Published version ${versionId}`);
+        }
+    }));
+    // unpublish
+    records
+        .command('unpublish <id>')
+        .description('Unpublish a record')
+        .action(withErrorHandler(globalOpts, async (id) => {
+        const opts = globalOpts();
+        const client = await createClient(opts);
+        await client.request(UNPUBLISH_RECORD, { id });
+        if (opts.json || opts.jsonl) {
+            formatOutput({ unpublished: true, id }, opts);
+        }
+        else {
+            success(`Unpublished record ${id}`);
+        }
+    }));
+    // duplicate
+    records
+        .command('duplicate <modelKey> <id>')
+        .description('Duplicate a record')
+        .option('--natural-key <key>', 'Natural key for the duplicate')
+        .action(withErrorHandler(globalOpts, async (_modelKey, id, cmdOpts) => {
+        const opts = globalOpts();
+        const client = await createClient(opts);
+        const naturalKey = cmdOpts.naturalKey ?? `${id}-copy`;
+        const data = await client.request(DUPLICATE_RECORD, { input: { recordId: id, naturalKey } });
+        formatOutput(data.duplicateRecord, opts);
+        if (!(opts.json || opts.jsonl || opts.quiet)) {
+            success(`Duplicated → ${data.duplicateRecord.record.id}`);
+        }
+    }));
+    // versions
+    records
+        .command('versions <id>')
+        .description('List versions for a record')
+        .option('--limit <n>', 'Max results', '20')
+        .action(withErrorHandler(globalOpts, async (parentId, cmdOpts) => {
+        const opts = globalOpts();
+        const client = await createClient(opts);
+        const data = await client.request(RECORD_VERSIONS, {
+            parentId,
+            limit: parseInt(cmdOpts.limit ?? '20', 10),
+        });
+        formatList(data.recordVersions.items, opts, {
+            columns: [
+                { key: 'id', header: 'Version ID', width: 28 },
+                { key: 'versionNumber', header: '#', width: 5 },
+                { key: 'publishStatus', header: 'Status', width: 12 },
+                { key: 'changeDescription', header: 'Description', width: 30 },
+                {
+                    key: 'createdAt',
+                    header: 'Created',
+                    width: 12,
+                    format: (v) => timeAgo(v),
+                },
+            ],
+        });
+    }));
+    // variants
+    records
+        .command('variants <recordId>')
+        .description('List variants for a record')
+        .action(withErrorHandler(globalOpts, async (recordId) => {
+        const opts = globalOpts();
+        const client = await createClient(opts);
+        const data = await client.request(RECORD_VARIANTS, { recordId });
+        formatList(data.recordVariants.items, opts, {
+            columns: [
+                { key: 'id', header: 'Variant ID', width: 28 },
+                { key: 'variantKey', header: 'Key', width: 20 },
+                { key: 'variantName', header: 'Name', width: 20 },
+                { key: 'isDefault', header: 'Default', width: 8 },
+                {
+                    key: 'createdAt',
+                    header: 'Created',
+                    width: 12,
+                    format: (v) => timeAgo(v),
+                },
+            ],
+        });
+    }));
+}

package/dist/commands/schedules.d.ts

@@ -0,0 +1,4 @@
+import type { Command } from 'commander';
+import type { GlobalOptions } from '../lib/config.js';
+export declare function registerSchedulesCommands(program: Command, globalOpts: () => GlobalOptions): void;
+//# sourceMappingURL=schedules.d.ts.map

package/dist/commands/schedules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schedules.d.ts","sourceRoot":"","sources":["../../src/commands/schedules.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACzC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAgBtD,wBAAgB,yBAAyB,CACvC,OAAO,EAAE,OAAO,EAChB,UAAU,EAAE,MAAM,aAAa,GAC9B,IAAI,CA4LN"}

package/dist/commands/schedules.js

@@ -0,0 +1,150 @@
+import { withErrorHandler } from '../lib/errors.js';
+import { createClient } from '../lib/client.js';
+import { formatOutput, formatList, timeAgo, success } from '../lib/output.js';
+import { parseInputData, confirmAction } from '../lib/input.js';
+import { SCHEDULES, SCHEDULE, CREATE_SCHEDULE, UPDATE_SCHEDULE, DELETE_SCHEDULE, PAUSE_SCHEDULE, RESUME_SCHEDULE, TRIGGER_SCHEDULE, } from '../graphql/queries.js';
+export function registerSchedulesCommands(program, globalOpts) {
+    const schedules = program
+        .command('schedules')
+        .description('Manage schedules');
+    // list
+    schedules
+        .command('list')
+        .description('List schedules')
+        .option('--active', 'Only active schedules')
+        .option('--limit <n>', 'Max results', '50')
+        .action(withErrorHandler(globalOpts, async (cmdOpts) => {
+        const opts = globalOpts();
+        const client = await createClient(opts);
+        const data = await client.request(SCHEDULES, {
+            isActive: cmdOpts.active ? true : undefined,
+            limit: parseInt(String(cmdOpts.limit ?? '50'), 10),
+        });
+        formatList(data.schedules.items, opts, {
+            columns: [
+                { key: 'key', header: 'Key', width: 20 },
+                { key: 'name', header: 'Name', width: 24 },
+                { key: 'cron', header: 'Cron', width: 16 },
+                {
+                    key: 'isActive',
+                    header: 'Active',
+                    width: 8,
+                    format: (v) => (v ? 'yes' : 'no'),
+                },
+                { key: 'lastRunStatus', header: 'Last Run', width: 10 },
+                {
+                    key: 'nextRunAt',
+                    header: 'Next Run',
+                    width: 12,
+                    format: (v) => timeAgo(v),
+                },
+            ],
+            total: data.schedules.total,
+        });
+    }));
+    // get
+    schedules
+        .command('get <key>')
+        .description('Get a schedule by key')
+        .action(withErrorHandler(globalOpts, async (key) => {
+        const opts = globalOpts();
+        const client = await createClient(opts);
+        const data = await client.request(SCHEDULE, { key });
+        if (!data.schedule)
+            throw new Error(`Schedule "${key}" not found.`);
+        formatOutput(data.schedule, opts);
+    }));
+    // create
+    schedules
+        .command('create')
+        .description('Create a new schedule')
+        .option('-d, --data <json>', 'Schedule data as JSON')
+        .option('-f, --file <path>', 'Read data from file')
+        .action(withErrorHandler(globalOpts, async (cmdOpts) => {
+        const opts = globalOpts();
+        const client = await createClient(opts);
+        const input = await parseInputData(cmdOpts);
+        const data = await client.request(CREATE_SCHEDULE, { input });
+        formatOutput(data.createSchedule, opts);
+        if (!(opts.json || opts.jsonl || opts.quiet))
+            success(`Created schedule ${data.createSchedule.key}`);
+    }));
+    // update
+    schedules
+        .command('update <key>')
+        .description('Update an existing schedule')
+        .option('-d, --data <json>', 'Schedule data as JSON')
+        .option('-f, --file <path>', 'Read data from file')
+        .action(withErrorHandler(globalOpts, async (key, cmdOpts) => {
+        const opts = globalOpts();
+        const client = await createClient(opts);
+        const input = await parseInputData(cmdOpts);
+        const data = await client.request(UPDATE_SCHEDULE, { key, input });
+        formatOutput(data.updateSchedule, opts);
+        if (!(opts.json || opts.jsonl || opts.quiet))
+            success(`Updated schedule "${key}"`);
+    }));
+    // trigger
+    schedules
+        .command('trigger <key>')
+        .description('Trigger a schedule immediately')
+        .action(withErrorHandler(globalOpts, async (key) => {
+        const opts = globalOpts();
+        const client = await createClient(opts);
+        const data = await client.request(TRIGGER_SCHEDULE, { key });
+        if (opts.json || opts.jsonl) {
+            formatOutput(data.triggerSchedule, opts);
+        }
+        else if (data.triggerSchedule.success) {
+            success(`Triggered schedule "${key}" (job: ${data.triggerSchedule.jobId ?? 'n/a'})`);
+        }
+        else {
+            throw new Error(data.triggerSchedule.error ?? 'Trigger failed');
+        }
+    }));
+    // pause
+    schedules
+        .command('pause <key>')
+        .description('Pause a schedule')
+        .action(withErrorHandler(globalOpts, async (key) => {
+        const opts = globalOpts();
+        const client = await createClient(opts);
+        const data = await client.request(PAUSE_SCHEDULE, { key });
+        formatOutput(data.pauseSchedule, opts);
+        if (!(opts.json || opts.jsonl || opts.quiet))
+            success(`Paused schedule "${key}"`);
+    }));
+    // resume
+    schedules
+        .command('resume <key>')
+        .description('Resume a paused schedule')
+        .action(withErrorHandler(globalOpts, async (key) => {
+        const opts = globalOpts();
+        const client = await createClient(opts);
+        const data = await client.request(RESUME_SCHEDULE, { key });
+        formatOutput(data.resumeSchedule, opts);
+        if (!(opts.json || opts.jsonl || opts.quiet))
+            success(`Resumed schedule "${key}"`);
+    }));
+    // delete
+    schedules
+        .command('delete <key>')
+        .description('Delete a schedule')
+        .option('--confirm', 'Skip confirmation prompt')
+        .action(withErrorHandler(globalOpts, async (key, cmdOpts) => {
+        const opts = globalOpts();
+        const confirmed = await confirmAction(`Delete schedule "${key}"?`, {
+            confirm: !!cmdOpts.confirm,
+        });
+        if (!confirmed) {
+            console.log('Aborted.');
+            return;
+        }
+        const client = await createClient(opts);
+        await client.request(DELETE_SCHEDULE, { key });
+        if (opts.json || opts.jsonl)
+            formatOutput({ deleted: true, key }, opts);
+        else
+            success(`Deleted schedule "${key}"`);
+    }));
+}

package/dist/commands/search.d.ts

@@ -0,0 +1,4 @@
+import type { Command } from 'commander';
+import type { GlobalOptions } from '../lib/config.js';
+export declare function registerSearchCommands(program: Command, globalOpts: () => GlobalOptions): void;
+//# sourceMappingURL=search.d.ts.map

package/dist/commands/search.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../../src/commands/search.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACzC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAMtD,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,OAAO,EAChB,UAAU,EAAE,MAAM,aAAa,GAC9B,IAAI,CA6EN"}

package/dist/commands/search.js

@@ -0,0 +1,60 @@
+import { withErrorHandler } from '../lib/errors.js';
+import { createClient } from '../lib/client.js';
+import { formatOutput, formatList, timeAgo } from '../lib/output.js';
+import { GLOBAL_SEARCH } from '../graphql/queries.js';
+export function registerSearchCommands(program, globalOpts) {
+    program
+        .command('search <query>')
+        .description('Search across all records and media')
+        .option('--models <keys>', 'Filter to specific model keys (comma-separated)')
+        .option('--limit <n>', 'Max results', '20')
+        .option('--no-media', 'Exclude media results')
+        .action(withErrorHandler(globalOpts, async (query, cmdOpts) => {
+        const opts = globalOpts();
+        const client = await createClient(opts);
+        const modelKeys = typeof cmdOpts.models === 'string'
+            ? cmdOpts.models.split(',').map((k) => k.trim())
+            : undefined;
+        const data = await client.request(GLOBAL_SEARCH, {
+            query,
+            limit: parseInt(String(cmdOpts.limit ?? '20'), 10),
+            modelKeys,
+            includeMedia: cmdOpts.media !== false,
+        });
+        if (opts.json || opts.jsonl) {
+            formatOutput(data.globalSearch, opts);
+            return;
+        }
+        if (data.globalSearch.records.length > 0) {
+            console.log(`\nRecords (${data.globalSearch.records.length}):`);
+            formatList(data.globalSearch.records, opts, {
+                columns: [
+                    { key: 'id', header: 'ID', width: 28 },
+                    { key: 'modelKey', header: 'Model', width: 18 },
+                    { key: 'title', header: 'Title', width: 28 },
+                    { key: 'naturalKey', header: 'Key', width: 20 },
+                    {
+                        key: 'updatedAt',
+                        header: 'Updated',
+                        width: 12,
+                        format: (v) => timeAgo(v),
+                    },
+                ],
+            });
+        }
+        if (data.globalSearch.media.length > 0) {
+            console.log(`\nMedia (${data.globalSearch.media.length}):`);
+            formatList(data.globalSearch.media, opts, {
+                columns: [
+                    { key: 'id', header: 'ID', width: 28 },
+                    { key: 'fileName', header: 'File', width: 30 },
+                    { key: 'altText', header: 'Alt', width: 24 },
+                ],
+            });
+        }
+        if (data.globalSearch.records.length === 0 &&
+            data.globalSearch.media.length === 0) {
+            console.log('No results found.');
+        }
+    }));
+}

package/dist/commands/segments.d.ts

@@ -0,0 +1,4 @@
+import type { Command } from 'commander';
+import type { GlobalOptions } from '../lib/config.js';
+export declare function registerSegmentsCommands(program: Command, globalOpts: () => GlobalOptions): void;
+//# sourceMappingURL=segments.d.ts.map

package/dist/commands/segments.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"segments.d.ts","sourceRoot":"","sources":["../../src/commands/segments.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACzC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAgBtD,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,OAAO,EAChB,UAAU,EAAE,MAAM,aAAa,GAC9B,IAAI,CAqLN"}