@nuxtseo/cli 0.1.0 → 0.1.2

package/dist/commands.js

@@ -4,8 +4,8 @@ import { createApiClient, fromStateError, loadApiContext } from './api.js';
 import { openBrowser } from './browser.js';
 import { EXIT_CODE, fail, fromSdkFailure, ok } from './failures.js';
 import { awaitPairingApproval, createCliPairingClient, startPairing } from './pairing.js';
-import { parseAbsolutePageUrl, parseInteger } from './parse.js';
-import { renderAction, renderActionResolution, renderActions, renderMentions, renderPageInspection, renderPageScan, renderPerformance, renderRecoverableBacklinks, renderSearchStatus, renderSites, renderUsage, } from './render.js';
+import { parseAbsolutePageUrl, parseChoice, parseInteger } from './parse.js';
+import { renderAction, renderActionResolution, renderActions, renderContentBrief, renderContentBriefCreated, renderContentBriefs, renderContentDecay, renderDuplicateClusters, renderKeywordResearch, renderLinkOpportunities, renderMentions, renderPageInspection, renderPageScan, renderPerformance, renderRankingsResearch, renderRecoverableBacklinks, renderResearchOverview, renderSearchAnalytics, renderSearchStatus, renderSerpResearch, renderSites, renderUsage, } from './render.js';
 import { writeCliResponse, writeDiagnostic, writeOutput, writeProtocolResponse } from './runtime.js';
 import { resolveSite } from './site.js';
 import { clearCredential, getCredentialStatus, readConfig, resolveApiUrl, saveCredential, updateConfig, } from './state/index.js';
@@ -23,7 +23,10 @@ async function withSpinner(runtime, message, task) {
     const spinner = runtime.interactive
         ? prompts.spinner({ output: runtime.error, signal: runtime.signal })
         : null;
-    spinner?.start(message);
+    const deadline = runtime.requestTimeoutMs === undefined
+        ? ''
+        : `, ${Math.ceil(runtime.requestTimeoutMs / 1_000)}s limit`;
+    spinner?.start(`${message}${deadline}`);
     return task().then((result) => {
         spinner?.stop();
         return result;
@@ -408,6 +411,224 @@ async function searchStatus(runtime, globals) {
     }, { signal: runtime.requestSignal }));
     return present(runtime, globals, response, value => renderSearchStatus(value.data));
 }
