@nxuss/lemma 1.4.0 → 1.6.0

package/dist/cjs/utils/CommandOutputDistiller.d.ts

@@ -0,0 +1,75 @@
+/**
+ * CommandOutputDistiller — turns raw build/test/lint output into the few lines a model
+ * actually needs, without ever losing the rest.
+ *
+ * The problem it solves: a failing `npm test` dumps thousands of lines into the model's
+ * context, of which maybe thirty carry signal (which tests failed, why, and where). The
+ * other 99% is code frames the model can read from the file itself, passing-test noise,
+ * and node_modules stack frames.
+ *
+ * Two rules this module is built around:
+ *
+ *  1. Deterministic only. Every parser here is a grammar over a known reporter format —
+ *     no LLM summarization. A summarizer that hallucinates a test name is worse than the
+ *     raw dump it replaced.
+ *  2. Lossless on demand. The complete output is always written to disk first and the
+ *     distilled view carries a handle back to it, so anything trimmed can be retrieved
+ *     verbatim (see `readRegion`). Nothing is silently dropped.
+ */
+export type OutputFormat = "jest" | "vitest" | "tsc" | "eslint" | "generic";
+/** A named, retrievable slice of the raw output (1-indexed, inclusive). */
+export interface OutputSection {
+    name: string;
+    startLine: number;
+    endLine: number;
+}
+export interface DistilledOutput {
+    format: OutputFormat;
+    /** The text to hand to the model. */
+    text: string;
+    /** Null when the output was small enough to pass through untouched. */
+    handle: string | null;
+    originalChars: number;
+    distilledChars: number;
+    originalLines: number;
+    sections: OutputSection[];
+}
+/**
+ * Persist the complete output and return its handle. Written before anything is trimmed,
+ * so a distilled view can never reference output that was never saved.
+ */
+export declare function storeRawOutput(raw: string, command: string, format: OutputFormat, sections: OutputSection[]): string;
+export interface RegionRequest {
+    handle: string;
+    /** Name of a section reported by the distiller (e.g. a failing test title). Prefix match, case-insensitive. */
+    section?: string;
+    startLine?: number;
+    endLine?: number;
+    /** Return the entire stored output. */
+    all?: boolean;
+}
+export interface RegionResult {
+    found: boolean;
+    command?: string;
+    totalLines?: number;
+    startLine?: number;
+    endLine?: number;
+    text?: string;
+    /** Section names available for this handle, so a failed lookup can be retried precisely. */
+    availableSections?: string[];
+    error?: string;
+}
+/** Retrieve raw output verbatim — the escape hatch that makes distillation lossless. */
+export declare function readRegion(req: RegionRequest): RegionResult;
+export declare function detectFormat(raw: string): OutputFormat;
+export interface DistillOptions {
+    command: string;
+    /** Skip distillation entirely and return the raw output (still stored). */
+    raw?: boolean;
+    /** Outputs at or below this size pass through untouched. */
+    thresholdChars?: number;
+}
+export declare function distillCommandOutput(rawOutput: string, options: DistillOptions): DistilledOutput;
+/** The footer that tells the model — and the user — that this view is not the whole output. */
+export declare function buildDistillFooter(d: DistilledOutput): string;
+//# sourceMappingURL=CommandOutputDistiller.d.ts.map

