shrinker-ai 0.1.0

package/dist/src/filters/git-log.js

@@ -0,0 +1,256 @@
+import { cleanText } from "../formatting/ansi.js";
+import { limitLines } from "../formatting/limits.js";
+const ONELINE_PATTERN = /^[0-9a-f]{7,40}(?:\s+\([^)]+\))?\s+\S/i;
+const BODY_LIMIT = 3;
+const TRAILER_PATTERN = /^(?:Signed-off-by|Co-authored-by):/i;
+const RAW_SHAPE_FLAGS = new Set([
+    "-L",
+    "-c",
+    "-p",
+    "-u",
+    "--cc",
+    "--dirstat",
+    "--name-only",
+    "--name-status",
+    "--numstat",
+    "--patch",
+    "--patch-with-raw",
+    "--patch-with-stat",
+    "--raw",
+    "--remerge-diff",
+    "--shortstat",
+    "--show-signature",
+    "--stat",
+    "--summary",
+]);
+const VALUE_FLAGS = new Set([
+    "-G",
+    "-L",
+    "-O",
+    "-S",
+    "-n",
+    "--after",
+    "--author",
+    "--before",
+    "--committer",
+    "--date",
+    "--encoding",
+    "--grep",
+    "--max-count",
+    "--since",
+    "--skip",
+    "--until",
+]);
+const SAFE_COMPACT_FLAGS = new Set([
+    "-E",
+    "-F",
+    "-i",
+    "-n",
+    "--all",
+    "--all-match",
+    "--ancestry-path",
+    "--author",
+    "--before",
+    "--branches",
+    "--committer",
+    "--date-order",
+    "--decorate",
+    "--exclude",
+    "--extended-regexp",
+    "--first-parent",
+    "--fixed-strings",
+    "--glob",
+    "--grep",
+    "--invert-grep",
+    "--max-count",
+    "--merges",
+    "--no-color",
+    "--no-decorate",
+    "--no-merges",
+    "--not",
+    "--remotes",
+    "--reverse",
+    "--since",
+    "--tags",
+    "--topo-order",
+    "--until",
+]);
+function gitLogFlags(command) {
+    const logIndex = command.findIndex((part) => part.toLowerCase() === "log");
+    if (logIndex < 0)
+        return [];
+    const flags = [];
+    for (let index = logIndex + 1; index < command.length; index += 1) {
+        const part = command[index];
+        if (!part || part === "--")
+            break;
+        if (part.startsWith("-")) {
+            flags.push(part);
+            if (VALUE_FLAGS.has(part))
+                index += 1;
+        }
+    }
+    return flags;
+}
+function requestsRawShape(flags) {
+    return flags.some((flag) => RAW_SHAPE_FLAGS.has(flag) ||
+        flag.startsWith("--stat=") ||
+        flag.startsWith("--dirstat="));
+}
+function requestsCustomFormat(flags) {
+    return flags.some((flag) => flag === "--oneline" ||
+        flag.startsWith("--pretty") ||
+        flag.startsWith("--format"));
+}
+function isSafeCompactFlag(flag) {
+    if (/^-\d+$/.test(flag))
+        return true;
+    if (flag.startsWith("--max-count=") ||
+        flag.startsWith("--author=") ||
+        flag.startsWith("--committer=") ||
+        flag.startsWith("--grep=") ||
+        flag.startsWith("--since=") ||
+        flag.startsWith("--after=") ||
+        flag.startsWith("--until=") ||
+        flag.startsWith("--before=") ||
+        flag.startsWith("--branches=") ||
+        flag.startsWith("--tags=") ||
+        flag.startsWith("--remotes=") ||
+        flag.startsWith("--glob=") ||
+        flag.startsWith("--exclude=") ||
+        flag.startsWith("--min-parents=") ||
+        flag.startsWith("--max-parents=") ||
+        flag.startsWith("--decorate=")) {
+        return true;
+    }
+    return SAFE_COMPACT_FLAGS.has(flag);
+}
+function hasStructuredLogDetails(lines) {
+    let afterSubject = false;
+    for (const line of lines) {
+        if (/^commit\s+[0-9a-f]{7,40}/i.test(line)) {
+            afterSubject = false;
+            continue;
+        }
+        if (/^Date:\s+/.test(line))
+            continue;
+        if (/^\s{4}\S/.test(line) && !afterSubject) {
+            afterSubject = true;
+            continue;
+        }
+        if (/^\s+\S.*\|\s+\d+/.test(line) ||
+            /^\s*\d+\s+files?\s+changed/.test(line) ||
+            /^\d+\s+\d+\s+\S/.test(line) ||
+            /^[ACDMRTUXB]\d*\s+\S/.test(line) ||
+            (afterSubject &&
+                line.trim() &&
+                !/^\s/.test(line) &&
+                !/^(?:Author|Merge):\s+/.test(line))) {
+            return true;
+        }
+    }
+    return false;
+}
+export function filterGitLog(input, options) {
+    const cleaned = cleanText(input);
+    const lines = cleaned.split("\n");
+    const flags = gitLogFlags(options.command ?? []);
+    if (requestsRawShape(flags) ||
+        requestsCustomFormat(flags) ||
+        flags.some((flag) => !isSafeCompactFlag(flag)) ||
+        lines.some((line) => line.startsWith("diff --git ")) ||
+        hasStructuredLogDetails(lines)) {
+        return {
+            output: cleaned,
+            kind: "git-log",
+            omitted: false,
+            notes: ["explicit Git output format preserved"],
+        };
+    }
+    if (lines.length > 0 && lines.every((line) => !line.trim() || ONELINE_PATTERN.test(line))) {
+        const limited = limitLines(lines.filter(Boolean), options.maxLines);
+        return {
+            output: limited.lines.join("\n"),
+            kind: "git-log",
+            omitted: limited.omitted > 0,
+            recovery: "always",
+            notes: limited.omitted > 0 ? [`omitted ${limited.omitted} commits`] : [],
+        };
+    }
+    const commits = [];
+    let current;
+    let phase = "metadata";
+    for (const rawLine of lines) {
+        const commitMatch = rawLine.match(/^commit\s+([0-9a-f]{7,40})(?:\s+\(([^)]+)\))?/i);
+        if (commitMatch) {
+            current = {
+                hash: (commitMatch[1] ?? "").slice(0, 10),
+                ...(commitMatch[2] ? { refs: commitMatch[2] } : {}),
+                body: [],
+            };
+            commits.push(current);
+            phase = "metadata";
+            continue;
+        }
+        if (!current)
+            continue;
+        const authorMatch = rawLine.match(/^Author:\s+(.+?)(?:\s+<[^>]+>)?$/);
+        const author = authorMatch?.[1];
+        if (author) {
+            current.author = author.trim();
+            continue;
+        }
+        const dateMatch = rawLine.match(/^Date:\s+(.+)$/);
+        const date = dateMatch?.[1];
+        if (date) {
+            const parsed = new Date(date);
+            current.date = Number.isNaN(parsed.valueOf()) ? date.trim() : parsed.toISOString().slice(0, 10);
+            phase = "subject";
+            continue;
+        }
+        const content = rawLine.trim();
+        if (phase === "subject" && content) {
+            current.subject = content;
+            phase = "body";
+        }
+        else if (phase === "body" && content && !TRAILER_PATTERN.test(content)) {
+            current.body.push(content);
+        }
+    }
+    if (commits.length === 0 || commits.some((commit) => !commit.subject)) {
+        const limited = limitLines(lines, options.maxLines);
+        return {
+            output: limited.lines.join("\n"),
+            kind: "git-log",
+            omitted: limited.omitted > 0,
+            recovery: "always",
+            notes: ["unrecognized log format; returned cleaned output"],
+        };
+    }
+    let omittedBodyLines = 0;
+    const compact = commits.flatMap((commit) => {
+        const refs = commit.refs ? ` (${commit.refs})` : "";
+        const details = [commit.author, commit.date].filter(Boolean).join(", ");
+        const header = `${commit.hash}${refs} ${commit.subject}${details ? ` — ${details}` : ""}`;
+        const body = commit.body.slice(0, BODY_LIMIT).map((line) => `  ${line}`);
+        const omitted = Math.max(0, commit.body.length - BODY_LIMIT);
+        omittedBodyLines += omitted;
+        if (omitted > 0)
+            body.push(`  [+${omitted} body ${omitted === 1 ? "line" : "lines"} omitted]`);
+        return [header, ...body];
+    });
+    const limited = limitLines(compact, options.maxLines);
+    const meaningfulOmission = omittedBodyLines > 0 || limited.omitted > 0;
+    return {
+        output: limited.lines.join("\n"),
+        kind: "git-log",
+        omitted: true,
+        recovery: meaningfulOmission ? "always" : "threshold",
+        notes: limited.omitted > 0
+            ? [`omitted verbose metadata and ${limited.omitted} output lines`]
+            : omittedBodyLines > 0
+                ? [`omitted verbose metadata and ${omittedBodyLines} body lines`]
+                : ["omitted verbose metadata"],
+    };
+}
+//# sourceMappingURL=git-log.js.map

