squeezr-ai 1.10.0

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

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

package/dist/__tests__/expand.test.js

@@ -0,0 +1,192 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { storeOriginal, retrieveOriginal, expandStoreSize, clearExpandStore, injectExpandToolAnthropic, injectExpandToolOpenAI, handleAnthropicExpandCall, handleOpenAIExpandCall, } from '../expand.js';
+describe('storeOriginal / retrieveOriginal', () => {
+    beforeEach(() => clearExpandStore());
+    it('stores and retrieves original content', () => {
+        const id = storeOriginal('hello world');
+        expect(retrieveOriginal(id)).toBe('hello world');
+    });
+    it('returns undefined for unknown ID', () => {
+        expect(retrieveOriginal('zzzzzz')).toBeUndefined();
+    });
+    it('returns a 6-char hex ID', () => {
+        const id = storeOriginal('test');
+        expect(id).toMatch(/^[a-f0-9]{6}$/);
+    });
+    it('is deterministic — same content always same ID', () => {
+        const id1 = storeOriginal('foo bar baz');
+        clearExpandStore();
+        const id2 = storeOriginal('foo bar baz');
+        expect(id1).toBe(id2);
+    });
+    it('different content produces different IDs', () => {
+        const id1 = storeOriginal('content one');
+        const id2 = storeOriginal('content two');
+        expect(id1).not.toBe(id2);
+    });
+    it('overwrites store entry if same content stored twice', () => {
+        storeOriginal('same');
+        storeOriginal('same');
+        expect(expandStoreSize()).toBe(1);
+    });
+});
+describe('expandStoreSize / clearExpandStore', () => {
+    beforeEach(() => clearExpandStore());
+    it('starts at 0', () => {
+        expect(expandStoreSize()).toBe(0);
+    });
+    it('increments on store', () => {
+        storeOriginal('a');
+        storeOriginal('b');
+        expect(expandStoreSize()).toBe(2);
+    });
+    it('clears to 0', () => {
+        storeOriginal('x');
+        clearExpandStore();
+        expect(expandStoreSize()).toBe(0);
+    });
+});
+// ── injectExpandToolAnthropic ─────────────────────────────────────────────────
+describe('injectExpandToolAnthropic', () => {
+    it('adds squeezr_expand tool when tools array is empty', () => {
+        const body = { tools: [] };
+        injectExpandToolAnthropic(body);
+        expect(body.tools.length).toBe(1);
+        expect(body.tools[0].name).toBe('squeezr_expand');
+    });
+    it('creates tools array if missing', () => {
+        const body = {};
+        injectExpandToolAnthropic(body);
+        expect(Array.isArray(body.tools)).toBe(true);
+        expect(body.tools.length).toBe(1);
+    });
+    it('does not add duplicate if already injected', () => {
+        const body = { tools: [] };
+        injectExpandToolAnthropic(body);
+        injectExpandToolAnthropic(body);
+        expect(body.tools.length).toBe(1);
+    });
+    it('preserves existing tools', () => {
+        const body = { tools: [{ name: 'read_file' }] };
+        injectExpandToolAnthropic(body);
+        expect(body.tools.length).toBe(2);
+        expect(body.tools[0].name).toBe('read_file');
+    });
+    it('injected tool has correct input_schema', () => {
+        const body = {};
+        injectExpandToolAnthropic(body);
+        const tool = body.tools[0];
+        expect(tool.input_schema.properties.id).toBeDefined();
+    });
+});
+// ── injectExpandToolOpenAI ────────────────────────────────────────────────────
+describe('injectExpandToolOpenAI', () => {
+    it('adds squeezr_expand tool in OpenAI format', () => {
+        const body = {};
+        injectExpandToolOpenAI(body);
+        const tools = body.tools;
+        expect(tools[0].type).toBe('function');
+        expect(tools[0].function.name).toBe('squeezr_expand');
+    });
+    it('does not add duplicate', () => {
+        const body = {};
+        injectExpandToolOpenAI(body);
+        injectExpandToolOpenAI(body);
+        expect(body.tools.length).toBe(1);
+    });
+});
+// ── handleAnthropicExpandCall ─────────────────────────────────────────────────
+describe('handleAnthropicExpandCall', () => {
+    beforeEach(() => clearExpandStore());
+    it('returns null when no tool_use in response', () => {
+        const resp = { content: [{ type: 'text', text: 'hello' }] };
+        expect(handleAnthropicExpandCall(resp)).toBeNull();
+    });
+    it('returns null for non-squeezr tool calls', () => {
+        const resp = { content: [{ type: 'tool_use', id: 'x', name: 'read_file', input: { path: '/foo' } }] };
+        expect(handleAnthropicExpandCall(resp)).toBeNull();
+    });
+    it('returns null when ID not in store', () => {
+        const resp = {
+            content: [{ type: 'tool_use', id: 'call_1', name: 'squeezr_expand', input: { id: 'aabbcc' } }],
+        };
+        expect(handleAnthropicExpandCall(resp)).toBeNull();
+    });
+    it('returns toolUseId and original when ID found', () => {
+        const id = storeOriginal('the original content');
+        const resp = {
+            content: [{ type: 'tool_use', id: 'call_abc', name: 'squeezr_expand', input: { id } }],
+        };
+        const result = handleAnthropicExpandCall(resp);
+        expect(result).not.toBeNull();
+        expect(result.toolUseId).toBe('call_abc');
+        expect(result.original).toBe('the original content');
+    });
+    it('returns null when response has no content', () => {
+        expect(handleAnthropicExpandCall({})).toBeNull();
+    });
+});
+// ── handleOpenAIExpandCall ────────────────────────────────────────────────────
+describe('handleOpenAIExpandCall', () => {
+    beforeEach(() => clearExpandStore());
+    it('returns null when no choices', () => {
+        expect(handleOpenAIExpandCall({})).toBeNull();
+    });
+    it('returns null when no tool_calls', () => {
+        const resp = { choices: [{ message: { content: 'hello' } }] };
+        expect(handleOpenAIExpandCall(resp)).toBeNull();
+    });
+    it('returns null for non-squeezr tool calls', () => {
+        const resp = {
+            choices: [{
+                    message: {
+                        tool_calls: [{ id: 'call_1', function: { name: 'read_file', arguments: '{}' } }],
+                    },
+                }],
+        };
+        expect(handleOpenAIExpandCall(resp)).toBeNull();
+    });
+    it('returns toolCallId and original when ID found', () => {
+        const id = storeOriginal('openai original');
+        const resp = {
+            choices: [{
+                    message: {
+                        tool_calls: [{
+                                id: 'call_xyz',
+                                function: { name: 'squeezr_expand', arguments: JSON.stringify({ id }) },
+                            }],
+                    },
+                }],
+        };
+        const result = handleOpenAIExpandCall(resp);
+        expect(result).not.toBeNull();
+        expect(result.toolCallId).toBe('call_xyz');
+        expect(result.original).toBe('openai original');
+    });
+    it('returns null when ID not in store', () => {
+        const resp = {
+            choices: [{
+                    message: {
+                        tool_calls: [{
+                                id: 'call_1',
+                                function: { name: 'squeezr_expand', arguments: JSON.stringify({ id: 'zzzzzz' }) },
+                            }],
+                    },
+                }],
+        };
+        expect(handleOpenAIExpandCall(resp)).toBeNull();
+    });
+    it('handles malformed arguments gracefully', () => {
+        const resp = {
+            choices: [{
+                    message: {
+                        tool_calls: [{
+                                id: 'call_1',
+                                function: { name: 'squeezr_expand', arguments: 'NOT JSON{{{' },
+                            }],
+                    },
+                }],
+        };
+        expect(handleOpenAIExpandCall(resp)).toBeNull();
+    });
+});

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

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

