movehat 0.1.9 → 0.2.0

package/src/commands/compile.ts

@@ -1,9 +1,9 @@
 import fs from "fs";
 import path from "path";
-import { exec } from "child_process";
 import { loadUserConfig } from "../core/config.js";
-import { validateAndEscapePath, escapeShellArg } from "../core/shell.js";
+import { validatePathSafety } from "../core/shell.js";
 import { logger } from "../ui/index.js";
+import { runCli } from "../utils/runCli.js";
 
 /**
  * Recursively find all .move files in a directory
@@ -61,6 +61,7 @@ export function extractNamedAddresses(moveDir: string): Set<string> {
 
     while ((match = moduleRegex.exec(content)) !== null) {
       const address = match[1];
+      if (!address) continue;
       // Skip standard addresses
       if (address !== 'std' && address !== 'aptos_framework' && address !== 'aptos_std') {
         addresses.add(address);
@@ -71,22 +72,148 @@ export function extractNamedAddresses(moveDir: string): Set<string> {
   return addresses;
 }
 
-function run(command: string, cwd: string) {
-  return new Promise<void>((resolve, reject) => {
-    exec(command, {
+/**
+ * List of dev addresses to use for auto-assignment (to avoid conflicts)
+ */
+const DEV_ADDRESSES = [
+  "0xcafe",
+  "0xbeef",
+  "0xdead",
+  "0xface",
+  "0xfeed",
+  "0xc0de",
+  "0xbabe",
+  "0xf00d",
+];
+
+/**
+ * Update Move.toml with detected addresses
+ * Adds missing addresses to [addresses] and [dev-addresses] sections
+ */
+export function updateMoveToml(moveDir: string, detectedAddresses: Set<string>): string[] {
+  const moveTomlPath = path.join(moveDir, "Move.toml");
+  
+  if (!fs.existsSync(moveTomlPath)) {
+    return [];
+  }
+
+  let content = fs.readFileSync(moveTomlPath, "utf-8");
+  const addedAddresses: string[] = [];
+
+  // Parse existing addresses from [addresses] section
+  const existingAddresses = new Set<string>();
+  const addressesMatch = content.match(/\[addresses\]([\s\S]*?)(?=\[|$)/);
+  if (addressesMatch && addressesMatch[1]) {
+    const addressesSection = addressesMatch[1];
+    const addrRegex = /^([a-zA-Z_][a-zA-Z0-9_]*)\s*=/gm;
+    let match;
+    while ((match = addrRegex.exec(addressesSection)) !== null) {
+      if (match[1]) existingAddresses.add(match[1]);
+    }
+  }
+
+  // Parse existing dev-addresses
+  const existingDevAddresses = new Map<string, string>();
+  const devAddressesMatch = content.match(/\[dev-addresses\]([\s\S]*?)(?=\[|$)/);
+  if (devAddressesMatch && devAddressesMatch[1]) {
+    const devSection = devAddressesMatch[1];
+    const devRegex = /^([a-zA-Z_][a-zA-Z0-9_]*)\s*=\s*"(0x[a-fA-F0-9]+)"/gm;
+    let match;
+    while ((match = devRegex.exec(devSection)) !== null) {
+      const name = match[1];
+      const addr = match[2];
+      if (name && addr) existingDevAddresses.set(name, addr.toLowerCase());
+    }
+  }
+
+  // Get used dev addresses to avoid conflicts
+  const usedDevAddresses = new Set(existingDevAddresses.values());
+
+  // Find addresses that need to be added
+  const missingAddresses: string[] = [];
+  for (const addr of detectedAddresses) {
+    if (!existingAddresses.has(addr)) {
+      missingAddresses.push(addr);
+    }
+  }
+
+  if (missingAddresses.length === 0) {
+    return [];
+  }
+
+  // Assign unique dev addresses to new addresses
+  const newDevAddresses: Map<string, string> = new Map();
+  let devAddrIndex = 0;
+  
+  for (const addr of missingAddresses) {
+    // Find next available dev address
+    while (devAddrIndex < DEV_ADDRESSES.length) {
+      const candidate = DEV_ADDRESSES[devAddrIndex];
+      if (candidate && !usedDevAddresses.has(candidate)) break;
+      devAddrIndex++;
+    }
+
+    const devCandidate = DEV_ADDRESSES[devAddrIndex];
+    if (devCandidate) {
+      newDevAddresses.set(addr, devCandidate);
+      usedDevAddresses.add(devCandidate);
+      devAddrIndex++;
+    } else {
+      // Generate a unique address if we run out of predefined ones
+      const uniqueAddr = `0x${(0x1000 + devAddrIndex).toString(16)}`;
+      newDevAddresses.set(addr, uniqueAddr);
+      devAddrIndex++;
+    }
+  }
+
+  // Update [addresses] section
+  if (addressesMatch && addressesMatch[1] !== undefined) {
+    const addressesSection = addressesMatch[1];
+    const newLines = missingAddresses.map(addr => `${addr} = "_"`).join("\n");
+    const updatedSection = addressesSection.trimEnd() + "\n" + newLines + "\n";
+    content = content.replace(addressesMatch[0], `[addresses]${updatedSection}`);
+  }
+
+  // Update [dev-addresses] section
+  const updatedDevMatch = content.match(/\[dev-addresses\]([\s\S]*?)(?=\[|$)/);
+  if (updatedDevMatch && updatedDevMatch[1] !== undefined) {
+    const devSection = updatedDevMatch[1];
+    const newDevLines = missingAddresses.map(addr => `${addr} = "${newDevAddresses.get(addr)}"`).join("\n");
+    // Remove trailing comments/whitespace before adding new lines
+    const cleanedSection = devSection.replace(/\n*$/, "\n");
+    const updatedDevSection = cleanedSection + newDevLines + "\n";
+    content = content.replace(updatedDevMatch[0], `[dev-addresses]${updatedDevSection}`);
+  }
+
+  // Write updated content
+  fs.writeFileSync(moveTomlPath, content);
+  
+  return missingAddresses;
+}
+
+async function runMovementBuild(
+  args: readonly string[],
+  cwd: string
+): Promise<void> {
+  // Use throwOnNonZeroExit:false so we can log stdout/stderr in both
+  // success and failure paths, matching the behavior of the previous
+  // exec-based helper.
+  const result = await runCli(
+    {
+      command: "movement",
+      args,
       cwd,
-      timeout: 120000, // 2 minutes for git dependency downloads
-      maxBuffer: 10 * 1024 * 1024, // 10MB buffer for large outputs
-    }, (error, stdout, stderr) => {
-      if (stdout) console.log(stdout.trim());
-      if (stderr) console.error(stderr.trim());
-      if (error) {
-        reject(error);
-        return;
-      }
-      resolve();
-    });
-  });
+      timeoutMs: 120000, // 2 minutes for git dependency downloads
+    },
+    { throwOnNonZeroExit: false }
+  );
+
+  if (result.stdout) console.log(result.stdout.trim());
+  if (result.stderr) console.error(result.stderr.trim());
+
+  if (result.exitCode !== 0) {
+    throw new Error(`movement move build exited with code ${result.exitCode}`);
+  }
 }
 
 /**
@@ -94,8 +221,9 @@ function run(command: string, cwd: string) {
  *
  * This command:
  * - Detects named addresses used in Move modules
+ * - Auto-updates Move.toml with missing addresses
  * - Merges auto-detected addresses with user-configured addresses
- * - Auto-assigns development addresses (0xcafe) for missing addresses
+ * - Auto-assigns development addresses for missing addresses
  * - Executes `movement move build` with proper named address mappings
  *
  * @example
@@ -118,12 +246,19 @@ export default async function compileCommand() {
       process.exit(1);
     }
 
-    // Validate and escape to prevent command injection
-    const safeMoveDir = validateAndEscapePath(moveDir, "Move directory");
+    // Validate the move directory before passing it to the child process.
+    // No shell escaping needed — runCli uses spawn-with-args, not exec.
+    const safeMoveDir = validatePathSafety(moveDir, "Move directory");
 
     // Auto-detect named addresses from Move files
     const detectedAddresses = extractNamedAddresses(moveDir);
 
+    // Auto-update Move.toml with missing addresses
+    const addedToToml = updateMoveToml(moveDir, detectedAddresses);
+    if (addedToToml.length > 0) {
+      logger.success(`Added ${addedToToml.length} address(es) to Move.toml: ${addedToToml.join(", ")}`);
+    }
+
     // Merge user-configured addresses with auto-detected ones
     const namedAddresses = { ...(userConfig.namedAddresses ?? {}) };
     const autoAssignedAddresses: string[] = [];
@@ -136,11 +271,10 @@ export default async function compileCommand() {
       }
     }
 
-    let namedAddressesArg = "";
+    let namedAddressesValue = "";
 
     if (Object.keys(namedAddresses).length > 0) {
-      // Validate and escape each address name and value
-      const escapedAddresses = Object.entries(namedAddresses)
+      namedAddressesValue = Object.entries(namedAddresses)
         .map(([k, v]) => {
           // Validate address name (alphanumeric, underscore only)
           if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(k)) {
@@ -158,36 +292,38 @@ export default async function compileCommand() {
             );
           }
 
-          // No need to escape since we validated the format
           return `${k}=${v}`;
         })
         .join(",");
-
-      namedAddressesArg = `--named-addresses ${escapeShellArg(escapedAddresses)}`;
     }
 
-    const command = `movement move build --package-dir ${safeMoveDir} ${namedAddressesArg}`.trim();
+    const args: string[] = ["move", "build", "--package-dir", safeMoveDir];
+    if (namedAddressesValue) {
+      args.push("--named-addresses", namedAddressesValue);
+    }
 
     logger.kv('Move directory', moveDir, 2);
     if (detectedAddresses.size > 0) {
       logger.kv('Detected addresses', Array.from(detectedAddresses).join(", "), 2);
     }
-    if (Object.keys(userConfig.namedAddresses ?? {}).length > 0) {
-      logger.kv('Configured addresses', Object.keys(userConfig.namedAddresses!).join(", "), 2);
+    const namedAddrs = userConfig.namedAddresses ?? {};
+    if (Object.keys(namedAddrs).length > 0) {
+      logger.kv('Configured addresses', Object.keys(namedAddrs).join(", "), 2);
     }
     if (autoAssignedAddresses.length > 0) {
       logger.kv('Auto-assigned (0xcafe)', autoAssignedAddresses.join(", "), 2);
     }
     logger.newline();
 
-    await run(command, moveDir);
+    await runMovementBuild(args, moveDir);
 
     logger.newline();
     logger.success('Compilation finished successfully');
     logger.newline();
-  } catch (err: any) {
+  } catch (err) {
     logger.newline();
-    logger.error(`Compilation failed: ${err.message ?? err}`);
+    const msg = err instanceof Error ? err.message : String(err);
+    logger.error(`Compilation failed: ${msg}`);
     logger.newline();
     process.exit(1);
   }

package/src/commands/fork/__tests__/create.test.ts

@@ -0,0 +1,132 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { existsSync, mkdtempSync, mkdirSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+const promptsMock = vi.fn();
+const forkManagerInitialize = vi.fn();
+const forkManagerGetMetadata = vi.fn();
+const ForkManagerCtor = vi.fn();
+const loadUserConfigMock = vi.fn();
+const resolveNetworkConfigMock = vi.fn();
+
+vi.mock("prompts", () => ({ default: promptsMock }));
+
+vi.mock("../../../fork/manager.js", () => ({
+  ForkManager: class {
+    constructor(forkPath: string) {
+      ForkManagerCtor(forkPath);
+    }
+    initialize = forkManagerInitialize;
+    getMetadata = forkManagerGetMetadata;
+  },
+}));
+
+vi.mock("../../../core/config.js", () => ({
+  loadUserConfig: loadUserConfigMock,
+  resolveNetworkConfig: resolveNetworkConfigMock,
+}));
+
+const { default: forkCreateCommand } = await import("../create.js");
+
+describe("forkCreateCommand", () => {
+  let tmpCwd: string;
+  let origCwd: string;
+  let exitSpy: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(() => {
+    promptsMock.mockReset();
+    forkManagerInitialize.mockReset().mockResolvedValue(undefined);
+    forkManagerGetMetadata.mockReset().mockReturnValue({
+      network: "testnet",
+      nodeUrl: "https://testnet.movementnetwork.xyz/v1",
+      chainId: 27,
+      ledgerVersion: "100",
+      timestamp: "12345",
+      epoch: "5",
+      blockHeight: "42",
+      createdAt: new Date(0).toISOString(),
+    });
+    ForkManagerCtor.mockReset();
+    loadUserConfigMock.mockReset().mockResolvedValue({
+      defaultNetwork: "testnet",
+      networks: { testnet: { url: "https://testnet.movementnetwork.xyz/v1", chainId: "testnet" } },
+    });
+    resolveNetworkConfigMock.mockReset().mockResolvedValue({
+      network: "testnet",
+      rpc: "https://testnet.movementnetwork.xyz/v1",
+      privateKey: "0x" + "1".repeat(64),
+      allAccounts: [],
+      profile: "default",
+      moveDir: "./move",
+      account: "",
+      namedAddresses: {},
+      networkConfig: { url: "https://testnet.movementnetwork.xyz/v1", chainId: "testnet" },
+    });
+
+    origCwd = process.cwd();
+    tmpCwd = mkdtempSync(join(tmpdir(), "movehat-forkcreate-"));
+    process.chdir(tmpCwd);
+    exitSpy = vi
+      .spyOn(process, "exit")
+      .mockImplementation(((code?: number) => {
+        throw new Error(`__test_exit_${code ?? 0}__`);
+      }) as never);
+    vi.spyOn(console, "log").mockImplementation(() => undefined);
+    vi.spyOn(console, "error").mockImplementation(() => undefined);
+  });
+
+  afterEach(() => {
+    process.chdir(origCwd);
+    if (existsSync(tmpCwd)) rmSync(tmpCwd, { recursive: true, force: true });
+    vi.restoreAllMocks();
+  });
+
+  it("happy path: initializes a fresh fork at the default path", async () => {
+    await forkCreateCommand({ network: "testnet" });
+
+    expect(forkManagerInitialize).toHaveBeenCalledTimes(1);
+    expect(forkManagerInitialize).toHaveBeenCalledWith(
+      "https://testnet.movementnetwork.xyz/v1",
+      "testnet"
+    );
+    expect(promptsMock).not.toHaveBeenCalled();
+  });
+
+  it("uses a custom fork name and path when provided", async () => {
+    const customPath = join(tmpCwd, "my-custom-fork");
+    await forkCreateCommand({ network: "testnet", path: customPath, name: "ignored-when-path-set" });
+
+    expect(ForkManagerCtor).toHaveBeenCalledWith(customPath);
+  });
+
+  it("prompts for overwrite when the fork directory already exists", async () => {
+    const forkPath = join(tmpCwd, ".movehat", "forks", "testnet-fork");
+    mkdirSync(forkPath, { recursive: true });
+    promptsMock.mockResolvedValueOnce({ overwrite: true });
+
+    await forkCreateCommand({ network: "testnet" });
+
+    expect(promptsMock).toHaveBeenCalledTimes(1);
+    expect(forkManagerInitialize).toHaveBeenCalledTimes(1);
+  });
+
+  it("aborts gracefully when the user declines the overwrite prompt", async () => {
+    const forkPath = join(tmpCwd, ".movehat", "forks", "testnet-fork");
+    mkdirSync(forkPath, { recursive: true });
+    promptsMock.mockResolvedValueOnce({ overwrite: false });
+
+    await forkCreateCommand({ network: "testnet" });
+
+    expect(forkManagerInitialize).not.toHaveBeenCalled();
+    expect(exitSpy).not.toHaveBeenCalled();
+  });
+
+  it("exits 1 when the manager's initialize throws", async () => {
+    forkManagerInitialize.mockRejectedValueOnce(new Error("upstream is unreachable"));
+
+    await expect(forkCreateCommand({ network: "testnet" })).rejects.toThrow(
+      "__test_exit_1__"
+    );
+  });
+});

package/src/commands/fork/__tests__/fund.test.ts

@@ -0,0 +1,104 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+const forkManagerLoad = vi.fn();
+const forkManagerFundAccount = vi.fn();
+const forkManagerGetResource = vi.fn();
+const ForkManagerCtor = vi.fn();
+
+vi.mock("../../../fork/manager.js", () => ({
+  ForkManager: class {
+    constructor(forkPath: string) {
+      ForkManagerCtor(forkPath);
+    }
+    load = forkManagerLoad;
+    fundAccount = forkManagerFundAccount;
+    getResource = forkManagerGetResource;
+  },
+}));
+
+const { default: forkFundCommand } = await import("../fund.js");
+
+describe("forkFundCommand", () => {
+  let exitSpy: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(() => {
+    forkManagerLoad.mockReset();
+    forkManagerFundAccount.mockReset().mockResolvedValue(undefined);
+    forkManagerGetResource.mockReset().mockResolvedValue({
+      coin: { value: "1000" },
+    });
+    ForkManagerCtor.mockReset();
+    exitSpy = vi
+      .spyOn(process, "exit")
+      .mockImplementation(((code?: number) => {
+        throw new Error(`__test_exit_${code ?? 0}__`);
+      }) as never);
+    vi.spyOn(console, "log").mockImplementation(() => undefined);
+    vi.spyOn(console, "error").mockImplementation(() => undefined);
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("exits 1 when --account is missing", async () => {
+    await expect(
+      forkFundCommand({ account: "", amount: "100" } as never)
+    ).rejects.toThrow("__test_exit_1__");
+    expect(forkManagerFundAccount).not.toHaveBeenCalled();
+  });
+
+  it("exits 1 when --amount is missing", async () => {
+    await expect(
+      forkFundCommand({ account: "0xabc", amount: "" } as never)
+    ).rejects.toThrow("__test_exit_1__");
+    expect(forkManagerFundAccount).not.toHaveBeenCalled();
+  });
+
+  it("exits 1 when --amount is not a positive integer", async () => {
+    await expect(
+      forkFundCommand({ account: "0xabc", amount: "abc" } as never)
+    ).rejects.toThrow("__test_exit_1__");
+    await expect(
+      forkFundCommand({ account: "0xabc", amount: "-5" } as never)
+    ).rejects.toThrow("__test_exit_1__");
+  });
+
+  it("happy path: loads fork, funds the account, prints new balance", async () => {
+    await forkFundCommand({
+      account: "0xabc",
+      amount: "1000",
+      fork: "/tmp/fork",
+    } as never);
+
+    expect(forkManagerLoad).toHaveBeenCalledTimes(1);
+    expect(forkManagerFundAccount).toHaveBeenCalledWith(
+      "0xabc",
+      1000,
+      "0x1::aptos_coin::AptosCoin"
+    );
+    expect(forkManagerGetResource).toHaveBeenCalled();
+  });
+
+  it("respects --coinType when provided", async () => {
+    await forkFundCommand({
+      account: "0xabc",
+      amount: "1000",
+      coinType: "0x99::custom::Coin",
+    } as never);
+
+    expect(forkManagerFundAccount).toHaveBeenCalledWith(
+      "0xabc",
+      1000,
+      "0x99::custom::Coin"
+    );
+  });
+
+  it("exits 1 when fundAccount throws", async () => {
+    forkManagerFundAccount.mockRejectedValueOnce(new Error("fund failed"));
+
+    await expect(
+      forkFundCommand({ account: "0xabc", amount: "1000" } as never)
+    ).rejects.toThrow("__test_exit_1__");
+  });
+});

package/src/commands/fork/__tests__/list.test.ts

@@ -0,0 +1,139 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { existsSync, mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+const storageExists = vi.fn();
+const storageLoadMetadata = vi.fn();
+const storageListAccounts = vi.fn();
+
+vi.mock("../../../fork/storage.js", () => ({
+  ForkStorage: class {
+    exists = storageExists;
+    loadMetadata = storageLoadMetadata;
+    listAccounts = storageListAccounts;
+  },
+}));
+
+const { default: forkListCommand } = await import("../list.js");
+
+describe("forkListCommand", () => {
+  let tmpCwd: string;
+  let origCwd: string;
+  let exitSpy: ReturnType<typeof vi.spyOn>;
+  let logSpy: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(() => {
+    storageExists.mockReset();
+    storageLoadMetadata.mockReset();
+    storageListAccounts.mockReset();
+    origCwd = process.cwd();
+    tmpCwd = mkdtempSync(join(tmpdir(), "movehat-forklist-"));
+    process.chdir(tmpCwd);
+    exitSpy = vi
+      .spyOn(process, "exit")
+      .mockImplementation(((code?: number) => {
+        throw new Error(`__test_exit_${code ?? 0}__`);
+      }) as never);
+    logSpy = vi.spyOn(console, "log").mockImplementation(() => undefined);
+    vi.spyOn(console, "error").mockImplementation(() => undefined);
+  });
+
+  afterEach(() => {
+    process.chdir(origCwd);
+    if (existsSync(tmpCwd)) rmSync(tmpCwd, { recursive: true, force: true });
+    vi.restoreAllMocks();
+  });
+
+  it("prints 'no forks found' when the forks dir doesn't exist", async () => {
+    await forkListCommand();
+
+    const printed = logSpy.mock.calls.flat().join(" ");
+    expect(printed).toMatch(/No forks found/i);
+    expect(storageExists).not.toHaveBeenCalled();
+  });
+
+  it("prints 'no forks found' when the forks dir is empty", async () => {
+    mkdirSync(join(tmpCwd, ".movehat", "forks"), { recursive: true });
+    await forkListCommand();
+
+    const printed = logSpy.mock.calls.flat().join(" ");
+    expect(printed).toMatch(/No forks found/i);
+  });
+
+  it("lists a single valid fork in a table", async () => {
+    mkdirSync(join(tmpCwd, ".movehat", "forks", "testnet-fork"), { recursive: true });
+    storageExists.mockReturnValue(true);
+    storageLoadMetadata.mockReturnValue({
+      network: "testnet",
+      nodeUrl: "https://testnet.movementnetwork.xyz/v1",
+      chainId: 27,
+      ledgerVersion: "100",
+      timestamp: "12345",
+      epoch: "5",
+      blockHeight: "42",
+      createdAt: new Date(1700000000000).toISOString(),
+    });
+    storageListAccounts.mockReturnValue(["0xabc", "0xdef"]);
+
+    await forkListCommand();
+
+    const printed = logSpy.mock.calls.flat().join(" ");
+    expect(printed).toMatch(/testnet-fork/);
+    expect(printed).toMatch(/testnet/);
+  });
+
+  it("flags forks with invalid/missing metadata gracefully", async () => {
+    mkdirSync(join(tmpCwd, ".movehat", "forks", "broken-fork"), { recursive: true });
+    storageExists.mockReturnValue(false);
+
+    await forkListCommand();
+
+    const printed = logSpy.mock.calls.flat().join(" ");
+    expect(printed).toMatch(/broken-fork/);
+    expect(printed).toMatch(/invalid/);
+  });
+
+  it("handles metadata-load errors per-fork without aborting the list", async () => {
+    mkdirSync(join(tmpCwd, ".movehat", "forks", "fork-a"), { recursive: true });
+    mkdirSync(join(tmpCwd, ".movehat", "forks", "fork-b"), { recursive: true });
+
+    // First fork: exists() throws on metadata load; second: ok.
+    let call = 0;
+    storageExists.mockImplementation(() => {
+      call++;
+      if (call === 1) throw new Error("metadata corrupt");
+      return true;
+    });
+    storageLoadMetadata.mockReturnValue({
+      network: "testnet",
+      nodeUrl: "url",
+      chainId: 27,
+      ledgerVersion: "100",
+      timestamp: "0",
+      epoch: "0",
+      blockHeight: "0",
+      createdAt: new Date(0).toISOString(),
+    });
+    storageListAccounts.mockReturnValue([]);
+
+    await forkListCommand();
+
+    const printed = logSpy.mock.calls.flat().join(" ");
+    expect(printed).toMatch(/fork-a/);
+    expect(printed).toMatch(/error/);
+    expect(printed).toMatch(/fork-b/);
+  });
+
+  it("skips non-directory entries in the forks dir", async () => {
+    mkdirSync(join(tmpCwd, ".movehat", "forks"), { recursive: true });
+    // Plant a stray file at the forks-dir level.
+    writeFileSync(join(tmpCwd, ".movehat", "forks", "not-a-fork.txt"), "x");
+
+    // No actual fork subdirs — should still hit the "0 forks" branch.
+    await forkListCommand();
+
+    const printed = logSpy.mock.calls.flat().join(" ");
+    expect(printed).toMatch(/No forks found/i);
+  });
+});