@shrkcrft/compress 0.1.0-alpha.16

package/dist/ccr/in-memory-ccr-store.d.ts

@@ -0,0 +1,21 @@
+import type { ICcrStore } from './ccr-store.js';
+import type { ICcrEntry } from './ccr-entry.js';
+/**
+ * In-memory CCR backend. Used by the MCP server, whose process is long-lived,
+ * so a `compress_context` call and a later `retrieve_original` call in the
+ * same session share one store. Holding originals in memory (never on disk)
+ * keeps the MCP-never-writes contract intact.
+ *
+ * Bounded by an insertion-order capacity: when full, the oldest entry is
+ * evicted (a retrieval miss just means the agent re-runs the producing call).
+ */
+export declare class InMemoryCcrStore implements ICcrStore {
+    private readonly entries;
+    private readonly capacity;
+    constructor(capacity?: number);
+    put(content: string): string;
+    get(key: string): ICcrEntry | undefined;
+    has(key: string): boolean;
+    size(): number;
+}
+//# sourceMappingURL=in-memory-ccr-store.d.ts.map

package/dist/ccr/in-memory-ccr-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"in-memory-ccr-store.d.ts","sourceRoot":"","sources":["../../src/ccr/in-memory-ccr-store.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAChD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAGhD;;;;;;;;GAQG;AACH,qBAAa,gBAAiB,YAAW,SAAS;IAChD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAgC;IACxD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;gBAEtB,QAAQ,SAAM;IAK1B,GAAG,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM;IAiB5B,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS;IAIvC,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAIzB,IAAI,IAAI,MAAM;CAGf"}

package/dist/ccr/in-memory-ccr-store.js

@@ -0,0 +1,45 @@
+import { Buffer } from 'node:buffer';
+import { ccrKey } from "./ccr-key.js";
+/**
+ * In-memory CCR backend. Used by the MCP server, whose process is long-lived,
+ * so a `compress_context` call and a later `retrieve_original` call in the
+ * same session share one store. Holding originals in memory (never on disk)
+ * keeps the MCP-never-writes contract intact.
+ *
+ * Bounded by an insertion-order capacity: when full, the oldest entry is
+ * evicted (a retrieval miss just means the agent re-runs the producing call).
+ */
+export class InMemoryCcrStore {
+    entries = new Map();
+    capacity;
+    constructor(capacity = 512) {
+        // No logic beyond field init — capacity is a plain bound.
+        this.capacity = capacity > 0 ? capacity : 512;
+    }
+    put(content) {
+        const key = ccrKey(content);
+        if (this.entries.has(key)) {
+            // Refresh recency: re-insert so it isn't the next eviction victim.
+            const existing = this.entries.get(key);
+            this.entries.delete(key);
+            this.entries.set(key, existing);
+            return key;
+        }
+        if (this.entries.size >= this.capacity) {
+            const oldest = this.entries.keys().next().value;
+            if (oldest !== undefined)
+                this.entries.delete(oldest);
+        }
+        this.entries.set(key, { key, content, bytes: Buffer.byteLength(content, 'utf8') });
+        return key;
+    }
+    get(key) {
+        return this.entries.get(key);
+    }
+    has(key) {
+        return this.entries.has(key);
+    }
+    size() {
+        return this.entries.size;
+    }
+}

package/dist/ccr/ttl-file-ccr-store.d.ts