+async function searchAnalytics(runtime, globals, args) {
+    const view = parseChoice(args.view, { name: 'view', choices: ['pages', 'keywords'] });
+    if (view._tag === 'Err')
+        return view;
+    const period = parseChoice(args.period, { name: '--period', choices: ['7d', '28d', '3m', '6m', '12m'], defaultValue: '28d' });
+    if (period._tag === 'Err')
+        return period;
+    const limit = parseInteger(args.limit, { name: '--limit', minimum: 1, maximum: 100, defaultValue: 25 });
+    if (limit._tag === 'Err')
+        return limit;
+    const page = parseInteger(args.page, { name: '--page', minimum: 1, defaultValue: 1 });
+    if (page._tag === 'Err')
+        return page;
+    const sort = parseChoice(args.sort, { name: '--sort', choices: ['clicks', 'impressions', 'ctr', 'position'], defaultValue: 'clicks' });
+    if (sort._tag === 'Err')
+        return sort;
+    const sortDir = parseChoice(args.sortDir, { name: '--sort-dir', choices: ['asc', 'desc'], defaultValue: 'desc' });
+    if (sortDir._tag === 'Err')
+        return sortDir;
+    const resolved = await apiAndSite(runtime, globals);
+    if (resolved._tag === 'Err')
+        return resolved;
+    const response = await withSpinner(runtime, 'Loading Search Console rows', () => resolved.value.api.client.search.queryAnalytics({
+        params: { siteId: resolved.value.siteId },
+        query: {
+            view: view.value,
+            period: period.value,
+            limit: limit.value,
+            page: page.value,
+            search: args.search,
+            sort: sort.value,
+            sortDir: sortDir.value,
+        },
+    }, { signal: runtime.requestSignal }));
+    return present(runtime, globals, response, value => renderSearchAnalytics(value.data));
+}
+async function researchOverview(runtime, globals) {
+    const resolved = await apiAndSite(runtime, globals);
+    if (resolved._tag === 'Err')
+        return resolved;
+    const response = await withSpinner(runtime, 'Loading stored research', () => resolved.value.api.client.research.overview({
+        params: { siteId: resolved.value.siteId },
+    }, { signal: runtime.requestSignal }));
+    return present(runtime, globals, response, value => renderResearchOverview(value.data));
+}
+async function researchKeywordIdeas(runtime, globals, args) {
+    const minVolume = parseInteger(args.minVolume, { name: '--min-volume', minimum: 0, defaultValue: 10 });
+    if (minVolume._tag === 'Err')
+        return minVolume;
+    const maxVolume = parseInteger(args.maxVolume, { name: '--max-volume', minimum: 0, defaultValue: 10_000 });
+    if (maxVolume._tag === 'Err')
+        return maxVolume;
+    const minDifficulty = parseInteger(args.minDifficulty, { name: '--min-difficulty', minimum: 0, maximum: 100, defaultValue: 0 });
+    if (minDifficulty._tag === 'Err')
+        return minDifficulty;
+    const maxDifficulty = parseInteger(args.maxDifficulty, { name: '--max-difficulty', minimum: 0, maximum: 100, defaultValue: 60 });
+    if (maxDifficulty._tag === 'Err')
+        return maxDifficulty;
+    const limit = parseInteger(args.limit, { name: '--limit', minimum: 1, maximum: 100, defaultValue: 20 });
+    if (limit._tag === 'Err')
+        return limit;
+    const locationCode = parseInteger(args.locationCode, { name: '--location-code', minimum: 1, defaultValue: 2840 });
+    if (locationCode._tag === 'Err')
+        return locationCode;
+    if (maxVolume.value < minVolume.value)
+        return fail(EXIT_CODE.invalidInput, '--max-volume must be at least --min-volume.');
+    if (maxDifficulty.value < minDifficulty.value)
+        return fail(EXIT_CODE.invalidInput, '--max-difficulty must be at least --min-difficulty.');
+    const resolved = await apiAndSite(runtime, globals);
+    if (resolved._tag === 'Err')
+        return resolved;
+    const response = await withSpinner(runtime, 'Researching keyword ideas', () => resolved.value.api.client.research.keywords({
+        params: { siteId: resolved.value.siteId },
+        query: {
+            topic: args.topic,
+            minVolume: minVolume.value,
+            maxVolume: maxVolume.value,
+            minDifficulty: minDifficulty.value,
+            maxDifficulty: maxDifficulty.value,
+            intent: args.intent,
+            includeRelated: args.related ?? true,
+            verbose: args.verbose ?? false,
+            limit: limit.value,
+            locationCode: locationCode.value,
+        },
+    }, { signal: runtime.requestSignal }));
+    return present(runtime, globals, response, value => renderKeywordResearch(value.data));
+}
+async function researchSerp(runtime, globals, args) {
+    const depth = parseInteger(args.depth, { name: '--depth', minimum: 1, maximum: 20, defaultValue: 10 });
+    if (depth._tag === 'Err')
+        return depth;
+    const locationCode = parseInteger(args.locationCode, { name: '--location-code', minimum: 1, defaultValue: 2840 });
+    if (locationCode._tag === 'Err')
+        return locationCode;
+    const resolved = await apiAndSite(runtime, globals);
+    if (resolved._tag === 'Err')
+        return resolved;
+    const response = await withSpinner(runtime, 'Analyzing the SERP', () => resolved.value.api.client.research.serp({
+        params: { siteId: resolved.value.siteId },
+        query: { keyword: args.keyword, depth: depth.value, locationCode: locationCode.value },
+    }, { signal: runtime.requestSignal }));
+    return present(runtime, globals, response, value => renderSerpResearch(value.data));
+}
+async function researchRankings(runtime, globals, args) {
+    const limit = parseInteger(args.limit, { name: '--limit', minimum: 1, maximum: 100, defaultValue: 50 });
+    if (limit._tag === 'Err')
+        return limit;
+    const minPosition = parseInteger(args.minPosition, { name: '--min-position', minimum: 1, maximum: 100, defaultValue: 1 });
+    if (minPosition._tag === 'Err')
+        return minPosition;
+    const maxPosition = parseInteger(args.maxPosition, { name: '--max-position', minimum: 1, maximum: 100, defaultValue: 20 });
+    if (maxPosition._tag === 'Err')
+        return maxPosition;
+    const locationCode = parseInteger(args.locationCode, { name: '--location-code', minimum: 1, defaultValue: 2840 });
+    if (locationCode._tag === 'Err')
+        return locationCode;
+    const order = parseChoice(args.order, { name: '--order', choices: ['position', 'traffic'], defaultValue: 'position' });
+    if (order._tag === 'Err')
+        return order;
+    if (maxPosition.value < minPosition.value)
+        return fail(EXIT_CODE.invalidInput, '--max-position must be at least --min-position.');
+    const resolved = await apiAndSite(runtime, globals);
+    if (resolved._tag === 'Err')
+        return resolved;
+    const response = await withSpinner(runtime, 'Researching domain rankings', () => resolved.value.api.client.research.rankings({
+        params: { siteId: resolved.value.siteId },
+        query: {
+            domain: args.domain,
+            limit: limit.value,
+            minPosition: minPosition.value,
+            maxPosition: maxPosition.value,
+            locationCode: locationCode.value,
+            order: order.value,
+        },
+    }, { signal: runtime.requestSignal }));
+    return present(runtime, globals, response, value => renderRankingsResearch(value.data));
+}
+async function auditContentDecay(runtime, globals) {
+    const resolved = await apiAndSite(runtime, globals);
+    if (resolved._tag === 'Err')
+        return resolved;
+    const response = await withSpinner(runtime, 'Loading content decay', () => resolved.value.api.client.audit.contentDecay({
+        params: { siteId: resolved.value.siteId },
+    }, { signal: runtime.requestSignal }));
+    return present(runtime, globals, response, value => renderContentDecay(value.data));
+}
+async function auditDuplicateClusters(runtime, globals) {
+    const resolved = await apiAndSite(runtime, globals);
+    if (resolved._tag === 'Err')
+        return resolved;
+    const response = await withSpinner(runtime, 'Loading duplicate clusters', () => resolved.value.api.client.audit.duplicateClusters({
+        params: { siteId: resolved.value.siteId },
+    }, { signal: runtime.requestSignal }));
+    return present(runtime, globals, response, value => renderDuplicateClusters(value.data));
+}
+async function auditLinkOpportunities(runtime, globals) {
+    const resolved = await apiAndSite(runtime, globals);
+    if (resolved._tag === 'Err')
+        return resolved;
+    const response = await withSpinner(runtime, 'Loading link opportunities', () => resolved.value.api.client.audit.linkOpportunities({
+        params: { siteId: resolved.value.siteId },
+    }, { signal: runtime.requestSignal }));
+    return present(runtime, globals, response, value => renderLinkOpportunities(value.data));
+}
+async function contentBriefList(runtime, globals, args) {
+    const status = args.status === undefined
+        ? ok(undefined)
+        : parseChoice(args.status, {
+            name: '--status',
+            choices: ['queued', 'researching', 'ready', 'written', 'published', 'stale', 'failed', 'archived'],
+        });
+    if (status._tag === 'Err')
+        return status;
+    const limit = parseInteger(args.limit, { name: '--limit', minimum: 1, maximum: 100, defaultValue: 25 });
+    if (limit._tag === 'Err')
+        return limit;
+    const offset = parseInteger(args.offset, { name: '--offset', minimum: 0, defaultValue: 0 });
+    if (offset._tag === 'Err')
+        return offset;
+    const resolved = await apiAndSite(runtime, globals);
+    if (resolved._tag === 'Err')
+        return resolved;
+    const response = await withSpinner(runtime, 'Loading Content Briefs', () => resolved.value.api.client.content.listBriefs({
+        params: { siteId: resolved.value.siteId },
+        query: { status: status.value, limit: limit.value, offset: offset.value },
+    }, { signal: runtime.requestSignal }));
+    return present(runtime, globals, response, value => renderContentBriefs(value.data));
+}
+async function contentBriefShow(runtime, globals, briefId) {
+    const resolved = await apiAndSite(runtime, globals);
+    if (resolved._tag === 'Err')
+        return resolved;
+    const response = await withSpinner(runtime, 'Loading Content Brief', () => resolved.value.api.client.content.showBrief({
+        params: { siteId: resolved.value.siteId, briefId },
+    }, { signal: runtime.requestSignal }));
+    return present(runtime, globals, response, value => renderContentBrief(value.data));
+}
+async function contentBriefCreate(runtime, globals, args) {
+    const targetPage = args.targetPage === undefined ? ok(undefined) : parseAbsolutePageUrl(args.targetPage);
+    if (targetPage._tag === 'Err')
+        return targetPage;
+    const resolved = await apiAndSite(runtime, globals);
+    if (resolved._tag === 'Err')
+        return resolved;
+    const confirmed = await confirmMutation(runtime, globals, `Create a Content Brief for ${args.keyword}?`);
+    if (confirmed._tag === 'Err')
+        return confirmed;
+    if (!confirmed.value) {
+        writeDiagnostic(runtime, 'Mutation cancelled.');
+        return ok(undefined);
+    }
+    const response = await withSpinner(runtime, 'Creating Content Brief', () => resolved.value.api.client.content.createBrief({
+        params: { siteId: resolved.value.siteId },
+        body: { keyword: args.keyword, targetPage: targetPage.value },
+    }, { signal: runtime.requestSignal }));
+    return present(runtime, globals, response, value => renderContentBriefCreated(value.data));
+}
 async function backlinksRecoverable(runtime, globals, limitInput, offsetInput) {
     const limit = parseInteger(limitInput, { name: '--limit', minimum: 1, maximum: 200, defaultValue: 100 });
     if (limit._tag === 'Err')
@@ -551,13 +772,162 @@ export function createRootCommand(runtime, globals, execution) {
             }),
         },
     });
