@bytevion/cli 0.1.0 → 0.3.0

package/dist/commands/providers/add.js

@@ -1,39 +1,121 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 const core_1 = require("@oclif/core");
 const base_1 = require("../../base");
-const util_1 = require("../../lib/util");
+const providers_1 = require("../../lib/providers");
+const tty_1 = require("../../lib/tty");
+const ui = __importStar(require("../../lib/ui"));
 class ProvidersAdd extends base_1.BaseCommand {
-    static description = 'Add an upstream provider key (BYOK). Byte stores it encrypted and can auto-import models.';
-    static examples = ['<%= config.bin %> providers add', '<%= config.bin %> providers add --api-key sk-... --label "OpenAI prod"'];
+    static description = 'Connect an upstream provider key (BYOK). Byte stores it encrypted and imports models.';
+    static examples = [
+        '<%= config.bin %> providers add --provider deepseek --api-key sk-...',
+        '<%= config.bin %> providers add --provider custom --provider-base-url https://api.example.com/v1 --api-key ...',
+    ];
     static flags = {
+        provider: core_1.Flags.string({ description: 'Provider preset id (openai, deepseek, anthropic, …)' }),
         'api-key': core_1.Flags.string({ description: 'Upstream provider API key', env: 'BYTE_PROVIDER_KEY' }),
-        mode: core_1.Flags.string({ description: 'Gateway mode for this provider', default: 'byte_auto' }),
-        label: core_1.Flags.string({ description: 'A label for this connection' }),
-        'no-fetch': core_1.Flags.boolean({ description: 'Skip auto-importing the provider model list' }),
+        'provider-base-url': core_1.Flags.string({ description: 'Custom base URL (for --provider custom or to override)' }),
+        mode: core_1.Flags.string({ description: 'Gateway mode (byte_compatible/byte_messages/byte_generative)' }),
+        label: core_1.Flags.string({ description: 'Label for this connection' }),
+        'no-fetch': core_1.Flags.boolean({ description: 'Skip auto-importing the model list' }),
     };
     async run() {
         const { flags } = await this.parse(ProvidersAdd);
         this.requireToken(flags);
+        const api = this.api(flags);
+        let preset = flags.provider ? (0, providers_1.findPreset)(flags.provider) : undefined;
+        if (flags.provider && !preset) {
+            return this.error(`Unknown provider "${flags.provider}". Run \`byte providers add --help\` for the list.`, { exit: 2 });
+        }
+        let baseUrl = flags['provider-base-url'] || preset?.base_url;
+        let mode = flags.mode || preset?.gateway_mode || 'byte_compatible';
         let apiKey = flags['api-key'];
+        if ((0, tty_1.interactive)() && !this.jsonEnabled() && (!preset || !baseUrl || !apiKey)) {
+            if (!preset) {
+                const id = await ui.select({
+                    message: 'Which provider?',
+                    options: providers_1.PROVIDER_PRESETS.map((p) => ({ value: p.id, label: p.label, hint: p.advanced ? 'advanced' : undefined })),
+                });
+                preset = (0, providers_1.findPreset)(id);
+                baseUrl = preset.base_url;
+                mode = preset.gateway_mode;
+            }
+            if (preset.custom || !baseUrl) {
+                baseUrl = await ui.text({ message: 'Provider base URL', placeholder: 'https://api.example.com/v1', validate: (v) => (v.startsWith('http') ? undefined : 'Must be a URL') });
+            }
+            if (preset.advanced && preset.note)
+                await ui.log.warn(preset.note);
+            if (!apiKey)
+                apiKey = await ui.password({ message: `${preset.label} API key`, validate: (v) => (v.trim() ? undefined : 'Required') });
+        }
         if (!apiKey)
-            apiKey = await (0, util_1.promptHidden)('Upstream provider API key: ');
-        if (!apiKey)
-            return this.error('A provider API key is required.', { exit: 2 });
-        const body = {
-            api_key: apiKey,
-            gateway_mode: flags.mode,
-            auto_fetch: !flags['no-fetch'],
-        };
+            return this.error('Missing --api-key (or run interactively).', { exit: 2 });
+        if (!baseUrl)
+            return this.error('Missing provider base URL — pass --provider <preset> or --provider-base-url.', { exit: 2 });
+        const body = { api_key: apiKey, gateway_mode: mode, base_url: baseUrl, auto_fetch: !flags['no-fetch'] };
         if (flags.label)
             body.label = flags.label;
-        const res = await this.api(flags).providersAdd(body);
-        if (!this.jsonEnabled()) {
-            const id = res.id ?? res.connection?.id;
-            const imported = res.fetch_result?.imported ?? res.imported ?? 0;
-            this.log(`Provider connection added (id ${id}). Models imported: ${imported}.`);
-            this.log('Next: `byte keys create <name>` then `byte integrate <harness>`.');
+        if ((0, tty_1.interactive)() && !this.jsonEnabled()) {
+            const spin = await ui.spinner();
+            spin.start('Connecting provider…');
+            let res;
+            try {
+                res = await api.providersAdd(body);
+            }
+            catch (err) {
+                spin.stop('Connection failed.');
+                throw err;
+            }
+            const models = res.fetch_result?.models ?? res.models ?? [];
+            spin.stop(`Connected — ${models.length} model(s) imported.`);
+            if (models.length) {
+                const alias = await ui.select({
+                    message: 'Model id to use in your tools',
+                    options: models.slice(0, 50).map((m) => ({ value: m.byte_alias, label: m.byte_alias, hint: m.model_id })),
+                });
+                await ui.note(alias, 'Model id (use this everywhere)');
+            }
+            return res;
         }
+        const res = await api.providersAdd(body);
+        if (this.jsonEnabled())
+            return res;
+        const id = res.id ?? res.connection?.id;
+        const imported = res.fetch_result?.imported ?? res.imported ?? 0;
+        this.log(`Provider connection added (id ${id}). Models imported: ${imported}.`);
         return res;
     }
 }

package/dist/commands/providers/rotate.js

@@ -1,8 +1,42 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 const core_1 = require("@oclif/core");
 const base_1 = require("../../base");
-const util_1 = require("../../lib/util");
+const tty_1 = require("../../lib/tty");
+const ui = __importStar(require("../../lib/ui"));
 class ProvidersRotate extends base_1.BaseCommand {
     static description = 'Replace the upstream API key on a provider connection (keeps imported models).';
     static args = {
@@ -15,10 +49,11 @@ class ProvidersRotate extends base_1.BaseCommand {
         const { args, flags } = await this.parse(ProvidersRotate);
         this.requireToken(flags);
         let apiKey = flags['api-key'];
+        if (!apiKey && (0, tty_1.interactive)() && !this.jsonEnabled()) {
+            apiKey = await ui.password({ message: 'New upstream provider API key', validate: (v) => (v.trim() ? undefined : 'Required') });
+        }
         if (!apiKey)
-            apiKey = await (0, util_1.promptHidden)('New upstream provider API key: ');
-        if (!apiKey)
-            return this.error('A provider API key is required.', { exit: 2 });
+            return this.error('Missing --api-key.', { exit: 2 });
         const res = await this.api(flags).providersRotate(args.id, apiKey);
         if (!this.jsonEnabled())
             this.log(`Rotated provider key on connection ${args.id} (now ****${res.secret_last4 ?? '????'}).`);

package/dist/commands/setup.d.ts

@@ -0,0 +1,19 @@
+import { BaseCommand } from '../base';
+export default class Setup extends BaseCommand {
+    static description: string;
+    static aliases: string[];
+    static examples: string[];
+    static flags: {
+        provider: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'provider-key': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'provider-base-url': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        mode: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        preset: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'key-name': import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'skip-provider': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        connect: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    run(): Promise<unknown>;
+    private connectProvider;
+    private runNonInteractive;
+}

package/dist/commands/setup.js

@@ -0,0 +1,277 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const base_1 = require("../base");
+const auth_1 = require("../lib/auth");
+const credentials_1 = require("../lib/credentials");
+const presets_1 = require("../lib/presets");
+const providers_1 = require("../lib/providers");
+const tty_1 = require("../lib/tty");
+const ui = __importStar(require("../lib/ui"));
+class Setup extends base_1.BaseCommand {
+    static description = 'Guided setup: sign in, connect a provider, create a Byte key, and wire a tool.';
+    static aliases = ['init', 'onboard'];
+    static examples = ['<%= config.bin %> setup', '<%= config.bin %> setup --provider deepseek --provider-key sk-... --connect opencode --json'];
+    static flags = {
+        provider: core_1.Flags.string({ description: 'Provider preset id (openai, deepseek, anthropic, …)' }),
+        'provider-key': core_1.Flags.string({ description: 'Upstream provider API key', env: 'BYTE_PROVIDER_KEY' }),
+        'provider-base-url': core_1.Flags.string({ description: 'Custom provider base URL (for --provider custom)' }),
+        mode: core_1.Flags.string({ description: 'Gateway mode override (byte_compatible/byte_messages/byte_generative)' }),
+        preset: core_1.Flags.string({
+            description: 'Optimization mode',
+            options: ['maximum', 'balanced', 'max_savings', 'lowest_latency', 'reliability_first'],
+            default: 'maximum',
+        }),
+        'key-name': core_1.Flags.string({ description: 'Name for the Byte key', default: 'cli' }),
+        'skip-provider': core_1.Flags.boolean({ description: 'Skip connecting a provider' }),
+        connect: core_1.Flags.string({ description: 'Tool to wire after setup (e.g. opencode, codex)' }),
+    };
+    async run() {
+        const { flags } = await this.parse(Setup);
+        const profile = this.profileFrom(flags);
+        const base = this.baseUrlFrom(flags);
+        if (this.jsonEnabled() || !(0, tty_1.interactive)()) {
+            return this.runNonInteractive(flags, profile, base);
+        }
+        await ui.intro(ui.banner());
+        // 1) Sign in
+        let token = (0, credentials_1.getToken)(profile);
+        const api = this.api(flags);
+        if (token) {
+            try {
+                const me = await api.me();
+                await ui.log.info(`Signed in as ${me.user?.email ?? 'you'}`);
+            }
+            catch {
+                token = undefined;
+            }
+        }
+        if (!token) {
+            await (0, auth_1.deviceLogin)({ baseUrl: base, profile });
+        }
+        // 2) Connect a provider
+        let provider = { status: 'skipped' };
+        if (!flags['skip-provider']) {
+            const existing = await api.providersList().catch(() => ({ connections: [] }));
+            const conns = existing.connections ?? (Array.isArray(existing) ? existing : []);
+            let addNew = true;
+            if (conns.length) {
+                addNew =
+                    (await ui.select({
+                        message: 'Provider',
+                        options: [
+                            { value: 'existing', label: `Use existing connection (${conns.length})` },
+                            { value: 'new', label: 'Connect a new provider' },
+                        ],
+                    })) === 'new';
+                if (!addNew)
+                    provider = { status: 'connected' };
+            }
+            if (addNew) {
+                provider = await this.connectProvider(api, flags);
+            }
+        }
+        // 3) Choose the optimization mode
+        const preset = await ui.select({
+            message: 'Optimization mode',
+            options: presets_1.PRESET_CARDS.map((c) => ({ value: c.value, label: c.label, hint: c.hint })),
+            initialValue: presets_1.PRESET_CARDS.some((c) => c.value === flags.preset) ? flags.preset : 'maximum',
+        });
+        // 4) Create a Byte key
+        let byteKey = (0, credentials_1.getByteKey)(profile);
+        if (!byteKey) {
+            const name = await ui.text({ message: 'Name this Byte key', defaultValue: flags['key-name'] || 'cli' });
+            const res = await api.keysCreate({ name: name || 'cli', preset });
+            byteKey = String(res.key);
+            (0, credentials_1.setByteKey)(profile, byteKey);
+            await ui.revealSecret('Your Byte API key', byteKey);
+        }
+        // 5) Apply the optimization mode to the org
+        await api.optPatch({ default_mode: preset }).catch(() => undefined);
+        await ui.log.success(`Optimizations: ${preset} mode applied — every layer this mode enables now runs on each request.`);
+        // 6) Connect a tool
+        const connect = await ui.select({
+            message: 'Connect a coding tool now?',
+            options: [
+                { value: 'skip', label: 'Skip for now' },
+                { value: 'opencode', label: 'opencode' },
+                { value: 'claude-code', label: 'Claude Code' },
+                { value: 'codex', label: 'Codex CLI' },
+                { value: 'cursor', label: 'Cursor' },
+                { value: 'cline', label: 'Cline' },
+                { value: 'aider', label: 'Aider' },
+            ],
+        });
+        if (connect !== 'skip') {
+            const argv = [connect, '--write', '--yes', ...(provider.alias ? ['--model', provider.alias] : [])];
+            await this.config.runCommand('integrate', argv);
+        }
+        // Accurate close-out — never claim a provider is wired when it is not.
+        const tips = [`${ui.theme.accent('byte run "hello from byte"')}`, `${ui.theme.accent('byte usage')}`];
+        if (provider.status === 'saved') {
+            await ui.note(`Your provider is saved but no model loaded yet. Fix the key/URL, then run ${ui.theme.accent('byte providers test')}.`, 'One thing left');
+        }
+        else if (provider.status === 'skipped' && !flags['skip-provider']) {
+            tips.unshift(`${ui.theme.accent('byte providers add')}`);
+        }
+        await ui.outro(`${ui.theme.ok('Setup complete.')}  Next: ${tips.join(' · ')}`);
+        return { status: 'setup_complete', profile, model: provider.alias, provider: provider.status, preset };
+    }
+    async connectProvider(api, flags) {
+        const providerId = await ui.select({
+            message: 'Which provider?',
+            options: providers_1.PROVIDER_PRESETS.map((p) => ({ value: p.id, label: p.label, hint: p.advanced ? 'advanced' : undefined })),
+        });
+        const preset = (0, providers_1.findPreset)(providerId);
+        let baseUrl = preset.base_url;
+        if (preset.custom || !baseUrl) {
+            baseUrl = await ui.text({
+                message: 'Provider base URL',
+                placeholder: 'https://api.example.com/v1',
+                validate: (v) => (v.startsWith('http') ? undefined : 'Must be a URL'),
+            });
+        }
+        if (preset.advanced && preset.note)
+            await ui.log.warn(preset.note);
+        const key = await ui.password({ message: `${preset.label} API key`, validate: (v) => (v.trim() ? undefined : 'Required') });
+        const spin = await ui.spinner();
+        spin.start(`Connecting ${preset.label}…`);
+        let res;
+        try {
+            res = await api.providersAdd({ api_key: key, gateway_mode: flags.mode || preset.gateway_mode, base_url: baseUrl, auto_fetch: true });
+        }
+        catch (err) {
+            spin.stop('Could not save the provider connection.');
+            await ui.log.error(err?.message ?? String(err));
+            return { status: 'failed' };
+        }
+        const connId = res.id ?? res.connection?.id;
+        let fetchResult = res.fetch_result ?? {};
+        let models = res.models ?? fetchResult.models ?? [];
+        // Retry / keep / skip loop — a failed model import never silently passes as success.
+        for (;;) {
+            const failed = fetchResult.status === 'error' || Boolean(res.fetch_error) || Boolean(fetchResult.last_error);
+            if (!failed || models.length) {
+                spin.stop(`Connected ${preset.label} — ${models.length} model(s) imported.`);
+                break;
+            }
+            spin.stop(`Saved ${preset.label}, but its models could not be loaded.`);
+            await ui.log.warn(String(fetchResult.last_error || res.fetch_error || 'The provider URL or key looks unreachable right now.'));
+            const choice = await ui.select({
+                message: 'What would you like to do?',
+                options: [
+                    { value: 'retry', label: 'Re-enter the key and retry' },
+                    { value: 'keep', label: 'Keep it — I will pick a model later' },
+                    { value: 'skip', label: 'Skip the provider for now' },
+                ],
+            });
+            if (choice !== 'retry' || !connId)
+                return { status: choice === 'skip' ? 'skipped' : 'saved' };
+            const retryKey = await ui.password({ message: `${preset.label} API key`, validate: (v) => (v.trim() ? undefined : 'Required') });
+            spin.start('Retrying…');
+            try {
+                await api.providersRotate(connId, retryKey);
+                const test = await api.providersTest(connId);
+                models = test.models ?? [];
+                fetchResult = { status: models.length ? 'ok' : 'error', last_error: models.length ? null : 'No models returned.' };
+                res = { ...res, fetch_error: undefined };
+            }
+            catch (err) {
+                models = [];
+                fetchResult = { status: 'error', last_error: err?.message ?? String(err) };
+                res = { ...res, fetch_error: undefined };
+            }
+        }
+        if (models.length) {
+            const alias = await ui.select({
+                message: 'Default model',
+                options: models.slice(0, 50).map((m) => ({ value: m.byte_alias, label: m.byte_alias, hint: m.model_id })),
+            });
+            return { alias, status: 'connected' };
+        }
+        return { status: 'saved' };
+    }
+    async runNonInteractive(flags, profile, base) {
+        this.requireToken(flags);
+        const api = this.api(flags);
+        let imported = 0;
+        let providerStatus = flags['skip-provider'] ? 'skipped' : 'skipped';
+        let providerError;
+        let chosenAlias;
+        const key = flags['provider-key'];
+        if (key && !flags['skip-provider']) {
+            const preset = flags.provider ? (0, providers_1.findPreset)(flags.provider) : undefined;
+            const baseUrl = flags['provider-base-url'] || preset?.base_url;
+            const mode = flags.mode || preset?.gateway_mode || 'byte_compatible';
+            if (!baseUrl) {
+                return this.error('Provide --provider <preset> or --provider-base-url for the upstream provider.', { exit: 2 });
+            }
+            const res = await api.providersAdd({ api_key: key, gateway_mode: mode, base_url: baseUrl, auto_fetch: true });
+            const fetchResult = res.fetch_result ?? {};
+            imported = fetchResult.imported ?? res.imported ?? 0;
+            chosenAlias = res.models?.[0]?.byte_alias;
+            if (fetchResult.status === 'error' || res.fetch_error) {
+                providerStatus = 'saved';
+                providerError = String(fetchResult.last_error || res.fetch_error);
+            }
+            else {
+                providerStatus = 'connected';
+            }
+        }
+        await api.optPatch({ default_mode: flags.preset }).catch(() => undefined);
+        const keyRes = await api.keysCreate({ name: flags['key-name'] || 'cli', preset: flags.preset });
+        (0, credentials_1.setByteKey)(profile, keyRes.key);
+        if (flags.connect) {
+            const argv = [flags.connect, '--write', '--yes', ...(chosenAlias ? ['--model', chosenAlias] : [])];
+            await this.config.runCommand('integrate', argv);
+        }
+        if (!this.jsonEnabled()) {
+            this.log(`Byte key: ${keyRes.key}`);
+            this.log(`Provider models imported: ${imported}`);
+            if (providerStatus === 'saved')
+                this.log(`Provider saved but models not loaded: ${providerError ?? 'unreachable'}. Run \`byte providers test\`.`);
+        }
+        return {
+            byte_key: keyRes.key,
+            provider_models_imported: imported,
+            provider: providerStatus,
+            provider_error: providerError,
+            preset: flags.preset,
+            model: chosenAlias,
+        };
+    }
+}
+exports.default = Setup;

package/dist/commands/usage.js

@@ -16,16 +16,40 @@ class Usage extends base_1.BaseCommand {
             return res;
         const points = res.series ?? res.points ?? (Array.isArray(res) ? res : []);
         if (!points.length) {
-            this.log('No usage recorded yet.');
+            this.log('No usage recorded yet. Send a request through your Byte key, then check back.');
             return res;
         }
-        this.log((0, output_1.renderTable)(['Bucket', 'Requests', 'Tokens', 'Cost', 'Savings'], points.map((p) => [
-            p.bucket ?? p.date ?? p.t ?? '-',
-            p.requests ?? p.total_requests ?? '-',
-            p.tokens ?? p.total_tokens ?? '-',
-            (0, output_1.fmtUsd)(p.cost_usd ?? p.cost_byte_usd),
-            (0, output_1.fmtUsd)(p.savings_usd),
-        ])));
+        const num = (v) => {
+            const n = typeof v === 'number' ? v : Number(v);
+            return Number.isFinite(n) ? n : 0;
+        };
+        const tokensOf = (p) => num(p.tokens_in) + num(p.tokens_out);
+        const rows = points.map((p) => [
+            (0, output_1.fmtBucket)(p.timestamp ?? p.bucket ?? p.date),
+            (0, output_1.fmtNum)(num(p.requests)),
+            (0, output_1.fmtNum)(num(p.cached)),
+            (0, output_1.fmtNum)(tokensOf(p)),
+            (0, output_1.fmtUsd)(num(p.cost_byte_usd ?? p.cost_usd)),
+            (0, output_1.fmtUsd)(num(p.savings_usd)),
+        ]);
+        const totals = {
+            requests: points.reduce((a, p) => a + num(p.requests), 0),
+            cached: points.reduce((a, p) => a + num(p.cached), 0),
+            tokens: points.reduce((a, p) => a + tokensOf(p), 0),
+            cost: points.reduce((a, p) => a + num(p.cost_byte_usd ?? p.cost_usd), 0),
+            savings: points.reduce((a, p) => a + num(p.savings_usd), 0),
+            raw: points.reduce((a, p) => a + num(p.cost_raw_usd), 0),
+        };
+        rows.push(['Total', (0, output_1.fmtNum)(totals.requests), (0, output_1.fmtNum)(totals.cached), (0, output_1.fmtNum)(totals.tokens), (0, output_1.fmtUsd)(totals.cost), (0, output_1.fmtUsd)(totals.savings)]);
+        this.log((0, output_1.renderTable)(['Bucket', 'Requests', 'Cached', 'Tokens', 'Cost', 'Savings'], rows));
+        const plain = Boolean(process.env.NO_COLOR) || process.env.BYTE_PLAIN === '1';
+        const spark = (0, output_1.sparkline)(points.map((p) => num(p.savings_usd)), plain);
+        if (spark)
+            this.log(`\nSavings trend  ${spark}`);
+        const savedPct = totals.raw > 0 ? (0, output_1.pct)(totals.savings / totals.raw) : null;
+        const hitRate = totals.requests > 0 ? (0, output_1.pct)(totals.cached / totals.requests) : null;
+        this.log(`Saved ${(0, output_1.fmtUsd)(totals.savings)}${savedPct ? ` (${savedPct})` : ''} across ${(0, output_1.fmtNum)(totals.requests)} requests` +
+            `${hitRate ? `, cache hit rate ${hitRate}` : ''}.`);
         return res;
     }
 }

package/dist/hooks/init/home.d.ts

@@ -0,0 +1,3 @@
+import { Hook } from '@oclif/core';
+declare const hook: Hook<'init'>;
+export default hook;