squeezr-ai 1.81.2 → 1.99.2

package/bin/squeezr.js

@@ -5,7 +5,7 @@ import http from 'http'
 import path from 'path'
 import fs from 'fs'
 import os from 'os'
-import { fileURLToPath } from 'url'
+import { fileURLToPath, pathToFileURL } from 'url'
 import { createRequire } from 'module'
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url))
@@ -250,8 +250,14 @@ Usage:
   squeezr gain             Show token savings stats
   squeezr gain --reset     Reset saved stats
   squeezr discover         Show pattern coverage report (proxy must be running)
+  squeezr learn            Mine Claude Code sessions for token-wasting loops
+  squeezr learn --apply    Write the learned rules to ./CLAUDE.local.md
+  squeezr bench            Run the compression + fact-recall benchmark
   squeezr status           Check if proxy is running
+  squeezr doctor           Diagnose proxy/version/routing/bypass (exit 0/1/2)
   squeezr config           Print config file path and current settings
+  squeezr rc [args...]     Launch 'claude --rc' (Remote Control) direct to api.anthropic.com
+                           (proxy bypassed for that session — Claude Code requires it)
   squeezr mcp install      Register Squeezr MCP server in Claude Code, Cursor, Windsurf & Cline
   squeezr mcp uninstall    Remove Squeezr MCP registration
   squeezr ports            Change HTTP and MITM proxy ports
@@ -284,6 +290,47 @@ function runNode(script, extraArgs = []) {
   child.on('exit', code => process.exit(code ?? 0))
 }
 