+    const research = defineCommand({
+        meta: { name: 'research', description: 'Read stored and live search research' },
+        subCommands: {
+            overview: defineCommand({
+                meta: { name: 'overview', description: 'Read stored Site metrics and competitor research' },
+                run: ({ args }) => capture(execution, () => researchOverview(runtime, globals), args._, 0)(),
+            }),
+            keywords: defineCommand({
+                meta: { name: 'keywords', description: 'Find live keyword ideas with volume and difficulty' },
+                args: {
+                    'topic': positional('topic', 'Keyword or topic'),
+                    'min-volume': { type: 'string', description: 'Minimum monthly volume' },
+                    'max-volume': { type: 'string', description: 'Maximum monthly volume' },
+                    'min-difficulty': { type: 'string', description: 'Minimum difficulty, 0 to 100' },
+                    'max-difficulty': { type: 'string', description: 'Maximum difficulty, 0 to 100' },
+                    'limit': { type: 'string', description: 'Maximum keywords, 1 to 100' },
+                    'location-code': { type: 'string', description: 'DataForSEO location code' },
+                    'intent': { type: 'string', description: 'Search intent filter' },
+                    'related': { type: 'boolean', default: true, description: 'Include related keywords; use --no-related to exclude them' },
+                    'verbose': { type: 'boolean', description: 'Include full keyword evidence' },
+                },
+                run: ({ args }) => capture(execution, () => researchKeywordIdeas(runtime, globals, {
+                    topic: args.topic,
+                    minVolume: args['min-volume'],
+                    maxVolume: args['max-volume'],
+                    minDifficulty: args['min-difficulty'],
+                    maxDifficulty: args['max-difficulty'],
+                    limit: args.limit,
+                    locationCode: args['location-code'],
+                    intent: args.intent,
+                    related: args.related,
+                    verbose: args.verbose,
+                }), args._, 1)(),
+            }),
+            serp: defineCommand({
+                meta: { name: 'serp', description: 'Analyze one live Google SERP' },
+                args: {
+                    'keyword': positional('keyword', 'Keyword'),
+                    'depth': { type: 'string', description: 'Organic result depth, 1 to 20' },
+                    'location-code': { type: 'string', description: 'DataForSEO location code' },
+                },
+                run: ({ args }) => capture(execution, () => researchSerp(runtime, globals, {
+                    keyword: args.keyword,
+                    depth: args.depth,
+                    locationCode: args['location-code'],
+                }), args._, 1)(),
+            }),
+            rankings: defineCommand({
+                meta: { name: 'rankings', description: 'Research live keyword rankings for a domain' },
+                args: {
+                    'domain': positional('domain', 'Domain without a protocol'),
+                    'limit': { type: 'string', description: 'Maximum keywords, 1 to 100' },
+                    'min-position': { type: 'string', description: 'Minimum position, 1 to 100' },
+                    'max-position': { type: 'string', description: 'Maximum position, 1 to 100' },
+                    'location-code': { type: 'string', description: 'DataForSEO location code' },
+                    'order': { type: 'enum', options: ['position', 'traffic'], description: 'Sort rankings' },
+                },
+                run: ({ args }) => capture(execution, () => researchRankings(runtime, globals, {
+                    domain: args.domain,
+                    limit: args.limit,
+                    minPosition: args['min-position'],
+                    maxPosition: args['max-position'],
+                    locationCode: args['location-code'],
+                    order: args.order,
+                }), args._, 1)(),
+            }),
+        },
+    });
+    const audit = defineCommand({
+        meta: { name: 'audit', description: 'Read stored Site audit reports' },
+        subCommands: {
+            'content-decay': defineCommand({
+                meta: { name: 'content-decay', description: 'List Pages losing Search Console clicks' },
+                run: ({ args }) => capture(execution, () => auditContentDecay(runtime, globals), args._, 0)(),
+            }),
+            'duplicates': defineCommand({
+                meta: { name: 'duplicates', description: 'List duplicate Page clusters' },
+                run: ({ args }) => capture(execution, () => auditDuplicateClusters(runtime, globals), args._, 0)(),
+            }),
+            'link-opportunities': defineCommand({
+                meta: { name: 'link-opportunities', description: 'List internal link opportunities' },
+                run: ({ args }) => capture(execution, () => auditLinkOpportunities(runtime, globals), args._, 0)(),
+            }),
+        },
+    });
+    const content = defineCommand({
+        meta: { name: 'content', description: 'Read and create Content Briefs' },
+        subCommands: {
+            briefs: defineCommand({
+                meta: { name: 'briefs', description: 'Manage Content Briefs' },
+                subCommands: {
+                    list: defineCommand({
+                        meta: { name: 'list', description: 'List Content Briefs' },
+                        args: {
+                            status: {
+                                type: 'enum',
+                                options: ['queued', 'researching', 'ready', 'written', 'published', 'stale', 'failed', 'archived'],
+                                description: 'Filter by status',
+                            },
+                            limit: { type: 'string', description: 'Maximum Content Briefs, 1 to 100' },
+                            offset: { type: 'string', description: 'Pagination offset' },
+                        },
+                        run: ({ args }) => capture(execution, () => contentBriefList(runtime, globals, {
+                            status: args.status,
+                            limit: args.limit,
+                            offset: args.offset,
+                        }), args._, 0)(),
+                    }),
+                    show: defineCommand({
+                        meta: { name: 'show', description: 'Show one Content Brief' },
+                        args: { briefId: positional('brief-id', 'Content Brief ID') },
+                        run: ({ args }) => capture(execution, () => contentBriefShow(runtime, globals, args.briefId), args._, 1)(),
+                    }),
+                    create: defineCommand({
+                        meta: { name: 'create', description: 'Create a Content Brief' },
+                        args: {
+                            'keyword': positional('keyword', 'Target keyword'),
+                            'target-page': { type: 'string', description: 'Absolute target Page URL' },
+                        },
+                        run: ({ args }) => capture(execution, () => contentBriefCreate(runtime, globals, {
+                            keyword: args.keyword,
+                            targetPage: args['target-page'],
+                        }), args._, 1)(),
+                    }),
+                },
+            }),
+        },
+    });
     const search = defineCommand({
         meta: { name: 'search', description: 'Read Search Console state' },
         subCommands: {
             status: defineCommand({
-                meta: { name: 'status', description: 'Read Search Console status' },
+                meta: { name: 'status', description: 'Read the stored Search Console connection' },
                 run: ({ args }) => capture(execution, () => searchStatus(runtime, globals), args._, 0)(),
             }),
+            analytics: defineCommand({
+                meta: { name: 'analytics', description: 'List Search Console query or Page rows' },
+                args: {
+                    'view': positional('pages-or-keywords', 'pages or keywords'),
+                    'period': { type: 'enum', options: ['7d', '28d', '3m', '6m', '12m'], description: 'Search Console period' },
+                    'limit': { type: 'string', description: 'Maximum rows, 1 to 100' },
+                    'page': { type: 'string', description: 'Result page number' },
+                    'search': { type: 'string', description: 'Filter rows by text' },
+                    'sort': { type: 'enum', options: ['clicks', 'impressions', 'ctr', 'position'], description: 'Sort field' },
+                    'sort-dir': { type: 'enum', options: ['asc', 'desc'], description: 'Sort direction' },
+                },
+                run: ({ args }) => capture(execution, () => searchAnalytics(runtime, globals, {
+                    view: args.view,
+                    period: args.period,
+                    limit: args.limit,
+                    page: args.page,
+                    search: args.search,
+                    sort: args.sort,
+                    sortDir: args['sort-dir'],
+                }), args._, 1)(),
+            }),
         },
     });
     return defineCommand({
@@ -613,13 +983,16 @@ export function createRootCommand(runtime, globals, execution) {
                 run: ({ args }) => capture(execution, () => usage(runtime, globals, args.group), args._, 0)(),
             }),
             actions,
+            audit,
             backlinks,
+            content,
             mentions,
             page,
             performance: defineCommand({
                 meta: { name: 'performance', description: 'Read the stored Site performance overview' },
                 run: ({ args }) => capture(execution, () => performance(runtime, globals), args._, 0)(),
             }),
+            research,
             search,
         },
     });

