@unerr-ai/unerr 0.1.0 → 0.1.2

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

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

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