package/dist/src/filters/git-status.js

@@ -0,0 +1,67 @@
+import { cleanText } from "../formatting/ansi.js";
+import { limitLines } from "../formatting/limits.js";
+const SECTION_MAP = [
+    [/^Changes to be committed:/i, "staged"],
+    [/^Changes not staged for commit:/i, "unstaged"],
+    [/^Untracked files:/i, "untracked"],
+    [/^Unmerged paths:/i, "conflicts"],
+];
+export function filterGitStatus(input, options) {
+    const lines = cleanText(input).split("\n");
+    const branch = [];
+    const groups = new Map();
+    let currentSection;
+    for (const rawLine of lines) {
+        const line = rawLine.trim();
+        if (!line)
+            continue;
+        if (line.startsWith("(") ||
+            line.startsWith("no changes added") ||
+            line.startsWith("nothing to commit")) {
+            continue;
+        }
+        const section = SECTION_MAP.find(([pattern]) => pattern.test(line));
+        if (section) {
+            currentSection = section[1];
+            continue;
+        }
+        if (line.startsWith("On branch ") ||
+            line.startsWith("Your branch ") ||
+            line.startsWith("HEAD detached")) {
+            branch.push(line.replace(/^On branch /, "branch: "));
+            continue;
+        }
+        const fileMatch = line.match(/^(modified|new file|deleted|renamed|copied|both modified|added by us|deleted by them):\s+(.+)$/i);
+        if (fileMatch) {
+            const state = fileMatch[1] ?? "changed";
+            const path = fileMatch[2] ?? line;
+            const group = currentSection ?? "changed";
+            groups.set(group, [...(groups.get(group) ?? []), `${state}: ${path}`]);
+            continue;
+        }
+        if (currentSection === "untracked" && !line.startsWith("(")) {
+            groups.set("untracked", [...(groups.get("untracked") ?? []), line]);
+        }
+    }
+    const output = [...branch];
+    for (const [name, files] of groups) {
+        output.push(`${name} (${files.length}):`);
+        output.push(...files.map((file) => `  ${file}`));
+    }
+    if (output.length === 0) {
+        return {
+            output: lines.join("\n"),
+            kind: "git-status",
+            omitted: false,
+            notes: ["unrecognized status format; returned cleaned output"],
+        };
+    }
+    const limited = limitLines(output, options.maxLines);
+    return {
+        output: limited.lines.join("\n"),
+        kind: "git-status",
+        omitted: limited.omitted > 0 || output.join("\n").length < cleanText(input).length,
+        notes: [],
+    };
+}
+//# sourceMappingURL=git-status.js.map