package/dist/cjs/utils/CommandOutputDistiller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CommandOutputDistiller.d.ts","sourceRoot":"","sources":["../../../src/utils/CommandOutputDistiller.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAwBH,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG,QAAQ,GAAG,KAAK,GAAG,QAAQ,GAAG,SAAS,CAAC;AAE5E,2EAA2E;AAC3E,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,YAAY,CAAC;IACrB,qCAAqC;IACrC,IAAI,EAAE,MAAM,CAAC;IACb,uEAAuE;IACvE,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,aAAa,EAAE,MAAM,CAAC;IACtB,cAAc,EAAE,MAAM,CAAC;IACvB,aAAa,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,aAAa,EAAE,CAAC;CAC3B;AAoDD;;;GAGG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,YAAY,EAAE,QAAQ,EAAE,aAAa,EAAE,GAAG,MAAM,CAepH;AAED,MAAM,WAAW,aAAa;IAC5B,MAAM,EAAE,MAAM,CAAC;IACf,+GAA+G;IAC/G,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,uCAAuC;IACvC,GAAG,CAAC,EAAE,OAAO,CAAC;CACf;AAED,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,OAAO,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,4FAA4F;IAC5F,iBAAiB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC7B,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,wFAAwF;AACxF,wBAAgB,UAAU,CAAC,GAAG,EAAE,aAAa,GAAG,YAAY,CAyD3D;AAWD,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,YAAY,CAUtD;AAgYD,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,MAAM,CAAC;IAChB,2EAA2E;IAC3E,GAAG,CAAC,EAAE,OAAO,CAAC;IACd,4DAA4D;IAC5D,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,wBAAgB,oBAAoB,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,cAAc,GAAG,eAAe,CAgEhG;AAED,+FAA+F;AAC/F,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,eAAe,GAAG,MAAM,CAc7D"}

package/dist/cjs/utils/CommandOutputDistiller.js

