movehat 0.0.8-alpha.0 → 0.0.10-alpha.0

package/src/helpers/move-tests.ts

@@ -0,0 +1,68 @@
+import { spawn } from "child_process";
+import { existsSync } from "fs";
+import { resolve } from "path";
+import { loadUserConfig } from "../core/config.js";
+
+interface RunMoveTestsOptions {
+  filter?: string;
+  ignoreWarnings?: boolean;
+  skipIfMissing?: boolean; // If true, skip gracefully when Move dir missing (for orchestrated tests)
+}
+
+/**
+ * Run Move unit tests using Movement CLI
+ * @param options Test options including filter, warnings, and skip behavior
+ * @returns Promise that resolves when tests complete successfully
+ */
+export async function runMoveTests(options: RunMoveTestsOptions = {}): Promise<void> {
+  const userConfig = await loadUserConfig();
+  const moveDir = resolve(process.cwd(), userConfig.moveDir || "./move");
+
+  if (!existsSync(moveDir)) {
+    if (options.skipIfMissing) {
+      console.log("⊘ No Move directory found (./move not found)");
+      console.log("   Skipping Move tests...\n");
+      return;
+    } else {
+      throw new Error(
+        `Move directory not found: ${moveDir}\n` +
+        `   Update movehat.config.ts -> moveDir`
+      );
+    }
+  }
+
+  const args = ["move", "test", "--package-dir", moveDir];
+
+  // Add dev flag for auto-detected addresses
+  args.push("--dev");
+
+  if (options.filter) {
+    args.push("--filter", options.filter);
+  }
+
+  if (options.ignoreWarnings) {
+    args.push("--ignore-compile-warnings");
+  }
+
+  return new Promise<void>((resolve, reject) => {
+    const child = spawn("movement", args, {
+      stdio: "inherit",
+      cwd: process.cwd(),
+    });
+
+    child.on("exit", (code) => {
+      if (code === 0) {
+        console.log("\n✓ Move tests passed");
+        resolve();
+      } else {
+        reject(new Error("Move tests failed"));
+      }
+    });
+
+    child.on("error", (error) => {
+      console.error(`Failed to run Move tests: ${error.message}`);
+      console.error("   Make sure Movement CLI is installed");
+      reject(error);
+    });
+  });
+}

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
 
@@ -52,11 +52,25 @@ npm run compile
 npm test
 ```
 
-**How it works:**
-- Tests use **Transaction Simulation** - no real blockchain required
-- Runs instantly without gas costs
-- Uses Movement testnet by default with auto-generated test accounts
-- Perfect for TDD and CI/CD workflows
+**Two types of tests available:**
+
+1. **Move Unit Tests** (`tests/Counter.move` lines 50-63)
+   - Written in Move with `#[test]` annotations
+   - Test internal logic and business rules
+   - Ultra-fast execution (milliseconds)
+   - Run with: `npm run test:move`
+
+2. **TypeScript Integration Tests** (`tests/Counter.test.ts`)
+   - Written in TypeScript using Transaction Simulation
+   - Test end-to-end flows and SDK integration
+   - No blockchain or gas costs required
+   - Run with: `npm run test:ts`
+
+**Commands:**
+- `npm test` - Runs both Move + TypeScript tests
+- `npm run test:move` - Only Move unit tests (fast)
+- `npm run test:ts` - Only TypeScript integration tests
+- `npm run test:watch` - TypeScript tests in watch mode
 
 ### 5. Deploy (optional)
 

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"

package/src/templates/package.json

@@ -3,8 +3,10 @@
   "version": "1.0.0",
   "type": "module",
   "scripts": {
-    "test": "mocha",
-    "test:watch": "mocha --watch",
+    "test": "movehat test",
+    "test:move": "movehat test:move",
+    "test:ts": "movehat test:ts",
+    "test:watch": "movehat test:ts --watch",
     "deploy": "movehat run scripts/deploy-counter.ts"
   },
   "dependencies": {