@sliday/tamp 0.1.0

package/bin/tamp.js

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+import { createProxy } from '../index.js'
+
+const { config, server } = createProxy()
+
+server.listen(config.port, () => {
+  console.error('')
+  console.error('  ┌─ Tamp ─────────────────────────────┐')
+  console.error(`  │  Proxy: http://localhost:${config.port}      │`)
+  console.error('  │  Status: ● Ready                   │')
+  console.error('  │                                    │')
+  console.error('  │  In another terminal:              │')
+  console.error(`  │  export ANTHROPIC_BASE_URL=http://localhost:${config.port}`)
+  console.error('  │  claude                            │')
+  console.error('  └────────────────────────────────────┘')
+  console.error('')
+  console.error(`  Upstream: ${config.upstream}`)
+  console.error(`  Stages: ${config.stages.join(', ')}`)
+  console.error('')
+})

package/compress.js

@@ -0,0 +1,114 @@
+import { encode } from '@toon-format/toon'
+import { tryParseJSON, classifyContent, stripLineNumbers } from './detect.js'
+
+export function compressText(text, config) {
+  if (text.length < config.minSize) return null
+  const cls = classifyContent(text)
+  if (cls === 'toon') return null
+  if (cls === 'text') {
+    if (config.stages.includes('llmlingua') && config.llmLinguaUrl) {
+      return { async: true, text, cls }
+    }
+    return null
+  }
+  if (cls !== 'json' && cls !== 'json-lined') return null
+
+  const raw = cls === 'json-lined' ? stripLineNumbers(text) : text
+  const { ok, value } = tryParseJSON(raw)
+  if (!ok) return null
+
+  const minified = JSON.stringify(value)
+  if (minified.length >= text.length) return null
+
+  let best = { text: minified, method: 'minify' }
+
+  if (config.stages.includes('toon')) {
+    try {
+      const tooned = encode(value)
+      if (tooned.length < best.text.length) {
+        best = { text: tooned, method: 'toon' }
+      }
+    } catch { /* fall back to minified */ }
+  }
+
+  return { text: best.text, method: best.method, originalLen: text.length, compressedLen: best.text.length }
+}
+
+async function compressWithLLMLingua(text, config) {
+  try {
+    const controller = new AbortController()
+    const timeout = setTimeout(() => controller.abort(), 5000)
+    const res = await fetch(config.llmLinguaUrl + '/compress', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ text, rate: 0.5 }),
+      signal: controller.signal,
+    })
+    clearTimeout(timeout)
+    if (!res.ok) return null
+    const data = await res.json()
+    return { text: data.text, method: 'llmlingua', originalLen: text.length, compressedLen: data.text.length }
+  } catch {
+    return null
+  }
+}
+
+async function compressBlock(text, config) {
+  const sync = compressText(text, config)
+  if (sync && sync.async) {
+    return compressWithLLMLingua(text, config)
+  }
+  return sync
+}
+
+export async function compressMessages(body, config) {
+  const stats = []
+  if (!body?.messages?.length) return { body, stats }
+
+  let lastUserIdx = -1
+  for (let i = body.messages.length - 1; i >= 0; i--) {
+    if (body.messages[i].role === 'user') { lastUserIdx = i; break }
+  }
+  if (lastUserIdx === -1) return { body, stats }
+
+  const msg = body.messages[lastUserIdx]
+  const debug = config.log
+
+  if (typeof msg.content === 'string') {
+    const result = await compressBlock(msg.content, config)
+    if (result) {
+      msg.content = result.text
+      stats.push({ index: lastUserIdx, ...result })
+    }
+  } else if (Array.isArray(msg.content)) {
+    for (let i = 0; i < msg.content.length; i++) {
+      const block = msg.content[i]
+      if (block.type !== 'tool_result') continue
+      if (block.is_error) { stats.push({ index: i, skipped: 'error' }); continue }
+
+      if (typeof block.content === 'string') {
+        if (debug) {
+          const cls = classifyContent(block.content)
+          const len = block.content.length
+          console.error(`[toona] debug block[${i}]: type=${cls} len=${len} tool_use_id=${block.tool_use_id || '?'}`)
+        }
+        const result = await compressBlock(block.content, config)
+        if (result) { block.content = result.text; stats.push({ index: i, ...result }) }
+      } else if (Array.isArray(block.content)) {
+        for (const sub of block.content) {
+          if (sub.type === 'text') {
+            if (debug) {
+              const cls = classifyContent(sub.text)
+              const len = sub.text.length
+              console.error(`[toona] debug sub-block: type=${cls} len=${len}`)
+            }
+            const result = await compressBlock(sub.text, config)
+            if (result) { sub.text = result.text; stats.push({ index: i, ...result }) }
+          }
+        }
+      }
+    }
+  }
+
+  return { body, stats }
+}

package/config.js

