movehat 0.2.1 → 0.2.3

package/src/commands/__tests__/init.test.ts

@@ -13,7 +13,8 @@ vi.mock("../../helpers/banner.js", () => ({
   printMovehatBanner: () => undefined,
 }));
 
-const { default: initCommand } = await import("../init.js");
+const initModule = await import("../init.js");
+const { default: initCommand, resolveProjectNames, InvalidProjectNameError } = initModule;
 
 /**
  * Strategy: real tmpdir + real fs ops (matches §6.1's example-as-canonical
@@ -28,10 +29,38 @@ const { default: initCommand } = await import("../init.js");
  * to `src/templates/` cleanly. No bundling step required.
  */
 
+describe("resolveProjectNames", () => {
+  const cases: Array<[
+    string,
+    { dirName: string; npmName: string; moveName: string; sanitized: boolean }
+  ]> = [
+    ["my_project", { dirName: "my_project", npmName: "my_project", moveName: "my_project", sanitized: false }],
+    ["my-project", { dirName: "my-project", npmName: "my-project", moveName: "my_project", sanitized: true }],
+    ["/tmp/my-project", { dirName: "/tmp/my-project", npmName: "my-project", moveName: "my_project", sanitized: true }],
+    ["123abc", { dirName: "123abc", npmName: "123abc", moveName: "pkg_123abc", sanitized: true }],
+    ["_underscore", { dirName: "_underscore", npmName: "_underscore", moveName: "_underscore", sanitized: false }],
+    ["UPPER", { dirName: "UPPER", npmName: "UPPER", moveName: "UPPER", sanitized: false }],
+    ["  spaced  ", { dirName: "spaced", npmName: "spaced", moveName: "spaced", sanitized: false }],
+    ["with spaces", { dirName: "with spaces", npmName: "with spaces", moveName: "with_spaces", sanitized: true }],
+  ];
+
+  it.each(cases)("derives names for %j", (input, expected) => {
+    expect(resolveProjectNames(input)).toEqual(expected);
+  });
+
+  it.each(["", "   ", ".", "..", "/", "////"])(
+    "rejects %j as an invalid project name",
+    (input) => {
+      expect(() => resolveProjectNames(input)).toThrow(InvalidProjectNameError);
+    }
+  );
+});
+
 describe("initCommand", () => {
   let tmpParent: string;
   let origCwd: string;
   let exitSpy: ReturnType<typeof vi.spyOn>;
+  let warnSpy: ReturnType<typeof vi.spyOn>;
 
   beforeEach(() => {
     promptsMock.mockReset();
@@ -48,6 +77,7 @@ describe("initCommand", () => {
       }) as never);
     vi.spyOn(console, "log").mockImplementation(() => undefined);
     vi.spyOn(console, "error").mockImplementation(() => undefined);
+    warnSpy = vi.spyOn(console, "warn").mockImplementation(() => undefined);
   });
 
   afterEach(() => {
@@ -59,9 +89,9 @@ describe("initCommand", () => {
   });
 
   it("happy path: scaffolds a project from the canonical template", async () => {
-    await initCommand("my-test-project");
+    await initCommand("my_test_project");
 
-    const target = join(tmpParent, "my-test-project");
+    const target = join(tmpParent, "my_test_project");
     expect(existsSync(target)).toBe(true);
     // Canonical files at the project root.
     expect(existsSync(join(target, "package.json"))).toBe(true);
@@ -78,32 +108,37 @@ describe("initCommand", () => {
     // Excluded template-development directory.
     expect(existsSync(join(target, "types"))).toBe(false);
     expect(existsSync(join(target, ".vscode"))).toBe(false);
+    // Move.toml gets a valid Move identifier.
+    const moveToml = readFileSync(join(target, "move", "Move.toml"), "utf-8");
+    expect(moveToml).toContain('name = "my_test_project"');
+    expect(moveToml).not.toContain("{{movePackageName}}");
+    expect(moveToml).not.toContain("{{projectName}}");
   });
 
   it("substitutes {{projectName}} placeholders inside template files", async () => {
-    await initCommand("substituted-project");
+    await initCommand("substituted_project");
 
     const pkg = readFileSync(
-      join(tmpParent, "substituted-project", "package.json"),
+      join(tmpParent, "substituted_project", "package.json"),
       "utf-8"
     );
-    expect(pkg).toContain("substituted-project");
+    expect(pkg).toContain("substituted_project");
     expect(pkg).not.toContain("{{projectName}}");
 
     const readme = readFileSync(
-      join(tmpParent, "substituted-project", "README.md"),
+      join(tmpParent, "substituted_project", "README.md"),
       "utf-8"
     );
-    expect(readme).toContain("substituted-project");
+    expect(readme).toContain("substituted_project");
   });
 
   it("prompts for project name when none is provided", async () => {
-    promptsMock.mockResolvedValueOnce({ projectName: "from-prompt" });
+    promptsMock.mockResolvedValueOnce({ projectName: "from_prompt" });
 
     await initCommand();
 
     expect(promptsMock).toHaveBeenCalledTimes(1);
-    expect(existsSync(join(tmpParent, "from-prompt"))).toBe(true);
+    expect(existsSync(join(tmpParent, "from_prompt"))).toBe(true);
   });
 
   it("exits 0 when the user Ctrl+Cs the prompt (no project created)", async () => {
@@ -116,10 +151,60 @@ describe("initCommand", () => {
   it("exits 1 when the template copy step hits an unwriteable target", async () => {
     // Plant a directory where the command will try to write package.json
     // as a file — fs.writeFile rejects with EISDIR.
-    const targetName = "blocked-project";
+    const targetName = "blocked_project";
     mkdirSync(join(tmpParent, targetName, "package.json"), { recursive: true });
 
     await expect(initCommand(targetName)).rejects.toThrow("__test_exit_1__");
     expect(exitSpy).toHaveBeenCalledWith(1);
   });
+
+  it("sanitizes Move.toml for hyphenated names but keeps package.json original", async () => {
+    await initCommand("my-project");
+
+    const target = join(tmpParent, "my-project");
+    expect(existsSync(target)).toBe(true);
+    // package.json keeps the original (npm allows hyphens).
+    const pkg = readFileSync(join(target, "package.json"), "utf-8");
+    expect(pkg).toContain('"my-project"');
+    // Move.toml gets the sanitized identifier.
+    const moveToml = readFileSync(join(target, "move", "Move.toml"), "utf-8");
+    expect(moveToml).toContain('name = "my_project"');
+    expect(moveToml).not.toContain('"my-project"');
+    // Warning was emitted.
+    expect(warnSpy).toHaveBeenCalled();
+    const warningText = warnSpy.mock.calls.flat().join(" ");
+    expect(warningText).toContain("my-project");
+    expect(warningText).toContain("my_project");
+  });
+
+  it("with a path argument, creates the dir at the full path and sanitizes Move.toml", async () => {
+    const nestedPath = join(tmpParent, "nested", "sub-project");
+
+    await initCommand(nestedPath);
+
+    expect(existsSync(nestedPath)).toBe(true);
+    const moveToml = readFileSync(join(nestedPath, "move", "Move.toml"), "utf-8");
+    expect(moveToml).toContain('name = "sub_project"');
+    const pkg = readFileSync(join(nestedPath, "package.json"), "utf-8");
+    expect(pkg).toContain('"sub-project"');
+  });
+
+  it("prefixes Move.toml package name with pkg_ for names that start with a digit", async () => {
+    await initCommand("123abc");
+
+    const moveToml = readFileSync(
+      join(tmpParent, "123abc", "move", "Move.toml"),
+      "utf-8"
+    );
+    expect(moveToml).toContain('name = "pkg_123abc"');
+    expect(warnSpy).toHaveBeenCalled();
+  });
+
+  it.each([".", "..", "/", "   "])(
+    "rejects %j as an invalid project name and exits 1",
+    async (input) => {
+      await expect(initCommand(input)).rejects.toThrow("__test_exit_1__");
+      expect(exitSpy).toHaveBeenCalledWith(1);
+    }
+  );
 });

package/src/commands/compile.ts

@@ -2,7 +2,8 @@ import fs from "fs";
 import path from "path";
 import { loadUserConfig } from "../core/config.js";
 import { validatePathSafety } from "../core/shell.js";
-import { logger } from "../ui/index.js";
+import { logger, isVerbose } from "../ui/index.js";
+import { withSpinner } from "../ui/spinner.js";
 import { runCli } from "../utils/runCli.js";
 
 /**
@@ -195,25 +196,33 @@ 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,
-      timeoutMs: 120000, // 2 minutes for git dependency downloads
-    },
-    { throwOnNonZeroExit: false }
+  // Use throwOnNonZeroExit:false so we can route stdout/stderr through
+  // the §9 verbosity gate ourselves. On failure we surface everything;
+  // on success the chatter is hidden unless isVerbose().
+  const result = await withSpinner("Compiling Move package", () =>
+    runCli(
+      {
+        command: "movement",
+        args,
+        cwd,
+        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) {
+    // Build failed — show the user everything we have so they can debug.
+    if (result.stdout) logger.plain(result.stdout.trim());
+    if (result.stderr) logger.plain(result.stderr.trim());
     throw new Error(`movement move build exited with code ${result.exitCode}`);
   }
+
+  // Success path: route output through the verbosity gate.
+  if (isVerbose()) {
+    if (result.stdout) logger.info(result.stdout.trim(), 2);
+    if (result.stderr) logger.info(result.stderr.trim(), 2);
+  }
 }
 
 /**

package/src/commands/init.ts

@@ -8,6 +8,60 @@ import { logger, createSpinnerChain, formatCommand } from "../ui/index.js";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
+export class InvalidProjectNameError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "InvalidProjectNameError";
+  }
+}
+
+export interface ProjectNames {
+  /** User input as-is (after trim) — used for the filesystem target. */
+  dirName: string;
+  /** Basename of the resolved path — used for package.json + README.md. */
+  npmName: string;
+  /** Valid Move identifier — used for Move.toml. */
+  moveName: string;
+  /** True when moveName had to diverge from npmName to satisfy Move identifier rules. */
+  sanitized: boolean;
+}
+
+/**
+ * Derive filesystem, npm, and Move identifier names from a single user input.
+ *
+ * Move identifiers must match `[a-zA-Z_][a-zA-Z0-9_]*`. npm package names are
+ * looser (hyphens allowed). The filesystem accepts almost anything. Rather
+ * than reject inputs that would compile fine for npm but not for Move, we
+ * sanitize the Move identifier and leave the npm name + dir unchanged.
+ */
+export function resolveProjectNames(input: string): ProjectNames {
+  const trimmed = input.trim();
+  if (
+    trimmed === "" ||
+    trimmed === "." ||
+    trimmed === ".." ||
+    /^\/+$/.test(trimmed)
+  ) {
+    throw new InvalidProjectNameError(
+      `Project name '${input}' must include at least one character besides path separators.`
+    );
+  }
+
+  const dirName = trimmed;
+  const npmName = path.basename(path.resolve(trimmed));
+  let moveName = npmName.replace(/[^a-zA-Z0-9_]/g, "_");
+  if (!/^[a-zA-Z_]/.test(moveName)) {
+    moveName = `pkg_${moveName}`;
+  }
+
+  return {
+    dirName,
+    npmName,
+    moveName,
+    sanitized: moveName !== npmName,
+  };
+}
+
 /**
  * Initialize a new Movehat project with template files
  *
@@ -49,8 +103,25 @@ export default async function initCommand(projectName?: string) {
     projectName = response.projectName;
   }
 
-  const targetDir = projectName!;
-  const projectPath = path.resolve(process.cwd(), targetDir);
+  let names: ProjectNames;
+  try {
+    names = resolveProjectNames(projectName!);
+  } catch (error) {
+    if (error instanceof InvalidProjectNameError) {
+      logger.error(error.message);
+      process.exit(1);
+    }
+    throw error;
+  }
+
+  const { dirName, npmName, moveName, sanitized } = names;
+  const projectPath = path.resolve(process.cwd(), dirName);
+
+  if (sanitized) {
+    logger.warning(
+      `'${npmName}' is not a valid Move identifier; using '${moveName}' for move/Move.toml. (package.json keeps '${npmName}'.)`
+    );
+  }
 
   logger.newline();
   logger.info(`Initializing new Movehat project in ${projectPath}...`);
@@ -67,7 +138,7 @@ export default async function initCommand(projectName?: string) {
       await copyFile(
         path.join(templatesDir, "package.json"),
         path.join(projectPath, "package.json"),
-        { projectName: projectName! }
+        { projectName: npmName }
       );
 
       await copyFile(
@@ -98,7 +169,7 @@ export default async function initCommand(projectName?: string) {
       await copyFile(
         path.join(templatesDir, "README.md"),
         path.join(projectPath, "README.md"),
-        { projectName: projectName! }
+        { projectName: npmName }
       );
     });
 
@@ -107,7 +178,7 @@ export default async function initCommand(projectName?: string) {
       await copyDir(
         path.join(templatesDir, "move"),
         path.join(projectPath, "move"),
-        { projectName: projectName! }
+        { projectName: npmName, movePackageName: moveName }
       );
     });
 
@@ -136,7 +207,7 @@ export default async function initCommand(projectName?: string) {
 
     // Next steps
     logger.section('Next steps');
-    logger.item(formatCommand(`cd ${projectName}`), 2);
+    logger.item(formatCommand(`cd ${dirName}`), 2);
     logger.item(formatCommand('cp .env.example .env'), 2);
     logger.plain('     # Edit .env with your credentials');
     logger.item(formatCommand('npm install'), 2);

package/src/commands/test.ts

@@ -97,8 +97,7 @@ async function showTestMenu(): Promise<TestType | undefined> {
  */
 async function runMoveTestsOnly(filter?: string): Promise<void> {
   logger.newline();
-  console.log(colors.bold("Move Unit Tests"));
-  console.log(colors.muted("─".repeat(50)));
+  logger.phase("Move Unit Tests");
   logger.newline();
 
   try {
@@ -118,8 +117,7 @@ async function runMoveTestsOnly(filter?: string): Promise<void> {
  */
 async function runTypeScriptTestsOnly(watch: boolean = false): Promise<void> {
   logger.newline();
-  console.log(colors.bold("TypeScript Integration Tests"));
-  console.log(colors.muted("─".repeat(50)));
+  logger.phase("TypeScript Integration Tests");
 
   if (!watch) {
     logger.newline();
@@ -146,13 +144,11 @@ async function runTypeScriptTestsOnly(watch: boolean = false): Promise<void> {
  */
 async function runAllTests(filter?: string): Promise<void> {
   logger.newline();
-  console.log(colors.bold("Running All Tests"));
-  console.log(colors.muted("═".repeat(50)));
+  logger.phase("Running All Tests");
 
   // Section 1: Move Tests
   logger.newline();
-  console.log(`${colors.brandBright("1.")} ${colors.bold("Move Unit Tests")}`);
-  console.log(colors.muted("─".repeat(50)));
+  logger.phase("1. Move Unit Tests");
   logger.newline();
 
   try {
@@ -163,28 +159,25 @@ async function runAllTests(filter?: string): Promise<void> {
   } catch (error) {
     logger.newline();
     logger.error("Move tests failed");
-    console.log(colors.muted("═".repeat(50)));
+    logger.divider();
     process.exit(1);
   }
 
   // Section 2: TypeScript Tests
   logger.newline();
-  console.log(colors.muted("═".repeat(50)));
-  logger.newline();
-  console.log(`${colors.brandBright("2.")} ${colors.bold("TypeScript Integration Tests")}`);
-  console.log(colors.muted("─".repeat(50)));
+  logger.phase("2. TypeScript Integration Tests");
   logger.newline();
 
   try {
     await runTypeScriptTests(false);
     logger.newline();
-    console.log(colors.muted("═".repeat(50)));
+    logger.divider();
     logger.newline();
     logger.success("All tests passed!");
     logger.newline();
   } catch (error) {
     logger.newline();
-    console.log(colors.muted("═".repeat(50)));
+    logger.divider();
     const message = error instanceof Error ? error.message : String(error);
     logger.error(message);
     process.exit(1);
@@ -198,8 +191,8 @@ async function runTypeScriptTests(watch: boolean = false): Promise<void> {
   const testDir = join(process.cwd(), "tests");
 
   if (!existsSync(testDir)) {
-    console.log(`${colors.muted(symbols.info)} No TypeScript tests found ${colors.muted("(tests/ directory not found)")}`);
-    console.log(`   ${colors.muted("Skipping TypeScript tests...")}`);
+    logger.plain(`${colors.muted(symbols.info)} No TypeScript tests found ${colors.muted("(tests/ directory not found)")}`);
+    logger.plain(`   ${colors.muted("Skipping TypeScript tests...")}`);
     logger.newline();
     return;
   }
@@ -208,7 +201,7 @@ async function runTypeScriptTests(watch: boolean = false): Promise<void> {
 
   if (!existsSync(mochaPath)) {
     logger.error("Mocha not found in project dependencies");
-    console.log(`   ${colors.muted("Install it with:")} ${colors.info("npm install --save-dev mocha")}`);
+    logger.plain(`   ${colors.muted("Install it with:")} ${colors.info("npm install --save-dev mocha")}`);
     throw new Error("Mocha not found");
   }
 
@@ -232,7 +225,7 @@ async function runTypeScriptTests(watch: boolean = false): Promise<void> {
       process.exit(1);
     });
 
-    console.log(`${colors.info(symbols.info)} Watch mode active. Press Ctrl+C to exit.`);
+    logger.plain(`${colors.info(symbols.info)} Watch mode active. Press Ctrl+C to exit.`);
     logger.newline();
     return;
   }

package/src/core/AccountManager.ts

@@ -1,6 +1,8 @@
 import {
   Account,
   Ed25519PrivateKey,
+  PrivateKey,
+  PrivateKeyVariants,
 } from "@aptos-labs/ts-sdk";
 import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import { join } from "path";
@@ -25,10 +27,18 @@ interface AccountPool {
  * Provides a pool of reusable test accounts with labels for better test readability.
  */
 export class AccountManager {
+  // Class-static maps: shared across every consumer in the same Node
+  // process (e.g. two Harness instances). Re-using a label across
+  // "sessions" overwrites the labelMap entry. Documented + fixed by
+  // contract in `AccountManager.global-state.test.ts` (audit F8).
   private static pool: Map<string, Account> = new Map(); // address → Account
   private static privateKeys: Map<string, string> = new Map(); // address → privateKey hex
   private static labelMap: Map<string, string> = new Map(); // label → address
   private static poolLoaded = false;
+  // `defaultPoolPath` is captured ONCE at module-import time. A later
+  // `process.chdir(...)` does NOT redirect the save destination — pass
+  // an explicit `poolPath` to `saveAccountPool`/`loadAccountPool` when
+  // per-test isolation matters. See audit finding F8.
   private static defaultPoolPath = join(process.cwd(), ".movehat", "accounts");
 
   /**
@@ -131,7 +141,14 @@ export class AccountManager {
    * const account = AccountManager.loadAccountFromPrivateKey("0xabc123...");
    */
   static loadAccountFromPrivateKey(privateKeyHex: string): Account {
-    const privateKey = new Ed25519PrivateKey(privateKeyHex);
+    // Format into AIP-80 shape (`ed25519-priv-0x…`) before constructing
+    // the SDK type. Without this, raw-hex inputs trigger a noisy
+    // deprecation warning from `@aptos-labs/ts-sdk` on every call.
+    const formatted = PrivateKey.formatPrivateKey(
+      privateKeyHex,
+      PrivateKeyVariants.Ed25519,
+    );
+    const privateKey = new Ed25519PrivateKey(formatted);
     const account = Account.fromPrivateKey({ privateKey });
     const address = account.accountAddress.toString();