package/dist/failures.js

@@ -1,3 +1,11 @@
+import { VERSION } from './version.js';
+const UPDATE_COMMAND = 'pnpm add -g @nuxtseo/cli';
+// `contract_violation` most often means this CLI is older than the server
+// contract. One line routes an agent to update before anything else.
+const CONTRACT_REMEDIATION = [
+    'Most common cause: this CLI is older than the server contract.',
+    `Update first with ${UPDATE_COMMAND}, then run the command again.`,
+].join(' ');
 export const EXIT_CODE = {
     success: 0,
     invalidInput: 2,
@@ -89,15 +97,23 @@ export function fromSdkFailure(error) {
                     message: [
                         `${error.code}: ${error.message}`,
                         ...metadataLines(error),
-                        error.code === 'unauthorized' || error.code === 'auth_expired'
+                        // `unauthorized` is the caller's own credential. `auth_expired` is the
+                        // Site's Search Console connection, which no token change repairs.
+                        error.code === 'unauthorized'
                             ? 'Replace NUXTSEO_TOKEN, or run `nuxtseo login` when using a stored credential.'
                             : undefined,
+                        error.code === 'auth_expired'
+                            ? 'Open site settings in the dashboard, then Search Console, to reconnect.'
+                            : undefined,
+                        error.code === 'contract_violation'
+                            ? CONTRACT_REMEDIATION
+                            : undefined,
                     ].filter((line) => line !== undefined).join('\n'),
                     protocolResponse: error.response,
                 },
             };
         case 'ContractFailure':
