chore: import upstream snapshot with attribution

tests/unit/compression/rtk-engine.test.ts

@@ -0,0 +1,115 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  detectCommandType,
+  loadRtkFilters,
+  matchRtkFilter,
+  processRtkText,
+  applyRtkCompression,
+  rtkEngine,
+} from "../../../open-sse/services/compression/index.ts";
+
+describe("RTK compression engine", () => {
+  it("detects TypeScript build output", () => {
+    const output = "src/a.ts:1:1 - error TS2322: Type 'string' is not assignable";
+    const detection = detectCommandType(output, "tsc --noEmit");
+    assert.equal(detection.type, "build-typescript");
+    assert.equal(detection.category, "build");
+  });
+
+  it("loads builtin declarative filters", () => {
+    const filters = loadRtkFilters({ refresh: true });
+    assert.ok(filters.length >= 10);
+    assert.ok(filters.some((filter) => filter.id === "git-diff"));
+  });
+
+  it("matches filters by detected output type", () => {
+    const filter = matchRtkFilter("diff --git a/a.ts b/a.ts\n@@ -1,1 +1,1 @@", "git diff");
+    assert.equal(filter?.id, "git-diff");
+  });
+
+  it("compresses repeated tool output", () => {
+    const output = Array.from({ length: 20 }, () => "same noisy line").join("\n");
+    const result = processRtkText(output);
+    assert.equal(result.compressed, true);
+    assert.ok(result.text.includes("[rtk:dropped"));
+  });
+
+  it("honors disabled and empty-message runtime branches", () => {
+    const disabled = applyRtkCompression(
+      { messages: [{ role: "tool", content: "same\nsame\nsame" }] },
+      { config: { enabled: false } }
+    );
+    assert.equal(disabled.compressed, false);
+    assert.equal(disabled.stats, null);
+
+    const empty = applyRtkCompression({ messages: [] });
+    assert.equal(empty.compressed, false);
+    assert.equal(empty.stats, null);
+  });
+
+  it("respects enabled and disabled filter lists", () => {
+    const output = "diff --git a/a.ts b/a.ts\n@@ -1,1 +1,1 @@\n-error\n+ok";
+
+    const disabled = processRtkText(output, {
+      command: "git diff",
+      config: { disabledFilters: ["git-diff"] },
+    });
+    assert.ok(!disabled.rulesApplied.includes("git-diff:keep"));
+
+    const enabledMismatch = processRtkText(output, {
+      command: "git diff",
+      config: { enabledFilters: ["git-status"] },
+    });
+    assert.ok(!enabledMismatch.rulesApplied.includes("git-diff:keep"));
+  });
+
+  it("exposes RTK engine schema, validation, apply and compress contracts", () => {
+    assert.ok(rtkEngine.getConfigSchema().some((field) => field.key === "rawOutputRetention"));
+    assert.equal(rtkEngine.validateConfig({ intensity: "invalid" }).valid, false);
+    assert.equal(rtkEngine.validateConfig({ rawOutputRetention: "always" }).valid, true);
+
+    const body = { messages: [{ role: "tool", content: "same\nsame\nsame\nsame" }] };
+    assert.equal(
+      rtkEngine.apply(body, { config: { rtkConfig: { enabled: true } } }).stats?.engine,
+      "rtk"
+    );
+    assert.equal(rtkEngine.compress(body, { enabled: true }).stats?.engine, "rtk");
+  });
+
+  it("applies to chat tool messages", () => {
+    const body = {
+      messages: [{ role: "tool", content: Array.from({ length: 20 }, () => "same").join("\n") }],
+    };
+    const result = applyRtkCompression(body);
+    assert.equal(result.compressed, true);
+    assert.equal(result.stats?.mode, "rtk");
+  });
+
+  it("compresses multipart text parts independently without duplicating output", () => {
+    const imagePart = { type: "image_url", image_url: { url: "data:image/png;base64,abc" } };
+    const body = {
+      messages: [
+        {
+          role: "tool",
+          content: [
+            { type: "text", text: Array.from({ length: 12 }, () => "alpha noisy line").join("\n") },
+            imagePart,
+            { type: "text", text: Array.from({ length: 12 }, () => "beta noisy line").join("\n") },
+          ],
+        },
+      ],
+    };
+
+    const result = applyRtkCompression(body);
+    const content = (result.body.messages as typeof body.messages)[0].content;
+
+    assert.equal(result.compressed, true);
+    assert.ok(Array.isArray(content));
+    assert.match(content[0].text ?? "", /alpha noisy line/);
+    assert.match(content[2].text ?? "", /beta noisy line/);
+    assert.notEqual(content[0].text, content[2].text);
+    assert.deepEqual(content[1], imagePart);
+  });
+});