@unerr-ai/unerr 0.1.0 → 0.1.1

package/dist/proxy/shell-strategies/key-value.js

@@ -0,0 +1,193 @@
+/**
+ * Strategy T6 — key=value (env, printenv) and Key: Value compression.
+ * Drops noisy keys, truncates long values, shortens PATH.
+ * Handles both KEY=VALUE format (env) and Key: Value format (kubectl describe, systemctl).
+ */
+/** Keys to drop from colon-format output (k8s/systemd noise). */
+const DROP_COLON_KEYS = new Set([
+    "managedFields",
+    "resourceVersion",
+    "selfLink",
+    "uid",
+    "creationTimestamp",
+    "generation",
+    "ownerReferences",
+    "finalizers",
+    "kubectl.kubernetes.io/last-applied-configuration",
+    "deployment.kubernetes.io/revision",
+    "control-plane.alpha.kubernetes.io/leader",
+]);
+const DROP_KEYS = new Set([
+    // PWD/shell state
+    "OLDPWD",
+    "SHLVL",
+    "_",
+    "PWD",
+    // Terminal noise
+    "LS_COLORS",
+    "LESSOPEN",
+    "LESSCLOSE",
+    "LSCOLORS",
+    "TERM",
+    "TERM_PROGRAM",
+    "TERM_SESSION_ID",
+    "COLORTERM",
+    "CLICOLOR",
+    "CLICOLOR_FORCE",
+    "FORCE_COLOR",
+    // Locale
+    "LANG",
+    "LC_ALL",
+    "LC_CTYPE",
+    "LC_MESSAGES",
+    "LC_COLLATE",
+    "LC_MONETARY",
+    "LC_NUMERIC",
+    "LC_TIME",
+    // System noise
+    "HOSTNAME",
+    "LOGNAME",
+    "DISPLAY",
+    "XDG_SESSION_TYPE",
+    "XDG_RUNTIME_DIR",
+    "XDG_DATA_DIRS",
+    "XDG_CONFIG_DIRS",
+    "DBUS_SESSION_BUS_ADDRESS",
+    "DESKTOP_SESSION",
+    // SSH/GPG
+    "SSH_AUTH_SOCK",
+    "SSH_AGENT_PID",
+    "GPG_AGENT_INFO",
+    "GPG_TTY",
+    // Shell internals
+    "SHELL",
+    "BASH_VERSION",
+    "ZSH_VERSION",
+    "HISTSIZE",
+    "HISTFILESIZE",
+    "HIST_STAMPS",
+    "SAVEHIST",
+    "HISTCONTROL",
+    "HISTFILE",
+    // Misc
+    "MANPATH",
+    "INFOPATH",
+    "MAIL",
+]);
+const VALUE_MAX = 200;
+/** Compress colon-format output (kubectl describe, systemctl status, etc.) */
+function compressColonFormat(lines) {
+    const kept = [];
+    let i = 0;
+    while (i < lines.length) {
+        const line = lines[i];
+        const colonMatch = /^(\s{0,4})([\w][\w\s./-]*):\s*(.*)$/.exec(line);
+        if (!colonMatch) {
+            if (line.trim())
+                kept.push(line.trimEnd());
+            i++;
+            continue;
+        }
+        const [, indent, key, value] = colonMatch;
+        const keyTrimmed = key?.trim();
+        // Drop noisy k8s keys
+        if (keyTrimmed && DROP_COLON_KEYS.has(keyTrimmed)) {
+            i++;
+            // Skip indented child lines
+            const childIndent = (indent?.length ?? 0) + 2;
+            while (i < lines.length) {
+                const nextLine = lines[i];
+                if (nextLine.trim() === "") {
+                    i++;
+                    break;
+                }
+                const nextIndent = nextLine.match(/^(\s*)/)?.[1]?.length ?? 0;
+                if (nextIndent < childIndent && nextLine.trim())
+                    break;
+                i++;
+            }
+            continue;
+        }
+        // Check for indented sub-block
+        const childIndent = (indent?.length ?? 0) + 2;
+        let childCount = 0;
+        let j = i + 1;
+        while (j < lines.length) {
+            const nextLine = lines[j];
+            if (nextLine.trim() === "")
+                break;
+            const nextInd = nextLine.match(/^(\s*)/)?.[1]?.length ?? 0;
+            if (nextInd < childIndent)
+                break;
+            childCount++;
+            j++;
+        }
+        if (childCount > 10 && !value?.trim()) {
+            // Collapse large sub-blocks
+            kept.push(`${indent}${keyTrimmed}: [${childCount} entries]`);
+            i = j;
+        }
+        else {
+            // Truncate long values
+            let val = value ?? "";
+            if (val.length > VALUE_MAX) {
+                val = `${val.slice(0, 100)}…(${val.length} chars)`;
+            }
+            kept.push(val ? `${indent}${keyTrimmed}: ${val}` : line.trimEnd());
+            i++;
+        }
+    }
+    return kept.join("\n");
+}
+export function compressKeyValue(raw, command) {
+    const lines = raw.split("\n");
+    // Detect format: KEY=VALUE vs Key: Value
+    const equalsCount = lines.filter((l) => /^[A-Za-z_]\w*=/.test(l)).length;
+    const colonCount = lines.filter((l) => /^\s{0,4}[A-Za-z][\w\s-]*:\s/.test(l)).length;
+    // Nothing to compress: input has no key=value or key:value rows. The
+    // classifier sometimes maps a `git`/`kubectl` subcommand to key_value
+    // (correct hint) even when the actual output is a single bare word
+    // (e.g. `git branch --show-current` → "main\n"). Emitting the
+    // `_shell_fmt:key_value\n` header on a sub-header-length payload is
+    // strictly net-negative — passthrough verbatim instead. Matches the
+    // "header is fixed overhead with nothing to decode" convention from
+    // log_text / omni / progress / yaml / tabular.
+    if (colonCount === 0 && equalsCount === 0)
+        return raw;
+    if (colonCount > equalsCount) {
+        const body = compressColonFormat(lines);
+        const clipped = body.length > 8000
+            ? `${body.slice(0, 5000)}\n…kv_omitted…\n${body.slice(-2000)}`
+            : body;
+        return `_shell_fmt:key_value\n${clipped}`;
+    }
+    // Original KEY=VALUE format handling
+    void command;
+    const kept = [];
+    for (const line of lines) {
+        const m = /^([A-Za-z_][A-Za-z0-9_]*)=(.*)$/.exec(line);
+        if (!m) {
+            if (line.trim())
+                kept.push(line.trimEnd());
+            continue;
+        }
+        const key = m[1];
+        let val = m[2] ?? "";
+        if (!key || DROP_KEYS.has(key))
+            continue;
+        // Shorten PATH
+        if (key === "PATH" && val.length > VALUE_MAX) {
+            const parts = val.split(":");
+            val = `${parts.slice(0, 3).join(":")}:…:${parts.length} segments`;
+        }
+        else if (val.length > VALUE_MAX) {
+            val = `${val.slice(0, 100)}…(${val.length} chars)`;
+        }
+        kept.push(`${key}=${val}`);
+    }
+    const body = kept.join("\n");
+    const clipped = body.length > 8000
+        ? `${body.slice(0, 5000)}\n…kv_omitted…\n${body.slice(-2000)}`
+        : body;
+    return `_shell_fmt:key_value\n${clipped}`;
+}

