@krtclcdy/tersio 2.19.0 → 2.20.0

package/extensions/shared/usage-store.ts

@@ -0,0 +1,325 @@
+// extensions/shared/usage-store.ts — tersio-owned usage.db.
+// Persists the same per-message rows importSessionTokens derives live (model,
+// tokens, cache, cost input, timing, status, tools), so top models, costing,
+// cache, CO2 inputs, and activity survive session-file rotation. Sync is
+// incremental: a files ledger (mtime+size) skips unchanged transcripts, and
+// every read applies the current reset watermark — the store is a cache,
+// never a fork. Missing sqlite3 CLI → sync false / read null, callers fall
+// back to the live path. Never touches RTK's history.db or host transcripts.
+import { execFileSync } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import {
+  RECENT_LIMIT,
+  canonicalModelId,
+  classifySessionLine,
+  codexSessionsDir,
+  costOf,
+  durOf,
+  ingestSessionRow,
+  newSessionAccum,
+  sessionsDir,
+  walkJsonl,
+} from './usage-ledger.ts';
+import type { RunStatus, SessionTokens } from './usage-ledger.ts';
+
+export function usageDbPath(): string {
+  const override = process.env.TERSIO_USAGE_DB;
+  if (override) return override;
+  return path.join(os.homedir(), '.omp', 'plugins', 'tersio-usage.db');
+}
+
+export interface StoredUsage {
+  tokens: SessionTokens;
+  syncedAt: number;
+}
+
+function esc(v: string): string {
+  return `'${v.replace(/'/g, "''")}'`;
+}
+
+function intOf(v: unknown): number {
+  return typeof v === 'number' && Number.isFinite(v) && v > 0 ? Math.floor(v) : 0;
+}
+
+function nullNum(v: number | undefined): string {
+  return v === undefined ? 'NULL' : String(v);
+}
+
+function nullStr(v: string | undefined): string {
+  return v === undefined ? 'NULL' : esc(v);
+}
+
+function run(db: string, sql: string): void {
+  execFileSync('sqlite3', [db, sql], { stdio: ['ignore', 'ignore', 'ignore'], timeout: 30000 });
+}
+
+function query(db: string, sql: string): string[][] {
+  const out = execFileSync('sqlite3', ['-separator', '\t', db, sql], {
+    encoding: 'utf8',
+    timeout: 30000,
+    stdio: ['ignore', 'pipe', 'ignore'],
+  });
+  return out
+    .split('\n')
+    .filter((line) => line.trim())
+    .map((line) => line.split('\t'));
+}
+
+function ensureSchema(db: string): void {
+  fs.mkdirSync(path.dirname(db), { recursive: true });
+  run(
+    db,
+    `CREATE TABLE IF NOT EXISTS meta (k TEXT PRIMARY KEY, v TEXT NOT NULL);` +
+      `CREATE TABLE IF NOT EXISTS files (path TEXT PRIMARY KEY, mtime REAL NOT NULL, size INTEGER NOT NULL);` +
+      `CREATE TABLE IF NOT EXISTS messages (file TEXT NOT NULL, t REAL, model TEXT NOT NULL,` +
+      ` i INTEGER NOT NULL, o INTEGER NOT NULL, d REAL, cr INTEGER NOT NULL, cw INTEGER NOT NULL,` +
+      ` usd REAL, st TEXT NOT NULL, code REAL, note TEXT, tools TEXT NOT NULL DEFAULT '[]');` +
+      `CREATE INDEX IF NOT EXISTS idx_messages_file ON messages(file);`,
+  );
+}
+
+function readFiles(db: string): Record<string, { mtime: number; size: number }> {
+  const known: Record<string, { mtime: number; size: number }> = {};
+  try {
+    for (const [p, mtime, size] of query(db, `SELECT path, mtime, size FROM files;`)) {
+      known[p] = { mtime: Number(mtime) || 0, size: Number(size) || 0 };
+    }
+  } catch { /* fresh db */ }
+  return known;
+}
+
+// One parsed assistant message, as stored. `t` is epoch ms or null when the
+// source row carries no usable timestamp (live counts it, skips its recent).
+interface StoredRow {
+  t: number | null;
+  model: string;
+  i: number;
+  o: number;
+  d: number | undefined;
+  cr: number;
+  cw: number;
+  usd: number | undefined;
+  st: RunStatus;
+  code: number | undefined;
+  note: string | undefined;
+  tools: string[];
+}
+
+function parseFile(text: string): StoredRow[] {
+  const rows: StoredRow[] = [];
+  let codexProvider: string | null = null;
+  for (const line of text.split('\n')) {
+    if (!line.trim()) continue;
+    try {
+      const row = JSON.parse(line) as Parameters<typeof classifySessionLine>[0];
+      const parsed = classifySessionLine(row);
+      if (parsed.kind === 'codex_provider') {
+        if (parsed.provider) codexProvider = parsed.provider;
+        continue;
+      }
+      const ts = row.timestamp;
+      const ms = ts === undefined ? NaN : typeof ts === 'number' ? ts : Date.parse(ts);
+      const t = Number.isFinite(ms) ? ms : null;
+      if (parsed.kind === 'token_row') {
+        const provider = parsed.provider ?? codexProvider;
+        const usage = parsed.usage ?? {};
+        rows.push({
+          t,
+          model: canonicalModelId(provider ? `codex/${provider}` : 'codex'),
+          i: intOf(usage.input),
+          o: intOf(usage.output),
+          d: undefined,
+          cr: intOf(usage.cacheRead),
+          cw: intOf(usage.cacheWrite),
+          usd: costOf(usage),
+          st: 'completed',
+          code: undefined,
+          note: undefined,
+          tools: [],
+        });
+        continue;
+      }
+      if (parsed.kind !== 'assistant_row' || !parsed.model || !parsed.usage) continue;
+      const usage = parsed.usage;
+      const dur = durOf(parsed.durMs);
+      const run = parsed.run ?? { st: 'completed' as RunStatus };
+      const note = run.note?.replace(/[\t\n\r]/g, ' ').slice(0, 180);
+      rows.push({
+        t,
+        model: canonicalModelId(parsed.model),
+        i: intOf(usage.input),
+        o: intOf(usage.output),
+        d: dur,
+        cr: intOf(usage.cacheRead),
+        cw: intOf(usage.cacheWrite),
+        usd: costOf(usage),
+        st: run.st,
+        code: run.code,
+        note,
+        tools: parsed.tools ?? [],
+      });
+    } catch { /* skip corrupt lines */ }
+  }
+  return rows;
+}
+
+function insertSql(file: string, r: StoredRow): string {
+  return `INSERT INTO messages (file, t, model, i, o, d, cr, cw, usd, st, code, note, tools) VALUES (` +
+    `${esc(file)},${r.t === null ? 'NULL' : String(r.t)},${esc(r.model)},${r.i},${r.o},` +
+    `${nullNum(r.d)},${r.cr},${r.cw},${nullNum(r.usd)},${esc(r.st)},` +
+    `${nullNum(r.code)},${nullStr(r.note)},${esc(JSON.stringify(r.tools))});`;
+}
+
+// Incremental sync: unchanged transcripts are skipped via mtime+size, changed
+// ones are deleted and re-inserted, removed ones are dropped. True on success
+// (including nothing-to-do), false when sqlite3 or disk is unavailable.
+export function syncUsageDb(): boolean {
+  let db: string;
+  try {
+    db = usageDbPath();
+    ensureSchema(db);
+  } catch {
+    return false;
+  }
+  const files: string[] = [];
+  try {
+    walkJsonl(sessionsDir(), files, 2000);
+    if (process.env.TERSIO_SESSIONS_DIR === undefined || process.env.TERSIO_CODEX_DIR !== undefined) {
+      walkJsonl(codexSessionsDir(), files, 2000);
+    }
+  } catch {
+    return false;
+  }
+  const known = readFiles(db);
+  const current: Record<string, { mtime: number; size: number }> = {};
+  const changed: string[] = [];
+  for (const file of files) {
+    let st: fs.Stats;
+    try {
+      st = fs.statSync(file);
+    } catch {
+      continue;
+    }
+    const entry = { mtime: st.mtimeMs, size: st.size };
+    current[file] = entry;
+    const prev = known[file];
+    if (!prev || prev.mtime !== entry.mtime || prev.size !== entry.size) changed.push(file);
+  }
+  const removed = Object.keys(known).filter((p) => current[p] === undefined);
+  if (!changed.length && !removed.length) return true;
+  const chunks: string[] = [];
+  let chunkBytes = 0;
+  const flush = (): boolean => {
+    if (!chunks.length) return true;
+    try {
+      run(db, `BEGIN;${chunks.join('')}COMMIT;`);
+    } catch {
+      return false;
+    }
+    chunks.length = 0;
+    chunkBytes = 0;
+    return true;
+  };
+  const push = (sql: string): boolean => {
+    chunks.push(sql);
+    chunkBytes += sql.length;
+    if (chunkBytes < 400_000) return true;
+    return flush();
+  };
+  for (const file of [...changed, ...removed]) {
+    if (!push(`DELETE FROM messages WHERE file=${esc(file)};DELETE FROM files WHERE path=${esc(file)};`)) return false;
+  }
+  try {
+    for (const file of changed) {
+      const entry = current[file];
+      const text = fs.readFileSync(file, 'utf8');
+      for (const r of parseFile(text)) {
+        if (!push(insertSql(file, r))) return false;
+      }
+      if (!push(`INSERT OR REPLACE INTO files (path, mtime, size) VALUES (${esc(file)},${entry.mtime},${entry.size});`)) return false;
+    }
+  } catch {
+    return false;
+  }
+  if (!push(`INSERT OR REPLACE INTO meta (k, v) VALUES ('last_sync',${esc(String(Date.now()))});`)) return false;
+  return flush();
+}
+
+export function readUsageDb(): StoredUsage | null {
+  const db = usageDbPath();
+  try {
+    if (!fs.existsSync(db)) return null;
+  } catch {
+    return null;
+  }
+  let rows: string[][];
+  try {
+    rows = query(db, `SELECT t, model, i, o, d, cr, cw, usd, st, code, note, tools FROM messages;`);
+  } catch {
+    return null;
+  }
+  const accum = newSessionAccum();
+  for (const [t, model, i, o, d, cr, cw, usd, st, code, note, tools] of rows) {
+    const ts = t === '' ? undefined : Number(t);
+    let toolNames: string[] = [];
+    try {
+      const parsed: unknown = JSON.parse(tools || '[]');
+      if (Array.isArray(parsed)) toolNames = parsed.filter((x): x is string => typeof x === 'string');
+    } catch { /* keep empty */ }
+    const usage: Record<string, unknown> = {
+      input: Number(i) || 0,
+      output: Number(o) || 0,
+      cacheRead: Number(cr) || 0,
+      cacheWrite: Number(cw) || 0,
+    };
+    if (usd !== '') {
+      const measured = Number(usd);
+      if (Number.isFinite(measured)) usage.cost = measured;
+    }
+    ingestSessionRow(
+      accum,
+      model || 'unknown',
+      usage,
+      Number.isFinite(ts) ? (ts as number) : undefined,
+      d === '' ? undefined : Number(d),
+      {
+        st: st === 'error' || st === 'aborted' ? st : 'completed',
+        code: code === '' ? undefined : Number(code),
+        note: note === '' ? undefined : note,
+      },
+      toolNames,
+    );
+  }
+  accum.recent.sort((a, b) => b.t - a.t);
+  let syncedAt = 0;
+  try {
+    const meta = query(db, `SELECT v FROM meta WHERE k='last_sync';`);
+    if (meta.length) syncedAt = Number(meta[0][0]) || 0;
+  } catch { /* keep 0 */ }
+  return {
+    tokens: {
+      messages: accum.messages,
+      totals: accum.totals,
+      byModel: accum.byModel,
+      byDay: accum.byDay,
+      byDayModel: accum.byDayModel,
+      byTool: accum.byTool,
+      byModelMessages: accum.byModelMessages,
+      costMeasured: accum.costMeasured,
+      recent: accum.recent.slice(0, RECENT_LIMIT),
+    },
+    syncedAt,
+  };
+}
+
+// Delete the store file. Returns 1 when removed, 0 when already absent.
+export function clearUsageDb(): number {
+  try {
+    fs.unlinkSync(usageDbPath());
+    return 1;
+  } catch {
+    return 0;
+  }
+}

