@krtclcdy/tersio 2.22.1 → 2.24.0

package/cli/update.js

@@ -2,11 +2,11 @@
 import { promises as fs } from 'node:fs';
 import path from 'node:path';
 import { spawn } from 'node:child_process';
-import { BUN_BIN_DIR, IS_WINDOWS, OMP_AGENT_DIR, OMP_PLUGINS_DIR, PACKAGE_BIN, PACKAGE_NAME, PACKAGE_VERSION, RTK_BINARY_NAME, dryRun, execP, parseJsonObject, verbose, } from './common.js';
+import { IS_WINDOWS, OMP_PLUGINS_DIR, PACKAGE_BIN, PACKAGE_NAME, PACKAGE_VERSION, dryRun, execP, parseJsonObject, verbose, } from './common.js';
 import { execNetwork } from './interactive.js';
-import { readTextIfExists, tersioDataPath } from '../extensions/lib/utils.js';
+import { readTextIfExists, resolveRtkBinary, tersioDataPath } from '../extensions/lib/utils.js';
 import { refreshPrices } from '../extensions/shared/pricing.js';
-import { CAVEMAN_REMOTE_RULE, RTK_RELEASE_API, fetchJson, httpsGet, normalizeRtkVersion, sha256Hex, } from '../extensions/lib/utils.js';
+import { CAVEMAN_REMOTE_RULE, RTK_RELEASE_API, httpsGet, normalizeRtkVersion, sha256Hex, } from '../extensions/lib/utils.js';
 const UPDATE_CHECK_TTL_MS = 6 * 60 * 60 * 1000;
 function newerThan(a, b) {
     const pa = a.replace(/^v/, '').split('.').map((n) => parseInt(n, 10) || 0);
@@ -34,10 +34,8 @@ async function latestPublishedVersion() {
         return null;
     }
 }
-// Returns a newer published version, null when up to date, or 'unknown' when
-// the registry cannot be reached. Reads the registry at most once per TTL
-// (cached under OMP_PLUGINS_DIR) unless force skips the cache — an explicit
-// "check for updates" must never trust a stale cache.
+// A newer published version, null when up to date, 'unknown' when the registry
+// is unreachable. Cached for a TTL unless force, which must not trust a cache.
 async function checkForUpdate(force = false) {
     const cachePath = tersioDataPath('update-check.json', 'tersio-update-check.json');
     const cached = parseJsonObject(await readTextIfExists(cachePath));
@@ -50,12 +48,11 @@ async function checkForUpdate(force = false) {
         await fs.writeFile(cachePath, JSON.stringify({ latest, lastCheck: Date.now() }) + '\n', 'utf8').catch(() => { });
         return newerThan(latest, PACKAGE_VERSION) ? latest : null;
     }
-    // Registry unreachable: a stale cache naming a newer release is still
-    // actionable; otherwise report unknown so callers never claim "latest".
+    // Unreachable registry: a stale cache naming a newer release is still
+    // actionable, else report unknown so nobody claims "latest".
     return cached?.latest && newerThan(cached.latest, PACKAGE_VERSION) ? cached.latest : 'unknown';
 }
