shrinker-ai 0.3.2 → 0.4.0

package/dist/src/cli.js

@@ -1,32 +1,37 @@
 #!/usr/bin/env node
-import process from "node:process";
 import path from "node:path";
+import process from "node:process";
 import { applyFilter } from "./filters/select-filter.js";
 import { runCommand } from "./execution/run-command.js";
 import { getLatestRawOutput, getRawOutput, saveRawOutput } from "./execution/raw-output-store.js";
 import { cleanText } from "./formatting/ansi.js";
 import { formatMeasurements, measure } from "./metrics/measure.js";
-import { openStatsDashboard, writeStatsDashboard } from "./metrics/dashboard.js";
-import { defaultStatsPath, formatStats, formatStatsChart, getStats, recordRun } from "./metrics/stats-store.js";
+import { serveStatsDashboard, startStatsDashboard, writeStatsDashboard } from "./metrics/dashboard.js";
+import { classifyWrappedRun, commandSignature, isCoverageTrackingEnabled } from "./metrics/coverage.js";
+import { defaultStatsPath, formatCoverage, formatStats, formatStatsChart, getStats, recordRun, recordUncovered, } from "./metrics/stats-store.js";
 function usage() {
-    return `Usage:
-  shrinker <command> [args...]
-  shrinker exec [options] [--] <command> [args...]
-  shrinker pipe [options]
-  shrinker stats [--json] [--chart] [--dashboard]
-  shrinker last [--path]
-  shrinker raw <capture-id> [--path]
-  shrinker help
-
-Options:
-  --kind <auto|git-status|git-diff|git-log|git-list|npm|tail|find|rg|docker|kubectl|cat|gh|test|log>
-  --max-lines <number>       default: 120
-  --per-file-lines <number>  default: 40
-  --raw                      bypass filtering
-  --metrics                  print per-run savings and duration
-  --no-save                  do not save omitted raw output
-  --no-stats                 do not record this run
-  --dashboard                write a browser dashboard to ~/.shrinker/dashboard.html
+    return `Usage:
+  shrinker <command> [args...]
+  shrinker exec [options] [--] <command> [args...]
+  shrinker pipe [options]
+  shrinker stats [--json] [--chart] [--coverage] [--dashboard] [--restart] [--port <number>]
+  shrinker last [--path]
+  shrinker raw <capture-id> [--path]
+  shrinker track --executable <name> [--subcommand <name>] [--bytes <number>] [--exit-code <number>]
+  shrinker help
+
+Options:
+  --kind <auto|git-status|git-diff|git-log|git-list|npm|tail|find|rg|docker|kubectl|cat|gh|test|log>
+  --max-lines <number>       default: 120
+  --per-file-lines <number>  default: 40
+  --raw                      bypass filtering
+  --metrics                  print per-run savings and duration
+  --no-save                  do not save omitted raw output
+  --no-stats                 do not record this run
+  --coverage                 list commands shrinker does not cover yet
+  --dashboard                serve and open the local dashboard at http://127.0.0.1:4317
+  --restart                  restart the local dashboard server
+  --port <number>            dashboard server port (default: 4317)
   --help`;
 }
 function parsePositiveInteger(value, option) {
@@ -36,6 +41,20 @@ function parsePositiveInteger(value, option) {
     }
     return parsed;
 }
+function parseNonNegativeInteger(value, option) {
+    const parsed = Number(value);
+    if (!Number.isInteger(parsed) || parsed < 0) {
+        throw new Error(`${option} requires a non-negative integer`);
+    }
+    return parsed;
+}
+function parseInteger(value, option) {
+    const parsed = Number(value);
+    if (!Number.isInteger(parsed)) {
+        throw new Error(`${option} requires an integer`);
+    }
+    return parsed;
+}
 function parseArgs(args) {
     const first = args[0];
     let mode;
@@ -48,6 +67,7 @@ function parseArgs(args) {
         first === "pipe" ||
         first === "stats" ||
         first === "last" ||
+        first === "track" ||
         first === "raw") {
         const reserved = args.shift();
         mode = reserved === "raw" ? "raw-output" : reserved;
@@ -62,9 +82,17 @@ function parseArgs(args) {
     let showMetrics = false;
     let json = false;
     let chart = false;
+    let coverage = false;
     let dashboard = false;
+    let dashboardServer = false;
+    let dashboardRestart = false;
+    let dashboardPort = 4317;
     let showPath = false;
     let captureId;
+    let trackExecutable;
+    let trackSubcommand;
+    let trackBytes;
+    let trackExitCode;
     let maxLines = 120;
     let perFileLines = 40;
     while (args.length > 0 && args[0] !== "--") {
@@ -85,8 +113,24 @@ function parseArgs(args) {
             json = true;
         else if (option === "--chart" && mode === "stats")
             chart = true;
+        else if (option === "--coverage" && mode === "stats")
+            coverage = true;
+        else if (option === "--executable" && mode === "track")
+            trackExecutable = args.shift();
+        else if (option === "--subcommand" && mode === "track")
+            trackSubcommand = args.shift();
+        else if (option === "--bytes" && mode === "track")
+            trackBytes = parseNonNegativeInteger(args.shift(), "--bytes");
+        else if (option === "--exit-code" && mode === "track")
+            trackExitCode = parseInteger(args.shift(), "--exit-code");
         else if (option === "--dashboard" && mode === "stats")
             dashboard = true;
+        else if (option === "--dashboard-server" && mode === "stats")
+            dashboardServer = true;
+        else if (option === "--restart" && mode === "stats")
+            dashboardRestart = true;
+        else if (option === "--port" && mode === "stats")
+            dashboardPort = parsePositiveInteger(args.shift(), "--port");
         else if (option === "--path" && mode === "last")
             showPath = true;
         else if (option === "--path" && mode === "raw-output")
@@ -138,10 +182,16 @@ function parseArgs(args) {
         throw new Error("exec requires a command");
     if (mode === "stats" && args.length > 0)
         throw new Error("stats does not accept command arguments");
+    if (dashboardRestart && !dashboard)
+        throw new Error("--restart requires stats --dashboard");
     if (mode === "last" && args.length > 0)
         throw new Error("last does not accept command arguments");
     if (mode === "raw-output" && !captureId)
         throw new Error("raw requires a capture ID");
+    if (mode === "track" && !trackExecutable)
+        throw new Error("track requires --executable");
+    if (mode === "track" && args.length > 0)
+        throw new Error("track does not accept command arguments");
     return {
         mode,
         kind,
@@ -151,9 +201,17 @@ function parseArgs(args) {
         showMetrics,
         json,
         chart,
+        coverage,
         dashboard,
+        dashboardServer,
+        dashboardRestart,
+        dashboardPort,
         showPath,
         ...(captureId ? { captureId } : {}),
+        ...(trackExecutable ? { trackExecutable } : {}),
+        ...(trackSubcommand ? { trackSubcommand } : {}),
+        ...(trackBytes === undefined ? {} : { trackBytes }),
+        ...(trackExitCode === undefined ? {} : { trackExitCode }),
         maxLines,
         perFileLines,
         command: args,
@@ -187,11 +245,13 @@ async function render(rawOutput, options, durationMs, exitCode) {
         process.stderr.write(`${formatMeasurements(measurements, durationMs)}\n`);
     }
     if (options.trackStats) {
+        const signature = options.mode === "pipe" ? undefined : commandSignature(options.command);
         try {
             recordRun({
                 mode: options.mode === "pipe" ? "pipe" : "exec",
                 filterKind: result.kind,
                 commandName: options.mode === "pipe" ? "stdin" : path.basename(options.command[0] ?? "unknown"),
+                ...(signature?.subcommand ? { commandSubcommand: signature.subcommand } : {}),
                 measurements,
                 ...(durationMs === undefined ? {} : { durationMs }),
                 omitted: result.omitted,
@@ -201,6 +261,29 @@ async function render(rawOutput, options, durationMs, exitCode) {
         catch (error) {
             process.stderr.write(`[shrinker] could not record stats: ${String(error)}\n`);
         }
+        if (options.mode !== "pipe" && isCoverageTrackingEnabled()) {
+            try {
+                const reason = classifyWrappedRun({
+                    matched: result.matched,
+                    kind: result.kind,
+                    measurements,
+                });
+                if (reason && signature) {
+                    recordUncovered({
+                        source: "wrapped",
+                        reason,
+                        executable: signature.executable,
+                        ...(signature.subcommand ? { subcommand: signature.subcommand } : {}),
+                        rawBytes: measurements.rawBytes,
+                        rawEstimatedTokens: measurements.rawEstimatedTokens,
+                        ...(exitCode === undefined ? {} : { exitCode }),
+                    });
+                }
+            }
+            catch (error) {
+                process.stderr.write(`[shrinker] could not record coverage: ${String(error)}\n`);
+            }
+        }
     }
     const isWrappedGitLog = options.mode === "exec" && result.kind === "git-log";
     const shouldSave = result.recovery !== "threshold" && !isWrappedGitLog;
@@ -223,15 +306,51 @@ async function main() {
     if (options.mode === "stats") {
         const summary = getStats(defaultStatsPath());
         if (options.dashboard) {
-            const dashboardPath = writeStatsDashboard(summary);
-            process.stdout.write(`Dashboard written to: ${dashboardPath}\n`);
-            openStatsDashboard(dashboardPath);
+            if (options.dashboardServer) {
+                await serveStatsDashboard(() => getStats(defaultStatsPath()), options.dashboardPort);
+            }
+            else {
+                writeStatsDashboard(summary);
+                const dashboard = await startStatsDashboard(options.dashboardPort, options.dashboardRestart);
+                if (dashboard.reused) {
+                    process.stdout.write(`Dashboard server already running at http://127.0.0.1:${options.dashboardPort}\n`);
+                }
+                else if (dashboard.restarted) {
+                    process.stdout.write(`Dashboard server restarted at http://127.0.0.1:${options.dashboardPort} (PID ${dashboard.pid})\n`);
+                }
+                else {
+                    process.stdout.write(`Dashboard server started at http://127.0.0.1:${options.dashboardPort} (PID ${dashboard.pid})\n`);
+                }
+            }
             return;
         }
