@captainsafia/stitch 1.0.0-preview.c77f34b → 1.0.0-preview.f2a6c41-preview.e348edd

package/dist/cli.js

@@ -1895,7 +1895,7 @@ var require_commander = __commonJS((exports) => {
 var require_package = __commonJS((exports, module) => {
   module.exports = {
     name: "@captainsafia/stitch",
-    version: "1.0.0-preview.c77f34b",
+    version: "1.0.0-preview.f2a6c41-preview.e348edd",
     type: "module",
     description: "A local-first CLI for recording intent and binding it to git commits/diffs",
     main: "dist/api.js",
@@ -1943,6 +1943,7 @@ var require_package = __commonJS((exports, module) => {
       "@modelcontextprotocol/sdk": "^1.25.1",
       "async-mutex": "^0.5.0",
       commander: "^12.0.0",
+      "gh-release-update-notifier": "^1.0.0",
       "smol-toml": "^1.3.0",
       zod: "^4.2.1"
     },
@@ -1964,6 +1965,9 @@ var require_package = __commonJS((exports, module) => {
   };
 });
 
+// src/cli.ts
+import { join as join4 } from "path";
+
 // node_modules/commander/esm.mjs
 var import__ = __toESM(require_commander(), 1);
 var {
@@ -1980,13 +1984,181 @@ var {
   Help
 } = import__.default;
 
+// node_modules/gh-release-update-notifier/dist/index.mjs
+import { existsSync, readFileSync, writeFileSync } from "fs";
+var ReleaseNotifier = class {
+  repo;
+  checkInterval;
+  cacheFilePath;
+  token;
+  cachedReleases = null;
+  lastFetchTime = 0;
+  constructor(config) {
+    this.repo = config.repo;
+    this.checkInterval = config.checkInterval ?? 3600000;
+    this.cacheFilePath = config.cacheFilePath ?? null;
+    this.token = config.token ?? null;
+    this.loadCacheFromDisk();
+  }
+  async getLatestRelease(includePrerelease = false) {
+    try {
+      const validReleases = (await this.fetchAllReleases()).filter((release) => {
+        if (release.draft)
+          return false;
+        if (!includePrerelease && release.prerelease)
+          return false;
+        return true;
+      });
+      if (validReleases.length === 0)
+        return null;
+      const latest = validReleases[0];
+      return {
+        tagName: latest.tag_name,
+        name: latest.name,
+        prerelease: latest.prerelease,
+        draft: latest.draft,
+        htmlUrl: latest.html_url,
+        publishedAt: latest.published_at
+      };
+    } catch (error) {
+      throw new Error(`Failed to fetch releases: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  async getLatestPrerelease() {
+    try {
+      const prerelease = (await this.fetchAllReleases()).find((release) => release.prerelease && !release.draft);
+      if (!prerelease)
+        return null;
+      return {
+        tagName: prerelease.tag_name,
+        name: prerelease.name,
+        prerelease: prerelease.prerelease,
+        draft: prerelease.draft,
+        htmlUrl: prerelease.html_url,
+        publishedAt: prerelease.published_at
+      };
+    } catch (error) {
+      throw new Error(`Failed to fetch prereleases: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  async checkVersion(currentVersion, isPrerelease = false) {
+    try {
+      const releases = await this.fetchAllReleases();
+      if (releases.length === 0)
+        return {
+          updateAvailable: false,
+          currentVersion,
+          latestVersion: null,
+          latestRelease: null
+        };
+      const normalizedCurrent = this.normalizeVersion(currentVersion);
+      const currentRelease = releases.find((r) => this.normalizeVersion(r.tag_name) === normalizedCurrent || r.tag_name === currentVersion);
+      const latestRelease = isPrerelease ? releases.find((r) => r.prerelease && !r.draft) : releases.find((r) => !r.prerelease && !r.draft);
+      if (!latestRelease)
+        return {
+          updateAvailable: false,
+          currentVersion,
+          latestVersion: null,
+          latestRelease: null
+        };
+      const latest = {
+        tagName: latestRelease.tag_name,
+        name: latestRelease.name,
+        prerelease: latestRelease.prerelease,
+        draft: latestRelease.draft,
+        htmlUrl: latestRelease.html_url,
+        publishedAt: latestRelease.published_at
+      };
+      if (!currentRelease)
+        return {
+          updateAvailable: true,
+          currentVersion,
+          latestVersion: latestRelease.tag_name,
+          latestRelease: latest
+        };
+      return {
+        updateAvailable: this.isVersionOlder(currentRelease.published_at, latestRelease.published_at),
+        currentVersion,
+        latestVersion: latestRelease.tag_name,
+        latestRelease: latest
+      };
+    } catch (error) {
+      throw new Error(`Failed to check version: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  async fetchAllReleases() {
+    const now = Date.now();
+    if (this.cachedReleases !== null && this.checkInterval > 0 && now - this.lastFetchTime < this.checkInterval)
+      return this.cachedReleases;
+    const headers = {
+      Accept: "application/vnd.github+json",
+      "X-GitHub-Api-Version": "2022-11-28"
+    };
+    if (this.token)
+      headers["Authorization"] = `Bearer ${this.token}`;
+    const response = await fetch(`https://api.github.com/repos/${this.repo}/releases`, { headers });
+    if (!response.ok)
+      throw new Error(`GitHub API error: ${response.status} ${response.statusText}`);
+    const releases = await response.json();
+    releases.sort((a, b) => new Date(b.published_at).getTime() - new Date(a.published_at).getTime());
+    this.cachedReleases = releases;
+    this.lastFetchTime = now;
+    this.saveCacheToDisk();
+    return releases;
+  }
+  clearCache() {
+    this.cachedReleases = null;
+    this.lastFetchTime = 0;
+    this.saveCacheToDisk();
+  }
+  loadCacheFromDisk() {
+    if (!this.cacheFilePath)
+      return;
+    try {
+      if (existsSync(this.cacheFilePath)) {
+        const data = readFileSync(this.cacheFilePath, "utf-8");
+        const cache = JSON.parse(data);
+        this.cachedReleases = cache.releases;
+        this.lastFetchTime = cache.lastFetchTime;
+      }
+    } catch {
+      this.cachedReleases = null;
+      this.lastFetchTime = 0;
+    }
+  }
+  saveCacheToDisk() {
+    if (!this.cacheFilePath)
+      return;
+    try {
+      if (this.cachedReleases === null)
+        writeFileSync(this.cacheFilePath, JSON.stringify({
+          lastFetchTime: 0,
+          releases: []
+        }), "utf-8");
+      else {
+        const cache = {
+          lastFetchTime: this.lastFetchTime,
+          releases: this.cachedReleases
+        };
+        writeFileSync(this.cacheFilePath, JSON.stringify(cache), "utf-8");
+      }
+    } catch {}
+  }
+  normalizeVersion(version) {
+    return version.trim().replace(/^v/i, "");
+  }
+  isVersionOlder(date1, date2) {
+    return new Date(date1).getTime() < new Date(date2).getTime();
+  }
+};
+
 // src/api.ts
 import { spawn } from "child_process";
 
 // src/core/store.ts
 import { readdir, readFile, writeFile, mkdir } from "fs/promises";
 import { join } from "path";
-import { existsSync } from "fs";
+import { existsSync as existsSync2 } from "fs";
 
 // src/core/errors.ts
 class StitchError extends Error {
@@ -3346,13 +3518,13 @@ function getCurrentFilePath(repoRoot) {
   return join(repoRoot, STITCH_DIR, CURRENT_FILE);
 }
 function isInitialized(repoRoot) {
-  return existsSync(getStitchDir(repoRoot));
+  return existsSync2(getStitchDir(repoRoot));
 }
 async function initializeStitch(repoRoot) {
   const stitchesDir = getStitchesDir(repoRoot);
   const currentPath = getCurrentFilePath(repoRoot);
   await mkdir(stitchesDir, { recursive: true });
-  if (!existsSync(currentPath)) {
+  if (!existsSync2(currentPath)) {
     await writeFile(currentPath, "", "utf-8");
   }
 }
@@ -3407,7 +3579,7 @@ async function loadStitch(repoRoot, id) {
     throw new NotInitializedError;
   }
   const filePath = getStitchFilePath(repoRoot, id);
-  if (!existsSync(filePath)) {
+  if (!existsSync2(filePath)) {
     throw new StitchNotFoundError(id);
   }
   const content = await readFile(filePath, "utf-8");
@@ -3431,7 +3603,7 @@ async function listStitches(repoRoot, filter) {
     throw new NotInitializedError;
   }
   const stitchesDir = getStitchesDir(repoRoot);
-  if (!existsSync(stitchesDir)) {
+  if (!existsSync2(stitchesDir)) {
     return [];
   }
   const files = await readdir(stitchesDir);
@@ -3966,145 +4138,6 @@ function truncate(str, maxLength) {
 function renderSuccess(message) {
   return `\u2713 ${message}`;
 }
-// src/platform/update/version.ts
-function parseVersion(version) {
-  const previewMatch = version.match(/^(\d+)\.(\d+)\.(\d+)(-preview\.([a-f0-9]+))?$/);
-  if (!previewMatch) {
-    throw new Error(`Invalid version format: ${version}`);
-  }
-  return {
-    major: parseInt(previewMatch[1], 10),
-    minor: parseInt(previewMatch[2], 10),
-    patch: parseInt(previewMatch[3], 10),
-    prerelease: previewMatch[5],
-    isPreview: !!previewMatch[4]
-  };
-}
-function compareVersions(a, b) {
-  const parsedA = parseVersion(a);
-  const parsedB = parseVersion(b);
-  if (parsedA.major !== parsedB.major) {
-    return parsedA.major < parsedB.major ? -1 : 1;
-  }
-  if (parsedA.minor !== parsedB.minor) {
-    return parsedA.minor < parsedB.minor ? -1 : 1;
-  }
-  if (parsedA.patch !== parsedB.patch) {
-    return parsedA.patch < parsedB.patch ? -1 : 1;
-  }
-  if (!parsedA.isPreview && parsedB.isPreview)
-    return 1;
-  if (parsedA.isPreview && !parsedB.isPreview)
-    return -1;
-  if (parsedA.prerelease && parsedB.prerelease) {
-    return parsedA.prerelease.localeCompare(parsedB.prerelease);
-  }
-  return 0;
-}
-function isUpdateAvailable(current, latest) {
-  return compareVersions(current, latest) < 0;
-}
-// src/platform/update/check.ts
-import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
-import { existsSync as existsSync2 } from "fs";
-import { join as join3 } from "path";
-var CACHE_FILE = "update-check.json";
-var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000;
-var GITHUB_API_URL = "https://api.github.com/repos/captainsafia/stitch/releases";
-function getCacheFilePath() {
-  return join3(getConfigDir(), CACHE_FILE);
-}
-async function readCache() {
-  const cachePath = getCacheFilePath();
-  if (!existsSync2(cachePath)) {
-    return null;
-  }
-  try {
-    const content = await readFile2(cachePath, "utf-8");
-    return JSON.parse(content);
-  } catch {
-    return null;
-  }
-}
-async function writeCache(cache) {
-  const configDir = getConfigDir();
-  if (!existsSync2(configDir)) {
-    await mkdir2(configDir, { recursive: true });
-  }
-  const cachePath = getCacheFilePath();
-  await writeFile2(cachePath, JSON.stringify(cache, null, 2), "utf-8");
-}
-function isCacheValid(cache) {
-  const now = Date.now();
-  return now - cache.lastChecked < CHECK_INTERVAL_MS;
-}
-async function fetchLatestRelease() {
-  try {
-    const response = await fetch(`${GITHUB_API_URL}/latest`, {
-      headers: {
-        Accept: "application/vnd.github.v3+json",
-        "User-Agent": "stitch-cli"
-      }
-    });
-    if (!response.ok) {
-      return null;
-    }
-    const data = await response.json();
-    return data.tag_name.replace(/^v/, "");
-  } catch {
-    return null;
-  }
-}
-async function fetchLatestPreviewRelease() {
-  try {
-    const response = await fetch(`${GITHUB_API_URL}?per_page=20`, {
-      headers: {
-        Accept: "application/vnd.github.v3+json",
-        "User-Agent": "stitch-cli"
-      }
-    });
-    if (!response.ok) {
-      return null;
-    }
-    const releases = await response.json();
-    for (const release of releases) {
-      const version = release.tag_name.replace(/^v/, "");
-      if (version.includes("-preview.")) {
-        return version;
-      }
-    }
-    return null;
-  } catch {
-    return null;
-  }
-}
-async function getLatestVersion(forceRefresh = false) {
-  if (!forceRefresh) {
-    const cache = await readCache();
-    if (cache && isCacheValid(cache)) {
-      return {
-        stable: cache.latestVersion,
-        preview: cache.latestPreviewVersion ?? null
-      };
-    }
-  }
-  const [stableVersion, previewVersion] = await Promise.all([
-    fetchLatestRelease(),
-    fetchLatestPreviewRelease()
-  ]);
-  if (stableVersion) {
-    const cache = {
-      lastChecked: Date.now(),
-      latestVersion: stableVersion,
-      latestPreviewVersion: previewVersion ?? undefined
-    };
-    writeCache(cache).catch(() => {});
-  }
-  return {
-    stable: stableVersion,
-    preview: previewVersion
-  };
-}
 // src/platform/update/download.ts
 var DOWNLOAD_BASE_URL = "https://github.com/captainsafia/stitch/releases/download";
 function detectPlatform() {
@@ -4188,7 +4221,7 @@ async function downloadBinary(url, destPath, onProgress) {
 // src/platform/update/install.ts
 import { rename, unlink, chmod } from "fs/promises";
 import { existsSync as existsSync3 } from "fs";
-import { dirname, join as join4 } from "path";
+import { dirname, join as join3 } from "path";
 var {$: $2 } = globalThis.Bun;
 function getCurrentExecutablePath() {
   return process.execPath;
@@ -4196,8 +4229,8 @@ function getCurrentExecutablePath() {
 async function cleanupOldBinaries(execPath) {
   const dir = dirname(execPath);
   const baseName = execPath.endsWith(".exe") ? "stitch" : "stitch";
-  const oldPath = join4(dir, `${baseName}.old`);
-  const oldPathExe = join4(dir, `${baseName}.old.exe`);
+  const oldPath = join3(dir, `${baseName}.old`);
+  const oldPathExe = join3(dir, `${baseName}.old.exe`);
   for (const path of [oldPath, oldPathExe]) {
     if (existsSync3(path)) {
       try {
@@ -4211,8 +4244,8 @@ async function installBinaryUpdate(targetVersion, currentVersion, onProgress) {
   const execPath = getCurrentExecutablePath();
   const dir = dirname(execPath);
   const isWindows = platform === "windows-x64";
-  const newBinaryPath = join4(dir, isWindows ? "stitch.new.exe" : "stitch.new");
-  const oldBinaryPath = join4(dir, isWindows ? "stitch.old.exe" : "stitch.old");
+  const newBinaryPath = join3(dir, isWindows ? "stitch.new.exe" : "stitch.new");
+  const oldBinaryPath = join3(dir, isWindows ? "stitch.old.exe" : "stitch.old");
   const downloadUrl = getDownloadUrl(targetVersion, platform);
   try {
     await cleanupOldBinaries(execPath);
@@ -4348,13 +4381,23 @@ function getInstallMethodDescription(method) {
 var packageJson = await Promise.resolve().then(() => __toESM(require_package(), 1));
 var program2 = new Command;
 program2.name("stitch").description(packageJson.description).version(packageJson.version);
+function createNotifier() {
+  const cacheFilePath = join4(getConfigDir(), "update-check.json");
+  return new ReleaseNotifier({
+    repo: "captainsafia/stitch",
+    checkInterval: 86400000,
+    cacheFilePath,
+    token: process.env["GITHUB_TOKEN"]
+  });
+}
 async function checkForUpdates() {
   try {
-    const versions = await getLatestVersion();
     const current = packageJson.version;
-    if (versions.stable && isUpdateAvailable(current, versions.stable)) {
+    const notifier = createNotifier();
+    const result = await notifier.checkVersion(current, true);
+    if (result.updateAvailable && result.latestVersion) {
       console.error("");
-      console.error(`A new version of stitch is available: ${versions.stable} (current: ${current})`);
+      console.error(`A new version of stitch is available: ${result.latestVersion} (current: ${current})`);
       console.error("Run 'stitch update' to update.");
       console.error("");
     }
@@ -4585,20 +4628,24 @@ program2.command("update").description("Update stitch to the latest version").op
       targetVersion = options.target;
     } else if (options.preview) {
       console.log("Checking for latest preview version...");
-      const versions = await getLatestVersion(true);
-      if (!versions.preview) {
+      const notifier = createNotifier();
+      notifier.clearCache();
+      const previewRelease = await notifier.getLatestPrerelease();
+      if (!previewRelease) {
         console.error("Error: No preview version available.");
         process.exit(1);
       }
-      targetVersion = versions.preview;
+      targetVersion = previewRelease.tagName.replace(/^v/, "");
     } else {
       console.log("Checking for latest version...");
-      const versions = await getLatestVersion(true);
-      if (!versions.stable) {
+      const notifier = createNotifier();
+      notifier.clearCache();
+      const stableRelease = await notifier.getLatestRelease();
+      if (!stableRelease) {
         console.error("Error: Could not fetch latest version. Check your network connection.");
         process.exit(1);
       }
-      targetVersion = versions.stable;
+      targetVersion = stableRelease.tagName.replace(/^v/, "");
     }
     if (current === targetVersion) {
       console.log(`Already running stitch v${current}`);

package/dist/mcp.js

@@ -6494,7 +6494,7 @@ var require_dist = __commonJS((exports, module) => {
 var require_package = __commonJS((exports, module) => {
   module.exports = {
     name: "@captainsafia/stitch",
-    version: "1.0.0-preview.c77f34b",
+    version: "1.0.0-preview.f2a6c41-preview.e348edd",
     type: "module",
     description: "A local-first CLI for recording intent and binding it to git commits/diffs",
     main: "dist/api.js",
@@ -6542,6 +6542,7 @@ var require_package = __commonJS((exports, module) => {
       "@modelcontextprotocol/sdk": "^1.25.1",
       "async-mutex": "^0.5.0",
       commander: "^12.0.0",
+      "gh-release-update-notifier": "^1.0.0",
       "smol-toml": "^1.3.0",
       zod: "^4.2.1"
     },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@captainsafia/stitch",
-  "version": "1.0.0-preview.c77f34b",
+  "version": "1.0.0-preview.f2a6c41-preview.e348edd",
   "type": "module",
   "description": "A local-first CLI for recording intent and binding it to git commits/diffs",
   "main": "dist/api.js",
@@ -48,6 +48,7 @@
     "@modelcontextprotocol/sdk": "^1.25.1",
     "async-mutex": "^0.5.0",
     "commander": "^12.0.0",
+    "gh-release-update-notifier": "^1.0.0",
     "smol-toml": "^1.3.0",
     "zod": "^4.2.1"
   },