@blockrun/runcode 2.3.0 → 2.4.0

package/dist/compression/layers/paths.js

@@ -0,0 +1,107 @@
+/**
+ * Layer 4: Path Shortening
+ *
+ * Detects common filesystem path prefixes and replaces them with short codes.
+ * Common in coding assistant contexts with repeated file paths.
+ *
+ * Safe for LLM: Lossless abbreviation with path map header.
+ * Expected savings: 1-3%
+ */
+// Regex to match filesystem paths
+const PATH_REGEX = /(?:\/[\w.-]+){3,}/g;
+/**
+ * Extract all paths from messages and find common prefixes.
+ */
+function extractPaths(messages) {
+    const paths = [];
+    for (const message of messages) {
+        if (!message.content || typeof message.content !== "string")
+            continue;
+        const matches = message.content.match(PATH_REGEX);
+        if (matches) {
+            paths.push(...matches);
+        }
+    }
+    return paths;
+}
+/**
+ * Group paths by their common prefixes.
+ * Returns prefixes that appear at least 3 times.
+ */
+function findFrequentPrefixes(paths) {
+    const prefixCounts = new Map();
+    for (const path of paths) {
+        const parts = path.split("/").filter(Boolean);
+        // Try prefixes of different lengths
+        for (let i = 2; i < parts.length; i++) {
+            const prefix = "/" + parts.slice(0, i).join("/") + "/";
+            prefixCounts.set(prefix, (prefixCounts.get(prefix) || 0) + 1);
+        }
+    }
+    // Return prefixes that appear 3+ times, sorted by length (longest first)
+    return Array.from(prefixCounts.entries())
+        .filter(([, count]) => count >= 3)
+        .sort((a, b) => b[0].length - a[0].length)
+        .slice(0, 5) // Max 5 path codes
+        .map(([prefix]) => prefix);
+}
+/**
+ * Apply path shortening to all messages.
+ */
+export function shortenPaths(messages) {
+    const allPaths = extractPaths(messages);
+    if (allPaths.length < 5) {
+        // Not enough paths to benefit from shortening
+        return {
+            messages,
+            pathMap: {},
+            charsSaved: 0,
+        };
+    }
+    const prefixes = findFrequentPrefixes(allPaths);
+    if (prefixes.length === 0) {
+        return {
+            messages,
+            pathMap: {},
+            charsSaved: 0,
+        };
+    }
+    // Create path map
+    const pathMap = {};
+    prefixes.forEach((prefix, i) => {
+        pathMap[`$P${i + 1}`] = prefix;
+    });
+    // Replace paths in messages
+    let charsSaved = 0;
+    const result = messages.map((message) => {
+        if (!message.content || typeof message.content !== "string")
+            return message;
+        let content = message.content;
+        const originalLength = content.length;
+        // Replace prefixes (longest first to avoid partial replacements)
+        for (const [code, prefix] of Object.entries(pathMap)) {
+            content = content.split(prefix).join(code + "/");
+        }
+        charsSaved += originalLength - content.length;
+        return {
+            ...message,
+            content,
+        };
+    });
+    return {
+        messages: result,
+        pathMap,
+        charsSaved,
+    };
+}
+/**
+ * Generate the path map header for the codebook.
+ */
+export function generatePathMapHeader(pathMap) {
+    if (Object.keys(pathMap).length === 0)
+        return "";
+    const entries = Object.entries(pathMap)
+        .map(([code, path]) => `${code}=${path}`)
+        .join(", ");
+    return `[Paths: ${entries}]`;
+}

package/dist/compression/layers/whitespace.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Layer 2: Whitespace Normalization
+ *
+ * Reduces excessive whitespace without changing semantic meaning.
+ *
+ * Safe for LLM: Tokenizers normalize whitespace anyway.
+ * Expected savings: 3-8%
+ */
+import { NormalizedMessage } from "../types.js";
+export interface WhitespaceResult {
+    messages: NormalizedMessage[];
+    charsSaved: number;
+}
+/**
+ * Normalize whitespace in a string.
+ *
+ * - Max 2 consecutive newlines
+ * - Remove trailing whitespace from lines
+ * - Normalize tabs to spaces
+ * - Trim start/end
+ */
+export declare function normalizeWhitespace(content: string): string;
+/**
+ * Apply whitespace normalization to all messages.
+ */
+export declare function normalizeMessagesWhitespace(messages: NormalizedMessage[]): WhitespaceResult;

package/dist/compression/layers/whitespace.js