@@ -0,0 +1,43 @@
+import type { ICcrStore } from './ccr-store.js';
+import type { ICcrEntry } from './ccr-entry.js';
+export interface ITtlFileCcrStoreOptions {
+    /** Entry lifetime in ms. 0 (default) = no expiry. */
+    ttlMs?: number;
+    /** Max live entries; oldest are evicted past this. 0 (default) = unbounded. */
+    maxEntries?: number;
+    /** Refresh an entry's timestamp on read (sliding TTL + LRU). Default false. */
+    refreshOnAccess?: boolean;
+    /** Injectable clock for deterministic tests. Defaults to `Date.now`. */
+    now?: () => number;
+}
+/**
+ * Filesystem-backed CCR store with TTL + size eviction, for the CLI write path
+ * (P5.1). Like {@link FileCcrStore} each original is a content-addressed file
+ * (cross-process by construction), but the file's mtime is the entry timestamp:
+ * entries older than `ttlMs` are treated as absent (and lazily removed), and a
+ * `put` past `maxEntries` evicts the oldest. The MCP server never uses this —
+ * it stays in-memory to honour the read-only contract.
+ *
+ * Stateful by design (a cache, not the deterministic engine path); the clock is
+ * injectable so tests are reproducible.
+ */
+export declare class TtlFileCcrStore implements ICcrStore {
+    private readonly dir;
+    private readonly ttlMs;
+    private readonly maxEntries;
+    private readonly refreshOnAccess;
+    private readonly now;
+    constructor(dir: string, opts?: ITtlFileCcrStoreOptions);
+    private pathFor;
+    private stamp;
+    private isExpired;
+    private remove;
+    put(content: string): string;
+    get(key: string): ICcrEntry | undefined;
+    has(key: string): boolean;
+    size(): number;
+    /** Live (non-expired) entries, sweeping expired files as a side effect. */
+    private liveEntries;
+    private evict;
+}
+//# sourceMappingURL=ttl-file-ccr-store.d.ts.map

package/dist/ccr/ttl-file-ccr-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ttl-file-ccr-store.d.ts","sourceRoot":"","sources":["../../src/ccr/ttl-file-ccr-store.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAChD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAMhD,MAAM,WAAW,uBAAuB;IACtC,qDAAqD;IACrD,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,+EAA+E;IAC/E,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,+EAA+E;IAC/E,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,wEAAwE;IACxE,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;CACpB;AAED;;;;;;;;;;GAUG;AACH,qBAAa,eAAgB,YAAW,SAAS;IAC/C,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAS;IAC7B,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAS;IAC/B,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;IACpC,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAU;IAC1C,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAe;gBAEvB,GAAG,EAAE,MAAM,EAAE,IAAI,GAAE,uBAA4B;IAS3D,OAAO,CAAC,OAAO;IAIf,OAAO,CAAC,KAAK;IAKb,OAAO,CAAC,SAAS;IAIjB,OAAO,CAAC,MAAM;IAQd,GAAG,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM;IAU5B,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS;IAavC,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAWzB,IAAI,IAAI,MAAM;IAId,2EAA2E;IAC3E,OAAO,CAAC,WAAW;IAgBnB,OAAO,CAAC,KAAK;CAOd"}

package/dist/ccr/ttl-file-ccr-store.js

