@eightstate/escli 0.5.0

package/dist/commands/search.js

@@ -0,0 +1,54 @@
+import { Args, Flags } from '@oclif/core';
+import { z } from 'zod';
+import { BaseCommand } from '../base-command.js';
+import { writeStderr } from '../io/io.js';
+import { searchWeb } from '../services/search.js';
+import { ErrorCode } from '@eightstate/contracts/errors';
+export const SearchResultSchema = z.object({
+    title: z.string(),
+    url: z.string(),
+    excerpts: z.array(z.string()),
+});
+export const SearchDataSchema = z.object({
+    elapsed_seconds: z.number().nonnegative().optional(),
+    results: z.array(SearchResultSchema),
+    count: z.number().int().nonnegative(),
+});
+export default class Search extends BaseCommand {
+    static errors = [ErrorCode.UsageRequired, ErrorCode.ApiUnauthorized, ErrorCode.ApiForbidden, ErrorCode.ApiRateLimited, ErrorCode.ApiError, ErrorCode.GateInvalidResponse, ErrorCode.NetworkError, ErrorCode.NetworkTimeout, ErrorCode.ServiceUnavailable, ErrorCode.SearchFailed];
+    static summary = 'Search the web, return ranked excerpts';
+    static description = 'Search the web via Parallel Search.';
+    static examples = [
+        '<%= config.bin %> search "latest cloudflare workers features"',
+        '<%= config.bin %> search "react server components" --queries "RSC tutorial" "RSC vs SSR"',
+        '<%= config.bin %> --json search "python web frameworks 2026"',
+    ];
+    static aliases = ['s'];
+    static flags = {
+        queries: Flags.string({ description: 'Override queries (default: objective).', multiple: true }),
+    };
+    static args = {
+        objective: Args.string({ description: 'Search objective.', required: true, multiple: true }),
+    };
+    static enableJsonFlag = true;
+    static strict = true;
+    async execute() {
+        const { args, flags } = await this.parse(Search);
+        const objective = args.objective.join(' ');
+        if (!flags.quiet && !flags.json)
+            await writeStderr(`  ▸ searching: ${objective}\n`);
+        const data = await searchWeb({
+            objective,
+            queries: flags.queries,
+            timeoutSeconds: flags.timeout,
+        });
+        if (!flags.quiet && !flags.json) {
+            if (data.count === 0)
+                await writeStderr('  No results found.\n');
+            else
+                await writeStderr(`\n  ${data.count} results · ${data.elapsed_seconds}s\n`);
+        }
+        return data;
+    }
+}
+//# sourceMappingURL=search.js.map

package/dist/commands/social.js

