squeez 1.21.0

Hook-based token compressor for 5 AI CLI hosts (Claude Code, Copilot CLI, OpenCode, Gemini CLI, Codex CLI). Up to 95% bash compression, signature-mode for code reads, cross-call dedup, MCP server, self-teaching protocol. Zero runtime deps.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200

use squeez::commands::compress_output::compute_rewrite;
use squeez::config::Config;
use squeez::context::cache::SessionContext;
use squeez::context::redundancy;
use std::path::PathBuf;
use std::sync::atomic::{AtomicU64, Ordering};

fn tmp() -> PathBuf {
    static CTR: AtomicU64 = AtomicU64::new(0);
    let n = CTR.fetch_add(1, Ordering::Relaxed);
    let d = std::env::temp_dir().join(format!(
        "squeez_co_test_{}_{}",
        std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .unwrap()
            .as_nanos(),
        n
    ));
    std::fs::create_dir_all(&d).unwrap();
    d
}

fn cfg() -> Config {
    Config::default()
}

fn make_json(content: &str) -> String {
    // Escape for JSON string embedding
    let escaped = content.replace('\\', "\\\\").replace('"', "\\\"").replace('\n', "\\n");
    format!(r#"{{"tool_name":"Read","tool_result":{{"content":"{escaped}"}}}}"#)
}

// ── passthrough ──────────────────────────────────────────────────────────────

#[test]
fn empty_raw_returns_none() {
    let dir = tmp();
    assert!(compute_rewrite("", "Read", &dir, &cfg()).is_none());
    assert!(compute_rewrite("   ", "Read", &dir, &cfg()).is_none());
    let _ = std::fs::remove_dir_all(&dir);
}

#[test]
fn no_content_field_returns_none() {
    let dir = tmp();
    let json = r#"{"tool_name":"Read","tool_result":{}}"#;
    assert!(compute_rewrite(json, "Read", &dir, &cfg()).is_none());
    let _ = std::fs::remove_dir_all(&dir);
}

#[test]
fn small_novel_content_returns_none_and_records() {
    let dir = tmp();
    let cfg = cfg();
    // 5 distinct lines — small, no summarize, first time seen → passthrough
    let content = "alpha\nbeta\ngamma\ndelta\nepsilon";
    let json = make_json(content);
    assert!(compute_rewrite(&json, "Read", &dir, &cfg).is_none());
    // Should have been recorded in SessionContext
    let ctx = SessionContext::load(&dir);
    assert!(ctx.call_log.len() >= 1, "content should be recorded for future dedup");
    let _ = std::fs::remove_dir_all(&dir);
}

// ── exact redundancy dedup ────────────────────────────────────────────────────

#[test]
fn exact_duplicate_returns_dedup_note() {
    let dir = tmp();
    let cfg = cfg();
    // Need enough lines for redundancy::check to engage (MIN_LINES = 2)
    let content = "line one\nline two\nline three\nline four\nline five";
    let json = make_json(content);

    // First call: novel → None, records
    assert!(compute_rewrite(&json, "Read", &dir, &cfg).is_none());

    // Second call: exact duplicate → Some with dedup note
    let result = compute_rewrite(&json, "Read", &dir, &cfg);
    assert!(result.is_some(), "second call with same content should return a dedup note");
    let note = result.unwrap();
    assert!(
        note.contains("[squeez: identical to Read"),
        "dedup note should identify tool and call: got {note:?}"
    );
    assert!(
        note.contains("— output omitted]"),
        "dedup note should say output omitted: got {note:?}"
    );
    let _ = std::fs::remove_dir_all(&dir);
}

#[test]
fn exact_dedup_hit_increments_counter() {
    let dir = tmp();
    let cfg = cfg();
    let content = "a\nb\nc\nd\ne\nf";
    let json = make_json(content);
    compute_rewrite(&json, "Read", &dir, &cfg);
    compute_rewrite(&json, "Read", &dir, &cfg);
    let ctx = SessionContext::load(&dir);
    assert!(ctx.exact_dedup_hits >= 1, "exact_dedup_hits should be incremented");
    let _ = std::fs::remove_dir_all(&dir);
}

#[test]
fn different_content_does_not_dedup() {
    let dir = tmp();
    let cfg = cfg();
    let json_a = make_json("apple\nbanana\ncherry\ndate\nelder");
    let json_b = make_json("zebra\nyak\nxray\nwolf\nviper");
    compute_rewrite(&json_a, "Read", &dir, &cfg);
    let result = compute_rewrite(&json_b, "Read", &dir, &cfg);
    assert!(result.is_none(), "distinct content should not trigger dedup");
    let _ = std::fs::remove_dir_all(&dir);
}

#[test]
fn dedup_note_includes_call_number() {
    let dir = tmp();
    let cfg = cfg();
    // Pre-seed context with a specific call so we know what call_n to expect
    let lines: Vec<String> = (0..10).map(|i| format!("seed line {i}")).collect();
    let mut ctx = SessionContext::load(&dir);
    redundancy::record(&mut ctx, "Read", &lines);
    ctx.save(&dir);

    let content = lines.join("\n");
    let json = make_json(&content);
    let result = compute_rewrite(&json, "Read", &dir, &cfg);
    assert!(result.is_some());
    let note = result.unwrap();
    assert!(note.contains('#'), "dedup note should contain call number with #: {note:?}");
    let _ = std::fs::remove_dir_all(&dir);
}

// ── summarize large outputs ───────────────────────────────────────────────────

#[test]
fn large_output_is_summarized() {
    let dir = tmp();
    let mut cfg = cfg();
    // Set a very low threshold so we can test with a small fixture
    cfg.summarize_threshold_lines = 10;

    // Use enough lines that the summarizer (≤40 lines out) is definitely shorter.
    // Include an error marker so is_benign() returns false (no benign multiplier).
    let mut lines: Vec<String> = (0..80).map(|i| format!("build output line {i}: compiled ok")).collect();
    lines.push("error: build failed with 1 error".to_string());
    let content = lines.join("\n");
    let json = make_json(&content);

    let result = compute_rewrite(&json, "Read", &dir, &cfg);
    assert!(
        result.is_some(),
        "output exceeding summarize_threshold_lines should be summarized"
    );
    let summary = result.unwrap();
    let summary_lines = summary.lines().count();
    assert!(
        summary_lines < 81,
        "summary ({summary_lines} lines) should be shorter than original (81 lines)"
    );
    let _ = std::fs::remove_dir_all(&dir);
}

// ── redundancy disabled ───────────────────────────────────────────────────────

#[test]
fn redundancy_disabled_never_deduplicates() {
    let dir = tmp();
    let mut cfg = cfg();
    cfg.redundancy_cache_enabled = false;

    let content = "x\ny\nz\nw\nv";
    let json = make_json(content);
    compute_rewrite(&json, "Read", &dir, &cfg);
    // Even on second call, no dedup when disabled
    let result = compute_rewrite(&json, "Read", &dir, &cfg);
    assert!(result.is_none(), "dedup should not fire when redundancy_cache_enabled=false");
    let _ = std::fs::remove_dir_all(&dir);
}

// ── tool name in note ─────────────────────────────────────────────────────────

#[test]
fn dedup_note_contains_tool_name() {
    let dir = tmp();
    let cfg = cfg();
    let content = "foo\nbar\nbaz\nqux\nquux";
    let json = make_json(content);
    compute_rewrite(&json, "Grep", &dir, &cfg);
    let result = compute_rewrite(&json, "Grep", &dir, &cfg);
    assert!(result.is_some());
    assert!(
        result.unwrap().contains("Grep"),
        "dedup note should name the tool"
    );
    let _ = std::fs::remove_dir_all(&dir);
}