package/extensions/tersio-commands/index.ts

@@ -0,0 +1,110 @@
+// /tersio root command — status, check, update, gain, usage, help.
+// Mode switches live on their own commands (/caveman, /rtk, /combo, and the
+// upstream /ponytail): the router keeps no redundant copies. Shared-state
+// publishes sync sibling mirrors live, so switches notify and take effect
+// next turn — no reload.
+import {
+  getSharedComboState,
+  reconcileSharedComboEntries,
+  sessionEntries,
+} from '../shared/session-state.ts';
+import os from 'node:os';
+import path from 'node:path';
+import { appendUsage, readUsage } from '../shared/usage-ledger.ts';
+import { checkAddonsSummary, runAddonUpdate } from '../ai-addons-updater/index.ts';
+import type { ExtensionApi, ExtensionCtx } from '../shared/types.ts';
+
+const HELP = [
+  '/tersio status — active modes + combo level',
+  '/tersio check — add-on version check',
+  '/tersio update <ponytail|rtk|caveman|all> [--dry-run]',
+  '/tersio gain — savings summary + dashboard hint',
+  '/tersio usage — ledger report for this machine',
+  '/tersio help — this table',
+  'mode switches: /caveman /rtk /combo (tersio) + /ponytail (upstream)',
+].join('\n');
+
+function statusLine(): string {
+  const s = getSharedComboState();
+  const level = s.level === 'custom' ? 'INACTIVE' : s.level.toUpperCase();
+  return `tersio — caveman=${s.caveman.toUpperCase()} · rtk=${s.rtk.toUpperCase()} · ponytail=${s.ponytail.toUpperCase()} (combo ${level})`;
+}
+
+function usageSummary(): string {
+  const rows = readUsage();
+  if (rows.length === 0) return 'tersio usage: no ledger yet — run commands first.';
+  const byKind: Record<string, number> = {};
+  for (const r of rows) byKind[r.kind] = (byKind[r.kind] ?? 0) + 1;
+  const parts = Object.entries(byKind).map(([k, n]) => `${k}×${n}`);
+  const last = new Date(rows[rows.length - 1].ts).toISOString();
+  return `tersio usage: ${rows.length} rows (${parts.join(', ')}), last write ${last}.`;
+}
+
+// Gain opens instantaneously in the default browser: export a file://-ready
+// snapshot (data inlined, no server to babysit) and open it. Falls back to
+// the shell command when export or open fails.
+async function openGainDashboard(pi: ExtensionApi, ctx?: ExtensionCtx): Promise<void> {
+  const file = path.join(os.tmpdir(), `tersio-gain-${Date.now()}.html`);
+  try {
+    const exported = await pi.exec?.('tersio', ['gain', '--export', file], { cwd: ctx?.cwd });
+    if (!exported || exported.code !== 0) throw new Error((exported?.stderr || 'export failed').trim());
+    const openCmd = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'start' : 'xdg-open';
+    await pi.exec?.(openCmd, [file], { cwd: ctx?.cwd });
+    ctx?.ui?.notify?.(`tersio gain: dashboard opened in your browser.`, 'info');
+  } catch (e) {
+    ctx?.ui?.notify?.(`tersio gain: could not open dashboard (${(e as Error).message}). Run 'tersio gain --open' in a shell.`, 'warning');
+  }
+}
+
+export default function tersioCommandsExtension(pi: ExtensionApi): void {
+  pi.setLabel?.('Tersio unified root command');
+
+
+  pi.registerCommand?.('tersio', {
+    description: 'Tersio root: status|check|update|gain|usage|help (modes: /caveman /rtk /combo /ponytail)',
+    handler: async (args, ctx) => {
+      const parts = String(args || '').trim().toLowerCase().split(/\s+/).filter(Boolean);
+      const [sub] = [parts[0]];
+      appendUsage('command', `/tersio ${parts.join(' ')}`.trim());
+
+      if (!sub || sub === 'status') {
+        if (ctx?.hasUI) reconcileSharedComboEntries(sessionEntries(ctx));
+        ctx?.ui?.notify?.(statusLine(), 'info');
+        return;
+      }
+      if (sub === 'help') {
+        ctx?.ui?.notify?.(HELP, 'info');
+        return;
+      }
+      if (sub === 'check') {
+        await checkAddonsSummary(ctx);
+        return;
+      }
+      if (sub === 'update') {
+        const dryRun = parts.includes('--dry-run');
+        const target = parts.filter((p) => p !== '--dry-run' && p !== 'update' && p !== 'tersio').join(' ');
+        if (!target) {
+          ctx?.ui?.notify?.('Usage: /tersio update <ponytail|rtk|caveman|all> [--dry-run]', 'warning');
+          return;
+        }
+        await runAddonUpdate(pi, ctx, target, dryRun);
+        return;
+      }
+      if (sub === 'gain') {
+        await openGainDashboard(pi, ctx);
+        return;
+      }
+      if (sub === 'usage') {
+        ctx?.ui?.notify?.(usageSummary(), 'info');
+        return;
+      }
+      // Removed mode switches redirect to their own commands so only one
+      // spelling exists to learn: /caveman, /rtk, /combo, /ponytail.
+      if (sub === 'caveman' || sub === 'rtk' || sub === 'combo' || sub === 'ponytail') {
+        ctx?.ui?.notify?.(`Use /${sub} instead — /tersio no longer duplicates mode switches.\n${HELP}`, 'warning');
+        return;
+      }
+      ctx?.ui?.notify?.(`Unknown subcommand: ${sub}.\n${HELP}`, 'warning');
+    },
+  });
+}