package/dist/src/filters/kubectl.js

@@ -0,0 +1,76 @@
+import { cleanText } from "../formatting/ansi.js";
+import { limitLines } from "../formatting/limits.js";
+import { filterGenericLog } from "./generic-log.js";
+import { compactTable } from "./table.js";
+const IMPORTANT_PATTERN = /\b(error|failed|failure|fatal|warn(?:ing)?|exception|panic)\b/i;
+function detectSubcommand(command) {
+    const index = command.findIndex((part) => /(?:^|[\\/])kubectl(?:\.exe)?$/i.test(part));
+    if (index < 0)
+        return undefined;
+    return command[index + 1]?.toLowerCase();
+}
+function getOutputFormat(command) {
+    for (let index = 0; index < command.length; index += 1) {
+        const part = command[index];
+        if (part === "-o" || part === "--output") {
+            return command[index + 1]?.toLowerCase();
+        }
+        if (part?.startsWith("--output=")) {
+            return part.slice("--output=".length).toLowerCase();
+        }
+    }
+    return undefined;
+}
+export function filterKubectlOutput(input, options) {
+    const command = options.command ?? [];
+    const subcommand = detectSubcommand(command);
+    const outputFormat = getOutputFormat(command);
+    if (outputFormat && ["json", "yaml", "name", "go-template", "go-template-file", "jsonpath", "jsonpath-as-json"].includes(outputFormat)) {
+        return {
+            output: cleanText(input),
+            kind: "kubectl",
+            omitted: false,
+            notes: ["explicit kubectl output format preserved"],
+        };
+    }
+    if (subcommand === "logs") {
+        const result = filterGenericLog(input, options);
+        return { ...result, kind: "kubectl" };
+    }
+    if (subcommand === "get") {
+        const table = compactTable(input, options);
+        if (table.parsed) {
+            return {
+                output: table.output,
+                kind: "kubectl",
+                omitted: table.omitted,
+                notes: table.notes,
+            };
+        }
+    }
+    if (subcommand === "describe") {
+        const lines = cleanText(input).split("\n");
+        const kept = lines.filter((line) => {
+            const trimmed = line.trim();
+            return (trimmed.startsWith("Name:") ||
+                trimmed.startsWith("Namespace:") ||
+                trimmed.startsWith("Status:") ||
+                trimmed.startsWith("Containers:") ||
+                trimmed.startsWith("Conditions:") ||
+                trimmed.startsWith("Events:") ||
+                IMPORTANT_PATTERN.test(trimmed));
+        });
+        if (kept.length > 0) {
+            const limited = limitLines(kept, options.maxLines);
+            return {
+                output: limited.lines.join("\n"),
+                kind: "kubectl",
+                omitted: kept.length < lines.length || limited.omitted > 0,
+                notes: ["collapsed kubectl describe details"],
+            };
+        }
+    }
+    const fallback = filterGenericLog(input, options);
+    return { ...fallback, kind: "kubectl" };
+}
+//# sourceMappingURL=kubectl.js.map

