checkly 9.5.0 → 10.0.0-prerelease-4f88d60

package/dist/formatters/usage.js

@@ -1,273 +1,313 @@
 import chalk from 'chalk';
-import logSymbols from 'log-symbols';
-import { escapeMdCell, formatMs, heading, padColumn, renderAdaptiveTable, renderCommandHints, renderDetailFields, } from './render.js';
-// --- Shared helpers ---
-export function checkRunMeasures(metrics) {
-    for (const meter of metrics.meters) {
-        if (meter.meterType === 'CHECK_RUN')
-            return meter.measures;
-    }
-    return undefined;
-}
-export function aiInvocationMeasures(metrics) {
-    for (const meter of metrics.meters) {
-        if (meter.meterType === 'AI_INVOCATION')
-            return meter.measures;
-    }
-    return undefined;
+import { shellJoin, shellQuote } from '../services/shell.js';
+import { heading, renderAdaptiveTable, renderCommandHints, renderDetailFields, } from './render.js';
+function number(value) {
+    return value == null ? '-' : value.toLocaleString('en-US', { maximumFractionDigits: 4 });
 }
-function dash(format) {
-    return format === 'terminal' ? chalk.dim('-') : '-';
+function percent(value) {
+    return value === null ? '-' : `${value.toLocaleString('en-US', { maximumFractionDigits: 2 })}%`;
 }
-function formatNumber(value, format) {
-    if (value === null || value === undefined)
-        return dash(format);
-    return Number.isInteger(value)
-        ? value.toLocaleString('en-US')
-        : value.toLocaleString('en-US', { maximumFractionDigits: 2 });
+function dateRange(period) {
+    return period === null ? '-' : `${period.from} to ${period.to}`;
 }
-function formatPercent(value, format) {
-    if (value === null || value === undefined)
-        return dash(format);
-    return `${value.toLocaleString('en-US', { maximumFractionDigits: 2 })}%`;
+function section(title, body, format, level = 2) {
+    return `${heading(title, level, format)}\n\n${body}`;
 }
-function dateRange(from, to) {
-    return `${from} → ${to}`;
+function namedId(id, names) {
+    if (id === undefined)
+        return '-';
+    const name = names?.get(id);
+    return name && name !== id ? `${name} (${id})` : id;
 }
-function sectionHeading(text, format) {
-    return heading(format === 'md' ? text : text.toUpperCase(), 2, format);
+export function formatUsageTermsList(terms, format) {
+    if (terms.length === 0)
+        return 'No usage terms found.';
+    const columns = [
+        { header: 'Name', minWidth: 15, maxWidth: 40, value: term => term.name },
+        { header: 'ID', minWidth: 38, truncate: false, value: term => term.id },
+        { header: 'Contract start', value: term => term.contractStartDate },
+        { header: 'Contract end', value: term => term.contractEndDate },
+        { header: 'Usage start', value: term => term.usageStartDate },
+        { header: 'Credit budget', align: 'right', value: term => number(term.creditBudget) },
+        { header: 'Package model', value: term => term.packageModel ?? '-' },
+        { header: 'Accounts', align: 'right', value: term => String(term.accounts.length) },
+    ];
+    return renderAdaptiveTable(columns, terms, format);
 }
-function renderMeasureList(entries, format) {
-    if (format === 'md') {
-        return [
-            '| Measure | Value |',
-            '| --- | --- |',
-            ...entries.map(entry => `| ${entry.label} | ${escapeMdCell(entry.value)} |`),
-        ].join('\n');
+function formatPricingRule(rule, format, level) {
+    if (rule === null)
+        return 'Pricing rule unavailable.';
+    switch (rule.method) {
+        case 'per_unit': {
+            const fields = [
+                { label: 'Method', value: value => value.method },
+                { label: 'Quantity', value: value => number(value.quantity) },
+                { label: 'Unit', value: value => value.unit },
+                { label: 'Credits', value: value => number(value.credits) },
+                { label: 'Included quantity', value: value => number(value.included?.quantity) },
+                { label: 'Included period', value: value => value.included?.period ?? '-' },
+            ];
+            const output = [renderDetailFields('Pricing rule', fields, rule, format, level)];
+            if (rule.rates !== undefined) {
+                output.push(section('Conditional rates', renderAdaptiveTable([
+                    { header: 'Condition', value: rate => rate.when },
+                    { header: 'Credits', align: 'right', value: rate => number(rate.credits) },
+                ], rule.rates, format), format, level === 3 ? 4 : 5));
+            }
+            return output.join('\n\n');
+        }
+        case 'per_period':
+            return renderDetailFields('Pricing rule', [
+                { label: 'Method', value: value => value.method },
+                { label: 'Period', value: value => value.period },
+                { label: 'Annual credits', value: value => number(value.price.annualCredits) },
+            ], rule, format, level);
+        case 'capacity_blocks_per_period':
+            return renderDetailFields('Pricing rule', [
+                { label: 'Method', value: value => value.method },
+                { label: 'Period', value: value => value.period },
+                { label: 'Unit', value: value => value.unit },
+                { label: 'Included quantity', value: value => number(value.included.quantity) },
+                { label: 'Block quantity', value: value => number(value.block.quantity) },
+                { label: 'Annual credits per block', value: value => number(value.block.annualCredits) },
+            ], rule, format, level);
+        default: {
+            const exhaustive = rule;
+            return exhaustive;
+        }
     }
-    const labelWidth = Math.max(0, ...entries.map(entry => entry.label.length)) + 3;
-    return entries
-        .map(entry => `${chalk.dim(padColumn(`${entry.label}:`, labelWidth, 'left', false))}${entry.value}`)
-        .join('\n');
 }
-// --- Terms detail ---
-const termsDetailFields = [
-    { label: 'Organization', value: terms => terms.name },
-    { label: 'Contract period', value: terms => dateRange(terms.contractStartDate, terms.contractEndDate) },
-    { label: 'Usage start date', value: terms => terms.usageStartDate },
-    { label: 'Credit budget', value: (terms, fmt) => formatNumber(terms.creditBudget, fmt) },
-    { label: 'Standard credits / unit', value: (terms, fmt) => formatNumber(terms.standardCreditsPerUnit, fmt) },
-    { label: 'Premium credits / unit', value: (terms, fmt) => formatNumber(terms.premiumCreditsPerUnit, fmt) },
-    { label: 'Accounts', value: terms => String(terms.accounts.length) },
-    { label: 'ID', value: terms => terms.id },
-];
-function buildAccountColumns(format) {
-    if (format === 'md') {
-        return [
-            { header: 'Name', value: account => account.name },
-            { header: 'ID', value: account => account.id },
-        ];
-    }
-    return [
-        { header: 'Name', minWidth: 12, maxWidth: 40, value: account => account.name },
-        { header: 'ID', width: 38, value: account => chalk.dim(account.id) },
+export function formatUsageTermDetail(term, format) {
+    const fields = [
+        { label: 'ID', value: value => value.id },
+        { label: 'Contract period', value: value => `${value.contractStartDate} to ${value.contractEndDate}` },
+        { label: 'Usage start date', value: value => value.usageStartDate },
+        { label: 'Credit budget', value: value => number(value.creditBudget) },
+        { label: 'Package model', value: value => value.packageModel ?? '-' },
+        { label: 'Standard credits / unit', value: value => number(value.standardCreditsPerUnit) },
+        { label: 'Premium credits / unit', value: value => number(value.premiumCreditsPerUnit) },
     ];
+    const output = [renderDetailFields(`Usage term: ${term.name}`, fields, term, format, 1)];
+    output.push(section('Accounts', renderAdaptiveTable([
+        { header: 'Name', minWidth: 15, maxWidth: 40, value: account => account.name },
+        { header: 'ID', minWidth: 38, truncate: false, value: account => account.id },
+    ], term.accounts, format), format));
+    if (term.pricingRules === null)
+        output.push(section('Pricing rules', 'Pricing rules unavailable.', format));
+    else {
+        for (const [key, rule] of Object.entries(term.pricingRules)) {
+            output.push(section(key, formatPricingRule(rule, format, 3), format));
+        }
+        if (Object.keys(term.pricingRules).length === 0)
+            output.push(section('Pricing rules', 'No pricing rules.', format));
+    }
+    return output.join('\n\n');
 }
-export function formatUsageTermsDetail(terms, format) {
-    const lines = [];
-    lines.push(renderDetailFields(`Usage terms: ${terms.name}`, termsDetailFields, terms, format));
-    lines.push('');
-    lines.push(sectionHeading('Accounts', format));
-    if (format === 'md')
-        lines.push('');
-    lines.push(renderAdaptiveTable(buildAccountColumns(format), terms.accounts, format));
-    return lines.join('\n');
-}
-// --- Warnings ---
-export function formatUsageWarnings(warnings, format) {
-    if (warnings.length === 0)
+export function formatUsageCoverage(coverage, format) {
+    if (coverage.gaps.length === 0)
         return '';
-    if (format === 'md') {
-        return warnings.map(warning => `> **Warning (${warning.code}):** ${warning.message}`).join('\n');
-    }
-    return warnings
-        .map(warning => `${logSymbols.warning} ${chalk.yellow(warning.message)} ${chalk.dim(`(${warning.code})`)}`)
-        .join('\n');
+    return section('Coverage gaps (credits unavailable)', renderAdaptiveTable([
+        { header: 'From', value: gap => gap.from },
+        { header: 'To', value: gap => gap.to },
+    ], coverage.gaps, format), format);
 }
-function creditsLabel(metrics, format) {
-    const { used, percentOfBudget } = metrics.credits;
-    if (used === null)
-        return dash(format);
-    const usedLabel = formatNumber(used, format);
-    return percentOfBudget === null ? usedLabel : `${usedLabel} (${formatPercent(percentOfBudget, format)} of budget)`;
+function formatCalculation(calculation, index, format, level) {
+    const title = `Calculation ${index + 1}`;
+    if ('rateCondition' in calculation) {
+        return renderDetailFields(title, [
+            { label: 'Rate condition', value: value => value.rateCondition ?? 'Default rate' },
+            { label: 'Measured quantity', value: value => number(value.measuredQuantity) },
+            { label: 'Included quantity', value: value => number(value.includedQuantity) },
+            { label: 'Billable quantity', value: value => number(value.billableQuantity) },
+            { label: 'Credits used', value: value => number(value.creditsUsed) },
+        ], calculation, format, level);
+    }
+    if ('scope' in calculation) {
+        return renderDetailFields(title, [
+            { label: 'Scope', value: value => value.scope },
+            { label: 'Measured quantity', value: value => number(value.measuredQuantity) },
+            { label: 'Included quantity', value: value => number(value.includedQuantity) },
+            { label: 'Billable block days', value: value => number(value.billableBlockDays) },
+            { label: 'Applied daily credits per block', value: value => number(value.appliedDailyCreditsPerBlock) },
+            { label: 'Proration days per year', value: value => String(value.proration.daysPerYear) },
+            { label: 'Credits used', value: value => number(value.creditsUsed) },
+        ], calculation, format, level);
+    }
+    return renderDetailFields(title, [
+        { label: 'Billable resource days', value: value => number(value.billableResourceDays) },
+        { label: 'Applied daily credits', value: value => number(value.appliedDailyCredits) },
+        { label: 'Proration days per year', value: value => String(value.proration.daysPerYear) },
+        { label: 'Credits used', value: value => number(value.creditsUsed) },
+    ], calculation, format, level);
 }
-const summaryHeaderFields = [
-    { label: 'Period', value: view => dateRange(view.summary.period.from, view.summary.period.to) },
-    {
-        label: 'Contract',
-        value: view => (view.terms ? dateRange(view.terms.contractStartDate, view.terms.contractEndDate) : null),
-    },
-    {
-        label: 'Progress',
-        value: view => {
-            const { weeksSinceStart, weeksRemaining } = view.summary.projections;
-            return `${weeksSinceStart} weeks since usage start, ${weeksRemaining} remaining`;
-        },
-    },
-    { label: 'Credit budget', value: (view, fmt) => (view.terms ? formatNumber(view.terms.creditBudget, fmt) : null) },
-    { label: 'Credits used', value: (view, fmt) => creditsLabel(view.summary.totals, fmt) },
-    { label: 'Remaining credits', value: (view, fmt) => formatNumber(view.summary.projections.remainingCredits, fmt) },
-    { label: 'Usage terms ID', value: view => view.summary.usageTermsId },
-];
-function checkRunEntries(metrics, format) {
-    const measures = checkRunMeasures(metrics);
-    if (!measures)
-        return [{ label: 'Check runs', value: dash(format) }];
-    return [
-        { label: 'Total runs', value: formatNumber(measures.totalRuns, format) },
-        { label: 'Final runs', value: formatNumber(measures.finalRuns, format) },
-        { label: 'Retry runs', value: formatNumber(measures.retryRuns, format) },
-        { label: 'Cancelled runs', value: formatNumber(measures.cancelledRuns, format) },
-        { label: 'Degraded runs', value: formatNumber(measures.degradedRuns, format) },
-        { label: 'Failed runs', value: formatNumber(measures.failedRuns, format) },
-        { label: 'Error runs', value: formatNumber(measures.errorRuns, format) },
-        { label: 'Aborted runs', value: formatNumber(measures.abortedRuns, format) },
-        { label: 'Over max response time runs', value: formatNumber(measures.overMaxResponseTimeRuns, format) },
-        { label: 'Multi-step requests', value: formatNumber(measures.multiStepRequests, format) },
-        { label: 'Playwright billable duration', value: formatMs(measures.playwrightBillableDurationMs) },
-        { label: 'Standard billable units', value: formatNumber(measures.standardBillableUnits, format) },
-        { label: 'Premium billable units', value: formatNumber(measures.premiumBillableUnits, format) },
+export function formatUsageSummary(summary, format) {
+    const fields = [
+        { label: 'Period', value: value => dateRange(value.period) },
+        { label: 'Usage term IDs', value: value => value.usageTermsIds.join(', ') || '-' },
+        { label: 'Credits used', value: value => number(value.totals.creditsUsed) },
     ];
-}
-function resolveEntries(metrics, format) {
-    const measures = aiInvocationMeasures(metrics);
-    if (!measures)
-        return [{ label: 'Invocations', value: dash(format) }];
-    return [
-        { label: 'Invocations', value: formatNumber(measures.invocations, format) },
-        { label: 'Duration', value: formatMs(measures.durationMs) },
+    const columns = [
+        { header: 'Period', truncate: false, value: row => dateRange(row.period) },
     ];
-}
-function toProjectionRow(label, window) {
-    return {
-        window: label,
-        creditsUsed: window.usage.credits.used,
-        annualPercent: window.projectedAnnualPercentOfBudget,
-        creditsAtEnd: window.projectedCreditsAtContractEnd,
-        percentAtEnd: window.projectedPercentAtContractEnd,
-        weeksUntilExhausted: window.projectedWeeksUntilExhausted,
-    };
-}
-function buildProjectionColumns() {
+    if (summary.usageTermsIds.length !== 1) {
+        columns.push({ header: 'Usage term ID', minWidth: 38, truncate: false, value: row => row.usageTermsId });
+    }
+    if (summary.breakdown.some(row => row.accountId !== undefined)) {
+        columns.push({ header: 'Account ID', minWidth: 38, truncate: false, value: row => row.accountId ?? '-' });
+    }
+    columns.push({ header: 'Pricing rule', truncate: false, value: row => row.pricingRuleKey }, { header: 'Credits used', align: 'right', value: row => number(row.creditsUsed) });
     return [
-        { header: 'Window', width: 20, value: row => row.window },
-        { header: 'Credits used', width: 14, align: 'right', value: (row, fmt) => formatNumber(row.creditsUsed, fmt) },
-        {
-            header: 'Annual % of budget',
-            width: 20,
-            align: 'right',
-            value: (row, fmt) => formatPercent(row.annualPercent, fmt),
-        },
-        {
-            header: 'Credits at contract end',
-            width: 25,
-            align: 'right',
-            value: (row, fmt) => formatNumber(row.creditsAtEnd, fmt),
-        },
-        { header: '% at contract end', width: 19, align: 'right', value: (row, fmt) => formatPercent(row.percentAtEnd, fmt) },
-        {
-            header: 'Weeks until exhausted',
-            width: 23,
-            align: 'right',
-            value: (row, fmt) => formatNumber(row.weeksUntilExhausted, fmt),
-        },
-    ];
-}
-export function formatUsageSummary(summary, format, terms) {
-    const view = { summary, terms };
-    const title = terms ? `Usage: ${terms.name}` : 'Usage summary';
-    const { windows } = summary.projections;
-    const projectionRows = [
-        toProjectionRow('Since usage start', windows.sinceStart),
-        toProjectionRow('Last 30 days', windows.last30Days),
-        toProjectionRow('Last 7 days', windows.last7Days),
-        toProjectionRow('Last 1 day', windows.last1Day),
-    ];
-    // Markdown needs a blank line between a heading and the table that follows it.
-    const headingGap = format === 'md' ? [''] : [];
-    const lines = [];
-    lines.push(renderDetailFields(title, summaryHeaderFields, view, format));
-    lines.push('');
-    lines.push(sectionHeading('Check runs', format), ...headingGap);
-    lines.push(renderMeasureList(checkRunEntries(summary.totals, format), format));
-    lines.push('');
-    lines.push(sectionHeading('Resolve', format), ...headingGap);
-    lines.push(renderMeasureList(resolveEntries(summary.totals, format), format));
-    lines.push('');
-    lines.push(sectionHeading('Projections (as of today)', format), ...headingGap);
-    lines.push(renderAdaptiveTable(buildProjectionColumns(), projectionRows, format));
-    return lines.join('\n');
-}
-function periodLabel(row, interval) {
-    return interval === 'day' ? row.periodStart : dateRange(row.periodStart, row.periodEnd);
+        renderDetailFields('Usage summary', fields, summary, format, 1),
+        formatUsageCoverage(summary.coverage, format),
+        summary.breakdown.length === 0
+            ? 'No usage breakdowns for the requested range.'
+            : section('Usage breakdown', renderAdaptiveTable(columns, summary.breakdown, format), format),
+    ].filter(Boolean).join('\n\n');
 }
-function buildSeriesColumns(format, options) {
-    const accountLabel = (row, fmt) => {
-        if (!row.accountId)
-            return dash(fmt);
-        return options.accountNames?.get(row.accountId) ?? row.accountId;
-    };
-    const columns = [
-        { header: 'Period', width: options.interval === 'day' ? 12 : 25, value: row => periodLabel(row, options.interval) },
-    ];
+const runColumns = [
+    { key: 'totalRuns', header: 'Total runs' },
+    { key: 'finalRuns', header: 'Final runs' },
+    { key: 'retryRuns', header: 'Retry runs' },
+    { key: 'cancelledRuns', header: 'Cancelled runs' },
+    { key: 'degradedRuns', header: 'Degraded runs' },
+    { key: 'failedRuns', header: 'Failed runs' },
+    { key: 'errorRuns', header: 'Error runs' },
+    { key: 'abortedRuns', header: 'Aborted runs' },
+    { key: 'overMaxResponseTimeRuns', header: 'Over max response time runs' },
+];
+export function formatUsageSeries(rows, format, options) {
+    if (rows.length === 0)
+        return 'No usage rows found for the requested range.';
+    const columns = [{
+            header: 'Period',
+            value: row => options.interval === 'day' ? row.periodStart : `${row.periodStart} to ${row.periodEnd}`,
+        }];
     if (options.groupBy.includes('account')) {
-        // 15 keeps a 13-character prefix on narrow terminals; the terminal view has no ID column to fall back on.
-        columns.push({ header: 'Account', minWidth: 15, maxWidth: 40, value: (row, fmt) => accountLabel(row, fmt) });
-        if (format === 'md') {
-            columns.push({ header: 'Account ID', value: (row, fmt) => row.accountId ?? dash(fmt) });
-        }
+        columns.push({
+            header: 'Account', minWidth: 15, maxWidth: 60,
+            value: row => options.names?.accounts.get(row.dimensions.accountId ?? '') ?? '-',
+        }, {
+            header: 'Account ID', minWidth: 38, truncate: false,
+            value: row => row.dimensions.accountId ?? '-',
+        });
+    }
+    if (options.groupBy.includes('usageTerm')) {
+        columns.push({
+            header: 'Usage term', minWidth: 15, maxWidth: 60,
+            value: row => options.names?.terms.get(row.dimensions.usageTermsId ?? '') ?? '-',
+        }, {
+            header: 'Usage term ID', minWidth: 38, truncate: false,
+            value: row => row.dimensions.usageTermsId ?? '-',
+        });
+    }
+    if (options.groupBy.includes('pricingRule')) {
+        columns.push({ header: 'Pricing rule', value: row => row.dimensions.pricingRuleKey ?? '-' });
     }
     if (options.groupBy.includes('checkType')) {
-        columns.push({ header: 'Check type', width: 13, value: (row, fmt) => row.checkType ?? dash(fmt) });
+        columns.push({ header: 'Check type', value: row => row.dimensions.checkType === null ? 'Unattributed' : row.dimensions.checkType ?? '-' });
+    }
+    columns.push({ header: 'Credits used', align: 'right', value: row => number(row.creditsUsed) });
+    if (options.include.includes('runs') || rows.some(row => row.runs !== undefined)) {
+        columns.push(...runColumns.map(({ key, header }) => ({
+            header, align: 'right', value: row => number(row.runs?.[key]),
+        })));
+    }
+    const output = [renderAdaptiveTable(columns, rows, format)];
+    if (options.include.includes('calculations')) {
+        for (const [index, row] of rows.entries()) {
+            output.push(section(`Row ${index + 1} calculations (${row.periodStart} to ${row.periodEnd})`, row.contributions.length === 0
+                ? 'No contributions.'
+                : row.contributions.map(contribution => {
+                    const fields = [
+                        { label: 'Usage term', value: value => namedId(value.usageTermsId, options.names?.terms) },
+                        { label: 'Pricing rule', value: value => value.pricingRuleKey },
+                        { label: 'Period', value: value => dateRange(value.period ?? null) },
+                        { label: 'Credits used', value: value => number(value.creditsUsed) },
+                    ];
+                    return [
+                        renderDetailFields('Contribution', fields, contribution, format, 3),
+                        formatPricingRule(contribution.pricingRule ?? null, format, 4),
+                        contribution.calculations === undefined
+                            ? 'Calculations unavailable.'
+                            : contribution.calculations.length === 0 ? 'No calculations.' : '',
+                        ...contribution.calculations?.map((value, i) => formatCalculation(value, i, format, 4)) ?? [],
+                    ].filter(Boolean).join('\n\n');
+                }).join('\n\n'), format));
+        }
     }
-    columns.push({
-        header: 'Total runs',
-        width: 12,
-        align: 'right',
-        value: (row, fmt) => formatNumber(checkRunMeasures(row)?.totalRuns, fmt),
-    }, {
-        header: 'Standard units',
-        width: 16,
-        align: 'right',
-        value: (row, fmt) => formatNumber(checkRunMeasures(row)?.standardBillableUnits, fmt),
-    }, {
-        header: 'Premium units',
-        width: 15,
-        align: 'right',
-        value: (row, fmt) => formatNumber(checkRunMeasures(row)?.premiumBillableUnits, fmt),
-    }, { header: 'Credits', width: 10, align: 'right', value: (row, fmt) => formatNumber(row.credits.used, fmt) }, {
-        header: '% of budget',
-        width: 13,
-        align: 'right',
-        value: (row, fmt) => formatPercent(row.credits.percentOfBudget, fmt),
-    }, {
-        header: 'Resolve invocations',
-        width: 21,
-        align: 'right',
-        value: (row, fmt) => formatNumber(aiInvocationMeasures(row)?.invocations, fmt),
-    });
-    return columns;
+    return output.join('\n\n');
 }
-export function formatUsageSeries(rows, format, options) {
-    return renderAdaptiveTable(buildSeriesColumns(format, options), rows, format);
+export function formatUsageProjections(value, format, term) {
+    const fields = [
+        { label: 'Usage term', value: report => term ? `${term.name} (${report.usageTermsId})` : report.usageTermsId },
+        { label: 'As of (completed UTC day)', value: report => report.asOf },
+        { label: 'Period', value: report => dateRange(report.period) },
+        { label: 'Weeks since usage start', value: report => String(report.weeksSinceStart) },
+        { label: 'Weeks remaining', value: report => String(report.weeksRemaining) },
+        { label: 'Credits used', value: report => number(report.creditsUsed) },
+        { label: 'Remaining credits', value: report => number(report.remainingCredits) },
+        { label: 'Budgeted daily credits', value: report => number(report.budgetedDailyCredits) },
+    ];
+    const windowFields = [
+        { label: 'Period', value: window => dateRange(window.period) },
+        { label: 'Observed days', value: window => String(window.observedDays) },
+        { label: 'Credits used', value: window => number(window.creditsUsed) },
+        { label: 'Average daily credits', value: window => number(window.averageDailyCredits) },
+        { label: 'Annual % of budget', value: window => percent(window.projectedAnnualPercentOfBudget) },
+        { label: 'Credits at contract end', value: window => number(window.projectedCreditsAtContractEnd) },
+        { label: 'Remaining credits at contract end', value: window => number(window.projectedRemainingCredits) },
+        { label: '% at contract end', value: window => percent(window.projectedPercentAtContractEnd) },
+        { label: 'Weeks until exhausted', value: window => window.projectedWeeksUntilExhausted === null
+                ? '-'
+                : window.projectedWeeksUntilExhausted.toLocaleString('en-US', { maximumFractionDigits: 2 }) },
+    ];
+    return [
+        renderDetailFields('Usage projections', fields, value, format, 1),
+        renderDetailFields('Since usage start', windowFields, value.windows.sinceStart, format, 2),
+        renderDetailFields('Last 30 days', windowFields, value.windows.last30Days, format, 2),
+        renderDetailFields('Last 7 days', windowFields, value.windows.last7Days, format, 2),
+        renderDetailFields('Last 1 day', windowFields, value.windows.last1Day, format, 2),
+    ].join('\n\n');
+}
+export function formatUsagePaginationInfo(count, nextId, noun) {
+    return chalk.dim(`Showing ${count} ${noun}${count === 1 ? '' : 's'}${nextId ? ' (more available)' : ''}`);
 }
-export function formatUsageSeriesPaginationInfo(count, nextId) {
-    const base = `${count} usage row${count !== 1 ? 's' : ''}`;
-    return chalk.dim(nextId ? `Showing ${base} (more available)` : `Showing ${base}`);
+export function usageListCommand(kind, params, format = 'terminal') {
+    const parts = ['checkly', 'account', 'usage', kind];
+    const append = (flag, value) => {
+        if (value !== undefined)
+            parts.push(flag, String(value));
+    };
+    append('--from', params.from);
+    append('--to', params.to);
+    append('--limit', params.limit);
+    if ('interval' in params)
+        append('--interval', params.interval);
+    if ('groupBy' in params)
+        append('--group-by', params.groupBy?.length ? params.groupBy.join(',') : 'none');
+    if ('usageTermsIds' in params)
+        for (const id of params.usageTermsIds ?? [])
+            append('--usage-terms-id', id);
+    if ('accountIds' in params)
+        for (const id of params.accountIds ?? [])
+            append('--account-id', id);
+    if ('pricingRuleKeys' in params)
+        for (const key of params.pricingRuleKeys ?? [])
+            append('--pricing-rule', key);
+    if ('include' in params && params.include?.length)
+        append('--include', params.include.join(','));
+    if (format === 'md')
+        append('--output', 'md');
+    return shellJoin(parts);
 }
-export function formatUsageSeriesNavigationHints(nextId, seriesCommand) {
-    if (!nextId)
+export function formatUsageNavigationHints(nextId, baseCommand, format) {
+    if (nextId === null)
         return '';
-    return renderCommandHints([{ label: 'Next page', command: `${seriesCommand} --cursor ${nextId}` }], { gap: 1 });
+    const command = `${baseCommand} --cursor ${shellQuote(nextId)}`;
+    if (format === 'md') {
+        const delimiter = '`'.repeat(Math.max(1, ...Array.from(command.matchAll(/`+/g), match => match[0].length + 1)));
+        return `Next page: ${delimiter}${command}${delimiter}`;
+    }
+    return renderCommandHints([{ label: 'Next page', command }], { gap: 1 });
 }
 //# sourceMappingURL=usage.js.map