sigrank-mcp 0.6.4 → 0.6.6

package/cli.mjs

@@ -3,23 +3,28 @@
  *
  * Commands (no external deps — pure Node.js ANSI escape codes):
  *
- *   npx sigrank-mcp board              live leaderboard, refreshes every 30s
- *   npx sigrank-mcp board --window 7d  board for a specific window
- *   npx sigrank-mcp board --once       print once and exit (no live refresh)
- *   npx sigrank-mcp me                 your cascade across all 4 windows
- *   npx sigrank-mcp me --platform amp  use a different platform adapter
- *   npx sigrank-mcp watch              RT tune meter — local cascade, refreshes
- *   npx sigrank-mcp watch --window 7d  watch a specific window
+ *   npx sigrank-mcp board                live leaderboard, refreshes every 30s
+ *   npx sigrank-mcp board --window 7d    board for a specific window
+ *   npx sigrank-mcp board --once         print once and exit (no live refresh)
+ *   npx sigrank-mcp me                   your cascade across all 4 windows
+ *   npx sigrank-mcp me --platform amp    use a different platform adapter
+ *   npx sigrank-mcp me --compare         raw pillar comparison: ccusage vs tokenpull vs token-dashboard
+ *   npx sigrank-mcp watch                RT tune meter — local cascade, refreshes
+ *   npx sigrank-mcp watch --window 7d    watch a specific window
  *
  * Color palette mirrors the SigRank web dark theme:
  *   gold = class TRANSMITTER headline + rank #1
  *   cyan = active metrics / your row highlight
  *   dim  = secondary data, separators
- *   red  = negative movement
+ *   red  = negative movement / delta
  *   green = positive movement
  */
 
 import { callTool, DEFAULT_API_BASE } from './tools.mjs'
+import { execSync } from 'child_process'
+import { existsSync, readFileSync } from 'fs'
+import os from 'os'
+import path from 'path'
 
 // ── ANSI helpers (no chalk dep) ────────────────────────────────────────────
 const ESC = '\x1b['
