@sliday/tamp 0.2.1 → 0.2.3

package/README.md

@@ -44,7 +44,7 @@ Gemini CLI ────►          │          ──► Google AI API
 | `toon` | Columnar [TOON encoding](https://github.com/nicholasgasior/toon-format) | Homogeneous arrays (file listings, routes, deps) |
 | `llmlingua` | Neural text compression via [LLMLingua](https://github.com/microsoft/LLMLingua) sidecar | Natural language text (requires sidecar) |
 
-Only `minify` is enabled by default. Enable more with `TOONA_STAGES=minify,toon`.
+`minify` and `toon` are enabled by default. Add LLMLingua with `TAMP_STAGES=minify,toon,llmlingua`.
 
 ## Quick Start
 
@@ -92,22 +92,22 @@ All configuration via environment variables:
 
 | Variable | Default | Description |
 |----------|---------|-------------|
-| `TOONA_PORT` | `7778` | Proxy listen port |
-| `TOONA_UPSTREAM` | `https://api.anthropic.com` | Default upstream API URL |
-| `TOONA_UPSTREAM_OPENAI` | `https://api.openai.com` | Upstream for OpenAI-format requests |
-| `TOONA_UPSTREAM_GEMINI` | `https://generativelanguage.googleapis.com` | Upstream for Gemini-format requests |
-| `TOONA_STAGES` | `minify` | Comma-separated compression stages |
-| `TOONA_MIN_SIZE` | `200` | Minimum content size (chars) to attempt compression |
-| `TOONA_LOG` | `true` | Enable request logging to stderr |
-| `TOONA_LOG_FILE` | _(none)_ | Write logs to file |
-| `TOONA_MAX_BODY` | `10485760` | Max request body size (bytes) before passthrough |
-| `TOONA_LLMLINGUA_URL` | _(none)_ | LLMLingua sidecar URL for text compression |
+| `TAMP_PORT` | `7778` | Proxy listen port |
+| `TAMP_UPSTREAM` | `https://api.anthropic.com` | Default upstream API URL |
+| `TAMP_UPSTREAM_OPENAI` | `https://api.openai.com` | Upstream for OpenAI-format requests |
+| `TAMP_UPSTREAM_GEMINI` | `https://generativelanguage.googleapis.com` | Upstream for Gemini-format requests |
+| `TAMP_STAGES` | `minify` | Comma-separated compression stages |
+| `TAMP_MIN_SIZE` | `200` | Minimum content size (chars) to attempt compression |
+| `TAMP_LOG` | `true` | Enable request logging to stderr |
+| `TAMP_LOG_FILE` | _(none)_ | Write logs to file |
+| `TAMP_MAX_BODY` | `10485760` | Max request body size (bytes) before passthrough |
+| `TAMP_LLMLINGUA_URL` | _(none)_ | LLMLingua sidecar URL for text compression |
 
 ### Recommended setup
 
 ```bash
 # Maximum compression
-TOONA_STAGES=minify,toon npx @sliday/tamp
+TAMP_STAGES=minify,toon,llmlingua TAMP_LLMLINGUA_URL=http://localhost:8788 npx @sliday/tamp
 ```
 
 ## Installation Methods
@@ -177,7 +177,7 @@ setup.sh             One-line installer script
 5. The modified body is forwarded to the correct upstream with updated `Content-Length`
 6. The upstream response is streamed back to the client unmodified
 
-Bodies exceeding `TOONA_MAX_BODY` are piped through without buffering.
+Bodies exceeding `TAMP_MAX_BODY` are piped through without buffering.
 
 ## Benchmarking
 

package/bin/tamp.js

@@ -1,26 +1,112 @@
 #!/usr/bin/env node
 import { createProxy } from '../index.js'
+import { existsSync } from 'node:fs'
+import { spawn } from 'node:child_process'
+import { fileURLToPath } from 'node:url'
+import { dirname, join } from 'node:path'
 
-const { config, server } = createProxy()
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const root = join(__dirname, '..')
 
-server.listen(config.port, () => {
+// ANSI colors
+const c = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  dim: '\x1b[2m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  magenta: '\x1b[35m',
+  cyan: '\x1b[36m',
+  bgGreen: '\x1b[42m',
+  bgYellow: '\x1b[43m',
+}
+
+function log(msg = '') { console.error(msg) }
+
+function printBanner(config) {
   const url = `http://localhost:${config.port}`
-  console.error('')
-  console.error('  ┌─ Tamp ─────────────────────────────────┐')
-  console.error(`  │  Proxy: ${url}              │`)
-  console.error('  │  Status: ● Ready                       │')
-  console.error('  │                                        │')
-  console.error('  │  Claude Code:                          │')
-  console.error(`  │    ANTHROPIC_BASE_URL=${url}  │`)
-  console.error('  │                                        │')
-  console.error('  │  Aider / Cursor / Cline:               │')
-  console.error(`  │    OPENAI_BASE_URL=${url}     │`)
-  console.error('  └────────────────────────────────────────┘')
-  console.error('')
-  console.error(`  Upstreams:`)
-  console.error(`    anthropic → ${config.upstreams.anthropic}`)
-  console.error(`    openai    → ${config.upstreams.openai}`)
-  console.error(`    gemini    → ${config.upstreams.gemini}`)
-  console.error(`  Stages: ${config.stages.join(', ')}`)
-  console.error('')
+
+  log('')
+  log(`  ${c.bold}${c.cyan}┌─ Tamp ─────────────────────────────────┐${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}`)
+  log(`  ${c.cyan}│${c.reset}  ${c.bold}Claude Code:${c.reset}                          ${c.cyan}│${c.reset}`)
+  log(`  ${c.cyan}│${c.reset}    ${c.dim}ANTHROPIC_BASE_URL=${c.reset}${c.yellow}${url}${c.reset}  ${c.cyan}│${c.reset}`)
+  log(`  ${c.cyan}│${c.reset}                                        ${c.cyan}│${c.reset}`)
+  log(`  ${c.cyan}│${c.reset}  ${c.bold}Aider / Cursor / Cline:${c.reset}               ${c.cyan}│${c.reset}`)
+  log(`  ${c.cyan}│${c.reset}    ${c.dim}OPENAI_BASE_URL=${c.reset}${c.yellow}${url}${c.reset}     ${c.cyan}│${c.reset}`)
+  log(`  ${c.cyan}└────────────────────────────────────────┘${c.reset}`)
+  log('')
+
+  log(`  ${c.bold}Upstreams:${c.reset}`)
+  log(`    ${c.magenta}anthropic${c.reset} → ${c.dim}${config.upstreams.anthropic}${c.reset}`)
+  log(`    ${c.magenta}openai${c.reset}    → ${c.dim}${config.upstreams.openai}${c.reset}`)
+  log(`    ${c.magenta}gemini${c.reset}    → ${c.dim}${config.upstreams.gemini}${c.reset}`)
+  log('')
+
+  log(`  ${c.bold}Compression:${c.reset}`)
+  for (const stage of config.stages) {
+    const icon = stage === 'llmlingua' ? `${c.green}▸${c.reset}` : `${c.green}▸${c.reset}`
+    const label = stage === 'minify' ? 'JSON whitespace removal'
+      : stage === 'toon' ? 'TOON columnar encoding'
+      : stage === 'llmlingua' ? `LLMLingua-2 neural compression ${c.dim}(${config.llmLinguaUrl})${c.reset}`
+      : stage
+    log(`    ${icon} ${c.cyan}${stage}${c.reset} — ${label}`)
+  }
+  log('')
+}
+
+// --- Auto-start LLMLingua-2 sidecar if needed ---
+let { config: finalConfig, server: finalServer } = createProxy()
+
+const needsSidecar = finalConfig.stages.includes('llmlingua') && !finalConfig.llmLinguaUrl
+const venvPython = join(root, 'sidecar', '.venv', 'bin', 'python')
+const serverPy = join(root, 'sidecar', 'server.py')
+const hasSidecar = existsSync(venvPython) && existsSync(serverPy)
+
+if (needsSidecar && hasSidecar) {
+  const sidecarPort = 8788
+  process.env.TAMP_LLMLINGUA_URL = `http://localhost:${sidecarPort}`
+  const refreshed = createProxy()
+  finalConfig = refreshed.config
+  finalServer = refreshed.server
+
+  log('')
+  log(`  ${c.yellow}→${c.reset} Starting LLMLingua-2 sidecar ...`)
+
+  const sidecar = spawn(venvPython, ['-m', 'uvicorn', 'server:app', '--host', '127.0.0.1', '--port', String(sidecarPort)], {
+    cwd: join(root, 'sidecar'),
+    stdio: ['ignore', 'pipe', 'pipe'],
+  })
+
+  let ready = false
+  sidecar.stderr.on('data', (d) => {
+    const line = d.toString()
+    if (!ready && line.includes('Uvicorn running')) {
+      ready = true
+      log(`  ${c.green}✓${c.reset} LLMLingua-2 sidecar ready on ${c.bold}port ${sidecarPort}${c.reset}`)
+    }
+  })
+
+  sidecar.on('exit', (code) => {
+    if (code !== null && code !== 0) {
+      log(`  ${c.yellow}✗${c.reset} LLMLingua-2 sidecar exited (code ${code})`)
+    }
+  })
+
+  process.on('exit', () => { sidecar?.kill() })
+  process.on('SIGINT', () => { sidecar?.kill(); process.exit() })
+  process.on('SIGTERM', () => { sidecar?.kill(); process.exit() })
+} else if (needsSidecar && !hasSidecar) {
+  log('')
+  log(`  ${c.yellow}✗${c.reset} LLMLingua-2 sidecar not installed`)
+  log(`    Run: ${c.cyan}curl -fsSL tamp.dev/setup.sh | bash${c.reset}`)
+}
+
+const { config: cfg, server: srv } = { config: finalConfig, server: finalServer }
+
+srv.listen(cfg.port, () => {
+  printBanner(cfg)
 })

package/config.js

@@ -1,19 +1,19 @@
 export function loadConfig(env = process.env) {
-  const stages = (env.TOONA_STAGES || 'minify').split(',').map(s => s.trim()).filter(Boolean)
+  const stages = (env.TAMP_STAGES || 'minify,toon').split(',').map(s => s.trim()).filter(Boolean)
   return Object.freeze({
-    port: parseInt(env.TOONA_PORT, 10) || 7778,
-    upstream: env.TOONA_UPSTREAM || 'https://api.anthropic.com',
+    port: parseInt(env.TAMP_PORT, 10) || 7778,
+    upstream: env.TAMP_UPSTREAM || 'https://api.anthropic.com',
     upstreams: Object.freeze({
-      anthropic: env.TOONA_UPSTREAM || 'https://api.anthropic.com',
-      openai: env.TOONA_UPSTREAM_OPENAI || 'https://api.openai.com',
-      gemini: env.TOONA_UPSTREAM_GEMINI || 'https://generativelanguage.googleapis.com',
+      anthropic: env.TAMP_UPSTREAM || 'https://api.anthropic.com',
+      openai: env.TAMP_UPSTREAM_OPENAI || 'https://api.openai.com',
+      gemini: env.TAMP_UPSTREAM_GEMINI || 'https://generativelanguage.googleapis.com',
     }),
-    minSize: parseInt(env.TOONA_MIN_SIZE, 10) || 200,
+    minSize: parseInt(env.TAMP_MIN_SIZE, 10) || 200,
     stages,
-    log: env.TOONA_LOG !== 'false',
-    logFile: env.TOONA_LOG_FILE || null,
-    maxBody: parseInt(env.TOONA_MAX_BODY, 10) || 10_485_760,
+    log: env.TAMP_LOG !== 'false',
+    logFile: env.TAMP_LOG_FILE || null,
+    maxBody: parseInt(env.TAMP_MAX_BODY, 10) || 10_485_760,
     cacheSafe: true,
-    llmLinguaUrl: env.TOONA_LLMLINGUA_URL || null,
+    llmLinguaUrl: env.TAMP_LLMLINGUA_URL || null,
   })
 }

package/index.js

@@ -30,16 +30,25 @@ function forwardRequest(method, upstreamUrl, headers, body, res) {
   const upstream = mod.request(opts, (upstreamRes) => {
     res.writeHead(upstreamRes.statusCode, upstreamRes.headers)
     upstreamRes.pipe(res)
+    upstreamRes.on('error', (err) => {
+      console.error(`[tamp] response stream error: ${err.code || ''} ${err.message}`)
+      res.destroy()
+    })
   })
 
   upstream.on('error', (err) => {
-    console.error(`[tamp] upstream error: ${err.message}`)
+    console.error(`[tamp] upstream error: ${err.code || ''} ${err.message}`)
     if (!res.headersSent) {
       res.writeHead(502, { 'Content-Type': 'application/json' })
     }
     res.end(JSON.stringify({ error: 'upstream_error', message: err.message }))
   })
 
+  res.on('error', (err) => {
+    console.error(`[tamp] client disconnect: ${err.code || ''} ${err.message}`)
+    upstream.destroy()
+  })
+
   if (body) {
     upstream.end(body)
   } else {
@@ -65,16 +74,25 @@ function pipeRequest(req, res, upstreamUrl, prefixChunks) {
   const upstream = mod.request(opts, (upstreamRes) => {
     res.writeHead(upstreamRes.statusCode, upstreamRes.headers)
     upstreamRes.pipe(res)
+    upstreamRes.on('error', (err) => {
+      console.error(`[tamp] response stream error: ${err.code || ''} ${err.message}`)
+      res.destroy()
+    })
   })
 
   upstream.on('error', (err) => {
-    console.error(`[tamp] upstream error: ${err.message}`)
+    console.error(`[tamp] upstream error: ${err.code || ''} ${err.message}`)
     if (!res.headersSent) {
       res.writeHead(502, { 'Content-Type': 'application/json' })
     }
     res.end(JSON.stringify({ error: 'upstream_error', message: err.message }))
   })
 
+  res.on('error', (err) => {
+    console.error(`[tamp] client disconnect: ${err.code || ''} ${err.message}`)
+    upstream.destroy()
+  })
+
   if (prefixChunks) {
     for (const chunk of prefixChunks) {
       upstream.write(chunk)

package/package.json

@@ -9,7 +9,7 @@
     "providers.js",
     "stats.js"
   ],
-  "version": "0.2.1",
+  "version": "0.2.3",
   "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

@@ -3,15 +3,15 @@ export function formatRequestLog(stats, session, providerName, url) {
   const skipped = stats.filter(s => s.skipped)
   const label = providerName || 'anthropic'
   const path = url || '/v1/messages'
-  const lines = [`[toona] ${label} ${path} — ${stats.length} blocks, ${compressed.length} compressed`]
+  const lines = [`[tamp] ${label} ${path} — ${stats.length} blocks, ${compressed.length} compressed`]
 
   for (const s of stats) {
     if (s.skipped) {
-      lines.push(`[toona]   block[${s.index}]: skipped (${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(`[toona]   block[${s.index}]: ${s.originalLen}->${s.compressedLen} chars (-${pct}%)${tokInfo} [${s.method}]`)
+      lines.push(`[tamp]   block[${s.index}]: ${s.originalLen}->${s.compressedLen} chars (-${pct}%)${tokInfo} [${s.method}]`)
     }
   }
 
@@ -22,12 +22,12 @@ export function formatRequestLog(stats, session, providerName, url) {
   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(`[toona]   total: ${totalOrig}->${totalComp} chars (-${pct}%), ${totalOrigTok}->${totalCompTok} tokens (-${tokPct}%)`)
+    lines.push(`[tamp]   total: ${totalOrig}->${totalComp} chars (-${pct}%), ${totalOrigTok}->${totalCompTok} tokens (-${tokPct}%)`)
   }
 
   if (session) {
     const totals = session.getTotals()
-    lines.push(`[toona]   session: ${totals.totalSaved} chars, ${totals.totalTokensSaved} tokens saved across ${totals.compressionCount} compressions`)
+    lines.push(`[tamp]   session: ${totals.totalSaved} chars, ${totals.totalTokensSaved} tokens saved across ${totals.compressionCount} compressions`)
   }
 
   return lines.join('\n')