package/dist/proxy/shell-strategies/log-text.js

@@ -0,0 +1,154 @@
+/**
+ * Strategy T3 — log/build output compression.
+ * Deduplicates by normalized pattern, preserves errors, emits compact summary.
+ */
+const SMALL_THRESHOLD = 80;
+const MAX_PATTERNS = 20;
+const MAX_ERROR_LINES = 30;
+const MAX_KEPT_LINES = 20;
+const ERROR_RE = /\b(ERROR|FATAL|CRIT|PANIC|Exception|Traceback|FAIL(?:ED)?|WARN(?:ING)?)\b/i;
+const FRAME_RE = /^\s+at\s/;
+const BUILD_RESULT_RE = /\b(error|warning|built|compiled|bundled|output|dist\/|size:|gzip:|emitted|generated|BUILD (SUCCESS|FAIL)|Finished|Total time|succeeded|SUCCEED|actionable tasks|up-to-date)\b/i;
+const BUILD_CMD_RE = /\b(build|compile|bundle|webpack|vite build|rollup|esbuild|swc|parcel|make|cmake|ninja|gradle|gradlew|mvn|sbt|xcodebuild|dotnet build|cargo build|go build|nx build|turbo|bazel)\b/i;
+/**
+ * Normalize a log line by replacing timestamps, UUIDs, IPs, and timings
+ * with placeholders so identical-in-spirit lines merge.
+ */
+function normalizeLogLine(line) {
+    return (line
+        .replace(/\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}:\d{2}[.\d]*Z?/g, "<TS>")
+        .replace(/\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b/gi, "<UUID>")
+        .replace(/\b[0-9a-f]{7,40}\b/gi, "<HASH>")
+        .replace(/\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b/g, "<IP>")
+        // File paths: src/foo/bar.ts → <PATH>
+        .replace(/\b(?:src|lib|app|test|pkg|cmd|internal)\/\S+/g, "<PATH>")
+        // Bare filenames with extensions
+        .replace(/\b[\w.-]+\.(ts|js|tsx|jsx|py|go|rs|c|cpp|java|rb|swift|kt|cs|o|so|dll|wasm)\b/g, "<FILE>")
+        // Relative/absolute paths
+        .replace(/(?:\.\.?\/|\/)[\w./-]+/g, "<PATH>")
+        // Package names with versions: foo@1.2.3, foo-1.2.3, foo v1.2.3
+        .replace(/\b[\w@/-]+[@-]\d+\.\d+[\w.-]*/g, "<PKG>")
+        // Port numbers
+        .replace(/:\d{2,5}\b/g, ":<PORT>")
+        // Timings with units
+        .replace(/\b\d+(\.\d+)?\s*(ms|s|sec|min|MB|KB|GB|B|bytes)\b/gi, "<N>$2")
+        .replace(/\b\d+ms\b/g, "<N>ms")
+        .replace(/\b\d+\.\d+s\b/g, "<N>s")
+        .replace(/\blatency=\d+/g, "latency=<N>")
+        .replace(/\bstatus=\d{3}/g, "status=<N>")
+        // Generic numbers (last, after specific patterns)
+        .replace(/\b\d+\b/g, "<N>"));
+}
+/**
+ * R1 — success short-circuit. When the entire output is a clean build/run
+ * (no errors, no warnings, classic "all green" markers), collapse to a
+ * one-line summary regardless of total length. Tee still preserves the raw
+ * payload on disk for recovery.
+ */
+const SUCCESS_PATTERNS = [
+    /\bBUILD SUCCESS(?:FUL)?\b/i,
+    /\bbuild succeeded\b/i,
+    /\bbuilt successfully\b/i,
+    /\bcompil(?:ed|ation) successful\b/i,
+    /^Finished\b.*\bin\s/m,
+    /\b0 errors?,?\s*0 warnings?\b/i,
+    /\bno (?:errors|problems|issues|violations) (?:found|reported)\b/i,
+    /\ball checks pass(?:ed)?\b/i,
+];
+function isCleanSuccess(text) {
+    if (ERROR_RE.test(text))
+        return { ok: false };
+    for (const pat of SUCCESS_PATTERNS) {
+        const m = text.match(pat);
+        if (m)
+            return { ok: true, line: m[0] };
+    }
+    return { ok: false };
+}
+export function compressLogText(text, command) {
+    const lines = text.replace(/\r\n/g, "\n").split("\n");
+    const total = lines.length;
+    if (total <= SMALL_THRESHOLD) {
+        return text;
+    }
+    const isBuild = command ? BUILD_CMD_RE.test(command) : false;
+    // R1 success short-circuit — content-driven (not command-gated).
+    // SUCCESS_PATTERNS are specific enough ("0 errors, 0 warnings",
+    // "Finished release...", "compilation successful") that wrapper scripts
+    // benefit too. The ERROR_RE veto inside isCleanSuccess prevents false
+    // positives when error/warning markers are also present.
+    {
+        const probe = isCleanSuccess(text);
+        if (probe.ok) {
+            const label = isBuild ? "build ok" : "ok";
+            return `_shell_fmt:log_text\n${label} — ${probe.line ?? "succeeded"} (${total} lines suppressed)`;
+        }
+    }
+    const patterns = new Map();
+    const errorLines = [];
+    const keptLines = [];
+    for (const line of lines) {
+        if (!line.trim())
+            continue;
+        // Always keep error/warning and stack frame lines verbatim
+        if (ERROR_RE.test(line) || FRAME_RE.test(line)) {
+            errorLines.push(line);
+            continue;
+        }
+        // For build output, keep result/summary lines
+        if (isBuild && BUILD_RESULT_RE.test(line)) {
+            keptLines.push(line);
+            continue;
+        }
+        const normalized = normalizeLogLine(line);
+        const existing = patterns.get(normalized);
+        if (existing) {
+            existing.count++;
+        }
+        else {
+            patterns.set(normalized, { firstLine: line, count: 1 });
+        }
+    }
+    const parts = ["_shell_fmt:log_text"];
+    parts.push(`(${total} lines, ${patterns.size} unique patterns)`);
+    // Errors first — dedup identical error/warning lines with [×N]
+    if (errorLines.length > 0) {
+        const errDedup = new Map();
+        for (const e of errorLines) {
+            const existing = errDedup.get(e);
+            if (existing)
+                existing.count++;
+            else
+                errDedup.set(e, { line: e, count: 1 });
+        }
+        let shown = 0;
+        for (const { line, count } of errDedup.values()) {
+            if (shown >= MAX_ERROR_LINES)
+                break;
+            parts.push(count > 1 ? `${line}  [×${count}]` : line);
+            shown++;
+        }
+        if (errDedup.size > MAX_ERROR_LINES) {
+            parts.push(`… ${errDedup.size - MAX_ERROR_LINES} more error lines`);
+        }
+    }
+    // Build-specific kept lines
+    if (keptLines.length > 0) {
+        for (const k of keptLines.slice(0, MAX_KEPT_LINES))
+            parts.push(k);
+    }
+    // Deduped patterns sorted by count desc
+    const sorted = [...patterns.values()].sort((a, b) => b.count - a.count);
+    for (const p of sorted.slice(0, MAX_PATTERNS)) {
+        if (p.count > 1) {
+            parts.push(`${p.firstLine}  [×${p.count}]`);
+        }
+        else {
+            parts.push(p.firstLine);
+        }
+    }
+    if (sorted.length > MAX_PATTERNS) {
+        parts.push(`… ${sorted.length - MAX_PATTERNS} more unique patterns`);
+    }
+    return parts.join("\n");
+}

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

