@safetnsr/vet 1.11.1 → 1.12.0

package/dist/checks/subsidy.d.ts

@@ -0,0 +1,29 @@
+import type { CheckResult } from '../types.js';
+interface ModelCost {
+    inputTokens: number;
+    outputTokens: number;
+    cost: number;
+}
+export interface SubsidyData {
+    sessionCount: number;
+    periodStart: string;
+    periodEnd: string;
+    models: Record<string, ModelCost>;
+    totalCost: number;
+    subscriptionCost: number;
+    subsidized: number;
+    subsidyRate: number;
+}
+export declare function computeSubsidy(entries: Array<Record<string, unknown>>, plan: string): {
+    models: Record<string, ModelCost>;
+    totalCost: number;
+    subscriptionCost: number;
+    subsidized: number;
+    subsidyRate: number;
+};
+export declare function checkSubsidy(cwd: string): Promise<CheckResult>;
+export declare function runSubsidyCommand(format: 'ascii' | 'json', options?: {
+    since?: string;
+    plan?: string;
+}): Promise<void>;
+export {};

package/dist/checks/subsidy.js

@@ -0,0 +1,217 @@
+import { findSessionFiles, parseSessionFile } from './receipt.js';
+import { statSync } from 'node:fs';
+const PRICING = {
+    'claude-opus-4-6': { input: 15, output: 75 },
+    'claude-sonnet-4-6': { input: 3, output: 15 },
+    'claude-sonnet-4-5': { input: 3, output: 15 },
+    'claude-haiku-3-5': { input: 0.80, output: 4 },
+    'gpt-5.4': { input: 2.50, output: 10 },
+    'gpt-4o': { input: 2.50, output: 10 },
+    'gemini-2.5-pro': { input: 1.25, output: 10 },
+};
+const FALLBACK_PRICING = { input: 3, output: 15 };
+const SUBSCRIPTION_TIERS = {
+    'claude-pro': 20,
+    'claude-max-5x': 100,
+    'claude-max-20x': 200,
+    'chatgpt-plus': 20,
+    'chatgpt-pro': 200,
+};
+const DEFAULT_SUBSCRIPTION = 20;
+// ── Helpers ──────────────────────────────────────────────────────────────────
+function getPricing(model) {
+    // Try exact match first, then prefix match
+    if (PRICING[model])
+        return PRICING[model];
+    for (const [key, pricing] of Object.entries(PRICING)) {
+        if (model.startsWith(key))
+            return pricing;
+    }
+    return FALLBACK_PRICING;
+}
+function getSubscriptionCost(plan) {
+    return SUBSCRIPTION_TIERS[plan] ?? DEFAULT_SUBSCRIPTION;
+}
+export function computeSubsidy(entries, plan) {
+    const models = {};
+    for (const entry of entries) {
+        // Extract model and usage from entry or entry.message
+        let model;
+        let usage;
+        if (entry.model && typeof entry.model === 'string')
+            model = entry.model;
+        if (entry.usage && typeof entry.usage === 'object')
+            usage = entry.usage;
+        const msg = entry.message;
+        if (msg) {
+            if (!model && msg.model && typeof msg.model === 'string')
+                model = msg.model;
+            if (!usage && msg.usage && typeof msg.usage === 'object')
+                usage = msg.usage;
+        }
+        if (!model || !usage)
+            continue;
+        const inputTokens = typeof usage.input_tokens === 'number' ? usage.input_tokens : 0;
+        const outputTokens = typeof usage.output_tokens === 'number' ? usage.output_tokens : 0;
+        if (inputTokens === 0 && outputTokens === 0)
+            continue;
+        const pricing = getPricing(model);
+        const cost = (inputTokens / 1_000_000) * pricing.input + (outputTokens / 1_000_000) * pricing.output;
+        if (!models[model])
+            models[model] = { inputTokens: 0, outputTokens: 0, cost: 0 };
+        models[model].inputTokens += inputTokens;
+        models[model].outputTokens += outputTokens;
+        models[model].cost += cost;
+    }
+    const totalCost = Object.values(models).reduce((sum, m) => sum + m.cost, 0);
+    const subscriptionCost = getSubscriptionCost(plan);
+    const subsidized = Math.max(0, totalCost - subscriptionCost);
+    const subsidyRate = totalCost > 0 ? (subsidized / totalCost) * 100 : 0;
+    return { models, totalCost, subscriptionCost, subsidized, subsidyRate };
+}
+// ── ASCII card ───────────────────────────────────────────────────────────────
+function renderCard(data) {
+    const W = 43;
+    const hr = '─'.repeat(W);
+    const pad = (s, w = W) => {
+        const visible = s.replace(/\x1b\[[0-9;]*m/g, '');
+        const diff = w - visible.length;
+        return diff > 0 ? s + ' '.repeat(diff) : s;
+    };
+    const line = (s) => `│ ${pad(s, W - 2)} │`;
+    const lines = [];
+    lines.push(`┌${hr}┐`);
+    const title = 'YOUR AI COST THIS MONTH';
+    const lp = Math.floor((W - 2 - title.length) / 2);
+    const rp = W - 2 - title.length - lp;
+    lines.push(`│${' '.repeat(lp + 1)}${title}${' '.repeat(rp + 1)}│`);
+    lines.push(`├${hr}┤`);
+    lines.push(line(`sessions analyzed:${' '.repeat(Math.max(1, W - 2 - 18 - String(data.sessionCount).length))}${data.sessionCount}`));
+    const period = `${data.periodStart} — ${data.periodEnd}`;
+    lines.push(line(`period:${' '.repeat(Math.max(1, W - 2 - 7 - period.length))}${period}`));
+    lines.push(`├${hr}┤`);
+    // Per-model breakdown sorted by cost desc
+    const sorted = Object.entries(data.models).sort((a, b) => b[1].cost - a[1].cost);
+    for (const [model, mc] of sorted) {
+        const pct = data.totalCost > 0 ? Math.round((mc.cost / data.totalCost) * 100) : 0;
+        const costStr = `$${mc.cost.toFixed(2)}`;
+        const pctStr = `(${pct}%)`;
+        const gap = Math.max(1, W - 2 - model.length - costStr.length - pctStr.length - 4);
+        lines.push(line(`${model}${' '.repeat(gap)}${costStr}    ${pctStr}`));
+    }
+    lines.push(`├${hr}┤`);
+    const fmtRow = (label, value) => {
+        const gap = Math.max(1, W - 2 - label.length - value.length);
+        return line(`${label}${' '.repeat(gap)}${value}`);
+    };
+    lines.push(fmtRow('USED (list price):', `$${data.totalCost.toFixed(2)}`));
+    lines.push(fmtRow('PAID (subscription):', `$${data.subscriptionCost.toFixed(2)}`));
+    lines.push(fmtRow('SUBSIDIZED:', `$${data.subsidized.toFixed(2)}`));
+    lines.push(fmtRow('SUBSIDY RATE:', `${data.subsidyRate.toFixed(1)}%`));
+    lines.push(`└${hr}┘`);
+    return lines.join('\n');
+}
+// ── Check for vet scan ───────────────────────────────────────────────────────
+export async function checkSubsidy(cwd) {
+    const files = findSessionFiles();
+    const issues = [];
+    if (files.length === 0) {
+        return {
+            name: 'subsidy',
+            score: 100,
+            maxScore: 100,
+            issues: [{ severity: 'info', message: 'no session logs found', fixable: false }],
+            summary: 'no session logs found',
+        };
+    }
+    const allEntries = [];
+    for (const f of files) {
+        try {
+            const { entries } = await parseSessionFile(f);
+            allEntries.push(...entries);
+        }
+        catch { /* skip */ }
+    }
+    const result = computeSubsidy(allEntries, 'claude-pro');
+    if (Object.keys(result.models).length === 0) {
+        return {
+            name: 'subsidy',
+            score: 100,
+            maxScore: 100,
+            issues: [{ severity: 'info', message: 'no token usage data in sessions', fixable: false }],
+            summary: 'no token usage data in sessions',
+        };
+    }
+    issues.push({
+        severity: 'info',
+        message: `API list price: $${result.totalCost.toFixed(2)}, subscription: $${result.subscriptionCost.toFixed(2)}, subsidy: ${result.subsidyRate.toFixed(1)}%`,
+        fixable: false,
+    });
+    return {
+        name: 'subsidy',
+        score: 100,
+        maxScore: 100,
+        issues,
+        summary: `used $${result.totalCost.toFixed(2)} at list price (paid $${result.subscriptionCost.toFixed(2)}, subsidy ${result.subsidyRate.toFixed(1)}%)`,
+    };
+}
+// ── Subcommand ───────────────────────────────────────────────────────────────
+export async function runSubsidyCommand(format, options) {
+    const plan = options?.plan || 'claude-pro';
+    const since = options?.since;
+    let files = findSessionFiles();
+    if (since) {
+        const sinceDate = new Date(since);
+        if (!isNaN(sinceDate.getTime())) {
+            files = files.filter(f => {
+                try {
+                    return statSync(f).mtimeMs >= sinceDate.getTime();
+                }
+                catch {
+                    return false;
+                }
+            });
+        }
+    }
+    if (files.length === 0) {
+        if (format === 'json') {
+            console.log(JSON.stringify({ error: 'no session files found' }));
+        }
+        else {
+            console.error('no claude session files found in ~/.claude/projects/');
+        }
+        return;
+    }
+    const allEntries = [];
+    let earliest = Infinity;
+    let latest = -Infinity;
+    for (const f of files) {
+        try {
+            const { entries } = await parseSessionFile(f);
+            allEntries.push(...entries);
+            const stat = statSync(f);
+            if (stat.mtimeMs < earliest)
+                earliest = stat.mtimeMs;
+            if (stat.mtimeMs > latest)
+                latest = stat.mtimeMs;
+        }
+        catch { /* skip */ }
+    }
+    const result = computeSubsidy(allEntries, plan);
+    const data = {
+        sessionCount: files.length,
+        periodStart: earliest === Infinity ? 'unknown' : new Date(earliest).toISOString().slice(0, 10),
+        periodEnd: latest === -Infinity ? 'unknown' : new Date(latest).toISOString().slice(0, 10),
+        models: result.models,
+        totalCost: result.totalCost,
+        subscriptionCost: result.subscriptionCost,
+        subsidized: result.subsidized,
+        subsidyRate: result.subsidyRate,
+    };
+    if (format === 'json') {
+        console.log(JSON.stringify(data, null, 2));
+    }
+    else {
+        console.log(renderCard(data));
+    }
+}

package/dist/cli.js

@@ -20,6 +20,7 @@ import { checkTests } from './checks/tests.js';
 import { checkMap, renderMapReport } from './checks/map.js';
 import { checkPermissions } from './checks/permissions.js';
 import { checkCompact, runCompactCommand } from './checks/compact.js';
+import { checkSubsidy, runSubsidyCommand } from './checks/subsidy.js';
 import { score } from './scorer.js';
 import { reportPretty, reportJSON, reportBadge } from './reporter.js';
 import { clearCache } from './file-cache.js';
@@ -35,6 +36,13 @@ for (let i = 0; i < args.length; i++) {
         flagMap.set('since', args[i + 1]);
         i++;
     }
+    else if (args[i].startsWith('--plan=')) {
+        flagMap.set('plan', args[i].split('=')[1]);
+    }
+    else if (args[i] === '--plan' && args[i + 1]) {
+        flagMap.set('plan', args[i + 1]);
+        i++;
+    }
     else if (args[i].startsWith('--max-files=')) {
         flagMap.set('max-files', args[i].split('=')[1]);
     }
@@ -61,6 +69,7 @@ if (flags.has('--help') || flags.has('-h')) {
     npx @safetnsr/vet map [dir]          show agent visibility map
     npx @safetnsr/vet permissions [dir]  audit Claude Code config for dangerous grants
     npx @safetnsr/vet compact [log]      compaction forensics for claude code sessions
+    npx @safetnsr/vet subsidy [--plan tier] [--since date]  show AI cost vs subscription
 
   ${c.dim}categories:${c.reset}
     security   (30%)  scan, secrets, config, model usage
@@ -96,7 +105,7 @@ if (flags.has('--version') || flags.has('-v')) {
     }
     process.exit(0);
 }
-const COMMANDS = ['init', 'receipt', 'map', 'permissions', 'compact'];
+const COMMANDS = ['init', 'receipt', 'map', 'permissions', 'compact', 'subsidy'];
 const command = COMMANDS.includes(positional[0]) ? positional[0] : undefined;
 const cwd = resolve(positional.find(p => !COMMANDS.includes(p)) || '.');
 const isCI = flags.has('--ci');
@@ -191,6 +200,19 @@ if (command === 'compact') {
     }
     process.exit(0);
 }