@@ -0,0 +1,69 @@
+import { Args, Flags } from '@oclif/core';
+import { z } from 'zod';
+import { BaseCommand } from '../base-command.js';
+import { writeStderr } from '../io/io.js';
+import { searchSocial, validDepths, validTimeRanges } from '../services/social.js';
+import { ErrorCode } from '@eightstate/contracts/errors';
+export const SocialResultSchema = z.object({
+    title: z.string(),
+    url: z.string(),
+    content: z.string(),
+    score: z.number().nullable().optional(),
+    raw_content: z.string().nullable().optional(),
+});
+export const SocialDataSchema = z.object({
+    answer: z.string().nullable(),
+    results: z.array(SocialResultSchema),
+    platform: z.string(),
+    query: z.string(),
+});
+export default class Social extends BaseCommand {
+    static errors = [ErrorCode.UsageRequired, ErrorCode.UsageInvalid, ErrorCode.ValidationFailed, ErrorCode.AuthRequired, ErrorCode.ApiUnauthorized, ErrorCode.ApiForbidden, ErrorCode.ApiRateLimited, ErrorCode.ApiError, ErrorCode.GateInvalidResponse, ErrorCode.NetworkError, ErrorCode.NetworkTimeout, ErrorCode.ServiceUnavailable, ErrorCode.SocialFailed];
+    static summary = 'Search posts across social platforms';
+    static description = 'Search Reddit, X/Twitter, TikTok, LinkedIn, Instagram, Facebook, YouTube, or combined social domains via Tavily.';
+    static examples = [
+        '<%= config.bin %> social "what are people saying about Claude Code"',
+        '<%= config.bin %> social "AI trends 2026" --platform reddit',
+        '<%= config.bin %> social "product reviews" --platform tiktok,instagram --time week',
+        '<%= config.bin %> social "company sentiment" --platform linkedin,x --answer',
+        '<%= config.bin %> --json --quiet social "brand perception" --platform reddit,x',
+    ];
+    static aliases = [];
+    static flags = {
+        platform: Flags.string({ char: 'p', description: 'Platform(s), comma-separated: reddit,x,twitter,tiktok,linkedin,instagram,facebook,youtube,combined.' }),
+        time: Flags.option({ char: 't', description: 'Time range.', options: validTimeRanges() })(),
+        'max-results': Flags.integer({ char: 'n', description: 'Max results.', default: 10 }),
+        depth: Flags.option({ description: 'Search depth.', options: validDepths(), default: 'advanced' })(),
+        answer: Flags.boolean({ char: 'a', description: 'Include AI-synthesized answer.', default: false }),
+        raw: Flags.boolean({ description: 'Include full post content.', default: false }),
+        images: Flags.boolean({ description: 'Include images.', default: false }),
+        country: Flags.string({ description: 'Country for geo-targeting.' }),
+    };
+    static args = {
+        query: Args.string({ description: 'Search query.', required: true, multiple: true }),
+    };
+    static enableJsonFlag = true;
+    static strict = true;
+    async execute() {
+        const { args, flags } = await this.parse(Social);
+        const query = args.query.join(' ');
+        if (!flags.quiet && !flags.json)
+            await writeStderr(`  ▸ searching ${flags.platform ?? 'all platforms'}: ${query}\n`);
+        const data = await searchSocial({
+            query,
+            platform: flags.platform,
+            time: flags.time,
+            maxResults: flags['max-results'],
+            depth: flags.depth,
+            answer: flags.answer,
+            raw: flags.raw,
+            images: flags.images,
+            country: flags.country,
+            timeoutSeconds: flags.timeout,
+        });
+        if (!flags.quiet && !flags.json)
+            await writeStderr(`  ${data.results.length} results · ? credit(s)\n`);
+        return data;
+    }
+}
+//# sourceMappingURL=social.js.map

package/dist/commands/usage.js