@@ -0,0 +1,117 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync, readdirSync, statSync, utimesSync, rmSync, } from 'node:fs';
+import * as nodePath from 'node:path';
+import { Buffer } from 'node:buffer';
+import { ccrKey } from "./ccr-key.js";
+/** CCR keys are content hashes — hex only. Rejects path-traversal lookups. */
+const VALID_KEY = /^[0-9a-f]{1,64}$/;
+/**
+ * Filesystem-backed CCR store with TTL + size eviction, for the CLI write path
+ * (P5.1). Like {@link FileCcrStore} each original is a content-addressed file
+ * (cross-process by construction), but the file's mtime is the entry timestamp:
+ * entries older than `ttlMs` are treated as absent (and lazily removed), and a
+ * `put` past `maxEntries` evicts the oldest. The MCP server never uses this —
+ * it stays in-memory to honour the read-only contract.
+ *
+ * Stateful by design (a cache, not the deterministic engine path); the clock is
+ * injectable so tests are reproducible.
+ */
+export class TtlFileCcrStore {
+    dir;
+    ttlMs;
+    maxEntries;
+    refreshOnAccess;
+    now;
+    constructor(dir, opts = {}) {
+        // Field init only.
+        this.dir = dir;
+        this.ttlMs = opts.ttlMs && opts.ttlMs > 0 ? opts.ttlMs : 0;
+        this.maxEntries = opts.maxEntries && opts.maxEntries > 0 ? opts.maxEntries : 0;
+        this.refreshOnAccess = opts.refreshOnAccess ?? false;
+        this.now = opts.now ?? (() => Date.now());
+    }
+    pathFor(key) {
+        return nodePath.join(this.dir, `${key}.txt`);
+    }
+    stamp(file, ms) {
+        const d = new Date(ms);
+        utimesSync(file, d, d);
+    }
+    isExpired(mtimeMs) {
+        return this.ttlMs > 0 && this.now() - mtimeMs > this.ttlMs;
+    }
+    remove(file) {
+        try {
+            rmSync(file, { force: true });
+        }
+        catch {
+            // best-effort eviction
+        }
+    }
+    put(content) {
+        const key = ccrKey(content);
+        const file = this.pathFor(key);
+        mkdirSync(this.dir, { recursive: true });
+        writeFileSync(file, content, 'utf8');
+        this.stamp(file, this.now());
+        this.evict();
+        return key;
+    }
+    get(key) {
+        if (!VALID_KEY.test(key))
+            return undefined;
+        const file = this.pathFor(key);
+        if (!existsSync(file))
+            return undefined;
+        if (this.isExpired(statSync(file).mtimeMs)) {
+            this.remove(file);
+            return undefined;
+        }
+        if (this.refreshOnAccess)
+            this.stamp(file, this.now());
+        const content = readFileSync(file, 'utf8');
+        return { key, content, bytes: Buffer.byteLength(content, 'utf8') };
+    }
+    has(key) {
+        if (!VALID_KEY.test(key))
+            return false;
+        const file = this.pathFor(key);
+        if (!existsSync(file))
+            return false;
+        if (this.isExpired(statSync(file).mtimeMs)) {
+            this.remove(file);
+            return false;
+        }
+        return true;
+    }
+    size() {
+        return this.liveEntries().length;
+    }
+    /** Live (non-expired) entries, sweeping expired files as a side effect. */
+    liveEntries() {
+        if (!existsSync(this.dir))
+            return [];
+        const out = [];
+        for (const name of readdirSync(this.dir)) {
+            if (!name.endsWith('.txt'))
+                continue;
+            const file = nodePath.join(this.dir, name);
+            const mtimeMs = statSync(file).mtimeMs;
+            if (this.isExpired(mtimeMs)) {
+                this.remove(file);
+                continue;
+            }
+            out.push({ file, mtimeMs });
+        }
+        return out;
+    }
+    evict() {
+        if (this.maxEntries <= 0)
+            return;
+        const live = this.liveEntries();
+        if (live.length <= this.maxEntries)
+            return;
+        live.sort((a, b) => a.mtimeMs - b.mtimeMs); // oldest first
+        for (const e of live.slice(0, live.length - this.maxEntries))
+            this.remove(e.file);
+    }
+}

package/dist/code/compress-code.d.ts

@@ -0,0 +1,4 @@
+import type { ICompressionResult } from '../result/compression-result.js';
+import type { ICompressOptions } from '../result/compress-options.js';
+export declare function compressCode(text: string, opts?: ICompressOptions): ICompressionResult;
+//# sourceMappingURL=compress-code.d.ts.map

package/dist/code/compress-code.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compress-code.d.ts","sourceRoot":"","sources":["../../src/code/compress-code.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,iCAAiC,CAAC;AAC1E,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AAyQtE,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,GAAE,gBAAqB,GAAG,kBAAkB,CA0C1F"}

package/dist/code/compress-code.js