package/package.json

@@ -1,10 +1,9 @@
 {
   "name": "@krtclcdy/tersio",
-  "version": "2.19.0",
+  "version": "2.20.0",
   "description": "✂️ Token-saving OMP add-ons: terse Caveman replies, compact RTK shell output, lean Ponytail code calls — one-command combo presets.",
   "keywords": [
     "omp",
-    "tersio",
     "token-saving",
     "ai-tools",
     "developer-tools",
@@ -19,10 +18,6 @@
     "type": "git",
     "url": "git+https://github.com/KurutoDenzeru/tersio.git"
   },
-  "homepage": "https://github.com/KurutoDenzeru/tersio",
-  "bugs": {
-    "url": "https://github.com/KurutoDenzeru/tersio/issues"
-  },
   "type": "module",
   "bin": {
     "tersio": "tersio.js"
@@ -36,43 +31,43 @@
         "description": "Caveman terse-reply session mode (/caveman)",
         "default": true,
         "extensions": [
-          "./extensions/caveman-session/index.js"
+          "./extensions/caveman-session/index.ts"
         ]
       },
       "rtk": {
         "description": "RTK compact shell-output session mode (/rtk)",
         "default": true,
         "extensions": [
-          "./extensions/rtk-session/index.js"
+          "./extensions/rtk-session/index.ts"
         ]
       },
       "ponytail": {
-        "description": "Combo toggle bar and Ponytail mode reinforcement (/combo, mode reinforcement)",
+        "description": "Combo presets + Ponytail mode reinforcement (/combo)",
         "default": true,
         "extensions": [
-          "./extensions/combo-toggle/index.js",
-          "./extensions/shared/mode-reinforcement.js"
+          "./extensions/combo-toggle/index.ts",
+          "./extensions/shared/mode-reinforcement.ts"
         ]
       },
       "updater": {
-        "description": "In-session /ai-addons updater for Ponytail, RTK, and Caveman",
+        "description": "In-session updater for Ponytail, RTK, and Caveman (/ai-addons)",
         "default": true,
         "extensions": [
-          "./extensions/ai-addons-updater/index.js"
+          "./extensions/ai-addons-updater/index.ts"
         ]
       },
       "tersio": {
-        "description": "Unified /tersio root command (caveman, combo, rtk, ponytail, status, check, update, gain, usage)",
+        "description": "Unified /tersio root command",
         "default": true,
         "extensions": [
-          "./extensions/tersio-commands/index.js"
+          "./extensions/tersio-commands/index.ts"
         ]
       }
     },
     "settings": {
       "comboDefault": {
         "type": "enum",
-        "description": "Combo preset applied on session start when no session state exists",
+        "description": "Session-start default (no saved state)",
         "values": [
           "off",
           "medium",
@@ -83,7 +78,7 @@
       },
       "cavemanDefault": {
         "type": "enum",
-        "description": "Caveman mode applied on session start when no session state exists",
+        "description": "Session-start default (no saved state)",
         "values": [
           "off",
           "lite",
@@ -95,12 +90,12 @@
       },
       "rtkDefault": {
         "type": "boolean",
-        "description": "RTK mode applied on session start when no session state exists",
+        "description": "Session-start default (no saved state)",
         "default": false
       },
       "ponytailDefault": {
         "type": "enum",
-        "description": "Ponytail mode applied on session start when no session state exists (follows combo preset unless overridden)",
+        "description": "Session-start default; follows the combo preset unless overridden",
         "values": [
           "off",
           "lite",
@@ -133,24 +128,24 @@
     "tersio.js",
     "cli/**/*.js",
     "dashboard/**/*",
-    "extensions/**/*.js"
+    "extensions/**/*.ts"
   ],
   "scripts": {
     "clean": "rm -f tersio.js cli/*.js extensions/**/*.js",
     "build": "tsc",
-    "prepublishOnly": "npm run build",
+    "prepublishOnly": "bun run build",
     "check": "tsc --noEmit",
     "doctor": "node tersio.js --doctor",
     "dry-run": "node tersio.js --dry-run --scope user --yes",
-    "test": "tsx --test test/*.test.ts test/*/*.test.ts"
+    "test": "vitest run"
   },
   "engines": {
     "node": ">=20.12.0"
   },
   "devDependencies": {
     "@types/node": "^26.4.1",
-    "tsx": "^4.23.13",
-    "typescript": "^7.0.2"
+    "typescript": "^7.0.2",
+    "vitest": "^5.0.1"
   },
   "dependencies": {
     "@clack/prompts": "^1.8.0"