@@ -0,0 +1,51 @@
+import { Flags } from '@oclif/core';
+import { z } from 'zod';
+import { BaseCommand } from '../base-command.js';
+import { writeStderr } from '../io/io.js';
+import { fetchUsage, normalizeDays } from '../services/usage.js';
+import { ErrorCode } from '@eightstate/contracts/errors';
+export const UsageDataSchema = z.record(z.string(), z.unknown());
+export default class Usage extends BaseCommand {
+    static errors = [ErrorCode.AuthRequired, ErrorCode.AuthInvalid, ErrorCode.AuthForbidden, ErrorCode.ApiRateLimited, ErrorCode.ApiError, ErrorCode.GateUnavailable, ErrorCode.GateInvalidResponse, ErrorCode.NetworkError, ErrorCode.NetworkTimeout, ErrorCode.UsageFetchFailed];
+    static summary = 'Show API usage and spend';
+    static description = 'Show API usage and spend analytics from the eightstate gate service.';
+    static examples = [
+        '<%= config.bin %> usage',
+        '<%= config.bin %> usage --days 7',
+        '<%= config.bin %> usage --service parallel',
+        '<%= config.bin %> usage --daily',
+        '<%= config.bin %> usage --pricing',
+        '<%= config.bin %> --json usage',
+    ];
+    static aliases = ['u'];
+    static flags = {
+        days: Flags.integer({ description: 'Window size in days.', default: 30 }),
+        service: Flags.string({ description: 'Filter to one service.' }),
+        daily: Flags.boolean({ description: 'Day-by-day breakdown.', default: false }),
+        pricing: Flags.boolean({ description: 'Show current pricing rules.', default: false }),
+    };
+    static enableJsonFlag = true;
+    static strict = true;
+    async execute() {
+        const flags = await this.parseFlags(Usage);
+        const days = normalizeDays(flags.days);
+        if (!flags.quiet && !flags.json)
+            await writeStderr(progressLine({ days, service: flags.service, daily: flags.daily, pricing: flags.pricing }));
+        return fetchUsage({
+            days: flags.days,
+            service: flags.service,
+            daily: flags.daily,
+            pricing: flags.pricing,
+        });
+    }
+}
+function progressLine(options) {
+    if (options.pricing)
+        return '  ▸ fetching pricing rules...\n';
+    if (options.daily)
+        return `  ▸ fetching daily breakdown (${options.days} days)...\n`;
+    if (options.service)
+        return `  ▸ fetching usage for ${options.service} (${options.days} days)...\n`;
+    return `  ▸ fetching usage summary (${options.days} days)...\n`;
+}
+//# sourceMappingURL=usage.js.map

package/dist/commands/version.js

@@ -0,0 +1,22 @@
+import { BaseCommand } from '../base-command.js';
+import { z } from 'zod';
+import { ErrorCode } from '@eightstate/contracts/errors';
+export const VersionDataSchema = z.object({
+    version: z.string(),
+    endpoint: z.string(),
+});
+export default class Version extends BaseCommand {
+    static errors = [ErrorCode.Internal];
+    static summary = 'Show escli version';
+    static description = 'Print the escli version and active default endpoint.';
+    static examples = ['<%= config.bin %> version', '<%= config.bin %> --json version'];
+    static enableJsonFlag = true;
+    async execute() {
+        const flags = await this.parseFlags(Version);
+        return {
+            version: this.config.version,
+            endpoint: flags['base-url'] ?? process.env.ESCLI_BASE_URL ?? 'https://ai.eightstate.co/v1',
+        };
+    }
+}
+//# sourceMappingURL=version.js.map

package/dist/entry.js