@@ -0,0 +1,294 @@
+import { EContentType } from "../content/content-type.js";
+import { ECompressionStrategy } from "../result/compression-strategy.js";
+import { splitLines, elide, queryTokens, queryOverlap } from "../text/line-utils.js";
+import { finalizeLossy, passthroughResult } from "../text/finalize.js";
+const DECL_OPEN = /^(?:export\s+)?(?:default\s+)?(?:declare\s+)?(?:abstract\s+)?(?:class|interface|enum|namespace|module)\b/;
+const PURE_CLOSE = /^[)}\]]+[;,]?$/;
+const REGEX_KEYWORDS = new Set([
+    'return', 'typeof', 'instanceof', 'in', 'of', 'new', 'delete', 'void', 'do', 'else', 'yield', 'await', 'case', 'throw',
+]);
+// Block-opening keywords whose body has no preceding `)` (so `closeParen` won't be set).
+const CONTROL_BODY_WORDS = new Set(['do', 'else', 'try', 'finally']);
+function isIdentChar(c) {
+    return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') || c === '_' || c === '$';
+}
+/** Advance past a string literal; returns the index after the closing quote (or EOL). */
+function skipString(line, start, quote) {
+    let i = start + 1;
+    while (i < line.length) {
+        const c = line[i];
+        if (c === '\\') {
+            i += 2;
+            continue;
+        }
+        if (c === quote)
+            return i + 1;
+        i += 1;
+    }
+    return line.length;
+}
+/** Index after a regex literal, or -1 if it doesn't close on this line (then it
+ *  wasn't a regex — a lone `/` to EOL is division/a path, not a literal). */
+function skipRegex(line, start) {
+    let i = start + 1;
+    let inClass = false;
+    while (i < line.length) {
+        const c = line[i];
+        if (c === '\\') {
+            i += 2;
+            continue;
+        }
+        if (inClass) {
+            if (c === ']')
+                inClass = false;
+            i += 1;
+            continue;
+        }
+        if (c === '[')
+            inClass = true;
+        else if (c === '/')
+            return i + 1;
+        i += 1;
+    }
+    return -1;
+}
+/**
+ * Scan one line, updating the block-comment/template state AND pushing/popping
+ * the block-kind stack per brace. Each `{` is classified at the moment it is
+ * opened, using the enclosing kind plus the line-local token context.
+ */
+function applyLineToStack(line, state, stack) {
+    let i = 0;
+    let prevWord = '';
+    let prevValue = false; // previous token can end an expression (ident/value/`)`/`]`/string/regex)
+    let arrow = false; // just saw `=>`
+    let closeParen = false; // saw `)` and only type-annotation tokens since
+    let typeDepth = 0; // `<…>` / `[…]` nesting within a return-type annotation
+    while (i < line.length) {
+        if (state.inBlockComment) {
+            if (line.startsWith('*/', i)) {
+                state.inBlockComment = false;
+                i += 2;
+            }
+            else {
+                i += 1;
+            }
+            continue;
+        }
+        if (state.inTemplate) {
+            const c = line[i];
+            if (c === '\\') {
+                i += 2;
+                continue;
+            }
+            if (c === '`') {
+                state.inTemplate = false;
+                prevValue = true;
+                prevWord = '';
+                arrow = false;
+            }
+            i += 1;
+            continue;
+        }
+        const c = line[i];
+        if (c === ' ' || c === '\t') {
+            i += 1;
+            continue;
+        }
+        if (line.startsWith('//', i))
+            break;
+        if (line.startsWith('/*', i)) {
+            state.inBlockComment = true;
+            i += 2;
+            prevWord = '';
+            arrow = false;
+            continue;
+        }
+        if (c === '/') {
+            const regexCtx = REGEX_KEYWORDS.has(prevWord) || !prevValue;
+            const end = regexCtx ? skipRegex(line, i) : -1;
+            if (end >= 0) {
+                i = end;
+                prevValue = true; // a regex literal is a value
+            }
+            else {
+                i += 1;
+                prevValue = false; // division operator (or unterminated `/`)
+            }
+            prevWord = '';
+            arrow = false;
+            continue;
+        }
+        if (c === "'" || c === '"') {
+            i = skipString(line, i, c);
+            prevValue = true;
+            closeParen = false;
+            prevWord = '';
+            arrow = false;
+            continue;
+        }
+        if (c === '`') {
+            state.inTemplate = true;
+            i += 1;
+            prevValue = true;
+            closeParen = false;
+            prevWord = '';
+            arrow = false;
+            continue;
+        }
+        if (c === '=' && line[i + 1] === '>') {
+            arrow = true;
+            prevValue = false;
+            prevWord = '';
+            i += 2;
+            continue;
+        }
+        if (c === '{') {
+            const top = stack.length > 0 ? stack[stack.length - 1] : 'decl';
+            const kind = top === 'func' || arrow || closeParen || CONTROL_BODY_WORDS.has(prevWord) ? 'func' : 'decl';
+            stack.push(kind);
+            prevValue = false;
+            closeParen = false;
+            typeDepth = 0;
+            arrow = false;
+            prevWord = '';
+            i += 1;
+            continue;
+        }
+        if (c === '}') {
+            if (stack.length > 0)
+                stack.pop();
+            prevValue = false;
+            closeParen = false;
+            typeDepth = 0;
+            arrow = false;
+            prevWord = '';
+            i += 1;
+            continue;
+        }
+        if (c === ')') {
+            closeParen = true;
+            typeDepth = 0;
+            prevValue = true;
+            prevWord = '';
+            arrow = false;
+            i += 1;
+            continue;
+        }
+        if (c === '[') {
+            // In a return-type window (`): [a, b] {`) a `[` opens a TUPLE type — keep
+            // closeParen and deepen; otherwise it's an array/index and ends the window.
+            if (closeParen)
+                typeDepth += 1;
+            else
+                closeParen = false;
+            prevValue = false;
+            prevWord = '';
+            arrow = false;
+            i += 1;
+            continue;
+        }
+        if (c === ']') {
+            if (closeParen && typeDepth > 0)
+                typeDepth -= 1;
+            prevValue = true;
+            prevWord = '';
+            arrow = false;
+            i += 1;
+            continue;
+        }
+        if (c === '(' || c === ';' || c === '=') {
+            closeParen = false;
+            typeDepth = 0;
+            prevValue = false;
+            prevWord = '';
+            arrow = false;
+            i += 1;
+            continue;
+        }
+        // A `,` keeps closeParen ONLY inside a generic/tuple return type
+        // (`): Record<string, Item> {` — typeDepth > 0). A top-level comma
+        // (`resolve(): void, options: {`) ends the return-type window so the next
+        // `{` is correctly an object/interface body, not a function body.
+        if (c === ',') {
+            if (!(closeParen && typeDepth > 0))
+                closeParen = false;
+            prevValue = false;
+            prevWord = '';
+            arrow = false;
+            i += 1;
+            continue;
+        }
+        if (isIdentChar(c)) {
+            let j = i;
+            while (j < line.length && isIdentChar(line[j]))
+                j += 1;
+            prevWord = line.slice(i, j);
+            prevValue = true; // identifiers / numbers are values (keyword check is separate)
+            arrow = false;
+            i = j;
+            continue;
+        }
+        // Any other punctuation (`:` `.` `<` `>` `+` `-` …): leave closeParen so a
+        // return-type annotation `): Foo<T> {` still reads as a func body. Track
+        // `<…>` nesting inside that window so a comma there is a generic separator.
+        if (closeParen) {
+            // A `<` opens a generic only when it follows a type NAME (prevWord set);
+            // a `<` after `)`/`]` (prevWord cleared) is a less-than comparison and
+            // must NOT bump typeDepth (else a later `,` wrongly keeps closeParen).
+            if (c === '<' && prevWord.length > 0)
+                typeDepth += 1;
+            else if (c === '>' && typeDepth > 0)
+                typeDepth -= 1;
+        }
+        prevValue = false;
+        prevWord = '';
+        arrow = false;
+        i += 1;
+    }
+}
+export function compressCode(text, opts = {}) {
+    const lines = splitLines(text);
+    const minLines = opts.minLines ?? 15;
+    if (lines.length < minLines)
+        return passthroughResult(text, EContentType.SourceCode);
+    const tokens = queryTokens(opts.query);
+    const state = { inBlockComment: false, inTemplate: false };
+    const stack = [];
+    const keep = new Set();
+    for (let i = 0; i < lines.length; i += 1) {
+        const raw = lines[i] ?? '';
+        const trimmed = raw.trim();
+        const enclosing = stack.length > 0 ? stack[stack.length - 1] : 'decl';
+        const inComment = state.inBlockComment;
+        if (trimmed.length === 0) {
+            // blanks elided
+        }
+        else if (inComment) {
+            if (enclosing !== 'func')
+                keep.add(i); // a top-level/decl block comment
+        }
+        else if (enclosing !== 'func') {
+            keep.add(i); // top-level / class / interface / enum / object member
+        }
+        else if (DECL_OPEN.test(trimmed)) {
+            keep.add(i); // a nested type declaration inside a body
+        }
+        else if (PURE_CLOSE.test(trimmed)) {
+            keep.add(i); // structural closer
+        }
+        else if (tokens.length > 0 && queryOverlap(trimmed, tokens) > 0) {
+            keep.add(i); // query-relevant body line
+        }
+        applyLineToStack(raw, state, stack);
+    }
+    const body = elide(lines, keep);
+    return finalizeLossy({
+        original: text,
+        body,
+        contentType: EContentType.SourceCode,
+        strategy: ECompressionStrategy.Code,
+        opts,
+        note: `code outline: ${lines.length} lines (function bodies elided)`,
+    });
+}