@@ -0,0 +1,188 @@
+/**
+ * Omni catch-all compression for unclassified shell output.
+ * Five tiers: normalize → pattern-dedup → consecutive-dedup → smart truncate → char cap.
+ * Fires only when classifier confidence < 0.7.
+ */
+const SMALL_THRESHOLD = 40;
+const DEDUP_THRESHOLD = 30;
+const DEDUP_MIN_RUN = 3;
+const TRUNCATE_THRESHOLD = 200;
+const HEAD_KEEP = 20;
+const TAIL_KEEP = 40;
+const CHAR_CAP = 50_000;
+const CHAR_HEAD = 30_000;
+const CHAR_TAIL = 15_000;
+const MAX_PATTERNS = 30;
+const DIAGNOSTIC_RE = /\b(ERROR|FATAL|WARN(?:ING)?|FAIL(?:ED)?|Exception|Traceback|panic|SIGKILL|SIGSEGV|OOM|error\[E\d+\]|cannot find|undefined reference|segmentation fault)\b/i;
+/** Normalize a line by replacing variable parts (numbers, hashes, UUIDs, paths) for pattern matching. */
+function normalizeForPattern(line) {
+    return line
+        .replace(/\b[0-9a-f]{7,40}\b/gi, "<HASH>")
+        .replace(/\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b/gi, "<UUID>")
+        .replace(/\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b/g, "<IP>")
+        .replace(/\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}:\d{2}[.\d]*Z?/g, "<TS>")
+        .replace(/\b\d+(\.\d+)?\s*(ms|s|sec|min|MB|KB|GB|B|bytes)\b/gi, "<N>$2")
+        .replace(/\d+/g, "<N>")
+        .trim();
+}
+/** Tier 1: Collapse blank runs (3+ → 1) and trim trailing whitespace. */
+function normalize(lines) {
+    const out = [];
+    let blankRun = 0;
+    for (const line of lines) {
+        const trimmed = line.trimEnd();
+        if (trimmed.length === 0) {
+            blankRun++;
+            if (blankRun <= 1)
+                out.push("");
+            continue;
+        }
+        blankRun = 0;
+        out.push(trimmed);
+    }
+    return out;
+}
+/**
+ * Tier 2: Pattern-based dedup — merge lines that are identical after normalizing
+ * variable parts (numbers, hashes, timestamps). Non-consecutive duplicates merge.
+ */
+function patternDedup(lines) {
+    if (lines.length < DEDUP_THRESHOLD)
+        return lines;
+    // Separate diagnostic lines (always keep verbatim)
+    const diagnosticLines = [];
+    const normalLines = [];
+    for (const line of lines) {
+        if (DIAGNOSTIC_RE.test(line)) {
+            diagnosticLines.push(line);
+        }
+        else {
+            normalLines.push(line);
+        }
+    }
+    // Group normal lines by normalized pattern
+    const patterns = new Map();
+    const ordered = []; // track insertion order of pattern keys
+    for (const line of normalLines) {
+        if (!line.trim())
+            continue;
+        const norm = normalizeForPattern(line);
+        const existing = patterns.get(norm);
+        if (existing) {
+            existing.count++;
+        }
+        else {
+            patterns.set(norm, { firstLine: line, count: 1 });
+            ordered.push(norm);
+        }
+    }
+    // If dedup saved less than 20% of lines, not worth it — return as-is
+    const dedupedCount = ordered.length + diagnosticLines.length;
+    if (dedupedCount > lines.length * 0.8)
+        return lines;
+    // Rebuild: diagnostics first, then patterns sorted by original order
+    const out = [];
+    // Dedup diagnostic lines too (identical ones)
+    const diagDedup = new Map();
+    for (const d of diagnosticLines) {
+        const existing = diagDedup.get(d);
+        if (existing)
+            existing.count++;
+        else
+            diagDedup.set(d, { line: d, count: 1 });
+    }
+    for (const { line, count } of diagDedup.values()) {
+        out.push(count > 1 ? `${line}  [×${count}]` : line);
+    }
+    let shown = 0;
+    for (const key of ordered) {
+        if (shown >= MAX_PATTERNS)
+            break;
+        const p = patterns.get(key);
+        if (p.count > 1) {
+            out.push(`${p.firstLine}  [×${p.count}]`);
+        }
+        else {
+            out.push(p.firstLine);
+        }
+        shown++;
+    }
+    if (ordered.length > MAX_PATTERNS) {
+        out.push(`… ${ordered.length - MAX_PATTERNS} more unique patterns`);
+    }
+    return out;
+}
+/** Tier 3: Collapse runs of 3+ identical consecutive lines into `line [×N]`. */
+function consecutiveDedup(lines) {
+    if (lines.length < DEDUP_THRESHOLD)
+        return lines;
+    const out = [];
+    let i = 0;
+    while (i < lines.length) {
+        const line = lines[i];
+        let runLen = 1;
+        while (i + runLen < lines.length &&
+            lines[i + runLen] === line &&
+            line.length > 0) {
+            runLen++;
+        }
+        if (runLen >= DEDUP_MIN_RUN) {
+            out.push(`${line}  [×${runLen}]`);
+        }
+        else {
+            for (let j = 0; j < runLen; j++)
+                out.push(line);
+        }
+        i += runLen;
+    }
+    return out;
+}
+/** Tier 4: Head + diagnostic-preserving middle + tail truncation. */
+function truncate(lines) {
+    if (lines.length <= TRUNCATE_THRESHOLD)
+        return lines;
+    const head = lines.slice(0, HEAD_KEEP);
+    const tail = lines.slice(-TAIL_KEEP);
+    const middleStart = HEAD_KEEP;
+    const middleEnd = lines.length - TAIL_KEEP;
+    const diagnostics = [];
+    for (let i = middleStart; i < middleEnd; i++) {
+        if (DIAGNOSTIC_RE.test(lines[i]))
+            diagnostics.push(lines[i]);
+    }
+    const omitted = middleEnd - middleStart - diagnostics.length;
+    const marker = diagnostics.length > 0
+        ? `… ${omitted} lines omitted (${diagnostics.length} diagnostic lines preserved) …`
+        : `… ${omitted} lines omitted …`;
+    return [...head, marker, ...diagnostics, ...tail];
+}
+/** Tier 5: Character-level safety cap for extremely wide output (e.g., minified JS). */
+function capChars(text) {
+    if (text.length <= CHAR_CAP)
+        return text;
+    const omitted = text.length - CHAR_HEAD - CHAR_TAIL;
+    return `${text.slice(0, CHAR_HEAD)}\n… ${omitted} chars omitted …\n${text.slice(-CHAR_TAIL)}`;
+}
+/** Universal catch-all compression. Format-agnostic, safe on any text. */
+export function compressOmni(raw) {
+    const lines = raw.replace(/\r\n/g, "\n").split("\n");
+    const originalCount = lines.length;
+    // Small output — pass through. Skip header (no compression happened);
+    // capChars's `… N chars omitted …` marker still signals any wide-line cap.
+    if (originalCount <= SMALL_THRESHOLD) {
+        return capChars(raw);
+    }
+    const normalized = normalize(lines);
+    // Try pattern dedup first (more aggressive, non-consecutive)
+    const patternDeduped = patternDedup(normalized);
+    // Then consecutive dedup on whatever remains
+    const deduped = consecutiveDedup(patternDeduped);
+    const truncated = truncate(deduped);
+    const joined = truncated.join("\n");
+    const capped = capChars(joined);
+    const savedLines = originalCount - truncated.length;
+    const header = savedLines > 5
+        ? `_shell_fmt:omni (${originalCount}→${truncated.length} lines)`
+        : "_shell_fmt:omni";
+    return `${header}\n${capped}`;
+}

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

