OmniRoute/tests/unit/compression/caveman-engine.test.ts

import { describe, it } from "node:test";
import assert from "node:assert/strict";
import {
  cavemanCompress,
  applyRulesToText,
} from "../../../open-sse/services/compression/caveman.ts";
import { CAVEMAN_RULES } from "../../../open-sse/services/compression/cavemanRules.ts";
import type { CavemanRule } from "../../../open-sse/services/compression/types.ts";

describe("caveman engine", () => {
  it("should compress a verbose user prompt", () => {
    const body = {
      messages: [
        {
          role: "user",
          content:
            "Please could you help me analyze this code? I would like you to provide a detailed explanation of what the function does. Thank you so much for your help!",
        },
      ],
    };
    const result = cavemanCompress(body, {
      enabled: true,
      compressRoles: ["user"],
      skipRules: [],
      minMessageLength: 50,
      preservePatterns: [],
    });
    assert.equal(result.compressed, true);
    assert.ok(
      result.stats.savingsPercent > 0,
      `Expected savings > 0, got ${result.stats.savingsPercent}`
    );
    assert.ok(
      result.stats.rulesApplied && result.stats.rulesApplied.length > 0,
      "Expected rules applied"
    );
  });

  it("should skip messages below minMessageLength", () => {
    const body = { messages: [{ role: "user", content: "Hi" }] };
    const result = cavemanCompress(body, {
      enabled: true,
      compressRoles: ["user"],
      skipRules: [],
      minMessageLength: 50,
      preservePatterns: [],
    });
    assert.equal(result.compressed, false);
  });

  it("should return unchanged body when disabled", () => {
    const body = { messages: [{ role: "user", content: "Please help me with this code" }] };
    const result = cavemanCompress(body, {
      enabled: false,
      compressRoles: ["user"],
      skipRules: [],
      minMessageLength: 50,
      preservePatterns: [],
    });
    assert.equal(result.compressed, false);
  });

  it("should preserve code blocks", () => {
    const codeContent = "const x = 42;\nconsole.log(x);";
    const body = {
      messages: [
        {
          role: "user",
          content: `Please analyze this code:\n\`\`\`typescript\n${codeContent}\n\`\`\`\nThank you so much!`,
        },
      ],
    };
    const result = cavemanCompress(body, {
      enabled: true,
      compressRoles: ["user"],
      skipRules: [],
      minMessageLength: 50,
      preservePatterns: [],
    });
    const text = result.body.messages[0].content as string;
    assert.ok(text.includes(codeContent), `Code block should be preserved exactly`);
  });

  it("should preserve URLs", () => {
    const url = "https://example.com/api/v1/users";
    const body = {
      messages: [
        {
          role: "user",
          content: `Please check ${url} for the API docs. Thank you so much!`,
        },
      ],
    };
    const result = cavemanCompress(body, {
      enabled: true,
      compressRoles: ["user"],
      skipRules: [],
      minMessageLength: 50,
      preservePatterns: [],
    });
    const text = result.body.messages[0].content as string;
    assert.equal(
      text.split(/\s+/).some((token) => token === url),
      true,
      `URL should be preserved`
    );
  });

  it("should handle empty messages array", () => {
    const body = { messages: [] };
    const result = cavemanCompress(body, {
      enabled: true,
      compressRoles: ["user"],
      skipRules: [],
      minMessageLength: 50,
      preservePatterns: [],
    });
    assert.equal(result.compressed, false);
  });

  it("should handle messages without content", () => {
    const body = { messages: [{ role: "user" }] };
    const result = cavemanCompress(body, {
      enabled: true,
      compressRoles: ["user"],
      skipRules: [],
      minMessageLength: 50,
      preservePatterns: [],
    });
    assert.equal(result.compressed, false);
  });

  it("should skip rules in skipRules list", () => {
    const body = {
      messages: [{ role: "user", content: "Please help me with this code. Thank you so much!" }],
    };
    const resultWithSkip = cavemanCompress(body, {
      enabled: true,
      compressRoles: ["user"],
      skipRules: ["polite_framing"],
      minMessageLength: 50,
      preservePatterns: [],
    });
    assert.ok(
      !resultWithSkip.stats.rulesApplied?.includes("polite_framing"),
      "polite_framing should be skipped"
    );
  });

  it("should respect compressRoles setting", () => {
    const body = {
      messages: [
        {
          role: "system",
          content:
            "You are a very helpful assistant. Please be extremely detailed in all your responses.",
        },
        {
          role: "user",
          content:
            "Please could you help me with this code problem? I would like you to provide a detailed explanation. Thank you so much!",
        },
      ],
    };
    const result = cavemanCompress(body, {
      enabled: true,
      compressRoles: ["user"],
      skipRules: [],
      minMessageLength: 50,
      preservePatterns: [],
    });
    const systemMsg = result.body.messages[0].content as string;
    const userMsg = result.body.messages[1].content as string;
    assert.ok(
      systemMsg.includes("very"),
      "System message should not be compressed (not in compressRoles)"
    );
    assert.ok(
      !userMsg.includes("Please could you"),
      "User message should have 'Please could you' removed"
    );
    assert.ok(
      !userMsg.includes("Thank you so much"),
      "User message should have 'Thank you so much' removed"
    );
  });

  it("should compute stats accurately", () => {
    const body = {
      messages: [
        { role: "user", content: "Please could you help me with this problem? Thank you so much!" },
      ],
    };
    const result = cavemanCompress(body, {
      enabled: true,
      compressRoles: ["user"],
      skipRules: [],
      minMessageLength: 50,
      preservePatterns: [],
    });
    assert.ok(result.stats.originalTokens > 0);
    assert.ok(result.stats.compressedTokens >= 0);
    assert.ok(result.stats.savingsPercent >= 0);
    assert.ok(result.stats.durationMs >= 0);
    assert.ok(
      // Loose catastrophic budget (see the 10K-token test below for rationale).
      result.stats.durationMs < 500,
      `Duration ${result.stats.durationMs}ms should stay under the 500ms catastrophic budget`
    );
  });

  it("applyRulesToText should track applied rules", () => {
    const { text, appliedRules } = applyRulesToText(
      "Please help me",
      CAVEMAN_RULES.filter((r) => r.context === "all" || r.context === "user")
    );
    assert.ok(appliedRules.length > 0, "Should track applied rules");
    assert.ok(appliedRules.includes("polite_framing"), "polite_framing should be in applied rules");
  });

  it("should complete in under 5ms for 10K token messages", () => {
    const longContent = "Please help me analyze this code. ".repeat(1000);
    const body = { messages: [{ role: "user", content: longContent }] };
    const result = cavemanCompress(body, {
      enabled: true,
      compressRoles: ["user"],
      skipRules: [],
      minMessageLength: 50,
      preservePatterns: [],
    });
    // Catastrophic-regression budget, not a benchmark: under a saturated full
    // suite (concurrency 20) this measured 175ms on a healthy engine — absolute
    // wall-clock asserts flake under load (re-wired by 6A.1c, 2026-06-09).
    // Real perf tracking belongs in tests/benchmarks/.
    assert.ok(result.stats.durationMs < 500, `Expected <500ms, got ${result.stats.durationMs}ms`);
  });

  it("cleans whitespace and punctuation artifacts without regex backtracking", () => {
    const body = {
      messages: [
        {
          role: "user",
          content: "\n\nPlease\t make sure to keep this   stable   !!!   \n\n\n\nThank you.",
        },
      ],
    };
    const result = cavemanCompress(body, {
      enabled: true,
      compressRoles: ["user"],
      skipRules: [],
      minMessageLength: 0,
      preservePatterns: [],
    });
    const text = result.body.messages[0].content as string;

    assert.doesNotMatch(text, /^\n/);
    assert.doesNotMatch(text, /\n$/);
    assert.doesNotMatch(text, /\n\n\n/);
    assert.doesNotMatch(text, /[ \t]+[,.!?;:]/);
    assert.doesNotMatch(text, /[ \t]{2,}/);
  });
});