-            return fail(EXIT_CODE.infrastructure, [`contract_violation: ${error.message}`, error.requestId ? `Request ID: ${error.requestId}` : undefined]
+            return fail(EXIT_CODE.infrastructure, [`contract_violation: ${error.message}`, error.requestId ? `Request ID: ${error.requestId}` : undefined, CONTRACT_REMEDIATION, `Current CLI version: ${VERSION}`]
                 .filter((line) => line !== undefined)
                 .join('\n'), undefined, 'contract_violation');
         case 'TransportFailure': {

package/dist/index.d.ts

@@ -2,4 +2,6 @@ export { runCli } from './cli.js';
 export { EXIT_CODE } from './failures.js';
 export type { CliFailure, CliFailureCode, CliResult, ExitCode, LocalFailureCode } from './failures.js';
 export type { CliRuntime } from './runtime.js';
+export { checkForUpdate, isNewerVersion, updateNoticeFor } from './update-check.js';
+export type { UpdateNotice } from './update-check.js';
 export { VERSION } from './version.js';

package/dist/index.js

@@ -1,3 +1,4 @@
 export { runCli } from './cli.js';
 export { EXIT_CODE } from './failures.js';
+export { checkForUpdate, isNewerVersion, updateNoticeFor } from './update-check.js';
 export { VERSION } from './version.js';

package/dist/parse.d.ts

@@ -21,3 +21,8 @@ export declare function parseInteger(input: string | undefined, options: {
     maximum?: number;
     defaultValue: number;
 }): CliResult<number>;
+export declare function parseChoice<const TChoice extends string>(input: string | undefined, options: {
+    name: string;
+    choices: readonly TChoice[];
+    defaultValue?: TChoice;
+}): CliResult<TChoice>;

package/dist/parse.js

@@ -124,3 +124,10 @@ export function parseInteger(input, options) {
     }
     return ok(parsed);
 }
+export function parseChoice(input, options) {
+    if (input === undefined && options.defaultValue !== undefined)
+        return ok(options.defaultValue);
+    if (input !== undefined && options.choices.includes(input))
+        return ok(input);
+    return fail(EXIT_CODE.invalidInput, `${options.name} must be one of: ${options.choices.join(', ')}.`);
+}

package/dist/render.d.ts

@@ -1,9 +1,12 @@
 import type { AccountUsageResponse, SitesListResponse } from '@nuxtseo/protocol/v1';
 import type { ActionList, ActionResolve, ActionShow } from '@nuxtseo/protocol/v1/actions';
+import type { AuditContentDecay, AuditDuplicateClusters, AuditLinkOpportunities } from '@nuxtseo/protocol/v1/audit';
 import type { Mentions, RecoverableBacklinks } from '@nuxtseo/protocol/v1/backlinks';
-import type { SearchStatusData } from '@nuxtseo/protocol/v1/gsc';
+import type { ContentBrief, ContentBriefCreateData, ContentBriefListData } from '@nuxtseo/protocol/v1/content';
+import type { SearchAnalyticsData, SearchStatusData } from '@nuxtseo/protocol/v1/gsc';
 import type { PageInspect, PageScan } from '@nuxtseo/protocol/v1/pages';
 import type { SitePerformanceOverview } from '@nuxtseo/protocol/v1/performance';
+import type { KeywordResearchData, RankingsResearchData, SerpResearchData, StoredResearchOverview } from '@nuxtseo/protocol/v1/research';
 export declare function renderSites(response: SitesListResponse, selectedSiteId?: string): string;
 export declare function renderUsage(response: AccountUsageResponse): string;
 export declare function renderActions(data: ActionList): string;
@@ -13,5 +16,16 @@ export declare function renderPageInspection(data: PageInspect): string;
 export declare function renderPageScan(data: PageScan): string;
 export declare function renderPerformance(data: SitePerformanceOverview): string;
 export declare function renderSearchStatus(data: SearchStatusData): string;
+export declare function renderSearchAnalytics(data: SearchAnalyticsData): string;
+export declare function renderResearchOverview(data: StoredResearchOverview): string;
+export declare function renderKeywordResearch(data: KeywordResearchData): string;
+export declare function renderSerpResearch(data: SerpResearchData): string;
+export declare function renderRankingsResearch(data: RankingsResearchData): string;
+export declare function renderContentBriefs(data: ContentBriefListData): string;
+export declare function renderContentBrief(data: ContentBrief): string;
+export declare function renderContentBriefCreated(data: ContentBriefCreateData): string;
+export declare function renderContentDecay(data: AuditContentDecay): string;
+export declare function renderDuplicateClusters(data: AuditDuplicateClusters): string;
+export declare function renderLinkOpportunities(data: AuditLinkOpportunities): string;
 export declare function renderRecoverableBacklinks(data: RecoverableBacklinks): string;
 export declare function renderMentions(data: Mentions): string;