@trazum/cli 1.31.0 → 1.33.0

package/dist/index.js

@@ -259,7 +259,7 @@ const COMMAND_FLAGS = {
     ],
     check: ['max-tokens', 'level', 'exact-tokens', 'markdown-out', 'baseline'],
     baseline: ['model', 'calls', 'output-tokens', 'cache-hit-rate', 'batch', 'exact-tokens', 'out', 'o'],
-    profile: ['json', 'pricing', 'pricing-live', 'against', 'what-if', 'markdown-out', 'csv-out', 'csv-shape', 'max-usd', 'max-growth-usd', 'max-cache-loss-usd', 'max-day-usd', 'max-session-usd', 'label', 'since', 'until'],
+    profile: ['json', 'pricing', 'pricing-live', 'against', 'what-if', 'markdown-out', 'csv-out', 'csv-shape', 'max-usd', 'max-growth-usd', 'max-cache-loss-usd', 'max-day-usd', 'max-session-usd', 'label', 'since', 'until', 'dry-run'],
     route: ['prompt-file', 'cases', 'label', 'concurrency', 'json', 'yes', 'pricing', 'pricing-live'],
     eval: ['cases', 'level', 'concurrency', 'export', 'out', 'o', 'model'],
     prune: ['cases', 'concurrency', 'json', 'yes'],
@@ -1626,6 +1626,53 @@ async function commandProfile(args, config, pricing, t) {
     }
     const n = (value) => value.toLocaleString(t.numberLocale);
     const pct = (share) => `${(share * 100).toFixed(1)}%`;
+    /**
+     * `--dry-run`: what this log could and could not answer, and no bill.
+     *
+     * The question somebody has *before* wiring Trazum into CI is not "what did
+     * we spend" but "will this log support the gates I want" — and answering it
+     * with a full report makes them read a bill to find out a field is missing.
+     * This path states readiness per capability and produces no dollar figure
+     * at all, so nothing here can be mistaken for spend. It also refuses to
+     * coexist with the gates: a gate over a report that was never produced
+     * would exit green having judged nothing.
+     */
+    if (boolFlag(args, 'dry-run')) {
+        const gateFlags = ['max-usd', 'max-growth-usd', 'max-cache-loss-usd', 'max-day-usd', 'max-session-usd'];
+        if (gateFlags.some((flag) => typeof args.flags.get(flag) === 'string')) {
+            throw new Error(t.profile.dryRunNoGates());
+        }
+        const cov = report.fieldCoverage;
+        const parsed = cov.parsed;
+        console.log(c.bold(t.profile.dryRunHeading()));
+        console.log(`  ${wrap(t.profile.dryRunParsed(n(parsed), n(report.skippedLines.length)), 74, '  ')}`);
+        if (report.unpricedModels.length > 0) {
+            console.log(`  ${c.yellow('!')} ${wrap(t.profile.dryRunUnpriced(report.unpricedModels.join(', ')), 74, '    ')}`);
+        }
+        console.log();
+        const can = (ok, line) => {
+            console.log(`  ${ok ? c.green('✓') : c.yellow('✗')} ${wrap(line, 74, '    ')}`);
+        };
+        const share = (count) => (parsed > 0 ? pct(count / parsed) : '0%');
+        can(parsed > 0, t.profile.dryRunTotals());
+        can(cov.label > 0, t.profile.dryRunLabels(share(cov.label)));
+        can(cov.ts > 0, t.profile.dryRunClock(share(cov.ts)));
+        can(cov.session > 0, t.profile.dryRunSessions(share(cov.session)));
+        can(cov.stopReason > 0, t.profile.dryRunStopReason(share(cov.stopReason)));
+        // "No cache traffic" is not a missing field: the split can only exist on
+        // records that wrote, and a log that never wrote has nothing to record.
+        if (cov.cacheWrites > 0) {
+            can(cov.cacheTtl > 0, t.profile.dryRunCacheTtl(n(cov.cacheTtl), n(cov.cacheWrites)));
+        }
+        else {
+            console.log(`  ${c.dim('·')} ${wrap(t.profile.dryRunNoCacheTraffic(), 74, '    ')}`);
+        }
+        console.log();
+        console.log(`  ${c.dim(wrap(t.profile.dryRunFooter(), 74, '  '))}`);
+        if (parsed === 0)
+            process.exitCode = 1;
+        return;
+    }
     /**
      * The previous log, loaded before the output paths split so the growth gate
      * exists under `--json` too — a CI step reads the JSON and trusts the exit
@@ -2717,9 +2764,27 @@ async function commandProfile(args, config, pricing, t) {
             const line = t.profile.whatIfTotal(formatUsd(whatIf.currentUsd), formatUsd(whatIf.targetUsd), formatUsd(Math.abs(whatIf.deltaUsd)));
             console.log(`  ${cheaper ? c.green('→') : c.yellow('!')} ${c.bold(wrap(line, 74, '    '))}`);
             console.log(`  ${c.dim(wrap(cheaper ? t.profile.whatIfCheaper() : t.profile.whatIfDearer(), 74, '  '))}`);
+            /**
+             * The other half of the whole decision: the same move with the target's
+             * Batch API on top. Computed against the target's rates, never by
+             * adding two savings, and hedged the only honest way — whether these
+             * calls can wait is not in the log.
+             */
+            if (whatIf.batchOnTarget !== null) {
+                console.log(`  ${c.dim(wrap(t.profile.whatIfBatchOnTarget(formatUsd(whatIf.batchOnTarget.targetUsd), formatUsd(whatIf.targetUsd)), 74, '  '))}`);
+            }
             for (const slice of whatIf.slices.slice(0, 5)) {
                 const label = slice.label === UNLABELLED ? t.profile.unlabelled() : slice.label;
                 console.log(`    ${c.dim('·')} ${c.dim(wrap(t.profile.whatIfSlice(label, slice.model, formatUsd(slice.currentUsd), formatUsd(slice.targetUsd)), 74, '      '))}`);
+                /**
+                 * Cache traffic the target could not grant, said loudly and beside
+                 * the figure it corrects. The standard row prices cache entries the
+                 * target's minimum would refuse to create — an error that flatters
+                 * the move, which is the direction this repository refuses.
+                 */
+                if (slice.cacheBeyondTarget !== null) {
+                    console.log(`    ${c.yellow('!')} ${c.dim(wrap(t.profile.whatIfCacheBeyond(n(slice.maxCallInputTokens), n(slice.cacheBeyondTarget.minTokens), formatUsd(slice.cacheBeyondTarget.noCacheUsd)), 74, '      '))}`);
+                }
             }
         }
         /**