@@ -0,0 +1,120 @@
+#!/usr/bin/env node
+import { Config, Help } from '@oclif/core';
+import { dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { ErrorCode } from '@eightstate/contracts/errors';
+import { buildErrorEnvelope, buildUsageError } from './lib/envelope.js';
+import { GLOBAL_SHORT_FLAGS, globalFlagTakesValue, isGlobalFlagToken } from './lib/globals.js';
+import { commandRegistry, commandsById } from './lib/registry.js';
+import { writeStdout } from './io/io.js';
+const moduleDir = dirname(fileURLToPath(import.meta.url));
+const pjson = {
+    name: '@eightstate/escli',
+    version: '0.5.0',
+    type: 'module',
+    oclif: {
+        bin: 'escli',
+        enableJsonFlag: true,
+        topicSeparator: ' ',
+    },
+};
+const plugin = { root: moduleDir, pjson, name: pjson.name, alias: pjson.name, type: 'core', valid: true, commands: [], topics: [], hooks: {}, commandIDs: [] };
+const config = await Config.load({
+    root: moduleDir,
+    pjson,
+    plugins: new Map([[pjson.name, plugin]]),
+});
+const start = Date.now();
+const argv = [...process.argv.slice(2)];
+const globals = [];
+while (argv[0] && isGlobalFlagToken(argv[0])) {
+    const flag = argv.shift();
+    globals.push(GLOBAL_SHORT_FLAGS.has(flag) ? `--${GLOBAL_SHORT_FLAGS.get(flag)}` : flag);
+    if (globalFlagTakesValue(flag) && !flag.includes('=') && argv[0] && !argv[0].startsWith('--')) {
+        globals.push(argv.shift());
+    }
+}
+const manifestRequested = globals.includes('--describe') || globals.includes('--schema');
+let versionRequested = globals.includes('--version');
+let helpRequested = globals.includes('--help');
+const rootManifestRequested = manifestRequested && argv.length === 0;
+const firstCommandToken = argv.shift() ?? (manifestRequested || versionRequested ? 'version' : undefined);
+let commandId = firstCommandToken;
+let registration = commandId ? commandsById.get(commandId) : undefined;
+if (firstCommandToken && argv.length > 0) {
+    const nestedCommandId = `${firstCommandToken} ${argv[0]}`;
+    const nestedRegistration = commandsById.get(nestedCommandId);
+    if (nestedRegistration) {
+        commandId = nestedCommandId;
+        registration = nestedRegistration;
+        argv.shift();
+    }
+}
+if (argv.includes('--help') || argv.includes('-h'))
+    helpRequested = true;
+if (argv.includes('--version') || argv.includes('-v'))
+    versionRequested = true;
+if (helpRequested) {
+    await emitHelp(commandId, argv);
+}
+if (versionRequested) {
+    commandId = 'version';
+    registration = commandsById.get(commandId);
+    argv.length = 0;
+}
+else if (!registration && manifestRequested) {
+    commandId = 'version';
+    registration = commandsById.get(commandId);
+}
+else if (registration && manifestRequested) {
+    if (rootManifestRequested)
+        globals.push('--root-manifest');
+    globals.push(...argv.filter((token) => token === '--describe' || token === '--schema'));
+    argv.length = 0;
+}
+if (helpRequested) {
+    process.exitCode = 0;
+}
+else if (!registration) {
+    const error = buildUsageError(commandId ? `command ${commandId} not found` : 'command required', commandId ? ErrorCode.UsageUnknownCommand : ErrorCode.UsageRequired);
+    process.exitCode = 2;
+    await writeStdout(`${JSON.stringify(buildErrorEnvelope(commandId ?? 'unknown', config.version, error, Date.now() - start))}\n`);
+}
+else {
+    const CommandClass = registration.command;
+    CommandClass.id = registration.id;
+    CommandClass.plugin = plugin;
+    CommandClass.pluginName = pjson.name;
+    CommandClass.pluginAlias = pjson.name;
+    CommandClass.pluginType = 'core';
+    const instance = new CommandClass([...globals, ...argv], config);
+    await instance._run();
+}
+async function emitHelp(commandId, argv) {
+    const commands = commandRegistry.map((registration) => {
+        const CommandClass = registration.command;
+        const staticArgs = CommandClass.args ?? {};
+        return {
+            aliases: registration.aliases.map((alias) => alias.replaceAll(' ', ':')),
+            args: Object.fromEntries(Object.entries(staticArgs).map(([name, arg]) => [name, typeof arg === 'object' && arg ? { ...arg, name } : arg])),
+            description: registration.description,
+            examples: registration.command.examples,
+            flags: Object.fromEntries(Object.entries(registration.flags).map(([name, flag]) => [name, typeof flag === 'object' && flag ? { ...flag, name } : flag])),
+            hasDynamicHelp: false,
+            hidden: false,
+            hiddenAliases: [],
+            id: registration.id.replaceAll(' ', ':'),
+            load: async () => registration.command,
+            pluginAlias: pjson.name,
+            pluginName: pjson.name,
+            pluginType: 'core',
+            strict: registration.command.strict,
+            summary: registration.summary,
+        };
+    });
+    const helpPlugin = { ...plugin, commands, commandIDs: commands.map((command) => command.id) };
+    const helpConfig = await Config.load({ root: moduleDir, pjson, plugins: new Map([[pjson.name, helpPlugin]]) });
+    const help = new Help(helpConfig, { hideAliasesFromRoot: true });
+    await help.showHelp(commandId ? [...commandId.split(' '), ...argv, '--help'] : ['--help']);
+}
+//# sourceMappingURL=entry.js.map

package/dist/io/io.js

@@ -0,0 +1,322 @@
+import { ux } from '@oclif/core';
+import chalk from 'chalk';
+export function isPlainOutput() {
+    return Boolean(process.env.NO_COLOR) || Boolean(process.env.CI) || !process.stdout.isTTY;
+}
+export function stylize(value, style) {
+    return isPlainOutput() ? value : style(value);
+}
+export async function writeStdout(value) {
+    process.stdout.write(value);
+}
+export async function writeStderr(value) {
+    process.stderr.write(value);
+}
+export function renderKeyValue(rows) {
+    return rows.map(([key, value]) => `${chalk.bold(key)}  ${value}`).join('\n');
+}
+export function renderModelList(data) {
+    const lines = ['', `  ${'MODEL'.padEnd(40)}`, `  ${'─'.repeat(40)}`];
+    for (const model of data.models)
+        lines.push(`  ${model}`);
+    lines.push('', `  ${data.count} models available`, '');
+    return lines.join('\n');
+}
+export function renderAuthStatus(data) {
+    const rows = [['profile', data.profile], ['auth', data.auth_type]];
+    if (data.key)
+        rows.push(['key', data.key]);
+    rows.push(['endpoint', data.endpoint]);
+    return renderKeyValue(rows);
+}
+export function renderAuthProfiles(data) {
+    if (data.profiles.length === 0)
+        return 'no profiles. run: escli auth login';
+    const lines = [`${'PROFILE'.padEnd(16)} ${'KEY'.padEnd(24)} ENDPOINT`];
+    for (const profile of data.profiles)
+        lines.push(`${profile.active ? '*' : ' '} ${profile.name.padEnd(14)} ${profile.key.padEnd(24)} ${profile.endpoint}`);
+    lines.push(`${data.count} profile(s)`);
+    return lines.join('\n');
+}
+export function renderAuthLogin(data) {
+    const rows = [['profile', data.profile], ['auth', data.auth_type]];
+    if (data.key)
+        rows.push(['key', data.key]);
+    if (data.models)
+        rows.push(['models', data.models]);
+    if (data.endpoint)
+        rows.push(['endpoint', data.endpoint]);
+    if (data.gate)
+        rows.push(['gate', data.gate]);
+    return renderKeyValue(rows);
+}
+export function renderAuthSwitch(data) {
+    return `switched → ${data.active_profile}`;
+}
+export function renderAuthLogout(data) {
+    if (data.message)
+        return data.message;
+    return `profile '${data.profile ?? ''}' ${data.deleted ? 'removed' : 'not found'}`;
+}
+export function renderDocsSearch(data) {
+    if (data.results.length === 0)
+        return '  No results found.\n';
+    const cacheLabel = data.cached ? ' (cached)' : '';
+    const lines = ['', `  Search results${cacheLabel}:`, ''];
+    for (const result of data.results) {
+        lines.push(`  ${(result.id ?? '').padEnd(40)} ${result.title ?? ''}`);
+        lines.push(`    state=${result.state ?? ''}  stars=${result.stars ?? ''}  ${(result.description ?? '').slice(0, 80)}`);
+    }
+    lines.push('');
+    return `${lines.join('\n')}\n`;
+}
+export function renderDocsSearchTsv(data) {
+    return data.results.map((result) => `${result.id ?? ''}\t${result.title ?? ''}\t${result.state ?? ''}`).join('\n') + (data.results.length > 0 ? '\n' : '');
+}
+export function renderDocsContent(data) {
+    return data.content;
+}
+export function renderFetch(data) {
+    const lines = [];
+    for (const result of data.results) {
+        if (result.title)
+            lines.push(`\n  # ${result.title}`);
+        lines.push(`  ${result.url}\n`);
+        for (const excerpt of result.excerpts ?? [])
+            lines.push(excerpt, '');
+        if (result.full_content)
+            lines.push(result.full_content);
+    }
+    return lines.join('\n');
+}
+export function renderSearch(data) {
+    const lines = [];
+    for (const result of data.results) {
+        lines.push(`\n  ${result.title}`);
+        lines.push(`  ${result.url}`);
+        for (const excerpt of result.excerpts.slice(0, 2))
+            lines.push(`    ${excerpt.trim().replace(/\n/gu, ' ').slice(0, 200)}`);
+    }
+    return lines.join('\n');
+}
+export function renderSocial(data) {
+    const lines = [];
+    if (data.answer)
+        lines.push(`\n  ${data.answer}\n`);
+    for (const result of data.results) {
+        lines.push(`  ${socialPlatformTag(result.url)}${result.title}`);
+        lines.push(`  ${result.url}`);
+        if (result.content)
+            lines.push(`    ${result.content.trim().replace(/\n/gu, ' ').slice(0, 200)}`);
+        lines.push('');
+    }
+    return lines.join('\n');
+}
+function socialPlatformTag(url) {
+    if (url.includes('reddit.com'))
+        return '[reddit] ';
+    if (url.includes('x.com') || url.includes('twitter.com'))
+        return '[x] ';
+    if (url.includes('tiktok.com'))
+        return '[tiktok] ';
+    if (url.includes('linkedin.com'))
+        return '[linkedin] ';
+    if (url.includes('instagram.com'))
+        return '[instagram] ';
+    if (url.includes('facebook.com'))
+        return '[facebook] ';
+    if (url.includes('youtube.com'))
+        return '[youtube] ';
+    return '';
+}
+export function renderResearch(data) {
+    if (Array.isArray(data.processors)) {
+        const lines = ['', '  Standard processors:', ''];
+        for (const processor of data.processors)
+            lines.push(`  ${processor.name}`);
+        lines.push('');
+        return lines.join('\n');
+    }
+    if (data.status)
+        return `${data.run_id}: ${data.status}`;
+    if (data.path)
+        return data.path;
+    if (data.output === null)
+        return '*No output returned.*';
+    const content = data.output?.content;
+    if (typeof content === 'string')
+        return content;
+    if (content !== undefined)
+        return JSON.stringify(content, null, 2);
+    return '';
+}
+export function renderVersion(data) {
+    return `escli v${data.version}\nendpoint  ${data.endpoint}`;
+}
+export function renderUsage(data) {
+    if (Array.isArray(data.rules) || Array.isArray(data.pricing) || Array.isArray(data.pricing_rules))
+        return renderUsagePricing(data);
+    if (Array.isArray(data.days) || Array.isArray(data.by_day))
+        return renderUsageDaily(data);
+    if (Array.isArray(data.services))
+        return renderUsageByService(data);
+    return renderUsageSummary(data);
+}
+function renderUsageSummary(data) {
+    const days = numberValue(data.days) ?? 30;
+    const service = stringValue(data.service);
+    const totalRequests = data.total_requests ?? data.requests ?? data.total_events ?? 0;
+    const totalCost = data.total_cost_usd ?? data.total_cost ?? data.estimated_cost_usd ?? 0;
+    const lines = ['', `  Usage  ·  last ${days} day${days === 1 ? '' : 's'}${service ? `  ·  service: ${service}` : ''}`];
+    const start = stringValue(data.start ?? data.range_start);
+    const end = stringValue(data.end ?? data.range_end);
+    if (start && end)
+        lines.push(`  · ${formatDateRange(start)}  →  ${formatDateRange(end)}`);
+    lines.push(`  ${'─'.repeat(60)}`);
+    lines.push(`  ${'requests'.padEnd(24)} ${formatInt(totalRequests).padStart(20)}`);
+    lines.push(`  ${'estimated spend'.padEnd(24)} ${formatMoney(totalCost).padStart(20)}`);
+    const services = serviceRows(data.by_service ?? data.services);
+    if (services.length > 0) {
+        lines.push('', `  ${'SERVICE'.padEnd(16)} ${'REQUESTS'.padStart(12)} ${'SPEND'.padStart(14)}`, `  ${'─'.repeat(46)}`);
+        services.sort((a, b) => b.cost - a.cost);
+        for (const row of services)
+            lines.push(`  ${row.name.padEnd(16)} ${formatInt(row.requests).padStart(12)} ${formatMoney(row.cost).padStart(14)}`);
+    }
+    lines.push('');
+    return lines.join('\n');
+}
+function renderUsageByService(data) {
+    const days = numberValue(data.days) ?? 30;
+    const rows = serviceRows(data.services ?? data.by_service, true);
+    const lines = [
+        '',
+        `  By service  ·  last ${days} day${days === 1 ? '' : 's'}`,
+        `  ${'─'.repeat(70)}`,
+        `  ${'SERVICE'.padEnd(14)} ${'REQUESTS'.padStart(10)} ${'TOKENS IN'.padStart(12)} ${'TOKENS OUT'.padStart(12)} ${'SPEND'.padStart(14)}`,
+        `  ${'─'.repeat(70)}`,
+    ];
+    for (const row of rows)
+        lines.push(`  ${row.name.padEnd(14)} ${formatInt(row.requests).padStart(10)} ${formatInt(row.tokensIn).padStart(12)} ${formatInt(row.tokensOut).padStart(12)} ${formatMoney(row.cost).padStart(14)}`);
+    lines.push('');
+    return lines.join('\n');
+}
+function renderUsageDaily(data) {
+    const days = numberValue(data.days) ?? 30;
+    const service = stringValue(data.service);
+    const rows = arrayValue(data.days ?? data.by_day);
+    const lines = [
+        '',
+        `  Daily usage  ·  last ${days} day${days === 1 ? '' : 's'}${service ? `  ·  service: ${service}` : ''}`,
+        `  ${'─'.repeat(50)}`,
+        `  ${'DATE'.padEnd(12)} ${'REQUESTS'.padStart(12)} ${'SPEND'.padStart(14)}`,
+        `  ${'─'.repeat(50)}`,
+    ];
+    let totalRequests = 0;
+    let totalCost = 0;
+    for (const item of rows) {
+        const entry = recordValue(item) ?? {};
+        const date = String(entry.date ?? entry.day ?? '?').split('T')[0];
+        const requests = numberValue(entry.requests ?? entry.count) ?? 0;
+        const cost = numberValue(entry.cost_usd ?? entry.cost) ?? 0;
+        totalRequests += requests;
+        totalCost += cost;
+        lines.push(`  ${date.padEnd(12)} ${formatInt(requests).padStart(12)} ${formatMoney(cost).padStart(14)}`);
+    }
+    if (rows.length > 0) {
+        lines.push(`  ${'─'.repeat(50)}`);
+        lines.push(`  ${'total'.padEnd(12)} ${formatInt(totalRequests).padStart(12)} ${formatMoney(totalCost).padStart(14)}`);
+    }
+    else {
+        lines.push('  (no events in range)');
+    }
+    lines.push('');
+    return lines.join('\n');
+}
+function renderUsagePricing(data) {
+    const rules = arrayValue(data.rules ?? data.pricing ?? data.pricing_rules)
+        .map((item) => recordValue(item) ?? {})
+        .filter((rule) => rule.enabled !== 0)
+        .sort((a, b) => `${a.service ?? ''}:${a.sku ?? ''}`.localeCompare(`${b.service ?? ''}:${b.sku ?? ''}`));
+    const lines = [
+        '',
+        '  Pricing rules',
+        `  ${'─'.repeat(70)}`,
+        `  ${'SERVICE'.padEnd(14)} ${'SKU'.padEnd(24)} ${'UNIT'.padEnd(14)} ${'COST/UNIT'.padStart(14)}`,
+        `  ${'─'.repeat(70)}`,
+    ];
+    for (const rule of rules) {
+        lines.push(`  ${String(rule.service ?? '?').padEnd(14)} ${String(rule.sku ?? '?').padEnd(24)} ${String(rule.unit_label ?? rule.unit ?? '').padEnd(14)} ${formatUnitCost(rule.cost_per_unit).padStart(14)}`);
+    }
+    if (rules.length === 0)
+        lines.push('  (no pricing rules configured)');
+    lines.push('');
+    return lines.join('\n');
+}
+function serviceRows(value, includeTokens = false) {
+    const rows = [];
+    if (Array.isArray(value)) {
+        for (const item of value) {
+            const entry = recordValue(item) ?? {};
+            rows.push({
+                name: String(entry.service ?? entry.name ?? '?'),
+                requests: numberValue(entry.requests ?? entry.count) ?? 0,
+                cost: numberValue(entry.cost_usd ?? entry.cost) ?? 0,
+                tokensIn: includeTokens ? numberValue(entry.tokens_in) ?? 0 : 0,
+                tokensOut: includeTokens ? numberValue(entry.tokens_out) ?? 0 : 0,
+            });
+        }
+        return rows;
+    }
+    const record = recordValue(value);
+    if (!record)
+        return rows;
+    for (const [name, item] of Object.entries(record)) {
+        const entry = recordValue(item) ?? {};
+        rows.push({
+            name,
+            requests: numberValue(entry.requests ?? entry.count) ?? 0,
+            cost: numberValue(entry.cost_usd ?? entry.cost) ?? 0,
+            tokensIn: includeTokens ? numberValue(entry.tokens_in) ?? 0 : 0,
+            tokensOut: includeTokens ? numberValue(entry.tokens_out) ?? 0 : 0,
+        });
+    }
+    return rows;
+}
+function formatMoney(value) {
+    const number = numberValue(value);
+    if (number === undefined)
+        return '—';
+    if (number === 0)
+        return '$0.00';
+    if (Math.abs(number) < 0.01)
+        return `$${number.toFixed(4)}`;
+    return `$${number.toLocaleString('en-US', { minimumFractionDigits: 2, maximumFractionDigits: 2 })}`;
+}
+function formatUnitCost(value) {
+    const number = numberValue(value);
+    if (number === undefined)
+        return '—';
+    return number < 0.01 ? `$${number.toFixed(6)}` : `$${number.toFixed(4)}`;
+}
+function formatInt(value) {
+    const number = numberValue(value);
+    return number === undefined ? '—' : Math.trunc(number).toLocaleString('en-US');
+}
+function formatDateRange(value) {
+    return value.split('.')[0]?.replace('T', ' ') ?? value;
+}
+function arrayValue(value) {
+    return Array.isArray(value) ? value : [];
+}
+function recordValue(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : undefined;
+}
+function stringValue(value) {
+    return typeof value === 'string' && value.length > 0 ? value : undefined;
+}
+function numberValue(value) {
+    const number = Number(value);
+    return Number.isFinite(number) ? number : undefined;
+}
+export { chalk, ux };
+//# sourceMappingURL=io.js.map

package/dist/lib/build-flags.js

@@ -0,0 +1,2 @@
+export const IS_TEST_BUILD = typeof __ESCLI_TEST__ === 'undefined' ? true : __ESCLI_TEST__;
+//# sourceMappingURL=build-flags.js.map

package/dist/lib/command-metadata.js

@@ -0,0 +1,8 @@
+export const commandMetadata = new Map();
+export function registerCommandMetadata(metadata) {
+    commandMetadata.set(metadata.id, metadata);
+}
+export function getCommandMetadata(id) {
+    return commandMetadata.get(id);
+}
+//# sourceMappingURL=command-metadata.js.map