shrinker-ai 0.1.0

package/dist/src/execution/run-command.js

@@ -0,0 +1,172 @@
+import { access } from "node:fs/promises";
+import { readFile, readdir } from "node:fs/promises";
+import path from "node:path";
+import { spawn } from "node:child_process";
+function quoteForCmd(argument) {
+    if (argument.length === 0)
+        return "\"\"";
+    if (!/[\s"^&|<>]/.test(argument))
+        return argument;
+    return `"${argument.replace(/"/g, '""')}"`;
+}
+async function resolveWindowsCommand(command) {
+    if (process.platform !== "win32" || path.extname(command))
+        return command;
+    const pathEntries = (process.env.PATH ?? "").split(path.delimiter);
+    const executableExtensions = new Set([".com", ".exe", ".bat", ".cmd"]);
+    const extensions = (process.env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD")
+        .split(";")
+        .map((extension) => extension.trim().toLowerCase())
+        .filter((extension) => executableExtensions.has(extension));
+    for (const directory of pathEntries) {
+        if (!directory)
+            continue;
+        for (const extension of extensions) {
+            const candidate = path.join(directory, `${command}${extension}`);
+            try {
+                await access(candidate);
+                return candidate;
+            }
+            catch {
+                // Continue searching PATH.
+            }
+        }
+    }
+    return command;
+}
+function parseAliasArgs(args) {
+    const paths = [];
+    for (const arg of args) {
+        if (arg.startsWith("-"))
+            return { paths, unsupportedOption: arg };
+        paths.push(arg);
+    }
+    return { paths };
+}
+async function runWindowsAlias(command, args) {
+    if (process.platform !== "win32")
+        return undefined;
+    const alias = command.toLowerCase();
+    if (alias !== "cat" && alias !== "ls" && alias !== "dir")
+        return undefined;
+    const started = performance.now();
+    const parsed = parseAliasArgs(args);
+    if (parsed.unsupportedOption) {
+        return {
+            stdout: "",
+            stderr: `Unsupported ${alias} option in shrinker alias mode: ${parsed.unsupportedOption}`,
+            combined: `Unsupported ${alias} option in shrinker alias mode: ${parsed.unsupportedOption}`,
+            exitCode: 2,
+            durationMs: Math.round(performance.now() - started),
+        };
+    }
+    if (alias === "cat") {
+        const targets = parsed.paths.length > 0 ? parsed.paths : ["-"];
+        if (targets.includes("-")) {
+            return {
+                stdout: "",
+                stderr: "cat alias requires at least one file path",
+                combined: "cat alias requires at least one file path",
+                exitCode: 2,
+                durationMs: Math.round(performance.now() - started),
+            };
+        }
+        const parts = [];
+        for (const target of targets) {
+            try {
+                parts.push(await readFile(target, "utf8"));
+            }
+            catch (error) {
+                const message = error.message;
+                return {
+                    stdout: "",
+                    stderr: message,
+                    combined: message,
+                    exitCode: 1,
+                    durationMs: Math.round(performance.now() - started),
+                };
+            }
+        }
+        const stdout = parts.join(parts.length > 1 ? "\n" : "");
+        return {
+            stdout,
+            stderr: "",
+            combined: stdout,
+            exitCode: 0,
+            durationMs: Math.round(performance.now() - started),
+        };
+    }
+    const targetPath = parsed.paths[0] ?? ".";
+    try {
+        const entries = await readdir(targetPath, { withFileTypes: true });
+        const lines = entries
+            .map((entry) => (entry.isDirectory() ? `${entry.name}/` : entry.name))
+            .sort((left, right) => left.localeCompare(right));
+        const stdout = lines.join("\n");
+        return {
+            stdout,
+            stderr: "",
+            combined: stdout,
+            exitCode: 0,
+            durationMs: Math.round(performance.now() - started),
+        };
+    }
+    catch (error) {
+        const message = error.message;
+        return {
+            stdout: "",
+            stderr: message,
+            combined: message,
+            exitCode: 1,
+            durationMs: Math.round(performance.now() - started),
+        };
+    }
+}
+async function spawnAndCapture(executable, args, viaCmdProxy) {
+    const started = performance.now();
+    return await new Promise((resolve, reject) => {
+        const spawnCommand = viaCmdProxy ? "cmd.exe" : executable;
+        const spawnArgs = viaCmdProxy
+            ? ["/d", "/s", "/c", `${quoteForCmd(executable)} ${args.map(quoteForCmd).join(" ")}`]
+            : args;
+        const child = spawn(spawnCommand, spawnArgs, {
+            cwd: process.cwd(),
+            env: process.env,
+            shell: false,
+            windowsHide: true,
+        });
+        const stdout = [];
+        const stderr = [];
+        child.stdout.on("data", (chunk) => stdout.push(chunk));
+        child.stderr.on("data", (chunk) => stderr.push(chunk));
+        child.on("error", reject);
+        child.on("close", (code) => {
+            const stdoutText = Buffer.concat(stdout).toString("utf8");
+            const stderrText = Buffer.concat(stderr).toString("utf8");
+            resolve({
+                stdout: stdoutText,
+                stderr: stderrText,
+                combined: [stdoutText, stderrText].filter(Boolean).join("\n"),
+                exitCode: code ?? 1,
+                durationMs: Math.round(performance.now() - started),
+            });
+        });
+    });
+}
+export async function runCommand(command, args) {
+    const aliasResult = await runWindowsAlias(command, args);
+    if (aliasResult)
+        return aliasResult;
+    const executable = await resolveWindowsCommand(command);
+    try {
+        return await spawnAndCapture(executable, args, false);
+    }
+    catch (error) {
+        const code = error.code;
+        if (process.platform === "win32" && (code === "EFTYPE" || code === "EINVAL")) {
+            return await spawnAndCapture(executable, args, true);
+        }
+        throw error;
+    }
+}
+//# sourceMappingURL=run-command.js.map

package/dist/src/filters/cat.js

@@ -0,0 +1,13 @@
+import { cleanText } from "../formatting/ansi.js";
+import { limitLines } from "../formatting/limits.js";
+export function filterCatOutput(input, options) {
+    const lines = cleanText(input).split("\n");
+    const limited = limitLines(lines, options.maxLines);
+    return {
+        output: limited.lines.join("\n"),
+        kind: "cat",
+        omitted: limited.omitted > 0,
+        notes: limited.omitted > 0 ? [`omitted ${limited.omitted} lines`] : [],
+    };
+}
+//# sourceMappingURL=cat.js.map

package/dist/src/filters/docker.js

@@ -0,0 +1,42 @@
+import { cleanText } from "../formatting/ansi.js";
+import { filterGenericLog } from "./generic-log.js";
+import { compactTable } from "./table.js";
+function hasOption(command, ...names) {
+    return command.some((part) => names.includes(part));
+}
+function detectSubcommand(command) {
+    const index = command.findIndex((part) => /(?:^|[\\/])docker(?:\.exe)?$/i.test(part));
+    if (index < 0)
+        return undefined;
+    return command[index + 1]?.toLowerCase();
+}
+export function filterDockerOutput(input, options) {
+    const command = options.command ?? [];
+    const subcommand = detectSubcommand(command);
+    if (hasOption(command, "--format", "-f", "--quiet", "-q")) {
+        return {
+            output: cleanText(input),
+            kind: "docker",
+            omitted: false,
+            notes: ["explicit docker format preserved"],
+        };
+    }
+    if (subcommand === "logs" || subcommand === "attach") {
+        const result = filterGenericLog(input, options);
+        return { ...result, kind: "docker" };
+    }
+    if (subcommand === "ps" || subcommand === "images" || subcommand === "container" || subcommand === "volume" || subcommand === "network") {
+        const table = compactTable(input, options);
+        if (table.parsed) {
+            return {
+                output: table.output,
+                kind: "docker",
+                omitted: table.omitted,
+                notes: table.notes,
+            };
+        }
+    }
+    const fallback = filterGenericLog(input, options);
+    return { ...fallback, kind: "docker" };
+}
+//# sourceMappingURL=docker.js.map

package/dist/src/filters/find.js

@@ -0,0 +1,63 @@
+import path from "node:path";
+import { cleanText } from "../formatting/ansi.js";
+import { limitLines } from "../formatting/limits.js";
+const ERROR_PATTERN = /permission denied|no such file|cannot access|find:/i;
+export function filterFindOutput(input, options) {
+    const lines = cleanText(input).split("\n").filter((line) => line.trim());
+    const paths = [];
+    const errors = [];
+    for (const line of lines) {
+        if (ERROR_PATTERN.test(line)) {
+            errors.push(line);
+        }
+        else {
+            paths.push(line);
+        }
+    }
+    if (paths.length === 0 && errors.length === 0) {
+        return {
+            output: "",
+            kind: "find",
+            omitted: false,
+            notes: [],
+        };
+    }
+    const directoryCounts = new Map();
+    for (const filePath of paths) {
+        const directory = path.dirname(filePath).replace(/\\/g, "/") || ".";
+        directoryCounts.set(directory, (directoryCounts.get(directory) ?? 0) + 1);
+    }
+    const topDirectories = [...directoryCounts.entries()]
+        .sort((left, right) => right[1] - left[1] || left[0].localeCompare(right[0]))
+        .slice(0, 8);
+    const output = [`paths: ${paths.length}`];
+    if (topDirectories.length > 0) {
+        output.push("top directories:");
+        for (const [directory, count] of topDirectories) {
+            output.push(`  ${directory} (${count})`);
+        }
+    }
+    if (errors.length > 0) {
+        output.push(`errors: ${errors.length}`);
+        output.push(...errors.slice(0, Math.max(1, options.perFileLines)).map((line) => `  ${line}`));
+        if (errors.length > options.perFileLines) {
+            output.push(`  ... ${errors.length - options.perFileLines} error lines omitted ...`);
+        }
+    }
+    output.push("sample paths:");
+    output.push(...paths.slice(0, Math.max(1, options.perFileLines)).map((filePath) => `  ${filePath}`));
+    if (paths.length > options.perFileLines) {
+        output.push(`  ... ${paths.length - options.perFileLines} paths omitted ...`);
+    }
+    const limited = limitLines(output, options.maxLines);
+    const omitted = paths.length > options.perFileLines ||
+        errors.length > options.perFileLines ||
+        limited.omitted > 0;
+    return {
+        output: limited.lines.join("\n"),
+        kind: "find",
+        omitted,
+        notes: omitted ? ["collapsed path listing"] : [],
+    };
+}
+//# sourceMappingURL=find.js.map

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

@@ -0,0 +1,38 @@
+import { cleanText } from "../formatting/ansi.js";
+import { limitLines } from "../formatting/limits.js";
+const PROGRESS_PATTERN = /^(?:\s*\d{1,3}%|progress\b|downloading\b|uploading\b|building\b|compiling\b|waiting\b|\.{3,}|[=\-#>.]{8,})/i;
+const IMPORTANT_PATTERN = /\b(error|failed|failure|fatal|warn(?:ing)?|exception|panic)\b/i;
+export function filterGenericLog(input, options) {
+    const lines = cleanText(input).split("\n");
+    const compact = [];
+    let progressLines = 0;
+    for (let index = 0; index < lines.length;) {
+        const line = lines[index] ?? "";
+        let count = 1;
+        while (lines[index + count] === line) {
+            count += 1;
+        }
+        if (PROGRESS_PATTERN.test(line) && !IMPORTANT_PATTERN.test(line)) {
+            progressLines += count;
+        }
+        else if (count >= 3) {
+            compact.push(`${line} [repeated ${count}x]`);
+        }
+        else {
+            compact.push(...lines.slice(index, index + count));
+        }
+        index += count;
+    }
+    if (progressLines > 0) {
+        compact.unshift(`[${progressLines} progress lines collapsed]`);
+    }
+    const limited = limitLines(compact, options.maxLines);
+    const omitted = progressLines > 0 || limited.omitted > 0 || compact.length < lines.length;
+    return {
+        output: limited.lines.join("\n"),
+        kind: "log",
+        omitted,
+        notes: progressLines > 0 ? [`collapsed ${progressLines} progress lines`] : [],
+    };
+}
+//# sourceMappingURL=generic-log.js.map

package/dist/src/filters/gh.js

@@ -0,0 +1,38 @@
+import { cleanText } from "../formatting/ansi.js";
+import { filterGenericLog } from "./generic-log.js";
+import { compactTable } from "./table.js";
+function hasStructuredOutput(command) {
+    for (let index = 0; index < command.length; index += 1) {
+        const part = command[index];
+        if (!part)
+            continue;
+        if (part === "--json" || part === "--template" || part === "--jq")
+            return true;
+        if (part.startsWith("--json=") || part.startsWith("--template=") || part.startsWith("--jq=")) {
+            return true;
+        }
+    }
+    return false;
+}
+export function filterGhOutput(input, options) {
+    if (hasStructuredOutput(options.command ?? [])) {
+        return {
+            output: cleanText(input),
+            kind: "gh",
+            omitted: false,
+            notes: ["explicit gh structured output preserved"],
+        };
+    }
+    const table = compactTable(input, options);
+    if (table.parsed) {
+        return {
+            output: table.output,
+            kind: "gh",
+            omitted: table.omitted,
+            notes: table.notes,
+        };
+    }
+    const fallback = filterGenericLog(input, options);
+    return { ...fallback, kind: "gh" };
+}
+//# sourceMappingURL=gh.js.map

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

@@ -0,0 +1,56 @@
+import { cleanText } from "../formatting/ansi.js";
+import { limitLines } from "../formatting/limits.js";
+export function filterGitDiff(input, options) {
+    const lines = cleanText(input).split("\n");
+    const files = [];
+    let current;
+    for (const line of lines) {
+        const header = line.match(/^diff --git a\/(.+?) b\/(.+)$/);
+        if (header) {
+            current = {
+                name: header[2] ?? header[1] ?? "unknown",
+                lines: [],
+                additions: 0,
+                deletions: 0,
+            };
+            files.push(current);
+            continue;
+        }
+        if (!current)
+            continue;
+        if (line.startsWith("+") && !line.startsWith("+++"))
+            current.additions += 1;
+        if (line.startsWith("-") && !line.startsWith("---"))
+            current.deletions += 1;
+        if (line.startsWith("@@") ||
+            (line.startsWith("+") && !line.startsWith("+++")) ||
+            (line.startsWith("-") && !line.startsWith("---"))) {
+            current.lines.push(line);
+        }
+    }
+    if (files.length === 0) {
+        return {
+            output: lines.join("\n"),
+            kind: "git-diff",
+            omitted: false,
+            notes: ["unrecognized diff format; returned cleaned output"],
+        };
+    }
+    const output = [];
+    let perFileOmitted = 0;
+    for (const file of files) {
+        output.push(`${file.name} (+${file.additions} -${file.deletions})`);
+        const limited = limitLines(file.lines, options.perFileLines);
+        perFileOmitted += limited.omitted;
+        output.push(...limited.lines.map((line) => `  ${line}`));
+    }
+    const limited = limitLines(output, options.maxLines);
+    const omitted = perFileOmitted + limited.omitted;
+    return {
+        output: limited.lines.join("\n"),
+        kind: "git-diff",
+        omitted: true,
+        notes: omitted > 0 ? [`omitted ${omitted} diff lines`] : ["removed diff metadata and context"],
+    };
+}
+//# sourceMappingURL=git-diff.js.map

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

@@ -0,0 +1,25 @@
+import { cleanText } from "../formatting/ansi.js";
+import { limitLines } from "../formatting/limits.js";
+export function filterGitList(input, options) {
+    const lines = cleanText(input)
+        .split("\n")
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .map((line) => line.replace(/^\*\s+/, "current: "));
+    if (lines.length === 0) {
+        return {
+            output: cleanText(input),
+            kind: "git-list",
+            omitted: false,
+            notes: ["unrecognized git list format; returned cleaned output"],
+        };
+    }
+    const limited = limitLines(lines, options.maxLines);
+    return {
+        output: limited.lines.join("\n"),
+        kind: "git-list",
+        omitted: limited.omitted > 0,
+        notes: limited.omitted > 0 ? [`omitted ${limited.omitted} lines`] : [],
+    };
+}
+//# sourceMappingURL=git-list.js.map