package/dist/__tests__/sessionCache.test.js

@@ -0,0 +1,72 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { hashText, getBlock, setBlock, sessionCacheSize, clearSessionCache, } from '../sessionCache.js';
+describe('sessionCache', () => {
+    beforeEach(() => {
+        clearSessionCache();
+    });
+    describe('hashText', () => {
+        it('returns a non-empty string', () => {
+            expect(hashText('hello')).toBeTruthy();
+        });
+        it('is deterministic — same input always same hash', () => {
+            expect(hashText('foo bar')).toBe(hashText('foo bar'));
+        });
+        it('produces different hashes for different inputs', () => {
+            expect(hashText('abc')).not.toBe(hashText('def'));
+        });
+        it('returns a 32-char hex string (MD5)', () => {
+            expect(hashText('test')).toMatch(/^[a-f0-9]{32}$/);
+        });
+    });
+    describe('getBlock / setBlock', () => {
+        it('returns undefined for unknown hash', () => {
+            expect(getBlock('nonexistent')).toBeUndefined();
+        });
+        it('stores and retrieves a block', () => {
+            const block = { fullString: '[squeezr:abc123 -80%] summary', savedChars: 100, originalChars: 500 };
+            setBlock('key1', block);
+            expect(getBlock('key1')).toEqual(block);
+        });
+        it('overwrites existing block', () => {
+            const block1 = { fullString: 'first', savedChars: 10, originalChars: 50 };
+            const block2 = { fullString: 'second', savedChars: 20, originalChars: 50 };
+            setBlock('k', block1);
+            setBlock('k', block2);
+            expect(getBlock('k')).toEqual(block2);
+        });
+        it('stores multiple independent blocks', () => {
+            setBlock('k1', { fullString: 'a', savedChars: 1, originalChars: 10 });
+            setBlock('k2', { fullString: 'b', savedChars: 2, originalChars: 20 });
+            expect(getBlock('k1')?.fullString).toBe('a');
+            expect(getBlock('k2')?.fullString).toBe('b');
+        });
+    });
+    describe('sessionCacheSize', () => {
+        it('starts at 0 after clear', () => {
+            expect(sessionCacheSize()).toBe(0);
+        });
+        it('increments on new entries', () => {
+            setBlock('a', { fullString: 'x', savedChars: 1, originalChars: 10 });
+            expect(sessionCacheSize()).toBe(1);
+            setBlock('b', { fullString: 'y', savedChars: 1, originalChars: 10 });
+            expect(sessionCacheSize()).toBe(2);
+        });
+        it('does not increment on overwrite', () => {
+            setBlock('a', { fullString: 'x', savedChars: 1, originalChars: 10 });
+            setBlock('a', { fullString: 'y', savedChars: 2, originalChars: 10 });
+            expect(sessionCacheSize()).toBe(1);
+        });
+    });
+    describe('clearSessionCache', () => {
+        it('resets size to 0', () => {
+            setBlock('x', { fullString: 'y', savedChars: 1, originalChars: 10 });
+            clearSessionCache();
+            expect(sessionCacheSize()).toBe(0);
+        });
+        it('makes previously set blocks unretrievable', () => {
+            setBlock('k', { fullString: 'v', savedChars: 1, originalChars: 10 });
+            clearSessionCache();
+            expect(getBlock('k')).toBeUndefined();
+        });
+    });
+});

