shrinker-ai 0.7.0 → 0.9.0

package/README.md

@@ -53,6 +53,22 @@ The installer downloads these anonymous GitHub Release assets by default:
 
 Network allowlists need access to `raw.githubusercontent.com` for the installer script and `github.com/ivanduplenskikh/shrinker/releases/download/...` for release assets.
 
+### Update notices
+
+Shrinker checks GitHub Releases at most once every 24 hours and prints an update notice to stderr when a newer version is available. The check only requests release metadata from GitHub; command output, paths, stats, and machine identifiers are not sent.
+
+To disable update checks for one shell session:
+
+```powershell
+$env:SHRINKER_UPDATE_CHECK = "0"
+```
+
+Or set it in `~/.shrinker/config`:
+
+```text
+SHRINKER_UPDATE_CHECK=0
+```
+
 ### Optional npm package install
 
 Use this only when npm registry access is available or preferred.

package/dist/src/cli.js

@@ -9,6 +9,8 @@ import { formatMeasurements, measure } from "./metrics/measure.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";
+import { checkForUpdate, formatUpdateNotice, markUpdateNoticeShown, wasUpdateNoticeShown } from "./updates/check.js";
+import { getCurrentVersion } from "./version.js";
 function usage() {
     return `Usage:
   shrinker <command> [args...]
@@ -297,10 +299,25 @@ async function render(rawOutput, options, durationMs, exitCode) {
         }
     }
 }
+async function maybeShowUpdateNotice() {
+    try {
+        const currentVersion = getCurrentVersion();
+        const result = await checkForUpdate(currentVersion ? { currentVersion } : {});
+        if (result.latestVersion && wasUpdateNoticeShown(result.latestVersion))
+            return;
+        const notice = formatUpdateNotice(result);
+        if (notice)
+            process.stderr.write(`${notice}\n`);
+        if (result.latestVersion && notice)
+            markUpdateNoticeShown(result.latestVersion);
+    }
+    catch { }
+}
 async function main() {
     const options = parseArgs(process.argv.slice(2));
     if (options.mode === "help") {
         process.stdout.write(`${usage()}\n`);
+        await maybeShowUpdateNotice();
         return;
     }
     if (options.mode === "stats") {
@@ -321,6 +338,7 @@ async function main() {
                 else {
                     process.stdout.write(`Dashboard server started at http://127.0.0.1:${options.dashboardPort} (PID ${dashboard.pid})\n`);
                 }
+                await maybeShowUpdateNotice();
             }
             return;
         }
