@phantomcodes/cli 1.2.2 → 1.2.4

package/dist/spend/command.mjs

@@ -1,30 +1,19 @@
+import { unknownSub } from "../cli/start.mjs";
 import { readFileSync } from 'node:fs';
 import { die } from "../core/errors.mjs";
-import { flagNum, out } from "../core/helpers.mjs";
+import { flagNum, out, pickIo, showsScreen } from "../core/helpers.mjs";
+import { colorOn, paint } from "../core/style.mjs";
+import { choose } from "../core/pick.mjs";
+import { hideHints, lineupScreen, priceHint, routeScreen, routeTestScreen, TIER_ABOUT } from "../cli/screens.mjs";
 import { getLineup, putLineup, resetLineup, LINEUP_TIERS } from "./lineup.mjs";
 import { getRoute, putRoute, patchRoute, clearRoute, testRoute, parseCondition } from "./routing.mjs";
-/** `--table` output for `route`. */
-export function tableRoute(d) {
-    const p = d.route_policy;
-    if (!p)
-        return 'route           none (model "auto" is refused)';
-    const rules = p.rules ?? [];
-    return [
-        `models          ${p.models.join(', ')}`,
-        `applies_to      ${p.applies_to ?? 'auto'}`,
-        `on_empty        ${p.on_empty ?? 'stop'}`,
-        `fallback        ${p.fallback_on_error ?? false}`,
-        `sticky          ${p.stick_minutes ?? 5} min${(p.stick_by_prompt ?? true) ? '' : ' (x-phantom-session only)'}`,
-        ...(rules.length ? rules.map((r, i) => `rule ${String(i + 1).padEnd(11)}if ${Object.entries(r.if).map(([k, v]) => `${k}=${v}`).join(' ')} use ${r.use}`) : ['rules           none (auto runs the first model)']),
-    ].join('\n');
-}
-/** `--table` output for `route test`. */
-export function tableRouteTest(d) {
-    const t = d;
-    return [`model           ${t.model}`, `reason          ${t.reason}`].join('\n');
-}
 /** `phantom route`: the key's route policy, its rules, and a dry run. Run by `run()`. */
