shrinker-ai 0.10.0 → 0.11.0

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

@@ -127,13 +127,14 @@ async function spawnAndCapture(executable, args, viaCmdProxy) {
     return await new Promise((resolve, reject) => {
         const spawnCommand = viaCmdProxy ? "cmd.exe" : executable;
         const spawnArgs = viaCmdProxy
-            ? ["/d", "/s", "/c", `${quoteForCmd(executable)} ${args.map(quoteForCmd).join(" ")}`]
+            ? ["/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,
+            windowsVerbatimArguments: viaCmdProxy,
         });
         const stdout = [];
         const stderr = [];

package/dist/src/metrics/dashboard.js

@@ -1,6 +1,6 @@
 import { execFile, spawn } from "node:child_process";
 import { mkdirSync, writeFileSync } from "node:fs";
-import { createServer } from "node:http";
+import { createServer, request as httpRequest } from "node:http";
 import path from "node:path";
 import { promisify } from "node:util";
 import { getInputCostPerMillionTokens } from "./stats-store.js";
@@ -8,11 +8,19 @@ import { DASHBOARD_STATS_PLACEHOLDER, DASHBOARD_TEMPLATE_HTML } from "./dashboar
 const execFileAsync = promisify(execFile);
 // Identifies a running server as ours without depending on user-visible copy.
 const DASHBOARD_MARKER = 'name="generator" content="shrinker-dashboard"';
-function getCliRelaunchCommand(args) {
-    if (process.pkg || !process.argv[1]) {
-        return { command: process.execPath, args };
+function isSnapshotPath(value) {
+    return Boolean(value && /(?:^|[\\/])(?:snapshot|snapshot:)(?:[\\/]|$)/i.test(value));
+}
+export function getCliRelaunchCommand(args, runtime = {
+    execPath: process.execPath,
+    argv: process.argv,
+    packaged: Boolean(process.pkg),
+}) {
+    const scriptPath = runtime.argv[1];
+    if (runtime.packaged || !scriptPath || isSnapshotPath(scriptPath)) {
+        return { command: runtime.execPath, args };
     }
-    return { command: process.execPath, args: [process.argv[1], ...args] };
+    return { command: runtime.execPath, args: [scriptPath, ...args] };
 }
 // Neutralizes `</script>` inside string fields so the payload cannot break out of the JSON block.
 function serializePayload(summary) {
@@ -79,16 +87,42 @@ export function serveStatsDashboard(getSummary, port = 4317) {
 }
 async function isShrinkerDashboard(url) {
     try {
-        const response = await fetch(url, { signal: AbortSignal.timeout(500) });
+        const response = await requestLocal(url);
         if (!response.ok)
             return false;
-        const body = await response.text();
+        const body = response.body;
         return body.includes(DASHBOARD_MARKER) || body.includes("Shrinker stats");
     }
     catch {
         return false;
     }
 }
+function requestLocal(url, method = "GET", timeoutMs = 500) {
+    return new Promise((resolve, reject) => {
+        const parsed = new URL(url);
+        const request = httpRequest({
+            hostname: parsed.hostname,
+            port: parsed.port,
+            path: `${parsed.pathname}${parsed.search}`,
+            method,
+            timeout: timeoutMs,
+        }, (response) => {
+            const chunks = [];
+            response.on("data", (chunk) => chunks.push(chunk));
+            response.on("end", () => {
+                const statusCode = response.statusCode ?? 0;
+                resolve({
+                    ok: statusCode >= 200 && statusCode < 300,
+                    statusCode,
+                    body: Buffer.concat(chunks).toString("utf8"),
+                });
+            });
+        });
+        request.on("error", reject);
+        request.on("timeout", () => request.destroy(new Error(`Timed out connecting to ${url}`)));
+        request.end();
+    });
+}
 async function findListeningProcessId(port) {
     try {
         if (process.platform === "win32") {
@@ -133,10 +167,8 @@ export async function startStatsDashboard(port = 4317, restart = false) {
     if (restart) {
         let response;
         try {
-            response = await fetch(`${url}/__shrinker_shutdown`, {
-                method: "POST",
-                signal: AbortSignal.timeout(500),
-            });
+            const shutdown = await requestLocal(`${url}/__shrinker_shutdown`, "POST");
+            response = { ok: shutdown.ok };
         }
         catch { }
         if (response && !response.ok) {
@@ -154,7 +186,23 @@ export async function startStatsDashboard(port = 4317, restart = false) {
     }
     const command = getCliRelaunchCommand(["stats", "--dashboard", "--dashboard-server", "--port", String(port)]);
     const child = spawn(command.command, command.args, { detached: true, stdio: "ignore" });
+    await new Promise((resolve, reject) => {
+        child.once("error", reject);
+        child.once("spawn", resolve);
+    });
     child.unref();
+    if (!(await waitForDashboard(url))) {
+        throw new Error(`Dashboard server did not start at ${url}`);
+    }
     return { pid: child.pid ?? 0, reused: false, restarted };
 }
+async function waitForDashboard(url, timeoutMs = 3000) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        if (await isShrinkerDashboard(url))
+            return true;
+        await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+    return false;
+}
 //# sourceMappingURL=dashboard.js.map

package/dist/src/metrics/measure.js

@@ -1,22 +1,26 @@
 function estimatedTokens(text) {
     return Math.ceil(text.length / 4);
 }
+export function reductionPercent(rawEstimatedTokens, outputEstimatedTokens) {
+    if (rawEstimatedTokens === 0)
+        return 0;
+    const rounded = Math.max(0, Math.round((1 - outputEstimatedTokens / rawEstimatedTokens) * 100));
+    return outputEstimatedTokens > 0 && rounded === 100 ? 99 : rounded;
+}
 export function measure(raw, output) {
     const rawBytes = Buffer.byteLength(raw);
     const outputBytes = Buffer.byteLength(output);
     const rawEstimatedTokens = estimatedTokens(raw);
     const outputEstimatedTokens = estimatedTokens(output);
     const estimatedTokensSaved = Math.max(0, rawEstimatedTokens - outputEstimatedTokens);
-    const reductionPercent = rawEstimatedTokens === 0
-        ? 0
-        : Math.max(0, Math.round((1 - outputEstimatedTokens / rawEstimatedTokens) * 100));
+    const percent = reductionPercent(rawEstimatedTokens, outputEstimatedTokens);
     return {
         rawBytes,
         outputBytes,
         rawEstimatedTokens,
         outputEstimatedTokens,
         estimatedTokensSaved,
-        reductionPercent,
+        reductionPercent: percent,
     };
 }
 export function formatMeasurements(measurements, durationMs) {

package/dist/src/metrics/stats-store.js

@@ -2,6 +2,7 @@ import { mkdirSync } from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { DatabaseSync } from "node:sqlite";
+import { reductionPercent } from "./measure.js";
 import { isCoverageTrackingEnabled, sanitizeToken, } from "./coverage.js";
 const DEFAULT_INPUT_COST_PER_MILLION_TOKENS = 5;
 function inputCostPerMillionTokens() {
@@ -156,7 +157,7 @@ function toStatsRow(row, filterKind = "all") {
         outputEstimatedTokens: output,
         estimatedTokensSaved,
         estimatedInputCostSavedUsd: (estimatedTokensSaved / 1_000_000) * inputCostPerMillionTokens(),
-        reductionPercent: raw === 0 ? 0 : Math.max(0, Math.round((1 - output / raw) * 100)),
+        reductionPercent: reductionPercent(raw, output),
     };
 }
 const AGGREGATE = `

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shrinker-ai",
-  "version": "0.10.0",
+  "version": "0.11.0",
   "description": "Local deterministic command-output shrinker for coding agents",
   "type": "module",
   "bin": {