@unerr-ai/unerr 0.1.0 → 0.1.1

package/dist/proxy/shell-strategies/structured.js

@@ -0,0 +1,241 @@
+/**
+ * Strategy T2 — structured output (JSON / text) compression.
+ * Depth limiting, array sampling, key pruning for large JSON.
+ */
+const SMALL_JSON = 2000;
+const MEDIUM_JSON = 8000;
+/** Keys whose values are typically large noise (base64, hashes, encoded blobs). */
+function shouldPruneGeneric(key, value) {
+    if (typeof value !== "string")
+        return false;
+    if (value.length < 500)
+        return false;
+    return /raw|encoded|binary|base64|hash|signature|certificate|token/i.test(key);
+}
+/** Command-specific key sets to drop entirely. */
+const PRUNE_KEYS = {
+    "docker inspect": new Set([
+        "GraphDriver",
+        "Mounts",
+        "Config",
+        "NetworkSettings",
+    ]),
+    kubectl: new Set([
+        "managedFields",
+        "annotations",
+        "resourceVersion",
+        "selfLink",
+        "uid",
+    ]),
+};
+function pruneCommandKeys(obj, keys) {
+    if (typeof obj !== "object" || obj === null)
+        return obj;
+    if (Array.isArray(obj))
+        return obj.map((item) => pruneCommandKeys(item, keys));
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+        if (keys.has(key))
+            continue;
+        result[key] = pruneCommandKeys(value, keys);
+    }
+    return result;
+}
+function depthLimit(obj, maxDepth, currentDepth = 0) {
+    if (currentDepth >= maxDepth) {
+        if (Array.isArray(obj))
+            return `[${obj.length} items]`;
+        if (typeof obj === "object" && obj !== null)
+            return "{...}";
+        return obj;
+    }
+    if (Array.isArray(obj)) {
+        if (obj.length > 10) {
+            const sampled = [
+                ...obj
+                    .slice(0, 3)
+                    .map((item) => depthLimit(item, maxDepth, currentDepth + 1)),
+                `… ${obj.length - 4} more items`,
+                depthLimit(obj[obj.length - 1], maxDepth, currentDepth + 1),
+            ];
+            return sampled;
+        }
+        return obj.map((item) => depthLimit(item, maxDepth, currentDepth + 1));
+    }
+    if (typeof obj === "object" && obj !== null) {
+        const result = {};
+        for (const [key, value] of Object.entries(obj)) {
+            if (shouldPruneGeneric(key, value)) {
+                result[key] = `<${value.length} chars pruned>`;
+                continue;
+            }
+            result[key] = depthLimit(value, maxDepth, currentDepth + 1);
+        }
+        return result;
+    }
+    return obj;
+}
+/** Collapse runs of 3+ lines containing a repeated marker. */
+function compressRepeatedValueLines(lines, marker) {
+    const out = [];
+    let i = 0;
+    while (i < lines.length) {
+        if (lines[i]?.includes(marker)) {
+            const runStart = i;
+            while (i < lines.length && lines[i]?.includes(marker))
+                i++;
+            const runLen = i - runStart;
+            if (runLen >= 3) {
+                out.push(lines[runStart]);
+                out.push(`  [${runLen - 1} more fields: ${marker}]`);
+            }
+            else {
+                for (let j = runStart; j < i; j++)
+                    out.push(lines[j]);
+            }
+        }
+        else {
+            out.push(lines[i]);
+            i++;
+        }
+    }
+    return out;
+}
+/** Normalize values in structured text for block comparison. */
+function normalizeBlockContent(block) {
+    return block
+        .map((l) => l.replace(/=\s*.+$/, "= <V>").replace(/:\s+\S.*$/, ": <V>"))
+        .join("\n");
+}
+/** Deduplicate structurally-similar indented blocks. */
+function deduplicateBlocks(lines) {
+    // Find top-level blocks (lines at base indent separated by blank lines or indent returns)
+    const blocks = [];
+    let blockStart = -1;
+    const baseIndent = lines.find((l) => l.trim())?.match(/^(\s*)/)?.[1]?.length ?? 0;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const indent = line.match(/^(\s*)/)?.[1]?.length ?? 0;
+        const isBase = line.trim().length > 0 && indent <= baseIndent;
+        if (isBase && blockStart === -1) {
+            blockStart = i;
+        }
+        else if ((isBase || (line.trim() === "" && blockStart !== -1)) &&
+            blockStart !== -1 &&
+            i - blockStart > 2) {
+            if (line.trim() === "" || isBase) {
+                blocks.push({
+                    start: blockStart,
+                    end: isBase ? i : i,
+                    lines: lines.slice(blockStart, i),
+                });
+                blockStart = isBase ? i : -1;
+            }
+        }
+    }
+    if (blockStart !== -1 && lines.length - blockStart > 2) {
+        blocks.push({
+            start: blockStart,
+            end: lines.length,
+            lines: lines.slice(blockStart),
+        });
+    }
+    if (blocks.length < 3)
+        return lines;
+    // Group blocks by normalized content
+    const groups = new Map();
+    for (const block of blocks) {
+        const norm = normalizeBlockContent(block.lines);
+        const existing = groups.get(norm);
+        if (existing) {
+            existing.count++;
+        }
+        else {
+            groups.set(norm, { first: block, count: 1 });
+        }
+    }
+    // If less than 20% dedup, not worth it
+    const dedupedCount = [...groups.values()].reduce((s, g) => s + 1, 0);
+    if (dedupedCount > blocks.length * 0.8)
+        return lines;
+    // Rebuild: keep first occurrence of each block pattern, collapse repeats
+    const out = [];
+    const seen = new Set();
+    let lastEnd = 0;
+    for (const block of blocks) {
+        // Add lines between blocks
+        for (let i = lastEnd; i < block.start; i++)
+            out.push(lines[i]);
+        const norm = normalizeBlockContent(block.lines);
+        if (!seen.has(norm)) {
+            seen.add(norm);
+            const group = groups.get(norm);
+            for (const l of block.lines)
+                out.push(l);
+            if (group.count > 1) {
+                out.push(`  [×${group.count} similar blocks]`);
+            }
+        }
+        lastEnd = block.end;
+    }
+    // Add remaining lines after last block
+    for (let i = lastEnd; i < lines.length; i++)
+        out.push(lines[i]);
+    return out;
+}
+export function compressStructured(raw, command) {
+    const t = raw.trim();
+    if ((t.startsWith("{") && t.endsWith("}")) ||
+        (t.startsWith("[") && t.endsWith("]"))) {
+        try {
+            let parsed = JSON.parse(t);
+            // Command-specific key pruning
+            if (command) {
+                const cmdLower = command.toLowerCase();
+                for (const [pattern, keys] of Object.entries(PRUNE_KEYS)) {
+                    if (cmdLower.includes(pattern)) {
+                        parsed = pruneCommandKeys(parsed, keys);
+                        break;
+                    }
+                }
+            }
+            const minified = JSON.stringify(parsed);
+            if (minified.length <= SMALL_JSON) {
+                return `_shell_fmt:structured_json\n${minified}`;
+            }
+            if (minified.length <= MEDIUM_JSON) {
+                const limited = depthLimit(parsed, 3);
+                return `_shell_fmt:structured_json\n${JSON.stringify(limited, null, 2)}`;
+            }
+            // Large: aggressive depth limit + minify
+            const limited = depthLimit(parsed, 2);
+            return `_shell_fmt:structured_json\n${JSON.stringify(limited)}`;
+        }
+        catch {
+            /* fall through */
+        }
+    }
+    // Non-JSON: structured text compression
+    let lines = t
+        .replace(/\r\n/g, "\n")
+        .replace(/\n{4,}/g, "\n\n\n")
+        .replace(/[ \t]+$/gm, "")
+        .split("\n");
+    // Collapse repeated "(known after apply)" lines (terraform plan)
+    if (lines.filter((l) => l.includes("(known after apply)")).length > 5) {
+        lines = compressRepeatedValueLines(lines, "(known after apply)");
+    }
+    // Collapse repeated "(sensitive value)" lines
+    if (lines.filter((l) => l.includes("(sensitive value)")).length > 3) {
+        lines = compressRepeatedValueLines(lines, "(sensitive value)");
+    }
+    // Deduplicate structurally-similar blocks
+    if (lines.length > 80) {
+        lines = deduplicateBlocks(lines);
+    }
+    const compact = lines.join("\n");
+    const clipped = compact.length > 12_000
+        ? `${compact.slice(0, 8000)}\n…shell_struct_omitted…\n${compact.slice(-3000)}`
+        : compact;
+    return `_shell_fmt:structured_text\n${clipped}`;
+}

