@sliday/tamp 0.2.5 → 0.2.7

package/bin/tamp.js

@@ -1,12 +1,13 @@
 #!/usr/bin/env node
 import { createProxy } from '../index.js'
-import { existsSync } from 'node:fs'
+import { existsSync, readFileSync } from 'node:fs'
 import { spawn } from 'node:child_process'
 import { fileURLToPath } from 'node:url'
 import { dirname, join } from 'node:path'
 
 const __dirname = dirname(fileURLToPath(import.meta.url))
 const root = join(__dirname, '..')
+const pkg = JSON.parse(readFileSync(join(root, 'package.json'), 'utf-8'))
 
 // ANSI colors
 const c = {
@@ -28,7 +29,7 @@ function printBanner(config) {
   const url = `http://localhost:${config.port}`
 
   log('')
-  log(`  ${c.bold}${c.cyan}┌─ Tamp ─────────────────────────────────┐${c.reset}`)
+  log(`  ${c.bold}${c.cyan}┌─ Tamp ${c.dim}v${pkg.version}${c.reset}${c.bold}${c.cyan} ───────────────────────────────┐${c.reset}`)
   log(`  ${c.cyan}│${c.reset}  Proxy: ${c.bold}${c.green}${url}${c.reset}${c.cyan}              │${c.reset}`)
   log(`  ${c.cyan}│${c.reset}  Status: ${c.bgGreen}${c.bold} ● READY ${c.reset}${c.cyan}                    │${c.reset}`)
   log(`  ${c.cyan}│${c.reset}                                        ${c.cyan}│${c.reset}`)

package/index.js

@@ -1,6 +1,7 @@
 import http from 'node:http'
 import https from 'node:https'
 import zlib from 'node:zlib'
+import * as fzstd from 'fzstd'
 import { loadConfig } from './config.js'
 import { compressRequest } from './compress.js'
 import { detectProvider } from './providers.js'
@@ -139,21 +140,36 @@ return http.createServer(async (req, res) => {
   const headers = { ...req.headers }
   delete headers.host
 
-  // Decompress gzip/deflate/br if needed
+  // Decompress request body if content-encoding is set
   const encoding = (req.headers['content-encoding'] || '').toLowerCase()
   let textBody
+  let decompressed = false
   try {
     if (encoding === 'gzip') {
       textBody = zlib.gunzipSync(rawBody)
+      decompressed = true
     } else if (encoding === 'deflate') {
       textBody = zlib.inflateSync(rawBody)
+      decompressed = true
     } else if (encoding === 'br') {
       textBody = zlib.brotliDecompressSync(rawBody)
+      decompressed = true
+    } else if (encoding === 'zstd') {
+      textBody = Buffer.from(fzstd.decompress(new Uint8Array(rawBody)))
+      decompressed = true
+    } else if (encoding && encoding !== 'identity') {
+      // Unknown encoding — can't decompress, passthrough as-is
+      if (config.log) console.error(`[tamp] passthrough (unsupported encoding: ${encoding})`)
+      forwardRequest(req.method, upstreamUrl, headers, rawBody, res)
+      return
     } else {
       textBody = rawBody
     }
   } catch {
-    textBody = rawBody
+    // Decompression failed — passthrough original body
+    if (config.log) console.error(`[tamp] passthrough (decompression failed)`)
+    forwardRequest(req.method, upstreamUrl, headers, rawBody, res)
+    return
   }
 
   try {
@@ -161,11 +177,11 @@ return http.createServer(async (req, res) => {
     const { body, stats } = await compressRequest(parsed, config, provider)
     finalBody = Buffer.from(JSON.stringify(body), 'utf-8')
     // Send uncompressed — simpler and content-length is accurate
-    delete headers['content-encoding']
+    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))
     }
   } 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.5",
+  "version": "0.2.7",
   "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",
@@ -39,6 +39,7 @@
   "homepage": "https://github.com/sliday/tamp",
   "dependencies": {
     "@anthropic-ai/tokenizer": "^0.0.4",
-    "@toon-format/toon": "^2.1.0"
+    "@toon-format/toon": "^2.1.0",
+    "fzstd": "^0.1.1"
   }
 }

package/stats.js

@@ -1,40 +1,68 @@
-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) {
   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'
+    lines.push(`[tamp]   ${c.magenta}session${c.reset} ${fmtSize(t.totalSaved)} saved across ${t.compressionCount} blocks ${c.dim}(${sessionPct}% avg)${c.reset}`)
   }
 
   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 +71,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 }
     },
   }
 }