-// Race a probe against a timeout; slow or failing probes resolve null so the
-// update plan stays best-effort and never blocks the update itself.
+// Race a probe against a timeout; failures resolve null so nothing blocks.
 async function settle(work, ms) {
     let timer;
     try {
@@ -68,9 +65,7 @@ async function settle(work, ms) {
         clearTimeout(timer);
     }
 }
-// Run a child with inherited stdio for live output. Used when the child
-// renders its own interactive UI (the delegated installer runs Clack
-// spinners), which a concurrent outer spinner would corrupt into stray bars.
+// Inherited stdio, so a child spinner cannot corrupt this parent's.
 async function execInherit(cmd, args) {
     const code = await new Promise((resolve, reject) => {
         const child = spawn(cmd, args, { stdio: 'inherit' });
@@ -80,29 +75,30 @@ async function execInherit(cmd, args) {
     if (code !== 0)
         throw new Error(`${cmd} exited with code ${code}`);
 }
-// Current → latest per add-on. Every probe is capped and nullable; the plan
-// prints `unknown` for anything unreachable and the update proceeds anyway.
+// Current → latest per add-on. Every probe is capped and nullable, and the
+// plan prints `unknown` for anything unreachable.
 async function probeUpdatePlan(cliLatest) {
-    const rtkBin = path.join(BUN_BIN_DIR, RTK_BINARY_NAME);
+    const rtkBin = resolveRtkBinary();
     const ponytailPkg = path.join(OMP_PLUGINS_DIR, 'node_modules', '@dietrichgebert', 'ponytail', 'package.json');
-    const ruleDest = path.join(OMP_AGENT_DIR, 'extensions', 'caveman-session', 'rule.md');
+    const tersioRule = path.join(OMP_PLUGINS_DIR, 'node_modules', '@krtclcdy', 'tersio', 'extensions', 'caveman-session', 'rule.md');
+    const controller = new AbortController();
     const [rtkLocal, rtkRelease, ruleLocalText, ruleRemoteText, ponytailLocalText] = await Promise.all([
-        settle(execP(rtkBin, ['--version'], { timeout: 5000 }).then((r) => normalizeRtkVersion(r.stdout.trim() || r.stderr.trim()) || null), 6000),
-        settle(fetchJson(RTK_RELEASE_API).then((r) => normalizeRtkVersion(r.tag_name) || null), 4000),
-        readTextIfExists(ruleDest),
-        settle(httpsGet(CAVEMAN_REMOTE_RULE), 4000),
+        settle(rtkBin ? execP(rtkBin, ['--version'], { timeout: 5000 }).then((r) => normalizeRtkVersion(r.stdout.trim() || r.stderr.trim()) || null) : Promise.resolve(null), 6000),
+        settle(httpsGet(RTK_RELEASE_API, { signal: controller.signal }).then((text) => normalizeRtkVersion(JSON.parse(text).tag_name) || null), 1500),
+        readTextIfExists(tersioRule),
+        settle(httpsGet(CAVEMAN_REMOTE_RULE, { signal: controller.signal }).then((text) => sha256Hex(text).slice(0, 8)), 1500),
         readTextIfExists(ponytailPkg),
     ]);
-    const shortHash = (text) => text === null ? null : sha256Hex(text).slice(0, 8);
+    controller.abort();
     return {
         cli: cliLatest,
         rtk: [rtkLocal, rtkRelease],
-        rule: [shortHash(ruleLocalText), shortHash(ruleRemoteText)],
+        rule: [ruleLocalText ? sha256Hex(ruleLocalText).slice(0, 8) : null, ruleRemoteText],
         ponytail: ponytailLocalText ? parseJsonObject(ponytailLocalText)?.version ?? null : null,
     };
 }
-// Every add-on prints its status: version jump when stale, "up to date"
-// otherwise, honest "unknown" when the probe cannot reach its source.
+// Every add-on prints a version jump when stale, "up to date" otherwise, and
+// "unknown" when its source cannot be reached.
 function planLines(plan) {
     const stale = [];
     const status = [];
@@ -136,12 +132,10 @@ async function runLatestUpdate() {
     if (verbose)
         forwardedArgs.push('--verbose');
     const npmCommand = IS_WINDOWS ? process.env.ComSpec || 'cmd.exe' : 'npm';
-    // Resolve the target explicitly: `npm view --prefer-online` beats the local
-    // metadata cache, so a stale `@latest` can never pin an older release.
+    // `--prefer-online` beats the local cache, so a stale @latest cannot pin down.
     const cliLatest = await latestPublishedVersion();
     const target = cliLatest && /^\d+\.\d+\.\d+$/.test(cliLatest) ? `@${cliLatest}` : '@latest';
-    // Current → latest per add-on. Best-effort; unreachable probes print as
-    // unknown and never block the update.
+    // Best-effort: unreachable probes print as unknown.
     const plan = await probeUpdatePlan(cliLatest);
     const { stale, status } = planLines(plan);
     if (dryRun) {

package/cli/usage.js

@@ -1,4 +1,6 @@
-import { co2GramsFor, displayModelId, energyWhFor, importSessionTokens, ledgerPath, priceFor, readResetWatermark, readUsage, refreshPricesIfStale, sessionsDir, usdCost, } from '../extensions/shared/usage-ledger.js';
+// cli/usage.ts — ledger + session-token usage report, tokscale-style.
+import { co2GramsFor, displayModelId, energyWhFor, importSessionTokens, ledgerPath, priceFor, readResetWatermark, readRtkAdoption, readRtkRecallDiagnostics, readUsage, refreshPricesIfStale, sessionsDir, usdCost, } from '../extensions/shared/usage-ledger.js';
+import { resolveRtkBinary } from '../extensions/lib/utils.js';
 import { readRtkGain } from '../extensions/shared/rtk-gain.js';
 import { readUsageDb, syncUsageDb, usageDbPath } from '../extensions/shared/usage-store.js';
 import { withInteractiveSpinner } from './interactive.js';
@@ -74,6 +76,8 @@ export function summarizeUsage(rows) {
             est: usdCost({ input: r.i, output: r.o, cacheRead: r.cr ?? 0, cacheWrite: r.cw ?? 0 }, r.m).usd,
         })),
         rtkGain: readRtkGain(RTK_COMMAND_ROWS, watermark || undefined),
+        rtkAdoption: readRtkAdoption(),
+        rtkRecall: readRtkRecallDiagnostics(resolveRtkBinary()),
         usd,
         priced,
         savedUsd,
@@ -134,6 +138,7 @@ function printReport(report) {
     const t = report.tokens;
     console.log(`  TOKENS  ${fmt(t.input)} in · ${fmt(t.output)} out · ${fmt(t.cacheRead)} cache read · ${fmt(t.cacheWrite)} cache write`);
     console.log(`  COST    ${formatCurrency(report.usd, report.currency)}${report.priced ? '' : ' (includes default pricing)'} · ~${formatCurrency(report.savedUsd, report.currency)} cache-saved (est.) · ~${report.co2g.toFixed(1)}g CO2 (est.)`);
+    console.log(`  RTK      ${fmt(report.rtkAdoption.rtkCalls)}/${fmt(report.rtkAdoption.eligibleCalls)} eligible OMP Bash calls use RTK (${report.rtkAdoption.adoptionPct.toFixed(1)}%) · ${fmt(report.rtkAdoption.missedCalls)} missed · recall ${report.rtkRecall.available ? `${report.rtkRecall.mode} (${report.rtkRecall.entries})` : 'unavailable'}`);
     const models = Object.entries(report.byModel).filter(([, b]) => b.input + b.output + b.cacheRead + b.cacheWrite > 0).sort((a, b) => (b[1].input + b[1].output) - (a[1].input + a[1].output)).slice(0, 8);
     if (models.length) {
         console.log('  BY MODEL');