@@ -0,0 +1,55 @@
+/**
+ * Strategy T9 — npm/pip-style progress: extract summary, drop transient lines.
+ */
+const KEEP_LAST = 18;
+const SUMMARY_PATTERNS = [
+    // npm/pnpm/yarn
+    /^added \d+ packages?/i,
+    /^Packages: \+\d+/,
+    /^success Saved lockfile/,
+    /^\d+ packages? installed/,
+    /^up to date/i,
+    /^Done in \d/,
+    /^✨\s+Done in/,
+    /^Lockfile is up to date/,
+    // pip/uv
+    /^Successfully installed/i,
+    /^Requirement already satisfied/i,
+    /^Resolved \d+ packages?/i,
+    /^Installed \d+ packages?/i,
+    // cargo
+    /^\s*Compiling .+ v\d/,
+    /^\s*Finished .+ target/,
+    /^\s*Downloaded \d+ crates?/,
+    // go
+    /^go: downloading /,
+    /^go: added /,
+    // bundle (ruby)
+    /^Bundle complete!/,
+    /^Using /,
+    /^\d+ gems? installed/,
+    // composer (php)
+    /^Package operations:/,
+    /^Generating autoload files/,
+    // apt/brew/dnf
+    /^\d+ upgraded, \d+ newly installed/,
+    /^==> (Downloading|Installing|Pouring)/,
+    /^Complete!/,
+    /^Transaction Summary/,
+];
+export function compressProgress(text, command) {
+    void command;
+    const lines = text.replace(/\r\n/g, "\n").split("\n");
+    // Look for summary line near the end
+    const summary = [...lines]
+        .reverse()
+        .find((l) => SUMMARY_PATTERNS.some((p) => p.test(l.trim())));
+    if (summary) {
+        return `_shell_fmt:progress\n${summary.trim()}`;
+    }
+    if (lines.length <= KEEP_LAST) {
+        return text;
+    }
+    const tail = lines.slice(-KEEP_LAST).join("\n");
+    return `_shell_fmt:progress\n… ${lines.length - KEEP_LAST} progress line(s) omitted …\n${tail}`;
+}

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