package/dist/src/filters/npm.js

@@ -0,0 +1,44 @@
+import { cleanText } from "../formatting/ansi.js";
+import { limitLines } from "../formatting/limits.js";
+const IMPORTANT_PATTERN = /(?:npm\s+ERR!|\berror\b|\bfailed\b|\bfailure\b|\bfatal\b|\bwarn(?:ing)?\b|\bexception\b|\bpanic\b)/i;
+const SUMMARY_PATTERN = /\b(added|removed|changed|audited|vulnerabilities?|packages?|dependencies|found\s+0\s+vulnerabilities)\b/i;
+const NOISE_PATTERN = /^(?:npm\s+notice\s+|npm\s+timing\s+|npm\s+http\s+|npm\s+verb\s+|\s*[\|/\\-]+\s*$|\s*\d+%\s*$)/i;
+export function filterNpmOutput(input, options) {
+    const lines = cleanText(input).split("\n");
+    const kept = [];
+    let noiseLines = 0;
+    for (const line of lines) {
+        if (!line.trim())
+            continue;
+        if (IMPORTANT_PATTERN.test(line)) {
+            kept.push(line);
+            continue;
+        }
+        if (SUMMARY_PATTERN.test(line)) {
+            kept.push(line);
+            continue;
+        }
+        if (NOISE_PATTERN.test(line)) {
+            noiseLines += 1;
+        }
+    }
+    if (noiseLines > 0) {
+        kept.unshift(`[${noiseLines} npm noise lines collapsed]`);
+    }
+    if (kept.length === 0) {
+        return {
+            output: lines.join("\n"),
+            kind: "npm",
+            omitted: false,
+            notes: ["unrecognized npm format; returned cleaned output"],
+        };
+    }
+    const limited = limitLines(kept, options.maxLines);
+    return {
+        output: limited.lines.join("\n"),
+        kind: "npm",
+        omitted: noiseLines > 0 || limited.omitted > 0 || kept.length < lines.length,
+        notes: noiseLines > 0 ? [`collapsed ${noiseLines} npm noise lines`] : [],
+    };
+}
+//# sourceMappingURL=npm.js.map

package/dist/src/filters/rg.js

