movehat 0.0.9-alpha.0 → 0.0.10-alpha.0

package/src/helpers/npm-registry.ts

@@ -0,0 +1,71 @@
+export interface NpmRegistryResponse {
+  "dist-tags": {
+    latest: string;
+    [tag: string]: string;
+  };
+  versions: Record<string, unknown>;
+}
+
+export interface FetchOptions {
+  timeout?: number; // Timeout in milliseconds
+  throwOnError?: boolean; // If true, throw errors; if false, return null on error
+}
+
+/**
+ * Fetch latest version from npm registry
+ * @param packageName - The npm package name
+ * @param options - Fetch options (timeout, error handling)
+ * @returns Latest version string, or null if failed and throwOnError is false
+ */
+export async function fetchLatestVersion(
+  packageName: string,
+  options: FetchOptions = {}
+): Promise<string | null> {
+  const { timeout = 0, throwOnError = false } = options;
+
+  try {
+    const controller = timeout > 0 ? new AbortController() : undefined;
+    const timeoutId = timeout > 0 && controller
+      ? setTimeout(() => controller.abort(), timeout)
+      : undefined;
+
+    const response = await fetch(`https://registry.npmjs.org/${packageName}`, {
+      signal: controller?.signal,
+    });
+
+    if (timeoutId) clearTimeout(timeoutId);
+
+    if (!response.ok) {
+      const error = new Error(`Failed to fetch package info: ${response.statusText}`);
+      if (throwOnError) throw error;
+      return null;
+    }
+
+    const data = (await response.json()) as NpmRegistryResponse;
+
+    // Defensive validation of registry response structure
+    if (
+      !data ||
+      typeof data !== "object" ||
+      !data["dist-tags"] ||
+      typeof data["dist-tags"] !== "object" ||
+      typeof data["dist-tags"].latest !== "string"
+    ) {
+      const error = new Error(
+        `Invalid npm registry response: missing or malformed "dist-tags.latest" field`
+      );
+      if (throwOnError) throw error;
+      return null;
+    }
+
+    return data["dist-tags"].latest;
+  } catch (error) {
+    if (throwOnError) {
+      throw new Error(
+        `Failed to check for updates: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+    // Silently fail - don't interrupt user's workflow
+    return null;
+  }
+}

package/src/helpers/semver-utils.ts

@@ -0,0 +1,53 @@
+/**
+ * Compare two semver versions
+ * Returns true if newVersion > currentVersion
+ * Handles variable-length versions (1.2, 1.2.3, 1.2.3.4, etc.)
+ */
+export function isNewerVersion(currentVersion: string, newVersion: string): boolean {
+  // Remove any pre-release tags (e.g., -alpha.0, -beta.1)
+  const cleanCurrent = currentVersion.split("-")[0];
+  const cleanNew = newVersion.split("-")[0];
+
+  // Split and validate numeric parts
+  const currentParts = cleanCurrent.split(".").map((part) => {
+    const num = Number(part);
+    if (isNaN(num) || !part.trim()) {
+      throw new Error(`Invalid version format: ${currentVersion}`);
+    }
+    return num;
+  });
+
+  const newerParts = cleanNew.split(".").map((part) => {
+    const num = Number(part);
+    if (isNaN(num) || !part.trim()) {
+      throw new Error(`Invalid version format: ${newVersion}`);
+    }
+    return num;
+  });
+
+  // Compare up to the maximum length, treating missing parts as 0
+  const maxLength = Math.max(currentParts.length, newerParts.length);
+
+  for (let i = 0; i < maxLength; i++) {
+    const currentPart = currentParts[i] || 0;
+    const newerPart = newerParts[i] || 0;
+
+    if (newerPart > currentPart) return true;
+    if (newerPart < currentPart) return false;
+  }
+
+  // If base versions are equal, check pre-release tags
+  // A version with no pre-release tag is considered newer than one with a tag
+  const currentHasPrerelease = currentVersion.includes("-");
+  const newHasPrerelease = newVersion.includes("-");
+
+  if (!currentHasPrerelease && newHasPrerelease) {
+    return false; // Current stable is newer than new pre-release
+  }
+
+  if (currentHasPrerelease && !newHasPrerelease) {
+    return true; // New stable is newer than current pre-release
+  }
+
+  return false;
+}

package/src/helpers/version-check.ts

@@ -0,0 +1,97 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import { isNewerVersion } from "./semver-utils.js";
+import { fetchLatestVersion } from "./npm-registry.js";
+
+interface VersionCache {
+  lastChecked: number;
+  latestVersion: string;
+}
+
+const CACHE_DURATION = 24 * 60 * 60 * 1000; // 24 hours in milliseconds
+const CACHE_DIR = join(homedir(), ".movehat");
+const CACHE_FILE = join(CACHE_DIR, "version-cache.json");
+
+/**
+ * Read version from cache
+ */
+function readCache(): VersionCache | null {
+  try {
+    if (!existsSync(CACHE_FILE)) {
+      return null;
+    }
+
+    const cacheContent = readFileSync(CACHE_FILE, "utf-8");
+    return JSON.parse(cacheContent) as VersionCache;
+  } catch (error) {
+    return null;
+  }
+}
+
+/**
+ * Write version to cache
+ */
+function writeCache(latestVersion: string): void {
+  try {
+    if (!existsSync(CACHE_DIR)) {
+      mkdirSync(CACHE_DIR, { recursive: true });
+    }
+
+    const cache: VersionCache = {
+      lastChecked: Date.now(),
+      latestVersion,
+    };
+
+    writeFileSync(CACHE_FILE, JSON.stringify(cache, null, 2));
+  } catch (error) {
+    // Silently fail - don't interrupt user's workflow
+  }
+}
+
+/**
+ * Check if a newer version is available and notify the user
+ * This runs synchronously using cache, and updates cache in background
+ */
+export function checkForUpdates(currentVersion: string, packageName: string): void {
+  try {
+    const cache = readCache();
+    let shouldNotify = false;
+
+    // Check cache synchronously for immediate notification
+    if (cache && isNewerVersion(currentVersion, cache.latestVersion)) {
+      shouldNotify = true;
+    }
+
+    // Display notification immediately if cache says there's an update
+    if (shouldNotify && cache) {
+      const updateMessage =
+        "\n" +
+        "┌" + "─".repeat(60) + "┐\n" +
+        `│  Update available: ${currentVersion} → ${cache.latestVersion}`.padEnd(61) + "│\n" +
+        `│  Run: movehat update`.padEnd(61) + "│\n" +
+        "└" + "─".repeat(60) + "┘\n";
+
+      console.error(updateMessage);
+    }
+
+    // Update cache in background if needed (doesn't block)
+    if (!cache || Date.now() - cache.lastChecked > CACHE_DURATION) {
+      setImmediate(async () => {
+        try {
+          const latestVersion = await fetchLatestVersion(packageName, {
+            timeout: 2000,
+            throwOnError: false,
+          });
+          if (latestVersion) {
+            writeCache(latestVersion);
+          }
+        } catch (error) {
+          // Silently fail
+        }
+      });
+    }
+  } catch (error) {
+    // Silently fail - never interrupt user's workflow
+  }
+}

package/src/templates/README.md

@@ -12,7 +12,7 @@ A Move smart contract project built with Movehat.
 
   Verify: `movement --version`
 
-**⚠️ Important:** Without Movement CLI, compilation will fail!
+**IMPORTANT:** Without Movement CLI, compilation will fail!
 
 ## Getting Started
 

package/src/templates/move/Move.toml

@@ -7,8 +7,9 @@ authors = []
 counter = "_"
 
 [dev-addresses]
-# Dev addresses are auto-detected by movehat during compilation
-# You can also add them manually here if needed
+# Dev addresses for testing (used with movement move test --dev)
+# These addresses are temporary and used for local development/testing only
+counter = "0xcafe"
 
 [dependencies.AptosFramework]
 git = "https://github.com/movementlabsxyz/aptos-core.git"