+// Launch Claude Code with Remote Control, bypassing the Squeezr proxy for THIS
+// session only. Claude Code refuses Remote Control unless it talks DIRECTLY to
+// api.anthropic.com — the binary guard is literally "Remote Control is only
+// available when using Claude via api.anthropic.com." Squeezr's terminal setup
+// exports ANTHROPIC_BASE_URL=http://localhost:<port>, which is not that host, so
+// `claude --rc` errors out. We strip that var (and the MITM CA) from the CHILD
+// env only. Global config is untouched: every other `claude` session still routes
+// through Squeezr and compresses normally. Trade-off: this remote session is not
+// compressed — remote sessions are short/interactive, so that's the right call.
+function claudeRc(extraArgs) {
+  const env = { ...process.env }
+  delete env.ANTHROPIC_BASE_URL
+  delete env.anthropic_base_url
+  delete env.NODE_EXTRA_CA_CERTS   // Squeezr's MITM CA — irrelevant talking direct
+
+  // Ensure --rc / --remote-control is present exactly once, then pass the rest through.
+  const rest = extraArgs.filter(a => a !== 'rc' && a !== 'remote-control')
+  const hasRc = rest.some(a => a === '--rc' || a === '--remote-control')
+  const claudeArgs = hasRc ? rest : ['--rc', ...rest]
+
+  console.log('Launching Claude Code with Remote Control — direct to api.anthropic.com')
+  console.log('(Squeezr proxy bypassed for THIS session only; global config untouched).\n')
+
+  // Never resolves — the child owns the terminal (stdio inherited) and we exit the
+  // wrapper with the child's code. Awaiting this blocks the trailing update banner
+  // from printing over Claude's interactive UI.
+  return new Promise(() => {
+    const child = spawn('claude', claudeArgs, {
+      stdio: 'inherit',
+      env,
+      shell: process.platform === 'win32',  // resolve claude.exe via PATH on Windows
+    })
+    child.on('exit', code => process.exit(code ?? 0))
+    child.on('error', err => {
+      console.error(`\nFailed to launch claude: ${err.message}`)
+      console.error('Is Claude Code installed and on your PATH? Try running `claude --version`.')
+      process.exit(1)
+    })
+  })
+}
+
 async function startDaemon() {
   const distIndex = path.join(ROOT, 'dist', 'index.js')
   if (!fs.existsSync(distIndex)) {
@@ -2504,6 +2551,11 @@ switch (command) {
     showConfig()
     break
 
+  case 'rc':
+  case 'remote-control':
+    await claudeRc(args.slice(1))
+    break
+
   case 'mcp': {
     const subCmd = args[1] ?? 'install'
     if (subCmd === 'uninstall') await mcpUninstall()
@@ -2514,6 +2566,35 @@ case 'zest':
     await installZest()
     break
 
+  case 'doctor': {
+    const { runDoctor } = await import(pathToFileURL(path.join(ROOT, 'dist', 'doctor.js')).href)
+    const res = await runDoctor()
+    console.log(res.report)
+    if (command !== 'update') await showUpdateBanner()
+    process.exit(res.exitCode)
+    break
+  }
+
+  case 'bench': {
+    const { runBench, formatBench } = await import(pathToFileURL(path.join(ROOT, 'dist', 'bench.js')).href)
+    console.log(formatBench(runBench()))
+    break
+  }
+
+  case 'learn': {
+    const apply = args.includes('--apply')
+    const tIdx = args.indexOf('--target')
+    const targetFile = tIdx >= 0 ? args[tIdx + 1] : undefined
+    const { runLearn } = await import(pathToFileURL(path.join(ROOT, 'dist', 'learn.js')).href)
+    const res = runLearn({ apply, targetFile })
+    console.log(res.report)
+    if (res.loops.length > 0) {
+      if (res.applied) console.log(`\nWrote ${res.loops.length} rule(s) to ${res.targetFile}`)
+      else console.log(`\nDry run. Re-run with --apply to write these rules to ${res.targetFile}.`)
+    }
+    break
+  }
+
   case 'version':
   case '--version':
   case '-v':

package/dist/__tests__/bench.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/bench.test.js

@@ -0,0 +1,55 @@
+import { describe, it, expect } from 'vitest';
+import { factRecall, runBench, FIXTURES } from '../bench.js';
+describe('factRecall', () => {
+    it('returns 1 when every fact is present verbatim', () => {
+        expect(factRecall('error E123 in file foo.ts at line 42', ['E123', 'foo.ts', '42'])).toBe(1);
+    });
+    it('returns the fraction present', () => {
+        expect(factRecall('only E123 here', ['E123', 'MISSING'])).toBe(0.5);
+    });
+    it('returns 1 for an empty fact list (nothing to lose)', () => {
+        expect(factRecall('whatever', [])).toBe(1);
+    });
+});
+describe('FIXTURES', () => {
+    it('every fixture declares its critical facts', () => {
+        expect(FIXTURES.length).toBeGreaterThan(0);
+        for (const f of FIXTURES) {
+            expect(f.facts.length).toBeGreaterThan(0);
+            // sanity: the facts must actually be in the original content
+            for (const fact of f.facts)
+                expect(f.content.includes(fact)).toBe(true);
+        }
+    });
+});
+describe('runBench', () => {
+    it('produces a row per fixture with a valid shape', () => {
+        const summary = runBench();
+        expect(summary.rows.length).toBe(FIXTURES.length);
+        for (const r of summary.rows) {
+            expect(r.originalChars).toBeGreaterThan(0);
+            expect(r.compressedChars).toBeGreaterThan(0);
+            expect(r.compressionPct).toBeGreaterThanOrEqual(0);
+            expect(r.inlineRecall).toBeGreaterThanOrEqual(0);
+            expect(r.inlineRecall).toBeLessThanOrEqual(1);
+        }
+    });
+    it('achieves real compression on at least one fixture', () => {
+        const summary = runBench();
+        expect(summary.rows.some(r => r.compressionPct > 10)).toBe(true);
+    });
+    it('never drops a critical fact from the highly-compressible JSON fixture', () => {
+        // The homogeneous JSON array is crushed to a table — all VALUES must stay inline.
+        const summary = runBench();
+        const json = summary.rows.find(r => r.name.includes('json'));
+        expect(json).toBeDefined();
+        expect(json.compressionPct).toBeGreaterThan(10);
+        expect(json.inlineRecall).toBe(1);
+    });
+    it('reports honest averages', () => {
+        const summary = runBench();
+        expect(summary.avgCompressionPct).toBeGreaterThan(0);
+        expect(summary.avgInlineRecall).toBeGreaterThan(0);
+        expect(summary.avgInlineRecall).toBeLessThanOrEqual(1);
+    });
+});

package/dist/__tests__/cacheAligner.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/cacheAligner.test.js

@@ -0,0 +1,75 @@
+import { describe, it, expect } from 'vitest';
+import { detectVolatile, analyzeSystemPrompt, formatVolatileWarning, _resetWarnedForTest, warnIfVolatile, } from '../cacheAligner.js';
+describe('detectVolatile', () => {
+    it('detects a UUID', () => {
+        const f = detectVolatile('session 550e8400-e29b-41d4-a716-446655440000 started');
+        expect(f.find(x => x.kind === 'uuid')?.count).toBe(1);
+    });
+    it('detects ISO timestamps', () => {
+        const f = detectVolatile('at 2026-07-21T10:00:00Z and 2026-07-21T11:00:00Z');
+        expect(f.find(x => x.kind === 'timestamp')?.count).toBe(2);
+    });
+    it('detects a JWT', () => {
+        const jwt = 'eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxMjM0NTY3ODkwIn0.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c';
+        const f = detectVolatile(`token=${jwt}`);
+        expect(f.find(x => x.kind === 'jwt')?.count).toBe(1);
+    });
+    it('detects long hex hashes', () => {
+        const sha = 'a'.repeat(64);
+        const f = detectVolatile(`commit ${sha}`);
+        expect(f.find(x => x.kind === 'hash')?.count).toBe(1);
+    });
+    it('returns nothing for clean stable text', () => {
+        expect(detectVolatile('You are a helpful coding assistant. Follow the rules.')).toEqual([]);
+    });
+    it('does not double-count a JWT as a hash', () => {
+        const jwt = 'eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxMjM0NTY3ODkwIn0.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c';
+        const f = detectVolatile(jwt);
+        expect(f.find(x => x.kind === 'hash')).toBeUndefined();
+        expect(f.find(x => x.kind === 'jwt')?.count).toBe(1);
+    });
+});
+describe('analyzeSystemPrompt', () => {
+    it('handles a string system prompt', () => {
+        const r = analyzeSystemPrompt('build id 550e8400-e29b-41d4-a716-446655440000');
+        expect(r.hasVolatile).toBe(true);
+        expect(r.findings.length).toBeGreaterThan(0);
+    });
+    it('aggregates across an array of text blocks', () => {
+        const sys = [
+            { type: 'text', text: 'stable preamble' },
+            { type: 'text', text: 'ts 2026-07-21T10:00:00Z' },
+        ];
+        const r = analyzeSystemPrompt(sys);
+        expect(r.findings.find(f => f.kind === 'timestamp')?.count).toBe(1);
+    });
+    it('reports clean when there is nothing volatile', () => {
+        const r = analyzeSystemPrompt('You are Claude, a coding assistant.');
+        expect(r.hasVolatile).toBe(false);
+        expect(r.findings).toEqual([]);
+    });
+    it('ignores non-text blocks and undefined', () => {
+        expect(analyzeSystemPrompt(undefined).hasVolatile).toBe(false);
+        const sys = [{ type: 'image', source: {} }, { type: 'text', text: 'clean' }];
+        expect(analyzeSystemPrompt(sys).hasVolatile).toBe(false);
+    });
+});
+describe('formatVolatileWarning', () => {
+    it('mentions each detected kind', () => {
+        const msg = formatVolatileWarning([{ kind: 'uuid', count: 2 }, { kind: 'timestamp', count: 1 }]);
+        expect(msg.includes('uuid')).toBe(true);
+        expect(msg.includes('timestamp')).toBe(true);
+    });
+});
+describe('warnIfVolatile', () => {
+    it('warns once per distinct finding signature (no per-request spam)', () => {
+        _resetWarnedForTest();
+        const sys = 'id 550e8400-e29b-41d4-a716-446655440000';
+        expect(warnIfVolatile(sys)).toBe(true); // first time → warns
+        expect(warnIfVolatile(sys)).toBe(false); // same signature → suppressed
+    });
+    it('does not warn on clean prompts', () => {
+        _resetWarnedForTest();
+        expect(warnIfVolatile('perfectly stable system prompt')).toBe(false);
+    });
+});

package/dist/__tests__/codeStructure.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/codeStructure.test.js

@@ -0,0 +1,74 @@
+import { describe, it, expect } from 'vitest';
+import { detectCodeLanguage, extractCodeStructure } from '../deterministic.js';
+import { retrieveOriginal } from '../expand.js';
+describe('detectCodeLanguage', () => {
+    it('detects the existing languages', () => {
+        expect(detectCodeLanguage("import x from 'y'\nexport function f(): void {}")).toBe('ts');
+        expect(detectCodeLanguage('from os import path\ndef f():\n    pass')).toBe('py');
+        expect(detectCodeLanguage('package main\nfunc main() {}')).toBe('go');
+        expect(detectCodeLanguage('use std::io;\npub fn main() {}')).toBe('rs');
+    });
+    it('detects Java', () => {
+        const java = 'package com.acme.app;\nimport java.util.List;\npublic class Service {\n  public void run() {}\n}';
+        expect(detectCodeLanguage(java)).toBe('java');
+    });
+    it('detects C++ (has std::/class/namespace)', () => {
+        const cpp = '#include <vector>\n#include <string>\nnamespace app {\nclass Widget {\n  void draw() {}\n};\n}';
+        expect(detectCodeLanguage(cpp)).toBe('cpp');
+    });
+    it('detects C (includes, no C++ markers)', () => {
+        const c = '#include <stdio.h>\n#include <stdlib.h>\nint main(int argc, char **argv) {\n  return 0;\n}';
+        expect(detectCodeLanguage(c)).toBe('c');
+    });
+    it('returns null for non-code prose', () => {
+        expect(detectCodeLanguage('This is a plain english log line.\nAnother sentence here.')).toBeNull();
+    });
+});
+describe('extractCodeStructure — Java', () => {
+    function bigJava() {
+        const lines = ['package com.acme;', 'import java.util.List;', '', 'public class Orders {'];
+        for (let m = 0; m < 6; m++) {
+            lines.push(`  public int method${m}(int a, int b) {`);
+            for (let b = 0; b < 15; b++)
+                lines.push(`    int local${b} = a + b + ${m};`);
+            lines.push('    return a;');
+            lines.push('  }');
+        }
+        lines.push('}');
+        return lines.join('\n');
+    }
+    it('keeps signatures, elides bodies, and stays smaller', () => {
+        const input = bigJava();
+        const out = extractCodeStructure(input, 'java');
+        expect(out).not.toBe(input);
+        expect(out.length).toBeLessThan(input.length);
+        // signatures survive
+        expect(out.includes('public int method0(int a, int b)')).toBe(true);
+        expect(out.includes('public class Orders')).toBe(true);
+        // an omitted-lines marker is present
+        expect(/implementation lines omitted|lines omitted/.test(out)).toBe(true);
+    });
+    it('is fully recoverable via the parent expand id', () => {
+        const input = bigJava();
+        const out = extractCodeStructure(input, 'java');
+        const m = out.match(/squeezr_expand\("([0-9a-f]{6,})"\)/);
+        expect(m).not.toBeNull();
+        expect(retrieveOriginal(m[1])).toBe(input);
+    });
+});
+describe('extractCodeStructure — C++', () => {
+    it('keeps class + method signatures', () => {
+        const lines = ['#include <vector>', '', 'class Engine {', 'public:'];
+        for (let m = 0; m < 5; m++) {
+            lines.push(`  void step${m}(double dt) {`);
+            for (let b = 0; b < 12; b++)
+                lines.push(`    acc += dt * ${b};`);
+            lines.push('  }');
+        }
+        lines.push('};');
+        const input = lines.join('\n');
+        const out = extractCodeStructure(input, 'cpp');
+        expect(out.includes('void step0(double dt)')).toBe(true);
+        expect(out.length).toBeLessThan(input.length);
+    });
+});

package/dist/__tests__/compressor.test.js

@@ -296,7 +296,11 @@ describe('compressGeminiContents', () => {
         const cts = makeContents(['g'.repeat(200), 'h'.repeat(200)]);
         await compressGeminiContents(cts, 'my-google-key', baseConfig);
         expect(mockFetch).toHaveBeenCalledWith(expect.stringContaining('generativelanguage.googleapis.com'), expect.any(Object));
-        expect(mockFetch).toHaveBeenCalledWith(expect.stringContaining('my-google-key'), expect.any(Object));
+        // Security: the key travels in the x-goog-api-key header, never in the URL.
+        const [calledUrl, calledOpts] = mockFetch.mock.calls.at(-1);
+        expect(calledUrl).not.toContain('my-google-key');
+        expect(calledUrl).not.toContain('key=');
+        expect(calledOpts.headers['x-goog-api-key']).toBe('my-google-key');
     });
     it('returns dry-run without modifications', async () => {
         const oldText = 'g'.repeat(200);

package/dist/__tests__/contentRouter.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/contentRouter.test.js

@@ -0,0 +1,76 @@
+import { describe, it, expect } from 'vitest';
+import { findObjectArraySpans, crushEmbeddedJson, TABLE_MARKER_RE } from '../contentRouter.js';
+import { retrieveOriginal } from '../expand.js';
+function bigArray(prefix = '', suffix = '') {
+    const rows = Array.from({ length: 20 }, (_, i) => ({ id: i, name: `svc-${i}`, status: 'ok', region: 'us-east-1' }));
+    return `${prefix}${JSON.stringify(rows)}${suffix}`;
+}
+describe('findObjectArraySpans', () => {
+    it('finds a whole-text array of objects', () => {
+        const t = JSON.stringify([{ a: 1 }, { a: 2 }]);
+        const spans = findObjectArraySpans(t);
+        expect(spans.length).toBe(1);
+        expect(t.slice(spans[0].start, spans[0].end)).toBe(t);
+    });
+    it('finds an array embedded between prose', () => {
+        const t = bigArray('Here are the pods:\n', '\nDone.');
+        const spans = findObjectArraySpans(t);
+        expect(spans.length).toBe(1);
+        const sub = t.slice(spans[0].start, spans[0].end);
+        expect(sub.startsWith('[{')).toBe(true);
+        expect(sub.endsWith('}]')).toBe(true);
+    });
+    it('handles brackets inside string values without breaking', () => {
+        const t = 'x ' + JSON.stringify([{ note: 'has ] and } inside' }, { note: 'more [ [ {' }]) + ' y';
+        const spans = findObjectArraySpans(t);
+        expect(spans.length).toBe(1);
+        expect(() => JSON.parse(t.slice(spans[0].start, spans[0].end))).not.toThrow();
+    });
+    it('finds two separate embedded arrays', () => {
+        const t = `first ${JSON.stringify([{ a: 1 }, { a: 2 }])} middle ${JSON.stringify([{ b: 3 }, { b: 4 }])} end`;
+        expect(findObjectArraySpans(t).length).toBe(2);
+    });
+    it('ignores arrays of scalars (not object arrays)', () => {
+        expect(findObjectArraySpans('[1, 2, 3, 4, 5]').length).toBe(0);
+    });
+});
+describe('crushEmbeddedJson', () => {
+    it('crushes an array embedded in prose, preserving the surrounding text', () => {
+        const t = bigArray('POD STATUS REPORT\n', '\n(end of report)');
+        const res = crushEmbeddedJson(t);
+        expect(res.savedChars).toBeGreaterThan(0);
+        expect(res.text.startsWith('POD STATUS REPORT')).toBe(true);
+        expect(res.text.includes('(end of report)')).toBe(true);
+        expect(TABLE_MARKER_RE.test(res.text)).toBe(true);
+    });
+    it('keeps the embedded original recoverable via expand', () => {
+        const t = bigArray('label: ', '');
+        const res = crushEmbeddedJson(t);
+        const m = res.text.match(TABLE_MARKER_RE);
+        expect(m).not.toBeNull();
+        const original = retrieveOriginal(m[1]);
+        expect(original).not.toBeUndefined();
+        expect(() => JSON.parse(original)).not.toThrow();
+    });
+    it('crushes the whole-text case too (parity with jsonCrush)', () => {
+        const res = crushEmbeddedJson(bigArray());
+        expect(res.savedChars).toBeGreaterThan(0);
+        expect(TABLE_MARKER_RE.test(res.text)).toBe(true);
+    });
+    it('leaves text with no crushable arrays unchanged', () => {
+        const t = 'just a normal log line\nwith no json at all';
+        const res = crushEmbeddedJson(t);
+        expect(res.savedChars).toBe(0);
+        expect(res.text).toBe(t);
+    });
+    it('leaves a small (non-crushable) embedded array untouched, surroundings intact', () => {
+        const t = 'before [{"a":1},{"a":2}] after';
+        const res = crushEmbeddedJson(t);
+        expect(res.text).toBe(t);
+        expect(res.savedChars).toBe(0);
+    });
+    it('is deterministic', () => {
+        const t = bigArray('p ', ' s');
+        expect(crushEmbeddedJson(t).text).toBe(crushEmbeddedJson(t).text);
+    });
+});

package/dist/__tests__/controlEndpointGuard.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/controlEndpointGuard.test.js

@@ -0,0 +1,61 @@
+import { describe, it, expect } from 'vitest';
+import { app } from '../server.js';
+// Security regression: control endpoints (/squeezr/*) must not be usable from a
+// cross-origin browser context. A malicious page open in the user's browser must
+// not be able to change state or read control responses on http://localhost:<port>.
+// We hit *non-existent* control paths so the guard runs but no real handler fires
+// (403 = guard blocked; 404 = guard allowed and routing missed) — no side effects.
+describe('control-endpoint CSRF/CORS guard', () => {
+    it('rejects a cross-origin mutation to a control endpoint with 403', async () => {
+        const res = await app.request('/squeezr/__guard_probe__', {
+            method: 'POST',
+            headers: { origin: 'http://evil.example' },
+        });
+        expect(res.status).toBe(403);
+    });
+    it('rejects a file:// (null) origin mutation to a control endpoint', async () => {
+        const res = await app.request('/squeezr/__guard_probe__', {
+            method: 'POST',
+            headers: { origin: 'null' },
+        });
+        expect(res.status).toBe(403);
+    });
+    it('allows a mutation with no Origin (curl / MCP / native over loopback)', async () => {
+        const res = await app.request('/squeezr/__guard_probe__', { method: 'POST' });
+        expect(res.status).toBe(404); // guard passed; route simply does not exist
+    });
+    it('allows a mutation from a loopback browser origin', async () => {
+        const res = await app.request('/squeezr/__guard_probe__', {
+            method: 'POST',
+            headers: { origin: 'http://localhost:8899' },
+        });
+        expect(res.status).toBe(404); // guard passed; route simply does not exist
+    });
+    it('does not guard the proxy endpoints (Cursor needs cross-origin)', async () => {
+        const res = await app.request('/v1/__proxy_probe__', {
+            method: 'POST',
+            headers: { origin: 'http://evil.example' },
+        });
+        expect(res.status).not.toBe(403);
+    });
+    it('never reflects a wildcard ACAO on control endpoints', async () => {
+        const res = await app.request('/squeezr/health', {
+            headers: { origin: 'http://evil.example' },
+        });
+        expect(res.headers.get('access-control-allow-origin')).not.toBe('*');
+    });
+    it('reflects the loopback origin (not wildcard) on control endpoints', async () => {
+        const res = await app.request('/squeezr/health', {
+            headers: { origin: 'http://127.0.0.1:1234' },
+        });
+        expect(res.headers.get('access-control-allow-origin')).toBe('http://127.0.0.1:1234');
+        expect(res.headers.get('vary')).toBe('Origin');
+    });
+    it('keeps wildcard ACAO on proxy endpoints for browser tooling', async () => {
+        const res = await app.request('/v1/__proxy_probe__', {
+            method: 'OPTIONS',
+            headers: { origin: 'http://evil.example' },
+        });
+        expect(res.headers.get('access-control-allow-origin')).toBe('*');
+    });
+});

package/dist/__tests__/deterministic.test.js

@@ -105,6 +105,19 @@ describe('preprocess - base pipeline', () => {
         const input = 'a\nb\na';
         expect(preprocess(input)).toBe('a\nb\na');
     });
+    // Regression (1.82.0): repeated bare object keys like `body:` were folded into
+    // "... [repeated N more times]", which corrupted code when it round-tripped to disk.
+    it('never folds repeated bare object keys (body:)', () => {
+        // Mirrors the real incident: identical keys, unique values on the next line.
+        const input = Array.from({ length: 5 }, (_, i) => `    body:\n      "unique text ${i}",`).join('\n');
+        const out = preprocess(input);
+        expect(out).not.toContain('repeated');
+        expect(out.split('\n').filter(l => l.trim() === 'body:')).toHaveLength(5);
+    });
+    it('still folds genuine repeated log prose (colon with a value after)', () => {
+        const input = Array(5).fill('ERROR: connection refused').join('\n');
+        expect(preprocess(input)).toContain('repeated 4 more times');
+    });
     it('minifies inline JSON blobs > 200 chars', () => {
         const obj = Object.fromEntries(Array.from({ length: 20 }, (_, i) => [`key_${i}`, `value_number_${i}`]));
         const pretty = JSON.stringify(obj, null, 2);

package/dist/__tests__/doctor.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/doctor.test.js

@@ -0,0 +1,86 @@
+import { describe, it, expect } from 'vitest';
+import { checkProxy, checkVersion, checkEnv, checkBypass, checkSavings, computeExitCode, formatDoctor, } from '../doctor.js';
+describe('checkProxy', () => {
+    it('passes when health is present', () => {
+        expect(checkProxy({ identity: 'squeezr', version: '1.89.0' }).status).toBe('pass');
+    });
+    it('fails when the proxy is unreachable', () => {
+        expect(checkProxy(null).status).toBe('fail');
+    });
+});
+describe('checkVersion', () => {
+    it('passes when installed matches running', () => {
+        expect(checkVersion('1.89.0', '1.89.0').status).toBe('pass');
+    });
+    it('warns on a stale running proxy', () => {
+        const r = checkVersion('1.89.0', '1.88.0');
+        expect(r.status).toBe('warn');
+        expect(r.detail.includes('1.88.0')).toBe(true);
+    });
+    it('skips when the running version is unknown (proxy down)', () => {
+        expect(checkVersion('1.89.0', null).status).toBe('skip');
+    });
+});
+describe('checkEnv', () => {
+    it('passes when ANTHROPIC_BASE_URL points at the local proxy', () => {
+        expect(checkEnv('http://localhost:8080', 8080).status).toBe('pass');
+        expect(checkEnv('http://127.0.0.1:8080', 8080).status).toBe('pass');
+    });
+    it('warns when unset (traffic not routed through squeezr)', () => {
+        expect(checkEnv(undefined, 8080).status).toBe('warn');
+        expect(checkEnv('', 8080).status).toBe('warn');
+    });
+    it('fails when it points somewhere else', () => {
+        expect(checkEnv('https://api.anthropic.com', 8080).status).toBe('fail');
+        expect(checkEnv('http://localhost:9999', 8080).status).toBe('fail');
+    });
+});
+describe('checkBypass', () => {
+    it('warns when bypass is on (compression disabled)', () => {
+        expect(checkBypass(true).status).toBe('warn');
+    });
+    it('passes when bypass is off', () => {
+        expect(checkBypass(false).status).toBe('pass');
+    });
+    it('skips when unknown', () => {
+        expect(checkBypass(undefined).status).toBe('skip');
+    });
+});
+describe('checkSavings', () => {
+    it('skips when the proxy is down (requests unknown)', () => {
+        expect(checkSavings(undefined, undefined).status).toBe('skip');
+    });
+    it('skips when there is no traffic yet', () => {
+        expect(checkSavings(0, 0).status).toBe('skip');
+    });
+    it('warns when traffic is flowing but nothing is being saved', () => {
+        expect(checkSavings(120, 0).status).toBe('warn');
+    });
+    it('passes when savings are flowing', () => {
+        const r = checkSavings(120, 34);
+        expect(r.status).toBe('pass');
+        expect(r.detail.includes('34')).toBe(true);
+    });
+});
+describe('computeExitCode', () => {
+    it('0 when all pass/skip', () => {
+        expect(computeExitCode([{ name: 'a', status: 'pass', detail: '' }, { name: 'b', status: 'skip', detail: '' }])).toBe(0);
+    });
+    it('1 when there is a warning but no failure', () => {
+        expect(computeExitCode([{ name: 'a', status: 'pass', detail: '' }, { name: 'b', status: 'warn', detail: '' }])).toBe(1);
+    });
+    it('2 when there is any failure', () => {
+        expect(computeExitCode([{ name: 'a', status: 'warn', detail: '' }, { name: 'b', status: 'fail', detail: '' }])).toBe(2);
+    });
+});
+describe('formatDoctor', () => {
+    it('renders every check line and a summary', () => {
+        const out = formatDoctor([
+            { name: 'Proxy', status: 'pass', detail: 'running v1.89.0' },
+            { name: 'Env', status: 'warn', detail: 'not set' },
+        ], 1);
+        expect(out.includes('Proxy')).toBe(true);
+        expect(out.includes('Env')).toBe(true);
+        expect(out.toLowerCase().includes('warn')).toBe(true);
+    });
+});

package/dist/__tests__/jsonCrush.test.d.ts

@@ -0,0 +1 @@
+export {};