@@ -0,0 +1,64 @@
+import { cleanText } from "../formatting/ansi.js";
+import { limitLines } from "../formatting/limits.js";
+function requestsStructuredOutput(command) {
+    return command.some((part) => part === "--json" || part.startsWith("--json="));
+}
+export function filterRgOutput(input, options) {
+    const cleaned = cleanText(input);
+    const lines = cleaned.split("\n");
+    if (requestsStructuredOutput(options.command ?? [])) {
+        return {
+            output: cleaned,
+            kind: "rg",
+            omitted: false,
+            notes: ["explicit rg structured output preserved"],
+        };
+    }
+    const byFile = new Map();
+    let parseable = 0;
+    for (const line of lines) {
+        const match = line.match(/^(.+?):(\d+):(.*)$/);
+        if (!match)
+            continue;
+        const filePath = match[1] ?? "";
+        const lineNumber = Number.parseInt(match[2] ?? "0", 10);
+        const body = match[3] ?? "";
+        if (!filePath || !Number.isFinite(lineNumber) || lineNumber <= 0)
+            continue;
+        const list = byFile.get(filePath) ?? [];
+        list.push({ line: lineNumber, text: body.trim() });
+        byFile.set(filePath, list);
+        parseable += 1;
+    }
+    if (parseable === 0) {
+        return {
+            output: cleaned,
+            kind: "rg",
+            omitted: false,
+            notes: ["unrecognized rg format; returned cleaned output"],
+        };
+    }
+    const files = [...byFile.entries()].sort((left, right) => right[1].length - left[1].length);
+    const output = [`matches: ${parseable} in ${files.length} files`];
+    let omittedMatches = 0;
+    for (const [filePath, matches] of files) {
+        output.push(`${filePath} (${matches.length})`);
+        const visible = matches.slice(0, Math.max(1, options.perFileLines));
+        for (const item of visible) {
+            output.push(`  ${item.line}: ${item.text}`);
+        }
+        if (matches.length > visible.length) {
+            const hidden = matches.length - visible.length;
+            omittedMatches += hidden;
+            output.push(`  ... ${hidden} matches omitted ...`);
+        }
+    }
+    const limited = limitLines(output, options.maxLines);
+    return {
+        output: limited.lines.join("\n"),
+        kind: "rg",
+        omitted: omittedMatches > 0 || limited.omitted > 0,
+        notes: omittedMatches > 0 ? [`omitted ${omittedMatches} rg matches`] : [],
+    };
+}
+//# sourceMappingURL=rg.js.map

package/dist/src/filters/select-filter.js

