skillwiki 0.9.55 → 0.9.56

package/dist/auto-update-bg.js

@@ -1,19 +1,23 @@
 #!/usr/bin/env node
 #!/usr/bin/env node
 import {
+  cachePath,
   normalizeDistTag,
-  semverGt
-} from "./chunk-E6UWZ3S3.js";
+  readCacheRaw,
+  resolveAutoApplyAt,
+  semverGt,
+  writeCache
+} from "./chunk-7I2TPIV5.js";
 
 // src/auto-update-bg.ts
 import { execSync } from "child_process";
 import { writeFileSync, mkdirSync } from "fs";
-import { join, dirname } from "path";
+import { dirname } from "path";
 var home = process.argv[2];
 var currentVersion = process.argv[3];
 var distTag = normalizeDistTag(process.argv[4]);
 if (!home || !currentVersion) process.exit(0);
-var cacheFile = join(home, ".skillwiki", ".update-cache.json");
+var cacheFile = cachePath(home);
 setTimeout(() => process.exit(0), 3e4);
 try {
   const latest = execSync(`npm view skillwiki@${distTag} version`, {
@@ -21,25 +25,41 @@ try {
     timeout: 15e3
   }).trim();
   mkdirSync(dirname(cacheFile), { recursive: true });
+  const prior = readCacheRaw(home);
+  const { firstSeenAt, autoApplyAt } = resolveAutoApplyAt(prior, latest);
   const cache = {
     lastCheck: Date.now(),
     latestVersion: latest,
     currentVersion,
-    distTag
+    distTag,
+    firstSeenAt,
+    autoApplyAt
   };
   if (semverGt(latest, currentVersion)) {
+    if (Date.now() < autoApplyAt) {
+      writeFileSync(cacheFile, JSON.stringify(cache, null, 2));
+      process.exit(0);
+    }
     execSync(`npm install -g skillwiki@${distTag}`, {
       stdio: "ignore",
       timeout: 6e4
     });
-    writeFileSync(cacheFile, JSON.stringify({ ...cache, updateAppliedAt: Date.now() }, null, 2));
+    writeCache(home, { ...cache, updateAppliedAt: Date.now() });
   } else {
     writeFileSync(cacheFile, JSON.stringify(cache, null, 2));
   }
 } catch {
   try {
-    mkdirSync(dirname(cacheFile), { recursive: true });
-    writeFileSync(cacheFile, JSON.stringify({ lastCheck: Date.now(), latestVersion: "", currentVersion, distTag }, null, 2));
+    const prior = readCacheRaw(home);
+    const staleCache = {
+      lastCheck: Date.now(),
+      latestVersion: "",
+      currentVersion,
+      distTag,
+      ...prior?.firstSeenAt ? { firstSeenAt: prior.firstSeenAt } : {},
+      ...prior?.autoApplyAt ? { autoApplyAt: prior.autoApplyAt } : {}
+    };
+    writeCache(home, staleCache);
   } catch {
   }
 }

package/dist/chunk-7I2TPIV5.js

@@ -0,0 +1,154 @@
+#!/usr/bin/env node
+
+// src/utils/semver.ts
+function semverGt(a, b) {
+  const pa = parseSemver(a);
+  const pb = parseSemver(b);
+  if (!pa || !pb) return a > b;
+  if (pa.major !== pb.major) return pa.major > pb.major;
+  if (pa.minor !== pb.minor) return pa.minor > pb.minor;
+  if (pa.patch !== pb.patch) return pa.patch > pb.patch;
+  if (!pa.pre && pb.pre) return true;
+  if (pa.pre && !pb.pre) return false;
+  if (!pa.pre && !pb.pre) return false;
+  const aParts = pa.pre.split(".");
+  const bParts = pb.pre.split(".");
+  const len = Math.max(aParts.length, bParts.length);
+  for (let i = 0; i < len; i++) {
+    const ai = aParts[i];
+    const bi = bParts[i];
+    if (ai === void 0) return false;
+    if (bi === void 0) return true;
+    const aNum = parseInt(ai, 10);
+    const bNum = parseInt(bi, 10);
+    if (!isNaN(aNum) && !isNaN(bNum)) {
+      if (aNum !== bNum) return aNum > bNum;
+    } else {
+      if (ai !== bi) return ai > bi;
+    }
+  }
+  return false;
+}
+function parseSemver(version) {
+  const match = version.match(/^(\d+)\.(\d+)\.(\d+)(?:-(.+))?$/);
+  if (!match) return null;
+  return {
+    major: parseInt(match[1], 10),
+    minor: parseInt(match[2], 10),
+    patch: parseInt(match[3], 10),
+    pre: match[4] ?? null
+  };
+}
+
+// src/utils/update-consts.ts
+var DIST_TAG = "latest";
+var CACHE_FILENAME = ".update-cache.json";
+var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
+var AUTO_APPLY_DELAY_MS = 6 * 60 * 60 * 1e3;
+var ENV_DISABLE_KEY = "NO_UPDATE_NOTIFIER";
+var CLI_DISABLE_FLAG = "--no-update-notifier";
+function normalizeDistTag(tag) {
+  const value = (tag ?? DIST_TAG).trim();
+  return /^[A-Za-z0-9._-]+$/.test(value) ? value : DIST_TAG;
+}
+
+// src/utils/auto-update.ts
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { join, dirname } from "path";
+import { spawn } from "child_process";
+import { fileURLToPath } from "url";
+function cachePath(home) {
+  return join(home, ".skillwiki", CACHE_FILENAME);
+}
+function readCacheRaw(home) {
+  try {
+    const raw = readFileSync(cachePath(home), "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function readCache(home) {
+  const cache = readCacheRaw(home);
+  if (!cache) return { cache: null, hasUpdate: false, isStale: true };
+  const isStale = Date.now() - cache.lastCheck >= CHECK_INTERVAL_MS;
+  const hasUpdate = !!cache.latestVersion && semverGt(cache.latestVersion, cache.currentVersion);
+  return { cache, hasUpdate, isStale };
+}
+function writeCache(home, cache) {
+  const p = cachePath(home);
+  mkdirSync(dirname(p), { recursive: true });
+  writeFileSync(p, JSON.stringify(cache, null, 2));
+}
+function resolveAutoApplyAt(cache, latestVersion, now = Date.now()) {
+  if (cache && cache.firstSeenAt && cache.latestVersion === latestVersion && cache.autoApplyAt) {
+    return { firstSeenAt: cache.firstSeenAt, autoApplyAt: cache.autoApplyAt };
+  }
+  const firstSeenAt = now;
+  return { firstSeenAt, autoApplyAt: firstSeenAt + AUTO_APPLY_DELAY_MS };
+}
+function formatCountdown(autoApplyAt, now = Date.now()) {
+  if (!autoApplyAt) return null;
+  const remainingMs = autoApplyAt - now;
+  if (remainingMs <= 0) return null;
+  const totalMin = Math.ceil(remainingMs / 6e4);
+  const hours = Math.floor(totalMin / 60);
+  const mins = totalMin % 60;
+  return hours > 0 ? `${hours}h ${mins}m` : `${mins}m`;
+}
+function latestFromCache(home, currentVersion) {
+  const { cache } = readCache(home);
+  if (!cache || !cache.latestVersion) return { hasUpdate: false, latest: null, distTag: DIST_TAG };
+  const distTag = normalizeDistTag(cache.distTag);
+  return {
+    hasUpdate: semverGt(cache.latestVersion, currentVersion),
+    latest: cache.latestVersion,
+    distTag
+  };
+}
+function isDisabled() {
+  return !!(process.env[ENV_DISABLE_KEY] || process.env.NODE_ENV === "test" || process.argv.includes(CLI_DISABLE_FLAG));
+}
+function triggerAutoUpdate(home, currentVersion) {
+  if (isDisabled()) return;
+  const { cache, isStale } = readCache(home);
+  if (isStale) {
+    const distTag = normalizeDistTag(cache?.distTag);
+    const bgScript = fileURLToPath(new URL("./auto-update-bg.js", import.meta.url));
+    if (existsSync(bgScript)) {
+      const child = spawn(process.execPath, [bgScript, home, currentVersion, distTag], {
+        detached: true,
+        stdio: "ignore"
+      });
+      child.on("error", () => {
+      });
+      child.unref();
+    }
+  }
+  notifyPendingUpdate(cache, currentVersion);
+}
+function notifyPendingUpdate(cache, currentVersion) {
+  if (isDisabled()) return;
+  if (!cache || !cache.latestVersion) return;
+  if (!semverGt(cache.latestVersion, currentVersion)) return;
+  const { autoApplyAt } = resolveAutoApplyAt(cache, cache.latestVersion);
+  const remaining = formatCountdown(autoApplyAt);
+  if (remaining === null) return;
+  const distTag = normalizeDistTag(cache.distTag);
+  process.stderr.write(
+    `Update available: ${currentVersion} -> ${cache.latestVersion} (${distTag}). Auto-applying in ${remaining}. Run \`skillwiki update --tag ${distTag}\` now, or set NO_UPDATE_NOTIFIER=1 to opt out.
+`
+  );
+}
+
+export {
+  semverGt,
+  normalizeDistTag,
+  cachePath,
+  readCacheRaw,
+  readCache,
+  writeCache,
+  resolveAutoApplyAt,
+  latestFromCache,
+  triggerAutoUpdate
+};