+if (command === 'subsidy') {
+    try {
+        const format = isJSON ? 'json' : 'ascii';
+        const plan = flagMap.get('plan') || 'claude-pro';
+        const since = flagMap.get('since');
+        await runSubsidyCommand(format, { since, plan });
+    }
+    catch (e) {
+        console.error(`${c.red}subsidy failed:${c.reset}`, e instanceof Error ? e.message : e);
+        process.exit(1);
+    }
+    process.exit(0);
+}
 if (!isGitRepo(cwd)) {
     console.error(`${c.red}not a git repository${c.reset}. vet operates on git repos.`);
     process.exit(1);
@@ -242,7 +264,7 @@ async function runChecks() {
             }
         }
         // Run ALL independent checks in parallel
-        const [scanResult, secretsResult, configResult, modelsResult, owaspResult, permissionsResult, integrityResult, readyResult, debtResult, depsResult, receiptResult, compactResult, memoryResult, verifyResult, testsResult,] = await Promise.all([
+        const [scanResult, secretsResult, configResult, modelsResult, owaspResult, permissionsResult, integrityResult, readyResult, debtResult, depsResult, receiptResult, compactResult, subsidyResult, memoryResult, verifyResult, testsResult,] = await Promise.all([
             withTimeout('scan', () => checkScan(cwd)),
             withTimeout('secrets', () => checkSecrets(cwd)),
             withTimeout('config', () => checkConfig(cwd, ignore)),
@@ -255,6 +277,7 @@ async function runChecks() {
             withTimeout('deps', () => checkDeps(cwd)),
             withTimeout('receipt', () => checkReceipt(cwd)),
             withTimeout('compact', () => checkCompact(cwd)),
+            withTimeout('subsidy', () => checkSubsidy(cwd)),
             withTimeout('memory', () => checkMemory(cwd)),
             withTimeout('verify', () => checkVerify(cwd, since)),
             withTimeout('tests', () => checkTests(cwd, ignore)),
@@ -267,7 +290,7 @@ async function runChecks() {
         // Clear file cache after all checks complete
         clearCache();
         return score(cwd, {
-            security: [scanResult, secretsResult, configResult, modelsResult, owaspResult, permissionsResult],
+            security: [scanResult, secretsResult, configResult, modelsResult, owaspResult, permissionsResult, subsidyResult],
             integrity: [diffResult, integrityResult, receiptResult, compactResult, memoryResult, verifyResult, testsResult],
             debt: [readyResult, historyResult, debtResult],
             deps: [depsResult],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@safetnsr/vet",
-  "version": "1.11.1",
+  "version": "1.12.0",
   "description": "vet your AI-generated code — one command, one score card, one letter grade",
   "type": "module",
   "bin": {