package/dist/compress-content.d.ts

@@ -0,0 +1,11 @@
+import type { ICompressionResult } from './result/compression-result.js';
+import type { ICompressOptions } from './result/compress-options.js';
+/**
+ * Route a blob to the right deterministic compressor and return the result.
+ * This is the one entry point the `shrk compress` CLI and the
+ * `compress_context` MCP tool call. Content type is auto-detected unless
+ * forced via `opts.contentType`. Pure — no model, no network; the same bytes
+ * and options always yield the same output.
+ */
+export declare function compressContent(text: string, opts?: ICompressOptions): ICompressionResult;
+//# sourceMappingURL=compress-content.d.ts.map

package/dist/compress-content.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compress-content.d.ts","sourceRoot":"","sources":["../src/compress-content.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AACzE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAWrE;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,GAAE,gBAAqB,GAAG,kBAAkB,CA4B7F"}

package/dist/compress-content.js

@@ -0,0 +1,79 @@
+import { EContentType } from "./content/content-type.js";
+import { detectContentType } from "./content/detect-content-type.js";
+import { segmentContent, isRichSegmentType } from "./content/segment.js";
+import { ECompressionStrategy } from "./result/compression-strategy.js";
+import { measureSavings } from "./tokens/estimate-tokens.js";
+import { compressJson } from "./json/compress-json.js";
+import { compressLog } from "./text/compress-log.js";
+import { compressSearch } from "./text/compress-search.js";
+import { compressDiff } from "./text/compress-diff.js";
+import { compressLines } from "./text/compress-lines.js";
+import { compressMarkdown } from "./text/compress-markdown.js";
+import { compressCode } from "./code/compress-code.js";
+/**
+ * Route a blob to the right deterministic compressor and return the result.
+ * This is the one entry point the `shrk compress` CLI and the
+ * `compress_context` MCP tool call. Content type is auto-detected unless
+ * forced via `opts.contentType`. Pure — no model, no network; the same bytes
+ * and options always yield the same output.
+ */
+export function compressContent(text, opts = {}) {
+    const type = opts.contentType ?? detectContentType(text);
+    switch (type) {
+        case EContentType.JsonArray:
+        case EContentType.Json:
+            return compressJson(text, opts);
+        case EContentType.GitDiff:
+            return compressDiff(text, opts);
+        case EContentType.SearchResults:
+            return compressSearch(text, opts);
+        case EContentType.BuildLog:
+            return compressLog(text, opts);
+        case EContentType.SourceCode:
+            return compressCode(text, opts);
+        case EContentType.Markdown:
+            return compressMarkdown(text, opts);
+        case EContentType.PlainText:
+        default:
+            // P4.3: a blob that didn't match one clean type may still be a MIX of
+            // types (prose + a JSON block + a stack trace). Segment and compress each
+            // run with its own strategy. Only the catch-all PlainText path tries this,
+            // so every single-type route above is byte-identical to before.
+            if (!opts.contentType) {
+                const mixed = compressMixed(text, opts);
+                if (mixed)
+                    return mixed;
+            }
+            return compressLines(text, type, opts);
+    }
+}
+/**
+ * Compress a mixed blob by segmenting it and routing each run to its own
+ * compressor, then reassembling. Returns null when the blob is effectively
+ * single-type (≤1 rich segment) or the segmented result doesn't beat plain
+ * line dedup — so the caller falls back to {@link compressLines}.
+ */
+function compressMixed(text, opts) {
+    const segments = segmentContent(text);
+    if (segments.length < 2 || !segments.some((s) => isRichSegmentType(s.type)))
+        return null;
+    let anyLossy = false;
+    const parts = segments.map((seg) => {
+        const r = compressContent(seg.text, { ...opts, contentType: seg.type });
+        if (r.lossy)
+            anyLossy = true;
+        return r.compressed;
+    });
+    const reassembled = parts.join('\n');
+    const savings = measureSavings(text, reassembled, EContentType.PlainText);
+    if (savings.after >= savings.before)
+        return null; // line dedup may still win
+    return {
+        compressed: reassembled,
+        contentType: EContentType.PlainText,
+        strategy: ECompressionStrategy.Mixed,
+        savings,
+        lossy: anyLossy,
+        note: `mixed: ${segments.length} segments (${segments.map((s) => s.type).join(', ')})`,
+    };
+}