-export async function routeCommand({ argv, io, apiKey, subcommand, flags, table, baseUrl }) {
+export async function routeCommand(input) {
+    const { argv, io, apiKey, subcommand, flags, baseUrl, env } = input;
+    const table = showsScreen(input);
+    const style = { env, color: colorOn(env, io.stdoutIsTTY) };
+    const tableRoute = (d) => routeScreen(d, style);
+    const tableRouteTest = (d) => routeTestScreen(d, style);
     if (!subcommand || subcommand === 'get') {
         out(await getRoute(apiKey, baseUrl), table, tableRoute, io.stdout);
     }
@@ -100,23 +89,10 @@ export async function routeCommand({ argv, io, apiKey, subcommand, flags, table,
         out(await clearRoute(apiKey, baseUrl), table, tableRoute, io.stdout);
     }
     else {
-        die(`Unknown route subcommand: ${subcommand}`);
+        die(unknownSub('route', String(subcommand), ['get', 'set', 'rule', 'test', 'clear']), 'route_usage');
     }
     return 0;
 }
-/** `--table` output for `lineup`. */
-export function tableLineup(d) {
-    const { lineup, tiers, choices } = d;
-    return LINEUP_TIERS.flatMap((tier) => {
-        const pick = lineup?.[tier];
-        const fallback = lineup?.fallbacks?.[tier];
-        return [
-            `${tier.padEnd(15)} ${tiers[tier].model}  ${pick ? '(your pick)' : '(default)'}`,
-            ...(fallback ? [`${''.padEnd(15)} falls back to ${fallback}`] : []),
-            ...(choices ? choices[tier].map((c) => `${''.padEnd(15)} - ${c.model}${c.default ? ' (default)' : ''}`) : []),
-        ];
-    }).join('\n');
-}
 /**
  * Changes one tier's entry in `into` from a flag value: a model id sets it,
  * and `default` clears it so the tier runs its default again.
@@ -132,7 +108,16 @@ function applyPick(into, tier, flag, value) {
         into[tier] = value;
 }
 /** `phantom lineup`: the model phantom-1 runs in each tier, and a fallback for each. Run by `run()`. */
-export async function lineupCommand({ io, apiKey, subcommand, flags, table, baseUrl }) {
+export async function lineupCommand(input) {
+    const { io, apiKey, subcommand, flags, baseUrl, env } = input;
+    const table = showsScreen(input);
+    const style = { env, color: colorOn(env, io.stdoutIsTTY) };
+    const tableLineup = (d) => lineupScreen(d, style);
+    // lineup set with no flags, at a terminal: pick a tier, then its model, from lists with prices.
+    // lineup alone, or set with no flags, at a terminal: the table, then a picker to change it, instead of a command to type.
+    const pick = (!subcommand || subcommand === 'set') && !LINEUP_FLAGS.some((name) => flags[name] !== undefined) ? pickIo(input) : null;
+    if (pick)
+        return lineupPicker(input, pick, tableLineup);
     if (!subcommand || subcommand === 'get') {
         out(await getLineup(apiKey, baseUrl), table, tableLineup, io.stdout);
     }
@@ -166,7 +151,59 @@ export async function lineupCommand({ io, apiKey, subcommand, flags, table, base
         out(await resetLineup(apiKey, baseUrl), table, tableLineup, io.stdout);
     }
     else {
-        die(`Unknown lineup subcommand: ${subcommand}`);
+        die(unknownSub('lineup', String(subcommand), ['get', 'set', 'reset']), 'lineup_usage');
     }
     return 0;
 }
+/** The flags `lineup set` reads; with none of them, at a terminal, it opens the picker instead. */
+const LINEUP_FLAGS = ['economy', 'standard', 'frontier', 'economy-fallback', 'standard-fallback', 'frontier-fallback'];
+/**
+ * `phantom lineup set` at a terminal: choose a tier, then a model for it from
+ * a list with prices (the default marked), and it saves at once. It loops
+ * back to the tiers so you can change another; Esc there is done.
+ */
+async function lineupPicker(input, pick, show) {
+    const { io, apiKey, baseUrl } = input;
+    let read = await getLineup(apiKey, baseUrl);
+    // The table's "→ phantom lineup set" line would point at the picker that's already open.
+    const hintsWere = hideHints(true);
+    // The marker stays on the tier you last changed, so changing it again (or the next one) is one move.
+    let last = 0;
+    try {
+        for (;;) {
+            io.stdout(show(read) + '\n\n');
+            const tier = await choose({ ...pick, esc: 'back' }, 'Which tier do you want to change?', [
+                ...LINEUP_TIERS.map((t) => ({ label: t[0].toUpperCase() + t.slice(1), hint: `${TIER_ABOUT[t]} · now ${read.tiers[t].model}`, value: t })),
+                { label: 'Put every tier back to its default', value: 'reset' },
+            ], last);
+            if (tier === null)
+                return 0;
+            if (tier === 'reset') {
+                read = { ...(await resetLineup(apiKey, baseUrl)), choices: read.choices };
+                continue;
+            }
+            const options = read.choices?.[tier] ?? [];
+            const now = read.tiers[tier].model;
+            const model = await choose({ ...pick, esc: 'back' }, `Which model should ${tier} run?`, options.map((c) => ({ label: c.model, hint: priceHint(c), value: c.model })), Math.max(0, options.findIndex((c) => c.model === now)));
+            if (model === null)
+                continue;
+            const { fallbacks, ...picks } = read.lineup ?? {};
+            const chosen = options.find((c) => c.model === model);
+            if (chosen?.default)
+                delete picks[tier];
+            else
+                picks[tier] = model;
+            // A fallback can't be the tier's own model, which the server refuses.
+            const keep = { ...fallbacks };
+            if (keep[tier] === model)
+                delete keep[tier];
+            read = { ...(await putLineup(apiKey, Object.keys(keep).length ? { ...picks, fallbacks: keep } : picks, baseUrl)), choices: read.choices };
+            last = LINEUP_TIERS.indexOf(tier);
+            // Said on its own line, so the change is plain before the table redraws.
+            io.stdout(`\n  ${paint(input.env, colorOn(input.env, io.stdoutIsTTY)).lime('✓')} ${tier[0].toUpperCase() + tier.slice(1)} now runs ${model}.\n`);
+        }
+    }
+    finally {
+        hideHints(hintsWere);
+    }
+}

package/dist/spend/report.mjs

@@ -1,5 +1,8 @@
 import { die } from "../core/errors.mjs";
-import { out } from "../core/helpers.mjs";
+import { out, showsScreen } from "../core/helpers.mjs";
+import { colorOn } from "../core/style.mjs";
+import { barsGrowing, motionOn, play } from "../core/motion.mjs";
+import { spendScreen } from "../cli/screens.mjs";
 import { request } from "../core/request.mjs";
 import { workspaceGet } from "../workspace/command.mjs";
 /** The dates `--from` and `--to` ask for, as a query string. The server checks them. */
@@ -51,11 +54,17 @@ export function tableSpend(d) {
  * workspace connection `phantom login` saved. Run by `run()`.
  */
 export async function spendCommand(input) {
-    const { io, apiKey, table, baseUrl, flags } = input;
+    const { io, apiKey, baseUrl, flags, env } = input;
     const dates = { from: flags['from'], to: flags['to'] };
     const result = flags['workspace']
         ? (await workspaceGet(input, `/spend${query(dates)}`))
         : await getSpend(apiKey, dates, baseUrl);
-    out(result, table, tableSpend, io.stdout);
+    const screen = showsScreen(input);
+    // The bars grow in, the way the site's cost bars do; JSON, pipes and NO_COLOR get the result at once.
+    if (screen && motionOn(env, io.stdoutIsTTY)) {
+        await play(io.stdout, barsGrowing(spendScreen(result, { env, color: true }).split('\n')), { rows: process.stdout.rows, skipOnKey: true });
+        return 0;
+    }
+    out(result, screen, (d) => spendScreen(d, { env, color: colorOn(env, io.stdoutIsTTY) }), io.stdout);
     return 0;
 }