@@ -283,10 +288,10 @@ async function runBoard({ window = '30d', once = false, refresh = 30 } = {}) {
 
 // ── ME command ───────────────────────────────────────────────────────────────
 
-async function runMe({ platform = 'claude' } = {}) {
+async function runMe({ platform = 'claude', compare = false } = {}) {
+  if (compare) return runCompare({ platform })
+
   write(HIDE_CURSOR)
-  writeln()
-  writeln(`  ${gold('⊙ SigRank')} ${bold('Your Cascade')}  ${dim(`platform: ${platform}`)}`)
   writeln(`  ${dim('reading local token logs…')}`)
 
   let pulled
@@ -294,6 +299,7 @@ async function runMe({ platform = 'claude' } = {}) {
     pulled = await callTool('tokenpull', { platform })
   } catch (e) {
     write(SHOW_CURSOR)
+    write(CURSOR_UP(1) + ERASE_LINE)
     writeln(red(`  ✗ ${e.message}`))
     process.exit(1)
   }
@@ -302,6 +308,7 @@ async function runMe({ platform = 'claude' } = {}) {
   write(CURSOR_UP(1) + ERASE_LINE)
 
   const w = termWidth()
+  writeln()
   writeln(`  ${gold('⊙ SigRank')} ${bold('Your Cascade')}  ${dim(`platform: ${pulled.platform ?? platform}`)}`)
   if (pulled.estimated) writeln(`  ${dim('⚠  estimated values (cache data unavailable for this platform)')}`)
   writeln(`  ${dim('─'.repeat(w - 4))}`)
@@ -380,6 +387,302 @@ async function runMe({ platform = 'claude' } = {}) {
   write(SHOW_CURSOR)
 }
 
+// ── COMPARE command ───────────────────────────────────────────────────────────
+// Side-by-side: ccusage (JSON) vs tokenpull vs token-dashboard (SQLite)
+
+function ccusagePillars(platform = 'claude') {
+  // ccusage <platform> daily --json → sum by window
+  try {
+    const cmd = platform === 'claude' ? 'ccusage claude daily --json' : `ccusage ${platform} daily --json`
+    const raw = execSync(cmd, { timeout: 15000, stdio: ['ignore', 'pipe', 'ignore'] }).toString()
+    const data = JSON.parse(raw)
+    const rows = data.daily ?? data // ccusage may return {daily:[...]} or [...]
+
+    const now = Date.now()
+    const cutoff = { '7d': 7, '30d': 30, '90d': 90 }
+    const result = {}
+
+    for (const [win, days] of Object.entries(cutoff)) {
+      const since = new Date(now - days * 86400000)
+      let input = 0, output = 0, cacheCreate = 0, cacheRead = 0
+      for (const row of rows) {
+        const d = new Date(row.date ?? row.day ?? row.week ?? '1970-01-01')
+        if (d >= since) {
+          input       += row.inputTokens        ?? row.input_tokens        ?? 0
+          output      += row.outputTokens       ?? row.output_tokens       ?? 0
+          cacheCreate += row.cacheCreationTokens ?? row.cache_create_tokens ?? 0
+          cacheRead   += row.cacheReadTokens    ?? row.cache_read_tokens   ?? 0
+        }
+      }
+      result[win] = { input, output, cacheCreate, cacheRead }
+    }
+    // all-time = sum everything
+    let input = 0, output = 0, cacheCreate = 0, cacheRead = 0
+    for (const row of rows) {
+      input       += row.inputTokens        ?? row.input_tokens        ?? 0
+      output      += row.outputTokens       ?? row.output_tokens       ?? 0
+      cacheCreate += row.cacheCreationTokens ?? row.cache_create_tokens ?? 0
+      cacheRead   += row.cacheReadTokens    ?? row.cache_read_tokens   ?? 0
+    }
+    result['all'] = { input, output, cacheCreate, cacheRead }
+    return result
+  } catch {
+    return null
+  }
+}
+
+function tokscalePillars() {
+  // Read tokscale_report.json — claude client only, all-time only (no timestamps in export)
+  const reportPath = path.join(os.homedir(), 'tokscale_report.json')
+  if (!existsSync(reportPath)) return null
+  try {
+    const data = JSON.parse(readFileSync(reportPath, 'utf8'))
+    const entries = data.entries ?? []
+    const claude = entries.filter(e =>
+      e.client === 'claude' &&
+      e.model !== '<synthetic>' && e.model !== 'unknown' &&
+      e.provider !== 'unknown'
+    )
+    const p = claude.reduce((acc, e) => ({
+      input:       acc.input       + (e.input      ?? 0),
+      output:      acc.output      + (e.output     ?? 0),
+      cacheCreate: acc.cacheCreate + (e.cacheWrite ?? 0),
+      cacheRead:   acc.cacheRead   + (e.cacheRead  ?? 0),
+    }), { input: 0, output: 0, cacheCreate: 0, cacheRead: 0 })
+    // tokscale export has no timestamps → only all-time available
+    return { all: p }
+  } catch { return null }
+}
+
+function appPillars() {
+  // App numbers from screenshots — all-time, per model (no cache fields)
+  // Hard-coded from 2026-06-23 screenshot capture (update when re-screenshotted)
+  return {
+    all: {
+      input:       6_378_000,   // sum of all models: 5.6M + 102.1K + 92.9K + 130.3K + 418.9K + 33.5K
+      output:     38_682_400,   // sum: 19.6M + 6.5M + 5.4M + 6.6M + 292.4K + 290.4K
+      cacheCreate: null,        // not shown in App UI
+      cacheRead:   null,        // not shown in App UI
+    },
+    _note: 'App UI — all-time, per-model sum from screenshots 2026-06-23. No cache fields. Update when re-screenshotted.',
+    _perModel: [
+      { model: 'claude-opus-4-8',  input: 5_600_000, output: 19_600_000 },
+      { model: 'claude-sonnet-4-5',input:   102_100,  output:  6_500_000 },
+      { model: 'claude-sonnet-4-6',input:    92_900,  output:  5_400_000 },
+      { model: 'claude-opus-4-7',  input:   130_300,  output:  6_600_000 },
+      { model: 'claude-fable-5',   input:   418_900,  output:    292_400 },
+      { model: 'claude-haiku-4-5', input:    33_500,  output:    290_400 },
+    ],
+  }
+}
+
+function tokenDashPillars() {
+  // query token-dashboard SQLite directly
+  const dbPath = path.join(os.homedir(), '.claude', 'token-dashboard.db')
+  if (!existsSync(dbPath)) return null
+  try {
+    const claudeFilter = `(model LIKE '%claude%' OR model LIKE '%fable%' OR model LIKE '%sonnet%' OR model LIKE '%opus%' OR model LIKE '%haiku%')`
+    const now = new Date()
+    const result = {}
+    for (const [win, days] of [['7d', 7], ['30d', 30], ['90d', 90]]) {
+      const since = new Date(now - days * 86400000).toISOString()
+      const cmd = `python3 -c "
+import sqlite3, json
+db = sqlite3.connect('${dbPath}')
+r = db.execute('''SELECT SUM(input_tokens),SUM(output_tokens),SUM(cache_create_5m_tokens+cache_create_1h_tokens),SUM(cache_read_tokens) FROM messages WHERE timestamp>=? AND ${claudeFilter}''',(('${since}',))).fetchone()
+print(json.dumps({'input':r[0] or 0,'output':r[1] or 0,'cacheCreate':r[2] or 0,'cacheRead':r[3] or 0}))
+"`
+      const raw = execSync(cmd, { timeout: 10000, stdio: ['ignore', 'pipe', 'ignore'] }).toString().trim()
+      result[win] = JSON.parse(raw)
+    }
+    // all-time
+    const cmd = `python3 -c "
+import sqlite3, json
+db = sqlite3.connect('${dbPath}')
+r = db.execute('SELECT SUM(input_tokens),SUM(output_tokens),SUM(cache_create_5m_tokens+cache_create_1h_tokens),SUM(cache_read_tokens) FROM messages WHERE ${claudeFilter}').fetchone()
+print(json.dumps({'input':r[0] or 0,'output':r[1] or 0,'cacheCreate':r[2] or 0,'cacheRead':r[3] or 0}))
+"`
+    const raw = execSync(cmd, { timeout: 10000, stdio: ['ignore', 'pipe', 'ignore'] }).toString().trim()
+    result['all'] = JSON.parse(raw)
+    return result
+  } catch {
+    return null
+  }
+}
+
+function fmtDelta(a, b) {
+  if (a == null || b == null) return dim('  —')
+  const d = b - a
+  if (d === 0) return dim('  =')
+  const pct = a !== 0 ? `${d > 0 ? '+' : ''}${((d / a) * 100).toFixed(1)}%` : ''
+  const abs = `${d > 0 ? '+' : ''}${fmtTokens(Math.abs(d))}`
+  const label = `${abs} ${pct}`
+  return d > 0 ? green(label) : red(label)
+}
+
+// Compute cascade metrics from raw pillars (mirrors bridge.ts computeCascadeMetrics)
+function cascadeFromPillars(p) {
+  if (!p) return null
+  const i  = p.input       ?? 0
+  const o  = p.output      ?? 0
+  const cw = p.cacheCreate ?? 0
+  const cr = p.cacheRead   ?? 0
+  if (i === 0 && o === 0) return null
+  const safeI = Math.max(i, 1)
+  const total = i + o + cw + cr
+  const velocity = o / safeI
+  const leverage = cr / safeI
+  const yield_   = leverage * velocity
+  const snr      = (i + o) > 0 ? o / (i + o) : 0
+  // dev10x = log10(T × C × R) — only when all four pillars present
+  let dev10x = null
+  if (cw > 0 && o > 0 && i > 0 && cr > 0) {
+    const T = o / i, C = cw / o, R = cr / cw
+    dev10x = Math.log10(T * C * R)
+  }
+  // efficiency = ((cr+cw+o)/i) / 4.0
+  const efficiency = ((cr + cw + o) / safeI) / 4.0
+  const cls = yield_ > 500 ? 'TRANSMITTER' : yield_ > 400 ? 'ARCH+' : yield_ > 300 ? 'ARCH' : yield_ > 150 ? 'POWER' : 'BASE'
+  return { yield: yield_, velocity, leverage, snr, dev10x, efficiency, class: cls, total }
+}
+
+async function runCompare({ platform = 'claude' } = {}) {
+  write(HIDE_CURSOR)
+
+  // Pull all five sources in parallel
+  writeln(`  ${dim('reading all 5 sources…')}`)
+  const [ccPillars, tpData, tdPillars, tsPillars, apPillars] = await Promise.all([
+    Promise.resolve(ccusagePillars(platform)),
+    callTool('tokenpull', { platform }).catch(() => null),
+    Promise.resolve(tokenDashPillars()),
+    Promise.resolve(tokscalePillars()),
+    Promise.resolve(appPillars()),
+  ])
+  write(CURSOR_UP(1) + ERASE_LINE)
+
+  const w = termWidth()
+  const WINS = ['7d', '30d', '90d', 'all']
+  const WIN_LABEL = { '7d': '7d', '30d': '30d', '90d': '90d', 'all': 'all-time' }
+
+  // build tokenpull pillar lookup
+  const tpPillars = {}
+  for (const win of (tpData?.windows ?? [])) {
+    tpPillars[win.window] = win.pillars
+  }
+
+  // sources: name, color, pillars-by-window, note
+  const SOURCES = [
+    { name: 'tokenpull',   color: cyan,                      pillars: tpPillars,                      note: 'JSONL deduped by msg id · canon source' },
+    { name: 'ccusage',     color: (s) => paint(c.green, s),  pillars: ccPillars ?? {},                note: 'ccusage claude subcommand · monthly only' },
+    { name: 'token-dash',  color: (s) => paint(c.magenta,s), pillars: tdPillars ?? {},                note: 'SQLite — double-counts sessions · use with caution' },
+    { name: 'tokscale',    color: (s) => paint(c.blue, s),   pillars: tsPillars ?? {},                note: 'all-time only · partial export (~5% of opus-4-8)' },
+    { name: 'App',         color: gold,                      pillars: apPillars ?? {},                note: 'screenshots 2026-06-23 · no cache fields · update manually' },
+  ]
+
+  writeln()
+  writeln(`  ${gold('⊙ SigRank')} ${bold('5-Source Comparison')}  ${dim(`platform: ${platform}  ·  claude only`)}`)
+  writeln(`  ${dim('─'.repeat(w - 4))}`)
+
+  // ── PILLARS TABLE ──────────────────────────────────────────────────────────
+  const PILLARS = [
+    { key: 'input',       label: 'Input' },
+    { key: 'output',      label: 'Output' },
+    { key: 'cacheCreate', label: 'Cache Write' },
+    { key: 'cacheRead',   label: 'Cache Read' },
+  ]
+
+  for (const { key, label } of PILLARS) {
+    writeln()
+    writeln(`  ${bold(label)}`)
+    const hcols = [padEnd(dim('Source'), 14), ...WINS.map(win => padStart(dim(WIN_LABEL[win]), 13))]
+    writeln(`    ${hcols.join('  ')}`)
+    writeln(`  ${dim('·'.repeat(Math.min(w - 4, 14 + WINS.length * 15)))}`)
+
+    for (const src of SOURCES) {
+      const vals = WINS.map(win => {
+        const p = src.pillars[win]
+        const v = p?.[key]
+        if (v == null) return padStart(dim('—'), 13)
+        return padStart(fmtTokens(v), 13)
+      })
+      writeln(`    ${padEnd(src.color(src.name), 14)}  ${vals.join('  ')}`)
+    }
+  }
+
+  // ── SIGNATURE TABLE ────────────────────────────────────────────────────────
+  writeln()
+  writeln(`  ${dim('─'.repeat(w - 4))}`)
+  writeln(`  ${bold('Cascade Signature')}  ${dim('per source · all windows where data available')}`)
+  writeln()
+
+  const SIG_METRICS = [
+    { key: 'yield',      label: 'Υ Yield',    fmt: v => fmtYield(v),       w: 9 },
+    { key: 'velocity',   label: 'Vel',         fmt: v => v.toFixed(2),      w: 6 },
+    { key: 'leverage',   label: 'Lev',         fmt: v => `${fmtLev(v)}×`,  w: 7 },
+    { key: 'snr',        label: 'SNR',         fmt: v => fmtSNR(v),         w: 6 },
+    { key: 'dev10x',     label: '10x',         fmt: v => v.toFixed(2),      w: 5 },
+    { key: 'efficiency', label: 'Eff',         fmt: v => v.toFixed(1),      w: 6 },
+    { key: 'class',      label: 'Class',       fmt: v => colorClass(v),     w: 12 },
+  ]
+
+  // header
+  const sigHdr = [
+    padEnd(dim('Source'), 14),
+    padEnd(dim('Window'), 8),
+    ...SIG_METRICS.map(m => padStart(dim(m.label), m.w)),
+  ]
+  writeln(`    ${sigHdr.join('  ')}`)
+  writeln(`  ${dim('·'.repeat(Math.min(w - 4, 80)))}`)
+
+  for (const src of SOURCES) {
+    const availWins = WINS.filter(win => src.pillars[win] != null)
+    if (availWins.length === 0) {
+      writeln(`    ${padEnd(src.color(src.name), 14)}  ${dim('no data')}`)
+      continue
+    }
+    let first = true
+    for (const win of availWins) {
+      const p = src.pillars[win]
+      // For tokenpull, use the pre-computed cascade from the tool if available
+      let cas
+      if (src.name === 'tokenpull') {
+        const tpWin = tpData?.windows?.find(ww => ww.window === win)
+        cas = tpWin?.cascade ? {
+          yield: tpWin.cascade.yield,
+          velocity: tpWin.cascade.velocity,
+          leverage: tpWin.cascade.leverage,
+          snr: tpWin.cascade.snr,
+          dev10x: tpWin.cascade.dev10x,
+          efficiency: null,
+          class: tpWin.cascade.class,
+        } : cascadeFromPillars(p)
+      } else {
+        cas = cascadeFromPillars(p)
+      }
+
+      const srcLabel = first ? src.color(src.name) : ' '.repeat(stripAnsi(src.name).length)
+      const winLabel = win === 'all' ? bold('all-time') : win
+      const sigCols = SIG_METRICS.map(m => {
+        const v = cas?.[m.key]
+        return padStart(v != null ? m.fmt(v) : dim('—'), m.w)
+      })
+      writeln(`    ${padEnd(srcLabel, 14)}  ${padEnd(winLabel, 8)}  ${sigCols.join('  ')}`)
+      first = false
+    }
+  }
+
+  // ── NOTES ─────────────────────────────────────────────────────────────────
+  writeln()
+  writeln(`  ${dim('─'.repeat(w - 4))}`)
+  for (const src of SOURCES) {
+    writeln(`  ${src.color(src.name.padEnd(12))}  ${dim(src.note)}`)
+  }
+  writeln(`  ${dim('Eff = ((cacheRead+cacheWrite+output)/input)/4.0 vs AA baseline')}`)
+  writeln(`  ${dim('App has no cache fields → Υ/Lev/Eff/10x unavailable from App source')}`)
+  writeln()
+  write(SHOW_CURSOR)
+}
+
 // ── WATCH command ─────────────────────────────────────────────────────────────
 
 async function runWatch({ platform = 'claude', window: win = '7d', refresh = 30 } = {}) {
@@ -446,16 +749,17 @@ async function runWatch({ platform = 'claude', window: win = '7d', refresh = 30
 
 function showHelp() {
   writeln()
-  writeln(`  ${gold('⊙ SigRank')} ${bold('CLI')}  ${dim('v0.6.4')}`)
+  writeln(`  ${gold('⊙ SigRank')} ${bold('CLI')}  ${dim('v0.6.5')}`)
   writeln()
   writeln(`  ${bold('Commands')}`)
-  writeln(`    ${cyan('board')}              live leaderboard (refreshes every 30s)`)
-  writeln(`    ${cyan('board --window 7d')} board for a specific window (7d, 30d, 90d, all_time)`)
-  writeln(`    ${cyan('board --once')}      print once and exit`)
-  writeln(`    ${cyan('me')}                your cascade across all 4 time windows`)
-  writeln(`    ${cyan('me --platform amp')} use a different platform adapter`)
-  writeln(`    ${cyan('watch')}             live tune meter — re-reads local logs every 30s`)
-  writeln(`    ${cyan('watch --window 7d')} watch a specific window`)
+  writeln(`    ${cyan('board')}                live leaderboard (refreshes every 30s)`)
+  writeln(`    ${cyan('board --window 7d')}    board for a specific window (7d, 30d, 90d, all_time)`)
+  writeln(`    ${cyan('board --once')}         print once and exit`)
+  writeln(`    ${cyan('me')}                   your cascade across all 4 time windows`)
+  writeln(`    ${cyan('me --platform amp')}    use a different platform adapter`)
+  writeln(`    ${cyan('me --compare')}         raw pillar comparison: ccusage vs tokenpull vs token-dashboard`)
+  writeln(`    ${cyan('watch')}                live tune meter — re-reads local logs every 30s`)
+  writeln(`    ${cyan('watch --window 7d')}    watch a specific window`)
   writeln()
   writeln(`  ${bold('Options')}`)
   writeln(`    ${dim('--window')}    7d · 30d · 90d · all_time  (default: 30d for board, 7d for watch)`)
@@ -498,7 +802,7 @@ export async function runCli(argv) {
         refresh: Number(flags.refresh) || 30,
       })
     } else if (cmd === 'me') {
-      await runMe({ platform: flags.platform ?? 'claude' })
+      await runMe({ platform: flags.platform ?? 'claude', compare: flags.compare === true || flags.compare === 'true' })
     } else if (cmd === 'watch') {
       await runWatch({
         platform: flags.platform ?? 'claude',
@@ -508,7 +812,7 @@ export async function runCli(argv) {
     } else if (cmd === '--help' || cmd === '-h' || cmd === 'help') {
       showHelp()
     } else if (cmd === '--version' || cmd === '-v') {
-      writeln('0.6.4')
+      writeln('0.6.5')
     } else {
       // unknown command: show help
       showHelp()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sigrank-mcp",
-  "version": "0.6.4",
+  "version": "0.6.6",
   "description": "SigRank MCP server — the yield cascade + live leaderboard as MCP tools any agent can call",
   "type": "module",
   "bin": {