@@ -332,6 +350,7 @@ async function main() {
                     ? formatStatsChart(summary)
                     : formatStats(summary);
         process.stdout.write(`${output}\n`);
+        await maybeShowUpdateNotice();
         return;
     }
     if (options.mode === "track") {
@@ -368,6 +387,7 @@ async function main() {
     if (options.mode === "pipe") {
         const input = await readStdin();
         await render(input, options);
+        await maybeShowUpdateNotice();
         return;
     }
     const [command, ...args] = options.command;
@@ -376,6 +396,8 @@ async function main() {
     const result = await runCommand(command, args);
     await render(result.combined, options, result.durationMs, result.exitCode);
     process.exitCode = result.exitCode;
+    if (result.exitCode === 0)
+        await maybeShowUpdateNotice();
 }
 main().catch((error) => {
     process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);

package/dist/src/config.js

@@ -1,4 +1,4 @@
-import { readFileSync } from "node:fs";
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import os from "node:os";
 import path from "node:path";
 export function defaultConfigPath() {
@@ -35,6 +35,28 @@ export function resolveSetting(key, configPath) {
         return fromEnvironment;
     return readConfig(configPath).get(key);
 }
+export function setConfigValue(key, value, configPath = defaultConfigPath()) {
+    const directory = path.dirname(configPath);
+    mkdirSync(directory, { recursive: true, mode: 0o700 });
+    let lines = [];
+    try {
+        lines = readFileSync(configPath, "utf8").split(/\r?\n/);
+    }
+    catch { }
+    let replaced = false;
+    const nextLines = lines.map((line) => {
+        const withoutComment = line.split("#")[0]?.trim() ?? "";
+        const separator = withoutComment.indexOf("=");
+        const existingKey = separator > 0 ? withoutComment.slice(0, separator).trim() : "";
+        if (existingKey !== key)
+            return line;
+        replaced = true;
+        return `${key}=${value}`;
+    }).filter((line, index, array) => line !== "" || index < array.length - 1);
+    if (!replaced)
+        nextLines.push(`${key}=${value}`);
+    writeFileSync(configPath, `${nextLines.join("\n")}\n`, "utf8");
+}
 export function isTruthy(value) {
     const normalized = value?.trim().toLowerCase();
     return normalized === "1" || normalized === "true" || normalized === "yes";

package/dist/src/updates/check.js

@@ -0,0 +1,144 @@
+import { defaultConfigPath, isTruthy, readConfig, resolveSetting, setConfigValue } from "../config.js";
+const DEFAULT_REPOSITORY = "ivanduplenskikh/shrinker";
+const DEFAULT_INTERVAL_HOURS = 24;
+const DEFAULT_TIMEOUT_MS = 750;
+const LAST_CHECK_KEY = "SHRINKER_LAST_UPDATE_CHECK";
+const LATEST_VERSION_KEY = "SHRINKER_LATEST_VERSION";
+const NOTICE_SHOWN_KEY = "SHRINKER_UPDATE_NOTICE_SHOWN";
+function normalizeVersion(value) {
+    const normalized = value?.trim().replace(/^v/, "");
+    return normalized && /^\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?$/.test(normalized) ? normalized : undefined;
+}
+function parseVersion(value) {
+    const normalized = normalizeVersion(value);
+    if (!normalized)
+        return undefined;
+    const [core, suffix] = normalized.split(/[-+]/, 2);
+    const parts = core?.split(".").map((part) => Number(part)) ?? [];
+    const major = parts[0];
+    const minor = parts[1];
+    const patch = parts[2];
+    if (!Number.isInteger(major) || !Number.isInteger(minor) || !Number.isInteger(patch))
+        return undefined;
+    const parsedMajor = major;
+    const parsedMinor = minor;
+    const parsedPatch = patch;
+    return {
+        major: parsedMajor,
+        minor: parsedMinor,
+        patch: parsedPatch,
+        ...(suffix ? { prerelease: suffix } : {}),
+    };
+}
+export function compareVersions(current, latest) {
+    const left = parseVersion(current);
+    const right = parseVersion(latest);
+    if (!left || !right)
+        return 0;
+    for (const key of ["major", "minor", "patch"]) {
+        if (left[key] < right[key])
+            return -1;
+        if (left[key] > right[key])
+            return 1;
+    }
+    if (left.prerelease && !right.prerelease)
+        return -1;
+    if (!left.prerelease && right.prerelease)
+        return 1;
+    if ((left.prerelease ?? "") < (right.prerelease ?? ""))
+        return -1;
+    if ((left.prerelease ?? "") > (right.prerelease ?? ""))
+        return 1;
+    return 0;
+}
+function updateChecksEnabled(configPath) {
+    const setting = resolveSetting("SHRINKER_UPDATE_CHECK", configPath);
+    if (setting === undefined)
+        return true;
+    return isTruthy(setting);
+}
+function intervalHours(configPath, fallback) {
+    const configured = Number(resolveSetting("SHRINKER_UPDATE_CHECK_INTERVAL_HOURS", configPath));
+    return Number.isFinite(configured) && configured >= 0 ? configured : fallback;
+}
+function cachedResult(currentVersion, latestVersion) {
+    const latest = normalizeVersion(latestVersion);
+    return {
+        updateAvailable: compareVersions(currentVersion, latest) < 0,
+        ...(currentVersion ? { currentVersion } : {}),
+        ...(latest ? { latestVersion: latest } : {}),
+        checked: false,
+    };
+}
+function isCacheFresh(config, now, maxAgeHours) {
+    const previous = Number(config.get(LAST_CHECK_KEY));
+    if (!Number.isFinite(previous) || previous <= 0)
+        return false;
+    return now - previous < maxAgeHours * 60 * 60 * 1000;
+}
+async function fetchLatestRelease(repository, timeoutMs, fetchImpl) {
+    const response = await fetchImpl(`https://api.github.com/repos/${repository}/releases/latest`, {
+        headers: { "Accept": "application/vnd.github+json", "User-Agent": "shrinker-update-check" },
+        signal: AbortSignal.timeout(timeoutMs),
+    });
+    if (!response.ok)
+        return undefined;
+    const body = await response.json();
+    const version = normalizeVersion(typeof body.tag_name === "string" ? body.tag_name : undefined);
+    if (!version)
+        return undefined;
+    return {
+        version,
+        ...(typeof body.html_url === "string" ? { releaseUrl: body.html_url } : {}),
+    };
+}
+export async function checkForUpdate(options = {}) {
+    const configPath = options.configPath ?? defaultConfigPath();
+    const currentVersion = normalizeVersion(options.currentVersion);
+    if (!currentVersion || !updateChecksEnabled(configPath)) {
+        return { updateAvailable: false, ...(currentVersion ? { currentVersion } : {}), checked: false };
+    }
+    const now = options.now ?? Date.now();
+    const config = readConfig(configPath);
+    const maxAgeHours = options.intervalHours ?? intervalHours(configPath, DEFAULT_INTERVAL_HOURS);
+    if (isCacheFresh(config, now, maxAgeHours)) {
+        return cachedResult(currentVersion, config.get(LATEST_VERSION_KEY));
+    }
+    try {
+        const latest = await fetchLatestRelease(options.repository ?? DEFAULT_REPOSITORY, options.timeoutMs ?? DEFAULT_TIMEOUT_MS, options.fetchImpl ?? fetch);
+        if (!latest?.version)
+            return { updateAvailable: false, currentVersion, checked: true };
+        setConfigValue(LAST_CHECK_KEY, String(now), configPath);
+        setConfigValue(LATEST_VERSION_KEY, latest.version, configPath);
+        return {
+            updateAvailable: compareVersions(currentVersion, latest.version) < 0,
+            currentVersion,
+            latestVersion: latest.version,
+            ...(latest.releaseUrl ? { releaseUrl: latest.releaseUrl } : {}),
+            checked: true,
+        };
+    }
+    catch {
+        return { updateAvailable: false, currentVersion, checked: true };
+    }
+}
+export function formatUpdateNotice(result) {
+    if (!result.updateAvailable || !result.currentVersion || !result.latestVersion)
+        return undefined;
+    const releaseUrl = result.releaseUrl ?? `https://github.com/${DEFAULT_REPOSITORY}/releases/latest`;
+    const installCommand = process.platform === "win32"
+        ? `& ([scriptblock]::Create((irm https://raw.githubusercontent.com/${DEFAULT_REPOSITORY}/main/integrations/windows/install.ps1))) -Version ${result.latestVersion}`
+        : `curl -fsSL https://raw.githubusercontent.com/${DEFAULT_REPOSITORY}/main/integrations/macos/install.sh | bash -s -- --version ${result.latestVersion}`;
+    return [
+        `[shrinker] Update available: ${result.currentVersion} -> ${result.latestVersion}`,
+        `[shrinker] Release: ${releaseUrl}`,
+        `[shrinker] Install: ${installCommand}`,
+    ].join("\n");
+}
+export function markUpdateNoticeShown(latestVersion, configPath = defaultConfigPath()) {
+    setConfigValue(NOTICE_SHOWN_KEY, latestVersion, configPath);
+}
+export function wasUpdateNoticeShown(latestVersion, configPath = defaultConfigPath()) {
+    return readConfig(configPath).get(NOTICE_SHOWN_KEY) === latestVersion;
+}
+//# sourceMappingURL=check.js.map

package/dist/src/version.js

@@ -0,0 +1,66 @@
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import process from "node:process";
+import { fileURLToPath } from "node:url";
+const VERSION_PATTERN = /^\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?$/;
+let cachedVersion;
+export function isPackagedBinary() {
+    return Boolean(process.pkg);
+}
+function normalizeVersion(value) {
+    if (typeof value !== "string")
+        return undefined;
+    const normalized = value.trim().replace(/^v/, "");
+    return VERSION_PATTERN.test(normalized) ? normalized : undefined;
+}
+function readVersionFile(filePath) {
+    try {
+        const metadata = JSON.parse(readFileSync(filePath, "utf8"));
+        return normalizeVersion(metadata.version);
+    }
+    catch {
+        return undefined;
+    }
+}
+function findPackageJsonVersion(startDirectory) {
+    let directory = startDirectory;
+    while (true) {
+        const packagePath = path.join(directory, "package.json");
+        const version = readVersionFile(packagePath);
+        if (version)
+            return version;
+        const parent = path.dirname(directory);
+        if (parent === directory)
+            return undefined;
+        directory = parent;
+    }
+}
+function findManifestVersion() {
+    const executableDirectory = path.dirname(process.execPath);
+    for (const candidate of [
+        path.join(executableDirectory, "..", "manifest.json"),
+        path.join(executableDirectory, "manifest.json"),
+        path.join(process.cwd(), "manifest.json"),
+    ]) {
+        const resolved = path.resolve(candidate);
+        if (!existsSync(resolved))
+            continue;
+        const version = readVersionFile(resolved);
+        if (version)
+            return version;
+    }
+    return undefined;
+}
+export function getCurrentVersion() {
+    if (cachedVersion)
+        return cachedVersion;
+    const manifestVersion = findManifestVersion();
+    if (manifestVersion) {
+        cachedVersion = manifestVersion;
+        return cachedVersion;
+    }
+    const moduleDirectory = path.dirname(fileURLToPath(import.meta.url));
+    cachedVersion = findPackageJsonVersion(moduleDirectory);
+    return cachedVersion;
+}
+//# sourceMappingURL=version.js.map

package/integrations/windows/install.ps1

@@ -137,6 +137,7 @@ function Install-ReleasePackage {
         Invoke-WebRequest -Uri $assetUrl -OutFile $archivePath -UseBasicParsing
         New-Item -ItemType Directory -Force -Path $extractPath | Out-Null
         Expand-Archive -LiteralPath $archivePath -DestinationPath $extractPath -Force
+        New-Item -ItemType Directory -Force -Path $InstallDir | Out-Null
 
         foreach ($name in @("bin", "integrations", "templates")) {
             $source = Join-Path $extractPath $name
@@ -154,6 +155,11 @@ function Install-ReleasePackage {
 
     $binPath = Join-Path $InstallDir "bin"
     $exePath = Join-Path $binPath "shrinker.exe"
+    $legacyExePath = Join-Path $InstallDir "shrinker.exe"
+    if (-not (Test-Path -LiteralPath $exePath) -and (Test-Path -LiteralPath $legacyExePath)) {
+        New-Item -ItemType Directory -Force -Path $binPath | Out-Null
+        Move-Item -LiteralPath $legacyExePath -Destination $exePath -Force
+    }
     if (-not (Test-Path -LiteralPath $exePath)) { throw "Installed executable not found: $exePath" }
     Add-UserPathEntry $binPath
 

package/package.json

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