@@ -0,0 +1,14 @@
+export function loadConfig(env = process.env) {
+  const stages = (env.TOONA_STAGES || 'minify').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',
+    minSize: parseInt(env.TOONA_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,
+    cacheSafe: true,
+    llmLinguaUrl: env.TOONA_LLMLINGUA_URL || null,
+  })
+}

package/detect.js

@@ -0,0 +1,43 @@
+const LINE_NUM_RE = /^ *\d+[\t→]/
+
+export function stripLineNumbers(str) {
+  if (typeof str !== 'string') return str
+  const lines = str.split('\n')
+  if (lines.length < 2) return str
+  // Check first 3 non-empty lines for line number pattern
+  let matches = 0
+  for (const line of lines.slice(0, 5)) {
+    if (line.length === 0) continue
+    if (LINE_NUM_RE.test(line)) matches++
+  }
+  if (matches < 2) return str
+  return lines.map(l => l.replace(LINE_NUM_RE, '')).join('\n')
+}
+
+export function tryParseJSON(str) {
+  if (typeof str !== 'string' || str.length === 0) return { ok: false }
+  try {
+    const value = JSON.parse(str)
+    return { ok: true, value }
+  } catch {
+    return { ok: false }
+  }
+}
+
+export function isTOON(str) {
+  if (typeof str !== 'string') return false
+  const firstLine = str.trimStart().split('\n')[0]
+  return /^\[TOON\]/.test(firstLine) || /\w+\[\d+\]\{/.test(firstLine) || /\w+\[\d+\]:/.test(firstLine)
+}
+
+export function classifyContent(str) {
+  if (typeof str !== 'string') return 'unknown'
+  if (isTOON(str)) return 'toon'
+  const { ok } = tryParseJSON(str)
+  if (ok) return 'json'
+  // Try stripping line numbers (e.g. Read tool output)
+  const stripped = stripLineNumbers(str)
+  if (stripped !== str && tryParseJSON(stripped).ok) return 'json-lined'
+  if (str.length > 0) return 'text'
+  return 'unknown'
+}

package/index.js

@@ -0,0 +1,144 @@
+import http from 'node:http'
+import https from 'node:https'
+import { loadConfig } from './config.js'
+import { compressMessages } from './compress.js'
+import { createSession, formatRequestLog } from './stats.js'
+
+export function createProxy(overrides = {}) {
+  const config = { ...loadConfig(), ...overrides }
+  const session = createSession()
+  return { config, session, server: _createServer(config, session) }
+}
+
+function _createServer(config, session) {
+
+function forwardRequest(method, upstreamUrl, headers, body, res) {
+  const mod = upstreamUrl.protocol === 'https:' ? https : http
+  const opts = {
+    hostname: upstreamUrl.hostname,
+    port: upstreamUrl.port,
+    path: upstreamUrl.pathname + upstreamUrl.search,
+    method,
+    headers,
+  }
+
+  const upstream = mod.request(opts, (upstreamRes) => {
+    res.writeHead(upstreamRes.statusCode, upstreamRes.headers)
+    upstreamRes.pipe(res)
+  })
+
+  upstream.on('error', (err) => {
+    console.error(`[tamp] upstream error: ${err.message}`)
+    if (!res.headersSent) {
+      res.writeHead(502, { 'Content-Type': 'application/json' })
+    }
+    res.end(JSON.stringify({ error: 'upstream_error', message: err.message }))
+  })
+
+  if (body) {
+    upstream.end(body)
+  } else {
+    upstream.end()
+  }
+
+  return upstream
+}
+
+function pipeRequest(req, res, upstreamUrl, prefixChunks) {
+  const mod = upstreamUrl.protocol === 'https:' ? https : http
+  const headers = { ...req.headers }
+  delete headers.host
+
+  const opts = {
+    hostname: upstreamUrl.hostname,
+    port: upstreamUrl.port,
+    path: upstreamUrl.pathname + upstreamUrl.search,
+    method: req.method,
+    headers,
+  }
+
+  const upstream = mod.request(opts, (upstreamRes) => {
+    res.writeHead(upstreamRes.statusCode, upstreamRes.headers)
+    upstreamRes.pipe(res)
+  })
+
+  upstream.on('error', (err) => {
+    console.error(`[tamp] upstream error: ${err.message}`)
+    if (!res.headersSent) {
+      res.writeHead(502, { 'Content-Type': 'application/json' })
+    }
+    res.end(JSON.stringify({ error: 'upstream_error', message: err.message }))
+  })
+
+  if (prefixChunks) {
+    for (const chunk of prefixChunks) {
+      upstream.write(chunk)
+    }
+  }
+
+  req.pipe(upstream)
+}
+
+return http.createServer(async (req, res) => {
+  if (config.log) console.error(`[tamp] ${req.method} ${req.url}`)
+  const upstreamUrl = new URL(req.url, config.upstream)
+  const isMessages = req.method === 'POST' && req.url.startsWith('/v1/messages')
+
+  if (!isMessages) {
+    return pipeRequest(req, res, upstreamUrl)
+  }
+
+  const chunks = []
+  let size = 0
+  let overflow = false
+
+  for await (const chunk of req) {
+    size += chunk.length
+    chunks.push(chunk)
+    if (size > config.maxBody) {
+      overflow = true
+      break
+    }
+  }
+
+  if (overflow) {
+    if (config.log) console.error('[tamp] passthrough (body too large)')
+    return pipeRequest(req, res, upstreamUrl, chunks)
+  }
+
+  const rawBody = Buffer.concat(chunks)
+  let finalBody = rawBody
+  const headers = { ...req.headers }
+  delete headers.host
+
+  try {
+    const parsed = JSON.parse(rawBody.toString('utf-8'))
+    const { body, stats } = await compressMessages(parsed, config)
+    finalBody = Buffer.from(JSON.stringify(body), 'utf-8')
+
+    if (config.log && stats.length) {
+      session.record(stats)
+      console.error(formatRequestLog(stats, session))
+    }
+  } catch (err) {
+    if (config.log) console.error(`[tamp] passthrough (parse error): ${err.message}`)
+    finalBody = rawBody
+  }
+
+  headers['content-length'] = Buffer.byteLength(finalBody)
+  delete headers['transfer-encoding']
+
+  forwardRequest(req.method, upstreamUrl, headers, finalBody, res)
+})
+}
+
+const isMain = !process.argv[1]?.includes('node_modules') && process.argv[1] === new URL(import.meta.url).pathname
+
+if (isMain) {
+  const { config, server } = createProxy()
+  server.listen(config.port, () => {
+    console.error(`[tamp] proxy listening on http://localhost:${config.port}`)
+    console.error(`[tamp] upstream: ${config.upstream}`)
+    console.error(`[tamp] stages: ${config.stages.join(', ')}`)
+  })
+}

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@sliday/tamp",
+  "files": [
+    "index.js",
+    "bin/",
+    "compress.js",
+    "config.js",
+    "detect.js",
+    "stats.js"
+  ],
+  "version": "0.1.0",
+  "description": "Token compression proxy for Claude Code. 50% fewer tokens, zero behavior change.",
+  "type": "module",
+  "main": "index.js",
+  "bin": {
+    "tamp": "./bin/tamp.js"
+  },
+  "scripts": {
+    "start": "node bin/tamp.js",
+    "test": "node --test test/*.test.js"
+  },
+  "keywords": ["claude", "anthropic", "proxy", "compression", "tokens", "llm"],
+  "author": "Stas Kulesh <stas@sliday.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/sliday/tamp"
+  },
+  "homepage": "https://github.com/sliday/tamp",
+  "dependencies": {
+    "@toon-format/toon": "^2.1.0"
+  }
+}