@@ -0,0 +1,119 @@
+import { filterGenericLog } from "./generic-log.js";
+import { filterCatOutput } from "./cat.js";
+import { filterDockerOutput } from "./docker.js";
+import { filterFindOutput } from "./find.js";
+import { filterGitDiff } from "./git-diff.js";
+import { filterGitList } from "./git-list.js";
+import { filterGitLog } from "./git-log.js";
+import { filterGitStatus } from "./git-status.js";
+import { filterGhOutput } from "./gh.js";
+import { filterKubectlOutput } from "./kubectl.js";
+import { filterNpmOutput } from "./npm.js";
+import { filterRgOutput } from "./rg.js";
+import { filterTailOutput } from "./tail.js";
+import { filterTestOutput } from "./test-output.js";
+import { cleanText } from "../formatting/ansi.js";
+import { measure } from "../metrics/measure.js";
+const FILTERS = {
+    "git-status": filterGitStatus,
+    "git-diff": filterGitDiff,
+    "git-log": filterGitLog,
+    "git-list": filterGitList,
+    npm: filterNpmOutput,
+    tail: filterTailOutput,
+    find: filterFindOutput,
+    rg: filterRgOutput,
+    docker: filterDockerOutput,
+    kubectl: filterKubectlOutput,
+    cat: filterCatOutput,
+    gh: filterGhOutput,
+    test: filterTestOutput,
+    log: filterGenericLog,
+};
+export function detectFilter(command) {
+    const executable = detectExecutable(command);
+    const gitSubcommand = detectGitSubcommand(command);
+    if (gitSubcommand === "status")
+        return "git-status";
+    if (gitSubcommand === "log")
+        return "git-log";
+    if (gitSubcommand === "reflog")
+        return "git-log";
+    if (gitSubcommand === "diff" || gitSubcommand === "show")
+        return "git-diff";
+    if (gitSubcommand)
+        return "git-list";
+    if (executable === "npm" || executable === "pnpm" || executable === "yarn") {
+        if (isTestRunnerCommand(command))
+            return "test";
+        return "npm";
+    }
+    if (executable === "tail")
+        return "tail";
+    if (executable === "find")
+        return "find";
+    if (executable === "rg" || executable === "ripgrep")
+        return "rg";
+    if (executable === "docker")
+        return "docker";
+    if (executable === "kubectl")
+        return "kubectl";
+    if (executable === "cat")
+        return "cat";
+    if (executable === "gh")
+        return "gh";
+    if (isTestRunnerCommand(command)) {
+        return "test";
+    }
+    return "log";
+}
+function detectExecutable(command) {
+    const first = command[0];
+    if (!first)
+        return undefined;
+    return first
+        .split(/[\\/]/)
+        .pop()
+        ?.replace(/\.exe$/i, "")
+        .toLowerCase();
+}
+function isTestRunnerCommand(command) {
+    const normalized = command.join(" ").toLowerCase();
+    return /\b(test|pytest|jest|vitest|cargo test|go test|dotnet test|rspec|npm test|pnpm test|yarn test)\b/.test(normalized);
+}
+function detectGitSubcommand(command) {
+    const gitIndex = command.findIndex((part) => /(?:^|[\\/])git(?:\.exe)?$/i.test(part));
+    if (gitIndex < 0)
+        return undefined;
+    const optionsWithValues = new Set(["-C", "-c", "--git-dir", "--work-tree", "--namespace"]);
+    for (let index = gitIndex + 1; index < command.length; index += 1) {
+        const part = command[index];
+        if (!part)
+            continue;
+        if (optionsWithValues.has(part)) {
+            index += 1;
+            continue;
+        }
+        if (part.startsWith("-"))
+            continue;
+        return part.toLowerCase();
+    }
+    return undefined;
+}
+export function applyFilter(input, requestedKind, command, options) {
+    const kind = requestedKind === "auto" ? detectFilter(command) : requestedKind;
+    const result = FILTERS[kind](input, { ...options, command });
+    const cleanedRaw = cleanText(input);
+    const comparison = measure(cleanedRaw, result.output);
+    if (comparison.outputBytes >= comparison.rawBytes ||
+        comparison.outputEstimatedTokens >= comparison.rawEstimatedTokens) {
+        return {
+            output: cleanedRaw,
+            kind,
+            omitted: false,
+            notes: [...result.notes, "compact output was not smaller; returned cleaned raw output"],
+        };
+    }
+    return result;
+}
+//# sourceMappingURL=select-filter.js.map

package/dist/src/filters/table.js

@@ -0,0 +1,27 @@
+import { cleanText } from "../formatting/ansi.js";
+import { limitLines } from "../formatting/limits.js";
+function hasWideSpacing(line) {
+    return /\S\s{2,}\S/.test(line);
+}
+export function compactTable(input, options) {
+    const lines = cleanText(input).split("\n").filter((line) => line.trim());
+    if (lines.length < 2 || !hasWideSpacing(lines[0] ?? "")) {
+        return { output: cleanText(input), omitted: false, notes: [], parsed: false };
+    }
+    const header = lines[0] ?? "";
+    const rows = lines.slice(1);
+    const rowLimit = Math.max(1, options.maxLines - 2);
+    const visibleRows = rows.slice(0, rowLimit);
+    const output = [header, ...visibleRows];
+    if (rows.length > visibleRows.length) {
+        output.push(`... ${rows.length - visibleRows.length} rows omitted ...`);
+    }
+    const limited = limitLines(output, options.maxLines);
+    return {
+        output: limited.lines.join("\n"),
+        omitted: rows.length > visibleRows.length || limited.omitted > 0,
+        notes: rows.length > visibleRows.length ? [`omitted ${rows.length - visibleRows.length} rows`] : [],
+        parsed: true,
+    };
+}
+//# sourceMappingURL=table.js.map

package/dist/src/filters/tail.js

@@ -0,0 +1,6 @@
+import { filterGenericLog } from "./generic-log.js";
+export function filterTailOutput(input, options) {
+    const result = filterGenericLog(input, options);
+    return { ...result, kind: "tail" };
+}
+//# sourceMappingURL=tail.js.map