package/dist/proxy/shell-strategies/tabular.js

@@ -0,0 +1,243 @@
+/**
+ * Strategy T1 — whitespace-aligned tabular shell output → compact pipe grid.
+ * Detects header rows and applies command-specific column pruning.
+ * Uses position-based parsing for fixed-width output (ps aux, ps -ef, etc.).
+ */
+const SPLIT = /\s{2,}|\t+/;
+/** Commands that use fixed-width positional columns (last column captures rest of line). */
+const POSITIONAL_COMMANDS = [
+    // Process listing
+    "ps aux",
+    "ps -ef",
+    "ps -elf",
+    "ps -al",
+    // Container runtimes
+    "docker ps",
+    "podman ps",
+    // File descriptors
+    "lsof",
+    // System services
+    "systemctl list-units",
+    "launchctl list",
+    // Hardware
+    "lspci",
+    "lsusb",
+    // Process managers
+    "pm2 list",
+    "pm2 status",
+    "forever list",
+    // Package management
+    "dpkg -l",
+];
+/** Command-specific column retention profiles. */
+const COLUMN_PROFILES = {
+    "ps aux": { keep: ["PID", "USER", "%CPU", "%MEM", "COMMAND", "CMD"] },
+    "ps -ef": { keep: ["PID", "PPID", "CMD", "COMMAND"] },
+    "docker ps": { keep: ["CONTAINER ID", "IMAGE", "STATUS", "PORTS", "NAMES"] },
+    "podman ps": { keep: ["CONTAINER ID", "IMAGE", "STATUS", "PORTS", "NAMES"] },
+    "systemctl list-units": {
+        keep: ["UNIT", "LOAD", "ACTIVE", "SUB", "DESCRIPTION"],
+    },
+    lsof: { keep: ["COMMAND", "PID", "USER", "FD", "TYPE", "NAME"] },
+    "dpkg -l": { keep: ["Name", "Version", "Architecture", "Description"] },
+    "docker images": {
+        keep: ["REPOSITORY", "TAG", "SIZE", "IMAGE ID"],
+    },
+    "df -h": {
+        keep: ["Filesystem", "Size", "Used", "Avail", "Use%", "Mounted on"],
+    },
+    df: {
+        keep: [
+            "Filesystem",
+            "1K-blocks",
+            "Used",
+            "Available",
+            "Use%",
+            "Mounted on",
+        ],
+    },
+};
+/** Check if a command uses fixed-width format where last column captures rest of line. */
+function isLastColRestCommand(command) {
+    const cmd = command.toLowerCase().trim();
+    return POSITIONAL_COMMANDS.some((p) => cmd.startsWith(p) || cmd.includes(p));
+}
+/**
+ * Split a line into N fields where the first N-1 are whitespace-delimited tokens
+ * and the Nth captures everything remaining (for COMMAND columns with spaces).
+ */
+function splitWithLastRest(line, numCols) {
+    const trimmed = line.trim();
+    const parts = [];
+    let remaining = trimmed;
+    for (let i = 0; i < numCols - 1; i++) {
+        const m = remaining.match(/^(\S+)\s+/);
+        if (!m) {
+            parts.push(remaining);
+            remaining = "";
+            break;
+        }
+        parts.push(m[1]);
+        remaining = remaining.slice(m[0].length);
+    }
+    // Last column = everything remaining
+    if (remaining)
+        parts.push(remaining);
+    // Pad if needed
+    while (parts.length < numCols)
+        parts.push("");
+    return parts;
+}
+function matchColumnProfile(command) {
+    const cmd = command.toLowerCase().trim();
+    for (const [pattern, profile] of Object.entries(COLUMN_PROFILES)) {
+        if (cmd.startsWith(pattern) || cmd.includes(pattern))
+            return profile;
+    }
+    return null;
+}
+function detectHeaderRow(lines) {
+    if (lines.length < 2)
+        return null;
+    const first = lines[0]?.trim() ?? "";
+    const words = first.split(SPLIT).filter(Boolean);
+    if (words.length < 2)
+        return null;
+    // Header heuristic: majority of words start with uppercase or are %/# prefixed
+    const upperCount = words.filter((w) => /^[A-Z%#]/.test(w)).length;
+    if (upperCount >= words.length * 0.5) {
+        return { headers: words, dataStart: 1 };
+    }
+    return null;
+}
+const esc = (s) => {
+    if (/[|\n\r"]/.test(s))
+        return `"${s.replace(/"/g, '""')}"`;
+    return s;
+};
+function compressTabularInner(text, command) {
+    const lines = text
+        .replace(/\r\n/g, "\n")
+        .split("\n")
+        .filter((l) => l.trim());
+    if (lines.length === 0)
+        return text;
+    const profile = command ? matchColumnProfile(command) : null;
+    const useLastColRest = command ? isLastColRestCommand(command) : false;
+    // Last-col-rest parsing for ps aux / ps -ef:
+    // First N-1 fields are whitespace-delimited, last field captures everything remaining.
+    if (useLastColRest && lines.length >= 2) {
+        const headerTokens = lines[0]?.trim().split(/\s+/).filter(Boolean);
+        if (headerTokens && headerTokens.length >= 2) {
+            const numCols = headerTokens.length;
+            const dataRows = lines.slice(1);
+            // Determine which columns to keep
+            let keepIndices;
+            let keepNames;
+            if (profile) {
+                const keepSet = new Set(profile.keep.map((k) => k.toUpperCase()));
+                keepIndices = [];
+                keepNames = [];
+                for (let i = 0; i < headerTokens.length; i++) {
+                    const tok = headerTokens[i];
+                    if (tok && keepSet.has(tok.toUpperCase())) {
+                        keepIndices.push(i);
+                        keepNames.push(tok);
+                    }
+                }
+                if (keepIndices.length < 2) {
+                    keepIndices = headerTokens.map((_, i) => i);
+                    keepNames = [...headerTokens];
+                }
+            }
+            else {
+                keepIndices = headerTokens.map((_, i) => i);
+                keepNames = [...headerTokens];
+            }
+            const parsedRows = dataRows.map((line) => {
+                const cells = splitWithLastRest(line, numCols);
+                return keepIndices.map((i) => cells[i] ?? "");
+            });
+            const header = `_shell_fmt:tabular\n${keepNames.join("|")}`;
+            const body = parsedRows.map((r) => r.map(esc).join("|")).join("\n");
+            return `${header}\n${body}`;
+        }
+    }
+    const detected = detectHeaderRow(lines);
+    // With a detected header + command profile → prune columns
+    if (profile && detected) {
+        const { headers, dataStart } = detected;
+        const headerUpper = new Map();
+        headers.forEach((h, i) => headerUpper.set(h.toUpperCase(), i));
+        const keepIndices = [];
+        const keepNames = [];
+        for (const col of profile.keep) {
+            const idx = headerUpper.get(col.toUpperCase());
+            if (idx !== undefined) {
+                keepIndices.push(idx);
+                keepNames.push(headers[idx] ?? col);
+            }
+        }
+        if (keepIndices.length >= 2) {
+            const dataRows = lines.slice(dataStart);
+            const parsedRows = dataRows.map((line) => {
+                const cells = line.trim().split(SPLIT).filter(Boolean);
+                return keepIndices.map((i) => cells[i] ?? "");
+            });
+            const header = `_shell_fmt:tabular\n${keepNames.join("|")}`;
+            const body = parsedRows.map((r) => r.map(esc).join("|")).join("\n");
+            return `${header}\n${body}`;
+        }
+    }
+    // With a detected header but no profile → use real column names
+    if (detected) {
+        const { headers, dataStart } = detected;
+        const dataRows = lines.slice(dataStart);
+        const parsedRows = dataRows.map((line) => line.trim().split(SPLIT).filter(Boolean));
+        const width = Math.max(headers.length, ...parsedRows.map((r) => r.length));
+        const paddedHeaders = [...headers];
+        while (paddedHeaders.length < width)
+            paddedHeaders.push(`c${paddedHeaders.length}`);
+        const header = `_shell_fmt:tabular\n${paddedHeaders.join("|")}`;
+        const body = parsedRows
+            .map((r) => {
+            const copy = [...r];
+            while (copy.length < width)
+                copy.push("");
+            return copy.map(esc).join("|");
+        })
+            .join("\n");
+        return `${header}\n${body}`;
+    }
+    // No header detected — generic c0/c1/... approach
+    const rows = [];
+    for (const line of lines) {
+        const cells = line.trim().split(SPLIT).filter(Boolean);
+        if (cells.length >= 2)
+            rows.push(cells);
+    }
+    if (rows.length === 0)
+        return text;
+    const width = Math.max(...rows.map((r) => r.length));
+    const padded = rows.map((r) => {
+        const copy = [...r];
+        while (copy.length < width)
+            copy.push("");
+        return copy;
+    });
+    const header = `_shell_fmt:tabular\n${Array.from({ length: width }, (_, i) => `c${i}`).join("|")}`;
+    const body = padded.map((r) => r.map(esc).join("|")).join("\n");
+    return `${header}\n${body}`;
+}
+export function compressTabular(text, command) {
+    const result = compressTabularInner(text, command);
+    // Safety valve: if compression was too aggressive (kept <35% of content),
+    // fall back to gentle approach that just strips blank lines
+    if (result.length < text.length * 0.35 && text.length > 200) {
+        return `_shell_fmt:tabular\n${text
+            .split("\n")
+            .filter((l) => l.trim())
+            .join("\n")}`;
+    }
+    return result;
+}

package/dist/proxy/shell-strategies/test-results-types.js

@@ -0,0 +1,13 @@
+/**
+ * R2 — shared types for the per-runner test_results parsers.
+ *
+ * The test_results.ts strategy is structurally per-runner: each framework has
+ * its own `parseFramework()` function. These types are extracted here so that
+ * adding a new framework parser (or moving an existing one into its own file
+ * later) doesn't require touching the strategy entry point.
+ *
+ * Frameworks currently supported (see test-results.ts):
+ *   vitest · jest · pytest · cargo_test · go_test · rspec · phpunit
+ *   dotnet_test · elixir_test · playwright · generic (fallback)
+ */
+export {};