package/stats.js

@@ -0,0 +1,47 @@
+export function formatRequestLog(stats, session) {
+  const compressed = stats.filter(s => s.method)
+  const skipped = stats.filter(s => s.skipped)
+  const lines = [`[toona] POST /v1/messages — ${stats.length} blocks, ${compressed.length} compressed`]
+
+  for (const s of stats) {
+    if (s.skipped) {
+      lines.push(`[toona]   block[${s.index}]: skipped (${s.skipped})`)
+    } else if (s.method) {
+      const pct = (((s.originalLen - s.compressedLen) / s.originalLen) * 100).toFixed(1)
+      lines.push(`[toona]   block[${s.index}]: ${s.originalLen}->${s.compressedLen} chars (-${pct}%) [${s.method}]`)
+    }
+  }
+
+  const totalOrig = compressed.reduce((a, s) => a + s.originalLen, 0)
+  const totalComp = compressed.reduce((a, s) => a + s.compressedLen, 0)
+  if (compressed.length > 0) {
+    const pct = (((totalOrig - totalComp) / totalOrig) * 100).toFixed(1)
+    lines.push(`[toona]   total: ${totalOrig}->${totalComp} chars (-${pct}%)`)
+  }
+
+  if (session) {
+    const totals = session.getTotals()
+    lines.push(`[toona]   session: ${totals.totalSaved} chars saved across ${totals.compressionCount} compressions`)
+  }
+
+  return lines.join('\n')
+}
+
+export function createSession() {
+  let totalSaved = 0
+  let compressionCount = 0
+
+  return {
+    record(stats) {
+      for (const s of stats) {
+        if (s.method && s.originalLen && s.compressedLen) {
+          totalSaved += s.originalLen - s.compressedLen
+          compressionCount++
+        }
+      }
+    },
+    getTotals() {
+      return { totalSaved, compressionCount }
+    },
+  }
+}