package/dist/content/content-type.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Coarse content classes the router recognises. The class selects which
+ * deterministic compressor runs. Ordered loosely from most-specific
+ * (cheapest to over-trigger) to least.
+ */
+export declare enum EContentType {
+    /** A JSON array (top-level `[ ... ]`). The table compactor's prime target. */
+    JsonArray = "json-array",
+    /** A JSON object or scalar (top-level `{ ... }` / value). */
+    Json = "json",
+    /** A unified/`git` diff. */
+    GitDiff = "git-diff",
+    /** grep/ripgrep `file:line:` style search output. */
+    SearchResults = "search-results",
+    /** Build / test / runtime log output. */
+    BuildLog = "build-log",
+    /** Source code in a recognised language. */
+    SourceCode = "source-code",
+    /** Markdown prose / docs. */
+    Markdown = "markdown",
+    /** YAML configuration / manifests (`key: value` mappings + `- ` lists). */
+    Yaml = "yaml",
+    /** Delimiter-separated values (CSV / TSV): a stable column count per line. */
+    Csv = "csv",
+    /** Anything else. */
+    PlainText = "plain-text"
+}
+//# sourceMappingURL=content-type.d.ts.map

package/dist/content/content-type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"content-type.d.ts","sourceRoot":"","sources":["../../src/content/content-type.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,oBAAY,YAAY;IACtB,8EAA8E;IAC9E,SAAS,eAAe;IACxB,6DAA6D;IAC7D,IAAI,SAAS;IACb,4BAA4B;IAC5B,OAAO,aAAa;IACpB,qDAAqD;IACrD,aAAa,mBAAmB;IAChC,yCAAyC;IACzC,QAAQ,cAAc;IACtB,4CAA4C;IAC5C,UAAU,gBAAgB;IAC1B,6BAA6B;IAC7B,QAAQ,aAAa;IACrB,2EAA2E;IAC3E,IAAI,SAAS;IACb,8EAA8E;IAC9E,GAAG,QAAQ;IACX,qBAAqB;IACrB,SAAS,eAAe;CACzB"}