@unerr-ai/unerr 0.2.1 → 0.2.3

package/dist/proxy/shell-strategies/filter-dsl.js

@@ -1,358 +0,0 @@
-/**
- * R3 — user-facing filter DSL.
- *
- * Reads `.unerr/filters.toml` (per-repo) and `~/.config/unerr/filters.toml`
- * (user-global). Filters are checked BEFORE the built-in classifier. First
- * filter whose `match_command` regex matches the command wins.
- *
- * Directives (subset of RTK's filter schema):
- *   match_command      = "^my-tool\\b"
- *   strip_lines_matching = ["^\\s*$", "^noise"]
- *   keep_lines_matching  = ["^ERROR"]
- *   replace              = [ { pattern = "...", replacement = "..." } ]
- *   match_output         = [ { pattern = "0 errors", message = "ok" } ]
- *   truncate_lines_at    = 200
- *   max_lines            = 80
- *   tail_lines           = 40
- *   filter_stderr        = true
- *   on_empty             = "ok"
- *
- * To keep zero new deps, this module ships a tiny TOML reader that
- * understands the directive subset above. Anything fancier (nested arrays,
- * multi-line strings, dates) is not supported — the loader returns null
- * and we fall through to the built-in classifier.
- */
-import { existsSync, readFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
-let cachedFilters = null;
-let cacheKey = "";
-function readFile(path) {
-    try {
-        if (!existsSync(path))
-            return null;
-        return readFileSync(path, "utf8");
-    }
-    catch {
-        return null;
-    }
-}
-// ─── Minimal TOML reader for our directive subset ──────────────────────────
-function unquote(input) {
-    const s = input.trim();
-    if ((s.startsWith('"') && s.endsWith('"')) ||
-        (s.startsWith("'") && s.endsWith("'"))) {
-        return s.slice(1, -1).replace(/\\"/g, '"').replace(/\\\\/g, "\\");
-    }
-    return s;
-}
-function parseScalar(v) {
-    const t = v.trim();
-    if (t === "true")
-        return true;
-    if (t === "false")
-        return false;
-    if (/^-?\d+$/.test(t))
-        return Number.parseInt(t, 10);
-    if (/^-?\d+\.\d+$/.test(t))
-        return Number.parseFloat(t);
-    return unquote(t);
-}
-function parseArrayLiteral(v) {
-    const trimmed = v.trim();
-    if (!trimmed.startsWith("[") || !trimmed.endsWith("]"))
-        return null;
-    const inner = trimmed.slice(1, -1).trim();
-    if (!inner)
-        return [];
-    // Array of inline tables: [{ pattern = "x", replacement = "y" }, ...]
-    if (inner.includes("{")) {
-        const tables = [];
-        let depth = 0;
-        let start = -1;
-        for (let i = 0; i < inner.length; i++) {
-            const ch = inner[i];
-            if (ch === "{") {
-                if (depth === 0)
-                    start = i + 1;
-                depth++;
-            }
-            else if (ch === "}") {
-                depth--;
-                if (depth === 0 && start >= 0) {
-                    const body = inner.slice(start, i);
-                    const obj = {};
-                    for (const pair of body.split(",")) {
-                        const eq = pair.indexOf("=");
-                        if (eq < 0)
-                            continue;
-                        const k = pair.slice(0, eq).trim();
-                        const val = pair.slice(eq + 1).trim();
-                        obj[k] = parseScalar(val);
-                    }
-                    tables.push(obj);
-                }
-            }
-        }
-        return tables;
-    }
-    // Simple string/number array
-    return inner
-        .split(/,\s*/)
-        .map((s) => s.trim())
-        .filter(Boolean)
-        .map(parseScalar);
-}
-function parseToml(src) {
-    const sections = [];
-    let current = null;
-    // Join continuation lines for arrays that span multiple lines
-    const compactLines = [];
-    let buf = "";
-    let depth = 0;
-    for (const rawLine of src.split("\n")) {
-        const line = rawLine.replace(/#.*$/, "");
-        if (depth > 0) {
-            buf += ` ${line.trim()}`;
-        }
-        else if (line.includes("[") && !line.match(/^\s*\[[^=]*\]\s*$/)) {
-            // Likely the start of an inline-table array or multi-line array
-            buf = line;
-        }
-        else {
-            compactLines.push(line);
-            continue;
-        }
-        for (const ch of line) {
-            if (ch === "[")
-                depth++;
-            else if (ch === "]")
-                depth--;
-        }
-        if (depth <= 0) {
-            compactLines.push(buf);
-            buf = "";
-            depth = 0;
-        }
-    }
-    if (buf)
-        compactLines.push(buf);
-    for (const rawLine of compactLines) {
-        const line = rawLine.trim();
-        if (!line)
-            continue;
-        const sectionMatch = line.match(/^\[([^\]]+)\]\s*$/);
-        if (sectionMatch?.[1]) {
-            if (current)
-                sections.push(current);
-            current = { name: sectionMatch[1], values: {} };
-            continue;
-        }
-        if (!current)
-            continue;
-        const eq = line.indexOf("=");
-        if (eq < 0)
-            continue;
-        const key = line.slice(0, eq).trim();
-        const rest = line.slice(eq + 1).trim();
-        const arr = parseArrayLiteral(rest);
-        current.values[key] = arr ?? parseScalar(rest);
-    }
-    if (current)
-        sections.push(current);
-    return sections;
-}
-// ─── Loading + compilation ─────────────────────────────────────────────────
-function compileOne(name, raw) {
-    const mc = raw.match_command;
-    if (typeof mc !== "string" || !mc)
-        return null;
-    let matchCommand;
-    try {
-        matchCommand = new RegExp(mc);
-    }
-    catch {
-        return null;
-    }
-    const toRegexes = (arr) => {
-        if (!Array.isArray(arr))
-            return undefined;
-        const out = [];
-        for (const s of arr) {
-            if (typeof s !== "string")
-                continue;
-            try {
-                out.push(new RegExp(s));
-            }
-            catch {
-                // skip bad regex
-            }
-        }
-        return out.length > 0 ? out : undefined;
-    };
-    const toReplace = (arr) => {
-        if (!Array.isArray(arr))
-            return undefined;
-        const out = [];
-        for (const item of arr) {
-            if (item &&
-                typeof item === "object" &&
-                typeof item.pattern === "string") {
-                const p = item.pattern;
-                const r = item.replacement;
-                try {
-                    out.push({ pattern: new RegExp(p, "g"), replacement: r ?? "" });
-                }
-                catch {
-                    // skip
-                }
-            }
-        }
-        return out.length > 0 ? out : undefined;
-    };
-    const toShortCircuit = (arr) => {
-        if (!Array.isArray(arr))
-            return undefined;
-        const out = [];
-        for (const item of arr) {
-            if (item &&
-                typeof item === "object" &&
-                typeof item.pattern === "string") {
-                const p = item.pattern;
-                const m = item.message ??
-                    "ok";
-                try {
-                    out.push({ pattern: new RegExp(p), message: m });
-                }
-                catch {
-                    // skip
-                }
-            }
-        }
-        return out.length > 0 ? out : undefined;
-    };
-    const f = {
-        name,
-        match_command: mc,
-        strip_lines_matching: Array.isArray(raw.strip_lines_matching)
-            ? raw.strip_lines_matching.filter((x) => typeof x === "string")
-            : undefined,
-        keep_lines_matching: Array.isArray(raw.keep_lines_matching)
-            ? raw.keep_lines_matching.filter((x) => typeof x === "string")
-            : undefined,
-        replace: Array.isArray(raw.replace)
-            ? raw.replace
-            : undefined,
-        match_output: Array.isArray(raw.match_output)
-            ? raw.match_output
-            : undefined,
-        truncate_lines_at: typeof raw.truncate_lines_at === "number"
-            ? raw.truncate_lines_at
-            : undefined,
-        max_lines: typeof raw.max_lines === "number" ? raw.max_lines : undefined,
-        tail_lines: typeof raw.tail_lines === "number" ? raw.tail_lines : undefined,
-        filter_stderr: typeof raw.filter_stderr === "boolean" ? raw.filter_stderr : undefined,
-        on_empty: typeof raw.on_empty === "string" ? raw.on_empty : undefined,
-        strip_ansi: typeof raw.strip_ansi === "boolean" ? raw.strip_ansi : undefined,
-    };
-    return {
-        raw: f,
-        matchCommand,
-        strip: toRegexes(raw.strip_lines_matching),
-        keep: toRegexes(raw.keep_lines_matching),
-        replace: toReplace(raw.replace),
-        shortCircuit: toShortCircuit(raw.match_output),
-    };
-}
-function loadFilters(cwd) {
-    const repoPath = join(cwd, ".unerr", "filters.toml");
-    const userPath = join(homedir(), ".config", "unerr", "filters.toml");
-    const key = `${repoPath}|${userPath}`;
-    if (cachedFilters && cacheKey === key)
-        return cachedFilters;
-    const sources = [readFile(repoPath), readFile(userPath)].filter((s) => Boolean(s));
-    const compiled = [];
-    for (const src of sources) {
-        const sections = parseToml(src);
-        for (const section of sections) {
-            if (!section.name.startsWith("filters."))
-                continue;
-            const name = section.name.slice("filters.".length);
-            const c = compileOne(name, section.values);
-            if (c)
-                compiled.push(c);
-        }
-    }
-    cachedFilters = compiled;
-    cacheKey = key;
-    return compiled;
-}
-/**
- * Apply the first matching user filter to the output. Returns null if no
- * filter matches — caller falls through to the built-in classifier.
- */
-export function applyUserFilter(command, stdout, cwd) {
-    const filters = loadFilters(cwd);
-    if (filters.length === 0)
-        return null;
-    const filter = filters.find((f) => f.matchCommand.test(command));
-    if (!filter)
-        return null;
-    // Short-circuit on success patterns first
-    if (filter.shortCircuit) {
-        for (const sc of filter.shortCircuit) {
-            if (sc.pattern.test(stdout)) {
-                return {
-                    text: `_shell_fmt:user_filter\n${sc.message}`,
-                    name: filter.raw.name,
-                };
-            }
-        }
-    }
-    let text = stdout;
-    // Replace
-    if (filter.replace) {
-        for (const r of filter.replace) {
-            text = text.replace(r.pattern, r.replacement);
-        }
-    }
-    // Strip / keep
-    let lines = text.split("\n");
-    if (filter.strip) {
-        lines = lines.filter((l) => !filter.strip?.some((r) => r.test(l)));
-    }
-    if (filter.keep) {
-        lines = lines.filter((l) => filter.keep?.some((r) => r.test(l)));
-    }
-    // Truncate long lines
-    if (filter.raw.truncate_lines_at) {
-        const limit = filter.raw.truncate_lines_at;
-        lines = lines.map((l) => (l.length > limit ? `${l.slice(0, limit)}…` : l));
-    }
-    // Window
-    if (filter.raw.tail_lines && lines.length > filter.raw.tail_lines) {
-        lines = [
-            `… (${lines.length - filter.raw.tail_lines} earlier lines suppressed)`,
-            ...lines.slice(-filter.raw.tail_lines),
-        ];
-    }
-    else if (filter.raw.max_lines && lines.length > filter.raw.max_lines) {
-        lines = [
-            ...lines.slice(0, filter.raw.max_lines),
-            `… (${lines.length - filter.raw.max_lines} more lines suppressed)`,
-        ];
-    }
-    text = lines.join("\n").trim();
-    if (!text && filter.raw.on_empty) {
-        text = filter.raw.on_empty;
-    }
-    return {
-        text: `_shell_fmt:user_filter[${filter.raw.name}]\n${text}`,
-        name: filter.raw.name,
-    };
-}
-/** Test helper — flush cache so repeated calls in tests pick up new files. */
-export function _clearFilterCache() {
-    cachedFilters = null;
-    cacheKey = "";
-}

package/dist/proxy/shell-strategies/git-status.js

@@ -1,177 +0,0 @@
-/**
- * Dedicated `git status` parser (Fix F2 from the verification report).
- *
- * Default git status output is mostly boilerplate help text in parens
- * ("(use git add ...)") that an agent does not need. Each section
- * (modified, untracked, staged, deleted) has a predictable shape that
- * compresses well with grouping by directory.
- *
- * Falls back to null on porcelain v2 / unrecognized formats so the caller
- * can defer to the generic strategy.
- */
-const HELP_RE = /^\s*\(use\b.*\)\s*$/i;
-const BRANCH_RE = /^On branch (.+)$/;
-const TRACKING_RE = /^Your branch is (.+)$/;
-const SECTION_HEADERS = new Map([
-    ["Changes to be committed:", "staged"],
-    ["Changes not staged for commit:", "modified"],
-    ["Untracked files:", "untracked"],
-    ["Unmerged paths:", "unmerged"],
-]);
-function extOf(path) {
-    const base = path.slice(path.lastIndexOf("/") + 1);
-    const dot = base.lastIndexOf(".");
-    if (dot <= 0 || dot === base.length - 1)
-        return "(no-ext)";
-    return base.slice(dot).toLowerCase();
-}
-function dirOf(path) {
-    const i = path.lastIndexOf("/");
-    return i >= 0 ? `${path.slice(0, i)}/` : "./";
-}
-function topExt(byExt, k = 3) {
-    const sorted = [...byExt.entries()].sort((a, b) => b[1] - a[1]);
-    return sorted
-        .slice(0, k)
-        .map(([ext, n]) => `${n} ${ext}`)
-        .join(", ");
-}
-/**
- * Compress a `git status` output. Returns null if input doesn't look like
- * default git status output.
- */
-export function compressGitStatus(raw) {
-    const lines = raw.replace(/\r\n/g, "\n").split("\n");
-    if (lines.length === 0)
-        return null;
-    // Quick fingerprint check
-    if (!lines.some((l) => /^On branch /.test(l) || /^HEAD detached/.test(l))) {
-        return null;
-    }
-    let branch = "";
-    let tracking = "";
-    let currentBucket = null;
-    const buckets = {
-        staged: { files: [], statuses: new Map() },
-        modified: { files: [], statuses: new Map() },
-        untracked: { files: [], statuses: new Map() },
-        unmerged: { files: [], statuses: new Map() },
-    };
-    let trailingMsg = "";
-    for (const line of lines) {
-        if (!line.trim())
-            continue;
-        if (HELP_RE.test(line))
-            continue; // strip "(use git add ...)" help blocks
-        const branchMatch = line.match(BRANCH_RE);
-        if (branchMatch) {
-            branch = branchMatch[1] ?? "";
-            continue;
-        }
-        const trackingMatch = line.match(TRACKING_RE);
-        if (trackingMatch) {
-            tracking = trackingMatch[1] ?? "";
-            continue;
-        }
-        const sectionKey = SECTION_HEADERS.get(line.trim());
-        if (sectionKey) {
-            currentBucket = sectionKey;
-            continue;
-        }
-        // Trailing summary like "no changes added to commit (use ...)" terminates
-        // any open section so it doesn't get misread as an untracked path.
-        if (/^(?:no changes added to commit|nothing to commit|nothing added|on branch \S+ nothing|.*working tree clean)/i.test(line.trim())) {
-            // Strip trailing "(use 'git add' ...)" boilerplate from the footer
-            trailingMsg = line
-                .trim()
-                .replace(/\s*\(use\b[^)]*\)\s*/g, "")
-                .trim();
-            currentBucket = null;
-            continue;
-        }
-        if (currentBucket) {
-            // Real file lines are tab-indented in git's default output. Anything
-            // un-indented after a section header is footer text, not a file.
-            if (!line.startsWith("\t") && !line.startsWith("    ")) {
-                currentBucket = null;
-                continue;
-            }
-            const stripped = line.replace(/^\t/, "").trim();
-            if (!stripped)
-                continue;
-            const m = stripped.match(/^([a-zA-Z ]+):\s+(.+?)(?:\s+->\s+(.+))?$/);
-            if (m) {
-                const status = m[1]?.trim() ?? "";
-                const path = (m[3] ?? m[2] ?? "").trim();
-                buckets[currentBucket].files.push(path);
-                buckets[currentBucket].statuses.set(status, (buckets[currentBucket].statuses.get(status) ?? 0) + 1);
-            }
-            else {
-                // Untracked section: each line is just a path
-                buckets[currentBucket].files.push(stripped);
-            }
-        }
-    }
-    const totalFiles = buckets.staged.files.length +
-        buckets.modified.files.length +
-        buckets.untracked.files.length +
-        buckets.unmerged.files.length;
-    // If we didn't recognize any files, this isn't a format we handle —
-    // let the generic strategy take it.
-    if (totalFiles === 0 && !branch)
-        return null;
-    const out = ["_shell_fmt:git_status"];
-    const branchLine = branch
-        ? tracking
-            ? `branch=${branch}; ${tracking}`
-            : `branch=${branch}`
-        : "";
-    if (branchLine)
-        out.push(branchLine);
-    // Per-section rollup: list files individually if ≤6, otherwise group by dir
-    const sectionOrder = [
-        "staged",
-        "modified",
-        "untracked",
-        "unmerged",
-    ];
-    for (const bucket of sectionOrder) {
-        const b = buckets[bucket];
-        if (b.files.length === 0)
-            continue;
-        const statusSummary = b.statuses.size > 0
-            ? ` (${[...b.statuses.entries()].map(([s, n]) => `${n} ${s}`).join(", ")})`
-            : "";
-        out.push(`${bucket}: ${b.files.length}${statusSummary}`);
-        if (b.files.length <= 6) {
-            // Small list — show each file
-            for (const f of b.files)
-                out.push(`  ${f}`);
-        }
-        else {
-            // Big list — group by directory
-            const byDir = new Map();
-            for (const f of b.files) {
-                const dir = dirOf(f);
-                let agg = byDir.get(dir);
-                if (!agg) {
-                    agg = { total: 0, byExt: new Map() };
-                    byDir.set(dir, agg);
-                }
-                agg.total++;
-                const ext = extOf(f);
-                agg.byExt.set(ext, (agg.byExt.get(ext) ?? 0) + 1);
-            }
-            const sortedDirs = [...byDir.entries()].sort((a, b2) => b2[1].total - a[1].total);
-            for (const [dir, agg] of sortedDirs.slice(0, 8)) {
-                out.push(`  ${dir} (${agg.total}: ${topExt(agg.byExt)})`);
-            }
-            if (sortedDirs.length > 8) {
-                out.push(`  … ${sortedDirs.length - 8} more directories`);
-            }
-        }
-    }
-    if (trailingMsg)
-        out.push(trailingMsg);
-    return out.join("\n");
-}