Performance Characteristics of the caveman-compress Skill: O(n) Linear Text Compression

The caveman-compress skill processes text in linear time and space complexity, delivering deterministic 15–30% token reduction through a single-pass regex algorithm that preserves code blocks, URLs, and identifiers.

The caveman-compress skill in the JuliusBrussee/caveman repository is a pure Node.js prose compressor designed for MCP (Model Context Protocol) workflows. Implemented in src/mcp-servers/caveman-shrink/compress.js, this utility reduces token counts by removing filler words and hedging phrases while maintaining the semantic integrity of technical content.

Time and Space Complexity Analysis

Linear O(n) Time Complexity

The compression algorithm operates in O(n) time complexity, where n represents the length of the input string. The implementation performs a single-pass tokenization over the text, scanning for filler words, articles, hedging phrases, and sentinel markers before rewriting the output string. No nested loops traverse the entire text, ensuring that processing time scales directly and predictably with input size.

Linear O(n) Space Complexity

Space complexity is also O(n). While processing, the algorithm constructs a new output string from the original characters and maintains only minimal auxiliary buffers for regex match lists and temporary sentinel arrays. This linear memory footprint ensures that the skill can handle large payloads without exponential memory growth.

Token Reduction and Compression Efficiency

The caveman-compress skill guarantees measurable token savings for MCP-style descriptions. According to the test suite in tests/test_mcp_shrink.js, the compressor asserts a minimum 15% reduction in byte count, with typical real-world payloads achieving approximately 30% token savings.

These reductions are achieved by targeting high-frequency prose patterns—removing articles like "the" and "a," stripping hedging phrases, and eliminating redundant qualifiers—while preserving the semantic meaning of technical descriptions.

Throughput and Runtime Benchmarks

Because the algorithm relies on simple regex-driven processing rather than heavyweight parsing or machine learning models, caveman-compress achieves exceptional throughput. On typical Node.js 12+ runtimes, the skill processes text at several hundred kilobytes per millisecond.

The test harness executes the compressor on dozens of strings in a few milliseconds, confirming negligible overhead compared with surrounding MCP server traffic. This performance profile makes the skill suitable for real-time JSON-RPC middleware where latency is critical.

Deterministic Behavior and Safety Guarantees

Pure Function Implementation

The compress(text) function behaves as a pure function, always returning identical compressed, before, and after values for a given input. No external state is consulted or modified, making the skill safe to invoke repeatedly within a single session without side effects.

Content Preservation Rules

The compressor enforces strict preservation of syntactic elements. As implemented in src/mcp-servers/caveman-shrink/compress.js (lines 55–78), the algorithm uses regex guards to short-circuit processing and leave the following elements untouched:

• Code blocks (triple backtick delimiters)
• Inline code (single backtick delimiters)
• URLs and file-system paths
• Constant-case identifiers (SCREAMING_SNAKE_CASE variables)

This preservation logic ensures that technical documentation retains executable examples and reference links even after aggressive prose compression.

Safe Mutation Patterns

When processing nested data structures, the compressDescriptionsInPlace function walks objects only when encountering string fields. Empty or null inputs are returned unchanged without throwing errors. The test suite in tests/test_mcp_shrink.js (lines 101–108) explicitly verifies these safety guarantees, ensuring the skill handles edge cases gracefully in production MCP environments.

Integration with caveman-shrink Middleware

The caveman-compress skill serves as the core engine for the caveman-shrink middleware, as defined in src/mcp-servers/caveman-shrink/index.js (lines 73–89). The middleware adds a modest line-buffering layer for JSON-RPC messages but does not introduce additional network hops or serialization overhead.

When integrated, the compressor processes tool descriptions in-place before they traverse the MCP wire protocol, reducing bandwidth usage and context window consumption without altering the functional API.

Practical Usage Examples

Basic String Compression

Compress individual description strings using the compress function:

const { compress } = require('./src/mcp-servers/caveman-shrink/compress');

const input = 'The user is the owner of an account';
const { compressed, before, after } = compress(input);

console.log(compressed); // "User is owner of account"
console.log(`Reduced ${before - after} bytes (${((before - after) / before * 100).toFixed(1)}%)`);

Batch Processing Nested Structures

Process MCP tool descriptions in-place using compressDescriptionsInPlace:

const { compressDescriptionsInPlace } = require('./src/mcp-servers/caveman-shrink/compress');

const payload = {
  tools: [
    { name: 'get_weather', description: 'The function returns the current weather' },
    { name: 'send_email', description: 'Sends an email to a given recipient' }
  ]
};

compressDescriptionsInPlace(payload, ['description']);
console.log(payload.tools[0].description); // "function returns current weather"

Summary

• Linear complexity – Both time and space complexity scale at O(n) with input size, ensuring predictable performance on large payloads.
• Sub-millisecond throughput – Regex-driven processing achieves several hundred kilobytes per millisecond, suitable for real-time MCP middleware.
• Guaranteed token reduction – The compressor delivers 15–30% byte savings while maintaining semantic meaning.
• Content preservation – Code blocks, inline code, URLs, paths, and constant-case identifiers remain untouched.
• Safe and deterministic – Pure function implementation with null-safety and non-mutating behavior on non-string fields.

Frequently Asked Questions

What is the time complexity of caveman-compress?

The caveman-compress skill runs in O(n) time complexity, performing a single linear pass over the input string without nested loops. This linear scaling ensures that processing time increases proportionally with text length, making it suitable for real-time MCP server workloads.

How much token reduction does caveman-compress achieve?

According to the test assertions in tests/test_mcp_shrink.js, the skill guarantees a minimum 15% reduction in token count, with typical MCP description payloads achieving approximately 30% compression. The actual savings depend on the density of filler words, articles, and hedging phrases in the source text.

Does caveman-compress modify code blocks or URLs?

No. The implementation in src/mcp-servers/caveman-shrink/compress.js specifically preserves code blocks (triple backticks), inline code (single backticks), URLs, file-system paths, and constant-case identifiers. Regex guards detect these patterns and short-circuit compression to prevent corruption of technical references.

Is caveman-compress safe to use with null or empty inputs?

Yes. The compressDescriptionsInPlace function safely handles null, undefined, and empty string inputs by returning them unchanged. The test suite verifies that the skill never mutates non-string fields or throws exceptions on edge cases, maintaining stability in production MCP environments.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}