@@ -0,0 +1,76 @@
+/**
+ * Pre-strategy redaction — runs BEFORE classification so every strategy
+ * sees normalized input. Strips boilerplate that survives ANSI strip and
+ * has no semantic value to a coding agent.
+ *
+ * Token wins are small per-rule but stack across every shell call:
+ * absolute home paths → ~, long hashes → <sha>, ISO timestamps → <ts>,
+ * surviving CSI/OSC cursor codes that the basic ANSI strip missed.
+ */
+import { homedir } from "node:os";
+const HOME = (() => {
+    try {
+        return homedir();
+    }
+    catch {
+        return "";
+    }
+})();
+function escapeRegex(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+/**
+ * Built-in redactors. Order matters — longer/more-specific patterns first.
+ */
+const BUILTIN_RULES = [
+    // Home directory → ~ (only the literal home, not arbitrary user paths)
+    ...(HOME
+        ? [{ pattern: new RegExp(escapeRegex(HOME), "g"), replacement: "~" }]
+        : []),
+    // ISO timestamps — keep the date but compress time portion
+    // 2026-05-13T14:32:01.123Z → <ts>
+    {
+        pattern: /\b\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:?\d{2})?\b/g,
+        replacement: "<ts>",
+    },
+    // Long full-line UUIDs
+    {
+        pattern: /\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b/gi,
+        replacement: "<uuid>",
+    },
+    // 40-char or 64-char hex digests (sha1/sha256) — keep first 7
+    {
+        pattern: /\b([0-9a-f]{7})[0-9a-f]{33,57}\b/gi,
+        replacement: "$1…",
+    },
+    // Surviving CSI cursor movement / scroll region codes that the basic
+    // ANSI stripper missed (rare but real on Windows-style output)
+    // biome-ignore lint/suspicious/noControlCharactersInRegex: stripping control codes by design
+    { pattern: /\x1b\][^\x07\x1b]*\x1b?\\?/g, replacement: "" },
+    // npm/pip progress carriage returns that don't survive ANSI strip cleanly
+    { pattern: /\r(?!\n)/g, replacement: "\n" },
+];
+/**
+ * Apply default + user redactors to raw output. Idempotent. Cheap.
+ */
+export function redactOutput(raw, extra) {
+    if (!raw)
+        return raw;
+    let s = raw;
+    for (const r of BUILTIN_RULES) {
+        s = s.replace(r.pattern, r.replacement);
+    }
+    if (extra && extra.length > 0) {
+        for (const r of extra) {
+            s = s.replace(r.pattern, r.replacement);
+        }
+    }
+    return s;
+}
+/**
+ * Expose builtin rules so the filter-DSL loader (R3) can merge user
+ * rules with the same shape.
+ */
+export function getBuiltinRedactRules() {
+    return BUILTIN_RULES;
+}