@unerr-ai/unerr 0.2.1 → 0.2.3

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

@@ -1,241 +0,0 @@
-/**
- * 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

@@ -1,243 +0,0 @@
-/**
- * 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

@@ -1,13 +0,0 @@
-/**
- * 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 {};