package/dist/cache.d.ts

@@ -0,0 +1,18 @@
+export declare class CompressionCache {
+    private maxEntries;
+    private store;
+    private hits;
+    private misses;
+    constructor(maxEntries: number);
+    private key;
+    get(text: string): string | undefined;
+    set(text: string, compressed: string): void;
+    stats(): {
+        size: number;
+        hits: number;
+        misses: number;
+        hit_rate_pct: number;
+    };
+    private load;
+    private persist;
+}

package/dist/cache.js

@@ -0,0 +1,65 @@
+import { createHash } from 'crypto';
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+const CACHE_FILE = join(homedir(), '.squeezr', 'cache.json');
+export class CompressionCache {
+    maxEntries;
+    store = new Map();
+    hits = 0;
+    misses = 0;
+    constructor(maxEntries) {
+        this.maxEntries = maxEntries;
+        this.load();
+    }
+    key(text) {
+        return createHash('md5').update(text).digest('hex');
+    }
+    get(text) {
+        const entry = this.store.get(this.key(text));
+        if (entry) {
+            entry.hits++;
+            this.hits++;
+            return entry.compressed;
+        }
+        this.misses++;
+        return undefined;
+    }
+    set(text, compressed) {
+        if (this.store.size >= this.maxEntries) {
+            const oldest = [...this.store.entries()].sort((a, b) => a[1].ts - b[1].ts)[0];
+            this.store.delete(oldest[0]);
+        }
+        this.store.set(this.key(text), { compressed, ts: Date.now(), hits: 0 });
+        this.persist();
+    }
+    stats() {
+        const total = this.hits + this.misses;
+        return {
+            size: this.store.size,
+            hits: this.hits,
+            misses: this.misses,
+            hit_rate_pct: total > 0 ? Math.round((this.hits / total) * 1000) / 10 : 0,
+        };
+    }
+    load() {
+        try {
+            if (existsSync(CACHE_FILE)) {
+                const raw = JSON.parse(readFileSync(CACHE_FILE, 'utf-8'));
+                for (const [k, v] of Object.entries(raw)) {
+                    this.store.set(k, v);
+                }
+            }
+        }
+        catch { /* ignore */ }
+    }
+    persist() {
+        try {
+            const dir = join(homedir(), '.squeezr');
+            if (!existsSync(dir))
+                mkdirSync(dir, { recursive: true });
+            writeFileSync(CACHE_FILE, JSON.stringify(Object.fromEntries(this.store)));
+        }
+        catch { /* ignore */ }
+    }
+}

package/dist/compressor.d.ts

@@ -0,0 +1,49 @@
+import { CompressionCache } from './cache.js';
+import type { Config } from './config.js';
+export interface Savings {
+    compressed: number;
+    savedChars: number;
+    originalChars: number;
+    byTool: Array<{
+        tool: string;
+        savedChars: number;
+        originalChars: number;
+    }>;
+    dryRun: boolean;
+    sessionCacheHits: number;
+}
+export declare function getCache(config: Config): CompressionCache;
+interface AnthropicMessage {
+    role: string;
+    content: string | Array<{
+        type: string;
+        tool_use_id?: string;
+        content?: unknown;
+    }>;
+}
+export declare function compressAnthropicMessages(messages: AnthropicMessage[], apiKey: string, config: Config): Promise<[AnthropicMessage[], Savings]>;
+interface OpenAIMessage {
+    role: string;
+    content?: string | null;
+    tool_call_id?: string;
+    tool_calls?: Array<{
+        id: string;
+        function: {
+            name: string;
+        };
+    }>;
+}
+export declare function compressOpenAIMessages(messages: OpenAIMessage[], apiKey: string, config: Config, isLocal?: boolean): Promise<[OpenAIMessage[], Savings]>;
+interface GeminiContent {
+    role: string;
+    parts: Array<{
+        text?: string;
+        functionCall?: unknown;
+        functionResponse?: {
+            name: string;
+            response: unknown;
+        };
+    }>;
+}
+export declare function compressGeminiContents(contents: GeminiContent[], apiKey: string, config: Config): Promise<[GeminiContent[], Savings]>;
+export {};