@@ -0,0 +1,57 @@
+/**
+ * Layer 2: Whitespace Normalization
+ *
+ * Reduces excessive whitespace without changing semantic meaning.
+ *
+ * Safe for LLM: Tokenizers normalize whitespace anyway.
+ * Expected savings: 3-8%
+ */
+/**
+ * Normalize whitespace in a string.
+ *
+ * - Max 2 consecutive newlines
+ * - Remove trailing whitespace from lines
+ * - Normalize tabs to spaces
+ * - Trim start/end
+ */
+export function normalizeWhitespace(content) {
+    if (!content)
+        return content;
+    return content
+        // Normalize line endings
+        .replace(/\r\n/g, "\n")
+        .replace(/\r/g, "\n")
+        // Max 2 consecutive newlines (preserve paragraph breaks)
+        .replace(/\n{3,}/g, "\n\n")
+        // Remove trailing whitespace from each line
+        .replace(/[ \t]+$/gm, "")
+        // Normalize multiple spaces to single (except at line start for indentation)
+        .replace(/([^\n]) {2,}/g, "$1 ")
+        // Reduce excessive indentation (more than 8 spaces → 2 spaces per level)
+        .replace(/^[ ]{8,}/gm, (match) => "  ".repeat(Math.ceil(match.length / 4)))
+        // Normalize tabs to 2 spaces
+        .replace(/\t/g, "  ")
+        // Trim
+        .trim();
+}
+/**
+ * Apply whitespace normalization to all messages.
+ */
+export function normalizeMessagesWhitespace(messages) {
+    let charsSaved = 0;
+    const result = messages.map((message) => {
+        if (!message.content || typeof message.content !== "string")
+            return message;
+        const originalLength = message.content.length;
+        const normalizedContent = normalizeWhitespace(message.content);
+        charsSaved += originalLength - normalizedContent.length;
+        return {
+            ...message,
+            content: normalizedContent,
+        };
+    });
+    return {
+        messages: result,
+        charsSaved,
+    };
+}

package/dist/compression/types.d.ts

@@ -0,0 +1,83 @@
+/**
+ * LLM-Safe Context Compression Types
+ *
+ * Types for the 5-layer compression system that reduces token usage
+ * while preserving semantic meaning for LLM queries.
+ */
+export type ContentPart = {
+    type: string;
+    text?: string;
+    image_url?: {
+        url: string;
+        detail?: string;
+    };
+};
+export interface NormalizedMessage {
+    role: "system" | "user" | "assistant" | "tool";
+    content: string | ContentPart[] | null;
+    tool_call_id?: string;
+    tool_calls?: ToolCall[];
+    name?: string;
+}
+export interface ToolCall {
+    id: string;
+    type: "function";
+    function: {
+        name: string;
+        arguments: string;
+    };
+}
+export interface CompressionConfig {
+    enabled: boolean;
+    preserveRaw: boolean;
+    layers: {
+        deduplication: boolean;
+        whitespace: boolean;
+        dictionary: boolean;
+        paths: boolean;
+        jsonCompact: boolean;
+        observation: boolean;
+        dynamicCodebook: boolean;
+    };
+    dictionary: {
+        maxEntries: number;
+        minPhraseLength: number;
+        includeCodebookHeader: boolean;
+    };
+}
+export interface CompressionStats {
+    duplicatesRemoved: number;
+    whitespaceSavedChars: number;
+    dictionarySubstitutions: number;
+    pathsShortened: number;
+    jsonCompactedChars: number;
+    observationsCompressed: number;
+    observationCharsSaved: number;
+    dynamicSubstitutions: number;
+    dynamicCharsSaved: number;
+}
+export interface CompressionResult {
+    messages: NormalizedMessage[];
+    originalMessages: NormalizedMessage[];
+    originalChars: number;
+    compressedChars: number;
+    compressionRatio: number;
+    stats: CompressionStats;
+    codebook: Record<string, string>;
+    pathMap: Record<string, string>;
+    dynamicCodes: Record<string, string>;
+}
+export interface CompressionLogData {
+    enabled: boolean;
+    ratio: number;
+    original_chars: number;
+    compressed_chars: number;
+    stats: {
+        duplicates_removed: number;
+        whitespace_saved: number;
+        dictionary_subs: number;
+        paths_shortened: number;
+        json_compacted: number;
+    };
+}
+export declare const DEFAULT_COMPRESSION_CONFIG: CompressionConfig;

package/dist/compression/types.js

@@ -0,0 +1,26 @@
+/**
+ * LLM-Safe Context Compression Types
+ *
+ * Types for the 5-layer compression system that reduces token usage
+ * while preserving semantic meaning for LLM queries.
+ */
+// Default configuration - CONSERVATIVE settings for model compatibility
+// Only enable layers that don't require the model to decode anything
+export const DEFAULT_COMPRESSION_CONFIG = {
+    enabled: true,
+    preserveRaw: true,
+    layers: {
+        deduplication: true, // Safe: removes duplicate messages
+        whitespace: true, // Safe: normalizes whitespace
+        dictionary: false, // DISABLED: requires model to understand codebook
+        paths: false, // DISABLED: requires model to understand path codes
+        jsonCompact: true, // Safe: just removes JSON whitespace
+        observation: false, // DISABLED: may lose important context
+        dynamicCodebook: false, // DISABLED: requires model to understand codes
+    },
+    dictionary: {
+        maxEntries: 50,
+        minPhraseLength: 15,
+        includeCodebookHeader: false, // No codebook header needed
+    },
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blockrun/runcode",
-  "version": "2.3.0",
+  "version": "2.4.0",
   "description": "RunCode — AI coding agent powered by 41+ models. Pay per use with USDC.",
   "type": "module",
   "bin": {