@sliday/tamp 0.2.6 → 0.2.8

package/config.js

@@ -15,5 +15,6 @@ export function loadConfig(env = process.env) {
     maxBody: parseInt(env.TAMP_MAX_BODY, 10) || 10_485_760,
     cacheSafe: true,
     llmLinguaUrl: env.TAMP_LLMLINGUA_URL || null,
+    tokenCost: parseFloat(env.TAMP_TOKEN_COST) || 3,
   })
 }

package/index.js

@@ -179,9 +179,9 @@ return http.createServer(async (req, res) => {
     // Send uncompressed — simpler and content-length is accurate
     if (decompressed) delete headers['content-encoding']
 
-    if (config.log && stats.length) {
+    if (config.log) {
       session.record(stats)
-      console.error(formatRequestLog(stats, session, provider.name, req.url))
+      console.error(formatRequestLog(stats, session, provider.name, req.url, textBody.length, config.tokenCost))
     }
   } catch (err) {
     if (config.log) console.error(`[tamp] passthrough (parse error): ${err.message}`)

package/package.json

@@ -9,7 +9,7 @@
     "providers.js",
     "stats.js"
   ],
-  "version": "0.2.6",
+  "version": "0.2.8",
   "description": "Token compression proxy for coding agents. Works with Claude Code, Aider, Cursor, Cline, Windsurf. 33.9% fewer input tokens.",
   "type": "module",
   "main": "index.js",

package/stats.js

@@ -1,40 +1,71 @@
-export function formatRequestLog(stats, session, providerName, url) {
+const c = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  dim: '\x1b[2m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  cyan: '\x1b[36m',
+  magenta: '\x1b[35m',
+  red: '\x1b[31m',
+}
+
+export function formatRequestLog(stats, session, providerName, url, bodySize, tokenCost) {
   const compressed = stats.filter(s => s.method)
-  const skipped = stats.filter(s => s.skipped)
   const label = providerName || 'anthropic'
   const path = url || '/v1/messages'
-  const lines = [`[tamp] ${label} ${path} — ${stats.length} blocks, ${compressed.length} compressed`]
-
-  for (const s of stats) {
-    if (s.skipped) {
-      lines.push(`[tamp]   block[${s.index}]: skipped (${s.skipped})`)
-    } else if (s.method) {
-      const pct = (((s.originalLen - s.compressedLen) / s.originalLen) * 100).toFixed(1)
-      const tokInfo = s.originalTokens ? ` ${s.originalTokens}->${s.compressedTokens} tok` : ''
-      lines.push(`[tamp]   block[${s.index}]: ${s.originalLen}->${s.compressedLen} chars (-${pct}%)${tokInfo} [${s.method}]`)
-    }
+  const sizeInfo = bodySize ? ` ${c.dim}${fmtSize(bodySize)}${c.reset}` : ''
+
+  if (!compressed.length && !stats.length) {
+    return `[tamp] ${c.cyan}${label}${c.reset} ${path}${sizeInfo} ${c.dim}— no tool blocks${c.reset}`
+  }
+
+  if (!compressed.length) {
+    const skipCount = stats.filter(s => s.skipped).length
+    const reason = skipCount ? `${skipCount} skipped` : 'nothing to compress'
+    return `[tamp] ${c.cyan}${label}${c.reset} ${path}${sizeInfo} ${c.dim}— ${stats.length} blocks, ${reason}${c.reset}`
   }
 
   const totalOrig = compressed.reduce((a, s) => a + s.originalLen, 0)
   const totalComp = compressed.reduce((a, s) => a + s.compressedLen, 0)
   const totalOrigTok = compressed.reduce((a, s) => a + (s.originalTokens || 0), 0)
   const totalCompTok = compressed.reduce((a, s) => a + (s.compressedTokens || 0), 0)
-  if (compressed.length > 0) {
-    const pct = (((totalOrig - totalComp) / totalOrig) * 100).toFixed(1)
-    const tokPct = totalOrigTok > 0 ? (((totalOrigTok - totalCompTok) / totalOrigTok) * 100).toFixed(1) : '0.0'
-    lines.push(`[tamp]   total: ${totalOrig}->${totalComp} chars (-${pct}%), ${totalOrigTok}->${totalCompTok} tokens (-${tokPct}%)`)
+  const pct = (((totalOrig - totalComp) / totalOrig) * 100).toFixed(1)
+  const saved = totalOrig - totalComp
+  const tokSaved = totalOrigTok - totalCompTok
+
+  const lines = []
+  lines.push(`[tamp] ${c.cyan}${label}${c.reset} ${path}${sizeInfo} ${c.green}— ${compressed.length} compressed, -${pct}%${c.reset}`)
+
+  for (const s of compressed) {
+    const sPct = (((s.originalLen - s.compressedLen) / s.originalLen) * 100).toFixed(1)
+    const tokInfo = s.originalTokens ? ` ${c.dim}${s.originalTokens}→${s.compressedTokens} tok${c.reset}` : ''
+    lines.push(`[tamp]   ${c.dim}block[${s.index}]${c.reset} ${fmtSize(s.originalLen)}→${fmtSize(s.compressedLen)} ${c.green}-${sPct}%${c.reset}${tokInfo} ${c.dim}[${s.method}]${c.reset}`)
+  }
+
+  for (const s of stats.filter(s => s.skipped)) {
+    lines.push(`[tamp]   ${c.dim}block[${s.index}] skipped (${s.skipped})${c.reset}`)
   }
 
   if (session) {
-    const totals = session.getTotals()
-    lines.push(`[tamp]   session: ${totals.totalSaved} chars, ${totals.totalTokensSaved} tokens saved across ${totals.compressionCount} compressions`)
+    const t = session.getTotals()
+    const sessionPct = t.totalOriginal > 0 ? (((t.totalSaved) / t.totalOriginal) * 100).toFixed(1) : '0.0'
+    const costPerM = tokenCost || 3
+    const dollarsSaved = (t.totalTokensSaved / 1_000_000) * costPerM
+    const moneyInfo = t.totalTokensSaved > 0 ? ` ${c.green}$${dollarsSaved.toFixed(4)} saved${c.reset} ${c.dim}@ $${costPerM}/Mtok${c.reset}` : ''
+    lines.push(`[tamp]   ${c.magenta}session${c.reset} ${fmtSize(t.totalSaved)} chars, ${t.totalTokensSaved} tokens saved across ${t.compressionCount} blocks ${c.dim}(${sessionPct}% avg)${c.reset}${moneyInfo}`)
   }
 
   return lines.join('\n')
 }
 
+function fmtSize(n) {
+  if (n >= 1024) return (n / 1024).toFixed(1) + 'k'
+  return n + ''
+}
+
 export function createSession() {
   let totalSaved = 0
+  let totalOriginal = 0
   let totalTokensSaved = 0
   let compressionCount = 0
 
@@ -43,13 +74,14 @@ export function createSession() {
       for (const s of stats) {
         if (s.method && s.originalLen && s.compressedLen) {
           totalSaved += s.originalLen - s.compressedLen
+          totalOriginal += s.originalLen
           totalTokensSaved += (s.originalTokens || 0) - (s.compressedTokens || 0)
           compressionCount++
         }
       }
     },
     getTotals() {
-      return { totalSaved, totalTokensSaved, compressionCount }
+      return { totalSaved, totalOriginal, totalTokensSaved, compressionCount }
     },
   }
 }