-        const output = options.json ? JSON.stringify(summary, null, 2) : options.chart ? formatStatsChart(summary) : formatStats(summary);
+        const output = options.json
+            ? JSON.stringify(summary, null, 2)
+            : options.coverage
+                ? formatCoverage(summary)
+                : options.chart
+                    ? formatStatsChart(summary)
+                    : formatStats(summary);
         process.stdout.write(`${output}\n`);
         return;
     }
+    if (options.mode === "track") {
+        try {
+            recordUncovered({
+                source: "shell",
+                reason: "unlisted-subcommand",
+                executable: options.trackExecutable ?? "",
+                ...(options.trackSubcommand ? { subcommand: options.trackSubcommand } : {}),
+                ...(options.trackBytes === undefined ? {} : { rawBytes: options.trackBytes }),
+                ...(options.trackBytes === undefined
+                    ? {}
+                    : { rawEstimatedTokens: Math.ceil(options.trackBytes / 4) }),
+                ...(options.trackExitCode === undefined ? {} : { exitCode: options.trackExitCode }),
+            });
+        }
+        catch { }
+        return;
+    }
     if (options.mode === "last") {
         const latest = await getLatestRawOutput();
         if (!latest)

package/dist/src/config.js

@@ -0,0 +1,42 @@
+import { readFileSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+export function defaultConfigPath() {
+    return process.env['SHRINKER_CONFIG_PATH'] ?? path.join(os.homedir(), ".shrinker", "config");
+}
+// `KEY=value` lines; `#` starts a comment. Unknown keys are ignored so older CLIs tolerate newer files.
+export function readConfig(configPath = defaultConfigPath()) {
+    const settings = new Map();
+    let contents;
+    try {
+        contents = readFileSync(configPath, "utf8");
+    }
+    catch {
+        return settings;
+    }
+    for (const line of contents.split(/\r?\n/)) {
+        const withoutComment = line.split("#")[0]?.trim();
+        if (!withoutComment)
+            continue;
+        const separator = withoutComment.indexOf("=");
+        if (separator <= 0)
+            continue;
+        const key = withoutComment.slice(0, separator).trim();
+        const value = withoutComment.slice(separator + 1).trim();
+        if (key)
+            settings.set(key, value);
+    }
+    return settings;
+}
+// Environment wins so a single command can override the persisted choice.
+export function resolveSetting(key, configPath) {
+    const fromEnvironment = process.env[key];
+    if (fromEnvironment !== undefined && fromEnvironment.trim() !== "")
+        return fromEnvironment;
+    return readConfig(configPath).get(key);
+}
+export function isTruthy(value) {
+    const normalized = value?.trim().toLowerCase();
+    return normalized === "1" || normalized === "true" || normalized === "yes";
+}
+//# sourceMappingURL=config.js.map

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

@@ -12,9 +12,9 @@ function quoteForCmd(argument) {
 async function resolveWindowsCommand(command) {
     if (process.platform !== "win32" || path.extname(command))
         return command;
-    const pathEntries = (process.env.PATH ?? "").split(path.delimiter);
+    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")
+    const extensions = (process.env['PATHEXT'] ?? ".COM;.EXE;.BAT;.CMD")
         .split(";")
         .map((extension) => extension.trim().toLowerCase())
         .filter((extension) => executableExtensions.has(extension));

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

@@ -31,41 +31,45 @@ const FILTERS = {
     log: filterGenericLog,
 };
 export function detectFilter(command) {
+    return detectFilterMatch(command).kind;
+}
+export function detectFilterMatch(command) {
     const executable = detectExecutable(command);
+    const matched = (kind) => ({ kind, matched: true });
     const gitSubcommand = detectGitSubcommand(command);
     if (gitSubcommand === "status")
-        return "git-status";
+        return matched("git-status");
     if (gitSubcommand === "log")
-        return "git-log";
+        return matched("git-log");
     if (gitSubcommand === "reflog")
-        return "git-log";
+        return matched("git-log");
     if (gitSubcommand === "diff" || gitSubcommand === "show")
-        return "git-diff";
+        return matched("git-diff");
     if (gitSubcommand)
-        return "git-list";
+        return matched("git-list");
     if (executable === "npm" || executable === "pnpm" || executable === "yarn") {
         if (isTestRunnerCommand(command))
-            return "test";
-        return "npm";
+            return matched("test");
+        return matched("npm");
     }
     if (executable === "tail")
-        return "tail";
+        return matched("tail");
     if (executable === "find")
-        return "find";
+        return matched("find");
     if (executable === "rg" || executable === "ripgrep")
-        return "rg";
+        return matched("rg");
     if (executable === "docker")
-        return "docker";
+        return matched("docker");
     if (executable === "kubectl")
-        return "kubectl";
+        return matched("kubectl");
     if (executable === "cat")
-        return "cat";
+        return matched("cat");
     if (executable === "gh")
-        return "gh";
+        return matched("gh");
     if (isTestRunnerCommand(command)) {
-        return "test";
+        return matched("test");
     }
-    return "log";
+    return { kind: "log", matched: false };
 }
 function detectExecutable(command) {
     const first = command[0];
@@ -101,7 +105,10 @@ function detectGitSubcommand(command) {
     return undefined;
 }
 export function applyFilter(input, requestedKind, command, options) {
-    const kind = requestedKind === "auto" ? detectFilter(command) : requestedKind;
+    const detection = requestedKind === "auto"
+        ? detectFilterMatch(command)
+        : { kind: requestedKind, matched: true };
+    const kind = detection.kind;
     const result = FILTERS[kind](input, { ...options, command });
     const cleanedRaw = cleanText(input);
     const comparison = measure(cleanedRaw, result.output);
@@ -110,10 +117,11 @@ export function applyFilter(input, requestedKind, command, options) {
         return {
             output: cleanedRaw,
             kind,
+            matched: detection.matched,
             omitted: false,
             notes: [...result.notes, "compact output was not smaller; returned cleaned raw output"],
         };
     }
-    return result;
+    return { ...result, matched: detection.matched };
 }
 //# sourceMappingURL=select-filter.js.map

package/dist/src/metrics/coverage.js

@@ -0,0 +1,67 @@
+import { isTruthy, resolveSetting } from "../config.js";
+const DEFAULT_LOW_REDUCTION_PERCENT = 10;
+const MINIMUM_TRACKED_RAW_TOKENS = 200;
+const TOKEN_PATTERN = /^[a-z0-9][a-z0-9._+-]{0,63}$/;
+const OPTION_VALUE_FLAGS = {
+    git: ["-C", "-c", "--git-dir", "--work-tree", "--namespace"],
+    npm: ["--prefix", "--cache", "--registry", "--workspace", "--userconfig", "-w", "-C"],
+    pnpm: ["--prefix", "--registry", "--workspace", "-w", "-C", "--dir"],
+    yarn: ["--cwd", "--registry"],
+    docker: ["-H", "--host", "--context", "--config"],
+    kubectl: ["-n", "--namespace", "-o", "--output", "--context", "--kubeconfig", "--cluster", "--user"],
+    gh: ["-R", "--repo"],
+};
+export function isCoverageTrackingEnabled() {
+    return isTruthy(resolveSetting("SHRINKER_TRACK_UNCOVERED"));
+}
+function lowReductionPercent() {
+    const configured = Number(process.env['SHRINKER_LOW_REDUCTION_PERCENT']);
+    return Number.isFinite(configured) && configured >= 0 && configured <= 100
+        ? configured
+        : DEFAULT_LOW_REDUCTION_PERCENT;
+}
+export function sanitizeToken(value) {
+    if (!value)
+        return undefined;
+    const normalized = value.trim().toLowerCase();
+    return TOKEN_PATTERN.test(normalized) ? normalized : undefined;
+}
+function normalizeExecutable(value) {
+    if (!value)
+        return undefined;
+    const base = value
+        .split(/[\\/]/)
+        .pop()
+        ?.replace(/\.(exe|cmd|bat|ps1)$/i, "");
+    return sanitizeToken(base);
+}
+export function commandSignature(command) {
+    const executable = normalizeExecutable(command[0]);
+    if (!executable)
+        return undefined;
+    const valueFlags = new Set(OPTION_VALUE_FLAGS[executable] ?? []);
+    for (let index = 1; index < command.length; index += 1) {
+        const part = command[index];
+        if (!part)
+            continue;
+        if (valueFlags.has(part)) {
+            index += 1;
+            continue;
+        }
+        if (part.startsWith("-"))
+            continue;
+        const subcommand = sanitizeToken(part);
+        return subcommand ? { executable, subcommand } : { executable };
+    }
+    return { executable };
+}
+export function classifyWrappedRun(run) {
+    if (run.measurements.rawEstimatedTokens < MINIMUM_TRACKED_RAW_TOKENS)
+        return undefined;
+    if (!run.matched)
+        return "no-filter";
+    if (run.measurements.reductionPercent < lowReductionPercent())
+        return "low-reduction";
+    return undefined;
+}
+//# sourceMappingURL=coverage.js.map