@@ -0,0 +1,598 @@
+"use strict";
+/**
+ * CommandOutputDistiller — turns raw build/test/lint output into the few lines a model
+ * actually needs, without ever losing the rest.
+ *
+ * The problem it solves: a failing `npm test` dumps thousands of lines into the model's
+ * context, of which maybe thirty carry signal (which tests failed, why, and where). The
+ * other 99% is code frames the model can read from the file itself, passing-test noise,
+ * and node_modules stack frames.
+ *
+ * Two rules this module is built around:
+ *
+ *  1. Deterministic only. Every parser here is a grammar over a known reporter format —
+ *     no LLM summarization. A summarizer that hallucinates a test name is worse than the
+ *     raw dump it replaced.
+ *  2. Lossless on demand. The complete output is always written to disk first and the
+ *     distilled view carries a handle back to it, so anything trimmed can be retrieved
+ *     verbatim (see `readRegion`). Nothing is silently dropped.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.storeRawOutput = storeRawOutput;
+exports.readRegion = readRegion;
+exports.detectFormat = detectFormat;
+exports.distillCommandOutput = distillCommandOutput;
+exports.buildDistillFooter = buildDistillFooter;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const crypto_1 = __importDefault(require("crypto"));
+/** Outputs at or under this size are returned untouched — distilling them saves nothing. */
+const DISTILL_THRESHOLD_CHARS = 3000;
+/** Max failing-test blocks rendered inline before we point at the handle for the rest. */
+const MAX_FAILURES_INLINE = 20;
+/** Max lines kept from a single failure's reason/diff body. */
+const MAX_REASON_LINES = 14;
+/** Max tsc/eslint entries rendered per file. */
+const MAX_ENTRIES_PER_FILE = 10;
+/** Head/tail lines kept by the generic fallback. */
+const GENERIC_EDGE_LINES = 25;
+/** Max matched "interesting" lines the generic fallback keeps from the middle. */
+const MAX_GENERIC_SIGNAL_LINES = 60;
+/** How many stored outputs to keep on disk before pruning the oldest. */
+const MAX_STORED_OUTPUTS = 30;
+const STORE_DIR = path_1.default.join(os_1.default.tmpdir(), "lemma-command-output");
+// ── Storage ────────────────────────────────────────────────────────────────────
+function storePathFor(handle, ext) {
+    return path_1.default.join(STORE_DIR, `${handle}.${ext}`);
+}
+function pruneStore() {
+    let entries;
+    try {
+        entries = fs_1.default.readdirSync(STORE_DIR).filter((f) => f.endsWith(".txt"));
+    }
+    catch {
+        return;
+    }
+    if (entries.length <= MAX_STORED_OUTPUTS)
+        return;
+    const withTime = entries
+        .map((f) => {
+        const full = path_1.default.join(STORE_DIR, f);
+        try {
+            return { full, base: full.slice(0, -4), mtime: fs_1.default.statSync(full).mtimeMs };
+        }
+        catch {
+            return null;
+        }
+    })
+        .filter((e) => e !== null)
+        .sort((a, b) => a.mtime - b.mtime);
+    for (const stale of withTime.slice(0, withTime.length - MAX_STORED_OUTPUTS)) {
+        try {
+            fs_1.default.unlinkSync(stale.full);
+        }
+        catch {
+            /* already gone */
+        }
+        try {
+            fs_1.default.unlinkSync(`${stale.base}.json`);
+        }
+        catch {
+            /* no sidecar */
+        }
+    }
+}
+/**
+ * Persist the complete output and return its handle. Written before anything is trimmed,
+ * so a distilled view can never reference output that was never saved.
+ */
+function storeRawOutput(raw, command, format, sections) {
+    fs_1.default.mkdirSync(STORE_DIR, { recursive: true });
+    const handle = crypto_1.default.randomBytes(6).toString("hex");
+    const meta = {
+        handle,
+        command,
+        createdAt: Date.now(),
+        totalLines: raw.split("\n").length,
+        format,
+        sections,
+    };
+    fs_1.default.writeFileSync(storePathFor(handle, "txt"), raw, "utf8");
+    fs_1.default.writeFileSync(storePathFor(handle, "json"), JSON.stringify(meta, null, 2), "utf8");
+    pruneStore();
+    return handle;
+}
+/** Retrieve raw output verbatim — the escape hatch that makes distillation lossless. */
+function readRegion(req) {
+    const txtPath = storePathFor(req.handle, "txt");
+    const jsonPath = storePathFor(req.handle, "json");
+    if (!fs_1.default.existsSync(txtPath)) {
+        return {
+            found: false,
+            error: `No stored output for handle "${req.handle}". Handles live in the OS temp dir and are pruned after ${MAX_STORED_OUTPUTS} newer runs — re-run the command to get a fresh one.`,
+        };
+    }
+    const raw = fs_1.default.readFileSync(txtPath, "utf8");
+    const lines = raw.split("\n");
+    let meta = null;
+    try {
+        meta = JSON.parse(fs_1.default.readFileSync(jsonPath, "utf8"));
+    }
+    catch {
+        meta = null;
+    }
+    const sections = meta?.sections ?? [];
+    const available = sections.map((s) => s.name);
+    let start = 1;
+    let end = lines.length;
+    if (req.all) {
+        // full range
+    }
+    else if (req.section) {
+        const needle = req.section.toLowerCase();
+        const hit = sections.find((s) => s.name.toLowerCase() === needle) ??
+            sections.find((s) => s.name.toLowerCase().includes(needle));
+        if (!hit) {
+            return {
+                found: false,
+                error: `No section matching "${req.section}" in handle ${req.handle}.`,
+                availableSections: available,
+                command: meta?.command,
+                totalLines: lines.length,
+            };
+        }
+        start = hit.startLine;
+        end = hit.endLine;
+    }
+    else if (req.startLine !== undefined || req.endLine !== undefined) {
+        start = Math.max(1, req.startLine ?? 1);
+        end = Math.min(lines.length, req.endLine ?? lines.length);
+        if (end < start)
+            return { found: false, error: `endLine (${end}) is before startLine (${start}).` };
+    }
+    return {
+        found: true,
+        command: meta?.command,
+        totalLines: lines.length,
+        startLine: start,
+        endLine: end,
+        text: lines.slice(start - 1, end).join("\n"),
+        availableSections: available,
+    };
+}
+// ── Format detection ───────────────────────────────────────────────────────────
+// All three carry the `m` flag so they work both per-line (`line.match(...)`) and as a
+// format probe against the whole output (`re.test(raw)`) — without it, detection silently
+// never matched anything but the first line.
+const JEST_FAILURE_HEADER = /^\s{2}● (?!Console\b)(.+)$/m;
+const TSC_ERROR = /^(.+?)\((\d+),(\d+)\): (error|warning) (TS\d+): (.*)$/m;
+const ESLINT_LOCATION = /^\s+(\d+):(\d+)\s+(error|warning)\s+(.+?)\s{2,}([\w@/-]+)\s*$/m;
+function detectFormat(raw) {
+    if (/^\s*(Test Suites|Tests):\s+\d/m.test(raw) || JEST_FAILURE_HEADER.test(raw))
+        return "jest";
+    // Vitest's default reporter labels its own summary block; checked after jest because a
+    // jest run never emits these markers.
+    if (/^\s*(Test Files|Tests)\s+\d+ (passed|failed)/m.test(raw) || /⎯+\s*Failed Tests?\s*\d*\s*⎯+/.test(raw)) {
+        return "vitest";
+    }
+    if (TSC_ERROR.test(raw))
+        return "tsc";
+    if (ESLINT_LOCATION.test(raw) && /^\/.*\.(ts|tsx|js|jsx|mjs|cjs)$/m.test(raw))
+        return "eslint";
+    return "generic";
+}
+// ── Helpers ────────────────────────────────────────────────────────────────────
+function isProjectFrame(line) {
+    return !line.includes("node_modules") && !line.includes("internal/");
+}
+/**
+ * Strip jest/vitest code frames — numbered source lines the model can read from the file
+ * itself. Covers jest's `> 5 |  expect(...)` and vitest's `  4| expect(...)`, plus the
+ * caret pointer line under either.
+ */
+function isCodeFrameLine(line) {
+    return /^\s*>?\s*\d+\s*\|/.test(line) || /^\s*\|\s*\^/.test(line);
+}
+function truncateBlock(lines, max) {
+    if (lines.length <= max)
+        return lines;
+    return [...lines.slice(0, max), `    … ${lines.length - max} more lines (use output_region)`];
+}
+function trimBlank(lines) {
+    let start = 0;
+    let end = lines.length;
+    while (start < end && lines[start].trim() === "")
+        start++;
+    while (end > start && lines[end - 1].trim() === "")
+        end--;
+    return lines.slice(start, end);
+}
+function collectJestFailures(lines) {
+    const blocks = [];
+    let current = null;
+    for (let i = 0; i < lines.length; i++) {
+        const m = lines[i].match(JEST_FAILURE_HEADER);
+        if (m) {
+            if (current) {
+                current.endLine = i; // previous block ends on the line before this header
+                blocks.push(current);
+            }
+            current = { title: m[1].trim(), startLine: i + 1, endLine: lines.length, body: [] };
+            continue;
+        }
+        // A summary line closes the last failure block.
+        if (current && /^(Test Suites|Tests|Snapshots|Time|Ran all test suites):/.test(lines[i])) {
+            current.endLine = i;
+            blocks.push(current);
+            current = null;
+            continue;
+        }
+        if (current)
+            current.body.push(lines[i]);
+    }
+    if (current)
+        blocks.push(current);
+    return blocks;
+}
+function distillJest(raw) {
+    const lines = raw.split("\n");
+    const failures = collectJestFailures(lines);
+    const sections = failures.map((f) => ({
+        name: f.title,
+        startLine: f.startLine,
+        endLine: f.endLine,
+    }));
+    const out = [];
+    const failedSuites = lines.filter((l) => /^\s*FAIL\s+/.test(l)).map((l) => l.trim());
+    if (failedSuites.length) {
+        out.push(`Failed suites (${failedSuites.length}):`);
+        for (const s of failedSuites.slice(0, 20))
+            out.push(`  ${s}`);
+        if (failedSuites.length > 20)
+            out.push(`  … ${failedSuites.length - 20} more`);
+        out.push("");
+    }
+    const shown = failures.slice(0, MAX_FAILURES_INLINE);
+    for (const f of shown) {
+        // Location: first project-local stack frame in the block.
+        const frame = f.body.find((l) => /^\s+at .*\(?[^\s]+:\d+:\d+\)?\s*$/.test(l) && isProjectFrame(l));
+        const loc = frame ? frame.trim().replace(/^at\s+/, "") : "";
+        // Reason: everything except code frames and stack frames.
+        const reason = trimBlank(f.body.filter((l) => {
+            if (isCodeFrameLine(l))
+                return false;
+            if (/^\s+at\s/.test(l))
+                return false;
+            return true;
+        }));
+        out.push(`✕ ${f.title}`);
+        if (loc)
+            out.push(`  ${loc}`);
+        for (const l of truncateBlock(reason, MAX_REASON_LINES))
+            out.push(l.trim() ? `  ${l}` : "");
+        out.push("");
+    }
+    if (failures.length > shown.length) {
+        out.push(`… ${failures.length - shown.length} more failing tests. Retrieve any of them with:`);
+        for (const f of failures.slice(MAX_FAILURES_INLINE, MAX_FAILURES_INLINE + 10)) {
+            out.push(`  output_region(section: "${f.title}")`);
+        }
+        out.push("");
+    }
+    const summary = lines.filter((l) => /^(Test Suites|Tests|Snapshots|Time|Test Files):/.test(l.trim()) || /^\s*(Tests|Test Files)\s+\d+ (passed|failed)/.test(l));
+    if (summary.length) {
+        out.push(...summary.map((l) => l.trim()));
+    }
+    if (!failures.length && !failedSuites.length) {
+        // A green run: the summary is the whole story.
+        const green = summary.length ? summary.map((l) => l.trim()) : ["Command produced no failures."];
+        return { text: green.join("\n"), sections };
+    }
+    return { text: trimBlank(out).join("\n"), sections };
+}
+// ── vitest ─────────────────────────────────────────────────────────────────────
+//
+// Vitest's default reporter is not jest's: failures are headed by
+// ` FAIL  file.test.ts > suite > test name`, the reason follows on the next line
+// (`AssertionError: …`), the location is a ` ❯ file:line:col` line, and blocks are
+// separated by `⎯⎯⎯[1/3]⎯` rules. Parsed separately rather than bent into the jest path.
+const VITEST_FAILURE_HEADER = /^\s*FAIL\s+(.+?)\s*$/;
+const VITEST_SEPARATOR = /^[⎯\-—_]{4,}(\[\d+\/\d+\])?[⎯\-—_]*\s*$/;
+const VITEST_LOCATION = /^\s*❯\s+(.+)$/;
+function distillVitest(raw) {
+    const lines = raw.split("\n");
+    const blocks = [];
+    let current = null;
+    const close = (endLine) => {
+        if (!current)
+            return;
+        current.endLine = endLine;
+        blocks.push(current);
+        current = null;
+    };
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const header = line.match(VITEST_FAILURE_HEADER);
+        // Only a header that names a test (`file > suite > test`) starts a block; the
+        // per-file `❯ fx.test.js (4 tests | 3 failed)` progress lines are not failures.
+        if (header && header[1].includes(">")) {
+            close(i);
+            current = { title: header[1].trim(), startLine: i + 1, endLine: lines.length, body: [] };
+            continue;
+        }
+        if (current && (VITEST_SEPARATOR.test(line) || /^\s*(Test Files|Tests|Duration|Start at)\s+\d/.test(line))) {
+            close(i);
+            continue;
+        }
+        if (current)
+            current.body.push(line);
+    }
+    close(lines.length);
+    const sections = blocks.map((b) => ({ name: b.title, startLine: b.startLine, endLine: b.endLine }));
+    const out = [];
+    const shown = blocks.slice(0, MAX_FAILURES_INLINE);
+    for (const b of shown) {
+        const locLine = b.body.find((l) => VITEST_LOCATION.test(l));
+        const loc = locLine ? locLine.match(VITEST_LOCATION)[1].trim() : "";
+        const reason = trimBlank(b.body.filter((l) => {
+            if (isCodeFrameLine(l))
+                return false;
+            if (VITEST_LOCATION.test(l))
+                return false;
+            if (VITEST_SEPARATOR.test(l))
+                return false;
+            return true;
+        }));
+        out.push(`✕ ${b.title}`);
+        if (loc)
+            out.push(`  ${loc}`);
+        for (const l of truncateBlock(reason, MAX_REASON_LINES))
+            out.push(l.trim() ? `  ${l}` : "");
+        out.push("");
+    }
+    if (blocks.length > shown.length) {
+        out.push(`… ${blocks.length - shown.length} more failing tests. Retrieve any of them with:`);
+        for (const b of blocks.slice(MAX_FAILURES_INLINE, MAX_FAILURES_INLINE + 10)) {
+            out.push(`  output_region(section: "${b.title}")`);
+        }
+        out.push("");
+    }
+    const summary = lines.filter((l) => /^\s*(Test Files|Tests|Duration)\s+\d/.test(l)).map((l) => l.trim());
+    if (summary.length)
+        out.push(...summary);
+    if (!blocks.length) {
+        return { text: (summary.length ? summary : ["Command produced no failures."]).join("\n"), sections };
+    }
+    return { text: trimBlank(out).join("\n"), sections };
+}
+// ── tsc ────────────────────────────────────────────────────────────────────────
+/** Positions shown for one repeated (code, message) pair before the rest are summarized. */
+const MAX_POSITIONS_PER_DIAGNOSTIC = 12;
+function distillTsc(raw) {
+    const lines = raw.split("\n");
+    const byFile = new Map();
+    const codeCounts = new Map();
+    let total = 0;
+    lines.forEach((line, index) => {
+        const m = line.match(TSC_ERROR);
+        if (!m)
+            return;
+        total++;
+        const file = m[1];
+        codeCounts.set(m[5], (codeCounts.get(m[5]) ?? 0) + 1);
+        if (!byFile.has(file))
+            byFile.set(file, []);
+        byFile.get(file).push({
+            line: Number(m[2]),
+            col: Number(m[3]),
+            severity: m[4],
+            code: m[5],
+            message: m[6],
+            index: index + 1,
+        });
+    });
+    if (total === 0)
+        return { text: trimBlank(lines).join("\n"), sections: [] };
+    const sections = [];
+    const out = [
+        `${total} TypeScript diagnostic${total === 1 ? "" : "s"} across ${byFile.size} file${byFile.size === 1 ? "" : "s"}.`,
+    ];
+    const topCodes = [...codeCounts.entries()].sort((a, b) => b[1] - a[1]).slice(0, 6);
+    out.push(`By code: ${topCodes.map(([c, n]) => `${c}×${n}`).join(", ")}`);
+    out.push("");
+    for (const [file, entries] of byFile) {
+        sections.push({ name: file, startLine: entries[0].index, endLine: entries[entries.length - 1].index });
+        out.push(`${file} (${entries.length})`);
+        // The same diagnostic repeated across 40 lines is one fact plus 40 positions, not
+        // 40 facts — printing the message once is the bulk of the saving on a broken build.
+        const grouped = new Map();
+        for (const e of entries) {
+            const key = `${e.severity} ${e.code} ${e.message}`;
+            if (!grouped.has(key))
+                grouped.set(key, { severity: e.severity, code: e.code, message: e.message, at: [] });
+            grouped.get(key).at.push(`${e.line}:${e.col}`);
+        }
+        for (const g of grouped.values()) {
+            const shown = g.at.slice(0, MAX_POSITIONS_PER_DIAGNOSTIC).join(", ");
+            const extra = g.at.length > MAX_POSITIONS_PER_DIAGNOSTIC ? `, +${g.at.length - MAX_POSITIONS_PER_DIAGNOSTIC} more` : "";
+            const count = g.at.length > 1 ? ` ×${g.at.length}` : "";
+            out.push(`  ${g.code}${count} ${g.severity}: ${g.message}`);
+            out.push(`    at ${shown}${extra}`);
+        }
+        if (grouped.size > 1 || entries.length > MAX_POSITIONS_PER_DIAGNOSTIC) {
+            out.push(`    (full list: output_region(section: "${file}"))`);
+        }
+    }
+    return { text: out.join("\n"), sections };
+}
+// ── eslint (stylish reporter) ──────────────────────────────────────────────────
+function distillEslint(raw) {
+    const lines = raw.split("\n");
+    const sections = [];
+    const out = [];
+    const ruleCounts = new Map();
+    let currentFile = null;
+    let fileStart = 0;
+    let fileEntries = [];
+    let totalProblems = 0;
+    const flush = (endIndex) => {
+        if (!currentFile)
+            return;
+        sections.push({ name: currentFile, startLine: fileStart, endLine: endIndex });
+        out.push(`${currentFile} (${fileEntries.length})`);
+        for (const e of fileEntries.slice(0, MAX_ENTRIES_PER_FILE))
+            out.push(`  ${e}`);
+        if (fileEntries.length > MAX_ENTRIES_PER_FILE) {
+            out.push(`  … ${fileEntries.length - MAX_ENTRIES_PER_FILE} more — output_region(section: "${currentFile}")`);
+        }
+        currentFile = null;
+        fileEntries = [];
+    };
+    lines.forEach((line, index) => {
+        if (/^\S/.test(line) && line.trim() && !/^\s*\d+:\d+/.test(line) && !/problems?\s*\(/.test(line)) {
+            flush(index);
+            currentFile = line.trim();
+            fileStart = index + 1;
+            return;
+        }
+        const m = line.match(ESLINT_LOCATION);
+        if (m && currentFile) {
+            totalProblems++;
+            ruleCounts.set(m[5], (ruleCounts.get(m[5]) ?? 0) + 1);
+            fileEntries.push(`${m[1]}:${m[2]}  ${m[3]}  ${m[4]}  ${m[5]}`);
+        }
+    });
+    flush(lines.length);
+    if (totalProblems === 0)
+        return { text: trimBlank(lines).join("\n"), sections: [] };
+    const topRules = [...ruleCounts.entries()].sort((a, b) => b[1] - a[1]).slice(0, 6);
+    const header = [
+        `${totalProblems} lint problem${totalProblems === 1 ? "" : "s"} across ${sections.length} file${sections.length === 1 ? "" : "s"}.`,
+        `Top rules: ${topRules.map(([r, n]) => `${r}×${n}`).join(", ")}`,
+        "",
+    ];
+    return { text: [...header, ...out].join("\n"), sections };
+}
+// ── generic fallback ───────────────────────────────────────────────────────────
+const SIGNAL_LINE = /(^|\W)(error|errors|failed|failure|exception|panic|fatal|ERR!|Cannot find|not found|undefined is not|Traceback|SyntaxError|refused)(\W|$)/i;
+function distillGeneric(raw) {
+    const lines = raw.split("\n");
+    const head = lines.slice(0, GENERIC_EDGE_LINES);
+    const tail = lines.slice(Math.max(GENERIC_EDGE_LINES, lines.length - GENERIC_EDGE_LINES));
+    const middleStart = GENERIC_EDGE_LINES;
+    const middleEnd = lines.length - GENERIC_EDGE_LINES;
+    const signal = [];
+    const seen = new Set();
+    for (let i = middleStart; i < middleEnd; i++) {
+        const line = lines[i];
+        if (!SIGNAL_LINE.test(line))
+            continue;
+        const key = line.trim();
+        if (!key || seen.has(key))
+            continue;
+        seen.add(key);
+        signal.push(`${i + 1}: ${line}`);
+        if (signal.length >= MAX_GENERIC_SIGNAL_LINES)
+            break;
+    }
+    const out = [];
+    out.push(...head);
+    const skipped = Math.max(0, middleEnd - middleStart);
+    if (skipped > 0) {
+        out.push("");
+        if (signal.length) {
+            out.push(`── ${skipped} middle lines withheld; lines matching error/failure below (with line numbers) ──`);
+            out.push(...signal);
+            if (signal.length >= MAX_GENERIC_SIGNAL_LINES)
+                out.push("… more matches withheld");
+        }
+        else {
+            out.push(`── ${skipped} middle lines withheld (no error/failure markers found) ──`);
+        }
+        out.push("");
+    }
+    out.push(...tail);
+    return { text: out.join("\n"), sections: [] };
+}
+function distillCommandOutput(rawOutput, options) {
+    const raw = rawOutput ?? "";
+    const originalChars = raw.length;
+    const originalLines = raw === "" ? 0 : raw.split("\n").length;
+    const threshold = options.thresholdChars ?? DISTILL_THRESHOLD_CHARS;
+    const format = detectFormat(raw);
+    // Small outputs: distilling costs more than it saves, and the raw text is already
+    // the most faithful thing we can hand back.
+    if (options.raw || originalChars <= threshold) {
+        return {
+            format,
+            text: raw,
+            handle: null,
+            originalChars,
+            distilledChars: originalChars,
+            originalLines,
+            sections: [],
+        };
+    }
+    let result;
+    switch (format) {
+        case "jest":
+            result = distillJest(raw);
+            break;
+        case "vitest":
+            result = distillVitest(raw);
+            break;
+        case "tsc":
+            result = distillTsc(raw);
+            break;
+        case "eslint":
+            result = distillEslint(raw);
+            break;
+        default:
+            result = distillGeneric(raw);
+    }
+    // If a parser somehow produced something no smaller than the original, the honest move
+    // is to hand back the original rather than a lossy view that saved nothing.
+    if (result.text.length >= originalChars) {
+        return {
+            format,
+            text: raw,
+            handle: null,
+            originalChars,
+            distilledChars: originalChars,
+            originalLines,
+            sections: result.sections,
+        };
+    }
+    const handle = storeRawOutput(raw, options.command, format, result.sections);
+    return {
+        format,
+        text: result.text,
+        handle,
+        originalChars,
+        distilledChars: result.text.length,
+        originalLines,
+        sections: result.sections,
+    };
+}
+/** The footer that tells the model — and the user — that this view is not the whole output. */
+function buildDistillFooter(d) {
+    if (!d.handle)
+        return "";
+    const pct = Math.round((1 - d.distilledChars / d.originalChars) * 100);
+    const lines = [
+        "",
+        `── distilled (${d.format}) — showing ${d.distilledChars} of ${d.originalChars} chars (${pct}% withheld, ${d.originalLines} lines total) ──`,
+        `Full output stored: handle "${d.handle}". Retrieve any part with output_region:`,
+        `  output_region({ handle: "${d.handle}", all: true })  — the complete original output`,
+    ];
+    if (d.sections.length) {
+        lines.push(`  output_region({ handle: "${d.handle}", section: "<name>" })  — one block verbatim`);
+    }
+    lines.push(`  output_region({ handle: "${d.handle}", startLine: N, endLine: M })  — a line range`);
+    return lines.join("\n");
+}
+//# sourceMappingURL=CommandOutputDistiller.js.map