@unerr-ai/unerr 0.2.1 → 0.2.2

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

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

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

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

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

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